diff --git a/compiler/driver/compiler_driver-inl.h b/compiler/driver/compiler_driver-inl.h
new file mode 100644
index 0000000..d401398
--- /dev/null
+++ b/compiler/driver/compiler_driver-inl.h
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_COMPILER_DRIVER_COMPILER_DRIVER_INL_H_
+#define ART_COMPILER_DRIVER_COMPILER_DRIVER_INL_H_
+
+#include "compiler_driver.h"
+#include "dex/compiler_ir.h"
+#include "mirror/art_field.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/class_loader.h"
+#include "mirror/dex_cache.h"
+#include "mirror/art_field-inl.h"
+#include "scoped_thread_state_change.h"
+
+namespace art {
+
+inline mirror::DexCache* CompilerDriver::GetDexCache(const DexCompilationUnit* mUnit) {
+  return mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile());
+}
+
+inline mirror::ClassLoader* CompilerDriver::GetClassLoader(ScopedObjectAccess& soa,
+                                                           const DexCompilationUnit* mUnit) {
+  return soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader());
+}
+
+inline mirror::Class* CompilerDriver::ResolveCompilingMethodsClass(
+    ScopedObjectAccess& soa, const SirtRef<mirror::DexCache>& dex_cache,
+    const SirtRef<mirror::ClassLoader>& class_loader, const DexCompilationUnit* mUnit) {
+  DCHECK(dex_cache->GetDexFile() == mUnit->GetDexFile());
+  DCHECK(class_loader.get() == soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()));
+  const DexFile::MethodId& referrer_method_id =
+      mUnit->GetDexFile()->GetMethodId(mUnit->GetDexMethodIndex());
+  mirror::Class* referrer_class = mUnit->GetClassLinker()->ResolveType(
+      *mUnit->GetDexFile(), referrer_method_id.class_idx_, dex_cache, class_loader);
+  DCHECK_EQ(referrer_class == nullptr, soa.Self()->IsExceptionPending());
+  if (UNLIKELY(referrer_class == nullptr)) {
+    // Clean up any exception left by type resolution.
+    soa.Self()->ClearException();
+  }
+  return referrer_class;
+}
+
+inline mirror::ArtField* CompilerDriver::ResolveField(
+    ScopedObjectAccess& soa, const SirtRef<mirror::DexCache>& dex_cache,
+    const SirtRef<mirror::ClassLoader>& class_loader, const DexCompilationUnit* mUnit,
+    uint32_t field_idx, bool is_static) {
+  DCHECK(dex_cache->GetDexFile() == mUnit->GetDexFile());
+  DCHECK(class_loader.get() == soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()));
+  mirror::ArtField* resolved_field = mUnit->GetClassLinker()->ResolveField(
+      *mUnit->GetDexFile(), field_idx, dex_cache, class_loader, is_static);
+  DCHECK_EQ(resolved_field == nullptr, soa.Self()->IsExceptionPending());
+  if (UNLIKELY(resolved_field == nullptr)) {
+    // Clean up any exception left by type resolution.
+    soa.Self()->ClearException();
+    return nullptr;
+  }
+  if (UNLIKELY(resolved_field->IsStatic() != is_static)) {
+    // ClassLinker can return a field of the wrong kind directly from the DexCache.
+    // Silently return nullptr on such incompatible class change.
+    return nullptr;
+  }
+  return resolved_field;
+}
+
+inline void CompilerDriver::GetResolvedFieldDexFileLocation(
+    mirror::ArtField* resolved_field, const DexFile** declaring_dex_file,
+    uint16_t* declaring_class_idx, uint16_t* declaring_field_idx) {
+  mirror::Class* declaring_class = resolved_field->GetDeclaringClass();
+  *declaring_dex_file = declaring_class->GetDexCache()->GetDexFile();
+  *declaring_class_idx = declaring_class->GetDexTypeIndex();
+  *declaring_field_idx = resolved_field->GetDexFieldIndex();
+}
+
+inline bool CompilerDriver::IsFieldVolatile(mirror::ArtField* field) {
+  return field->IsVolatile();
+}
+
+inline std::pair<bool, bool> CompilerDriver::IsFastInstanceField(
+    mirror::DexCache* dex_cache, mirror::Class* referrer_class,
+    mirror::ArtField* resolved_field, uint16_t field_idx, MemberOffset* field_offset) {
+  DCHECK(!resolved_field->IsStatic());
+  mirror::Class* fields_class = resolved_field->GetDeclaringClass();
+  bool fast_get = referrer_class != nullptr &&
+      referrer_class->CanAccessResolvedField(fields_class, resolved_field,
+                                             dex_cache, field_idx);
+  bool fast_put = fast_get && (!resolved_field->IsFinal() || fields_class == referrer_class);
+  *field_offset = fast_get ? resolved_field->GetOffset() : MemberOffset(0u);
+  return std::make_pair(fast_get, fast_put);
+}
+
+inline std::pair<bool, bool> CompilerDriver::IsFastStaticField(
+    mirror::DexCache* dex_cache, mirror::Class* referrer_class,
+    mirror::ArtField* resolved_field, uint16_t field_idx, MemberOffset* field_offset,
+    uint32_t* storage_index, bool* is_referrers_class, bool* is_initialized) {
+  DCHECK(resolved_field->IsStatic());
+  if (LIKELY(referrer_class != nullptr)) {
+    mirror::Class* fields_class = resolved_field->GetDeclaringClass();
+    if (fields_class == referrer_class) {
+      *field_offset = resolved_field->GetOffset();
+      *storage_index = fields_class->GetDexTypeIndex();
+      *is_referrers_class = true;  // implies no worrying about class initialization
+      *is_initialized = true;
+      return std::make_pair(true, true);
+    }
+    if (referrer_class->CanAccessResolvedField(fields_class, resolved_field,
+                                               dex_cache, field_idx)) {
+      // We have the resolved field, we must make it into a index for the referrer
+      // in its static storage (which may fail if it doesn't have a slot for it)
+      // TODO: for images we can elide the static storage base null check
+      // if we know there's a non-null entry in the image
+      const DexFile* dex_file = dex_cache->GetDexFile();
+      uint32_t storage_idx = DexFile::kDexNoIndex;
+      if (LIKELY(fields_class->GetDexCache() == dex_cache)) {
+        // common case where the dex cache of both the referrer and the field are the same,
+        // no need to search the dex file
+        storage_idx = fields_class->GetDexTypeIndex();
+      } else {
+        // Search dex file for localized ssb index, may fail if field's class is a parent
+        // of the class mentioned in the dex file and there is no dex cache entry.
+        const DexFile::StringId* string_id =
+            dex_file->FindStringId(FieldHelper(resolved_field).GetDeclaringClassDescriptor());
+        if (string_id != nullptr) {
+          const DexFile::TypeId* type_id =
+             dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id));
+          if (type_id != nullptr) {
+            // medium path, needs check of static storage base being initialized
+            storage_idx = dex_file->GetIndexForTypeId(*type_id);
+          }
+        }
+      }
+      if (storage_idx != DexFile::kDexNoIndex) {
+        *field_offset = resolved_field->GetOffset();
+        *storage_index = storage_idx;
+        *is_referrers_class = false;
+        *is_initialized = fields_class->IsInitialized() &&
+            CanAssumeTypeIsPresentInDexCache(*dex_file, storage_idx);
+        return std::make_pair(true, !resolved_field->IsFinal());
+      }
+    }
+  }
+  // Conservative defaults.
+  *field_offset = MemberOffset(0u);
+  *storage_index = DexFile::kDexNoIndex;
+  *is_referrers_class = false;
+  *is_initialized = false;
+  return std::make_pair(false, false);
+}
+
+}  // namespace art
+
+#endif  // ART_COMPILER_DRIVER_COMPILER_DRIVER_INL_H_