diff --git a/compiler/debug/elf_debug_loc_writer.h b/compiler/debug/elf_debug_loc_writer.h
index c1bf915..8cb4e55 100644
--- a/compiler/debug/elf_debug_loc_writer.h
+++ b/compiler/debug/elf_debug_loc_writer.h
@@ -149,11 +149,9 @@
     DexRegisterMap dex_register_map = dex_register_maps[stack_map_index];
     DCHECK(dex_register_map.IsValid());
     CodeItemDataAccessor accessor(*method_info->dex_file, method_info->code_item);
-    reg_lo = dex_register_map.GetDexRegisterLocation(
-        vreg, accessor.RegistersSize(), code_info);
+    reg_lo = dex_register_map.GetDexRegisterLocation(vreg);
     if (is64bitValue) {
-      reg_hi = dex_register_map.GetDexRegisterLocation(
-          vreg + 1, accessor.RegistersSize(), code_info);
+      reg_hi = dex_register_map.GetDexRegisterLocation(vreg + 1);
     }
 
     // Add location entry for this address range.
diff --git a/compiler/optimizing/stack_map_stream.cc b/compiler/optimizing/stack_map_stream.cc
index 5dc2acd..b1dcb68 100644
--- a/compiler/optimizing/stack_map_stream.cc
+++ b/compiler/optimizing/stack_map_stream.cc
@@ -248,20 +248,8 @@
     }
   }
 
-  // Write dex register maps.
-  MemoryRegion dex_register_map_region =
-      EncodeMemoryRegion(&out_, &bit_offset, dex_register_map_bytes * kBitsPerByte);
-  for (DexRegisterMapEntry& entry : dex_register_entries_) {
-    size_t entry_size = entry.ComputeSize(location_catalog_entries_.size());
-    if (entry_size != 0) {
-      DexRegisterMap dex_register_map(
-          dex_register_map_region.Subregion(entry.offset, entry_size));
-      FillInDexRegisterMap(dex_register_map,
-                           entry.num_dex_registers,
-                           *entry.live_dex_registers_mask,
-                           entry.locations_start_index);
-    }
-  }
+  // Allocate space for dex register maps.
+  EncodeMemoryRegion(&out_, &bit_offset, dex_register_map_bytes * kBitsPerByte);
 
   // Write dex register catalog.
   EncodeVarintBits(&out_, &bit_offset, location_catalog_entries_.size());
@@ -340,6 +328,22 @@
   uint8_t* ptr = EncodeUnsignedLeb128(region.begin(), out_.size());
   region.CopyFromVector(ptr - region.begin(), out_);
 
+  // Write dex register maps.
+  CodeInfo code_info(region);
+  for (DexRegisterMapEntry& entry : dex_register_entries_) {
+    size_t entry_size = entry.ComputeSize(location_catalog_entries_.size());
+    if (entry_size != 0) {
+      DexRegisterMap dex_register_map(
+          code_info.dex_register_maps_.Subregion(entry.offset, entry_size),
+          entry.num_dex_registers,
+          code_info);
+      FillInDexRegisterMap(dex_register_map,
+                           entry.num_dex_registers,
+                           *entry.live_dex_registers_mask,
+                           entry.locations_start_index);
+    }
+  }
+
   // Verify all written data in debug build.
   if (kIsDebugBuild) {
     CheckCodeInfo(region);
@@ -364,7 +368,6 @@
     dex_register_map.SetLocationCatalogEntryIndex(
         index_in_dex_register_locations,
         location_catalog_entry_index,
-        num_dex_registers,
         location_catalog_entries_.size());
   }
 }
@@ -421,8 +424,7 @@
 }
 
 // Helper for CheckCodeInfo - check that register map has the expected content.
-void StackMapStream::CheckDexRegisterMap(const CodeInfo& code_info,
-                                         const DexRegisterMap& dex_register_map,
+void StackMapStream::CheckDexRegisterMap(const DexRegisterMap& dex_register_map,
                                          size_t num_dex_registers,
                                          BitVector* live_dex_registers_mask,
                                          size_t dex_register_locations_index) const {
@@ -439,8 +441,7 @@
           << dex_register_map.IsValid() << " " << dex_register_map.IsDexRegisterLive(reg);
     } else {
       DCHECK(dex_register_map.IsDexRegisterLive(reg));
-      DexRegisterLocation seen = dex_register_map.GetDexRegisterLocation(
-          reg, num_dex_registers, code_info);
+      DexRegisterLocation seen = dex_register_map.GetDexRegisterLocation(reg);
       DCHECK_EQ(expected.GetKind(), seen.GetKind());
       DCHECK_EQ(expected.GetValue(), seen.GetValue());
     }
@@ -506,8 +507,7 @@
       DCHECK_EQ(invoke_info.GetMethodIndexIdx(), entry.dex_method_index_idx);
       invoke_info_index++;
     }
-    CheckDexRegisterMap(code_info,
-                        code_info.GetDexRegisterMapOf(
+    CheckDexRegisterMap(code_info.GetDexRegisterMapOf(
                             stack_map, entry.dex_register_entry.num_dex_registers),
                         entry.dex_register_entry.num_dex_registers,
                         entry.dex_register_entry.live_dex_registers_mask,
@@ -533,8 +533,7 @@
           DCHECK_EQ(method_indices_[method_index_idx], inline_entry.method_index);
         }
 
-        CheckDexRegisterMap(code_info,
-                            code_info.GetDexRegisterMapAtDepth(
+        CheckDexRegisterMap(code_info.GetDexRegisterMapAtDepth(
                                 d,
                                 inline_info,
                                 inline_entry.dex_register_entry.num_dex_registers),
diff --git a/compiler/optimizing/stack_map_stream.h b/compiler/optimizing/stack_map_stream.h
index 37a9bfc..6d505b9 100644
--- a/compiler/optimizing/stack_map_stream.h
+++ b/compiler/optimizing/stack_map_stream.h
@@ -178,8 +178,7 @@
                             const BitVector& live_dex_registers_mask,
                             uint32_t start_index_in_dex_register_locations) const;
 
-  void CheckDexRegisterMap(const CodeInfo& code_info,
-                           const DexRegisterMap& dex_register_map,
+  void CheckDexRegisterMap(const DexRegisterMap& dex_register_map,
                            size_t num_dex_registers,
                            BitVector* live_dex_registers_mask,
                            size_t dex_register_locations_index) const;
diff --git a/compiler/optimizing/stack_map_test.cc b/compiler/optimizing/stack_map_test.cc
index 45466d8..1127718 100644
--- a/compiler/optimizing/stack_map_test.cc
+++ b/compiler/optimizing/stack_map_test.cc
@@ -96,22 +96,15 @@
   size_t expected_dex_register_map_size = 1u + 1u;
   ASSERT_EQ(expected_dex_register_map_size, dex_register_map.Size());
 
-  ASSERT_EQ(Kind::kInStack, dex_register_map.GetLocationKind(
-                0, number_of_dex_registers, code_info));
-  ASSERT_EQ(Kind::kConstant, dex_register_map.GetLocationKind(
-                1, number_of_dex_registers, code_info));
-  ASSERT_EQ(Kind::kInStack, dex_register_map.GetLocationInternalKind(
-                0, number_of_dex_registers, code_info));
-  ASSERT_EQ(Kind::kConstantLargeValue, dex_register_map.GetLocationInternalKind(
-                1, number_of_dex_registers, code_info));
-  ASSERT_EQ(0, dex_register_map.GetStackOffsetInBytes(
-                0, number_of_dex_registers, code_info));
-  ASSERT_EQ(-2, dex_register_map.GetConstant(1, number_of_dex_registers, code_info));
+  ASSERT_EQ(Kind::kInStack, dex_register_map.GetLocationKind(0));
+  ASSERT_EQ(Kind::kConstant, dex_register_map.GetLocationKind(1));
+  ASSERT_EQ(Kind::kInStack, dex_register_map.GetLocationInternalKind(0));
+  ASSERT_EQ(Kind::kConstantLargeValue, dex_register_map.GetLocationInternalKind(1));
+  ASSERT_EQ(0, dex_register_map.GetStackOffsetInBytes(0));
+  ASSERT_EQ(-2, dex_register_map.GetConstant(1));
 
-  size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(
-      0, number_of_dex_registers, number_of_catalog_entries);
-  size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(
-      1, number_of_dex_registers, number_of_catalog_entries);
+  size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(0, number_of_catalog_entries);
+  size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(1, number_of_catalog_entries);
   ASSERT_EQ(0u, index0);
   ASSERT_EQ(1u, index1);
   DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -211,22 +204,15 @@
     size_t expected_dex_register_map_size = 1u + 1u;
     ASSERT_EQ(expected_dex_register_map_size, dex_register_map.Size());
 
-    ASSERT_EQ(Kind::kInStack, dex_register_map.GetLocationKind(
-                  0, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kConstant, dex_register_map.GetLocationKind(
-                  1, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kInStack, dex_register_map.GetLocationInternalKind(
-                  0, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kConstantLargeValue, dex_register_map.GetLocationInternalKind(
-                  1, number_of_dex_registers, code_info));
-    ASSERT_EQ(0, dex_register_map.GetStackOffsetInBytes(
-                  0, number_of_dex_registers, code_info));
-    ASSERT_EQ(-2, dex_register_map.GetConstant(1, number_of_dex_registers, code_info));
+    ASSERT_EQ(Kind::kInStack, dex_register_map.GetLocationKind(0));
+    ASSERT_EQ(Kind::kConstant, dex_register_map.GetLocationKind(1));
+    ASSERT_EQ(Kind::kInStack, dex_register_map.GetLocationInternalKind(0));
+    ASSERT_EQ(Kind::kConstantLargeValue, dex_register_map.GetLocationInternalKind(1));
+    ASSERT_EQ(0, dex_register_map.GetStackOffsetInBytes(0));
+    ASSERT_EQ(-2, dex_register_map.GetConstant(1));
 
-    size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(
-        0, number_of_dex_registers, number_of_catalog_entries);
-    size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(
-        1, number_of_dex_registers, number_of_catalog_entries);
+    size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(0, number_of_catalog_entries);
+    size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(1, number_of_catalog_entries);
     ASSERT_EQ(0u, index0);
     ASSERT_EQ(1u, index1);
     DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -270,23 +256,15 @@
     size_t expected_dex_register_map_size = 1u + 1u;
     ASSERT_EQ(expected_dex_register_map_size, dex_register_map.Size());
 
-    ASSERT_EQ(Kind::kInRegister, dex_register_map.GetLocationKind(
-                  0, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kInFpuRegister, dex_register_map.GetLocationKind(
-                  1, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kInRegister, dex_register_map.GetLocationInternalKind(
-                  0, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kInFpuRegister, dex_register_map.GetLocationInternalKind(
-                  1, number_of_dex_registers, code_info));
-    ASSERT_EQ(18, dex_register_map.GetMachineRegister(
-                  0, number_of_dex_registers, code_info));
-    ASSERT_EQ(3, dex_register_map.GetMachineRegister(
-                  1, number_of_dex_registers, code_info));
+    ASSERT_EQ(Kind::kInRegister, dex_register_map.GetLocationKind(0));
+    ASSERT_EQ(Kind::kInFpuRegister, dex_register_map.GetLocationKind(1));
+    ASSERT_EQ(Kind::kInRegister, dex_register_map.GetLocationInternalKind(0));
+    ASSERT_EQ(Kind::kInFpuRegister, dex_register_map.GetLocationInternalKind(1));
+    ASSERT_EQ(18, dex_register_map.GetMachineRegister(0));
+    ASSERT_EQ(3, dex_register_map.GetMachineRegister(1));
 
-    size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(
-        0, number_of_dex_registers, number_of_catalog_entries);
-    size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(
-        1, number_of_dex_registers, number_of_catalog_entries);
+    size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(0, number_of_catalog_entries);
+    size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(1, number_of_catalog_entries);
     ASSERT_EQ(2u, index0);
     ASSERT_EQ(3u, index1);
     DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -324,23 +302,15 @@
     size_t expected_dex_register_map_size = 1u + 1u;
     ASSERT_EQ(expected_dex_register_map_size, dex_register_map.Size());
 
-    ASSERT_EQ(Kind::kInRegister, dex_register_map.GetLocationKind(
-                  0, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kInRegisterHigh, dex_register_map.GetLocationKind(
-                  1, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kInRegister, dex_register_map.GetLocationInternalKind(
-                  0, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kInRegisterHigh, dex_register_map.GetLocationInternalKind(
-                  1, number_of_dex_registers, code_info));
-    ASSERT_EQ(6, dex_register_map.GetMachineRegister(
-                  0, number_of_dex_registers, code_info));
-    ASSERT_EQ(8, dex_register_map.GetMachineRegister(
-                  1, number_of_dex_registers, code_info));
+    ASSERT_EQ(Kind::kInRegister, dex_register_map.GetLocationKind(0));
+    ASSERT_EQ(Kind::kInRegisterHigh, dex_register_map.GetLocationKind(1));
+    ASSERT_EQ(Kind::kInRegister, dex_register_map.GetLocationInternalKind(0));
+    ASSERT_EQ(Kind::kInRegisterHigh, dex_register_map.GetLocationInternalKind(1));
+    ASSERT_EQ(6, dex_register_map.GetMachineRegister(0));
+    ASSERT_EQ(8, dex_register_map.GetMachineRegister(1));
 
-    size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(
-        0, number_of_dex_registers, number_of_catalog_entries);
-    size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(
-        1, number_of_dex_registers, number_of_catalog_entries);
+    size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(0, number_of_catalog_entries);
+    size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(1, number_of_catalog_entries);
     ASSERT_EQ(4u, index0);
     ASSERT_EQ(5u, index1);
     DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -378,23 +348,15 @@
     size_t expected_dex_register_map_size = 1u + 1u;
     ASSERT_EQ(expected_dex_register_map_size, dex_register_map.Size());
 
-    ASSERT_EQ(Kind::kInFpuRegister, dex_register_map.GetLocationKind(
-                  0, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kInFpuRegisterHigh, dex_register_map.GetLocationKind(
-                  1, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kInFpuRegister, dex_register_map.GetLocationInternalKind(
-                  0, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kInFpuRegisterHigh, dex_register_map.GetLocationInternalKind(
-                  1, number_of_dex_registers, code_info));
-    ASSERT_EQ(3, dex_register_map.GetMachineRegister(
-                  0, number_of_dex_registers, code_info));
-    ASSERT_EQ(1, dex_register_map.GetMachineRegister(
-                  1, number_of_dex_registers, code_info));
+    ASSERT_EQ(Kind::kInFpuRegister, dex_register_map.GetLocationKind(0));
+    ASSERT_EQ(Kind::kInFpuRegisterHigh, dex_register_map.GetLocationKind(1));
+    ASSERT_EQ(Kind::kInFpuRegister, dex_register_map.GetLocationInternalKind(0));
+    ASSERT_EQ(Kind::kInFpuRegisterHigh, dex_register_map.GetLocationInternalKind(1));
+    ASSERT_EQ(3, dex_register_map.GetMachineRegister(0));
+    ASSERT_EQ(1, dex_register_map.GetMachineRegister(1));
 
-    size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(
-        0, number_of_dex_registers, number_of_catalog_entries);
-    size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(
-        1, number_of_dex_registers, number_of_catalog_entries);
+    size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(0, number_of_catalog_entries);
+    size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(1, number_of_catalog_entries);
     ASSERT_EQ(3u, index0);  // Shared with second stack map.
     ASSERT_EQ(6u, index1);
     DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -470,20 +432,15 @@
     size_t expected_map_size = 1u + 1u;
     ASSERT_EQ(expected_map_size, map.Size());
 
-    ASSERT_EQ(Kind::kInStack, map.GetLocationKind(0, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kConstant,
-              map.GetLocationKind(1, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kInStack,
-              map.GetLocationInternalKind(0, number_of_dex_registers, code_info));
-    ASSERT_EQ(Kind::kConstantLargeValue,
-              map.GetLocationInternalKind(1, number_of_dex_registers, code_info));
-    ASSERT_EQ(0, map.GetStackOffsetInBytes(0, number_of_dex_registers, code_info));
-    ASSERT_EQ(-2, map.GetConstant(1, number_of_dex_registers, code_info));
+    ASSERT_EQ(Kind::kInStack, map.GetLocationKind(0));
+    ASSERT_EQ(Kind::kConstant, map.GetLocationKind(1));
+    ASSERT_EQ(Kind::kInStack, map.GetLocationInternalKind(0));
+    ASSERT_EQ(Kind::kConstantLargeValue, map.GetLocationInternalKind(1));
+    ASSERT_EQ(0, map.GetStackOffsetInBytes(0));
+    ASSERT_EQ(-2, map.GetConstant(1));
 
-    const size_t index0 =
-        map.GetLocationCatalogEntryIndex(0, number_of_dex_registers, number_of_catalog_entries);
-    const size_t index1 =
-        map.GetLocationCatalogEntryIndex(1, number_of_dex_registers, number_of_catalog_entries);
+    const size_t index0 = map.GetLocationCatalogEntryIndex(0, number_of_catalog_entries);
+    const size_t index1 = map.GetLocationCatalogEntryIndex(1, number_of_catalog_entries);
     ASSERT_EQ(0u, index0);
     ASSERT_EQ(1u, index1);
     DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -552,20 +509,14 @@
   size_t expected_dex_register_map_size = 1u + 0u;
   ASSERT_EQ(expected_dex_register_map_size, dex_register_map.Size());
 
-  ASSERT_EQ(Kind::kNone, dex_register_map.GetLocationKind(
-                0, number_of_dex_registers, code_info));
-  ASSERT_EQ(Kind::kConstant, dex_register_map.GetLocationKind(
-                1, number_of_dex_registers, code_info));
-  ASSERT_EQ(Kind::kNone, dex_register_map.GetLocationInternalKind(
-                0, number_of_dex_registers, code_info));
-  ASSERT_EQ(Kind::kConstantLargeValue, dex_register_map.GetLocationInternalKind(
-                1, number_of_dex_registers, code_info));
-  ASSERT_EQ(-2, dex_register_map.GetConstant(1, number_of_dex_registers, code_info));
+  ASSERT_EQ(Kind::kNone, dex_register_map.GetLocationKind(0));
+  ASSERT_EQ(Kind::kConstant, dex_register_map.GetLocationKind(1));
+  ASSERT_EQ(Kind::kNone, dex_register_map.GetLocationInternalKind(0));
+  ASSERT_EQ(Kind::kConstantLargeValue, dex_register_map.GetLocationInternalKind(1));
+  ASSERT_EQ(-2, dex_register_map.GetConstant(1));
 
-  size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(
-      0, number_of_dex_registers, number_of_catalog_entries);
-  size_t index1 =  dex_register_map.GetLocationCatalogEntryIndex(
-      1, number_of_dex_registers, number_of_catalog_entries);
+  size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(0, number_of_catalog_entries);
+  size_t index1 =  dex_register_map.GetLocationCatalogEntryIndex(1, number_of_catalog_entries);
   ASSERT_EQ(DexRegisterLocationCatalog::kNoLocationEntryIndex, index0);
   ASSERT_EQ(0u, index1);
   DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -632,8 +583,7 @@
   StackMap stack_map0 = code_info.GetStackMapAt(0);
   DexRegisterMap dex_register_map0 =
       code_info.GetDexRegisterMapOf(stack_map0, number_of_dex_registers);
-  ASSERT_EQ(127u, dex_register_map0.GetLocationMappingDataSize(number_of_dex_registers,
-                                                               number_of_catalog_entries));
+  ASSERT_EQ(127u, dex_register_map0.GetLocationMappingDataSize(number_of_catalog_entries));
   ASSERT_EQ(255u, dex_register_map0.Size());
 
   StackMap stack_map1 = code_info.GetStackMapAt(1);
@@ -680,20 +630,20 @@
   // Verify first stack map.
   StackMap sm0 = ci.GetStackMapAt(0);
   DexRegisterMap dex_registers0 = ci.GetDexRegisterMapOf(sm0, number_of_dex_registers);
-  ASSERT_EQ(0, dex_registers0.GetMachineRegister(0, number_of_dex_registers, ci));
-  ASSERT_EQ(-2, dex_registers0.GetConstant(1, number_of_dex_registers, ci));
+  ASSERT_EQ(0, dex_registers0.GetMachineRegister(0));
+  ASSERT_EQ(-2, dex_registers0.GetConstant(1));
 
   // Verify second stack map.
   StackMap sm1 = ci.GetStackMapAt(1);
   DexRegisterMap dex_registers1 = ci.GetDexRegisterMapOf(sm1, number_of_dex_registers);
-  ASSERT_EQ(0, dex_registers1.GetMachineRegister(0, number_of_dex_registers, ci));
-  ASSERT_EQ(-2, dex_registers1.GetConstant(1, number_of_dex_registers, ci));
+  ASSERT_EQ(0, dex_registers1.GetMachineRegister(0));
+  ASSERT_EQ(-2, dex_registers1.GetConstant(1));
 
   // Verify third stack map.
   StackMap sm2 = ci.GetStackMapAt(2);
   DexRegisterMap dex_registers2 = ci.GetDexRegisterMapOf(sm2, number_of_dex_registers);
-  ASSERT_EQ(2, dex_registers2.GetMachineRegister(0, number_of_dex_registers, ci));
-  ASSERT_EQ(-2, dex_registers2.GetConstant(1, number_of_dex_registers, ci));
+  ASSERT_EQ(2, dex_registers2.GetMachineRegister(0));
+  ASSERT_EQ(-2, dex_registers2.GetConstant(1));
 
   // Verify dex register map offsets.
   ASSERT_EQ(sm0.GetDexRegisterMapOffset(),
@@ -833,8 +783,8 @@
     StackMap sm0 = ci.GetStackMapAt(0);
 
     DexRegisterMap dex_registers0 = ci.GetDexRegisterMapOf(sm0, 2);
-    ASSERT_EQ(0, dex_registers0.GetStackOffsetInBytes(0, 2, ci));
-    ASSERT_EQ(4, dex_registers0.GetConstant(1, 2, ci));
+    ASSERT_EQ(0, dex_registers0.GetStackOffsetInBytes(0));
+    ASSERT_EQ(4, dex_registers0.GetConstant(1));
 
     InlineInfo if0 = ci.GetInlineInfoOf(sm0);
     ASSERT_EQ(2u, if0.GetDepth());
@@ -844,12 +794,12 @@
     ASSERT_TRUE(if0.EncodesArtMethodAtDepth(1));
 
     DexRegisterMap dex_registers1 = ci.GetDexRegisterMapAtDepth(0, if0, 1);
-    ASSERT_EQ(8, dex_registers1.GetStackOffsetInBytes(0, 1, ci));
+    ASSERT_EQ(8, dex_registers1.GetStackOffsetInBytes(0));
 
     DexRegisterMap dex_registers2 = ci.GetDexRegisterMapAtDepth(1, if0, 3);
-    ASSERT_EQ(16, dex_registers2.GetStackOffsetInBytes(0, 3, ci));
-    ASSERT_EQ(20, dex_registers2.GetConstant(1, 3, ci));
-    ASSERT_EQ(15, dex_registers2.GetMachineRegister(2, 3, ci));
+    ASSERT_EQ(16, dex_registers2.GetStackOffsetInBytes(0));
+    ASSERT_EQ(20, dex_registers2.GetConstant(1));
+    ASSERT_EQ(15, dex_registers2.GetMachineRegister(2));
   }
 
   {
@@ -857,8 +807,8 @@
     StackMap sm1 = ci.GetStackMapAt(1);
 
     DexRegisterMap dex_registers0 = ci.GetDexRegisterMapOf(sm1, 2);
-    ASSERT_EQ(56, dex_registers0.GetStackOffsetInBytes(0, 2, ci));
-    ASSERT_EQ(0, dex_registers0.GetConstant(1, 2, ci));
+    ASSERT_EQ(56, dex_registers0.GetStackOffsetInBytes(0));
+    ASSERT_EQ(0, dex_registers0.GetConstant(1));
 
     InlineInfo if1 = ci.GetInlineInfoOf(sm1);
     ASSERT_EQ(3u, if1.GetDepth());
@@ -870,12 +820,12 @@
     ASSERT_TRUE(if1.EncodesArtMethodAtDepth(2));
 
     DexRegisterMap dex_registers1 = ci.GetDexRegisterMapAtDepth(0, if1, 1);
-    ASSERT_EQ(12, dex_registers1.GetStackOffsetInBytes(0, 1, ci));
+    ASSERT_EQ(12, dex_registers1.GetStackOffsetInBytes(0));
 
     DexRegisterMap dex_registers2 = ci.GetDexRegisterMapAtDepth(1, if1, 3);
-    ASSERT_EQ(80, dex_registers2.GetStackOffsetInBytes(0, 3, ci));
-    ASSERT_EQ(10, dex_registers2.GetConstant(1, 3, ci));
-    ASSERT_EQ(5, dex_registers2.GetMachineRegister(2, 3, ci));
+    ASSERT_EQ(80, dex_registers2.GetStackOffsetInBytes(0));
+    ASSERT_EQ(10, dex_registers2.GetConstant(1));
+    ASSERT_EQ(5, dex_registers2.GetMachineRegister(2));
 
     ASSERT_FALSE(if1.HasDexRegisterMapAtDepth(2));
   }
@@ -886,7 +836,7 @@
 
     DexRegisterMap dex_registers0 = ci.GetDexRegisterMapOf(sm2, 2);
     ASSERT_FALSE(dex_registers0.IsDexRegisterLive(0));
-    ASSERT_EQ(4, dex_registers0.GetConstant(1, 2, ci));
+    ASSERT_EQ(4, dex_registers0.GetConstant(1));
     ASSERT_FALSE(sm2.HasInlineInfo());
   }
 
@@ -895,8 +845,8 @@
     StackMap sm3 = ci.GetStackMapAt(3);
 
     DexRegisterMap dex_registers0 = ci.GetDexRegisterMapOf(sm3, 2);
-    ASSERT_EQ(56, dex_registers0.GetStackOffsetInBytes(0, 2, ci));
-    ASSERT_EQ(0, dex_registers0.GetConstant(1, 2, ci));
+    ASSERT_EQ(56, dex_registers0.GetStackOffsetInBytes(0));
+    ASSERT_EQ(0, dex_registers0.GetConstant(1));
 
     InlineInfo if2 = ci.GetInlineInfoOf(sm3);
     ASSERT_EQ(3u, if2.GetDepth());
@@ -910,11 +860,11 @@
     ASSERT_FALSE(if2.HasDexRegisterMapAtDepth(0));
 
     DexRegisterMap dex_registers1 = ci.GetDexRegisterMapAtDepth(1, if2, 1);
-    ASSERT_EQ(2, dex_registers1.GetMachineRegister(0, 1, ci));
+    ASSERT_EQ(2, dex_registers1.GetMachineRegister(0));
 
     DexRegisterMap dex_registers2 = ci.GetDexRegisterMapAtDepth(2, if2, 2);
     ASSERT_FALSE(dex_registers2.IsDexRegisterLive(0));
-    ASSERT_EQ(3, dex_registers2.GetMachineRegister(1, 2, ci));
+    ASSERT_EQ(3, dex_registers2.GetMachineRegister(1));
   }
 }
 
diff --git a/runtime/check_reference_map_visitor.h b/runtime/check_reference_map_visitor.h
index 6917899..acdb235 100644
--- a/runtime/check_reference_map_visitor.h
+++ b/runtime/check_reference_map_visitor.h
@@ -75,8 +75,7 @@
     for (int i = 0; i < number_of_references; ++i) {
       int reg = registers[i];
       CHECK_LT(reg, accessor.RegistersSize());
-      DexRegisterLocation location = dex_register_map.GetDexRegisterLocation(
-          reg, number_of_dex_registers, code_info);
+      DexRegisterLocation location = dex_register_map.GetDexRegisterLocation(reg);
       switch (location.GetKind()) {
         case DexRegisterLocation::Kind::kNone:
           // Not set, should not be a reference.
diff --git a/runtime/jit/jit.cc b/runtime/jit/jit.cc
index 9c02dce..b7b779c 100644
--- a/runtime/jit/jit.cc
+++ b/runtime/jit/jit.cc
@@ -515,8 +515,7 @@
       // this dex pc.
     } else {
       for (uint16_t vreg = 0; vreg < number_of_vregs; ++vreg) {
-        DexRegisterLocation::Kind location =
-            vreg_map.GetLocationKind(vreg, number_of_vregs, code_info);
+        DexRegisterLocation::Kind location = vreg_map.GetLocationKind(vreg);
         if (location == DexRegisterLocation::Kind::kNone) {
           // Dex register is dead or uninitialized.
           continue;
@@ -530,9 +529,7 @@
         DCHECK_EQ(location, DexRegisterLocation::Kind::kInStack);
 
         int32_t vreg_value = shadow_frame->GetVReg(vreg);
-        int32_t slot_offset = vreg_map.GetStackOffsetInBytes(vreg,
-                                                             number_of_vregs,
-                                                             code_info);
+        int32_t slot_offset = vreg_map.GetStackOffsetInBytes(vreg);
         DCHECK_LT(slot_offset, static_cast<int32_t>(frame_size));
         DCHECK_GT(slot_offset, 0);
         (reinterpret_cast<int32_t*>(memory))[slot_offset / sizeof(int32_t)] = vreg_value;
diff --git a/runtime/quick_exception_handler.cc b/runtime/quick_exception_handler.cc
index 2648920..63a09f2 100644
--- a/runtime/quick_exception_handler.cc
+++ b/runtime/quick_exception_handler.cc
@@ -246,8 +246,7 @@
 
   // Copy values between them.
   for (uint16_t vreg = 0; vreg < number_of_vregs; ++vreg) {
-    DexRegisterLocation::Kind catch_location =
-        catch_vreg_map.GetLocationKind(vreg, number_of_vregs, code_info);
+    DexRegisterLocation::Kind catch_location = catch_vreg_map.GetLocationKind(vreg);
     if (catch_location == DexRegisterLocation::Kind::kNone) {
       continue;
     }
@@ -255,9 +254,7 @@
 
     // Get vreg value from its current location.
     uint32_t vreg_value;
-    VRegKind vreg_kind = ToVRegKind(throw_vreg_map.GetLocationKind(vreg,
-                                                                   number_of_vregs,
-                                                                   code_info));
+    VRegKind vreg_kind = ToVRegKind(throw_vreg_map.GetLocationKind(vreg));
     bool get_vreg_success = stack_visitor->GetVReg(stack_visitor->GetMethod(),
                                                    vreg,
                                                    vreg_kind,
@@ -268,9 +265,7 @@
                             << "native_pc_offset=" << stack_visitor->GetNativePcOffset() << ")";
 
     // Copy value to the catch phi's stack slot.
-    int32_t slot_offset = catch_vreg_map.GetStackOffsetInBytes(vreg,
-                                                               number_of_vregs,
-                                                               code_info);
+    int32_t slot_offset = catch_vreg_map.GetStackOffsetInBytes(vreg);
     ArtMethod** frame_top = stack_visitor->GetCurrentQuickFrame();
     uint8_t* slot_address = reinterpret_cast<uint8_t*>(frame_top) + slot_offset;
     uint32_t* slot_ptr = reinterpret_cast<uint32_t*>(slot_address);
@@ -425,17 +420,14 @@
         continue;
       }
 
-      DexRegisterLocation::Kind location =
-          vreg_map.GetLocationKind(vreg, number_of_vregs, code_info);
+      DexRegisterLocation::Kind location = vreg_map.GetLocationKind(vreg);
       static constexpr uint32_t kDeadValue = 0xEBADDE09;
       uint32_t value = kDeadValue;
       bool is_reference = false;
 
       switch (location) {
         case DexRegisterLocation::Kind::kInStack: {
-          const int32_t offset = vreg_map.GetStackOffsetInBytes(vreg,
-                                                                number_of_vregs,
-                                                                code_info);
+          const int32_t offset = vreg_map.GetStackOffsetInBytes(vreg);
           const uint8_t* addr = reinterpret_cast<const uint8_t*>(GetCurrentQuickFrame()) + offset;
           value = *reinterpret_cast<const uint32_t*>(addr);
           uint32_t bit = (offset >> 2);
@@ -448,7 +440,7 @@
         case DexRegisterLocation::Kind::kInRegisterHigh:
         case DexRegisterLocation::Kind::kInFpuRegister:
         case DexRegisterLocation::Kind::kInFpuRegisterHigh: {
-          uint32_t reg = vreg_map.GetMachineRegister(vreg, number_of_vregs, code_info);
+          uint32_t reg = vreg_map.GetMachineRegister(vreg);
           bool result = GetRegisterIfAccessible(reg, ToVRegKind(location), &value);
           CHECK(result);
           if (location == DexRegisterLocation::Kind::kInRegister) {
@@ -459,7 +451,7 @@
           break;
         }
         case DexRegisterLocation::Kind::kConstant: {
-          value = vreg_map.GetConstant(vreg, number_of_vregs, code_info);
+          value = vreg_map.GetConstant(vreg);
           if (value == 0) {
             // Make it a reference for extra safety.
             is_reference = true;
@@ -472,9 +464,7 @@
         default: {
           LOG(FATAL)
               << "Unexpected location kind "
-              << vreg_map.GetLocationInternalKind(vreg,
-                                                  number_of_vregs,
-                                                  code_info);
+              << vreg_map.GetLocationInternalKind(vreg);
           UNREACHABLE();
         }
       }
diff --git a/runtime/stack.cc b/runtime/stack.cc
index 8cb0700..6da7dcb 100644
--- a/runtime/stack.cc
+++ b/runtime/stack.cc
@@ -245,13 +245,10 @@
   if (!dex_register_map.IsValid()) {
     return false;
   }
-  DexRegisterLocation::Kind location_kind =
-      dex_register_map.GetLocationKind(vreg, number_of_dex_registers, code_info);
+  DexRegisterLocation::Kind location_kind = dex_register_map.GetLocationKind(vreg);
   switch (location_kind) {
     case DexRegisterLocation::Kind::kInStack: {
-      const int32_t offset = dex_register_map.GetStackOffsetInBytes(vreg,
-                                                                    number_of_dex_registers,
-                                                                    code_info);
+      const int32_t offset = dex_register_map.GetStackOffsetInBytes(vreg);
       const uint8_t* addr = reinterpret_cast<const uint8_t*>(cur_quick_frame_) + offset;
       *val = *reinterpret_cast<const uint32_t*>(addr);
       return true;
@@ -260,21 +257,18 @@
     case DexRegisterLocation::Kind::kInRegisterHigh:
     case DexRegisterLocation::Kind::kInFpuRegister:
     case DexRegisterLocation::Kind::kInFpuRegisterHigh: {
-      uint32_t reg =
-          dex_register_map.GetMachineRegister(vreg, number_of_dex_registers, code_info);
+      uint32_t reg = dex_register_map.GetMachineRegister(vreg);
       return GetRegisterIfAccessible(reg, kind, val);
     }
     case DexRegisterLocation::Kind::kConstant:
-      *val = dex_register_map.GetConstant(vreg, number_of_dex_registers, code_info);
+      *val = dex_register_map.GetConstant(vreg);
       return true;
     case DexRegisterLocation::Kind::kNone:
       return false;
     default:
       LOG(FATAL)
           << "Unexpected location kind "
-          << dex_register_map.GetLocationInternalKind(vreg,
-                                                      number_of_dex_registers,
-                                                      code_info);
+          << dex_register_map.GetLocationInternalKind(vreg);
       UNREACHABLE();
   }
 }
diff --git a/runtime/stack_map.cc b/runtime/stack_map.cc
index 4ed60bf..61fe2e7 100644
--- a/runtime/stack_map.cc
+++ b/runtime/stack_map.cc
@@ -52,27 +52,21 @@
 }
 
 DexRegisterLocation::Kind DexRegisterMap::GetLocationInternalKind(
-    uint16_t dex_register_number,
-    uint16_t number_of_dex_registers,
-    const CodeInfo& code_info) const {
+    uint16_t dex_register_number) const {
   DexRegisterLocationCatalog dex_register_location_catalog =
-      code_info.GetDexRegisterLocationCatalog();
+      code_info_.GetDexRegisterLocationCatalog();
   size_t location_catalog_entry_index = GetLocationCatalogEntryIndex(
       dex_register_number,
-      number_of_dex_registers,
-      code_info.GetNumberOfLocationCatalogEntries());
+      code_info_.GetNumberOfLocationCatalogEntries());
   return dex_register_location_catalog.GetLocationInternalKind(location_catalog_entry_index);
 }
 
-DexRegisterLocation DexRegisterMap::GetDexRegisterLocation(uint16_t dex_register_number,
-                                                           uint16_t number_of_dex_registers,
-                                                           const CodeInfo& code_info) const {
+DexRegisterLocation DexRegisterMap::GetDexRegisterLocation(uint16_t dex_register_number) const {
   DexRegisterLocationCatalog dex_register_location_catalog =
-      code_info.GetDexRegisterLocationCatalog();
+      code_info_.GetDexRegisterLocationCatalog();
   size_t location_catalog_entry_index = GetLocationCatalogEntryIndex(
       dex_register_number,
-      number_of_dex_registers,
-      code_info.GetNumberOfLocationCatalogEntries());
+      code_info_.GetNumberOfLocationCatalogEntries());
   return dex_register_location_catalog.GetDexRegisterLocation(location_catalog_entry_index);
 }
 
@@ -160,18 +154,15 @@
   }
 }
 
-void DexRegisterMap::Dump(VariableIndentationOutputStream* vios,
-                          const CodeInfo& code_info,
-                          uint16_t number_of_dex_registers) const {
-  size_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
+void DexRegisterMap::Dump(VariableIndentationOutputStream* vios) const {
+  size_t number_of_location_catalog_entries = code_info_.GetNumberOfLocationCatalogEntries();
   // TODO: Display the bit mask of live Dex registers.
-  for (size_t j = 0; j < number_of_dex_registers; ++j) {
+  for (size_t j = 0; j < number_of_dex_registers_; ++j) {
     if (IsDexRegisterLive(j)) {
       size_t location_catalog_entry_index = GetLocationCatalogEntryIndex(
-          j, number_of_dex_registers, number_of_location_catalog_entries);
-      DexRegisterLocation location = GetDexRegisterLocation(j,
-                                                            number_of_dex_registers,
-                                                            code_info);
+          j,
+          number_of_location_catalog_entries);
+      DexRegisterLocation location = GetDexRegisterLocation(j);
       ScopedIndentation indent1(vios);
       DumpRegisterMapping(
           vios->Stream(), j, location, "v",
@@ -207,7 +198,7 @@
   if (HasDexRegisterMap()) {
     DexRegisterMap dex_register_map = code_info.GetDexRegisterMapOf(
         *this, number_of_dex_registers);
-    dex_register_map.Dump(vios, code_info, number_of_dex_registers);
+    dex_register_map.Dump(vios);
   }
   if (HasInlineInfo()) {
     InlineInfo inline_info = code_info.GetInlineInfoOf(*this);
@@ -244,7 +235,7 @@
       DexRegisterMap dex_register_map =
           code_info.GetDexRegisterMapAtDepth(i, *this, number_of_dex_registers[i]);
       ScopedIndentation indent1(vios);
-      dex_register_map.Dump(vios, code_info, number_of_dex_registers[i]);
+      dex_register_map.Dump(vios);
     }
   }
 }
diff --git a/runtime/stack_map.h b/runtime/stack_map.h
index 363884a..9d66b31 100644
--- a/runtime/stack_map.h
+++ b/runtime/stack_map.h
@@ -445,53 +445,39 @@
  */
 class DexRegisterMap {
  public:
-  explicit DexRegisterMap(MemoryRegion region) : region_(region) {}
-  DexRegisterMap() {}
+  DexRegisterMap(MemoryRegion region, uint16_t number_of_dex_registers, const CodeInfo& code_info)
+      : region_(region),
+        number_of_dex_registers_(number_of_dex_registers),
+        code_info_(code_info) {}
 
   bool IsValid() const { return region_.IsValid(); }
 
   // Get the surface kind of Dex register `dex_register_number`.
-  DexRegisterLocation::Kind GetLocationKind(uint16_t dex_register_number,
-                                            uint16_t number_of_dex_registers,
-                                            const CodeInfo& code_info) const {
-    return DexRegisterLocation::ConvertToSurfaceKind(
-        GetLocationInternalKind(dex_register_number, number_of_dex_registers, code_info));
+  DexRegisterLocation::Kind GetLocationKind(uint16_t dex_register_number) const {
+    return DexRegisterLocation::ConvertToSurfaceKind(GetLocationInternalKind(dex_register_number));
   }
 
   // Get the internal kind of Dex register `dex_register_number`.
-  DexRegisterLocation::Kind GetLocationInternalKind(uint16_t dex_register_number,
-                                                    uint16_t number_of_dex_registers,
-                                                    const CodeInfo& code_info) const;
+  DexRegisterLocation::Kind GetLocationInternalKind(uint16_t dex_register_number) const;
 
   // Get the Dex register location `dex_register_number`.
-  DexRegisterLocation GetDexRegisterLocation(uint16_t dex_register_number,
-                                             uint16_t number_of_dex_registers,
-                                             const CodeInfo& code_info) const;
+  DexRegisterLocation GetDexRegisterLocation(uint16_t dex_register_number) const;
 
-  int32_t GetStackOffsetInBytes(uint16_t dex_register_number,
-                                uint16_t number_of_dex_registers,
-                                const CodeInfo& code_info) const {
-    DexRegisterLocation location =
-        GetDexRegisterLocation(dex_register_number, number_of_dex_registers, code_info);
+  int32_t GetStackOffsetInBytes(uint16_t dex_register_number) const {
+    DexRegisterLocation location = GetDexRegisterLocation(dex_register_number);
     DCHECK(location.GetKind() == DexRegisterLocation::Kind::kInStack);
     // GetDexRegisterLocation returns the offset in bytes.
     return location.GetValue();
   }
 
-  int32_t GetConstant(uint16_t dex_register_number,
-                      uint16_t number_of_dex_registers,
-                      const CodeInfo& code_info) const {
-    DexRegisterLocation location =
-        GetDexRegisterLocation(dex_register_number, number_of_dex_registers, code_info);
+  int32_t GetConstant(uint16_t dex_register_number) const {
+    DexRegisterLocation location = GetDexRegisterLocation(dex_register_number);
     DCHECK_EQ(location.GetKind(), DexRegisterLocation::Kind::kConstant);
     return location.GetValue();
   }
 
-  int32_t GetMachineRegister(uint16_t dex_register_number,
-                             uint16_t number_of_dex_registers,
-                             const CodeInfo& code_info) const {
-    DexRegisterLocation location =
-        GetDexRegisterLocation(dex_register_number, number_of_dex_registers, code_info);
+  int32_t GetMachineRegister(uint16_t dex_register_number) const {
+    DexRegisterLocation location = GetDexRegisterLocation(dex_register_number);
     DCHECK(location.GetInternalKind() == DexRegisterLocation::Kind::kInRegister ||
            location.GetInternalKind() == DexRegisterLocation::Kind::kInRegisterHigh ||
            location.GetInternalKind() == DexRegisterLocation::Kind::kInFpuRegister ||
@@ -503,7 +489,6 @@
   // Get the index of the entry in the Dex register location catalog
   // corresponding to `dex_register_number`.
   size_t GetLocationCatalogEntryIndex(uint16_t dex_register_number,
-                                      uint16_t number_of_dex_registers,
                                       size_t number_of_location_catalog_entries) const {
     if (!IsDexRegisterLive(dex_register_number)) {
       return DexRegisterLocationCatalog::kNoLocationEntryIndex;
@@ -518,9 +503,9 @@
 
     // The bit offset of the beginning of the map locations.
     size_t map_locations_offset_in_bits =
-        GetLocationMappingDataOffset(number_of_dex_registers) * kBitsPerByte;
+        GetLocationMappingDataOffset(number_of_dex_registers_) * kBitsPerByte;
     size_t index_in_dex_register_map = GetIndexInDexRegisterMap(dex_register_number);
-    DCHECK_LT(index_in_dex_register_map, GetNumberOfLiveDexRegisters(number_of_dex_registers));
+    DCHECK_LT(index_in_dex_register_map, GetNumberOfLiveDexRegisters());
     // The bit size of an entry.
     size_t map_entry_size_in_bits = SingleEntrySizeInBits(number_of_location_catalog_entries);
     // The bit offset where `index_in_dex_register_map` is located.
@@ -535,9 +520,8 @@
   // Map entry at `index_in_dex_register_map` to `location_catalog_entry_index`.
   void SetLocationCatalogEntryIndex(size_t index_in_dex_register_map,
                                     size_t location_catalog_entry_index,
-                                    uint16_t number_of_dex_registers,
                                     size_t number_of_location_catalog_entries) {
-    DCHECK_LT(index_in_dex_register_map, GetNumberOfLiveDexRegisters(number_of_dex_registers));
+    DCHECK_LT(index_in_dex_register_map, GetNumberOfLiveDexRegisters());
     DCHECK_LT(location_catalog_entry_index, number_of_location_catalog_entries);
 
     if (number_of_location_catalog_entries == 1) {
@@ -548,7 +532,7 @@
 
     // The bit offset of the beginning of the map locations.
     size_t map_locations_offset_in_bits =
-        GetLocationMappingDataOffset(number_of_dex_registers) * kBitsPerByte;
+        GetLocationMappingDataOffset(number_of_dex_registers_) * kBitsPerByte;
     // The bit size of an entry.
     size_t map_entry_size_in_bits = SingleEntrySizeInBits(number_of_location_catalog_entries);
     // The bit offset where `index_in_dex_register_map` is located.
@@ -580,6 +564,10 @@
     return number_of_live_dex_registers;
   }
 
+  size_t GetNumberOfLiveDexRegisters() const {
+    return GetNumberOfLiveDexRegisters(number_of_dex_registers_);
+  }
+
   static size_t GetLiveBitMaskOffset() {
     return kFixedSize;
   }
@@ -594,10 +582,9 @@
     return GetLiveBitMaskOffset() + GetLiveBitMaskSize(number_of_dex_registers);
   }
 
-  size_t GetLocationMappingDataSize(uint16_t number_of_dex_registers,
-                                    size_t number_of_location_catalog_entries) const {
+  size_t GetLocationMappingDataSize(size_t number_of_location_catalog_entries) const {
     size_t location_mapping_data_size_in_bits =
-        GetNumberOfLiveDexRegisters(number_of_dex_registers)
+        GetNumberOfLiveDexRegisters()
         * SingleEntrySizeInBits(number_of_location_catalog_entries);
     return RoundUp(location_mapping_data_size_in_bits, kBitsPerByte) / kBitsPerByte;
   }
@@ -620,8 +607,7 @@
     return BitsToBytesRoundUp(region_.size_in_bits());
   }
 
-  void Dump(VariableIndentationOutputStream* vios,
-            const CodeInfo& code_info, uint16_t number_of_dex_registers) const;
+  void Dump(VariableIndentationOutputStream* vios) const;
 
  private:
   // Return the index in the Dex register map corresponding to the Dex
@@ -641,6 +627,8 @@
   static constexpr int kFixedSize = 0;
 
   BitMemoryRegion region_;
+  uint16_t number_of_dex_registers_;
+  const CodeInfo& code_info_;
 
   friend class CodeInfo;
   friend class StackMapStream;
@@ -896,11 +884,13 @@
   DexRegisterMap GetDexRegisterMapOf(StackMap stack_map,
                                      size_t number_of_dex_registers) const {
     if (!stack_map.HasDexRegisterMap()) {
-      return DexRegisterMap();
+      return DexRegisterMap(MemoryRegion(), 0, *this);
     }
     const uint32_t offset = stack_map.GetDexRegisterMapOffset();
     size_t size = ComputeDexRegisterMapSizeOf(offset, number_of_dex_registers);
-    return DexRegisterMap(dex_register_maps_.Subregion(offset, size));
+    return DexRegisterMap(dex_register_maps_.Subregion(offset, size),
+                          number_of_dex_registers,
+                          *this);
   }
 
   size_t GetDexRegisterMapsSize(uint32_t number_of_dex_registers) const {
@@ -918,11 +908,13 @@
                                           InlineInfo inline_info,
                                           uint32_t number_of_dex_registers) const {
     if (!inline_info.HasDexRegisterMapAtDepth(depth)) {
-      return DexRegisterMap();
+      return DexRegisterMap(MemoryRegion(), 0, *this);
     } else {
       uint32_t offset = inline_info.GetDexRegisterMapOffsetAtDepth(depth);
       size_t size = ComputeDexRegisterMapSizeOf(offset, number_of_dex_registers);
-      return DexRegisterMap(dex_register_maps_.Subregion(offset, size));
+      return DexRegisterMap(dex_register_maps_.Subregion(offset, size),
+                            number_of_dex_registers,
+                            *this);
     }
   }
 
@@ -1036,9 +1028,11 @@
     // art::DexRegisterMap::GetNumberOfLiveDexRegisters and
     DexRegisterMap dex_register_map_without_locations(
         MemoryRegion(dex_register_maps_.Subregion(dex_register_map_offset,
-                                        location_mapping_data_offset_in_dex_register_map)));
+                                        location_mapping_data_offset_in_dex_register_map)),
+        number_of_dex_registers,
+        *this);
     size_t number_of_live_dex_registers =
-        dex_register_map_without_locations.GetNumberOfLiveDexRegisters(number_of_dex_registers);
+        dex_register_map_without_locations.GetNumberOfLiveDexRegisters();
     size_t location_mapping_data_size_in_bits =
         DexRegisterMap::SingleEntrySizeInBits(GetNumberOfLocationCatalogEntries())
         * number_of_live_dex_registers;
@@ -1084,6 +1078,7 @@
   BitTable<1> stack_masks_;
 
   friend class OatDumper;
+  friend class StackMapStream;
 };
 
 #undef ELEMENT_BYTE_OFFSET_AFTER
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 95efc8a..ab1a4bb 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -3679,8 +3679,7 @@
           REQUIRES_SHARED(Locks::mutator_lock_) {
         bool found = false;
         for (size_t dex_reg = 0; dex_reg != number_of_dex_registers; ++dex_reg) {
-          DexRegisterLocation location = dex_register_map.GetDexRegisterLocation(
-              dex_reg, number_of_dex_registers, code_info);
+          DexRegisterLocation location = dex_register_map.GetDexRegisterLocation(dex_reg);
           if (location.GetKind() == kind && static_cast<size_t>(location.GetValue()) == index) {
             visitor(ref, dex_reg, stack_visitor);
             found = true;