diff --git a/compiler/optimizing/stack_map_stream.cc b/compiler/optimizing/stack_map_stream.cc
index 7a60d4a..d80e2fc 100644
--- a/compiler/optimizing/stack_map_stream.cc
+++ b/compiler/optimizing/stack_map_stream.cc
@@ -84,9 +84,7 @@
         CHECK_EQ(seen_stack_mask.LoadBit(b), stack_mask != nullptr && stack_mask->IsBitSet(b));
       }
       CHECK_EQ(stack_map.HasInlineInfo(), (inlining_depth != 0));
-      if (inlining_depth != 0) {
-        CHECK_EQ(code_info.GetInlineInfoOf(stack_map).GetDepth(), inlining_depth);
-      }
+      CHECK_EQ(code_info.GetInlineDepthOf(stack_map), inlining_depth);
       CHECK_EQ(stack_map.HasDexRegisterMap(), (num_dex_registers != 0));
     });
   }
@@ -174,17 +172,17 @@
     size_t depth = current_inline_infos_.size() - 1;
     dchecks_.emplace_back([=](const CodeInfo& code_info) {
       StackMap stack_map = code_info.GetStackMapAt(stack_map_index);
-      InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map);
-      CHECK_EQ(inline_info.GetDexPcAtDepth(depth), dex_pc);
+      InlineInfo inline_info = code_info.GetInlineInfoAtDepth(stack_map, depth);
+      CHECK_EQ(inline_info.GetDexPc(), dex_pc);
       bool encode_art_method = EncodeArtMethodInInlineInfo(method);
-      CHECK_EQ(inline_info.EncodesArtMethodAtDepth(depth), encode_art_method);
+      CHECK_EQ(inline_info.EncodesArtMethod(), encode_art_method);
       if (encode_art_method) {
-        CHECK_EQ(inline_info.GetArtMethodAtDepth(depth), method);
+        CHECK_EQ(inline_info.GetArtMethod(), method);
       } else {
-        CHECK_EQ(method_infos_[inline_info.GetMethodIndexIdxAtDepth(depth)],
+        CHECK_EQ(method_infos_[inline_info.GetMethodIndexIdx()],
                  method->GetDexMethodIndexUnchecked());
       }
-      CHECK_EQ(inline_info.HasDexRegisterMapAtDepth(depth), (num_dex_registers != 0));
+      CHECK_EQ(inline_info.HasDexRegisterMap(), (num_dex_registers != 0));
     });
   }
 }
@@ -240,9 +238,7 @@
       size_t num_dex_registers = expected_dex_registers->size();
       DexRegisterMap map = (depth == -1)
         ? code_info.GetDexRegisterMapOf(stack_map, num_dex_registers)
-        : code_info.GetDexRegisterMapAtDepth(depth,
-                                             code_info.GetInlineInfoOf(stack_map),
-                                             num_dex_registers);
+        : code_info.GetDexRegisterMapAtDepth(depth, stack_map, num_dex_registers);
       CHECK_EQ(map.size(), num_dex_registers);
       for (size_t r = 0; r < num_dex_registers; r++) {
         CHECK_EQ(expected_dex_registers->at(r), map.Get(r));
diff --git a/compiler/optimizing/stack_map_test.cc b/compiler/optimizing/stack_map_test.cc
index 262c240..77aa3ef 100644
--- a/compiler/optimizing/stack_map_test.cc
+++ b/compiler/optimizing/stack_map_test.cc
@@ -189,12 +189,13 @@
     ASSERT_EQ(-2, location1.GetValue());
 
     ASSERT_TRUE(stack_map.HasInlineInfo());
-    InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map);
-    ASSERT_EQ(2u, inline_info.GetDepth());
-    ASSERT_EQ(3u, inline_info.GetDexPcAtDepth(0));
-    ASSERT_EQ(2u, inline_info.GetDexPcAtDepth(1));
-    ASSERT_TRUE(inline_info.EncodesArtMethodAtDepth(0));
-    ASSERT_TRUE(inline_info.EncodesArtMethodAtDepth(1));
+    InlineInfo inline_info0 = code_info.GetInlineInfoAtDepth(stack_map, 0);
+    InlineInfo inline_info1 = code_info.GetInlineInfoAtDepth(stack_map, 1);
+    ASSERT_EQ(2u, code_info.GetInlineDepthOf(stack_map));
+    ASSERT_EQ(3u, inline_info0.GetDexPc());
+    ASSERT_EQ(2u, inline_info1.GetDexPc());
+    ASSERT_TRUE(inline_info0.EncodesArtMethod());
+    ASSERT_TRUE(inline_info1.EncodesArtMethod());
   }
 
   // Second stack map.
@@ -361,8 +362,8 @@
     // Test that the inline info dex register map deduplicated to the same offset as the stack map
     // one.
     ASSERT_TRUE(stack_map.HasInlineInfo());
-    InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map);
-    EXPECT_EQ(inline_info.GetDexRegisterMapIndexAtDepth(0),
+    InlineInfo inline_info = code_info.GetInlineInfoAtDepth(stack_map, 0);
+    EXPECT_EQ(inline_info.GetDexRegisterMapIndex(),
               stack_map.GetDexRegisterMapIndex());
   }
 }
@@ -605,17 +606,18 @@
     ASSERT_EQ(0, dex_registers0.GetStackOffsetInBytes(0));
     ASSERT_EQ(4, dex_registers0.GetConstant(1));
 
-    InlineInfo if0 = ci.GetInlineInfoOf(sm0);
-    ASSERT_EQ(2u, if0.GetDepth());
-    ASSERT_EQ(2u, if0.GetDexPcAtDepth(0));
-    ASSERT_TRUE(if0.EncodesArtMethodAtDepth(0));
-    ASSERT_EQ(3u, if0.GetDexPcAtDepth(1));
-    ASSERT_TRUE(if0.EncodesArtMethodAtDepth(1));
+    InlineInfo if0_0 = ci.GetInlineInfoAtDepth(sm0, 0);
+    InlineInfo if0_1 = ci.GetInlineInfoAtDepth(sm0, 1);
+    ASSERT_EQ(2u, ci.GetInlineDepthOf(sm0));
+    ASSERT_EQ(2u, if0_0.GetDexPc());
+    ASSERT_TRUE(if0_0.EncodesArtMethod());
+    ASSERT_EQ(3u, if0_1.GetDexPc());
+    ASSERT_TRUE(if0_1.EncodesArtMethod());
 
-    DexRegisterMap dex_registers1 = ci.GetDexRegisterMapAtDepth(0, if0, 1);
+    DexRegisterMap dex_registers1 = ci.GetDexRegisterMapAtDepth(0, sm0, 1);
     ASSERT_EQ(8, dex_registers1.GetStackOffsetInBytes(0));
 
-    DexRegisterMap dex_registers2 = ci.GetDexRegisterMapAtDepth(1, if0, 3);
+    DexRegisterMap dex_registers2 = ci.GetDexRegisterMapAtDepth(1, sm0, 3);
     ASSERT_EQ(16, dex_registers2.GetStackOffsetInBytes(0));
     ASSERT_EQ(20, dex_registers2.GetConstant(1));
     ASSERT_EQ(15, dex_registers2.GetMachineRegister(2));
@@ -629,24 +631,26 @@
     ASSERT_EQ(56, dex_registers0.GetStackOffsetInBytes(0));
     ASSERT_EQ(0, dex_registers0.GetConstant(1));
 
-    InlineInfo if1 = ci.GetInlineInfoOf(sm1);
-    ASSERT_EQ(3u, if1.GetDepth());
-    ASSERT_EQ(2u, if1.GetDexPcAtDepth(0));
-    ASSERT_TRUE(if1.EncodesArtMethodAtDepth(0));
-    ASSERT_EQ(3u, if1.GetDexPcAtDepth(1));
-    ASSERT_TRUE(if1.EncodesArtMethodAtDepth(1));
-    ASSERT_EQ(5u, if1.GetDexPcAtDepth(2));
-    ASSERT_TRUE(if1.EncodesArtMethodAtDepth(2));
+    InlineInfo if1_0 = ci.GetInlineInfoAtDepth(sm1, 0);
+    InlineInfo if1_1 = ci.GetInlineInfoAtDepth(sm1, 1);
+    InlineInfo if1_2 = ci.GetInlineInfoAtDepth(sm1, 2);
+    ASSERT_EQ(3u, ci.GetInlineDepthOf(sm1));
+    ASSERT_EQ(2u, if1_0.GetDexPc());
+    ASSERT_TRUE(if1_0.EncodesArtMethod());
+    ASSERT_EQ(3u, if1_1.GetDexPc());
+    ASSERT_TRUE(if1_1.EncodesArtMethod());
+    ASSERT_EQ(5u, if1_2.GetDexPc());
+    ASSERT_TRUE(if1_2.EncodesArtMethod());
 
-    DexRegisterMap dex_registers1 = ci.GetDexRegisterMapAtDepth(0, if1, 1);
+    DexRegisterMap dex_registers1 = ci.GetDexRegisterMapAtDepth(0, sm1, 1);
     ASSERT_EQ(12, dex_registers1.GetStackOffsetInBytes(0));
 
-    DexRegisterMap dex_registers2 = ci.GetDexRegisterMapAtDepth(1, if1, 3);
+    DexRegisterMap dex_registers2 = ci.GetDexRegisterMapAtDepth(1, sm1, 3);
     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));
+    ASSERT_FALSE(if1_2.HasDexRegisterMap());
   }
 
   {
@@ -667,21 +671,23 @@
     ASSERT_EQ(56, dex_registers0.GetStackOffsetInBytes(0));
     ASSERT_EQ(0, dex_registers0.GetConstant(1));
 
-    InlineInfo if2 = ci.GetInlineInfoOf(sm3);
-    ASSERT_EQ(3u, if2.GetDepth());
-    ASSERT_EQ(2u, if2.GetDexPcAtDepth(0));
-    ASSERT_TRUE(if2.EncodesArtMethodAtDepth(0));
-    ASSERT_EQ(5u, if2.GetDexPcAtDepth(1));
-    ASSERT_TRUE(if2.EncodesArtMethodAtDepth(1));
-    ASSERT_EQ(10u, if2.GetDexPcAtDepth(2));
-    ASSERT_TRUE(if2.EncodesArtMethodAtDepth(2));
+    InlineInfo if2_0 = ci.GetInlineInfoAtDepth(sm3, 0);
+    InlineInfo if2_1 = ci.GetInlineInfoAtDepth(sm3, 1);
+    InlineInfo if2_2 = ci.GetInlineInfoAtDepth(sm3, 2);
+    ASSERT_EQ(3u, ci.GetInlineDepthOf(sm3));
+    ASSERT_EQ(2u, if2_0.GetDexPc());
+    ASSERT_TRUE(if2_0.EncodesArtMethod());
+    ASSERT_EQ(5u, if2_1.GetDexPc());
+    ASSERT_TRUE(if2_1.EncodesArtMethod());
+    ASSERT_EQ(10u, if2_2.GetDexPc());
+    ASSERT_TRUE(if2_2.EncodesArtMethod());
 
-    ASSERT_FALSE(if2.HasDexRegisterMapAtDepth(0));
+    ASSERT_FALSE(if2_0.HasDexRegisterMap());
 
-    DexRegisterMap dex_registers1 = ci.GetDexRegisterMapAtDepth(1, if2, 1);
+    DexRegisterMap dex_registers1 = ci.GetDexRegisterMapAtDepth(1, sm3, 1);
     ASSERT_EQ(2, dex_registers1.GetMachineRegister(0));
 
-    DexRegisterMap dex_registers2 = ci.GetDexRegisterMapAtDepth(2, if2, 2);
+    DexRegisterMap dex_registers2 = ci.GetDexRegisterMapAtDepth(2, sm3, 2);
     ASSERT_FALSE(dex_registers2.IsDexRegisterLive(0));
     ASSERT_EQ(3, dex_registers2.GetMachineRegister(1));
   }
diff --git a/runtime/entrypoints/entrypoint_utils-inl.h b/runtime/entrypoints/entrypoint_utils-inl.h
index f6b1c73..12e1397 100644
--- a/runtime/entrypoints/entrypoint_utils-inl.h
+++ b/runtime/entrypoints/entrypoint_utils-inl.h
@@ -46,22 +46,24 @@
 
 inline ArtMethod* GetResolvedMethod(ArtMethod* outer_method,
                                     const MethodInfo& method_info,
-                                    const InlineInfo& inline_info,
+                                    const CodeInfo& code_info,
+                                    const StackMap& stack_map,
                                     uint8_t inlining_depth)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   DCHECK(!outer_method->IsObsolete());
+  InlineInfo inline_info = code_info.GetInlineInfoAtDepth(stack_map, inlining_depth);
 
   // This method is being used by artQuickResolutionTrampoline, before it sets up
   // the passed parameters in a GC friendly way. Therefore we must never be
   // suspended while executing it.
   ScopedAssertNoThreadSuspension sants(__FUNCTION__);
 
-  if (inline_info.EncodesArtMethodAtDepth(inlining_depth)) {
-    return inline_info.GetArtMethodAtDepth(inlining_depth);
+  if (inline_info.EncodesArtMethod()) {
+    return inline_info.GetArtMethod();
   }
 
-  uint32_t method_index = inline_info.GetMethodIndexAtDepth(method_info, inlining_depth);
-  if (inline_info.GetDexPcAtDepth(inlining_depth) == static_cast<uint32_t>(-1)) {
+  uint32_t method_index = inline_info.GetMethodIndex(method_info);
+  if (inline_info.GetDexPc() == static_cast<uint32_t>(-1)) {
     // "charAt" special case. It is the only non-leaf method we inline across dex files.
     ArtMethod* inlined_method = jni::DecodeArtMethod(WellKnownClasses::java_lang_String_charAt);
     DCHECK_EQ(inlined_method->GetDexMethodIndex(), method_index);
@@ -72,9 +74,10 @@
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   ArtMethod* method = outer_method;
   for (uint32_t depth = 0, end = inlining_depth + 1u; depth != end; ++depth) {
-    DCHECK(!inline_info.EncodesArtMethodAtDepth(depth));
-    DCHECK_NE(inline_info.GetDexPcAtDepth(depth), static_cast<uint32_t>(-1));
-    method_index = inline_info.GetMethodIndexAtDepth(method_info, depth);
+    inline_info = code_info.GetInlineInfoAtDepth(stack_map, depth);
+    DCHECK(!inline_info.EncodesArtMethod());
+    DCHECK_NE(inline_info.GetDexPc(), static_cast<uint32_t>(-1));
+    method_index = inline_info.GetMethodIndex(method_info);
     ArtMethod* inlined_method = class_linker->LookupResolvedMethod(method_index,
                                                                    method->GetDexCache(),
                                                                    method->GetClassLoader());
diff --git a/runtime/entrypoints/entrypoint_utils.cc b/runtime/entrypoints/entrypoint_utils.cc
index 7f9b385..e71d1fa 100644
--- a/runtime/entrypoints/entrypoint_utils.cc
+++ b/runtime/entrypoints/entrypoint_utils.cc
@@ -205,12 +205,9 @@
       MethodInfo method_info = current_code->GetOptimizedMethodInfo();
       StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset);
       DCHECK(stack_map.IsValid());
-      if (stack_map.HasInlineInfo()) {
-        InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map);
-        caller = GetResolvedMethod(outer_method,
-                                   method_info,
-                                   inline_info,
-                                   inline_info.GetDepth() - 1);
+      uint32_t depth = code_info.GetInlineDepthOf(stack_map);
+      if (depth != 0) {
+        caller = GetResolvedMethod(outer_method, method_info, code_info, stack_map, depth - 1);
       }
     }
     if (kIsDebugBuild && do_caller_check) {
diff --git a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
index a59faea..af6a936 100644
--- a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
@@ -344,9 +344,10 @@
       CodeInfo code_info(current_code);
       StackMap stack_map = code_info.GetStackMapForNativePcOffset(outer_pc_offset);
       DCHECK(stack_map.IsValid());
-      if (stack_map.HasInlineInfo()) {
-        InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map);
-        return inline_info.GetDexPcAtDepth(inline_info.GetDepth()-1);
+      uint32_t depth = code_info.GetInlineDepthOf(stack_map);
+      if (depth != 0) {
+        InlineInfo inline_info = code_info.GetInlineInfoAtDepth(stack_map, depth - 1);
+        return inline_info.GetDexPc();
       } else {
         return stack_map.GetDexPc();
       }
@@ -1231,17 +1232,17 @@
   LOG(FATAL_WITHOUT_ABORT) << "  instruction: " << DumpInstruction(outer_method, dex_pc);
 
   ArtMethod* caller = outer_method;
-  if (stack_map.HasInlineInfo()) {
-    InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map);
-    size_t depth = inline_info.GetDepth();
+  uint32_t depth = code_info.GetInlineDepthOf(stack_map);
+  if (depth != 0) {
     for (size_t d = 0; d < depth; ++d) {
+      InlineInfo inline_info = code_info.GetInlineInfoAtDepth(stack_map, d);
       const char* tag = "";
-      dex_pc = inline_info.GetDexPcAtDepth(d);
-      if (inline_info.EncodesArtMethodAtDepth(d)) {
+      dex_pc = inline_info.GetDexPc();
+      if (inline_info.EncodesArtMethod()) {
         tag = "encoded ";
-        caller = inline_info.GetArtMethodAtDepth(d);
+        caller = inline_info.GetArtMethod();
       } else {
-        uint32_t method_index = inline_info.GetMethodIndexAtDepth(method_info, d);
+        uint32_t method_index = inline_info.GetMethodIndex(method_info);
         if (dex_pc == static_cast<uint32_t>(-1)) {
           tag = "special ";
           CHECK_EQ(d + 1u, depth);
diff --git a/runtime/quick_exception_handler.cc b/runtime/quick_exception_handler.cc
index 4f4abf7..23ccf6a 100644
--- a/runtime/quick_exception_handler.cc
+++ b/runtime/quick_exception_handler.cc
@@ -406,7 +406,7 @@
     BitMemoryRegion stack_mask = code_info.GetStackMaskOf(stack_map);
     DexRegisterMap vreg_map = IsInInlinedFrame()
         ? code_info.GetDexRegisterMapAtDepth(GetCurrentInliningDepth() - 1,
-                                             code_info.GetInlineInfoOf(stack_map),
+                                             stack_map,
                                              number_of_vregs)
         : code_info.GetDexRegisterMapOf(stack_map, number_of_vregs);
 
diff --git a/runtime/stack.cc b/runtime/stack.cc
index 6da7dcb..bd0d5d6 100644
--- a/runtime/stack.cc
+++ b/runtime/stack.cc
@@ -76,14 +76,14 @@
   }
 }
 
-static InlineInfo GetCurrentInlineInfo(CodeInfo& code_info,
-                                       const OatQuickMethodHeader* method_header,
-                                       uintptr_t cur_quick_frame_pc)
+static StackMap GetCurrentStackMap(CodeInfo& code_info,
+                                   const OatQuickMethodHeader* method_header,
+                                   uintptr_t cur_quick_frame_pc)
     REQUIRES_SHARED(Locks::mutator_lock_) {
   uint32_t native_pc_offset = method_header->NativeQuickPcOffset(cur_quick_frame_pc);
   StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset);
   DCHECK(stack_map.IsValid());
-  return code_info.GetInlineInfoOf(stack_map);
+  return stack_map;
 }
 
 ArtMethod* StackVisitor::GetMethod() const {
@@ -94,14 +94,13 @@
       size_t depth_in_stack_map = current_inlining_depth_ - 1;
       const OatQuickMethodHeader* method_header = GetCurrentOatQuickMethodHeader();
       CodeInfo code_info(method_header);
-      InlineInfo inline_info = GetCurrentInlineInfo(code_info,
-                                                    method_header,
-                                                    cur_quick_frame_pc_);
+      StackMap stack_map = GetCurrentStackMap(code_info, method_header, cur_quick_frame_pc_);
       MethodInfo method_info = method_header->GetOptimizedMethodInfo();
       DCHECK(walk_kind_ != StackWalkKind::kSkipInlinedFrames);
       return GetResolvedMethod(*GetCurrentQuickFrame(),
                                method_info,
-                               inline_info,
+                               code_info,
+                               stack_map,
                                depth_in_stack_map);
     } else {
       return *cur_quick_frame_;
@@ -118,8 +117,8 @@
       const OatQuickMethodHeader* method_header = GetCurrentOatQuickMethodHeader();
       CodeInfo code_info(method_header);
       size_t depth_in_stack_map = current_inlining_depth_ - 1;
-      return GetCurrentInlineInfo(code_info, method_header, cur_quick_frame_pc_).
-          GetDexPcAtDepth(depth_in_stack_map);
+      StackMap stack_map = GetCurrentStackMap(code_info, method_header, cur_quick_frame_pc_);
+      return code_info.GetInlineInfoAtDepth(stack_map, depth_in_stack_map).GetDexPc();
     } else if (cur_oat_quick_method_header_ == nullptr) {
       return dex::kDexNoIndex;
     } else {
@@ -237,9 +236,7 @@
   size_t depth_in_stack_map = current_inlining_depth_ - 1;
 
   DexRegisterMap dex_register_map = IsInInlinedFrame()
-      ? code_info.GetDexRegisterMapAtDepth(depth_in_stack_map,
-                                           code_info.GetInlineInfoOf(stack_map),
-                                           number_of_dex_registers)
+      ? code_info.GetDexRegisterMapAtDepth(depth_in_stack_map, stack_map, number_of_dex_registers)
       : code_info.GetDexRegisterMapOf(stack_map, number_of_dex_registers);
 
   if (!dex_register_map.IsValid()) {
@@ -825,9 +822,8 @@
               cur_oat_quick_method_header_->NativeQuickPcOffset(cur_quick_frame_pc_);
           StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset);
           if (stack_map.IsValid() && stack_map.HasInlineInfo()) {
-            InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map);
             DCHECK_EQ(current_inlining_depth_, 0u);
-            for (current_inlining_depth_ = inline_info.GetDepth();
+            for (current_inlining_depth_ = code_info.GetInlineDepthOf(stack_map);
                  current_inlining_depth_ != 0;
                  --current_inlining_depth_) {
               bool should_continue = VisitFrame();
diff --git a/runtime/stack_map.cc b/runtime/stack_map.cc
index 923bb35..a5749b8 100644
--- a/runtime/stack_map.cc
+++ b/runtime/stack_map.cc
@@ -146,38 +146,39 @@
   }
   vios->Stream() << ")\n";
   DumpDexRegisterMap(vios, code_info.GetDexRegisterMapOf(*this, number_of_dex_registers));
-  if (HasInlineInfo()) {
-    InlineInfo inline_info = code_info.GetInlineInfoOf(*this);
+  uint32_t depth = code_info.GetInlineDepthOf(*this);
+  for (size_t d = 0; d < depth; d++) {
+    InlineInfo inline_info = code_info.GetInlineInfoAtDepth(*this, d);
     // We do not know the length of the dex register maps of inlined frames
     // at this level, so we just pass null to `InlineInfo::Dump` to tell
     // it not to look at these maps.
-    inline_info.Dump(vios, code_info, method_info, nullptr);
+    inline_info.Dump(vios, code_info, *this, method_info, 0);
   }
 }
 
 void InlineInfo::Dump(VariableIndentationOutputStream* vios,
                       const CodeInfo& code_info,
+                      const StackMap& stack_map,
                       const MethodInfo& method_info,
-                      uint16_t number_of_dex_registers[]) const {
-  for (size_t i = 0; i < GetDepth(); ++i) {
+                      uint16_t number_of_dex_registers) const {
+  uint32_t depth = Row() - stack_map.GetInlineInfoIndex();
+  vios->Stream()
+      << "InlineInfo[" << Row() << "]"
+      << " (depth=" << depth
+      << std::hex
+      << ", dex_pc=0x" << GetDexPc();
+  if (EncodesArtMethod()) {
+    ScopedObjectAccess soa(Thread::Current());
+    vios->Stream() << ", method=" << GetArtMethod()->PrettyMethod();
+  } else {
     vios->Stream()
-        << "InlineInfo[" << Row() + i << "]"
-        << " (depth=" << i
-        << std::hex
-        << ", dex_pc=0x" << GetDexPcAtDepth(i);
-    if (EncodesArtMethodAtDepth(i)) {
-      ScopedObjectAccess soa(Thread::Current());
-      vios->Stream() << ", method=" << GetArtMethodAtDepth(i)->PrettyMethod();
-    } else {
-      vios->Stream()
-          << std::dec
-          << ", method_index=" << GetMethodIndexAtDepth(method_info, i);
-    }
-    vios->Stream() << ")\n";
-    if (number_of_dex_registers != nullptr) {
-      uint16_t vregs = number_of_dex_registers[i];
-      DumpDexRegisterMap(vios, code_info.GetDexRegisterMapAtDepth(i, *this, vregs));
-    }
+        << std::dec
+        << ", method_index=" << GetMethodIndex(method_info);
+  }
+  vios->Stream() << ")\n";
+  if (number_of_dex_registers != 0) {
+    uint16_t vregs = number_of_dex_registers;
+    DumpDexRegisterMap(vios, code_info.GetDexRegisterMapAtDepth(depth, stack_map, vregs));
   }
 }
 
diff --git a/runtime/stack_map.h b/runtime/stack_map.h
index 9aac204..b04197e 100644
--- a/runtime/stack_map.h
+++ b/runtime/stack_map.h
@@ -222,54 +222,47 @@
   InlineInfo(const BitTable<kCount>* table, uint32_t row)
     : BitTable<kCount>::Accessor(table, row) {}
 
-  ALWAYS_INLINE InlineInfo AtDepth(uint32_t depth) const {
-    return InlineInfo(table_, this->row_ + depth);
+  uint32_t GetIsLast() const { return Get<kIsLast>(); }
+
+  uint32_t GetMethodIndexIdx() const {
+    DCHECK(!EncodesArtMethod());
+    return Get<kMethodIndexIdx>();
   }
 
-  uint32_t GetDepth() const {
-    size_t depth = 0;
-    while (AtDepth(depth++).Get<kIsLast>() == kMore) { }
-    return depth;
+  uint32_t GetMethodIndex(const MethodInfo& method_info) const {
+    return method_info.GetMethodIndex(GetMethodIndexIdx());
   }
 
-  uint32_t GetMethodIndexIdxAtDepth(uint32_t depth) const {
-    DCHECK(!EncodesArtMethodAtDepth(depth));
-    return AtDepth(depth).Get<kMethodIndexIdx>();
+  uint32_t GetDexPc() const {
+    return Get<kDexPc>();
   }
 
-  uint32_t GetMethodIndexAtDepth(const MethodInfo& method_info, uint32_t depth) const {
-    return method_info.GetMethodIndex(GetMethodIndexIdxAtDepth(depth));
+  bool EncodesArtMethod() const {
+    return Get<kArtMethodLo>() != kNoValue;
   }
 
-  uint32_t GetDexPcAtDepth(uint32_t depth) const {
-    return AtDepth(depth).Get<kDexPc>();
-  }
-
-  bool EncodesArtMethodAtDepth(uint32_t depth) const {
-    return AtDepth(depth).Get<kArtMethodLo>() != kNoValue;
-  }
-
-  ArtMethod* GetArtMethodAtDepth(uint32_t depth) const {
-    uint64_t lo = AtDepth(depth).Get<kArtMethodLo>();
-    uint64_t hi = AtDepth(depth).Get<kArtMethodHi>();
+  ArtMethod* GetArtMethod() const {
+    uint64_t lo = Get<kArtMethodLo>();
+    uint64_t hi = Get<kArtMethodHi>();
     return reinterpret_cast<ArtMethod*>((hi << 32) | lo);
   }
 
-  uint32_t GetDexRegisterMaskIndexAtDepth(uint32_t depth) const {
-    return AtDepth(depth).Get<kDexRegisterMaskIndex>();
+  uint32_t GetDexRegisterMaskIndex() const {
+    return Get<kDexRegisterMaskIndex>();
   }
 
-  uint32_t GetDexRegisterMapIndexAtDepth(uint32_t depth) const {
-    return AtDepth(depth).Get<kDexRegisterMapIndex>();
+  uint32_t GetDexRegisterMapIndex() const {
+    return Get<kDexRegisterMapIndex>();
   }
-  bool HasDexRegisterMapAtDepth(uint32_t depth) const {
-    return GetDexRegisterMapIndexAtDepth(depth) != kNoValue;
+  bool HasDexRegisterMap() const {
+    return GetDexRegisterMapIndex() != kNoValue;
   }
 
   void Dump(VariableIndentationOutputStream* vios,
             const CodeInfo& info,
+            const StackMap& stack_map,
             const MethodInfo& method_info,
-            uint16_t* number_of_dex_registers) const;
+            uint16_t number_of_dex_registers) const;
 };
 
 class InvokeInfo : public BitTable<3>::Accessor {
@@ -417,10 +410,11 @@
   }
 
   ALWAYS_INLINE DexRegisterMap GetDexRegisterMapAtDepth(uint8_t depth,
-                                                        InlineInfo inline_info,
+                                                        StackMap stack_map,
                                                         size_t num_dex_registers) const {
-    return DecodeDexRegisterMap(inline_info.GetDexRegisterMaskIndexAtDepth(depth),
-                                inline_info.GetDexRegisterMapIndexAtDepth(depth),
+    InlineInfo inline_info = GetInlineInfoAtDepth(stack_map, depth);
+    return DecodeDexRegisterMap(inline_info.GetDexRegisterMaskIndex(),
+                                inline_info.GetDexRegisterMapIndex(),
                                 num_dex_registers);
   }
 
@@ -428,10 +422,19 @@
     return InlineInfo(&inline_infos_, index);
   }
 
-  InlineInfo GetInlineInfoOf(StackMap stack_map) const {
-    DCHECK(stack_map.HasInlineInfo());
+  uint32_t GetInlineDepthOf(StackMap stack_map) const {
+    uint32_t depth = 0;
     uint32_t index = stack_map.GetInlineInfoIndex();
-    return GetInlineInfo(index);
+    if (index != StackMap::kNoValue) {
+      while (GetInlineInfo(index + depth++).GetIsLast() == InlineInfo::kMore) { }
+    }
+    return depth;
+  }
+
+  InlineInfo GetInlineInfoAtDepth(StackMap stack_map, uint32_t depth) const {
+    DCHECK(stack_map.HasInlineInfo());
+    DCHECK_LT(depth, GetInlineDepthOf(stack_map));
+    return GetInlineInfo(stack_map.GetInlineInfoIndex() + depth);
   }
 
   StackMap GetStackMapForDexPc(uint32_t dex_pc) const {
@@ -473,7 +476,6 @@
                 stack_map.GetNativePcOffset(kRuntimeISA)) {
           DCHECK_EQ(other.GetDexRegisterMapIndex(),
                     stack_map.GetDexRegisterMapIndex());
-          DCHECK(!stack_map.HasInlineInfo());
           if (i < e - 2) {
             // Make sure there are not three identical stack maps following each other.
             DCHECK_NE(