diff --git a/compiler/optimizing/inliner.cc b/compiler/optimizing/inliner.cc
index af2fe9c..6080551 100644
--- a/compiler/optimizing/inliner.cc
+++ b/compiler/optimizing/inliner.cc
@@ -1138,7 +1138,7 @@
                         *code_item,
                         compiler_driver_,
                         inline_stats.get(),
-                        resolved_method->GetQuickenedInfo(),
+                        resolved_method->GetQuickenedInfo(class_linker->GetImagePointerSize()),
                         dex_cache,
                         handles_);
 
diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index d3a55dd..99504aa 100644
--- a/compiler/optimizing/optimizing_compiler.cc
+++ b/compiler/optimizing/optimizing_compiler.cc
@@ -867,9 +867,10 @@
     return nullptr;
   }
 
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   DexCompilationUnit dex_compilation_unit(
       class_loader,
-      Runtime::Current()->GetClassLinker(),
+      class_linker,
       dex_file,
       code_item,
       class_def_idx,
@@ -908,7 +909,7 @@
   if (method != nullptr) {
     graph->SetArtMethod(method);
     ScopedObjectAccess soa(Thread::Current());
-    interpreter_metadata = method->GetQuickenedInfo();
+    interpreter_metadata = method->GetQuickenedInfo(class_linker->GetImagePointerSize());
     uint16_t type_index = method->GetDeclaringClass()->GetDexTypeIndex();
 
     // Update the dex cache if the type is not in it yet. Note that under AOT,
diff --git a/runtime/art_method.cc b/runtime/art_method.cc
index c97c328..937dcee 100644
--- a/runtime/art_method.cc
+++ b/runtime/art_method.cc
@@ -283,7 +283,9 @@
       // Ensure that we won't be accidentally calling quick compiled code when -Xint.
       if (kIsDebugBuild && runtime->GetInstrumentation()->IsForcedInterpretOnly()) {
         CHECK(!runtime->UseJitCompilation());
-        const void* oat_quick_code = runtime->GetClassLinker()->GetOatMethodQuickCodeFor(this);
+        const void* oat_quick_code = (IsNative() || !IsInvokable() || IsProxyMethod())
+            ? nullptr
+            : GetOatMethodQuickCode(runtime->GetClassLinker()->GetImagePointerSize());
         CHECK(oat_quick_code == nullptr || oat_quick_code != GetEntryPointFromQuickCompiledCode())
             << "Don't call compiled code when -Xint " << PrettyMethod(this);
       }
@@ -360,6 +362,80 @@
   return annotations::IsMethodAnnotationPresent(this, annotation_handle, visibility);
 }
 
+static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file,
+                                                 uint16_t class_def_idx,
+                                                 uint32_t method_idx) {
+  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx);
+  const uint8_t* class_data = dex_file.GetClassData(class_def);
+  CHECK(class_data != nullptr);
+  ClassDataItemIterator it(dex_file, class_data);
+  // Skip fields
+  while (it.HasNextStaticField()) {
+    it.Next();
+  }
+  while (it.HasNextInstanceField()) {
+    it.Next();
+  }
+  // Process methods
+  size_t class_def_method_index = 0;
+  while (it.HasNextDirectMethod()) {
+    if (it.GetMemberIndex() == method_idx) {
+      return class_def_method_index;
+    }
+    class_def_method_index++;
+    it.Next();
+  }
+  while (it.HasNextVirtualMethod()) {
+    if (it.GetMemberIndex() == method_idx) {
+      return class_def_method_index;
+    }
+    class_def_method_index++;
+    it.Next();
+  }
+  DCHECK(!it.HasNext());
+  LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
+  UNREACHABLE();
+}
+
+static const OatFile::OatMethod FindOatMethodFor(ArtMethod* method,
+                                                 PointerSize pointer_size,
+                                                 bool* found)
+    REQUIRES_SHARED(Locks::mutator_lock_) {
+  // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
+  // method for direct methods (or virtual methods made direct).
+  mirror::Class* declaring_class = method->GetDeclaringClass();
+  size_t oat_method_index;
+  if (method->IsStatic() || method->IsDirect()) {
+    // Simple case where the oat method index was stashed at load time.
+    oat_method_index = method->GetMethodIndex();
+  } else {
+    // Compute the oat_method_index by search for its position in the declared virtual methods.
+    oat_method_index = declaring_class->NumDirectMethods();
+    bool found_virtual = false;
+    for (ArtMethod& art_method : declaring_class->GetVirtualMethods(pointer_size)) {
+      // Check method index instead of identity in case of duplicate method definitions.
+      if (method->GetDexMethodIndex() == art_method.GetDexMethodIndex()) {
+        found_virtual = true;
+        break;
+      }
+      oat_method_index++;
+    }
+    CHECK(found_virtual) << "Didn't find oat method index for virtual method: "
+                         << PrettyMethod(method);
+  }
+  DCHECK_EQ(oat_method_index,
+            GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
+                                             method->GetDeclaringClass()->GetDexClassDefIndex(),
+                                             method->GetDexMethodIndex()));
+  OatFile::OatClass oat_class = OatFile::FindOatClass(*declaring_class->GetDexCache()->GetDexFile(),
+                                                      declaring_class->GetDexClassDefIndex(),
+                                                      found);
+  if (!(*found)) {
+    return OatFile::OatMethod::Invalid();
+  }
+  return oat_class.GetOatMethod(oat_method_index);
+}
+
 bool ArtMethod::EqualParameters(Handle<mirror::ObjectArray<mirror::Class>> params) {
   auto* dex_cache = GetDexCache();
   auto* dex_file = dex_cache->GetDexFile();
@@ -386,10 +462,9 @@
   return true;
 }
 
-const uint8_t* ArtMethod::GetQuickenedInfo() {
+const uint8_t* ArtMethod::GetQuickenedInfo(PointerSize pointer_size) {
   bool found = false;
-  OatFile::OatMethod oat_method =
-      Runtime::Current()->GetClassLinker()->FindOatMethodFor(this, &found);
+  OatFile::OatMethod oat_method = FindOatMethodFor(this, pointer_size, &found);
   if (!found || (oat_method.GetQuickCode() != nullptr)) {
     return nullptr;
   }
@@ -433,7 +508,7 @@
   }
 
   // Check whether the pc is in the JIT code cache.
-  jit::Jit* jit = Runtime::Current()->GetJit();
+  jit::Jit* jit = runtime->GetJit();
   if (jit != nullptr) {
     jit::JitCodeCache* code_cache = jit->GetCodeCache();
     OatQuickMethodHeader* method_header = code_cache->LookupMethodHeader(pc, this);
@@ -452,7 +527,8 @@
 
   // The code has to be in an oat file.
   bool found;
-  OatFile::OatMethod oat_method = class_linker->FindOatMethodFor(this, &found);
+  OatFile::OatMethod oat_method =
+      FindOatMethodFor(this, class_linker->GetImagePointerSize(), &found);
   if (!found) {
     if (class_linker->IsQuickResolutionStub(existing_entry_point)) {
       // We are running the generic jni stub, but the entry point of the method has not
@@ -491,15 +567,29 @@
   return method_header;
 }
 
+const void* ArtMethod::GetOatMethodQuickCode(PointerSize pointer_size) {
+  bool found;
+  OatFile::OatMethod oat_method = FindOatMethodFor(this, pointer_size, &found);
+  if (found) {
+    return oat_method.GetQuickCode();
+  }
+  return nullptr;
+}
+
 bool ArtMethod::HasAnyCompiledCode() {
+  if (IsNative() || !IsInvokable() || IsProxyMethod()) {
+    return false;
+  }
+
   // Check whether the JIT has compiled it.
-  jit::Jit* jit = Runtime::Current()->GetJit();
+  Runtime* runtime = Runtime::Current();
+  jit::Jit* jit = runtime->GetJit();
   if (jit != nullptr && jit->GetCodeCache()->ContainsMethod(this)) {
     return true;
   }
 
   // Check whether we have AOT code.
-  return Runtime::Current()->GetClassLinker()->GetOatMethodQuickCodeFor(this) != nullptr;
+  return GetOatMethodQuickCode(runtime->GetClassLinker()->GetImagePointerSize()) != nullptr;
 }
 
 void ArtMethod::CopyFrom(ArtMethod* src, PointerSize image_pointer_size) {
diff --git a/runtime/art_method.h b/runtime/art_method.h
index 7a8f479..0d0bf20 100644
--- a/runtime/art_method.h
+++ b/runtime/art_method.h
@@ -600,13 +600,17 @@
     return hotness_count_;
   }
 
-  const uint8_t* GetQuickenedInfo() REQUIRES_SHARED(Locks::mutator_lock_);
+  const uint8_t* GetQuickenedInfo(PointerSize pointer_size) REQUIRES_SHARED(Locks::mutator_lock_);
 
   // Returns the method header for the compiled code containing 'pc'. Note that runtime
   // methods will return null for this method, as they are not oat based.
   const OatQuickMethodHeader* GetOatQuickMethodHeader(uintptr_t pc)
       REQUIRES_SHARED(Locks::mutator_lock_);
 
+  // Get compiled code for the method, return null if no code exists.
+  const void* GetOatMethodQuickCode(PointerSize pointer_size)
+      REQUIRES_SHARED(Locks::mutator_lock_);
+
   // Returns whether the method has any compiled code, JIT or AOT.
   bool HasAnyCompiledCode() REQUIRES_SHARED(Locks::mutator_lock_);
 
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 0d3c012..6f24568 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -2750,104 +2750,15 @@
                                          image_pointer_size_);
 }
 
-OatFile::OatClass ClassLinker::FindOatClass(const DexFile& dex_file,
-                                            uint16_t class_def_idx,
-                                            bool* found) {
-  DCHECK_NE(class_def_idx, DexFile::kDexNoIndex16);
-  const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile();
-  if (oat_dex_file == nullptr) {
-    *found = false;
-    return OatFile::OatClass::Invalid();
-  }
-  *found = true;
-  return oat_dex_file->GetOatClass(class_def_idx);
-}
-
-static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file,
-                                                 uint16_t class_def_idx,
-                                                 uint32_t method_idx) {
-  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx);
-  const uint8_t* class_data = dex_file.GetClassData(class_def);
-  CHECK(class_data != nullptr);
-  ClassDataItemIterator it(dex_file, class_data);
-  // Skip fields
-  while (it.HasNextStaticField()) {
-    it.Next();
-  }
-  while (it.HasNextInstanceField()) {
-    it.Next();
-  }
-  // Process methods
-  size_t class_def_method_index = 0;
-  while (it.HasNextDirectMethod()) {
-    if (it.GetMemberIndex() == method_idx) {
-      return class_def_method_index;
-    }
-    class_def_method_index++;
-    it.Next();
-  }
-  while (it.HasNextVirtualMethod()) {
-    if (it.GetMemberIndex() == method_idx) {
-      return class_def_method_index;
-    }
-    class_def_method_index++;
-    it.Next();
-  }
-  DCHECK(!it.HasNext());
-  LOG(FATAL) << "Failed to find method index " << method_idx << " in " << dex_file.GetLocation();
-  UNREACHABLE();
-}
-
-const OatFile::OatMethod ClassLinker::FindOatMethodFor(ArtMethod* method, bool* found) {
-  // Although we overwrite the trampoline of non-static methods, we may get here via the resolution
-  // method for direct methods (or virtual methods made direct).
-  mirror::Class* declaring_class = method->GetDeclaringClass();
-  size_t oat_method_index;
-  if (method->IsStatic() || method->IsDirect()) {
-    // Simple case where the oat method index was stashed at load time.
-    oat_method_index = method->GetMethodIndex();
-  } else {
-    // We're invoking a virtual method directly (thanks to sharpening), compute the oat_method_index
-    // by search for its position in the declared virtual methods.
-    oat_method_index = declaring_class->NumDirectMethods();
-    bool found_virtual = false;
-    for (ArtMethod& art_method : declaring_class->GetVirtualMethods(image_pointer_size_)) {
-      // Check method index instead of identity in case of duplicate method definitions.
-      if (method->GetDexMethodIndex() == art_method.GetDexMethodIndex()) {
-        found_virtual = true;
-        break;
-      }
-      oat_method_index++;
-    }
-    CHECK(found_virtual) << "Didn't find oat method index for virtual method: "
-                         << PrettyMethod(method);
-  }
-  DCHECK_EQ(oat_method_index,
-            GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
-                                             method->GetDeclaringClass()->GetDexClassDefIndex(),
-                                             method->GetDexMethodIndex()));
-  OatFile::OatClass oat_class = FindOatClass(*declaring_class->GetDexCache()->GetDexFile(),
-                                             declaring_class->GetDexClassDefIndex(),
-                                             found);
-  if (!(*found)) {
-    return OatFile::OatMethod::Invalid();
-  }
-  return oat_class.GetOatMethod(oat_method_index);
-}
-
 // Special case to get oat code without overwriting a trampoline.
 const void* ClassLinker::GetQuickOatCodeFor(ArtMethod* method) {
   CHECK(method->IsInvokable()) << PrettyMethod(method);
   if (method->IsProxyMethod()) {
     return GetQuickProxyInvokeHandler();
   }
-  bool found;
-  OatFile::OatMethod oat_method = FindOatMethodFor(method, &found);
-  if (found) {
-    auto* code = oat_method.GetQuickCode();
-    if (code != nullptr) {
-      return code;
-    }
+  auto* code = method->GetOatMethodQuickCode(GetImagePointerSize());
+  if (code != nullptr) {
+    return code;
   }
   if (method->IsNative()) {
     // No code and native? Use generic trampoline.
@@ -2856,18 +2767,6 @@
   return GetQuickToInterpreterBridge();
 }
 
-const void* ClassLinker::GetOatMethodQuickCodeFor(ArtMethod* method) {
-  if (method->IsNative() || !method->IsInvokable() || method->IsProxyMethod()) {
-    return nullptr;
-  }
-  bool found;
-  OatFile::OatMethod oat_method = FindOatMethodFor(method, &found);
-  if (found) {
-    return oat_method.GetQuickCode();
-  }
-  return nullptr;
-}
-
 bool ClassLinker::ShouldUseInterpreterEntrypoint(ArtMethod* method, const void* quick_code) {
   if (UNLIKELY(method->IsNative() || method->IsProxyMethod())) {
     return false;
@@ -2938,9 +2837,9 @@
     it.Next();
   }
   bool has_oat_class;
-  OatFile::OatClass oat_class = FindOatClass(dex_file,
-                                             klass->GetDexClassDefIndex(),
-                                             &has_oat_class);
+  OatFile::OatClass oat_class = OatFile::FindOatClass(dex_file,
+                                                      klass->GetDexClassDefIndex(),
+                                                      &has_oat_class);
   // Link the code of methods skipped by LinkCode.
   for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) {
     ArtMethod* method = klass->GetDirectMethod(method_index, image_pointer_size_);
@@ -2965,15 +2864,20 @@
   // Ignore virtual methods on the iterator.
 }
 
-void ClassLinker::EnsureThrowsInvocationError(ArtMethod* method) {
+// Does anything needed to make sure that the compiler will not generate a direct invoke to this
+// method. Should only be called on non-invokable methods.
+inline void EnsureThrowsInvocationError(ClassLinker* class_linker, ArtMethod* method) {
   DCHECK(method != nullptr);
   DCHECK(!method->IsInvokable());
-  method->SetEntryPointFromQuickCompiledCodePtrSize(quick_to_interpreter_bridge_trampoline_,
-                                                    image_pointer_size_);
+  method->SetEntryPointFromQuickCompiledCodePtrSize(
+      class_linker->GetQuickToInterpreterBridgeTrampoline(),
+      class_linker->GetImagePointerSize());
 }
 
-void ClassLinker::LinkCode(ArtMethod* method, const OatFile::OatClass* oat_class,
-                           uint32_t class_def_method_index) {
+static void LinkCode(ClassLinker* class_linker,
+                     ArtMethod* method,
+                     const OatFile::OatClass* oat_class,
+                     uint32_t class_def_method_index) REQUIRES_SHARED(Locks::mutator_lock_) {
   Runtime* const runtime = Runtime::Current();
   if (runtime->IsAotCompiler()) {
     // The following code only applies to a non-compiler runtime.
@@ -2990,10 +2894,10 @@
 
   // Install entry point from interpreter.
   const void* quick_code = method->GetEntryPointFromQuickCompiledCode();
-  bool enter_interpreter = ShouldUseInterpreterEntrypoint(method, quick_code);
+  bool enter_interpreter = class_linker->ShouldUseInterpreterEntrypoint(method, quick_code);
 
   if (!method->IsInvokable()) {
-    EnsureThrowsInvocationError(method);
+    EnsureThrowsInvocationError(class_linker, method);
     return;
   }
 
@@ -3018,7 +2922,8 @@
       // trampoline as entrypoint (non-static), or the resolution trampoline (static).
       // TODO: this doesn't handle all the cases where trampolines may be installed.
       const void* entry_point = method->GetEntryPointFromQuickCompiledCode();
-      DCHECK(IsQuickGenericJniStub(entry_point) || IsQuickResolutionStub(entry_point));
+      DCHECK(class_linker->IsQuickGenericJniStub(entry_point) ||
+             class_linker->IsQuickResolutionStub(entry_point));
     }
   }
 }
@@ -3054,17 +2959,7 @@
   if (class_data == nullptr) {
     return;  // no fields or methods - for example a marker interface
   }
-  bool has_oat_class = false;
-  if (Runtime::Current()->IsStarted() && !Runtime::Current()->IsAotCompiler()) {
-    OatFile::OatClass oat_class = FindOatClass(dex_file, klass->GetDexClassDefIndex(),
-                                               &has_oat_class);
-    if (has_oat_class) {
-      LoadClassMembers(self, dex_file, class_data, klass, &oat_class);
-    }
-  }
-  if (!has_oat_class) {
-    LoadClassMembers(self, dex_file, class_data, klass, nullptr);
-  }
+  LoadClassMembers(self, dex_file, class_data, klass);
 }
 
 LengthPrefixedArray<ArtField>* ClassLinker::AllocArtFieldArray(Thread* self,
@@ -3128,8 +3023,7 @@
 void ClassLinker::LoadClassMembers(Thread* self,
                                    const DexFile& dex_file,
                                    const uint8_t* class_data,
-                                   Handle<mirror::Class> klass,
-                                   const OatFile::OatClass* oat_class) {
+                                   Handle<mirror::Class> klass) {
   {
     // Note: We cannot have thread suspension until the field and method arrays are setup or else
     // Class::VisitFieldRoots may miss some fields or methods.
@@ -3189,6 +3083,12 @@
     klass->SetIFieldsPtr(ifields);
     DCHECK_EQ(klass->NumInstanceFields(), num_ifields);
     // Load methods.
+    bool has_oat_class = false;
+    const OatFile::OatClass oat_class =
+        (Runtime::Current()->IsStarted() && !Runtime::Current()->IsAotCompiler())
+            ? OatFile::FindOatClass(dex_file, klass->GetDexClassDefIndex(), &has_oat_class)
+            : OatFile::OatClass::Invalid();
+    const OatFile::OatClass* oat_class_ptr = has_oat_class ? &oat_class : nullptr;
     klass->SetMethodsPtr(
         AllocArtMethodArray(self, allocator, it.NumDirectMethods() + it.NumVirtualMethods()),
         it.NumDirectMethods(),
@@ -3200,7 +3100,7 @@
     for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
       ArtMethod* method = klass->GetDirectMethodUnchecked(i, image_pointer_size_);
       LoadMethod(dex_file, it, klass, method);
-      LinkCode(method, oat_class, class_def_method_index);
+      LinkCode(this, method, oat_class_ptr, class_def_method_index);
       uint32_t it_method_index = it.GetMemberIndex();
       if (last_dex_method_index == it_method_index) {
         // duplicate case
@@ -3216,7 +3116,7 @@
       ArtMethod* method = klass->GetVirtualMethodUnchecked(i, image_pointer_size_);
       LoadMethod(dex_file, it, klass, method);
       DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
-      LinkCode(method, oat_class, class_def_method_index);
+      LinkCode(this, method, oat_class_ptr, class_def_method_index);
       class_def_method_index++;
     }
     DCHECK(!it.HasNext());
@@ -7185,7 +7085,7 @@
         // The actual method might or might not be marked abstract since we just copied it from a
         // (possibly default) interface method. We need to set it entry point to be the bridge so
         // that the compiler will not invoke the implementation of whatever method we copied from.
-        EnsureThrowsInvocationError(&new_method);
+        EnsureThrowsInvocationError(this, &new_method);
         move_table.emplace(conf_method, &new_method);
         ++out;
       }
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index f69a576..63389d8 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -34,7 +34,7 @@
 #include "dex_file.h"
 #include "gc_root.h"
 #include "jni.h"
-#include "oat_file.h"
+#include "mirror/class.h"
 #include "object_callbacks.h"
 #include "verifier/verifier_log_mode.h"
 
@@ -57,8 +57,9 @@
   class StackTraceElement;
 }  // namespace mirror
 
-class ImtConflictTable;
 template<class T> class Handle;
+class ImtConflictTable;
+template<typename T> class LengthPrefixedArray;
 template<class T> class MutableHandle;
 class InternTable;
 template<class T> class ObjectLock;
@@ -511,19 +512,10 @@
       REQUIRES(!dex_lock_)
       REQUIRES_SHARED(Locks::mutator_lock_);
 
-  // Get the oat code for a method when its class isn't yet initialized
+  // Get the oat code for a method when its class isn't yet initialized.
   const void* GetQuickOatCodeFor(ArtMethod* method)
       REQUIRES_SHARED(Locks::mutator_lock_);
 
-  // Get compiled code for a method, return null if no code
-  // exists. This is unlike Get..OatCodeFor which will return a bridge
-  // or interpreter entrypoint.
-  const void* GetOatMethodQuickCodeFor(ArtMethod* method)
-      REQUIRES_SHARED(Locks::mutator_lock_);
-
-  const OatFile::OatMethod FindOatMethodFor(ArtMethod* method, bool* found)
-      REQUIRES_SHARED(Locks::mutator_lock_);
-
   pid_t GetClassesLockOwner();  // For SignalCatcher.
   pid_t GetDexLockOwner();  // For SignalCatcher.
 
@@ -540,6 +532,10 @@
   // Is the given entry point quick code to run the generic JNI stub?
   bool IsQuickGenericJniStub(const void* entry_point) const;
 
+  const void* GetQuickToInterpreterBridgeTrampoline() const {
+    return quick_to_interpreter_bridge_trampoline_;
+  }
+
   InternTable* GetInternTable() const {
     return intern_table_;
   }
@@ -783,8 +779,7 @@
   void LoadClassMembers(Thread* self,
                         const DexFile& dex_file,
                         const uint8_t* class_data,
-                        Handle<mirror::Class> klass,
-                        const OatFile::OatClass* oat_class)
+                        Handle<mirror::Class> klass)
       REQUIRES_SHARED(Locks::mutator_lock_);
 
   void LoadField(const ClassDataItemIterator& it, Handle<mirror::Class> klass, ArtField* dst)
@@ -797,11 +792,6 @@
 
   void FixupStaticTrampolines(mirror::Class* klass) REQUIRES_SHARED(Locks::mutator_lock_);
 
-  // Finds the associated oat class for a dex_file and descriptor. Returns an invalid OatClass on
-  // error and sets found to false.
-  OatFile::OatClass FindOatClass(const DexFile& dex_file, uint16_t class_def_idx, bool* found)
-      REQUIRES_SHARED(Locks::mutator_lock_);
-
   void RegisterDexFileLocked(const DexFile& dex_file, Handle<mirror::DexCache> dex_cache)
       REQUIRES(dex_lock_)
       REQUIRES_SHARED(Locks::mutator_lock_);
@@ -861,11 +851,6 @@
                    ArtMethod** out_imt)
       REQUIRES_SHARED(Locks::mutator_lock_);
 
-  // Does anything needed to make sure that the compiler will not generate a direct invoke to this
-  // method. Should only be called on non-invokable methods.
-  void EnsureThrowsInvocationError(ArtMethod* method)
-      REQUIRES_SHARED(Locks::mutator_lock_);
-
   // A wrapper class representing the result of a method translation used for linking methods and
   // updating superclass default methods. For each method in a classes vtable there are 4 states it
   // could be in:
@@ -1015,10 +1000,6 @@
       REQUIRES_SHARED(Locks::mutator_lock_);
   bool LinkFields(Thread* self, Handle<mirror::Class> klass, bool is_static, size_t* class_size)
       REQUIRES_SHARED(Locks::mutator_lock_);
-  void LinkCode(ArtMethod* method,
-                const OatFile::OatClass* oat_class,
-                uint32_t class_def_method_index)
-      REQUIRES_SHARED(Locks::mutator_lock_);
   void CreateReferenceInstanceOffsets(Handle<mirror::Class> klass)
       REQUIRES_SHARED(Locks::mutator_lock_);
 
diff --git a/runtime/instrumentation.cc b/runtime/instrumentation.cc
index ff43389..a73970b 100644
--- a/runtime/instrumentation.cc
+++ b/runtime/instrumentation.cc
@@ -887,11 +887,10 @@
 }
 
 const void* Instrumentation::GetQuickCodeFor(ArtMethod* method, PointerSize pointer_size) const {
-  Runtime* runtime = Runtime::Current();
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   if (LIKELY(!instrumentation_stubs_installed_)) {
     const void* code = method->GetEntryPointFromQuickCompiledCodePtrSize(pointer_size);
     DCHECK(code != nullptr);
-    ClassLinker* class_linker = runtime->GetClassLinker();
     if (LIKELY(!class_linker->IsQuickResolutionStub(code) &&
                !class_linker->IsQuickToInterpreterBridge(code)) &&
                !class_linker->IsQuickResolutionStub(code) &&
@@ -899,7 +898,7 @@
       return code;
     }
   }
-  return runtime->GetClassLinker()->GetQuickOatCodeFor(method);
+  return class_linker->GetQuickOatCodeFor(method);
 }
 
 void Instrumentation::MethodEnterEventImpl(Thread* thread, mirror::Object* this_object,
diff --git a/runtime/oat_file.cc b/runtime/oat_file.cc
index ea692cd..b05d7ac 100644
--- a/runtime/oat_file.cc
+++ b/runtime/oat_file.cc
@@ -52,6 +52,7 @@
 #include "utf-inl.h"
 #include "utils.h"
 #include "utils/dex_cache_arrays_layout-inl.h"
+#include "vdex_file.h"
 
 namespace art {
 
@@ -1497,4 +1498,17 @@
   return true;
 }
 
+OatFile::OatClass OatFile::FindOatClass(const DexFile& dex_file,
+                                        uint16_t class_def_idx,
+                                        bool* found) {
+  DCHECK_NE(class_def_idx, DexFile::kDexNoIndex16);
+  const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile();
+  if (oat_dex_file == nullptr) {
+    *found = false;
+    return OatFile::OatClass::Invalid();
+  }
+  *found = true;
+  return oat_dex_file->GetOatClass(class_def_idx);
+}
+
 }  // namespace art
diff --git a/runtime/oat_file.h b/runtime/oat_file.h
index a61b941..fb6250a 100644
--- a/runtime/oat_file.h
+++ b/runtime/oat_file.h
@@ -23,16 +23,14 @@
 
 #include "base/mutex.h"
 #include "base/stringpiece.h"
+#include "compiler_filter.h"
 #include "dex_file.h"
-#include "invoke_type.h"
-#include "mem_map.h"
 #include "mirror/class.h"
 #include "oat.h"
 #include "os.h"
 #include "type_lookup_table.h"
 #include "utf.h"
 #include "utils.h"
-#include "vdex_file.h"
 
 namespace art {
 
@@ -42,6 +40,7 @@
 class OatMethodOffsets;
 class OatHeader;
 class OatDexFile;
+class VdexFile;
 
 namespace gc {
 namespace collector {
@@ -200,7 +199,7 @@
     uint32_t GetOatMethodOffsetsOffset(uint32_t method_index) const;
 
     // A representation of an invalid OatClass, used when an OatClass can't be found.
-    // See ClassLinker::FindOatClass.
+    // See FindOatClass().
     static OatClass Invalid() {
       return OatClass(nullptr, mirror::Class::kStatusError, kOatClassNoneCompiled, 0, nullptr,
                       nullptr);
@@ -290,6 +289,10 @@
   static bool GetDexLocationsFromDependencies(const char* dex_dependencies,
                                               std::vector<std::string>* locations);
 
+  // Finds the associated oat class for a dex_file and descriptor. Returns an invalid OatClass on
+  // error and sets found to false.
+  static OatClass FindOatClass(const DexFile& dex_file, uint16_t class_def_idx, bool* found);
+
  protected:
   OatFile(const std::string& filename, bool executable);
 
diff --git a/runtime/openjdkjvmti/transform.cc b/runtime/openjdkjvmti/transform.cc
index 9c42b2f..f59e01e 100644
--- a/runtime/openjdkjvmti/transform.cc
+++ b/runtime/openjdkjvmti/transform.cc
@@ -43,6 +43,7 @@
 #include "mirror/class-inl.h"
 #include "mirror/class_loader-inl.h"
 #include "mirror/string-inl.h"
+#include "oat_file.h"
 #include "scoped_thread_state_change-inl.h"
 #include "thread_list.h"
 #include "transform.h"
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index df0dca0..3d74af4 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -143,6 +143,7 @@
 #include "trace.h"
 #include "transaction.h"
 #include "utils.h"
+#include "vdex_file.h"
 #include "verifier/method_verifier.h"
 #include "well_known_classes.h"
 
diff --git a/test/117-nopatchoat/nopatchoat.cc b/test/117-nopatchoat/nopatchoat.cc
index 56c0dcd..3236bde 100644
--- a/test/117-nopatchoat/nopatchoat.cc
+++ b/test/117-nopatchoat/nopatchoat.cc
@@ -19,6 +19,7 @@
 #include "gc/heap.h"
 #include "gc/space/image_space.h"
 #include "mirror/class-inl.h"
+#include "oat_file.h"
 #include "runtime.h"
 #include "scoped_thread_state_change-inl.h"
 #include "thread.h"
diff --git a/test/common/stack_inspect.cc b/test/common/stack_inspect.cc
index d2aacf0..4df2d47 100644
--- a/test/common/stack_inspect.cc
+++ b/test/common/stack_inspect.cc
@@ -20,6 +20,7 @@
 #include "dex_file-inl.h"
 #include "mirror/class-inl.h"
 #include "nth_caller_visitor.h"
+#include "oat_file.h"
 #include "runtime.h"
 #include "scoped_thread_state_change-inl.h"
 #include "stack.h"