Move some helper methods to DexRegisterLocation.

Test: test-art-host-gtest-stack_map_test
Change-Id: I0abab008159db023d531df69214cd3bb8c0639bd
diff --git a/compiler/debug/elf_debug_loc_writer.h b/compiler/debug/elf_debug_loc_writer.h
index 4009acb..b663291 100644
--- a/compiler/debug/elf_debug_loc_writer.h
+++ b/compiler/debug/elf_debug_loc_writer.h
@@ -149,9 +149,9 @@
     DexRegisterMap dex_register_map = dex_register_maps[stack_map_index];
     DCHECK(!dex_register_map.empty());
     CodeItemDataAccessor accessor(*method_info->dex_file, method_info->code_item);
-    reg_lo = dex_register_map.GetDexRegisterLocation(vreg);
+    reg_lo = dex_register_map[vreg];
     if (is64bitValue) {
-      reg_hi = dex_register_map.GetDexRegisterLocation(vreg + 1);
+      reg_hi = dex_register_map[vreg + 1];
     }
 
     // Add location entry for this address range.
diff --git a/compiler/optimizing/code_generator.cc b/compiler/optimizing/code_generator.cc
index b3feb78..eea146e 100644
--- a/compiler/optimizing/code_generator.cc
+++ b/compiler/optimizing/code_generator.cc
@@ -1294,50 +1294,45 @@
       continue;
     }
 
+    using Kind = DexRegisterLocation::Kind;
     Location location = environment->GetLocationAt(i);
     switch (location.GetKind()) {
       case Location::kConstant: {
         DCHECK_EQ(current, location.GetConstant());
         if (current->IsLongConstant()) {
           int64_t value = current->AsLongConstant()->GetValue();
-          stack_map_stream->AddDexRegisterEntry(
-              DexRegisterLocation::Kind::kConstant, Low32Bits(value));
-          stack_map_stream->AddDexRegisterEntry(
-              DexRegisterLocation::Kind::kConstant, High32Bits(value));
+          stack_map_stream->AddDexRegisterEntry(Kind::kConstant, Low32Bits(value));
+          stack_map_stream->AddDexRegisterEntry(Kind::kConstant, High32Bits(value));
           ++i;
           DCHECK_LT(i, environment_size);
         } else if (current->IsDoubleConstant()) {
           int64_t value = bit_cast<int64_t, double>(current->AsDoubleConstant()->GetValue());
-          stack_map_stream->AddDexRegisterEntry(
-              DexRegisterLocation::Kind::kConstant, Low32Bits(value));
-          stack_map_stream->AddDexRegisterEntry(
-              DexRegisterLocation::Kind::kConstant, High32Bits(value));
+          stack_map_stream->AddDexRegisterEntry(Kind::kConstant, Low32Bits(value));
+          stack_map_stream->AddDexRegisterEntry(Kind::kConstant, High32Bits(value));
           ++i;
           DCHECK_LT(i, environment_size);
         } else if (current->IsIntConstant()) {
           int32_t value = current->AsIntConstant()->GetValue();
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kConstant, value);
+          stack_map_stream->AddDexRegisterEntry(Kind::kConstant, value);
         } else if (current->IsNullConstant()) {
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kConstant, 0);
+          stack_map_stream->AddDexRegisterEntry(Kind::kConstant, 0);
         } else {
           DCHECK(current->IsFloatConstant()) << current->DebugName();
           int32_t value = bit_cast<int32_t, float>(current->AsFloatConstant()->GetValue());
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kConstant, value);
+          stack_map_stream->AddDexRegisterEntry(Kind::kConstant, value);
         }
         break;
       }
 
       case Location::kStackSlot: {
-        stack_map_stream->AddDexRegisterEntry(
-            DexRegisterLocation::Kind::kInStack, location.GetStackIndex());
+        stack_map_stream->AddDexRegisterEntry(Kind::kInStack, location.GetStackIndex());
         break;
       }
 
       case Location::kDoubleStackSlot: {
+        stack_map_stream->AddDexRegisterEntry(Kind::kInStack, location.GetStackIndex());
         stack_map_stream->AddDexRegisterEntry(
-            DexRegisterLocation::Kind::kInStack, location.GetStackIndex());
-        stack_map_stream->AddDexRegisterEntry(
-            DexRegisterLocation::Kind::kInStack, location.GetHighStackIndex(kVRegSize));
+            Kind::kInStack, location.GetHighStackIndex(kVRegSize));
         ++i;
         DCHECK_LT(i, environment_size);
         break;
@@ -1347,17 +1342,16 @@
         int id = location.reg();
         if (slow_path != nullptr && slow_path->IsCoreRegisterSaved(id)) {
           uint32_t offset = slow_path->GetStackOffsetOfCoreRegister(id);
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInStack, offset);
+          stack_map_stream->AddDexRegisterEntry(Kind::kInStack, offset);
           if (current->GetType() == DataType::Type::kInt64) {
-            stack_map_stream->AddDexRegisterEntry(
-                DexRegisterLocation::Kind::kInStack, offset + kVRegSize);
+            stack_map_stream->AddDexRegisterEntry(Kind::kInStack, offset + kVRegSize);
             ++i;
             DCHECK_LT(i, environment_size);
           }
         } else {
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInRegister, id);
+          stack_map_stream->AddDexRegisterEntry(Kind::kInRegister, id);
           if (current->GetType() == DataType::Type::kInt64) {
-            stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInRegisterHigh, id);
+            stack_map_stream->AddDexRegisterEntry(Kind::kInRegisterHigh, id);
             ++i;
             DCHECK_LT(i, environment_size);
           }
@@ -1369,18 +1363,16 @@
         int id = location.reg();
         if (slow_path != nullptr && slow_path->IsFpuRegisterSaved(id)) {
           uint32_t offset = slow_path->GetStackOffsetOfFpuRegister(id);
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInStack, offset);
+          stack_map_stream->AddDexRegisterEntry(Kind::kInStack, offset);
           if (current->GetType() == DataType::Type::kFloat64) {
-            stack_map_stream->AddDexRegisterEntry(
-                DexRegisterLocation::Kind::kInStack, offset + kVRegSize);
+            stack_map_stream->AddDexRegisterEntry(Kind::kInStack, offset + kVRegSize);
             ++i;
             DCHECK_LT(i, environment_size);
           }
         } else {
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInFpuRegister, id);
+          stack_map_stream->AddDexRegisterEntry(Kind::kInFpuRegister, id);
           if (current->GetType() == DataType::Type::kFloat64) {
-            stack_map_stream->AddDexRegisterEntry(
-                DexRegisterLocation::Kind::kInFpuRegisterHigh, id);
+            stack_map_stream->AddDexRegisterEntry(Kind::kInFpuRegisterHigh, id);
             ++i;
             DCHECK_LT(i, environment_size);
           }
@@ -1393,16 +1385,16 @@
         int high = location.high();
         if (slow_path != nullptr && slow_path->IsFpuRegisterSaved(low)) {
           uint32_t offset = slow_path->GetStackOffsetOfFpuRegister(low);
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInStack, offset);
+          stack_map_stream->AddDexRegisterEntry(Kind::kInStack, offset);
         } else {
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInFpuRegister, low);
+          stack_map_stream->AddDexRegisterEntry(Kind::kInFpuRegister, low);
         }
         if (slow_path != nullptr && slow_path->IsFpuRegisterSaved(high)) {
           uint32_t offset = slow_path->GetStackOffsetOfFpuRegister(high);
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInStack, offset);
+          stack_map_stream->AddDexRegisterEntry(Kind::kInStack, offset);
           ++i;
         } else {
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInFpuRegister, high);
+          stack_map_stream->AddDexRegisterEntry(Kind::kInFpuRegister, high);
           ++i;
         }
         DCHECK_LT(i, environment_size);
@@ -1414,15 +1406,15 @@
         int high = location.high();
         if (slow_path != nullptr && slow_path->IsCoreRegisterSaved(low)) {
           uint32_t offset = slow_path->GetStackOffsetOfCoreRegister(low);
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInStack, offset);
+          stack_map_stream->AddDexRegisterEntry(Kind::kInStack, offset);
         } else {
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInRegister, low);
+          stack_map_stream->AddDexRegisterEntry(Kind::kInRegister, low);
         }
         if (slow_path != nullptr && slow_path->IsCoreRegisterSaved(high)) {
           uint32_t offset = slow_path->GetStackOffsetOfCoreRegister(high);
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInStack, offset);
+          stack_map_stream->AddDexRegisterEntry(Kind::kInStack, offset);
         } else {
-          stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kInRegister, high);
+          stack_map_stream->AddDexRegisterEntry(Kind::kInRegister, high);
         }
         ++i;
         DCHECK_LT(i, environment_size);
@@ -1430,7 +1422,7 @@
       }
 
       case Location::kInvalid: {
-        stack_map_stream->AddDexRegisterEntry(DexRegisterLocation::Kind::kNone, 0);
+        stack_map_stream->AddDexRegisterEntry(Kind::kNone, 0);
         break;
       }
 
diff --git a/compiler/optimizing/stack_map_stream.cc b/compiler/optimizing/stack_map_stream.cc
index 094b75d..2bfa430 100644
--- a/compiler/optimizing/stack_map_stream.cc
+++ b/compiler/optimizing/stack_map_stream.cc
@@ -114,10 +114,6 @@
   stack_maps_.Add(current_stack_map_);
 }
 
-void StackMapStream::AddDexRegisterEntry(DexRegisterLocation::Kind kind, int32_t value) {
-  current_dex_registers_.push_back(DexRegisterLocation(kind, value));
-}
-
 void StackMapStream::AddInvoke(InvokeType invoke_type, uint32_t dex_method_index) {
   uint32_t packed_native_pc = current_stack_map_.packed_native_pc;
   size_t invoke_info_index = invoke_infos_.size();
diff --git a/compiler/optimizing/stack_map_stream.h b/compiler/optimizing/stack_map_stream.h
index 02fb6cb..e3ae8a2 100644
--- a/compiler/optimizing/stack_map_stream.h
+++ b/compiler/optimizing/stack_map_stream.h
@@ -69,7 +69,9 @@
                           uint8_t inlining_depth);
   void EndStackMapEntry();
 
-  void AddDexRegisterEntry(DexRegisterLocation::Kind kind, int32_t value);
+  void AddDexRegisterEntry(DexRegisterLocation::Kind kind, int32_t value) {
+    current_dex_registers_.push_back(DexRegisterLocation(kind, value));
+  }
 
   void AddInvoke(InvokeType type, uint32_t dex_method_index);
 
diff --git a/compiler/optimizing/stack_map_test.cc b/compiler/optimizing/stack_map_test.cc
index 9adc4c5..56717b5 100644
--- a/compiler/optimizing/stack_map_test.cc
+++ b/compiler/optimizing/stack_map_test.cc
@@ -83,14 +83,14 @@
   ASSERT_TRUE(stack_map.HasDexRegisterMap());
   DexRegisterMap dex_register_map = code_info.GetDexRegisterMapOf(stack_map);
   ASSERT_EQ(number_of_dex_registers, dex_register_map.size());
-  ASSERT_TRUE(dex_register_map.IsDexRegisterLive(0));
-  ASSERT_TRUE(dex_register_map.IsDexRegisterLive(1));
+  ASSERT_TRUE(dex_register_map[0].IsLive());
+  ASSERT_TRUE(dex_register_map[1].IsLive());
   ASSERT_EQ(2u, dex_register_map.GetNumberOfLiveDexRegisters());
 
-  ASSERT_EQ(Kind::kInStack, dex_register_map.GetLocationKind(0));
-  ASSERT_EQ(Kind::kConstant, dex_register_map.GetLocationKind(1));
-  ASSERT_EQ(0, dex_register_map.GetStackOffsetInBytes(0));
-  ASSERT_EQ(-2, dex_register_map.GetConstant(1));
+  ASSERT_EQ(Kind::kInStack, dex_register_map[0].GetKind());
+  ASSERT_EQ(Kind::kConstant, dex_register_map[1].GetKind());
+  ASSERT_EQ(0, dex_register_map[0].GetStackOffsetInBytes());
+  ASSERT_EQ(-2, dex_register_map[1].GetConstant());
 
   DexRegisterLocation location0 = code_info.GetDexRegisterCatalogEntry(0);
   DexRegisterLocation location1 = code_info.GetDexRegisterCatalogEntry(1);
@@ -172,14 +172,14 @@
     ASSERT_TRUE(stack_map.HasDexRegisterMap());
     DexRegisterMap dex_register_map = code_info.GetDexRegisterMapOf(stack_map);
     ASSERT_EQ(number_of_dex_registers, dex_register_map.size());
-    ASSERT_TRUE(dex_register_map.IsDexRegisterLive(0));
-    ASSERT_TRUE(dex_register_map.IsDexRegisterLive(1));
+    ASSERT_TRUE(dex_register_map[0].IsLive());
+    ASSERT_TRUE(dex_register_map[1].IsLive());
     ASSERT_EQ(2u, dex_register_map.GetNumberOfLiveDexRegisters());
 
-    ASSERT_EQ(Kind::kInStack, dex_register_map.GetLocationKind(0));
-    ASSERT_EQ(Kind::kConstant, dex_register_map.GetLocationKind(1));
-    ASSERT_EQ(0, dex_register_map.GetStackOffsetInBytes(0));
-    ASSERT_EQ(-2, dex_register_map.GetConstant(1));
+    ASSERT_EQ(Kind::kInStack, dex_register_map[0].GetKind());
+    ASSERT_EQ(Kind::kConstant, dex_register_map[1].GetKind());
+    ASSERT_EQ(0, dex_register_map[0].GetStackOffsetInBytes());
+    ASSERT_EQ(-2, dex_register_map[1].GetConstant());
 
     DexRegisterLocation location0 = code_info.GetDexRegisterCatalogEntry(0);
     DexRegisterLocation location1 = code_info.GetDexRegisterCatalogEntry(1);
@@ -212,14 +212,14 @@
     ASSERT_TRUE(stack_map.HasDexRegisterMap());
     DexRegisterMap dex_register_map = code_info.GetDexRegisterMapOf(stack_map);
     ASSERT_EQ(number_of_dex_registers, dex_register_map.size());
-    ASSERT_TRUE(dex_register_map.IsDexRegisterLive(0));
-    ASSERT_TRUE(dex_register_map.IsDexRegisterLive(1));
+    ASSERT_TRUE(dex_register_map[0].IsLive());
+    ASSERT_TRUE(dex_register_map[1].IsLive());
     ASSERT_EQ(2u, dex_register_map.GetNumberOfLiveDexRegisters());
 
-    ASSERT_EQ(Kind::kInRegister, dex_register_map.GetLocationKind(0));
-    ASSERT_EQ(Kind::kInFpuRegister, dex_register_map.GetLocationKind(1));
-    ASSERT_EQ(18, dex_register_map.GetMachineRegister(0));
-    ASSERT_EQ(3, dex_register_map.GetMachineRegister(1));
+    ASSERT_EQ(Kind::kInRegister, dex_register_map[0].GetKind());
+    ASSERT_EQ(Kind::kInFpuRegister, dex_register_map[1].GetKind());
+    ASSERT_EQ(18, dex_register_map[0].GetMachineRegister());
+    ASSERT_EQ(3, dex_register_map[1].GetMachineRegister());
 
     DexRegisterLocation location0 = code_info.GetDexRegisterCatalogEntry(2);
     DexRegisterLocation location1 = code_info.GetDexRegisterCatalogEntry(3);
@@ -245,14 +245,14 @@
     ASSERT_TRUE(stack_map.HasDexRegisterMap());
     DexRegisterMap dex_register_map = code_info.GetDexRegisterMapOf(stack_map);
     ASSERT_EQ(number_of_dex_registers, dex_register_map.size());
-    ASSERT_TRUE(dex_register_map.IsDexRegisterLive(0));
-    ASSERT_TRUE(dex_register_map.IsDexRegisterLive(1));
+    ASSERT_TRUE(dex_register_map[0].IsLive());
+    ASSERT_TRUE(dex_register_map[1].IsLive());
     ASSERT_EQ(2u, dex_register_map.GetNumberOfLiveDexRegisters());
 
-    ASSERT_EQ(Kind::kInRegister, dex_register_map.GetLocationKind(0));
-    ASSERT_EQ(Kind::kInRegisterHigh, dex_register_map.GetLocationKind(1));
-    ASSERT_EQ(6, dex_register_map.GetMachineRegister(0));
-    ASSERT_EQ(8, dex_register_map.GetMachineRegister(1));
+    ASSERT_EQ(Kind::kInRegister, dex_register_map[0].GetKind());
+    ASSERT_EQ(Kind::kInRegisterHigh, dex_register_map[1].GetKind());
+    ASSERT_EQ(6, dex_register_map[0].GetMachineRegister());
+    ASSERT_EQ(8, dex_register_map[1].GetMachineRegister());
 
     DexRegisterLocation location0 = code_info.GetDexRegisterCatalogEntry(4);
     DexRegisterLocation location1 = code_info.GetDexRegisterCatalogEntry(5);
@@ -278,14 +278,14 @@
     ASSERT_TRUE(stack_map.HasDexRegisterMap());
     DexRegisterMap dex_register_map = code_info.GetDexRegisterMapOf(stack_map);
     ASSERT_EQ(number_of_dex_registers, dex_register_map.size());
-    ASSERT_TRUE(dex_register_map.IsDexRegisterLive(0));
-    ASSERT_TRUE(dex_register_map.IsDexRegisterLive(1));
+    ASSERT_TRUE(dex_register_map[0].IsLive());
+    ASSERT_TRUE(dex_register_map[1].IsLive());
     ASSERT_EQ(2u, dex_register_map.GetNumberOfLiveDexRegisters());
 
-    ASSERT_EQ(Kind::kInFpuRegister, dex_register_map.GetLocationKind(0));
-    ASSERT_EQ(Kind::kInFpuRegisterHigh, dex_register_map.GetLocationKind(1));
-    ASSERT_EQ(3, dex_register_map.GetMachineRegister(0));
-    ASSERT_EQ(1, dex_register_map.GetMachineRegister(1));
+    ASSERT_EQ(Kind::kInFpuRegister, dex_register_map[0].GetKind());
+    ASSERT_EQ(Kind::kInFpuRegisterHigh, dex_register_map[1].GetKind());
+    ASSERT_EQ(3, dex_register_map[0].GetMachineRegister());
+    ASSERT_EQ(1, dex_register_map[1].GetMachineRegister());
 
     DexRegisterLocation location0 = code_info.GetDexRegisterCatalogEntry(3);
     DexRegisterLocation location1 = code_info.GetDexRegisterCatalogEntry(6);
@@ -344,14 +344,14 @@
     ASSERT_TRUE(stack_map.HasDexRegisterMap());
     DexRegisterMap map(code_info.GetDexRegisterMapOf(stack_map));
     ASSERT_EQ(number_of_dex_registers, map.size());
-    ASSERT_TRUE(map.IsDexRegisterLive(0));
-    ASSERT_TRUE(map.IsDexRegisterLive(1));
+    ASSERT_TRUE(map[0].IsLive());
+    ASSERT_TRUE(map[1].IsLive());
     ASSERT_EQ(2u, map.GetNumberOfLiveDexRegisters());
 
-    ASSERT_EQ(Kind::kInStack, map.GetLocationKind(0));
-    ASSERT_EQ(Kind::kConstant, map.GetLocationKind(1));
-    ASSERT_EQ(0, map.GetStackOffsetInBytes(0));
-    ASSERT_EQ(-2, map.GetConstant(1));
+    ASSERT_EQ(Kind::kInStack, map[0].GetKind());
+    ASSERT_EQ(Kind::kConstant, map[1].GetKind());
+    ASSERT_EQ(0, map[0].GetStackOffsetInBytes());
+    ASSERT_EQ(-2, map[1].GetConstant());
 
     DexRegisterLocation location0 = code_info.GetDexRegisterCatalogEntry(0);
     DexRegisterLocation location1 = code_info.GetDexRegisterCatalogEntry(1);
@@ -396,13 +396,13 @@
   ASSERT_TRUE(stack_map.HasDexRegisterMap());
   DexRegisterMap dex_register_map = code_info.GetDexRegisterMapOf(stack_map);
   ASSERT_EQ(number_of_dex_registers, dex_register_map.size());
-  ASSERT_FALSE(dex_register_map.IsDexRegisterLive(0));
-  ASSERT_TRUE(dex_register_map.IsDexRegisterLive(1));
+  ASSERT_FALSE(dex_register_map[0].IsLive());
+  ASSERT_TRUE(dex_register_map[1].IsLive());
   ASSERT_EQ(1u, dex_register_map.GetNumberOfLiveDexRegisters());
 
-  ASSERT_EQ(Kind::kNone, dex_register_map.GetLocationKind(0));
-  ASSERT_EQ(Kind::kConstant, dex_register_map.GetLocationKind(1));
-  ASSERT_EQ(-2, dex_register_map.GetConstant(1));
+  ASSERT_EQ(Kind::kNone, dex_register_map[0].GetKind());
+  ASSERT_EQ(Kind::kConstant, dex_register_map[1].GetKind());
+  ASSERT_EQ(-2, dex_register_map[1].GetConstant());
 
   DexRegisterLocation location1 = code_info.GetDexRegisterCatalogEntry(0);
   ASSERT_EQ(Kind::kConstant, location1.GetKind());
@@ -446,22 +446,22 @@
   StackMap sm0 = ci.GetStackMapAt(0);
   DexRegisterMap dex_registers0 = ci.GetDexRegisterMapOf(sm0);
   ASSERT_EQ(number_of_dex_registers, dex_registers0.size());
-  ASSERT_EQ(0, dex_registers0.GetMachineRegister(0));
-  ASSERT_EQ(-2, dex_registers0.GetConstant(1));
+  ASSERT_EQ(0, dex_registers0[0].GetMachineRegister());
+  ASSERT_EQ(-2, dex_registers0[1].GetConstant());
 
   // Verify second stack map.
   StackMap sm1 = ci.GetStackMapAt(1);
   DexRegisterMap dex_registers1 = ci.GetDexRegisterMapOf(sm1);
   ASSERT_EQ(number_of_dex_registers, dex_registers1.size());
-  ASSERT_EQ(0, dex_registers1.GetMachineRegister(0));
-  ASSERT_EQ(-2, dex_registers1.GetConstant(1));
+  ASSERT_EQ(0, dex_registers1[0].GetMachineRegister());
+  ASSERT_EQ(-2, dex_registers1[1].GetConstant());
 
   // Verify third stack map.
   StackMap sm2 = ci.GetStackMapAt(2);
   DexRegisterMap dex_registers2 = ci.GetDexRegisterMapOf(sm2);
   ASSERT_EQ(number_of_dex_registers, dex_registers2.size());
-  ASSERT_EQ(2, dex_registers2.GetMachineRegister(0));
-  ASSERT_EQ(-2, dex_registers2.GetConstant(1));
+  ASSERT_EQ(2, dex_registers2[0].GetMachineRegister());
+  ASSERT_EQ(-2, dex_registers2[1].GetConstant());
 
   // Verify dex register mask offsets.
   ASSERT_FALSE(sm1.HasDexRegisterMaskIndex());  // No delta.
@@ -597,8 +597,8 @@
 
     DexRegisterMap dex_registers0 = ci.GetDexRegisterMapOf(sm0);
     ASSERT_EQ(2u, dex_registers0.size());
-    ASSERT_EQ(0, dex_registers0.GetStackOffsetInBytes(0));
-    ASSERT_EQ(4, dex_registers0.GetConstant(1));
+    ASSERT_EQ(0, dex_registers0[0].GetStackOffsetInBytes());
+    ASSERT_EQ(4, dex_registers0[1].GetConstant());
 
     InlineInfo if0_0 = ci.GetInlineInfoAtDepth(sm0, 0);
     InlineInfo if0_1 = ci.GetInlineInfoAtDepth(sm0, 1);
@@ -610,13 +610,13 @@
 
     DexRegisterMap dex_registers1 = ci.GetDexRegisterMapAtDepth(0, sm0);
     ASSERT_EQ(1u, dex_registers1.size());
-    ASSERT_EQ(8, dex_registers1.GetStackOffsetInBytes(0));
+    ASSERT_EQ(8, dex_registers1[0].GetStackOffsetInBytes());
 
     DexRegisterMap dex_registers2 = ci.GetDexRegisterMapAtDepth(1, sm0);
     ASSERT_EQ(3u, dex_registers2.size());
-    ASSERT_EQ(16, dex_registers2.GetStackOffsetInBytes(0));
-    ASSERT_EQ(20, dex_registers2.GetConstant(1));
-    ASSERT_EQ(15, dex_registers2.GetMachineRegister(2));
+    ASSERT_EQ(16, dex_registers2[0].GetStackOffsetInBytes());
+    ASSERT_EQ(20, dex_registers2[1].GetConstant());
+    ASSERT_EQ(15, dex_registers2[2].GetMachineRegister());
   }
 
   {
@@ -625,8 +625,8 @@
 
     DexRegisterMap dex_registers0 = ci.GetDexRegisterMapOf(sm1);
     ASSERT_EQ(2u, dex_registers0.size());
-    ASSERT_EQ(56, dex_registers0.GetStackOffsetInBytes(0));
-    ASSERT_EQ(0, dex_registers0.GetConstant(1));
+    ASSERT_EQ(56, dex_registers0[0].GetStackOffsetInBytes());
+    ASSERT_EQ(0, dex_registers0[1].GetConstant());
 
     InlineInfo if1_0 = ci.GetInlineInfoAtDepth(sm1, 0);
     InlineInfo if1_1 = ci.GetInlineInfoAtDepth(sm1, 1);
@@ -641,13 +641,13 @@
 
     DexRegisterMap dex_registers1 = ci.GetDexRegisterMapAtDepth(0, sm1);
     ASSERT_EQ(1u, dex_registers1.size());
-    ASSERT_EQ(12, dex_registers1.GetStackOffsetInBytes(0));
+    ASSERT_EQ(12, dex_registers1[0].GetStackOffsetInBytes());
 
     DexRegisterMap dex_registers2 = ci.GetDexRegisterMapAtDepth(1, sm1);
     ASSERT_EQ(3u, dex_registers2.size());
-    ASSERT_EQ(80, dex_registers2.GetStackOffsetInBytes(0));
-    ASSERT_EQ(10, dex_registers2.GetConstant(1));
-    ASSERT_EQ(5, dex_registers2.GetMachineRegister(2));
+    ASSERT_EQ(80, dex_registers2[0].GetStackOffsetInBytes());
+    ASSERT_EQ(10, dex_registers2[1].GetConstant());
+    ASSERT_EQ(5, dex_registers2[2].GetMachineRegister());
   }
 
   {
@@ -656,8 +656,8 @@
 
     DexRegisterMap dex_registers0 = ci.GetDexRegisterMapOf(sm2);
     ASSERT_EQ(2u, dex_registers0.size());
-    ASSERT_FALSE(dex_registers0.IsDexRegisterLive(0));
-    ASSERT_EQ(4, dex_registers0.GetConstant(1));
+    ASSERT_FALSE(dex_registers0[0].IsLive());
+    ASSERT_EQ(4, dex_registers0[1].GetConstant());
     ASSERT_FALSE(sm2.HasInlineInfo());
   }
 
@@ -667,8 +667,8 @@
 
     DexRegisterMap dex_registers0 = ci.GetDexRegisterMapOf(sm3);
     ASSERT_EQ(2u, dex_registers0.size());
-    ASSERT_EQ(56, dex_registers0.GetStackOffsetInBytes(0));
-    ASSERT_EQ(0, dex_registers0.GetConstant(1));
+    ASSERT_EQ(56, dex_registers0[0].GetStackOffsetInBytes());
+    ASSERT_EQ(0, dex_registers0[1].GetConstant());
 
     InlineInfo if2_0 = ci.GetInlineInfoAtDepth(sm3, 0);
     InlineInfo if2_1 = ci.GetInlineInfoAtDepth(sm3, 1);
@@ -683,12 +683,12 @@
 
     DexRegisterMap dex_registers1 = ci.GetDexRegisterMapAtDepth(1, sm3);
     ASSERT_EQ(1u, dex_registers1.size());
-    ASSERT_EQ(2, dex_registers1.GetMachineRegister(0));
+    ASSERT_EQ(2, dex_registers1[0].GetMachineRegister());
 
     DexRegisterMap dex_registers2 = ci.GetDexRegisterMapAtDepth(2, sm3);
     ASSERT_EQ(2u, dex_registers2.size());
-    ASSERT_FALSE(dex_registers2.IsDexRegisterLive(0));
-    ASSERT_EQ(3, dex_registers2.GetMachineRegister(1));
+    ASSERT_FALSE(dex_registers2[0].IsLive());
+    ASSERT_EQ(3, dex_registers2[1].GetMachineRegister());
   }
 }