From 7940e44f4517de5e2634a7e07d58d0fb26160513 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 12 Jul 2013 13:46:57 -0700
Subject: Create separate Android.mk for main build targets

The runtime, compiler, dex2oat, and oatdump now are in seperate trees
to prevent dependency creep.  They can now be individually built
without rebuilding the rest of the art projects. dalvikvm and jdwpspy
were already this way. Builds in the art directory should behave as
before, building everything including tests.

Change-Id: Ic6b1151e5ed0f823c3dd301afd2b13eb2d8feb81
---
 compiler/driver/compiler_driver.cc | 2404 ++++++++++++++++++++++++++++++++++++
 1 file changed, 2404 insertions(+)
 create mode 100644 compiler/driver/compiler_driver.cc

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
new file mode 100644
index 0000000000..c99d103c17
--- /dev/null
+++ b/compiler/driver/compiler_driver.cc
@@ -0,0 +1,2404 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "compiler_driver.h"
+
+#include <vector>
+
+#include <unistd.h>
+
+#include "base/stl_util.h"
+#include "base/timing_logger.h"
+#include "class_linker.h"
+#include "dex_compilation_unit.h"
+#include "dex_file-inl.h"
+#include "jni_internal.h"
+#include "oat_file.h"
+#include "object_utils.h"
+#include "runtime.h"
+#include "gc/accounting/card_table-inl.h"
+#include "gc/accounting/heap_bitmap.h"
+#include "gc/space/space.h"
+#include "mirror/class_loader.h"
+#include "mirror/class-inl.h"
+#include "mirror/dex_cache-inl.h"
+#include "mirror/field-inl.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/throwable.h"
+#include "scoped_thread_state_change.h"
+#include "ScopedLocalRef.h"
+#include "stubs/stubs.h"
+#include "thread.h"
+#include "thread_pool.h"
+#include "verifier/method_verifier.h"
+
+#if defined(ART_USE_PORTABLE_COMPILER)
+#include "elf_writer_mclinker.h"
+#else
+#include "elf_writer_quick.h"
+#endif
+
+namespace art {
+
+static double Percentage(size_t x, size_t y) {
+  return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y));
+}
+
+static void DumpStat(size_t x, size_t y, const char* str) {
+  if (x == 0 && y == 0) {
+    return;
+  }
+  LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases";
+}
+
+class AOTCompilationStats {
+ public:
+  AOTCompilationStats()
+      : stats_lock_("AOT compilation statistics lock"),
+        types_in_dex_cache_(0), types_not_in_dex_cache_(0),
+        strings_in_dex_cache_(0), strings_not_in_dex_cache_(0),
+        resolved_types_(0), unresolved_types_(0),
+        resolved_instance_fields_(0), unresolved_instance_fields_(0),
+        resolved_local_static_fields_(0), resolved_static_fields_(0), unresolved_static_fields_(0),
+        type_based_devirtualization_(0),
+        safe_casts_(0), not_safe_casts_(0) {
+    for (size_t i = 0; i <= kMaxInvokeType; i++) {
+      resolved_methods_[i] = 0;
+      unresolved_methods_[i] = 0;
+      virtual_made_direct_[i] = 0;
+      direct_calls_to_boot_[i] = 0;
+      direct_methods_to_boot_[i] = 0;
+    }
+  }
+
+  void Dump() {
+    DumpStat(types_in_dex_cache_, types_not_in_dex_cache_, "types known to be in dex cache");
+    DumpStat(strings_in_dex_cache_, strings_not_in_dex_cache_, "strings known to be in dex cache");
+    DumpStat(resolved_types_, unresolved_types_, "types resolved");
+    DumpStat(resolved_instance_fields_, unresolved_instance_fields_, "instance fields resolved");
+    DumpStat(resolved_local_static_fields_ + resolved_static_fields_, unresolved_static_fields_,
+             "static fields resolved");
+    DumpStat(resolved_local_static_fields_, resolved_static_fields_ + unresolved_static_fields_,
+             "static fields local to a class");
+    DumpStat(safe_casts_, not_safe_casts_, "check-casts removed based on type information");
+    // Note, the code below subtracts the stat value so that when added to the stat value we have
+    // 100% of samples. TODO: clean this up.
+    DumpStat(type_based_devirtualization_,
+             resolved_methods_[kVirtual] + unresolved_methods_[kVirtual] +
+             resolved_methods_[kInterface] + unresolved_methods_[kInterface] -
+             type_based_devirtualization_,
+             "virtual/interface calls made direct based on type information");
+
+    for (size_t i = 0; i <= kMaxInvokeType; i++) {
+      std::ostringstream oss;
+      oss << static_cast<InvokeType>(i) << " methods were AOT resolved";
+      DumpStat(resolved_methods_[i], unresolved_methods_[i], oss.str().c_str());
+      if (virtual_made_direct_[i] > 0) {
+        std::ostringstream oss2;
+        oss2 << static_cast<InvokeType>(i) << " methods made direct";
+        DumpStat(virtual_made_direct_[i],
+                 resolved_methods_[i] + unresolved_methods_[i] - virtual_made_direct_[i],
+                 oss2.str().c_str());
+      }
+      if (direct_calls_to_boot_[i] > 0) {
+        std::ostringstream oss2;
+        oss2 << static_cast<InvokeType>(i) << " method calls are direct into boot";
+        DumpStat(direct_calls_to_boot_[i],
+                 resolved_methods_[i] + unresolved_methods_[i] - direct_calls_to_boot_[i],
+                 oss2.str().c_str());
+      }
+      if (direct_methods_to_boot_[i] > 0) {
+        std::ostringstream oss2;
+        oss2 << static_cast<InvokeType>(i) << " method calls have methods in boot";
+        DumpStat(direct_methods_to_boot_[i],
+                 resolved_methods_[i] + unresolved_methods_[i] - direct_methods_to_boot_[i],
+                 oss2.str().c_str());
+      }
+    }
+  }
+
+// Allow lossy statistics in non-debug builds.
+#ifndef NDEBUG
+#define STATS_LOCK() MutexLock mu(Thread::Current(), stats_lock_)
+#else
+#define STATS_LOCK()
+#endif
+
+  void TypeInDexCache() {
+    STATS_LOCK();
+    types_in_dex_cache_++;
+  }
+
+  void TypeNotInDexCache() {
+    STATS_LOCK();
+    types_not_in_dex_cache_++;
+  }
+
+  void StringInDexCache() {
+    STATS_LOCK();
+    strings_in_dex_cache_++;
+  }
+
+  void StringNotInDexCache() {
+    STATS_LOCK();
+    strings_not_in_dex_cache_++;
+  }
+
+  void TypeDoesntNeedAccessCheck() {
+    STATS_LOCK();
+    resolved_types_++;
+  }
+
+  void TypeNeedsAccessCheck() {
+    STATS_LOCK();
+    unresolved_types_++;
+  }
+
+  void ResolvedInstanceField() {
+    STATS_LOCK();
+    resolved_instance_fields_++;
+  }
+
+  void UnresolvedInstanceField() {
+    STATS_LOCK();
+    unresolved_instance_fields_++;
+  }
+
+  void ResolvedLocalStaticField() {
+    STATS_LOCK();
+    resolved_local_static_fields_++;
+  }
+
+  void ResolvedStaticField() {
+    STATS_LOCK();
+    resolved_static_fields_++;
+  }
+
+  void UnresolvedStaticField() {
+    STATS_LOCK();
+    unresolved_static_fields_++;
+  }
+
+  // Indicate that type information from the verifier led to devirtualization.
+  void PreciseTypeDevirtualization() {
+    STATS_LOCK();
+    type_based_devirtualization_++;
+  }
+
+  // Indicate that a method of the given type was resolved at compile time.
+  void ResolvedMethod(InvokeType type) {
+    DCHECK_LE(type, kMaxInvokeType);
+    STATS_LOCK();
+    resolved_methods_[type]++;
+  }
+
+  // Indicate that a method of the given type was unresolved at compile time as it was in an
+  // unknown dex file.
+  void UnresolvedMethod(InvokeType type) {
+    DCHECK_LE(type, kMaxInvokeType);
+    STATS_LOCK();
+    unresolved_methods_[type]++;
+  }
+
+  // Indicate that a type of virtual method dispatch has been converted into a direct method
+  // dispatch.
+  void VirtualMadeDirect(InvokeType type) {
+    DCHECK(type == kVirtual || type == kInterface || type == kSuper);
+    STATS_LOCK();
+    virtual_made_direct_[type]++;
+  }
+
+  // Indicate that a method of the given type was able to call directly into boot.
+  void DirectCallsToBoot(InvokeType type) {
+    DCHECK_LE(type, kMaxInvokeType);
+    STATS_LOCK();
+    direct_calls_to_boot_[type]++;
+  }
+
+  // Indicate that a method of the given type was able to be resolved directly from boot.
+  void DirectMethodsToBoot(InvokeType type) {
+    DCHECK_LE(type, kMaxInvokeType);
+    STATS_LOCK();
+    direct_methods_to_boot_[type]++;
+  }
+
+  // A check-cast could be eliminated due to verifier type analysis.
+  void SafeCast() {
+    STATS_LOCK();
+    safe_casts_++;
+  }
+
+  // A check-cast couldn't be eliminated due to verifier type analysis.
+  void NotASafeCast() {
+    STATS_LOCK();
+    not_safe_casts_++;
+  }
+
+ private:
+  Mutex stats_lock_;
+
+  size_t types_in_dex_cache_;
+  size_t types_not_in_dex_cache_;
+
+  size_t strings_in_dex_cache_;
+  size_t strings_not_in_dex_cache_;
+
+  size_t resolved_types_;
+  size_t unresolved_types_;
+
+  size_t resolved_instance_fields_;
+  size_t unresolved_instance_fields_;
+
+  size_t resolved_local_static_fields_;
+  size_t resolved_static_fields_;
+  size_t unresolved_static_fields_;
+  // Type based devirtualization for invoke interface and virtual.
+  size_t type_based_devirtualization_;
+
+  size_t resolved_methods_[kMaxInvokeType + 1];
+  size_t unresolved_methods_[kMaxInvokeType + 1];
+  size_t virtual_made_direct_[kMaxInvokeType + 1];
+  size_t direct_calls_to_boot_[kMaxInvokeType + 1];
+  size_t direct_methods_to_boot_[kMaxInvokeType + 1];
+
+  size_t safe_casts_;
+  size_t not_safe_casts_;
+
+  DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats);
+};
+
+extern "C" void ArtInitCompilerContext(art::CompilerDriver& driver);
+extern "C" void ArtInitQuickCompilerContext(art::CompilerDriver& compiler);
+
+extern "C" void ArtUnInitCompilerContext(art::CompilerDriver& driver);
+extern "C" void ArtUnInitQuickCompilerContext(art::CompilerDriver& compiler);
+
+extern "C" art::CompiledMethod* ArtCompileMethod(art::CompilerDriver& driver,
+                                                 const art::DexFile::CodeItem* code_item,
+                                                 uint32_t access_flags,
+                                                 art::InvokeType invoke_type,
+                                                 uint32_t class_def_idx,
+                                                 uint32_t method_idx,
+                                                 jobject class_loader,
+                                                 const art::DexFile& dex_file);
+extern "C" art::CompiledMethod* ArtQuickCompileMethod(art::CompilerDriver& compiler,
+                                                      const art::DexFile::CodeItem* code_item,
+                                                      uint32_t access_flags,
+                                                      art::InvokeType invoke_type,
+                                                      uint32_t class_def_idx,
+                                                      uint32_t method_idx,
+                                                      jobject class_loader,
+                                                      const art::DexFile& dex_file);
+
+extern "C" art::CompiledMethod* ArtCompileDEX(art::CompilerDriver& compiler,
+                                              const art::DexFile::CodeItem* code_item,
+                                              uint32_t access_flags,
+                                              art::InvokeType invoke_type,
+                                              uint32_t class_def_idx,
+                                              uint32_t method_idx,
+                                              jobject class_loader,
+                                              const art::DexFile& dex_file);
+
+extern "C" art::CompiledMethod* SeaIrCompileMethod(art::CompilerDriver& compiler,
+                                                   const art::DexFile::CodeItem* code_item,
+                                                   uint32_t access_flags,
+                                                   art::InvokeType invoke_type,
+                                                   uint32_t class_def_idx,
+                                                   uint32_t method_idx,
+                                                   jobject class_loader,
+                                                   const art::DexFile& dex_file);
+
+extern "C" art::CompiledMethod* ArtLLVMJniCompileMethod(art::CompilerDriver& driver,
+                                                        uint32_t access_flags, uint32_t method_idx,
+                                                        const art::DexFile& dex_file);
+
+extern "C" art::CompiledMethod* ArtQuickJniCompileMethod(art::CompilerDriver& compiler,
+                                                         uint32_t access_flags, uint32_t method_idx,
+                                                         const art::DexFile& dex_file);
+
+extern "C" void compilerLLVMSetBitcodeFileName(art::CompilerDriver& driver,
+                                               std::string const& filename);
+
+CompilerDriver::CompilerDriver(CompilerBackend compiler_backend, InstructionSet instruction_set,
+                               bool image, DescriptorSet* image_classes,
+                               size_t thread_count, bool support_debugging,
+                               bool dump_stats, bool dump_timings)
+    : compiler_backend_(compiler_backend),
+      instruction_set_(instruction_set),
+      freezing_constructor_lock_("freezing constructor lock"),
+      compiled_classes_lock_("compiled classes lock"),
+      compiled_methods_lock_("compiled method lock"),
+      image_(image),
+      image_classes_(image_classes),
+      thread_count_(thread_count),
+      support_debugging_(support_debugging),
+      start_ns_(0),
+      stats_(new AOTCompilationStats),
+      dump_stats_(dump_stats),
+      dump_timings_(dump_timings),
+      compiler_library_(NULL),
+      compiler_(NULL),
+      compiler_context_(NULL),
+      jni_compiler_(NULL),
+      compiler_enable_auto_elf_loading_(NULL),
+      compiler_get_method_code_addr_(NULL),
+      support_boot_image_fixup_(true)
+{
+  CHECK_PTHREAD_CALL(pthread_key_create, (&tls_key_, NULL), "compiler tls key");
+
+  // TODO: more work needed to combine initializations and allow per-method backend selection
+  typedef void (*InitCompilerContextFn)(CompilerDriver&);
+  InitCompilerContextFn init_compiler_context;
+  if (compiler_backend_ == kPortable){
+    // Initialize compiler_context_
+    init_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtInitCompilerContext);
+    compiler_ = reinterpret_cast<CompilerFn>(ArtCompileMethod);
+  } else {
+    init_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtInitQuickCompilerContext);
+    compiler_ = reinterpret_cast<CompilerFn>(ArtQuickCompileMethod);
+  }
+
+  dex_to_dex_compiler_ = reinterpret_cast<CompilerFn>(ArtCompileDEX);
+
+#ifdef ART_SEA_IR_MODE
+  sea_ir_compiler_ = NULL;
+  if (Runtime::Current()->IsSeaIRMode()) {
+    sea_ir_compiler_ = reinterpret_cast<CompilerFn>(SeaIrCompileMethod);
+  }
+#endif
+
+  init_compiler_context(*this);
+
+  if (compiler_backend_ == kPortable) {
+    jni_compiler_ = reinterpret_cast<JniCompilerFn>(ArtLLVMJniCompileMethod);
+  } else {
+    jni_compiler_ = reinterpret_cast<JniCompilerFn>(ArtQuickJniCompileMethod);
+  }
+
+  CHECK(!Runtime::Current()->IsStarted());
+  if (!image_) {
+    CHECK(image_classes_.get() == NULL);
+  }
+}
+
+CompilerDriver::~CompilerDriver() {
+  Thread* self = Thread::Current();
+  {
+    MutexLock mu(self, compiled_classes_lock_);
+    STLDeleteValues(&compiled_classes_);
+  }
+  {
+    MutexLock mu(self, compiled_methods_lock_);
+    STLDeleteValues(&compiled_methods_);
+  }
+  {
+    MutexLock mu(self, compiled_methods_lock_);
+    STLDeleteElements(&code_to_patch_);
+  }
+  {
+    MutexLock mu(self, compiled_methods_lock_);
+    STLDeleteElements(&methods_to_patch_);
+  }
+  CHECK_PTHREAD_CALL(pthread_key_delete, (tls_key_), "delete tls key");
+  typedef void (*UninitCompilerContextFn)(CompilerDriver&);
+  UninitCompilerContextFn uninit_compiler_context;
+  // Uninitialize compiler_context_
+  // TODO: rework to combine initialization/uninitialization
+  if (compiler_backend_ == kPortable) {
+    uninit_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtUnInitCompilerContext);
+  } else {
+    uninit_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtUnInitQuickCompilerContext);
+  }
+  uninit_compiler_context(*this);
+}
+
+CompilerTls* CompilerDriver::GetTls() {
+  // Lazily create thread-local storage
+  CompilerTls* res = static_cast<CompilerTls*>(pthread_getspecific(tls_key_));
+  if (res == NULL) {
+    res = new CompilerTls();
+    CHECK_PTHREAD_CALL(pthread_setspecific, (tls_key_, res), "compiler tls");
+  }
+  return res;
+}
+
+const std::vector<uint8_t>* CompilerDriver::CreatePortableResolutionTrampoline() const {
+  switch (instruction_set_) {
+    case kArm:
+    case kThumb2:
+      return arm::CreatePortableResolutionTrampoline();
+    case kMips:
+      return mips::CreatePortableResolutionTrampoline();
+    case kX86:
+      return x86::CreatePortableResolutionTrampoline();
+    default:
+      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
+      return NULL;
+  }
+}
+
+const std::vector<uint8_t>* CompilerDriver::CreateQuickResolutionTrampoline() const {
+  switch (instruction_set_) {
+    case kArm:
+    case kThumb2:
+      return arm::CreateQuickResolutionTrampoline();
+    case kMips:
+      return mips::CreateQuickResolutionTrampoline();
+    case kX86:
+      return x86::CreateQuickResolutionTrampoline();
+    default:
+      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
+      return NULL;
+  }
+}
+
+const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToInterpreterEntry() const {
+  switch (instruction_set_) {
+    case kArm:
+    case kThumb2:
+      return arm::CreateInterpreterToInterpreterEntry();
+    case kMips:
+      return mips::CreateInterpreterToInterpreterEntry();
+    case kX86:
+      return x86::CreateInterpreterToInterpreterEntry();
+    default:
+      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
+      return NULL;
+  }
+}
+
+const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToQuickEntry() const {
+  switch (instruction_set_) {
+    case kArm:
+    case kThumb2:
+      return arm::CreateInterpreterToQuickEntry();
+    case kMips:
+      return mips::CreateInterpreterToQuickEntry();
+    case kX86:
+      return x86::CreateInterpreterToQuickEntry();
+    default:
+      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
+      return NULL;
+  }
+}
+
+void CompilerDriver::CompileAll(jobject class_loader,
+                                const std::vector<const DexFile*>& dex_files) {
+  DCHECK(!Runtime::Current()->IsStarted());
+
+  UniquePtr<ThreadPool> thread_pool(new ThreadPool(thread_count_));
+  TimingLogger timings("compiler", false);
+
+  PreCompile(class_loader, dex_files, *thread_pool.get(), timings);
+
+  Compile(class_loader, dex_files, *thread_pool.get(), timings);
+
+  if (dump_timings_ && timings.GetTotalNs() > MsToNs(1000)) {
+    LOG(INFO) << Dumpable<TimingLogger>(timings);
+  }
+
+  if (dump_stats_) {
+    stats_->Dump();
+  }
+}
+
+static bool IsDexToDexCompilationAllowed(mirror::ClassLoader* class_loader,
+                                         const DexFile& dex_file,
+                                         const DexFile::ClassDef& class_def)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  // Do not allow DEX-to-DEX compilation of image classes. This is to prevent the
+  // verifier from passing on "quick" instruction at compilation time. It must
+  // only pass on quick instructions at runtime.
+  if (class_loader == NULL) {
+    return false;
+  }
+  const char* descriptor = dex_file.GetClassDescriptor(class_def);
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  mirror::Class* klass = class_linker->FindClass(descriptor, class_loader);
+  if (klass == NULL) {
+    Thread* self = Thread::Current();
+    CHECK(self->IsExceptionPending());
+    self->ClearException();
+    return false;
+  }
+  // DEX-to-DEX compilation is only allowed on preverified classes.
+  return klass->IsVerified();
+}
+
+void CompilerDriver::CompileOne(const mirror::AbstractMethod* method) {
+  DCHECK(!Runtime::Current()->IsStarted());
+  Thread* self = Thread::Current();
+  jobject jclass_loader;
+  const DexFile* dex_file;
+  uint32_t class_def_idx;
+  {
+    ScopedObjectAccessUnchecked soa(self);
+    ScopedLocalRef<jobject>
+      local_class_loader(soa.Env(),
+                    soa.AddLocalReference<jobject>(method->GetDeclaringClass()->GetClassLoader()));
+    jclass_loader = soa.Env()->NewGlobalRef(local_class_loader.get());
+    // Find the dex_file
+    MethodHelper mh(method);
+    dex_file = &mh.GetDexFile();
+    class_def_idx = mh.GetClassDefIndex();
+  }
+  self->TransitionFromRunnableToSuspended(kNative);
+
+  std::vector<const DexFile*> dex_files;
+  dex_files.push_back(dex_file);
+
+  UniquePtr<ThreadPool> thread_pool(new ThreadPool(1U));
+  TimingLogger timings("CompileOne", false);
+  PreCompile(jclass_loader, dex_files, *thread_pool.get(), timings);
+
+  uint32_t method_idx = method->GetDexMethodIndex();
+  const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset());
+  // Can we run DEX-to-DEX compiler on this class ?
+  bool allow_dex_compilation;
+  {
+    ScopedObjectAccess soa(Thread::Current());
+    const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_idx);
+    mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(jclass_loader);
+    allow_dex_compilation = IsDexToDexCompilationAllowed(class_loader, *dex_file, class_def);
+  }
+  CompileMethod(code_item, method->GetAccessFlags(), method->GetInvokeType(),
+                class_def_idx, method_idx, jclass_loader, *dex_file, allow_dex_compilation);
+
+  self->GetJniEnv()->DeleteGlobalRef(jclass_loader);
+
+  self->TransitionFromSuspendedToRunnable();
+}
+
+void CompilerDriver::Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
+                             ThreadPool& thread_pool, TimingLogger& timings) {
+  for (size_t i = 0; i != dex_files.size(); ++i) {
+    const DexFile* dex_file = dex_files[i];
+    CHECK(dex_file != NULL);
+    ResolveDexFile(class_loader, *dex_file, thread_pool, timings);
+  }
+}
+
+void CompilerDriver::PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
+                                ThreadPool& thread_pool, TimingLogger& timings) {
+  LoadImageClasses(timings);
+
+  Resolve(class_loader, dex_files, thread_pool, timings);
+
+  Verify(class_loader, dex_files, thread_pool, timings);
+
+  InitializeClasses(class_loader, dex_files, thread_pool, timings);
+
+  UpdateImageClasses(timings);
+}
+
+bool CompilerDriver::IsImageClass(const char* descriptor) const {
+  DCHECK(descriptor != NULL);
+  if (image_classes_.get() == NULL) {
+    return true;
+  }
+  return image_classes_->find(descriptor) != image_classes_->end();
+}
+
+static void ResolveExceptionsForMethod(MethodHelper* mh,
+    std::set<std::pair<uint16_t, const DexFile*> >& exceptions_to_resolve)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  const DexFile::CodeItem* code_item = mh->GetCodeItem();
+  if (code_item == NULL) {
+    return;  // native or abstract method
+  }
+  if (code_item->tries_size_ == 0) {
+    return;  // nothing to process
+  }
+  const byte* encoded_catch_handler_list = DexFile::GetCatchHandlerData(*code_item, 0);
+  size_t num_encoded_catch_handlers = DecodeUnsignedLeb128(&encoded_catch_handler_list);
+  for (size_t i = 0; i < num_encoded_catch_handlers; i++) {
+    int32_t encoded_catch_handler_size = DecodeSignedLeb128(&encoded_catch_handler_list);
+    bool has_catch_all = false;
+    if (encoded_catch_handler_size <= 0) {
+      encoded_catch_handler_size = -encoded_catch_handler_size;
+      has_catch_all = true;
+    }
+    for (int32_t j = 0; j < encoded_catch_handler_size; j++) {
+      uint16_t encoded_catch_handler_handlers_type_idx =
+          DecodeUnsignedLeb128(&encoded_catch_handler_list);
+      // Add to set of types to resolve if not already in the dex cache resolved types
+      if (!mh->IsResolvedTypeIdx(encoded_catch_handler_handlers_type_idx)) {
+        exceptions_to_resolve.insert(
+            std::pair<uint16_t, const DexFile*>(encoded_catch_handler_handlers_type_idx,
+                                                &mh->GetDexFile()));
+      }
+      // ignore address associated with catch handler
+      DecodeUnsignedLeb128(&encoded_catch_handler_list);
+    }
+    if (has_catch_all) {
+      // ignore catch all address
+      DecodeUnsignedLeb128(&encoded_catch_handler_list);
+    }
+  }
+}
+
+static bool ResolveCatchBlockExceptionsClassVisitor(mirror::Class* c, void* arg)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  std::set<std::pair<uint16_t, const DexFile*> >* exceptions_to_resolve =
+      reinterpret_cast<std::set<std::pair<uint16_t, const DexFile*> >*>(arg);
+  MethodHelper mh;
+  for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
+    mirror::AbstractMethod* m = c->GetVirtualMethod(i);
+    mh.ChangeMethod(m);
+    ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
+  }
+  for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
+    mirror::AbstractMethod* m = c->GetDirectMethod(i);
+    mh.ChangeMethod(m);
+    ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
+  }
+  return true;
+}
+
+static bool RecordImageClassesVisitor(mirror::Class* klass, void* arg)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  CompilerDriver::DescriptorSet* image_classes =
+      reinterpret_cast<CompilerDriver::DescriptorSet*>(arg);
+  image_classes->insert(ClassHelper(klass).GetDescriptor());
+  return true;
+}
+
+// Make a list of descriptors for classes to include in the image
+void CompilerDriver::LoadImageClasses(TimingLogger& timings)
+      LOCKS_EXCLUDED(Locks::mutator_lock_) {
+  if (image_classes_.get() == NULL) {
+    return;
+  }
+
+  // Make a first class to load all classes explicitly listed in the file
+  Thread* self = Thread::Current();
+  ScopedObjectAccess soa(self);
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  typedef DescriptorSet::iterator It;  // TODO: C++0x auto
+  for (It it = image_classes_->begin(), end = image_classes_->end(); it != end;) {
+    std::string descriptor(*it);
+    SirtRef<mirror::Class> klass(self, class_linker->FindSystemClass(descriptor.c_str()));
+    if (klass.get() == NULL) {
+      image_classes_->erase(it++);
+      LOG(WARNING) << "Failed to find class " << descriptor;
+      Thread::Current()->ClearException();
+    } else {
+      ++it;
+    }
+  }
+
+  // Resolve exception classes referenced by the loaded classes. The catch logic assumes
+  // exceptions are resolved by the verifier when there is a catch block in an interested method.
+  // Do this here so that exception classes appear to have been specified image classes.
+  std::set<std::pair<uint16_t, const DexFile*> > unresolved_exception_types;
+  SirtRef<mirror::Class> java_lang_Throwable(self,
+                                     class_linker->FindSystemClass("Ljava/lang/Throwable;"));
+  do {
+    unresolved_exception_types.clear();
+    class_linker->VisitClasses(ResolveCatchBlockExceptionsClassVisitor,
+                               &unresolved_exception_types);
+    typedef std::set<std::pair<uint16_t, const DexFile*> >::const_iterator It;  // TODO: C++0x auto
+    for (It it = unresolved_exception_types.begin(),
+         end = unresolved_exception_types.end();
+         it != end; ++it) {
+      uint16_t exception_type_idx = it->first;
+      const DexFile* dex_file = it->second;
+      mirror::DexCache* dex_cache = class_linker->FindDexCache(*dex_file);
+      mirror:: ClassLoader* class_loader = NULL;
+      SirtRef<mirror::Class> klass(self, class_linker->ResolveType(*dex_file, exception_type_idx,
+                                                                   dex_cache, class_loader));
+      if (klass.get() == NULL) {
+        const DexFile::TypeId& type_id = dex_file->GetTypeId(exception_type_idx);
+        const char* descriptor = dex_file->GetTypeDescriptor(type_id);
+        LOG(FATAL) << "Failed to resolve class " << descriptor;
+      }
+      DCHECK(java_lang_Throwable->IsAssignableFrom(klass.get()));
+    }
+    // Resolving exceptions may load classes that reference more exceptions, iterate until no
+    // more are found
+  } while (!unresolved_exception_types.empty());
+
+  // We walk the roots looking for classes so that we'll pick up the
+  // above classes plus any classes them depend on such super
+  // classes, interfaces, and the required ClassLinker roots.
+  class_linker->VisitClasses(RecordImageClassesVisitor, image_classes_.get());
+
+  CHECK_NE(image_classes_->size(), 0U);
+  timings.AddSplit("LoadImageClasses");
+}
+
+static void MaybeAddToImageClasses(mirror::Class* klass, CompilerDriver::DescriptorSet* image_classes)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  while (!klass->IsObjectClass()) {
+    ClassHelper kh(klass);
+    const char* descriptor = kh.GetDescriptor();
+    std::pair<CompilerDriver::DescriptorSet::iterator, bool> result =
+        image_classes->insert(descriptor);
+    if (result.second) {
+      LOG(INFO) << "Adding " << descriptor << " to image classes";
+    } else {
+      return;
+    }
+    for (size_t i = 0; i < kh.NumDirectInterfaces(); ++i) {
+      MaybeAddToImageClasses(kh.GetDirectInterface(i), image_classes);
+    }
+    if (klass->IsArrayClass()) {
+      MaybeAddToImageClasses(klass->GetComponentType(), image_classes);
+    }
+    klass = klass->GetSuperClass();
+  }
+}
+
+void CompilerDriver::FindClinitImageClassesCallback(mirror::Object* object, void* arg) {
+  DCHECK(object != NULL);
+  DCHECK(arg != NULL);
+  CompilerDriver* compiler_driver = reinterpret_cast<CompilerDriver*>(arg);
+  MaybeAddToImageClasses(object->GetClass(), compiler_driver->image_classes_.get());
+}
+
+void CompilerDriver::UpdateImageClasses(TimingLogger& timings) {
+  if (image_classes_.get() == NULL) {
+    return;
+  }
+
+  // Update image_classes_ with classes for objects created by <clinit> methods.
+  Thread* self = Thread::Current();
+  const char* old_cause = self->StartAssertNoThreadSuspension("ImageWriter");
+  gc::Heap* heap = Runtime::Current()->GetHeap();
+  // TODO: Image spaces only?
+  WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
+  heap->FlushAllocStack();
+  heap->GetLiveBitmap()->Walk(FindClinitImageClassesCallback, this);
+  self->EndAssertNoThreadSuspension(old_cause);
+  timings.AddSplit("UpdateImageClasses");
+}
+
+void CompilerDriver::RecordClassStatus(ClassReference ref, CompiledClass* compiled_class) {
+  MutexLock mu(Thread::Current(), CompilerDriver::compiled_classes_lock_);
+  compiled_classes_.Put(ref, compiled_class);
+}
+
+bool CompilerDriver::CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file,
+                                                      uint32_t type_idx) {
+  if (IsImage() && IsImageClass(dex_file.GetTypeDescriptor(dex_file.GetTypeId(type_idx)))) {
+    if (kIsDebugBuild) {
+      ScopedObjectAccess soa(Thread::Current());
+      mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
+      mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
+      CHECK(resolved_class != NULL);
+    }
+    stats_->TypeInDexCache();
+    return true;
+  } else {
+    stats_->TypeNotInDexCache();
+    return false;
+  }
+}
+
+bool CompilerDriver::CanAssumeStringIsPresentInDexCache(const DexFile& dex_file,
+                                                        uint32_t string_idx) {
+  // See also Compiler::ResolveDexFile
+
+  bool result = false;
+  if (IsImage()) {
+    // We resolve all const-string strings when building for the image.
+    ScopedObjectAccess soa(Thread::Current());
+    mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
+    Runtime::Current()->GetClassLinker()->ResolveString(dex_file, string_idx, dex_cache);
+    result = true;
+  }
+  if (result) {
+    stats_->StringInDexCache();
+  } else {
+    stats_->StringNotInDexCache();
+  }
+  return result;
+}
+
+bool CompilerDriver::CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
+                                                uint32_t type_idx,
+                                                bool* type_known_final, bool* type_known_abstract,
+                                                bool* equals_referrers_class) {
+  if (type_known_final != NULL) {
+    *type_known_final = false;
+  }
+  if (type_known_abstract != NULL) {
+    *type_known_abstract = false;
+  }
+  if (equals_referrers_class != NULL) {
+    *equals_referrers_class = false;
+  }
+  ScopedObjectAccess soa(Thread::Current());
+  mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
+  // Get type from dex cache assuming it was populated by the verifier
+  mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
+  if (resolved_class == NULL) {
+    stats_->TypeNeedsAccessCheck();
+    return false;  // Unknown class needs access checks.
+  }
+  const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
+  if (equals_referrers_class != NULL) {
+    *equals_referrers_class = (method_id.class_idx_ == type_idx);
+  }
+  mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
+  if (referrer_class == NULL) {
+    stats_->TypeNeedsAccessCheck();
+    return false;  // Incomplete referrer knowledge needs access check.
+  }
+  // Perform access check, will return true if access is ok or false if we're going to have to
+  // check this at runtime (for example for class loaders).
+  bool result = referrer_class->CanAccess(resolved_class);
+  if (result) {
+    stats_->TypeDoesntNeedAccessCheck();
+    if (type_known_final != NULL) {
+      *type_known_final = resolved_class->IsFinal() && !resolved_class->IsArrayClass();
+    }
+    if (type_known_abstract != NULL) {
+      *type_known_abstract = resolved_class->IsAbstract() && !resolved_class->IsArrayClass();
+    }
+  } else {
+    stats_->TypeNeedsAccessCheck();
+  }
+  return result;
+}
+
+bool CompilerDriver::CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx,
+                                                            const DexFile& dex_file,
+                                                            uint32_t type_idx) {
+  ScopedObjectAccess soa(Thread::Current());
+  mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
+  // Get type from dex cache assuming it was populated by the verifier.
+  mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
+  if (resolved_class == NULL) {
+    stats_->TypeNeedsAccessCheck();
+    return false;  // Unknown class needs access checks.
+  }
+  const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
+  mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
+  if (referrer_class == NULL) {
+    stats_->TypeNeedsAccessCheck();
+    return false;  // Incomplete referrer knowledge needs access check.
+  }
+  // Perform access and instantiable checks, will return true if access is ok or false if we're
+  // going to have to check this at runtime (for example for class loaders).
+  bool result = referrer_class->CanAccess(resolved_class) && resolved_class->IsInstantiable();
+  if (result) {
+    stats_->TypeDoesntNeedAccessCheck();
+  } else {
+    stats_->TypeNeedsAccessCheck();
+  }
+  return result;
+}
+
+static mirror::Class* ComputeCompilingMethodsClass(ScopedObjectAccess& soa,
+                                                   mirror::DexCache* dex_cache,
+                                                   const DexCompilationUnit* mUnit)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  // The passed dex_cache is a hint, sanity check before asking the class linker that will take a
+  // lock.
+  if (dex_cache->GetDexFile() != mUnit->GetDexFile()) {
+    dex_cache = mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile());
+  }
+  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader());
+  const DexFile::MethodId& referrer_method_id = mUnit->GetDexFile()->GetMethodId(mUnit->GetDexMethodIndex());
+  return mUnit->GetClassLinker()->ResolveType(*mUnit->GetDexFile(), referrer_method_id.class_idx_,
+                                              dex_cache, class_loader);
+}
+
+static mirror::Field* ComputeFieldReferencedFromCompilingMethod(ScopedObjectAccess& soa,
+                                                                const DexCompilationUnit* mUnit,
+                                                                uint32_t field_idx)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  mirror::DexCache* dex_cache = mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile());
+  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader());
+  return mUnit->GetClassLinker()->ResolveField(*mUnit->GetDexFile(), field_idx, dex_cache,
+                                               class_loader, false);
+}
+
+static mirror::AbstractMethod* ComputeMethodReferencedFromCompilingMethod(ScopedObjectAccess& soa,
+                                                                          const DexCompilationUnit* mUnit,
+                                                                          uint32_t method_idx,
+                                                                          InvokeType type)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  mirror::DexCache* dex_cache = mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile());
+  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader());
+  return mUnit->GetClassLinker()->ResolveMethod(*mUnit->GetDexFile(), method_idx, dex_cache,
+                                                class_loader, NULL, type);
+}
+
+bool CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
+                                              int& field_offset, bool& is_volatile, bool is_put) {
+  ScopedObjectAccess soa(Thread::Current());
+  // Conservative defaults.
+  field_offset = -1;
+  is_volatile = true;
+  // Try to resolve field and ignore if an Incompatible Class Change Error (ie is static).
+  mirror::Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
+  if (resolved_field != NULL && !resolved_field->IsStatic()) {
+    mirror::Class* referrer_class =
+        ComputeCompilingMethodsClass(soa, resolved_field->GetDeclaringClass()->GetDexCache(),
+                                     mUnit);
+    if (referrer_class != NULL) {
+      mirror::Class* fields_class = resolved_field->GetDeclaringClass();
+      bool access_ok = referrer_class->CanAccess(fields_class) &&
+                       referrer_class->CanAccessMember(fields_class,
+                                                       resolved_field->GetAccessFlags());
+      if (!access_ok) {
+        // The referring class can't access the resolved field, this may occur as a result of a
+        // protected field being made public by a sub-class. Resort to the dex file to determine
+        // the correct class for the access check.
+        const DexFile& dex_file = *referrer_class->GetDexCache()->GetDexFile();
+        mirror::Class* dex_fields_class = mUnit->GetClassLinker()->ResolveType(dex_file,
+                                                         dex_file.GetFieldId(field_idx).class_idx_,
+                                                         referrer_class);
+        access_ok = referrer_class->CanAccess(dex_fields_class) &&
+                    referrer_class->CanAccessMember(dex_fields_class,
+                                                    resolved_field->GetAccessFlags());
+      }
+      bool is_write_to_final_from_wrong_class = is_put && resolved_field->IsFinal() &&
+          fields_class != referrer_class;
+      if (access_ok && !is_write_to_final_from_wrong_class) {
+        field_offset = resolved_field->GetOffset().Int32Value();
+        is_volatile = resolved_field->IsVolatile();
+        stats_->ResolvedInstanceField();
+        return true;  // Fast path.
+      }
+    }
+  }
+  // Clean up any exception left by field/type resolution
+  if (soa.Self()->IsExceptionPending()) {
+    soa.Self()->ClearException();
+  }
+  stats_->UnresolvedInstanceField();
+  return false;  // Incomplete knowledge needs slow path.
+}
+
+bool CompilerDriver::ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
+                                            int& field_offset, int& ssb_index,
+                                            bool& is_referrers_class, bool& is_volatile,
+                                            bool is_put) {
+  ScopedObjectAccess soa(Thread::Current());
+  // Conservative defaults.
+  field_offset = -1;
+  ssb_index = -1;
+  is_referrers_class = false;
+  is_volatile = true;
+  // Try to resolve field and ignore if an Incompatible Class Change Error (ie isn't static).
+  mirror::Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
+  if (resolved_field != NULL && resolved_field->IsStatic()) {
+    mirror::Class* referrer_class =
+        ComputeCompilingMethodsClass(soa, resolved_field->GetDeclaringClass()->GetDexCache(),
+                                     mUnit);
+    if (referrer_class != NULL) {
+      mirror::Class* fields_class = resolved_field->GetDeclaringClass();
+      if (fields_class == referrer_class) {
+        is_referrers_class = true;  // implies no worrying about class initialization
+        field_offset = resolved_field->GetOffset().Int32Value();
+        is_volatile = resolved_field->IsVolatile();
+        stats_->ResolvedLocalStaticField();
+        return true;  // fast path
+      } else {
+        bool access_ok = referrer_class->CanAccess(fields_class) &&
+                         referrer_class->CanAccessMember(fields_class,
+                                                         resolved_field->GetAccessFlags());
+        if (!access_ok) {
+          // The referring class can't access the resolved field, this may occur as a result of a
+          // protected field being made public by a sub-class. Resort to the dex file to determine
+          // the correct class for the access check. Don't change the field's class as that is
+          // used to identify the SSB.
+          const DexFile& dex_file = *referrer_class->GetDexCache()->GetDexFile();
+          mirror::Class* dex_fields_class =
+              mUnit->GetClassLinker()->ResolveType(dex_file,
+                                                   dex_file.GetFieldId(field_idx).class_idx_,
+                                                   referrer_class);
+          access_ok = referrer_class->CanAccess(dex_fields_class) &&
+                      referrer_class->CanAccessMember(dex_fields_class,
+                                                      resolved_field->GetAccessFlags());
+        }
+        bool is_write_to_final_from_wrong_class = is_put && resolved_field->IsFinal();
+        if (access_ok && !is_write_to_final_from_wrong_class) {
+          // We have the resolved field, we must make it into a ssbIndex for the referrer
+          // in its static storage base (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
+          mirror::DexCache* dex_cache = mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile());
+          if (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
+            ssb_index = fields_class->GetDexTypeIndex();
+            field_offset = resolved_field->GetOffset().Int32Value();
+            is_volatile = resolved_field->IsVolatile();
+            stats_->ResolvedStaticField();
+            return true;
+          }
+          // 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 =
+              mUnit->GetDexFile()->FindStringId(FieldHelper(resolved_field).GetDeclaringClassDescriptor());
+          if (string_id != NULL) {
+            const DexFile::TypeId* type_id =
+               mUnit->GetDexFile()->FindTypeId(mUnit->GetDexFile()->GetIndexForStringId(*string_id));
+            if (type_id != NULL) {
+              // medium path, needs check of static storage base being initialized
+              ssb_index = mUnit->GetDexFile()->GetIndexForTypeId(*type_id);
+              field_offset = resolved_field->GetOffset().Int32Value();
+              is_volatile = resolved_field->IsVolatile();
+              stats_->ResolvedStaticField();
+              return true;
+            }
+          }
+        }
+      }
+    }
+  }
+  // Clean up any exception left by field/type resolution
+  if (soa.Self()->IsExceptionPending()) {
+    soa.Self()->ClearException();
+  }
+  stats_->UnresolvedStaticField();
+  return false;  // Incomplete knowledge needs slow path.
+}
+
+void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type,
+                                                   mirror::Class* referrer_class,
+                                                   mirror::AbstractMethod* method,
+                                                   uintptr_t& direct_code,
+                                                   uintptr_t& direct_method,
+                                                   bool update_stats) {
+  // For direct and static methods compute possible direct_code and direct_method values, ie
+  // an address for the Method* being invoked and an address of the code for that Method*.
+  // For interface calls compute a value for direct_method that is the interface method being
+  // invoked, so this can be passed to the out-of-line runtime support code.
+  direct_code = 0;
+  direct_method = 0;
+  if (compiler_backend_ == kPortable) {
+    if (sharp_type != kStatic && sharp_type != kDirect) {
+      return;
+    }
+  } else {
+    if (sharp_type != kStatic && sharp_type != kDirect && sharp_type != kInterface) {
+      return;
+    }
+  }
+  bool method_code_in_boot = method->GetDeclaringClass()->GetClassLoader() == NULL;
+  if (!method_code_in_boot) {
+    return;
+  }
+  bool has_clinit_trampoline = method->IsStatic() && !method->GetDeclaringClass()->IsInitialized();
+  if (has_clinit_trampoline && (method->GetDeclaringClass() != referrer_class)) {
+    // Ensure we run the clinit trampoline unless we are invoking a static method in the same class.
+    return;
+  }
+  if (update_stats) {
+    if (sharp_type != kInterface) {  // Interfaces always go via a trampoline.
+      stats_->DirectCallsToBoot(type);
+    }
+    stats_->DirectMethodsToBoot(type);
+  }
+  bool compiling_boot = Runtime::Current()->GetHeap()->GetContinuousSpaces().size() == 1;
+  if (compiling_boot) {
+    if (support_boot_image_fixup_) {
+      MethodHelper mh(method);
+      if (IsImageClass(mh.GetDeclaringClassDescriptor())) {
+        // We can only branch directly to Methods that are resolved in the DexCache.
+        // Otherwise we won't invoke the resolution trampoline.
+        direct_method = -1;
+        direct_code = -1;
+      }
+    }
+  } else {
+    if (Runtime::Current()->GetHeap()->FindSpaceFromObject(method, false)->IsImageSpace()) {
+      direct_method = reinterpret_cast<uintptr_t>(method);
+    }
+    direct_code = reinterpret_cast<uintptr_t>(method->GetEntryPointFromCompiledCode());
+  }
+}
+
+bool CompilerDriver::ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc,
+                                       InvokeType& invoke_type,
+                                       MethodReference& target_method,
+                                       int& vtable_idx,
+                                       uintptr_t& direct_code, uintptr_t& direct_method,
+                                       bool update_stats) {
+  ScopedObjectAccess soa(Thread::Current());
+  vtable_idx = -1;
+  direct_code = 0;
+  direct_method = 0;
+  mirror::AbstractMethod* resolved_method =
+      ComputeMethodReferencedFromCompilingMethod(soa, mUnit, target_method.dex_method_index,
+                                                 invoke_type);
+  if (resolved_method != NULL) {
+    // Don't try to fast-path if we don't understand the caller's class or this appears to be an
+    // Incompatible Class Change Error.
+    mirror::Class* referrer_class =
+        ComputeCompilingMethodsClass(soa, resolved_method->GetDeclaringClass()->GetDexCache(),
+                                     mUnit);
+    bool icce = resolved_method->CheckIncompatibleClassChange(invoke_type);
+    if (referrer_class != NULL && !icce) {
+      mirror::Class* methods_class = resolved_method->GetDeclaringClass();
+      if (!referrer_class->CanAccess(methods_class) ||
+          !referrer_class->CanAccessMember(methods_class,
+                                           resolved_method->GetAccessFlags())) {
+        // The referring class can't access the resolved method, this may occur as a result of a
+        // protected method being made public by implementing an interface that re-declares the
+        // method public. Resort to the dex file to determine the correct class for the access
+        // check.
+        uint16_t class_idx =
+            target_method.dex_file->GetMethodId(target_method.dex_method_index).class_idx_;
+        methods_class = mUnit->GetClassLinker()->ResolveType(*target_method.dex_file,
+                                                             class_idx, referrer_class);
+      }
+      if (referrer_class->CanAccess(methods_class) &&
+          referrer_class->CanAccessMember(methods_class, resolved_method->GetAccessFlags())) {
+        const bool kEnableFinalBasedSharpening = true;
+        // Sharpen a virtual call into a direct call when the target is known not to have been
+        // overridden (ie is final).
+        bool can_sharpen_virtual_based_on_type =
+            (invoke_type == kVirtual) && (resolved_method->IsFinal() || methods_class->IsFinal());
+        // For invoke-super, ensure the vtable index will be correct to dispatch in the vtable of
+        // the super class.
+        bool can_sharpen_super_based_on_type = (invoke_type == kSuper) &&
+            (referrer_class != methods_class) && referrer_class->IsSubClass(methods_class) &&
+            resolved_method->GetMethodIndex() < methods_class->GetVTable()->GetLength() &&
+            (methods_class->GetVTable()->Get(resolved_method->GetMethodIndex()) == resolved_method);
+
+        if (kEnableFinalBasedSharpening && (can_sharpen_virtual_based_on_type ||
+                                            can_sharpen_super_based_on_type)) {
+          // Sharpen a virtual call into a direct call. The method_idx is into referrer's
+          // dex cache, check that this resolved method is where we expect it.
+          CHECK(referrer_class->GetDexCache()->GetResolvedMethod(target_method.dex_method_index) ==
+                resolved_method) << PrettyMethod(resolved_method);
+          if (update_stats) {
+            stats_->ResolvedMethod(invoke_type);
+            stats_->VirtualMadeDirect(invoke_type);
+          }
+          GetCodeAndMethodForDirectCall(invoke_type, kDirect, referrer_class, resolved_method,
+                                        direct_code, direct_method, update_stats);
+          invoke_type = kDirect;
+          return true;
+        }
+        const bool kEnableVerifierBasedSharpening = true;
+        if (kEnableVerifierBasedSharpening && (invoke_type == kVirtual ||
+                                               invoke_type == kInterface)) {
+          // Did the verifier record a more precise invoke target based on its type information?
+          const MethodReference caller_method(mUnit->GetDexFile(), mUnit->GetDexMethodIndex());
+          const MethodReference* devirt_map_target =
+              verifier::MethodVerifier::GetDevirtMap(caller_method, dex_pc);
+          if (devirt_map_target != NULL) {
+            mirror::DexCache* target_dex_cache =
+                mUnit->GetClassLinker()->FindDexCache(*devirt_map_target->dex_file);
+            mirror::ClassLoader* class_loader =
+                soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader());
+            mirror::AbstractMethod* called_method =
+                mUnit->GetClassLinker()->ResolveMethod(*devirt_map_target->dex_file,
+                                                       devirt_map_target->dex_method_index,
+                                                       target_dex_cache, class_loader, NULL,
+                                                       kVirtual);
+            CHECK(called_method != NULL);
+            CHECK(!called_method->IsAbstract());
+            GetCodeAndMethodForDirectCall(invoke_type, kDirect, referrer_class, called_method,
+                                          direct_code, direct_method, update_stats);
+            bool compiler_needs_dex_cache =
+                (GetCompilerBackend() == kPortable) ||
+                (GetCompilerBackend() == kQuick && instruction_set_ != kThumb2) ||
+                (direct_code == 0) || (direct_code == static_cast<unsigned int>(-1)) ||
+                (direct_method == 0) || (direct_method == static_cast<unsigned int>(-1));
+            if ((devirt_map_target->dex_file != target_method.dex_file) &&
+                compiler_needs_dex_cache) {
+              // We need to use the dex cache to find either the method or code, and the dex file
+              // containing the method isn't the one expected for the target method. Try to find
+              // the method within the expected target dex file.
+              // TODO: the -1 could be handled as direct code if the patching new the target dex
+              //       file.
+              // TODO: quick only supports direct pointers with Thumb2.
+              // TODO: the following should be factored into a common helper routine to find
+              //       one dex file's method within another.
+              const DexFile* dexfile = target_method.dex_file;
+              const DexFile* cm_dexfile =
+                  called_method->GetDeclaringClass()->GetDexCache()->GetDexFile();
+              const DexFile::MethodId& cm_method_id =
+                  cm_dexfile->GetMethodId(called_method->GetDexMethodIndex());
+              const char* cm_descriptor = cm_dexfile->StringByTypeIdx(cm_method_id.class_idx_);
+              const DexFile::StringId* descriptor = dexfile->FindStringId(cm_descriptor);
+              if (descriptor != NULL) {
+                const DexFile::TypeId* type_id =
+                    dexfile->FindTypeId(dexfile->GetIndexForStringId(*descriptor));
+                if (type_id != NULL) {
+                  const char* cm_name = cm_dexfile->GetMethodName(cm_method_id);
+                  const DexFile::StringId* name = dexfile->FindStringId(cm_name);
+                  if (name != NULL) {
+                    uint16_t return_type_idx;
+                    std::vector<uint16_t> param_type_idxs;
+                    bool success = dexfile->CreateTypeList(&return_type_idx, &param_type_idxs,
+                                                           cm_dexfile->GetMethodSignature(cm_method_id));
+                    if (success) {
+                      const DexFile::ProtoId* sig =
+                          dexfile->FindProtoId(return_type_idx, param_type_idxs);
+                      if (sig != NULL) {
+                        const  DexFile::MethodId* method_id = dexfile->FindMethodId(*type_id,
+                                                                                    *name, *sig);
+                        if (method_id != NULL) {
+                          if (update_stats) {
+                            stats_->ResolvedMethod(invoke_type);
+                            stats_->VirtualMadeDirect(invoke_type);
+                            stats_->PreciseTypeDevirtualization();
+                          }
+                          target_method.dex_method_index = dexfile->GetIndexForMethodId(*method_id);
+                          invoke_type = kDirect;
+                          return true;
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+              // TODO: the stats for direct code and method are off as we failed to find the direct
+              //       method in the referring method's dex cache/file.
+            } else {
+              if (update_stats) {
+                stats_->ResolvedMethod(invoke_type);
+                stats_->VirtualMadeDirect(invoke_type);
+                stats_->PreciseTypeDevirtualization();
+              }
+              target_method = *devirt_map_target;
+              invoke_type = kDirect;
+              return true;
+            }
+          }
+        }
+        if (invoke_type == kSuper) {
+          // Unsharpened super calls are suspicious so go slow-path.
+        } else {
+          // Sharpening failed so generate a regular resolved method dispatch.
+          if (update_stats) {
+            stats_->ResolvedMethod(invoke_type);
+          }
+          if (invoke_type == kVirtual || invoke_type == kSuper) {
+            vtable_idx = resolved_method->GetMethodIndex();
+          }
+          GetCodeAndMethodForDirectCall(invoke_type, invoke_type, referrer_class, resolved_method,
+                                        direct_code, direct_method, update_stats);
+          return true;
+        }
+      }
+    }
+  }
+  // Clean up any exception left by method/invoke_type resolution
+  if (soa.Self()->IsExceptionPending()) {
+      soa.Self()->ClearException();
+  }
+  if (update_stats) {
+    stats_->UnresolvedMethod(invoke_type);
+  }
+  return false;  // Incomplete knowledge needs slow path.
+}
+
+bool CompilerDriver::IsSafeCast(const MethodReference& mr, uint32_t dex_pc) {
+  bool result = verifier::MethodVerifier::IsSafeCast(mr, dex_pc);
+  if (result) {
+    stats_->SafeCast();
+  } else {
+    stats_->NotASafeCast();
+  }
+  return result;
+}
+
+
+void CompilerDriver::AddCodePatch(const DexFile* dex_file,
+                            uint32_t referrer_method_idx,
+                            InvokeType referrer_invoke_type,
+                            uint32_t target_method_idx,
+                            InvokeType target_invoke_type,
+                            size_t literal_offset) {
+  MutexLock mu(Thread::Current(), compiled_methods_lock_);
+  code_to_patch_.push_back(new PatchInformation(dex_file,
+                                                referrer_method_idx,
+                                                referrer_invoke_type,
+                                                target_method_idx,
+                                                target_invoke_type,
+                                                literal_offset));
+}
+void CompilerDriver::AddMethodPatch(const DexFile* dex_file,
+                              uint32_t referrer_method_idx,
+                              InvokeType referrer_invoke_type,
+                              uint32_t target_method_idx,
+                              InvokeType target_invoke_type,
+                              size_t literal_offset) {
+  MutexLock mu(Thread::Current(), compiled_methods_lock_);
+  methods_to_patch_.push_back(new PatchInformation(dex_file,
+                                                   referrer_method_idx,
+                                                   referrer_invoke_type,
+                                                   target_method_idx,
+                                                   target_invoke_type,
+                                                   literal_offset));
+}
+
+class ParallelCompilationManager {
+ public:
+  typedef void Callback(const ParallelCompilationManager* manager, size_t index);
+
+  ParallelCompilationManager(ClassLinker* class_linker,
+                             jobject class_loader,
+                             CompilerDriver* compiler,
+                             const DexFile* dex_file,
+                             ThreadPool& thread_pool)
+    : class_linker_(class_linker),
+      class_loader_(class_loader),
+      compiler_(compiler),
+      dex_file_(dex_file),
+      thread_pool_(&thread_pool) {}
+
+  ClassLinker* GetClassLinker() const {
+    CHECK(class_linker_ != NULL);
+    return class_linker_;
+  }
+
+  jobject GetClassLoader() const {
+    return class_loader_;
+  }
+
+  CompilerDriver* GetCompiler() const {
+    CHECK(compiler_ != NULL);
+    return compiler_;
+  }
+
+  const DexFile* GetDexFile() const {
+    CHECK(dex_file_ != NULL);
+    return dex_file_;
+  }
+
+  void ForAll(size_t begin, size_t end, Callback callback, size_t work_units) {
+    Thread* self = Thread::Current();
+    self->AssertNoPendingException();
+    CHECK_GT(work_units, 0U);
+
+    std::vector<ForAllClosure*> closures(work_units);
+    for (size_t i = 0; i < work_units; ++i) {
+      closures[i] = new ForAllClosure(this, begin + i, end, callback, work_units);
+      thread_pool_->AddTask(self, closures[i]);
+    }
+    thread_pool_->StartWorkers(self);
+
+    // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
+    // thread destructor's called below perform join).
+    CHECK_NE(self->GetState(), kRunnable);
+
+    // Wait for all the worker threads to finish.
+    thread_pool_->Wait(self, true, false);
+  }
+
+ private:
+
+  class ForAllClosure : public Task {
+   public:
+    ForAllClosure(ParallelCompilationManager* manager, size_t begin, size_t end, Callback* callback,
+                  size_t stripe)
+        : manager_(manager),
+          begin_(begin),
+          end_(end),
+          callback_(callback),
+          stripe_(stripe)
+    {
+
+    }
+
+    virtual void Run(Thread* self) {
+      for (size_t i = begin_; i < end_; i += stripe_) {
+        callback_(manager_, i);
+        self->AssertNoPendingException();
+      }
+    }
+
+    virtual void Finalize() {
+      delete this;
+    }
+   private:
+    const ParallelCompilationManager* const manager_;
+    const size_t begin_;
+    const size_t end_;
+    const Callback* const callback_;
+    const size_t stripe_;
+  };
+
+  ClassLinker* const class_linker_;
+  const jobject class_loader_;
+  CompilerDriver* const compiler_;
+  const DexFile* const dex_file_;
+  ThreadPool* const thread_pool_;
+};
+
+// Return true if the class should be skipped during compilation. We
+// never skip classes in the boot class loader. However, if we have a
+// non-boot class loader and we can resolve the class in the boot
+// class loader, we do skip the class. This happens if an app bundles
+// classes found in the boot classpath. Since at runtime we will
+// select the class from the boot classpath, do not attempt to resolve
+// or compile it now.
+static bool SkipClass(mirror::ClassLoader* class_loader,
+                      const DexFile& dex_file,
+                      const DexFile::ClassDef& class_def)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  if (class_loader == NULL) {
+    return false;
+  }
+  const char* descriptor = dex_file.GetClassDescriptor(class_def);
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  mirror::Class* klass = class_linker->FindClass(descriptor, NULL);
+  if (klass == NULL) {
+    Thread* self = Thread::Current();
+    CHECK(self->IsExceptionPending());
+    self->ClearException();
+    return false;
+  }
+  return true;
+}
+
+static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manager, size_t class_def_index)
+    LOCKS_EXCLUDED(Locks::mutator_lock_) {
+  ScopedObjectAccess soa(Thread::Current());
+  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader());
+  const DexFile& dex_file = *manager->GetDexFile();
+
+  // Method and Field are the worst. We can't resolve without either
+  // context from the code use (to disambiguate virtual vs direct
+  // method and instance vs static field) or from class
+  // definitions. While the compiler will resolve what it can as it
+  // needs it, here we try to resolve fields and methods used in class
+  // definitions, since many of them many never be referenced by
+  // generated code.
+  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
+  if (SkipClass(class_loader, dex_file, class_def)) {
+    return;
+  }
+
+  // Note the class_data pointer advances through the headers,
+  // static fields, instance fields, direct methods, and virtual
+  // methods.
+  const byte* class_data = dex_file.GetClassData(class_def);
+  if (class_data == NULL) {
+    // empty class such as a marker interface
+    return;
+  }
+  Thread* self = Thread::Current();
+  ClassLinker* class_linker = manager->GetClassLinker();
+  mirror::DexCache* dex_cache = class_linker->FindDexCache(dex_file);
+  ClassDataItemIterator it(dex_file, class_data);
+  while (it.HasNextStaticField()) {
+    mirror::Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
+                                                      class_loader, true);
+    if (field == NULL) {
+      CHECK(self->IsExceptionPending());
+      self->ClearException();
+    }
+    it.Next();
+  }
+  // If an instance field is final then we need to have a barrier on the return, static final
+  // fields are assigned within the lock held for class initialization.
+  bool requires_constructor_barrier = false;
+  while (it.HasNextInstanceField()) {
+    if ((it.GetMemberAccessFlags() & kAccFinal) != 0) {
+      requires_constructor_barrier = true;
+    }
+
+    mirror::Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
+                                                      class_loader, false);
+    if (field == NULL) {
+      CHECK(self->IsExceptionPending());
+      self->ClearException();
+    }
+    it.Next();
+  }
+  if (requires_constructor_barrier) {
+    manager->GetCompiler()->AddRequiresConstructorBarrier(soa.Self(), manager->GetDexFile(),
+                                                          class_def_index);
+  }
+  while (it.HasNextDirectMethod()) {
+    mirror::AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
+                                                                 dex_cache, class_loader, NULL,
+                                                                 it.GetMethodInvokeType(class_def));
+    if (method == NULL) {
+      CHECK(self->IsExceptionPending());
+      self->ClearException();
+    }
+    it.Next();
+  }
+  while (it.HasNextVirtualMethod()) {
+    mirror::AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
+                                                                 dex_cache, class_loader, NULL,
+                                                                 it.GetMethodInvokeType(class_def));
+    if (method == NULL) {
+      CHECK(self->IsExceptionPending());
+      self->ClearException();
+    }
+    it.Next();
+  }
+  DCHECK(!it.HasNext());
+}
+
+static void ResolveType(const ParallelCompilationManager* manager, size_t type_idx)
+    LOCKS_EXCLUDED(Locks::mutator_lock_) {
+  // Class derived values are more complicated, they require the linker and loader.
+  ScopedObjectAccess soa(Thread::Current());
+  ClassLinker* class_linker = manager->GetClassLinker();
+  const DexFile& dex_file = *manager->GetDexFile();
+  mirror::DexCache* dex_cache = class_linker->FindDexCache(dex_file);
+  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader());
+  mirror::Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
+
+  if (klass == NULL) {
+    CHECK(soa.Self()->IsExceptionPending());
+    Thread::Current()->ClearException();
+  }
+}
+
+void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_file,
+                                    ThreadPool& thread_pool, TimingLogger& timings) {
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+
+  // TODO: we could resolve strings here, although the string table is largely filled with class
+  //       and method names.
+
+  ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
+  context.ForAll(0, dex_file.NumTypeIds(), ResolveType, thread_count_);
+  timings.AddSplit("Resolve " + dex_file.GetLocation() + " Types");
+
+  context.ForAll(0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_);
+  timings.AddSplit("Resolve " + dex_file.GetLocation() + " MethodsAndFields");
+}
+
+void CompilerDriver::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
+                            ThreadPool& thread_pool, TimingLogger& timings) {
+  for (size_t i = 0; i != dex_files.size(); ++i) {
+    const DexFile* dex_file = dex_files[i];
+    CHECK(dex_file != NULL);
+    VerifyDexFile(class_loader, *dex_file, thread_pool, timings);
+  }
+}
+
+static void VerifyClass(const ParallelCompilationManager* manager, size_t class_def_index)
+    LOCKS_EXCLUDED(Locks::mutator_lock_) {
+  ScopedObjectAccess soa(Thread::Current());
+  const DexFile::ClassDef& class_def = manager->GetDexFile()->GetClassDef(class_def_index);
+  const char* descriptor = manager->GetDexFile()->GetClassDescriptor(class_def);
+  mirror::Class* klass =
+      manager->GetClassLinker()->FindClass(descriptor,
+                                           soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader()));
+  if (klass == NULL) {
+    CHECK(soa.Self()->IsExceptionPending());
+    soa.Self()->ClearException();
+
+    /*
+     * At compile time, we can still structurally verify the class even if FindClass fails.
+     * This is to ensure the class is structurally sound for compilation. An unsound class
+     * will be rejected by the verifier and later skipped during compilation in the compiler.
+     */
+    mirror::DexCache* dex_cache =  manager->GetClassLinker()->FindDexCache(*manager->GetDexFile());
+    std::string error_msg;
+    if (verifier::MethodVerifier::VerifyClass(manager->GetDexFile(),
+                                              dex_cache,
+                                              soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader()),
+                                              class_def_index, error_msg, true) ==
+                                                  verifier::MethodVerifier::kHardFailure) {
+      const DexFile::ClassDef& class_def = manager->GetDexFile()->GetClassDef(class_def_index);
+      LOG(ERROR) << "Verification failed on class "
+                 << PrettyDescriptor(manager->GetDexFile()->GetClassDescriptor(class_def))
+                 << " because: " << error_msg;
+    }
+    return;
+  }
+  CHECK(klass->IsResolved()) << PrettyClass(klass);
+  manager->GetClassLinker()->VerifyClass(klass);
+
+  if (klass->IsErroneous()) {
+    // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
+    CHECK(soa.Self()->IsExceptionPending());
+    soa.Self()->ClearException();
+  }
+
+  CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous())
+      << PrettyDescriptor(klass) << ": state=" << klass->GetStatus();
+  soa.Self()->AssertNoPendingException();
+}
+
+void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file,
+                                   ThreadPool& thread_pool, TimingLogger& timings) {
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
+  context.ForAll(0, dex_file.NumClassDefs(), VerifyClass, thread_count_);
+  timings.AddSplit("Verify " + dex_file.GetLocation());
+}
+
+static const char* class_initializer_black_list[] = {
+  "Landroid/app/ActivityThread;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/bluetooth/BluetoothAudioGateway;", // Calls android.bluetooth.BluetoothAudioGateway.classInitNative().
+  "Landroid/bluetooth/HeadsetBase;", // Calls android.bluetooth.HeadsetBase.classInitNative().
+  "Landroid/content/res/CompatibilityInfo;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
+  "Landroid/content/res/CompatibilityInfo$1;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
+  "Landroid/content/UriMatcher;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/database/CursorWindow;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
+  "Landroid/database/sqlite/SQLiteConnection;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/database/sqlite/SQLiteConnection$Operation;", // Requires SimpleDateFormat -> java.util.Locale.
+  "Landroid/database/sqlite/SQLiteDatabaseConfiguration;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/database/sqlite/SQLiteDebug;", // Calls android.util.Log.isLoggable.
+  "Landroid/database/sqlite/SQLiteOpenHelper;", // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
+  "Landroid/database/sqlite/SQLiteQueryBuilder;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/drm/DrmManagerClient;", // Calls System.loadLibrary.
+  "Landroid/graphics/drawable/AnimatedRotateDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/AnimationDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/BitmapDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/ClipDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/ColorDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/Drawable;", // Requires android.graphics.Rect.
+  "Landroid/graphics/drawable/DrawableContainer;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/GradientDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/LayerDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/NinePatchDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/RotateDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/ScaleDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/ShapeDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/StateListDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/drawable/TransitionDrawable;", // Sub-class of Drawable.
+  "Landroid/graphics/Matrix;", // Calls android.graphics.Matrix.native_create.
+  "Landroid/graphics/Matrix$1;", // Requires Matrix.
+  "Landroid/graphics/PixelFormat;", // Calls android.graphics.PixelFormat.nativeClassInit().
+  "Landroid/graphics/Rect;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/graphics/SurfaceTexture;", // Calls android.graphics.SurfaceTexture.nativeClassInit().
+  "Landroid/graphics/Typeface;", // Calls android.graphics.Typeface.nativeCreate.
+  "Landroid/inputmethodservice/ExtractEditText;", // Requires android.widget.TextView.
+  "Landroid/media/AmrInputStream;", // Calls OsConstants.initConstants.
+  "Landroid/media/CamcorderProfile;", // Calls OsConstants.initConstants.
+  "Landroid/media/CameraProfile;", // Calls System.loadLibrary.
+  "Landroid/media/DecoderCapabilities;", // Calls System.loadLibrary.
+  "Landroid/media/EncoderCapabilities;", // Calls OsConstants.initConstants.
+  "Landroid/media/ExifInterface;", // Calls OsConstants.initConstants.
+  "Landroid/media/MediaCodec;", // Calls OsConstants.initConstants.
+  "Landroid/media/MediaCodecList;", // Calls OsConstants.initConstants.
+  "Landroid/media/MediaCrypto;", // Calls OsConstants.initConstants.
+  "Landroid/media/MediaDrm;", // Calls OsConstants.initConstants.
+  "Landroid/media/MediaExtractor;", // Calls OsConstants.initConstants.
+  "Landroid/media/MediaFile;", // Requires DecoderCapabilities.
+  "Landroid/media/MediaMetadataRetriever;", // Calls OsConstants.initConstants.
+  "Landroid/media/MediaMuxer;", // Calls OsConstants.initConstants.
+  "Landroid/media/MediaPlayer;", // Calls System.loadLibrary.
+  "Landroid/media/MediaRecorder;", // Calls System.loadLibrary.
+  "Landroid/media/MediaScanner;", // Calls System.loadLibrary.
+  "Landroid/media/ResampleInputStream;", // Calls OsConstants.initConstants.
+  "Landroid/media/SoundPool;", // Calls OsConstants.initConstants.
+  "Landroid/media/videoeditor/MediaArtistNativeHelper;", // Calls OsConstants.initConstants.
+  "Landroid/media/videoeditor/VideoEditorProfile;", // Calls OsConstants.initConstants.
+  "Landroid/mtp/MtpDatabase;", // Calls OsConstants.initConstants.
+  "Landroid/mtp/MtpDevice;", // Calls OsConstants.initConstants.
+  "Landroid/mtp/MtpServer;", // Calls OsConstants.initConstants.
+  "Landroid/net/NetworkInfo;", // Calls java.util.EnumMap.<init> -> java.lang.Enum.getSharedConstants -> System.identityHashCode.
+  "Landroid/net/Proxy;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/net/SSLCertificateSocketFactory;", // Requires javax.net.ssl.HttpsURLConnection.
+  "Landroid/net/Uri;", // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
+  "Landroid/net/Uri$AbstractHierarchicalUri;", // Requires Uri.
+  "Landroid/net/Uri$HierarchicalUri;", // Requires Uri.
+  "Landroid/net/Uri$OpaqueUri;", // Requires Uri.
+  "Landroid/net/Uri$StringUri;", // Requires Uri.
+  "Landroid/net/WebAddress;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/nfc/NdefRecord;", // Calls String.getBytes -> java.nio.charset.Charset.
+  "Landroid/opengl/EGL14;", // Calls android.opengl.EGL14._nativeClassInit.
+  "Landroid/opengl/GLES10;", // Calls android.opengl.GLES10._nativeClassInit.
+  "Landroid/opengl/GLES10Ext;", // Calls android.opengl.GLES10Ext._nativeClassInit.
+  "Landroid/opengl/GLES11;", // Requires GLES10.
+  "Landroid/opengl/GLES11Ext;", // Calls android.opengl.GLES11Ext._nativeClassInit.
+  "Landroid/opengl/GLES20;", // Calls android.opengl.GLES20._nativeClassInit.
+  "Landroid/opengl/GLUtils;", // Calls android.opengl.GLUtils.nativeClassInit.
+  "Landroid/os/Build;", // Calls -..-> android.os.SystemProperties.native_get.
+  "Landroid/os/Build$VERSION;", // Requires Build.
+  "Landroid/os/Debug;", // Requires android.os.Environment.
+  "Landroid/os/Environment;", // Calls System.getenv.
+  "Landroid/os/FileUtils;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/os/StrictMode;", // Calls android.util.Log.isLoggable.
+  "Landroid/os/StrictMode$VmPolicy;", // Requires StrictMode.
+  "Landroid/os/Trace;", // Calls android.os.Trace.nativeGetEnabledTags.
+  "Landroid/os/UEventObserver;", // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
+  "Landroid/provider/ContactsContract;", // Calls OsConstants.initConstants.
+  "Landroid/provider/Settings$Global;", // Calls OsConstants.initConstants.
+  "Landroid/provider/Settings$Secure;", // Requires android.net.Uri.
+  "Landroid/provider/Settings$System;", // Requires android.net.Uri.
+  "Landroid/renderscript/RenderScript;", // Calls System.loadLibrary.
+  "Landroid/server/BluetoothService;", // Calls android.server.BluetoothService.classInitNative.
+  "Landroid/server/BluetoothEventLoop;", // Calls android.server.BluetoothEventLoop.classInitNative.
+  "Landroid/telephony/PhoneNumberUtils;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/telephony/TelephonyManager;", // Calls OsConstants.initConstants.
+  "Landroid/text/AutoText;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
+  "Landroid/text/Layout;", // Calls com.android.internal.util.ArrayUtils.emptyArray -> System.identityHashCode.
+  "Landroid/text/BoringLayout;", // Requires Layout.
+  "Landroid/text/DynamicLayout;", // Requires Layout.
+  "Landroid/text/Html$HtmlParser;", // Calls -..-> String.toLowerCase -> java.util.Locale.
+  "Landroid/text/StaticLayout;", // Requires Layout.
+  "Landroid/text/TextUtils;", // Requires android.util.DisplayMetrics.
+  "Landroid/util/DisplayMetrics;", // Calls SystemProperties.native_get_int.
+  "Landroid/util/Patterns;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/view/Choreographer;", // Calls SystemProperties.native_get_boolean.
+  "Landroid/util/Patterns;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/view/GLES20Canvas;", // Calls GLES20Canvas.nIsAvailable().
+  "Landroid/view/GLES20RecordingCanvas;", // Requires android.view.GLES20Canvas.
+  "Landroid/view/GestureDetector;", // Calls android.view.GLES20Canvas.nIsAvailable.
+  "Landroid/view/HardwareRenderer$Gl20Renderer;", // Requires SystemProperties.native_get.
+  "Landroid/view/HardwareRenderer$GlRenderer;", // Requires SystemProperties.native_get.
+  "Landroid/view/InputEventConsistencyVerifier;", // Requires android.os.Build.
+  "Landroid/view/Surface;", // Requires SystemProperties.native_get.
+  "Landroid/view/SurfaceControl;", // Calls OsConstants.initConstants.
+  "Landroid/view/animation/AlphaAnimation;", // Requires Animation.
+  "Landroid/view/animation/Animation;", // Calls SystemProperties.native_get_boolean.
+  "Landroid/view/animation/AnimationSet;", // Calls OsConstants.initConstants.
+  "Landroid/view/textservice/SpellCheckerSubtype;", // Calls Class.getDex().
+  "Landroid/webkit/JniUtil;", // Calls System.loadLibrary.
+  "Landroid/webkit/PluginManager;", // // Calls OsConstants.initConstants.
+  "Landroid/webkit/WebViewCore;", // Calls System.loadLibrary.
+  "Landroid/webkit/WebViewFactory$Preloader;",  // Calls to Class.forName.
+  "Landroid/webkit/WebViewInputDispatcher;", // Calls Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/webkit/URLUtil;", // Calls Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/widget/AutoCompleteTextView;", // Requires TextView.
+  "Landroid/widget/Button;", // Requires TextView.
+  "Landroid/widget/CheckBox;", // Requires TextView.
+  "Landroid/widget/CheckedTextView;", // Requires TextView.
+  "Landroid/widget/CompoundButton;", // Requires TextView.
+  "Landroid/widget/EditText;", // Requires TextView.
+  "Landroid/widget/NumberPicker;", // Requires java.util.Locale.
+  "Landroid/widget/ScrollBarDrawable;", // Sub-class of Drawable.
+  "Landroid/widget/SearchView$SearchAutoComplete;", // Requires TextView.
+  "Landroid/widget/Switch;", // Requires TextView.
+  "Landroid/widget/TextView;", // Calls Paint.<init> -> Paint.native_init.
+  "Lcom/android/i18n/phonenumbers/AsYouTypeFormatter;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Lcom/android/i18n/phonenumbers/MetadataManager;", // Calls OsConstants.initConstants.
+  "Lcom/android/i18n/phonenumbers/PhoneNumberMatcher;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Lcom/android/i18n/phonenumbers/PhoneNumberUtil;", // Requires java.util.logging.LogManager.
+  "Lcom/android/i18n/phonenumbers/geocoding/AreaCodeMap;", // Calls OsConstants.initConstants.
+  "Lcom/android/i18n/phonenumbers/geocoding/PhoneNumberOfflineGeocoder;", // Calls OsConstants.initConstants.
+  "Lcom/android/internal/os/SamplingProfilerIntegration;", // Calls SystemProperties.native_get_int.
+  "Lcom/android/internal/policy/impl/PhoneWindow;", // Calls android.os.Binder.init.
+  "Lcom/android/internal/view/menu/ActionMenuItemView;", // Requires TextView.
+  "Lcom/android/internal/widget/DialogTitle;", // Requires TextView.
+  "Lcom/android/org/bouncycastle/asn1/StreamUtil;", // Calls Runtime.getRuntime().maxMemory().
+  "Lcom/android/org/bouncycastle/asn1/pkcs/MacData;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/asn1/pkcs/RSASSAPSSparams;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/asn1/cms/SignedData;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/asn1/x509/GeneralSubtree;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/asn1/x9/X9ECParameters;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$MD5;", // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA1;", // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA256;", // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA384;", // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA512;", // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/bouncycastle/crypto/engines/RSABlindedEngine;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/crypto/generators/DHKeyGeneratorHelper;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/crypto/generators/DHParametersGenerator;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/crypto/generators/DHParametersHelper;", // Calls System.getenv -> OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/crypto/generators/DSAKeyPairGenerator;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/crypto/generators/DSAParametersGenerator;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/crypto/generators/RSAKeyPairGenerator;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/dsa/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$EC;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDH;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDHC;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDSA;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECMQV;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/BCRSAPrivateCrtKey;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/BCRSAPrivateKey;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/keystore/pkcs12/PKCS12KeyStoreSpi$BCPKCS12KeyStore;", // Calls Thread.currentThread.
+  "Lcom/android/org/bouncycastle/jcajce/provider/keystore/pkcs12/PKCS12KeyStoreSpi;", // Calls Thread.currentThread.
+  "Lcom/android/org/bouncycastle/jce/PKCS10CertificationRequest;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/jce/provider/CertBlacklist;", // Calls System.getenv -> OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jce/provider/JCERSAPrivateCrtKey;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/jce/provider/JCERSAPrivateKey;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/jce/provider/PKIXCertPathValidatorSpi;", // Calls System.getenv -> OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/math/ec/ECConstants;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/math/ec/Tnaf;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/util/BigIntegers;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/x509/X509Util;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/conscrypt/CipherSuite;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/FileClientSessionCache$CacheFile;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/HandshakeIODataStream;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/Logger;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/NativeCrypto;", // Calls native NativeCrypto.clinit().
+  "Lcom/android/org/conscrypt/OpenSSLECKeyPairGenerator;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/OpenSSLEngine;", // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/conscrypt/OpenSSLMac$HmacMD5;", // Calls native NativeCrypto.clinit().
+  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA1;", // Calls native NativeCrypto.clinit().
+  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA256;", // Calls native NativeCrypto.clinit().
+  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA384;", // Calls native NativeCrypto.clinit().
+  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA512;", // Calls native NativeCrypto.clinit().
+  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$MD5;", // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA1;", // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA256;", // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA384;", // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA512;", // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/conscrypt/OpenSSLX509CertPath;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/OpenSSLX509CertificateFactory;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/PRF;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/SSLSessionImpl;", // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/TrustedCertificateStore;", // Calls System.getenv -> OsConstants.initConstants.
+  "Lcom/android/okhttp/ConnectionPool;", // Calls OsConstants.initConstants.
+  "Lcom/android/okhttp/OkHttpClient;", // Calls OsConstants.initConstants.
+  "Lcom/android/okhttp/internal/DiskLruCache;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Lcom/android/okhttp/internal/Util;", // Calls OsConstants.initConstants.
+  "Lcom/android/okhttp/internal/http/HttpsURLConnectionImpl;", // Calls VMClassLoader.getBootClassPathSize.
+  "Lcom/android/okhttp/internal/spdy/SpdyConnection;", // Calls OsConstants.initConstants.
+  "Lcom/android/okhttp/internal/spdy/SpdyReader;", // Calls OsConstants.initConstants.
+  "Lcom/android/okhttp/internal/tls/OkHostnameVerifier;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Lcom/google/android/gles_jni/EGLContextImpl;", // Calls com.google.android.gles_jni.EGLImpl._nativeClassInit.
+  "Lcom/google/android/gles_jni/EGLImpl;", // Calls com.google.android.gles_jni.EGLImpl._nativeClassInit.
+  "Lcom/google/android/gles_jni/GLImpl;", // Calls com.google.android.gles_jni.GLImpl._nativeClassInit.
+  "Lgov/nist/core/GenericObject;", // Calls OsConstants.initConstants.
+  "Lgov/nist/core/Host;", // Calls OsConstants.initConstants.
+  "Lgov/nist/core/HostPort;", // Calls OsConstants.initConstants.
+  "Lgov/nist/core/NameValue;", // Calls OsConstants.initConstants.
+  "Lgov/nist/core/net/DefaultNetworkLayer;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/Utils;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/AddressImpl;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/Authority;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/GenericURI;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/NetObject;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/SipUri;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/TelephoneNumber;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/UserInfo;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Accept;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AcceptEncoding;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AcceptLanguage;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AddressParametersHeader;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AlertInfoList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AllowEvents;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AllowEventsList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AuthenticationInfo;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Authorization;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/CSeq;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/CallIdentifier;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Challenge;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ContactList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ContentEncoding;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ContentEncodingList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ContentLanguageList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ContentType;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Credentials;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ErrorInfoList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Expires;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/From;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/MimeVersion;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/NameMap;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Priority;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Protocol;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ProxyAuthenticate;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ProxyAuthenticateList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ProxyAuthorizationList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ProxyRequire;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ProxyRequireList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/RSeq;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/RecordRoute;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ReferTo;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/RequestLine;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Require;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/RetryAfter;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/SIPETag;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/SIPHeader;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/SIPHeaderNamesCache;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/StatusLine;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/SubscriptionState;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/TimeStamp;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/UserAgent;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Unsupported;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Warning;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ViaList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/extensions/Join;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/extensions/References;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/extensions/Replaces;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PAccessNetworkInfo;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PAssertedIdentity;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PAssertedIdentityList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PAssociatedURI;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PCalledPartyID;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PChargingVector;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PPreferredIdentity;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PVisitedNetworkIDList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PathList;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/SecurityAgree;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/SecurityClient;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/ServiceRoute;", // Calls OsConstants.initConstants.
+  "Ljava/io/Console;", // Has FileDescriptor(s).
+  "Ljava/io/File;", // Calls to Random.<init> -> System.currentTimeMillis -> OsConstants.initConstants.
+  "Ljava/io/FileDescriptor;", // Requires libcore.io.OsConstants.
+  "Ljava/io/ObjectInputStream;", // Requires java.lang.ClassLoader$SystemClassLoader.
+  "Ljava/io/ObjectStreamClass;",  // Calls to Class.forName -> java.io.FileDescriptor.
+  "Ljava/io/ObjectStreamConstants;", // Instance of non-image class SerializablePermission.
+  "Ljava/lang/ClassLoader$SystemClassLoader;", // Calls System.getProperty -> OsConstants.initConstants.
+  "Ljava/lang/HexStringParser;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Ljava/lang/ProcessManager;", // Calls Thread.currentThread.
+  "Ljava/lang/Runtime;", // Calls System.getProperty -> OsConstants.initConstants.
+  "Ljava/lang/System;", // Calls OsConstants.initConstants.
+  "Ljava/math/BigDecimal;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Ljava/math/BigInteger;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Ljava/math/Primality;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Ljava/math/Multiplication;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Ljava/net/InetAddress;", // Requires libcore.io.OsConstants.
+  "Ljava/net/Inet4Address;", // Sub-class of InetAddress.
+  "Ljava/net/Inet6Address;", // Sub-class of InetAddress.
+  "Ljava/net/InetUnixAddress;", // Sub-class of InetAddress.
+  "Ljava/nio/charset/Charset;", // Calls Charset.getDefaultCharset -> System.getProperty -> OsConstants.initConstants.
+  "Ljava/nio/charset/CharsetICU;", // Sub-class of Charset.
+  "Ljava/nio/charset/Charsets;", // Calls Charset.forName.
+  "Ljava/nio/charset/StandardCharsets;", // Calls OsConstants.initConstants.
+  "Ljava/security/AlgorithmParameterGenerator;", // Calls OsConstants.initConstants.
+  "Ljava/security/KeyPairGenerator$KeyPairGeneratorImpl;", // Calls OsConstants.initConstants.
+  "Ljava/security/KeyPairGenerator;", // Calls OsConstants.initConstants.
+  "Ljava/security/Security;", // Tries to do disk IO for "security.properties".
+  "Ljava/security/spec/RSAKeyGenParameterSpec;", // java.math.NativeBN.BN_new()
+  "Ljava/sql/Date;", // Calls OsConstants.initConstants.
+  "Ljava/sql/DriverManager;", // Calls OsConstants.initConstants.
+  "Ljava/sql/Time;", // Calls OsConstants.initConstants.
+  "Ljava/sql/Timestamp;", // Calls OsConstants.initConstants.
+  "Ljava/util/Date;", // Calls Date.<init> -> System.currentTimeMillis -> OsConstants.initConstants.
+  "Ljava/util/ListResourceBundle;", // Calls OsConstants.initConstants.
+  "Ljava/util/Locale;", // Calls System.getProperty -> OsConstants.initConstants.
+  "Ljava/util/PropertyResourceBundle;", // Calls OsConstants.initConstants.
+  "Ljava/util/ResourceBundle;", // Calls OsConstants.initConstants.
+  "Ljava/util/ResourceBundle$MissingBundle;", // Calls OsConstants.initConstants.
+  "Ljava/util/Scanner;", // regex.Pattern.compileImpl.
+  "Ljava/util/SimpleTimeZone;", // Sub-class of TimeZone.
+  "Ljava/util/TimeZone;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Ljava/util/concurrent/ConcurrentHashMap$Segment;", // Calls Runtime.getRuntime().availableProcessors().
+  "Ljava/util/concurrent/ConcurrentSkipListMap;", // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/Exchanger;", // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/ForkJoinPool;", // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/LinkedTransferQueue;", // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/Phaser;", // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/ScheduledThreadPoolExecutor;", // Calls AtomicLong.VMSupportsCS8()
+  "Ljava/util/concurrent/SynchronousQueue;", // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/atomic/AtomicLong;", // Calls AtomicLong.VMSupportsCS8()
+  "Ljava/util/logging/LogManager;", // Calls System.getProperty -> OsConstants.initConstants.
+  "Ljava/util/prefs/AbstractPreferences;", // Calls OsConstants.initConstants.
+  "Ljava/util/prefs/FilePreferencesImpl;", // Calls OsConstants.initConstants.
+  "Ljava/util/prefs/FilePreferencesFactoryImpl;", // Calls OsConstants.initConstants.
+  "Ljava/util/prefs/Preferences;", // Calls OsConstants.initConstants.
+  "Ljavax/crypto/KeyAgreement;", // Calls OsConstants.initConstants.
+  "Ljavax/crypto/KeyGenerator;", // Calls OsConstants.initConstants.
+  "Ljavax/security/cert/X509Certificate;", // Calls VMClassLoader.getBootClassPathSize.
+  "Ljavax/security/cert/X509Certificate$1;", // Calls VMClassLoader.getBootClassPathSize.
+  "Ljavax/microedition/khronos/egl/EGL10;", // Requires EGLContext.
+  "Ljavax/microedition/khronos/egl/EGLContext;", // Requires com.google.android.gles_jni.EGLImpl.
+  "Ljavax/net/ssl/HttpsURLConnection;", // Calls SSLSocketFactory.getDefault -> java.security.Security.getProperty.
+  "Ljavax/xml/datatype/DatatypeConstants;", // Calls OsConstants.initConstants.
+  "Ljavax/xml/datatype/FactoryFinder;", // Calls OsConstants.initConstants.
+  "Ljavax/xml/namespace/QName;", // Calls OsConstants.initConstants.
+  "Ljavax/xml/validation/SchemaFactoryFinder;", // Calls OsConstants.initConstants.
+  "Ljavax/xml/xpath/XPathConstants;", // Calls OsConstants.initConstants.
+  "Ljavax/xml/xpath/XPathFactoryFinder;", // Calls OsConstants.initConstants.
+  "Llibcore/icu/LocaleData;", // Requires java.util.Locale.
+  "Llibcore/icu/TimeZoneNames;", // Requires java.util.TimeZone.
+  "Llibcore/io/IoUtils;",  // Calls Random.<init> -> System.currentTimeMillis -> FileDescriptor -> OsConstants.initConstants.
+  "Llibcore/io/OsConstants;", // Platform specific.
+  "Llibcore/net/MimeUtils;", // Calls libcore.net.MimeUtils.getContentTypesPropertiesStream -> System.getProperty.
+  "Llibcore/reflect/Types;", // Calls OsConstants.initConstants.
+  "Llibcore/util/ZoneInfo;", // Sub-class of TimeZone.
+  "Llibcore/util/ZoneInfoDB;", // Calls System.getenv -> OsConstants.initConstants.
+  "Lorg/apache/commons/logging/LogFactory;", // Calls System.getProperty.
+  "Lorg/apache/commons/logging/impl/LogFactoryImpl;", // Calls OsConstants.initConstants.
+  "Lorg/apache/harmony/security/fortress/Services;", // Calls ClassLoader.getSystemClassLoader -> System.getProperty.
+  "Lorg/apache/harmony/security/provider/cert/X509CertFactoryImpl;", // Requires java.nio.charsets.Charsets.
+  "Lorg/apache/harmony/security/provider/crypto/RandomBitsSupplier;", // Requires java.io.File.
+  "Lorg/apache/harmony/security/utils/AlgNameMapper;", // Requires java.util.Locale.
+  "Lorg/apache/harmony/security/pkcs10/CertificationRequest;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/pkcs10/CertificationRequestInfo;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/pkcs7/AuthenticatedAttributes;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/pkcs7/SignedData;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/pkcs7/SignerInfo;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/pkcs8/PrivateKeyInfo;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/provider/crypto/SHA1PRNG_SecureRandomImpl;", // Calls OsConstants.initConstants.
+  "Lorg/apache/harmony/security/x501/AttributeTypeAndValue;", // Calls IntegralToString.convertInt -> Thread.currentThread.
+  "Lorg/apache/harmony/security/x501/DirectoryString;", // Requires BigInteger.
+  "Lorg/apache/harmony/security/x501/Name;", // Requires org.apache.harmony.security.x501.AttributeTypeAndValue.
+  "Lorg/apache/harmony/security/x509/AccessDescription;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/AuthorityKeyIdentifier;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/CRLDistributionPoints;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/Certificate;", // Requires org.apache.harmony.security.x509.TBSCertificate.
+  "Lorg/apache/harmony/security/x509/CertificateIssuer;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/CertificateList;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/DistributionPoint;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/DistributionPointName;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/EDIPartyName;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lorg/apache/harmony/security/x509/GeneralName;", // Requires org.apache.harmony.security.x501.Name.
+  "Lorg/apache/harmony/security/x509/GeneralNames;", // Requires GeneralName.
+  "Lorg/apache/harmony/security/x509/GeneralSubtree;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/GeneralSubtrees;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/InfoAccessSyntax;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/IssuingDistributionPoint;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/NameConstraints;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/TBSCertList$RevokedCertificate;", // Calls NativeBN.BN_new().
+  "Lorg/apache/harmony/security/x509/TBSCertList;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/TBSCertificate;",  // Requires org.apache.harmony.security.x501.Name.
+  "Lorg/apache/harmony/security/x509/Time;", // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lorg/apache/harmony/security/x509/Validity;", // Requires x509.Time.
+  "Lorg/apache/harmony/security/x509/tsp/TSTInfo;", // Calls Thread.currentThread.
+  "Lorg/apache/harmony/xml/ExpatParser;", // Calls native ExpatParser.staticInitialize.
+  "Lorg/apache/harmony/xml/ExpatParser$EntityParser;", // Calls ExpatParser.staticInitialize.
+  "Lorg/apache/http/conn/params/ConnRouteParams;", // Requires java.util.Locale.
+  "Lorg/apache/http/conn/ssl/SSLSocketFactory;", // Calls java.security.Security.getProperty.
+  "Lorg/apache/http/conn/util/InetAddressUtils;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+};
+
+static void InitializeClass(const ParallelCompilationManager* manager, size_t class_def_index)
+    LOCKS_EXCLUDED(Locks::mutator_lock_) {
+  const DexFile::ClassDef& class_def = manager->GetDexFile()->GetClassDef(class_def_index);
+  ScopedObjectAccess soa(Thread::Current());
+  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader());
+  const char* descriptor = manager->GetDexFile()->GetClassDescriptor(class_def);
+  mirror::Class* klass = manager->GetClassLinker()->FindClass(descriptor, class_loader);
+  bool compiling_boot = Runtime::Current()->GetHeap()->GetContinuousSpaces().size() == 1;
+  bool can_init_static_fields = compiling_boot &&
+      manager->GetCompiler()->IsImageClass(descriptor);
+  if (klass != NULL) {
+    // We don't want class initialization occurring on multiple threads due to deadlock problems.
+    // For example, a parent class is initialized (holding its lock) that refers to a sub-class
+    // in its static/class initializer causing it to try to acquire the sub-class' lock. While
+    // on a second thread the sub-class is initialized (holding its lock) after first initializing
+    // its parents, whose locks are acquired. This leads to a parent-to-child and a child-to-parent
+    // lock ordering and consequent potential deadlock.
+    // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather
+    // than use a special Object for the purpose we use the Class of java.lang.Class.
+    ObjectLock lock1(soa.Self(), klass->GetClass());
+    // The lock required to initialize the class.
+    ObjectLock lock2(soa.Self(), klass);
+    // Only try to initialize classes that were successfully verified.
+    if (klass->IsVerified()) {
+      manager->GetClassLinker()->EnsureInitialized(klass, false, can_init_static_fields);
+      if (soa.Self()->IsExceptionPending()) {
+        soa.Self()->GetException(NULL)->Dump();
+      }
+      if (!klass->IsInitialized()) {
+        if (can_init_static_fields) {
+          bool is_black_listed = false;
+          for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) {
+            if (StringPiece(descriptor) == class_initializer_black_list[i]) {
+              is_black_listed = true;
+              break;
+            }
+          }
+          if (!is_black_listed) {
+            LOG(INFO) << "Initializing: " << descriptor;
+            if (StringPiece(descriptor) == "Ljava/lang/Void;"){
+              // Hand initialize j.l.Void to avoid Dex file operations in un-started runtime.
+              mirror::ObjectArray<mirror::Field>* fields = klass->GetSFields();
+              CHECK_EQ(fields->GetLength(), 1);
+              fields->Get(0)->SetObj(klass, manager->GetClassLinker()->FindPrimitiveClass('V'));
+              klass->SetStatus(mirror::Class::kStatusInitialized);
+            } else {
+              manager->GetClassLinker()->EnsureInitialized(klass, true, can_init_static_fields);
+            }
+            soa.Self()->AssertNoPendingException();
+          }
+        }
+      }
+      // If successfully initialized place in SSB array.
+      if (klass->IsInitialized()) {
+        klass->GetDexCache()->GetInitializedStaticStorage()->Set(klass->GetDexTypeIndex(), klass);
+      }
+    }
+    // Record the final class status if necessary.
+    mirror::Class::Status status = klass->GetStatus();
+    ClassReference ref(manager->GetDexFile(), class_def_index);
+    CompiledClass* compiled_class = manager->GetCompiler()->GetCompiledClass(ref);
+    if (compiled_class == NULL) {
+      compiled_class = new CompiledClass(status);
+      manager->GetCompiler()->RecordClassStatus(ref, compiled_class);
+    } else {
+      DCHECK_GE(status, compiled_class->GetStatus()) << descriptor;
+    }
+  }
+  // Clear any class not found or verification exceptions.
+  soa.Self()->ClearException();
+}
+
+void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile& dex_file,
+                                       ThreadPool& thread_pool, TimingLogger& timings) {
+#ifndef NDEBUG
+  for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) {
+    const char* descriptor = class_initializer_black_list[i];
+    CHECK(IsValidDescriptor(descriptor)) << descriptor;
+  }
+#endif
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, thread_pool);
+  context.ForAll(0, dex_file.NumClassDefs(), InitializeClass, thread_count_);
+  timings.AddSplit("InitializeNoClinit " + dex_file.GetLocation());
+}
+
+void CompilerDriver::InitializeClasses(jobject class_loader,
+                                       const std::vector<const DexFile*>& dex_files,
+                                       ThreadPool& thread_pool, TimingLogger& timings) {
+  for (size_t i = 0; i != dex_files.size(); ++i) {
+    const DexFile* dex_file = dex_files[i];
+    CHECK(dex_file != NULL);
+    InitializeClasses(class_loader, *dex_file, thread_pool, timings);
+  }
+}
+
+void CompilerDriver::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
+                       ThreadPool& thread_pool, TimingLogger& timings) {
+  for (size_t i = 0; i != dex_files.size(); ++i) {
+    const DexFile* dex_file = dex_files[i];
+    CHECK(dex_file != NULL);
+    CompileDexFile(class_loader, *dex_file, thread_pool, timings);
+  }
+}
+
+void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, size_t class_def_index) {
+  jobject jclass_loader = manager->GetClassLoader();
+  const DexFile& dex_file = *manager->GetDexFile();
+  const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
+  {
+    ScopedObjectAccess soa(Thread::Current());
+    mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(jclass_loader);
+    if (SkipClass(class_loader, dex_file, class_def)) {
+      return;
+    }
+  }
+  ClassReference ref(&dex_file, class_def_index);
+  // Skip compiling classes with generic verifier failures since they will still fail at runtime
+  if (verifier::MethodVerifier::IsClassRejected(ref)) {
+    return;
+  }
+  const byte* class_data = dex_file.GetClassData(class_def);
+  if (class_data == NULL) {
+    // empty class, probably a marker interface
+    return;
+  }
+  // Can we run DEX-to-DEX compiler on this class ?
+  bool allow_dex_compilation;
+  {
+    ScopedObjectAccess soa(Thread::Current());
+    mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(jclass_loader);
+    allow_dex_compilation = IsDexToDexCompilationAllowed(class_loader, dex_file, class_def);
+  }
+  ClassDataItemIterator it(dex_file, class_data);
+  // Skip fields
+  while (it.HasNextStaticField()) {
+    it.Next();
+  }
+  while (it.HasNextInstanceField()) {
+    it.Next();
+  }
+  // Compile direct methods
+  int64_t previous_direct_method_idx = -1;
+  while (it.HasNextDirectMethod()) {
+    uint32_t method_idx = it.GetMemberIndex();
+    if (method_idx == previous_direct_method_idx) {
+      // smali can create dex files with two encoded_methods sharing the same method_idx
+      // http://code.google.com/p/smali/issues/detail?id=119
+      it.Next();
+      continue;
+    }
+    previous_direct_method_idx = method_idx;
+    manager->GetCompiler()->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
+                                          it.GetMethodInvokeType(class_def), class_def_index,
+                                          method_idx, jclass_loader, dex_file, allow_dex_compilation);
+    it.Next();
+  }
+  // Compile virtual methods
+  int64_t previous_virtual_method_idx = -1;
+  while (it.HasNextVirtualMethod()) {
+    uint32_t method_idx = it.GetMemberIndex();
+    if (method_idx == previous_virtual_method_idx) {
+      // smali can create dex files with two encoded_methods sharing the same method_idx
+      // http://code.google.com/p/smali/issues/detail?id=119
+      it.Next();
+      continue;
+    }
+    previous_virtual_method_idx = method_idx;
+    manager->GetCompiler()->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
+                                          it.GetMethodInvokeType(class_def), class_def_index,
+                                          method_idx, jclass_loader, dex_file, allow_dex_compilation);
+    it.Next();
+  }
+  DCHECK(!it.HasNext());
+}
+
+void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_file,
+                                    ThreadPool& thread_pool, TimingLogger& timings) {
+  ParallelCompilationManager context(NULL, class_loader, this, &dex_file, thread_pool);
+  context.ForAll(0, dex_file.NumClassDefs(), CompilerDriver::CompileClass, thread_count_);
+  timings.AddSplit("Compile " + dex_file.GetLocation());
+}
+
+void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
+                                   InvokeType invoke_type, uint32_t class_def_idx,
+                                   uint32_t method_idx, jobject class_loader,
+                                   const DexFile& dex_file,
+                                   bool allow_dex_to_dex_compilation) {
+  CompiledMethod* compiled_method = NULL;
+  uint64_t start_ns = NanoTime();
+
+  if ((access_flags & kAccNative) != 0) {
+    compiled_method = (*jni_compiler_)(*this, access_flags, method_idx, dex_file);
+    CHECK(compiled_method != NULL);
+  } else if ((access_flags & kAccAbstract) != 0) {
+  } else {
+    // In small mode we only compile image classes.
+    bool dont_compile = (Runtime::Current()->IsSmallMode() &&
+                         ((image_classes_.get() == NULL) || (image_classes_->size() == 0)));
+
+    // Don't compile class initializers, ever.
+    if (((access_flags & kAccConstructor) != 0) && ((access_flags & kAccStatic) != 0)) {
+      dont_compile = true;
+    } else if (code_item->insns_size_in_code_units_ < Runtime::Current()->GetSmallModeMethodDexSizeLimit()) {
+    // Do compile small methods.
+      dont_compile = false;
+    }
+    if (!dont_compile) {
+      CompilerFn compiler = compiler_;
+#ifdef ART_SEA_IR_MODE
+      bool use_sea = Runtime::Current()->IsSeaIRMode();
+      use_sea &&= (std::string::npos != PrettyMethod(method_idx, dex_file).find("fibonacci"));
+      if (use_sea) {
+        compiler = sea_ir_compiler_;
+      }
+#endif
+      compiled_method = (*compiler)(*this, code_item, access_flags, invoke_type, class_def_idx,
+                                    method_idx, class_loader, dex_file);
+      CHECK(compiled_method != NULL) << PrettyMethod(method_idx, dex_file);
+    } else if (allow_dex_to_dex_compilation) {
+      // TODO: add a mode to disable DEX-to-DEX compilation ?
+      compiled_method = (*dex_to_dex_compiler_)(*this, code_item, access_flags,
+                                                invoke_type, class_def_idx,
+                                                method_idx, class_loader, dex_file);
+      // No native code is generated.
+      CHECK(compiled_method == NULL) << PrettyMethod(method_idx, dex_file);
+    }
+  }
+  uint64_t duration_ns = NanoTime() - start_ns;
+#ifdef ART_USE_PORTABLE_COMPILER
+  const uint64_t kWarnMilliSeconds = 1000;
+#else
+  const uint64_t kWarnMilliSeconds = 100;
+#endif
+  if (duration_ns > MsToNs(kWarnMilliSeconds)) {
+    LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file)
+                 << " took " << PrettyDuration(duration_ns);
+  }
+
+  Thread* self = Thread::Current();
+  if (compiled_method != NULL) {
+    MethodReference ref(&dex_file, method_idx);
+    CHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
+    {
+      MutexLock mu(self, compiled_methods_lock_);
+      compiled_methods_.Put(ref, compiled_method);
+    }
+    DCHECK(GetCompiledMethod(ref) != NULL) << PrettyMethod(method_idx, dex_file);
+  }
+
+  if (self->IsExceptionPending()) {
+    ScopedObjectAccess soa(self);
+    LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n"
+        << self->GetException(NULL)->Dump();
+  }
+}
+
+CompiledClass* CompilerDriver::GetCompiledClass(ClassReference ref) const {
+  MutexLock mu(Thread::Current(), compiled_classes_lock_);
+  ClassTable::const_iterator it = compiled_classes_.find(ref);
+  if (it == compiled_classes_.end()) {
+    return NULL;
+  }
+  CHECK(it->second != NULL);
+  return it->second;
+}
+
+CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const {
+  MutexLock mu(Thread::Current(), compiled_methods_lock_);
+  MethodTable::const_iterator it = compiled_methods_.find(ref);
+  if (it == compiled_methods_.end()) {
+    return NULL;
+  }
+  CHECK(it->second != NULL);
+  return it->second;
+}
+
+void CompilerDriver::SetBitcodeFileName(std::string const& filename) {
+  typedef void (*SetBitcodeFileNameFn)(CompilerDriver&, std::string const&);
+
+  SetBitcodeFileNameFn set_bitcode_file_name =
+    reinterpret_cast<SetBitcodeFileNameFn>(compilerLLVMSetBitcodeFileName);
+
+  set_bitcode_file_name(*this, filename);
+}
+
+
+void CompilerDriver::AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
+                                             size_t class_def_index) {
+  MutexLock mu(self, freezing_constructor_lock_);
+  freezing_constructor_classes_.insert(ClassReference(dex_file, class_def_index));
+}
+
+bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
+                                          size_t class_def_index) {
+  MutexLock mu(self, freezing_constructor_lock_);
+  return freezing_constructor_classes_.count(ClassReference(dex_file, class_def_index)) != 0;
+}
+
+bool CompilerDriver::WriteElf(const std::string& android_root,
+                              bool is_host,
+                              const std::vector<const art::DexFile*>& dex_files,
+                              std::vector<uint8_t>& oat_contents,
+                              art::File* file)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+#if defined(ART_USE_PORTABLE_COMPILER)
+  return art::ElfWriterMclinker::Create(file, oat_contents, dex_files, android_root, is_host, *this);
+#else
+  return art::ElfWriterQuick::Create(file, oat_contents, dex_files, android_root, is_host, *this);
+#endif
+}
+void CompilerDriver::InstructionSetToLLVMTarget(InstructionSet instruction_set,
+                                                std::string& target_triple,
+                                                std::string& target_cpu,
+                                                std::string& target_attr) {
+  switch (instruction_set) {
+    case kThumb2:
+      target_triple = "thumb-none-linux-gnueabi";
+      target_cpu = "cortex-a9";
+      target_attr = "+thumb2,+neon,+neonfp,+vfp3,+db";
+      break;
+
+    case kArm:
+      target_triple = "armv7-none-linux-gnueabi";
+      // TODO: Fix for Nexus S.
+      target_cpu = "cortex-a9";
+      // TODO: Fix for Xoom.
+      target_attr = "+v7,+neon,+neonfp,+vfp3,+db";
+      break;
+
+    case kX86:
+      target_triple = "i386-pc-linux-gnu";
+      target_attr = "";
+      break;
+
+    case kMips:
+      target_triple = "mipsel-unknown-linux";
+      target_attr = "mips32r2";
+      break;
+
+    default:
+      LOG(FATAL) << "Unknown instruction set: " << instruction_set;
+    }
+  }
+}  // namespace art
-- 
cgit v1.2.3-59-g8ed1b


From 56d947fbc9bc2992e2f93112fafb73e50d2aaa7a Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Mon, 15 Jul 2013 13:14:23 -0700
Subject: Add verification of boot.oat generated on device

Change-Id: I069586205a9a92fc7375ccf5cdde136bbbcfc800
---
 compiler/driver/compiler_driver.cc |   1 -
 compiler/driver/compiler_driver.h  |   2 +-
 compiler/elf_writer.cc             |   1 -
 compiler/llvm/compiler_llvm.cc     |   1 -
 runtime/class_linker.cc            |  55 ++++-------
 runtime/class_linker.h             |   2 +-
 runtime/gc/heap.cc                 | 133 ++------------------------
 runtime/gc/heap.h                  |   6 --
 runtime/gc/space/image_space.cc    | 188 +++++++++++++++++++++++++++++++++++--
 runtime/gc/space/image_space.h     |  39 +++++++-
 runtime/oat_file.h                 |   9 +-
 11 files changed, 254 insertions(+), 183 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index c99d103c17..9e71dff464 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -26,7 +26,6 @@
 #include "dex_compilation_unit.h"
 #include "dex_file-inl.h"
 #include "jni_internal.h"
-#include "oat_file.h"
 #include "object_utils.h"
 #include "runtime.h"
 #include "gc/accounting/card_table-inl.h"
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index d37f494ef1..4d7f0cf7b6 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -29,7 +29,7 @@
 #include "instruction_set.h"
 #include "invoke_type.h"
 #include "method_reference.h"
-#include "oat_file.h"
+#include "os.h"
 #include "runtime.h"
 #include "safe_map.h"
 #include "thread_pool.h"
diff --git a/compiler/elf_writer.cc b/compiler/elf_writer.cc
index 0823a53f87..70d17de102 100644
--- a/compiler/elf_writer.cc
+++ b/compiler/elf_writer.cc
@@ -27,7 +27,6 @@
 #include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
 #include "oat.h"
-#include "oat_file.h"
 #include "scoped_thread_state_change.h"
 
 namespace art {
diff --git a/compiler/llvm/compiler_llvm.cc b/compiler/llvm/compiler_llvm.cc
index afca223192..4475b25043 100644
--- a/compiler/llvm/compiler_llvm.cc
+++ b/compiler/llvm/compiler_llvm.cc
@@ -26,7 +26,6 @@
 #include "ir_builder.h"
 #include "jni/portable/jni_compiler.h"
 #include "llvm_compilation_unit.h"
-#include "oat_file.h"
 #include "utils_llvm.h"
 #include "verifier/method_verifier.h"
 
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index e35b95c1e9..fbceb597f0 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -680,35 +680,12 @@ void ClassLinker::RegisterOatFileLocked(const OatFile& oat_file) {
   oat_files_.push_back(&oat_file);
 }
 
-OatFile* ClassLinker::OpenOat(const gc::space::ImageSpace* space) {
+OatFile& ClassLinker::GetImageOatFile(gc::space::ImageSpace* space) {
+  VLOG(startup) << "ClassLinker::GetImageOatFile entering";
+  OatFile& oat_file = space->ReleaseOatFile();
   WriterMutexLock mu(Thread::Current(), dex_lock_);
-  const Runtime* runtime = Runtime::Current();
-  const ImageHeader& image_header = space->GetImageHeader();
-  // Grab location but don't use Object::AsString as we haven't yet initialized the roots to
-  // check the down cast
-  mirror::String* oat_location =
-      down_cast<mirror::String*>(image_header.GetImageRoot(ImageHeader::kOatLocation));
-  std::string oat_filename;
-  oat_filename += runtime->GetHostPrefix();
-  oat_filename += oat_location->ToModifiedUtf8();
-  runtime->GetHeap()->UnReserveOatFileAddressRange();
-  OatFile* oat_file = OatFile::Open(oat_filename, oat_filename, image_header.GetOatDataBegin(),
-                                    !Runtime::Current()->IsCompiler());
-  VLOG(startup) << "ClassLinker::OpenOat entering oat_filename=" << oat_filename;
-  if (oat_file == NULL) {
-    LOG(ERROR) << "Failed to open oat file " << oat_filename << " referenced from image.";
-    return NULL;
-  }
-  uint32_t oat_checksum = oat_file->GetOatHeader().GetChecksum();
-  uint32_t image_oat_checksum = image_header.GetOatChecksum();
-  if (oat_checksum != image_oat_checksum) {
-    LOG(ERROR) << "Failed to match oat file checksum " << std::hex << oat_checksum
-               << " to expected oat checksum " << std::hex << image_oat_checksum
-               << " in image";
-    return NULL;
-  }
-  RegisterOatFileLocked(*oat_file);
-  VLOG(startup) << "ClassLinker::OpenOat exiting";
+  RegisterOatFileLocked(oat_file);
+  VLOG(startup) << "ClassLinker::GetImageOatFile exiting";
   return oat_file;
 }
 
@@ -952,13 +929,13 @@ void ClassLinker::InitFromImage() {
 
   gc::Heap* heap = Runtime::Current()->GetHeap();
   gc::space::ImageSpace* space = heap->GetImageSpace();
-  OatFile* oat_file = OpenOat(space);
-  CHECK(oat_file != NULL) << "Failed to open oat file for image";
-  CHECK_EQ(oat_file->GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
-  CHECK_EQ(oat_file->GetOatHeader().GetImageFileLocationOatDataBegin(), 0U);
-  CHECK(oat_file->GetOatHeader().GetImageFileLocation().empty());
-  portable_resolution_trampoline_ = oat_file->GetOatHeader().GetPortableResolutionTrampoline();
-  quick_resolution_trampoline_ = oat_file->GetOatHeader().GetQuickResolutionTrampoline();
+  CHECK(space != NULL);
+  OatFile& oat_file = GetImageOatFile(space);
+  CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
+  CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatDataBegin(), 0U);
+  CHECK(oat_file.GetOatHeader().GetImageFileLocation().empty());
+  portable_resolution_trampoline_ = oat_file.GetOatHeader().GetPortableResolutionTrampoline();
+  quick_resolution_trampoline_ = oat_file.GetOatHeader().GetQuickResolutionTrampoline();
   mirror::Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
   mirror::ObjectArray<mirror::DexCache>* dex_caches =
       dex_caches_object->AsObjectArray<mirror::DexCache>();
@@ -971,18 +948,18 @@ void ClassLinker::InitFromImage() {
   // as being Strings or not
   mirror::String::SetClass(GetClassRoot(kJavaLangString));
 
-  CHECK_EQ(oat_file->GetOatHeader().GetDexFileCount(),
+  CHECK_EQ(oat_file.GetOatHeader().GetDexFileCount(),
            static_cast<uint32_t>(dex_caches->GetLength()));
   Thread* self = Thread::Current();
   for (int i = 0; i < dex_caches->GetLength(); i++) {
     SirtRef<mirror::DexCache> dex_cache(self, dex_caches->Get(i));
     const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
-    const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file_location);
-    CHECK(oat_dex_file != NULL) << oat_file->GetLocation() << " " << dex_file_location;
+    const OatFile::OatDexFile* oat_dex_file = oat_file.GetOatDexFile(dex_file_location);
+    CHECK(oat_dex_file != NULL) << oat_file.GetLocation() << " " << dex_file_location;
     const DexFile* dex_file = oat_dex_file->OpenDexFile();
     if (dex_file == NULL) {
       LOG(FATAL) << "Failed to open dex file " << dex_file_location
-                 << " from within oat file " << oat_file->GetLocation();
+                 << " from within oat file " << oat_file.GetLocation();
     }
 
     CHECK_EQ(dex_file->GetLocationChecksum(), oat_dex_file->GetDexFileLocationChecksum());
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index df336724fa..df1ecc6207 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -359,7 +359,7 @@ class ClassLinker {
 
   // Initialize class linker from one or more images.
   void InitFromImage() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  OatFile* OpenOat(const gc::space::ImageSpace* space)
+  OatFile& GetImageOatFile(gc::space::ImageSpace* space)
       LOCKS_EXCLUDED(dex_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   static void InitFromImageCallback(mirror::Object* obj, void* arg)
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index a68cc02435..53b8cd9550 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -18,8 +18,6 @@
 
 #define ATRACE_TAG ATRACE_TAG_DALVIK
 #include <cutils/trace.h>
-#include <sys/types.h>
-#include <sys/wait.h>
 
 #include <limits>
 #include <vector>
@@ -66,96 +64,6 @@ static const bool kDumpGcPerformanceOnShutdown = false;
 static const size_t kMinConcurrentRemainingBytes = 128 * KB;
 const double Heap::kDefaultTargetUtilization = 0.5;
 
-static bool GenerateImage(const std::string& image_file_name) {
-  const std::string boot_class_path_string(Runtime::Current()->GetBootClassPathString());
-  std::vector<std::string> boot_class_path;
-  Split(boot_class_path_string, ':', boot_class_path);
-  if (boot_class_path.empty()) {
-    LOG(FATAL) << "Failed to generate image because no boot class path specified";
-  }
-
-  std::vector<char*> arg_vector;
-
-  std::string dex2oat_string(GetAndroidRoot());
-  dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
-  const char* dex2oat = dex2oat_string.c_str();
-  arg_vector.push_back(strdup(dex2oat));
-
-  std::string image_option_string("--image=");
-  image_option_string += image_file_name;
-  const char* image_option = image_option_string.c_str();
-  arg_vector.push_back(strdup(image_option));
-
-  arg_vector.push_back(strdup("--runtime-arg"));
-  arg_vector.push_back(strdup("-Xms64m"));
-
-  arg_vector.push_back(strdup("--runtime-arg"));
-  arg_vector.push_back(strdup("-Xmx64m"));
-
-  for (size_t i = 0; i < boot_class_path.size(); i++) {
-    std::string dex_file_option_string("--dex-file=");
-    dex_file_option_string += boot_class_path[i];
-    const char* dex_file_option = dex_file_option_string.c_str();
-    arg_vector.push_back(strdup(dex_file_option));
-  }
-
-  std::string oat_file_option_string("--oat-file=");
-  oat_file_option_string += image_file_name;
-  oat_file_option_string.erase(oat_file_option_string.size() - 3);
-  oat_file_option_string += "oat";
-  const char* oat_file_option = oat_file_option_string.c_str();
-  arg_vector.push_back(strdup(oat_file_option));
-
-  std::string base_option_string(StringPrintf("--base=0x%x", ART_BASE_ADDRESS));
-  arg_vector.push_back(strdup(base_option_string.c_str()));
-
-  if (kIsTargetBuild) {
-    arg_vector.push_back(strdup("--image-classes-zip=/system/framework/framework.jar"));
-    arg_vector.push_back(strdup("--image-classes=preloaded-classes"));
-  } else {
-    arg_vector.push_back(strdup("--host"));
-  }
-
-  std::string command_line(Join(arg_vector, ' '));
-  LOG(INFO) << command_line;
-
-  arg_vector.push_back(NULL);
-  char** argv = &arg_vector[0];
-
-  // fork and exec dex2oat
-  pid_t pid = fork();
-  if (pid == 0) {
-    // no allocation allowed between fork and exec
-
-    // change process groups, so we don't get reaped by ProcessManager
-    setpgid(0, 0);
-
-    execv(dex2oat, argv);
-
-    PLOG(FATAL) << "execv(" << dex2oat << ") failed";
-    return false;
-  } else {
-    STLDeleteElements(&arg_vector);
-
-    // wait for dex2oat to finish
-    int status;
-    pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
-    if (got_pid != pid) {
-      PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
-      return false;
-    }
-    if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
-      LOG(ERROR) << dex2oat << " failed: " << command_line;
-      return false;
-    }
-  }
-  return true;
-}
-
-void Heap::UnReserveOatFileAddressRange() {
-  oat_file_map_.reset(NULL);
-}
-
 Heap::Heap(size_t initial_size, size_t growth_limit, size_t min_free, size_t max_free,
            double target_utilization, size_t capacity,
            const std::string& original_image_file_name, bool concurrent_gc)
@@ -206,45 +114,20 @@ Heap::Heap(size_t initial_size, size_t growth_limit, size_t min_free, size_t max
   mark_bitmap_.reset(new accounting::HeapBitmap(this));
 
   // Requested begin for the alloc space, to follow the mapped image and oat files
-  byte* requested_begin = NULL;
+  byte* requested_alloc_space_begin = NULL;
   std::string image_file_name(original_image_file_name);
   if (!image_file_name.empty()) {
-    space::ImageSpace* image_space = NULL;
-
-    if (OS::FileExists(image_file_name.c_str())) {
-      // If the /system file exists, it should be up-to-date, don't try to generate
-      image_space = space::ImageSpace::Create(image_file_name);
-    } else {
-      // If the /system file didn't exist, we need to use one from the dalvik-cache.
-      // If the cache file exists, try to open, but if it fails, regenerate.
-      // If it does not exist, generate.
-      image_file_name = GetDalvikCacheFilenameOrDie(image_file_name);
-      if (OS::FileExists(image_file_name.c_str())) {
-        image_space = space::ImageSpace::Create(image_file_name);
-      }
-      if (image_space == NULL) {
-        CHECK(GenerateImage(image_file_name)) << "Failed to generate image: " << image_file_name;
-        image_space = space::ImageSpace::Create(image_file_name);
-      }
-    }
-
-    CHECK(image_space != NULL) << "Failed to create space from " << image_file_name;
+    space::ImageSpace* image_space = space::ImageSpace::Create(image_file_name);
+    CHECK(image_space != NULL) << "Failed to create space for " << image_file_name;
     AddContinuousSpace(image_space);
     // Oat files referenced by image files immediately follow them in memory, ensure alloc space
     // isn't going to get in the middle
     byte* oat_file_end_addr = image_space->GetImageHeader().GetOatFileEnd();
     CHECK_GT(oat_file_end_addr, image_space->End());
-
-    // Reserve address range from image_space->End() to image_space->GetImageHeader().GetOatEnd()
-    uintptr_t reserve_begin = RoundUp(reinterpret_cast<uintptr_t>(image_space->End()), kPageSize);
-    uintptr_t reserve_end = RoundUp(reinterpret_cast<uintptr_t>(oat_file_end_addr), kPageSize);
-    oat_file_map_.reset(MemMap::MapAnonymous("oat file reserve",
-                                             reinterpret_cast<byte*>(reserve_begin),
-                                             reserve_end - reserve_begin, PROT_NONE));
-
-    if (oat_file_end_addr > requested_begin) {
-      requested_begin = reinterpret_cast<byte*>(RoundUp(reinterpret_cast<uintptr_t>(oat_file_end_addr),
-                                                          kPageSize));
+    if (oat_file_end_addr > requested_alloc_space_begin) {
+      requested_alloc_space_begin =
+          reinterpret_cast<byte*>(RoundUp(reinterpret_cast<uintptr_t>(oat_file_end_addr),
+                                          kPageSize));
     }
   }
 
@@ -261,7 +144,7 @@ Heap::Heap(size_t initial_size, size_t growth_limit, size_t min_free, size_t max
   alloc_space_ = space::DlMallocSpace::Create("alloc space",
                                               initial_size,
                                               growth_limit, capacity,
-                                              requested_begin);
+                                              requested_alloc_space_begin);
   CHECK(alloc_space_ != NULL) << "Failed to create alloc space";
   alloc_space_->SetFootprintLimit(alloc_space_->Capacity());
   AddContinuousSpace(alloc_space_);
diff --git a/runtime/gc/heap.h b/runtime/gc/heap.h
index 790ab0216d..e6c92211d4 100644
--- a/runtime/gc/heap.h
+++ b/runtime/gc/heap.h
@@ -373,9 +373,6 @@ class Heap {
 
   void DumpSpaces();
 
-  // UnReserve the address range where the oat file will be placed.
-  void UnReserveOatFileAddressRange();
-
   // GC performance measuring
   void DumpGcPerformanceInfo(std::ostream& os);
 
@@ -599,9 +596,6 @@ class Heap {
 
   std::vector<collector::MarkSweep*> mark_sweep_collectors_;
 
-  // A map that we use to temporarily reserve address range for the oat file.
-  UniquePtr<MemMap> oat_file_map_;
-
   friend class collector::MarkSweep;
   friend class VerifyReferenceCardVisitor;
   friend class VerifyReferenceVisitor;
diff --git a/runtime/gc/space/image_space.cc b/runtime/gc/space/image_space.cc
index 46c39378d7..c279ecf1ff 100644
--- a/runtime/gc/space/image_space.cc
+++ b/runtime/gc/space/image_space.cc
@@ -16,11 +16,16 @@
 
 #include "image_space.h"
 
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include "base/stl_util.h"
 #include "base/unix_file/fd_file.h"
 #include "gc/accounting/space_bitmap-inl.h"
 #include "mirror/abstract_method.h"
 #include "mirror/class-inl.h"
 #include "mirror/object-inl.h"
+#include "oat_file.h"
 #include "os.h"
 #include "runtime.h"
 #include "space-inl.h"
@@ -41,13 +46,118 @@ ImageSpace::ImageSpace(const std::string& name, MemMap* mem_map)
   DCHECK(live_bitmap_.get() != NULL) << "could not create imagespace live bitmap #" << bitmap_index;
 }
 
-ImageSpace* ImageSpace::Create(const std::string& image_file_name) {
+static bool GenerateImage(const std::string& image_file_name) {
+  const std::string boot_class_path_string(Runtime::Current()->GetBootClassPathString());
+  std::vector<std::string> boot_class_path;
+  Split(boot_class_path_string, ':', boot_class_path);
+  if (boot_class_path.empty()) {
+    LOG(FATAL) << "Failed to generate image because no boot class path specified";
+  }
+
+  std::vector<char*> arg_vector;
+
+  std::string dex2oat_string(GetAndroidRoot());
+  dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
+  const char* dex2oat = dex2oat_string.c_str();
+  arg_vector.push_back(strdup(dex2oat));
+
+  std::string image_option_string("--image=");
+  image_option_string += image_file_name;
+  const char* image_option = image_option_string.c_str();
+  arg_vector.push_back(strdup(image_option));
+
+  arg_vector.push_back(strdup("--runtime-arg"));
+  arg_vector.push_back(strdup("-Xms64m"));
+
+  arg_vector.push_back(strdup("--runtime-arg"));
+  arg_vector.push_back(strdup("-Xmx64m"));
+
+  for (size_t i = 0; i < boot_class_path.size(); i++) {
+    std::string dex_file_option_string("--dex-file=");
+    dex_file_option_string += boot_class_path[i];
+    const char* dex_file_option = dex_file_option_string.c_str();
+    arg_vector.push_back(strdup(dex_file_option));
+  }
+
+  std::string oat_file_option_string("--oat-file=");
+  oat_file_option_string += image_file_name;
+  oat_file_option_string.erase(oat_file_option_string.size() - 3);
+  oat_file_option_string += "oat";
+  const char* oat_file_option = oat_file_option_string.c_str();
+  arg_vector.push_back(strdup(oat_file_option));
+
+  std::string base_option_string(StringPrintf("--base=0x%x", ART_BASE_ADDRESS));
+  arg_vector.push_back(strdup(base_option_string.c_str()));
+
+  if (kIsTargetBuild) {
+    arg_vector.push_back(strdup("--image-classes-zip=/system/framework/framework.jar"));
+    arg_vector.push_back(strdup("--image-classes=preloaded-classes"));
+  } else {
+    arg_vector.push_back(strdup("--host"));
+  }
+
+  std::string command_line(Join(arg_vector, ' '));
+  LOG(INFO) << "GenerateImage: " << command_line;
+
+  arg_vector.push_back(NULL);
+  char** argv = &arg_vector[0];
+
+  // fork and exec dex2oat
+  pid_t pid = fork();
+  if (pid == 0) {
+    // no allocation allowed between fork and exec
+
+    // change process groups, so we don't get reaped by ProcessManager
+    setpgid(0, 0);
+
+    execv(dex2oat, argv);
+
+    PLOG(FATAL) << "execv(" << dex2oat << ") failed";
+    return false;
+  } else {
+    STLDeleteElements(&arg_vector);
+
+    // wait for dex2oat to finish
+    int status;
+    pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
+    if (got_pid != pid) {
+      PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
+      return false;
+    }
+    if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+      LOG(ERROR) << dex2oat << " failed: " << command_line;
+      return false;
+    }
+  }
+  return true;
+}
+
+ImageSpace* ImageSpace::Create(const std::string& original_image_file_name) {
+  if (OS::FileExists(original_image_file_name.c_str())) {
+    // If the /system file exists, it should be up-to-date, don't try to generate
+    return space::ImageSpace::Init(original_image_file_name, false);
+  }
+  // If the /system file didn't exist, we need to use one from the dalvik-cache.
+  // If the cache file exists, try to open, but if it fails, regenerate.
+  // If it does not exist, generate.
+  std::string image_file_name(GetDalvikCacheFilenameOrDie(original_image_file_name));
+  if (OS::FileExists(image_file_name.c_str())) {
+    space::ImageSpace* image_space = space::ImageSpace::Init(image_file_name, true);
+    if (image_space != NULL) {
+      return image_space;
+    }
+  }
+  CHECK(GenerateImage(image_file_name)) << "Failed to generate image: " << image_file_name;
+  return space::ImageSpace::Init(image_file_name, true);
+}
+
+ImageSpace* ImageSpace::Init(const std::string& image_file_name, bool validate_oat_file) {
   CHECK(!image_file_name.empty());
 
   uint64_t start_time = 0;
   if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
     start_time = NanoTime();
-    LOG(INFO) << "Space::CreateImageSpace entering" << " image_file_name=" << image_file_name;
+    LOG(INFO) << "ImageSpace::Init entering image_file_name=" << image_file_name;
   }
 
   UniquePtr<File> file(OS::OpenFile(image_file_name.c_str(), false));
@@ -86,12 +196,78 @@ ImageSpace* ImageSpace::Create(const std::string& image_file_name) {
   callee_save_method = image_header.GetImageRoot(ImageHeader::kRefsAndArgsSaveMethod);
   runtime->SetCalleeSaveMethod(down_cast<mirror::AbstractMethod*>(callee_save_method), Runtime::kRefsAndArgs);
 
-  ImageSpace* space = new ImageSpace(image_file_name, map.release());
+  UniquePtr<ImageSpace> space(new ImageSpace(image_file_name, map.release()));
+
+  space->oat_file_.reset(space->OpenOatFile());
+  if (space->oat_file_.get() == NULL) {
+    LOG(ERROR) << "Failed to open oat file for image: " << image_file_name;
+    return NULL;
+  }
+
+  if (validate_oat_file && !space->ValidateOatFile()) {
+    LOG(WARNING) << "Failed to validate oat file for image: " << image_file_name;
+    return NULL;
+  }
+
   if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
-    LOG(INFO) << "Space::CreateImageSpace exiting (" << PrettyDuration(NanoTime() - start_time)
-             << ") " << *space;
+    LOG(INFO) << "ImageSpace::Init exiting (" << PrettyDuration(NanoTime() - start_time)
+             << ") " << *space.get();
   }
-  return space;
+  return space.release();
+}
+
+OatFile* ImageSpace::OpenOatFile() const {
+  const Runtime* runtime = Runtime::Current();
+  const ImageHeader& image_header = GetImageHeader();
+  // Grab location but don't use Object::AsString as we haven't yet initialized the roots to
+  // check the down cast
+  mirror::String* oat_location =
+      down_cast<mirror::String*>(image_header.GetImageRoot(ImageHeader::kOatLocation));
+  std::string oat_filename;
+  oat_filename += runtime->GetHostPrefix();
+  oat_filename += oat_location->ToModifiedUtf8();
+  OatFile* oat_file = OatFile::Open(oat_filename, oat_filename, image_header.GetOatDataBegin(),
+                                    !Runtime::Current()->IsCompiler());
+  if (oat_file == NULL) {
+    LOG(ERROR) << "Failed to open oat file " << oat_filename << " referenced from image.";
+    return NULL;
+  }
+  uint32_t oat_checksum = oat_file->GetOatHeader().GetChecksum();
+  uint32_t image_oat_checksum = image_header.GetOatChecksum();
+  if (oat_checksum != image_oat_checksum) {
+    LOG(ERROR) << "Failed to match oat file checksum " << std::hex << oat_checksum
+               << " to expected oat checksum " << std::hex << image_oat_checksum
+               << " in image";
+    return NULL;
+  }
+  return oat_file;
+}
+
+bool ImageSpace::ValidateOatFile() const {
+  CHECK(oat_file_.get() != NULL);
+  std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file_->GetOatDexFiles();
+  for (size_t i = 0; i < oat_dex_files.size(); i++) {
+    const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
+    const std::string& dex_file_location = oat_dex_file->GetDexFileLocation();
+    uint32_t dex_file_location_checksum;
+    if (!DexFile::GetChecksum(dex_file_location.c_str(), dex_file_location_checksum)) {
+      LOG(WARNING) << "ValidateOatFile could not find checksum for " << dex_file_location;
+      return false;
+    }
+    if (dex_file_location_checksum != oat_dex_file->GetDexFileLocationChecksum()) {
+      LOG(WARNING) << "ValidateOatFile found checksum mismatch between oat file "
+                   << oat_file_->GetLocation() << " and dex file " << dex_file_location
+                   << " (" << oat_dex_file->GetDexFileLocationChecksum() << " != "
+                   << dex_file_location_checksum << ")";
+      return false;
+    }
+  }
+  return true;
+}
+
+OatFile& ImageSpace::ReleaseOatFile() {
+  CHECK(oat_file_.get() != NULL);
+  return *oat_file_.release();
 }
 
 void ImageSpace::RecordImageAllocations(accounting::SpaceBitmap* live_bitmap) const {
diff --git a/runtime/gc/space/image_space.h b/runtime/gc/space/image_space.h
index afec5b7305..833fb8d73a 100644
--- a/runtime/gc/space/image_space.h
+++ b/runtime/gc/space/image_space.h
@@ -20,6 +20,9 @@
 #include "space.h"
 
 namespace art {
+
+class OatFile;
+
 namespace gc {
 namespace space {
 
@@ -34,10 +37,22 @@ class ImageSpace : public MemMapSpace {
     return kSpaceTypeImageSpace;
   }
 
-  // create a Space from an image file. cannot be used for future allocation or collected.
+  // Create a Space from an image file. Cannot be used for future
+  // allocation or collected.
+  //
+  // Create also opens the OatFile associated with the image file so
+  // that it be contiguously allocated with the image before the
+  // creation of the alloc space. The ReleaseOatFile will later be
+  // used to transfer ownership of the OatFile to the ClassLinker when
+  // it is initialized.
   static ImageSpace* Create(const std::string& image)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
+  // Releases the OatFile from the ImageSpace so it can be transfer to
+  // the caller, presumably the ClassLinker.
+  OatFile& ReleaseOatFile()
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
   const ImageHeader& GetImageHeader() const {
     return *reinterpret_cast<ImageHeader*>(Begin());
   }
@@ -63,6 +78,23 @@ class ImageSpace : public MemMapSpace {
   void Dump(std::ostream& os) const;
 
  private:
+
+  // Tries to initialize an ImageSpace from the given image path,
+  // returning NULL on error.
+  //
+  // If validate_oat_file is false (for /system), do not verify that
+  // image's OatFile is up-to-date relative to its DexFile
+  // inputs. Otherwise (for /data), validate the inputs and generate
+  // the OatFile in /data/dalvik-cache if necessary.
+  static ImageSpace* Init(const std::string& image, bool validate_oat_file)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  OatFile* OpenOatFile() const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  bool ValidateOatFile() const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
   friend class Space;
 
   static size_t bitmap_index_;
@@ -71,6 +103,11 @@ class ImageSpace : public MemMapSpace {
 
   ImageSpace(const std::string& name, MemMap* mem_map);
 
+  // The OatFile associated with the image during early startup to
+  // reserve space contiguous to the image. It is later released to
+  // the ClassLinker during it's initialization.
+  UniquePtr<OatFile> oat_file_;
+
   DISALLOW_COPY_AND_ASSIGN(ImageSpace);
 };
 
diff --git a/runtime/oat_file.h b/runtime/oat_file.h
index e3fd0025f0..ecc8d0c965 100644
--- a/runtime/oat_file.h
+++ b/runtime/oat_file.h
@@ -166,18 +166,25 @@ class OatFile {
 
   class OatDexFile {
    public:
+    // Opens the DexFile referred to by this OatDexFile from within the containing OatFile.
     const DexFile* OpenDexFile() const;
-    const OatClass* GetOatClass(uint32_t class_def_index) const;
+
+    // Returns the size of the DexFile refered to by this OatDexFile.
     size_t FileSize() const;
 
+    // Returns original path of DexFile that was the source of this OatDexFile.
     const std::string& GetDexFileLocation() const {
       return dex_file_location_;
     }
 
+    // Returns checksum of original DexFile that was the source of this OatDexFile;
     uint32_t GetDexFileLocationChecksum() const {
       return dex_file_location_checksum_;
     }
 
+    // Returns the OatClass for the class specified by the given DexFile class_def_index.
+    const OatClass* GetOatClass(uint32_t class_def_index) const;
+
     ~OatDexFile();
 
    private:
-- 
cgit v1.2.3-59-g8ed1b


From 2ce745c06271d5223d57dbf08117b20d5b60694a Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Wed, 17 Jul 2013 17:44:30 -0700
Subject: Fix cpplint whitespace/braces issues

Change-Id: Ide80939faf8e8690d8842dde8133902ac725ed1a
---
 Android.mk                                |   2 +-
 compiler/dex/arena_allocator.h            |   2 +-
 compiler/dex/arena_bit_vector.cc          |   6 +-
 compiler/dex/dataflow_iterator.h          |   2 +-
 compiler/dex/frontend.cc                  |   2 +-
 compiler/dex/local_value_numbering.cc     |   3 +-
 compiler/dex/mir_dataflow.cc              |  45 +++-----
 compiler/dex/mir_graph.cc                 |  71 ++++--------
 compiler/dex/mir_graph.h                  |  18 +--
 compiler/dex/mir_optimization.cc          |  69 ++++-------
 compiler/dex/portable/mir_to_gbc.cc       | 180 ++++++++++-------------------
 compiler/dex/quick/arm/assemble_arm.cc    |   6 +-
 compiler/dex/quick/arm/call_arm.cc        |  57 ++++------
 compiler/dex/quick/arm/fp_arm.cc          |  21 ++--
 compiler/dex/quick/arm/int_arm.cc         | 114 +++++++------------
 compiler/dex/quick/arm/target_arm.cc      | 105 ++++++-----------
 compiler/dex/quick/arm/utility_arm.cc     |  99 ++++++----------
 compiler/dex/quick/codegen_util.cc        | 111 ++++++------------
 compiler/dex/quick/gen_common.cc          | 107 ++++++-----------
 compiler/dex/quick/gen_invoke.cc          |  81 +++++--------
 compiler/dex/quick/gen_loadstore.cc       |  42 +++----
 compiler/dex/quick/local_optimizations.cc |  18 +--
 compiler/dex/quick/mips/assemble_mips.cc  |   9 +-
 compiler/dex/quick/mips/call_mips.cc      |  30 ++---
 compiler/dex/quick/mips/fp_mips.cc        |  24 ++--
 compiler/dex/quick/mips/int_mips.cc       |  99 ++++++----------
 compiler/dex/quick/mips/target_mips.cc    | 105 ++++++-----------
 compiler/dex/quick/mips/utility_mips.cc   |  81 +++++--------
 compiler/dex/quick/mir_to_lir.cc          |  15 +--
 compiler/dex/quick/mir_to_lir.h           |   2 +-
 compiler/dex/quick/ralloc_util.cc         | 183 ++++++++++--------------------
 compiler/dex/quick/x86/call_x86.cc        |  27 ++---
 compiler/dex/quick/x86/fp_x86.cc          |   6 +-
 compiler/dex/quick/x86/int_x86.cc         |  99 ++++++----------
 compiler/dex/quick/x86/target_x86.cc      |  81 +++++--------
 compiler/dex/quick/x86/utility_x86.cc     |  60 ++++------
 compiler/dex/ssa_transformation.cc        |  60 ++++------
 compiler/dex/vreg_analysis.cc             |   9 +-
 compiler/driver/compiler_driver.cc        |  13 +--
 compiler/image_writer.cc                  |   2 +-
 compiler/jni/jni_compiler_test.cc         |   2 +-
 compiler/llvm/runtime_support_builder.cc  |   3 +-
 jdwpspy/Common.h                          |  12 +-
 runtime/base/mutex.cc                     |   2 +-
 runtime/common_throws.cc                  |   4 +-
 runtime/compiled_method.cc                |   6 +-
 runtime/dex_file.cc                       |   2 +-
 runtime/dex_instruction.h                 |   2 +-
 runtime/gc/space/large_object_space.cc    |   5 +-
 runtime/interpreter/interpreter.cc        |   2 +-
 runtime/mirror/abstract_method.cc         |   2 +-
 runtime/mirror/class-inl.h                |   6 +-
 runtime/native/dalvik_system_Zygote.cc    |   2 +-
 runtime/oat/runtime/support_jni.cc        |   2 +-
 runtime/oat/runtime/x86/context_x86.cc    |   2 +-
 runtime/oat_file.cc                       |   3 +-
 runtime/runtime.cc                        |   2 +-
 runtime/thread_pool.cc                    |   4 +-
 58 files changed, 719 insertions(+), 1410 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/Android.mk b/Android.mk
index 5a28723e8e..4e4928c022 100644
--- a/Android.mk
+++ b/Android.mk
@@ -334,7 +334,7 @@ endif
 .PHONY: cpplint-art
 cpplint-art:
 	./art/tools/cpplint.py \
-	    --filter=-,+build/header_guard, \
+	    --filter=-,+build/header_guard,+whitespace/braces \
 	    $(shell find art -name *.h -o -name *$(ART_CPP_EXTENSION))
 
 # "mm cpplint-art-aspirational" to see warnings we would like to fix
diff --git a/compiler/dex/arena_allocator.h b/compiler/dex/arena_allocator.h
index 23d6b9f06b..cc81e50c5b 100644
--- a/compiler/dex/arena_allocator.h
+++ b/compiler/dex/arena_allocator.h
@@ -86,7 +86,7 @@ struct MemStats {
      void Dump(std::ostream& os) const {
        arena_.DumpMemStats(os);
      }
-     MemStats(const ArenaAllocator &arena) : arena_(arena){};
+     MemStats(const ArenaAllocator &arena) : arena_(arena) {};
   private:
     const ArenaAllocator &arena_;
 }; // MemStats
diff --git a/compiler/dex/arena_bit_vector.cc b/compiler/dex/arena_bit_vector.cc
index 1fbf7740ac..724fdf81c7 100644
--- a/compiler/dex/arena_bit_vector.cc
+++ b/compiler/dex/arena_bit_vector.cc
@@ -114,8 +114,7 @@ void ArenaBitVector::Union(const ArenaBitVector* src) {
 }
 
 // Count the number of bits that are set.
-int ArenaBitVector::NumSetBits()
-{
+int ArenaBitVector::NumSetBits() {
   unsigned int count = 0;
 
   for (unsigned int word = 0; word < storage_size_; word++) {
@@ -129,8 +128,7 @@ int ArenaBitVector::NumSetBits()
  * since there might be unused bits - setting those to one will confuse the
  * iterator.
  */
-void ArenaBitVector::SetInitialBits(unsigned int num_bits)
-{
+void ArenaBitVector::SetInitialBits(unsigned int num_bits) {
   DCHECK_LE(((num_bits + 31) >> 5), storage_size_);
   unsigned int idx;
   for (idx = 0; idx < (num_bits >> 5); idx++) {
diff --git a/compiler/dex/dataflow_iterator.h b/compiler/dex/dataflow_iterator.h
index 4c112f9678..19468698f9 100644
--- a/compiler/dex/dataflow_iterator.h
+++ b/compiler/dex/dataflow_iterator.h
@@ -42,7 +42,7 @@ namespace art {
   class DataflowIterator {
     public:
 
-      virtual ~DataflowIterator(){}
+      virtual ~DataflowIterator() {}
 
       // Return the next BasicBlock* to visit.
       BasicBlock* Next() {
diff --git a/compiler/dex/frontend.cc b/compiler/dex/frontend.cc
index 746d475a9b..2d7c973859 100644
--- a/compiler/dex/frontend.cc
+++ b/compiler/dex/frontend.cc
@@ -220,7 +220,7 @@ static CompiledMethod* CompileMethod(CompilerDriver& compiler,
                                        llvm_compilation_unit));
   } else
 #endif
-  {
+  { // NOLINT(whitespace/braces)
     switch (compiler.GetInstructionSet()) {
       case kThumb2:
         cu->cg.reset(ArmCodeGenerator(cu.get(), cu->mir_graph.get(), &cu->arena)); break;
diff --git a/compiler/dex/local_value_numbering.cc b/compiler/dex/local_value_numbering.cc
index ec5ab5db38..b783f3ed52 100644
--- a/compiler/dex/local_value_numbering.cc
+++ b/compiler/dex/local_value_numbering.cc
@@ -19,8 +19,7 @@
 namespace art {
 
 
-uint16_t LocalValueNumbering::GetValueNumber(MIR* mir)
-{
+uint16_t LocalValueNumbering::GetValueNumber(MIR* mir) {
   uint16_t res = NO_VALUE;
   uint16_t opcode = mir->dalvikInsn.opcode;
   switch (opcode) {
diff --git a/compiler/dex/mir_dataflow.cc b/compiler/dex/mir_dataflow.cc
index 6c152d2fb3..9632388e19 100644
--- a/compiler/dex/mir_dataflow.cc
+++ b/compiler/dex/mir_dataflow.cc
@@ -849,8 +849,7 @@ int MIRGraph::SRegToVReg(int ssa_reg) const {
 
 /* Any register that is used before being defined is considered live-in */
 void MIRGraph::HandleLiveInUse(ArenaBitVector* use_v, ArenaBitVector* def_v,
-                            ArenaBitVector* live_in_v, int dalvik_reg_id)
-{
+                            ArenaBitVector* live_in_v, int dalvik_reg_id) {
   use_v->SetBit(dalvik_reg_id);
   if (!def_v->IsBitSet(dalvik_reg_id)) {
     live_in_v->SetBit(dalvik_reg_id);
@@ -858,8 +857,7 @@ void MIRGraph::HandleLiveInUse(ArenaBitVector* use_v, ArenaBitVector* def_v,
 }
 
 /* Mark a reg as being defined */
-void MIRGraph::HandleDef(ArenaBitVector* def_v, int dalvik_reg_id)
-{
+void MIRGraph::HandleDef(ArenaBitVector* def_v, int dalvik_reg_id) {
   def_v->SetBit(dalvik_reg_id);
 }
 
@@ -867,8 +865,7 @@ void MIRGraph::HandleDef(ArenaBitVector* def_v, int dalvik_reg_id)
  * Find out live-in variables for natural loops. Variables that are live-in in
  * the main loop body are considered to be defined in the entry block.
  */
-bool MIRGraph::FindLocalLiveIn(BasicBlock* bb)
-{
+bool MIRGraph::FindLocalLiveIn(BasicBlock* bb) {
   MIR* mir;
   ArenaBitVector *use_v, *def_v, *live_in_v;
 
@@ -925,8 +922,7 @@ bool MIRGraph::FindLocalLiveIn(BasicBlock* bb)
   return true;
 }
 
-int MIRGraph::AddNewSReg(int v_reg)
-{
+int MIRGraph::AddNewSReg(int v_reg) {
   // Compiler temps always have a subscript of 0
   int subscript = (v_reg < 0) ? 0 : ++ssa_last_defs_[v_reg];
   int ssa_reg = GetNumSSARegs();
@@ -938,15 +934,13 @@ int MIRGraph::AddNewSReg(int v_reg)
 }
 
 /* Find out the latest SSA register for a given Dalvik register */
-void MIRGraph::HandleSSAUse(int* uses, int dalvik_reg, int reg_index)
-{
+void MIRGraph::HandleSSAUse(int* uses, int dalvik_reg, int reg_index) {
   DCHECK((dalvik_reg >= 0) && (dalvik_reg < cu_->num_dalvik_registers));
   uses[reg_index] = vreg_to_ssa_map_[dalvik_reg];
 }
 
 /* Setup a new SSA register for a given Dalvik register */
-void MIRGraph::HandleSSADef(int* defs, int dalvik_reg, int reg_index)
-{
+void MIRGraph::HandleSSADef(int* defs, int dalvik_reg, int reg_index) {
   DCHECK((dalvik_reg >= 0) && (dalvik_reg < cu_->num_dalvik_registers));
   int ssa_reg = AddNewSReg(dalvik_reg);
   vreg_to_ssa_map_[dalvik_reg] = ssa_reg;
@@ -954,8 +948,7 @@ void MIRGraph::HandleSSADef(int* defs, int dalvik_reg, int reg_index)
 }
 
 /* Look up new SSA names for format_35c instructions */
-void MIRGraph::DataFlowSSAFormat35C(MIR* mir)
-{
+void MIRGraph::DataFlowSSAFormat35C(MIR* mir) {
   DecodedInstruction *d_insn = &mir->dalvikInsn;
   int num_uses = d_insn->vA;
   int i;
@@ -973,8 +966,7 @@ void MIRGraph::DataFlowSSAFormat35C(MIR* mir)
 }
 
 /* Look up new SSA names for format_3rc instructions */
-void MIRGraph::DataFlowSSAFormat3RC(MIR* mir)
-{
+void MIRGraph::DataFlowSSAFormat3RC(MIR* mir) {
   DecodedInstruction *d_insn = &mir->dalvikInsn;
   int num_uses = d_insn->vA;
   int i;
@@ -992,8 +984,7 @@ void MIRGraph::DataFlowSSAFormat3RC(MIR* mir)
 }
 
 /* Entry function to convert a block into SSA representation */
-bool MIRGraph::DoSSAConversion(BasicBlock* bb)
-{
+bool MIRGraph::DoSSAConversion(BasicBlock* bb) {
   MIR* mir;
 
   if (bb->data_flow_info == NULL) return false;
@@ -1127,8 +1118,7 @@ bool MIRGraph::DoSSAConversion(BasicBlock* bb)
 }
 
 /* Setup the basic data structures for SSA conversion */
-void MIRGraph::CompilerInitializeSSAConversion()
-{
+void MIRGraph::CompilerInitializeSSAConversion() {
   size_t num_dalvik_reg = cu_->num_dalvik_registers;
 
   ssa_base_vregs_ = new (arena_) GrowableArray<int>(arena_, num_dalvik_reg + GetDefCount() + 128,
@@ -1196,8 +1186,7 @@ void MIRGraph::CompilerInitializeSSAConversion()
  * and attempting to do would involve more complexity than it's
  * worth.
  */
-bool MIRGraph::InvokeUsesMethodStar(MIR* mir)
-{
+bool MIRGraph::InvokeUsesMethodStar(MIR* mir) {
   InvokeType type;
   Instruction::Code opcode = mir->dalvikInsn.opcode;
   switch (opcode) {
@@ -1246,8 +1235,7 @@ bool MIRGraph::InvokeUsesMethodStar(MIR* mir)
  * counts explicitly used s_regs.  A later phase will add implicit
  * counts for things such as Method*, null-checked references, etc.
  */
-bool MIRGraph::CountUses(struct BasicBlock* bb)
-{
+bool MIRGraph::CountUses(struct BasicBlock* bb) {
   if (bb->block_type != kDalvikByteCode) {
     return false;
   }
@@ -1286,8 +1274,7 @@ bool MIRGraph::CountUses(struct BasicBlock* bb)
   return false;
 }
 
-void MIRGraph::MethodUseCount()
-{
+void MIRGraph::MethodUseCount() {
   // Now that we know, resize the lists.
   int num_ssa_regs = GetNumSSARegs();
   use_counts_.Resize(num_ssa_regs + 32);
@@ -1307,8 +1294,7 @@ void MIRGraph::MethodUseCount()
 }
 
 /* Verify if all the successor is connected with all the claimed predecessors */
-bool MIRGraph::VerifyPredInfo(BasicBlock* bb)
-{
+bool MIRGraph::VerifyPredInfo(BasicBlock* bb) {
   GrowableArray<BasicBlock*>::Iterator iter(bb->predecessors);
 
   while (true) {
@@ -1343,8 +1329,7 @@ bool MIRGraph::VerifyPredInfo(BasicBlock* bb)
   return true;
 }
 
-void MIRGraph::VerifyDataflow()
-{
+void MIRGraph::VerifyDataflow() {
     /* Verify if all blocks are connected as claimed */
   AllNodesIterator iter(this, false /* not iterative */);
   for (BasicBlock* bb = iter.Next(); bb != NULL; bb = iter.Next()) {
diff --git a/compiler/dex/mir_graph.cc b/compiler/dex/mir_graph.cc
index 11e100dc61..ef9955e585 100644
--- a/compiler/dex/mir_graph.cc
+++ b/compiler/dex/mir_graph.cc
@@ -107,8 +107,7 @@ MIRGraph::MIRGraph(CompilationUnit* cu, ArenaAllocator* arena)
       method_sreg_(0),
       attributes_(METHOD_IS_LEAF),  // Start with leaf assumption, change on encountering invoke.
       checkstats_(NULL),
-      arena_(arena)
-      {
+      arena_(arena) {
   try_block_addr_ = new (arena_) ArenaBitVector(arena_, 0, true /* expandable */);
 }
 
@@ -129,8 +128,7 @@ bool MIRGraph::ContentIsInsn(const uint16_t* code_ptr) {
 /*
  * Parse an instruction, return the length of the instruction
  */
-int MIRGraph::ParseInsn(const uint16_t* code_ptr, DecodedInstruction* decoded_instruction)
-{
+int MIRGraph::ParseInsn(const uint16_t* code_ptr, DecodedInstruction* decoded_instruction) {
   // Don't parse instruction data
   if (!ContentIsInsn(code_ptr)) {
     return 0;
@@ -145,8 +143,7 @@ int MIRGraph::ParseInsn(const uint16_t* code_ptr, DecodedInstruction* decoded_in
 
 /* Split an existing block from the specified code offset into two */
 BasicBlock* MIRGraph::SplitBlock(unsigned int code_offset,
-                                 BasicBlock* orig_block, BasicBlock** immed_pred_block_p)
-{
+                                 BasicBlock* orig_block, BasicBlock** immed_pred_block_p) {
   MIR* insn = orig_block->first_mir_insn;
   while (insn) {
     if (insn->offset == code_offset) break;
@@ -224,8 +221,7 @@ BasicBlock* MIRGraph::SplitBlock(unsigned int code_offset,
  * Utilizes a map for fast lookup of the typical cases.
  */
 BasicBlock* MIRGraph::FindBlock(unsigned int code_offset, bool split, bool create,
-                                BasicBlock** immed_pred_block_p)
-{
+                                BasicBlock** immed_pred_block_p) {
   BasicBlock* bb;
   unsigned int i;
   SafeMap<unsigned int, BasicBlock*>::iterator it;
@@ -260,8 +256,7 @@ BasicBlock* MIRGraph::FindBlock(unsigned int code_offset, bool split, bool creat
 }
 
 /* Identify code range in try blocks and set up the empty catch blocks */
-void MIRGraph::ProcessTryCatchBlocks()
-{
+void MIRGraph::ProcessTryCatchBlocks() {
   int tries_size = current_code_item_->tries_size_;
   int offset;
 
@@ -296,8 +291,7 @@ void MIRGraph::ProcessTryCatchBlocks()
 /* Process instructions with the kBranch flag */
 BasicBlock* MIRGraph::ProcessCanBranch(BasicBlock* cur_block, MIR* insn, int cur_offset, int width,
                                        int flags, const uint16_t* code_ptr,
-                                       const uint16_t* code_end)
-{
+                                       const uint16_t* code_end) {
   int target = cur_offset;
   switch (insn->dalvikInsn.opcode) {
     case Instruction::GOTO:
@@ -365,8 +359,7 @@ BasicBlock* MIRGraph::ProcessCanBranch(BasicBlock* cur_block, MIR* insn, int cur
 
 /* Process instructions with the kSwitch flag */
 void MIRGraph::ProcessCanSwitch(BasicBlock* cur_block, MIR* insn, int cur_offset, int width,
-                                int flags)
-{
+                                int flags) {
   const uint16_t* switch_data =
       reinterpret_cast<const uint16_t*>(GetCurrentInsns() + cur_offset + insn->dalvikInsn.vB);
   int size;
@@ -443,8 +436,7 @@ void MIRGraph::ProcessCanSwitch(BasicBlock* cur_block, MIR* insn, int cur_offset
 /* Process instructions with the kThrow flag */
 BasicBlock* MIRGraph::ProcessCanThrow(BasicBlock* cur_block, MIR* insn, int cur_offset, int width,
                                       int flags, ArenaBitVector* try_block_addr,
-                                      const uint16_t* code_ptr, const uint16_t* code_end)
-{
+                                      const uint16_t* code_ptr, const uint16_t* code_end) {
   bool in_try_block = try_block_addr->IsBitSet(cur_offset);
 
   /* In try block */
@@ -483,7 +475,7 @@ BasicBlock* MIRGraph::ProcessCanThrow(BasicBlock* cur_block, MIR* insn, int cur_
     eh_block->predecessors->Insert(cur_block);
   }
 
-  if (insn->dalvikInsn.opcode == Instruction::THROW){
+  if (insn->dalvikInsn.opcode == Instruction::THROW) {
     cur_block->explicit_throw = true;
     if ((code_ptr < code_end) && ContentIsInsn(code_ptr)) {
       // Force creation of new block following THROW via side-effect
@@ -529,8 +521,7 @@ BasicBlock* MIRGraph::ProcessCanThrow(BasicBlock* cur_block, MIR* insn, int cur_
 /* Parse a Dex method and insert it into the MIRGraph at the current insert point. */
 void MIRGraph::InlineMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
                            InvokeType invoke_type, uint32_t class_def_idx,
-                           uint32_t method_idx, jobject class_loader, const DexFile& dex_file)
-{
+                           uint32_t method_idx, jobject class_loader, const DexFile& dex_file) {
   current_code_item_ = code_item;
   method_stack_.push_back(std::make_pair(current_method_, current_offset_));
   current_method_ = m_units_.size();
@@ -705,8 +696,7 @@ void MIRGraph::InlineMethod(const DexFile::CodeItem* code_item, uint32_t access_
   }
 }
 
-void MIRGraph::ShowOpcodeStats()
-{
+void MIRGraph::ShowOpcodeStats() {
   DCHECK(opcode_count_ != NULL);
   LOG(INFO) << "Opcode Count";
   for (int i = 0; i < kNumPackedOpcodes; i++) {
@@ -719,8 +709,7 @@ void MIRGraph::ShowOpcodeStats()
 
 // TODO: use a configurable base prefix, and adjust callers to supply pass name.
 /* Dump the CFG into a DOT graph */
-void MIRGraph::DumpCFG(const char* dir_prefix, bool all_blocks)
-{
+void MIRGraph::DumpCFG(const char* dir_prefix, bool all_blocks) {
   FILE* file;
   std::string fname(PrettyMethod(cu_->method_idx, *cu_->dex_file));
   ReplaceSpecialChars(fname);
@@ -849,8 +838,7 @@ void MIRGraph::DumpCFG(const char* dir_prefix, bool all_blocks)
 }
 
 /* Insert an MIR instruction to the end of a basic block */
-void MIRGraph::AppendMIR(BasicBlock* bb, MIR* mir)
-{
+void MIRGraph::AppendMIR(BasicBlock* bb, MIR* mir) {
   if (bb->first_mir_insn == NULL) {
     DCHECK(bb->last_mir_insn == NULL);
     bb->last_mir_insn = bb->first_mir_insn = mir;
@@ -864,8 +852,7 @@ void MIRGraph::AppendMIR(BasicBlock* bb, MIR* mir)
 }
 
 /* Insert an MIR instruction to the head of a basic block */
-void MIRGraph::PrependMIR(BasicBlock* bb, MIR* mir)
-{
+void MIRGraph::PrependMIR(BasicBlock* bb, MIR* mir) {
   if (bb->first_mir_insn == NULL) {
     DCHECK(bb->last_mir_insn == NULL);
     bb->last_mir_insn = bb->first_mir_insn = mir;
@@ -879,8 +866,7 @@ void MIRGraph::PrependMIR(BasicBlock* bb, MIR* mir)
 }
 
 /* Insert a MIR instruction after the specified MIR */
-void MIRGraph::InsertMIRAfter(BasicBlock* bb, MIR* current_mir, MIR* new_mir)
-{
+void MIRGraph::InsertMIRAfter(BasicBlock* bb, MIR* current_mir, MIR* new_mir) {
   new_mir->prev = current_mir;
   new_mir->next = current_mir->next;
   current_mir->next = new_mir;
@@ -894,8 +880,7 @@ void MIRGraph::InsertMIRAfter(BasicBlock* bb, MIR* current_mir, MIR* new_mir)
   }
 }
 
-char* MIRGraph::GetDalvikDisassembly(const MIR* mir)
-{
+char* MIRGraph::GetDalvikDisassembly(const MIR* mir) {
   DecodedInstruction insn = mir->dalvikInsn;
   std::string str;
   int flags = 0;
@@ -1024,8 +1009,7 @@ char* MIRGraph::GetDalvikDisassembly(const MIR* mir)
 }
 
 /* Turn method name into a legal Linux file name */
-void MIRGraph::ReplaceSpecialChars(std::string& str)
-{
+void MIRGraph::ReplaceSpecialChars(std::string& str) {
   static const struct { const char before; const char after; } match[] =
       {{'/','-'}, {';','#'}, {' ','#'}, {'$','+'},
        {'(','@'}, {')','@'}, {'<','='}, {'>','='}};
@@ -1034,8 +1018,7 @@ void MIRGraph::ReplaceSpecialChars(std::string& str)
   }
 }
 
-std::string MIRGraph::GetSSAName(int ssa_reg)
-{
+std::string MIRGraph::GetSSAName(int ssa_reg) {
   // TODO: This value is needed for LLVM and debugging. Currently, we compute this and then copy to
   //       the arena. We should be smarter and just place straight into the arena, or compute the
   //       value more lazily.
@@ -1043,8 +1026,7 @@ std::string MIRGraph::GetSSAName(int ssa_reg)
 }
 
 // Similar to GetSSAName, but if ssa name represents an immediate show that as well.
-std::string MIRGraph::GetSSANameWithConst(int ssa_reg, bool singles_only)
-{
+std::string MIRGraph::GetSSANameWithConst(int ssa_reg, bool singles_only) {
   if (reg_location_ == NULL) {
     // Pre-SSA - just use the standard name
     return GetSSAName(ssa_reg);
@@ -1062,8 +1044,7 @@ std::string MIRGraph::GetSSANameWithConst(int ssa_reg, bool singles_only)
   }
 }
 
-void MIRGraph::GetBlockName(BasicBlock* bb, char* name)
-{
+void MIRGraph::GetBlockName(BasicBlock* bb, char* name) {
   switch (bb->block_type) {
     case kEntryBlock:
       snprintf(name, BLOCK_NAME_LEN, "entry_%d", bb->id);
@@ -1084,16 +1065,14 @@ void MIRGraph::GetBlockName(BasicBlock* bb, char* name)
   }
 }
 
-const char* MIRGraph::GetShortyFromTargetIdx(int target_idx)
-{
+const char* MIRGraph::GetShortyFromTargetIdx(int target_idx) {
   // FIXME: use current code unit for inline support.
   const DexFile::MethodId& method_id = cu_->dex_file->GetMethodId(target_idx);
   return cu_->dex_file->GetShorty(method_id.proto_idx_);
 }
 
 /* Debug Utility - dump a compilation unit */
-void MIRGraph::DumpMIRGraph()
-{
+void MIRGraph::DumpMIRGraph() {
   BasicBlock* bb;
   const char* block_type_names[] = {
     "Entry Block",
@@ -1135,8 +1114,7 @@ void MIRGraph::DumpMIRGraph()
  * MOVE_RESULT and incorporate it into the invoke.
  */
 CallInfo* MIRGraph::NewMemCallInfo(BasicBlock* bb, MIR* mir, InvokeType type,
-                                  bool is_range)
-{
+                                  bool is_range) {
   CallInfo* info = static_cast<CallInfo*>(arena_->NewMem(sizeof(CallInfo), true,
                                                          ArenaAllocator::kAllocMisc));
   MIR* move_result_mir = FindMoveResult(bb, mir);
@@ -1163,8 +1141,7 @@ CallInfo* MIRGraph::NewMemCallInfo(BasicBlock* bb, MIR* mir, InvokeType type,
 }
 
 // Allocate a new basic block.
-BasicBlock* MIRGraph::NewMemBB(BBType block_type, int block_id)
-{
+BasicBlock* MIRGraph::NewMemBB(BBType block_type, int block_id) {
   BasicBlock* bb = static_cast<BasicBlock*>(arena_->NewMem(sizeof(BasicBlock), true,
                                                            ArenaAllocator::kAllocBB));
   bb->block_type = block_type;
diff --git a/compiler/dex/mir_graph.h b/compiler/dex/mir_graph.h
index a40fa97ad5..f86e13016d 100644
--- a/compiler/dex/mir_graph.h
+++ b/compiler/dex/mir_graph.h
@@ -452,43 +452,37 @@ class MIRGraph {
     return ssa_subscripts_->Get(ssa_reg);
   }
 
-  RegLocation GetRawSrc(MIR* mir, int num)
-  {
+  RegLocation GetRawSrc(MIR* mir, int num) {
     DCHECK(num < mir->ssa_rep->num_uses);
     RegLocation res = reg_location_[mir->ssa_rep->uses[num]];
     return res;
   }
 
-  RegLocation GetRawDest(MIR* mir)
-  {
+  RegLocation GetRawDest(MIR* mir) {
     DCHECK_GT(mir->ssa_rep->num_defs, 0);
     RegLocation res = reg_location_[mir->ssa_rep->defs[0]];
     return res;
   }
 
-  RegLocation GetDest(MIR* mir)
-  {
+  RegLocation GetDest(MIR* mir) {
     RegLocation res = GetRawDest(mir);
     DCHECK(!res.wide);
     return res;
   }
 
-  RegLocation GetSrc(MIR* mir, int num)
-  {
+  RegLocation GetSrc(MIR* mir, int num) {
     RegLocation res = GetRawSrc(mir, num);
     DCHECK(!res.wide);
     return res;
   }
 
-  RegLocation GetDestWide(MIR* mir)
-  {
+  RegLocation GetDestWide(MIR* mir) {
     RegLocation res = GetRawDest(mir);
     DCHECK(res.wide);
     return res;
   }
 
-  RegLocation GetSrcWide(MIR* mir, int low)
-  {
+  RegLocation GetSrcWide(MIR* mir, int low) {
     RegLocation res = GetRawSrc(mir, low);
     DCHECK(res.wide);
     return res;
diff --git a/compiler/dex/mir_optimization.cc b/compiler/dex/mir_optimization.cc
index 6b8f3f0915..306dbc7b6b 100644
--- a/compiler/dex/mir_optimization.cc
+++ b/compiler/dex/mir_optimization.cc
@@ -20,27 +20,23 @@
 
 namespace art {
 
-static unsigned int Predecessors(BasicBlock* bb)
-{
+static unsigned int Predecessors(BasicBlock* bb) {
   return bb->predecessors->Size();
 }
 
 /* Setup a constant value for opcodes thare have the DF_SETS_CONST attribute */
-void MIRGraph::SetConstant(int32_t ssa_reg, int value)
-{
+void MIRGraph::SetConstant(int32_t ssa_reg, int value) {
   is_constant_v_->SetBit(ssa_reg);
   constant_values_[ssa_reg] = value;
 }
 
-void MIRGraph::SetConstantWide(int ssa_reg, int64_t value)
-{
+void MIRGraph::SetConstantWide(int ssa_reg, int64_t value) {
   is_constant_v_->SetBit(ssa_reg);
   constant_values_[ssa_reg] = Low32Bits(value);
   constant_values_[ssa_reg + 1] = High32Bits(value);
 }
 
-void MIRGraph::DoConstantPropogation(BasicBlock* bb)
-{
+void MIRGraph::DoConstantPropogation(BasicBlock* bb) {
   MIR* mir;
 
   for (mir = bb->first_mir_insn; mir != NULL; mir = mir->next) {
@@ -96,8 +92,7 @@ void MIRGraph::DoConstantPropogation(BasicBlock* bb)
   /* TODO: implement code to handle arithmetic operations */
 }
 
-void MIRGraph::PropagateConstants()
-{
+void MIRGraph::PropagateConstants() {
   is_constant_v_ = new (arena_) ArenaBitVector(arena_, GetNumSSARegs(), false);
   constant_values_ = static_cast<int*>(arena_->NewMem(sizeof(int) * GetNumSSARegs(), true,
                                                       ArenaAllocator::kAllocDFInfo));
@@ -108,8 +103,7 @@ void MIRGraph::PropagateConstants()
 }
 
 /* Advance to next strictly dominated MIR node in an extended basic block */
-static MIR* AdvanceMIR(BasicBlock** p_bb, MIR* mir)
-{
+static MIR* AdvanceMIR(BasicBlock** p_bb, MIR* mir) {
   BasicBlock* bb = *p_bb;
   if (mir != NULL) {
     mir = mir->next;
@@ -133,8 +127,7 @@ static MIR* AdvanceMIR(BasicBlock** p_bb, MIR* mir)
  * opcodes or incoming arcs.  However, if the result of the invoke is not
  * used, a move-result may not be present.
  */
-MIR* MIRGraph::FindMoveResult(BasicBlock* bb, MIR* mir)
-{
+MIR* MIRGraph::FindMoveResult(BasicBlock* bb, MIR* mir) {
   BasicBlock* tbb = bb;
   mir = AdvanceMIR(&tbb, mir);
   while (mir != NULL) {
@@ -154,8 +147,7 @@ MIR* MIRGraph::FindMoveResult(BasicBlock* bb, MIR* mir)
   return mir;
 }
 
-static BasicBlock* NextDominatedBlock(BasicBlock* bb)
-{
+static BasicBlock* NextDominatedBlock(BasicBlock* bb) {
   if (bb->block_type == kDead) {
     return NULL;
   }
@@ -169,8 +161,7 @@ static BasicBlock* NextDominatedBlock(BasicBlock* bb)
   return bb;
 }
 
-static MIR* FindPhi(BasicBlock* bb, int ssa_name)
-{
+static MIR* FindPhi(BasicBlock* bb, int ssa_name) {
   for (MIR* mir = bb->first_mir_insn; mir != NULL; mir = mir->next) {
     if (static_cast<int>(mir->dalvikInsn.opcode) == kMirOpPhi) {
       for (int i = 0; i < mir->ssa_rep->num_uses; i++) {
@@ -183,8 +174,7 @@ static MIR* FindPhi(BasicBlock* bb, int ssa_name)
   return NULL;
 }
 
-static SelectInstructionKind SelectKind(MIR* mir)
-{
+static SelectInstructionKind SelectKind(MIR* mir) {
   switch (mir->dalvikInsn.opcode) {
     case Instruction::MOVE:
     case Instruction::MOVE_OBJECT:
@@ -206,15 +196,13 @@ static SelectInstructionKind SelectKind(MIR* mir)
   return kSelectNone;
 }
 
-int MIRGraph::GetSSAUseCount(int s_reg)
-{
+int MIRGraph::GetSSAUseCount(int s_reg) {
   return raw_use_counts_.Get(s_reg);
 }
 
 
 /* Do some MIR-level extended basic block optimizations */
-bool MIRGraph::BasicBlockOpt(BasicBlock* bb)
-{
+bool MIRGraph::BasicBlockOpt(BasicBlock* bb) {
   if (bb->block_type == kDead) {
     return true;
   }
@@ -474,8 +462,7 @@ bool MIRGraph::BasicBlockOpt(BasicBlock* bb)
   return true;
 }
 
-void MIRGraph::NullCheckEliminationInit(struct BasicBlock* bb)
-{
+void MIRGraph::NullCheckEliminationInit(struct BasicBlock* bb) {
   if (bb->data_flow_info != NULL) {
     bb->data_flow_info->ending_null_check_v =
         new (arena_) ArenaBitVector(arena_, GetNumSSARegs(), false, kBitMapNullCheck);
@@ -483,8 +470,7 @@ void MIRGraph::NullCheckEliminationInit(struct BasicBlock* bb)
 }
 
 /* Collect stats on number of checks removed */
-void MIRGraph::CountChecks(struct BasicBlock* bb)
-{
+void MIRGraph::CountChecks(struct BasicBlock* bb) {
   if (bb->data_flow_info != NULL) {
     for (MIR* mir = bb->first_mir_insn; mir != NULL; mir = mir->next) {
       if (mir->ssa_rep == NULL) {
@@ -508,8 +494,7 @@ void MIRGraph::CountChecks(struct BasicBlock* bb)
 }
 
 /* Try to make common case the fallthrough path */
-static bool LayoutBlocks(struct BasicBlock* bb)
-{
+static bool LayoutBlocks(struct BasicBlock* bb) {
   // TODO: For now, just looking for direct throws.  Consider generalizing for profile feedback
   if (!bb->explicit_throw) {
     return false;
@@ -556,8 +541,7 @@ static bool LayoutBlocks(struct BasicBlock* bb)
 }
 
 /* Combine any basic blocks terminated by instructions that we now know can't throw */
-bool MIRGraph::CombineBlocks(struct BasicBlock* bb)
-{
+bool MIRGraph::CombineBlocks(struct BasicBlock* bb) {
   // Loop here to allow combining a sequence of blocks
   while (true) {
     // Check termination conditions
@@ -625,8 +609,7 @@ bool MIRGraph::CombineBlocks(struct BasicBlock* bb)
 }
 
 /* Eliminate unnecessary null checks for a basic block. */
-bool MIRGraph::EliminateNullChecks(struct BasicBlock* bb)
-{
+bool MIRGraph::EliminateNullChecks(struct BasicBlock* bb) {
   if (bb->data_flow_info == NULL) return false;
 
   /*
@@ -770,8 +753,7 @@ bool MIRGraph::EliminateNullChecks(struct BasicBlock* bb)
   return changed;
 }
 
-void MIRGraph::NullCheckElimination()
-{
+void MIRGraph::NullCheckElimination() {
   if (!(cu_->disable_opt & (1 << kNullCheckElimination))) {
     DCHECK(temp_ssa_register_v_ != NULL);
     AllNodesIterator iter(this, false /* not iterative */);
@@ -789,8 +771,7 @@ void MIRGraph::NullCheckElimination()
   }
 }
 
-void MIRGraph::BasicBlockCombine()
-{
+void MIRGraph::BasicBlockCombine() {
   PreOrderDfsIterator iter(this, false /* not iterative */);
   for (BasicBlock* bb = iter.Next(); bb != NULL; bb = iter.Next()) {
     CombineBlocks(bb);
@@ -800,8 +781,7 @@ void MIRGraph::BasicBlockCombine()
   }
 }
 
-void MIRGraph::CodeLayout()
-{
+void MIRGraph::CodeLayout() {
   if (cu_->enable_debug & (1 << kDebugVerifyDataflow)) {
     VerifyDataflow();
   }
@@ -814,8 +794,7 @@ void MIRGraph::CodeLayout()
   }
 }
 
-void MIRGraph::DumpCheckStats()
-{
+void MIRGraph::DumpCheckStats() {
   Checkstats* stats =
       static_cast<Checkstats*>(arena_->NewMem(sizeof(Checkstats), true,
                                               ArenaAllocator::kAllocDFInfo));
@@ -840,8 +819,7 @@ void MIRGraph::DumpCheckStats()
   }
 }
 
-bool MIRGraph::BuildExtendedBBList(struct BasicBlock* bb)
-{
+bool MIRGraph::BuildExtendedBBList(struct BasicBlock* bb) {
   if (bb->visited) return false;
   if (!((bb->block_type == kEntryBlock) || (bb->block_type == kDalvikByteCode)
       || (bb->block_type == kExitBlock))) {
@@ -871,8 +849,7 @@ bool MIRGraph::BuildExtendedBBList(struct BasicBlock* bb)
 }
 
 
-void MIRGraph::BasicBlockOptimization()
-{
+void MIRGraph::BasicBlockOptimization() {
   if (!(cu_->disable_opt & (1 << kBBOpt))) {
     DCHECK_EQ(cu_->num_compiler_temps, 0);
     ClearAllVisitedFlags();
diff --git a/compiler/dex/portable/mir_to_gbc.cc b/compiler/dex/portable/mir_to_gbc.cc
index 2be1ef435b..4317d1e354 100644
--- a/compiler/dex/portable/mir_to_gbc.cc
+++ b/compiler/dex/portable/mir_to_gbc.cc
@@ -42,18 +42,15 @@ const char kCatchBlock = 'C';
 
 namespace art {
 
-::llvm::BasicBlock* MirConverter::GetLLVMBlock(int id)
-{
+::llvm::BasicBlock* MirConverter::GetLLVMBlock(int id) {
   return id_to_block_map_.Get(id);
 }
 
-::llvm::Value* MirConverter::GetLLVMValue(int s_reg)
-{
+::llvm::Value* MirConverter::GetLLVMValue(int s_reg) {
   return llvm_values_.Get(s_reg);
 }
 
-void MirConverter::SetVregOnValue(::llvm::Value* val, int s_reg)
-{
+void MirConverter::SetVregOnValue(::llvm::Value* val, int s_reg) {
   // Set vreg for debugging
   art::llvm::IntrinsicHelper::IntrinsicId id = art::llvm::IntrinsicHelper::SetVReg;
   ::llvm::Function* func = intrinsic_helper_->GetIntrinsicFunction(id);
@@ -64,8 +61,7 @@ void MirConverter::SetVregOnValue(::llvm::Value* val, int s_reg)
 }
 
 // Replace the placeholder value with the real definition
-void MirConverter::DefineValueOnly(::llvm::Value* val, int s_reg)
-{
+void MirConverter::DefineValueOnly(::llvm::Value* val, int s_reg) {
   ::llvm::Value* placeholder = GetLLVMValue(s_reg);
   if (placeholder == NULL) {
     // This can happen on instruction rewrite on verification failure
@@ -81,14 +77,12 @@ void MirConverter::DefineValueOnly(::llvm::Value* val, int s_reg)
 
 }
 
-void MirConverter::DefineValue(::llvm::Value* val, int s_reg)
-{
+void MirConverter::DefineValue(::llvm::Value* val, int s_reg) {
   DefineValueOnly(val, s_reg);
   SetVregOnValue(val, s_reg);
 }
 
-::llvm::Type* MirConverter::LlvmTypeFromLocRec(RegLocation loc)
-{
+::llvm::Type* MirConverter::LlvmTypeFromLocRec(RegLocation loc) {
   ::llvm::Type* res = NULL;
   if (loc.wide) {
     if (loc.fp)
@@ -108,8 +102,7 @@ void MirConverter::DefineValue(::llvm::Value* val, int s_reg)
   return res;
 }
 
-void MirConverter::InitIR()
-{
+void MirConverter::InitIR() {
   if (llvm_info_ == NULL) {
     CompilerTls* tls = cu_->compiler_driver->GetTls();
     CHECK(tls != NULL);
@@ -125,16 +118,14 @@ void MirConverter::InitIR()
   irb_ = llvm_info_->GetIRBuilder();
 }
 
-::llvm::BasicBlock* MirConverter::FindCaseTarget(uint32_t vaddr)
-{
+::llvm::BasicBlock* MirConverter::FindCaseTarget(uint32_t vaddr) {
   BasicBlock* bb = mir_graph_->FindBlock(vaddr);
   DCHECK(bb != NULL);
   return GetLLVMBlock(bb->id);
 }
 
 void MirConverter::ConvertPackedSwitch(BasicBlock* bb,
-                                int32_t table_offset, RegLocation rl_src)
-{
+                                int32_t table_offset, RegLocation rl_src) {
   const Instruction::PackedSwitchPayload* payload =
       reinterpret_cast<const Instruction::PackedSwitchPayload*>(
       cu_->insns + current_dalvik_offset_ + table_offset);
@@ -158,8 +149,7 @@ void MirConverter::ConvertPackedSwitch(BasicBlock* bb,
 }
 
 void MirConverter::ConvertSparseSwitch(BasicBlock* bb,
-                                int32_t table_offset, RegLocation rl_src)
-{
+                                int32_t table_offset, RegLocation rl_src) {
   const Instruction::SparseSwitchPayload* payload =
       reinterpret_cast<const Instruction::SparseSwitchPayload*>(
       cu_->insns + current_dalvik_offset_ + table_offset);
@@ -186,8 +176,7 @@ void MirConverter::ConvertSparseSwitch(BasicBlock* bb,
 }
 
 void MirConverter::ConvertSget(int32_t field_index,
-                        art::llvm::IntrinsicHelper::IntrinsicId id, RegLocation rl_dest)
-{
+                        art::llvm::IntrinsicHelper::IntrinsicId id, RegLocation rl_dest) {
   ::llvm::Constant* field_idx = irb_->getInt32(field_index);
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(id);
   ::llvm::Value* res = irb_->CreateCall(intr, field_idx);
@@ -195,8 +184,7 @@ void MirConverter::ConvertSget(int32_t field_index,
 }
 
 void MirConverter::ConvertSput(int32_t field_index,
-                        art::llvm::IntrinsicHelper::IntrinsicId id, RegLocation rl_src)
-{
+                        art::llvm::IntrinsicHelper::IntrinsicId id, RegLocation rl_src) {
   ::llvm::SmallVector< ::llvm::Value*, 2> args;
   args.push_back(irb_->getInt32(field_index));
   args.push_back(GetLLVMValue(rl_src.orig_sreg));
@@ -204,8 +192,7 @@ void MirConverter::ConvertSput(int32_t field_index,
   irb_->CreateCall(intr, args);
 }
 
-void MirConverter::ConvertFillArrayData(int32_t offset, RegLocation rl_array)
-{
+void MirConverter::ConvertFillArrayData(int32_t offset, RegLocation rl_array) {
   art::llvm::IntrinsicHelper::IntrinsicId id;
   id = art::llvm::IntrinsicHelper::HLFillArrayData;
   ::llvm::SmallVector< ::llvm::Value*, 2> args;
@@ -216,8 +203,7 @@ void MirConverter::ConvertFillArrayData(int32_t offset, RegLocation rl_array)
 }
 
 ::llvm::Value* MirConverter::EmitConst(::llvm::ArrayRef< ::llvm::Value*> src,
-                              RegLocation loc)
-{
+                              RegLocation loc) {
   art::llvm::IntrinsicHelper::IntrinsicId id;
   if (loc.wide) {
     if (loc.fp) {
@@ -238,16 +224,14 @@ void MirConverter::ConvertFillArrayData(int32_t offset, RegLocation rl_array)
   return irb_->CreateCall(intr, src);
 }
 
-void MirConverter::EmitPopShadowFrame()
-{
+void MirConverter::EmitPopShadowFrame() {
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(
       art::llvm::IntrinsicHelper::PopShadowFrame);
   irb_->CreateCall(intr);
 }
 
 ::llvm::Value* MirConverter::EmitCopy(::llvm::ArrayRef< ::llvm::Value*> src,
-                             RegLocation loc)
-{
+                             RegLocation loc) {
   art::llvm::IntrinsicHelper::IntrinsicId id;
   if (loc.wide) {
     if (loc.fp) {
@@ -268,16 +252,14 @@ void MirConverter::EmitPopShadowFrame()
   return irb_->CreateCall(intr, src);
 }
 
-void MirConverter::ConvertMoveException(RegLocation rl_dest)
-{
+void MirConverter::ConvertMoveException(RegLocation rl_dest) {
   ::llvm::Function* func = intrinsic_helper_->GetIntrinsicFunction(
       art::llvm::IntrinsicHelper::GetException);
   ::llvm::Value* res = irb_->CreateCall(func);
   DefineValue(res, rl_dest.orig_sreg);
 }
 
-void MirConverter::ConvertThrow(RegLocation rl_src)
-{
+void MirConverter::ConvertThrow(RegLocation rl_src) {
   ::llvm::Value* src = GetLLVMValue(rl_src.orig_sreg);
   ::llvm::Function* func = intrinsic_helper_->GetIntrinsicFunction(
       art::llvm::IntrinsicHelper::HLThrowException);
@@ -286,8 +268,7 @@ void MirConverter::ConvertThrow(RegLocation rl_src)
 
 void MirConverter::ConvertMonitorEnterExit(int opt_flags,
                                     art::llvm::IntrinsicHelper::IntrinsicId id,
-                                    RegLocation rl_src)
-{
+                                    RegLocation rl_src) {
   ::llvm::SmallVector< ::llvm::Value*, 2> args;
   args.push_back(irb_->getInt32(opt_flags));
   args.push_back(GetLLVMValue(rl_src.orig_sreg));
@@ -296,8 +277,7 @@ void MirConverter::ConvertMonitorEnterExit(int opt_flags,
 }
 
 void MirConverter::ConvertArrayLength(int opt_flags,
-                               RegLocation rl_dest, RegLocation rl_src)
-{
+                               RegLocation rl_dest, RegLocation rl_src) {
   ::llvm::SmallVector< ::llvm::Value*, 2> args;
   args.push_back(irb_->getInt32(opt_flags));
   args.push_back(GetLLVMValue(rl_src.orig_sreg));
@@ -307,8 +287,7 @@ void MirConverter::ConvertArrayLength(int opt_flags,
   DefineValue(res, rl_dest.orig_sreg);
 }
 
-void MirConverter::EmitSuspendCheck()
-{
+void MirConverter::EmitSuspendCheck() {
   art::llvm::IntrinsicHelper::IntrinsicId id =
       art::llvm::IntrinsicHelper::CheckSuspend;
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(id);
@@ -316,8 +295,7 @@ void MirConverter::EmitSuspendCheck()
 }
 
 ::llvm::Value* MirConverter::ConvertCompare(ConditionCode cc,
-                                   ::llvm::Value* src1, ::llvm::Value* src2)
-{
+                                   ::llvm::Value* src1, ::llvm::Value* src2) {
   ::llvm::Value* res = NULL;
   DCHECK_EQ(src1->getType(), src2->getType());
   switch(cc) {
@@ -333,8 +311,7 @@ void MirConverter::EmitSuspendCheck()
 }
 
 void MirConverter::ConvertCompareAndBranch(BasicBlock* bb, MIR* mir,
-                                    ConditionCode cc, RegLocation rl_src1, RegLocation rl_src2)
-{
+                                    ConditionCode cc, RegLocation rl_src1, RegLocation rl_src2) {
   if (bb->taken->start_offset <= mir->offset) {
     EmitSuspendCheck();
   }
@@ -349,8 +326,7 @@ void MirConverter::ConvertCompareAndBranch(BasicBlock* bb, MIR* mir,
 }
 
 void MirConverter::ConvertCompareZeroAndBranch(BasicBlock* bb,
-                                        MIR* mir, ConditionCode cc, RegLocation rl_src1)
-{
+                                        MIR* mir, ConditionCode cc, RegLocation rl_src1) {
   if (bb->taken->start_offset <= mir->offset) {
     EmitSuspendCheck();
   }
@@ -369,8 +345,7 @@ void MirConverter::ConvertCompareZeroAndBranch(BasicBlock* bb,
 }
 
 ::llvm::Value* MirConverter::GenDivModOp(bool is_div, bool is_long,
-                                ::llvm::Value* src1, ::llvm::Value* src2)
-{
+                                ::llvm::Value* src1, ::llvm::Value* src2) {
   art::llvm::IntrinsicHelper::IntrinsicId id;
   if (is_long) {
     if (is_div) {
@@ -393,8 +368,7 @@ void MirConverter::ConvertCompareZeroAndBranch(BasicBlock* bb,
 }
 
 ::llvm::Value* MirConverter::GenArithOp(OpKind op, bool is_long,
-                               ::llvm::Value* src1, ::llvm::Value* src2)
-{
+                               ::llvm::Value* src1, ::llvm::Value* src2) {
   ::llvm::Value* res = NULL;
   switch(op) {
     case kOpAdd: res = irb_->CreateAdd(src1, src2); break;
@@ -416,8 +390,7 @@ void MirConverter::ConvertCompareZeroAndBranch(BasicBlock* bb,
 }
 
 void MirConverter::ConvertFPArithOp(OpKind op, RegLocation rl_dest,
-                             RegLocation rl_src1, RegLocation rl_src2)
-{
+                             RegLocation rl_src1, RegLocation rl_src2) {
   ::llvm::Value* src1 = GetLLVMValue(rl_src1.orig_sreg);
   ::llvm::Value* src2 = GetLLVMValue(rl_src2.orig_sreg);
   ::llvm::Value* res = NULL;
@@ -434,8 +407,7 @@ void MirConverter::ConvertFPArithOp(OpKind op, RegLocation rl_dest,
 }
 
 void MirConverter::ConvertShift(art::llvm::IntrinsicHelper::IntrinsicId id,
-                         RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2)
-{
+                         RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2) {
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(id);
   ::llvm::SmallVector< ::llvm::Value*, 2>args;
   args.push_back(GetLLVMValue(rl_src1.orig_sreg));
@@ -445,8 +417,7 @@ void MirConverter::ConvertShift(art::llvm::IntrinsicHelper::IntrinsicId id,
 }
 
 void MirConverter::ConvertShiftLit(art::llvm::IntrinsicHelper::IntrinsicId id,
-                            RegLocation rl_dest, RegLocation rl_src, int shift_amount)
-{
+                            RegLocation rl_dest, RegLocation rl_src, int shift_amount) {
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(id);
   ::llvm::SmallVector< ::llvm::Value*, 2>args;
   args.push_back(GetLLVMValue(rl_src.orig_sreg));
@@ -456,8 +427,7 @@ void MirConverter::ConvertShiftLit(art::llvm::IntrinsicHelper::IntrinsicId id,
 }
 
 void MirConverter::ConvertArithOp(OpKind op, RegLocation rl_dest,
-                           RegLocation rl_src1, RegLocation rl_src2)
-{
+                           RegLocation rl_src1, RegLocation rl_src2) {
   ::llvm::Value* src1 = GetLLVMValue(rl_src1.orig_sreg);
   ::llvm::Value* src2 = GetLLVMValue(rl_src2.orig_sreg);
   DCHECK_EQ(src1->getType(), src2->getType());
@@ -466,8 +436,7 @@ void MirConverter::ConvertArithOp(OpKind op, RegLocation rl_dest,
 }
 
 void MirConverter::ConvertArithOpLit(OpKind op, RegLocation rl_dest,
-                              RegLocation rl_src1, int32_t imm)
-{
+                              RegLocation rl_src1, int32_t imm) {
   ::llvm::Value* src1 = GetLLVMValue(rl_src1.orig_sreg);
   ::llvm::Value* src2 = irb_->getInt32(imm);
   ::llvm::Value* res = GenArithOp(op, rl_dest.wide, src1, src2);
@@ -480,8 +449,7 @@ void MirConverter::ConvertArithOpLit(OpKind op, RegLocation rl_dest,
  * The requirements are similar.
  */
 void MirConverter::ConvertInvoke(BasicBlock* bb, MIR* mir,
-                          InvokeType invoke_type, bool is_range, bool is_filled_new_array)
-{
+                          InvokeType invoke_type, bool is_range, bool is_filled_new_array) {
   CallInfo* info = mir_graph_->NewMemCallInfo(bb, mir, invoke_type, is_range);
   ::llvm::SmallVector< ::llvm::Value*, 10> args;
   // Insert the invoke_type
@@ -529,16 +497,14 @@ void MirConverter::ConvertInvoke(BasicBlock* bb, MIR* mir,
 }
 
 void MirConverter::ConvertConstObject(uint32_t idx,
-                               art::llvm::IntrinsicHelper::IntrinsicId id, RegLocation rl_dest)
-{
+                               art::llvm::IntrinsicHelper::IntrinsicId id, RegLocation rl_dest) {
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(id);
   ::llvm::Value* index = irb_->getInt32(idx);
   ::llvm::Value* res = irb_->CreateCall(intr, index);
   DefineValue(res, rl_dest.orig_sreg);
 }
 
-void MirConverter::ConvertCheckCast(uint32_t type_idx, RegLocation rl_src)
-{
+void MirConverter::ConvertCheckCast(uint32_t type_idx, RegLocation rl_src) {
   art::llvm::IntrinsicHelper::IntrinsicId id;
   id = art::llvm::IntrinsicHelper::HLCheckCast;
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(id);
@@ -548,8 +514,7 @@ void MirConverter::ConvertCheckCast(uint32_t type_idx, RegLocation rl_src)
   irb_->CreateCall(intr, args);
 }
 
-void MirConverter::ConvertNewInstance(uint32_t type_idx, RegLocation rl_dest)
-{
+void MirConverter::ConvertNewInstance(uint32_t type_idx, RegLocation rl_dest) {
   art::llvm::IntrinsicHelper::IntrinsicId id;
   id = art::llvm::IntrinsicHelper::NewInstance;
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(id);
@@ -559,8 +524,7 @@ void MirConverter::ConvertNewInstance(uint32_t type_idx, RegLocation rl_dest)
 }
 
 void MirConverter::ConvertNewArray(uint32_t type_idx,
-                            RegLocation rl_dest, RegLocation rl_src)
-{
+                            RegLocation rl_dest, RegLocation rl_src) {
   art::llvm::IntrinsicHelper::IntrinsicId id;
   id = art::llvm::IntrinsicHelper::NewArray;
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(id);
@@ -573,8 +537,7 @@ void MirConverter::ConvertNewArray(uint32_t type_idx,
 
 void MirConverter::ConvertAget(int opt_flags,
                         art::llvm::IntrinsicHelper::IntrinsicId id,
-                        RegLocation rl_dest, RegLocation rl_array, RegLocation rl_index)
-{
+                        RegLocation rl_dest, RegLocation rl_array, RegLocation rl_index) {
   ::llvm::SmallVector< ::llvm::Value*, 3> args;
   args.push_back(irb_->getInt32(opt_flags));
   args.push_back(GetLLVMValue(rl_array.orig_sreg));
@@ -586,8 +549,7 @@ void MirConverter::ConvertAget(int opt_flags,
 
 void MirConverter::ConvertAput(int opt_flags,
                         art::llvm::IntrinsicHelper::IntrinsicId id,
-                        RegLocation rl_src, RegLocation rl_array, RegLocation rl_index)
-{
+                        RegLocation rl_src, RegLocation rl_array, RegLocation rl_index) {
   ::llvm::SmallVector< ::llvm::Value*, 4> args;
   args.push_back(irb_->getInt32(opt_flags));
   args.push_back(GetLLVMValue(rl_src.orig_sreg));
@@ -599,8 +561,7 @@ void MirConverter::ConvertAput(int opt_flags,
 
 void MirConverter::ConvertIget(int opt_flags,
                         art::llvm::IntrinsicHelper::IntrinsicId id,
-                        RegLocation rl_dest, RegLocation rl_obj, int field_index)
-{
+                        RegLocation rl_dest, RegLocation rl_obj, int field_index) {
   ::llvm::SmallVector< ::llvm::Value*, 3> args;
   args.push_back(irb_->getInt32(opt_flags));
   args.push_back(GetLLVMValue(rl_obj.orig_sreg));
@@ -612,8 +573,7 @@ void MirConverter::ConvertIget(int opt_flags,
 
 void MirConverter::ConvertIput(int opt_flags,
                         art::llvm::IntrinsicHelper::IntrinsicId id,
-                        RegLocation rl_src, RegLocation rl_obj, int field_index)
-{
+                        RegLocation rl_src, RegLocation rl_obj, int field_index) {
   ::llvm::SmallVector< ::llvm::Value*, 4> args;
   args.push_back(irb_->getInt32(opt_flags));
   args.push_back(GetLLVMValue(rl_src.orig_sreg));
@@ -624,8 +584,7 @@ void MirConverter::ConvertIput(int opt_flags,
 }
 
 void MirConverter::ConvertInstanceOf(uint32_t type_idx,
-                              RegLocation rl_dest, RegLocation rl_src)
-{
+                              RegLocation rl_dest, RegLocation rl_src) {
   art::llvm::IntrinsicHelper::IntrinsicId id;
   id = art::llvm::IntrinsicHelper::InstanceOf;
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(id);
@@ -636,29 +595,25 @@ void MirConverter::ConvertInstanceOf(uint32_t type_idx,
   DefineValue(res, rl_dest.orig_sreg);
 }
 
-void MirConverter::ConvertIntToLong(RegLocation rl_dest, RegLocation rl_src)
-{
+void MirConverter::ConvertIntToLong(RegLocation rl_dest, RegLocation rl_src) {
   ::llvm::Value* res = irb_->CreateSExt(GetLLVMValue(rl_src.orig_sreg),
                                             irb_->getInt64Ty());
   DefineValue(res, rl_dest.orig_sreg);
 }
 
-void MirConverter::ConvertLongToInt(RegLocation rl_dest, RegLocation rl_src)
-{
+void MirConverter::ConvertLongToInt(RegLocation rl_dest, RegLocation rl_src) {
   ::llvm::Value* src = GetLLVMValue(rl_src.orig_sreg);
   ::llvm::Value* res = irb_->CreateTrunc(src, irb_->getInt32Ty());
   DefineValue(res, rl_dest.orig_sreg);
 }
 
-void MirConverter::ConvertFloatToDouble(RegLocation rl_dest, RegLocation rl_src)
-{
+void MirConverter::ConvertFloatToDouble(RegLocation rl_dest, RegLocation rl_src) {
   ::llvm::Value* src = GetLLVMValue(rl_src.orig_sreg);
   ::llvm::Value* res = irb_->CreateFPExt(src, irb_->getDoubleTy());
   DefineValue(res, rl_dest.orig_sreg);
 }
 
-void MirConverter::ConvertDoubleToFloat(RegLocation rl_dest, RegLocation rl_src)
-{
+void MirConverter::ConvertDoubleToFloat(RegLocation rl_dest, RegLocation rl_src) {
   ::llvm::Value* src = GetLLVMValue(rl_src.orig_sreg);
   ::llvm::Value* res = irb_->CreateFPTrunc(src, irb_->getFloatTy());
   DefineValue(res, rl_dest.orig_sreg);
@@ -666,8 +621,7 @@ void MirConverter::ConvertDoubleToFloat(RegLocation rl_dest, RegLocation rl_src)
 
 void MirConverter::ConvertWideComparison(art::llvm::IntrinsicHelper::IntrinsicId id,
                                          RegLocation rl_dest, RegLocation rl_src1,
-                                         RegLocation rl_src2)
-{
+                                         RegLocation rl_src2) {
   DCHECK_EQ(rl_src1.fp, rl_src2.fp);
   DCHECK_EQ(rl_src1.wide, rl_src2.wide);
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(id);
@@ -679,23 +633,20 @@ void MirConverter::ConvertWideComparison(art::llvm::IntrinsicHelper::IntrinsicId
 }
 
 void MirConverter::ConvertIntNarrowing(RegLocation rl_dest, RegLocation rl_src,
-                                art::llvm::IntrinsicHelper::IntrinsicId id)
-{
+                                art::llvm::IntrinsicHelper::IntrinsicId id) {
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(id);
   ::llvm::Value* res =
       irb_->CreateCall(intr, GetLLVMValue(rl_src.orig_sreg));
   DefineValue(res, rl_dest.orig_sreg);
 }
 
-void MirConverter::ConvertNeg(RegLocation rl_dest, RegLocation rl_src)
-{
+void MirConverter::ConvertNeg(RegLocation rl_dest, RegLocation rl_src) {
   ::llvm::Value* res = irb_->CreateNeg(GetLLVMValue(rl_src.orig_sreg));
   DefineValue(res, rl_dest.orig_sreg);
 }
 
 void MirConverter::ConvertIntToFP(::llvm::Type* ty, RegLocation rl_dest,
-                           RegLocation rl_src)
-{
+                           RegLocation rl_src) {
   ::llvm::Value* res =
       irb_->CreateSIToFP(GetLLVMValue(rl_src.orig_sreg), ty);
   DefineValue(res, rl_dest.orig_sreg);
@@ -703,23 +654,20 @@ void MirConverter::ConvertIntToFP(::llvm::Type* ty, RegLocation rl_dest,
 
 void MirConverter::ConvertFPToInt(art::llvm::IntrinsicHelper::IntrinsicId id,
                            RegLocation rl_dest,
-                    RegLocation rl_src)
-{
+                    RegLocation rl_src) {
   ::llvm::Function* intr = intrinsic_helper_->GetIntrinsicFunction(id);
   ::llvm::Value* res = irb_->CreateCall(intr, GetLLVMValue(rl_src.orig_sreg));
   DefineValue(res, rl_dest.orig_sreg);
 }
 
 
-void MirConverter::ConvertNegFP(RegLocation rl_dest, RegLocation rl_src)
-{
+void MirConverter::ConvertNegFP(RegLocation rl_dest, RegLocation rl_src) {
   ::llvm::Value* res =
       irb_->CreateFNeg(GetLLVMValue(rl_src.orig_sreg));
   DefineValue(res, rl_dest.orig_sreg);
 }
 
-void MirConverter::ConvertNot(RegLocation rl_dest, RegLocation rl_src)
-{
+void MirConverter::ConvertNot(RegLocation rl_dest, RegLocation rl_src) {
   ::llvm::Value* src = GetLLVMValue(rl_src.orig_sreg);
   ::llvm::Value* res = irb_->CreateXor(src, static_cast<uint64_t>(-1));
   DefineValue(res, rl_dest.orig_sreg);
@@ -737,8 +685,7 @@ void MirConverter::EmitConstructorBarrier() {
  * when necessary.
  */
 bool MirConverter::ConvertMIRNode(MIR* mir, BasicBlock* bb,
-                           ::llvm::BasicBlock* llvm_bb)
-{
+                           ::llvm::BasicBlock* llvm_bb) {
   bool res = false;   // Assume success
   RegLocation rl_src[3];
   RegLocation rl_dest = mir_graph_->GetBadLoc();
@@ -1556,8 +1503,7 @@ bool MirConverter::ConvertMIRNode(MIR* mir, BasicBlock* bb,
   return res;
 }
 
-void MirConverter::SetDexOffset(int32_t offset)
-{
+void MirConverter::SetDexOffset(int32_t offset) {
   current_dalvik_offset_ = offset;
   ::llvm::SmallVector< ::llvm::Value*, 1> array_ref;
   array_ref.push_back(irb_->getInt32(offset));
@@ -1566,8 +1512,7 @@ void MirConverter::SetDexOffset(int32_t offset)
 }
 
 // Attach method info as metadata to special intrinsic
-void MirConverter::SetMethodInfo()
-{
+void MirConverter::SetMethodInfo() {
   // We don't want dex offset on this
   irb_->SetDexOffset(NULL);
   art::llvm::IntrinsicHelper::IntrinsicId id;
@@ -1585,8 +1530,7 @@ void MirConverter::SetMethodInfo()
   SetDexOffset(current_dalvik_offset_);
 }
 
-void MirConverter::HandlePhiNodes(BasicBlock* bb, ::llvm::BasicBlock* llvm_bb)
-{
+void MirConverter::HandlePhiNodes(BasicBlock* bb, ::llvm::BasicBlock* llvm_bb) {
   SetDexOffset(bb->start_offset);
   for (MIR* mir = bb->first_mir_insn; mir != NULL; mir = mir->next) {
     int opcode = mir->dalvikInsn.opcode;
@@ -1636,8 +1580,7 @@ void MirConverter::HandlePhiNodes(BasicBlock* bb, ::llvm::BasicBlock* llvm_bb)
 
 /* Extended MIR instructions like PHI */
 void MirConverter::ConvertExtendedMIR(BasicBlock* bb, MIR* mir,
-                               ::llvm::BasicBlock* llvm_bb)
-{
+                               ::llvm::BasicBlock* llvm_bb) {
 
   switch (static_cast<ExtendedMIROpcode>(mir->dalvikInsn.opcode)) {
     case kMirOpPhi: {
@@ -1684,8 +1627,7 @@ void MirConverter::ConvertExtendedMIR(BasicBlock* bb, MIR* mir,
 }
 
 /* Handle the content in each basic block */
-bool MirConverter::BlockBitcodeConversion(BasicBlock* bb)
-{
+bool MirConverter::BlockBitcodeConversion(BasicBlock* bb) {
   if (bb->block_type == kDead) return false;
   ::llvm::BasicBlock* llvm_bb = GetLLVMBlock(bb->id);
   if (llvm_bb == NULL) {
@@ -1901,8 +1843,7 @@ bool MirConverter::CreateFunction() {
   return true;
 }
 
-bool MirConverter::CreateLLVMBasicBlock(BasicBlock* bb)
-{
+bool MirConverter::CreateLLVMBasicBlock(BasicBlock* bb) {
   // Skip the exit block
   if ((bb->block_type == kDead) ||(bb->block_type == kExitBlock)) {
     id_to_block_map_.Put(bb->id, NULL);
@@ -1933,8 +1874,7 @@ bool MirConverter::CreateLLVMBasicBlock(BasicBlock* bb)
  *  o Iterate through the MIR a basic block at a time, setting arguments
  *    to recovered ssa name.
  */
-void MirConverter::MethodMIR2Bitcode()
-{
+void MirConverter::MethodMIR2Bitcode() {
   InitIR();
 
   // Create the function
diff --git a/compiler/dex/quick/arm/assemble_arm.cc b/compiler/dex/quick/arm/assemble_arm.cc
index e804215c11..9e144579db 100644
--- a/compiler/dex/quick/arm/assemble_arm.cc
+++ b/compiler/dex/quick/arm/assemble_arm.cc
@@ -1002,8 +1002,7 @@ const ArmEncodingMap ArmMir2Lir::EncodingMap[kArmLast] = {
  * discover that pc-relative displacements may not fit the selected
  * instruction.
  */
-AssemblerStatus ArmMir2Lir::AssembleInstructions(uintptr_t start_addr)
-{
+AssemblerStatus ArmMir2Lir::AssembleInstructions(uintptr_t start_addr) {
   LIR* lir;
   AssemblerStatus res = kSuccess;  // Assume success
 
@@ -1389,8 +1388,7 @@ AssemblerStatus ArmMir2Lir::AssembleInstructions(uintptr_t start_addr)
   return res;
 }
 
-int ArmMir2Lir::GetInsnSize(LIR* lir)
-{
+int ArmMir2Lir::GetInsnSize(LIR* lir) {
   return EncodingMap[lir->opcode].size;
 }
 
diff --git a/compiler/dex/quick/arm/call_arm.cc b/compiler/dex/quick/arm/call_arm.cc
index a6720ce6f2..0e813247db 100644
--- a/compiler/dex/quick/arm/call_arm.cc
+++ b/compiler/dex/quick/arm/call_arm.cc
@@ -25,8 +25,7 @@ namespace art {
 
 
 /* Return the position of an ssa name within the argument list */
-int ArmMir2Lir::InPosition(int s_reg)
-{
+int ArmMir2Lir::InPosition(int s_reg) {
   int v_reg = mir_graph_->SRegToVReg(s_reg);
   return v_reg - cu_->num_regs;
 }
@@ -36,8 +35,7 @@ int ArmMir2Lir::InPosition(int s_reg)
  * there.  NOTE: all live arg registers must be locked prior to this call
  * to avoid having them allocated as a temp by downstream utilities.
  */
-RegLocation ArmMir2Lir::ArgLoc(RegLocation loc)
-{
+RegLocation ArmMir2Lir::ArgLoc(RegLocation loc) {
   int arg_num = InPosition(loc.s_reg_low);
   if (loc.wide) {
     if (arg_num == 2) {
@@ -66,8 +64,7 @@ RegLocation ArmMir2Lir::ArgLoc(RegLocation loc)
  * the frame, we can't use the normal LoadValue() because it assumed
  * a proper frame - and we're frameless.
  */
-RegLocation ArmMir2Lir::LoadArg(RegLocation loc)
-{
+RegLocation ArmMir2Lir::LoadArg(RegLocation loc) {
   if (loc.location == kLocDalvikFrame) {
     int start = (InPosition(loc.s_reg_low) + 1) * sizeof(uint32_t);
     loc.low_reg = AllocTemp();
@@ -82,8 +79,7 @@ RegLocation ArmMir2Lir::LoadArg(RegLocation loc)
 }
 
 /* Lock any referenced arguments that arrive in registers */
-void ArmMir2Lir::LockLiveArgs(MIR* mir)
-{
+void ArmMir2Lir::LockLiveArgs(MIR* mir) {
   int first_in = cu_->num_regs;
   const int num_arg_regs = 3;  // TODO: generalize & move to RegUtil.cc
   for (int i = 0; i < mir->ssa_rep->num_uses; i++) {
@@ -97,8 +93,7 @@ void ArmMir2Lir::LockLiveArgs(MIR* mir)
 
 /* Find the next MIR, which may be in a following basic block */
 // TODO: should this be a utility in mir_graph?
-MIR* ArmMir2Lir::GetNextMir(BasicBlock** p_bb, MIR* mir)
-{
+MIR* ArmMir2Lir::GetNextMir(BasicBlock** p_bb, MIR* mir) {
   BasicBlock* bb = *p_bb;
   MIR* orig_mir = mir;
   while (bb != NULL) {
@@ -123,8 +118,7 @@ MIR* ArmMir2Lir::GetNextMir(BasicBlock** p_bb, MIR* mir)
 
 /* Used for the "verbose" listing */
 //TODO:  move to common code
-void ArmMir2Lir::GenPrintLabel(MIR* mir)
-{
+void ArmMir2Lir::GenPrintLabel(MIR* mir) {
   /* Mark the beginning of a Dalvik instruction for line tracking */
   char* inst_str = cu_->verbose ?
      mir_graph_->GetDalvikDisassembly(mir) : NULL;
@@ -132,8 +126,7 @@ void ArmMir2Lir::GenPrintLabel(MIR* mir)
 }
 
 MIR* ArmMir2Lir::SpecialIGet(BasicBlock** bb, MIR* mir,
-                             OpSize size, bool long_or_double, bool is_object)
-{
+                             OpSize size, bool long_or_double, bool is_object) {
   int field_offset;
   bool is_volatile;
   uint32_t field_idx = mir->dalvikInsn.vC;
@@ -158,8 +151,7 @@ MIR* ArmMir2Lir::SpecialIGet(BasicBlock** bb, MIR* mir,
 }
 
 MIR* ArmMir2Lir::SpecialIPut(BasicBlock** bb, MIR* mir,
-                             OpSize size, bool long_or_double, bool is_object)
-{
+                             OpSize size, bool long_or_double, bool is_object) {
   int field_offset;
   bool is_volatile;
   uint32_t field_idx = mir->dalvikInsn.vC;
@@ -192,8 +184,7 @@ MIR* ArmMir2Lir::SpecialIPut(BasicBlock** bb, MIR* mir,
   return GetNextMir(bb, mir);
 }
 
-MIR* ArmMir2Lir::SpecialIdentity(MIR* mir)
-{
+MIR* ArmMir2Lir::SpecialIdentity(MIR* mir) {
   RegLocation rl_src;
   RegLocation rl_dest;
   bool wide = (mir->ssa_rep->num_uses == 2);
@@ -225,8 +216,7 @@ MIR* ArmMir2Lir::SpecialIdentity(MIR* mir)
  * Special-case code genration for simple non-throwing leaf methods.
  */
 void ArmMir2Lir::GenSpecialCase(BasicBlock* bb, MIR* mir,
-                                SpecialCaseHandler special_case)
-{
+                                SpecialCaseHandler special_case) {
    current_dalvik_offset_ = mir->offset;
    MIR* next_mir = NULL;
    switch (special_case) {
@@ -319,8 +309,7 @@ void ArmMir2Lir::GenSpecialCase(BasicBlock* bb, MIR* mir,
  *   cbnz  r_idx, lp
  */
 void ArmMir2Lir::GenSparseSwitch(MIR* mir, uint32_t table_offset,
-                                 RegLocation rl_src)
-{
+                                 RegLocation rl_src) {
   const uint16_t* table = cu_->insns + current_dalvik_offset_ + table_offset;
   if (cu_->verbose) {
     DumpSparseSwitchTable(table);
@@ -369,8 +358,7 @@ void ArmMir2Lir::GenSparseSwitch(MIR* mir, uint32_t table_offset,
 
 
 void ArmMir2Lir::GenPackedSwitch(MIR* mir, uint32_t table_offset,
-                                 RegLocation rl_src)
-{
+                                 RegLocation rl_src) {
   const uint16_t* table = cu_->insns + current_dalvik_offset_ + table_offset;
   if (cu_->verbose) {
     DumpPackedSwitchTable(table);
@@ -427,8 +415,7 @@ void ArmMir2Lir::GenPackedSwitch(MIR* mir, uint32_t table_offset,
  *
  * Total size is 4+(width * size + 1)/2 16-bit code units.
  */
-void ArmMir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src)
-{
+void ArmMir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src) {
   const uint16_t* table = cu_->insns + current_dalvik_offset_ + table_offset;
   // Add the table to the list - we'll process it later
   FillArrayData *tab_rec =
@@ -480,8 +467,7 @@ void ArmMir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src)
  * preserved.
  *
  */
-void ArmMir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src)
-{
+void ArmMir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src) {
   FlushAllRegs();
   DCHECK_EQ(LW_SHAPE_THIN, 0);
   LoadValueDirectFixed(rl_src, r0);  // Get obj
@@ -515,8 +501,7 @@ void ArmMir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src)
  * a zero recursion count, it's safe to punch it back to the
  * initial, unlock thin state with a store word.
  */
-void ArmMir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src)
-{
+void ArmMir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src) {
   DCHECK_EQ(LW_SHAPE_THIN, 0);
   FlushAllRegs();
   LoadValueDirectFixed(rl_src, r0);  // Get obj
@@ -541,8 +526,7 @@ void ArmMir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src)
   GenMemBarrier(kStoreLoad);
 }
 
-void ArmMir2Lir::GenMoveException(RegLocation rl_dest)
-{
+void ArmMir2Lir::GenMoveException(RegLocation rl_dest) {
   int ex_offset = Thread::ExceptionOffset().Int32Value();
   RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
   int reset_reg = AllocTemp();
@@ -556,8 +540,7 @@ void ArmMir2Lir::GenMoveException(RegLocation rl_dest)
 /*
  * Mark garbage collection card. Skip if the value we're storing is null.
  */
-void ArmMir2Lir::MarkGCCard(int val_reg, int tgt_addr_reg)
-{
+void ArmMir2Lir::MarkGCCard(int val_reg, int tgt_addr_reg) {
   int reg_card_base = AllocTemp();
   int reg_card_no = AllocTemp();
   LIR* branch_over = OpCmpImmBranch(kCondEq, val_reg, 0, NULL);
@@ -571,8 +554,7 @@ void ArmMir2Lir::MarkGCCard(int val_reg, int tgt_addr_reg)
   FreeTemp(reg_card_no);
 }
 
-void ArmMir2Lir::GenEntrySequence(RegLocation* ArgLocs, RegLocation rl_method)
-{
+void ArmMir2Lir::GenEntrySequence(RegLocation* ArgLocs, RegLocation rl_method) {
   int spill_count = num_core_spills_ + num_fp_spills_;
   /*
    * On entry, r0, r1, r2 & r3 are live.  Let the register allocation
@@ -624,8 +606,7 @@ void ArmMir2Lir::GenEntrySequence(RegLocation* ArgLocs, RegLocation rl_method)
   FreeTemp(r3);
 }
 
-void ArmMir2Lir::GenExitSequence()
-{
+void ArmMir2Lir::GenExitSequence() {
   int spill_count = num_core_spills_ + num_fp_spills_;
   /*
    * In the exit path, r0/r1 are live - make sure they aren't
diff --git a/compiler/dex/quick/arm/fp_arm.cc b/compiler/dex/quick/arm/fp_arm.cc
index 53a5e1a6dc..2c626a0e8f 100644
--- a/compiler/dex/quick/arm/fp_arm.cc
+++ b/compiler/dex/quick/arm/fp_arm.cc
@@ -21,8 +21,7 @@
 namespace art {
 
 void ArmMir2Lir::GenArithOpFloat(Instruction::Code opcode, RegLocation rl_dest,
-                                 RegLocation rl_src1, RegLocation rl_src2)
-{
+                                 RegLocation rl_src1, RegLocation rl_src2) {
   int op = kThumbBkpt;
   RegLocation rl_result;
 
@@ -68,8 +67,7 @@ void ArmMir2Lir::GenArithOpFloat(Instruction::Code opcode, RegLocation rl_dest,
 }
 
 void ArmMir2Lir::GenArithOpDouble(Instruction::Code opcode,
-                                  RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2)
-{
+                                  RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2) {
   int op = kThumbBkpt;
   RegLocation rl_result;
 
@@ -117,8 +115,7 @@ void ArmMir2Lir::GenArithOpDouble(Instruction::Code opcode,
 }
 
 void ArmMir2Lir::GenConversion(Instruction::Code opcode,
-                               RegLocation rl_dest, RegLocation rl_src)
-{
+                               RegLocation rl_dest, RegLocation rl_src) {
   int op = kThumbBkpt;
   int src_reg;
   RegLocation rl_result;
@@ -176,8 +173,7 @@ void ArmMir2Lir::GenConversion(Instruction::Code opcode,
 }
 
 void ArmMir2Lir::GenFusedFPCmpBranch(BasicBlock* bb, MIR* mir, bool gt_bias,
-                                     bool is_double)
-{
+                                     bool is_double) {
   LIR* target = &block_label_list_[bb->taken->id];
   RegLocation rl_src1;
   RegLocation rl_src2;
@@ -229,8 +225,7 @@ void ArmMir2Lir::GenFusedFPCmpBranch(BasicBlock* bb, MIR* mir, bool gt_bias,
 
 
 void ArmMir2Lir::GenCmpFP(Instruction::Code opcode, RegLocation rl_dest,
-                          RegLocation rl_src1, RegLocation rl_src2)
-{
+                          RegLocation rl_src1, RegLocation rl_src2) {
   bool is_double = false;
   int default_result = -1;
   RegLocation rl_result;
@@ -288,8 +283,7 @@ void ArmMir2Lir::GenCmpFP(Instruction::Code opcode, RegLocation rl_dest,
   StoreValue(rl_dest, rl_result);
 }
 
-void ArmMir2Lir::GenNegFloat(RegLocation rl_dest, RegLocation rl_src)
-{
+void ArmMir2Lir::GenNegFloat(RegLocation rl_dest, RegLocation rl_src) {
   RegLocation rl_result;
   rl_src = LoadValue(rl_src, kFPReg);
   rl_result = EvalLoc(rl_dest, kFPReg, true);
@@ -297,8 +291,7 @@ void ArmMir2Lir::GenNegFloat(RegLocation rl_dest, RegLocation rl_src)
   StoreValue(rl_dest, rl_result);
 }
 
-void ArmMir2Lir::GenNegDouble(RegLocation rl_dest, RegLocation rl_src)
-{
+void ArmMir2Lir::GenNegDouble(RegLocation rl_dest, RegLocation rl_src) {
   RegLocation rl_result;
   rl_src = LoadValueWide(rl_src, kFPReg);
   rl_result = EvalLoc(rl_dest, kFPReg, true);
diff --git a/compiler/dex/quick/arm/int_arm.cc b/compiler/dex/quick/arm/int_arm.cc
index feea896e9f..ee2d76c7b7 100644
--- a/compiler/dex/quick/arm/int_arm.cc
+++ b/compiler/dex/quick/arm/int_arm.cc
@@ -25,8 +25,7 @@
 namespace art {
 
 LIR* ArmMir2Lir::OpCmpBranch(ConditionCode cond, int src1,
-         int src2, LIR* target)
-{
+         int src2, LIR* target) {
   OpRegReg(kOpCmp, src1, src2);
   return OpCondBranch(cond, target);
 }
@@ -41,8 +40,7 @@ LIR* ArmMir2Lir::OpCmpBranch(ConditionCode cond, int src1,
  * met, and an "E" means the instruction is executed if the condition
  * is not met.
  */
-LIR* ArmMir2Lir::OpIT(ConditionCode ccode, const char* guide)
-{
+LIR* ArmMir2Lir::OpIT(ConditionCode ccode, const char* guide) {
   int mask;
   int mask3 = 0;
   int mask2 = 0;
@@ -86,8 +84,7 @@ LIR* ArmMir2Lir::OpIT(ConditionCode ccode, const char* guide)
  * done:
  */
 void ArmMir2Lir::GenCmpLong(RegLocation rl_dest, RegLocation rl_src1,
-                            RegLocation rl_src2)
-{
+                            RegLocation rl_src2) {
   LIR* target1;
   LIR* target2;
   rl_src1 = LoadValueWide(rl_src1, kCoreReg);
@@ -121,8 +118,7 @@ void ArmMir2Lir::GenCmpLong(RegLocation rl_dest, RegLocation rl_src1,
 }
 
 void ArmMir2Lir::GenFusedLongCmpImmBranch(BasicBlock* bb, RegLocation rl_src1,
-                                          int64_t val, ConditionCode ccode)
-{
+                                          int64_t val, ConditionCode ccode) {
   int32_t val_lo = Low32Bits(val);
   int32_t val_hi = High32Bits(val);
   DCHECK(ModifiedImmediate(val_lo) >= 0);
@@ -180,8 +176,7 @@ void ArmMir2Lir::GenFusedLongCmpImmBranch(BasicBlock* bb, RegLocation rl_src1,
   OpCmpImmBranch(ccode, low_reg, val_lo, taken);
 }
 
-void ArmMir2Lir::GenSelect(BasicBlock* bb, MIR* mir)
-{
+void ArmMir2Lir::GenSelect(BasicBlock* bb, MIR* mir) {
   RegLocation rl_result;
   RegLocation rl_src = mir_graph_->GetSrc(mir, 0);
   // Temporary debugging code
@@ -249,8 +244,7 @@ void ArmMir2Lir::GenSelect(BasicBlock* bb, MIR* mir)
   StoreValue(rl_dest, rl_result);
 }
 
-void ArmMir2Lir::GenFusedLongCmpBranch(BasicBlock* bb, MIR* mir)
-{
+void ArmMir2Lir::GenFusedLongCmpBranch(BasicBlock* bb, MIR* mir) {
   RegLocation rl_src1 = mir_graph_->GetSrcWide(mir, 0);
   RegLocation rl_src2 = mir_graph_->GetSrcWide(mir, 2);
   // Normalize such that if either operand is constant, src2 will be constant.
@@ -315,8 +309,7 @@ void ArmMir2Lir::GenFusedLongCmpBranch(BasicBlock* bb, MIR* mir)
  * is responsible for setting branch target field.
  */
 LIR* ArmMir2Lir::OpCmpImmBranch(ConditionCode cond, int reg, int check_value,
-                                LIR* target)
-{
+                                LIR* target) {
   LIR* branch;
   int mod_imm;
   ArmConditionCode arm_cond = ArmConditionEncoding(cond);
@@ -341,8 +334,7 @@ LIR* ArmMir2Lir::OpCmpImmBranch(ConditionCode cond, int reg, int check_value,
   return branch;
 }
 
-LIR* ArmMir2Lir::OpRegCopyNoInsert(int r_dest, int r_src)
-{
+LIR* ArmMir2Lir::OpRegCopyNoInsert(int r_dest, int r_src) {
   LIR* res;
   int opcode;
   if (ARM_FPREG(r_dest) || ARM_FPREG(r_src))
@@ -362,16 +354,14 @@ LIR* ArmMir2Lir::OpRegCopyNoInsert(int r_dest, int r_src)
   return res;
 }
 
-LIR* ArmMir2Lir::OpRegCopy(int r_dest, int r_src)
-{
+LIR* ArmMir2Lir::OpRegCopy(int r_dest, int r_src) {
   LIR* res = OpRegCopyNoInsert(r_dest, r_src);
   AppendLIR(res);
   return res;
 }
 
 void ArmMir2Lir::OpRegCopyWide(int dest_lo, int dest_hi, int src_lo,
-                               int src_hi)
-{
+                               int src_hi) {
   bool dest_fp = ARM_FPREG(dest_lo) && ARM_FPREG(dest_hi);
   bool src_fp = ARM_FPREG(src_lo) && ARM_FPREG(src_hi);
   DCHECK_EQ(ARM_FPREG(src_lo), ARM_FPREG(src_hi));
@@ -426,8 +416,7 @@ static const MagicTable magic_table[] = {
 
 // Integer division by constant via reciprocal multiply (Hacker's Delight, 10-4)
 bool ArmMir2Lir::SmallLiteralDivide(Instruction::Code dalvik_opcode,
-                                    RegLocation rl_src, RegLocation rl_dest, int lit)
-{
+                                    RegLocation rl_src, RegLocation rl_dest, int lit) {
   if ((lit < 0) || (lit >= static_cast<int>(sizeof(magic_table)/sizeof(magic_table[0])))) {
     return false;
   }
@@ -471,28 +460,24 @@ bool ArmMir2Lir::SmallLiteralDivide(Instruction::Code dalvik_opcode,
 }
 
 LIR* ArmMir2Lir::GenRegMemCheck(ConditionCode c_code,
-                    int reg1, int base, int offset, ThrowKind kind)
-{
+                    int reg1, int base, int offset, ThrowKind kind) {
   LOG(FATAL) << "Unexpected use of GenRegMemCheck for Arm";
   return NULL;
 }
 
 RegLocation ArmMir2Lir::GenDivRemLit(RegLocation rl_dest, int reg1, int lit,
-                                     bool is_div)
-{
+                                     bool is_div) {
   LOG(FATAL) << "Unexpected use of GenDivRemLit for Arm";
   return rl_dest;
 }
 
 RegLocation ArmMir2Lir::GenDivRem(RegLocation rl_dest, int reg1, int reg2,
-                                  bool is_div)
-{
+                                  bool is_div) {
   LOG(FATAL) << "Unexpected use of GenDivRem for Arm";
   return rl_dest;
 }
 
-bool ArmMir2Lir::GenInlinedMinMaxInt(CallInfo* info, bool is_min)
-{
+bool ArmMir2Lir::GenInlinedMinMaxInt(CallInfo* info, bool is_min) {
   DCHECK_EQ(cu_->instruction_set, kThumb2);
   RegLocation rl_src1 = info->args[0];
   RegLocation rl_src2 = info->args[1];
@@ -509,13 +494,11 @@ bool ArmMir2Lir::GenInlinedMinMaxInt(CallInfo* info, bool is_min)
   return true;
 }
 
-void ArmMir2Lir::OpLea(int rBase, int reg1, int reg2, int scale, int offset)
-{
+void ArmMir2Lir::OpLea(int rBase, int reg1, int reg2, int scale, int offset) {
   LOG(FATAL) << "Unexpected use of OpLea for Arm";
 }
 
-void ArmMir2Lir::OpTlsCmp(int offset, int val)
-{
+void ArmMir2Lir::OpTlsCmp(int offset, int val) {
   LOG(FATAL) << "Unexpected use of OpTlsCmp for Arm";
 }
 
@@ -577,25 +560,21 @@ bool ArmMir2Lir::GenInlinedCas32(CallInfo* info, bool need_write_barrier) {
   return true;
 }
 
-LIR* ArmMir2Lir::OpPcRelLoad(int reg, LIR* target)
-{
+LIR* ArmMir2Lir::OpPcRelLoad(int reg, LIR* target) {
   return RawLIR(current_dalvik_offset_, kThumb2LdrPcRel12, reg, 0, 0, 0, 0, target);
 }
 
-LIR* ArmMir2Lir::OpVldm(int rBase, int count)
-{
+LIR* ArmMir2Lir::OpVldm(int rBase, int count) {
   return NewLIR3(kThumb2Vldms, rBase, fr0, count);
 }
 
-LIR* ArmMir2Lir::OpVstm(int rBase, int count)
-{
+LIR* ArmMir2Lir::OpVstm(int rBase, int count) {
   return NewLIR3(kThumb2Vstms, rBase, fr0, count);
 }
 
 void ArmMir2Lir::GenMultiplyByTwoBitMultiplier(RegLocation rl_src,
                                                RegLocation rl_result, int lit,
-                                               int first_bit, int second_bit)
-{
+                                               int first_bit, int second_bit) {
   OpRegRegRegShift(kOpAdd, rl_result.low_reg, rl_src.low_reg, rl_src.low_reg,
                    EncodeShift(kArmLsl, second_bit - first_bit));
   if (first_bit != 0) {
@@ -603,8 +582,7 @@ void ArmMir2Lir::GenMultiplyByTwoBitMultiplier(RegLocation rl_src,
   }
 }
 
-void ArmMir2Lir::GenDivZeroCheck(int reg_lo, int reg_hi)
-{
+void ArmMir2Lir::GenDivZeroCheck(int reg_lo, int reg_hi) {
   int t_reg = AllocTemp();
   NewLIR4(kThumb2OrrRRRs, t_reg, reg_lo, reg_hi, 0);
   FreeTemp(t_reg);
@@ -612,22 +590,19 @@ void ArmMir2Lir::GenDivZeroCheck(int reg_lo, int reg_hi)
 }
 
 // Test suspend flag, return target of taken suspend branch
-LIR* ArmMir2Lir::OpTestSuspend(LIR* target)
-{
+LIR* ArmMir2Lir::OpTestSuspend(LIR* target) {
   NewLIR2(kThumbSubRI8, rARM_SUSPEND, 1);
   return OpCondBranch((target == NULL) ? kCondEq : kCondNe, target);
 }
 
 // Decrement register and branch on condition
-LIR* ArmMir2Lir::OpDecAndBranch(ConditionCode c_code, int reg, LIR* target)
-{
+LIR* ArmMir2Lir::OpDecAndBranch(ConditionCode c_code, int reg, LIR* target) {
   // Combine sub & test using sub setflags encoding here
   NewLIR3(kThumb2SubsRRI12, reg, reg, 1);
   return OpCondBranch(c_code, target);
 }
 
-void ArmMir2Lir::GenMemBarrier(MemBarrierKind barrier_kind)
-{
+void ArmMir2Lir::GenMemBarrier(MemBarrierKind barrier_kind) {
 #if ANDROID_SMP != 0
   int dmb_flavor;
   // TODO: revisit Arm barrier kinds
@@ -646,8 +621,7 @@ void ArmMir2Lir::GenMemBarrier(MemBarrierKind barrier_kind)
 #endif
 }
 
-void ArmMir2Lir::GenNegLong(RegLocation rl_dest, RegLocation rl_src)
-{
+void ArmMir2Lir::GenNegLong(RegLocation rl_dest, RegLocation rl_src) {
   rl_src = LoadValueWide(rl_src, kCoreReg);
   RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
   int z_reg = AllocTemp();
@@ -672,16 +646,14 @@ void ArmMir2Lir::GenNegLong(RegLocation rl_dest, RegLocation rl_src)
   * is not usual for dx to generate, but it is legal (for now).  In a future rev of
   * dex, we'll want to make this case illegal.
   */
-bool ArmMir2Lir::BadOverlap(RegLocation rl_src, RegLocation rl_dest)
-{
+bool ArmMir2Lir::BadOverlap(RegLocation rl_src, RegLocation rl_dest) {
   DCHECK(rl_src.wide);
   DCHECK(rl_dest.wide);
   return (abs(mir_graph_->SRegToVReg(rl_src.s_reg_low) - mir_graph_->SRegToVReg(rl_dest.s_reg_low)) == 1);
 }
 
 void ArmMir2Lir::GenMulLong(RegLocation rl_dest, RegLocation rl_src1,
-                            RegLocation rl_src2)
-{
+                            RegLocation rl_src2) {
     /*
      * To pull off inline multiply, we have a worst-case requirement of 8 temporary
      * registers.  Normally for Arm, we get 5.  We can get to 6 by including
@@ -754,32 +726,27 @@ void ArmMir2Lir::GenMulLong(RegLocation rl_dest, RegLocation rl_src1,
 }
 
 void ArmMir2Lir::GenAddLong(RegLocation rl_dest, RegLocation rl_src1,
-                            RegLocation rl_src2)
-{
+                            RegLocation rl_src2) {
   LOG(FATAL) << "Unexpected use of GenAddLong for Arm";
 }
 
 void ArmMir2Lir::GenSubLong(RegLocation rl_dest, RegLocation rl_src1,
-                            RegLocation rl_src2)
-{
+                            RegLocation rl_src2) {
   LOG(FATAL) << "Unexpected use of GenSubLong for Arm";
 }
 
 void ArmMir2Lir::GenAndLong(RegLocation rl_dest, RegLocation rl_src1,
-                            RegLocation rl_src2)
-{
+                            RegLocation rl_src2) {
   LOG(FATAL) << "Unexpected use of GenAndLong for Arm";
 }
 
 void ArmMir2Lir::GenOrLong(RegLocation rl_dest, RegLocation rl_src1,
-                           RegLocation rl_src2)
-{
+                           RegLocation rl_src2) {
   LOG(FATAL) << "Unexpected use of GenOrLong for Arm";
 }
 
 void ArmMir2Lir::GenXorLong(RegLocation rl_dest, RegLocation rl_src1,
-                            RegLocation rl_src2)
-{
+                            RegLocation rl_src2) {
   LOG(FATAL) << "Unexpected use of genXoLong for Arm";
 }
 
@@ -787,8 +754,7 @@ void ArmMir2Lir::GenXorLong(RegLocation rl_dest, RegLocation rl_src1,
  * Generate array load
  */
 void ArmMir2Lir::GenArrayGet(int opt_flags, OpSize size, RegLocation rl_array,
-                          RegLocation rl_index, RegLocation rl_dest, int scale)
-{
+                          RegLocation rl_index, RegLocation rl_dest, int scale) {
   RegisterClass reg_class = oat_reg_class_by_size(size);
   int len_offset = mirror::Array::LengthOffset().Int32Value();
   int data_offset;
@@ -878,8 +844,7 @@ void ArmMir2Lir::GenArrayGet(int opt_flags, OpSize size, RegLocation rl_array,
  *
  */
 void ArmMir2Lir::GenArrayPut(int opt_flags, OpSize size, RegLocation rl_array,
-                          RegLocation rl_index, RegLocation rl_src, int scale)
-{
+                          RegLocation rl_index, RegLocation rl_src, int scale) {
   RegisterClass reg_class = oat_reg_class_by_size(size);
   int len_offset = mirror::Array::LengthOffset().Int32Value();
   int data_offset;
@@ -968,8 +933,7 @@ void ArmMir2Lir::GenArrayPut(int opt_flags, OpSize size, RegLocation rl_array,
  *
  */
 void ArmMir2Lir::GenArrayObjPut(int opt_flags, RegLocation rl_array,
-                             RegLocation rl_index, RegLocation rl_src, int scale)
-{
+                             RegLocation rl_index, RegLocation rl_src, int scale) {
   int len_offset = mirror::Array::LengthOffset().Int32Value();
   int data_offset = mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value();
 
@@ -1025,8 +989,7 @@ void ArmMir2Lir::GenArrayObjPut(int opt_flags, RegLocation rl_array,
 }
 
 void ArmMir2Lir::GenShiftImmOpLong(Instruction::Code opcode,
-                                   RegLocation rl_dest, RegLocation rl_src, RegLocation rl_shift)
-{
+                                   RegLocation rl_dest, RegLocation rl_src, RegLocation rl_shift) {
   rl_src = LoadValueWide(rl_src, kCoreReg);
   // Per spec, we only care about low 6 bits of shift amount.
   int shift_amount = mir_graph_->ConstantValue(rl_shift) & 0x3f;
@@ -1099,8 +1062,7 @@ void ArmMir2Lir::GenShiftImmOpLong(Instruction::Code opcode,
 }
 
 void ArmMir2Lir::GenArithImmOpLong(Instruction::Code opcode,
-                                   RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2)
-{
+                                   RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2) {
   if ((opcode == Instruction::SUB_LONG_2ADDR) || (opcode == Instruction::SUB_LONG)) {
     if (!rl_src2.is_const) {
       // Don't bother with special handling for subtract from immediate.
diff --git a/compiler/dex/quick/arm/target_arm.cc b/compiler/dex/quick/arm/target_arm.cc
index 4bece136bc..7021593a79 100644
--- a/compiler/dex/quick/arm/target_arm.cc
+++ b/compiler/dex/quick/arm/target_arm.cc
@@ -34,26 +34,22 @@ static int core_temps[] = {r0, r1, r2, r3, r12};
 static int fp_temps[] = {fr0, fr1, fr2, fr3, fr4, fr5, fr6, fr7,
                         fr8, fr9, fr10, fr11, fr12, fr13, fr14, fr15};
 
-RegLocation ArmMir2Lir::LocCReturn()
-{
+RegLocation ArmMir2Lir::LocCReturn() {
   RegLocation res = ARM_LOC_C_RETURN;
   return res;
 }
 
-RegLocation ArmMir2Lir::LocCReturnWide()
-{
+RegLocation ArmMir2Lir::LocCReturnWide() {
   RegLocation res = ARM_LOC_C_RETURN_WIDE;
   return res;
 }
 
-RegLocation ArmMir2Lir::LocCReturnFloat()
-{
+RegLocation ArmMir2Lir::LocCReturnFloat() {
   RegLocation res = ARM_LOC_C_RETURN_FLOAT;
   return res;
 }
 
-RegLocation ArmMir2Lir::LocCReturnDouble()
-{
+RegLocation ArmMir2Lir::LocCReturnDouble() {
   RegLocation res = ARM_LOC_C_RETURN_DOUBLE;
   return res;
 }
@@ -85,28 +81,24 @@ int ArmMir2Lir::TargetReg(SpecialTargetRegister reg) {
 
 
 // Create a double from a pair of singles.
-int ArmMir2Lir::S2d(int low_reg, int high_reg)
-{
+int ArmMir2Lir::S2d(int low_reg, int high_reg) {
   return ARM_S2D(low_reg, high_reg);
 }
 
 // Return mask to strip off fp reg flags and bias.
-uint32_t ArmMir2Lir::FpRegMask()
-{
+uint32_t ArmMir2Lir::FpRegMask() {
   return ARM_FP_REG_MASK;
 }
 
 // True if both regs single, both core or both double.
-bool ArmMir2Lir::SameRegType(int reg1, int reg2)
-{
+bool ArmMir2Lir::SameRegType(int reg1, int reg2) {
   return (ARM_REGTYPE(reg1) == ARM_REGTYPE(reg2));
 }
 
 /*
  * Decode the register id.
  */
-uint64_t ArmMir2Lir::GetRegMaskCommon(int reg)
-{
+uint64_t ArmMir2Lir::GetRegMaskCommon(int reg) {
   uint64_t seed;
   int shift;
   int reg_id;
@@ -122,13 +114,11 @@ uint64_t ArmMir2Lir::GetRegMaskCommon(int reg)
   return (seed << shift);
 }
 
-uint64_t ArmMir2Lir::GetPCUseDefEncoding()
-{
+uint64_t ArmMir2Lir::GetPCUseDefEncoding() {
   return ENCODE_ARM_REG_PC;
 }
 
-void ArmMir2Lir::SetupTargetResourceMasks(LIR* lir)
-{
+void ArmMir2Lir::SetupTargetResourceMasks(LIR* lir) {
   DCHECK_EQ(cu_->instruction_set, kThumb2);
 
   // Thumb2 specific setup
@@ -203,8 +193,7 @@ void ArmMir2Lir::SetupTargetResourceMasks(LIR* lir)
   }
 }
 
-ArmConditionCode ArmMir2Lir::ArmConditionEncoding(ConditionCode ccode)
-{
+ArmConditionCode ArmMir2Lir::ArmConditionEncoding(ConditionCode ccode) {
   ArmConditionCode res;
   switch (ccode) {
     case kCondEq: res = kArmCondEq; break;
@@ -257,8 +246,7 @@ static const char* shift_names[4] = {
   "ror"};
 
 /* Decode and print a ARM register name */
-static char* DecodeRegList(int opcode, int vector, char* buf)
-{
+static char* DecodeRegList(int opcode, int vector, char* buf) {
   int i;
   bool printed = false;
   buf[0] = 0;
@@ -281,8 +269,7 @@ static char* DecodeRegList(int opcode, int vector, char* buf)
   return buf;
 }
 
-static char*  DecodeFPCSRegList(int count, int base, char* buf)
-{
+static char*  DecodeFPCSRegList(int count, int base, char* buf) {
   sprintf(buf, "s%d", base);
   for (int i = 1; i < count; i++) {
     sprintf(buf + strlen(buf), ", s%d",base + i);
@@ -290,8 +277,7 @@ static char*  DecodeFPCSRegList(int count, int base, char* buf)
   return buf;
 }
 
-static int ExpandImmediate(int value)
-{
+static int ExpandImmediate(int value) {
   int mode = (value & 0xf00) >> 8;
   uint32_t bits = value & 0xff;
   switch (mode) {
@@ -316,8 +302,7 @@ const char* cc_names[] = {"eq","ne","cs","cc","mi","pl","vs","vc",
  * Interpret a format string and build a string no longer than size
  * See format key in Assemble.c.
  */
-std::string ArmMir2Lir::BuildInsnString(const char* fmt, LIR* lir, unsigned char* base_addr)
-{
+std::string ArmMir2Lir::BuildInsnString(const char* fmt, LIR* lir, unsigned char* base_addr) {
   std::string buf;
   int i;
   const char* fmt_end = &fmt[strlen(fmt)];
@@ -455,8 +440,7 @@ std::string ArmMir2Lir::BuildInsnString(const char* fmt, LIR* lir, unsigned char
   return buf;
 }
 
-void ArmMir2Lir::DumpResourceMask(LIR* arm_lir, uint64_t mask, const char* prefix)
-{
+void ArmMir2Lir::DumpResourceMask(LIR* arm_lir, uint64_t mask, const char* prefix) {
   char buf[256];
   buf[0] = 0;
 
@@ -501,8 +485,7 @@ void ArmMir2Lir::DumpResourceMask(LIR* arm_lir, uint64_t mask, const char* prefi
   }
 }
 
-bool ArmMir2Lir::IsUnconditionalBranch(LIR* lir)
-{
+bool ArmMir2Lir::IsUnconditionalBranch(LIR* lir) {
   return ((lir->opcode == kThumbBUncond) || (lir->opcode == kThumb2BUncond));
 }
 
@@ -527,8 +510,7 @@ Mir2Lir* ArmCodeGenerator(CompilationUnit* const cu, MIRGraph* const mir_graph,
  * Alloc a pair of core registers, or a double.  Low reg in low byte,
  * high reg in next byte.
  */
-int ArmMir2Lir::AllocTypedTempPair(bool fp_hint, int reg_class)
-{
+int ArmMir2Lir::AllocTypedTempPair(bool fp_hint, int reg_class) {
   int high_reg;
   int low_reg;
   int res = 0;
@@ -544,15 +526,13 @@ int ArmMir2Lir::AllocTypedTempPair(bool fp_hint, int reg_class)
   return res;
 }
 
-int ArmMir2Lir::AllocTypedTemp(bool fp_hint, int reg_class)
-{
+int ArmMir2Lir::AllocTypedTemp(bool fp_hint, int reg_class) {
   if (((reg_class == kAnyReg) && fp_hint) || (reg_class == kFPReg))
     return AllocTempFloat();
   return AllocTemp();
 }
 
-void ArmMir2Lir::CompilerInitializeRegAlloc()
-{
+void ArmMir2Lir::CompilerInitializeRegAlloc() {
   int num_regs = sizeof(core_regs)/sizeof(*core_regs);
   int num_reserved = sizeof(ReservedRegs)/sizeof(*ReservedRegs);
   int num_temps = sizeof(core_temps)/sizeof(*core_temps);
@@ -591,8 +571,7 @@ void ArmMir2Lir::CompilerInitializeRegAlloc()
 }
 
 void ArmMir2Lir::FreeRegLocTemps(RegLocation rl_keep,
-                     RegLocation rl_free)
-{
+                     RegLocation rl_free) {
   if ((rl_free.low_reg != rl_keep.low_reg) && (rl_free.low_reg != rl_keep.high_reg) &&
     (rl_free.high_reg != rl_keep.low_reg) && (rl_free.high_reg != rl_keep.high_reg)) {
     // No overlap, free both
@@ -606,8 +585,7 @@ void ArmMir2Lir::FreeRegLocTemps(RegLocation rl_keep,
  * machinery is in place, always spill lr.
  */
 
-void ArmMir2Lir::AdjustSpillMask()
-{
+void ArmMir2Lir::AdjustSpillMask() {
   core_spill_mask_ |= (1 << rARM_LR);
   num_core_spills_++;
 }
@@ -618,8 +596,7 @@ void ArmMir2Lir::AdjustSpillMask()
  * include any holes in the mask.  Associate holes with
  * Dalvik register INVALID_VREG (0xFFFFU).
  */
-void ArmMir2Lir::MarkPreservedSingle(int v_reg, int reg)
-{
+void ArmMir2Lir::MarkPreservedSingle(int v_reg, int reg) {
   DCHECK_GE(reg, ARM_FP_REG_MASK + ARM_FP_CALLEE_SAVE_BASE);
   reg = (reg & ARM_FP_REG_MASK) - ARM_FP_CALLEE_SAVE_BASE;
   // Ensure fp_vmap_table is large enough
@@ -634,8 +611,7 @@ void ArmMir2Lir::MarkPreservedSingle(int v_reg, int reg)
   fp_spill_mask_ = ((1 << num_fp_spills_) - 1) << ARM_FP_CALLEE_SAVE_BASE;
 }
 
-void ArmMir2Lir::FlushRegWide(int reg1, int reg2)
-{
+void ArmMir2Lir::FlushRegWide(int reg1, int reg2) {
   RegisterInfo* info1 = GetRegInfo(reg1);
   RegisterInfo* info2 = GetRegInfo(reg2);
   DCHECK(info1 && info2 && info1->pair && info2->pair &&
@@ -657,8 +633,7 @@ void ArmMir2Lir::FlushRegWide(int reg1, int reg2)
   }
 }
 
-void ArmMir2Lir::FlushReg(int reg)
-{
+void ArmMir2Lir::FlushReg(int reg) {
   RegisterInfo* info = GetRegInfo(reg);
   if (info->live && info->dirty) {
     info->dirty = false;
@@ -673,8 +648,7 @@ bool ArmMir2Lir::IsFpReg(int reg) {
 }
 
 /* Clobber all regs that might be used by an external C call */
-void ArmMir2Lir::ClobberCalleeSave()
-{
+void ArmMir2Lir::ClobberCalleeSave() {
   Clobber(r0);
   Clobber(r1);
   Clobber(r2);
@@ -699,8 +673,7 @@ void ArmMir2Lir::ClobberCalleeSave()
   Clobber(fr15);
 }
 
-RegLocation ArmMir2Lir::GetReturnWideAlt()
-{
+RegLocation ArmMir2Lir::GetReturnWideAlt() {
   RegLocation res = LocCReturnWide();
   res.low_reg = r2;
   res.high_reg = r3;
@@ -712,8 +685,7 @@ RegLocation ArmMir2Lir::GetReturnWideAlt()
   return res;
 }
 
-RegLocation ArmMir2Lir::GetReturnAlt()
-{
+RegLocation ArmMir2Lir::GetReturnAlt() {
   RegLocation res = LocCReturn();
   res.low_reg = r1;
   Clobber(r1);
@@ -721,15 +693,13 @@ RegLocation ArmMir2Lir::GetReturnAlt()
   return res;
 }
 
-ArmMir2Lir::RegisterInfo* ArmMir2Lir::GetRegInfo(int reg)
-{
+ArmMir2Lir::RegisterInfo* ArmMir2Lir::GetRegInfo(int reg) {
   return ARM_FPREG(reg) ? &reg_pool_->FPRegs[reg & ARM_FP_REG_MASK]
       : &reg_pool_->core_regs[reg];
 }
 
 /* To be used when explicitly managing register use */
-void ArmMir2Lir::LockCallTemps()
-{
+void ArmMir2Lir::LockCallTemps() {
   LockTemp(r0);
   LockTemp(r1);
   LockTemp(r2);
@@ -737,32 +707,27 @@ void ArmMir2Lir::LockCallTemps()
 }
 
 /* To be used when explicitly managing register use */
-void ArmMir2Lir::FreeCallTemps()
-{
+void ArmMir2Lir::FreeCallTemps() {
   FreeTemp(r0);
   FreeTemp(r1);
   FreeTemp(r2);
   FreeTemp(r3);
 }
 
-int ArmMir2Lir::LoadHelper(int offset)
-{
+int ArmMir2Lir::LoadHelper(int offset) {
   LoadWordDisp(rARM_SELF, offset, rARM_LR);
   return rARM_LR;
 }
 
-uint64_t ArmMir2Lir::GetTargetInstFlags(int opcode)
-{
+uint64_t ArmMir2Lir::GetTargetInstFlags(int opcode) {
   return ArmMir2Lir::EncodingMap[opcode].flags;
 }
 
-const char* ArmMir2Lir::GetTargetInstName(int opcode)
-{
+const char* ArmMir2Lir::GetTargetInstName(int opcode) {
   return ArmMir2Lir::EncodingMap[opcode].name;
 }
 
-const char* ArmMir2Lir::GetTargetInstFmt(int opcode)
-{
+const char* ArmMir2Lir::GetTargetInstFmt(int opcode) {
   return ArmMir2Lir::EncodingMap[opcode].fmt;
 }
 
diff --git a/compiler/dex/quick/arm/utility_arm.cc b/compiler/dex/quick/arm/utility_arm.cc
index abf921f8ad..80f597d640 100644
--- a/compiler/dex/quick/arm/utility_arm.cc
+++ b/compiler/dex/quick/arm/utility_arm.cc
@@ -22,8 +22,7 @@ namespace art {
 
 /* This file contains codegen for the Thumb ISA. */
 
-static int EncodeImmSingle(int value)
-{
+static int EncodeImmSingle(int value) {
   int res;
   int bit_a =  (value & 0x80000000) >> 31;
   int not_bit_b = (value & 0x40000000) >> 30;
@@ -48,8 +47,7 @@ static int EncodeImmSingle(int value)
  * Determine whether value can be encoded as a Thumb2 floating point
  * immediate.  If not, return -1.  If so return encoded 8-bit value.
  */
-static int EncodeImmDouble(int64_t value)
-{
+static int EncodeImmDouble(int64_t value) {
   int res;
   int bit_a = (value & 0x8000000000000000ll) >> 63;
   int not_bit_b = (value & 0x4000000000000000ll) >> 62;
@@ -70,8 +68,7 @@ static int EncodeImmDouble(int64_t value)
   return res;
 }
 
-LIR* ArmMir2Lir::LoadFPConstantValue(int r_dest, int value)
-{
+LIR* ArmMir2Lir::LoadFPConstantValue(int r_dest, int value) {
   DCHECK(ARM_SINGLEREG(r_dest));
   if (value == 0) {
     // TODO: we need better info about the target CPU.  a vector exclusive or
@@ -98,8 +95,7 @@ LIR* ArmMir2Lir::LoadFPConstantValue(int r_dest, int value)
   return load_pc_rel;
 }
 
-static int LeadingZeros(uint32_t val)
-{
+static int LeadingZeros(uint32_t val) {
   uint32_t alt;
   int n;
   int count;
@@ -121,8 +117,7 @@ static int LeadingZeros(uint32_t val)
  * Determine whether value can be encoded as a Thumb2 modified
  * immediate.  If not, return -1.  If so, return i:imm3:a:bcdefgh form.
  */
-int ArmMir2Lir::ModifiedImmediate(uint32_t value)
-{
+int ArmMir2Lir::ModifiedImmediate(uint32_t value) {
    int z_leading;
    int z_trailing;
    uint32_t b0 = value & 0xff;
@@ -151,23 +146,19 @@ int ArmMir2Lir::ModifiedImmediate(uint32_t value)
    return value | ((0x8 + z_leading) << 7); /* [01000..11111]:bcdefgh */
 }
 
-bool ArmMir2Lir::InexpensiveConstantInt(int32_t value)
-{
+bool ArmMir2Lir::InexpensiveConstantInt(int32_t value) {
   return (ModifiedImmediate(value) >= 0) || (ModifiedImmediate(~value) >= 0);
 }
 
-bool ArmMir2Lir::InexpensiveConstantFloat(int32_t value)
-{
+bool ArmMir2Lir::InexpensiveConstantFloat(int32_t value) {
   return EncodeImmSingle(value) >= 0;
 }
 
-bool ArmMir2Lir::InexpensiveConstantLong(int64_t value)
-{
+bool ArmMir2Lir::InexpensiveConstantLong(int64_t value) {
   return InexpensiveConstantInt(High32Bits(value)) && InexpensiveConstantInt(Low32Bits(value));
 }
 
-bool ArmMir2Lir::InexpensiveConstantDouble(int64_t value)
-{
+bool ArmMir2Lir::InexpensiveConstantDouble(int64_t value) {
   return EncodeImmDouble(value) >= 0;
 }
 
@@ -179,8 +170,7 @@ bool ArmMir2Lir::InexpensiveConstantDouble(int64_t value)
  * 1) r_dest is freshly returned from AllocTemp or
  * 2) The codegen is under fixed register usage
  */
-LIR* ArmMir2Lir::LoadConstantNoClobber(int r_dest, int value)
-{
+LIR* ArmMir2Lir::LoadConstantNoClobber(int r_dest, int value) {
   LIR* res;
   int mod_imm;
 
@@ -214,23 +204,20 @@ LIR* ArmMir2Lir::LoadConstantNoClobber(int r_dest, int value)
   return res;
 }
 
-LIR* ArmMir2Lir::OpUnconditionalBranch(LIR* target)
-{
+LIR* ArmMir2Lir::OpUnconditionalBranch(LIR* target) {
   LIR* res = NewLIR1(kThumbBUncond, 0 /* offset to be patched  during assembly*/);
   res->target = target;
   return res;
 }
 
-LIR* ArmMir2Lir::OpCondBranch(ConditionCode cc, LIR* target)
-{
+LIR* ArmMir2Lir::OpCondBranch(ConditionCode cc, LIR* target) {
   LIR* branch = NewLIR2(kThumb2BCond, 0 /* offset to be patched */,
                         ArmConditionEncoding(cc));
   branch->target = target;
   return branch;
 }
 
-LIR* ArmMir2Lir::OpReg(OpKind op, int r_dest_src)
-{
+LIR* ArmMir2Lir::OpReg(OpKind op, int r_dest_src) {
   ArmOpcode opcode = kThumbBkpt;
   switch (op) {
     case kOpBlx:
@@ -243,8 +230,7 @@ LIR* ArmMir2Lir::OpReg(OpKind op, int r_dest_src)
 }
 
 LIR* ArmMir2Lir::OpRegRegShift(OpKind op, int r_dest_src1, int r_src2,
-                               int shift)
-{
+                               int shift) {
   bool thumb_form = ((shift == 0) && ARM_LOWREG(r_dest_src1) && ARM_LOWREG(r_src2));
   ArmOpcode opcode = kThumbBkpt;
   switch (op) {
@@ -358,14 +344,12 @@ LIR* ArmMir2Lir::OpRegRegShift(OpKind op, int r_dest_src1, int r_src2,
   }
 }
 
-LIR* ArmMir2Lir::OpRegReg(OpKind op, int r_dest_src1, int r_src2)
-{
+LIR* ArmMir2Lir::OpRegReg(OpKind op, int r_dest_src1, int r_src2) {
   return OpRegRegShift(op, r_dest_src1, r_src2, 0);
 }
 
 LIR* ArmMir2Lir::OpRegRegRegShift(OpKind op, int r_dest, int r_src1,
-                                  int r_src2, int shift)
-{
+                                  int r_src2, int shift) {
   ArmOpcode opcode = kThumbBkpt;
   bool thumb_form = (shift == 0) && ARM_LOWREG(r_dest) && ARM_LOWREG(r_src1) &&
       ARM_LOWREG(r_src2);
@@ -430,13 +414,11 @@ LIR* ArmMir2Lir::OpRegRegRegShift(OpKind op, int r_dest, int r_src1,
   }
 }
 
-LIR* ArmMir2Lir::OpRegRegReg(OpKind op, int r_dest, int r_src1, int r_src2)
-{
+LIR* ArmMir2Lir::OpRegRegReg(OpKind op, int r_dest, int r_src1, int r_src2) {
   return OpRegRegRegShift(op, r_dest, r_src1, r_src2, 0);
 }
 
-LIR* ArmMir2Lir::OpRegRegImm(OpKind op, int r_dest, int r_src1, int value)
-{
+LIR* ArmMir2Lir::OpRegRegImm(OpKind op, int r_dest, int r_src1, int value) {
   LIR* res;
   bool neg = (value < 0);
   int abs_value = (neg) ? -value : value;
@@ -560,8 +542,7 @@ LIR* ArmMir2Lir::OpRegRegImm(OpKind op, int r_dest, int r_src1, int value)
 }
 
 /* Handle Thumb-only variants here - otherwise punt to OpRegRegImm */
-LIR* ArmMir2Lir::OpRegImm(OpKind op, int r_dest_src1, int value)
-{
+LIR* ArmMir2Lir::OpRegImm(OpKind op, int r_dest_src1, int value) {
   bool neg = (value < 0);
   int abs_value = (neg) ? -value : value;
   bool short_form = (((abs_value & 0xff) == abs_value) && ARM_LOWREG(r_dest_src1));
@@ -605,8 +586,7 @@ LIR* ArmMir2Lir::OpRegImm(OpKind op, int r_dest_src1, int value)
   }
 }
 
-LIR* ArmMir2Lir::LoadConstantWide(int r_dest_lo, int r_dest_hi, int64_t value)
-{
+LIR* ArmMir2Lir::LoadConstantWide(int r_dest_lo, int r_dest_hi, int64_t value) {
   LIR* res = NULL;
   int32_t val_lo = Low32Bits(value);
   int32_t val_hi = High32Bits(value);
@@ -656,8 +636,7 @@ int ArmMir2Lir::EncodeShift(int code, int amount) {
 }
 
 LIR* ArmMir2Lir::LoadBaseIndexed(int rBase, int r_index, int r_dest,
-                                 int scale, OpSize size)
-{
+                                 int scale, OpSize size) {
   bool all_low_regs = ARM_LOWREG(rBase) && ARM_LOWREG(r_index) && ARM_LOWREG(r_dest);
   LIR* load;
   ArmOpcode opcode = kThumbBkpt;
@@ -721,8 +700,7 @@ LIR* ArmMir2Lir::LoadBaseIndexed(int rBase, int r_index, int r_dest,
 }
 
 LIR* ArmMir2Lir::StoreBaseIndexed(int rBase, int r_index, int r_src,
-                                  int scale, OpSize size)
-{
+                                  int scale, OpSize size) {
   bool all_low_regs = ARM_LOWREG(rBase) && ARM_LOWREG(r_index) && ARM_LOWREG(r_src);
   LIR* store = NULL;
   ArmOpcode opcode = kThumbBkpt;
@@ -787,8 +765,7 @@ LIR* ArmMir2Lir::StoreBaseIndexed(int rBase, int r_index, int r_src,
  * performing null check, incoming MIR can be null.
  */
 LIR* ArmMir2Lir::LoadBaseDispBody(int rBase, int displacement, int r_dest,
-                                  int r_dest_hi, OpSize size, int s_reg)
-{
+                                  int r_dest_hi, OpSize size, int s_reg) {
   LIR* load = NULL;
   ArmOpcode opcode = kThumbBkpt;
   bool short_form = false;
@@ -908,14 +885,12 @@ LIR* ArmMir2Lir::LoadBaseDispBody(int rBase, int displacement, int r_dest,
 }
 
 LIR* ArmMir2Lir::LoadBaseDisp(int rBase, int displacement, int r_dest,
-                              OpSize size, int s_reg)
-{
+                              OpSize size, int s_reg) {
   return LoadBaseDispBody(rBase, displacement, r_dest, -1, size, s_reg);
 }
 
 LIR* ArmMir2Lir::LoadBaseDispWide(int rBase, int displacement, int r_dest_lo,
-                                  int r_dest_hi, int s_reg)
-{
+                                  int r_dest_hi, int s_reg) {
   return LoadBaseDispBody(rBase, displacement, r_dest_lo, r_dest_hi, kLong, s_reg);
 }
 
@@ -1024,19 +999,16 @@ LIR* ArmMir2Lir::StoreBaseDispBody(int rBase, int displacement,
 }
 
 LIR* ArmMir2Lir::StoreBaseDisp(int rBase, int displacement, int r_src,
-                               OpSize size)
-{
+                               OpSize size) {
   return StoreBaseDispBody(rBase, displacement, r_src, -1, size);
 }
 
 LIR* ArmMir2Lir::StoreBaseDispWide(int rBase, int displacement,
-                                   int r_src_lo, int r_src_hi)
-{
+                                   int r_src_lo, int r_src_hi) {
   return StoreBaseDispBody(rBase, displacement, r_src_lo, r_src_hi, kLong);
 }
 
-LIR* ArmMir2Lir::OpFpRegCopy(int r_dest, int r_src)
-{
+LIR* ArmMir2Lir::OpFpRegCopy(int r_dest, int r_src) {
   int opcode;
   DCHECK_EQ(ARM_DOUBLEREG(r_dest), ARM_DOUBLEREG(r_src));
   if (ARM_DOUBLEREG(r_dest)) {
@@ -1056,36 +1028,31 @@ LIR* ArmMir2Lir::OpFpRegCopy(int r_dest, int r_src)
   return res;
 }
 
-LIR* ArmMir2Lir::OpThreadMem(OpKind op, int thread_offset)
-{
+LIR* ArmMir2Lir::OpThreadMem(OpKind op, int thread_offset) {
   LOG(FATAL) << "Unexpected use of OpThreadMem for Arm";
   return NULL;
 }
 
-LIR* ArmMir2Lir::OpMem(OpKind op, int rBase, int disp)
-{
+LIR* ArmMir2Lir::OpMem(OpKind op, int rBase, int disp) {
   LOG(FATAL) << "Unexpected use of OpMem for Arm";
   return NULL;
 }
 
 LIR* ArmMir2Lir::StoreBaseIndexedDisp(int rBase, int r_index, int scale,
                                       int displacement, int r_src, int r_src_hi, OpSize size,
-                                      int s_reg)
-{
+                                      int s_reg) {
   LOG(FATAL) << "Unexpected use of StoreBaseIndexedDisp for Arm";
   return NULL;
 }
 
-LIR* ArmMir2Lir::OpRegMem(OpKind op, int r_dest, int rBase, int offset)
-{
+LIR* ArmMir2Lir::OpRegMem(OpKind op, int r_dest, int rBase, int offset) {
   LOG(FATAL) << "Unexpected use of OpRegMem for Arm";
   return NULL;
 }
 
 LIR* ArmMir2Lir::LoadBaseIndexedDisp(int rBase, int r_index, int scale,
                                      int displacement, int r_dest, int r_dest_hi, OpSize size,
-                                     int s_reg)
-{
+                                     int s_reg) {
   LOG(FATAL) << "Unexpected use of LoadBaseIndexedDisp for Arm";
   return NULL;
 }
diff --git a/compiler/dex/quick/codegen_util.cc b/compiler/dex/quick/codegen_util.cc
index 5c10c4ce2b..e728d2769b 100644
--- a/compiler/dex/quick/codegen_util.cc
+++ b/compiler/dex/quick/codegen_util.cc
@@ -23,8 +23,7 @@
 
 namespace art {
 
-bool Mir2Lir::IsInexpensiveConstant(RegLocation rl_src)
-{
+bool Mir2Lir::IsInexpensiveConstant(RegLocation rl_src) {
   bool res = false;
   if (rl_src.is_const) {
     if (rl_src.wide) {
@@ -44,27 +43,23 @@ bool Mir2Lir::IsInexpensiveConstant(RegLocation rl_src)
   return res;
 }
 
-void Mir2Lir::MarkSafepointPC(LIR* inst)
-{
+void Mir2Lir::MarkSafepointPC(LIR* inst) {
   inst->def_mask = ENCODE_ALL;
   LIR* safepoint_pc = NewLIR0(kPseudoSafepointPC);
   DCHECK_EQ(safepoint_pc->def_mask, ENCODE_ALL);
 }
 
-bool Mir2Lir::FastInstance(uint32_t field_idx, int& field_offset, bool& is_volatile, bool is_put)
-{
+bool Mir2Lir::FastInstance(uint32_t field_idx, int& field_offset, bool& is_volatile, bool is_put) {
   return cu_->compiler_driver->ComputeInstanceFieldInfo(
       field_idx, mir_graph_->GetCurrentDexCompilationUnit(), field_offset, is_volatile, is_put);
 }
 
 /* Convert an instruction to a NOP */
-void Mir2Lir::NopLIR( LIR* lir)
-{
+void Mir2Lir::NopLIR( LIR* lir) {
   lir->flags.is_nop = true;
 }
 
-void Mir2Lir::SetMemRefType(LIR* lir, bool is_load, int mem_type)
-{
+void Mir2Lir::SetMemRefType(LIR* lir, bool is_load, int mem_type) {
   uint64_t *mask_ptr;
   uint64_t mask = ENCODE_MEM;;
   DCHECK(GetTargetInstFlags(lir->opcode) & (IS_LOAD | IS_STORE));
@@ -101,8 +96,7 @@ void Mir2Lir::SetMemRefType(LIR* lir, bool is_load, int mem_type)
  * Mark load/store instructions that access Dalvik registers through the stack.
  */
 void Mir2Lir::AnnotateDalvikRegAccess(LIR* lir, int reg_id, bool is_load,
-                                      bool is64bit)
-{
+                                      bool is64bit) {
   SetMemRefType(lir, is_load, kDalvikReg);
 
   /*
@@ -118,8 +112,7 @@ void Mir2Lir::AnnotateDalvikRegAccess(LIR* lir, int reg_id, bool is_load,
 #define DUMP_RESOURCE_MASK(X)
 
 /* Pretty-print a LIR instruction */
-void Mir2Lir::DumpLIRInsn(LIR* lir, unsigned char* base_addr)
-{
+void Mir2Lir::DumpLIRInsn(LIR* lir, unsigned char* base_addr) {
   int offset = lir->offset;
   int dest = lir->operands[0];
   const bool dump_nop = (cu_->enable_debug & (1 << kDebugShowNops));
@@ -204,8 +197,7 @@ void Mir2Lir::DumpLIRInsn(LIR* lir, unsigned char* base_addr)
   }
 }
 
-void Mir2Lir::DumpPromotionMap()
-{
+void Mir2Lir::DumpPromotionMap() {
   int num_regs = cu_->num_dalvik_registers + cu_->num_compiler_temps + 1;
   for (int i = 0; i < num_regs; i++) {
     PromotionMap v_reg_map = promotion_map_[i];
@@ -249,8 +241,7 @@ void Mir2Lir::DumpMappingTable(const char* table_name, const std::string& descri
 }
 
 /* Dump instructions and constant pool contents */
-void Mir2Lir::CodegenDump()
-{
+void Mir2Lir::CodegenDump() {
   LOG(INFO) << "Dumping LIR insns for "
             << PrettyMethod(cu_->method_idx, *cu_->dex_file);
   LIR* lir_insn;
@@ -291,8 +282,7 @@ void Mir2Lir::CodegenDump()
  * Search the existing constants in the literal pool for an exact or close match
  * within specified delta (greater or equal to 0).
  */
-LIR* Mir2Lir::ScanLiteralPool(LIR* data_target, int value, unsigned int delta)
-{
+LIR* Mir2Lir::ScanLiteralPool(LIR* data_target, int value, unsigned int delta) {
   while (data_target) {
     if ((static_cast<unsigned>(value - data_target->operands[0])) <= delta)
       return data_target;
@@ -302,8 +292,7 @@ LIR* Mir2Lir::ScanLiteralPool(LIR* data_target, int value, unsigned int delta)
 }
 
 /* Search the existing constants in the literal pool for an exact wide match */
-LIR* Mir2Lir::ScanLiteralPoolWide(LIR* data_target, int val_lo, int val_hi)
-{
+LIR* Mir2Lir::ScanLiteralPoolWide(LIR* data_target, int val_lo, int val_hi) {
   bool lo_match = false;
   LIR* lo_target = NULL;
   while (data_target) {
@@ -328,8 +317,7 @@ LIR* Mir2Lir::ScanLiteralPoolWide(LIR* data_target, int val_lo, int val_hi)
  */
 
 /* Add a 32-bit constant to the constant pool */
-LIR* Mir2Lir::AddWordData(LIR* *constant_list_p, int value)
-{
+LIR* Mir2Lir::AddWordData(LIR* *constant_list_p, int value) {
   /* Add the constant to the literal pool */
   if (constant_list_p) {
     LIR* new_value = static_cast<LIR*>(arena_->NewMem(sizeof(LIR), true, ArenaAllocator::kAllocData));
@@ -342,8 +330,7 @@ LIR* Mir2Lir::AddWordData(LIR* *constant_list_p, int value)
 }
 
 /* Add a 64-bit constant to the constant pool or mixed with code */
-LIR* Mir2Lir::AddWideData(LIR* *constant_list_p, int val_lo, int val_hi)
-{
+LIR* Mir2Lir::AddWideData(LIR* *constant_list_p, int val_lo, int val_hi) {
   AddWordData(constant_list_p, val_hi);
   return AddWordData(constant_list_p, val_lo);
 }
@@ -362,8 +349,7 @@ static void AlignBuffer(std::vector<uint8_t>&buf, size_t offset) {
 }
 
 /* Write the literal pool to the output stream */
-void Mir2Lir::InstallLiteralPools()
-{
+void Mir2Lir::InstallLiteralPools() {
   AlignBuffer(code_buffer_, data_offset_);
   LIR* data_lir = literal_list_;
   while (data_lir != NULL) {
@@ -404,8 +390,7 @@ void Mir2Lir::InstallLiteralPools()
 }
 
 /* Write the switch tables to the output stream */
-void Mir2Lir::InstallSwitchTables()
-{
+void Mir2Lir::InstallSwitchTables() {
   GrowableArray<SwitchTable*>::Iterator iterator(&switch_tables_);
   while (true) {
     Mir2Lir::SwitchTable* tab_rec = iterator.Next();
@@ -462,8 +447,7 @@ void Mir2Lir::InstallSwitchTables()
 }
 
 /* Write the fill array dta to the output stream */
-void Mir2Lir::InstallFillArrayData()
-{
+void Mir2Lir::InstallFillArrayData() {
   GrowableArray<FillArrayData*>::Iterator iterator(&fill_array_data_);
   while (true) {
     Mir2Lir::FillArrayData *tab_rec = iterator.Next();
@@ -476,8 +460,7 @@ void Mir2Lir::InstallFillArrayData()
   }
 }
 
-static int AssignLiteralOffsetCommon(LIR* lir, int offset)
-{
+static int AssignLiteralOffsetCommon(LIR* lir, int offset) {
   for (;lir != NULL; lir = lir->next) {
     lir->offset = offset;
     offset += 4;
@@ -486,8 +469,7 @@ static int AssignLiteralOffsetCommon(LIR* lir, int offset)
 }
 
 // Make sure we have a code address for every declared catch entry
-bool Mir2Lir::VerifyCatchEntries()
-{
+bool Mir2Lir::VerifyCatchEntries() {
   bool success = true;
   for (std::set<uint32_t>::const_iterator it = mir_graph_->catches_.begin();
        it != mir_graph_->catches_.end(); ++it) {
@@ -521,8 +503,7 @@ bool Mir2Lir::VerifyCatchEntries()
 }
 
 
-void Mir2Lir::CreateMappingTables()
-{
+void Mir2Lir::CreateMappingTables() {
   for (LIR* tgt_lir = first_lir_insn_; tgt_lir != NULL; tgt_lir = NEXT_LIR(tgt_lir)) {
     if (!tgt_lir->flags.is_nop && (tgt_lir->opcode == kPseudoSafepointPC)) {
       pc2dex_mapping_table_.push_back(tgt_lir->offset);
@@ -650,16 +631,14 @@ void Mir2Lir::CreateNativeGcMap() {
 }
 
 /* Determine the offset of each literal field */
-int Mir2Lir::AssignLiteralOffset(int offset)
-{
+int Mir2Lir::AssignLiteralOffset(int offset) {
   offset = AssignLiteralOffsetCommon(literal_list_, offset);
   offset = AssignLiteralOffsetCommon(code_literal_list_, offset);
   offset = AssignLiteralOffsetCommon(method_literal_list_, offset);
   return offset;
 }
 
-int Mir2Lir::AssignSwitchTablesOffset(int offset)
-{
+int Mir2Lir::AssignSwitchTablesOffset(int offset) {
   GrowableArray<SwitchTable*>::Iterator iterator(&switch_tables_);
   while (true) {
     Mir2Lir::SwitchTable *tab_rec = iterator.Next();
@@ -676,8 +655,7 @@ int Mir2Lir::AssignSwitchTablesOffset(int offset)
   return offset;
 }
 
-int Mir2Lir::AssignFillArrayDataOffset(int offset)
-{
+int Mir2Lir::AssignFillArrayDataOffset(int offset) {
   GrowableArray<FillArrayData*>::Iterator iterator(&fill_array_data_);
   while (true) {
     Mir2Lir::FillArrayData *tab_rec = iterator.Next();
@@ -691,8 +669,7 @@ int Mir2Lir::AssignFillArrayDataOffset(int offset)
 }
 
 // LIR offset assignment.
-int Mir2Lir::AssignInsnOffsets()
-{
+int Mir2Lir::AssignInsnOffsets() {
   LIR* lir;
   int offset = 0;
 
@@ -720,8 +697,7 @@ int Mir2Lir::AssignInsnOffsets()
  * Walk the compilation unit and assign offsets to instructions
  * and literals and compute the total size of the compiled unit.
  */
-void Mir2Lir::AssignOffsets()
-{
+void Mir2Lir::AssignOffsets() {
   int offset = AssignInsnOffsets();
 
   /* Const values have to be word aligned */
@@ -744,8 +720,7 @@ void Mir2Lir::AssignOffsets()
  * before sending them off to the assembler. If out-of-range branch distance is
  * seen rearrange the instructions a bit to correct it.
  */
-void Mir2Lir::AssembleLIR()
-{
+void Mir2Lir::AssembleLIR() {
   AssignOffsets();
   int assembler_retries = 0;
   /*
@@ -791,8 +766,7 @@ void Mir2Lir::AssembleLIR()
  * all resource flags on this to prevent code motion across
  * target boundaries.  KeyVal is just there for debugging.
  */
-LIR* Mir2Lir::InsertCaseLabel(int vaddr, int keyVal)
-{
+LIR* Mir2Lir::InsertCaseLabel(int vaddr, int keyVal) {
   SafeMap<unsigned int, LIR*>::iterator it;
   it = boundary_map_.find(vaddr);
   if (it == boundary_map_.end()) {
@@ -806,8 +780,7 @@ LIR* Mir2Lir::InsertCaseLabel(int vaddr, int keyVal)
   return new_label;
 }
 
-void Mir2Lir::MarkPackedCaseLabels(Mir2Lir::SwitchTable *tab_rec)
-{
+void Mir2Lir::MarkPackedCaseLabels(Mir2Lir::SwitchTable *tab_rec) {
   const uint16_t* table = tab_rec->table;
   int base_vaddr = tab_rec->vaddr;
   const int *targets = reinterpret_cast<const int*>(&table[4]);
@@ -818,8 +791,7 @@ void Mir2Lir::MarkPackedCaseLabels(Mir2Lir::SwitchTable *tab_rec)
   }
 }
 
-void Mir2Lir::MarkSparseCaseLabels(Mir2Lir::SwitchTable *tab_rec)
-{
+void Mir2Lir::MarkSparseCaseLabels(Mir2Lir::SwitchTable *tab_rec) {
   const uint16_t* table = tab_rec->table;
   int base_vaddr = tab_rec->vaddr;
   int entries = table[1];
@@ -830,8 +802,7 @@ void Mir2Lir::MarkSparseCaseLabels(Mir2Lir::SwitchTable *tab_rec)
   }
 }
 
-void Mir2Lir::ProcessSwitchTables()
-{
+void Mir2Lir::ProcessSwitchTables() {
   GrowableArray<SwitchTable*>::Iterator iterator(&switch_tables_);
   while (true) {
     Mir2Lir::SwitchTable *tab_rec = iterator.Next();
@@ -846,7 +817,7 @@ void Mir2Lir::ProcessSwitchTables()
   }
 }
 
-void Mir2Lir::DumpSparseSwitchTable(const uint16_t* table)
+void Mir2Lir::DumpSparseSwitchTable(const uint16_t* table) {
   /*
    * Sparse switch data format:
    *  ushort ident = 0x0200   magic value
@@ -856,7 +827,6 @@ void Mir2Lir::DumpSparseSwitchTable(const uint16_t* table)
    *
    * Total size is (2+size*4) 16-bit code units.
    */
-{
   uint16_t ident = table[0];
   int entries = table[1];
   const int* keys = reinterpret_cast<const int*>(&table[2]);
@@ -868,7 +838,7 @@ void Mir2Lir::DumpSparseSwitchTable(const uint16_t* table)
   }
 }
 
-void Mir2Lir::DumpPackedSwitchTable(const uint16_t* table)
+void Mir2Lir::DumpPackedSwitchTable(const uint16_t* table) {
   /*
    * Packed switch data format:
    *  ushort ident = 0x0100   magic value
@@ -878,7 +848,6 @@ void Mir2Lir::DumpPackedSwitchTable(const uint16_t* table)
    *
    * Total size is (4+size*2) 16-bit code units.
    */
-{
   uint16_t ident = table[0];
   const int* targets = reinterpret_cast<const int*>(&table[4]);
   int entries = table[1];
@@ -897,8 +866,7 @@ void Mir2Lir::DumpPackedSwitchTable(const uint16_t* table)
  * which we split a single Dalvik instruction, only the first MIR op
  * associated with a Dalvik PC should be entered into the map.
  */
-LIR* Mir2Lir::MarkBoundary(int offset, const char* inst_str)
-{
+LIR* Mir2Lir::MarkBoundary(int offset, const char* inst_str) {
   LIR* res = NewLIR1(kPseudoDalvikByteCodeBoundary, reinterpret_cast<uintptr_t>(inst_str));
   if (boundary_map_.find(offset) == boundary_map_.end()) {
     boundary_map_.Put(offset, res);
@@ -906,8 +874,7 @@ LIR* Mir2Lir::MarkBoundary(int offset, const char* inst_str)
   return res;
 }
 
-bool Mir2Lir::EvaluateBranch(Instruction::Code opcode, int32_t src1, int32_t src2)
-{
+bool Mir2Lir::EvaluateBranch(Instruction::Code opcode, int32_t src1, int32_t src2) {
   bool is_taken;
   switch (opcode) {
     case Instruction::IF_EQ: is_taken = (src1 == src2); break;
@@ -971,8 +938,7 @@ Mir2Lir::Mir2Lir(CompilationUnit* cu, MIRGraph* mir_graph, ArenaAllocator* arena
       core_spill_mask_(0),
       fp_spill_mask_(0),
       first_lir_insn_(NULL),
-      last_lir_insn_(NULL)
- {
+      last_lir_insn_(NULL) {
   promotion_map_ = static_cast<PromotionMap*>
       (arena_->NewMem((cu_->num_dalvik_registers  + cu_->num_compiler_temps + 1) *
                       sizeof(promotion_map_[0]), true, ArenaAllocator::kAllocRegAlloc));
@@ -1060,8 +1026,7 @@ int Mir2Lir::ComputeFrameSize() {
  * Append an LIR instruction to the LIR list maintained by a compilation
  * unit
  */
-void Mir2Lir::AppendLIR(LIR* lir)
-{
+void Mir2Lir::AppendLIR(LIR* lir) {
   if (first_lir_insn_ == NULL) {
     DCHECK(last_lir_insn_ == NULL);
     last_lir_insn_ = first_lir_insn_ = lir;
@@ -1080,8 +1045,7 @@ void Mir2Lir::AppendLIR(LIR* lir)
  *
  * prev_lir <-> new_lir <-> current_lir
  */
-void Mir2Lir::InsertLIRBefore(LIR* current_lir, LIR* new_lir)
-{
+void Mir2Lir::InsertLIRBefore(LIR* current_lir, LIR* new_lir) {
   DCHECK(current_lir->prev != NULL);
   LIR *prev_lir = current_lir->prev;
 
@@ -1097,8 +1061,7 @@ void Mir2Lir::InsertLIRBefore(LIR* current_lir, LIR* new_lir)
  *
  * current_lir -> new_lir -> old_next
  */
-void Mir2Lir::InsertLIRAfter(LIR* current_lir, LIR* new_lir)
-{
+void Mir2Lir::InsertLIRAfter(LIR* current_lir, LIR* new_lir) {
   new_lir->prev = current_lir;
   new_lir->next = current_lir->next;
   current_lir->next = new_lir;
diff --git a/compiler/dex/quick/gen_common.cc b/compiler/dex/quick/gen_common.cc
index 865b9c5c4d..a34d2a9e76 100644
--- a/compiler/dex/quick/gen_common.cc
+++ b/compiler/dex/quick/gen_common.cc
@@ -33,8 +33,7 @@ namespace art {
  * Generate an kPseudoBarrier marker to indicate the boundary of special
  * blocks.
  */
-void Mir2Lir::GenBarrier()
-{
+void Mir2Lir::GenBarrier() {
   LIR* barrier = NewLIR0(kPseudoBarrier);
   /* Mark all resources as being clobbered */
   barrier->def_mask = -1;
@@ -42,8 +41,7 @@ void Mir2Lir::GenBarrier()
 
 // FIXME: need to do some work to split out targets with
 // condition codes and those without
-LIR* Mir2Lir::GenCheck(ConditionCode c_code, ThrowKind kind)
-{
+LIR* Mir2Lir::GenCheck(ConditionCode c_code, ThrowKind kind) {
   DCHECK_NE(cu_->instruction_set, kMips);
   LIR* tgt = RawLIR(0, kPseudoThrowTarget, kind, current_dalvik_offset_);
   LIR* branch = OpCondBranch(c_code, tgt);
@@ -52,8 +50,7 @@ LIR* Mir2Lir::GenCheck(ConditionCode c_code, ThrowKind kind)
   return branch;
 }
 
-LIR* Mir2Lir::GenImmedCheck(ConditionCode c_code, int reg, int imm_val, ThrowKind kind)
-{
+LIR* Mir2Lir::GenImmedCheck(ConditionCode c_code, int reg, int imm_val, ThrowKind kind) {
   LIR* tgt = RawLIR(0, kPseudoThrowTarget, kind, current_dalvik_offset_, reg, imm_val);
   LIR* branch;
   if (c_code == kCondAl) {
@@ -67,8 +64,7 @@ LIR* Mir2Lir::GenImmedCheck(ConditionCode c_code, int reg, int imm_val, ThrowKin
 }
 
 /* Perform null-check on a register.  */
-LIR* Mir2Lir::GenNullCheck(int s_reg, int m_reg, int opt_flags)
-{
+LIR* Mir2Lir::GenNullCheck(int s_reg, int m_reg, int opt_flags) {
   if (!(cu_->disable_opt & (1 << kNullCheckElimination)) &&
     opt_flags & MIR_IGNORE_NULL_CHECK) {
     return NULL;
@@ -78,8 +74,7 @@ LIR* Mir2Lir::GenNullCheck(int s_reg, int m_reg, int opt_flags)
 
 /* Perform check on two registers */
 LIR* Mir2Lir::GenRegRegCheck(ConditionCode c_code, int reg1, int reg2,
-                             ThrowKind kind)
-{
+                             ThrowKind kind) {
   LIR* tgt = RawLIR(0, kPseudoThrowTarget, kind, current_dalvik_offset_, reg1, reg2);
   LIR* branch = OpCmpBranch(c_code, reg1, reg2, tgt);
   // Remember branch target - will process later
@@ -89,8 +84,7 @@ LIR* Mir2Lir::GenRegRegCheck(ConditionCode c_code, int reg1, int reg2,
 
 void Mir2Lir::GenCompareAndBranch(Instruction::Code opcode, RegLocation rl_src1,
                                   RegLocation rl_src2, LIR* taken,
-                                  LIR* fall_through)
-{
+                                  LIR* fall_through) {
   ConditionCode cond;
   switch (opcode) {
     case Instruction::IF_EQ:
@@ -143,8 +137,7 @@ void Mir2Lir::GenCompareAndBranch(Instruction::Code opcode, RegLocation rl_src1,
 }
 
 void Mir2Lir::GenCompareZeroAndBranch(Instruction::Code opcode, RegLocation rl_src, LIR* taken,
-                                      LIR* fall_through)
-{
+                                      LIR* fall_through) {
   ConditionCode cond;
   rl_src = LoadValue(rl_src, kCoreReg);
   switch (opcode) {
@@ -174,8 +167,7 @@ void Mir2Lir::GenCompareZeroAndBranch(Instruction::Code opcode, RegLocation rl_s
   OpUnconditionalBranch(fall_through);
 }
 
-void Mir2Lir::GenIntToLong(RegLocation rl_dest, RegLocation rl_src)
-{
+void Mir2Lir::GenIntToLong(RegLocation rl_dest, RegLocation rl_src) {
   RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
   if (rl_src.location == kLocPhysReg) {
     OpRegCopy(rl_result.low_reg, rl_src.low_reg);
@@ -187,8 +179,7 @@ void Mir2Lir::GenIntToLong(RegLocation rl_dest, RegLocation rl_src)
 }
 
 void Mir2Lir::GenIntNarrowing(Instruction::Code opcode, RegLocation rl_dest,
-                              RegLocation rl_src)
-{
+                              RegLocation rl_src) {
    rl_src = LoadValue(rl_src, kCoreReg);
    RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
    OpKind op = kOpInvalid;
@@ -215,8 +206,7 @@ void Mir2Lir::GenIntNarrowing(Instruction::Code opcode, RegLocation rl_dest,
  * Note: AllocFromCode will handle checks for errNegativeArraySize.
  */
 void Mir2Lir::GenNewArray(uint32_t type_idx, RegLocation rl_dest,
-                          RegLocation rl_src)
-{
+                          RegLocation rl_src) {
   FlushAllRegs();  /* Everything to home location */
   int func_offset;
   if (cu_->compiler_driver->CanAccessTypeWithoutChecks(cu_->method_idx, *cu_->dex_file,
@@ -236,8 +226,7 @@ void Mir2Lir::GenNewArray(uint32_t type_idx, RegLocation rl_dest,
  * code throws runtime exception "bad Filled array req" for 'D' and 'J'.
  * Current code also throws internal unimp if not 'L', '[' or 'I'.
  */
-void Mir2Lir::GenFilledNewArray(CallInfo* info)
-{
+void Mir2Lir::GenFilledNewArray(CallInfo* info) {
   int elems = info->num_arg_words;
   int type_idx = info->index;
   FlushAllRegs();  /* Everything to home location */
@@ -342,8 +331,7 @@ void Mir2Lir::GenFilledNewArray(CallInfo* info)
 }
 
 void Mir2Lir::GenSput(uint32_t field_idx, RegLocation rl_src, bool is_long_or_double,
-                      bool is_object)
-{
+                      bool is_object) {
   int field_offset;
   int ssb_index;
   bool is_volatile;
@@ -428,8 +416,7 @@ void Mir2Lir::GenSput(uint32_t field_idx, RegLocation rl_src, bool is_long_or_do
 }
 
 void Mir2Lir::GenSget(uint32_t field_idx, RegLocation rl_dest,
-                      bool is_long_or_double, bool is_object)
-{
+                      bool is_long_or_double, bool is_object) {
   int field_offset;
   int ssb_index;
   bool is_volatile;
@@ -510,8 +497,7 @@ void Mir2Lir::GenSget(uint32_t field_idx, RegLocation rl_dest,
   }
 }
 
-void Mir2Lir::HandleSuspendLaunchPads()
-{
+void Mir2Lir::HandleSuspendLaunchPads() {
   int num_elems = suspend_launchpads_.Size();
   int helper_offset = ENTRYPOINT_OFFSET(pTestSuspendFromCode);
   for (int i = 0; i < num_elems; i++) {
@@ -527,8 +513,7 @@ void Mir2Lir::HandleSuspendLaunchPads()
   }
 }
 
-void Mir2Lir::HandleIntrinsicLaunchPads()
-{
+void Mir2Lir::HandleIntrinsicLaunchPads() {
   int num_elems = intrinsic_launchpads_.Size();
   for (int i = 0; i < num_elems; i++) {
     ResetRegPool();
@@ -546,8 +531,7 @@ void Mir2Lir::HandleIntrinsicLaunchPads()
   }
 }
 
-void Mir2Lir::HandleThrowLaunchPads()
-{
+void Mir2Lir::HandleThrowLaunchPads() {
   int num_elems = throw_launchpads_.Size();
   for (int i = 0; i < num_elems; i++) {
     ResetRegPool();
@@ -636,8 +620,7 @@ void Mir2Lir::HandleThrowLaunchPads()
 
 void Mir2Lir::GenIGet(uint32_t field_idx, int opt_flags, OpSize size,
                       RegLocation rl_dest, RegLocation rl_obj, bool is_long_or_double,
-                      bool is_object)
-{
+                      bool is_object) {
   int field_offset;
   bool is_volatile;
 
@@ -697,8 +680,7 @@ void Mir2Lir::GenIGet(uint32_t field_idx, int opt_flags, OpSize size,
 
 void Mir2Lir::GenIPut(uint32_t field_idx, int opt_flags, OpSize size,
                       RegLocation rl_src, RegLocation rl_obj, bool is_long_or_double,
-                      bool is_object)
-{
+                      bool is_object) {
   int field_offset;
   bool is_volatile;
 
@@ -744,8 +726,7 @@ void Mir2Lir::GenIPut(uint32_t field_idx, int opt_flags, OpSize size,
   }
 }
 
-void Mir2Lir::GenConstClass(uint32_t type_idx, RegLocation rl_dest)
-{
+void Mir2Lir::GenConstClass(uint32_t type_idx, RegLocation rl_dest) {
   RegLocation rl_method = LoadCurrMethod();
   int res_reg = AllocTemp();
   RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
@@ -803,8 +784,7 @@ void Mir2Lir::GenConstClass(uint32_t type_idx, RegLocation rl_dest)
   }
 }
 
-void Mir2Lir::GenConstString(uint32_t string_idx, RegLocation rl_dest)
-{
+void Mir2Lir::GenConstString(uint32_t string_idx, RegLocation rl_dest) {
   /* NOTE: Most strings should be available at compile time */
   int32_t offset_of_string = mirror::Array::DataOffset(sizeof(mirror::String*)).Int32Value() +
                  (sizeof(mirror::String*) * string_idx);
@@ -860,8 +840,7 @@ void Mir2Lir::GenConstString(uint32_t string_idx, RegLocation rl_dest)
  * Let helper function take care of everything.  Will
  * call Class::NewInstanceFromCode(type_idx, method);
  */
-void Mir2Lir::GenNewInstance(uint32_t type_idx, RegLocation rl_dest)
-{
+void Mir2Lir::GenNewInstance(uint32_t type_idx, RegLocation rl_dest) {
   FlushAllRegs();  /* Everything to home location */
   // alloc will always check for resolution, do we also need to verify
   // access because the verifier was unable to?
@@ -877,8 +856,7 @@ void Mir2Lir::GenNewInstance(uint32_t type_idx, RegLocation rl_dest)
   StoreValue(rl_dest, rl_result);
 }
 
-void Mir2Lir::GenThrow(RegLocation rl_src)
-{
+void Mir2Lir::GenThrow(RegLocation rl_src) {
   FlushAllRegs();
   CallRuntimeHelperRegLocation(ENTRYPOINT_OFFSET(pDeliverException), rl_src, true);
 }
@@ -1065,8 +1043,7 @@ void Mir2Lir::GenInstanceof(uint32_t type_idx, RegLocation rl_dest, RegLocation
   }
 }
 
-void Mir2Lir::GenCheckCast(uint32_t insn_idx, uint32_t type_idx, RegLocation rl_src)
-{
+void Mir2Lir::GenCheckCast(uint32_t insn_idx, uint32_t type_idx, RegLocation rl_src) {
   bool type_known_final, type_known_abstract, use_declaring_class;
   bool needs_access_check = !cu_->compiler_driver->CanAccessTypeWithoutChecks(cu_->method_idx,
                                                                               *cu_->dex_file,
@@ -1142,8 +1119,7 @@ void Mir2Lir::GenCheckCast(uint32_t insn_idx, uint32_t type_idx, RegLocation rl_
 }
 
 void Mir2Lir::GenLong3Addr(OpKind first_op, OpKind second_op, RegLocation rl_dest,
-                           RegLocation rl_src1, RegLocation rl_src2)
-{
+                           RegLocation rl_src1, RegLocation rl_src2) {
   RegLocation rl_result;
   if (cu_->instruction_set == kThumb2) {
     /*
@@ -1161,7 +1137,7 @@ void Mir2Lir::GenLong3Addr(OpKind first_op, OpKind second_op, RegLocation rl_des
   rl_src2 = LoadValueWide(rl_src2, kCoreReg);
   rl_result = EvalLoc(rl_dest, kCoreReg, true);
   // The longs may overlap - use intermediate temp if so
-  if ((rl_result.low_reg == rl_src1.high_reg) || (rl_result.low_reg == rl_src2.high_reg)){
+  if ((rl_result.low_reg == rl_src1.high_reg) || (rl_result.low_reg == rl_src2.high_reg)) {
     int t_reg = AllocTemp();
     OpRegRegReg(first_op, t_reg, rl_src1.low_reg, rl_src2.low_reg);
     OpRegRegReg(second_op, rl_result.high_reg, rl_src1.high_reg, rl_src2.high_reg);
@@ -1190,8 +1166,7 @@ void Mir2Lir::GenLong3Addr(OpKind first_op, OpKind second_op, RegLocation rl_des
 
 
 void Mir2Lir::GenShiftOpLong(Instruction::Code opcode, RegLocation rl_dest,
-                             RegLocation rl_src1, RegLocation rl_shift)
-{
+                             RegLocation rl_src1, RegLocation rl_shift) {
   int func_offset = -1; // Make gcc happy
 
   switch (opcode) {
@@ -1218,8 +1193,7 @@ void Mir2Lir::GenShiftOpLong(Instruction::Code opcode, RegLocation rl_dest,
 
 
 void Mir2Lir::GenArithOpInt(Instruction::Code opcode, RegLocation rl_dest,
-                            RegLocation rl_src1, RegLocation rl_src2)
-{
+                            RegLocation rl_src1, RegLocation rl_src2) {
   OpKind op = kOpBkpt;
   bool is_div_rem = false;
   bool check_zero = false;
@@ -1353,14 +1327,12 @@ void Mir2Lir::GenArithOpInt(Instruction::Code opcode, RegLocation rl_dest,
  * or produce corresponding Thumb instructions directly.
  */
 
-static bool IsPowerOfTwo(int x)
-{
+static bool IsPowerOfTwo(int x) {
   return (x & (x - 1)) == 0;
 }
 
 // Returns true if no more than two bits are set in 'x'.
-static bool IsPopCountLE2(unsigned int x)
-{
+static bool IsPopCountLE2(unsigned int x) {
   x &= x - 1;
   return (x & (x - 1)) == 0;
 }
@@ -1382,8 +1354,7 @@ static int LowestSetBit(unsigned int x) {
 // Returns true if it added instructions to 'cu' to divide 'rl_src' by 'lit'
 // and store the result in 'rl_dest'.
 bool Mir2Lir::HandleEasyDivide(Instruction::Code dalvik_opcode,
-                               RegLocation rl_src, RegLocation rl_dest, int lit)
-{
+                               RegLocation rl_src, RegLocation rl_dest, int lit) {
   if ((lit < 2) || ((cu_->instruction_set != kThumb2) && !IsPowerOfTwo(lit))) {
     return false;
   }
@@ -1435,8 +1406,7 @@ bool Mir2Lir::HandleEasyDivide(Instruction::Code dalvik_opcode,
 
 // Returns true if it added instructions to 'cu' to multiply 'rl_src' by 'lit'
 // and store the result in 'rl_dest'.
-bool Mir2Lir::HandleEasyMultiply(RegLocation rl_src, RegLocation rl_dest, int lit)
-{
+bool Mir2Lir::HandleEasyMultiply(RegLocation rl_src, RegLocation rl_dest, int lit) {
   // Can we simplify this multiplication?
   bool power_of_two = false;
   bool pop_count_le2 = false;
@@ -1476,8 +1446,7 @@ bool Mir2Lir::HandleEasyMultiply(RegLocation rl_src, RegLocation rl_dest, int li
 }
 
 void Mir2Lir::GenArithOpIntLit(Instruction::Code opcode, RegLocation rl_dest, RegLocation rl_src,
-                               int lit)
-{
+                               int lit) {
   RegLocation rl_result;
   OpKind op = static_cast<OpKind>(0);    /* Make gcc happy */
   int shift_op = false;
@@ -1613,8 +1582,7 @@ void Mir2Lir::GenArithOpIntLit(Instruction::Code opcode, RegLocation rl_dest, Re
 }
 
 void Mir2Lir::GenArithOpLong(Instruction::Code opcode, RegLocation rl_dest,
-                             RegLocation rl_src1, RegLocation rl_src2)
-{
+                             RegLocation rl_src1, RegLocation rl_src2) {
   RegLocation rl_result;
   OpKind first_op = kOpBkpt;
   OpKind second_op = kOpBkpt;
@@ -1741,8 +1709,7 @@ void Mir2Lir::GenArithOpLong(Instruction::Code opcode, RegLocation rl_dest,
 }
 
 void Mir2Lir::GenConversionCall(int func_offset,
-                                RegLocation rl_dest, RegLocation rl_src)
-{
+                                RegLocation rl_dest, RegLocation rl_src) {
   /*
    * Don't optimize the register usage since it calls out to support
    * functions
@@ -1767,8 +1734,7 @@ void Mir2Lir::GenConversionCall(int func_offset,
 }
 
 /* Check if we need to check for pending suspend request */
-void Mir2Lir::GenSuspendTest(int opt_flags)
-{
+void Mir2Lir::GenSuspendTest(int opt_flags) {
   if (NO_SUSPEND || (opt_flags & MIR_IGNORE_SUSPEND_CHECK)) {
     return;
   }
@@ -1782,8 +1748,7 @@ void Mir2Lir::GenSuspendTest(int opt_flags)
 }
 
 /* Check if we need to check for pending suspend request */
-void Mir2Lir::GenSuspendTestAndBranch(int opt_flags, LIR* target)
-{
+void Mir2Lir::GenSuspendTestAndBranch(int opt_flags, LIR* target) {
   if (NO_SUSPEND || (opt_flags & MIR_IGNORE_SUSPEND_CHECK)) {
     OpUnconditionalBranch(target);
     return;
diff --git a/compiler/dex/quick/gen_invoke.cc b/compiler/dex/quick/gen_invoke.cc
index e3993e0617..14e395cdac 100644
--- a/compiler/dex/quick/gen_invoke.cc
+++ b/compiler/dex/quick/gen_invoke.cc
@@ -37,14 +37,12 @@ namespace art {
  * has a memory call operation, part 1 is a NOP for x86.  For other targets,
  * load arguments between the two parts.
  */
-int Mir2Lir::CallHelperSetup(int helper_offset)
-{
+int Mir2Lir::CallHelperSetup(int helper_offset) {
   return (cu_->instruction_set == kX86) ? 0 : LoadHelper(helper_offset);
 }
 
 /* NOTE: if r_tgt is a temp, it will be freed following use */
-LIR* Mir2Lir::CallHelper(int r_tgt, int helper_offset, bool safepoint_pc)
-{
+LIR* Mir2Lir::CallHelper(int r_tgt, int helper_offset, bool safepoint_pc) {
   LIR* call_inst;
   if (cu_->instruction_set == kX86) {
     call_inst = OpThreadMem(kOpBlx, helper_offset);
@@ -233,8 +231,7 @@ void Mir2Lir::CallRuntimeHelperImmRegLocationRegLocation(int helper_offset,
  * ArgLocs is an array of location records describing the incoming arguments
  * with one location record per word of argument.
  */
-void Mir2Lir::FlushIns(RegLocation* ArgLocs, RegLocation rl_method)
-{
+void Mir2Lir::FlushIns(RegLocation* ArgLocs, RegLocation rl_method) {
   /*
    * Dummy up a RegLocation for the incoming Method*
    * It will attempt to keep kArg0 live (or copy it to home location
@@ -316,8 +313,7 @@ static int NextSDCallInsn(CompilationUnit* cu, CallInfo* info,
                           int state, const MethodReference& target_method,
                           uint32_t unused,
                           uintptr_t direct_code, uintptr_t direct_method,
-                          InvokeType type)
-{
+                          InvokeType type) {
   Mir2Lir* cg = static_cast<Mir2Lir*>(cu->cg.get());
   if (cu->instruction_set != kThumb2) {
     // Disable sharpening
@@ -420,8 +416,7 @@ static int NextSDCallInsn(CompilationUnit* cu, CallInfo* info,
 static int NextVCallInsn(CompilationUnit* cu, CallInfo* info,
                          int state, const MethodReference& target_method,
                          uint32_t method_idx, uintptr_t unused, uintptr_t unused2,
-                         InvokeType unused3)
-{
+                         InvokeType unused3) {
   Mir2Lir* cg = static_cast<Mir2Lir*>(cu->cg.get());
   /*
    * This is the fast path in which the target virtual method is
@@ -469,8 +464,7 @@ static int NextVCallInsn(CompilationUnit* cu, CallInfo* info,
 static int NextInterfaceCallInsn(CompilationUnit* cu, CallInfo* info, int state,
                                  const MethodReference& target_method,
                                  uint32_t unused, uintptr_t unused2,
-                                 uintptr_t direct_method, InvokeType unused4)
-{
+                                 uintptr_t direct_method, InvokeType unused4) {
   Mir2Lir* cg = static_cast<Mir2Lir*>(cu->cg.get());
   if (cu->instruction_set != kThumb2) {
     // Disable sharpening
@@ -536,8 +530,7 @@ static int NextInterfaceCallInsn(CompilationUnit* cu, CallInfo* info, int state,
 
 static int NextInvokeInsnSP(CompilationUnit* cu, CallInfo* info, int trampoline,
                             int state, const MethodReference& target_method,
-                            uint32_t method_idx)
-{
+                            uint32_t method_idx) {
   Mir2Lir* cg = static_cast<Mir2Lir*>(cu->cg.get());
   /*
    * This handles the case in which the base method is not fully
@@ -561,8 +554,7 @@ static int NextStaticCallInsnSP(CompilationUnit* cu, CallInfo* info,
                                 const MethodReference& target_method,
                                 uint32_t method_idx,
                                 uintptr_t unused, uintptr_t unused2,
-                                InvokeType unused3)
-{
+                                InvokeType unused3) {
   int trampoline = ENTRYPOINT_OFFSET(pInvokeStaticTrampolineWithAccessCheck);
   return NextInvokeInsnSP(cu, info, trampoline, state, target_method, 0);
 }
@@ -570,8 +562,7 @@ static int NextStaticCallInsnSP(CompilationUnit* cu, CallInfo* info,
 static int NextDirectCallInsnSP(CompilationUnit* cu, CallInfo* info, int state,
                                 const MethodReference& target_method,
                                 uint32_t method_idx, uintptr_t unused,
-                                uintptr_t unused2, InvokeType unused3)
-{
+                                uintptr_t unused2, InvokeType unused3) {
   int trampoline = ENTRYPOINT_OFFSET(pInvokeDirectTrampolineWithAccessCheck);
   return NextInvokeInsnSP(cu, info, trampoline, state, target_method, 0);
 }
@@ -579,8 +570,7 @@ static int NextDirectCallInsnSP(CompilationUnit* cu, CallInfo* info, int state,
 static int NextSuperCallInsnSP(CompilationUnit* cu, CallInfo* info, int state,
                                const MethodReference& target_method,
                                uint32_t method_idx, uintptr_t unused,
-                               uintptr_t unused2, InvokeType unused3)
-{
+                               uintptr_t unused2, InvokeType unused3) {
   int trampoline = ENTRYPOINT_OFFSET(pInvokeSuperTrampolineWithAccessCheck);
   return NextInvokeInsnSP(cu, info, trampoline, state, target_method, 0);
 }
@@ -588,8 +578,7 @@ static int NextSuperCallInsnSP(CompilationUnit* cu, CallInfo* info, int state,
 static int NextVCallInsnSP(CompilationUnit* cu, CallInfo* info, int state,
                            const MethodReference& target_method,
                            uint32_t method_idx, uintptr_t unused,
-                           uintptr_t unused2, InvokeType unused3)
-{
+                           uintptr_t unused2, InvokeType unused3) {
   int trampoline = ENTRYPOINT_OFFSET(pInvokeVirtualTrampolineWithAccessCheck);
   return NextInvokeInsnSP(cu, info, trampoline, state, target_method, 0);
 }
@@ -599,8 +588,7 @@ static int NextInterfaceCallInsnWithAccessCheck(CompilationUnit* cu,
                                                 const MethodReference& target_method,
                                                 uint32_t unused,
                                                 uintptr_t unused2, uintptr_t unused3,
-                                                InvokeType unused4)
-{
+                                                InvokeType unused4) {
   int trampoline = ENTRYPOINT_OFFSET(pInvokeInterfaceTrampolineWithAccessCheck);
   return NextInvokeInsnSP(cu, info, trampoline, state, target_method, 0);
 }
@@ -609,8 +597,7 @@ int Mir2Lir::LoadArgRegs(CallInfo* info, int call_state,
                          NextCallInsn next_call_insn,
                          const MethodReference& target_method,
                          uint32_t vtable_idx, uintptr_t direct_code,
-                         uintptr_t direct_method, InvokeType type, bool skip_this)
-{
+                         uintptr_t direct_method, InvokeType type, bool skip_this) {
   int last_arg_reg = TargetReg(kArg3);
   int next_reg = TargetReg(kArg1);
   int next_arg = 0;
@@ -649,8 +636,7 @@ int Mir2Lir::GenDalvikArgsNoRange(CallInfo* info,
                                   int call_state, LIR** pcrLabel, NextCallInsn next_call_insn,
                                   const MethodReference& target_method,
                                   uint32_t vtable_idx, uintptr_t direct_code,
-                                  uintptr_t direct_method, InvokeType type, bool skip_this)
-{
+                                  uintptr_t direct_method, InvokeType type, bool skip_this) {
   RegLocation rl_arg;
 
   /* If no arguments, just return */
@@ -749,8 +735,7 @@ int Mir2Lir::GenDalvikArgsRange(CallInfo* info, int call_state,
                                 LIR** pcrLabel, NextCallInsn next_call_insn,
                                 const MethodReference& target_method,
                                 uint32_t vtable_idx, uintptr_t direct_code, uintptr_t direct_method,
-                                InvokeType type, bool skip_this)
-{
+                                InvokeType type, bool skip_this) {
 
   // If we can treat it as non-range (Jumbo ops will use range form)
   if (info->num_arg_words <= 5)
@@ -833,8 +818,7 @@ int Mir2Lir::GenDalvikArgsRange(CallInfo* info, int call_state,
   return call_state;
 }
 
-RegLocation Mir2Lir::InlineTarget(CallInfo* info)
-{
+RegLocation Mir2Lir::InlineTarget(CallInfo* info) {
   RegLocation res;
   if (info->result.location == kLocInvalid) {
     res = GetReturn(false);
@@ -844,8 +828,7 @@ RegLocation Mir2Lir::InlineTarget(CallInfo* info)
   return res;
 }
 
-RegLocation Mir2Lir::InlineTargetWide(CallInfo* info)
-{
+RegLocation Mir2Lir::InlineTargetWide(CallInfo* info) {
   RegLocation res;
   if (info->result.location == kLocInvalid) {
     res = GetReturnWide(false);
@@ -855,8 +838,7 @@ RegLocation Mir2Lir::InlineTargetWide(CallInfo* info)
   return res;
 }
 
-bool Mir2Lir::GenInlinedCharAt(CallInfo* info)
-{
+bool Mir2Lir::GenInlinedCharAt(CallInfo* info) {
   if (cu_->instruction_set == kMips) {
     // TODO - add Mips implementation
     return false;
@@ -932,8 +914,7 @@ bool Mir2Lir::GenInlinedCharAt(CallInfo* info)
 }
 
 // Generates an inlined String.is_empty or String.length.
-bool Mir2Lir::GenInlinedStringIsEmptyOrLength(CallInfo* info, bool is_empty)
-{
+bool Mir2Lir::GenInlinedStringIsEmptyOrLength(CallInfo* info, bool is_empty) {
   if (cu_->instruction_set == kMips) {
     // TODO - add Mips implementation
     return false;
@@ -961,8 +942,7 @@ bool Mir2Lir::GenInlinedStringIsEmptyOrLength(CallInfo* info, bool is_empty)
   return true;
 }
 
-bool Mir2Lir::GenInlinedAbsInt(CallInfo* info)
-{
+bool Mir2Lir::GenInlinedAbsInt(CallInfo* info) {
   if (cu_->instruction_set == kMips) {
     // TODO - add Mips implementation
     return false;
@@ -980,8 +960,7 @@ bool Mir2Lir::GenInlinedAbsInt(CallInfo* info)
   return true;
 }
 
-bool Mir2Lir::GenInlinedAbsLong(CallInfo* info)
-{
+bool Mir2Lir::GenInlinedAbsLong(CallInfo* info) {
   if (cu_->instruction_set == kMips) {
     // TODO - add Mips implementation
     return false;
@@ -1022,8 +1001,7 @@ bool Mir2Lir::GenInlinedAbsLong(CallInfo* info)
   }
 }
 
-bool Mir2Lir::GenInlinedFloatCvt(CallInfo* info)
-{
+bool Mir2Lir::GenInlinedFloatCvt(CallInfo* info) {
   if (cu_->instruction_set == kMips) {
     // TODO - add Mips implementation
     return false;
@@ -1034,8 +1012,7 @@ bool Mir2Lir::GenInlinedFloatCvt(CallInfo* info)
   return true;
 }
 
-bool Mir2Lir::GenInlinedDoubleCvt(CallInfo* info)
-{
+bool Mir2Lir::GenInlinedDoubleCvt(CallInfo* info) {
   if (cu_->instruction_set == kMips) {
     // TODO - add Mips implementation
     return false;
@@ -1050,8 +1027,7 @@ bool Mir2Lir::GenInlinedDoubleCvt(CallInfo* info)
  * Fast string.index_of(I) & (II).  Tests for simple case of char <= 0xffff,
  * otherwise bails to standard library code.
  */
-bool Mir2Lir::GenInlinedIndexOf(CallInfo* info, bool zero_based)
-{
+bool Mir2Lir::GenInlinedIndexOf(CallInfo* info, bool zero_based) {
   if (cu_->instruction_set == kMips) {
     // TODO - add Mips implementation
     return false;
@@ -1094,8 +1070,7 @@ bool Mir2Lir::GenInlinedIndexOf(CallInfo* info, bool zero_based)
 }
 
 /* Fast string.compareTo(Ljava/lang/string;)I. */
-bool Mir2Lir::GenInlinedStringCompareTo(CallInfo* info)
-{
+bool Mir2Lir::GenInlinedStringCompareTo(CallInfo* info) {
   if (cu_->instruction_set == kMips) {
     // TODO - add Mips implementation
     return false;
@@ -1211,8 +1186,7 @@ bool Mir2Lir::GenInlinedUnsafePut(CallInfo* info, bool is_long,
   return true;
 }
 
-bool Mir2Lir::GenIntrinsic(CallInfo* info)
-{
+bool Mir2Lir::GenIntrinsic(CallInfo* info) {
   if (info->opt_flags & MIR_INLINED) {
     return false;
   }
@@ -1358,8 +1332,7 @@ bool Mir2Lir::GenIntrinsic(CallInfo* info)
   return false;
 }
 
-void Mir2Lir::GenInvoke(CallInfo* info)
-{
+void Mir2Lir::GenInvoke(CallInfo* info) {
   if (GenIntrinsic(info)) {
     return;
   }
diff --git a/compiler/dex/quick/gen_loadstore.cc b/compiler/dex/quick/gen_loadstore.cc
index 6a25c1db45..353910606e 100644
--- a/compiler/dex/quick/gen_loadstore.cc
+++ b/compiler/dex/quick/gen_loadstore.cc
@@ -27,8 +27,7 @@ namespace art {
  * Load an immediate value into a fixed or temp register.  Target
  * register is clobbered, and marked in_use.
  */
-LIR* Mir2Lir::LoadConstant(int r_dest, int value)
-{
+LIR* Mir2Lir::LoadConstant(int r_dest, int value) {
   if (IsTemp(r_dest)) {
     Clobber(r_dest);
     MarkInUse(r_dest);
@@ -41,8 +40,7 @@ LIR* Mir2Lir::LoadConstant(int r_dest, int value)
  * promoted floating point register, also copy a zero into the int/ref identity of
  * that sreg.
  */
-void Mir2Lir::Workaround7250540(RegLocation rl_dest, int zero_reg)
-{
+void Mir2Lir::Workaround7250540(RegLocation rl_dest, int zero_reg) {
   if (rl_dest.fp) {
     int pmap_index = SRegToPMap(rl_dest.s_reg_low);
     if (promotion_map_[pmap_index].fp_location == kLocPhysReg) {
@@ -77,14 +75,12 @@ void Mir2Lir::Workaround7250540(RegLocation rl_dest, int zero_reg)
 }
 
 /* Load a word at base + displacement.  Displacement must be word multiple */
-LIR* Mir2Lir::LoadWordDisp(int rBase, int displacement, int r_dest)
-{
+LIR* Mir2Lir::LoadWordDisp(int rBase, int displacement, int r_dest) {
   return LoadBaseDisp(rBase, displacement, r_dest, kWord,
                       INVALID_SREG);
 }
 
-LIR* Mir2Lir::StoreWordDisp(int rBase, int displacement, int r_src)
-{
+LIR* Mir2Lir::StoreWordDisp(int rBase, int displacement, int r_src) {
   return StoreBaseDisp(rBase, displacement, r_src, kWord);
 }
 
@@ -93,8 +89,7 @@ LIR* Mir2Lir::StoreWordDisp(int rBase, int displacement, int r_src)
  * using this routine, as it doesn't perform any bookkeeping regarding
  * register liveness.  That is the responsibility of the caller.
  */
-void Mir2Lir::LoadValueDirect(RegLocation rl_src, int r_dest)
-{
+void Mir2Lir::LoadValueDirect(RegLocation rl_src, int r_dest) {
   rl_src = UpdateLoc(rl_src);
   if (rl_src.location == kLocPhysReg) {
     OpRegCopy(r_dest, rl_src.low_reg);
@@ -112,8 +107,7 @@ void Mir2Lir::LoadValueDirect(RegLocation rl_src, int r_dest)
  * register.  Should be used when loading to a fixed register (for example,
  * loading arguments to an out of line call.
  */
-void Mir2Lir::LoadValueDirectFixed(RegLocation rl_src, int r_dest)
-{
+void Mir2Lir::LoadValueDirectFixed(RegLocation rl_src, int r_dest) {
   Clobber(r_dest);
   MarkInUse(r_dest);
   LoadValueDirect(rl_src, r_dest);
@@ -125,8 +119,7 @@ void Mir2Lir::LoadValueDirectFixed(RegLocation rl_src, int r_dest)
  * register liveness.  That is the responsibility of the caller.
  */
 void Mir2Lir::LoadValueDirectWide(RegLocation rl_src, int reg_lo,
-             int reg_hi)
-{
+             int reg_hi) {
   rl_src = UpdateLocWide(rl_src);
   if (rl_src.location == kLocPhysReg) {
     OpRegCopyWide(reg_lo, reg_hi, rl_src.low_reg, rl_src.high_reg);
@@ -146,8 +139,7 @@ void Mir2Lir::LoadValueDirectWide(RegLocation rl_src, int reg_lo,
  * loading arguments to an out of line call.
  */
 void Mir2Lir::LoadValueDirectWideFixed(RegLocation rl_src, int reg_lo,
-                                       int reg_hi)
-{
+                                       int reg_hi) {
   Clobber(reg_lo);
   Clobber(reg_hi);
   MarkInUse(reg_lo);
@@ -155,8 +147,7 @@ void Mir2Lir::LoadValueDirectWideFixed(RegLocation rl_src, int reg_lo,
   LoadValueDirectWide(rl_src, reg_lo, reg_hi);
 }
 
-RegLocation Mir2Lir::LoadValue(RegLocation rl_src, RegisterClass op_kind)
-{
+RegLocation Mir2Lir::LoadValue(RegLocation rl_src, RegisterClass op_kind) {
   rl_src = EvalLoc(rl_src, op_kind, false);
   if (IsInexpensiveConstant(rl_src) || rl_src.location != kLocPhysReg) {
     LoadValueDirect(rl_src, rl_src.low_reg);
@@ -166,8 +157,7 @@ RegLocation Mir2Lir::LoadValue(RegLocation rl_src, RegisterClass op_kind)
   return rl_src;
 }
 
-void Mir2Lir::StoreValue(RegLocation rl_dest, RegLocation rl_src)
-{
+void Mir2Lir::StoreValue(RegLocation rl_dest, RegLocation rl_src) {
   /*
    * Sanity checking - should never try to store to the same
    * ssa name during the compilation of a single instruction
@@ -222,8 +212,7 @@ void Mir2Lir::StoreValue(RegLocation rl_dest, RegLocation rl_src)
   }
 }
 
-RegLocation Mir2Lir::LoadValueWide(RegLocation rl_src, RegisterClass op_kind)
-{
+RegLocation Mir2Lir::LoadValueWide(RegLocation rl_src, RegisterClass op_kind) {
   DCHECK(rl_src.wide);
   rl_src = EvalLoc(rl_src, op_kind, false);
   if (IsInexpensiveConstant(rl_src) || rl_src.location != kLocPhysReg) {
@@ -235,8 +224,7 @@ RegLocation Mir2Lir::LoadValueWide(RegLocation rl_src, RegisterClass op_kind)
   return rl_src;
 }
 
-void Mir2Lir::StoreValueWide(RegLocation rl_dest, RegLocation rl_src)
-{
+void Mir2Lir::StoreValueWide(RegLocation rl_dest, RegLocation rl_src) {
   /*
    * Sanity checking - should never try to store to the same
    * ssa name during the compilation of a single instruction
@@ -299,13 +287,11 @@ void Mir2Lir::StoreValueWide(RegLocation rl_dest, RegLocation rl_src)
 }
 
 /* Utilities to load the current Method* */
-void Mir2Lir::LoadCurrMethodDirect(int r_tgt)
-{
+void Mir2Lir::LoadCurrMethodDirect(int r_tgt) {
   LoadValueDirectFixed(mir_graph_->GetMethodLoc(), r_tgt);
 }
 
-RegLocation Mir2Lir::LoadCurrMethod()
-{
+RegLocation Mir2Lir::LoadCurrMethod() {
   return LoadValue(mir_graph_->GetMethodLoc(), kCoreReg);
 }
 
diff --git a/compiler/dex/quick/local_optimizations.cc b/compiler/dex/quick/local_optimizations.cc
index ac654d8f21..eb27bf8b5d 100644
--- a/compiler/dex/quick/local_optimizations.cc
+++ b/compiler/dex/quick/local_optimizations.cc
@@ -29,8 +29,7 @@ namespace art {
 #define LDLD_DISTANCE 4
 #define LD_LATENCY 2
 
-static bool IsDalvikRegisterClobbered(LIR* lir1, LIR* lir2)
-{
+static bool IsDalvikRegisterClobbered(LIR* lir1, LIR* lir2) {
   int reg1Lo = DECODE_ALIAS_INFO_REG(lir1->alias_info);
   int reg1Hi = reg1Lo + DECODE_ALIAS_INFO_WIDE(lir1->alias_info);
   int reg2Lo = DECODE_ALIAS_INFO_REG(lir2->alias_info);
@@ -40,8 +39,7 @@ static bool IsDalvikRegisterClobbered(LIR* lir1, LIR* lir2)
 }
 
 /* Convert a more expensive instruction (ie load) into a move */
-void Mir2Lir::ConvertMemOpIntoMove(LIR* orig_lir, int dest, int src)
-{
+void Mir2Lir::ConvertMemOpIntoMove(LIR* orig_lir, int dest, int src) {
   /* Insert a move to replace the load */
   LIR* move_lir;
   move_lir = OpRegCopyNoInsert(dest, src);
@@ -72,8 +70,7 @@ void Mir2Lir::ConvertMemOpIntoMove(LIR* orig_lir, int dest, int src)
  *   1) They are must-aliases
  *   2) The memory location is not written to in between
  */
-void Mir2Lir::ApplyLoadStoreElimination(LIR* head_lir, LIR* tail_lir)
-{
+void Mir2Lir::ApplyLoadStoreElimination(LIR* head_lir, LIR* tail_lir) {
   LIR* this_lir;
 
   if (head_lir == tail_lir) return;
@@ -268,8 +265,7 @@ void Mir2Lir::ApplyLoadStoreElimination(LIR* head_lir, LIR* tail_lir)
  * Perform a pass of bottom-up walk, from the second instruction in the
  * superblock, to try to hoist loads to earlier slots.
  */
-void Mir2Lir::ApplyLoadHoisting(LIR* head_lir, LIR* tail_lir)
-{
+void Mir2Lir::ApplyLoadHoisting(LIR* head_lir, LIR* tail_lir) {
   LIR* this_lir, *check_lir;
   /*
    * Store the list of independent instructions that can be hoisted past.
@@ -447,8 +443,7 @@ void Mir2Lir::ApplyLoadHoisting(LIR* head_lir, LIR* tail_lir)
   }
 }
 
-void Mir2Lir::ApplyLocalOptimizations(LIR* head_lir, LIR* tail_lir)
-{
+void Mir2Lir::ApplyLocalOptimizations(LIR* head_lir, LIR* tail_lir) {
   if (!(cu_->disable_opt & (1 << kLoadStoreElimination))) {
     ApplyLoadStoreElimination(head_lir, tail_lir);
   }
@@ -462,8 +457,7 @@ void Mir2Lir::ApplyLocalOptimizations(LIR* head_lir, LIR* tail_lir)
  * Note: new redundant branches may be inserted later, and we'll
  * use a check in final instruction assembly to nop those out.
  */
-void Mir2Lir::RemoveRedundantBranches()
-{
+void Mir2Lir::RemoveRedundantBranches() {
   LIR* this_lir;
 
   for (this_lir = first_lir_insn_; this_lir != last_lir_insn_; this_lir = NEXT_LIR(this_lir)) {
diff --git a/compiler/dex/quick/mips/assemble_mips.cc b/compiler/dex/quick/mips/assemble_mips.cc
index 2482aa4fbb..dcfb13f549 100644
--- a/compiler/dex/quick/mips/assemble_mips.cc
+++ b/compiler/dex/quick/mips/assemble_mips.cc
@@ -457,8 +457,7 @@ const MipsEncodingMap MipsMir2Lir::EncodingMap[kMipsLast] = {
  * NOTE: An out-of-range bal isn't supported because it should
  * never happen with the current PIC model.
  */
-void MipsMir2Lir::ConvertShortToLongBranch(LIR* lir)
-{
+void MipsMir2Lir::ConvertShortToLongBranch(LIR* lir) {
   // For conditional branches we'll need to reverse the sense
   bool unconditional = false;
   int opcode = lir->opcode;
@@ -513,8 +512,7 @@ void MipsMir2Lir::ConvertShortToLongBranch(LIR* lir)
  * instruction.  In those cases we will try to substitute a new code
  * sequence or request that the trace be shortened and retried.
  */
-AssemblerStatus MipsMir2Lir::AssembleInstructions(uintptr_t start_addr)
-{
+AssemblerStatus MipsMir2Lir::AssembleInstructions(uintptr_t start_addr) {
   LIR *lir;
   AssemblerStatus res = kSuccess;  // Assume success
 
@@ -708,8 +706,7 @@ AssemblerStatus MipsMir2Lir::AssembleInstructions(uintptr_t start_addr)
   return res;
 }
 
-int MipsMir2Lir::GetInsnSize(LIR* lir)
-{
+int MipsMir2Lir::GetInsnSize(LIR* lir) {
   return EncodingMap[lir->opcode].size;
 }
 
diff --git a/compiler/dex/quick/mips/call_mips.cc b/compiler/dex/quick/mips/call_mips.cc
index eb0302e80f..db5764336a 100644
--- a/compiler/dex/quick/mips/call_mips.cc
+++ b/compiler/dex/quick/mips/call_mips.cc
@@ -24,8 +24,7 @@
 namespace art {
 
 void MipsMir2Lir::GenSpecialCase(BasicBlock* bb, MIR* mir,
-                                 SpecialCaseHandler special_case)
-{
+                                 SpecialCaseHandler special_case) {
     // TODO
 }
 
@@ -61,8 +60,7 @@ void MipsMir2Lir::GenSpecialCase(BasicBlock* bb, MIR* mir,
  *
  */
 void MipsMir2Lir::GenSparseSwitch(MIR* mir, uint32_t table_offset,
-                                  RegLocation rl_src)
-{
+                                  RegLocation rl_src) {
   const uint16_t* table = cu_->insns + current_dalvik_offset_ + table_offset;
   if (cu_->verbose) {
     DumpSparseSwitchTable(table);
@@ -142,8 +140,7 @@ void MipsMir2Lir::GenSparseSwitch(MIR* mir, uint32_t table_offset,
  * done:
  */
 void MipsMir2Lir::GenPackedSwitch(MIR* mir, uint32_t table_offset,
-                                  RegLocation rl_src)
-{
+                                  RegLocation rl_src) {
   const uint16_t* table = cu_->insns + current_dalvik_offset_ + table_offset;
   if (cu_->verbose) {
     DumpPackedSwitchTable(table);
@@ -227,8 +224,7 @@ void MipsMir2Lir::GenPackedSwitch(MIR* mir, uint32_t table_offset,
  *
  * Total size is 4+(width * size + 1)/2 16-bit code units.
  */
-void MipsMir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src)
-{
+void MipsMir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src) {
   const uint16_t* table = cu_->insns + current_dalvik_offset_ + table_offset;
   // Add the table to the list - we'll process it later
   FillArrayData *tab_rec =
@@ -270,8 +266,7 @@ void MipsMir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src)
 /*
  * TODO: implement fast path to short-circuit thin-lock case
  */
-void MipsMir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src)
-{
+void MipsMir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src) {
   FlushAllRegs();
   LoadValueDirectFixed(rl_src, rMIPS_ARG0);  // Get obj
   LockCallTemps();  // Prepare for explicit register usage
@@ -286,8 +281,7 @@ void MipsMir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src)
 /*
  * TODO: implement fast path to short-circuit thin-lock case
  */
-void MipsMir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src)
-{
+void MipsMir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src) {
   FlushAllRegs();
   LoadValueDirectFixed(rl_src, rMIPS_ARG0);  // Get obj
   LockCallTemps();  // Prepare for explicit register usage
@@ -299,8 +293,7 @@ void MipsMir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src)
   MarkSafepointPC(call_inst);
 }
 
-void MipsMir2Lir::GenMoveException(RegLocation rl_dest)
-{
+void MipsMir2Lir::GenMoveException(RegLocation rl_dest) {
   int ex_offset = Thread::ExceptionOffset().Int32Value();
   RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
   int reset_reg = AllocTemp();
@@ -314,8 +307,7 @@ void MipsMir2Lir::GenMoveException(RegLocation rl_dest)
 /*
  * Mark garbage collection card. Skip if the value we're storing is null.
  */
-void MipsMir2Lir::MarkGCCard(int val_reg, int tgt_addr_reg)
-{
+void MipsMir2Lir::MarkGCCard(int val_reg, int tgt_addr_reg) {
   int reg_card_base = AllocTemp();
   int reg_card_no = AllocTemp();
   LIR* branch_over = OpCmpImmBranch(kCondEq, val_reg, 0, NULL);
@@ -328,8 +320,7 @@ void MipsMir2Lir::MarkGCCard(int val_reg, int tgt_addr_reg)
   FreeTemp(reg_card_base);
   FreeTemp(reg_card_no);
 }
-void MipsMir2Lir::GenEntrySequence(RegLocation* ArgLocs, RegLocation rl_method)
-{
+void MipsMir2Lir::GenEntrySequence(RegLocation* ArgLocs, RegLocation rl_method) {
   int spill_count = num_core_spills_ + num_fp_spills_;
   /*
    * On entry, rMIPS_ARG0, rMIPS_ARG1, rMIPS_ARG2 & rMIPS_ARG3 are live.  Let the register
@@ -375,8 +366,7 @@ void MipsMir2Lir::GenEntrySequence(RegLocation* ArgLocs, RegLocation rl_method)
   FreeTemp(rMIPS_ARG3);
 }
 
-void MipsMir2Lir::GenExitSequence()
-{
+void MipsMir2Lir::GenExitSequence() {
   /*
    * In the exit path, rMIPS_RET0/rMIPS_RET1 are live - make sure they aren't
    * allocated by the register utilities as temps.
diff --git a/compiler/dex/quick/mips/fp_mips.cc b/compiler/dex/quick/mips/fp_mips.cc
index 8581d5beb6..2e744a2afc 100644
--- a/compiler/dex/quick/mips/fp_mips.cc
+++ b/compiler/dex/quick/mips/fp_mips.cc
@@ -22,8 +22,7 @@
 namespace art {
 
 void MipsMir2Lir::GenArithOpFloat(Instruction::Code opcode,
-                                  RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2)
-{
+                                  RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2) {
   int op = kMipsNop;
   RegLocation rl_result;
 
@@ -69,8 +68,7 @@ void MipsMir2Lir::GenArithOpFloat(Instruction::Code opcode,
 }
 
 void MipsMir2Lir::GenArithOpDouble(Instruction::Code opcode,
-                                   RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2)
-{
+                                   RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2) {
   int op = kMipsNop;
   RegLocation rl_result;
 
@@ -117,8 +115,7 @@ void MipsMir2Lir::GenArithOpDouble(Instruction::Code opcode,
 }
 
 void MipsMir2Lir::GenConversion(Instruction::Code opcode, RegLocation rl_dest,
-                                RegLocation rl_src)
-{
+                                RegLocation rl_src) {
   int op = kMipsNop;
   int src_reg;
   RegLocation rl_result;
@@ -175,8 +172,7 @@ void MipsMir2Lir::GenConversion(Instruction::Code opcode, RegLocation rl_dest,
 }
 
 void MipsMir2Lir::GenCmpFP(Instruction::Code opcode, RegLocation rl_dest,
-                           RegLocation rl_src1, RegLocation rl_src2)
-{
+                           RegLocation rl_src1, RegLocation rl_src2) {
   bool wide = true;
   int offset = -1; // Make gcc happy.
 
@@ -215,13 +211,11 @@ void MipsMir2Lir::GenCmpFP(Instruction::Code opcode, RegLocation rl_dest,
 }
 
 void MipsMir2Lir::GenFusedFPCmpBranch(BasicBlock* bb, MIR* mir,
-                                bool gt_bias, bool is_double)
-{
+                                bool gt_bias, bool is_double) {
   UNIMPLEMENTED(FATAL) << "Need codegen for fused fp cmp branch";
 }
 
-void MipsMir2Lir::GenNegFloat(RegLocation rl_dest, RegLocation rl_src)
-{
+void MipsMir2Lir::GenNegFloat(RegLocation rl_dest, RegLocation rl_src) {
   RegLocation rl_result;
   rl_src = LoadValue(rl_src, kCoreReg);
   rl_result = EvalLoc(rl_dest, kCoreReg, true);
@@ -229,8 +223,7 @@ void MipsMir2Lir::GenNegFloat(RegLocation rl_dest, RegLocation rl_src)
   StoreValue(rl_dest, rl_result);
 }
 
-void MipsMir2Lir::GenNegDouble(RegLocation rl_dest, RegLocation rl_src)
-{
+void MipsMir2Lir::GenNegDouble(RegLocation rl_dest, RegLocation rl_src) {
   RegLocation rl_result;
   rl_src = LoadValueWide(rl_src, kCoreReg);
   rl_result = EvalLoc(rl_dest, kCoreReg, true);
@@ -239,8 +232,7 @@ void MipsMir2Lir::GenNegDouble(RegLocation rl_dest, RegLocation rl_src)
   StoreValueWide(rl_dest, rl_result);
 }
 
-bool MipsMir2Lir::GenInlinedMinMaxInt(CallInfo* info, bool is_min)
-{
+bool MipsMir2Lir::GenInlinedMinMaxInt(CallInfo* info, bool is_min) {
   // TODO: need Mips implementation
   return false;
 }
diff --git a/compiler/dex/quick/mips/int_mips.cc b/compiler/dex/quick/mips/int_mips.cc
index 8bfc4e1f91..03a58cc958 100644
--- a/compiler/dex/quick/mips/int_mips.cc
+++ b/compiler/dex/quick/mips/int_mips.cc
@@ -41,8 +41,7 @@ namespace art {
  *
  */
 void MipsMir2Lir::GenCmpLong(RegLocation rl_dest, RegLocation rl_src1,
-                             RegLocation rl_src2)
-{
+                             RegLocation rl_src2) {
   rl_src1 = LoadValueWide(rl_src1, kCoreReg);
   rl_src2 = LoadValueWide(rl_src2, kCoreReg);
   int t0 = AllocTemp();
@@ -63,8 +62,7 @@ void MipsMir2Lir::GenCmpLong(RegLocation rl_dest, RegLocation rl_src1,
 }
 
 LIR* MipsMir2Lir::OpCmpBranch(ConditionCode cond, int src1, int src2,
-                              LIR* target)
-{
+                              LIR* target) {
   LIR* branch;
   MipsOpCode slt_op;
   MipsOpCode br_op;
@@ -131,8 +129,7 @@ LIR* MipsMir2Lir::OpCmpBranch(ConditionCode cond, int src1, int src2,
 }
 
 LIR* MipsMir2Lir::OpCmpImmBranch(ConditionCode cond, int reg,
-                                 int check_value, LIR* target)
-{
+                                 int check_value, LIR* target) {
   LIR* branch;
   if (check_value != 0) {
     // TUNING: handle s16 & kCondLt/Mi case using slti
@@ -164,8 +161,7 @@ LIR* MipsMir2Lir::OpCmpImmBranch(ConditionCode cond, int reg,
   return branch;
 }
 
-LIR* MipsMir2Lir::OpRegCopyNoInsert(int r_dest, int r_src)
-{
+LIR* MipsMir2Lir::OpRegCopyNoInsert(int r_dest, int r_src) {
   if (MIPS_FPREG(r_dest) || MIPS_FPREG(r_src))
     return OpFpRegCopy(r_dest, r_src);
   LIR* res = RawLIR(current_dalvik_offset_, kMipsMove,
@@ -176,16 +172,14 @@ LIR* MipsMir2Lir::OpRegCopyNoInsert(int r_dest, int r_src)
   return res;
 }
 
-LIR* MipsMir2Lir::OpRegCopy(int r_dest, int r_src)
-{
+LIR* MipsMir2Lir::OpRegCopy(int r_dest, int r_src) {
   LIR *res = OpRegCopyNoInsert(r_dest, r_src);
   AppendLIR(res);
   return res;
 }
 
 void MipsMir2Lir::OpRegCopyWide(int dest_lo, int dest_hi, int src_lo,
-                                int src_hi)
-{
+                                int src_hi) {
   bool dest_fp = MIPS_FPREG(dest_lo) && MIPS_FPREG(dest_hi);
   bool src_fp = MIPS_FPREG(src_lo) && MIPS_FPREG(src_hi);
   assert(MIPS_FPREG(src_lo) == MIPS_FPREG(src_hi));
@@ -215,26 +209,22 @@ void MipsMir2Lir::OpRegCopyWide(int dest_lo, int dest_hi, int src_lo,
   }
 }
 
-void MipsMir2Lir::GenSelect(BasicBlock* bb, MIR* mir)
-{
+void MipsMir2Lir::GenSelect(BasicBlock* bb, MIR* mir) {
   UNIMPLEMENTED(FATAL) << "Need codegen for select";
 }
 
-void MipsMir2Lir::GenFusedLongCmpBranch(BasicBlock* bb, MIR* mir)
-{
+void MipsMir2Lir::GenFusedLongCmpBranch(BasicBlock* bb, MIR* mir) {
   UNIMPLEMENTED(FATAL) << "Need codegen for fused long cmp branch";
 }
 
 LIR* MipsMir2Lir::GenRegMemCheck(ConditionCode c_code,
-                    int reg1, int base, int offset, ThrowKind kind)
-{
+                    int reg1, int base, int offset, ThrowKind kind) {
   LOG(FATAL) << "Unexpected use of GenRegMemCheck for Arm";
   return NULL;
 }
 
 RegLocation MipsMir2Lir::GenDivRem(RegLocation rl_dest, int reg1, int reg2,
-                                    bool is_div)
-{
+                                    bool is_div) {
   NewLIR4(kMipsDiv, r_HI, r_LO, reg1, reg2);
   RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
   if (is_div) {
@@ -246,8 +236,7 @@ RegLocation MipsMir2Lir::GenDivRem(RegLocation rl_dest, int reg1, int reg2,
 }
 
 RegLocation MipsMir2Lir::GenDivRemLit(RegLocation rl_dest, int reg1, int lit,
-                                       bool is_div)
-{
+                                       bool is_div) {
   int t_reg = AllocTemp();
   NewLIR3(kMipsAddiu, t_reg, r_ZERO, lit);
   NewLIR4(kMipsDiv, r_HI, r_LO, reg1, t_reg);
@@ -261,13 +250,11 @@ RegLocation MipsMir2Lir::GenDivRemLit(RegLocation rl_dest, int reg1, int lit,
   return rl_result;
 }
 
-void MipsMir2Lir::OpLea(int rBase, int reg1, int reg2, int scale, int offset)
-{
+void MipsMir2Lir::OpLea(int rBase, int reg1, int reg2, int scale, int offset) {
   LOG(FATAL) << "Unexpected use of OpLea for Arm";
 }
 
-void MipsMir2Lir::OpTlsCmp(int offset, int val)
-{
+void MipsMir2Lir::OpTlsCmp(int offset, int val) {
   LOG(FATAL) << "Unexpected use of OpTlsCmp for Arm";
 }
 
@@ -286,22 +273,19 @@ LIR* MipsMir2Lir::OpPcRelLoad(int reg, LIR* target) {
   return NULL;
 }
 
-LIR* MipsMir2Lir::OpVldm(int rBase, int count)
-{
+LIR* MipsMir2Lir::OpVldm(int rBase, int count) {
   LOG(FATAL) << "Unexpected use of OpVldm for Mips";
   return NULL;
 }
 
-LIR* MipsMir2Lir::OpVstm(int rBase, int count)
-{
+LIR* MipsMir2Lir::OpVstm(int rBase, int count) {
   LOG(FATAL) << "Unexpected use of OpVstm for Mips";
   return NULL;
 }
 
 void MipsMir2Lir::GenMultiplyByTwoBitMultiplier(RegLocation rl_src,
                                                 RegLocation rl_result, int lit,
-                                                int first_bit, int second_bit)
-{
+                                                int first_bit, int second_bit) {
   int t_reg = AllocTemp();
   OpRegRegImm(kOpLsl, t_reg, rl_src.low_reg, second_bit - first_bit);
   OpRegRegReg(kOpAdd, rl_result.low_reg, rl_src.low_reg, t_reg);
@@ -311,8 +295,7 @@ void MipsMir2Lir::GenMultiplyByTwoBitMultiplier(RegLocation rl_src,
   }
 }
 
-void MipsMir2Lir::GenDivZeroCheck(int reg_lo, int reg_hi)
-{
+void MipsMir2Lir::GenDivZeroCheck(int reg_lo, int reg_hi) {
   int t_reg = AllocTemp();
   OpRegRegReg(kOpOr, t_reg, reg_lo, reg_hi);
   GenImmedCheck(kCondEq, t_reg, 0, kThrowDivZero);
@@ -320,41 +303,35 @@ void MipsMir2Lir::GenDivZeroCheck(int reg_lo, int reg_hi)
 }
 
 // Test suspend flag, return target of taken suspend branch
-LIR* MipsMir2Lir::OpTestSuspend(LIR* target)
-{
+LIR* MipsMir2Lir::OpTestSuspend(LIR* target) {
   OpRegImm(kOpSub, rMIPS_SUSPEND, 1);
   return OpCmpImmBranch((target == NULL) ? kCondEq : kCondNe, rMIPS_SUSPEND, 0, target);
 }
 
 // Decrement register and branch on condition
-LIR* MipsMir2Lir::OpDecAndBranch(ConditionCode c_code, int reg, LIR* target)
-{
+LIR* MipsMir2Lir::OpDecAndBranch(ConditionCode c_code, int reg, LIR* target) {
   OpRegImm(kOpSub, reg, 1);
   return OpCmpImmBranch(c_code, reg, 0, target);
 }
 
 bool MipsMir2Lir::SmallLiteralDivide(Instruction::Code dalvik_opcode,
-                                     RegLocation rl_src, RegLocation rl_dest, int lit)
-{
+                                     RegLocation rl_src, RegLocation rl_dest, int lit) {
   LOG(FATAL) << "Unexpected use of smallLiteralDive in Mips";
   return false;
 }
 
-LIR* MipsMir2Lir::OpIT(ConditionCode cond, const char* guide)
-{
+LIR* MipsMir2Lir::OpIT(ConditionCode cond, const char* guide) {
   LOG(FATAL) << "Unexpected use of OpIT in Mips";
   return NULL;
 }
 
 void MipsMir2Lir::GenMulLong(RegLocation rl_dest, RegLocation rl_src1,
-                             RegLocation rl_src2)
-{
+                             RegLocation rl_src2) {
   LOG(FATAL) << "Unexpected use of GenMulLong for Mips";
 }
 
 void MipsMir2Lir::GenAddLong(RegLocation rl_dest, RegLocation rl_src1,
-                             RegLocation rl_src2)
-{
+                             RegLocation rl_src2) {
   rl_src1 = LoadValueWide(rl_src1, kCoreReg);
   rl_src2 = LoadValueWide(rl_src2, kCoreReg);
   RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
@@ -376,8 +353,7 @@ void MipsMir2Lir::GenAddLong(RegLocation rl_dest, RegLocation rl_src1,
 }
 
 void MipsMir2Lir::GenSubLong(RegLocation rl_dest, RegLocation rl_src1,
-                             RegLocation rl_src2)
-{
+                             RegLocation rl_src2) {
   rl_src1 = LoadValueWide(rl_src1, kCoreReg);
   rl_src2 = LoadValueWide(rl_src2, kCoreReg);
   RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
@@ -398,8 +374,7 @@ void MipsMir2Lir::GenSubLong(RegLocation rl_dest, RegLocation rl_src1,
   StoreValueWide(rl_dest, rl_result);
 }
 
-void MipsMir2Lir::GenNegLong(RegLocation rl_dest, RegLocation rl_src)
-{
+void MipsMir2Lir::GenNegLong(RegLocation rl_dest, RegLocation rl_src) {
   rl_src = LoadValueWide(rl_src, kCoreReg);
   RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
   /*
@@ -420,20 +395,17 @@ void MipsMir2Lir::GenNegLong(RegLocation rl_dest, RegLocation rl_src)
 }
 
 void MipsMir2Lir::GenAndLong(RegLocation rl_dest, RegLocation rl_src1,
-                             RegLocation rl_src2)
-{
+                             RegLocation rl_src2) {
   LOG(FATAL) << "Unexpected use of GenAndLong for Mips";
 }
 
 void MipsMir2Lir::GenOrLong(RegLocation rl_dest, RegLocation rl_src1,
-                            RegLocation rl_src2)
-{
+                            RegLocation rl_src2) {
   LOG(FATAL) << "Unexpected use of GenOrLong for Mips";
 }
 
 void MipsMir2Lir::GenXorLong(RegLocation rl_dest, RegLocation rl_src1,
-                             RegLocation rl_src2)
-{
+                             RegLocation rl_src2) {
   LOG(FATAL) << "Unexpected use of GenXorLong for Mips";
 }
 
@@ -441,8 +413,7 @@ void MipsMir2Lir::GenXorLong(RegLocation rl_dest, RegLocation rl_src1,
  * Generate array load
  */
 void MipsMir2Lir::GenArrayGet(int opt_flags, OpSize size, RegLocation rl_array,
-                          RegLocation rl_index, RegLocation rl_dest, int scale)
-{
+                          RegLocation rl_index, RegLocation rl_dest, int scale) {
   RegisterClass reg_class = oat_reg_class_by_size(size);
   int len_offset = mirror::Array::LengthOffset().Int32Value();
   int data_offset;
@@ -513,8 +484,7 @@ void MipsMir2Lir::GenArrayGet(int opt_flags, OpSize size, RegLocation rl_array,
  *
  */
 void MipsMir2Lir::GenArrayPut(int opt_flags, OpSize size, RegLocation rl_array,
-                          RegLocation rl_index, RegLocation rl_src, int scale)
-{
+                          RegLocation rl_index, RegLocation rl_src, int scale) {
   RegisterClass reg_class = oat_reg_class_by_size(size);
   int len_offset = mirror::Array::LengthOffset().Int32Value();
   int data_offset;
@@ -586,8 +556,7 @@ void MipsMir2Lir::GenArrayPut(int opt_flags, OpSize size, RegLocation rl_array,
  *
  */
 void MipsMir2Lir::GenArrayObjPut(int opt_flags, RegLocation rl_array,
-                             RegLocation rl_index, RegLocation rl_src, int scale)
-{
+                             RegLocation rl_index, RegLocation rl_src, int scale) {
   int len_offset = mirror::Array::LengthOffset().Int32Value();
   int data_offset = mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value();
 
@@ -643,15 +612,13 @@ void MipsMir2Lir::GenArrayObjPut(int opt_flags, RegLocation rl_array,
 }
 
 void MipsMir2Lir::GenShiftImmOpLong(Instruction::Code opcode, RegLocation rl_dest,
-                                    RegLocation rl_src1, RegLocation rl_shift)
-{
+                                    RegLocation rl_src1, RegLocation rl_shift) {
   // Default implementation is just to ignore the constant case.
   GenShiftOpLong(opcode, rl_dest, rl_src1, rl_shift);
 }
 
 void MipsMir2Lir::GenArithImmOpLong(Instruction::Code opcode,
-                                    RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2)
-{
+                                    RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2) {
   // Default - bail to non-const handler.
   GenArithOpLong(opcode, rl_dest, rl_src1, rl_src2);
 }
diff --git a/compiler/dex/quick/mips/target_mips.cc b/compiler/dex/quick/mips/target_mips.cc
index cab2c1b53d..bd20e00404 100644
--- a/compiler/dex/quick/mips/target_mips.cc
+++ b/compiler/dex/quick/mips/target_mips.cc
@@ -36,26 +36,22 @@ static int FpRegs[] = {r_F0, r_F1, r_F2, r_F3, r_F4, r_F5, r_F6, r_F7,
 static int fp_temps[] = {r_F0, r_F1, r_F2, r_F3, r_F4, r_F5, r_F6, r_F7,
                          r_F8, r_F9, r_F10, r_F11, r_F12, r_F13, r_F14, r_F15};
 
-RegLocation MipsMir2Lir::LocCReturn()
-{
+RegLocation MipsMir2Lir::LocCReturn() {
   RegLocation res = MIPS_LOC_C_RETURN;
   return res;
 }
 
-RegLocation MipsMir2Lir::LocCReturnWide()
-{
+RegLocation MipsMir2Lir::LocCReturnWide() {
   RegLocation res = MIPS_LOC_C_RETURN_WIDE;
   return res;
 }
 
-RegLocation MipsMir2Lir::LocCReturnFloat()
-{
+RegLocation MipsMir2Lir::LocCReturnFloat() {
   RegLocation res = MIPS_LOC_C_RETURN_FLOAT;
   return res;
 }
 
-RegLocation MipsMir2Lir::LocCReturnDouble()
-{
+RegLocation MipsMir2Lir::LocCReturnDouble() {
   RegLocation res = MIPS_LOC_C_RETURN_DOUBLE;
   return res;
 }
@@ -86,28 +82,24 @@ int MipsMir2Lir::TargetReg(SpecialTargetRegister reg) {
 }
 
 // Create a double from a pair of singles.
-int MipsMir2Lir::S2d(int low_reg, int high_reg)
-{
+int MipsMir2Lir::S2d(int low_reg, int high_reg) {
   return MIPS_S2D(low_reg, high_reg);
 }
 
 // Return mask to strip off fp reg flags and bias.
-uint32_t MipsMir2Lir::FpRegMask()
-{
+uint32_t MipsMir2Lir::FpRegMask() {
   return MIPS_FP_REG_MASK;
 }
 
 // True if both regs single, both core or both double.
-bool MipsMir2Lir::SameRegType(int reg1, int reg2)
-{
+bool MipsMir2Lir::SameRegType(int reg1, int reg2) {
   return (MIPS_REGTYPE(reg1) == MIPS_REGTYPE(reg2));
 }
 
 /*
  * Decode the register id.
  */
-uint64_t MipsMir2Lir::GetRegMaskCommon(int reg)
-{
+uint64_t MipsMir2Lir::GetRegMaskCommon(int reg) {
   uint64_t seed;
   int shift;
   int reg_id;
@@ -123,14 +115,12 @@ uint64_t MipsMir2Lir::GetRegMaskCommon(int reg)
   return (seed << shift);
 }
 
-uint64_t MipsMir2Lir::GetPCUseDefEncoding()
-{
+uint64_t MipsMir2Lir::GetPCUseDefEncoding() {
   return ENCODE_MIPS_REG_PC;
 }
 
 
-void MipsMir2Lir::SetupTargetResourceMasks(LIR* lir)
-{
+void MipsMir2Lir::SetupTargetResourceMasks(LIR* lir) {
   DCHECK_EQ(cu_->instruction_set, kMips);
 
   // Mips-specific resource map setup here.
@@ -162,8 +152,7 @@ static const char *mips_reg_name[MIPS_REG_COUNT] = {
  * Interpret a format string and build a string no longer than size
  * See format key in Assemble.c.
  */
-std::string MipsMir2Lir::BuildInsnString(const char *fmt, LIR *lir, unsigned char* base_addr)
-{
+std::string MipsMir2Lir::BuildInsnString(const char *fmt, LIR *lir, unsigned char* base_addr) {
   std::string buf;
   int i;
   const char *fmt_end = &fmt[strlen(fmt)];
@@ -255,8 +244,7 @@ std::string MipsMir2Lir::BuildInsnString(const char *fmt, LIR *lir, unsigned cha
 }
 
 // FIXME: need to redo resource maps for MIPS - fix this at that time
-void MipsMir2Lir::DumpResourceMask(LIR *mips_lir, uint64_t mask, const char *prefix)
-{
+void MipsMir2Lir::DumpResourceMask(LIR *mips_lir, uint64_t mask, const char *prefix) {
   char buf[256];
   buf[0] = 0;
 
@@ -306,8 +294,7 @@ void MipsMir2Lir::DumpResourceMask(LIR *mips_lir, uint64_t mask, const char *pre
  * machinery is in place, always spill lr.
  */
 
-void MipsMir2Lir::AdjustSpillMask()
-{
+void MipsMir2Lir::AdjustSpillMask() {
   core_spill_mask_ |= (1 << r_RA);
   num_core_spills_++;
 }
@@ -318,13 +305,11 @@ void MipsMir2Lir::AdjustSpillMask()
  * include any holes in the mask.  Associate holes with
  * Dalvik register INVALID_VREG (0xFFFFU).
  */
-void MipsMir2Lir::MarkPreservedSingle(int s_reg, int reg)
-{
+void MipsMir2Lir::MarkPreservedSingle(int s_reg, int reg) {
   LOG(FATAL) << "No support yet for promoted FP regs";
 }
 
-void MipsMir2Lir::FlushRegWide(int reg1, int reg2)
-{
+void MipsMir2Lir::FlushRegWide(int reg1, int reg2) {
   RegisterInfo* info1 = GetRegInfo(reg1);
   RegisterInfo* info2 = GetRegInfo(reg2);
   DCHECK(info1 && info2 && info1->pair && info2->pair &&
@@ -345,8 +330,7 @@ void MipsMir2Lir::FlushRegWide(int reg1, int reg2)
   }
 }
 
-void MipsMir2Lir::FlushReg(int reg)
-{
+void MipsMir2Lir::FlushReg(int reg) {
   RegisterInfo* info = GetRegInfo(reg);
   if (info->live && info->dirty) {
     info->dirty = false;
@@ -361,8 +345,7 @@ bool MipsMir2Lir::IsFpReg(int reg) {
 }
 
 /* Clobber all regs that might be used by an external C call */
-void MipsMir2Lir::ClobberCalleeSave()
-{
+void MipsMir2Lir::ClobberCalleeSave() {
   Clobber(r_ZERO);
   Clobber(r_AT);
   Clobber(r_V0);
@@ -404,29 +387,25 @@ void MipsMir2Lir::ClobberCalleeSave()
   Clobber(r_F15);
 }
 
-RegLocation MipsMir2Lir::GetReturnWideAlt()
-{
+RegLocation MipsMir2Lir::GetReturnWideAlt() {
   UNIMPLEMENTED(FATAL) << "No GetReturnWideAlt for MIPS";
   RegLocation res = LocCReturnWide();
   return res;
 }
 
-RegLocation MipsMir2Lir::GetReturnAlt()
-{
+RegLocation MipsMir2Lir::GetReturnAlt() {
   UNIMPLEMENTED(FATAL) << "No GetReturnAlt for MIPS";
   RegLocation res = LocCReturn();
   return res;
 }
 
-MipsMir2Lir::RegisterInfo* MipsMir2Lir::GetRegInfo(int reg)
-{
+MipsMir2Lir::RegisterInfo* MipsMir2Lir::GetRegInfo(int reg) {
   return MIPS_FPREG(reg) ? &reg_pool_->FPRegs[reg & MIPS_FP_REG_MASK]
             : &reg_pool_->core_regs[reg];
 }
 
 /* To be used when explicitly managing register use */
-void MipsMir2Lir::LockCallTemps()
-{
+void MipsMir2Lir::LockCallTemps() {
   LockTemp(rMIPS_ARG0);
   LockTemp(rMIPS_ARG1);
   LockTemp(rMIPS_ARG2);
@@ -434,16 +413,14 @@ void MipsMir2Lir::LockCallTemps()
 }
 
 /* To be used when explicitly managing register use */
-void MipsMir2Lir::FreeCallTemps()
-{
+void MipsMir2Lir::FreeCallTemps() {
   FreeTemp(rMIPS_ARG0);
   FreeTemp(rMIPS_ARG1);
   FreeTemp(rMIPS_ARG2);
   FreeTemp(rMIPS_ARG3);
 }
 
-void MipsMir2Lir::GenMemBarrier(MemBarrierKind barrier_kind)
-{
+void MipsMir2Lir::GenMemBarrier(MemBarrierKind barrier_kind) {
 #if ANDROID_SMP != 0
   NewLIR1(kMipsSync, 0 /* Only stype currently supported */);
 #endif
@@ -454,8 +431,7 @@ void MipsMir2Lir::GenMemBarrier(MemBarrierKind barrier_kind)
  * high reg in next byte.
  */
 int MipsMir2Lir::AllocTypedTempPair(bool fp_hint,
-                  int reg_class)
-{
+                  int reg_class) {
   int high_reg;
   int low_reg;
   int res = 0;
@@ -473,17 +449,14 @@ int MipsMir2Lir::AllocTypedTempPair(bool fp_hint,
   return res;
 }
 
-int MipsMir2Lir::AllocTypedTemp(bool fp_hint, int reg_class)
-{
-  if (((reg_class == kAnyReg) && fp_hint) || (reg_class == kFPReg))
-{
+int MipsMir2Lir::AllocTypedTemp(bool fp_hint, int reg_class) {
+  if (((reg_class == kAnyReg) && fp_hint) || (reg_class == kFPReg)) {
     return AllocTempFloat();
 }
   return AllocTemp();
 }
 
-void MipsMir2Lir::CompilerInitializeRegAlloc()
-{
+void MipsMir2Lir::CompilerInitializeRegAlloc() {
   int num_regs = sizeof(core_regs)/sizeof(*core_regs);
   int num_reserved = sizeof(ReservedRegs)/sizeof(*ReservedRegs);
   int num_temps = sizeof(core_temps)/sizeof(*core_temps);
@@ -518,8 +491,7 @@ void MipsMir2Lir::CompilerInitializeRegAlloc()
   }
 }
 
-void MipsMir2Lir::FreeRegLocTemps(RegLocation rl_keep, RegLocation rl_free)
-{
+void MipsMir2Lir::FreeRegLocTemps(RegLocation rl_keep, RegLocation rl_free) {
   if ((rl_free.low_reg != rl_keep.low_reg) && (rl_free.low_reg != rl_keep.high_reg) &&
     (rl_free.high_reg != rl_keep.low_reg) && (rl_free.high_reg != rl_keep.high_reg)) {
     // No overlap, free both
@@ -533,14 +505,12 @@ void MipsMir2Lir::FreeRegLocTemps(RegLocation rl_keep, RegLocation rl_free)
  * ensure that all branch instructions can be restarted if
  * there is a trap in the shadow.  Allocate a temp register.
  */
-int MipsMir2Lir::LoadHelper(int offset)
-{
+int MipsMir2Lir::LoadHelper(int offset) {
   LoadWordDisp(rMIPS_SELF, offset, r_T9);
   return r_T9;
 }
 
-void MipsMir2Lir::SpillCoreRegs()
-{
+void MipsMir2Lir::SpillCoreRegs() {
   if (num_core_spills_ == 0) {
     return;
   }
@@ -555,8 +525,7 @@ void MipsMir2Lir::SpillCoreRegs()
   }
 }
 
-void MipsMir2Lir::UnSpillCoreRegs()
-{
+void MipsMir2Lir::UnSpillCoreRegs() {
   if (num_core_spills_ == 0) {
     return;
   }
@@ -571,8 +540,7 @@ void MipsMir2Lir::UnSpillCoreRegs()
   OpRegImm(kOpAdd, rMIPS_SP, frame_size_);
 }
 
-bool MipsMir2Lir::IsUnconditionalBranch(LIR* lir)
-{
+bool MipsMir2Lir::IsUnconditionalBranch(LIR* lir) {
   return (lir->opcode == kMipsB);
 }
 
@@ -592,18 +560,15 @@ Mir2Lir* MipsCodeGenerator(CompilationUnit* const cu, MIRGraph* const mir_graph,
   return new MipsMir2Lir(cu, mir_graph, arena);
 }
 
-uint64_t MipsMir2Lir::GetTargetInstFlags(int opcode)
-{
+uint64_t MipsMir2Lir::GetTargetInstFlags(int opcode) {
   return MipsMir2Lir::EncodingMap[opcode].flags;
 }
 
-const char* MipsMir2Lir::GetTargetInstName(int opcode)
-{
+const char* MipsMir2Lir::GetTargetInstName(int opcode) {
   return MipsMir2Lir::EncodingMap[opcode].name;
 }
 
-const char* MipsMir2Lir::GetTargetInstFmt(int opcode)
-{
+const char* MipsMir2Lir::GetTargetInstFmt(int opcode) {
   return MipsMir2Lir::EncodingMap[opcode].fmt;
 }
 
diff --git a/compiler/dex/quick/mips/utility_mips.cc b/compiler/dex/quick/mips/utility_mips.cc
index 8daafc8d96..089764ff45 100644
--- a/compiler/dex/quick/mips/utility_mips.cc
+++ b/compiler/dex/quick/mips/utility_mips.cc
@@ -21,8 +21,7 @@
 namespace art {
 
 /* This file contains codegen for the MIPS32 ISA. */
-LIR* MipsMir2Lir::OpFpRegCopy(int r_dest, int r_src)
-{
+LIR* MipsMir2Lir::OpFpRegCopy(int r_dest, int r_src) {
   int opcode;
   /* must be both DOUBLE or both not DOUBLE */
   DCHECK_EQ(MIPS_DOUBLEREG(r_dest),MIPS_DOUBLEREG(r_src));
@@ -51,23 +50,19 @@ LIR* MipsMir2Lir::OpFpRegCopy(int r_dest, int r_src)
   return res;
 }
 
-bool MipsMir2Lir::InexpensiveConstantInt(int32_t value)
-{
+bool MipsMir2Lir::InexpensiveConstantInt(int32_t value) {
   return ((value == 0) || IsUint(16, value) || ((value < 0) && (value >= -32768)));
 }
 
-bool MipsMir2Lir::InexpensiveConstantFloat(int32_t value)
-{
+bool MipsMir2Lir::InexpensiveConstantFloat(int32_t value) {
   return false;  // TUNING
 }
 
-bool MipsMir2Lir::InexpensiveConstantLong(int64_t value)
-{
+bool MipsMir2Lir::InexpensiveConstantLong(int64_t value) {
   return false;  // TUNING
 }
 
-bool MipsMir2Lir::InexpensiveConstantDouble(int64_t value)
-{
+bool MipsMir2Lir::InexpensiveConstantDouble(int64_t value) {
   return false; // TUNING
 }
 
@@ -80,8 +75,7 @@ bool MipsMir2Lir::InexpensiveConstantDouble(int64_t value)
  * 1) r_dest is freshly returned from AllocTemp or
  * 2) The codegen is under fixed register usage
  */
-LIR* MipsMir2Lir::LoadConstantNoClobber(int r_dest, int value)
-{
+LIR* MipsMir2Lir::LoadConstantNoClobber(int r_dest, int value) {
   LIR *res;
 
   int r_dest_save = r_dest;
@@ -112,15 +106,13 @@ LIR* MipsMir2Lir::LoadConstantNoClobber(int r_dest, int value)
   return res;
 }
 
-LIR* MipsMir2Lir::OpUnconditionalBranch(LIR* target)
-{
+LIR* MipsMir2Lir::OpUnconditionalBranch(LIR* target) {
   LIR* res = NewLIR1(kMipsB, 0 /* offset to be patched during assembly*/ );
   res->target = target;
   return res;
 }
 
-LIR* MipsMir2Lir::OpReg(OpKind op, int r_dest_src)
-{
+LIR* MipsMir2Lir::OpReg(OpKind op, int r_dest_src) {
   MipsOpCode opcode = kMipsNop;
   switch (op) {
     case kOpBlx:
@@ -136,8 +128,7 @@ LIR* MipsMir2Lir::OpReg(OpKind op, int r_dest_src)
 }
 
 LIR* MipsMir2Lir::OpRegImm(OpKind op, int r_dest_src1,
-          int value)
-{
+          int value) {
   LIR *res;
   bool neg = (value < 0);
   int abs_value = (neg) ? -value : value;
@@ -167,8 +158,7 @@ LIR* MipsMir2Lir::OpRegImm(OpKind op, int r_dest_src1,
   return res;
 }
 
-LIR* MipsMir2Lir::OpRegRegReg(OpKind op, int r_dest, int r_src1, int r_src2)
-{
+LIR* MipsMir2Lir::OpRegRegReg(OpKind op, int r_dest, int r_src1, int r_src2) {
   MipsOpCode opcode = kMipsNop;
   switch (op) {
     case kOpAdd:
@@ -209,8 +199,7 @@ LIR* MipsMir2Lir::OpRegRegReg(OpKind op, int r_dest, int r_src1, int r_src2)
   return NewLIR3(opcode, r_dest, r_src1, r_src2);
 }
 
-LIR* MipsMir2Lir::OpRegRegImm(OpKind op, int r_dest, int r_src1, int value)
-{
+LIR* MipsMir2Lir::OpRegRegImm(OpKind op, int r_dest, int r_src1, int value) {
   LIR *res;
   MipsOpCode opcode = kMipsNop;
   bool short_form = true;
@@ -298,8 +287,7 @@ LIR* MipsMir2Lir::OpRegRegImm(OpKind op, int r_dest, int r_src1, int value)
   return res;
 }
 
-LIR* MipsMir2Lir::OpRegReg(OpKind op, int r_dest_src1, int r_src2)
-{
+LIR* MipsMir2Lir::OpRegReg(OpKind op, int r_dest_src1, int r_src2) {
   MipsOpCode opcode = kMipsNop;
   LIR *res;
   switch (op) {
@@ -342,8 +330,7 @@ LIR* MipsMir2Lir::OpRegReg(OpKind op, int r_dest_src1, int r_src2)
   return NewLIR2(opcode, r_dest_src1, r_src2);
 }
 
-LIR* MipsMir2Lir::LoadConstantWide(int r_dest_lo, int r_dest_hi, int64_t value)
-{
+LIR* MipsMir2Lir::LoadConstantWide(int r_dest_lo, int r_dest_hi, int64_t value) {
   LIR *res;
   res = LoadConstantNoClobber(r_dest_lo, Low32Bits(value));
   LoadConstantNoClobber(r_dest_hi, High32Bits(value));
@@ -352,8 +339,7 @@ LIR* MipsMir2Lir::LoadConstantWide(int r_dest_lo, int r_dest_hi, int64_t value)
 
 /* Load value from base + scaled index. */
 LIR* MipsMir2Lir::LoadBaseIndexed(int rBase, int r_index, int r_dest,
-                                  int scale, OpSize size)
-{
+                                  int scale, OpSize size) {
   LIR *first = NULL;
   LIR *res;
   MipsOpCode opcode = kMipsNop;
@@ -405,8 +391,7 @@ LIR* MipsMir2Lir::LoadBaseIndexed(int rBase, int r_index, int r_dest,
 
 /* store value base base + scaled index. */
 LIR* MipsMir2Lir::StoreBaseIndexed(int rBase, int r_index, int r_src,
-                                   int scale, OpSize size)
-{
+                                   int scale, OpSize size) {
   LIR *first = NULL;
   MipsOpCode opcode = kMipsNop;
   int r_new_index = r_index;
@@ -452,7 +437,7 @@ LIR* MipsMir2Lir::StoreBaseIndexed(int rBase, int r_index, int r_src,
 }
 
 LIR* MipsMir2Lir::LoadBaseDispBody(int rBase, int displacement, int r_dest,
-                                   int r_dest_hi, OpSize size, int s_reg)
+                                   int r_dest_hi, OpSize size, int s_reg) {
 /*
  * Load value from base + displacement.  Optionally perform null check
  * on base (which must have an associated s_reg and MIR).  If not
@@ -461,7 +446,6 @@ LIR* MipsMir2Lir::LoadBaseDispBody(int rBase, int displacement, int r_dest,
  * and base and dest are the same, spill some other register to
  * rlp and then restore.
  */
-{
   LIR *res;
   LIR *load = NULL;
   LIR *load2 = NULL;
@@ -551,21 +535,18 @@ LIR* MipsMir2Lir::LoadBaseDispBody(int rBase, int displacement, int r_dest,
 }
 
 LIR* MipsMir2Lir::LoadBaseDisp(int rBase, int displacement, int r_dest,
-                               OpSize size, int s_reg)
-{
+                               OpSize size, int s_reg) {
   return LoadBaseDispBody(rBase, displacement, r_dest, -1,
                           size, s_reg);
 }
 
 LIR* MipsMir2Lir::LoadBaseDispWide(int rBase, int displacement,
-                                   int r_dest_lo, int r_dest_hi, int s_reg)
-{
+                                   int r_dest_lo, int r_dest_hi, int s_reg) {
   return LoadBaseDispBody(rBase, displacement, r_dest_lo, r_dest_hi, kLong, s_reg);
 }
 
 LIR* MipsMir2Lir::StoreBaseDispBody(int rBase, int displacement,
-                                    int r_src, int r_src_hi, OpSize size)
-{
+                                    int r_src, int r_src_hi, OpSize size) {
   LIR *res;
   LIR *store = NULL;
   LIR *store2 = NULL;
@@ -647,52 +628,44 @@ LIR* MipsMir2Lir::StoreBaseDispBody(int rBase, int displacement,
 }
 
 LIR* MipsMir2Lir::StoreBaseDisp(int rBase, int displacement, int r_src,
-                                OpSize size)
-{
+                                OpSize size) {
   return StoreBaseDispBody(rBase, displacement, r_src, -1, size);
 }
 
 LIR* MipsMir2Lir::StoreBaseDispWide(int rBase, int displacement,
-                                    int r_src_lo, int r_src_hi)
-{
+                                    int r_src_lo, int r_src_hi) {
   return StoreBaseDispBody(rBase, displacement, r_src_lo, r_src_hi, kLong);
 }
 
-LIR* MipsMir2Lir::OpThreadMem(OpKind op, int thread_offset)
-{
+LIR* MipsMir2Lir::OpThreadMem(OpKind op, int thread_offset) {
   LOG(FATAL) << "Unexpected use of OpThreadMem for MIPS";
   return NULL;
 }
 
-LIR* MipsMir2Lir::OpMem(OpKind op, int rBase, int disp)
-{
+LIR* MipsMir2Lir::OpMem(OpKind op, int rBase, int disp) {
   LOG(FATAL) << "Unexpected use of OpMem for MIPS";
   return NULL;
 }
 
 LIR* MipsMir2Lir::StoreBaseIndexedDisp( int rBase, int r_index, int scale, int displacement,
-                                        int r_src, int r_src_hi, OpSize size, int s_reg)
-{
+                                        int r_src, int r_src_hi, OpSize size, int s_reg) {
   LOG(FATAL) << "Unexpected use of StoreBaseIndexedDisp for MIPS";
   return NULL;
 }
 
 LIR* MipsMir2Lir::OpRegMem(OpKind op, int r_dest, int rBase,
-              int offset)
-{
+              int offset) {
   LOG(FATAL) << "Unexpected use of OpRegMem for MIPS";
   return NULL;
 }
 
 LIR* MipsMir2Lir::LoadBaseIndexedDisp(int rBase, int r_index, int scale, int displacement,
-                                      int r_dest, int r_dest_hi, OpSize size, int s_reg)
-{
+                                      int r_dest, int r_dest_hi, OpSize size, int s_reg) {
   LOG(FATAL) << "Unexpected use of LoadBaseIndexedDisp for MIPS";
   return NULL;
 }
 
-LIR* MipsMir2Lir::OpCondBranch(ConditionCode cc, LIR* target)
-{
+LIR* MipsMir2Lir::OpCondBranch(ConditionCode cc, LIR* target) {
   LOG(FATAL) << "Unexpected use of OpCondBranch for MIPS";
   return NULL;
 }
diff --git a/compiler/dex/quick/mir_to_lir.cc b/compiler/dex/quick/mir_to_lir.cc
index 4562482a06..b758fb538e 100644
--- a/compiler/dex/quick/mir_to_lir.cc
+++ b/compiler/dex/quick/mir_to_lir.cc
@@ -26,8 +26,7 @@ namespace art {
  * load/store utilities here, or target-dependent genXX() handlers
  * when necessary.
  */
-void Mir2Lir::CompileDalvikInstruction(MIR* mir, BasicBlock* bb, LIR* label_list)
-{
+void Mir2Lir::CompileDalvikInstruction(MIR* mir, BasicBlock* bb, LIR* label_list) {
   RegLocation rl_src[3];
   RegLocation rl_dest = mir_graph_->GetBadLoc();
   RegLocation rl_result = mir_graph_->GetBadLoc();
@@ -659,8 +658,7 @@ void Mir2Lir::CompileDalvikInstruction(MIR* mir, BasicBlock* bb, LIR* label_list
 }
 
 // Process extended MIR instructions
-void Mir2Lir::HandleExtendedMethodMIR(BasicBlock* bb, MIR* mir)
-{
+void Mir2Lir::HandleExtendedMethodMIR(BasicBlock* bb, MIR* mir) {
   switch (static_cast<ExtendedMIROpcode>(mir->dalvikInsn.opcode)) {
     case kMirOpCopy: {
       RegLocation rl_src = mir_graph_->GetSrc(mir, 0);
@@ -692,8 +690,7 @@ void Mir2Lir::HandleExtendedMethodMIR(BasicBlock* bb, MIR* mir)
 }
 
 // Handle the content in each basic block.
-bool Mir2Lir::MethodBlockCodeGen(BasicBlock* bb)
-{
+bool Mir2Lir::MethodBlockCodeGen(BasicBlock* bb) {
   if (bb->block_type == kDead) return false;
   current_dalvik_offset_ = bb->start_offset;
   MIR* mir;
@@ -787,8 +784,7 @@ bool Mir2Lir::MethodBlockCodeGen(BasicBlock* bb)
   return false;
 }
 
-void Mir2Lir::SpecialMIR2LIR(SpecialCaseHandler special_case)
-{
+void Mir2Lir::SpecialMIR2LIR(SpecialCaseHandler special_case) {
   // Find the first DalvikByteCode block.
   int num_reachable_blocks = mir_graph_->GetNumReachableBlocks();
   BasicBlock*bb = NULL;
@@ -817,8 +813,7 @@ void Mir2Lir::SpecialMIR2LIR(SpecialCaseHandler special_case)
   GenSpecialCase(bb, mir, special_case);
 }
 
-void Mir2Lir::MethodMIR2LIR()
-{
+void Mir2Lir::MethodMIR2LIR() {
   // Hold the labels of each block.
   block_label_list_ =
       static_cast<LIR*>(arena_->NewMem(sizeof(LIR) * mir_graph_->GetNumBlocks(), true,
diff --git a/compiler/dex/quick/mir_to_lir.h b/compiler/dex/quick/mir_to_lir.h
index bec86c181e..abb687cb84 100644
--- a/compiler/dex/quick/mir_to_lir.h
+++ b/compiler/dex/quick/mir_to_lir.h
@@ -226,7 +226,7 @@ class Mir2Lir : public Backend {
       bool first_in_pair;
     };
 
-    virtual ~Mir2Lir(){};
+    virtual ~Mir2Lir() {};
 
     int32_t s4FromSwitchData(const void* switch_data) {
       return *reinterpret_cast<const int32_t*>(switch_data);
diff --git a/compiler/dex/quick/ralloc_util.cc b/compiler/dex/quick/ralloc_util.cc
index 8f43542098..4c91223687 100644
--- a/compiler/dex/quick/ralloc_util.cc
+++ b/compiler/dex/quick/ralloc_util.cc
@@ -27,8 +27,7 @@ namespace art {
  * not affect the "liveness" of a temp register, which will stay
  * live until it is either explicitly killed or reallocated.
  */
-void Mir2Lir::ResetRegPool()
-{
+void Mir2Lir::ResetRegPool() {
   int i;
   for (i=0; i < reg_pool_->num_core_regs; i++) {
     if (reg_pool_->core_regs[i].is_temp)
@@ -48,8 +47,7 @@ void Mir2Lir::ResetRegPool()
   * Set up temp & preserved register pools specialized by target.
   * Note: num_regs may be zero.
   */
-void Mir2Lir::CompilerInitPool(RegisterInfo* regs, int* reg_nums, int num)
-{
+void Mir2Lir::CompilerInitPool(RegisterInfo* regs, int* reg_nums, int num) {
   int i;
   for (i=0; i < num; i++) {
     regs[i].reg = reg_nums[i];
@@ -62,8 +60,7 @@ void Mir2Lir::CompilerInitPool(RegisterInfo* regs, int* reg_nums, int num)
   }
 }
 
-void Mir2Lir::DumpRegPool(RegisterInfo* p, int num_regs)
-{
+void Mir2Lir::DumpRegPool(RegisterInfo* p, int num_regs) {
   LOG(INFO) << "================================================";
   for (int i = 0; i < num_regs; i++) {
     LOG(INFO) << StringPrintf(
@@ -75,18 +72,15 @@ void Mir2Lir::DumpRegPool(RegisterInfo* p, int num_regs)
   LOG(INFO) << "================================================";
 }
 
-void Mir2Lir::DumpCoreRegPool()
-{
+void Mir2Lir::DumpCoreRegPool() {
   DumpRegPool(reg_pool_->core_regs, reg_pool_->num_core_regs);
 }
 
-void Mir2Lir::DumpFpRegPool()
-{
+void Mir2Lir::DumpFpRegPool() {
   DumpRegPool(reg_pool_->FPRegs, reg_pool_->num_fp_regs);
 }
 
-void Mir2Lir::ClobberSRegBody(RegisterInfo* p, int num_regs, int s_reg)
-{
+void Mir2Lir::ClobberSRegBody(RegisterInfo* p, int num_regs, int s_reg) {
   int i;
   for (i=0; i< num_regs; i++) {
     if (p[i].s_reg == s_reg) {
@@ -110,8 +104,7 @@ void Mir2Lir::ClobberSRegBody(RegisterInfo* p, int num_regs, int s_reg)
  * changes (for example: INT_TO_FLOAT v1, v1).  Revisit when improved register allocation is
  * addressed.
  */
-void Mir2Lir::ClobberSReg(int s_reg)
-{
+void Mir2Lir::ClobberSReg(int s_reg) {
   /* Reset live temp tracking sanity checker */
   if (kIsDebugBuild) {
     if (s_reg == live_sreg_) {
@@ -131,8 +124,7 @@ void Mir2Lir::ClobberSReg(int s_reg)
  * ssa name (above the last original Dalvik register).  This function
  * maps SSA names to positions in the promotion_map array.
  */
-int Mir2Lir::SRegToPMap(int s_reg)
-{
+int Mir2Lir::SRegToPMap(int s_reg) {
   DCHECK_LT(s_reg, mir_graph_->GetNumSSARegs());
   DCHECK_GE(s_reg, 0);
   int v_reg = mir_graph_->SRegToVReg(s_reg);
@@ -146,8 +138,7 @@ int Mir2Lir::SRegToPMap(int s_reg)
   }
 }
 
-void Mir2Lir::RecordCorePromotion(int reg, int s_reg)
-{
+void Mir2Lir::RecordCorePromotion(int reg, int s_reg) {
   int p_map_idx = SRegToPMap(s_reg);
   int v_reg = mir_graph_->SRegToVReg(s_reg);
   GetRegInfo(reg)->in_use = true;
@@ -160,8 +151,7 @@ void Mir2Lir::RecordCorePromotion(int reg, int s_reg)
 }
 
 /* Reserve a callee-save register.  Return -1 if none available */
-int Mir2Lir::AllocPreservedCoreReg(int s_reg)
-{
+int Mir2Lir::AllocPreservedCoreReg(int s_reg) {
   int res = -1;
   RegisterInfo* core_regs = reg_pool_->core_regs;
   for (int i = 0; i < reg_pool_->num_core_regs; i++) {
@@ -174,8 +164,7 @@ int Mir2Lir::AllocPreservedCoreReg(int s_reg)
   return res;
 }
 
-void Mir2Lir::RecordFpPromotion(int reg, int s_reg)
-{
+void Mir2Lir::RecordFpPromotion(int reg, int s_reg) {
   int p_map_idx = SRegToPMap(s_reg);
   int v_reg = mir_graph_->SRegToVReg(s_reg);
   GetRegInfo(reg)->in_use = true;
@@ -189,8 +178,7 @@ void Mir2Lir::RecordFpPromotion(int reg, int s_reg)
  * even/odd  allocation, but go ahead and allocate anything if not
  * available.  If nothing's available, return -1.
  */
-int Mir2Lir::AllocPreservedSingle(int s_reg, bool even)
-{
+int Mir2Lir::AllocPreservedSingle(int s_reg, bool even) {
   int res = -1;
   RegisterInfo* FPRegs = reg_pool_->FPRegs;
   for (int i = 0; i < reg_pool_->num_fp_regs; i++) {
@@ -212,8 +200,7 @@ int Mir2Lir::AllocPreservedSingle(int s_reg, bool even)
  * allocate if we can't meet the requirements for the pair of
  * s_reg<=sX[even] & (s_reg+1)<= sX+1.
  */
-int Mir2Lir::AllocPreservedDouble(int s_reg)
-{
+int Mir2Lir::AllocPreservedDouble(int s_reg) {
   int res = -1; // Assume failure
   int v_reg = mir_graph_->SRegToVReg(s_reg);
   int p_map_idx = SRegToPMap(s_reg);
@@ -269,8 +256,7 @@ int Mir2Lir::AllocPreservedDouble(int s_reg)
  * single regs (but if can't still attempt to allocate a single, preferring
  * first to allocate an odd register.
  */
-int Mir2Lir::AllocPreservedFPReg(int s_reg, bool double_start)
-{
+int Mir2Lir::AllocPreservedFPReg(int s_reg, bool double_start) {
   int res = -1;
   if (double_start) {
     res = AllocPreservedDouble(s_reg);
@@ -284,8 +270,7 @@ int Mir2Lir::AllocPreservedFPReg(int s_reg, bool double_start)
 }
 
 int Mir2Lir::AllocTempBody(RegisterInfo* p, int num_regs, int* next_temp,
-                           bool required)
-{
+                           bool required) {
   int i;
   int next = *next_temp;
   for (i=0; i< num_regs; i++) {
@@ -323,8 +308,7 @@ int Mir2Lir::AllocTempBody(RegisterInfo* p, int num_regs, int* next_temp,
 }
 
 //REDO: too many assumptions.
-int Mir2Lir::AllocTempDouble()
-{
+int Mir2Lir::AllocTempDouble() {
   RegisterInfo* p = reg_pool_->FPRegs;
   int num_regs = reg_pool_->num_fp_regs;
   /* Start looking at an even reg */
@@ -377,29 +361,25 @@ int Mir2Lir::AllocTempDouble()
 }
 
 /* Return a temp if one is available, -1 otherwise */
-int Mir2Lir::AllocFreeTemp()
-{
+int Mir2Lir::AllocFreeTemp() {
   return AllocTempBody(reg_pool_->core_regs,
              reg_pool_->num_core_regs,
              &reg_pool_->next_core_reg, true);
 }
 
-int Mir2Lir::AllocTemp()
-{
+int Mir2Lir::AllocTemp() {
   return AllocTempBody(reg_pool_->core_regs,
              reg_pool_->num_core_regs,
              &reg_pool_->next_core_reg, true);
 }
 
-int Mir2Lir::AllocTempFloat()
-{
+int Mir2Lir::AllocTempFloat() {
   return AllocTempBody(reg_pool_->FPRegs,
              reg_pool_->num_fp_regs,
              &reg_pool_->next_fp_reg, true);
 }
 
-Mir2Lir::RegisterInfo* Mir2Lir::AllocLiveBody(RegisterInfo* p, int num_regs, int s_reg)
-{
+Mir2Lir::RegisterInfo* Mir2Lir::AllocLiveBody(RegisterInfo* p, int num_regs, int s_reg) {
   int i;
   if (s_reg == -1)
     return NULL;
@@ -413,8 +393,7 @@ Mir2Lir::RegisterInfo* Mir2Lir::AllocLiveBody(RegisterInfo* p, int num_regs, int
   return NULL;
 }
 
-Mir2Lir::RegisterInfo* Mir2Lir::AllocLive(int s_reg, int reg_class)
-{
+Mir2Lir::RegisterInfo* Mir2Lir::AllocLive(int s_reg, int reg_class) {
   RegisterInfo* res = NULL;
   switch (reg_class) {
     case kAnyReg:
@@ -437,8 +416,7 @@ Mir2Lir::RegisterInfo* Mir2Lir::AllocLive(int s_reg, int reg_class)
   return res;
 }
 
-void Mir2Lir::FreeTemp(int reg)
-{
+void Mir2Lir::FreeTemp(int reg) {
   RegisterInfo* p = reg_pool_->core_regs;
   int num_regs = reg_pool_->num_core_regs;
   int i;
@@ -465,8 +443,7 @@ void Mir2Lir::FreeTemp(int reg)
   LOG(FATAL) << "Tried to free a non-existant temp: r" << reg;
 }
 
-Mir2Lir::RegisterInfo* Mir2Lir::IsLive(int reg)
-{
+Mir2Lir::RegisterInfo* Mir2Lir::IsLive(int reg) {
   RegisterInfo* p = reg_pool_->core_regs;
   int num_regs = reg_pool_->num_core_regs;
   int i;
@@ -485,20 +462,17 @@ Mir2Lir::RegisterInfo* Mir2Lir::IsLive(int reg)
   return NULL;
 }
 
-Mir2Lir::RegisterInfo* Mir2Lir::IsTemp(int reg)
-{
+Mir2Lir::RegisterInfo* Mir2Lir::IsTemp(int reg) {
   RegisterInfo* p = GetRegInfo(reg);
   return (p->is_temp) ? p : NULL;
 }
 
-Mir2Lir::RegisterInfo* Mir2Lir::IsPromoted(int reg)
-{
+Mir2Lir::RegisterInfo* Mir2Lir::IsPromoted(int reg) {
   RegisterInfo* p = GetRegInfo(reg);
   return (p->is_temp) ? NULL : p;
 }
 
-bool Mir2Lir::IsDirty(int reg)
-{
+bool Mir2Lir::IsDirty(int reg) {
   RegisterInfo* p = GetRegInfo(reg);
   return p->dirty;
 }
@@ -508,8 +482,7 @@ bool Mir2Lir::IsDirty(int reg)
  * register.  No check is made to see if the register was previously
  * allocated.  Use with caution.
  */
-void Mir2Lir::LockTemp(int reg)
-{
+void Mir2Lir::LockTemp(int reg) {
   RegisterInfo* p = reg_pool_->core_regs;
   int num_regs = reg_pool_->num_core_regs;
   int i;
@@ -534,13 +507,11 @@ void Mir2Lir::LockTemp(int reg)
   LOG(FATAL) << "Tried to lock a non-existant temp: r" << reg;
 }
 
-void Mir2Lir::ResetDef(int reg)
-{
+void Mir2Lir::ResetDef(int reg) {
   ResetDefBody(GetRegInfo(reg));
 }
 
-void Mir2Lir::NullifyRange(LIR *start, LIR *finish, int s_reg1, int s_reg2)
-{
+void Mir2Lir::NullifyRange(LIR *start, LIR *finish, int s_reg1, int s_reg2) {
   if (start && finish) {
     LIR *p;
     DCHECK_EQ(s_reg1, s_reg2);
@@ -557,8 +528,7 @@ void Mir2Lir::NullifyRange(LIR *start, LIR *finish, int s_reg1, int s_reg2)
  * on entry start points to the LIR prior to the beginning of the
  * sequence.
  */
-void Mir2Lir::MarkDef(RegLocation rl, LIR *start, LIR *finish)
-{
+void Mir2Lir::MarkDef(RegLocation rl, LIR *start, LIR *finish) {
   DCHECK(!rl.wide);
   DCHECK(start && start->next);
   DCHECK(finish);
@@ -572,8 +542,7 @@ void Mir2Lir::MarkDef(RegLocation rl, LIR *start, LIR *finish)
  * on entry start points to the LIR prior to the beginning of the
  * sequence.
  */
-void Mir2Lir::MarkDefWide(RegLocation rl, LIR *start, LIR *finish)
-{
+void Mir2Lir::MarkDefWide(RegLocation rl, LIR *start, LIR *finish) {
   DCHECK(rl.wide);
   DCHECK(start && start->next);
   DCHECK(finish);
@@ -583,8 +552,7 @@ void Mir2Lir::MarkDefWide(RegLocation rl, LIR *start, LIR *finish)
   p->def_end = finish;
 }
 
-RegLocation Mir2Lir::WideToNarrow(RegLocation rl)
-{
+RegLocation Mir2Lir::WideToNarrow(RegLocation rl) {
   DCHECK(rl.wide);
   if (rl.location == kLocPhysReg) {
     RegisterInfo* info_lo = GetRegInfo(rl.low_reg);
@@ -604,8 +572,7 @@ RegLocation Mir2Lir::WideToNarrow(RegLocation rl)
   return rl;
 }
 
-void Mir2Lir::ResetDefLoc(RegLocation rl)
-{
+void Mir2Lir::ResetDefLoc(RegLocation rl) {
   DCHECK(!rl.wide);
   RegisterInfo* p = IsTemp(rl.low_reg);
   if (p && !(cu_->disable_opt & (1 << kSuppressLoads))) {
@@ -615,8 +582,7 @@ void Mir2Lir::ResetDefLoc(RegLocation rl)
   ResetDef(rl.low_reg);
 }
 
-void Mir2Lir::ResetDefLocWide(RegLocation rl)
-{
+void Mir2Lir::ResetDefLocWide(RegLocation rl) {
   DCHECK(rl.wide);
   RegisterInfo* p_low = IsTemp(rl.low_reg);
   RegisterInfo* p_high = IsTemp(rl.high_reg);
@@ -631,8 +597,7 @@ void Mir2Lir::ResetDefLocWide(RegLocation rl)
   ResetDef(rl.high_reg);
 }
 
-void Mir2Lir::ResetDefTracking()
-{
+void Mir2Lir::ResetDefTracking() {
   int i;
   for (i=0; i< reg_pool_->num_core_regs; i++) {
     ResetDefBody(&reg_pool_->core_regs[i]);
@@ -642,8 +607,7 @@ void Mir2Lir::ResetDefTracking()
   }
 }
 
-void Mir2Lir::ClobberAllRegs()
-{
+void Mir2Lir::ClobberAllRegs() {
   int i;
   for (i=0; i< reg_pool_->num_core_regs; i++) {
     ClobberBody(&reg_pool_->core_regs[i]);
@@ -654,8 +618,7 @@ void Mir2Lir::ClobberAllRegs()
 }
 
 // Make sure nothing is live and dirty
-void Mir2Lir::FlushAllRegsBody(RegisterInfo* info, int num_regs)
-{
+void Mir2Lir::FlushAllRegsBody(RegisterInfo* info, int num_regs) {
   int i;
   for (i=0; i < num_regs; i++) {
     if (info[i].live && info[i].dirty) {
@@ -668,8 +631,7 @@ void Mir2Lir::FlushAllRegsBody(RegisterInfo* info, int num_regs)
   }
 }
 
-void Mir2Lir::FlushAllRegs()
-{
+void Mir2Lir::FlushAllRegs() {
   FlushAllRegsBody(reg_pool_->core_regs,
            reg_pool_->num_core_regs);
   FlushAllRegsBody(reg_pool_->FPRegs,
@@ -679,8 +641,7 @@ void Mir2Lir::FlushAllRegs()
 
 
 //TUNING: rewrite all of this reg stuff.  Probably use an attribute table
-bool Mir2Lir::RegClassMatches(int reg_class, int reg)
-{
+bool Mir2Lir::RegClassMatches(int reg_class, int reg) {
   if (reg_class == kAnyReg) {
     return true;
   } else if (reg_class == kCoreReg) {
@@ -690,8 +651,7 @@ bool Mir2Lir::RegClassMatches(int reg_class, int reg)
   }
 }
 
-void Mir2Lir::MarkLive(int reg, int s_reg)
-{
+void Mir2Lir::MarkLive(int reg, int s_reg) {
   RegisterInfo* info = GetRegInfo(reg);
   if ((info->reg == reg) && (info->s_reg == s_reg) && info->live) {
     return;  /* already live */
@@ -708,20 +668,17 @@ void Mir2Lir::MarkLive(int reg, int s_reg)
   info->s_reg = s_reg;
 }
 
-void Mir2Lir::MarkTemp(int reg)
-{
+void Mir2Lir::MarkTemp(int reg) {
   RegisterInfo* info = GetRegInfo(reg);
   info->is_temp = true;
 }
 
-void Mir2Lir::UnmarkTemp(int reg)
-{
+void Mir2Lir::UnmarkTemp(int reg) {
   RegisterInfo* info = GetRegInfo(reg);
   info->is_temp = false;
 }
 
-void Mir2Lir::MarkPair(int low_reg, int high_reg)
-{
+void Mir2Lir::MarkPair(int low_reg, int high_reg) {
   RegisterInfo* info_lo = GetRegInfo(low_reg);
   RegisterInfo* info_hi = GetRegInfo(high_reg);
   info_lo->pair = info_hi->pair = true;
@@ -729,8 +686,7 @@ void Mir2Lir::MarkPair(int low_reg, int high_reg)
   info_hi->partner = low_reg;
 }
 
-void Mir2Lir::MarkClean(RegLocation loc)
-{
+void Mir2Lir::MarkClean(RegLocation loc) {
   RegisterInfo* info = GetRegInfo(loc.low_reg);
   info->dirty = false;
   if (loc.wide) {
@@ -739,8 +695,7 @@ void Mir2Lir::MarkClean(RegLocation loc)
   }
 }
 
-void Mir2Lir::MarkDirty(RegLocation loc)
-{
+void Mir2Lir::MarkDirty(RegLocation loc) {
   if (loc.home) {
     // If already home, can't be dirty
     return;
@@ -753,14 +708,12 @@ void Mir2Lir::MarkDirty(RegLocation loc)
   }
 }
 
-void Mir2Lir::MarkInUse(int reg)
-{
+void Mir2Lir::MarkInUse(int reg) {
     RegisterInfo* info = GetRegInfo(reg);
     info->in_use = true;
 }
 
-void Mir2Lir::CopyRegInfo(int new_reg, int old_reg)
-{
+void Mir2Lir::CopyRegInfo(int new_reg, int old_reg) {
   RegisterInfo* new_info = GetRegInfo(new_reg);
   RegisterInfo* old_info = GetRegInfo(old_reg);
   // Target temp status must not change
@@ -771,8 +724,7 @@ void Mir2Lir::CopyRegInfo(int new_reg, int old_reg)
   new_info->reg = new_reg;
 }
 
-bool Mir2Lir::CheckCorePoolSanity()
-{
+bool Mir2Lir::CheckCorePoolSanity() {
    for (static int i = 0; i < reg_pool_->num_core_regs; i++) {
      if (reg_pool_->core_regs[i].pair) {
        static int my_reg = reg_pool_->core_regs[i].reg;
@@ -808,8 +760,7 @@ bool Mir2Lir::CheckCorePoolSanity()
  * if it's worthwhile trying to be more clever here.
  */
 
-RegLocation Mir2Lir::UpdateLoc(RegLocation loc)
-{
+RegLocation Mir2Lir::UpdateLoc(RegLocation loc) {
   DCHECK(!loc.wide);
   DCHECK(CheckCorePoolSanity());
   if (loc.location != kLocPhysReg) {
@@ -832,8 +783,7 @@ RegLocation Mir2Lir::UpdateLoc(RegLocation loc)
 }
 
 /* see comments for update_loc */
-RegLocation Mir2Lir::UpdateLocWide(RegLocation loc)
-{
+RegLocation Mir2Lir::UpdateLocWide(RegLocation loc) {
   DCHECK(loc.wide);
   DCHECK(CheckCorePoolSanity());
   if (loc.location != kLocPhysReg) {
@@ -886,16 +836,14 @@ RegLocation Mir2Lir::UpdateLocWide(RegLocation loc)
 
 
 /* For use in cases we don't know (or care) width */
-RegLocation Mir2Lir::UpdateRawLoc(RegLocation loc)
-{
+RegLocation Mir2Lir::UpdateRawLoc(RegLocation loc) {
   if (loc.wide)
     return UpdateLocWide(loc);
   else
     return UpdateLoc(loc);
 }
 
-RegLocation Mir2Lir::EvalLocWide(RegLocation loc, int reg_class, bool update)
-{
+RegLocation Mir2Lir::EvalLocWide(RegLocation loc, int reg_class, bool update) {
   DCHECK(loc.wide);
   int new_regs;
   int low_reg;
@@ -942,8 +890,7 @@ RegLocation Mir2Lir::EvalLocWide(RegLocation loc, int reg_class, bool update)
   return loc;
 }
 
-RegLocation Mir2Lir::EvalLoc(RegLocation loc, int reg_class, bool update)
-{
+RegLocation Mir2Lir::EvalLoc(RegLocation loc, int reg_class, bool update) {
   int new_reg;
 
   if (loc.wide)
@@ -992,15 +939,13 @@ void Mir2Lir::CountRefs(RefCounts* core_counts, RefCounts* fp_counts) {
 }
 
 /* qsort callback function, sort descending */
-static int SortCounts(const void *val1, const void *val2)
-{
+static int SortCounts(const void *val1, const void *val2) {
   const Mir2Lir::RefCounts* op1 = reinterpret_cast<const Mir2Lir::RefCounts*>(val1);
   const Mir2Lir::RefCounts* op2 = reinterpret_cast<const Mir2Lir::RefCounts*>(val2);
   return (op1->count == op2->count) ? 0 : (op1->count < op2->count ? 1 : -1);
 }
 
-void Mir2Lir::DumpCounts(const RefCounts* arr, int size, const char* msg)
-{
+void Mir2Lir::DumpCounts(const RefCounts* arr, int size, const char* msg) {
   LOG(INFO) << msg;
   for (int i = 0; i < size; i++) {
     LOG(INFO) << "s_reg[" << arr[i].s_reg << "]: " << arr[i].count;
@@ -1011,8 +956,7 @@ void Mir2Lir::DumpCounts(const RefCounts* arr, int size, const char* msg)
  * Note: some portions of this code required even if the kPromoteRegs
  * optimization is disabled.
  */
-void Mir2Lir::DoPromotion()
-{
+void Mir2Lir::DoPromotion() {
   int reg_bias = cu_->num_compiler_temps + 1;
   int dalvik_regs = cu_->num_dalvik_registers;
   int num_regs = dalvik_regs + reg_bias;
@@ -1158,21 +1102,18 @@ void Mir2Lir::DoPromotion()
 }
 
 /* Returns sp-relative offset in bytes for a VReg */
-int Mir2Lir::VRegOffset(int v_reg)
-{
+int Mir2Lir::VRegOffset(int v_reg) {
   return StackVisitor::GetVRegOffset(cu_->code_item, core_spill_mask_,
                                      fp_spill_mask_, frame_size_, v_reg);
 }
 
 /* Returns sp-relative offset in bytes for a SReg */
-int Mir2Lir::SRegOffset(int s_reg)
-{
+int Mir2Lir::SRegOffset(int s_reg) {
   return VRegOffset(mir_graph_->SRegToVReg(s_reg));
 }
 
 /* Mark register usage state and return long retloc */
-RegLocation Mir2Lir::GetReturnWide(bool is_double)
-{
+RegLocation Mir2Lir::GetReturnWide(bool is_double) {
   RegLocation gpr_res = LocCReturnWide();
   RegLocation fpr_res = LocCReturnDouble();
   RegLocation res = is_double ? fpr_res : gpr_res;
@@ -1184,8 +1125,7 @@ RegLocation Mir2Lir::GetReturnWide(bool is_double)
   return res;
 }
 
-RegLocation Mir2Lir::GetReturn(bool is_float)
-{
+RegLocation Mir2Lir::GetReturn(bool is_float) {
   RegLocation gpr_res = LocCReturn();
   RegLocation fpr_res = LocCReturnFloat();
   RegLocation res = is_float ? fpr_res : gpr_res;
@@ -1198,8 +1138,7 @@ RegLocation Mir2Lir::GetReturn(bool is_float)
   return res;
 }
 
-void Mir2Lir::SimpleRegAlloc()
-{
+void Mir2Lir::SimpleRegAlloc() {
   DoPromotion();
 
   if (cu_->verbose && !(cu_->disable_opt & (1 << kPromoteRegs))) {
diff --git a/compiler/dex/quick/x86/call_x86.cc b/compiler/dex/quick/x86/call_x86.cc
index d60be72c31..1aeb39ae4b 100644
--- a/compiler/dex/quick/x86/call_x86.cc
+++ b/compiler/dex/quick/x86/call_x86.cc
@@ -23,8 +23,7 @@
 namespace art {
 
 void X86Mir2Lir::GenSpecialCase(BasicBlock* bb, MIR* mir,
-                                SpecialCaseHandler special_case)
-{
+                                SpecialCaseHandler special_case) {
   // TODO
 }
 
@@ -33,8 +32,7 @@ void X86Mir2Lir::GenSpecialCase(BasicBlock* bb, MIR* mir,
  * pairs.
  */
 void X86Mir2Lir::GenSparseSwitch(MIR* mir, uint32_t table_offset,
-                                 RegLocation rl_src)
-{
+                                 RegLocation rl_src) {
   const uint16_t* table = cu_->insns + current_dalvik_offset_ + table_offset;
   if (cu_->verbose) {
     DumpSparseSwitchTable(table);
@@ -69,8 +67,7 @@ void X86Mir2Lir::GenSparseSwitch(MIR* mir, uint32_t table_offset,
  * done:
  */
 void X86Mir2Lir::GenPackedSwitch(MIR* mir, uint32_t table_offset,
-                                 RegLocation rl_src)
-{
+                                 RegLocation rl_src) {
   const uint16_t* table = cu_->insns + current_dalvik_offset_ + table_offset;
   if (cu_->verbose) {
     DumpPackedSwitchTable(table);
@@ -130,8 +127,7 @@ void X86Mir2Lir::GenPackedSwitch(MIR* mir, uint32_t table_offset,
  *
  * Total size is 4+(width * size + 1)/2 16-bit code units.
  */
-void X86Mir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src)
-{
+void X86Mir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src) {
   const uint16_t* table = cu_->insns + current_dalvik_offset_ + table_offset;
   // Add the table to the list - we'll process it later
   FillArrayData *tab_rec =
@@ -156,8 +152,7 @@ void X86Mir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src)
                           rX86_ARG1, true);
 }
 
-void X86Mir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src)
-{
+void X86Mir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src) {
   FlushAllRegs();
   LoadValueDirectFixed(rl_src, rCX);  // Get obj
   LockCallTemps();  // Prepare for explicit register usage
@@ -174,8 +169,7 @@ void X86Mir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src)
   branch->target = NewLIR0(kPseudoTargetLabel);
 }
 
-void X86Mir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src)
-{
+void X86Mir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src) {
   FlushAllRegs();
   LoadValueDirectFixed(rl_src, rAX);  // Get obj
   LockCallTemps();  // Prepare for explicit register usage
@@ -195,8 +189,7 @@ void X86Mir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src)
   branch2->target = NewLIR0(kPseudoTargetLabel);
 }
 
-void X86Mir2Lir::GenMoveException(RegLocation rl_dest)
-{
+void X86Mir2Lir::GenMoveException(RegLocation rl_dest) {
   int ex_offset = Thread::ExceptionOffset().Int32Value();
   RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
   NewLIR2(kX86Mov32RT, rl_result.low_reg, ex_offset);
@@ -207,8 +200,7 @@ void X86Mir2Lir::GenMoveException(RegLocation rl_dest)
 /*
  * Mark garbage collection card. Skip if the value we're storing is null.
  */
-void X86Mir2Lir::MarkGCCard(int val_reg, int tgt_addr_reg)
-{
+void X86Mir2Lir::MarkGCCard(int val_reg, int tgt_addr_reg) {
   int reg_card_base = AllocTemp();
   int reg_card_no = AllocTemp();
   LIR* branch_over = OpCmpImmBranch(kCondEq, val_reg, 0, NULL);
@@ -222,8 +214,7 @@ void X86Mir2Lir::MarkGCCard(int val_reg, int tgt_addr_reg)
   FreeTemp(reg_card_no);
 }
 
-void X86Mir2Lir::GenEntrySequence(RegLocation* ArgLocs, RegLocation rl_method)
-{
+void X86Mir2Lir::GenEntrySequence(RegLocation* ArgLocs, RegLocation rl_method) {
   /*
    * On entry, rX86_ARG0, rX86_ARG1, rX86_ARG2 are live.  Let the register
    * allocation mechanism know so it doesn't try to use any of them when
diff --git a/compiler/dex/quick/x86/fp_x86.cc b/compiler/dex/quick/x86/fp_x86.cc
index 906b4cc759..f2ecf6c959 100644
--- a/compiler/dex/quick/x86/fp_x86.cc
+++ b/compiler/dex/quick/x86/fp_x86.cc
@@ -349,8 +349,7 @@ void X86Mir2Lir::GenFusedFPCmpBranch(BasicBlock* bb, MIR* mir, bool gt_bias,
   OpCondBranch(ccode, taken);
 }
 
-void X86Mir2Lir::GenNegFloat(RegLocation rl_dest, RegLocation rl_src)
-{
+void X86Mir2Lir::GenNegFloat(RegLocation rl_dest, RegLocation rl_src) {
   RegLocation rl_result;
   rl_src = LoadValue(rl_src, kCoreReg);
   rl_result = EvalLoc(rl_dest, kCoreReg, true);
@@ -358,8 +357,7 @@ void X86Mir2Lir::GenNegFloat(RegLocation rl_dest, RegLocation rl_src)
   StoreValue(rl_dest, rl_result);
 }
 
-void X86Mir2Lir::GenNegDouble(RegLocation rl_dest, RegLocation rl_src)
-{
+void X86Mir2Lir::GenNegDouble(RegLocation rl_dest, RegLocation rl_src) {
   RegLocation rl_result;
   rl_src = LoadValueWide(rl_src, kCoreReg);
   rl_result = EvalLoc(rl_dest, kCoreReg, true);
diff --git a/compiler/dex/quick/x86/int_x86.cc b/compiler/dex/quick/x86/int_x86.cc
index 97d9d2deed..3be24df565 100644
--- a/compiler/dex/quick/x86/int_x86.cc
+++ b/compiler/dex/quick/x86/int_x86.cc
@@ -27,8 +27,7 @@ namespace art {
  * Perform register memory operation.
  */
 LIR* X86Mir2Lir::GenRegMemCheck(ConditionCode c_code,
-                                int reg1, int base, int offset, ThrowKind kind)
-{
+                                int reg1, int base, int offset, ThrowKind kind) {
   LIR* tgt = RawLIR(0, kPseudoThrowTarget, kind,
                     current_dalvik_offset_, reg1, base, offset);
   OpRegMem(kOpCmp, reg1, base, offset);
@@ -45,8 +44,7 @@ LIR* X86Mir2Lir::GenRegMemCheck(ConditionCode c_code,
  *    x > y     return  1
  */
 void X86Mir2Lir::GenCmpLong(RegLocation rl_dest, RegLocation rl_src1,
-                            RegLocation rl_src2)
-{
+                            RegLocation rl_src2) {
   FlushAllRegs();
   LockCallTemps();  // Prepare for explicit register usage
   LoadValueDirectWideFixed(rl_src1, r0, r1);
@@ -88,8 +86,7 @@ X86ConditionCode X86ConditionEncoding(ConditionCode cond) {
 }
 
 LIR* X86Mir2Lir::OpCmpBranch(ConditionCode cond, int src1, int src2,
-                             LIR* target)
-{
+                             LIR* target) {
   NewLIR2(kX86Cmp32RR, src1, src2);
   X86ConditionCode cc = X86ConditionEncoding(cond);
   LIR* branch = NewLIR2(kX86Jcc8, 0 /* lir operand for Jcc offset */ ,
@@ -99,8 +96,7 @@ LIR* X86Mir2Lir::OpCmpBranch(ConditionCode cond, int src1, int src2,
 }
 
 LIR* X86Mir2Lir::OpCmpImmBranch(ConditionCode cond, int reg,
-                                int check_value, LIR* target)
-{
+                                int check_value, LIR* target) {
   if ((check_value == 0) && (cond == kCondEq || cond == kCondNe)) {
     // TODO: when check_value == 0 and reg is rCX, use the jcxz/nz opcode
     NewLIR2(kX86Test32RR, reg, reg);
@@ -113,8 +109,7 @@ LIR* X86Mir2Lir::OpCmpImmBranch(ConditionCode cond, int reg,
   return branch;
 }
 
-LIR* X86Mir2Lir::OpRegCopyNoInsert(int r_dest, int r_src)
-{
+LIR* X86Mir2Lir::OpRegCopyNoInsert(int r_dest, int r_src) {
   if (X86_FPREG(r_dest) || X86_FPREG(r_src))
     return OpFpRegCopy(r_dest, r_src);
   LIR* res = RawLIR(current_dalvik_offset_, kX86Mov32RR,
@@ -125,16 +120,14 @@ LIR* X86Mir2Lir::OpRegCopyNoInsert(int r_dest, int r_src)
   return res;
 }
 
-LIR* X86Mir2Lir::OpRegCopy(int r_dest, int r_src)
-{
+LIR* X86Mir2Lir::OpRegCopy(int r_dest, int r_src) {
   LIR *res = OpRegCopyNoInsert(r_dest, r_src);
   AppendLIR(res);
   return res;
 }
 
 void X86Mir2Lir::OpRegCopyWide(int dest_lo, int dest_hi,
-                               int src_lo, int src_hi)
-{
+                               int src_lo, int src_hi) {
   bool dest_fp = X86_FPREG(dest_lo) && X86_FPREG(dest_hi);
   bool src_fp = X86_FPREG(src_lo) && X86_FPREG(src_hi);
   assert(X86_FPREG(src_lo) == X86_FPREG(src_hi));
@@ -168,8 +161,7 @@ void X86Mir2Lir::OpRegCopyWide(int dest_lo, int dest_hi,
   }
 }
 
-void X86Mir2Lir::GenSelect(BasicBlock* bb, MIR* mir)
-{
+void X86Mir2Lir::GenSelect(BasicBlock* bb, MIR* mir) {
   UNIMPLEMENTED(FATAL) << "Need codegen for GenSelect";
 }
 
@@ -213,21 +205,18 @@ void X86Mir2Lir::GenFusedLongCmpBranch(BasicBlock* bb, MIR* mir) {
 }
 
 RegLocation X86Mir2Lir::GenDivRemLit(RegLocation rl_dest, int reg_lo,
-                                     int lit, bool is_div)
-{
+                                     int lit, bool is_div) {
   LOG(FATAL) << "Unexpected use of GenDivRemLit for x86";
   return rl_dest;
 }
 
 RegLocation X86Mir2Lir::GenDivRem(RegLocation rl_dest, int reg_lo,
-                                  int reg_hi, bool is_div)
-{
+                                  int reg_hi, bool is_div) {
   LOG(FATAL) << "Unexpected use of GenDivRem for x86";
   return rl_dest;
 }
 
-bool X86Mir2Lir::GenInlinedMinMaxInt(CallInfo* info, bool is_min)
-{
+bool X86Mir2Lir::GenInlinedMinMaxInt(CallInfo* info, bool is_min) {
   DCHECK_EQ(cu_->instruction_set, kX86);
   RegLocation rl_src1 = info->args[0];
   RegLocation rl_src2 = info->args[1];
@@ -247,13 +236,11 @@ bool X86Mir2Lir::GenInlinedMinMaxInt(CallInfo* info, bool is_min)
   return true;
 }
 
-void X86Mir2Lir::OpLea(int rBase, int reg1, int reg2, int scale, int offset)
-{
+void X86Mir2Lir::OpLea(int rBase, int reg1, int reg2, int scale, int offset) {
   NewLIR5(kX86Lea32RA, rBase, reg1, reg2, scale, offset);
 }
 
-void X86Mir2Lir::OpTlsCmp(int offset, int val)
-{
+void X86Mir2Lir::OpTlsCmp(int offset, int val) {
   NewLIR2(kX86Cmp16TI8, offset, val);
 }
 
@@ -267,22 +254,19 @@ LIR* X86Mir2Lir::OpPcRelLoad(int reg, LIR* target) {
   return NULL;
 }
 
-LIR* X86Mir2Lir::OpVldm(int rBase, int count)
-{
+LIR* X86Mir2Lir::OpVldm(int rBase, int count) {
   LOG(FATAL) << "Unexpected use of OpVldm for x86";
   return NULL;
 }
 
-LIR* X86Mir2Lir::OpVstm(int rBase, int count)
-{
+LIR* X86Mir2Lir::OpVstm(int rBase, int count) {
   LOG(FATAL) << "Unexpected use of OpVstm for x86";
   return NULL;
 }
 
 void X86Mir2Lir::GenMultiplyByTwoBitMultiplier(RegLocation rl_src,
                                                RegLocation rl_result, int lit,
-                                               int first_bit, int second_bit)
-{
+                                               int first_bit, int second_bit) {
   int t_reg = AllocTemp();
   OpRegRegImm(kOpLsl, t_reg, rl_src.low_reg, second_bit - first_bit);
   OpRegRegReg(kOpAdd, rl_result.low_reg, rl_src.low_reg, t_reg);
@@ -292,8 +276,7 @@ void X86Mir2Lir::GenMultiplyByTwoBitMultiplier(RegLocation rl_src,
   }
 }
 
-void X86Mir2Lir::GenDivZeroCheck(int reg_lo, int reg_hi)
-{
+void X86Mir2Lir::GenDivZeroCheck(int reg_lo, int reg_hi) {
   int t_reg = AllocTemp();
   OpRegRegReg(kOpOr, t_reg, reg_lo, reg_hi);
   GenImmedCheck(kCondEq, t_reg, 0, kThrowDivZero);
@@ -301,40 +284,34 @@ void X86Mir2Lir::GenDivZeroCheck(int reg_lo, int reg_hi)
 }
 
 // Test suspend flag, return target of taken suspend branch
-LIR* X86Mir2Lir::OpTestSuspend(LIR* target)
-{
+LIR* X86Mir2Lir::OpTestSuspend(LIR* target) {
   OpTlsCmp(Thread::ThreadFlagsOffset().Int32Value(), 0);
   return OpCondBranch((target == NULL) ? kCondNe : kCondEq, target);
 }
 
 // Decrement register and branch on condition
-LIR* X86Mir2Lir::OpDecAndBranch(ConditionCode c_code, int reg, LIR* target)
-{
+LIR* X86Mir2Lir::OpDecAndBranch(ConditionCode c_code, int reg, LIR* target) {
   OpRegImm(kOpSub, reg, 1);
   return OpCmpImmBranch(c_code, reg, 0, target);
 }
 
 bool X86Mir2Lir::SmallLiteralDivide(Instruction::Code dalvik_opcode,
-                                    RegLocation rl_src, RegLocation rl_dest, int lit)
-{
+                                    RegLocation rl_src, RegLocation rl_dest, int lit) {
   LOG(FATAL) << "Unexpected use of smallLiteralDive in x86";
   return false;
 }
 
-LIR* X86Mir2Lir::OpIT(ConditionCode cond, const char* guide)
-{
+LIR* X86Mir2Lir::OpIT(ConditionCode cond, const char* guide) {
   LOG(FATAL) << "Unexpected use of OpIT in x86";
   return NULL;
 }
 
 void X86Mir2Lir::GenMulLong(RegLocation rl_dest, RegLocation rl_src1,
-                            RegLocation rl_src2)
-{
+                            RegLocation rl_src2) {
   LOG(FATAL) << "Unexpected use of GenX86Long for x86";
 }
 void X86Mir2Lir::GenAddLong(RegLocation rl_dest, RegLocation rl_src1,
-                         RegLocation rl_src2)
-{
+                         RegLocation rl_src2) {
   // TODO: fixed register usage here as we only have 4 temps and temporary allocation isn't smart
   // enough.
   FlushAllRegs();
@@ -350,8 +327,7 @@ void X86Mir2Lir::GenAddLong(RegLocation rl_dest, RegLocation rl_src1,
 }
 
 void X86Mir2Lir::GenSubLong(RegLocation rl_dest, RegLocation rl_src1,
-                            RegLocation rl_src2)
-{
+                            RegLocation rl_src2) {
   // TODO: fixed register usage here as we only have 4 temps and temporary allocation isn't smart
   // enough.
   FlushAllRegs();
@@ -367,8 +343,7 @@ void X86Mir2Lir::GenSubLong(RegLocation rl_dest, RegLocation rl_src1,
 }
 
 void X86Mir2Lir::GenAndLong(RegLocation rl_dest, RegLocation rl_src1,
-                            RegLocation rl_src2)
-{
+                            RegLocation rl_src2) {
   // TODO: fixed register usage here as we only have 4 temps and temporary allocation isn't smart
   // enough.
   FlushAllRegs();
@@ -384,8 +359,7 @@ void X86Mir2Lir::GenAndLong(RegLocation rl_dest, RegLocation rl_src1,
 }
 
 void X86Mir2Lir::GenOrLong(RegLocation rl_dest,
-                           RegLocation rl_src1, RegLocation rl_src2)
-{
+                           RegLocation rl_src1, RegLocation rl_src2) {
   // TODO: fixed register usage here as we only have 4 temps and temporary allocation isn't smart
   // enough.
   FlushAllRegs();
@@ -401,8 +375,7 @@ void X86Mir2Lir::GenOrLong(RegLocation rl_dest,
 }
 
 void X86Mir2Lir::GenXorLong(RegLocation rl_dest,
-                            RegLocation rl_src1, RegLocation rl_src2)
-{
+                            RegLocation rl_src1, RegLocation rl_src2) {
   // TODO: fixed register usage here as we only have 4 temps and temporary allocation isn't smart
   // enough.
   FlushAllRegs();
@@ -417,8 +390,7 @@ void X86Mir2Lir::GenXorLong(RegLocation rl_dest,
   StoreValueWide(rl_dest, rl_result);
 }
 
-void X86Mir2Lir::GenNegLong(RegLocation rl_dest, RegLocation rl_src)
-{
+void X86Mir2Lir::GenNegLong(RegLocation rl_dest, RegLocation rl_src) {
   FlushAllRegs();
   LockCallTemps();  // Prepare for explicit register usage
   LoadValueDirectWideFixed(rl_src, r0, r1);
@@ -447,8 +419,7 @@ void X86Mir2Lir::OpRegThreadMem(OpKind op, int r_dest, int thread_offset) {
  * Generate array load
  */
 void X86Mir2Lir::GenArrayGet(int opt_flags, OpSize size, RegLocation rl_array,
-                          RegLocation rl_index, RegLocation rl_dest, int scale)
-{
+                          RegLocation rl_index, RegLocation rl_dest, int scale) {
   RegisterClass reg_class = oat_reg_class_by_size(size);
   int len_offset = mirror::Array::LengthOffset().Int32Value();
   int data_offset;
@@ -495,8 +466,7 @@ void X86Mir2Lir::GenArrayGet(int opt_flags, OpSize size, RegLocation rl_array,
  *
  */
 void X86Mir2Lir::GenArrayPut(int opt_flags, OpSize size, RegLocation rl_array,
-                          RegLocation rl_index, RegLocation rl_src, int scale)
-{
+                             RegLocation rl_index, RegLocation rl_src, int scale) {
   RegisterClass reg_class = oat_reg_class_by_size(size);
   int len_offset = mirror::Array::LengthOffset().Int32Value();
   int data_offset;
@@ -539,8 +509,7 @@ void X86Mir2Lir::GenArrayPut(int opt_flags, OpSize size, RegLocation rl_array,
  *
  */
 void X86Mir2Lir::GenArrayObjPut(int opt_flags, RegLocation rl_array,
-                             RegLocation rl_index, RegLocation rl_src, int scale)
-{
+                             RegLocation rl_index, RegLocation rl_src, int scale) {
   int len_offset = mirror::Array::LengthOffset().Int32Value();
   int data_offset = mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value();
 
@@ -590,15 +559,13 @@ void X86Mir2Lir::GenArrayObjPut(int opt_flags, RegLocation rl_array,
 }
 
 void X86Mir2Lir::GenShiftImmOpLong(Instruction::Code opcode, RegLocation rl_dest,
-                                   RegLocation rl_src1, RegLocation rl_shift)
-{
+                                   RegLocation rl_src1, RegLocation rl_shift) {
   // Default implementation is just to ignore the constant case.
   GenShiftOpLong(opcode, rl_dest, rl_src1, rl_shift);
 }
 
 void X86Mir2Lir::GenArithImmOpLong(Instruction::Code opcode,
-                                   RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2)
-{
+                                   RegLocation rl_dest, RegLocation rl_src1, RegLocation rl_src2) {
   // Default - bail to non-const handler.
   GenArithOpLong(opcode, rl_dest, rl_src1, rl_src2);
 }
diff --git a/compiler/dex/quick/x86/target_x86.cc b/compiler/dex/quick/x86/target_x86.cc
index c421ef3f11..5b64a6b5c3 100644
--- a/compiler/dex/quick/x86/target_x86.cc
+++ b/compiler/dex/quick/x86/target_x86.cc
@@ -45,26 +45,22 @@ namespace art {
 #endif
 };
 
-RegLocation X86Mir2Lir::LocCReturn()
-{
+RegLocation X86Mir2Lir::LocCReturn() {
   RegLocation res = X86_LOC_C_RETURN;
   return res;
 }
 
-RegLocation X86Mir2Lir::LocCReturnWide()
-{
+RegLocation X86Mir2Lir::LocCReturnWide() {
   RegLocation res = X86_LOC_C_RETURN_WIDE;
   return res;
 }
 
-RegLocation X86Mir2Lir::LocCReturnFloat()
-{
+RegLocation X86Mir2Lir::LocCReturnFloat() {
   RegLocation res = X86_LOC_C_RETURN_FLOAT;
   return res;
 }
 
-RegLocation X86Mir2Lir::LocCReturnDouble()
-{
+RegLocation X86Mir2Lir::LocCReturnDouble() {
   RegLocation res = X86_LOC_C_RETURN_DOUBLE;
   return res;
 }
@@ -95,28 +91,24 @@ int X86Mir2Lir::TargetReg(SpecialTargetRegister reg) {
 }
 
 // Create a double from a pair of singles.
-int X86Mir2Lir::S2d(int low_reg, int high_reg)
-{
+int X86Mir2Lir::S2d(int low_reg, int high_reg) {
   return X86_S2D(low_reg, high_reg);
 }
 
 // Return mask to strip off fp reg flags and bias.
-uint32_t X86Mir2Lir::FpRegMask()
-{
+uint32_t X86Mir2Lir::FpRegMask() {
   return X86_FP_REG_MASK;
 }
 
 // True if both regs single, both core or both double.
-bool X86Mir2Lir::SameRegType(int reg1, int reg2)
-{
+bool X86Mir2Lir::SameRegType(int reg1, int reg2) {
   return (X86_REGTYPE(reg1) == X86_REGTYPE(reg2));
 }
 
 /*
  * Decode the register id.
  */
-uint64_t X86Mir2Lir::GetRegMaskCommon(int reg)
-{
+uint64_t X86Mir2Lir::GetRegMaskCommon(int reg) {
   uint64_t seed;
   int shift;
   int reg_id;
@@ -131,8 +123,7 @@ uint64_t X86Mir2Lir::GetRegMaskCommon(int reg)
   return (seed << shift);
 }
 
-uint64_t X86Mir2Lir::GetPCUseDefEncoding()
-{
+uint64_t X86Mir2Lir::GetPCUseDefEncoding() {
   /*
    * FIXME: might make sense to use a virtual resource encoding bit for pc.  Might be
    * able to clean up some of the x86/Arm_Mips differences
@@ -141,8 +132,7 @@ uint64_t X86Mir2Lir::GetPCUseDefEncoding()
   return 0ULL;
 }
 
-void X86Mir2Lir::SetupTargetResourceMasks(LIR* lir)
-{
+void X86Mir2Lir::SetupTargetResourceMasks(LIR* lir) {
   DCHECK_EQ(cu_->instruction_set, kX86);
 
   // X86-specific resource map setup here.
@@ -263,8 +253,7 @@ std::string X86Mir2Lir::BuildInsnString(const char *fmt, LIR *lir, unsigned char
   return buf;
 }
 
-void X86Mir2Lir::DumpResourceMask(LIR *x86LIR, uint64_t mask, const char *prefix)
-{
+void X86Mir2Lir::DumpResourceMask(LIR *x86LIR, uint64_t mask, const char *prefix) {
   char buf[256];
   buf[0] = 0;
 
@@ -317,16 +306,14 @@ void X86Mir2Lir::AdjustSpillMask() {
  * include any holes in the mask.  Associate holes with
  * Dalvik register INVALID_VREG (0xFFFFU).
  */
-void X86Mir2Lir::MarkPreservedSingle(int v_reg, int reg)
-{
+void X86Mir2Lir::MarkPreservedSingle(int v_reg, int reg) {
   UNIMPLEMENTED(WARNING) << "MarkPreservedSingle";
 #if 0
   LOG(FATAL) << "No support yet for promoted FP regs";
 #endif
 }
 
-void X86Mir2Lir::FlushRegWide(int reg1, int reg2)
-{
+void X86Mir2Lir::FlushRegWide(int reg1, int reg2) {
   RegisterInfo* info1 = GetRegInfo(reg1);
   RegisterInfo* info2 = GetRegInfo(reg2);
   DCHECK(info1 && info2 && info1->pair && info2->pair &&
@@ -347,8 +334,7 @@ void X86Mir2Lir::FlushRegWide(int reg1, int reg2)
   }
 }
 
-void X86Mir2Lir::FlushReg(int reg)
-{
+void X86Mir2Lir::FlushReg(int reg) {
   RegisterInfo* info = GetRegInfo(reg);
   if (info->live && info->dirty) {
     info->dirty = false;
@@ -363,8 +349,7 @@ bool X86Mir2Lir::IsFpReg(int reg) {
 }
 
 /* Clobber all regs that might be used by an external C call */
-void X86Mir2Lir::ClobberCalleeSave()
-{
+void X86Mir2Lir::ClobberCalleeSave() {
   Clobber(rAX);
   Clobber(rCX);
   Clobber(rDX);
@@ -382,8 +367,7 @@ RegLocation X86Mir2Lir::GetReturnWideAlt() {
   return res;
 }
 
-RegLocation X86Mir2Lir::GetReturnAlt()
-{
+RegLocation X86Mir2Lir::GetReturnAlt() {
   RegLocation res = LocCReturn();
   res.low_reg = rDX;
   Clobber(rDX);
@@ -391,15 +375,13 @@ RegLocation X86Mir2Lir::GetReturnAlt()
   return res;
 }
 
-X86Mir2Lir::RegisterInfo* X86Mir2Lir::GetRegInfo(int reg)
-{
+X86Mir2Lir::RegisterInfo* X86Mir2Lir::GetRegInfo(int reg) {
   return X86_FPREG(reg) ? &reg_pool_->FPRegs[reg & X86_FP_REG_MASK]
                     : &reg_pool_->core_regs[reg];
 }
 
 /* To be used when explicitly managing register use */
-void X86Mir2Lir::LockCallTemps()
-{
+void X86Mir2Lir::LockCallTemps() {
   LockTemp(rX86_ARG0);
   LockTemp(rX86_ARG1);
   LockTemp(rX86_ARG2);
@@ -407,16 +389,14 @@ void X86Mir2Lir::LockCallTemps()
 }
 
 /* To be used when explicitly managing register use */
-void X86Mir2Lir::FreeCallTemps()
-{
+void X86Mir2Lir::FreeCallTemps() {
   FreeTemp(rX86_ARG0);
   FreeTemp(rX86_ARG1);
   FreeTemp(rX86_ARG2);
   FreeTemp(rX86_ARG3);
 }
 
-void X86Mir2Lir::GenMemBarrier(MemBarrierKind barrier_kind)
-{
+void X86Mir2Lir::GenMemBarrier(MemBarrierKind barrier_kind) {
 #if ANDROID_SMP != 0
   // TODO: optimize fences
   NewLIR0(kX86Mfence);
@@ -427,8 +407,7 @@ void X86Mir2Lir::GenMemBarrier(MemBarrierKind barrier_kind)
  * high reg in next byte.
  */
 int X86Mir2Lir::AllocTypedTempPair(bool fp_hint,
-                          int reg_class)
-{
+                          int reg_class) {
   int high_reg;
   int low_reg;
   int res = 0;
@@ -485,8 +464,7 @@ void X86Mir2Lir::CompilerInitializeRegAlloc() {
 }
 
 void X86Mir2Lir::FreeRegLocTemps(RegLocation rl_keep,
-                     RegLocation rl_free)
-{
+                     RegLocation rl_free) {
   if ((rl_free.low_reg != rl_keep.low_reg) && (rl_free.low_reg != rl_keep.high_reg) &&
       (rl_free.high_reg != rl_keep.low_reg) && (rl_free.high_reg != rl_keep.high_reg)) {
     // No overlap, free both
@@ -525,8 +503,7 @@ void X86Mir2Lir::UnSpillCoreRegs() {
   }
 }
 
-bool X86Mir2Lir::IsUnconditionalBranch(LIR* lir)
-{
+bool X86Mir2Lir::IsUnconditionalBranch(LIR* lir) {
   return (lir->opcode == kX86Jmp8 || lir->opcode == kX86Jmp32);
 }
 
@@ -547,24 +524,20 @@ Mir2Lir* X86CodeGenerator(CompilationUnit* const cu, MIRGraph* const mir_graph,
 }
 
 // Not used in x86
-int X86Mir2Lir::LoadHelper(int offset)
-{
+int X86Mir2Lir::LoadHelper(int offset) {
   LOG(FATAL) << "Unexpected use of LoadHelper in x86";
   return INVALID_REG;
 }
 
-uint64_t X86Mir2Lir::GetTargetInstFlags(int opcode)
-{
+uint64_t X86Mir2Lir::GetTargetInstFlags(int opcode) {
   return X86Mir2Lir::EncodingMap[opcode].flags;
 }
 
-const char* X86Mir2Lir::GetTargetInstName(int opcode)
-{
+const char* X86Mir2Lir::GetTargetInstName(int opcode) {
   return X86Mir2Lir::EncodingMap[opcode].name;
 }
 
-const char* X86Mir2Lir::GetTargetInstFmt(int opcode)
-{
+const char* X86Mir2Lir::GetTargetInstFmt(int opcode) {
   return X86Mir2Lir::EncodingMap[opcode].fmt;
 }
 
diff --git a/compiler/dex/quick/x86/utility_x86.cc b/compiler/dex/quick/x86/utility_x86.cc
index fb07ff1e22..6376e3b87a 100644
--- a/compiler/dex/quick/x86/utility_x86.cc
+++ b/compiler/dex/quick/x86/utility_x86.cc
@@ -22,8 +22,7 @@ namespace art {
 
 /* This file contains codegen for the X86 ISA */
 
-LIR* X86Mir2Lir::OpFpRegCopy(int r_dest, int r_src)
-{
+LIR* X86Mir2Lir::OpFpRegCopy(int r_dest, int r_src) {
   int opcode;
   /* must be both DOUBLE or both not DOUBLE */
   DCHECK_EQ(X86_DOUBLEREG(r_dest), X86_DOUBLEREG(r_src));
@@ -49,23 +48,19 @@ LIR* X86Mir2Lir::OpFpRegCopy(int r_dest, int r_src)
   return res;
 }
 
-bool X86Mir2Lir::InexpensiveConstantInt(int32_t value)
-{
+bool X86Mir2Lir::InexpensiveConstantInt(int32_t value) {
   return true;
 }
 
-bool X86Mir2Lir::InexpensiveConstantFloat(int32_t value)
-{
+bool X86Mir2Lir::InexpensiveConstantFloat(int32_t value) {
   return false;
 }
 
-bool X86Mir2Lir::InexpensiveConstantLong(int64_t value)
-{
+bool X86Mir2Lir::InexpensiveConstantLong(int64_t value) {
   return true;
 }
 
-bool X86Mir2Lir::InexpensiveConstantDouble(int64_t value)
-{
+bool X86Mir2Lir::InexpensiveConstantDouble(int64_t value) {
   return false; // TUNING
 }
 
@@ -78,8 +73,7 @@ bool X86Mir2Lir::InexpensiveConstantDouble(int64_t value)
  * 1) r_dest is freshly returned from AllocTemp or
  * 2) The codegen is under fixed register usage
  */
-LIR* X86Mir2Lir::LoadConstantNoClobber(int r_dest, int value)
-{
+LIR* X86Mir2Lir::LoadConstantNoClobber(int r_dest, int value) {
   int r_dest_save = r_dest;
   if (X86_FPREG(r_dest)) {
     if (value == 0) {
@@ -105,23 +99,20 @@ LIR* X86Mir2Lir::LoadConstantNoClobber(int r_dest, int value)
   return res;
 }
 
-LIR* X86Mir2Lir::OpUnconditionalBranch(LIR* target)
-{
+LIR* X86Mir2Lir::OpUnconditionalBranch(LIR* target) {
   LIR* res = NewLIR1(kX86Jmp8, 0 /* offset to be patched during assembly*/ );
   res->target = target;
   return res;
 }
 
-LIR* X86Mir2Lir::OpCondBranch(ConditionCode cc, LIR* target)
-{
+LIR* X86Mir2Lir::OpCondBranch(ConditionCode cc, LIR* target) {
   LIR* branch = NewLIR2(kX86Jcc8, 0 /* offset to be patched */,
                         X86ConditionEncoding(cc));
   branch->target = target;
   return branch;
 }
 
-LIR* X86Mir2Lir::OpReg(OpKind op, int r_dest_src)
-{
+LIR* X86Mir2Lir::OpReg(OpKind op, int r_dest_src) {
   X86OpCode opcode = kX86Bkpt;
   switch (op) {
     case kOpNeg: opcode = kX86Neg32R; break;
@@ -133,8 +124,7 @@ LIR* X86Mir2Lir::OpReg(OpKind op, int r_dest_src)
   return NewLIR1(opcode, r_dest_src);
 }
 
-LIR* X86Mir2Lir::OpRegImm(OpKind op, int r_dest_src1, int value)
-{
+LIR* X86Mir2Lir::OpRegImm(OpKind op, int r_dest_src1, int value) {
   X86OpCode opcode = kX86Bkpt;
   bool byte_imm = IS_SIMM8(value);
   DCHECK(!X86_FPREG(r_dest_src1));
@@ -160,8 +150,7 @@ LIR* X86Mir2Lir::OpRegImm(OpKind op, int r_dest_src1, int value)
   return NewLIR2(opcode, r_dest_src1, value);
 }
 
-LIR* X86Mir2Lir::OpRegReg(OpKind op, int r_dest_src1, int r_src2)
-{
+LIR* X86Mir2Lir::OpRegReg(OpKind op, int r_dest_src1, int r_src2) {
     X86OpCode opcode = kX86Nop;
     bool src2_must_be_cx = false;
     switch (op) {
@@ -207,8 +196,7 @@ LIR* X86Mir2Lir::OpRegReg(OpKind op, int r_dest_src1, int r_src2)
 }
 
 LIR* X86Mir2Lir::OpRegMem(OpKind op, int r_dest, int rBase,
-              int offset)
-{
+              int offset) {
   X86OpCode opcode = kX86Nop;
   switch (op) {
       // X86 binary opcodes
@@ -231,8 +219,7 @@ LIR* X86Mir2Lir::OpRegMem(OpKind op, int r_dest, int rBase,
 }
 
 LIR* X86Mir2Lir::OpRegRegReg(OpKind op, int r_dest, int r_src1,
-                 int r_src2)
-{
+                 int r_src2) {
   if (r_dest != r_src1 && r_dest != r_src2) {
     if (op == kOpAdd) { // lea special case, except can't encode rbp as base
       if (r_src1 == r_src2) {
@@ -280,8 +267,7 @@ LIR* X86Mir2Lir::OpRegRegReg(OpKind op, int r_dest, int r_src1,
 }
 
 LIR* X86Mir2Lir::OpRegRegImm(OpKind op, int r_dest, int r_src,
-                 int value)
-{
+                 int value) {
   if (op == kOpMul) {
     X86OpCode opcode = IS_SIMM8(value) ? kX86Imul32RRI8 : kX86Imul32RRI;
     return NewLIR3(opcode, r_dest, r_src, value);
@@ -306,8 +292,7 @@ LIR* X86Mir2Lir::OpRegRegImm(OpKind op, int r_dest, int r_src,
   return OpRegImm(op, r_dest, value);
 }
 
-LIR* X86Mir2Lir::OpThreadMem(OpKind op, int thread_offset)
-{
+LIR* X86Mir2Lir::OpThreadMem(OpKind op, int thread_offset) {
   X86OpCode opcode = kX86Bkpt;
   switch (op) {
     case kOpBlx: opcode = kX86CallT;  break;
@@ -318,8 +303,7 @@ LIR* X86Mir2Lir::OpThreadMem(OpKind op, int thread_offset)
   return NewLIR1(opcode, thread_offset);
 }
 
-LIR* X86Mir2Lir::OpMem(OpKind op, int rBase, int disp)
-{
+LIR* X86Mir2Lir::OpMem(OpKind op, int rBase, int disp) {
   X86OpCode opcode = kX86Bkpt;
   switch (op) {
     case kOpBlx: opcode = kX86CallM;  break;
@@ -330,8 +314,7 @@ LIR* X86Mir2Lir::OpMem(OpKind op, int rBase, int disp)
   return NewLIR2(opcode, rBase, disp);
 }
 
-LIR* X86Mir2Lir::LoadConstantWide(int r_dest_lo, int r_dest_hi, int64_t value)
-{
+LIR* X86Mir2Lir::LoadConstantWide(int r_dest_lo, int r_dest_hi, int64_t value) {
     int32_t val_lo = Low32Bits(value);
     int32_t val_hi = High32Bits(value);
     LIR *res;
@@ -558,23 +541,20 @@ LIR* X86Mir2Lir::StoreBaseIndexedDisp(int rBase, int r_index, int scale,
 
 /* store value base base + scaled index. */
 LIR* X86Mir2Lir::StoreBaseIndexed(int rBase, int r_index, int r_src,
-                      int scale, OpSize size)
-{
+                      int scale, OpSize size) {
   return StoreBaseIndexedDisp(rBase, r_index, scale, 0,
                               r_src, INVALID_REG, size, INVALID_SREG);
 }
 
 LIR* X86Mir2Lir::StoreBaseDisp(int rBase, int displacement,
-                               int r_src, OpSize size)
-{
+                               int r_src, OpSize size) {
     return StoreBaseIndexedDisp(rBase, INVALID_REG, 0,
                                 displacement, r_src, INVALID_REG, size,
                                 INVALID_SREG);
 }
 
 LIR* X86Mir2Lir::StoreBaseDispWide(int rBase, int displacement,
-                                   int r_src_lo, int r_src_hi)
-{
+                                   int r_src_lo, int r_src_hi) {
   return StoreBaseIndexedDisp(rBase, INVALID_REG, 0, displacement,
                               r_src_lo, r_src_hi, kLong, INVALID_SREG);
 }
diff --git a/compiler/dex/ssa_transformation.cc b/compiler/dex/ssa_transformation.cc
index 41820720d8..ccd2454a49 100644
--- a/compiler/dex/ssa_transformation.cc
+++ b/compiler/dex/ssa_transformation.cc
@@ -37,8 +37,7 @@ BasicBlock* MIRGraph::NeedsVisit(BasicBlock* bb) {
   return bb;
 }
 
-BasicBlock* MIRGraph::NextUnvisitedSuccessor(BasicBlock* bb)
-{
+BasicBlock* MIRGraph::NextUnvisitedSuccessor(BasicBlock* bb) {
   BasicBlock* res = NeedsVisit(bb->fall_through);
   if (res == NULL) {
     res = NeedsVisit(bb->taken);
@@ -57,15 +56,13 @@ BasicBlock* MIRGraph::NextUnvisitedSuccessor(BasicBlock* bb)
   return res;
 }
 
-void MIRGraph::MarkPreOrder(BasicBlock* block)
-{
+void MIRGraph::MarkPreOrder(BasicBlock* block) {
   block->visited = true;
   /* Enqueue the pre_order block id */
   dfs_order_->Insert(block->id);
 }
 
-void MIRGraph::RecordDFSOrders(BasicBlock* block)
-{
+void MIRGraph::RecordDFSOrders(BasicBlock* block) {
   std::vector<BasicBlock*> succ;
   MarkPreOrder(block);
   succ.push_back(block);
@@ -84,8 +81,7 @@ void MIRGraph::RecordDFSOrders(BasicBlock* block)
 }
 
 /* Sort the blocks by the Depth-First-Search */
-void MIRGraph::ComputeDFSOrders()
-{
+void MIRGraph::ComputeDFSOrders() {
   /* Initialize or reset the DFS pre_order list */
   if (dfs_order_ == NULL) {
     dfs_order_ = new (arena_) GrowableArray<int>(arena_, GetNumBlocks(), kGrowableArrayDfsOrder);
@@ -115,8 +111,7 @@ void MIRGraph::ComputeDFSOrders()
  * Mark block bit on the per-Dalvik register vector to denote that Dalvik
  * register idx is defined in BasicBlock bb.
  */
-bool MIRGraph::FillDefBlockMatrix(BasicBlock* bb)
-{
+bool MIRGraph::FillDefBlockMatrix(BasicBlock* bb) {
   if (bb->data_flow_info == NULL) return false;
 
   ArenaBitVector::Iterator iterator(bb->data_flow_info->def_v);
@@ -129,8 +124,7 @@ bool MIRGraph::FillDefBlockMatrix(BasicBlock* bb)
   return true;
 }
 
-void MIRGraph::ComputeDefBlockMatrix()
-{
+void MIRGraph::ComputeDefBlockMatrix() {
   int num_registers = cu_->num_dalvik_registers;
   /* Allocate num_dalvik_registers bit vector pointers */
   def_block_matrix_ = static_cast<ArenaBitVector**>
@@ -203,8 +197,7 @@ void MIRGraph::ComputeDomPostOrderTraversal(BasicBlock* bb) {
 }
 
 void MIRGraph::CheckForDominanceFrontier(BasicBlock* dom_bb,
-                                         const BasicBlock* succ_bb)
-{
+                                         const BasicBlock* succ_bb) {
   /*
    * TODO - evaluate whether phi will ever need to be inserted into exit
    * blocks.
@@ -217,8 +210,7 @@ void MIRGraph::CheckForDominanceFrontier(BasicBlock* dom_bb,
 }
 
 /* Worker function to compute the dominance frontier */
-bool MIRGraph::ComputeDominanceFrontier(BasicBlock* bb)
-{
+bool MIRGraph::ComputeDominanceFrontier(BasicBlock* bb) {
   /* Calculate DF_local */
   if (bb->taken) {
     CheckForDominanceFrontier(bb, bb->taken);
@@ -257,8 +249,7 @@ bool MIRGraph::ComputeDominanceFrontier(BasicBlock* bb)
 }
 
 /* Worker function for initializing domination-related data structures */
-void MIRGraph::InitializeDominationInfo(BasicBlock* bb)
-{
+void MIRGraph::InitializeDominationInfo(BasicBlock* bb) {
   int num_total_blocks = GetBasicBlockListCount();
 
   if (bb->dominators == NULL ) {
@@ -284,8 +275,7 @@ void MIRGraph::InitializeDominationInfo(BasicBlock* bb)
  * Given the ordering of i_dom_list, this common parent represents the
  * last element of the intersection of block1 and block2 dominators.
   */
-int MIRGraph::FindCommonParent(int block1, int block2)
-{
+int MIRGraph::FindCommonParent(int block1, int block2) {
   while (block1 != block2) {
     while (block1 < block2) {
       block1 = i_dom_list_[block1];
@@ -300,8 +290,7 @@ int MIRGraph::FindCommonParent(int block1, int block2)
 }
 
 /* Worker function to compute each block's immediate dominator */
-bool MIRGraph::ComputeblockIDom(BasicBlock* bb)
-{
+bool MIRGraph::ComputeblockIDom(BasicBlock* bb) {
   /* Special-case entry block */
   if (bb == GetEntryBlock()) {
     return false;
@@ -343,8 +332,7 @@ bool MIRGraph::ComputeblockIDom(BasicBlock* bb)
 }
 
 /* Worker function to compute each block's domintors */
-bool MIRGraph::ComputeBlockDominators(BasicBlock* bb)
-{
+bool MIRGraph::ComputeBlockDominators(BasicBlock* bb) {
   if (bb == GetEntryBlock()) {
     bb->dominators->ClearAllBits();
   } else {
@@ -354,8 +342,7 @@ bool MIRGraph::ComputeBlockDominators(BasicBlock* bb)
   return false;
 }
 
-bool MIRGraph::SetDominators(BasicBlock* bb)
-{
+bool MIRGraph::SetDominators(BasicBlock* bb) {
   if (bb != GetEntryBlock()) {
     int idom_dfs_idx = i_dom_list_[bb->dfs_id];
     DCHECK_NE(idom_dfs_idx, NOTVISITED);
@@ -369,8 +356,7 @@ bool MIRGraph::SetDominators(BasicBlock* bb)
 }
 
 /* Compute dominators, immediate dominator, and dominance fronter */
-void MIRGraph::ComputeDominators()
-{
+void MIRGraph::ComputeDominators() {
   int num_reachable_blocks = num_reachable_blocks_;
   int num_total_blocks = GetBasicBlockListCount();
 
@@ -435,8 +421,7 @@ void MIRGraph::ComputeDominators()
  * This is probably not general enough to be placed in BitVector.[ch].
  */
 void MIRGraph::ComputeSuccLineIn(ArenaBitVector* dest, const ArenaBitVector* src1,
-                                 const ArenaBitVector* src2)
-{
+                                 const ArenaBitVector* src2) {
   if (dest->GetStorageSize() != src1->GetStorageSize() ||
       dest->GetStorageSize() != src2->GetStorageSize() ||
       dest->IsExpandable() != src1->IsExpandable() ||
@@ -455,8 +440,7 @@ void MIRGraph::ComputeSuccLineIn(ArenaBitVector* dest, const ArenaBitVector* src
  * The calculated result is used for phi-node pruning - where we only need to
  * insert a phi node if the variable is live-in to the block.
  */
-bool MIRGraph::ComputeBlockLiveIns(BasicBlock* bb)
-{
+bool MIRGraph::ComputeBlockLiveIns(BasicBlock* bb) {
   ArenaBitVector* temp_dalvik_register_v = temp_dalvik_register_v_;
 
   if (bb->data_flow_info == NULL) return false;
@@ -487,8 +471,7 @@ bool MIRGraph::ComputeBlockLiveIns(BasicBlock* bb)
 }
 
 /* Insert phi nodes to for each variable to the dominance frontiers */
-void MIRGraph::InsertPhiNodes()
-{
+void MIRGraph::InsertPhiNodes() {
   int dalvik_reg;
   ArenaBitVector* phi_blocks =
       new (arena_) ArenaBitVector(arena_, GetNumBlocks(), false, kBitMapPhi);
@@ -569,8 +552,7 @@ void MIRGraph::InsertPhiNodes()
  * Worker function to insert phi-operands with latest SSA names from
  * predecessor blocks
  */
-bool MIRGraph::InsertPhiNodeOperands(BasicBlock* bb)
-{
+bool MIRGraph::InsertPhiNodeOperands(BasicBlock* bb) {
   MIR *mir;
   std::vector<int> uses;
   std::vector<int> incoming_arc;
@@ -622,8 +604,7 @@ bool MIRGraph::InsertPhiNodeOperands(BasicBlock* bb)
   return true;
 }
 
-void MIRGraph::DoDFSPreOrderSSARename(BasicBlock* block)
-{
+void MIRGraph::DoDFSPreOrderSSARename(BasicBlock* block) {
 
   if (block->visited || block->hidden) return;
   block->visited = true;
@@ -663,8 +644,7 @@ void MIRGraph::DoDFSPreOrderSSARename(BasicBlock* block)
 }
 
 /* Perform SSA transformation for the whole method */
-void MIRGraph::SSATransformation()
-{
+void MIRGraph::SSATransformation() {
   /* Compute the DFS order */
   ComputeDFSOrders();
 
diff --git a/compiler/dex/vreg_analysis.cc b/compiler/dex/vreg_analysis.cc
index adbda5c18f..8df6dd93e7 100644
--- a/compiler/dex/vreg_analysis.cc
+++ b/compiler/dex/vreg_analysis.cc
@@ -72,8 +72,7 @@ bool MIRGraph::SetHigh(int index, bool is_high) {
  * as it doesn't propagate.  We're guaranteed at least one pass through
  * the cfg.
  */
-bool MIRGraph::InferTypeAndSize(BasicBlock* bb)
-{
+bool MIRGraph::InferTypeAndSize(BasicBlock* bb) {
   MIR *mir;
   bool changed = false;   // Did anything change?
 
@@ -333,8 +332,7 @@ bool MIRGraph::InferTypeAndSize(BasicBlock* bb)
 
 static const char* storage_name[] = {" Frame ", "PhysReg", " Spill "};
 
-void MIRGraph::DumpRegLocTable(RegLocation* table, int count)
-{
+void MIRGraph::DumpRegLocTable(RegLocation* table, int count) {
   //FIXME: Quick-specific.  Move to Quick (and make a generic version for MIRGraph?
   Mir2Lir* cg = static_cast<Mir2Lir*>(cu_->cg.get());
   if (cg != NULL) {
@@ -374,8 +372,7 @@ static const RegLocation fresh_loc = {kLocDalvikFrame, 0, 0, 0, 0, 0, 0, 0, 0,
  * allocation is done on the fly.  We also do some initialization and
  * type inference here.
  */
-void MIRGraph::BuildRegLocations()
-{
+void MIRGraph::BuildRegLocations() {
   int i;
   RegLocation* loc;
 
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 9e71dff464..d1d21b1d03 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -356,14 +356,14 @@ CompilerDriver::CompilerDriver(CompilerBackend compiler_backend, InstructionSet
       jni_compiler_(NULL),
       compiler_enable_auto_elf_loading_(NULL),
       compiler_get_method_code_addr_(NULL),
-      support_boot_image_fixup_(true)
-{
+      support_boot_image_fixup_(true) {
+
   CHECK_PTHREAD_CALL(pthread_key_create, (&tls_key_, NULL), "compiler tls key");
 
   // TODO: more work needed to combine initializations and allow per-method backend selection
   typedef void (*InitCompilerContextFn)(CompilerDriver&);
   InitCompilerContextFn init_compiler_context;
-  if (compiler_backend_ == kPortable){
+  if (compiler_backend_ == kPortable) {
     // Initialize compiler_context_
     init_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtInitCompilerContext);
     compiler_ = reinterpret_cast<CompilerFn>(ArtCompileMethod);
@@ -1411,10 +1411,7 @@ class ParallelCompilationManager {
           begin_(begin),
           end_(end),
           callback_(callback),
-          stripe_(stripe)
-    {
-
-    }
+          stripe_(stripe) {}
 
     virtual void Run(Thread* self) {
       for (size_t i = begin_; i < end_; i += stripe_) {
@@ -2095,7 +2092,7 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
           }
           if (!is_black_listed) {
             LOG(INFO) << "Initializing: " << descriptor;
-            if (StringPiece(descriptor) == "Ljava/lang/Void;"){
+            if (StringPiece(descriptor) == "Ljava/lang/Void;") {
               // Hand initialize j.l.Void to avoid Dex file operations in un-started runtime.
               mirror::ObjectArray<mirror::Field>* fields = klass->GetSFields();
               CHECK_EQ(fields->GetLength(), 1);
diff --git a/compiler/image_writer.cc b/compiler/image_writer.cc
index 8d32a915dd..7fd1a7cb10 100644
--- a/compiler/image_writer.cc
+++ b/compiler/image_writer.cc
@@ -108,7 +108,7 @@ bool ImageWriter::Write(const std::string& image_filename,
     return false;
   }
 #ifndef NDEBUG
-  {
+  { // NOLINT(whitespace/braces)
     ScopedObjectAccess soa(Thread::Current());
     CheckNonImageClassesRemoved();
   }
diff --git a/compiler/jni/jni_compiler_test.cc b/compiler/jni/jni_compiler_test.cc
index 560a146052..4b6967faa0 100644
--- a/compiler/jni/jni_compiler_test.cc
+++ b/compiler/jni/jni_compiler_test.cc
@@ -68,7 +68,7 @@ class JniCompilerTest : public CommonTest {
   void SetUpForTest(bool direct, const char* method_name, const char* method_sig,
                     void* native_fnptr) {
     // Initialize class loader and compile method when runtime not started.
-    if (!runtime_->IsStarted()){
+    if (!runtime_->IsStarted()) {
       {
         ScopedObjectAccess soa(Thread::Current());
         class_loader_ = LoadDex("MyClassNatives");
diff --git a/compiler/llvm/runtime_support_builder.cc b/compiler/llvm/runtime_support_builder.cc
index 28405f67d4..976aa8f50d 100644
--- a/compiler/llvm/runtime_support_builder.cc
+++ b/compiler/llvm/runtime_support_builder.cc
@@ -38,8 +38,7 @@ using namespace runtime_support;
 RuntimeSupportBuilder::RuntimeSupportBuilder(::llvm::LLVMContext& context,
                                              ::llvm::Module& module,
                                              IRBuilder& irb)
-    : context_(context), module_(module), irb_(irb)
-{
+    : context_(context), module_(module), irb_(irb) {
   memset(target_runtime_support_func_, 0, sizeof(target_runtime_support_func_));
 #define GET_RUNTIME_SUPPORT_FUNC_DECL(ID, NAME) \
   do { \
diff --git a/jdwpspy/Common.h b/jdwpspy/Common.h
index 33f1a670ea..30a49fba76 100644
--- a/jdwpspy/Common.h
+++ b/jdwpspy/Common.h
@@ -26,16 +26,14 @@ typedef uint64_t u8;
 /*
  * Get 1 byte.  (Included to make the code more legible.)
  */
-INLINE u1 get1(unsigned const char* pSrc)
-{
+INLINE u1 get1(unsigned const char* pSrc) {
     return *pSrc;
 }
 
 /*
  * Get 2 big-endian bytes.
  */
-INLINE u2 get2BE(unsigned char const* pSrc)
-{
+INLINE u2 get2BE(unsigned char const* pSrc) {
     u2 result;
 
     result = *pSrc++ << 8;
@@ -47,8 +45,7 @@ INLINE u2 get2BE(unsigned char const* pSrc)
 /*
  * Get 4 big-endian bytes.
  */
-INLINE u4 get4BE(unsigned char const* pSrc)
-{
+INLINE u4 get4BE(unsigned char const* pSrc) {
     u4 result;
 
     result = *pSrc++ << 24;
@@ -62,8 +59,7 @@ INLINE u4 get4BE(unsigned char const* pSrc)
 /*
  * Get 8 big-endian bytes.
  */
-INLINE u8 get8BE(unsigned char const* pSrc)
-{
+INLINE u8 get8BE(unsigned char const* pSrc) {
     u8 result;
 
     result = (u8) *pSrc++ << 56;
diff --git a/runtime/base/mutex.cc b/runtime/base/mutex.cc
index fbec826af2..bb4b5c5dab 100644
--- a/runtime/base/mutex.cc
+++ b/runtime/base/mutex.cc
@@ -465,7 +465,7 @@ ReaderWriterMutex::ReaderWriterMutex(const char* name, LockLevel level) :
 #if ART_USE_FUTEXES
     , state_(0), exclusive_owner_(0), num_pending_readers_(0), num_pending_writers_(0)
 #endif
-{
+{ // NOLINT(whitespace/braces)
 #if !ART_USE_FUTEXES
   CHECK_MUTEX_CALL(pthread_rwlock_init, (&rwlock_, NULL));
 #endif
diff --git a/runtime/common_throws.cc b/runtime/common_throws.cc
index 04979016e3..2a55e3138b 100644
--- a/runtime/common_throws.cc
+++ b/runtime/common_throws.cc
@@ -169,7 +169,7 @@ void ThrowIllegalAccessErrorFinalField(const mirror::AbstractMethod* referrer,
                  msg.str().c_str());
 }
 
-void ThrowIllegalAccessError(mirror::Class* referrer, const char* fmt, ...){
+void ThrowIllegalAccessError(mirror::Class* referrer, const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
   ThrowException(NULL, "Ljava/lang/IllegalAccessError;", referrer, fmt, &args);
@@ -222,7 +222,7 @@ void ThrowIncompatibleClassChangeErrorField(const mirror::Field* resolved_field,
                  msg.str().c_str());
 }
 
-void ThrowIncompatibleClassChangeError(const mirror::Class* referrer, const char* fmt, ...){
+void ThrowIncompatibleClassChangeError(const mirror::Class* referrer, const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
   ThrowException(NULL, "Ljava/lang/IncompatibleClassChangeError;", referrer, fmt, &args);
diff --git a/runtime/compiled_method.cc b/runtime/compiled_method.cc
index 757a324155..49706ae8eb 100644
--- a/runtime/compiled_method.cc
+++ b/runtime/compiled_method.cc
@@ -19,8 +19,7 @@
 namespace art {
 
 CompiledCode::CompiledCode(InstructionSet instruction_set, const std::vector<uint8_t>& code)
-    : instruction_set_(instruction_set), code_(code)
-{
+    : instruction_set_(instruction_set), code_(code) {
   CHECK_NE(code.size(), 0U);
 }
 
@@ -118,8 +117,7 @@ CompiledMethod::CompiledMethod(InstructionSet instruction_set,
                                const std::vector<uint8_t>& native_gc_map)
     : CompiledCode(instruction_set, code), frame_size_in_bytes_(frame_size_in_bytes),
       core_spill_mask_(core_spill_mask), fp_spill_mask_(fp_spill_mask),
-      gc_map_(native_gc_map)
-{
+      gc_map_(native_gc_map) {
   DCHECK_EQ(vmap_table.size(),
             static_cast<uint32_t>(__builtin_popcount(core_spill_mask)
                                   + __builtin_popcount(fp_spill_mask)));
diff --git a/runtime/dex_file.cc b/runtime/dex_file.cc
index 1e37dcde07..cd34c3c89e 100644
--- a/runtime/dex_file.cc
+++ b/runtime/dex_file.cc
@@ -252,7 +252,7 @@ DexFile::~DexFile() {
 
 class ScopedJniMonitorLock {
  public:
-  ScopedJniMonitorLock(JNIEnv* env, jobject locked) : env_(env), locked_(locked){
+  ScopedJniMonitorLock(JNIEnv* env, jobject locked) : env_(env), locked_(locked) {
     env->MonitorEnter(locked_);
   }
   ~ScopedJniMonitorLock() {
diff --git a/runtime/dex_instruction.h b/runtime/dex_instruction.h
index d2ad989395..c3424dcdff 100644
--- a/runtime/dex_instruction.h
+++ b/runtime/dex_instruction.h
@@ -82,7 +82,7 @@ class Instruction {
   // TODO: the code layout below is deliberate to avoid this enum being picked up by
   //       generate-operator-out.py.
   enum Code
-  {
+  { // NOLINT(whitespace/braces)
 #define INSTRUCTION_ENUM(opcode, cname, p, f, r, i, a, v) cname = opcode,
 #include "dex_instruction_list.h"
     DEX_INSTRUCTION_LIST(INSTRUCTION_ENUM)
diff --git a/runtime/gc/space/large_object_space.cc b/runtime/gc/space/large_object_space.cc
index 3cee1b7355..f7d776fbfb 100644
--- a/runtime/gc/space/large_object_space.cc
+++ b/runtime/gc/space/large_object_space.cc
@@ -49,8 +49,7 @@ void LargeObjectSpace::CopyLiveToMarked() {
 
 LargeObjectMapSpace::LargeObjectMapSpace(const std::string& name)
     : LargeObjectSpace(name),
-      lock_("large object map space lock", kAllocSpaceLock)
-{
+      lock_("large object map space lock", kAllocSpaceLock) {
 
 }
 
@@ -274,7 +273,7 @@ mirror::Object* FreeListSpace::Alloc(Thread* self, size_t num_bytes) {
   return reinterpret_cast<mirror::Object*>(addr);
 }
 
-void FreeListSpace::Dump(std::ostream& os) const{
+void FreeListSpace::Dump(std::ostream& os) const {
   os << GetName() << " -"
      << " begin: " << reinterpret_cast<void*>(Begin())
      << " end: " << reinterpret_cast<void*>(End());
diff --git a/runtime/interpreter/interpreter.cc b/runtime/interpreter/interpreter.cc
index 16e04a5a3f..2fb272cef4 100644
--- a/runtime/interpreter/interpreter.cc
+++ b/runtime/interpreter/interpreter.cc
@@ -2574,7 +2574,7 @@ static JValue ExecuteImpl(Thread* self, MethodHelper& mh, const DexFile::CodeIte
         POSSIBLY_HANDLE_PENDING_EXCEPTION(Next_1xx);
         break;
       }
-      case Instruction::SHL_INT_2ADDR:{
+      case Instruction::SHL_INT_2ADDR: {
         PREAMBLE();
         uint32_t vregA = inst->VRegA_12x();
         shadow_frame.SetVReg(vregA,
diff --git a/runtime/mirror/abstract_method.cc b/runtime/mirror/abstract_method.cc
index 88a9dc1aa6..58ef5f7bc8 100644
--- a/runtime/mirror/abstract_method.cc
+++ b/runtime/mirror/abstract_method.cc
@@ -262,7 +262,7 @@ void AbstractMethod::Invoke(Thread* self, uint32_t* args, uint32_t args_size, JV
 
   Runtime* runtime = Runtime::Current();
   // Call the invoke stub, passing everything as arguments.
-  if (UNLIKELY(!runtime->IsStarted())){
+  if (UNLIKELY(!runtime->IsStarted())) {
     LOG(INFO) << "Not invoking " << PrettyMethod(this) << " for a runtime that isn't started";
     if (result != NULL) {
       result->SetJ(0);
diff --git a/runtime/mirror/class-inl.h b/runtime/mirror/class-inl.h
index d323c3333b..52906a2650 100644
--- a/runtime/mirror/class-inl.h
+++ b/runtime/mirror/class-inl.h
@@ -75,7 +75,7 @@ inline AbstractMethod* Class::GetDirectMethod(int32_t i) const
 }
 
 inline void Class::SetDirectMethod(uint32_t i, AbstractMethod* f)  // TODO: uint16_t
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   ObjectArray<AbstractMethod>* direct_methods =
       GetFieldObject<ObjectArray<AbstractMethod>*>(
           OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false);
@@ -308,13 +308,13 @@ inline size_t Class::NumInstanceFields() const {
 }
 
 inline Field* Class::GetInstanceField(uint32_t i) const  // TODO: uint16_t
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK_NE(NumInstanceFields(), 0U);
   return GetIFields()->Get(i);
 }
 
 inline void Class::SetInstanceField(uint32_t i, Field* f)  // TODO: uint16_t
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   ObjectArray<Field>* ifields= GetFieldObject<ObjectArray<Field>*>(
       OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false);
   ifields->Set(i, f);
diff --git a/runtime/native/dalvik_system_Zygote.cc b/runtime/native/dalvik_system_Zygote.cc
index 9b995f421d..e6b4513972 100644
--- a/runtime/native/dalvik_system_Zygote.cc
+++ b/runtime/native/dalvik_system_Zygote.cc
@@ -492,7 +492,7 @@ static pid_t ForkAndSpecializeCommon(JNIEnv* env, uid_t uid, gid_t gid, jintArra
     SetSchedulerPolicy();
 
 #if defined(HAVE_ANDROID_OS)
-    {
+    { // NOLINT(whitespace/braces)
       const char* se_info_c_str = NULL;
       UniquePtr<ScopedUtfChars> se_info;
       if (java_se_info != NULL) {
diff --git a/runtime/oat/runtime/support_jni.cc b/runtime/oat/runtime/support_jni.cc
index 8f0f7ca93d..25f6930dd0 100644
--- a/runtime/oat/runtime/support_jni.cc
+++ b/runtime/oat/runtime/support_jni.cc
@@ -104,7 +104,7 @@ static void WorkAroundJniBugsForJobject(intptr_t* arg_ptr) {
 }
 
 extern "C" const void* artWorkAroundAppJniBugs(Thread* self, intptr_t* sp)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK(Thread::Current() == self);
   // TODO: this code is specific to ARM
   // On entry the stack pointed by sp is:
diff --git a/runtime/oat/runtime/x86/context_x86.cc b/runtime/oat/runtime/x86/context_x86.cc
index ceb10bd6ca..c728ae97ec 100644
--- a/runtime/oat/runtime/x86/context_x86.cc
+++ b/runtime/oat/runtime/x86/context_x86.cc
@@ -61,7 +61,7 @@ void X86Context::SmashCallerSaves() {
   gprs_[EBX] = NULL;
 }
 
-void X86Context::SetGPR(uint32_t reg, uintptr_t value){
+void X86Context::SetGPR(uint32_t reg, uintptr_t value) {
   CHECK_LT(reg, static_cast<uint32_t>(kNumberOfCpuRegisters));
   CHECK_NE(gprs_[reg], &gZero);
   CHECK(gprs_[reg] != NULL);
diff --git a/runtime/oat_file.cc b/runtime/oat_file.cc
index 0f29915a9b..bb8341ee9f 100644
--- a/runtime/oat_file.cc
+++ b/runtime/oat_file.cc
@@ -358,8 +358,7 @@ OatFile::OatMethod::OatMethod(const byte* base,
     fp_spill_mask_(fp_spill_mask),
     mapping_table_offset_(mapping_table_offset),
     vmap_table_offset_(vmap_table_offset),
-    native_gc_map_offset_(gc_map_offset)
-{
+    native_gc_map_offset_(gc_map_offset) {
 #ifndef NDEBUG
   if (mapping_table_offset_ != 0) {  // implies non-native, non-stub code
     if (vmap_table_offset_ == 0) {
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index e5fb46fa5b..14d4c8a592 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -566,7 +566,7 @@ Runtime::ParsedOptions* Runtime::ParsedOptions::Create(const Options& options, b
       Trace::SetDefaultClockSource(kProfilerClockSourceDual);
     } else if (option == "-small") {
       parsed->small_mode_ = true;
-    }else if (option == "-sea_ir") {
+    } else if (option == "-sea_ir") {
       parsed->sea_ir_mode_ = true;
     } else if (StartsWith(option, "-small-mode-methods-max:")) {
       parsed->small_mode_method_threshold_ = ParseIntegerOrDie(option);
diff --git a/runtime/thread_pool.cc b/runtime/thread_pool.cc
index f0f6f1844d..784a7caadf 100644
--- a/runtime/thread_pool.cc
+++ b/runtime/thread_pool.cc
@@ -60,7 +60,7 @@ void* ThreadPoolWorker::Callback(void* arg) {
   return NULL;
 }
 
-void ThreadPool::AddTask(Thread* self, Task* task){
+void ThreadPool::AddTask(Thread* self, Task* task) {
   MutexLock mu(self, task_queue_lock_);
   tasks_.push_back(task);
   // If we have any waiters, signal one.
@@ -173,7 +173,7 @@ void ThreadPool::Wait(Thread* self, bool do_work, bool may_hold_locks) {
   }
 }
 
-size_t ThreadPool::GetTaskCount(Thread* self){
+size_t ThreadPool::GetTaskCount(Thread* self) {
   MutexLock mu(self, task_queue_lock_);
   return tasks_.size();
 }
-- 
cgit v1.2.3-59-g8ed1b


From 0cd7ec2dcd8d7ba30bf3ca420b40dac52849876c Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Wed, 17 Jul 2013 23:40:20 -0700
Subject: Fix cpplint whitespace/blank_line issues

Change-Id: Ice937e95e23dd622c17054551d4ae4cebd0ef8a2
---
 Android.mk                                       |  6 +-
 compiler/dex/arena_allocator.h                   |  3 -
 compiler/dex/arena_bit_vector.h                  |  1 -
 compiler/dex/backend.h                           |  2 -
 compiler/dex/dataflow_iterator.h                 |  3 -
 compiler/dex/growable_array.h                    |  1 -
 compiler/dex/local_value_numbering.cc            |  1 -
 compiler/dex/local_value_numbering.h             |  1 -
 compiler/dex/mir_graph.cc                        |  1 -
 compiler/dex/mir_graph.h                         |  1 -
 compiler/dex/portable/mir_to_gbc.cc              |  6 +-
 compiler/dex/portable/mir_to_gbc.h               |  1 -
 compiler/dex/quick/arm/assemble_arm.cc           |  1 -
 compiler/dex/quick/codegen_util.cc               |  3 -
 compiler/dex/quick/gen_invoke.cc                 |  1 -
 compiler/dex/quick/local_optimizations.cc        | 45 +++++++----
 compiler/dex/quick/mips/codegen_mips.h           |  2 -
 compiler/dex/quick/mir_to_lir.h                  |  1 -
 compiler/dex/quick/x86/codegen_x86.h             |  1 -
 compiler/dex/ssa_transformation.cc               | 97 ++++++++++++++++--------
 compiler/driver/compiler_driver.cc               |  2 +-
 compiler/elf_writer_mclinker.cc                  |  1 -
 compiler/elf_writer_mclinker.h                   |  1 -
 compiler/elf_writer_test.cc                      |  1 -
 compiler/jni/portable/jni_compiler.cc            |  9 +--
 compiler/jni/quick/x86/calling_convention_x86.cc |  1 -
 compiler/llvm/gbc_expander.cc                    |  5 --
 compiler/llvm/ir_builder.h                       |  2 -
 compiler/llvm/llvm_compilation_unit.cc           |  1 -
 compiler/oat_writer.cc                           |  1 -
 dex2oat/dex2oat.cc                               |  1 -
 runtime/atomic_integer.h                         |  3 +-
 runtime/barrier.cc                               |  2 +-
 runtime/barrier_test.cc                          |  9 +--
 runtime/base/histogram-inl.h                     |  1 -
 runtime/base/histogram.h                         |  1 -
 runtime/base/timing_logger.h                     |  3 -
 runtime/debugger.cc                              |  2 -
 runtime/dex_method_iterator.h                    |  1 -
 runtime/gc/accounting/heap_bitmap-inl.h          |  1 -
 runtime/gc/accounting/heap_bitmap.h              |  1 -
 runtime/gc/accounting/space_bitmap.cc            |  4 +-
 runtime/gc/accounting/space_bitmap.h             |  1 +
 runtime/gc/collector/garbage_collector.h         |  1 -
 runtime/gc/space/image_space.h                   |  1 -
 runtime/gc/space/large_object_space.cc           |  8 +-
 runtime/gc/space/large_object_space.h            |  2 +-
 runtime/image_test.cc                            |  1 -
 runtime/interpreter/interpreter.cc               |  1 -
 runtime/jdwp/jdwp_handler.cc                     |  1 -
 runtime/mirror/abstract_method.h                 |  8 +-
 runtime/mirror/class.cc                          |  4 +-
 runtime/oat/runtime/argument_visitor.h           |  3 +-
 runtime/oat_file.cc                              |  1 -
 runtime/runtime_support_llvm.cc                  |  2 -
 runtime/runtime_support_llvm.h                   |  3 -
 runtime/stack.h                                  |  3 +-
 runtime/thread.cc                                |  4 +-
 runtime/thread_pool.cc                           | 13 +---
 runtime/thread_pool.h                            |  4 +-
 runtime/thread_pool_test.cc                      |  4 +-
 runtime/trace.h                                  |  1 +
 runtime/verifier/method_verifier.cc              |  1 -
 runtime/verifier/reg_type.h                      |  4 +
 runtime/verifier/reg_type_test.cc                |  4 +-
 runtime/verifier/register_line.cc                |  1 -
 test/ReferenceMap/stack_walk_refmap_jni.cc       |  2 +-
 test/StackWalk/stack_walk_jni.cc                 |  2 +-
 68 files changed, 134 insertions(+), 177 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/Android.mk b/Android.mk
index 27bd894f13..971eb2f202 100644
--- a/Android.mk
+++ b/Android.mk
@@ -334,15 +334,15 @@ endif
 .PHONY: cpplint-art
 cpplint-art:
 	./art/tools/cpplint.py \
-	    --filter=-,+build/header_guard,+whitespace/braces,+whitespace/comma,+runtime/explicit,+whitespace/newline \
-	    $(shell find art -name *.h -o -name *$(ART_CPP_EXTENSION))
+	    --filter=-,+build/header_guard,+whitespace/braces,+whitespace/comma,+runtime/explicit,+whitespace/newline,+whitespace/parens \
+	    $(shell find art -name *.h -o -name *$(ART_CPP_EXTENSION) | grep -v art/compiler/llvm/generated/)
 
 # "mm cpplint-art-aspirational" to see warnings we would like to fix
 .PHONY: cpplint-art-aspirational
 cpplint-art-aspirational:
 	./art/tools/cpplint.py \
 	    --filter=-whitespace/comments,-whitespace/line_length,-build/include,-readability/function,-readability/streams,-readability/todo,-runtime/references \
-	    $(shell find art -name *.h -o -name *$(ART_CPP_EXTENSION))
+	    $(shell find art -name *.h -o -name *$(ART_CPP_EXTENSION) | grep -v art/compiler/llvm/generated/)
 
 ########################################################################
 # targets to switch back and forth from libdvm to libart
diff --git a/compiler/dex/arena_allocator.h b/compiler/dex/arena_allocator.h
index 0ad859ea9a..cd2141a3c3 100644
--- a/compiler/dex/arena_allocator.h
+++ b/compiler/dex/arena_allocator.h
@@ -28,7 +28,6 @@ namespace art {
 
 class ArenaAllocator {
   public:
-
     // Type of allocation for memory tuning.
     enum ArenaAllocKind {
       kAllocMisc,
@@ -57,7 +56,6 @@ class ArenaAllocator {
   void DumpMemStats(std::ostream& os) const;
 
   private:
-
     // Variable-length allocation block.
     struct ArenaMemBlock {
       size_t block_size;
@@ -77,7 +75,6 @@ class ArenaAllocator {
     uint32_t alloc_stats_[kNumAllocKinds];   // Bytes used by various allocation kinds.
     uint32_t lost_bytes_;                    // Lost memory at end of too-small region
     uint32_t num_allocations_;
-
 };  // ArenaAllocator
 
 
diff --git a/compiler/dex/arena_bit_vector.h b/compiler/dex/arena_bit_vector.h
index 7e5c436f4c..de30859bfd 100644
--- a/compiler/dex/arena_bit_vector.h
+++ b/compiler/dex/arena_bit_vector.h
@@ -30,7 +30,6 @@ namespace art {
  */
 class ArenaBitVector {
   public:
-
     class Iterator {
       public:
         explicit Iterator(ArenaBitVector* bit_vector)
diff --git a/compiler/dex/backend.h b/compiler/dex/backend.h
index 7fa8e9992a..acfec42352 100644
--- a/compiler/dex/backend.h
+++ b/compiler/dex/backend.h
@@ -23,7 +23,6 @@
 namespace art {
 
 class Backend {
-
   public:
     virtual ~Backend() {};
     virtual void Materialize() = 0;
@@ -32,7 +31,6 @@ class Backend {
   protected:
     explicit Backend(ArenaAllocator* arena) : arena_(arena) {};
     ArenaAllocator* const arena_;
-
 };  // Class Backend
 
 }  // namespace art
diff --git a/compiler/dex/dataflow_iterator.h b/compiler/dex/dataflow_iterator.h
index 19468698f9..e427862956 100644
--- a/compiler/dex/dataflow_iterator.h
+++ b/compiler/dex/dataflow_iterator.h
@@ -41,7 +41,6 @@ namespace art {
    */
   class DataflowIterator {
     public:
-
       virtual ~DataflowIterator() {}
 
       // Return the next BasicBlock* to visit.
@@ -81,7 +80,6 @@ namespace art {
       GrowableArray<int>* block_id_list_;
       int idx_;
       bool changed_;
-
   }; // DataflowIterator
 
   class ReachableNodesIterator : public DataflowIterator {
@@ -106,7 +104,6 @@ namespace art {
 
   class PostOrderDfsIterator : public DataflowIterator {
     public:
-
       PostOrderDfsIterator(MIRGraph* mir_graph, bool is_iterative)
           : DataflowIterator(mir_graph, is_iterative, 0,
                              mir_graph->GetNumReachableBlocks(), false) {
diff --git a/compiler/dex/growable_array.h b/compiler/dex/growable_array.h
index 6d26bc216d..3bfbcd4edf 100644
--- a/compiler/dex/growable_array.h
+++ b/compiler/dex/growable_array.h
@@ -46,7 +46,6 @@ enum OatListKind {
 template<typename T>
 class GrowableArray {
   public:
-
     class Iterator {
       public:
         explicit Iterator(GrowableArray* g_list)
diff --git a/compiler/dex/local_value_numbering.cc b/compiler/dex/local_value_numbering.cc
index b783f3ed52..35d29235f2 100644
--- a/compiler/dex/local_value_numbering.cc
+++ b/compiler/dex/local_value_numbering.cc
@@ -509,7 +509,6 @@ uint16_t LocalValueNumbering::GetValueNumber(MIR* mir) {
         AdvanceMemoryVersion(NO_VALUE, field_ref);
       }
       break;
-
   }
   return res;
 }
diff --git a/compiler/dex/local_value_numbering.h b/compiler/dex/local_value_numbering.h
index 09ed7aec8d..d29600a479 100644
--- a/compiler/dex/local_value_numbering.h
+++ b/compiler/dex/local_value_numbering.h
@@ -135,7 +135,6 @@ class LocalValueNumbering {
   ValueMap value_map_;
   MemoryVersionMap memory_version_map_;
   std::set<uint16_t> null_checked_;
-
 };
 
 } // namespace art
diff --git a/compiler/dex/mir_graph.cc b/compiler/dex/mir_graph.cc
index a9af477d2a..0b3fa46faa 100644
--- a/compiler/dex/mir_graph.cc
+++ b/compiler/dex/mir_graph.cc
@@ -804,7 +804,6 @@ void MIRGraph::DumpCFG(const char* dir_prefix, bool all_blocks) {
 
       if (bb->successor_block_list.block_list_type == kPackedSwitch ||
           bb->successor_block_list.block_list_type == kSparseSwitch) {
-
         GrowableArray<SuccessorBlockInfo*>::Iterator iter(bb->successor_block_list.blocks);
 
         succ_id = 0;
diff --git a/compiler/dex/mir_graph.h b/compiler/dex/mir_graph.h
index f86e13016d..f6011e06e6 100644
--- a/compiler/dex/mir_graph.h
+++ b/compiler/dex/mir_graph.h
@@ -553,7 +553,6 @@ class MIRGraph {
    static const char* extended_mir_op_names_[kMirOpLast - kMirOpFirst];
 
  private:
-
    int FindCommonParent(int block1, int block2);
    void ComputeSuccLineIn(ArenaBitVector* dest, const ArenaBitVector* src1,
                           const ArenaBitVector* src2);
diff --git a/compiler/dex/portable/mir_to_gbc.cc b/compiler/dex/portable/mir_to_gbc.cc
index 4317d1e354..cfd3dafbee 100644
--- a/compiler/dex/portable/mir_to_gbc.cc
+++ b/compiler/dex/portable/mir_to_gbc.cc
@@ -74,7 +74,6 @@ void MirConverter::DefineValueOnly(::llvm::Value* val, int s_reg) {
   ::llvm::Instruction* inst = ::llvm::dyn_cast< ::llvm::Instruction>(placeholder);
   DCHECK(inst != NULL);
   inst->eraseFromParent();
-
 }
 
 void MirConverter::DefineValue(::llvm::Value* val, int s_reg) {
@@ -1580,8 +1579,7 @@ void MirConverter::HandlePhiNodes(BasicBlock* bb, ::llvm::BasicBlock* llvm_bb) {
 
 /* Extended MIR instructions like PHI */
 void MirConverter::ConvertExtendedMIR(BasicBlock* bb, MIR* mir,
-                               ::llvm::BasicBlock* llvm_bb) {
-
+                                      ::llvm::BasicBlock* llvm_bb) {
   switch (static_cast<ExtendedMIROpcode>(mir->dalvikInsn.opcode)) {
     case kMirOpPhi: {
       // The llvm Phi node already emitted - just DefineValue() here.
@@ -1706,7 +1704,6 @@ bool MirConverter::BlockBitcodeConversion(BasicBlock* bb) {
   HandlePhiNodes(bb, llvm_bb);
 
   for (MIR* mir = bb->first_mir_insn; mir != NULL; mir = mir->next) {
-
     SetDexOffset(mir->offset);
 
     int opcode = mir->dalvikInsn.opcode;
@@ -1795,7 +1792,6 @@ char RemapShorty(char shorty_type) {
 }
 
 ::llvm::FunctionType* MirConverter::GetFunctionType() {
-
   // Get return type
   ::llvm::Type* ret_type = irb_->getJType(RemapShorty(cu_->shorty[0]));
 
diff --git a/compiler/dex/portable/mir_to_gbc.h b/compiler/dex/portable/mir_to_gbc.h
index 278631466f..2b681f6097 100644
--- a/compiler/dex/portable/mir_to_gbc.h
+++ b/compiler/dex/portable/mir_to_gbc.h
@@ -41,7 +41,6 @@ Backend* PortableCodeGenerator(CompilationUnit* const cu, MIRGraph* const mir_gr
                                llvm::LlvmCompilationUnit* const llvm_compilation_unit);
 
 class MirConverter : public Backend {
-
   public:
     // TODO: flesh out and integrate into new world order.
     MirConverter(CompilationUnit* cu, MIRGraph* mir_graph, ArenaAllocator* arena,
diff --git a/compiler/dex/quick/arm/assemble_arm.cc b/compiler/dex/quick/arm/assemble_arm.cc
index f4aa1f3212..0649c9f319 100644
--- a/compiler/dex/quick/arm/assemble_arm.cc
+++ b/compiler/dex/quick/arm/assemble_arm.cc
@@ -1007,7 +1007,6 @@ AssemblerStatus ArmMir2Lir::AssembleInstructions(uintptr_t start_addr) {
   AssemblerStatus res = kSuccess;  // Assume success
 
   for (lir = first_lir_insn_; lir != NULL; lir = NEXT_LIR(lir)) {
-
     if (lir->opcode < 0) {
       /* 1 means padding is needed */
       if ((lir->opcode == kPseudoPseudoAlign4) && (lir->operands[0] == 1)) {
diff --git a/compiler/dex/quick/codegen_util.cc b/compiler/dex/quick/codegen_util.cc
index e169dc8f54..8698b1f9ed 100644
--- a/compiler/dex/quick/codegen_util.cc
+++ b/compiler/dex/quick/codegen_util.cc
@@ -969,7 +969,6 @@ void Mir2Lir::Materialize() {
 
   /* Method is not empty */
   if (first_lir_insn_) {
-
     // mark the targets of switch statement case labels
     ProcessSwitchTables();
 
@@ -979,9 +978,7 @@ void Mir2Lir::Materialize() {
     if (cu_->verbose) {
       CodegenDump();
     }
-
   }
-
 }
 
 CompiledMethod* Mir2Lir::GetCompiledMethod() {
diff --git a/compiler/dex/quick/gen_invoke.cc b/compiler/dex/quick/gen_invoke.cc
index 14e395cdac..fd8f86b5fc 100644
--- a/compiler/dex/quick/gen_invoke.cc
+++ b/compiler/dex/quick/gen_invoke.cc
@@ -736,7 +736,6 @@ int Mir2Lir::GenDalvikArgsRange(CallInfo* info, int call_state,
                                 const MethodReference& target_method,
                                 uint32_t vtable_idx, uintptr_t direct_code, uintptr_t direct_method,
                                 InvokeType type, bool skip_this) {
-
   // If we can treat it as non-range (Jumbo ops will use range form)
   if (info->num_arg_words <= 5)
     return GenDalvikArgsNoRange(info, call_state, pcrLabel,
diff --git a/compiler/dex/quick/local_optimizations.cc b/compiler/dex/quick/local_optimizations.cc
index eb27bf8b5d..2e9c845d05 100644
--- a/compiler/dex/quick/local_optimizations.cc
+++ b/compiler/dex/quick/local_optimizations.cc
@@ -73,11 +73,14 @@ void Mir2Lir::ConvertMemOpIntoMove(LIR* orig_lir, int dest, int src) {
 void Mir2Lir::ApplyLoadStoreElimination(LIR* head_lir, LIR* tail_lir) {
   LIR* this_lir;
 
-  if (head_lir == tail_lir) return;
+  if (head_lir == tail_lir) {
+    return;
+  }
 
   for (this_lir = PREV_LIR(tail_lir); this_lir != head_lir; this_lir = PREV_LIR(this_lir)) {
-
-    if (is_pseudo_opcode(this_lir->opcode)) continue;
+    if (is_pseudo_opcode(this_lir->opcode)) {
+      continue;
+    }
 
     int sink_distance = 0;
 
@@ -110,7 +113,9 @@ void Mir2Lir::ApplyLoadStoreElimination(LIR* head_lir, LIR* tail_lir) {
      * Currently only eliminate redundant ld/st for constant and Dalvik
      * register accesses.
      */
-    if (!(this_mem_mask & (ENCODE_LITERAL | ENCODE_DALVIK_REG))) continue;
+    if (!(this_mem_mask & (ENCODE_LITERAL | ENCODE_DALVIK_REG))) {
+      continue;
+    }
 
     uint64_t stop_def_reg_mask = this_lir->def_mask & ~ENCODE_MEM;
     uint64_t stop_use_reg_mask;
@@ -127,12 +132,13 @@ void Mir2Lir::ApplyLoadStoreElimination(LIR* head_lir, LIR* tail_lir) {
     }
 
     for (check_lir = NEXT_LIR(this_lir); check_lir != tail_lir; check_lir = NEXT_LIR(check_lir)) {
-
       /*
        * Skip already dead instructions (whose dataflow information is
        * outdated and misleading).
        */
-      if (check_lir->flags.is_nop || is_pseudo_opcode(check_lir->opcode)) continue;
+      if (check_lir->flags.is_nop || is_pseudo_opcode(check_lir->opcode)) {
+        continue;
+      }
 
       uint64_t check_mem_mask = (check_lir->use_mask | check_lir->def_mask) & ENCODE_MEM;
       uint64_t alias_condition = this_mem_mask & check_mem_mask;
@@ -274,12 +280,15 @@ void Mir2Lir::ApplyLoadHoisting(LIR* head_lir, LIR* tail_lir) {
   LIR* prev_inst_list[MAX_HOIST_DISTANCE];
 
   /* Empty block */
-  if (head_lir == tail_lir) return;
+  if (head_lir == tail_lir) {
+    return;
+  }
 
   /* Start from the second instruction */
   for (this_lir = NEXT_LIR(head_lir); this_lir != tail_lir; this_lir = NEXT_LIR(this_lir)) {
-
-    if (is_pseudo_opcode(this_lir->opcode)) continue;
+    if (is_pseudo_opcode(this_lir->opcode)) {
+      continue;
+    }
 
     uint64_t target_flags = GetTargetInstFlags(this_lir->opcode);
     /* Skip non-interesting instructions */
@@ -312,12 +321,13 @@ void Mir2Lir::ApplyLoadHoisting(LIR* head_lir, LIR* tail_lir) {
 
     /* Try to hoist the load to a good spot */
     for (check_lir = PREV_LIR(this_lir); check_lir != head_lir; check_lir = PREV_LIR(check_lir)) {
-
       /*
        * Skip already dead instructions (whose dataflow information is
        * outdated and misleading).
        */
-      if (check_lir->flags.is_nop) continue;
+      if (check_lir->flags.is_nop) {
+        continue;
+      }
 
       uint64_t check_mem_mask = check_lir->def_mask & ENCODE_MEM;
       uint64_t alias_condition = stop_use_all_mask & check_mem_mask;
@@ -355,7 +365,9 @@ void Mir2Lir::ApplyLoadHoisting(LIR* head_lir, LIR* tail_lir) {
        */
       if (stop_here || !is_pseudo_opcode(check_lir->opcode)) {
         prev_inst_list[next_slot++] = check_lir;
-        if (next_slot == MAX_HOIST_DISTANCE) break;
+        if (next_slot == MAX_HOIST_DISTANCE) {
+          break;
+        }
       }
 
       /* Found a new place to put the load - move it here */
@@ -400,12 +412,16 @@ void Mir2Lir::ApplyLoadHoisting(LIR* head_lir, LIR* tail_lir) {
            * If the first instruction is a load, don't hoist anything
            * above it since it is unlikely to be beneficial.
            */
-          if (GetTargetInstFlags(cur_lir->opcode) & IS_LOAD) continue;
+          if (GetTargetInstFlags(cur_lir->opcode) & IS_LOAD) {
+            continue;
+          }
           /*
            * If the remaining number of slots is less than LD_LATENCY,
            * insert the hoisted load here.
            */
-          if (slot < LD_LATENCY) break;
+          if (slot < LD_LATENCY) {
+            break;
+          }
         }
 
         // Don't look across a barrier label
@@ -461,7 +477,6 @@ void Mir2Lir::RemoveRedundantBranches() {
   LIR* this_lir;
 
   for (this_lir = first_lir_insn_; this_lir != last_lir_insn_; this_lir = NEXT_LIR(this_lir)) {
-
     /* Branch to the next instruction */
     if (IsUnconditionalBranch(this_lir)) {
       LIR* next_lir = this_lir;
diff --git a/compiler/dex/quick/mips/codegen_mips.h b/compiler/dex/quick/mips/codegen_mips.h
index 376ad7f10e..802ff625c9 100644
--- a/compiler/dex/quick/mips/codegen_mips.h
+++ b/compiler/dex/quick/mips/codegen_mips.h
@@ -24,7 +24,6 @@ namespace art {
 
 class MipsMir2Lir : public Mir2Lir {
   public:
-
     MipsMir2Lir(CompilationUnit* cu, MIRGraph* mir_graph, ArenaAllocator* arena);
 
     // Required for target - codegen utilities.
@@ -175,7 +174,6 @@ class MipsMir2Lir : public Mir2Lir {
 
   private:
     void ConvertShortToLongBranch(LIR* lir);
-
 };
 
 }  // namespace art
diff --git a/compiler/dex/quick/mir_to_lir.h b/compiler/dex/quick/mir_to_lir.h
index abb687cb84..41e5a2d988 100644
--- a/compiler/dex/quick/mir_to_lir.h
+++ b/compiler/dex/quick/mir_to_lir.h
@@ -166,7 +166,6 @@ Mir2Lir* X86CodeGenerator(CompilationUnit* const cu, MIRGraph* const mir_graph,
 #define is_pseudo_opcode(opcode) (static_cast<int>(opcode) < 0)
 
 class Mir2Lir : public Backend {
-
   public:
     struct SwitchTable {
       int offset;
diff --git a/compiler/dex/quick/x86/codegen_x86.h b/compiler/dex/quick/x86/codegen_x86.h
index 4fa9dfb4d9..edb5ae57c2 100644
--- a/compiler/dex/quick/x86/codegen_x86.h
+++ b/compiler/dex/quick/x86/codegen_x86.h
@@ -24,7 +24,6 @@ namespace art {
 
 class X86Mir2Lir : public Mir2Lir {
   public:
-
     X86Mir2Lir(CompilationUnit* cu, MIRGraph* mir_graph, ArenaAllocator* arena);
 
     // Required for target - codegen helpers.
diff --git a/compiler/dex/ssa_transformation.cc b/compiler/dex/ssa_transformation.cc
index ccd2454a49..3a0cbcc67c 100644
--- a/compiler/dex/ssa_transformation.cc
+++ b/compiler/dex/ssa_transformation.cc
@@ -46,9 +46,13 @@ BasicBlock* MIRGraph::NextUnvisitedSuccessor(BasicBlock* bb) {
         GrowableArray<SuccessorBlockInfo*>::Iterator iterator(bb->successor_block_list.blocks);
         while (true) {
           SuccessorBlockInfo *sbi = iterator.Next();
-          if (sbi == NULL) break;
+          if (sbi == NULL) {
+            break;
+          }
           res = NeedsVisit(sbi->block);
-          if (res != NULL) break;
+          if (res != NULL) {
+            break;
+          }
         }
       }
     }
@@ -112,12 +116,16 @@ void MIRGraph::ComputeDFSOrders() {
  * register idx is defined in BasicBlock bb.
  */
 bool MIRGraph::FillDefBlockMatrix(BasicBlock* bb) {
-  if (bb->data_flow_info == NULL) return false;
+  if (bb->data_flow_info == NULL) {
+    return false;
+  }
 
   ArenaBitVector::Iterator iterator(bb->data_flow_info->def_v);
   while (true) {
     int idx = iterator.Next();
-    if (idx == -1) break;
+    if (idx == -1) {
+      break;
+    }
     /* Block bb defines register idx */
     def_block_matrix_[idx]->SetBit(bb->id);
   }
@@ -222,7 +230,9 @@ bool MIRGraph::ComputeDominanceFrontier(BasicBlock* bb) {
     GrowableArray<SuccessorBlockInfo*>::Iterator iterator(bb->successor_block_list.blocks);
       while (true) {
         SuccessorBlockInfo *successor_block_info = iterator.Next();
-        if (successor_block_info == NULL) break;
+        if (successor_block_info == NULL) {
+          break;
+        }
         BasicBlock* succ_bb = successor_block_info->block;
         CheckForDominanceFrontier(bb, succ_bb);
       }
@@ -233,13 +243,17 @@ bool MIRGraph::ComputeDominanceFrontier(BasicBlock* bb) {
   while (true) {
     //TUNING: hot call to BitVectorIteratorNext
     int dominated_idx = bv_iterator.Next();
-    if (dominated_idx == -1) break;
+    if (dominated_idx == -1) {
+      break;
+    }
     BasicBlock* dominated_bb = GetBasicBlock(dominated_idx);
     ArenaBitVector::Iterator df_iterator(dominated_bb->dom_frontier);
     while (true) {
       //TUNING: hot call to BitVectorIteratorNext
       int df_up_idx = df_iterator.Next();
-      if (df_up_idx == -1) break;
+      if (df_up_idx == -1) {
+        break;
+      }
       BasicBlock* df_up_block = GetBasicBlock(df_up_idx);
       CheckForDominanceFrontier(bb, df_up_block);
     }
@@ -313,7 +327,9 @@ bool MIRGraph::ComputeblockIDom(BasicBlock* bb) {
   /* Scan the rest of the predecessors */
   while (true) {
       BasicBlock* pred_bb = iter.Next();
-      if (!pred_bb) break;
+      if (!pred_bb) {
+        break;
+      }
       if (i_dom_list_[pred_bb->dfs_id] == NOTVISITED) {
         continue;
       } else {
@@ -443,7 +459,9 @@ void MIRGraph::ComputeSuccLineIn(ArenaBitVector* dest, const ArenaBitVector* src
 bool MIRGraph::ComputeBlockLiveIns(BasicBlock* bb) {
   ArenaBitVector* temp_dalvik_register_v = temp_dalvik_register_v_;
 
-  if (bb->data_flow_info == NULL) return false;
+  if (bb->data_flow_info == NULL) {
+    return false;
+  }
   temp_dalvik_register_v->Copy(bb->data_flow_info->live_in_v);
   if (bb->taken && bb->taken->data_flow_info)
     ComputeSuccLineIn(temp_dalvik_register_v, bb->taken->data_flow_info->live_in_v,
@@ -455,7 +473,9 @@ bool MIRGraph::ComputeBlockLiveIns(BasicBlock* bb) {
     GrowableArray<SuccessorBlockInfo*>::Iterator iterator(bb->successor_block_list.blocks);
     while (true) {
       SuccessorBlockInfo *successor_block_info = iterator.Next();
-      if (successor_block_info == NULL) break;
+      if (successor_block_info == NULL) {
+        break;
+      }
       BasicBlock* succ_bb = successor_block_info->block;
       if (succ_bb->data_flow_info) {
         ComputeSuccLineIn(temp_dalvik_register_v, succ_bb->data_flow_info->live_in_v,
@@ -504,25 +524,27 @@ void MIRGraph::InsertPhiNodes() {
 
       while (true) {
         int idx = iterator.Next();
-        if (idx == -1) break;
-          BasicBlock* def_bb = GetBasicBlock(idx);
+        if (idx == -1) {
+          break;
+        }
+        BasicBlock* def_bb = GetBasicBlock(idx);
 
-          /* Merge the dominance frontier to tmp_blocks */
-          //TUNING: hot call to Union().
-          if (def_bb->dom_frontier != NULL) {
-            tmp_blocks->Union(def_bb->dom_frontier);
-          }
+        /* Merge the dominance frontier to tmp_blocks */
+        //TUNING: hot call to Union().
+        if (def_bb->dom_frontier != NULL) {
+          tmp_blocks->Union(def_bb->dom_frontier);
         }
-        if (!phi_blocks->Equal(tmp_blocks)) {
-          change = true;
-          phi_blocks->Copy(tmp_blocks);
-
-          /*
-           * Iterate through the original blocks plus the new ones in
-           * the dominance frontier.
-           */
-          input_blocks->Copy(phi_blocks);
-          input_blocks->Union(def_block_matrix_[dalvik_reg]);
+      }
+      if (!phi_blocks->Equal(tmp_blocks)) {
+        change = true;
+        phi_blocks->Copy(tmp_blocks);
+
+        /*
+         * Iterate through the original blocks plus the new ones in
+         * the dominance frontier.
+         */
+        input_blocks->Copy(phi_blocks);
+        input_blocks->Union(def_block_matrix_[dalvik_reg]);
       }
     } while (change);
 
@@ -533,10 +555,14 @@ void MIRGraph::InsertPhiNodes() {
     ArenaBitVector::Iterator iterator(phi_blocks);
     while (true) {
       int idx = iterator.Next();
-      if (idx == -1) break;
+      if (idx == -1) {
+        break;
+      }
       BasicBlock* phi_bb = GetBasicBlock(idx);
       /* Variable will be clobbered before being used - no need for phi */
-      if (!phi_bb->data_flow_info->live_in_v->IsBitSet(dalvik_reg)) continue;
+      if (!phi_bb->data_flow_info->live_in_v->IsBitSet(dalvik_reg)) {
+        continue;
+      }
       MIR *phi =
           static_cast<MIR*>(arena_->NewMem(sizeof(MIR), true, ArenaAllocator::kAllocDFInfo));
       phi->dalvikInsn.opcode = static_cast<Instruction::Code>(kMirOpPhi);
@@ -572,7 +598,9 @@ bool MIRGraph::InsertPhiNodeOperands(BasicBlock* bb) {
     GrowableArray<BasicBlock*>::Iterator iter(bb->predecessors);
     while (true) {
       BasicBlock* pred_bb = iter.Next();
-      if (!pred_bb) break;
+      if (!pred_bb) {
+        break;
+      }
       int ssa_reg = pred_bb->data_flow_info->vreg_to_ssa_map[v_reg];
       uses.push_back(ssa_reg);
       incoming_arc.push_back(pred_bb->id);
@@ -605,8 +633,9 @@ bool MIRGraph::InsertPhiNodeOperands(BasicBlock* bb) {
 }
 
 void MIRGraph::DoDFSPreOrderSSARename(BasicBlock* block) {
-
-  if (block->visited || block->hidden) return;
+  if (block->visited || block->hidden) {
+    return;
+  }
   block->visited = true;
 
   /* Process this block */
@@ -632,7 +661,9 @@ void MIRGraph::DoDFSPreOrderSSARename(BasicBlock* block) {
     GrowableArray<SuccessorBlockInfo*>::Iterator iterator(block->successor_block_list.blocks);
     while (true) {
       SuccessorBlockInfo *successor_block_info = iterator.Next();
-      if (successor_block_info == NULL) break;
+      if (successor_block_info == NULL) {
+        break;
+      }
       BasicBlock* succ_bb = successor_block_info->block;
       DoDFSPreOrderSSARename(succ_bb);
       /* Restore SSA map snapshot */
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index d1d21b1d03..f1082db9bc 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -1402,7 +1402,6 @@ class ParallelCompilationManager {
   }
 
  private:
-
   class ForAllClosure : public Task {
    public:
     ForAllClosure(ParallelCompilationManager* manager, size_t begin, size_t end, Callback* callback,
@@ -1423,6 +1422,7 @@ class ParallelCompilationManager {
     virtual void Finalize() {
       delete this;
     }
+
    private:
     const ParallelCompilationManager* const manager_;
     const size_t begin_;
diff --git a/compiler/elf_writer_mclinker.cc b/compiler/elf_writer_mclinker.cc
index 472a606cc6..05f3b025e7 100644
--- a/compiler/elf_writer_mclinker.cc
+++ b/compiler/elf_writer_mclinker.cc
@@ -307,7 +307,6 @@ void ElfWriterMclinker::AddRuntimeInputs(const std::string& android_root, bool i
   // TODO: ownership of libm_lib_input?
   mcld::Input* libm_lib_input_input = ir_builder_->ReadInput(libm_lib, libm_lib);
   CHECK(libm_lib_input_input != NULL);
-
 }
 #endif
 
diff --git a/compiler/elf_writer_mclinker.h b/compiler/elf_writer_mclinker.h
index 468fa9a84f..3b33bc4986 100644
--- a/compiler/elf_writer_mclinker.h
+++ b/compiler/elf_writer_mclinker.h
@@ -38,7 +38,6 @@ class CompiledCode;
 
 class ElfWriterMclinker : public ElfWriter {
  public:
-
   // Write an ELF file. Returns true on success, false on failure.
   static bool Create(File* file,
                      std::vector<uint8_t>& oat_contents,
diff --git a/compiler/elf_writer_test.cc b/compiler/elf_writer_test.cc
index 4a02b61242..e48806ecc4 100644
--- a/compiler/elf_writer_test.cc
+++ b/compiler/elf_writer_test.cc
@@ -22,7 +22,6 @@
 namespace art {
 
 class ElfWriterTest : public CommonTest {
-
  protected:
   virtual void SetUp() {
     ReserveImageSpace();
diff --git a/compiler/jni/portable/jni_compiler.cc b/compiler/jni/portable/jni_compiler.cc
index 44d0c2d215..57b8a315a1 100644
--- a/compiler/jni/portable/jni_compiler.cc
+++ b/compiler/jni/portable/jni_compiler.cc
@@ -46,11 +46,10 @@ using namespace runtime_support;
 JniCompiler::JniCompiler(LlvmCompilationUnit* cunit,
                          const CompilerDriver& driver,
                          const DexCompilationUnit* dex_compilation_unit)
-: cunit_(cunit), driver_(&driver), module_(cunit_->GetModule()),
-  context_(cunit_->GetLLVMContext()), irb_(*cunit_->GetIRBuilder()),
-  dex_compilation_unit_(dex_compilation_unit),
-  func_(NULL), elf_func_idx_(0) {
-
+    : cunit_(cunit), driver_(&driver), module_(cunit_->GetModule()),
+      context_(cunit_->GetLLVMContext()), irb_(*cunit_->GetIRBuilder()),
+      dex_compilation_unit_(dex_compilation_unit),
+      func_(NULL), elf_func_idx_(0) {
   // Check: Ensure that JNI compiler will only get "native" method
   CHECK(dex_compilation_unit->IsNative());
 }
diff --git a/compiler/jni/quick/x86/calling_convention_x86.cc b/compiler/jni/quick/x86/calling_convention_x86.cc
index b671bd190c..45dd42960c 100644
--- a/compiler/jni/quick/x86/calling_convention_x86.cc
+++ b/compiler/jni/quick/x86/calling_convention_x86.cc
@@ -159,7 +159,6 @@ size_t X86JniCallingConvention::NumberOfOutgoingStackArgs() {
   // count JNIEnv* and return pc (pushed after Method*)
   size_t total_args = static_args + param_args + 2;
   return total_args;
-
 }
 
 }  // namespace x86
diff --git a/compiler/llvm/gbc_expander.cc b/compiler/llvm/gbc_expander.cc
index b139e322f1..94cc9731aa 100644
--- a/compiler/llvm/gbc_expander.cc
+++ b/compiler/llvm/gbc_expander.cc
@@ -361,7 +361,6 @@ class GBCExpanderPass : public llvm::FunctionPass {
 
   llvm::Value* ExpandIntrinsic(IntrinsicHelper::IntrinsicId intr_id,
                                llvm::CallInst& call_inst);
-
 };
 
 char GBCExpanderPass::ID = 0;
@@ -710,7 +709,6 @@ llvm::Value* GBCExpanderPass::EmitLoadArrayLength(llvm::Value* array) {
                                    art::mirror::Array::LengthOffset().Int32Value(),
                                    irb_.getJIntTy(),
                                    kTBAAConstJObject);
-
 }
 
 llvm::Value*
@@ -751,7 +749,6 @@ EmitLoadVirtualCalleeMethodObjectAddr(int vtable_idx, llvm::Value* this_addr) {
 llvm::Value* GBCExpanderPass::EmitArrayGEP(llvm::Value* array_addr,
                                            llvm::Value* index_value,
                                            JType elem_jty) {
-
   int data_offset;
   if (elem_jty == kLong || elem_jty == kDouble ||
       (elem_jty == kObject && sizeof(uint64_t) == sizeof(art::mirror::Object*))) {
@@ -1426,7 +1423,6 @@ llvm::Value* GBCExpanderPass::Expand_LongCompare(llvm::Value* src1_value, llvm::
 
 llvm::Value* GBCExpanderPass::EmitCompareResultSelection(llvm::Value* cmp_eq,
                                                          llvm::Value* cmp_lt) {
-
   llvm::Constant* zero = irb_.getJInt(0);
   llvm::Constant* pos1 = irb_.getJInt(1);
   llvm::Constant* neg1 = irb_.getJInt(-1);
@@ -2437,7 +2433,6 @@ EmitCallRuntimeForCalleeMethodObjectAddr(uint32_t callee_method_idx,
                                          llvm::Value* this_addr,
                                          uint32_t dex_pc,
                                          bool is_fast_path) {
-
   llvm::Function* runtime_func = NULL;
 
   switch (invoke_type) {
diff --git a/compiler/llvm/ir_builder.h b/compiler/llvm/ir_builder.h
index 65da005e9b..c81ba278a8 100644
--- a/compiler/llvm/ir_builder.h
+++ b/compiler/llvm/ir_builder.h
@@ -219,7 +219,6 @@ class IRBuilder : public LLVMIRBuilder {
   ::llvm::Value* CreatePtrDisp(::llvm::Value* base,
                              ::llvm::Value* offset,
                              ::llvm::PointerType* ret_ty) {
-
     ::llvm::Value* base_int = CreatePtrToInt(base, getPtrEquivIntTy());
     ::llvm::Value* result_int = CreateAdd(base_int, offset);
     ::llvm::Value* result = CreateIntToPtr(result_int, ret_ty);
@@ -232,7 +231,6 @@ class IRBuilder : public LLVMIRBuilder {
                              ::llvm::Value* count,
                              ::llvm::Value* offset,
                              ::llvm::PointerType* ret_ty) {
-
     ::llvm::Value* block_offset = CreateMul(bs, count);
     ::llvm::Value* total_offset = CreateAdd(block_offset, offset);
 
diff --git a/compiler/llvm/llvm_compilation_unit.cc b/compiler/llvm/llvm_compilation_unit.cc
index dfb572477e..1f2b977921 100644
--- a/compiler/llvm/llvm_compilation_unit.cc
+++ b/compiler/llvm/llvm_compilation_unit.cc
@@ -166,7 +166,6 @@ void LlvmCompilationUnit::DumpBitcodeToString(std::string& str_buffer) {
 }
 
 bool LlvmCompilationUnit::Materialize() {
-
   const bool kDumpBitcode = false;
   if (kDumpBitcode) {
     // Dump the bitcode for debugging
diff --git a/compiler/oat_writer.cc b/compiler/oat_writer.cc
index 0bfa4ec328..4c32506d43 100644
--- a/compiler/oat_writer.cc
+++ b/compiler/oat_writer.cc
@@ -83,7 +83,6 @@ OatWriter::OatWriter(const std::vector<const DexFile*>& dex_files,
     size_oat_dex_file_methods_offsets_(0),
     size_oat_class_status_(0),
     size_oat_class_method_offsets_(0) {
-
   size_t offset = InitOatHeader();
   offset = InitOatDexFiles(offset);
   offset = InitDexFiles(offset);
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index 541c916936..9e23d3e7d3 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -440,7 +440,6 @@ static size_t OpenDexFiles(const std::vector<const char*>& dex_filenames,
 // during development when fatal aborts lead to a cascade of failures
 // that result in a deadlock.
 class WatchDog {
-
 // WatchDog defines its own CHECK_PTHREAD_CALL to avoid using Log which uses locks
 #undef CHECK_PTHREAD_CALL
 #define CHECK_WATCH_DOG_PTHREAD_CALL(call, args, what) \
diff --git a/runtime/atomic_integer.h b/runtime/atomic_integer.h
index 117e837bdb..6711722672 100644
--- a/runtime/atomic_integer.h
+++ b/runtime/atomic_integer.h
@@ -70,10 +70,11 @@ class AtomicInteger {
     bool success = android_atomic_cas(expected_value, new_value, &value_) == 0;
     return success;
   }
+
  private:
   volatile int32_t value_;
 };
 
-}
+}  // namespace art
 
 #endif  // ART_RUNTIME_ATOMIC_INTEGER_H_
diff --git a/runtime/barrier.cc b/runtime/barrier.cc
index 250d468adb..a64499848e 100644
--- a/runtime/barrier.cc
+++ b/runtime/barrier.cc
@@ -60,4 +60,4 @@ Barrier::~Barrier() {
   CHECK(!count_) << "Attempted to destroy barrier with non zero count";
 }
 
-}
+}  // namespace art
diff --git a/runtime/barrier_test.cc b/runtime/barrier_test.cc
index d26ae9e20f..298ae569fb 100644
--- a/runtime/barrier_test.cc
+++ b/runtime/barrier_test.cc
@@ -32,9 +32,7 @@ class CheckWaitTask : public Task {
       : barrier_(barrier),
         count1_(count1),
         count2_(count2),
-        count3_(count3) {
-
-  }
+        count3_(count3) {}
 
   void Run(Thread* self) {
     LOG(INFO) << "Before barrier 1 " << *self;
@@ -50,6 +48,7 @@ class CheckWaitTask : public Task {
   virtual void Finalize() {
     delete this;
   }
+
  private:
   Barrier* const barrier_;
   AtomicInteger* const count1_;
@@ -100,9 +99,7 @@ class CheckPassTask : public Task {
   CheckPassTask(Barrier* barrier, AtomicInteger* count, size_t subtasks)
       : barrier_(barrier),
         count_(count),
-        subtasks_(subtasks) {
-
-  }
+        subtasks_(subtasks) {}
 
   void Run(Thread* self) {
     for (size_t i = 0; i < subtasks_; ++i) {
diff --git a/runtime/base/histogram-inl.h b/runtime/base/histogram-inl.h
index bbca60308a..d572cf9cba 100644
--- a/runtime/base/histogram-inl.h
+++ b/runtime/base/histogram-inl.h
@@ -212,7 +212,6 @@ inline double Histogram<Value>::Percentile(double per) const {
   DCHECK_GT(cumulative_perc_.size(), 0ull);
   size_t idx, upper_idx = 0, lower_idx = 0;
   for (idx = 0; idx < cumulative_perc_.size(); idx++) {
-
     if (per <= cumulative_perc_[idx]) {
       upper_idx = idx;
       break;
diff --git a/runtime/base/histogram.h b/runtime/base/histogram.h
index dfb556bd79..33a1e6518b 100644
--- a/runtime/base/histogram.h
+++ b/runtime/base/histogram.h
@@ -30,7 +30,6 @@ namespace art {
 // Designed to be simple and used with timing logger in art.
 
 template <class Value> class Histogram {
-
   const double kAdjust;
   const Value kBucketWidth;
   const size_t kInitialBucketCount;
diff --git a/runtime/base/timing_logger.h b/runtime/base/timing_logger.h
index 816cbeadec..0f00a046e5 100644
--- a/runtime/base/timing_logger.h
+++ b/runtime/base/timing_logger.h
@@ -50,9 +50,7 @@ namespace base {
 }  // namespace base
 
 class CumulativeLogger {
-
  public:
-
   explicit CumulativeLogger(const std::string& name);
   void prepare_stats();
   ~CumulativeLogger();
@@ -68,7 +66,6 @@ class CumulativeLogger {
   void AddNewLogger(const base::NewTimingLogger& logger) LOCKS_EXCLUDED(lock_);
 
  private:
-
   void AddPair(const std::string &label, uint64_t delta_time)
       EXCLUSIVE_LOCKS_REQUIRED(lock_);
   void DumpHistogram(std::ostream &os) EXCLUSIVE_LOCKS_REQUIRED(lock_);
diff --git a/runtime/debugger.cc b/runtime/debugger.cc
index 5a31c87935..b502c9ab58 100644
--- a/runtime/debugger.cc
+++ b/runtime/debugger.cc
@@ -155,7 +155,6 @@ class DebugInstrumentationListener : public instrumentation::InstrumentationList
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     Dbg::PostException(thread, throw_location, catch_method, catch_dex_pc, exception_object);
   }
-
 } gDebugInstrumentationListener;
 
 // JDWP is allowed unless the Zygote forbids it.
@@ -761,7 +760,6 @@ JDWP::JdwpError Dbg::GetContendedMonitor(JDWP::ObjectId thread_id, JDWP::ObjectI
 JDWP::JdwpError Dbg::GetInstanceCounts(const std::vector<JDWP::RefTypeId>& class_ids,
                                        std::vector<uint64_t>& counts)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-
   std::vector<mirror::Class*> classes;
   counts.clear();
   for (size_t i = 0; i < class_ids.size(); ++i) {
diff --git a/runtime/dex_method_iterator.h b/runtime/dex_method_iterator.h
index e915d77e6d..1975e48330 100644
--- a/runtime/dex_method_iterator.h
+++ b/runtime/dex_method_iterator.h
@@ -120,7 +120,6 @@ class DexMethodIterator {
   }
 
  private:
-
   ClassDataItemIterator& GetIterator() const {
     CHECK(it_.get() != NULL);
     return *it_.get();
diff --git a/runtime/gc/accounting/heap_bitmap-inl.h b/runtime/gc/accounting/heap_bitmap-inl.h
index 76226041d1..5edea95dc3 100644
--- a/runtime/gc/accounting/heap_bitmap-inl.h
+++ b/runtime/gc/accounting/heap_bitmap-inl.h
@@ -40,7 +40,6 @@ inline void HeapBitmap::Visit(const Visitor& visitor) {
     SpaceSetMap* set = *it;
     set->Visit(visitor);
   }
-
 }
 
 }  // namespace accounting
diff --git a/runtime/gc/accounting/heap_bitmap.h b/runtime/gc/accounting/heap_bitmap.h
index f4b725c4e9..1710579619 100644
--- a/runtime/gc/accounting/heap_bitmap.h
+++ b/runtime/gc/accounting/heap_bitmap.h
@@ -106,7 +106,6 @@ class HeapBitmap {
   explicit HeapBitmap(Heap* heap) : heap_(heap) {}
 
  private:
-
   const Heap* const heap_;
 
   void AddContinuousSpaceBitmap(SpaceBitmap* bitmap);
diff --git a/runtime/gc/accounting/space_bitmap.cc b/runtime/gc/accounting/space_bitmap.cc
index 19f1128963..6edc067cc7 100644
--- a/runtime/gc/accounting/space_bitmap.cc
+++ b/runtime/gc/accounting/space_bitmap.cc
@@ -64,9 +64,7 @@ SpaceBitmap* SpaceBitmap::Create(const std::string& name, byte* heap_begin, size
 }
 
 // Clean up any resources associated with the bitmap.
-SpaceBitmap::~SpaceBitmap() {
-
-}
+SpaceBitmap::~SpaceBitmap() {}
 
 void SpaceBitmap::SetHeapLimit(uintptr_t new_end) {
   DCHECK(IsAligned<kBitsPerWord * kAlignment>(new_end));
diff --git a/runtime/gc/accounting/space_bitmap.h b/runtime/gc/accounting/space_bitmap.h
index 5a1bfe3250..bf4c1ed9af 100644
--- a/runtime/gc/accounting/space_bitmap.h
+++ b/runtime/gc/accounting/space_bitmap.h
@@ -174,6 +174,7 @@ class SpaceBitmap {
     const size_t index = OffsetToIndex(offset);
     return &bitmap_begin_[index];
   }
+
  private:
   // TODO: heap_end_ is initialized so that the heap bitmap is empty, this doesn't require the -1,
   // however, we document that this is expected on heap_end_
diff --git a/runtime/gc/collector/garbage_collector.h b/runtime/gc/collector/garbage_collector.h
index a22faac43b..1684664eff 100644
--- a/runtime/gc/collector/garbage_collector.h
+++ b/runtime/gc/collector/garbage_collector.h
@@ -79,7 +79,6 @@ class GarbageCollector {
   void SwapBitmaps() EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
 
  protected:
-
   // The initial phase. Done without mutators paused.
   virtual void InitializePhase() = 0;
 
diff --git a/runtime/gc/space/image_space.h b/runtime/gc/space/image_space.h
index fde2b419ac..bdda9fa4b1 100644
--- a/runtime/gc/space/image_space.h
+++ b/runtime/gc/space/image_space.h
@@ -78,7 +78,6 @@ class ImageSpace : public MemMapSpace {
   void Dump(std::ostream& os) const;
 
  private:
-
   // Tries to initialize an ImageSpace from the given image path,
   // returning NULL on error.
   //
diff --git a/runtime/gc/space/large_object_space.cc b/runtime/gc/space/large_object_space.cc
index f7d776fbfb..6aedd9cf2b 100644
--- a/runtime/gc/space/large_object_space.cc
+++ b/runtime/gc/space/large_object_space.cc
@@ -49,9 +49,7 @@ void LargeObjectSpace::CopyLiveToMarked() {
 
 LargeObjectMapSpace::LargeObjectMapSpace(const std::string& name)
     : LargeObjectSpace(name),
-      lock_("large object map space lock", kAllocSpaceLock) {
-
-}
+      lock_("large object map space lock", kAllocSpaceLock) {}
 
 LargeObjectMapSpace* LargeObjectMapSpace::Create(const std::string& name) {
   return new LargeObjectMapSpace(name);
@@ -147,9 +145,7 @@ FreeListSpace::FreeListSpace(const std::string& name, MemMap* mem_map, byte* beg
   AddFreeChunk(begin_, end_ - begin_, NULL);
 }
 
-FreeListSpace::~FreeListSpace() {
-
-}
+FreeListSpace::~FreeListSpace() {}
 
 void FreeListSpace::AddFreeChunk(void* address, size_t size, Chunk* previous) {
   Chunk* chunk = ChunkFromAddr(address);
diff --git a/runtime/gc/space/large_object_space.h b/runtime/gc/space/large_object_space.h
index db845db4e6..20a48673b6 100644
--- a/runtime/gc/space/large_object_space.h
+++ b/runtime/gc/space/large_object_space.h
@@ -60,7 +60,6 @@ class LargeObjectSpace : public DiscontinuousSpace, public AllocSpace {
   size_t FreeList(Thread* self, size_t num_ptrs, mirror::Object** ptrs);
 
  protected:
-
   explicit LargeObjectSpace(const std::string& name);
 
   // Approximate number of bytes which have been allocated into the space.
@@ -165,6 +164,7 @@ class FreeListSpace : public LargeObjectSpace {
       DCHECK(m_previous == NULL ||
             (m_previous != NULL && m_previous + m_previous->GetSize() / kAlignment == this));
     }
+
    private:
     size_t m_size;
     Chunk* m_previous;
diff --git a/runtime/image_test.cc b/runtime/image_test.cc
index 9ab1d7475b..ee50118b06 100644
--- a/runtime/image_test.cc
+++ b/runtime/image_test.cc
@@ -31,7 +31,6 @@
 namespace art {
 
 class ImageTest : public CommonTest {
-
  protected:
   virtual void SetUp() {
     ReserveImageSpace();
diff --git a/runtime/interpreter/interpreter.cc b/runtime/interpreter/interpreter.cc
index 2fb272cef4..45314c231b 100644
--- a/runtime/interpreter/interpreter.cc
+++ b/runtime/interpreter/interpreter.cc
@@ -366,7 +366,6 @@ static void InterpreterJni(Thread* self, AbstractMethod* method, StringPiece sho
       {
         ScopedThreadStateChange tsc(self, kNative);
         jresult = fn(soa.Env(), rcvr.get(), arg0.get());
-
       }
       result->SetL(soa.Decode<Object*>(jresult));
       ScopedThreadStateChange tsc(self, kNative);
diff --git a/runtime/jdwp/jdwp_handler.cc b/runtime/jdwp/jdwp_handler.cc
index 8ef146c096..e141496c3b 100644
--- a/runtime/jdwp/jdwp_handler.cc
+++ b/runtime/jdwp/jdwp_handler.cc
@@ -361,7 +361,6 @@ static JdwpError VM_Capabilities(JdwpState*, Request&, ExpandBuf* reply)
 
 static JdwpError VM_CapabilitiesNew(JdwpState*, Request& request, ExpandBuf* reply)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-
   // The first few capabilities are the same as those reported by the older call.
   VM_Capabilities(NULL, request, reply);
 
diff --git a/runtime/mirror/abstract_method.h b/runtime/mirror/abstract_method.h
index d909058e0d..bbebecebb4 100644
--- a/runtime/mirror/abstract_method.h
+++ b/runtime/mirror/abstract_method.h
@@ -497,13 +497,9 @@ class MANAGED AbstractMethod : public Object {
   DISALLOW_IMPLICIT_CONSTRUCTORS(AbstractMethod);
 };
 
-class MANAGED Method : public AbstractMethod {
+class MANAGED Method : public AbstractMethod {};
 
-};
-
-class MANAGED Constructor : public AbstractMethod {
-
-};
+class MANAGED Constructor : public AbstractMethod {};
 
 class MANAGED AbstractMethodClass : public Class {
  private:
diff --git a/runtime/mirror/class.cc b/runtime/mirror/class.cc
index 2d2130c39e..e490d97f80 100644
--- a/runtime/mirror/class.cc
+++ b/runtime/mirror/class.cc
@@ -320,13 +320,11 @@ bool Class::IsFieldClass() const {
   Class* java_lang_Class = GetClass();
   Class* java_lang_reflect_Field = java_lang_Class->GetInstanceField(0)->GetClass();
   return this == java_lang_reflect_Field;
-
 }
 
 bool Class::IsMethodClass() const {
   return (this == AbstractMethod::GetMethodClass()) ||
-      (this == AbstractMethod::GetConstructorClass());
-
+          (this == AbstractMethod::GetConstructorClass());
 }
 
 void Class::SetClassLoader(ClassLoader* new_class_loader) {
diff --git a/runtime/oat/runtime/argument_visitor.h b/runtime/oat/runtime/argument_visitor.h
index d92ff19d13..aaf93f7db7 100644
--- a/runtime/oat/runtime/argument_visitor.h
+++ b/runtime/oat/runtime/argument_visitor.h
@@ -199,7 +199,6 @@ class QuickArgumentVisitor {
     uint64_t low_half = *reinterpret_cast<uint32_t*>(GetParamAddress());
     uint64_t high_half = *reinterpret_cast<uint32_t*>(stack_args_);
     return (low_half & 0xffffffffULL) | (high_half << 32);
-
   }
 
   void VisitArguments() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -244,6 +243,6 @@ class QuickArgumentVisitor {
   bool is_split_long_or_double_;
 };
 
-}
+}  // namespace art
 
 #endif  // ART_RUNTIME_OAT_RUNTIME_ARGUMENT_VISITOR_H_
diff --git a/runtime/oat_file.cc b/runtime/oat_file.cc
index bb8341ee9f..6562633bc3 100644
--- a/runtime/oat_file.cc
+++ b/runtime/oat_file.cc
@@ -122,7 +122,6 @@ OatFile::~OatFile() {
 }
 
 bool OatFile::Dlopen(const std::string& elf_filename, byte* requested_base) {
-
   char* absolute_path = realpath(elf_filename.c_str(), NULL);
   if (absolute_path == NULL) {
     return false;
diff --git a/runtime/runtime_support_llvm.cc b/runtime/runtime_support_llvm.cc
index cbdefe8a03..d703db29d5 100644
--- a/runtime/runtime_support_llvm.cc
+++ b/runtime/runtime_support_llvm.cc
@@ -50,7 +50,6 @@
 using namespace art;
 
 extern "C" {
-
 class ShadowFrameCopyVisitor : public StackVisitor {
  public:
   explicit ShadowFrameCopyVisitor(Thread* self) : StackVisitor(self, NULL), prev_frame_(NULL),
@@ -844,5 +843,4 @@ void art_portable_proxy_invoke_handler_from_code(mirror::AbstractMethod* proxy_m
 void art_portable_constructor_barrier() {
   LOG(FATAL) << "Implemented by IRBuilder.";
 }
-
 }  // extern "C"
diff --git a/runtime/runtime_support_llvm.h b/runtime/runtime_support_llvm.h
index 566f7bcb16..43ea953a96 100644
--- a/runtime/runtime_support_llvm.h
+++ b/runtime/runtime_support_llvm.h
@@ -18,13 +18,10 @@
 #define ART_RUNTIME_RUNTIME_SUPPORT_LLVM_H_
 
 extern "C" {
-
 //----------------------------------------------------------------------------
 // Runtime Support Function Lookup Callback
 //----------------------------------------------------------------------------
-
 void* art_portable_find_runtime_support_func(void* context, const char* name);
-
 }  // extern "C"
 
 #endif  // ART_RUNTIME_RUNTIME_SUPPORT_LLVM_H_
diff --git a/runtime/stack.h b/runtime/stack.h
index 0e2c4c5b86..99ba898362 100644
--- a/runtime/stack.h
+++ b/runtime/stack.h
@@ -554,7 +554,6 @@ class StackVisitor {
   static void DescribeStack(Thread* thread) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
  private:
-
   instrumentation::InstrumentationStackFrame GetInstrumentationStackFrame(uint32_t depth) const;
 
   void SanityCheckFrame() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -567,6 +566,7 @@ class StackVisitor {
   size_t num_frames_;
   // Depth of the frame we're currently at.
   size_t cur_depth_;
+
  protected:
   Context* const context_;
 };
@@ -638,6 +638,7 @@ class VmapTable {
     spill_shifts--;  // wind back one as we want the last match
     return spill_shifts;
   }
+
  private:
   const uint16_t* table_;
 };
diff --git a/runtime/thread.cc b/runtime/thread.cc
index dd55195c15..a1fb862a17 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -2104,9 +2104,7 @@ class ReferenceMapVisitor : public StackVisitor {
 
 class RootCallbackVisitor {
  public:
-  RootCallbackVisitor(RootVisitor* visitor, void* arg) : visitor_(visitor), arg_(arg) {
-
-  }
+  RootCallbackVisitor(RootVisitor* visitor, void* arg) : visitor_(visitor), arg_(arg) {}
 
   void operator()(const mirror::Object* obj, size_t, const StackVisitor*) const {
     visitor_(obj, arg_);
diff --git a/runtime/thread_pool.cc b/runtime/thread_pool.cc
index 784a7caadf..067ef2d5d8 100644
--- a/runtime/thread_pool.cc
+++ b/runtime/thread_pool.cc
@@ -180,10 +180,7 @@ size_t ThreadPool::GetTaskCount(Thread* self) {
 
 WorkStealingWorker::WorkStealingWorker(ThreadPool* thread_pool, const std::string& name,
                                        size_t stack_size)
-    : ThreadPoolWorker(thread_pool, name, stack_size),
-      task_(NULL) {
-
-}
+    : ThreadPoolWorker(thread_pool, name, stack_size), task_(NULL) {}
 
 void WorkStealingWorker::Run() {
   Thread* self = Thread::Current();
@@ -254,9 +251,7 @@ void WorkStealingWorker::Run() {
   }
 }
 
-WorkStealingWorker::~WorkStealingWorker() {
-
-}
+WorkStealingWorker::~WorkStealingWorker() {}
 
 WorkStealingThreadPool::WorkStealingThreadPool(size_t num_threads)
     : ThreadPool(0),
@@ -288,8 +283,6 @@ WorkStealingTask* WorkStealingThreadPool::FindTaskToStealFrom(Thread* self) {
   return NULL;
 }
 
-WorkStealingThreadPool::~WorkStealingThreadPool() {
-
-}
+WorkStealingThreadPool::~WorkStealingThreadPool() {}
 
 }  // namespace art
diff --git a/runtime/thread_pool.h b/runtime/thread_pool.h
index b9f185d5f9..7b626fbbe1 100644
--- a/runtime/thread_pool.h
+++ b/runtime/thread_pool.h
@@ -124,9 +124,7 @@ class ThreadPool {
 
 class WorkStealingTask : public Task {
  public:
-  WorkStealingTask() : ref_count_(0) {
-
-  }
+  WorkStealingTask() : ref_count_(0) {}
 
   size_t GetRefCount() const {
     return ref_count_;
diff --git a/runtime/thread_pool_test.cc b/runtime/thread_pool_test.cc
index 9b66318d8d..98178bc40c 100644
--- a/runtime/thread_pool_test.cc
+++ b/runtime/thread_pool_test.cc
@@ -105,9 +105,7 @@ class TreeTask : public Task {
   TreeTask(ThreadPool* const thread_pool, AtomicInteger* count, int depth)
       : thread_pool_(thread_pool),
         count_(count),
-        depth_(depth) {
-
-  }
+        depth_(depth) {}
 
   void Run(Thread* self) {
     if (depth_ > 1) {
diff --git a/runtime/trace.h b/runtime/trace.h
index 5bd6a8d5ca..bd9c140d26 100644
--- a/runtime/trace.h
+++ b/runtime/trace.h
@@ -78,6 +78,7 @@ class Trace : public instrumentation::InstrumentationListener {
                                mirror::AbstractMethod* catch_method, uint32_t catch_dex_pc,
                                mirror::Throwable* exception_object)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
  private:
   explicit Trace(File* trace_file, int buffer_size, int flags);
 
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index 5a70f2a696..ff7f594501 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -3749,7 +3749,6 @@ MethodVerifier::MethodSafeCastSet* MethodVerifier::GenerateSafeCastSet() {
 }
 
 MethodVerifier::PcToConcreteMethodMap* MethodVerifier::GenerateDevirtMap() {
-
   // It is risky to rely on reg_types for sharpening in cases of soft
   // verification, we might end up sharpening to a wrong implementation. Just abort.
   if (!failure_messages_.empty()) {
diff --git a/runtime/verifier/reg_type.h b/runtime/verifier/reg_type.h
index c66e7cb514..5b806c47e5 100644
--- a/runtime/verifier/reg_type.h
+++ b/runtime/verifier/reg_type.h
@@ -309,6 +309,7 @@ class ConflictType : public RegType {
 
   // Destroy the singleton instance.
   static void Destroy();
+
  private:
   ConflictType(mirror::Class* klass, const std::string& descriptor, uint16_t cache_id)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
@@ -338,6 +339,7 @@ class UndefinedType : public RegType {
 
   // Destroy the singleton instance.
   static void Destroy();
+
  private:
   UndefinedType(mirror::Class* klass, const std::string& descriptor, uint16_t cache_id)
      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
@@ -875,6 +877,7 @@ class UnresolvedSuperClass : public UnresolvedType {
   }
 
   std::string Dump() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
  private:
   void CheckInvariants() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -909,6 +912,7 @@ class UnresolvedMergedType : public UnresolvedType {
   }
 
   std::string Dump() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
  private:
   void CheckInvariants() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
diff --git a/runtime/verifier/reg_type_test.cc b/runtime/verifier/reg_type_test.cc
index f37edff6ac..d2c9dd6ba7 100644
--- a/runtime/verifier/reg_type_test.cc
+++ b/runtime/verifier/reg_type_test.cc
@@ -414,7 +414,6 @@ TEST_F(RegTypeReferenceTest, Dump) {
   EXPECT_EQ(expected, unresolved_merged.Dump());
 }
 
-
 TEST_F(RegTypeReferenceTest, JavalangString) {
   // Add a class to the cache then look for the same class and make sure it is  a
   // Hit the second time. Then check for the same effect when using
@@ -433,8 +432,8 @@ TEST_F(RegTypeReferenceTest, JavalangString) {
   const RegType& ref_type_unintialized = cache.Uninitialized(ref_type, 0110ull);
   EXPECT_TRUE(ref_type_unintialized.IsUninitializedReference());
   EXPECT_FALSE(ref_type_unintialized.IsUnresolvedAndUninitializedReference());
-
 }
+
 TEST_F(RegTypeReferenceTest, JavalangObject) {
   // Add a class to the cache then look for the same class and make sure it is  a
   // Hit the second time. Then I am checking for the same effect when using
@@ -474,7 +473,6 @@ TEST_F(RegTypeReferenceTest, Merging) {
 
 
 TEST_F(RegTypeTest, ConstPrecision) {
-
   // Tests creating primitive types types.
   ScopedObjectAccess soa(Thread::Current());
   RegTypeCache cache_new(true);
diff --git a/runtime/verifier/register_line.cc b/runtime/verifier/register_line.cc
index 3a2145b9bb..d2abaac6f7 100644
--- a/runtime/verifier/register_line.cc
+++ b/runtime/verifier/register_line.cc
@@ -254,7 +254,6 @@ void RegisterLine::CopyResultRegister2(uint32_t vdst) {
     SetRegisterTypeWide(vdst, type_l, type_h);  // also sets the high
     result_[0] = verifier_->GetRegTypeCache()->Undefined().GetId();
     result_[1] = verifier_->GetRegTypeCache()->Undefined().GetId();
-
   }
 }
 
diff --git a/test/ReferenceMap/stack_walk_refmap_jni.cc b/test/ReferenceMap/stack_walk_refmap_jni.cc
index 9ef4a59dc1..492916ed90 100644
--- a/test/ReferenceMap/stack_walk_refmap_jni.cc
+++ b/test/ReferenceMap/stack_walk_refmap_jni.cc
@@ -280,4 +280,4 @@ extern "C" JNIEXPORT jint JNICALL Java_ReferenceMap_refmap(JNIEnv*, jobject, jin
   return count + 1;
 }
 
-}
+}  // namespace art
diff --git a/test/StackWalk/stack_walk_jni.cc b/test/StackWalk/stack_walk_jni.cc
index 4b472daa5e..fc156b15d1 100644
--- a/test/StackWalk/stack_walk_jni.cc
+++ b/test/StackWalk/stack_walk_jni.cc
@@ -127,4 +127,4 @@ extern "C" JNIEXPORT jint JNICALL Java_StackWalk2_refmap2(JNIEnv*, jobject, jint
   return count + 1;
 }
 
-}
+} // namespace art
-- 
cgit v1.2.3-59-g8ed1b


From 0177fe200efc1bf4d433955ee7920c683fdf5901 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Sun, 21 Jul 2013 12:21:36 -0700
Subject: Remove CompilerDriver::IsDebuggingSupported

Change-Id: Ib67e3ef67462fe5dae81148f7fe8cc76b3887f11
---
 compiler/driver/compiler_driver.cc |  4 +---
 compiler/driver/compiler_driver.h  |  8 +-------
 dex2oat/dex2oat.cc                 | 16 ++++------------
 runtime/common_test.h              |  2 +-
 runtime/oat_test.cc                |  3 +--
 5 files changed, 8 insertions(+), 25 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index f1082db9bc..6558f8acfe 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -335,8 +335,7 @@ extern "C" void compilerLLVMSetBitcodeFileName(art::CompilerDriver& driver,
 
 CompilerDriver::CompilerDriver(CompilerBackend compiler_backend, InstructionSet instruction_set,
                                bool image, DescriptorSet* image_classes,
-                               size_t thread_count, bool support_debugging,
-                               bool dump_stats, bool dump_timings)
+                               size_t thread_count, bool dump_stats, bool dump_timings)
     : compiler_backend_(compiler_backend),
       instruction_set_(instruction_set),
       freezing_constructor_lock_("freezing constructor lock"),
@@ -345,7 +344,6 @@ CompilerDriver::CompilerDriver(CompilerBackend compiler_backend, InstructionSet
       image_(image),
       image_classes_(image_classes),
       thread_count_(thread_count),
-      support_debugging_(support_debugging),
       start_ns_(0),
       stats_(new AOTCompilationStats),
       dump_stats_(dump_stats),
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index 80cc89b95f..902fda7f0c 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -72,8 +72,7 @@ class CompilerDriver {
   // classes.
   explicit CompilerDriver(CompilerBackend compiler_backend, InstructionSet instruction_set,
                           bool image, DescriptorSet* image_classes,
-                          size_t thread_count, bool support_debugging,
-                          bool dump_stats, bool dump_timings);
+                          size_t thread_count, bool dump_stats, bool dump_timings);
 
   ~CompilerDriver();
 
@@ -84,10 +83,6 @@ class CompilerDriver {
   void CompileOne(const mirror::AbstractMethod* method)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  bool IsDebuggingSupported() {
-    return support_debugging_;
-  }
-
   InstructionSet GetInstructionSet() const {
     return instruction_set_;
   }
@@ -362,7 +357,6 @@ class CompilerDriver {
   UniquePtr<DescriptorSet> image_classes_;
 
   size_t thread_count_;
-  bool support_debugging_;
   uint64_t start_ns_;
 
   UniquePtr<AOTCompilationStats> stats_;
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index 9e23d3e7d3..75e1afe09a 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -149,14 +149,13 @@ static void Usage(const char* fmt, ...) {
 class Dex2Oat {
  public:
   static bool Create(Dex2Oat** p_dex2oat, Runtime::Options& options, CompilerBackend compiler_backend,
-                     InstructionSet instruction_set, size_t thread_count, bool support_debugging)
+                     InstructionSet instruction_set, size_t thread_count)
       SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_) {
     if (!CreateRuntime(options, instruction_set)) {
       *p_dex2oat = NULL;
       return false;
     }
-    *p_dex2oat = new Dex2Oat(Runtime::Current(), compiler_backend, instruction_set, thread_count,
-                             support_debugging);
+    *p_dex2oat = new Dex2Oat(Runtime::Current(), compiler_backend, instruction_set, thread_count);
     return true;
   }
 
@@ -249,7 +248,6 @@ class Dex2Oat {
                                                         image,
                                                         image_classes.release(),
                                                         thread_count_,
-                                                        support_debugging_,
                                                         dump_stats,
                                                         dump_timings));
 
@@ -336,12 +334,11 @@ class Dex2Oat {
 
  private:
   explicit Dex2Oat(Runtime* runtime, CompilerBackend compiler_backend, InstructionSet instruction_set,
-                   size_t thread_count, bool support_debugging)
+                   size_t thread_count)
       : compiler_backend_(compiler_backend),
         instruction_set_(instruction_set),
         runtime_(runtime),
         thread_count_(thread_count),
-        support_debugging_(support_debugging),
         start_ns_(NanoTime()) {
   }
 
@@ -402,7 +399,6 @@ class Dex2Oat {
 
   Runtime* runtime_;
   size_t thread_count_;
-  bool support_debugging_;
   uint64_t start_ns_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Dex2Oat);
@@ -596,7 +592,6 @@ static int dex2oat(int argc, char** argv) {
   std::string android_root;
   std::vector<const char*> runtime_args;
   int thread_count = sysconf(_SC_NPROCESSORS_CONF);
-  bool support_debugging = false;
 #if defined(ART_USE_PORTABLE_COMPILER)
   CompilerBackend compiler_backend = kPortable;
 #else
@@ -643,8 +638,6 @@ static int dex2oat(int argc, char** argv) {
       if (!ParseInt(oat_fd_str, &oat_fd)) {
         Usage("could not parse --oat-fd argument '%s' as an integer", oat_fd_str);
       }
-    } else if (option == "-g") {
-      support_debugging = true;
     } else if (option == "--watch-dog") {
       watch_dog_enabled = true;
     } else if (option == "--no-watch-dog") {
@@ -866,8 +859,7 @@ static int dex2oat(int argc, char** argv) {
 
 
   Dex2Oat* p_dex2oat;
-  if (!Dex2Oat::Create(&p_dex2oat, options, compiler_backend, instruction_set, thread_count,
-                       support_debugging)) {
+  if (!Dex2Oat::Create(&p_dex2oat, options, compiler_backend, instruction_set, thread_count)) {
     LOG(ERROR) << "Failed to create dex2oat";
     return EXIT_FAILURE;
   }
diff --git a/runtime/common_test.h b/runtime/common_test.h
index 03a45aa20b..13626a5eac 100644
--- a/runtime/common_test.h
+++ b/runtime/common_test.h
@@ -349,7 +349,7 @@ class CommonTest : public testing::Test {
       class_linker_->FixupDexCaches(runtime_->GetResolutionMethod());
       compiler_driver_.reset(new CompilerDriver(compiler_backend, instruction_set,
                                                 true, new CompilerDriver::DescriptorSet,
-                                                2, false, true, true));
+                                                2, true, true));
     }
     // We typically don't generate an image in unit tests, disable this optimization by default.
     compiler_driver_->SetSupportBootImageFixup(false);
diff --git a/runtime/oat_test.cc b/runtime/oat_test.cc
index 70c2e9e88e..7f24564eb2 100644
--- a/runtime/oat_test.cc
+++ b/runtime/oat_test.cc
@@ -74,8 +74,7 @@ TEST_F(OatTest, WriteRead) {
 #else
   CompilerBackend compiler_backend = kQuick;
 #endif
-  compiler_driver_.reset(new CompilerDriver(compiler_backend, kThumb2, false, NULL, 2, false,
-                                            true, true));
+  compiler_driver_.reset(new CompilerDriver(compiler_backend, kThumb2, false, NULL, 2, true, true));
   jobject class_loader = NULL;
   if (compile) {
     compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath());
-- 
cgit v1.2.3-59-g8ed1b


From 4560248d4c85cade7f4fc7b30c3fb41b95a04a7f Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Sun, 21 Jul 2013 22:07:55 -0700
Subject: Move TimingLogger creation to dex2oat

Change-Id: I4fdb6afd4ce2ac0d91c6c968893606d593b6ea18
---
 compiler/driver/compiler_driver.cc      | 18 ++-------
 compiler/driver/compiler_driver.h       |  8 ++--
 compiler/driver/compiler_driver_test.cc |  5 ++-
 dex2oat/dex2oat.cc                      | 65 +++++++++++++++++++++++----------
 runtime/common_test.h                   |  5 ++-
 runtime/image_test.cc                   |  3 +-
 runtime/oat_test.cc                     |  8 ++--
 7 files changed, 68 insertions(+), 44 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 6558f8acfe..b1b205e067 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -335,7 +335,7 @@ extern "C" void compilerLLVMSetBitcodeFileName(art::CompilerDriver& driver,
 
 CompilerDriver::CompilerDriver(CompilerBackend compiler_backend, InstructionSet instruction_set,
                                bool image, DescriptorSet* image_classes,
-                               size_t thread_count, bool dump_stats, bool dump_timings)
+                               size_t thread_count, bool dump_stats)
     : compiler_backend_(compiler_backend),
       instruction_set_(instruction_set),
       freezing_constructor_lock_("freezing constructor lock"),
@@ -347,7 +347,6 @@ CompilerDriver::CompilerDriver(CompilerBackend compiler_backend, InstructionSet
       start_ns_(0),
       stats_(new AOTCompilationStats),
       dump_stats_(dump_stats),
-      dump_timings_(dump_timings),
       compiler_library_(NULL),
       compiler_(NULL),
       compiler_context_(NULL),
@@ -495,20 +494,12 @@ const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToQuickEntry() cons
 }
 
 void CompilerDriver::CompileAll(jobject class_loader,
-                                const std::vector<const DexFile*>& dex_files) {
+                                const std::vector<const DexFile*>& dex_files,
+                                TimingLogger& timings) {
   DCHECK(!Runtime::Current()->IsStarted());
-
   UniquePtr<ThreadPool> thread_pool(new ThreadPool(thread_count_));
-  TimingLogger timings("compiler", false);
-
   PreCompile(class_loader, dex_files, *thread_pool.get(), timings);
-
   Compile(class_loader, dex_files, *thread_pool.get(), timings);
-
-  if (dump_timings_ && timings.GetTotalNs() > MsToNs(1000)) {
-    LOG(INFO) << Dumpable<TimingLogger>(timings);
-  }
-
   if (dump_stats_) {
     stats_->Dump();
   }
@@ -537,7 +528,7 @@ static bool IsDexToDexCompilationAllowed(mirror::ClassLoader* class_loader,
   return klass->IsVerified();
 }
 
-void CompilerDriver::CompileOne(const mirror::AbstractMethod* method) {
+void CompilerDriver::CompileOne(const mirror::AbstractMethod* method, TimingLogger& timings) {
   DCHECK(!Runtime::Current()->IsStarted());
   Thread* self = Thread::Current();
   jobject jclass_loader;
@@ -560,7 +551,6 @@ void CompilerDriver::CompileOne(const mirror::AbstractMethod* method) {
   dex_files.push_back(dex_file);
 
   UniquePtr<ThreadPool> thread_pool(new ThreadPool(1U));
-  TimingLogger timings("CompileOne", false);
   PreCompile(jclass_loader, dex_files, *thread_pool.get(), timings);
 
   uint32_t method_idx = method->GetDexMethodIndex();
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index 902fda7f0c..1799057ea6 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -72,15 +72,16 @@ class CompilerDriver {
   // classes.
   explicit CompilerDriver(CompilerBackend compiler_backend, InstructionSet instruction_set,
                           bool image, DescriptorSet* image_classes,
-                          size_t thread_count, bool dump_stats, bool dump_timings);
+                          size_t thread_count, bool dump_stats);
 
   ~CompilerDriver();
 
-  void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files)
+  void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files,
+                  TimingLogger& timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
 
   // Compile a single Method
-  void CompileOne(const mirror::AbstractMethod* method)
+  void CompileOne(const mirror::AbstractMethod* method, TimingLogger& timings)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   InstructionSet GetInstructionSet() const {
@@ -362,7 +363,6 @@ class CompilerDriver {
   UniquePtr<AOTCompilationStats> stats_;
 
   bool dump_stats_;
-  bool dump_timings_;
 
   typedef void (*CompilerCallbackFn)(CompilerDriver& driver);
   typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver);
diff --git a/compiler/driver/compiler_driver_test.cc b/compiler/driver/compiler_driver_test.cc
index 6a160f75c6..78cacaf08e 100644
--- a/compiler/driver/compiler_driver_test.cc
+++ b/compiler/driver/compiler_driver_test.cc
@@ -36,7 +36,10 @@ namespace art {
 class CompilerDriverTest : public CommonTest {
  protected:
   void CompileAll(jobject class_loader) LOCKS_EXCLUDED(Locks::mutator_lock_) {
-    compiler_driver_->CompileAll(class_loader, Runtime::Current()->GetCompileTimeClassPath(class_loader));
+    TimingLogger timings("CompilerDriverTest::CompileAll", false);
+    compiler_driver_->CompileAll(class_loader,
+                                 Runtime::Current()->GetCompileTimeClassPath(class_loader),
+                                 timings);
     MakeAllExecutable(class_loader);
   }
 
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index 75e1afe09a..995f6d4052 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -83,8 +83,8 @@ static void Usage(const char* fmt, ...) {
   UsageError("      containing a classes.dex file to compile.");
   UsageError("      Example: --zip-fd=5");
   UsageError("");
-  UsageError("  --zip-location=<zip-location>: specifies a symbolic name for the file corresponding");
-  UsageError("      to the file descriptor specified by --zip-fd.");
+  UsageError("  --zip-location=<zip-location>: specifies a symbolic name for the file");
+  UsageError("      corresponding to the file descriptor specified by --zip-fd.");
   UsageError("      Example: --zip-location=/system/app/Calculator.apk");
   UsageError("");
   UsageError("  --oat-file=<file.oat>: specifies the oat output destination via a filename.");
@@ -148,8 +148,11 @@ static void Usage(const char* fmt, ...) {
 
 class Dex2Oat {
  public:
-  static bool Create(Dex2Oat** p_dex2oat, Runtime::Options& options, CompilerBackend compiler_backend,
-                     InstructionSet instruction_set, size_t thread_count)
+  static bool Create(Dex2Oat** p_dex2oat,
+                     Runtime::Options& options,
+                     CompilerBackend compiler_backend,
+                     InstructionSet instruction_set,
+                     size_t thread_count)
       SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_) {
     if (!CreateRuntime(options, instruction_set)) {
       *p_dex2oat = NULL;
@@ -161,13 +164,15 @@ class Dex2Oat {
 
   ~Dex2Oat() {
     delete runtime_;
-    LOG(INFO) << "dex2oat took " << PrettyDuration(NanoTime() - start_ns_) << " (threads: " << thread_count_ << ")";
+    LOG(INFO) << "dex2oat took " << PrettyDuration(NanoTime() - start_ns_)
+              << " (threads: " << thread_count_ << ")";
   }
 
 
-  // Reads the class names (java.lang.Object) and returns as set of class descriptors (Ljava/lang/Object;)
+  // Reads the class names (java.lang.Object) and returns a set of descriptors (Ljava/lang/Object;)
   CompilerDriver::DescriptorSet* ReadImageClassesFromFile(const char* image_classes_filename) {
-    UniquePtr<std::ifstream> image_classes_file(new std::ifstream(image_classes_filename, std::ifstream::in));
+    UniquePtr<std::ifstream> image_classes_file(new std::ifstream(image_classes_filename,
+                                                                  std::ifstream::in));
     if (image_classes_file.get() == NULL) {
       LOG(ERROR) << "Failed to open image classes file " << image_classes_filename;
       return NULL;
@@ -191,8 +196,9 @@ class Dex2Oat {
     return image_classes.release();
   }
 
-  // Reads the class names (java.lang.Object) and returns as set of class descriptors (Ljava/lang/Object;)
-  CompilerDriver::DescriptorSet* ReadImageClassesFromZip(const std::string& zip_filename, const char* image_classes_filename) {
+  // Reads the class names (java.lang.Object) and returns a set of descriptors (Ljava/lang/Object;)
+  CompilerDriver::DescriptorSet* ReadImageClassesFromZip(const std::string& zip_filename,
+                                                         const char* image_classes_filename) {
     UniquePtr<ZipArchive> zip_archive(ZipArchive::Open(zip_filename));
     if (zip_archive.get() == NULL) {
       LOG(ERROR) << "Failed to open zip file " << zip_filename;
@@ -224,7 +230,7 @@ class Dex2Oat {
                                       bool image,
                                       UniquePtr<CompilerDriver::DescriptorSet>& image_classes,
                                       bool dump_stats,
-                                      bool dump_timings)
+                                      TimingLogger& timings)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     // SirtRef and ClassLoader creation needs to come after Runtime::Create
     jobject class_loader = NULL;
@@ -248,8 +254,7 @@ class Dex2Oat {
                                                         image,
                                                         image_classes.release(),
                                                         thread_count_,
-                                                        dump_stats,
-                                                        dump_timings));
+                                                        dump_stats));
 
     if (compiler_backend_ == kPortable) {
       driver->SetBitcodeFileName(bitcode_filename);
@@ -258,7 +263,8 @@ class Dex2Oat {
 
     Thread::Current()->TransitionFromRunnableToSuspended(kNative);
 
-    driver->CompileAll(class_loader, dex_files);
+    timings.AddSplit("dex2oat Setup");
+    driver->CompileAll(class_loader, dex_files, timings);
 
     Thread::Current()->TransitionFromSuspendedToRunnable();
 
@@ -294,11 +300,13 @@ class Dex2Oat {
       LOG(ERROR) << "Failed to create oat file " << oat_file->GetPath();
       return NULL;
     }
+    timings.AddSplit("dex2oat OatWriter");
 
     if (!driver->WriteElf(android_root, is_host, dex_files, oat_contents, oat_file)) {
       LOG(ERROR) << "Failed to write ELF file " << oat_file->GetPath();
       return NULL;
     }
+    timings.AddSplit("dex2oat ElfWriter");
 
     return driver.release();
   }
@@ -333,7 +341,9 @@ class Dex2Oat {
   }
 
  private:
-  explicit Dex2Oat(Runtime* runtime, CompilerBackend compiler_backend, InstructionSet instruction_set,
+  explicit Dex2Oat(Runtime* runtime,
+                   CompilerBackend compiler_backend,
+                   InstructionSet instruction_set,
                    size_t thread_count)
       : compiler_backend_(compiler_backend),
         instruction_set_(instruction_set),
@@ -365,7 +375,8 @@ class Dex2Oat {
 
   // Appends to dex_files any elements of class_path that it doesn't already
   // contain. This will open those dex files as necessary.
-  static void OpenClassPathFiles(const std::string& class_path, std::vector<const DexFile*>& dex_files) {
+  static void OpenClassPathFiles(const std::string& class_path,
+                                 std::vector<const DexFile*>& dex_files) {
     std::vector<std::string> parsed;
     Split(class_path, ':', parsed);
     // Take Locks::mutator_lock_ so that lock ordering on the ClassLinker::dex_lock_ is maintained.
@@ -384,7 +395,8 @@ class Dex2Oat {
   }
 
   // Returns true if dex_files has a dex with the named location.
-  static bool DexFilesContains(const std::vector<const DexFile*>& dex_files, const std::string& location) {
+  static bool DexFilesContains(const std::vector<const DexFile*>& dex_files,
+                               const std::string& location) {
     for (size_t i = 0; i < dex_files.size(); ++i) {
       if (dex_files[i]->GetLocation() == location) {
         return true;
@@ -564,6 +576,8 @@ const unsigned int WatchDog::kWatchDogWarningSeconds;
 const unsigned int WatchDog::kWatchDogTimeoutSeconds;
 
 static int dex2oat(int argc, char** argv) {
+  TimingLogger timings("compiler", false);
+
   InitLogging(argv);
 
   // Skip over argv[0].
@@ -937,7 +951,7 @@ static int dex2oat(int argc, char** argv) {
                                                                   image,
                                                                   image_classes,
                                                                   dump_stats,
-                                                                  dump_timings));
+                                                                  timings));
 
   if (compiler.get() == NULL) {
     LOG(ERROR) << "Failed to create oat file: " << oat_location;
@@ -959,7 +973,7 @@ static int dex2oat(int argc, char** argv) {
   // | alloc spaces |
   // +--------------+
   //
-  // There are several constraints on the loading of the imag and boot.oat.
+  // There are several constraints on the loading of the image and boot.oat.
   //
   // 1. The image is expected to be loaded at an absolute address and
   // contains Objects with absolute pointers within the image.
@@ -977,7 +991,7 @@ static int dex2oat(int argc, char** argv) {
   //
   // 1. We have already created that oat file above with
   // CreateOatFile. Originally this was just our own proprietary file
-  // but now it is contained within an ELF dynamic object (aka .so
+  // but now it is contained within an ELF dynamic object (aka an .so
   // file). The Compiler returned by CreateOatFile provides
   // PatchInformation for references to oat code and Methods that need
   // to be update once we know where the oat file will be located
@@ -1003,6 +1017,7 @@ static int dex2oat(int argc, char** argv) {
                                                            oat_unstripped,
                                                            oat_location,
                                                            *compiler.get());
+    timings.AddSplit("dex2oat ImageWriter");
     Thread::Current()->TransitionFromSuspendedToRunnable();
     LOG(INFO) << "Image written successfully: " << image_filename;
     if (!image_creation_success) {
@@ -1011,9 +1026,13 @@ static int dex2oat(int argc, char** argv) {
   }
 
   if (is_host) {
+    if (dump_timings && timings.GetTotalNs() > MsToNs(1000)) {
+      LOG(INFO) << Dumpable<TimingLogger>(timings);
+    }
     return EXIT_SUCCESS;
   }
 
+#if ART_USE_PORTABLE_COMPILER  // We currently only generate symbols on Portable
   // If we don't want to strip in place, copy from unstripped location to stripped location.
   // We need to strip after image creation because FixupElf needs to use .strtab.
   if (oat_unstripped != oat_stripped) {
@@ -1031,6 +1050,7 @@ static int dex2oat(int argc, char** argv) {
       CHECK(write_ok);
     }
     oat_file.reset(out.release());
+    timings.AddSplit("dex2oat OatFile copy");
     LOG(INFO) << "Oat file copied successfully (stripped): " << oat_stripped;
   }
 
@@ -1038,12 +1058,19 @@ static int dex2oat(int argc, char** argv) {
   off_t seek_actual = lseek(oat_file->Fd(), 0, SEEK_SET);
   CHECK_EQ(0, seek_actual);
   ElfStripper::Strip(oat_file.get());
+  timings.AddSplit("dex2oat ElfStripper");
 
   // We wrote the oat file successfully, and want to keep it.
   LOG(INFO) << "Oat file written successfully (stripped): " << oat_location;
+#endif // ART_USE_PORTABLE_COMPILER
+
+  if (dump_timings && timings.GetTotalNs() > MsToNs(1000)) {
+    LOG(INFO) << Dumpable<TimingLogger>(timings);
+  }
   return EXIT_SUCCESS;
 }
 
+
 } // namespace art
 
 int main(int argc, char** argv) {
diff --git a/runtime/common_test.h b/runtime/common_test.h
index 13626a5eac..09ad7fd7b7 100644
--- a/runtime/common_test.h
+++ b/runtime/common_test.h
@@ -349,7 +349,7 @@ class CommonTest : public testing::Test {
       class_linker_->FixupDexCaches(runtime_->GetResolutionMethod());
       compiler_driver_.reset(new CompilerDriver(compiler_backend, instruction_set,
                                                 true, new CompilerDriver::DescriptorSet,
-                                                2, true, true));
+                                                2, true));
     }
     // We typically don't generate an image in unit tests, disable this optimization by default.
     compiler_driver_->SetSupportBootImageFixup(false);
@@ -473,7 +473,8 @@ class CommonTest : public testing::Test {
 
   void CompileMethod(mirror::AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     CHECK(method != NULL);
-    compiler_driver_->CompileOne(method);
+    TimingLogger timings("CommonTest::CompileMethod", false);
+    compiler_driver_->CompileOne(method, timings);
     MakeExecutable(method);
   }
 
diff --git a/runtime/image_test.cc b/runtime/image_test.cc
index ee50118b06..11218ad513 100644
--- a/runtime/image_test.cc
+++ b/runtime/image_test.cc
@@ -45,7 +45,8 @@ TEST_F(ImageTest, WriteRead) {
     {
       jobject class_loader = NULL;
       ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-      compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath());
+      TimingLogger timings("ImageTest::WriteRead", false);
+      compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), timings);
 
       ScopedObjectAccess soa(Thread::Current());
       VectorOutputStream output_stream(tmp_elf.GetFilename(), oat_contents);
diff --git a/runtime/oat_test.cc b/runtime/oat_test.cc
index 7f24564eb2..9a6bc19b13 100644
--- a/runtime/oat_test.cc
+++ b/runtime/oat_test.cc
@@ -74,10 +74,11 @@ TEST_F(OatTest, WriteRead) {
 #else
   CompilerBackend compiler_backend = kQuick;
 #endif
-  compiler_driver_.reset(new CompilerDriver(compiler_backend, kThumb2, false, NULL, 2, true, true));
+  compiler_driver_.reset(new CompilerDriver(compiler_backend, kThumb2, false, NULL, 2, true));
   jobject class_loader = NULL;
   if (compile) {
-    compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath());
+    TimingLogger timings("OatTest::WriteRead", false);
+    compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), timings);
   }
 
   ScopedObjectAccess soa(Thread::Current());
@@ -99,7 +100,8 @@ TEST_F(OatTest, WriteRead) {
   ASSERT_TRUE(success_elf);
 
   if (compile) {  // OatWriter strips the code, regenerate to compare
-    compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath());
+    TimingLogger timings("CommonTest::WriteRead", false);
+    compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), timings);
   }
   UniquePtr<OatFile> oat_file(OatFile::Open(tmp.GetFilename(), tmp.GetFilename(), NULL, false));
   ASSERT_TRUE(oat_file.get() != NULL);
-- 
cgit v1.2.3-59-g8ed1b


From c50d8e11a098cc5c6239aa86b47d4fcf8cbb4899 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Tue, 23 Jul 2013 22:35:16 -0700
Subject: Remove OatWriter buffering to memory for ElfWriterQuick

This allows the oat contents to be directly written to the file.

Change-Id: Ibc7ddf57477b152f07784b52f7334be73fd22833
---
 compiler/driver/compiler_driver.cc |   6 +-
 compiler/driver/compiler_driver.h  |   3 +-
 compiler/elf_writer.h              |   3 +-
 compiler/elf_writer_mclinker.cc    |  15 ++-
 compiler/elf_writer_mclinker.h     |   4 +-
 compiler/elf_writer_quick.cc       |  23 ++--
 compiler/elf_writer_quick.h        |   4 +-
 compiler/image_writer.cc           |   4 +
 compiler/oat_writer.cc             | 215 ++++++++++++++++++++-----------------
 compiler/oat_writer.h              |  51 +++++----
 dex2oat/dex2oat.cc                 |  27 ++---
 runtime/image_test.cc              |  20 ++--
 runtime/oat_test.cc                |  26 ++---
 13 files changed, 211 insertions(+), 190 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 1f667308bd..ea2291cb44 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -2343,13 +2343,13 @@ bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex
 bool CompilerDriver::WriteElf(const std::string& android_root,
                               bool is_host,
                               const std::vector<const art::DexFile*>& dex_files,
-                              std::vector<uint8_t>& oat_contents,
+                              OatWriter& oat_writer,
                               art::File* file)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
 #if defined(ART_USE_PORTABLE_COMPILER)
-  return art::ElfWriterMclinker::Create(file, oat_contents, dex_files, android_root, is_host, *this);
+  return art::ElfWriterMclinker::Create(file, oat_writer, dex_files, android_root, is_host, *this);
 #else
-  return art::ElfWriterQuick::Create(file, oat_contents, dex_files, android_root, is_host, *this);
+  return art::ElfWriterQuick::Create(file, oat_writer, dex_files, android_root, is_host, *this);
 #endif
 }
 void CompilerDriver::InstructionSetToLLVMTarget(InstructionSet instruction_set,
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index 1799057ea6..f3f72dd3c7 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -39,6 +39,7 @@ namespace art {
 class AOTCompilationStats;
 class ParallelCompilationManager;
 class DexCompilationUnit;
+class OatWriter;
 class TimingLogger;
 
 enum CompilerBackend {
@@ -192,7 +193,7 @@ class CompilerDriver {
   bool WriteElf(const std::string& android_root,
                 bool is_host,
                 const std::vector<const DexFile*>& dex_files,
-                std::vector<uint8_t>& oat_contents,
+                OatWriter& oat_writer,
                 File* file);
 
   // TODO: move to a common home for llvm helpers once quick/portable are merged
diff --git a/compiler/elf_writer.h b/compiler/elf_writer.h
index 0dfce6e40f..0ef4185431 100644
--- a/compiler/elf_writer.h
+++ b/compiler/elf_writer.h
@@ -33,6 +33,7 @@ namespace art {
 class CompilerDriver;
 class DexFile;
 class ElfFile;
+class OatWriter;
 
 class ElfWriter {
  public:
@@ -49,7 +50,7 @@ class ElfWriter {
   ElfWriter(const CompilerDriver& driver, File* elf_file);
   virtual ~ElfWriter();
 
-  virtual bool Write(std::vector<uint8_t>& oat_contents,
+  virtual bool Write(OatWriter& oat_writer,
                      const std::vector<const DexFile*>& dex_files,
                      const std::string& android_root,
                      bool is_host)
diff --git a/compiler/elf_writer_mclinker.cc b/compiler/elf_writer_mclinker.cc
index 05f3b025e7..2a9bc35559 100644
--- a/compiler/elf_writer_mclinker.cc
+++ b/compiler/elf_writer_mclinker.cc
@@ -36,7 +36,9 @@
 #include "mirror/abstract_method.h"
 #include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
+#include "oat_writer.h"
 #include "scoped_thread_state_change.h"
+#include "vector_output_stream.h"
 
 namespace art {
 
@@ -46,19 +48,25 @@ ElfWriterMclinker::ElfWriterMclinker(const CompilerDriver& driver, File* elf_fil
 ElfWriterMclinker::~ElfWriterMclinker() {}
 
 bool ElfWriterMclinker::Create(File* elf_file,
-                               std::vector<uint8_t>& oat_contents,
+                               OatWriter& oat_writer,
                                const std::vector<const DexFile*>& dex_files,
                                const std::string& android_root,
                                bool is_host,
                                const CompilerDriver& driver) {
   ElfWriterMclinker elf_writer(driver, elf_file);
-  return elf_writer.Write(oat_contents, dex_files, android_root, is_host);
+  return elf_writer.Write(oat_writer, dex_files, android_root, is_host);
 }
 
-bool ElfWriterMclinker::Write(std::vector<uint8_t>& oat_contents,
+bool ElfWriterMclinker::Write(OatWriter& oat_writer,
                               const std::vector<const DexFile*>& dex_files,
                               const std::string& android_root,
                               bool is_host) {
+  std::vector<uint8_t> oat_contents;
+  oat_contents.reserve(oat_writer.GetSize());
+  VectorOutputStream output_stream("oat contents", oat_contents);
+  CHECK(oat_writer.Write(output_stream));
+  CHECK_EQ(oat_writer.GetSize(), oat_contents.size());
+
   Init();
   AddOatInput(oat_contents);
 #if defined(ART_USE_PORTABLE_COMPILER)
@@ -68,6 +76,7 @@ bool ElfWriterMclinker::Write(std::vector<uint8_t>& oat_contents,
   if (!Link()) {
     return false;
   }
+  oat_contents.clear();
 #if defined(ART_USE_PORTABLE_COMPILER)
   FixupOatMethodOffsets(dex_files);
 #endif
diff --git a/compiler/elf_writer_mclinker.h b/compiler/elf_writer_mclinker.h
index 3b33bc4986..bdadf8f206 100644
--- a/compiler/elf_writer_mclinker.h
+++ b/compiler/elf_writer_mclinker.h
@@ -40,7 +40,7 @@ class ElfWriterMclinker : public ElfWriter {
  public:
   // Write an ELF file. Returns true on success, false on failure.
   static bool Create(File* file,
-                     std::vector<uint8_t>& oat_contents,
+                     OatWriter& oat_writer,
                      const std::vector<const DexFile*>& dex_files,
                      const std::string& android_root,
                      bool is_host,
@@ -48,7 +48,7 @@ class ElfWriterMclinker : public ElfWriter {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
  protected:
-  virtual bool Write(std::vector<uint8_t>& oat_contents,
+  virtual bool Write(OatWriter& oat_writer,
                      const std::vector<const DexFile*>& dex_files,
                      const std::string& android_root,
                      bool is_host)
diff --git a/compiler/elf_writer_quick.cc b/compiler/elf_writer_quick.cc
index 9de96d271e..f2db5d834c 100644
--- a/compiler/elf_writer_quick.cc
+++ b/compiler/elf_writer_quick.cc
@@ -19,8 +19,10 @@
 #include "base/logging.h"
 #include "base/unix_file/fd_file.h"
 #include "driver/compiler_driver.h"
+#include "file_output_stream.h"
 #include "globals.h"
 #include "oat.h"
+#include "oat_writer.h"
 #include "utils.h"
 
 namespace art {
@@ -31,16 +33,16 @@ ElfWriterQuick::ElfWriterQuick(const CompilerDriver& driver, File* elf_file)
 ElfWriterQuick::~ElfWriterQuick() {}
 
 bool ElfWriterQuick::Create(File* elf_file,
-                            std::vector<uint8_t>& oat_contents,
+                            OatWriter& oat_writer,
                             const std::vector<const DexFile*>& dex_files,
                             const std::string& android_root,
                             bool is_host,
                             const CompilerDriver& driver) {
   ElfWriterQuick elf_writer(driver, elf_file);
-  return elf_writer.Write(oat_contents, dex_files, android_root, is_host);
+  return elf_writer.Write(oat_writer, dex_files, android_root, is_host);
 }
 
-bool ElfWriterQuick::Write(std::vector<uint8_t>& oat_contents,
+bool ElfWriterQuick::Write(OatWriter& oat_writer,
                            const std::vector<const DexFile*>& dex_files_unused,
                            const std::string& android_root_unused,
                            bool is_host_unused) {
@@ -193,9 +195,9 @@ bool ElfWriterQuick::Write(std::vector<uint8_t>& oat_contents,
   // .rodata
   uint32_t oat_data_alignment = kPageSize;
   uint32_t oat_data_offset = expected_offset = RoundUp(expected_offset, oat_data_alignment);
-  const OatHeader* oat_header = reinterpret_cast<OatHeader*>(&oat_contents[0]);
-  CHECK(oat_header->IsValid());
-  uint32_t oat_data_size = oat_header->GetExecutableOffset();
+  const OatHeader& oat_header = oat_writer.GetOatHeader();
+  CHECK(oat_header.IsValid());
+  uint32_t oat_data_size = oat_header.GetExecutableOffset();
   expected_offset += oat_data_size;
   if (debug) {
     LOG(INFO) << "oat_data_offset=" << oat_data_offset << std::hex << " " << oat_data_offset;
@@ -206,9 +208,9 @@ bool ElfWriterQuick::Write(std::vector<uint8_t>& oat_contents,
   uint32_t oat_exec_alignment = kPageSize;
   CHECK_ALIGNED(expected_offset, kPageSize);
   uint32_t oat_exec_offset = expected_offset = RoundUp(expected_offset, oat_exec_alignment);
-  uint32_t oat_exec_size = oat_contents.size() - oat_data_size;
+  uint32_t oat_exec_size = oat_writer.GetSize() - oat_data_size;
   expected_offset += oat_exec_size;
-  CHECK_EQ(oat_data_offset + oat_contents.size(), expected_offset);
+  CHECK_EQ(oat_data_offset + oat_writer.GetSize(), expected_offset);
   if (debug) {
     LOG(INFO) << "oat_exec_offset=" << oat_exec_offset << std::hex << " " << oat_exec_offset;
     LOG(INFO) << "oat_exec_size=" << oat_exec_size << std::hex << " " << oat_exec_size;
@@ -617,13 +619,14 @@ bool ElfWriterQuick::Write(std::vector<uint8_t>& oat_contents,
                 << " for " << elf_file_->GetPath();
     return false;
   }
-  if (!elf_file_->WriteFully(&oat_contents[0], oat_contents.size())) {
+  FileOutputStream output_stream(elf_file_);
+  if (!oat_writer.Write(output_stream)) {
     PLOG(ERROR) << "Failed to write .rodata and .text for " << elf_file_->GetPath();
     return false;
   }
 
   // .dynamic
-  DCHECK_LE(oat_data_offset + oat_contents.size(), dynamic_offset);
+  DCHECK_LE(oat_data_offset + oat_writer.GetSize(), dynamic_offset);
   if (static_cast<off_t>(dynamic_offset) != lseek(elf_file_->Fd(), dynamic_offset, SEEK_SET)) {
     PLOG(ERROR) << "Failed to seek to .dynamic offset " << dynamic_offset
                 << " for " << elf_file_->GetPath();
diff --git a/compiler/elf_writer_quick.h b/compiler/elf_writer_quick.h
index a15c239de9..f36d06f79d 100644
--- a/compiler/elf_writer_quick.h
+++ b/compiler/elf_writer_quick.h
@@ -25,7 +25,7 @@ class ElfWriterQuick : public ElfWriter {
  public:
   // Write an ELF file. Returns true on success, false on failure.
   static bool Create(File* file,
-                     std::vector<uint8_t>& oat_contents,
+                     OatWriter& oat_writer,
                      const std::vector<const DexFile*>& dex_files,
                      const std::string& android_root,
                      bool is_host,
@@ -33,7 +33,7 @@ class ElfWriterQuick : public ElfWriter {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
  protected:
-  virtual bool Write(std::vector<uint8_t>& oat_contents,
+  virtual bool Write(OatWriter& oat_writer,
                      const std::vector<const DexFile*>& dex_files,
                      const std::string& android_root,
                      bool is_host)
diff --git a/compiler/image_writer.cc b/compiler/image_writer.cc
index f395428c7d..1612f7eb33 100644
--- a/compiler/image_writer.cc
+++ b/compiler/image_writer.cc
@@ -85,6 +85,10 @@ bool ImageWriter::Write(const std::string& image_filename,
     return false;
   }
   oat_file_ = OatFile::OpenWritable(oat_file.get(), oat_location);
+  if (oat_file_ == NULL) {
+    LOG(ERROR) << "Failed to open writable oat file " << oat_filename << " for " << oat_location;
+    return false;
+  }
   class_linker->RegisterOatFile(*oat_file_);
   interpreter_to_interpreter_entry_offset_ = oat_file_->GetOatHeader().GetInterpreterToInterpreterEntryOffset();
   interpreter_to_quick_entry_offset_ = oat_file_->GetOatHeader().GetInterpreterToQuickEntryOffset();
diff --git a/compiler/oat_writer.cc b/compiler/oat_writer.cc
index da05c49e0e..5eb837b25c 100644
--- a/compiler/oat_writer.cc
+++ b/compiler/oat_writer.cc
@@ -35,20 +35,6 @@
 
 namespace art {
 
-bool OatWriter::Create(OutputStream& output_stream,
-                       const std::vector<const DexFile*>& dex_files,
-                       uint32_t image_file_location_oat_checksum,
-                       uint32_t image_file_location_oat_begin,
-                       const std::string& image_file_location,
-                       const CompilerDriver& driver) {
-  OatWriter oat_writer(dex_files,
-                       image_file_location_oat_checksum,
-                       image_file_location_oat_begin,
-                       image_file_location,
-                       &driver);
-  return oat_writer.Write(output_stream);
-}
-
 OatWriter::OatWriter(const std::vector<const DexFile*>& dex_files,
                      uint32_t image_file_location_oat_checksum,
                      uint32_t image_file_location_oat_begin,
@@ -89,6 +75,7 @@ OatWriter::OatWriter(const std::vector<const DexFile*>& dex_files,
   offset = InitOatClasses(offset);
   offset = InitOatCode(offset);
   offset = InitOatCodeDexFiles(offset);
+  size_ = offset;
 
   CHECK_EQ(dex_files_->size(), oat_dex_files_.size());
   CHECK(image_file_location.empty() == compiler->IsImage());
@@ -190,7 +177,8 @@ size_t OatWriter::InitOatCode(size_t offset) {
   if (compiler_driver_->IsImage()) {
     InstructionSet instruction_set = compiler_driver_->GetInstructionSet();
     oat_header_->SetInterpreterToInterpreterEntryOffset(offset);
-    interpreter_to_interpreter_entry_.reset(compiler_driver_->CreateInterpreterToInterpreterEntry());
+    interpreter_to_interpreter_entry_.reset(
+        compiler_driver_->CreateInterpreterToInterpreterEntry());
     offset += interpreter_to_interpreter_entry_->size();
 
     offset = CompiledCode::AlignCode(offset, instruction_set);
@@ -336,7 +324,8 @@ size_t OatWriter::InitOatCodeMethod(size_t offset, size_t oat_class_index,
     mapping_table_offset = (mapping_table_size == 0) ? 0 : offset;
 
     // Deduplicate mapping tables
-    SafeMap<const std::vector<uint32_t>*, uint32_t>::iterator mapping_iter = mapping_table_offsets_.find(&mapping_table);
+    SafeMap<const std::vector<uint32_t>*, uint32_t>::iterator mapping_iter =
+        mapping_table_offsets_.find(&mapping_table);
     if (mapping_iter != mapping_table_offsets_.end()) {
       mapping_table_offset = mapping_iter->second;
     } else {
@@ -350,7 +339,8 @@ size_t OatWriter::InitOatCodeMethod(size_t offset, size_t oat_class_index,
     vmap_table_offset = (vmap_table_size == 0) ? 0 : offset;
 
     // Deduplicate vmap tables
-    SafeMap<const std::vector<uint16_t>*, uint32_t>::iterator vmap_iter = vmap_table_offsets_.find(&vmap_table);
+    SafeMap<const std::vector<uint16_t>*, uint32_t>::iterator vmap_iter =
+        vmap_table_offsets_.find(&vmap_table);
     if (vmap_iter != vmap_table_offsets_.end()) {
       vmap_table_offset = vmap_iter->second;
     } else {
@@ -382,7 +372,8 @@ size_t OatWriter::InitOatCodeMethod(size_t offset, size_t oat_class_index,
 #endif
 
     // Deduplicate GC maps
-    SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator gc_map_iter = gc_map_offsets_.find(&gc_map);
+    SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator gc_map_iter =
+        gc_map_offsets_.find(&gc_map);
     if (gc_map_iter != gc_map_offsets_.end()) {
       gc_map_offset = gc_map_iter->second;
     } else {
@@ -392,14 +383,14 @@ size_t OatWriter::InitOatCodeMethod(size_t offset, size_t oat_class_index,
     }
   }
 
-  oat_class->method_offsets_[class_def_method_index]
-      = OatMethodOffsets(code_offset,
-                         frame_size_in_bytes,
-                         core_spill_mask,
-                         fp_spill_mask,
-                         mapping_table_offset,
-                         vmap_table_offset,
-                         gc_map_offset);
+  oat_class->method_offsets_[class_def_method_index] =
+      OatMethodOffsets(code_offset,
+                       frame_size_in_bytes,
+                       core_spill_mask,
+                       fp_spill_mask,
+                       mapping_table_offset,
+                       vmap_table_offset,
+                       gc_map_offset);
 
   if (compiler_driver_->IsImage()) {
     ClassLinker* linker = Runtime::Current()->GetClassLinker();
@@ -428,12 +419,16 @@ size_t OatWriter::InitOatCodeMethod(size_t offset, size_t oat_class_index,
 }
 
 #define DCHECK_OFFSET() \
-  DCHECK_EQ(static_cast<off_t>(offset), out.Seek(0, kSeekCurrent))
+  DCHECK_EQ(static_cast<off_t>(file_offset + relative_offset), out.Seek(0, kSeekCurrent)) \
+    << "file_offset=" << file_offset << " relative_offset=" << relative_offset
 
 #define DCHECK_OFFSET_() \
-  DCHECK_EQ(static_cast<off_t>(offset_), out.Seek(0, kSeekCurrent))
+  DCHECK_EQ(static_cast<off_t>(file_offset + offset_), out.Seek(0, kSeekCurrent)) \
+    << "file_offset=" << file_offset << " offset_=" << offset_
 
 bool OatWriter::Write(OutputStream& out) {
+  const size_t file_offset = out.Seek(0, kSeekCurrent);
+
   if (!out.WriteFully(oat_header_, sizeof(*oat_header_))) {
     PLOG(ERROR) << "Failed to write oat header to " << out.GetLocation();
     return false;
@@ -446,19 +441,19 @@ bool OatWriter::Write(OutputStream& out) {
   }
   size_oat_header_image_file_location_ += image_file_location_.size();
 
-  if (!WriteTables(out)) {
+  if (!WriteTables(out, file_offset)) {
     LOG(ERROR) << "Failed to write oat tables to " << out.GetLocation();
     return false;
   }
 
-  size_t code_offset = WriteCode(out);
-  if (code_offset == 0) {
+  size_t relative_offset = WriteCode(out, file_offset);
+  if (relative_offset == 0) {
     LOG(ERROR) << "Failed to write oat code to " << out.GetLocation();
     return false;
   }
 
-  code_offset = WriteCodeDexFiles(out, code_offset);
-  if (code_offset == 0) {
+  relative_offset = WriteCodeDexFiles(out, file_offset, relative_offset);
+  if (relative_offset == 0) {
     LOG(ERROR) << "Failed to write oat code for dex files to " << out.GetLocation();
     return false;
   }
@@ -495,21 +490,25 @@ bool OatWriter::Write(OutputStream& out) {
     #undef DO_STAT
 
     LOG(INFO) << "size_total=" << PrettySize(size_total) << " (" << size_total << "B)"; \
-    CHECK_EQ(size_total, static_cast<uint32_t>(out.Seek(0, kSeekCurrent)));
+    CHECK_EQ(file_offset + size_total, static_cast<uint32_t>(out.Seek(0, kSeekCurrent)));
+    CHECK_EQ(size_, size_total);
   }
 
+  CHECK_EQ(file_offset + size_, static_cast<uint32_t>(out.Seek(0, kSeekCurrent)));
+  CHECK_EQ(size_, relative_offset);
+
   return true;
 }
 
-bool OatWriter::WriteTables(OutputStream& out) {
+bool OatWriter::WriteTables(OutputStream& out, const size_t file_offset) {
   for (size_t i = 0; i != oat_dex_files_.size(); ++i) {
-    if (!oat_dex_files_[i]->Write(this, out)) {
+    if (!oat_dex_files_[i]->Write(this, out, file_offset)) {
       PLOG(ERROR) << "Failed to write oat dex information to " << out.GetLocation();
       return false;
     }
   }
   for (size_t i = 0; i != oat_dex_files_.size(); ++i) {
-    uint32_t expected_offset = oat_dex_files_[i]->dex_file_offset_;
+    uint32_t expected_offset = file_offset + oat_dex_files_[i]->dex_file_offset_;
     off_t actual_offset = out.Seek(expected_offset, kSeekSet);
     if (static_cast<uint32_t>(actual_offset) != expected_offset) {
       const DexFile* dex_file = (*dex_files_)[i];
@@ -519,13 +518,14 @@ bool OatWriter::WriteTables(OutputStream& out) {
     }
     const DexFile* dex_file = (*dex_files_)[i];
     if (!out.WriteFully(&dex_file->GetHeader(), dex_file->GetHeader().file_size_)) {
-      PLOG(ERROR) << "Failed to write dex file " << dex_file->GetLocation() << " to " << out.GetLocation();
+      PLOG(ERROR) << "Failed to write dex file " << dex_file->GetLocation()
+                  << " to " << out.GetLocation();
       return false;
     }
     size_dex_file_ += dex_file->GetHeader().file_size_;
   }
   for (size_t i = 0; i != oat_classes_.size(); ++i) {
-    if (!oat_classes_[i]->Write(this, out)) {
+    if (!oat_classes_[i]->Write(this, out, file_offset)) {
       PLOG(ERROR) << "Failed to write oat methods information to " << out.GetLocation();
       return false;
     }
@@ -533,27 +533,29 @@ bool OatWriter::WriteTables(OutputStream& out) {
   return true;
 }
 
-size_t OatWriter::WriteCode(OutputStream& out) {
-  uint32_t offset = oat_header_->GetExecutableOffset();
+size_t OatWriter::WriteCode(OutputStream& out, const size_t file_offset) {
+  size_t relative_offset = oat_header_->GetExecutableOffset();
   off_t new_offset = out.Seek(size_executable_offset_alignment_, kSeekCurrent);
-  if (static_cast<uint32_t>(new_offset) != offset) {
+  size_t expected_file_offset = file_offset + relative_offset;
+  if (static_cast<uint32_t>(new_offset) != expected_file_offset) {
     PLOG(ERROR) << "Failed to seek to oat code section. Actual: " << new_offset
-                << " Expected: " << offset << " File: " << out.GetLocation();
+                << " Expected: " << expected_file_offset << " File: " << out.GetLocation();
     return 0;
   }
   DCHECK_OFFSET();
   if (compiler_driver_->IsImage()) {
     InstructionSet instruction_set = compiler_driver_->GetInstructionSet();
-    if (!out.WriteFully(&(*interpreter_to_interpreter_entry_)[0], interpreter_to_interpreter_entry_->size())) {
+    if (!out.WriteFully(&(*interpreter_to_interpreter_entry_)[0],
+                        interpreter_to_interpreter_entry_->size())) {
       PLOG(ERROR) << "Failed to write interpreter to interpreter entry to " << out.GetLocation();
       return false;
     }
     size_interpreter_to_interpreter_entry_ += interpreter_to_interpreter_entry_->size();
-    offset += interpreter_to_interpreter_entry_->size();
+    relative_offset += interpreter_to_interpreter_entry_->size();
     DCHECK_OFFSET();
 
-    uint32_t aligned_offset = CompiledCode::AlignCode(offset, instruction_set);
-    uint32_t alignment_padding = aligned_offset - offset;
+    uint32_t aligned_offset = CompiledCode::AlignCode(relative_offset, instruction_set);
+    uint32_t alignment_padding = aligned_offset - relative_offset;
     out.Seek(alignment_padding, kSeekCurrent);
     size_stubs_alignment_ += alignment_padding;
     if (!out.WriteFully(&(*interpreter_to_quick_entry_)[0], interpreter_to_quick_entry_->size())) {
@@ -561,60 +563,67 @@ size_t OatWriter::WriteCode(OutputStream& out) {
       return false;
     }
     size_interpreter_to_quick_entry_ += interpreter_to_quick_entry_->size();
-    offset += alignment_padding + interpreter_to_quick_entry_->size();
+    relative_offset += alignment_padding + interpreter_to_quick_entry_->size();
     DCHECK_OFFSET();
 
-    aligned_offset = CompiledCode::AlignCode(offset, instruction_set);
-    alignment_padding = aligned_offset - offset;
+    aligned_offset = CompiledCode::AlignCode(relative_offset, instruction_set);
+    alignment_padding = aligned_offset - relative_offset;
     out.Seek(alignment_padding, kSeekCurrent);
     size_stubs_alignment_ += alignment_padding;
-    if (!out.WriteFully(&(*portable_resolution_trampoline_)[0], portable_resolution_trampoline_->size())) {
+    if (!out.WriteFully(&(*portable_resolution_trampoline_)[0],
+                        portable_resolution_trampoline_->size())) {
       PLOG(ERROR) << "Failed to write portable resolution trampoline to " << out.GetLocation();
       return false;
     }
     size_portable_resolution_trampoline_ += portable_resolution_trampoline_->size();
-    offset += alignment_padding + portable_resolution_trampoline_->size();
+    relative_offset += alignment_padding + portable_resolution_trampoline_->size();
     DCHECK_OFFSET();
 
-    aligned_offset = CompiledCode::AlignCode(offset, instruction_set);
-    alignment_padding = aligned_offset - offset;
+    aligned_offset = CompiledCode::AlignCode(relative_offset, instruction_set);
+    alignment_padding = aligned_offset - relative_offset;
     out.Seek(alignment_padding, kSeekCurrent);
     size_stubs_alignment_ += alignment_padding;
-    if (!out.WriteFully(&(*quick_resolution_trampoline_)[0], quick_resolution_trampoline_->size())) {
+    if (!out.WriteFully(&(*quick_resolution_trampoline_)[0],
+                        quick_resolution_trampoline_->size())) {
       PLOG(ERROR) << "Failed to write quick resolution trampoline to " << out.GetLocation();
       return false;
     }
     size_quick_resolution_trampoline_ += quick_resolution_trampoline_->size();
-    offset += alignment_padding + quick_resolution_trampoline_->size();
+    relative_offset += alignment_padding + quick_resolution_trampoline_->size();
     DCHECK_OFFSET();
   }
-  return offset;
+  return relative_offset;
 }
 
-size_t OatWriter::WriteCodeDexFiles(OutputStream& out, size_t code_offset) {
+size_t OatWriter::WriteCodeDexFiles(OutputStream& out,
+                                    const size_t file_offset,
+                                    size_t relative_offset) {
   size_t oat_class_index = 0;
   for (size_t i = 0; i != oat_dex_files_.size(); ++i) {
     const DexFile* dex_file = (*dex_files_)[i];
     CHECK(dex_file != NULL);
-    code_offset = WriteCodeDexFile(out, code_offset, oat_class_index, *dex_file);
-    if (code_offset == 0) {
+    relative_offset = WriteCodeDexFile(out, file_offset, relative_offset, oat_class_index,
+                                       *dex_file);
+    if (relative_offset == 0) {
       return 0;
     }
   }
-  return code_offset;
+  return relative_offset;
 }
 
-size_t OatWriter::WriteCodeDexFile(OutputStream& out, size_t code_offset, size_t& oat_class_index,
+size_t OatWriter::WriteCodeDexFile(OutputStream& out, const size_t file_offset,
+                                   size_t relative_offset, size_t& oat_class_index,
                                    const DexFile& dex_file) {
   for (size_t class_def_index = 0; class_def_index < dex_file.NumClassDefs();
       class_def_index++, oat_class_index++) {
     const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
-    code_offset = WriteCodeClassDef(out, code_offset, oat_class_index, dex_file, class_def);
-    if (code_offset == 0) {
+    relative_offset = WriteCodeClassDef(out, file_offset, relative_offset, oat_class_index,
+                                        dex_file, class_def);
+    if (relative_offset == 0) {
       return 0;
     }
   }
-  return code_offset;
+  return relative_offset;
 }
 
 void OatWriter::ReportWriteFailure(const char* what, uint32_t method_idx,
@@ -624,13 +633,15 @@ void OatWriter::ReportWriteFailure(const char* what, uint32_t method_idx,
 }
 
 size_t OatWriter::WriteCodeClassDef(OutputStream& out,
-                                    size_t code_offset, size_t oat_class_index,
+                                    const size_t file_offset,
+                                    size_t relative_offset,
+                                    size_t oat_class_index,
                                     const DexFile& dex_file,
                                     const DexFile::ClassDef& class_def) {
   const byte* class_data = dex_file.GetClassData(class_def);
   if (class_data == NULL) {
     // ie. an empty class such as a marker interface
-    return code_offset;
+    return relative_offset;
   }
   ClassDataItemIterator it(dex_file, class_data);
   // Skip fields
@@ -644,27 +655,29 @@ size_t OatWriter::WriteCodeClassDef(OutputStream& out,
   size_t class_def_method_index = 0;
   while (it.HasNextDirectMethod()) {
     bool is_static = (it.GetMemberAccessFlags() & kAccStatic) != 0;
-    code_offset = WriteCodeMethod(out, code_offset, oat_class_index, class_def_method_index,
-                                  is_static, it.GetMemberIndex(), dex_file);
-    if (code_offset == 0) {
+    relative_offset = WriteCodeMethod(out, file_offset, relative_offset, oat_class_index,
+                                      class_def_method_index, is_static, it.GetMemberIndex(),
+                                      dex_file);
+    if (relative_offset == 0) {
       return 0;
     }
     class_def_method_index++;
     it.Next();
   }
   while (it.HasNextVirtualMethod()) {
-    code_offset = WriteCodeMethod(out, code_offset, oat_class_index, class_def_method_index,
-                                  false, it.GetMemberIndex(), dex_file);
-    if (code_offset == 0) {
+    relative_offset = WriteCodeMethod(out, file_offset, relative_offset, oat_class_index,
+                                      class_def_method_index, false, it.GetMemberIndex(), dex_file);
+    if (relative_offset == 0) {
       return 0;
     }
     class_def_method_index++;
     it.Next();
   }
-  return code_offset;
+  return relative_offset;
 }
 
-size_t OatWriter::WriteCodeMethod(OutputStream& out, size_t offset, size_t oat_class_index,
+size_t OatWriter::WriteCodeMethod(OutputStream& out, const size_t file_offset,
+                                  size_t relative_offset, size_t oat_class_index,
                                   size_t class_def_method_index, bool is_static,
                                   uint32_t method_idx, const DexFile& dex_file) {
   const CompiledMethod* compiled_method =
@@ -676,26 +689,27 @@ size_t OatWriter::WriteCodeMethod(OutputStream& out, size_t offset, size_t oat_c
 
   if (compiled_method != NULL) {  // ie. not an abstract method
 #if !defined(ART_USE_PORTABLE_COMPILER)
-    uint32_t aligned_offset = compiled_method->AlignCode(offset);
-    uint32_t aligned_code_delta = aligned_offset - offset;
+    uint32_t aligned_offset = compiled_method->AlignCode(relative_offset);
+    uint32_t aligned_code_delta = aligned_offset - relative_offset;
     if (aligned_code_delta != 0) {
       off_t new_offset = out.Seek(aligned_code_delta, kSeekCurrent);
       size_code_alignment_ += aligned_code_delta;
-      if (static_cast<uint32_t>(new_offset) != aligned_offset) {
+      uint32_t expected_offset = file_offset + aligned_offset;
+      if (static_cast<uint32_t>(new_offset) != expected_offset) {
         PLOG(ERROR) << "Failed to seek to align oat code. Actual: " << new_offset
-                    << " Expected: " << aligned_offset << " File: " << out.GetLocation();
+                    << " Expected: " << expected_offset << " File: " << out.GetLocation();
         return 0;
       }
-      offset += aligned_code_delta;
+      relative_offset += aligned_code_delta;
       DCHECK_OFFSET();
     }
-    DCHECK_ALIGNED(offset, kArmAlignment);
+    DCHECK_ALIGNED(relative_offset, kArmAlignment);
     const std::vector<uint8_t>& code = compiled_method->GetCode();
     uint32_t code_size = code.size() * sizeof(code[0]);
     CHECK_NE(code_size, 0U);
 
     // Deduplicate code arrays
-    size_t code_offset = offset + sizeof(code_size) + compiled_method->CodeDelta();
+    size_t code_offset = relative_offset + sizeof(code_size) + compiled_method->CodeDelta();
     SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator code_iter = code_offsets_.find(&code);
     if (code_iter != code_offsets_.end() && code_offset != method_offsets.code_offset_) {
       DCHECK(code_iter->second == method_offsets.code_offset_)
@@ -707,14 +721,14 @@ size_t OatWriter::WriteCodeMethod(OutputStream& out, size_t offset, size_t oat_c
         return 0;
       }
       size_code_size_ += sizeof(code_size);
-      offset += sizeof(code_size);
+      relative_offset += sizeof(code_size);
       DCHECK_OFFSET();
       if (!out.WriteFully(&code[0], code_size)) {
         ReportWriteFailure("method code", method_idx, dex_file, out);
         return 0;
       }
       size_code_ += code_size;
-      offset += code_size;
+      relative_offset += code_size;
     }
     DCHECK_OFFSET();
 #endif
@@ -726,20 +740,20 @@ size_t OatWriter::WriteCodeMethod(OutputStream& out, size_t offset, size_t oat_c
     SafeMap<const std::vector<uint32_t>*, uint32_t>::iterator mapping_iter =
         mapping_table_offsets_.find(&mapping_table);
     if (mapping_iter != mapping_table_offsets_.end() &&
-        offset != method_offsets.mapping_table_offset_) {
+        relative_offset != method_offsets.mapping_table_offset_) {
       DCHECK((mapping_table_size == 0 && method_offsets.mapping_table_offset_ == 0)
           || mapping_iter->second == method_offsets.mapping_table_offset_)
           << PrettyMethod(method_idx, dex_file);
     } else {
       DCHECK((mapping_table_size == 0 && method_offsets.mapping_table_offset_ == 0)
-          || offset == method_offsets.mapping_table_offset_)
+          || relative_offset == method_offsets.mapping_table_offset_)
           << PrettyMethod(method_idx, dex_file);
       if (!out.WriteFully(&mapping_table[0], mapping_table_size)) {
         ReportWriteFailure("mapping table", method_idx, dex_file, out);
         return 0;
       }
       size_mapping_table_ += mapping_table_size;
-      offset += mapping_table_size;
+      relative_offset += mapping_table_size;
     }
     DCHECK_OFFSET();
 
@@ -750,20 +764,20 @@ size_t OatWriter::WriteCodeMethod(OutputStream& out, size_t offset, size_t oat_c
     SafeMap<const std::vector<uint16_t>*, uint32_t>::iterator vmap_iter =
         vmap_table_offsets_.find(&vmap_table);
     if (vmap_iter != vmap_table_offsets_.end() &&
-        offset != method_offsets.vmap_table_offset_) {
+        relative_offset != method_offsets.vmap_table_offset_) {
       DCHECK((vmap_table_size == 0 && method_offsets.vmap_table_offset_ == 0)
           || vmap_iter->second == method_offsets.vmap_table_offset_)
           << PrettyMethod(method_idx, dex_file);
     } else {
       DCHECK((vmap_table_size == 0 && method_offsets.vmap_table_offset_ == 0)
-          || offset == method_offsets.vmap_table_offset_)
+          || relative_offset == method_offsets.vmap_table_offset_)
           << PrettyMethod(method_idx, dex_file);
       if (!out.WriteFully(&vmap_table[0], vmap_table_size)) {
         ReportWriteFailure("vmap table", method_idx, dex_file, out);
         return 0;
       }
       size_vmap_table_ += vmap_table_size;
-      offset += vmap_table_size;
+      relative_offset += vmap_table_size;
     }
     DCHECK_OFFSET();
 
@@ -774,25 +788,25 @@ size_t OatWriter::WriteCodeMethod(OutputStream& out, size_t offset, size_t oat_c
     SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator gc_map_iter =
         gc_map_offsets_.find(&gc_map);
     if (gc_map_iter != gc_map_offsets_.end() &&
-        offset != method_offsets.gc_map_offset_) {
+        relative_offset != method_offsets.gc_map_offset_) {
       DCHECK((gc_map_size == 0 && method_offsets.gc_map_offset_ == 0)
           || gc_map_iter->second == method_offsets.gc_map_offset_)
           << PrettyMethod(method_idx, dex_file);
     } else {
       DCHECK((gc_map_size == 0 && method_offsets.gc_map_offset_ == 0)
-          || offset == method_offsets.gc_map_offset_)
+          || relative_offset == method_offsets.gc_map_offset_)
           << PrettyMethod(method_idx, dex_file);
       if (!out.WriteFully(&gc_map[0], gc_map_size)) {
         ReportWriteFailure("GC map", method_idx, dex_file, out);
         return 0;
       }
       size_gc_map_ += gc_map_size;
-      offset += gc_map_size;
+      relative_offset += gc_map_size;
     }
     DCHECK_OFFSET();
   }
 
-  return offset;
+  return relative_offset;
 }
 
 OatWriter::OatDexFile::OatDexFile(size_t offset, const DexFile& dex_file) {
@@ -822,7 +836,9 @@ void OatWriter::OatDexFile::UpdateChecksum(OatHeader& oat_header) const {
                             sizeof(methods_offsets_[0]) * methods_offsets_.size());
 }
 
-bool OatWriter::OatDexFile::Write(OatWriter* oat_writer, OutputStream& out) const {
+bool OatWriter::OatDexFile::Write(OatWriter* oat_writer,
+                                  OutputStream& out,
+                                  const size_t file_offset) const {
   DCHECK_OFFSET_();
   if (!out.WriteFully(&dex_file_location_size_, sizeof(dex_file_location_size_))) {
     PLOG(ERROR) << "Failed to write dex file location length to " << out.GetLocation();
@@ -881,14 +897,16 @@ void OatWriter::OatClass::UpdateChecksum(OatHeader& oat_header) const {
                             sizeof(method_offsets_[0]) * method_offsets_.size());
 }
 
-bool OatWriter::OatClass::Write(OatWriter* oat_writer, OutputStream& out) const {
+bool OatWriter::OatClass::Write(OatWriter* oat_writer,
+                                OutputStream& out,
+                                const size_t file_offset) const {
   DCHECK_OFFSET_();
   if (!out.WriteFully(&status_, sizeof(status_))) {
     PLOG(ERROR) << "Failed to write class status to " << out.GetLocation();
     return false;
   }
   oat_writer->size_oat_class_status_ += sizeof(status_);
-  DCHECK_EQ(static_cast<off_t>(GetOatMethodOffsetsOffsetFromOatHeader(0)),
+  DCHECK_EQ(static_cast<off_t>(file_offset + GetOatMethodOffsetsOffsetFromOatHeader(0)),
             out.Seek(0, kSeekCurrent));
   if (!out.WriteFully(&method_offsets_[0],
                       sizeof(method_offsets_[0]) * method_offsets_.size())) {
@@ -896,7 +914,8 @@ bool OatWriter::OatClass::Write(OatWriter* oat_writer, OutputStream& out) const
     return false;
   }
   oat_writer->size_oat_class_method_offsets_ += sizeof(method_offsets_[0]) * method_offsets_.size();
-  DCHECK_EQ(static_cast<off_t>(GetOatMethodOffsetsOffsetFromOatHeader(method_offsets_.size())),
+  DCHECK_EQ(static_cast<off_t>(file_offset +
+                               GetOatMethodOffsetsOffsetFromOatHeader(method_offsets_.size())),
             out.Seek(0, kSeekCurrent));
   return true;
 }
diff --git a/compiler/oat_writer.h b/compiler/oat_writer.h
index ea7156ea49..f2c5626b4d 100644
--- a/compiler/oat_writer.h
+++ b/compiler/oat_writer.h
@@ -62,23 +62,25 @@ class OutputStream;
 //
 class OatWriter {
  public:
-  // Write an oat file. Returns true on success, false on failure.
-  static bool Create(OutputStream& out,
-                     const std::vector<const DexFile*>& dex_files,
-                     uint32_t image_file_location_oat_checksum,
-                     uint32_t image_file_location_oat_begin,
-                     const std::string& image_file_location,
-                     const CompilerDriver& compiler)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- private:
   OatWriter(const std::vector<const DexFile*>& dex_files,
             uint32_t image_file_location_oat_checksum,
             uint32_t image_file_location_oat_begin,
             const std::string& image_file_location,
             const CompilerDriver* compiler) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  const OatHeader& GetOatHeader() const {
+    return *oat_header_;
+  }
+
+  size_t GetSize() const {
+    return size_;
+  }
+
+  bool Write(OutputStream& out);
+
   ~OatWriter();
 
+ private:
   size_t InitOatHeader();
   size_t InitOatDexFiles(size_t offset);
   size_t InitDexFiles(size_t offset);
@@ -101,17 +103,17 @@ class OatWriter {
                            uint32_t method_idx, const DexFile*)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  bool Write(OutputStream& out);
-  bool WriteTables(OutputStream& out);
-  size_t WriteCode(OutputStream& out);
-  size_t WriteCodeDexFiles(OutputStream& out, size_t offset);
-  size_t WriteCodeDexFile(OutputStream& out, size_t offset, size_t& oat_class_index,
-                          const DexFile& dex_file);
-  size_t WriteCodeClassDef(OutputStream& out, size_t offset, size_t oat_class_index,
-                           const DexFile& dex_file, const DexFile::ClassDef& class_def);
-  size_t WriteCodeMethod(OutputStream& out, size_t offset, size_t oat_class_index,
-                         size_t class_def_method_index, bool is_static, uint32_t method_idx,
-                         const DexFile& dex_file);
+  bool WriteTables(OutputStream& out, const size_t file_offset);
+  size_t WriteCode(OutputStream& out, const size_t file_offset);
+  size_t WriteCodeDexFiles(OutputStream& out, const size_t file_offset, size_t relative_offset);
+  size_t WriteCodeDexFile(OutputStream& out, const size_t file_offset, size_t relative_offset,
+                          size_t& oat_class_index, const DexFile& dex_file);
+  size_t WriteCodeClassDef(OutputStream& out, const size_t file_offset, size_t relative_offset,
+                           size_t oat_class_index, const DexFile& dex_file,
+                           const DexFile::ClassDef& class_def);
+  size_t WriteCodeMethod(OutputStream& out, const size_t file_offset, size_t relative_offset,
+                         size_t oat_class_index, size_t class_def_method_index, bool is_static,
+                         uint32_t method_idx, const DexFile& dex_file);
 
   void ReportWriteFailure(const char* what, uint32_t method_idx, const DexFile& dex_file,
                           OutputStream& out) const;
@@ -121,7 +123,7 @@ class OatWriter {
     explicit OatDexFile(size_t offset, const DexFile& dex_file);
     size_t SizeOf() const;
     void UpdateChecksum(OatHeader& oat_header) const;
-    bool Write(OatWriter* oat_writer, OutputStream& out) const;
+    bool Write(OatWriter* oat_writer, OutputStream& out, const size_t file_offset) const;
 
     // Offset of start of OatDexFile from beginning of OatHeader. It is
     // used to validate file position when writing.
@@ -145,7 +147,7 @@ class OatWriter {
     size_t GetOatMethodOffsetsOffsetFromOatClass(size_t class_def_method_index_) const;
     size_t SizeOf() const;
     void UpdateChecksum(OatHeader& oat_header) const;
-    bool Write(OatWriter* oat_writer, OutputStream& out) const;
+    bool Write(OatWriter* oat_writer, OutputStream& out, const size_t file_offset) const;
 
     // Offset of start of OatClass from beginning of OatHeader. It is
     // used to validate file position when writing. For Portable, it
@@ -167,6 +169,9 @@ class OatWriter {
   // note OatFile does not take ownership of the DexFiles
   const std::vector<const DexFile*>* dex_files_;
 
+  // Size required for Oat data structures.
+  size_t size_;
+
   // dependencies on the image.
   uint32_t image_file_location_oat_checksum_;
   uint32_t image_file_location_oat_begin_;
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index 0e32f0b9f2..1a6a98a2af 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -282,27 +282,14 @@ class Dex2Oat {
       }
     }
 
-    std::vector<uint8_t> oat_contents;
-    // TODO: change ElfWriterQuick to not require the creation of oat_contents. The old pre-mclinker
-    //       OatWriter streamed directly to disk. The new could can be adapted to do it as follows:
-    // 1.) use first pass of OatWriter to calculate size of oat structure,
-    // 2.) call ElfWriterQuick with pointer to OatWriter instead of contents,
-    // 3.) have ElfWriterQuick call back to OatWriter to stream generate the output directly in
-    //     place in the elf file.
-    oat_contents.reserve(5 * MB);
-    VectorOutputStream vector_output_stream(oat_file->GetPath(), oat_contents);
-    if (!OatWriter::Create(vector_output_stream,
-                           dex_files,
-                           image_file_location_oat_checksum,
-                           image_file_location_oat_data_begin,
-                           image_file_location,
-                           *driver.get())) {
-      LOG(ERROR) << "Failed to create oat file " << oat_file->GetPath();
-      return NULL;
-    }
+    OatWriter oat_writer(dex_files,
+                         image_file_location_oat_checksum,
+                         image_file_location_oat_data_begin,
+                         image_file_location,
+                         driver.get());
     timings.AddSplit("dex2oat OatWriter");
 
-    if (!driver->WriteElf(android_root, is_host, dex_files, oat_contents, oat_file)) {
+    if (!driver->WriteElf(android_root, is_host, dex_files, oat_writer, oat_file)) {
       LOG(ERROR) << "Failed to write ELF file " << oat_file->GetPath();
       return NULL;
     }
@@ -1019,10 +1006,10 @@ static int dex2oat(int argc, char** argv) {
                                                            *compiler.get());
     timings.AddSplit("dex2oat ImageWriter");
     Thread::Current()->TransitionFromSuspendedToRunnable();
-    LOG(INFO) << "Image written successfully: " << image_filename;
     if (!image_creation_success) {
       return EXIT_FAILURE;
     }
+    LOG(INFO) << "Image written successfully: " << image_filename;
   }
 
   if (is_host) {
diff --git a/runtime/image_test.cc b/runtime/image_test.cc
index 11218ad513..75eead4d8f 100644
--- a/runtime/image_test.cc
+++ b/runtime/image_test.cc
@@ -41,7 +41,6 @@ class ImageTest : public CommonTest {
 TEST_F(ImageTest, WriteRead) {
   ScratchFile tmp_elf;
   {
-    std::vector<uint8_t> oat_contents;
     {
       jobject class_loader = NULL;
       ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
@@ -49,17 +48,14 @@ TEST_F(ImageTest, WriteRead) {
       compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), timings);
 
       ScopedObjectAccess soa(Thread::Current());
-      VectorOutputStream output_stream(tmp_elf.GetFilename(), oat_contents);
-      bool success_oat = OatWriter::Create(output_stream, class_linker->GetBootClassPath(),
-                                           0, 0, "", *compiler_driver_.get());
-      ASSERT_TRUE(success_oat);
-
-      bool success_elf = compiler_driver_->WriteElf(GetTestAndroidRoot(),
-                                                    !kIsTargetBuild,
-                                                    class_linker->GetBootClassPath(),
-                                                    oat_contents,
-                                                    tmp_elf.GetFile());
-      ASSERT_TRUE(success_elf);
+      OatWriter oat_writer(class_linker->GetBootClassPath(),
+                           0, 0, "", compiler_driver_.get());
+      bool success = compiler_driver_->WriteElf(GetTestAndroidRoot(),
+                                                !kIsTargetBuild,
+                                                class_linker->GetBootClassPath(),
+                                                oat_writer,
+                                                tmp_elf.GetFile());
+      ASSERT_TRUE(success);
     }
   }
   // Workound bug that mcld::Linker::emit closes tmp_elf by reopening as tmp_oat.
diff --git a/runtime/oat_test.cc b/runtime/oat_test.cc
index 9a6bc19b13..3f2e43e985 100644
--- a/runtime/oat_test.cc
+++ b/runtime/oat_test.cc
@@ -83,21 +83,17 @@ TEST_F(OatTest, WriteRead) {
 
   ScopedObjectAccess soa(Thread::Current());
   ScratchFile tmp;
-  std::vector<uint8_t> oat_contents;
-  VectorOutputStream output_stream(tmp.GetFilename(), oat_contents);
-  bool success_oat = OatWriter::Create(output_stream,
-                                       class_linker->GetBootClassPath(),
-                                       42U,
-                                       4096U,
-                                       "lue.art",
-                                       *compiler_driver_.get());
-  ASSERT_TRUE(success_oat);
-  bool success_elf = compiler_driver_->WriteElf(GetTestAndroidRoot(),
-                                                !kIsTargetBuild,
-                                                class_linker->GetBootClassPath(),
-                                                oat_contents,
-                                                tmp.GetFile());
-  ASSERT_TRUE(success_elf);
+  OatWriter oat_writer(class_linker->GetBootClassPath(),
+                       42U,
+                       4096U,
+                       "lue.art",
+                       compiler_driver_.get());
+  bool success = compiler_driver_->WriteElf(GetTestAndroidRoot(),
+                                            !kIsTargetBuild,
+                                            class_linker->GetBootClassPath(),
+                                            oat_writer,
+                                            tmp.GetFile());
+  ASSERT_TRUE(success);
 
   if (compile) {  // OatWriter strips the code, regenerate to compare
     TimingLogger timings("CommonTest::WriteRead", false);
-- 
cgit v1.2.3-59-g8ed1b


From 8f20ff4354fd3fdd7604a299b7bf4446e5f4584c Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Wed, 24 Jul 2013 13:15:42 -0700
Subject: Update blacklist with HttpsURLConnection$DefaultHolder

Change-Id: Ib0a8b9511dc8e63d14f11ba48b80dfb78e32d25e
---
 compiler/driver/compiler_driver.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index ea2291cb44..486c536956 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -1981,7 +1981,7 @@ static const char* class_initializer_black_list[] = {
   "Ljavax/security/cert/X509Certificate$1;", // Calls VMClassLoader.getBootClassPathSize.
   "Ljavax/microedition/khronos/egl/EGL10;", // Requires EGLContext.
   "Ljavax/microedition/khronos/egl/EGLContext;", // Requires com.google.android.gles_jni.EGLImpl.
-  "Ljavax/net/ssl/HttpsURLConnection;", // Calls SSLSocketFactory.getDefault -> java.security.Security.getProperty.
+  "Ljavax/net/ssl/HttpsURLConnection$DefaultHolder;", // Calls VMClassLoader.getBootClassPathSize().
   "Ljavax/xml/datatype/DatatypeConstants;", // Calls OsConstants.initConstants.
   "Ljavax/xml/datatype/FactoryFinder;", // Calls OsConstants.initConstants.
   "Ljavax/xml/namespace/QName;", // Calls OsConstants.initConstants.
-- 
cgit v1.2.3-59-g8ed1b


From d792cc1569c3505d68352c11a72447419ee6eaaf Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Thu, 25 Jul 2013 10:50:39 -0700
Subject: Add art support for Zygote NoPreloadHolder which black lists early
 initialization.

Change-Id: I9c68f6d7a1f230aba6382b1331d413d4cb92be12
---
 compiler/driver/compiler_driver.cc | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 486c536956..c2a1312354 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -1981,7 +1981,6 @@ static const char* class_initializer_black_list[] = {
   "Ljavax/security/cert/X509Certificate$1;", // Calls VMClassLoader.getBootClassPathSize.
   "Ljavax/microedition/khronos/egl/EGL10;", // Requires EGLContext.
   "Ljavax/microedition/khronos/egl/EGLContext;", // Requires com.google.android.gles_jni.EGLImpl.
-  "Ljavax/net/ssl/HttpsURLConnection$DefaultHolder;", // Calls VMClassLoader.getBootClassPathSize().
   "Ljavax/xml/datatype/DatatypeConstants;", // Calls OsConstants.initConstants.
   "Ljavax/xml/datatype/FactoryFinder;", // Calls OsConstants.initConstants.
   "Ljavax/xml/namespace/QName;", // Calls OsConstants.initConstants.
@@ -2071,11 +2070,14 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
       }
       if (!klass->IsInitialized()) {
         if (can_init_static_fields) {
-          bool is_black_listed = false;
-          for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) {
-            if (StringPiece(descriptor) == class_initializer_black_list[i]) {
-              is_black_listed = true;
-              break;
+          // NoPreloadHolder inner class implies this should not be initialized early.
+          bool is_black_listed = StringPiece(descriptor).ends_with("$NoPreloadHolder;");
+          if (!is_black_listed) {
+            for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) {
+              if (StringPiece(descriptor) == class_initializer_black_list[i]) {
+                is_black_listed = true;
+                break;
+              }
             }
           }
           if (!is_black_listed) {
-- 
cgit v1.2.3-59-g8ed1b


From 6f28d91aab952e3244fbb4e707fa38f85538f374 Mon Sep 17 00:00:00 2001
From: Anwar Ghuloum <anwarg@google.com>
Date: Wed, 24 Jul 2013 15:02:53 -0700
Subject: Add systrace support to NewTimingLogger, migrate compiler timing
 logging to NewTimingLogger

Rpleaced old TimingLogger by NewTimingLogger, renamed NewTimingLogger to TimingLogger, added systrace support to TimingLogger.
Tests passing, phone booting, systrace working.

Change-Id: I2aeffb8bcb7f0fd979d8a2a3a8bcfbaa02413679
---
 compiler/driver/compiler_driver.cc       | 41 ++++++++---------
 compiler/driver/compiler_driver.h        | 26 +++++------
 compiler/driver/compiler_driver_test.cc  |  2 +-
 dex2oat/dex2oat.cc                       | 22 ++++-----
 runtime/base/timing_logger.cc            | 77 +++++++-------------------------
 runtime/base/timing_logger.h             | 35 +++------------
 runtime/common_test.h                    |  2 +-
 runtime/gc/collector/garbage_collector.h |  4 +-
 runtime/gc/collector/mark_sweep.cc       |  2 +-
 runtime/gc/heap.cc                       |  6 +--
 runtime/gc/heap.h                        |  4 +-
 runtime/image_test.cc                    |  2 +-
 runtime/oat_test.cc                      |  4 +-
 13 files changed, 83 insertions(+), 144 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index c2a1312354..2aa2a98efb 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -495,7 +495,7 @@ const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToQuickEntry() cons
 
 void CompilerDriver::CompileAll(jobject class_loader,
                                 const std::vector<const DexFile*>& dex_files,
-                                TimingLogger& timings) {
+                                base::TimingLogger& timings) {
   DCHECK(!Runtime::Current()->IsStarted());
   UniquePtr<ThreadPool> thread_pool(new ThreadPool(thread_count_));
   PreCompile(class_loader, dex_files, *thread_pool.get(), timings);
@@ -528,7 +528,7 @@ static bool IsDexToDexCompilationAllowed(mirror::ClassLoader* class_loader,
   return klass->IsVerified();
 }
 
-void CompilerDriver::CompileOne(const mirror::AbstractMethod* method, TimingLogger& timings) {
+void CompilerDriver::CompileOne(const mirror::AbstractMethod* method, base::TimingLogger& timings) {
   DCHECK(!Runtime::Current()->IsStarted());
   Thread* self = Thread::Current();
   jobject jclass_loader;
@@ -572,7 +572,7 @@ void CompilerDriver::CompileOne(const mirror::AbstractMethod* method, TimingLogg
 }
 
 void CompilerDriver::Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                             ThreadPool& thread_pool, TimingLogger& timings) {
+                             ThreadPool& thread_pool, base::TimingLogger& timings) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
@@ -581,7 +581,7 @@ void CompilerDriver::Resolve(jobject class_loader, const std::vector<const DexFi
 }
 
 void CompilerDriver::PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                                ThreadPool& thread_pool, TimingLogger& timings) {
+                                ThreadPool& thread_pool, base::TimingLogger& timings) {
   LoadImageClasses(timings);
 
   Resolve(class_loader, dex_files, thread_pool, timings);
@@ -666,12 +666,13 @@ static bool RecordImageClassesVisitor(mirror::Class* klass, void* arg)
 }
 
 // Make a list of descriptors for classes to include in the image
-void CompilerDriver::LoadImageClasses(TimingLogger& timings)
+void CompilerDriver::LoadImageClasses(base::TimingLogger& timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_) {
   if (image_classes_.get() == NULL) {
     return;
   }
 
+  timings.NewSplit("LoadImageClasses");
   // Make a first class to load all classes explicitly listed in the file
   Thread* self = Thread::Current();
   ScopedObjectAccess soa(self);
@@ -726,7 +727,6 @@ void CompilerDriver::LoadImageClasses(TimingLogger& timings)
   class_linker->VisitClasses(RecordImageClassesVisitor, image_classes_.get());
 
   CHECK_NE(image_classes_->size(), 0U);
-  timings.AddSplit("LoadImageClasses");
 }
 
 static void MaybeAddToImageClasses(mirror::Class* klass, CompilerDriver::DescriptorSet* image_classes)
@@ -758,11 +758,13 @@ void CompilerDriver::FindClinitImageClassesCallback(mirror::Object* object, void
   MaybeAddToImageClasses(object->GetClass(), compiler_driver->image_classes_.get());
 }
 
-void CompilerDriver::UpdateImageClasses(TimingLogger& timings) {
+void CompilerDriver::UpdateImageClasses(base::TimingLogger& timings) {
   if (image_classes_.get() == NULL) {
     return;
   }
 
+  timings.NewSplit("UpdateImageClasses");
+
   // Update image_classes_ with classes for objects created by <clinit> methods.
   Thread* self = Thread::Current();
   const char* old_cause = self->StartAssertNoThreadSuspension("ImageWriter");
@@ -772,7 +774,6 @@ void CompilerDriver::UpdateImageClasses(TimingLogger& timings) {
   heap->FlushAllocStack();
   heap->GetLiveBitmap()->Walk(FindClinitImageClassesCallback, this);
   self->EndAssertNoThreadSuspension(old_cause);
-  timings.AddSplit("UpdateImageClasses");
 }
 
 void CompilerDriver::RecordClassStatus(ClassReference ref, CompiledClass* compiled_class) {
@@ -1551,22 +1552,22 @@ static void ResolveType(const ParallelCompilationManager* manager, size_t type_i
 }
 
 void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_file,
-                                    ThreadPool& thread_pool, TimingLogger& timings) {
+                                    ThreadPool& thread_pool, base::TimingLogger& timings) {
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
 
   // TODO: we could resolve strings here, although the string table is largely filled with class
   //       and method names.
 
+  timings.NewSplit(strdup(("Resolve " + dex_file.GetLocation() + " Types").c_str()));
   ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
   context.ForAll(0, dex_file.NumTypeIds(), ResolveType, thread_count_);
-  timings.AddSplit("Resolve " + dex_file.GetLocation() + " Types");
 
+  timings.NewSplit(strdup(("Resolve " + dex_file.GetLocation() + " MethodsAndFields").c_str()));
   context.ForAll(0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_);
-  timings.AddSplit("Resolve " + dex_file.GetLocation() + " MethodsAndFields");
 }
 
 void CompilerDriver::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                            ThreadPool& thread_pool, TimingLogger& timings) {
+                            ThreadPool& thread_pool, base::TimingLogger& timings) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
@@ -1620,11 +1621,11 @@ static void VerifyClass(const ParallelCompilationManager* manager, size_t class_
 }
 
 void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file,
-                                   ThreadPool& thread_pool, TimingLogger& timings) {
+                                   ThreadPool& thread_pool, base::TimingLogger& timings) {
+  timings.NewSplit(strdup(("Verify " + dex_file.GetLocation()).c_str()));
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
   context.ForAll(0, dex_file.NumClassDefs(), VerifyClass, thread_count_);
-  timings.AddSplit("Verify " + dex_file.GetLocation());
 }
 
 static const char* class_initializer_black_list[] = {
@@ -2116,7 +2117,8 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
 }
 
 void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile& dex_file,
-                                       ThreadPool& thread_pool, TimingLogger& timings) {
+                                       ThreadPool& thread_pool, base::TimingLogger& timings) {
+  timings.NewSplit(strdup(("InitializeNoClinit " + dex_file.GetLocation()).c_str()));
 #ifndef NDEBUG
   for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) {
     const char* descriptor = class_initializer_black_list[i];
@@ -2126,12 +2128,11 @@ void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile&
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, thread_pool);
   context.ForAll(0, dex_file.NumClassDefs(), InitializeClass, thread_count_);
-  timings.AddSplit("InitializeNoClinit " + dex_file.GetLocation());
 }
 
 void CompilerDriver::InitializeClasses(jobject class_loader,
                                        const std::vector<const DexFile*>& dex_files,
-                                       ThreadPool& thread_pool, TimingLogger& timings) {
+                                       ThreadPool& thread_pool, base::TimingLogger& timings) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
@@ -2140,7 +2141,7 @@ void CompilerDriver::InitializeClasses(jobject class_loader,
 }
 
 void CompilerDriver::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                       ThreadPool& thread_pool, TimingLogger& timings) {
+                       ThreadPool& thread_pool, base::TimingLogger& timings) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
@@ -2220,10 +2221,10 @@ void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, siz
 }
 
 void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_file,
-                                    ThreadPool& thread_pool, TimingLogger& timings) {
+                                    ThreadPool& thread_pool, base::TimingLogger& timings) {
+  timings.NewSplit(strdup(("Compile " + dex_file.GetLocation()).c_str()));
   ParallelCompilationManager context(NULL, class_loader, this, &dex_file, thread_pool);
   context.ForAll(0, dex_file.NumClassDefs(), CompilerDriver::CompileClass, thread_count_);
-  timings.AddSplit("Compile " + dex_file.GetLocation());
 }
 
 void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index f3f72dd3c7..a7a47ed876 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -78,11 +78,11 @@ class CompilerDriver {
   ~CompilerDriver();
 
   void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                  TimingLogger& timings)
+                  base::TimingLogger& timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
 
   // Compile a single Method
-  void CompileOne(const mirror::AbstractMethod* method, TimingLogger& timings)
+  void CompileOne(const mirror::AbstractMethod* method, base::TimingLogger& timings)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   InstructionSet GetInstructionSet() const {
@@ -284,42 +284,42 @@ class CompilerDriver {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                  ThreadPool& thread_pool, TimingLogger& timings)
+                  ThreadPool& thread_pool, base::TimingLogger& timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
 
-  void LoadImageClasses(TimingLogger& timings);
+  void LoadImageClasses(base::TimingLogger& timings);
 
   // Attempt to resolve all type, methods, fields, and strings
   // referenced from code in the dex file following PathClassLoader
   // ordering semantics.
   void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-               ThreadPool& thread_pool, TimingLogger& timings)
+               ThreadPool& thread_pool, base::TimingLogger& timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
   void ResolveDexFile(jobject class_loader, const DexFile& dex_file,
-                      ThreadPool& thread_pool, TimingLogger& timings)
+                      ThreadPool& thread_pool, base::TimingLogger& timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
 
   void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-              ThreadPool& thread_pool, TimingLogger& timings);
+              ThreadPool& thread_pool, base::TimingLogger& timings);
   void VerifyDexFile(jobject class_loader, const DexFile& dex_file,
-                     ThreadPool& thread_pool, TimingLogger& timings)
+                     ThreadPool& thread_pool, base::TimingLogger& timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
 
   void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                         ThreadPool& thread_pool, TimingLogger& timings)
+                         ThreadPool& thread_pool, base::TimingLogger& timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
   void InitializeClasses(jobject class_loader, const DexFile& dex_file,
-                         ThreadPool& thread_pool, TimingLogger& timings)
+                         ThreadPool& thread_pool, base::TimingLogger& timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_);
 
-  void UpdateImageClasses(TimingLogger& timings);
+  void UpdateImageClasses(base::TimingLogger& timings);
   static void FindClinitImageClassesCallback(mirror::Object* object, void* arg)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-               ThreadPool& thread_pool, TimingLogger& timings);
+               ThreadPool& thread_pool, base::TimingLogger& timings);
   void CompileDexFile(jobject class_loader, const DexFile& dex_file,
-                      ThreadPool& thread_pool, TimingLogger& timings)
+                      ThreadPool& thread_pool, base::TimingLogger& timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
   void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
                      InvokeType invoke_type, uint32_t class_def_idx, uint32_t method_idx,
diff --git a/compiler/driver/compiler_driver_test.cc b/compiler/driver/compiler_driver_test.cc
index 78cacaf08e..b06a3180fb 100644
--- a/compiler/driver/compiler_driver_test.cc
+++ b/compiler/driver/compiler_driver_test.cc
@@ -36,7 +36,7 @@ namespace art {
 class CompilerDriverTest : public CommonTest {
  protected:
   void CompileAll(jobject class_loader) LOCKS_EXCLUDED(Locks::mutator_lock_) {
-    TimingLogger timings("CompilerDriverTest::CompileAll", false);
+    base::TimingLogger timings("CompilerDriverTest::CompileAll", false, false);
     compiler_driver_->CompileAll(class_loader,
                                  Runtime::Current()->GetCompileTimeClassPath(class_loader),
                                  timings);
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index 1a6a98a2af..fb6f775675 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -230,7 +230,7 @@ class Dex2Oat {
                                       bool image,
                                       UniquePtr<CompilerDriver::DescriptorSet>& image_classes,
                                       bool dump_stats,
-                                      TimingLogger& timings)
+                                      base::TimingLogger& timings)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     // SirtRef and ClassLoader creation needs to come after Runtime::Create
     jobject class_loader = NULL;
@@ -263,11 +263,11 @@ class Dex2Oat {
 
     Thread::Current()->TransitionFromRunnableToSuspended(kNative);
 
-    timings.AddSplit("dex2oat Setup");
     driver->CompileAll(class_loader, dex_files, timings);
 
     Thread::Current()->TransitionFromSuspendedToRunnable();
 
+    timings.NewSplit("dex2oat OatWriter");
     std::string image_file_location;
     uint32_t image_file_location_oat_checksum = 0;
     uint32_t image_file_location_oat_data_begin = 0;
@@ -287,13 +287,11 @@ class Dex2Oat {
                          image_file_location_oat_data_begin,
                          image_file_location,
                          driver.get());
-    timings.AddSplit("dex2oat OatWriter");
 
     if (!driver->WriteElf(android_root, is_host, dex_files, oat_writer, oat_file)) {
       LOG(ERROR) << "Failed to write ELF file " << oat_file->GetPath();
       return NULL;
     }
-    timings.AddSplit("dex2oat ElfWriter");
 
     return driver.release();
   }
@@ -563,7 +561,7 @@ const unsigned int WatchDog::kWatchDogWarningSeconds;
 const unsigned int WatchDog::kWatchDogTimeoutSeconds;
 
 static int dex2oat(int argc, char** argv) {
-  TimingLogger timings("compiler", false);
+  base::TimingLogger timings("compiler", false, false);
 
   InitLogging(argv);
 
@@ -928,6 +926,7 @@ static int dex2oat(int argc, char** argv) {
     }
   }
 
+  timings.StartSplit("dex2oat Setup");
   UniquePtr<const CompilerDriver> compiler(dex2oat->CreateOatFile(boot_image_option,
                                                                   host_prefix.get(),
                                                                   android_root,
@@ -998,13 +997,13 @@ static int dex2oat(int argc, char** argv) {
   // Elf32_Phdr.p_vaddr values by the desired base address.
   //
   if (image) {
+    timings.NewSplit("dex2oat ImageWriter");
     Thread::Current()->TransitionFromRunnableToSuspended(kNative);
     bool image_creation_success = dex2oat->CreateImageFile(image_filename,
                                                            image_base,
                                                            oat_unstripped,
                                                            oat_location,
                                                            *compiler.get());
-    timings.AddSplit("dex2oat ImageWriter");
     Thread::Current()->TransitionFromSuspendedToRunnable();
     if (!image_creation_success) {
       return EXIT_FAILURE;
@@ -1014,7 +1013,7 @@ static int dex2oat(int argc, char** argv) {
 
   if (is_host) {
     if (dump_timings && timings.GetTotalNs() > MsToNs(1000)) {
-      LOG(INFO) << Dumpable<TimingLogger>(timings);
+      LOG(INFO) << Dumpable<base::TimingLogger>(timings);
     }
     return EXIT_SUCCESS;
   }
@@ -1022,6 +1021,7 @@ static int dex2oat(int argc, char** argv) {
   // If we don't want to strip in place, copy from unstripped location to stripped location.
   // We need to strip after image creation because FixupElf needs to use .strtab.
   if (oat_unstripped != oat_stripped) {
+    timings.NewSplit("dex2oat OatFile copy");
     oat_file.reset();
     UniquePtr<File> in(OS::OpenFile(oat_unstripped.c_str(), false));
     UniquePtr<File> out(OS::OpenFile(oat_stripped.c_str(), true));
@@ -1036,23 +1036,25 @@ static int dex2oat(int argc, char** argv) {
       CHECK(write_ok);
     }
     oat_file.reset(out.release());
-    timings.AddSplit("dex2oat OatFile copy");
     LOG(INFO) << "Oat file copied successfully (stripped): " << oat_stripped;
   }
 
 #if ART_USE_PORTABLE_COMPILER  // We currently only generate symbols on Portable
+  timings.NewSplit("dex2oat ElfStripper");
   // Strip unneeded sections for target
   off_t seek_actual = lseek(oat_file->Fd(), 0, SEEK_SET);
   CHECK_EQ(0, seek_actual);
   ElfStripper::Strip(oat_file.get());
-  timings.AddSplit("dex2oat ElfStripper");
+
 
   // We wrote the oat file successfully, and want to keep it.
   LOG(INFO) << "Oat file written successfully (stripped): " << oat_location;
 #endif // ART_USE_PORTABLE_COMPILER
 
+  timings.EndSplit();
+
   if (dump_timings && timings.GetTotalNs() > MsToNs(1000)) {
-    LOG(INFO) << Dumpable<TimingLogger>(timings);
+    LOG(INFO) << Dumpable<base::TimingLogger>(timings);
   }
   return EXIT_SUCCESS;
 }
diff --git a/runtime/base/timing_logger.cc b/runtime/base/timing_logger.cc
index bf6fd17a49..dfb0220d46 100644
--- a/runtime/base/timing_logger.cc
+++ b/runtime/base/timing_logger.cc
@@ -14,6 +14,11 @@
  * limitations under the License.
  */
 
+
+#define ATRACE_TAG ATRACE_TAG_DALVIK
+#include <stdio.h>
+#include <cutils/trace.h>
+
 #include "timing_logger.h"
 
 #include "base/logging.h"
@@ -26,49 +31,6 @@
 
 namespace art {
 
-void TimingLogger::Reset() {
-  times_.clear();
-  labels_.clear();
-  AddSplit("");
-}
-
-TimingLogger::TimingLogger(const std::string &name, bool precise)
-    : name_(name),
-      precise_(precise) {
-  AddSplit("");
-}
-
-void TimingLogger::AddSplit(const std::string &label) {
-  times_.push_back(NanoTime());
-  labels_.push_back(label);
-}
-
-uint64_t TimingLogger::GetTotalNs() const {
-  return times_.back() - times_.front();
-}
-
-void TimingLogger::Dump(std::ostream &os) const {
-  uint64_t largest_time = 0;
-  os << name_ << ": begin\n";
-  for (size_t i = 1; i < times_.size(); ++i) {
-    uint64_t delta_time = times_[i] - times_[i - 1];
-    largest_time = std::max(largest_time, delta_time);
-  }
-  // Compute which type of unit we will use for printing the timings.
-  TimeUnit tu = GetAppropriateTimeUnit(largest_time);
-  uint64_t divisor = GetNsToTimeUnitDivisor(tu);
-  for (size_t i = 1; i < times_.size(); ++i) {
-    uint64_t delta_time = times_[i] - times_[i - 1];
-    if (!precise_ && divisor >= 1000) {
-      // Make the fraction 0.
-      delta_time -= delta_time % (divisor / 1000);
-    }
-    os << name_ << ": " << std::setw(8) << FormatDuration(delta_time, tu) << " "
-       << labels_[i] << "\n";
-  }
-  os << name_ << ": end, " << NsToMs(GetTotalNs()) << " ms\n";
-}
-
 CumulativeLogger::CumulativeLogger(const std::string& name)
     : name_(name),
       lock_name_("CumulativeLoggerLock" + name),
@@ -112,17 +74,8 @@ uint64_t CumulativeLogger::GetTotalTime() const {
   return total;
 }
 
-void CumulativeLogger::AddLogger(const TimingLogger &logger) {
-  MutexLock mu(Thread::Current(), lock_);
-  DCHECK_EQ(logger.times_.size(), logger.labels_.size());
-  for (size_t i = 1; i < logger.times_.size(); ++i) {
-    const uint64_t delta_time = logger.times_[i] - logger.times_[i - 1];
-    const std::string &label = logger.labels_[i];
-    AddPair(label, delta_time);
-  }
-}
 
-void CumulativeLogger::AddNewLogger(const base::NewTimingLogger &logger) {
+void CumulativeLogger::AddLogger(const base::TimingLogger &logger) {
   MutexLock mu(Thread::Current(), lock_);
   const std::vector<std::pair<uint64_t, const char*> >& splits = logger.GetSplits();
   typedef std::vector<std::pair<uint64_t, const char*> >::const_iterator It;
@@ -183,51 +136,55 @@ void CumulativeLogger::DumpHistogram(std::ostream &os) {
 
 namespace base {
 
-NewTimingLogger::NewTimingLogger(const char* name, bool precise, bool verbose)
+TimingLogger::TimingLogger(const char* name, bool precise, bool verbose)
     : name_(name), precise_(precise), verbose_(verbose),
       current_split_(NULL), current_split_start_ns_(0) {
 }
 
-void NewTimingLogger::Reset() {
+void TimingLogger::Reset() {
   current_split_ = NULL;
   current_split_start_ns_ = 0;
   splits_.clear();
 }
 
-void NewTimingLogger::StartSplit(const char* new_split_label) {
+void TimingLogger::StartSplit(const char* new_split_label) {
   DCHECK(current_split_ == NULL);
   if (verbose_) {
     LOG(INFO) << "Begin: " << new_split_label;
   }
   current_split_ = new_split_label;
+  ATRACE_BEGIN(current_split_);
   current_split_start_ns_ = NanoTime();
 }
 
 // Ends the current split and starts the one given by the label.
-void NewTimingLogger::NewSplit(const char* new_split_label) {
+void TimingLogger::NewSplit(const char* new_split_label) {
   DCHECK(current_split_ != NULL);
   uint64_t current_time = NanoTime();
   uint64_t split_time = current_time - current_split_start_ns_;
+  ATRACE_END();
   splits_.push_back(std::pair<uint64_t, const char*>(split_time, current_split_));
   if (verbose_) {
     LOG(INFO) << "End: " << current_split_ << " " << PrettyDuration(split_time) << "\n"
         << "Begin: " << new_split_label;
   }
   current_split_ = new_split_label;
+  ATRACE_BEGIN(current_split_);
   current_split_start_ns_ = current_time;
 }
 
-void NewTimingLogger::EndSplit() {
+void TimingLogger::EndSplit() {
   DCHECK(current_split_ != NULL);
   uint64_t current_time = NanoTime();
   uint64_t split_time = current_time - current_split_start_ns_;
+  ATRACE_END();
   if (verbose_) {
     LOG(INFO) << "End: " << current_split_ << " " << PrettyDuration(split_time);
   }
   splits_.push_back(std::pair<uint64_t, const char*>(split_time, current_split_));
 }
 
-uint64_t NewTimingLogger::GetTotalNs() const {
+uint64_t TimingLogger::GetTotalNs() const {
   uint64_t total_ns = 0;
   typedef std::vector<std::pair<uint64_t, const char*> >::const_iterator It;
   for (It it = splits_.begin(), end = splits_.end(); it != end; ++it) {
@@ -237,7 +194,7 @@ uint64_t NewTimingLogger::GetTotalNs() const {
   return total_ns;
 }
 
-void NewTimingLogger::Dump(std::ostream &os) const {
+void TimingLogger::Dump(std::ostream &os) const {
   uint64_t longest_split = 0;
   uint64_t total_ns = 0;
   typedef std::vector<std::pair<uint64_t, const char*> >::const_iterator It;
diff --git a/runtime/base/timing_logger.h b/runtime/base/timing_logger.h
index 0f00a046e5..0998837517 100644
--- a/runtime/base/timing_logger.h
+++ b/runtime/base/timing_logger.h
@@ -26,27 +26,8 @@
 
 namespace art {
 
-class CumulativeLogger;
-
-class TimingLogger {
- public:
-  explicit TimingLogger(const std::string& name, bool precise);
-  void AddSplit(const std::string& label);
-  void Dump(std::ostream& os) const;
-  void Reset();
-  uint64_t GetTotalNs() const;
-
- protected:
-  const std::string name_;
-  const bool precise_;
-  std::vector<uint64_t> times_;
-  std::vector<std::string> labels_;
-
-  friend class CumulativeLogger;
-};
-
 namespace base {
-  class NewTimingLogger;
+  class TimingLogger;
 }  // namespace base
 
 class CumulativeLogger {
@@ -62,8 +43,7 @@ class CumulativeLogger {
   // Allow the name to be modified, particularly when the cumulative logger is a field within a
   // parent class that is unable to determine the "name" of a sub-class.
   void SetName(const std::string& name);
-  void AddLogger(const TimingLogger& logger) LOCKS_EXCLUDED(lock_);
-  void AddNewLogger(const base::NewTimingLogger& logger) LOCKS_EXCLUDED(lock_);
+  void AddLogger(const base::TimingLogger& logger) LOCKS_EXCLUDED(lock_);
 
  private:
   void AddPair(const std::string &label, uint64_t delta_time)
@@ -84,16 +64,15 @@ class CumulativeLogger {
 namespace base {
 
 // A replacement to timing logger that know when a split starts for the purposes of logging.
-// TODO: replace uses of TimingLogger with base::NewTimingLogger.
-class NewTimingLogger {
+class TimingLogger {
  public:
-  explicit NewTimingLogger(const char* name, bool precise, bool verbose);
+  explicit TimingLogger(const char* name, bool precise, bool verbose);
 
   // Clears current splits and labels.
   void Reset();
 
   // Starts a split, a split shouldn't be in progress.
-  void StartSplit(const char* new_split_label);
+  void StartSplit(const char*  new_split_label);
 
   // Ends the current split and starts the one given by the label.
   void NewSplit(const char* new_split_label);
@@ -111,7 +90,7 @@ class NewTimingLogger {
 
  protected:
   // The name of the timing logger.
-  const std::string name_;
+  const char* name_;
 
   // Do we want to print the exactly recorded split (true) or round down to the time unit being
   // used (false).
@@ -130,7 +109,7 @@ class NewTimingLogger {
   std::vector<std::pair<uint64_t, const char*> > splits_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(NewTimingLogger);
+  DISALLOW_COPY_AND_ASSIGN(TimingLogger);
 };
 
 }  // namespace base
diff --git a/runtime/common_test.h b/runtime/common_test.h
index 09ad7fd7b7..4fe9be6d8f 100644
--- a/runtime/common_test.h
+++ b/runtime/common_test.h
@@ -473,7 +473,7 @@ class CommonTest : public testing::Test {
 
   void CompileMethod(mirror::AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     CHECK(method != NULL);
-    TimingLogger timings("CommonTest::CompileMethod", false);
+    base::TimingLogger timings("CommonTest::CompileMethod", false, false);
     compiler_driver_->CompileOne(method, timings);
     MakeExecutable(method);
   }
diff --git a/runtime/gc/collector/garbage_collector.h b/runtime/gc/collector/garbage_collector.h
index 1684664eff..0f566c954b 100644
--- a/runtime/gc/collector/garbage_collector.h
+++ b/runtime/gc/collector/garbage_collector.h
@@ -64,7 +64,7 @@ class GarbageCollector {
 
   void RegisterPause(uint64_t nano_length);
 
-  base::NewTimingLogger& GetTimings() {
+  base::TimingLogger& GetTimings() {
     return timings_;
   }
 
@@ -101,7 +101,7 @@ class GarbageCollector {
   const bool verbose_;
 
   uint64_t duration_ns_;
-  base::NewTimingLogger timings_;
+  base::TimingLogger timings_;
 
   // Cumulative statistics.
   uint64_t total_time_ns_;
diff --git a/runtime/gc/collector/mark_sweep.cc b/runtime/gc/collector/mark_sweep.cc
index c8e60322d6..0cbd6fb267 100644
--- a/runtime/gc/collector/mark_sweep.cc
+++ b/runtime/gc/collector/mark_sweep.cc
@@ -1509,7 +1509,7 @@ void MarkSweep::FinishPhase() {
 
   // Update the cumulative loggers.
   cumulative_timings_.Start();
-  cumulative_timings_.AddNewLogger(timings_);
+  cumulative_timings_.AddLogger(timings_);
   cumulative_timings_.End();
 
   // Clear all of the spaces' mark bitmaps.
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index 1c1818873a..b0ba8b6874 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -1131,7 +1131,7 @@ collector::GcType Heap::CollectGarbageInternal(collector::GcType gc_type, GcCaus
               << PrettySize(total_memory) << ", " << "paused " << pause_string.str()
               << " total " << PrettyDuration((duration / 1000) * 1000);
     if (VLOG_IS_ON(heap)) {
-      LOG(INFO) << Dumpable<base::NewTimingLogger>(collector->GetTimings());
+      LOG(INFO) << Dumpable<base::TimingLogger>(collector->GetTimings());
     }
   }
 
@@ -1149,7 +1149,7 @@ collector::GcType Heap::CollectGarbageInternal(collector::GcType gc_type, GcCaus
   return gc_type;
 }
 
-void Heap::UpdateAndMarkModUnion(collector::MarkSweep* mark_sweep, base::NewTimingLogger& timings,
+void Heap::UpdateAndMarkModUnion(collector::MarkSweep* mark_sweep, base::TimingLogger& timings,
                                  collector::GcType gc_type) {
   if (gc_type == collector::kGcTypeSticky) {
     // Don't need to do anything for mod union table in this case since we are only scanning dirty
@@ -1441,7 +1441,7 @@ void Heap::SwapStacks() {
   }
 }
 
-void Heap::ProcessCards(base::NewTimingLogger& timings) {
+void Heap::ProcessCards(base::TimingLogger& timings) {
   // Clear cards and keep track of cards cleared in the mod-union table.
   typedef std::vector<space::ContinuousSpace*>::iterator It;
   for (It it = continuous_spaces_.begin(), end = continuous_spaces_.end(); it != end; ++it) {
diff --git a/runtime/gc/heap.h b/runtime/gc/heap.h
index b7b2e84942..b71c2bc421 100644
--- a/runtime/gc/heap.h
+++ b/runtime/gc/heap.h
@@ -379,7 +379,7 @@ class Heap {
       EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
 
   // Update and mark mod union table based on gc type.
-  void UpdateAndMarkModUnion(collector::MarkSweep* mark_sweep, base::NewTimingLogger& timings,
+  void UpdateAndMarkModUnion(collector::MarkSweep* mark_sweep, base::TimingLogger& timings,
                              collector::GcType gc_type)
       EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
 
@@ -472,7 +472,7 @@ class Heap {
   void SwapStacks();
 
   // Clear cards and update the mod union table.
-  void ProcessCards(base::NewTimingLogger& timings);
+  void ProcessCards(base::TimingLogger& timings);
 
   // All-known continuous spaces, where objects lie within fixed bounds.
   std::vector<space::ContinuousSpace*> continuous_spaces_;
diff --git a/runtime/image_test.cc b/runtime/image_test.cc
index 75eead4d8f..92ee1f83c6 100644
--- a/runtime/image_test.cc
+++ b/runtime/image_test.cc
@@ -44,7 +44,7 @@ TEST_F(ImageTest, WriteRead) {
     {
       jobject class_loader = NULL;
       ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-      TimingLogger timings("ImageTest::WriteRead", false);
+      base::TimingLogger timings("ImageTest::WriteRead", false, false);
       compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), timings);
 
       ScopedObjectAccess soa(Thread::Current());
diff --git a/runtime/oat_test.cc b/runtime/oat_test.cc
index 3f2e43e985..217e2d8743 100644
--- a/runtime/oat_test.cc
+++ b/runtime/oat_test.cc
@@ -77,7 +77,7 @@ TEST_F(OatTest, WriteRead) {
   compiler_driver_.reset(new CompilerDriver(compiler_backend, kThumb2, false, NULL, 2, true));
   jobject class_loader = NULL;
   if (compile) {
-    TimingLogger timings("OatTest::WriteRead", false);
+    base::TimingLogger timings("OatTest::WriteRead", false, false);
     compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), timings);
   }
 
@@ -96,7 +96,7 @@ TEST_F(OatTest, WriteRead) {
   ASSERT_TRUE(success);
 
   if (compile) {  // OatWriter strips the code, regenerate to compare
-    TimingLogger timings("CommonTest::WriteRead", false);
+    base::TimingLogger timings("CommonTest::WriteRead", false, false);
     compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), timings);
   }
   UniquePtr<OatFile> oat_file(OatFile::Open(tmp.GetFilename(), tmp.GetFilename(), NULL, false));
-- 
cgit v1.2.3-59-g8ed1b


From 4d4adb1dae07bb7421e863732ab789413a3b43f0 Mon Sep 17 00:00:00 2001
From: Sebastien Hertz <shertz@google.com>
Date: Wed, 24 Jul 2013 16:14:19 +0200
Subject: Prevent verifier from creating unused compilation data.

The verifier used to create data which may be unused like GC map. This is the
case for non-compiled method (which are interpreted). This CL aims to optimize
this.

Here are the changes:
- Move compilation selection to MethodVerifier::IsCandidateForCompilation.
- Compiler and verifier use this method to know if a method must be compiled.
- Only create compilation data while compiling using Runtime::IsCompiler.
- Do not create internal structures concerning GC map, ... in Runtime::Init and
Runtime::Shutdown when we are not compiling.
- Checks we are compiling when accessing these structures.
- Add missing destruction of MethodVerifier::safecast_map_lock_ and
MethodVerifier::safecast_map_ in Runtime::Shutdown.
- Call Runtime::Shutdown just before Runtime instance is destroyed to avoid a
crash.
- Add missing "GUARDED_BY" macro for MethodVerifier::rejected_classes_ field.
- Add "has_check_casts" to avoid the safecast pass if there is no check-cast
instruction.
- Add "has_virtual_or_interface_invokes" to avoid the devirtualization pass if
there is no invoke-virtual/range nor invoke-interface/range instructions.

Bug: 9987437
Change-Id: I418ee99f63e4203409cf5b7d2c2295b22fcf24c1
---
 compiler/driver/compiler_driver.cc  |  14 +--
 runtime/runtime.cc                  |   2 +-
 runtime/verifier/method_verifier.cc | 192 +++++++++++++++++++++++-------------
 runtime/verifier/method_verifier.h  |  12 ++-
 4 files changed, 139 insertions(+), 81 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 2aa2a98efb..8ce0aa9c94 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -2240,18 +2240,8 @@ void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t
     CHECK(compiled_method != NULL);
   } else if ((access_flags & kAccAbstract) != 0) {
   } else {
-    // In small mode we only compile image classes.
-    bool dont_compile = (Runtime::Current()->IsSmallMode() &&
-                         ((image_classes_.get() == NULL) || (image_classes_->size() == 0)));
-
-    // Don't compile class initializers, ever.
-    if (((access_flags & kAccConstructor) != 0) && ((access_flags & kAccStatic) != 0)) {
-      dont_compile = true;
-    } else if (code_item->insns_size_in_code_units_ < Runtime::Current()->GetSmallModeMethodDexSizeLimit()) {
-    // Do compile small methods.
-      dont_compile = false;
-    }
-    if (!dont_compile) {
+    bool compile = verifier::MethodVerifier::IsCandidateForCompilation(code_item, access_flags);
+    if (compile) {
       CompilerFn compiler = compiler_;
 #ifdef ART_SEA_IR_MODE
       bool use_sea = Runtime::Current()->IsSeaIRMode();
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index cf6e537df0..48ee127d21 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -134,10 +134,10 @@ Runtime::~Runtime() {
   delete java_vm_;
   Thread::Shutdown();
   QuasiAtomic::Shutdown();
+  verifier::MethodVerifier::Shutdown();
   // TODO: acquire a static mutex on Runtime to avoid racing.
   CHECK(instance_ == NULL || instance_ == this);
   instance_ = NULL;
-  verifier::MethodVerifier::Shutdown();
 }
 
 struct AbortState {
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index e182af7b82..3549945a4c 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -282,7 +282,9 @@ MethodVerifier::MethodVerifier(const DexFile* dex_file, mirror::DexCache* dex_ca
       new_instance_count_(0),
       monitor_enter_count_(0),
       can_load_classes_(can_load_classes),
-      allow_soft_failures_(allow_soft_failures) {
+      allow_soft_failures_(allow_soft_failures),
+      has_check_casts_(false),
+      has_virtual_or_interface_invokes_(false) {
 }
 
 void MethodVerifier::FindLocksAtDexPc(mirror::AbstractMethod* m, uint32_t dex_pc,
@@ -470,6 +472,13 @@ bool MethodVerifier::ComputeWidthsAndCountOps() {
       new_instance_count++;
     } else if (opcode == Instruction::MONITOR_ENTER) {
       monitor_enter_count++;
+    } else if (opcode == Instruction::CHECK_CAST) {
+      has_check_casts_ = true;
+    } else if ((inst->Opcode() == Instruction::INVOKE_VIRTUAL) ||
+              (inst->Opcode() ==  Instruction::INVOKE_VIRTUAL_RANGE) ||
+              (inst->Opcode() == Instruction::INVOKE_INTERFACE) ||
+              (inst->Opcode() == Instruction::INVOKE_INTERFACE_RANGE)) {
+      has_virtual_or_interface_invokes_ = true;
     }
     size_t inst_size = inst->SizeInCodeUnits();
     insn_flags_[dex_pc].SetLengthInCodeUnits(inst_size);
@@ -1002,27 +1011,37 @@ bool MethodVerifier::VerifyCodeFlow() {
     return false;
   }
 
-  /* Generate a register map and add it to the method. */
-  UniquePtr<const std::vector<uint8_t> > map(GenerateGcMap());
-  if (map.get() == NULL) {
-    DCHECK_NE(failures_.size(), 0U);
-    return false;  // Not a real failure, but a failure to encode
-  }
-  if (kIsDebugBuild) {
-    VerifyGcMap(*map);
-  }
-  MethodReference ref(dex_file_, dex_method_idx_);
-  const std::vector<uint8_t>* dex_gc_map = CreateLengthPrefixedDexGcMap(*(map.get()));
-  verifier::MethodVerifier::SetDexGcMap(ref, *dex_gc_map);
+  // Compute information for compiler.
+  if (Runtime::Current()->IsCompiler()) {
+    MethodReference ref(dex_file_, dex_method_idx_);
+    bool compile = IsCandidateForCompilation(code_item_, method_access_flags_);
+    if (compile) {
+      /* Generate a register map and add it to the method. */
+      UniquePtr<const std::vector<uint8_t> > map(GenerateGcMap());
+      if (map.get() == NULL) {
+        DCHECK_NE(failures_.size(), 0U);
+        return false;  // Not a real failure, but a failure to encode
+      }
+      if (kIsDebugBuild) {
+        VerifyGcMap(*map);
+      }
+      const std::vector<uint8_t>* dex_gc_map = CreateLengthPrefixedDexGcMap(*(map.get()));
+      verifier::MethodVerifier::SetDexGcMap(ref, *dex_gc_map);
+    }
 
-  MethodVerifier::MethodSafeCastSet* method_to_safe_casts = GenerateSafeCastSet();
-  if (method_to_safe_casts != NULL) {
-    SetSafeCastMap(ref, method_to_safe_casts);
-  }
+    if (has_check_casts_) {
+      MethodVerifier::MethodSafeCastSet* method_to_safe_casts = GenerateSafeCastSet();
+      if(method_to_safe_casts != NULL ) {
+        SetSafeCastMap(ref, method_to_safe_casts);
+      }
+    }
 
-  MethodVerifier::PcToConcreteMethodMap* pc_to_concrete_method = GenerateDevirtMap();
-  if (pc_to_concrete_method != NULL) {
-    SetDevirtMap(ref, pc_to_concrete_method);
+    if (has_virtual_or_interface_invokes_) {
+      MethodVerifier::PcToConcreteMethodMap* pc_to_concrete_method = GenerateDevirtMap();
+      if(pc_to_concrete_method != NULL ) {
+        SetDevirtMap(ref, pc_to_concrete_method);
+      }
+    }
   }
   return true;
 }
@@ -3948,6 +3967,7 @@ void MethodVerifier::VerifyGcMap(const std::vector<uint8_t>& data) {
 }
 
 void MethodVerifier::SetDexGcMap(MethodReference ref, const std::vector<uint8_t>& gc_map) {
+  DCHECK(Runtime::Current()->IsCompiler());
   {
     WriterMutexLock mu(Thread::Current(), *dex_gc_maps_lock_);
     DexGcMapTable::iterator it = dex_gc_maps_->find(ref);
@@ -3962,6 +3982,7 @@ void MethodVerifier::SetDexGcMap(MethodReference ref, const std::vector<uint8_t>
 
 
 void  MethodVerifier::SetSafeCastMap(MethodReference ref, const MethodSafeCastSet* cast_set) {
+  DCHECK(Runtime::Current()->IsCompiler());
   MutexLock mu(Thread::Current(), *safecast_map_lock_);
   SafeCastMap::iterator it = safecast_map_->find(ref);
   if (it != safecast_map_->end()) {
@@ -3970,10 +3991,11 @@ void  MethodVerifier::SetSafeCastMap(MethodReference ref, const MethodSafeCastSe
   }
 
   safecast_map_->Put(ref, cast_set);
-  CHECK(safecast_map_->find(ref) != safecast_map_->end());
+  DCHECK(safecast_map_->find(ref) != safecast_map_->end());
 }
 
 bool MethodVerifier::IsSafeCast(MethodReference ref, uint32_t pc) {
+  DCHECK(Runtime::Current()->IsCompiler());
   MutexLock mu(Thread::Current(), *safecast_map_lock_);
   SafeCastMap::const_iterator it = safecast_map_->find(ref);
   if (it == safecast_map_->end()) {
@@ -3986,6 +4008,7 @@ bool MethodVerifier::IsSafeCast(MethodReference ref, uint32_t pc) {
 }
 
 const std::vector<uint8_t>* MethodVerifier::GetDexGcMap(MethodReference ref) {
+  DCHECK(Runtime::Current()->IsCompiler());
   ReaderMutexLock mu(Thread::Current(), *dex_gc_maps_lock_);
   DexGcMapTable::const_iterator it = dex_gc_maps_->find(ref);
   if (it == dex_gc_maps_->end()) {
@@ -3998,6 +4021,7 @@ const std::vector<uint8_t>* MethodVerifier::GetDexGcMap(MethodReference ref) {
 
 void  MethodVerifier::SetDevirtMap(MethodReference ref,
                                    const PcToConcreteMethodMap* devirt_map) {
+  DCHECK(Runtime::Current()->IsCompiler());
   WriterMutexLock mu(Thread::Current(), *devirt_maps_lock_);
   DevirtualizationMapTable::iterator it = devirt_maps_->find(ref);
   if (it != devirt_maps_->end()) {
@@ -4006,11 +4030,12 @@ void  MethodVerifier::SetDevirtMap(MethodReference ref,
   }
 
   devirt_maps_->Put(ref, devirt_map);
-  CHECK(devirt_maps_->find(ref) != devirt_maps_->end());
+  DCHECK(devirt_maps_->find(ref) != devirt_maps_->end());
 }
 
 const MethodReference* MethodVerifier::GetDevirtMap(const MethodReference& ref,
                                                                     uint32_t dex_pc) {
+  DCHECK(Runtime::Current()->IsCompiler());
   ReaderMutexLock mu(Thread::Current(), *devirt_maps_lock_);
   DevirtualizationMapTable::const_iterator it = devirt_maps_->find(ref);
   if (it == devirt_maps_->end()) {
@@ -4070,6 +4095,24 @@ std::vector<int32_t> MethodVerifier::DescribeVRegs(uint32_t dex_pc) {
   return result;
 }
 
+bool MethodVerifier::IsCandidateForCompilation(const DexFile::CodeItem* code_item,
+                                               const uint32_t access_flags) {
+  // Don't compile class initializers, ever.
+  if (((access_flags & kAccConstructor) != 0) && ((access_flags & kAccStatic) != 0)) {
+    return false;
+  }
+
+  const Runtime* runtime = Runtime::Current();
+  if (runtime->IsSmallMode() && runtime->UseCompileTimeClassPath()) {
+    // In Small mode, we only compile small methods.
+    const uint32_t code_size = code_item->insns_size_in_code_units_;
+    return (code_size < runtime->GetSmallModeMethodDexSizeLimit());
+  } else {
+    // In normal mode, we compile everything.
+    return true;
+  }
+}
+
 ReaderWriterMutex* MethodVerifier::dex_gc_maps_lock_ = NULL;
 MethodVerifier::DexGcMapTable* MethodVerifier::dex_gc_maps_ = NULL;
 
@@ -4083,65 +4126,79 @@ Mutex* MethodVerifier::rejected_classes_lock_ = NULL;
 MethodVerifier::RejectedClassesTable* MethodVerifier::rejected_classes_ = NULL;
 
 void MethodVerifier::Init() {
-  dex_gc_maps_lock_ = new ReaderWriterMutex("verifier GC maps lock");
-  Thread* self = Thread::Current();
-  {
-    WriterMutexLock mu(self, *dex_gc_maps_lock_);
-    dex_gc_maps_ = new MethodVerifier::DexGcMapTable;
-  }
+  if (Runtime::Current()->IsCompiler()) {
+    dex_gc_maps_lock_ = new ReaderWriterMutex("verifier GC maps lock");
+    Thread* self = Thread::Current();
+    {
+      WriterMutexLock mu(self, *dex_gc_maps_lock_);
+      dex_gc_maps_ = new MethodVerifier::DexGcMapTable;
+    }
 
-  safecast_map_lock_ = new Mutex("verifier Cast Elision lock");
-  {
-    MutexLock mu(self, *safecast_map_lock_);
-    safecast_map_ = new MethodVerifier::SafeCastMap();
-  }
+    safecast_map_lock_ = new Mutex("verifier Cast Elision lock");
+    {
+      MutexLock mu(self, *safecast_map_lock_);
+      safecast_map_ = new MethodVerifier::SafeCastMap();
+    }
 
-  devirt_maps_lock_ = new ReaderWriterMutex("verifier Devirtualization lock");
+    devirt_maps_lock_ = new ReaderWriterMutex("verifier Devirtualization lock");
 
-  {
-    WriterMutexLock mu(self, *devirt_maps_lock_);
-    devirt_maps_ = new MethodVerifier::DevirtualizationMapTable();
-  }
+    {
+      WriterMutexLock mu(self, *devirt_maps_lock_);
+      devirt_maps_ = new MethodVerifier::DevirtualizationMapTable();
+    }
 
-  rejected_classes_lock_ = new Mutex("verifier rejected classes lock");
-  {
-    MutexLock mu(self, *rejected_classes_lock_);
-    rejected_classes_ = new MethodVerifier::RejectedClassesTable;
+    rejected_classes_lock_ = new Mutex("verifier rejected classes lock");
+    {
+      MutexLock mu(self, *rejected_classes_lock_);
+      rejected_classes_ = new MethodVerifier::RejectedClassesTable;
+    }
   }
   art::verifier::RegTypeCache::Init();
 }
 
 void MethodVerifier::Shutdown() {
-  Thread* self = Thread::Current();
-  {
-    WriterMutexLock mu(self, *dex_gc_maps_lock_);
-    STLDeleteValues(dex_gc_maps_);
-    delete dex_gc_maps_;
-    dex_gc_maps_ = NULL;
-  }
-  delete dex_gc_maps_lock_;
-  dex_gc_maps_lock_ = NULL;
-
-  {
-    WriterMutexLock mu(self, *devirt_maps_lock_);
-    STLDeleteValues(devirt_maps_);
-    delete devirt_maps_;
-    devirt_maps_ = NULL;
-  }
-  delete devirt_maps_lock_;
-  devirt_maps_lock_ = NULL;
-
-  {
-    MutexLock mu(self, *rejected_classes_lock_);
-    delete rejected_classes_;
-    rejected_classes_ = NULL;
+  if (Runtime::Current()->IsCompiler()) {
+    Thread* self = Thread::Current();
+    {
+      WriterMutexLock mu(self, *dex_gc_maps_lock_);
+      STLDeleteValues(dex_gc_maps_);
+      delete dex_gc_maps_;
+      dex_gc_maps_ = NULL;
+    }
+    delete dex_gc_maps_lock_;
+    dex_gc_maps_lock_ = NULL;
+
+    {
+      MutexLock mu(self, *safecast_map_lock_);
+      STLDeleteValues(safecast_map_);
+      delete safecast_map_;
+      safecast_map_ = NULL;
+    }
+    delete safecast_map_lock_;
+    safecast_map_lock_ = NULL;
+
+    {
+      WriterMutexLock mu(self, *devirt_maps_lock_);
+      STLDeleteValues(devirt_maps_);
+      delete devirt_maps_;
+      devirt_maps_ = NULL;
+    }
+    delete devirt_maps_lock_;
+    devirt_maps_lock_ = NULL;
+
+    {
+      MutexLock mu(self, *rejected_classes_lock_);
+      delete rejected_classes_;
+      rejected_classes_ = NULL;
+    }
+    delete rejected_classes_lock_;
+    rejected_classes_lock_ = NULL;
   }
-  delete rejected_classes_lock_;
-  rejected_classes_lock_ = NULL;
   verifier::RegTypeCache::ShutDown();
 }
 
 void MethodVerifier::AddRejectedClass(ClassReference ref) {
+  DCHECK(Runtime::Current()->IsCompiler());
   {
     MutexLock mu(Thread::Current(), *rejected_classes_lock_);
     rejected_classes_->insert(ref);
@@ -4150,6 +4207,7 @@ void MethodVerifier::AddRejectedClass(ClassReference ref) {
 }
 
 bool MethodVerifier::IsClassRejected(ClassReference ref) {
+  DCHECK(Runtime::Current()->IsCompiler());
   MutexLock mu(Thread::Current(), *rejected_classes_lock_);
   return (rejected_classes_->find(ref) != rejected_classes_->end());
 }
diff --git a/runtime/verifier/method_verifier.h b/runtime/verifier/method_verifier.h
index 57d630de5a..fdd90cc767 100644
--- a/runtime/verifier/method_verifier.h
+++ b/runtime/verifier/method_verifier.h
@@ -237,6 +237,9 @@ class MethodVerifier {
   // Describe VRegs at the given dex pc.
   std::vector<int32_t> DescribeVRegs(uint32_t dex_pc);
 
+  static bool IsCandidateForCompilation(const DexFile::CodeItem* code_item,
+                                        const uint32_t access_flags);
+
  private:
   // Adds the given string to the beginning of the last failure message.
   void PrependToLastFailMessage(std::string);
@@ -654,7 +657,7 @@ class MethodVerifier {
         LOCKS_EXCLUDED(devirt_maps_lock_);
   typedef std::set<ClassReference> RejectedClassesTable;
   static Mutex* rejected_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
-  static RejectedClassesTable* rejected_classes_;
+  static RejectedClassesTable* rejected_classes_ GUARDED_BY(rejected_classes_lock_);
 
   static void AddRejectedClass(ClassReference ref)
       LOCKS_EXCLUDED(rejected_classes_lock_);
@@ -717,6 +720,13 @@ class MethodVerifier {
   // Converts soft failures to hard failures when false. Only false when the compiler isn't
   // running and the verifier is called from the class linker.
   const bool allow_soft_failures_;
+
+  // Indicates if the method being verified contains at least one check-cast instruction.
+  bool has_check_casts_;
+
+  // Indicates if the method being verified contains at least one invoke-virtual/range
+  // or invoke-interface/range.
+  bool has_virtual_or_interface_invokes_;
 };
 std::ostream& operator<<(std::ostream& os, const MethodVerifier::FailureKind& rhs);
 
-- 
cgit v1.2.3-59-g8ed1b


From 7934ac288acfb2552bb0b06ec1f61e5820d924a4 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 26 Jul 2013 10:54:15 -0700
Subject: Fix cpplint whitespace/comments issues

Change-Id: Iae286862c85fb8fd8901eae1204cd6d271d69496
---
 build/Android.cpplint.mk                           |   2 +-
 compiler/dex/arena_allocator.h                     |   2 +-
 compiler/dex/compiler_enums.h                      |  20 +-
 compiler/dex/dataflow_iterator.h                   |   2 +-
 compiler/dex/dex_to_dex_compiler.cc                |   4 +-
 compiler/dex/frontend.cc                           |  56 +-
 compiler/dex/frontend.h                            |   2 +-
 compiler/dex/local_value_numbering.h               |   2 +-
 compiler/dex/mir_graph.cc                          |  12 +-
 compiler/dex/mir_graph.h                           |   6 +-
 compiler/dex/mir_optimization.cc                   |   2 +-
 compiler/dex/portable/mir_to_gbc.cc                |   6 +-
 compiler/dex/quick/arm/arm_lir.h                   |  28 +-
 compiler/dex/quick/arm/call_arm.cc                 |   6 +-
 compiler/dex/quick/arm/fp_arm.cc                   |   2 +-
 compiler/dex/quick/arm/int_arm.cc                  |  16 +-
 compiler/dex/quick/arm/target_arm.cc               |   2 +-
 compiler/dex/quick/arm/utility_arm.cc              |   6 +-
 compiler/dex/quick/codegen_util.cc                 |   2 +-
 compiler/dex/quick/gen_common.cc                   |  10 +-
 compiler/dex/quick/gen_invoke.cc                   |  14 +-
 compiler/dex/quick/mips/call_mips.cc               |   2 +-
 compiler/dex/quick/mips/fp_mips.cc                 |   4 +-
 compiler/dex/quick/mips/int_mips.cc                |   6 +-
 compiler/dex/quick/mips/mips_lir.h                 |  58 +-
 compiler/dex/quick/mips/target_mips.cc             |   4 +-
 compiler/dex/quick/mips/utility_mips.cc            |   2 +-
 compiler/dex/quick/mir_to_lir.h                    |   4 +-
 compiler/dex/quick/ralloc_util.cc                  |  10 +-
 compiler/dex/quick/x86/assemble_x86.cc             |   4 +-
 compiler/dex/quick/x86/call_x86.cc                 |   2 +-
 compiler/dex/quick/x86/fp_x86.cc                   |   2 +-
 compiler/dex/quick/x86/target_x86.cc               |   4 +-
 compiler/dex/quick/x86/utility_x86.cc              |  10 +-
 compiler/dex/quick/x86/x86_lir.h                   |  36 +-
 compiler/dex/ssa_transformation.cc                 |   8 +-
 compiler/dex/vreg_analysis.cc                      |   2 +-
 compiler/driver/compiler_driver.cc                 | 808 ++++++++++-----------
 compiler/driver/dex_compilation_unit.cc            |   2 +-
 compiler/driver/dex_compilation_unit.h             |   2 +-
 compiler/elf_fixup.cc                              |  32 +-
 compiler/elf_writer_mclinker.h                     |   2 +-
 compiler/elf_writer_quick.cc                       |   4 +-
 compiler/image_writer.cc                           |   6 +-
 compiler/jni/portable/jni_compiler.cc              |  14 +-
 compiler/llvm/backend_types.h                      |   4 +-
 compiler/llvm/compiler_llvm.cc                     |   8 +-
 compiler/llvm/compiler_llvm.h                      |   4 +-
 compiler/llvm/gbc_expander.cc                      |  46 +-
 compiler/llvm/generated/art_module.cc              | 132 ++--
 compiler/llvm/intrinsic_helper.cc                  |   4 +-
 compiler/llvm/intrinsic_helper.h                   |   4 +-
 compiler/llvm/ir_builder.cc                        |   4 +-
 compiler/llvm/ir_builder.h                         |   4 +-
 compiler/llvm/llvm_compilation_unit.cc             |  12 +-
 compiler/llvm/llvm_compilation_unit.h              |   6 +-
 compiler/llvm/md_builder.cc                        |   4 +-
 compiler/llvm/md_builder.h                         |   4 +-
 compiler/llvm/runtime_support_builder.cc           |   4 +-
 compiler/llvm/runtime_support_builder.h            |   4 +-
 compiler/llvm/runtime_support_builder_arm.cc       |   6 +-
 compiler/llvm/runtime_support_builder_arm.h        |   4 +-
 compiler/llvm/runtime_support_builder_thumb2.cc    |   6 +-
 compiler/llvm/runtime_support_builder_thumb2.h     |   4 +-
 compiler/llvm/runtime_support_builder_x86.cc       |   4 +-
 compiler/llvm/runtime_support_builder_x86.h        |   4 +-
 compiler/llvm/runtime_support_llvm_func.h          |   6 +-
 compiler/sea_ir/code_gen.cc                        |   4 +-
 compiler/sea_ir/code_gen.h                         |   8 +-
 compiler/sea_ir/frontend.cc                        |   4 +-
 compiler/sea_ir/instruction_nodes.h                |   6 +-
 compiler/sea_ir/instruction_tools.cc               |   2 +-
 compiler/sea_ir/instruction_tools.h                |   2 +-
 compiler/sea_ir/sea.cc                             |  28 +-
 compiler/sea_ir/sea.h                              |   4 +-
 compiler/sea_ir/sea_node.h                         |   2 +-
 compiler/sea_ir/visitor.h                          |   4 +-
 compiler/stubs/portable/stubs.cc                   |  14 +-
 compiler/stubs/quick/stubs.cc                      |  12 +-
 compiler/utils/scoped_hashtable.h                  |   2 +-
 compiler/utils/scoped_hashtable_test.cc            |   2 +-
 dalvikvm/dalvikvm.cc                               |   2 +-
 dex2oat/dex2oat.cc                                 |   6 +-
 jdwpspy/Net.cpp                                    |   2 +-
 oatdump/oatdump.cc                                 |   2 +-
 runtime/base/histogram_test.cc                     |  28 +-
 runtime/base/logging.cc                            |   2 +-
 runtime/base/logging.h                             |   4 +-
 runtime/base/macros.h                              |   2 +-
 runtime/base/mutex-inl.h                           |   2 +-
 runtime/base/mutex.cc                              |  10 +-
 runtime/base/unix_file/mapped_file_test.cc         |   2 +-
 runtime/check_jni.cc                               |  56 +-
 runtime/class_linker.cc                            |   6 +-
 runtime/class_linker.h                             |   4 +-
 runtime/common_test.h                              |   8 +-
 runtime/compiled_method.cc                         |   2 +-
 runtime/debugger.cc                                |  44 +-
 runtime/debugger.h                                 |   2 +-
 runtime/dex_file.cc                                |   2 +-
 runtime/dex_file.h                                 |   2 +-
 runtime/dex_file_verifier.cc                       |   2 +-
 runtime/dex_instruction-inl.h                      |   8 +-
 runtime/dex_instruction.cc                         |   8 +-
 runtime/dex_instruction.h                          |   4 +-
 runtime/dex_instruction_list.h                     |   2 +-
 runtime/disassembler_arm.cc                        |  52 +-
 runtime/disassembler_mips.cc                       |  42 +-
 runtime/disassembler_x86.cc                        |   2 +-
 runtime/exception_test.cc                          |   2 +-
 runtime/gc/accounting/card_table.cc                |   2 +-
 runtime/gc/accounting/space_bitmap-inl.h           |   2 +-
 runtime/gc/collector/mark_sweep.cc                 |   4 +-
 runtime/gc/collector/mark_sweep.h                  |   2 +-
 runtime/gc/heap.cc                                 |   2 +-
 runtime/gc/space/dlmalloc_space.cc                 |   4 +-
 runtime/gc/space/space.h                           |   2 +-
 runtime/hprof/hprof.cc                             |  18 +-
 runtime/indirect_reference_table.cc                |   2 +-
 runtime/indirect_reference_table.h                 |   8 +-
 runtime/instrumentation.cc                         |  14 +-
 runtime/intern_table.cc                            |   8 +-
 runtime/intern_table_test.cc                       |   2 +-
 runtime/interpreter/interpreter.cc                 |   6 +-
 runtime/invoke_type.h                              |  10 +-
 runtime/jdwp/jdwp.h                                |   8 +-
 runtime/jdwp/jdwp_constants.h                      |   8 +-
 runtime/jdwp/jdwp_event.cc                         |   6 +-
 runtime/jdwp/jdwp_handler.cc                       |   6 +-
 runtime/jdwp/jdwp_priv.h                           |   4 +-
 runtime/jdwp/jdwp_request.cc                       |   2 +-
 runtime/jdwp/object_registry.cc                    |   6 +-
 runtime/jni_internal.cc                            |  26 +-
 runtime/jvalue.h                                   |   4 +-
 runtime/locks.h                                    |   2 +-
 runtime/log_severity.h                             |   2 +-
 runtime/mem_map.cc                                 |   6 +-
 runtime/mirror/dex_cache.h                         |   2 +-
 runtime/mirror/field.cc                            |   2 +-
 runtime/mirror/throwable.h                         |   2 +-
 runtime/monitor.cc                                 |   6 +-
 runtime/native/dalvik_system_VMDebug.cc            |   4 +-
 runtime/native/dalvik_system_Zygote.cc             |   2 +-
 runtime/native/java_lang_Thread.cc                 |   2 +-
 runtime/oat/runtime/arm/context_arm.cc             |   2 +-
 runtime/oat/runtime/mips/context_mips.cc           |   2 +-
 runtime/oat/runtime/support_interpreter.cc         |   2 +-
 runtime/oat/runtime/support_jni.cc                 |   2 +-
 runtime/oat/runtime/support_stubs.cc               |   4 +-
 .../oat/runtime/x86/oat_support_entrypoints_x86.cc |  12 +-
 runtime/oat_test.cc                                |   2 +-
 runtime/reference_table.cc                         |   2 +-
 runtime/reference_table.h                          |   2 +-
 runtime/reflection.cc                              |   2 +-
 runtime/runtime.cc                                 |  32 +-
 runtime/runtime_linux.cc                           |   2 +-
 runtime/runtime_support.cc                         |   8 +-
 runtime/runtime_support_llvm_func_list.h           |   2 +-
 runtime/safe_map.h                                 |   2 +-
 runtime/scoped_thread_state_change.h               |   2 +-
 runtime/signal_catcher.cc                          |   2 +-
 runtime/stack.cc                                   |   8 +-
 runtime/stack.h                                    |   6 +-
 runtime/thread.cc                                  |  20 +-
 runtime/thread.h                                   |   6 +-
 runtime/thread_linux.cc                            |   2 +-
 runtime/thread_list.cc                             |   6 +-
 runtime/thread_list.h                              |   4 +-
 runtime/thread_state.h                             |  40 +-
 runtime/trace.cc                                   |  14 +-
 runtime/utils.cc                                   |  34 +-
 runtime/verifier/dex_gc_map.h                      |   6 +-
 runtime/verifier/method_verifier.cc                |  16 +-
 runtime/verifier/method_verifier.h                 |  22 +-
 runtime/verifier/reg_type_cache.cc                 |   2 +-
 runtime/verifier/reg_type_test.cc                  |   2 +-
 runtime/zip_archive.cc                             |   2 +-
 test/ReferenceMap/stack_walk_refmap_jni.cc         |  44 +-
 test/StackWalk/stack_walk_jni.cc                   |   2 +-
 179 files changed, 1208 insertions(+), 1208 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/build/Android.cpplint.mk b/build/Android.cpplint.mk
index eabaf31cca..adb87cb4e9 100644
--- a/build/Android.cpplint.mk
+++ b/build/Android.cpplint.mk
@@ -15,7 +15,7 @@
 #
 
 ART_CPPLINT := art/tools/cpplint.py
-ART_CPPLINT_FILTER := --filter=-whitespace/comments,-whitespace/line_length,-build/include,-readability/function,-readability/streams,-readability/todo,-runtime/references,-runtime/sizeof,-runtime/threadsafe_fn,-runtime/printf
+ART_CPPLINT_FILTER := --filter=-whitespace/line_length,-build/include,-readability/function,-readability/streams,-readability/todo,-runtime/references,-runtime/sizeof,-runtime/threadsafe_fn,-runtime/printf
 ART_CPPLINT_SRC := $(shell find art -name *.h -o -name *$(ART_CPP_EXTENSION) | grep -v art/compiler/llvm/generated/)
 
 # "mm cpplint-art" to verify we aren't regressing
diff --git a/compiler/dex/arena_allocator.h b/compiler/dex/arena_allocator.h
index 3bd733e753..e8e2c027d0 100644
--- a/compiler/dex/arena_allocator.h
+++ b/compiler/dex/arena_allocator.h
@@ -86,7 +86,7 @@ struct MemStats {
      explicit MemStats(const ArenaAllocator &arena) : arena_(arena) {}
   private:
     const ArenaAllocator &arena_;
-}; // MemStats
+};  // MemStats
 
 }  // namespace art
 
diff --git a/compiler/dex/compiler_enums.h b/compiler/dex/compiler_enums.h
index 88240e8c40..97a682f2aa 100644
--- a/compiler/dex/compiler_enums.h
+++ b/compiler/dex/compiler_enums.h
@@ -48,7 +48,7 @@ enum SpecialTargetRegister {
 };
 
 enum RegLocationType {
-  kLocDalvikFrame = 0, // Normal Dalvik register
+  kLocDalvikFrame = 0,  // Normal Dalvik register
   kLocPhysReg,
   kLocCompilerTemp,
   kLocInvalid
@@ -249,20 +249,20 @@ enum X86ConditionCode {
   kX86CondC   = kX86CondB,  // carry
 
   kX86CondNb  = 0x3,    // not-below
-  kX86CondAe  = kX86CondNb, // above-equal
-  kX86CondNc  = kX86CondNb, // not-carry
+  kX86CondAe  = kX86CondNb,  // above-equal
+  kX86CondNc  = kX86CondNb,  // not-carry
 
   kX86CondZ   = 0x4,    // zero
   kX86CondEq  = kX86CondZ,  // equal
 
   kX86CondNz  = 0x5,    // not-zero
-  kX86CondNe  = kX86CondNz, // not-equal
+  kX86CondNe  = kX86CondNz,  // not-equal
 
   kX86CondBe  = 0x6,    // below-equal
-  kX86CondNa  = kX86CondBe, // not-above
+  kX86CondNa  = kX86CondBe,  // not-above
 
   kX86CondNbe = 0x7,    // not-below-equal
-  kX86CondA   = kX86CondNbe,// above
+  kX86CondA   = kX86CondNbe,  // above
 
   kX86CondS   = 0x8,    // sign
   kX86CondNs  = 0x9,    // not-sign
@@ -277,13 +277,13 @@ enum X86ConditionCode {
   kX86CondNge = kX86CondL,  // not-greater-equal
 
   kX86CondNl  = 0xd,    // not-less-than
-  kX86CondGe  = kX86CondNl, // not-greater-equal
+  kX86CondGe  = kX86CondNl,  // not-greater-equal
 
   kX86CondLe  = 0xe,    // less-than-equal
-  kX86CondNg  = kX86CondLe, // not-greater
+  kX86CondNg  = kX86CondLe,  // not-greater
 
   kX86CondNle = 0xf,    // not-less-than
-  kX86CondG   = kX86CondNle,// greater
+  kX86CondG   = kX86CondNle,  // greater
 };
 
 std::ostream& operator<<(std::ostream& os, const X86ConditionCode& kind);
@@ -349,7 +349,7 @@ enum OpFeatureFlags {
   kIsIT,
   kMemLoad,
   kMemStore,
-  kPCRelFixup, // x86 FIXME: add NEEDS_FIXUP to instruction attributes.
+  kPCRelFixup,  // x86 FIXME: add NEEDS_FIXUP to instruction attributes.
   kRegDef0,
   kRegDef1,
   kRegDefA,
diff --git a/compiler/dex/dataflow_iterator.h b/compiler/dex/dataflow_iterator.h
index 847a614727..da44ffd99c 100644
--- a/compiler/dex/dataflow_iterator.h
+++ b/compiler/dex/dataflow_iterator.h
@@ -80,7 +80,7 @@ namespace art {
       GrowableArray<int>* block_id_list_;
       int idx_;
       bool changed_;
-  }; // DataflowIterator
+  };  // DataflowIterator
 
   class ReachableNodesIterator : public DataflowIterator {
     public:
diff --git a/compiler/dex/dex_to_dex_compiler.cc b/compiler/dex/dex_to_dex_compiler.cc
index 28c325726e..3c491ce20f 100644
--- a/compiler/dex/dex_to_dex_compiler.cc
+++ b/compiler/dex/dex_to_dex_compiler.cc
@@ -240,12 +240,12 @@ Instruction* DexCompiler::CompileCheckCast(Instruction* inst, uint32_t dex_pc) {
   // We are modifying 4 consecutive bytes.
   ScopedDexWriteAccess sdwa(GetModifiableDexFile(), inst, 4u);
   inst->SetOpcode(Instruction::NOP);
-  inst->SetVRegA_10x(0u); // keep compliant with verifier.
+  inst->SetVRegA_10x(0u);  // keep compliant with verifier.
   // Get to next instruction which is the second half of check-cast and replace
   // it by a NOP.
   inst = const_cast<Instruction*>(inst->Next());
   inst->SetOpcode(Instruction::NOP);
-  inst->SetVRegA_10x(0u); // keep compliant with verifier.
+  inst->SetVRegA_10x(0u);  // keep compliant with verifier.
   return inst;
 }
 
diff --git a/compiler/dex/frontend.cc b/compiler/dex/frontend.cc
index 113a80a96c..9cc4d18d37 100644
--- a/compiler/dex/frontend.cc
+++ b/compiler/dex/frontend.cc
@@ -72,37 +72,37 @@ extern "C" void ArtUnInitQuickCompilerContext(art::CompilerDriver& compiler) {
 }
 
 /* Default optimizer/debug setting for the compiler. */
-static uint32_t kCompilerOptimizerDisableFlags = 0 | // Disable specific optimizations
+static uint32_t kCompilerOptimizerDisableFlags = 0 |  // Disable specific optimizations
   (1 << kLoadStoreElimination) |
-  //(1 << kLoadHoisting) |
-  //(1 << kSuppressLoads) |
-  //(1 << kNullCheckElimination) |
-  //(1 << kPromoteRegs) |
-  //(1 << kTrackLiveTemps) |
-  //(1 << kSafeOptimizations) |
-  //(1 << kBBOpt) |
-  //(1 << kMatch) |
-  //(1 << kPromoteCompilerTemps) |
+  // (1 << kLoadHoisting) |
+  // (1 << kSuppressLoads) |
+  // (1 << kNullCheckElimination) |
+  // (1 << kPromoteRegs) |
+  // (1 << kTrackLiveTemps) |
+  // (1 << kSafeOptimizations) |
+  // (1 << kBBOpt) |
+  // (1 << kMatch) |
+  // (1 << kPromoteCompilerTemps) |
   0;
 
 static uint32_t kCompilerDebugFlags = 0 |     // Enable debug/testing modes
-  //(1 << kDebugDisplayMissingTargets) |
-  //(1 << kDebugVerbose) |
-  //(1 << kDebugDumpCFG) |
-  //(1 << kDebugSlowFieldPath) |
-  //(1 << kDebugSlowInvokePath) |
-  //(1 << kDebugSlowStringPath) |
-  //(1 << kDebugSlowestFieldPath) |
-  //(1 << kDebugSlowestStringPath) |
-  //(1 << kDebugExerciseResolveMethod) |
-  //(1 << kDebugVerifyDataflow) |
-  //(1 << kDebugShowMemoryUsage) |
-  //(1 << kDebugShowNops) |
-  //(1 << kDebugCountOpcodes) |
-  //(1 << kDebugDumpCheckStats) |
-  //(1 << kDebugDumpBitcodeFile) |
-  //(1 << kDebugVerifyBitcode) |
-  //(1 << kDebugShowSummaryMemoryUsage) |
+  // (1 << kDebugDisplayMissingTargets) |
+  // (1 << kDebugVerbose) |
+  // (1 << kDebugDumpCFG) |
+  // (1 << kDebugSlowFieldPath) |
+  // (1 << kDebugSlowInvokePath) |
+  // (1 << kDebugSlowStringPath) |
+  // (1 << kDebugSlowestFieldPath) |
+  // (1 << kDebugSlowestStringPath) |
+  // (1 << kDebugExerciseResolveMethod) |
+  // (1 << kDebugVerifyDataflow) |
+  // (1 << kDebugShowMemoryUsage) |
+  // (1 << kDebugShowNops) |
+  // (1 << kDebugCountOpcodes) |
+  // (1 << kDebugDumpCheckStats) |
+  // (1 << kDebugDumpBitcodeFile) |
+  // (1 << kDebugVerifyBitcode) |
+  // (1 << kDebugShowSummaryMemoryUsage) |
   0;
 
 static CompiledMethod* CompileMethod(CompilerDriver& compiler,
@@ -277,7 +277,7 @@ CompiledMethod* CompileOneMethod(CompilerDriver& compiler,
 #if defined(ART_USE_PORTABLE_COMPILER)
                        , llvm_compilation_unit
 #endif
-                       ); // NOLINT(whitespace/parens)
+                       );  // NOLINT(whitespace/parens)
 }
 
 }  // namespace art
diff --git a/compiler/dex/frontend.h b/compiler/dex/frontend.h
index a86338950c..5c68ab4244 100644
--- a/compiler/dex/frontend.h
+++ b/compiler/dex/frontend.h
@@ -102,7 +102,7 @@ class LLVMInfo {
 
   private:
     UniquePtr< ::llvm::LLVMContext> llvm_context_;
-    ::llvm::Module* llvm_module_; // Managed by context_.
+    ::llvm::Module* llvm_module_;  // Managed by context_.
     UniquePtr<art::llvm::IntrinsicHelper> intrinsic_helper_;
     UniquePtr<art::llvm::IRBuilder> ir_builder_;
 };
diff --git a/compiler/dex/local_value_numbering.h b/compiler/dex/local_value_numbering.h
index e3fd7ad2da..33ca8f1ad8 100644
--- a/compiler/dex/local_value_numbering.h
+++ b/compiler/dex/local_value_numbering.h
@@ -137,6 +137,6 @@ class LocalValueNumbering {
   std::set<uint16_t> null_checked_;
 };
 
-} // namespace art
+}  // namespace art
 
 #endif  // ART_COMPILER_DEX_LOCAL_VALUE_NUMBERING_H_
diff --git a/compiler/dex/mir_graph.cc b/compiler/dex/mir_graph.cc
index 264604c355..6b010ed9b3 100644
--- a/compiler/dex/mir_graph.cc
+++ b/compiler/dex/mir_graph.cc
@@ -972,23 +972,23 @@ char* MIRGraph::GetDalvikDisassembly(const MIR* mir) {
       }
     }
     switch (dalvik_format) {
-      case Instruction::k11n: // Add one immediate from vB
+      case Instruction::k11n:  // Add one immediate from vB
       case Instruction::k21s:
       case Instruction::k31i:
       case Instruction::k21h:
         str.append(StringPrintf(", #%d", insn.vB));
         break;
-      case Instruction::k51l: // Add one wide immediate
+      case Instruction::k51l:  // Add one wide immediate
         str.append(StringPrintf(", #%lld", insn.vB_wide));
         break;
-      case Instruction::k21c: // One register, one string/type/method index
+      case Instruction::k21c:  // One register, one string/type/method index
       case Instruction::k31c:
         str.append(StringPrintf(", index #%d", insn.vB));
         break;
-      case Instruction::k22c: // Two registers, one string/type/method index
+      case Instruction::k22c:  // Two registers, one string/type/method index
         str.append(StringPrintf(", index #%d", insn.vC));
         break;
-      case Instruction::k22s: // Add one immediate from vC
+      case Instruction::k22s:  // Add one immediate from vC
       case Instruction::k22b:
         str.append(StringPrintf(", #%d", insn.vC));
         break;
@@ -1154,4 +1154,4 @@ BasicBlock* MIRGraph::NewMemBB(BBType block_type, int block_id) {
   return bb;
 }
 
-} // namespace art
+}  // namespace art
diff --git a/compiler/dex/mir_graph.h b/compiler/dex/mir_graph.h
index 342d2a296a..e9ec949f23 100644
--- a/compiler/dex/mir_graph.h
+++ b/compiler/dex/mir_graph.h
@@ -273,7 +273,7 @@ struct RegLocation {
   unsigned fp:1;        // Floating point?
   unsigned core:1;      // Non-floating point?
   unsigned ref:1;       // Something GC cares about.
-  unsigned high_word:1; // High word of pair?
+  unsigned high_word:1;  // High word of pair?
   unsigned home:1;      // Does this represent the home location?
   uint8_t low_reg;      // First physical register.
   uint8_t high_reg;     // 2nd physical register (if wide).
@@ -650,7 +650,7 @@ class MIRGraph {
   BasicBlock* cur_block_;
   int num_blocks_;
   const DexFile::CodeItem* current_code_item_;
-  SafeMap<unsigned int, BasicBlock*> block_map_; // FindBlock lookup cache.
+  SafeMap<unsigned int, BasicBlock*> block_map_;  // FindBlock lookup cache.
   std::vector<DexCompilationUnit*> m_units_;     // List of methods included in this graph
   typedef std::pair<int, int> MIRLocation;       // Insert point, (m_unit_ index, offset)
   std::vector<MIRLocation> method_stack_;        // Include stack
@@ -659,7 +659,7 @@ class MIRGraph {
   int def_count_;                                // Used to estimate size of ssa name storage.
   int* opcode_count_;                            // Dex opcode coverage stats.
   int num_ssa_regs_;                             // Number of names following SSA transformation.
-  std::vector<BasicBlock*> extended_basic_blocks_; // Heads of block "traces".
+  std::vector<BasicBlock*> extended_basic_blocks_;  // Heads of block "traces".
   int method_sreg_;
   unsigned int attributes_;
   Checkstats* checkstats_;
diff --git a/compiler/dex/mir_optimization.cc b/compiler/dex/mir_optimization.cc
index d79b26e4b9..a6314f4cab 100644
--- a/compiler/dex/mir_optimization.cc
+++ b/compiler/dex/mir_optimization.cc
@@ -845,7 +845,7 @@ bool MIRGraph::BuildExtendedBBList(struct BasicBlock* bb) {
       bb = NextDominatedBlock(bb);
     }
   }
-  return false; // Not iterative - return value will be ignored
+  return false;  // Not iterative - return value will be ignored
 }
 
 
diff --git a/compiler/dex/portable/mir_to_gbc.cc b/compiler/dex/portable/mir_to_gbc.cc
index 6fc01bdff2..7831cf6f7a 100644
--- a/compiler/dex/portable/mir_to_gbc.cc
+++ b/compiler/dex/portable/mir_to_gbc.cc
@@ -1648,7 +1648,7 @@ bool MirConverter::BlockBitcodeConversion(BasicBlock* bb) {
   if (bb->block_type == kEntryBlock) {
     SetMethodInfo();
 
-    { // Allocate shadowframe.
+    {  // Allocate shadowframe.
       art::llvm::IntrinsicHelper::IntrinsicId id =
               art::llvm::IntrinsicHelper::AllocaShadowFrame;
       ::llvm::Function* func = intrinsic_helper_->GetIntrinsicFunction(id);
@@ -1656,7 +1656,7 @@ bool MirConverter::BlockBitcodeConversion(BasicBlock* bb) {
       irb_->CreateCall(func, entries);
     }
 
-    { // Store arguments to vregs.
+    {  // Store arguments to vregs.
       uint16_t arg_reg = cu_->num_regs;
 
       ::llvm::Function::arg_iterator arg_iter(func_->arg_begin());
@@ -1666,7 +1666,7 @@ bool MirConverter::BlockBitcodeConversion(BasicBlock* bb) {
       uint32_t shorty_size = strlen(shorty);
       CHECK_GE(shorty_size, 1u);
 
-      ++arg_iter; // skip method object
+      ++arg_iter;  // skip method object
 
       if ((cu_->access_flags & kAccStatic) == 0) {
         SetVregOnValue(arg_iter, arg_reg);
diff --git a/compiler/dex/quick/arm/arm_lir.h b/compiler/dex/quick/arm/arm_lir.h
index 93fee05e4e..2f54190ae7 100644
--- a/compiler/dex/quick/arm/arm_lir.h
+++ b/compiler/dex/quick/arm/arm_lir.h
@@ -239,7 +239,7 @@ enum ArmShiftEncodings {
  */
 enum ArmOpcode {
   kArmFirst = 0,
-  kArm16BitData = kArmFirst, // DATA   [0] rd[15..0].
+  kArm16BitData = kArmFirst,  // DATA   [0] rd[15..0].
   kThumbAdcRR,       // adc   [0100000101] rm[5..3] rd[2..0].
   kThumbAddRRI3,     // add(1)  [0001110] imm_3[8..6] rn[5..3] rd[2..0]*/
   kThumbAddRI8,      // add(2)  [00110] rd[10..8] imm_8[7..0].
@@ -332,12 +332,12 @@ enum ArmOpcode {
   kThumb2VcvtDF,     // vcvt.F32.F64 vd, vm [1110111010110111] vd[15..12] [10111100] vm[3..0].
   kThumb2Vsqrts,     // vsqrt.f32 vd, vm [1110111010110001] vd[15..12] [10101100] vm[3..0].
   kThumb2Vsqrtd,     // vsqrt.f64 vd, vm [1110111010110001] vd[15..12] [10111100] vm[3..0].
-  kThumb2MovImmShift,// mov(T2) rd, #<const> [11110] i [00001001111] imm3 rd[11..8] imm8.
+  kThumb2MovImmShift,  // mov(T2) rd, #<const> [11110] i [00001001111] imm3 rd[11..8] imm8.
   kThumb2MovImm16,   // mov(T3) rd, #<const> [11110] i [0010100] imm4 [0] imm3 rd[11..8] imm8.
   kThumb2StrRRI12,   // str(Imm,T3) rd,[rn,#imm12] [111110001100] rn[19..16] rt[15..12] imm12[11..0].
   kThumb2LdrRRI12,   // str(Imm,T3) rd,[rn,#imm12] [111110001100] rn[19..16] rt[15..12] imm12[11..0].
-  kThumb2StrRRI8Predec, // str(Imm,T4) rd,[rn,#-imm8] [111110000100] rn[19..16] rt[15..12] [1100] imm[7..0]*/
-  kThumb2LdrRRI8Predec, // ldr(Imm,T4) rd,[rn,#-imm8] [111110000101] rn[19..16] rt[15..12] [1100] imm[7..0]*/
+  kThumb2StrRRI8Predec,  // str(Imm,T4) rd,[rn,#-imm8] [111110000100] rn[19..16] rt[15..12] [1100] imm[7..0]*/
+  kThumb2LdrRRI8Predec,  // ldr(Imm,T4) rd,[rn,#-imm8] [111110000101] rn[19..16] rt[15..12] [1100] imm[7..0]*/
   kThumb2Cbnz,       // cbnz rd,<label> [101110] i [1] imm5[7..3] rn[2..0].
   kThumb2Cbz,        // cbn rd,<label> [101100] i [1] imm5[7..3] rn[2..0].
   kThumb2AddRRI12,   // add rd, rn, #imm12 [11110] i [100000] rn[19..16] [0] imm3[14..12] rd[11..8] imm8[7..0].
@@ -364,9 +364,9 @@ enum ArmOpcode {
   kThumb2StrhRRR,    // str rt,[rn,rm,LSL #imm] [111110000010] rn[19-16] rt[15-12] [000000] imm[5-4] rm[3-0].
   kThumb2StrbRRR,    // str rt,[rn,rm,LSL #imm] [111110000000] rn[19-16] rt[15-12] [000000] imm[5-4] rm[3-0].
   kThumb2LdrhRRI12,  // ldrh rt,[rn,#imm12] [111110001011] rt[15..12] rn[19..16] imm12[11..0].
-  kThumb2LdrshRRI12, // ldrsh rt,[rn,#imm12] [111110011011] rt[15..12] rn[19..16] imm12[11..0].
+  kThumb2LdrshRRI12,  // ldrsh rt,[rn,#imm12] [111110011011] rt[15..12] rn[19..16] imm12[11..0].
   kThumb2LdrbRRI12,  // ldrb rt,[rn,#imm12] [111110001001] rt[15..12] rn[19..16] imm12[11..0].
-  kThumb2LdrsbRRI12, // ldrsb rt,[rn,#imm12] [111110011001] rt[15..12] rn[19..16] imm12[11..0].
+  kThumb2LdrsbRRI12,  // ldrsb rt,[rn,#imm12] [111110011001] rt[15..12] rn[19..16] imm12[11..0].
   kThumb2StrhRRI12,  // strh rt,[rn,#imm12] [111110001010] rt[15..12] rn[19..16] imm12[11..0].
   kThumb2StrbRRI12,  // strb rt,[rn,#imm12] [111110001000] rt[15..12] rn[19..16] imm12[11..0].
   kThumb2Pop,        // pop   [1110100010111101] list[15-0]*/
@@ -403,7 +403,7 @@ enum ArmOpcode {
   kThumb2Fmstat,     // fmstat [11101110111100011111101000010000].
   kThumb2Vcmpd,      // vcmp [111011101] D [11011] rd[15-12] [1011] E [1] M [0] rm[3-0].
   kThumb2Vcmps,      // vcmp [111011101] D [11010] rd[15-12] [1011] E [1] M [0] rm[3-0].
-  kThumb2LdrPcRel12, // ldr rd,[pc,#imm12] [1111100011011111] rt[15-12] imm12[11-0].
+  kThumb2LdrPcRel12,  // ldr rd,[pc,#imm12] [1111100011011111] rt[15-12] imm12[11-0].
   kThumb2BCond,      // b<c> [1110] S cond[25-22] imm6[21-16] [10] J1 [0] J2 imm11[10..0].
   kThumb2Vmovd_RR,   // vmov [111011101] D [110000] vd[15-12 [101101] M [0] vm[3-0].
   kThumb2Vmovs_RR,   // vmov [111011101] D [110000] vd[15-12 [101001] M [0] vm[3-0].
@@ -415,8 +415,8 @@ enum ArmOpcode {
   kThumb2Vabss,      // vabs.f32 [111011101] D [110000] rd[15-12] [1010110] M [0] vm[3-0].
   kThumb2Vnegd,      // vneg.f64 [111011101] D [110000] rd[15-12] [1011110] M [0] vm[3-0].
   kThumb2Vnegs,      // vneg.f32 [111011101] D [110000] rd[15-12] [1010110] M [0] vm[3-0].
-  kThumb2Vmovs_IMM8, // vmov.f32 [111011101] D [11] imm4h[19-16] vd[15-12] [10100000] imm4l[3-0].
-  kThumb2Vmovd_IMM8, // vmov.f64 [111011101] D [11] imm4h[19-16] vd[15-12] [10110000] imm4l[3-0].
+  kThumb2Vmovs_IMM8,  // vmov.f32 [111011101] D [11] imm4h[19-16] vd[15-12] [10100000] imm4l[3-0].
+  kThumb2Vmovd_IMM8,  // vmov.f64 [111011101] D [11] imm4h[19-16] vd[15-12] [10110000] imm4l[3-0].
   kThumb2Mla,        // mla [111110110000] rn[19-16] ra[15-12] rd[7-4] [0000] rm[3-0].
   kThumb2Umull,      // umull [111110111010] rn[19-16], rdlo[15-12] rdhi[11-8] [0000] rm[3-0].
   kThumb2Ldrex,      // ldrex [111010000101] rn[19-16] rt[11-8] [1111] imm8[7-0].
@@ -425,7 +425,7 @@ enum ArmOpcode {
   kThumb2Bfi,        // bfi [111100110110] rn[19-16] [0] imm3[14-12] rd[11-8] imm2[7-6] [0] msb[4-0].
   kThumb2Bfc,        // bfc [11110011011011110] [0] imm3[14-12] rd[11-8] imm2[7-6] [0] msb[4-0].
   kThumb2Dmb,        // dmb [1111001110111111100011110101] option[3-0].
-  kThumb2LdrPcReln12,// ldr rd,[pc,-#imm12] [1111100011011111] rt[15-12] imm12[11-0].
+  kThumb2LdrPcReln12,  // ldr rd,[pc,-#imm12] [1111100011011111] rt[15-12] imm12[11-0].
   kThumb2Stm,        // stm <list> [111010010000] rn[19-16] 000 rl[12-0].
   kThumbUndefined,   // undefined [11011110xxxxxxxx].
   kThumb2VPopCS,     // vpop <list of callee save fp singles (s16+).
@@ -436,8 +436,8 @@ enum ArmOpcode {
   kThumb2MovImm16H,  // similar to kThumb2MovImm16, but target high hw.
   kThumb2AddPCR,     // Thumb2 2-operand add with hard-coded PC target.
   kThumb2Adr,        // Special purpose encoding of ADR for switch tables.
-  kThumb2MovImm16LST,// Special purpose version for switch table use.
-  kThumb2MovImm16HST,// Special purpose version for switch table use.
+  kThumb2MovImm16LST,  // Special purpose version for switch table use.
+  kThumb2MovImm16HST,  // Special purpose version for switch table use.
   kThumb2LdmiaWB,    // ldmia  [111010011001[ rn[19..16] mask[15..0].
   kThumb2SubsRRI12,  // setflags encoding.
   kThumb2OrrRRRs,    // orrx [111010100101] rn[19..16] [0000] rd[11..8] [0000] rm[3..0].
@@ -445,7 +445,7 @@ enum ArmOpcode {
   kThumb2Pop1,       // t3 encoding of pop.
   kThumb2RsubRRR,    // rsb [111010111101] rn[19..16] [0000] rd[11..8] [0000] rm[3..0].
   kThumb2Smull,      // smull [111110111000] rn[19-16], rdlo[15-12] rdhi[11-8] [0000] rm[3-0].
-  kThumb2LdrdPcRel8, // ldrd rt, rt2, pc +-/1024.
+  kThumb2LdrdPcRel8,  // ldrd rt, rt2, pc +-/1024.
   kThumb2LdrdI8,     // ldrd rt, rt2, [rn +-/1024].
   kThumb2StrdI8,     // strd rt, rt2, [rn +-/1024].
   kArmLast,
@@ -485,7 +485,7 @@ struct ArmEncodingMap {
   struct {
     ArmEncodingKind kind;
     int end;   // end for kFmtBitBlt, 1-bit slice end for FP regs.
-    int start; // start for kFmtBitBlt, 4-bit slice end for FP regs.
+    int start;  // start for kFmtBitBlt, 4-bit slice end for FP regs.
   } field_loc[4];
   ArmOpcode opcode;
   uint64_t flags;
diff --git a/compiler/dex/quick/arm/call_arm.cc b/compiler/dex/quick/arm/call_arm.cc
index 1416c6115b..64ebb6abbd 100644
--- a/compiler/dex/quick/arm/call_arm.cc
+++ b/compiler/dex/quick/arm/call_arm.cc
@@ -117,7 +117,7 @@ MIR* ArmMir2Lir::GetNextMir(BasicBlock** p_bb, MIR* mir) {
 }
 
 /* Used for the "verbose" listing */
-//TODO:  move to common code
+// TODO:  move to common code
 void ArmMir2Lir::GenPrintLabel(MIR* mir) {
   /* Mark the beginning of a Dalvik instruction for line tracking */
   char* inst_str = cu_->verbose ?
@@ -475,7 +475,7 @@ void ArmMir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src) {
   GenNullCheck(rl_src.s_reg_low, r0, opt_flags);
   LoadWordDisp(rARM_SELF, Thread::ThinLockIdOffset().Int32Value(), r2);
   NewLIR3(kThumb2Ldrex, r1, r0,
-          mirror::Object::MonitorOffset().Int32Value() >> 2); // Get object->lock
+          mirror::Object::MonitorOffset().Int32Value() >> 2);  // Get object->lock
   // Align owner
   OpRegImm(kOpLsl, r2, LW_LOCK_OWNER_SHIFT);
   // Is lock unheld on lock or held by us (==thread_id) on unlock?
@@ -507,7 +507,7 @@ void ArmMir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src) {
   LoadValueDirectFixed(rl_src, r0);  // Get obj
   LockCallTemps();  // Prepare for explicit register usage
   GenNullCheck(rl_src.s_reg_low, r0, opt_flags);
-  LoadWordDisp(r0, mirror::Object::MonitorOffset().Int32Value(), r1); // Get lock
+  LoadWordDisp(r0, mirror::Object::MonitorOffset().Int32Value(), r1);  // Get lock
   LoadWordDisp(rARM_SELF, Thread::ThinLockIdOffset().Int32Value(), r2);
   // Is lock unheld on lock or held by us (==thread_id) on unlock?
   OpRegRegImm(kOpAnd, r3, r1,
diff --git a/compiler/dex/quick/arm/fp_arm.cc b/compiler/dex/quick/arm/fp_arm.cc
index 8f73f0c2f5..1bb08c45e3 100644
--- a/compiler/dex/quick/arm/fp_arm.cc
+++ b/compiler/dex/quick/arm/fp_arm.cc
@@ -273,7 +273,7 @@ void ArmMir2Lir::GenCmpFP(Instruction::Code opcode, RegLocation rl_dest,
 
   OpIT((default_result == -1) ? kCondGt : kCondMi, "");
   NewLIR2(kThumb2MovImmShift, rl_result.low_reg,
-          ModifiedImmediate(-default_result)); // Must not alter ccodes
+          ModifiedImmediate(-default_result));  // Must not alter ccodes
   GenBarrier();
 
   OpIT(kCondEq, "");
diff --git a/compiler/dex/quick/arm/int_arm.cc b/compiler/dex/quick/arm/int_arm.cc
index 15d361edcc..e1a77daba9 100644
--- a/compiler/dex/quick/arm/int_arm.cc
+++ b/compiler/dex/quick/arm/int_arm.cc
@@ -49,7 +49,7 @@ LIR* ArmMir2Lir::OpIT(ConditionCode ccode, const char* guide) {
   int cond_bit = code & 1;
   int alt_bit = cond_bit ^ 1;
 
-  //Note: case fallthroughs intentional
+  // Note: case fallthroughs intentional
   switch (strlen(guide)) {
     case 3:
       mask1 = (guide[2] == 'T') ? cond_bit : alt_bit;
@@ -107,7 +107,7 @@ void ArmMir2Lir::GenCmpLong(RegLocation rl_dest, RegLocation rl_src1,
 
   target1 = NewLIR0(kPseudoTargetLabel);
 
-  RegLocation rl_temp = LocCReturn(); // Just using as template, will change
+  RegLocation rl_temp = LocCReturn();  // Just using as template, will change
   rl_temp.low_reg = t_reg;
   StoreValue(rl_dest, rl_temp);
   FreeTemp(t_reg);
@@ -207,13 +207,13 @@ void ArmMir2Lir::GenSelect(BasicBlock* bb, MIR* mir) {
       OpRegRegImm(kOpRsub, rl_result.low_reg, rl_src.low_reg, 1);
       OpIT(kCondCc, "");
       LoadConstant(rl_result.low_reg, 0);
-      GenBarrier(); // Add a scheduling barrier to keep the IT shadow intact
+      GenBarrier();  // Add a scheduling barrier to keep the IT shadow intact
     } else if (InexpensiveConstantInt(true_val) && InexpensiveConstantInt(false_val)) {
       OpRegImm(kOpCmp, rl_src.low_reg, 0);
       OpIT(kCondEq, "E");
       LoadConstant(rl_result.low_reg, true_val);
       LoadConstant(rl_result.low_reg, false_val);
-      GenBarrier(); // Add a scheduling barrier to keep the IT shadow intact
+      GenBarrier();  // Add a scheduling barrier to keep the IT shadow intact
     } else {
       // Unlikely case - could be tuned.
       int t_reg1 = AllocTemp();
@@ -224,7 +224,7 @@ void ArmMir2Lir::GenSelect(BasicBlock* bb, MIR* mir) {
       OpIT(kCondEq, "E");
       OpRegCopy(rl_result.low_reg, t_reg1);
       OpRegCopy(rl_result.low_reg, t_reg2);
-      GenBarrier(); // Add a scheduling barrier to keep the IT shadow intact
+      GenBarrier();  // Add a scheduling barrier to keep the IT shadow intact
     }
   } else {
     // MOVE case
@@ -239,7 +239,7 @@ void ArmMir2Lir::GenSelect(BasicBlock* bb, MIR* mir) {
     l1->flags.is_nop = false;  // Make sure this instruction isn't optimized away
     LIR* l2 = OpRegCopy(rl_result.low_reg, rl_false.low_reg);
     l2->flags.is_nop = false;  // Make sure this instruction isn't optimized away
-    GenBarrier(); // Add a scheduling barrier to keep the IT shadow intact
+    GenBarrier();  // Add a scheduling barrier to keep the IT shadow intact
   }
   StoreValue(rl_dest, rl_result);
 }
@@ -716,7 +716,7 @@ void ArmMir2Lir::GenMulLong(RegLocation rl_dest, RegLocation rl_src1,
       }
     }
     FreeTemp(tmp1);
-    rl_result = GetReturnWide(false); // Just using as a template.
+    rl_result = GetReturnWide(false);  // Just using as a template.
     rl_result.low_reg = res_lo;
     rl_result.high_reg = res_hi;
     StoreValueWide(rl_dest, rl_result);
@@ -883,7 +883,7 @@ void ArmMir2Lir::GenArrayPut(int opt_flags, OpSize size, RegLocation rl_array,
   int reg_len = INVALID_REG;
   if (needs_range_check) {
     reg_len = AllocTemp();
-    //NOTE: max live temps(4) here.
+    // NOTE: max live temps(4) here.
     /* Get len */
     LoadWordDisp(rl_array.low_reg, len_offset, reg_len);
   }
diff --git a/compiler/dex/quick/arm/target_arm.cc b/compiler/dex/quick/arm/target_arm.cc
index 5296f30d5e..6f3779879c 100644
--- a/compiler/dex/quick/arm/target_arm.cc
+++ b/compiler/dex/quick/arm/target_arm.cc
@@ -553,7 +553,7 @@ void ArmMir2Lir::CompilerInitializeRegAlloc() {
   // Keep special registers from being allocated
   for (int i = 0; i < num_reserved; i++) {
     if (NO_SUSPEND && (ReservedRegs[i] == rARM_SUSPEND)) {
-      //To measure cost of suspend check
+      // To measure cost of suspend check
       continue;
     }
     MarkInUse(ReservedRegs[i]);
diff --git a/compiler/dex/quick/arm/utility_arm.cc b/compiler/dex/quick/arm/utility_arm.cc
index 1ea0a648f2..afc8a66d8a 100644
--- a/compiler/dex/quick/arm/utility_arm.cc
+++ b/compiler/dex/quick/arm/utility_arm.cc
@@ -507,7 +507,7 @@ LIR* ArmMir2Lir::OpRegRegImm(OpKind op, int r_dest, int r_src1, int value) {
       alt_opcode = kThumb2EorRRR;
       break;
     case kOpMul:
-      //TUNING: power of 2, shift & add
+      // TUNING: power of 2, shift & add
       mod_imm = -1;
       alt_opcode = kThumb2MulRRR;
       break;
@@ -662,7 +662,7 @@ LIR* ArmMir2Lir::LoadBaseIndexed(int rBase, int r_index, int r_dest,
   }
 
   switch (size) {
-    case kDouble: // fall-through
+    case kDouble:  // fall-through
     case kSingle:
       reg_ptr = AllocTemp();
       if (scale) {
@@ -726,7 +726,7 @@ LIR* ArmMir2Lir::StoreBaseIndexed(int rBase, int r_index, int r_src,
   }
 
   switch (size) {
-    case kDouble: // fall-through
+    case kDouble:  // fall-through
     case kSingle:
       reg_ptr = AllocTemp();
       if (scale) {
diff --git a/compiler/dex/quick/codegen_util.cc b/compiler/dex/quick/codegen_util.cc
index 9e9b39e3ef..c9780fa537 100644
--- a/compiler/dex/quick/codegen_util.cc
+++ b/compiler/dex/quick/codegen_util.cc
@@ -1063,4 +1063,4 @@ void Mir2Lir::InsertLIRAfter(LIR* current_lir, LIR* new_lir) {
 }
 
 
-} // namespace art
+}  // namespace art
diff --git a/compiler/dex/quick/gen_common.cc b/compiler/dex/quick/gen_common.cc
index bc49b7051a..40db2c69d9 100644
--- a/compiler/dex/quick/gen_common.cc
+++ b/compiler/dex/quick/gen_common.cc
@@ -547,7 +547,7 @@ void Mir2Lir::HandleThrowLaunchPads() {
       case kThrowNullPointer:
         func_offset = ENTRYPOINT_OFFSET(pThrowNullPointerFromCode);
         break;
-      case kThrowConstantArrayBounds: // v1 is length reg (for Arm/Mips), v2 constant index
+      case kThrowConstantArrayBounds:  // v1 is length reg (for Arm/Mips), v2 constant index
         // v1 holds the constant array index.  Mips/Arm uses v2 for length, x86 reloads.
         if (target_x86) {
           OpRegMem(kOpMov, TargetReg(kArg1), v1, mirror::Array::LengthOffset().Int32Value());
@@ -792,7 +792,7 @@ void Mir2Lir::GenConstString(uint32_t string_idx, RegLocation rl_dest) {
       *cu_->dex_file, string_idx) || SLOW_STRING_PATH) {
     // slow path, resolve string if not in dex cache
     FlushAllRegs();
-    LockCallTemps(); // Using explicit registers
+    LockCallTemps();  // Using explicit registers
     LoadCurrMethodDirect(TargetReg(kArg2));
     LoadWordDisp(TargetReg(kArg2),
                  mirror::AbstractMethod::DexCacheStringsOffset().Int32Value(), TargetReg(kArg0));
@@ -951,7 +951,7 @@ void Mir2Lir::GenInstanceofCallingHelper(bool needs_access_check, bool type_know
       // Not resolved
       // Call out to helper, which will return resolved type in kRet0
       CallRuntimeHelperImm(ENTRYPOINT_OFFSET(pInitializeTypeFromCode), type_idx, true);
-      OpRegCopy(TargetReg(kArg2), TargetReg(kRet0)); // Align usage with fast path
+      OpRegCopy(TargetReg(kArg2), TargetReg(kRet0));  // Align usage with fast path
       LoadValueDirectFixed(rl_src, TargetReg(kArg0));  /* reload Ref */
       // Rejoin code paths
       LIR* hop_target = NewLIR0(kPseudoTargetLabel);
@@ -1090,7 +1090,7 @@ void Mir2Lir::GenCheckCast(uint32_t insn_idx, uint32_t type_idx, RegLocation rl_
       // InitializeTypeFromCode(idx, method)
       CallRuntimeHelperImmReg(ENTRYPOINT_OFFSET(pInitializeTypeFromCode), type_idx, TargetReg(kArg1),
                               true);
-      OpRegCopy(class_reg, TargetReg(kRet0)); // Align usage with fast path
+      OpRegCopy(class_reg, TargetReg(kRet0));  // Align usage with fast path
       // Rejoin code paths
       LIR* hop_target = NewLIR0(kPseudoTargetLabel);
       hop_branch->target = hop_target;
@@ -1167,7 +1167,7 @@ void Mir2Lir::GenLong3Addr(OpKind first_op, OpKind second_op, RegLocation rl_des
 
 void Mir2Lir::GenShiftOpLong(Instruction::Code opcode, RegLocation rl_dest,
                              RegLocation rl_src1, RegLocation rl_shift) {
-  int func_offset = -1; // Make gcc happy
+  int func_offset = -1;  // Make gcc happy
 
   switch (opcode) {
     case Instruction::SHL_LONG:
diff --git a/compiler/dex/quick/gen_invoke.cc b/compiler/dex/quick/gen_invoke.cc
index 13a59bf69a..cae13190ec 100644
--- a/compiler/dex/quick/gen_invoke.cc
+++ b/compiler/dex/quick/gen_invoke.cc
@@ -428,22 +428,22 @@ static int NextVCallInsn(CompilationUnit* cu, CallInfo* info,
       cg->LoadValueDirectFixed(rl_arg, cg->TargetReg(kArg1));
       break;
     }
-    case 1: // Is "this" null? [use kArg1]
+    case 1:  // Is "this" null? [use kArg1]
       cg->GenNullCheck(info->args[0].s_reg_low, cg->TargetReg(kArg1), info->opt_flags);
       // get this->klass_ [use kArg1, set kInvokeTgt]
       cg->LoadWordDisp(cg->TargetReg(kArg1), mirror::Object::ClassOffset().Int32Value(),
                        cg->TargetReg(kInvokeTgt));
       break;
-    case 2: // Get this->klass_->vtable [usr kInvokeTgt, set kInvokeTgt]
+    case 2:  // Get this->klass_->vtable [usr kInvokeTgt, set kInvokeTgt]
       cg->LoadWordDisp(cg->TargetReg(kInvokeTgt), mirror::Class::VTableOffset().Int32Value(),
                        cg->TargetReg(kInvokeTgt));
       break;
-    case 3: // Get target method [use kInvokeTgt, set kArg0]
+    case 3:  // Get target method [use kInvokeTgt, set kArg0]
       cg->LoadWordDisp(cg->TargetReg(kInvokeTgt), (method_idx * 4) +
                        mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value(),
                        cg->TargetReg(kArg0));
       break;
-    case 4: // Get the compiled code address [uses kArg0, sets kInvokeTgt]
+    case 4:  // Get the compiled code address [uses kArg0, sets kInvokeTgt]
       if (cu->instruction_set != kX86) {
         cg->LoadWordDisp(cg->TargetReg(kArg0),
                          mirror::AbstractMethod::GetEntryPointFromCompiledCodeOffset().Int32Value(),
@@ -649,7 +649,7 @@ int Mir2Lir::GenDalvikArgsNoRange(CallInfo* info,
   DCHECK_LE(info->num_arg_words, 5);
   if (info->num_arg_words > 3) {
     int32_t next_use = 3;
-    //Detect special case of wide arg spanning arg3/arg4
+    // Detect special case of wide arg spanning arg3/arg4
     RegLocation rl_use0 = info->args[0];
     RegLocation rl_use1 = info->args[1];
     RegLocation rl_use2 = info->args[2];
@@ -789,7 +789,7 @@ int Mir2Lir::GenDalvikArgsRange(CallInfo* info, int call_state,
                                direct_code, direct_method, type);
       OpRegRegImm(kOpAdd, TargetReg(kArg3), TargetReg(kSp), start_offset);
       LIR* ld = OpVldm(TargetReg(kArg3), regs_left);
-      //TUNING: loosen barrier
+      // TUNING: loosen barrier
       ld->def_mask = ENCODE_ALL;
       SetMemRefType(ld, true /* is_load */, kDalvikReg);
       call_state = next_call_insn(cu_, info, call_state, target_method, vtable_idx,
@@ -1086,7 +1086,7 @@ bool Mir2Lir::GenInlinedStringCompareTo(CallInfo* info) {
   int r_tgt = (cu_->instruction_set != kX86) ?
       LoadHelper(ENTRYPOINT_OFFSET(pStringCompareTo)) : 0;
   GenNullCheck(rl_this.s_reg_low, reg_this, info->opt_flags);
-  //TUNING: check if rl_cmp.s_reg_low is already null checked
+  // TUNING: check if rl_cmp.s_reg_low is already null checked
   LIR* launch_pad = RawLIR(0, kPseudoIntrinsicRetry, reinterpret_cast<uintptr_t>(info));
   intrinsic_launchpads_.Insert(launch_pad);
   OpCmpImmBranch(kCondEq, reg_cmp, 0, launch_pad);
diff --git a/compiler/dex/quick/mips/call_mips.cc b/compiler/dex/quick/mips/call_mips.cc
index db5764336a..8b375ea2f0 100644
--- a/compiler/dex/quick/mips/call_mips.cc
+++ b/compiler/dex/quick/mips/call_mips.cc
@@ -259,7 +259,7 @@ void MipsMir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src) {
 
   // And go...
   ClobberCalleeSave();
-  LIR* call_inst = OpReg(kOpBlx, r_tgt); // ( array*, fill_data* )
+  LIR* call_inst = OpReg(kOpBlx, r_tgt);  // ( array*, fill_data* )
   MarkSafepointPC(call_inst);
 }
 
diff --git a/compiler/dex/quick/mips/fp_mips.cc b/compiler/dex/quick/mips/fp_mips.cc
index 2e744a2afc..6cd9acc099 100644
--- a/compiler/dex/quick/mips/fp_mips.cc
+++ b/compiler/dex/quick/mips/fp_mips.cc
@@ -174,7 +174,7 @@ void MipsMir2Lir::GenConversion(Instruction::Code opcode, RegLocation rl_dest,
 void MipsMir2Lir::GenCmpFP(Instruction::Code opcode, RegLocation rl_dest,
                            RegLocation rl_src1, RegLocation rl_src2) {
   bool wide = true;
-  int offset = -1; // Make gcc happy.
+  int offset = -1;  // Make gcc happy.
 
   switch (opcode) {
     case Instruction::CMPL_FLOAT:
@@ -237,4 +237,4 @@ bool MipsMir2Lir::GenInlinedMinMaxInt(CallInfo* info, bool is_min) {
   return false;
 }
 
-} //  namespace art
+}  // namespace art
diff --git a/compiler/dex/quick/mips/int_mips.cc b/compiler/dex/quick/mips/int_mips.cc
index 03a58cc958..ea7da6030e 100644
--- a/compiler/dex/quick/mips/int_mips.cc
+++ b/compiler/dex/quick/mips/int_mips.cc
@@ -145,7 +145,7 @@ LIR* MipsMir2Lir::OpCmpImmBranch(ConditionCode cond, int reg,
     case kCondGe: opc = kMipsBgez; break;
     case kCondGt: opc = kMipsBgtz; break;
     case kCondLe: opc = kMipsBlez; break;
-    //case KCondMi:
+    // case KCondMi:
     case kCondLt: opc = kMipsBltz; break;
     case kCondNe: opc = kMipsBnez; break;
     default:
@@ -513,7 +513,7 @@ void MipsMir2Lir::GenArrayPut(int opt_flags, OpSize size, RegLocation rl_array,
   int reg_len = INVALID_REG;
   if (needs_range_check) {
     reg_len = AllocTemp();
-    //NOTE: max live temps(4) here.
+    // NOTE: max live temps(4) here.
     /* Get len */
     LoadWordDisp(rl_array.low_reg, len_offset, reg_len);
   }
@@ -521,7 +521,7 @@ void MipsMir2Lir::GenArrayPut(int opt_flags, OpSize size, RegLocation rl_array,
   OpRegImm(kOpAdd, reg_ptr, data_offset);
   /* at this point, reg_ptr points to array, 2 live temps */
   if ((size == kLong) || (size == kDouble)) {
-    //TUNING: specific wide routine that can handle fp regs
+    // TUNING: specific wide routine that can handle fp regs
     if (scale) {
       int r_new_index = AllocTemp();
       OpRegRegImm(kOpLsl, r_new_index, rl_index.low_reg, scale);
diff --git a/compiler/dex/quick/mips/mips_lir.h b/compiler/dex/quick/mips/mips_lir.h
index c3709b7204..278fcefcbf 100644
--- a/compiler/dex/quick/mips/mips_lir.h
+++ b/compiler/dex/quick/mips/mips_lir.h
@@ -155,7 +155,7 @@ enum MipsResourceEncodingPos {
   kMipsGPReg0   = 0,
   kMipsRegSP    = 29,
   kMipsRegLR    = 31,
-  kMipsFPReg0   = 32, // only 16 fp regs supported currently.
+  kMipsFPReg0   = 32,  // only 16 fp regs supported currently.
   kMipsFPRegEnd   = 48,
   kMipsRegHI    = kMipsFPRegEnd,
   kMipsRegLO,
@@ -248,7 +248,7 @@ enum MipsNativeRegisterPool {
   r_DF5 = r_F10 + MIPS_FP_DOUBLE,
   r_DF6 = r_F12 + MIPS_FP_DOUBLE,
   r_DF7 = r_F14 + MIPS_FP_DOUBLE,
-#if 0 // TODO: expand resource mask to enable use of all MIPS fp registers.
+#if 0  // TODO: expand resource mask to enable use of all MIPS fp registers.
   r_DF8 = r_F16 + MIPS_FP_DOUBLE,
   r_DF9 = r_F18 + MIPS_FP_DOUBLE,
   r_DF10 = r_F20 + MIPS_FP_DOUBLE,
@@ -305,8 +305,8 @@ enum MipsShiftEncodings {
  */
 enum MipsOpCode {
   kMipsFirst = 0,
-  kMips32BitData = kMipsFirst, // data [31..0].
-  kMipsAddiu, // addiu t,s,imm16 [001001] s[25..21] t[20..16] imm16[15..0].
+  kMips32BitData = kMipsFirst,  // data [31..0].
+  kMipsAddiu,  // addiu t,s,imm16 [001001] s[25..21] t[20..16] imm16[15..0].
   kMipsAddu,  // add d,s,t [000000] s[25..21] t[20..16] d[15..11] [00000100001].
   kMipsAnd,   // and d,s,t [000000] s[25..21] t[20..16] d[15..11] [00000100100].
   kMipsAndi,  // andi t,s,imm16 [001100] s[25..21] t[20..16] imm16[15..0].
@@ -366,31 +366,31 @@ enum MipsOpCode {
   kMipsSw,    // sw t,o(b) [101011] b[25..21] t[20..16] o[15..0].
   kMipsXor,   // xor d,s,t [000000] s[25..21] t[20..16] d[15..11] [00000100110].
   kMipsXori,  // xori t,s,imm16 [001110] s[25..21] t[20..16] imm16[15..0].
-  kMipsFadds, // add.s d,s,t [01000110000] t[20..16] s[15..11] d[10..6] [000000].
-  kMipsFsubs, // sub.s d,s,t [01000110000] t[20..16] s[15..11] d[10..6] [000001].
-  kMipsFmuls, // mul.s d,s,t [01000110000] t[20..16] s[15..11] d[10..6] [000010].
-  kMipsFdivs, // div.s d,s,t [01000110000] t[20..16] s[15..11] d[10..6] [000011].
-  kMipsFaddd, // add.d d,s,t [01000110001] t[20..16] s[15..11] d[10..6] [000000].
-  kMipsFsubd, // sub.d d,s,t [01000110001] t[20..16] s[15..11] d[10..6] [000001].
-  kMipsFmuld, // mul.d d,s,t [01000110001] t[20..16] s[15..11] d[10..6] [000010].
-  kMipsFdivd, // div.d d,s,t [01000110001] t[20..16] s[15..11] d[10..6] [000011].
-  kMipsFcvtsd,// cvt.s.d d,s [01000110001] [00000] s[15..11] d[10..6] [100000].
-  kMipsFcvtsw,// cvt.s.w d,s [01000110100] [00000] s[15..11] d[10..6] [100000].
-  kMipsFcvtds,// cvt.d.s d,s [01000110000] [00000] s[15..11] d[10..6] [100001].
-  kMipsFcvtdw,// cvt.d.w d,s [01000110100] [00000] s[15..11] d[10..6] [100001].
-  kMipsFcvtws,// cvt.w.d d,s [01000110000] [00000] s[15..11] d[10..6] [100100].
-  kMipsFcvtwd,// cvt.w.d d,s [01000110001] [00000] s[15..11] d[10..6] [100100].
-  kMipsFmovs, // mov.s d,s [01000110000] [00000] s[15..11] d[10..6] [000110].
-  kMipsFmovd, // mov.d d,s [01000110001] [00000] s[15..11] d[10..6] [000110].
-  kMipsFlwc1, // lwc1 t,o(b) [110001] b[25..21] t[20..16] o[15..0].
-  kMipsFldc1, // ldc1 t,o(b) [110101] b[25..21] t[20..16] o[15..0].
-  kMipsFswc1, // swc1 t,o(b) [111001] b[25..21] t[20..16] o[15..0].
-  kMipsFsdc1, // sdc1 t,o(b) [111101] b[25..21] t[20..16] o[15..0].
+  kMipsFadds,  // add.s d,s,t [01000110000] t[20..16] s[15..11] d[10..6] [000000].
+  kMipsFsubs,  // sub.s d,s,t [01000110000] t[20..16] s[15..11] d[10..6] [000001].
+  kMipsFmuls,  // mul.s d,s,t [01000110000] t[20..16] s[15..11] d[10..6] [000010].
+  kMipsFdivs,  // div.s d,s,t [01000110000] t[20..16] s[15..11] d[10..6] [000011].
+  kMipsFaddd,  // add.d d,s,t [01000110001] t[20..16] s[15..11] d[10..6] [000000].
+  kMipsFsubd,  // sub.d d,s,t [01000110001] t[20..16] s[15..11] d[10..6] [000001].
+  kMipsFmuld,  // mul.d d,s,t [01000110001] t[20..16] s[15..11] d[10..6] [000010].
+  kMipsFdivd,  // div.d d,s,t [01000110001] t[20..16] s[15..11] d[10..6] [000011].
+  kMipsFcvtsd,  // cvt.s.d d,s [01000110001] [00000] s[15..11] d[10..6] [100000].
+  kMipsFcvtsw,  // cvt.s.w d,s [01000110100] [00000] s[15..11] d[10..6] [100000].
+  kMipsFcvtds,  // cvt.d.s d,s [01000110000] [00000] s[15..11] d[10..6] [100001].
+  kMipsFcvtdw,  // cvt.d.w d,s [01000110100] [00000] s[15..11] d[10..6] [100001].
+  kMipsFcvtws,  // cvt.w.d d,s [01000110000] [00000] s[15..11] d[10..6] [100100].
+  kMipsFcvtwd,  // cvt.w.d d,s [01000110001] [00000] s[15..11] d[10..6] [100100].
+  kMipsFmovs,  // mov.s d,s [01000110000] [00000] s[15..11] d[10..6] [000110].
+  kMipsFmovd,  // mov.d d,s [01000110001] [00000] s[15..11] d[10..6] [000110].
+  kMipsFlwc1,  // lwc1 t,o(b) [110001] b[25..21] t[20..16] o[15..0].
+  kMipsFldc1,  // ldc1 t,o(b) [110101] b[25..21] t[20..16] o[15..0].
+  kMipsFswc1,  // swc1 t,o(b) [111001] b[25..21] t[20..16] o[15..0].
+  kMipsFsdc1,  // sdc1 t,o(b) [111101] b[25..21] t[20..16] o[15..0].
   kMipsMfc1,  // mfc1 t,s [01000100000] t[20..16] s[15..11] [00000000000].
   kMipsMtc1,  // mtc1 t,s [01000100100] t[20..16] s[15..11] [00000000000].
-  kMipsDelta, // Psuedo for ori t, s, <label>-<label>.
-  kMipsDeltaHi, // Pseudo for lui t, high16(<label>-<label>).
-  kMipsDeltaLo, // Pseudo for ori t, s, low16(<label>-<label>).
+  kMipsDelta,  // Psuedo for ori t, s, <label>-<label>.
+  kMipsDeltaHi,  // Pseudo for lui t, high16(<label>-<label>).
+  kMipsDeltaLo,  // Pseudo for ori t, s, low16(<label>-<label>).
   kMipsCurrPC,  // jal to .+8 to materialize pc.
   kMipsSync,    // sync kind [000000] [0000000000000000] s[10..6] [001111].
   kMipsUndefined,  // undefined [011001xxxxxxxxxxxxxxxx].
@@ -412,7 +412,7 @@ struct MipsEncodingMap {
   struct {
     MipsEncodingKind kind;
     int end;   // end for kFmtBitBlt, 1-bit slice end for FP regs.
-    int start; // start for kFmtBitBlt, 4-bit slice end for FP regs.
+    int start;  // start for kFmtBitBlt, 4-bit slice end for FP regs.
   } field_loc[4];
   MipsOpCode opcode;
   uint64_t flags;
@@ -425,7 +425,7 @@ extern MipsEncodingMap EncodingMap[kMipsLast];
 
 #define IS_UIMM16(v) ((0 <= (v)) && ((v) <= 65535))
 #define IS_SIMM16(v) ((-32768 <= (v)) && ((v) <= 32766))
-#define IS_SIMM16_2WORD(v) ((-32764 <= (v)) && ((v) <= 32763)) // 2 offsets must fit.
+#define IS_SIMM16_2WORD(v) ((-32764 <= (v)) && ((v) <= 32763))  // 2 offsets must fit.
 
 }  // namespace art
 
diff --git a/compiler/dex/quick/mips/target_mips.cc b/compiler/dex/quick/mips/target_mips.cc
index 21ba69ccd6..0a17fb1078 100644
--- a/compiler/dex/quick/mips/target_mips.cc
+++ b/compiler/dex/quick/mips/target_mips.cc
@@ -477,7 +477,7 @@ void MipsMir2Lir::CompilerInitializeRegAlloc() {
   // Keep special registers from being allocated
   for (int i = 0; i < num_reserved; i++) {
     if (NO_SUSPEND && (ReservedRegs[i] == rMIPS_SUSPEND)) {
-      //To measure cost of suspend check
+      // To measure cost of suspend check
       continue;
     }
     MarkInUse(ReservedRegs[i]);
@@ -572,4 +572,4 @@ const char* MipsMir2Lir::GetTargetInstFmt(int opcode) {
   return MipsMir2Lir::EncodingMap[opcode].fmt;
 }
 
-} // namespace art
+}  // namespace art
diff --git a/compiler/dex/quick/mips/utility_mips.cc b/compiler/dex/quick/mips/utility_mips.cc
index 79f6f16457..68b26f1936 100644
--- a/compiler/dex/quick/mips/utility_mips.cc
+++ b/compiler/dex/quick/mips/utility_mips.cc
@@ -63,7 +63,7 @@ bool MipsMir2Lir::InexpensiveConstantLong(int64_t value) {
 }
 
 bool MipsMir2Lir::InexpensiveConstantDouble(int64_t value) {
-  return false; // TUNING
+  return false;  // TUNING
 }
 
 /*
diff --git a/compiler/dex/quick/mir_to_lir.h b/compiler/dex/quick/mir_to_lir.h
index 4774456646..a34e9295e9 100644
--- a/compiler/dex/quick/mir_to_lir.h
+++ b/compiler/dex/quick/mir_to_lir.h
@@ -157,7 +157,7 @@ Mir2Lir* X86CodeGenerator(CompilationUnit* const cu, MIRGraph* const mir_graph,
 #define ENCODE_ALL              (~0ULL)
 #define ENCODE_MEM              (ENCODE_DALVIK_REG | ENCODE_LITERAL | \
                                  ENCODE_HEAP_REF | ENCODE_MUST_NOT_ALIAS)
-//TODO: replace these macros
+// TODO: replace these macros
 #define SLOW_FIELD_PATH (cu_->enable_debug & (1 << kDebugSlowFieldPath))
 #define SLOW_INVOKE_PATH (cu_->enable_debug & (1 << kDebugSlowInvokePath))
 #define SLOW_STRING_PATH (cu_->enable_debug & (1 << kDebugSlowStringPath))
@@ -726,7 +726,7 @@ class Mir2Lir : public Backend {
     GrowableArray<LIR*> throw_launchpads_;
     GrowableArray<LIR*> suspend_launchpads_;
     GrowableArray<LIR*> intrinsic_launchpads_;
-    SafeMap<unsigned int, LIR*> boundary_map_; // boundary lookup cache.
+    SafeMap<unsigned int, LIR*> boundary_map_;  // boundary lookup cache.
     /*
      * Holds mapping from native PC to dex PC for safepoints where we may deoptimize.
      * Native PC is on the return address of the safepointed operation.  Dex PC is for
diff --git a/compiler/dex/quick/ralloc_util.cc b/compiler/dex/quick/ralloc_util.cc
index 4542f8f0b0..d59c986dda 100644
--- a/compiler/dex/quick/ralloc_util.cc
+++ b/compiler/dex/quick/ralloc_util.cc
@@ -198,7 +198,7 @@ int Mir2Lir::AllocPreservedSingle(int s_reg, bool even) {
  * s_reg<=sX[even] & (s_reg+1)<= sX+1.
  */
 int Mir2Lir::AllocPreservedDouble(int s_reg) {
-  int res = -1; // Assume failure
+  int res = -1;  // Assume failure
   int v_reg = mir_graph_->SRegToVReg(s_reg);
   int p_map_idx = SRegToPMap(s_reg);
   if (promotion_map_[p_map_idx+1].fp_location == kLocPhysReg) {
@@ -303,7 +303,7 @@ int Mir2Lir::AllocTempBody(RegisterInfo* p, int num_regs, int* next_temp,
   return -1;  // No register available
 }
 
-//REDO: too many assumptions.
+// REDO: too many assumptions.
 int Mir2Lir::AllocTempDouble() {
   RegisterInfo* p = reg_pool_->FPRegs;
   int num_regs = reg_pool_->num_fp_regs;
@@ -629,7 +629,7 @@ void Mir2Lir::FlushAllRegs() {
 }
 
 
-//TUNING: rewrite all of this reg stuff.  Probably use an attribute table
+// TUNING: rewrite all of this reg stuff.  Probably use an attribute table
 bool Mir2Lir::RegClassMatches(int reg_class, int reg) {
   if (reg_class == kAnyReg) {
     return true;
@@ -917,7 +917,7 @@ void Mir2Lir::CountRefs(RefCounts* core_counts, RefCounts* fp_counts) {
     RegLocation loc = mir_graph_->reg_location_[i];
     RefCounts* counts = loc.fp ? fp_counts : core_counts;
     int p_map_idx = SRegToPMap(loc.s_reg_low);
-    //Don't count easily regenerated immediates
+    // Don't count easily regenerated immediates
     if (loc.fp || !IsInexpensiveConstant(loc)) {
       counts[p_map_idx].count += mir_graph_->GetUseCount(i);
     }
@@ -1152,7 +1152,7 @@ int Mir2Lir::GetSRegHi(int lowSreg) {
 }
 
 bool Mir2Lir::oat_live_out(int s_reg) {
-  //For now.
+  // For now.
   return true;
 }
 
diff --git a/compiler/dex/quick/x86/assemble_x86.cc b/compiler/dex/quick/x86/assemble_x86.cc
index d864115fc0..e8834320a9 100644
--- a/compiler/dex/quick/x86/assemble_x86.cc
+++ b/compiler/dex/quick/x86/assemble_x86.cc
@@ -474,7 +474,7 @@ int X86Mir2Lir::GetInsnSize(LIR* lir) {
         return ComputeSize(entry, lir->operands[1], 0x12345678, true);
       } else {
         DCHECK(entry->opcode == kX86PcRelAdr);
-        return 5; // opcode with reg + 4 byte immediate
+        return 5;  // opcode with reg + 4 byte immediate
       }
     case kMacro:
       DCHECK_EQ(lir->opcode, static_cast<int>(kX86StartOfMethod));
@@ -1342,7 +1342,7 @@ AssemblerStatus X86Mir2Lir::AssembleInstructions(uintptr_t start_addr) {
       case kShiftRegImm:  // lir operands - 0: reg, 1: immediate
         EmitShiftRegImm(entry, lir->operands[0], lir->operands[1]);
         break;
-      case kShiftRegCl: // lir operands - 0: reg, 1: cl
+      case kShiftRegCl:  // lir operands - 0: reg, 1: cl
         EmitShiftRegCl(entry, lir->operands[0], lir->operands[1]);
         break;
       case kRegCond:  // lir operands - 0: reg, 1: condition
diff --git a/compiler/dex/quick/x86/call_x86.cc b/compiler/dex/quick/x86/call_x86.cc
index 1aeb39ae4b..d530a1c644 100644
--- a/compiler/dex/quick/x86/call_x86.cc
+++ b/compiler/dex/quick/x86/call_x86.cc
@@ -87,7 +87,7 @@ void X86Mir2Lir::GenPackedSwitch(MIR* mir, uint32_t table_offset,
   rl_src = LoadValue(rl_src, kCoreReg);
   int start_of_method_reg = AllocTemp();
   // Materialize a pointer to the switch table
-  //NewLIR0(kX86Bkpt);
+  // NewLIR0(kX86Bkpt);
   NewLIR1(kX86StartOfMethod, start_of_method_reg);
   int low_key = s4FromSwitchData(&table[2]);
   int keyReg;
diff --git a/compiler/dex/quick/x86/fp_x86.cc b/compiler/dex/quick/x86/fp_x86.cc
index f2ecf6c959..cc6f374488 100644
--- a/compiler/dex/quick/x86/fp_x86.cc
+++ b/compiler/dex/quick/x86/fp_x86.cc
@@ -373,4 +373,4 @@ bool X86Mir2Lir::GenInlinedSqrt(CallInfo* info) {
 
 
 
-} //  namespace art
+}  // namespace art
diff --git a/compiler/dex/quick/x86/target_x86.cc b/compiler/dex/quick/x86/target_x86.cc
index 5b64a6b5c3..2c9b3c837c 100644
--- a/compiler/dex/quick/x86/target_x86.cc
+++ b/compiler/dex/quick/x86/target_x86.cc
@@ -23,7 +23,7 @@
 
 namespace art {
 
-//FIXME: restore "static" when usage uncovered
+// FIXME: restore "static" when usage uncovered
 /*static*/ int core_regs[] = {
   rAX, rCX, rDX, rBX, rX86_SP, rBP, rSI, rDI
 #ifdef TARGET_REX_SUPPORT
@@ -541,4 +541,4 @@ const char* X86Mir2Lir::GetTargetInstFmt(int opcode) {
   return X86Mir2Lir::EncodingMap[opcode].fmt;
 }
 
-} // namespace art
+}  // namespace art
diff --git a/compiler/dex/quick/x86/utility_x86.cc b/compiler/dex/quick/x86/utility_x86.cc
index 75367a340a..e15995fef4 100644
--- a/compiler/dex/quick/x86/utility_x86.cc
+++ b/compiler/dex/quick/x86/utility_x86.cc
@@ -61,7 +61,7 @@ bool X86Mir2Lir::InexpensiveConstantLong(int64_t value) {
 }
 
 bool X86Mir2Lir::InexpensiveConstantDouble(int64_t value) {
-  return false; // TUNING
+  return false;  // TUNING
 }
 
 /*
@@ -135,7 +135,7 @@ LIR* X86Mir2Lir::OpRegImm(OpKind op, int r_dest_src1, int value) {
     case kOpAdd: opcode = byte_imm ? kX86Add32RI8 : kX86Add32RI; break;
     case kOpOr:  opcode = byte_imm ? kX86Or32RI8  : kX86Or32RI;  break;
     case kOpAdc: opcode = byte_imm ? kX86Adc32RI8 : kX86Adc32RI; break;
-    //case kOpSbb: opcode = kX86Sbb32RI; break;
+    // case kOpSbb: opcode = kX86Sbb32RI; break;
     case kOpAnd: opcode = byte_imm ? kX86And32RI8 : kX86And32RI; break;
     case kOpSub: opcode = byte_imm ? kX86Sub32RI8 : kX86Sub32RI; break;
     case kOpXor: opcode = byte_imm ? kX86Xor32RI8 : kX86Xor32RI; break;
@@ -221,7 +221,7 @@ LIR* X86Mir2Lir::OpRegMem(OpKind op, int r_dest, int rBase,
 LIR* X86Mir2Lir::OpRegRegReg(OpKind op, int r_dest, int r_src1,
                  int r_src2) {
   if (r_dest != r_src1 && r_dest != r_src2) {
-    if (op == kOpAdd) { // lea special case, except can't encode rbp as base
+    if (op == kOpAdd) {  // lea special case, except can't encode rbp as base
       if (r_src1 == r_src2) {
         OpRegCopy(r_dest, r_src1);
         return OpRegImm(kOpLsl, r_dest, 1);
@@ -279,11 +279,11 @@ LIR* X86Mir2Lir::OpRegRegImm(OpKind op, int r_dest, int r_src,
     }
   }
   if (r_dest != r_src) {
-    if (false && op == kOpLsl && value >= 0 && value <= 3) { // lea shift special case
+    if (false && op == kOpLsl && value >= 0 && value <= 3) {  // lea shift special case
       // TODO: fix bug in LEA encoding when disp == 0
       return NewLIR5(kX86Lea32RA, r_dest,  r5sib_no_base /* base */,
                      r_src /* index */, value /* scale */, 0 /* disp */);
-    } else if (op == kOpAdd) { // lea add special case
+    } else if (op == kOpAdd) {  // lea add special case
       return NewLIR5(kX86Lea32RA, r_dest, r_src /* base */,
                      r4sib_no_index /* index */, 0 /* scale */, value /* disp */);
     }
diff --git a/compiler/dex/quick/x86/x86_lir.h b/compiler/dex/quick/x86/x86_lir.h
index 73e562e85f..643a3d5b8f 100644
--- a/compiler/dex/quick/x86/x86_lir.h
+++ b/compiler/dex/quick/x86/x86_lir.h
@@ -219,7 +219,7 @@ enum X86NativeRegisterPool {
  */
 enum X86OpCode {
   kX86First = 0,
-  kX8632BitData = kX86First, // data [31..0].
+  kX8632BitData = kX86First,  // data [31..0].
   kX86Bkpt,
   kX86Nop,
   // Define groups of binary operations
@@ -322,12 +322,12 @@ enum X86OpCode {
   Binary0fOpCode(kX86Movss),
   kX86MovssMR,
   kX86MovssAR,
-  Binary0fOpCode(kX86Cvtsi2sd), // int to double
-  Binary0fOpCode(kX86Cvtsi2ss), // int to float
-  Binary0fOpCode(kX86Cvttsd2si),// truncating double to int
-  Binary0fOpCode(kX86Cvttss2si),// truncating float to int
-  Binary0fOpCode(kX86Cvtsd2si), // rounding double to int
-  Binary0fOpCode(kX86Cvtss2si), // rounding float to int
+  Binary0fOpCode(kX86Cvtsi2sd),  // int to double
+  Binary0fOpCode(kX86Cvtsi2ss),  // int to float
+  Binary0fOpCode(kX86Cvttsd2si),  // truncating double to int
+  Binary0fOpCode(kX86Cvttss2si),  // truncating float to int
+  Binary0fOpCode(kX86Cvtsd2si),  // rounding double to int
+  Binary0fOpCode(kX86Cvtss2si),  // rounding float to int
   Binary0fOpCode(kX86Ucomisd),  // unordered double compare
   Binary0fOpCode(kX86Ucomiss),  // unordered float compare
   Binary0fOpCode(kX86Comisd),   // double compare
@@ -338,8 +338,8 @@ enum X86OpCode {
   Binary0fOpCode(kX86Addss),    // float add
   Binary0fOpCode(kX86Mulsd),    // double multiply
   Binary0fOpCode(kX86Mulss),    // float multiply
-  Binary0fOpCode(kX86Cvtsd2ss), // double to float
-  Binary0fOpCode(kX86Cvtss2sd), // float to double
+  Binary0fOpCode(kX86Cvtsd2ss),  // double to float
+  Binary0fOpCode(kX86Cvtss2sd),  // float to double
   Binary0fOpCode(kX86Subsd),    // double subtract
   Binary0fOpCode(kX86Subss),    // float subtract
   Binary0fOpCode(kX86Divsd),    // double divide
@@ -347,13 +347,13 @@ enum X86OpCode {
   kX86PsrlqRI,                  // right shift of floating point registers
   kX86PsllqRI,                  // left shift of floating point registers
   Binary0fOpCode(kX86Movdxr),   // move into xmm from gpr
-  kX86MovdrxRR, kX86MovdrxMR, kX86MovdrxAR,// move into reg from xmm
-  kX86Set8R, kX86Set8M, kX86Set8A,// set byte depending on condition operand
+  kX86MovdrxRR, kX86MovdrxMR, kX86MovdrxAR,  // move into reg from xmm
+  kX86Set8R, kX86Set8M, kX86Set8A,  // set byte depending on condition operand
   kX86Mfence,                   // memory barrier
   Binary0fOpCode(kX86Imul16),   // 16bit multiply
   Binary0fOpCode(kX86Imul32),   // 32bit multiply
-  kX86CmpxchgRR, kX86CmpxchgMR, kX86CmpxchgAR,// compare and exchange
-  kX86LockCmpxchgRR, kX86LockCmpxchgMR, kX86LockCmpxchgAR,// locked compare and exchange
+  kX86CmpxchgRR, kX86CmpxchgMR, kX86CmpxchgAR,  // compare and exchange
+  kX86LockCmpxchgRR, kX86LockCmpxchgMR, kX86LockCmpxchgAR,  // locked compare and exchange
   Binary0fOpCode(kX86Movzx8),   // zero-extend 8-bit value
   Binary0fOpCode(kX86Movzx16),  // zero-extend 16-bit value
   Binary0fOpCode(kX86Movsx8),   // sign-extend 8-bit value
@@ -383,9 +383,9 @@ enum X86EncodingKind {
   kNullary,                                // Opcode that takes no arguments.
   kReg, kMem, kArray,                      // R, M and A instruction kinds.
   kMemReg, kArrayReg, kThreadReg,          // MR, AR and TR instruction kinds.
-  kRegReg, kRegMem, kRegArray, kRegThread, // RR, RM, RA and RT instruction kinds.
+  kRegReg, kRegMem, kRegArray, kRegThread,  // RR, RM, RA and RT instruction kinds.
   kRegRegStore,                            // RR following the store modrm reg-reg encoding rather than the load.
-  kRegImm, kMemImm, kArrayImm, kThreadImm, // RI, MI, AI and TI instruction kinds.
+  kRegImm, kMemImm, kArrayImm, kThreadImm,  // RI, MI, AI and TI instruction kinds.
   kRegRegImm, kRegMemImm, kRegArrayImm,    // RRI, RMI and RAI instruction kinds.
   kMovRegImm,                              // Shorter form move RI.
   kShiftRegImm, kShiftMemImm, kShiftArrayImm,  // Shift opcode with immediate.
@@ -407,13 +407,13 @@ struct X86EncodingMap {
   uint8_t prefix1;       // non-zero => a prefix byte
   uint8_t prefix2;       // non-zero => a second prefix byte
   uint8_t opcode;        // 1 byte opcode
-  uint8_t extra_opcode1; // possible extra opcode byte
-  uint8_t extra_opcode2; // possible second extra opcode byte
+  uint8_t extra_opcode1;  // possible extra opcode byte
+  uint8_t extra_opcode2;  // possible second extra opcode byte
   // 3bit opcode that gets encoded in the register bits of the modrm byte, use determined by the
   // encoding kind
   uint8_t modrm_opcode;
   uint8_t ax_opcode;  // non-zero => shorter encoding for AX as a destination
-  uint8_t immediate_bytes; // number of bytes of immediate
+  uint8_t immediate_bytes;  // number of bytes of immediate
   } skeleton;
   const char *name;
   const char* fmt;
diff --git a/compiler/dex/ssa_transformation.cc b/compiler/dex/ssa_transformation.cc
index 7739e2996f..18d8e93b1b 100644
--- a/compiler/dex/ssa_transformation.cc
+++ b/compiler/dex/ssa_transformation.cc
@@ -241,7 +241,7 @@ bool MIRGraph::ComputeDominanceFrontier(BasicBlock* bb) {
   /* Calculate DF_up */
   ArenaBitVector::Iterator bv_iterator(bb->i_dominated);
   while (true) {
-    //TUNING: hot call to BitVectorIteratorNext
+    // TUNING: hot call to BitVectorIteratorNext
     int dominated_idx = bv_iterator.Next();
     if (dominated_idx == -1) {
       break;
@@ -249,7 +249,7 @@ bool MIRGraph::ComputeDominanceFrontier(BasicBlock* bb) {
     BasicBlock* dominated_bb = GetBasicBlock(dominated_idx);
     ArenaBitVector::Iterator df_iterator(dominated_bb->dom_frontier);
     while (true) {
-      //TUNING: hot call to BitVectorIteratorNext
+      // TUNING: hot call to BitVectorIteratorNext
       int df_up_idx = df_iterator.Next();
       if (df_up_idx == -1) {
         break;
@@ -530,7 +530,7 @@ void MIRGraph::InsertPhiNodes() {
         BasicBlock* def_bb = GetBasicBlock(idx);
 
         /* Merge the dominance frontier to tmp_blocks */
-        //TUNING: hot call to Union().
+        // TUNING: hot call to Union().
         if (def_bb->dom_frontier != NULL) {
           tmp_blocks->Union(def_bb->dom_frontier);
         }
@@ -568,7 +568,7 @@ void MIRGraph::InsertPhiNodes() {
       phi->dalvikInsn.opcode = static_cast<Instruction::Code>(kMirOpPhi);
       phi->dalvikInsn.vA = dalvik_reg;
       phi->offset = phi_bb->start_offset;
-      phi->m_unit_index = 0; // Arbitrarily assign all Phi nodes to outermost method.
+      phi->m_unit_index = 0;  // Arbitrarily assign all Phi nodes to outermost method.
       PrependMIR(phi_bb, phi);
     }
   }
diff --git a/compiler/dex/vreg_analysis.cc b/compiler/dex/vreg_analysis.cc
index b50fe71b85..5ee675306d 100644
--- a/compiler/dex/vreg_analysis.cc
+++ b/compiler/dex/vreg_analysis.cc
@@ -333,7 +333,7 @@ bool MIRGraph::InferTypeAndSize(BasicBlock* bb) {
 static const char* storage_name[] = {" Frame ", "PhysReg", " Spill "};
 
 void MIRGraph::DumpRegLocTable(RegLocation* table, int count) {
-  //FIXME: Quick-specific.  Move to Quick (and make a generic version for MIRGraph?
+  // FIXME: Quick-specific.  Move to Quick (and make a generic version for MIRGraph?
   Mir2Lir* cg = static_cast<Mir2Lir*>(cu_->cg.get());
   if (cg != NULL) {
     for (int i = 0; i < count; i++) {
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index c2a1312354..038957e128 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -1628,416 +1628,416 @@ void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file
 }
 
 static const char* class_initializer_black_list[] = {
-  "Landroid/app/ActivityThread;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/bluetooth/BluetoothAudioGateway;", // Calls android.bluetooth.BluetoothAudioGateway.classInitNative().
-  "Landroid/bluetooth/HeadsetBase;", // Calls android.bluetooth.HeadsetBase.classInitNative().
-  "Landroid/content/res/CompatibilityInfo;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
-  "Landroid/content/res/CompatibilityInfo$1;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
-  "Landroid/content/UriMatcher;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/database/CursorWindow;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
-  "Landroid/database/sqlite/SQLiteConnection;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/database/sqlite/SQLiteConnection$Operation;", // Requires SimpleDateFormat -> java.util.Locale.
-  "Landroid/database/sqlite/SQLiteDatabaseConfiguration;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/database/sqlite/SQLiteDebug;", // Calls android.util.Log.isLoggable.
-  "Landroid/database/sqlite/SQLiteOpenHelper;", // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
-  "Landroid/database/sqlite/SQLiteQueryBuilder;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/drm/DrmManagerClient;", // Calls System.loadLibrary.
-  "Landroid/graphics/drawable/AnimatedRotateDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/AnimationDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/BitmapDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/ClipDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/ColorDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/Drawable;", // Requires android.graphics.Rect.
-  "Landroid/graphics/drawable/DrawableContainer;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/GradientDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/LayerDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/NinePatchDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/RotateDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/ScaleDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/ShapeDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/StateListDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/drawable/TransitionDrawable;", // Sub-class of Drawable.
-  "Landroid/graphics/Matrix;", // Calls android.graphics.Matrix.native_create.
-  "Landroid/graphics/Matrix$1;", // Requires Matrix.
-  "Landroid/graphics/PixelFormat;", // Calls android.graphics.PixelFormat.nativeClassInit().
-  "Landroid/graphics/Rect;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/graphics/SurfaceTexture;", // Calls android.graphics.SurfaceTexture.nativeClassInit().
-  "Landroid/graphics/Typeface;", // Calls android.graphics.Typeface.nativeCreate.
-  "Landroid/inputmethodservice/ExtractEditText;", // Requires android.widget.TextView.
-  "Landroid/media/AmrInputStream;", // Calls OsConstants.initConstants.
-  "Landroid/media/CamcorderProfile;", // Calls OsConstants.initConstants.
-  "Landroid/media/CameraProfile;", // Calls System.loadLibrary.
-  "Landroid/media/DecoderCapabilities;", // Calls System.loadLibrary.
-  "Landroid/media/EncoderCapabilities;", // Calls OsConstants.initConstants.
-  "Landroid/media/ExifInterface;", // Calls OsConstants.initConstants.
-  "Landroid/media/MediaCodec;", // Calls OsConstants.initConstants.
-  "Landroid/media/MediaCodecList;", // Calls OsConstants.initConstants.
-  "Landroid/media/MediaCrypto;", // Calls OsConstants.initConstants.
-  "Landroid/media/MediaDrm;", // Calls OsConstants.initConstants.
-  "Landroid/media/MediaExtractor;", // Calls OsConstants.initConstants.
-  "Landroid/media/MediaFile;", // Requires DecoderCapabilities.
-  "Landroid/media/MediaMetadataRetriever;", // Calls OsConstants.initConstants.
-  "Landroid/media/MediaMuxer;", // Calls OsConstants.initConstants.
-  "Landroid/media/MediaPlayer;", // Calls System.loadLibrary.
-  "Landroid/media/MediaRecorder;", // Calls System.loadLibrary.
-  "Landroid/media/MediaScanner;", // Calls System.loadLibrary.
-  "Landroid/media/ResampleInputStream;", // Calls OsConstants.initConstants.
-  "Landroid/media/SoundPool;", // Calls OsConstants.initConstants.
-  "Landroid/media/videoeditor/MediaArtistNativeHelper;", // Calls OsConstants.initConstants.
-  "Landroid/media/videoeditor/VideoEditorProfile;", // Calls OsConstants.initConstants.
-  "Landroid/mtp/MtpDatabase;", // Calls OsConstants.initConstants.
-  "Landroid/mtp/MtpDevice;", // Calls OsConstants.initConstants.
-  "Landroid/mtp/MtpServer;", // Calls OsConstants.initConstants.
-  "Landroid/net/NetworkInfo;", // Calls java.util.EnumMap.<init> -> java.lang.Enum.getSharedConstants -> System.identityHashCode.
-  "Landroid/net/Proxy;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/net/SSLCertificateSocketFactory;", // Requires javax.net.ssl.HttpsURLConnection.
-  "Landroid/net/Uri;", // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
-  "Landroid/net/Uri$AbstractHierarchicalUri;", // Requires Uri.
-  "Landroid/net/Uri$HierarchicalUri;", // Requires Uri.
-  "Landroid/net/Uri$OpaqueUri;", // Requires Uri.
-  "Landroid/net/Uri$StringUri;", // Requires Uri.
-  "Landroid/net/WebAddress;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/nfc/NdefRecord;", // Calls String.getBytes -> java.nio.charset.Charset.
-  "Landroid/opengl/EGL14;", // Calls android.opengl.EGL14._nativeClassInit.
-  "Landroid/opengl/GLES10;", // Calls android.opengl.GLES10._nativeClassInit.
-  "Landroid/opengl/GLES10Ext;", // Calls android.opengl.GLES10Ext._nativeClassInit.
-  "Landroid/opengl/GLES11;", // Requires GLES10.
-  "Landroid/opengl/GLES11Ext;", // Calls android.opengl.GLES11Ext._nativeClassInit.
-  "Landroid/opengl/GLES20;", // Calls android.opengl.GLES20._nativeClassInit.
-  "Landroid/opengl/GLUtils;", // Calls android.opengl.GLUtils.nativeClassInit.
-  "Landroid/os/Build;", // Calls -..-> android.os.SystemProperties.native_get.
-  "Landroid/os/Build$VERSION;", // Requires Build.
-  "Landroid/os/Debug;", // Requires android.os.Environment.
-  "Landroid/os/Environment;", // Calls System.getenv.
-  "Landroid/os/FileUtils;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/os/StrictMode;", // Calls android.util.Log.isLoggable.
-  "Landroid/os/StrictMode$VmPolicy;", // Requires StrictMode.
-  "Landroid/os/Trace;", // Calls android.os.Trace.nativeGetEnabledTags.
-  "Landroid/os/UEventObserver;", // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
-  "Landroid/provider/ContactsContract;", // Calls OsConstants.initConstants.
-  "Landroid/provider/Settings$Global;", // Calls OsConstants.initConstants.
-  "Landroid/provider/Settings$Secure;", // Requires android.net.Uri.
-  "Landroid/provider/Settings$System;", // Requires android.net.Uri.
-  "Landroid/renderscript/RenderScript;", // Calls System.loadLibrary.
-  "Landroid/server/BluetoothService;", // Calls android.server.BluetoothService.classInitNative.
-  "Landroid/server/BluetoothEventLoop;", // Calls android.server.BluetoothEventLoop.classInitNative.
-  "Landroid/telephony/PhoneNumberUtils;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/telephony/TelephonyManager;", // Calls OsConstants.initConstants.
-  "Landroid/text/AutoText;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
-  "Landroid/text/Layout;", // Calls com.android.internal.util.ArrayUtils.emptyArray -> System.identityHashCode.
-  "Landroid/text/BoringLayout;", // Requires Layout.
-  "Landroid/text/DynamicLayout;", // Requires Layout.
-  "Landroid/text/Html$HtmlParser;", // Calls -..-> String.toLowerCase -> java.util.Locale.
-  "Landroid/text/StaticLayout;", // Requires Layout.
-  "Landroid/text/TextUtils;", // Requires android.util.DisplayMetrics.
-  "Landroid/util/DisplayMetrics;", // Calls SystemProperties.native_get_int.
-  "Landroid/util/Patterns;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/view/Choreographer;", // Calls SystemProperties.native_get_boolean.
-  "Landroid/util/Patterns;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/view/GLES20Canvas;", // Calls GLES20Canvas.nIsAvailable().
-  "Landroid/view/GLES20RecordingCanvas;", // Requires android.view.GLES20Canvas.
-  "Landroid/view/GestureDetector;", // Calls android.view.GLES20Canvas.nIsAvailable.
-  "Landroid/view/HardwareRenderer$Gl20Renderer;", // Requires SystemProperties.native_get.
-  "Landroid/view/HardwareRenderer$GlRenderer;", // Requires SystemProperties.native_get.
-  "Landroid/view/InputEventConsistencyVerifier;", // Requires android.os.Build.
-  "Landroid/view/Surface;", // Requires SystemProperties.native_get.
-  "Landroid/view/SurfaceControl;", // Calls OsConstants.initConstants.
-  "Landroid/view/animation/AlphaAnimation;", // Requires Animation.
-  "Landroid/view/animation/Animation;", // Calls SystemProperties.native_get_boolean.
-  "Landroid/view/animation/AnimationSet;", // Calls OsConstants.initConstants.
-  "Landroid/view/textservice/SpellCheckerSubtype;", // Calls Class.getDex().
-  "Landroid/webkit/JniUtil;", // Calls System.loadLibrary.
-  "Landroid/webkit/PluginManager;", // // Calls OsConstants.initConstants.
-  "Landroid/webkit/WebViewCore;", // Calls System.loadLibrary.
+  "Landroid/app/ActivityThread;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/bluetooth/BluetoothAudioGateway;",  // Calls android.bluetooth.BluetoothAudioGateway.classInitNative().
+  "Landroid/bluetooth/HeadsetBase;",  // Calls android.bluetooth.HeadsetBase.classInitNative().
+  "Landroid/content/res/CompatibilityInfo;",  // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
+  "Landroid/content/res/CompatibilityInfo$1;",  // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
+  "Landroid/content/UriMatcher;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/database/CursorWindow;",  // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
+  "Landroid/database/sqlite/SQLiteConnection;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/database/sqlite/SQLiteConnection$Operation;",  // Requires SimpleDateFormat -> java.util.Locale.
+  "Landroid/database/sqlite/SQLiteDatabaseConfiguration;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/database/sqlite/SQLiteDebug;",  // Calls android.util.Log.isLoggable.
+  "Landroid/database/sqlite/SQLiteOpenHelper;",  // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
+  "Landroid/database/sqlite/SQLiteQueryBuilder;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/drm/DrmManagerClient;",  // Calls System.loadLibrary.
+  "Landroid/graphics/drawable/AnimatedRotateDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/AnimationDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/BitmapDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/ClipDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/ColorDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/Drawable;",  // Requires android.graphics.Rect.
+  "Landroid/graphics/drawable/DrawableContainer;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/GradientDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/LayerDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/NinePatchDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/RotateDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/ScaleDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/ShapeDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/StateListDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/drawable/TransitionDrawable;",  // Sub-class of Drawable.
+  "Landroid/graphics/Matrix;",  // Calls android.graphics.Matrix.native_create.
+  "Landroid/graphics/Matrix$1;",  // Requires Matrix.
+  "Landroid/graphics/PixelFormat;",  // Calls android.graphics.PixelFormat.nativeClassInit().
+  "Landroid/graphics/Rect;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/graphics/SurfaceTexture;",  // Calls android.graphics.SurfaceTexture.nativeClassInit().
+  "Landroid/graphics/Typeface;",  // Calls android.graphics.Typeface.nativeCreate.
+  "Landroid/inputmethodservice/ExtractEditText;",  // Requires android.widget.TextView.
+  "Landroid/media/AmrInputStream;",  // Calls OsConstants.initConstants.
+  "Landroid/media/CamcorderProfile;",  // Calls OsConstants.initConstants.
+  "Landroid/media/CameraProfile;",  // Calls System.loadLibrary.
+  "Landroid/media/DecoderCapabilities;",  // Calls System.loadLibrary.
+  "Landroid/media/EncoderCapabilities;",  // Calls OsConstants.initConstants.
+  "Landroid/media/ExifInterface;",  // Calls OsConstants.initConstants.
+  "Landroid/media/MediaCodec;",  // Calls OsConstants.initConstants.
+  "Landroid/media/MediaCodecList;",  // Calls OsConstants.initConstants.
+  "Landroid/media/MediaCrypto;",  // Calls OsConstants.initConstants.
+  "Landroid/media/MediaDrm;",  // Calls OsConstants.initConstants.
+  "Landroid/media/MediaExtractor;",  // Calls OsConstants.initConstants.
+  "Landroid/media/MediaFile;",  // Requires DecoderCapabilities.
+  "Landroid/media/MediaMetadataRetriever;",  // Calls OsConstants.initConstants.
+  "Landroid/media/MediaMuxer;",  // Calls OsConstants.initConstants.
+  "Landroid/media/MediaPlayer;",  // Calls System.loadLibrary.
+  "Landroid/media/MediaRecorder;",  // Calls System.loadLibrary.
+  "Landroid/media/MediaScanner;",  // Calls System.loadLibrary.
+  "Landroid/media/ResampleInputStream;",  // Calls OsConstants.initConstants.
+  "Landroid/media/SoundPool;",  // Calls OsConstants.initConstants.
+  "Landroid/media/videoeditor/MediaArtistNativeHelper;",  // Calls OsConstants.initConstants.
+  "Landroid/media/videoeditor/VideoEditorProfile;",  // Calls OsConstants.initConstants.
+  "Landroid/mtp/MtpDatabase;",  // Calls OsConstants.initConstants.
+  "Landroid/mtp/MtpDevice;",  // Calls OsConstants.initConstants.
+  "Landroid/mtp/MtpServer;",  // Calls OsConstants.initConstants.
+  "Landroid/net/NetworkInfo;",  // Calls java.util.EnumMap.<init> -> java.lang.Enum.getSharedConstants -> System.identityHashCode.
+  "Landroid/net/Proxy;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/net/SSLCertificateSocketFactory;",  // Requires javax.net.ssl.HttpsURLConnection.
+  "Landroid/net/Uri;",  // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
+  "Landroid/net/Uri$AbstractHierarchicalUri;",  // Requires Uri.
+  "Landroid/net/Uri$HierarchicalUri;",  // Requires Uri.
+  "Landroid/net/Uri$OpaqueUri;",  // Requires Uri.
+  "Landroid/net/Uri$StringUri;",  // Requires Uri.
+  "Landroid/net/WebAddress;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/nfc/NdefRecord;",  // Calls String.getBytes -> java.nio.charset.Charset.
+  "Landroid/opengl/EGL14;",  // Calls android.opengl.EGL14._nativeClassInit.
+  "Landroid/opengl/GLES10;",  // Calls android.opengl.GLES10._nativeClassInit.
+  "Landroid/opengl/GLES10Ext;",  // Calls android.opengl.GLES10Ext._nativeClassInit.
+  "Landroid/opengl/GLES11;",  // Requires GLES10.
+  "Landroid/opengl/GLES11Ext;",  // Calls android.opengl.GLES11Ext._nativeClassInit.
+  "Landroid/opengl/GLES20;",  // Calls android.opengl.GLES20._nativeClassInit.
+  "Landroid/opengl/GLUtils;",  // Calls android.opengl.GLUtils.nativeClassInit.
+  "Landroid/os/Build;",  // Calls -..-> android.os.SystemProperties.native_get.
+  "Landroid/os/Build$VERSION;",  // Requires Build.
+  "Landroid/os/Debug;",  // Requires android.os.Environment.
+  "Landroid/os/Environment;",  // Calls System.getenv.
+  "Landroid/os/FileUtils;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/os/StrictMode;",  // Calls android.util.Log.isLoggable.
+  "Landroid/os/StrictMode$VmPolicy;",  // Requires StrictMode.
+  "Landroid/os/Trace;",  // Calls android.os.Trace.nativeGetEnabledTags.
+  "Landroid/os/UEventObserver;",  // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
+  "Landroid/provider/ContactsContract;",  // Calls OsConstants.initConstants.
+  "Landroid/provider/Settings$Global;",  // Calls OsConstants.initConstants.
+  "Landroid/provider/Settings$Secure;",  // Requires android.net.Uri.
+  "Landroid/provider/Settings$System;",  // Requires android.net.Uri.
+  "Landroid/renderscript/RenderScript;",  // Calls System.loadLibrary.
+  "Landroid/server/BluetoothService;",  // Calls android.server.BluetoothService.classInitNative.
+  "Landroid/server/BluetoothEventLoop;",  // Calls android.server.BluetoothEventLoop.classInitNative.
+  "Landroid/telephony/PhoneNumberUtils;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/telephony/TelephonyManager;",  // Calls OsConstants.initConstants.
+  "Landroid/text/AutoText;",  // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int.
+  "Landroid/text/Layout;",  // Calls com.android.internal.util.ArrayUtils.emptyArray -> System.identityHashCode.
+  "Landroid/text/BoringLayout;",  // Requires Layout.
+  "Landroid/text/DynamicLayout;",  // Requires Layout.
+  "Landroid/text/Html$HtmlParser;",  // Calls -..-> String.toLowerCase -> java.util.Locale.
+  "Landroid/text/StaticLayout;",  // Requires Layout.
+  "Landroid/text/TextUtils;",  // Requires android.util.DisplayMetrics.
+  "Landroid/util/DisplayMetrics;",  // Calls SystemProperties.native_get_int.
+  "Landroid/util/Patterns;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/view/Choreographer;",  // Calls SystemProperties.native_get_boolean.
+  "Landroid/util/Patterns;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/view/GLES20Canvas;",  // Calls GLES20Canvas.nIsAvailable().
+  "Landroid/view/GLES20RecordingCanvas;",  // Requires android.view.GLES20Canvas.
+  "Landroid/view/GestureDetector;",  // Calls android.view.GLES20Canvas.nIsAvailable.
+  "Landroid/view/HardwareRenderer$Gl20Renderer;",  // Requires SystemProperties.native_get.
+  "Landroid/view/HardwareRenderer$GlRenderer;",  // Requires SystemProperties.native_get.
+  "Landroid/view/InputEventConsistencyVerifier;",  // Requires android.os.Build.
+  "Landroid/view/Surface;",  // Requires SystemProperties.native_get.
+  "Landroid/view/SurfaceControl;",  // Calls OsConstants.initConstants.
+  "Landroid/view/animation/AlphaAnimation;",  // Requires Animation.
+  "Landroid/view/animation/Animation;",  // Calls SystemProperties.native_get_boolean.
+  "Landroid/view/animation/AnimationSet;",  // Calls OsConstants.initConstants.
+  "Landroid/view/textservice/SpellCheckerSubtype;",  // Calls Class.getDex().
+  "Landroid/webkit/JniUtil;",  // Calls System.loadLibrary.
+  "Landroid/webkit/PluginManager;",  // // Calls OsConstants.initConstants.
+  "Landroid/webkit/WebViewCore;",  // Calls System.loadLibrary.
   "Landroid/webkit/WebViewFactory$Preloader;",  // Calls to Class.forName.
-  "Landroid/webkit/WebViewInputDispatcher;", // Calls Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/webkit/URLUtil;", // Calls Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Landroid/widget/AutoCompleteTextView;", // Requires TextView.
-  "Landroid/widget/Button;", // Requires TextView.
-  "Landroid/widget/CheckBox;", // Requires TextView.
-  "Landroid/widget/CheckedTextView;", // Requires TextView.
-  "Landroid/widget/CompoundButton;", // Requires TextView.
-  "Landroid/widget/EditText;", // Requires TextView.
-  "Landroid/widget/NumberPicker;", // Requires java.util.Locale.
-  "Landroid/widget/ScrollBarDrawable;", // Sub-class of Drawable.
-  "Landroid/widget/SearchView$SearchAutoComplete;", // Requires TextView.
-  "Landroid/widget/Switch;", // Requires TextView.
-  "Landroid/widget/TextView;", // Calls Paint.<init> -> Paint.native_init.
-  "Lcom/android/i18n/phonenumbers/AsYouTypeFormatter;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Lcom/android/i18n/phonenumbers/MetadataManager;", // Calls OsConstants.initConstants.
-  "Lcom/android/i18n/phonenumbers/PhoneNumberMatcher;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Lcom/android/i18n/phonenumbers/PhoneNumberUtil;", // Requires java.util.logging.LogManager.
-  "Lcom/android/i18n/phonenumbers/geocoding/AreaCodeMap;", // Calls OsConstants.initConstants.
-  "Lcom/android/i18n/phonenumbers/geocoding/PhoneNumberOfflineGeocoder;", // Calls OsConstants.initConstants.
-  "Lcom/android/internal/os/SamplingProfilerIntegration;", // Calls SystemProperties.native_get_int.
-  "Lcom/android/internal/policy/impl/PhoneWindow;", // Calls android.os.Binder.init.
-  "Lcom/android/internal/view/menu/ActionMenuItemView;", // Requires TextView.
-  "Lcom/android/internal/widget/DialogTitle;", // Requires TextView.
-  "Lcom/android/org/bouncycastle/asn1/StreamUtil;", // Calls Runtime.getRuntime().maxMemory().
-  "Lcom/android/org/bouncycastle/asn1/pkcs/MacData;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/asn1/pkcs/RSASSAPSSparams;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/asn1/cms/SignedData;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/asn1/x509/GeneralSubtree;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/asn1/x9/X9ECParameters;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$MD5;", // Requires com.android.org.conscrypt.NativeCrypto.
-  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA1;", // Requires com.android.org.conscrypt.NativeCrypto.
-  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA256;", // Requires com.android.org.conscrypt.NativeCrypto.
-  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA384;", // Requires com.android.org.conscrypt.NativeCrypto.
-  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA512;", // Requires com.android.org.conscrypt.NativeCrypto.
-  "Lcom/android/org/bouncycastle/crypto/engines/RSABlindedEngine;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/crypto/generators/DHKeyGeneratorHelper;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/crypto/generators/DHParametersGenerator;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/crypto/generators/DHParametersHelper;", // Calls System.getenv -> OsConstants.initConstants.
-  "Lcom/android/org/bouncycastle/crypto/generators/DSAKeyPairGenerator;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/crypto/generators/DSAParametersGenerator;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/crypto/generators/RSAKeyPairGenerator;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/dsa/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$EC;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDH;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDHC;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDSA;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECMQV;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/BCRSAPrivateCrtKey;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/BCRSAPrivateKey;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/bouncycastle/jcajce/provider/keystore/pkcs12/PKCS12KeyStoreSpi$BCPKCS12KeyStore;", // Calls Thread.currentThread.
-  "Lcom/android/org/bouncycastle/jcajce/provider/keystore/pkcs12/PKCS12KeyStoreSpi;", // Calls Thread.currentThread.
-  "Lcom/android/org/bouncycastle/jce/PKCS10CertificationRequest;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/jce/provider/CertBlacklist;", // Calls System.getenv -> OsConstants.initConstants.
-  "Lcom/android/org/bouncycastle/jce/provider/JCERSAPrivateCrtKey;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/jce/provider/JCERSAPrivateKey;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/jce/provider/PKIXCertPathValidatorSpi;", // Calls System.getenv -> OsConstants.initConstants.
-  "Lcom/android/org/bouncycastle/math/ec/ECConstants;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/math/ec/Tnaf;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/util/BigIntegers;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/bouncycastle/x509/X509Util;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lcom/android/org/conscrypt/CipherSuite;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/conscrypt/FileClientSessionCache$CacheFile;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/conscrypt/HandshakeIODataStream;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/conscrypt/Logger;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/conscrypt/NativeCrypto;", // Calls native NativeCrypto.clinit().
-  "Lcom/android/org/conscrypt/OpenSSLECKeyPairGenerator;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/conscrypt/OpenSSLEngine;", // Requires com.android.org.conscrypt.NativeCrypto.
-  "Lcom/android/org/conscrypt/OpenSSLMac$HmacMD5;", // Calls native NativeCrypto.clinit().
-  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA1;", // Calls native NativeCrypto.clinit().
-  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA256;", // Calls native NativeCrypto.clinit().
-  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA384;", // Calls native NativeCrypto.clinit().
-  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA512;", // Calls native NativeCrypto.clinit().
-  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$MD5;", // Requires com.android.org.conscrypt.NativeCrypto.
-  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA1;", // Requires com.android.org.conscrypt.NativeCrypto.
-  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA256;", // Requires com.android.org.conscrypt.NativeCrypto.
-  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA384;", // Requires com.android.org.conscrypt.NativeCrypto.
-  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA512;", // Requires com.android.org.conscrypt.NativeCrypto.
-  "Lcom/android/org/conscrypt/OpenSSLX509CertPath;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/conscrypt/OpenSSLX509CertificateFactory;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/conscrypt/PRF;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/conscrypt/SSLSessionImpl;", // Calls OsConstants.initConstants.
-  "Lcom/android/org/conscrypt/TrustedCertificateStore;", // Calls System.getenv -> OsConstants.initConstants.
-  "Lcom/android/okhttp/ConnectionPool;", // Calls OsConstants.initConstants.
-  "Lcom/android/okhttp/OkHttpClient;", // Calls OsConstants.initConstants.
-  "Lcom/android/okhttp/internal/DiskLruCache;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Lcom/android/okhttp/internal/Util;", // Calls OsConstants.initConstants.
-  "Lcom/android/okhttp/internal/http/HttpsURLConnectionImpl;", // Calls VMClassLoader.getBootClassPathSize.
-  "Lcom/android/okhttp/internal/spdy/SpdyConnection;", // Calls OsConstants.initConstants.
-  "Lcom/android/okhttp/internal/spdy/SpdyReader;", // Calls OsConstants.initConstants.
-  "Lcom/android/okhttp/internal/tls/OkHostnameVerifier;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Lcom/google/android/gles_jni/EGLContextImpl;", // Calls com.google.android.gles_jni.EGLImpl._nativeClassInit.
-  "Lcom/google/android/gles_jni/EGLImpl;", // Calls com.google.android.gles_jni.EGLImpl._nativeClassInit.
-  "Lcom/google/android/gles_jni/GLImpl;", // Calls com.google.android.gles_jni.GLImpl._nativeClassInit.
-  "Lgov/nist/core/GenericObject;", // Calls OsConstants.initConstants.
-  "Lgov/nist/core/Host;", // Calls OsConstants.initConstants.
-  "Lgov/nist/core/HostPort;", // Calls OsConstants.initConstants.
-  "Lgov/nist/core/NameValue;", // Calls OsConstants.initConstants.
-  "Lgov/nist/core/net/DefaultNetworkLayer;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/Utils;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/address/AddressImpl;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/address/Authority;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/address/GenericURI;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/address/NetObject;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/address/SipUri;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/address/TelephoneNumber;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/address/UserInfo;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/Accept;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/AcceptEncoding;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/AcceptLanguage;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/AddressParametersHeader;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/AlertInfoList;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/AllowEvents;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/AllowEventsList;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/AuthenticationInfo;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/Authorization;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/CSeq;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/CallIdentifier;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/Challenge;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ContactList;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ContentEncoding;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ContentEncodingList;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ContentLanguageList;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ContentType;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/Credentials;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ErrorInfoList;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/Expires;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/From;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/MimeVersion;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/NameMap;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/Priority;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/Protocol;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ProxyAuthenticate;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ProxyAuthenticateList;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ProxyAuthorizationList;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ProxyRequire;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ProxyRequireList;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/RSeq;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/RecordRoute;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ReferTo;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/RequestLine;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/Require;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/RetryAfter;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/SIPETag;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/SIPHeader;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/SIPHeaderNamesCache;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/StatusLine;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/SubscriptionState;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/TimeStamp;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/UserAgent;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/Unsupported;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/Warning;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ViaList;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/extensions/Join;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/extensions/References;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/extensions/Replaces;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ims/PAccessNetworkInfo;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ims/PAssertedIdentity;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ims/PAssertedIdentityList;", // Calls OsConstants.initConstants.
+  "Landroid/webkit/WebViewInputDispatcher;",  // Calls Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/webkit/URLUtil;",  // Calls Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/widget/AutoCompleteTextView;",  // Requires TextView.
+  "Landroid/widget/Button;",  // Requires TextView.
+  "Landroid/widget/CheckBox;",  // Requires TextView.
+  "Landroid/widget/CheckedTextView;",  // Requires TextView.
+  "Landroid/widget/CompoundButton;",  // Requires TextView.
+  "Landroid/widget/EditText;",  // Requires TextView.
+  "Landroid/widget/NumberPicker;",  // Requires java.util.Locale.
+  "Landroid/widget/ScrollBarDrawable;",  // Sub-class of Drawable.
+  "Landroid/widget/SearchView$SearchAutoComplete;",  // Requires TextView.
+  "Landroid/widget/Switch;",  // Requires TextView.
+  "Landroid/widget/TextView;",  // Calls Paint.<init> -> Paint.native_init.
+  "Lcom/android/i18n/phonenumbers/AsYouTypeFormatter;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Lcom/android/i18n/phonenumbers/MetadataManager;",  // Calls OsConstants.initConstants.
+  "Lcom/android/i18n/phonenumbers/PhoneNumberMatcher;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Lcom/android/i18n/phonenumbers/PhoneNumberUtil;",  // Requires java.util.logging.LogManager.
+  "Lcom/android/i18n/phonenumbers/geocoding/AreaCodeMap;",  // Calls OsConstants.initConstants.
+  "Lcom/android/i18n/phonenumbers/geocoding/PhoneNumberOfflineGeocoder;",  // Calls OsConstants.initConstants.
+  "Lcom/android/internal/os/SamplingProfilerIntegration;",  // Calls SystemProperties.native_get_int.
+  "Lcom/android/internal/policy/impl/PhoneWindow;",  // Calls android.os.Binder.init.
+  "Lcom/android/internal/view/menu/ActionMenuItemView;",  // Requires TextView.
+  "Lcom/android/internal/widget/DialogTitle;",  // Requires TextView.
+  "Lcom/android/org/bouncycastle/asn1/StreamUtil;",  // Calls Runtime.getRuntime().maxMemory().
+  "Lcom/android/org/bouncycastle/asn1/pkcs/MacData;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/asn1/pkcs/RSASSAPSSparams;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/asn1/cms/SignedData;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/asn1/x509/GeneralSubtree;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/asn1/x9/X9ECParameters;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$MD5;",  // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA1;",  // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA256;",  // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA384;",  // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA512;",  // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/bouncycastle/crypto/engines/RSABlindedEngine;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/crypto/generators/DHKeyGeneratorHelper;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/crypto/generators/DHParametersGenerator;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/crypto/generators/DHParametersHelper;",  // Calls System.getenv -> OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/crypto/generators/DSAKeyPairGenerator;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/crypto/generators/DSAParametersGenerator;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/crypto/generators/RSAKeyPairGenerator;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyPairGeneratorSpi;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/dsa/KeyPairGeneratorSpi;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$EC;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDH;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDHC;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDSA;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECMQV;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/BCRSAPrivateCrtKey;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/BCRSAPrivateKey;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/KeyPairGeneratorSpi;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jcajce/provider/keystore/pkcs12/PKCS12KeyStoreSpi$BCPKCS12KeyStore;",  // Calls Thread.currentThread.
+  "Lcom/android/org/bouncycastle/jcajce/provider/keystore/pkcs12/PKCS12KeyStoreSpi;",  // Calls Thread.currentThread.
+  "Lcom/android/org/bouncycastle/jce/PKCS10CertificationRequest;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/jce/provider/CertBlacklist;",  // Calls System.getenv -> OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/jce/provider/JCERSAPrivateCrtKey;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/jce/provider/JCERSAPrivateKey;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/jce/provider/PKIXCertPathValidatorSpi;",  // Calls System.getenv -> OsConstants.initConstants.
+  "Lcom/android/org/bouncycastle/math/ec/ECConstants;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/math/ec/Tnaf;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/util/BigIntegers;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/bouncycastle/x509/X509Util;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lcom/android/org/conscrypt/CipherSuite;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/FileClientSessionCache$CacheFile;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/HandshakeIODataStream;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/Logger;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/NativeCrypto;",  // Calls native NativeCrypto.clinit().
+  "Lcom/android/org/conscrypt/OpenSSLECKeyPairGenerator;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/OpenSSLEngine;",  // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/conscrypt/OpenSSLMac$HmacMD5;",  // Calls native NativeCrypto.clinit().
+  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA1;",  // Calls native NativeCrypto.clinit().
+  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA256;",  // Calls native NativeCrypto.clinit().
+  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA384;",  // Calls native NativeCrypto.clinit().
+  "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA512;",  // Calls native NativeCrypto.clinit().
+  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$MD5;",  // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA1;",  // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA256;",  // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA384;",  // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA512;",  // Requires com.android.org.conscrypt.NativeCrypto.
+  "Lcom/android/org/conscrypt/OpenSSLX509CertPath;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/OpenSSLX509CertificateFactory;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/PRF;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/SSLSessionImpl;",  // Calls OsConstants.initConstants.
+  "Lcom/android/org/conscrypt/TrustedCertificateStore;",  // Calls System.getenv -> OsConstants.initConstants.
+  "Lcom/android/okhttp/ConnectionPool;",  // Calls OsConstants.initConstants.
+  "Lcom/android/okhttp/OkHttpClient;",  // Calls OsConstants.initConstants.
+  "Lcom/android/okhttp/internal/DiskLruCache;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Lcom/android/okhttp/internal/Util;",  // Calls OsConstants.initConstants.
+  "Lcom/android/okhttp/internal/http/HttpsURLConnectionImpl;",  // Calls VMClassLoader.getBootClassPathSize.
+  "Lcom/android/okhttp/internal/spdy/SpdyConnection;",  // Calls OsConstants.initConstants.
+  "Lcom/android/okhttp/internal/spdy/SpdyReader;",  // Calls OsConstants.initConstants.
+  "Lcom/android/okhttp/internal/tls/OkHostnameVerifier;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Lcom/google/android/gles_jni/EGLContextImpl;",  // Calls com.google.android.gles_jni.EGLImpl._nativeClassInit.
+  "Lcom/google/android/gles_jni/EGLImpl;",  // Calls com.google.android.gles_jni.EGLImpl._nativeClassInit.
+  "Lcom/google/android/gles_jni/GLImpl;",  // Calls com.google.android.gles_jni.GLImpl._nativeClassInit.
+  "Lgov/nist/core/GenericObject;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/core/Host;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/core/HostPort;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/core/NameValue;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/core/net/DefaultNetworkLayer;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/Utils;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/AddressImpl;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/Authority;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/GenericURI;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/NetObject;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/SipUri;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/TelephoneNumber;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/address/UserInfo;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Accept;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AcceptEncoding;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AcceptLanguage;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AddressParametersHeader;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AlertInfoList;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AllowEvents;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AllowEventsList;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/AuthenticationInfo;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Authorization;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/CSeq;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/CallIdentifier;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Challenge;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ContactList;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ContentEncoding;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ContentEncodingList;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ContentLanguageList;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ContentType;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Credentials;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ErrorInfoList;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Expires;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/From;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/MimeVersion;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/NameMap;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Priority;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Protocol;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ProxyAuthenticate;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ProxyAuthenticateList;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ProxyAuthorizationList;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ProxyRequire;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ProxyRequireList;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/RSeq;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/RecordRoute;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ReferTo;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/RequestLine;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Require;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/RetryAfter;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/SIPETag;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/SIPHeader;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/SIPHeaderNamesCache;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/StatusLine;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/SubscriptionState;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/TimeStamp;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/UserAgent;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Unsupported;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/Warning;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ViaList;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/extensions/Join;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/extensions/References;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/extensions/Replaces;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PAccessNetworkInfo;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PAssertedIdentity;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PAssertedIdentityList;",  // Calls OsConstants.initConstants.
   "Lgov/nist/javax/sip/header/ims/PAssociatedURI;",  // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ims/PCalledPartyID;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ims/PChargingVector;", // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PCalledPartyID;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PChargingVector;",  // Calls OsConstants.initConstants.
   "Lgov/nist/javax/sip/header/ims/PPreferredIdentity;",  // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ims/PVisitedNetworkIDList;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ims/PathList;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ims/SecurityAgree;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ims/SecurityClient;", // Calls OsConstants.initConstants.
-  "Lgov/nist/javax/sip/header/ims/ServiceRoute;", // Calls OsConstants.initConstants.
-  "Ljava/io/Console;", // Has FileDescriptor(s).
-  "Ljava/io/File;", // Calls to Random.<init> -> System.currentTimeMillis -> OsConstants.initConstants.
-  "Ljava/io/FileDescriptor;", // Requires libcore.io.OsConstants.
-  "Ljava/io/ObjectInputStream;", // Requires java.lang.ClassLoader$SystemClassLoader.
+  "Lgov/nist/javax/sip/header/ims/PVisitedNetworkIDList;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/PathList;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/SecurityAgree;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/SecurityClient;",  // Calls OsConstants.initConstants.
+  "Lgov/nist/javax/sip/header/ims/ServiceRoute;",  // Calls OsConstants.initConstants.
+  "Ljava/io/Console;",  // Has FileDescriptor(s).
+  "Ljava/io/File;",  // Calls to Random.<init> -> System.currentTimeMillis -> OsConstants.initConstants.
+  "Ljava/io/FileDescriptor;",  // Requires libcore.io.OsConstants.
+  "Ljava/io/ObjectInputStream;",  // Requires java.lang.ClassLoader$SystemClassLoader.
   "Ljava/io/ObjectStreamClass;",  // Calls to Class.forName -> java.io.FileDescriptor.
-  "Ljava/io/ObjectStreamConstants;", // Instance of non-image class SerializablePermission.
-  "Ljava/lang/ClassLoader$SystemClassLoader;", // Calls System.getProperty -> OsConstants.initConstants.
-  "Ljava/lang/HexStringParser;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Ljava/lang/ProcessManager;", // Calls Thread.currentThread.
-  "Ljava/lang/Runtime;", // Calls System.getProperty -> OsConstants.initConstants.
-  "Ljava/lang/System;", // Calls OsConstants.initConstants.
-  "Ljava/math/BigDecimal;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Ljava/math/BigInteger;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Ljava/math/Primality;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Ljava/math/Multiplication;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Ljava/net/InetAddress;", // Requires libcore.io.OsConstants.
-  "Ljava/net/Inet4Address;", // Sub-class of InetAddress.
-  "Ljava/net/Inet6Address;", // Sub-class of InetAddress.
-  "Ljava/net/InetUnixAddress;", // Sub-class of InetAddress.
-  "Ljava/nio/charset/Charset;", // Calls Charset.getDefaultCharset -> System.getProperty -> OsConstants.initConstants.
-  "Ljava/nio/charset/CharsetICU;", // Sub-class of Charset.
-  "Ljava/nio/charset/Charsets;", // Calls Charset.forName.
-  "Ljava/nio/charset/StandardCharsets;", // Calls OsConstants.initConstants.
-  "Ljava/security/AlgorithmParameterGenerator;", // Calls OsConstants.initConstants.
-  "Ljava/security/KeyPairGenerator$KeyPairGeneratorImpl;", // Calls OsConstants.initConstants.
-  "Ljava/security/KeyPairGenerator;", // Calls OsConstants.initConstants.
-  "Ljava/security/Security;", // Tries to do disk IO for "security.properties".
-  "Ljava/security/spec/RSAKeyGenParameterSpec;", // java.math.NativeBN.BN_new()
-  "Ljava/sql/Date;", // Calls OsConstants.initConstants.
-  "Ljava/sql/DriverManager;", // Calls OsConstants.initConstants.
-  "Ljava/sql/Time;", // Calls OsConstants.initConstants.
-  "Ljava/sql/Timestamp;", // Calls OsConstants.initConstants.
-  "Ljava/util/Date;", // Calls Date.<init> -> System.currentTimeMillis -> OsConstants.initConstants.
-  "Ljava/util/ListResourceBundle;", // Calls OsConstants.initConstants.
-  "Ljava/util/Locale;", // Calls System.getProperty -> OsConstants.initConstants.
-  "Ljava/util/PropertyResourceBundle;", // Calls OsConstants.initConstants.
-  "Ljava/util/ResourceBundle;", // Calls OsConstants.initConstants.
-  "Ljava/util/ResourceBundle$MissingBundle;", // Calls OsConstants.initConstants.
-  "Ljava/util/Scanner;", // regex.Pattern.compileImpl.
-  "Ljava/util/SimpleTimeZone;", // Sub-class of TimeZone.
-  "Ljava/util/TimeZone;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Ljava/util/concurrent/ConcurrentHashMap$Segment;", // Calls Runtime.getRuntime().availableProcessors().
-  "Ljava/util/concurrent/ConcurrentSkipListMap;", // Calls OsConstants.initConstants.
-  "Ljava/util/concurrent/Exchanger;", // Calls OsConstants.initConstants.
-  "Ljava/util/concurrent/ForkJoinPool;", // Calls OsConstants.initConstants.
-  "Ljava/util/concurrent/LinkedTransferQueue;", // Calls OsConstants.initConstants.
-  "Ljava/util/concurrent/Phaser;", // Calls OsConstants.initConstants.
-  "Ljava/util/concurrent/ScheduledThreadPoolExecutor;", // Calls AtomicLong.VMSupportsCS8()
-  "Ljava/util/concurrent/SynchronousQueue;", // Calls OsConstants.initConstants.
-  "Ljava/util/concurrent/atomic/AtomicLong;", // Calls AtomicLong.VMSupportsCS8()
-  "Ljava/util/logging/LogManager;", // Calls System.getProperty -> OsConstants.initConstants.
-  "Ljava/util/prefs/AbstractPreferences;", // Calls OsConstants.initConstants.
-  "Ljava/util/prefs/FilePreferencesImpl;", // Calls OsConstants.initConstants.
-  "Ljava/util/prefs/FilePreferencesFactoryImpl;", // Calls OsConstants.initConstants.
-  "Ljava/util/prefs/Preferences;", // Calls OsConstants.initConstants.
-  "Ljavax/crypto/KeyAgreement;", // Calls OsConstants.initConstants.
-  "Ljavax/crypto/KeyGenerator;", // Calls OsConstants.initConstants.
-  "Ljavax/security/cert/X509Certificate;", // Calls VMClassLoader.getBootClassPathSize.
-  "Ljavax/security/cert/X509Certificate$1;", // Calls VMClassLoader.getBootClassPathSize.
-  "Ljavax/microedition/khronos/egl/EGL10;", // Requires EGLContext.
-  "Ljavax/microedition/khronos/egl/EGLContext;", // Requires com.google.android.gles_jni.EGLImpl.
-  "Ljavax/xml/datatype/DatatypeConstants;", // Calls OsConstants.initConstants.
-  "Ljavax/xml/datatype/FactoryFinder;", // Calls OsConstants.initConstants.
-  "Ljavax/xml/namespace/QName;", // Calls OsConstants.initConstants.
-  "Ljavax/xml/validation/SchemaFactoryFinder;", // Calls OsConstants.initConstants.
-  "Ljavax/xml/xpath/XPathConstants;", // Calls OsConstants.initConstants.
-  "Ljavax/xml/xpath/XPathFactoryFinder;", // Calls OsConstants.initConstants.
-  "Llibcore/icu/LocaleData;", // Requires java.util.Locale.
-  "Llibcore/icu/TimeZoneNames;", // Requires java.util.TimeZone.
+  "Ljava/io/ObjectStreamConstants;",  // Instance of non-image class SerializablePermission.
+  "Ljava/lang/ClassLoader$SystemClassLoader;",  // Calls System.getProperty -> OsConstants.initConstants.
+  "Ljava/lang/HexStringParser;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Ljava/lang/ProcessManager;",  // Calls Thread.currentThread.
+  "Ljava/lang/Runtime;",  // Calls System.getProperty -> OsConstants.initConstants.
+  "Ljava/lang/System;",  // Calls OsConstants.initConstants.
+  "Ljava/math/BigDecimal;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Ljava/math/BigInteger;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Ljava/math/Primality;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Ljava/math/Multiplication;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Ljava/net/InetAddress;",  // Requires libcore.io.OsConstants.
+  "Ljava/net/Inet4Address;",  // Sub-class of InetAddress.
+  "Ljava/net/Inet6Address;",  // Sub-class of InetAddress.
+  "Ljava/net/InetUnixAddress;",  // Sub-class of InetAddress.
+  "Ljava/nio/charset/Charset;",  // Calls Charset.getDefaultCharset -> System.getProperty -> OsConstants.initConstants.
+  "Ljava/nio/charset/CharsetICU;",  // Sub-class of Charset.
+  "Ljava/nio/charset/Charsets;",  // Calls Charset.forName.
+  "Ljava/nio/charset/StandardCharsets;",  // Calls OsConstants.initConstants.
+  "Ljava/security/AlgorithmParameterGenerator;",  // Calls OsConstants.initConstants.
+  "Ljava/security/KeyPairGenerator$KeyPairGeneratorImpl;",  // Calls OsConstants.initConstants.
+  "Ljava/security/KeyPairGenerator;",  // Calls OsConstants.initConstants.
+  "Ljava/security/Security;",  // Tries to do disk IO for "security.properties".
+  "Ljava/security/spec/RSAKeyGenParameterSpec;",  // java.math.NativeBN.BN_new()
+  "Ljava/sql/Date;",  // Calls OsConstants.initConstants.
+  "Ljava/sql/DriverManager;",  // Calls OsConstants.initConstants.
+  "Ljava/sql/Time;",  // Calls OsConstants.initConstants.
+  "Ljava/sql/Timestamp;",  // Calls OsConstants.initConstants.
+  "Ljava/util/Date;",  // Calls Date.<init> -> System.currentTimeMillis -> OsConstants.initConstants.
+  "Ljava/util/ListResourceBundle;",  // Calls OsConstants.initConstants.
+  "Ljava/util/Locale;",  // Calls System.getProperty -> OsConstants.initConstants.
+  "Ljava/util/PropertyResourceBundle;",  // Calls OsConstants.initConstants.
+  "Ljava/util/ResourceBundle;",  // Calls OsConstants.initConstants.
+  "Ljava/util/ResourceBundle$MissingBundle;",  // Calls OsConstants.initConstants.
+  "Ljava/util/Scanner;",  // regex.Pattern.compileImpl.
+  "Ljava/util/SimpleTimeZone;",  // Sub-class of TimeZone.
+  "Ljava/util/TimeZone;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Ljava/util/concurrent/ConcurrentHashMap$Segment;",  // Calls Runtime.getRuntime().availableProcessors().
+  "Ljava/util/concurrent/ConcurrentSkipListMap;",  // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/Exchanger;",  // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/ForkJoinPool;",  // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/LinkedTransferQueue;",  // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/Phaser;",  // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/ScheduledThreadPoolExecutor;",  // Calls AtomicLong.VMSupportsCS8()
+  "Ljava/util/concurrent/SynchronousQueue;",  // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/atomic/AtomicLong;",  // Calls AtomicLong.VMSupportsCS8()
+  "Ljava/util/logging/LogManager;",  // Calls System.getProperty -> OsConstants.initConstants.
+  "Ljava/util/prefs/AbstractPreferences;",  // Calls OsConstants.initConstants.
+  "Ljava/util/prefs/FilePreferencesImpl;",  // Calls OsConstants.initConstants.
+  "Ljava/util/prefs/FilePreferencesFactoryImpl;",  // Calls OsConstants.initConstants.
+  "Ljava/util/prefs/Preferences;",  // Calls OsConstants.initConstants.
+  "Ljavax/crypto/KeyAgreement;",  // Calls OsConstants.initConstants.
+  "Ljavax/crypto/KeyGenerator;",  // Calls OsConstants.initConstants.
+  "Ljavax/security/cert/X509Certificate;",  // Calls VMClassLoader.getBootClassPathSize.
+  "Ljavax/security/cert/X509Certificate$1;",  // Calls VMClassLoader.getBootClassPathSize.
+  "Ljavax/microedition/khronos/egl/EGL10;",  // Requires EGLContext.
+  "Ljavax/microedition/khronos/egl/EGLContext;",  // Requires com.google.android.gles_jni.EGLImpl.
+  "Ljavax/xml/datatype/DatatypeConstants;",  // Calls OsConstants.initConstants.
+  "Ljavax/xml/datatype/FactoryFinder;",  // Calls OsConstants.initConstants.
+  "Ljavax/xml/namespace/QName;",  // Calls OsConstants.initConstants.
+  "Ljavax/xml/validation/SchemaFactoryFinder;",  // Calls OsConstants.initConstants.
+  "Ljavax/xml/xpath/XPathConstants;",  // Calls OsConstants.initConstants.
+  "Ljavax/xml/xpath/XPathFactoryFinder;",  // Calls OsConstants.initConstants.
+  "Llibcore/icu/LocaleData;",  // Requires java.util.Locale.
+  "Llibcore/icu/TimeZoneNames;",  // Requires java.util.TimeZone.
   "Llibcore/io/IoUtils;",  // Calls Random.<init> -> System.currentTimeMillis -> FileDescriptor -> OsConstants.initConstants.
-  "Llibcore/io/OsConstants;", // Platform specific.
-  "Llibcore/net/MimeUtils;", // Calls libcore.net.MimeUtils.getContentTypesPropertiesStream -> System.getProperty.
-  "Llibcore/reflect/Types;", // Calls OsConstants.initConstants.
-  "Llibcore/util/ZoneInfo;", // Sub-class of TimeZone.
-  "Llibcore/util/ZoneInfoDB;", // Calls System.getenv -> OsConstants.initConstants.
-  "Lorg/apache/commons/logging/LogFactory;", // Calls System.getProperty.
-  "Lorg/apache/commons/logging/impl/LogFactoryImpl;", // Calls OsConstants.initConstants.
-  "Lorg/apache/harmony/security/fortress/Services;", // Calls ClassLoader.getSystemClassLoader -> System.getProperty.
-  "Lorg/apache/harmony/security/provider/cert/X509CertFactoryImpl;", // Requires java.nio.charsets.Charsets.
-  "Lorg/apache/harmony/security/provider/crypto/RandomBitsSupplier;", // Requires java.io.File.
-  "Lorg/apache/harmony/security/utils/AlgNameMapper;", // Requires java.util.Locale.
-  "Lorg/apache/harmony/security/pkcs10/CertificationRequest;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/pkcs10/CertificationRequestInfo;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/pkcs7/AuthenticatedAttributes;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/pkcs7/SignedData;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/pkcs7/SignerInfo;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/pkcs8/PrivateKeyInfo;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/provider/crypto/SHA1PRNG_SecureRandomImpl;", // Calls OsConstants.initConstants.
-  "Lorg/apache/harmony/security/x501/AttributeTypeAndValue;", // Calls IntegralToString.convertInt -> Thread.currentThread.
-  "Lorg/apache/harmony/security/x501/DirectoryString;", // Requires BigInteger.
-  "Lorg/apache/harmony/security/x501/Name;", // Requires org.apache.harmony.security.x501.AttributeTypeAndValue.
-  "Lorg/apache/harmony/security/x509/AccessDescription;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/x509/AuthorityKeyIdentifier;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/x509/CRLDistributionPoints;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/x509/Certificate;", // Requires org.apache.harmony.security.x509.TBSCertificate.
-  "Lorg/apache/harmony/security/x509/CertificateIssuer;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/x509/CertificateList;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/x509/DistributionPoint;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/x509/DistributionPointName;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/x509/EDIPartyName;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lorg/apache/harmony/security/x509/GeneralName;", // Requires org.apache.harmony.security.x501.Name.
-  "Lorg/apache/harmony/security/x509/GeneralNames;", // Requires GeneralName.
-  "Lorg/apache/harmony/security/x509/GeneralSubtree;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/x509/GeneralSubtrees;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/x509/InfoAccessSyntax;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/x509/IssuingDistributionPoint;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/x509/NameConstraints;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/security/x509/TBSCertList$RevokedCertificate;", // Calls NativeBN.BN_new().
-  "Lorg/apache/harmony/security/x509/TBSCertList;", // Calls Thread.currentThread.
+  "Llibcore/io/OsConstants;",  // Platform specific.
+  "Llibcore/net/MimeUtils;",  // Calls libcore.net.MimeUtils.getContentTypesPropertiesStream -> System.getProperty.
+  "Llibcore/reflect/Types;",  // Calls OsConstants.initConstants.
+  "Llibcore/util/ZoneInfo;",  // Sub-class of TimeZone.
+  "Llibcore/util/ZoneInfoDB;",  // Calls System.getenv -> OsConstants.initConstants.
+  "Lorg/apache/commons/logging/LogFactory;",  // Calls System.getProperty.
+  "Lorg/apache/commons/logging/impl/LogFactoryImpl;",  // Calls OsConstants.initConstants.
+  "Lorg/apache/harmony/security/fortress/Services;",  // Calls ClassLoader.getSystemClassLoader -> System.getProperty.
+  "Lorg/apache/harmony/security/provider/cert/X509CertFactoryImpl;",  // Requires java.nio.charsets.Charsets.
+  "Lorg/apache/harmony/security/provider/crypto/RandomBitsSupplier;",  // Requires java.io.File.
+  "Lorg/apache/harmony/security/utils/AlgNameMapper;",  // Requires java.util.Locale.
+  "Lorg/apache/harmony/security/pkcs10/CertificationRequest;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/pkcs10/CertificationRequestInfo;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/pkcs7/AuthenticatedAttributes;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/pkcs7/SignedData;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/pkcs7/SignerInfo;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/pkcs8/PrivateKeyInfo;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/provider/crypto/SHA1PRNG_SecureRandomImpl;",  // Calls OsConstants.initConstants.
+  "Lorg/apache/harmony/security/x501/AttributeTypeAndValue;",  // Calls IntegralToString.convertInt -> Thread.currentThread.
+  "Lorg/apache/harmony/security/x501/DirectoryString;",  // Requires BigInteger.
+  "Lorg/apache/harmony/security/x501/Name;",  // Requires org.apache.harmony.security.x501.AttributeTypeAndValue.
+  "Lorg/apache/harmony/security/x509/AccessDescription;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/AuthorityKeyIdentifier;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/CRLDistributionPoints;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/Certificate;",  // Requires org.apache.harmony.security.x509.TBSCertificate.
+  "Lorg/apache/harmony/security/x509/CertificateIssuer;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/CertificateList;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/DistributionPoint;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/DistributionPointName;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/EDIPartyName;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lorg/apache/harmony/security/x509/GeneralName;",  // Requires org.apache.harmony.security.x501.Name.
+  "Lorg/apache/harmony/security/x509/GeneralNames;",  // Requires GeneralName.
+  "Lorg/apache/harmony/security/x509/GeneralSubtree;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/GeneralSubtrees;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/InfoAccessSyntax;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/IssuingDistributionPoint;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/NameConstraints;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/security/x509/TBSCertList$RevokedCertificate;",  // Calls NativeBN.BN_new().
+  "Lorg/apache/harmony/security/x509/TBSCertList;",  // Calls Thread.currentThread.
   "Lorg/apache/harmony/security/x509/TBSCertificate;",  // Requires org.apache.harmony.security.x501.Name.
-  "Lorg/apache/harmony/security/x509/Time;", // Calls native ... -> java.math.NativeBN.BN_new().
-  "Lorg/apache/harmony/security/x509/Validity;", // Requires x509.Time.
-  "Lorg/apache/harmony/security/x509/tsp/TSTInfo;", // Calls Thread.currentThread.
-  "Lorg/apache/harmony/xml/ExpatParser;", // Calls native ExpatParser.staticInitialize.
-  "Lorg/apache/harmony/xml/ExpatParser$EntityParser;", // Calls ExpatParser.staticInitialize.
-  "Lorg/apache/http/conn/params/ConnRouteParams;", // Requires java.util.Locale.
-  "Lorg/apache/http/conn/ssl/SSLSocketFactory;", // Calls java.security.Security.getProperty.
-  "Lorg/apache/http/conn/util/InetAddressUtils;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Lorg/apache/harmony/security/x509/Time;",  // Calls native ... -> java.math.NativeBN.BN_new().
+  "Lorg/apache/harmony/security/x509/Validity;",  // Requires x509.Time.
+  "Lorg/apache/harmony/security/x509/tsp/TSTInfo;",  // Calls Thread.currentThread.
+  "Lorg/apache/harmony/xml/ExpatParser;",  // Calls native ExpatParser.staticInitialize.
+  "Lorg/apache/harmony/xml/ExpatParser$EntityParser;",  // Calls ExpatParser.staticInitialize.
+  "Lorg/apache/http/conn/params/ConnRouteParams;",  // Requires java.util.Locale.
+  "Lorg/apache/http/conn/ssl/SSLSocketFactory;",  // Calls java.security.Security.getProperty.
+  "Lorg/apache/http/conn/util/InetAddressUtils;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
 };
 
 static void InitializeClass(const ParallelCompilationManager* manager, size_t class_def_index)
diff --git a/compiler/driver/dex_compilation_unit.cc b/compiler/driver/dex_compilation_unit.cc
index 6ba338aa96..eb8941b15f 100644
--- a/compiler/driver/dex_compilation_unit.cc
+++ b/compiler/driver/dex_compilation_unit.cc
@@ -60,4 +60,4 @@ const std::string& DexCompilationUnit::GetSymbol() {
   return symbol_;
 }
 
-} // namespace art
+}  // namespace art
diff --git a/compiler/driver/dex_compilation_unit.h b/compiler/driver/dex_compilation_unit.h
index facc9cbd32..5bf0086075 100644
--- a/compiler/driver/dex_compilation_unit.h
+++ b/compiler/driver/dex_compilation_unit.h
@@ -111,6 +111,6 @@ class DexCompilationUnit {
   std::string symbol_;
 };
 
-} // namespace art
+}  // namespace art
 
 #endif  // ART_COMPILER_DRIVER_DEX_COMPILATION_UNIT_H_
diff --git a/compiler/elf_fixup.cc b/compiler/elf_fixup.cc
index 127bc85d2c..6c090fdbec 100644
--- a/compiler/elf_fixup.cc
+++ b/compiler/elf_fixup.cc
@@ -62,22 +62,22 @@ bool ElfFixup::Fixup(File* file, uintptr_t oat_data_begin) {
 }
 
 // MIPS seems to break the rules d_val vs d_ptr even though their values are between DT_LOPROC and DT_HIPROC
-#define DT_MIPS_RLD_VERSION  0x70000001 // d_val
-#define DT_MIPS_TIME_STAMP   0x70000002 // d_val
-#define DT_MIPS_ICHECKSUM    0x70000003 // d_val
-#define DT_MIPS_IVERSION     0x70000004 // d_val
-#define DT_MIPS_FLAGS        0x70000005 // d_val
-#define DT_MIPS_BASE_ADDRESS 0x70000006 // d_ptr
-#define DT_MIPS_CONFLICT     0x70000008 // d_ptr
-#define DT_MIPS_LIBLIST      0x70000009 // d_ptr
-#define DT_MIPS_LOCAL_GOTNO  0x7000000A // d_val
-#define DT_MIPS_CONFLICTNO   0x7000000B // d_val
-#define DT_MIPS_LIBLISTNO    0x70000010 // d_val
-#define DT_MIPS_SYMTABNO     0x70000011 // d_val
-#define DT_MIPS_UNREFEXTNO   0x70000012 // d_val
-#define DT_MIPS_GOTSYM       0x70000013 // d_val
-#define DT_MIPS_HIPAGENO     0x70000014 // d_val
-#define DT_MIPS_RLD_MAP      0x70000016 // d_ptr
+#define DT_MIPS_RLD_VERSION  0x70000001  // d_val
+#define DT_MIPS_TIME_STAMP   0x70000002  // d_val
+#define DT_MIPS_ICHECKSUM    0x70000003  // d_val
+#define DT_MIPS_IVERSION     0x70000004  // d_val
+#define DT_MIPS_FLAGS        0x70000005  // d_val
+#define DT_MIPS_BASE_ADDRESS 0x70000006  // d_ptr
+#define DT_MIPS_CONFLICT     0x70000008  // d_ptr
+#define DT_MIPS_LIBLIST      0x70000009  // d_ptr
+#define DT_MIPS_LOCAL_GOTNO  0x7000000A  // d_val
+#define DT_MIPS_CONFLICTNO   0x7000000B  // d_val
+#define DT_MIPS_LIBLISTNO    0x70000010  // d_val
+#define DT_MIPS_SYMTABNO     0x70000011  // d_val
+#define DT_MIPS_UNREFEXTNO   0x70000012  // d_val
+#define DT_MIPS_GOTSYM       0x70000013  // d_val
+#define DT_MIPS_HIPAGENO     0x70000014  // d_val
+#define DT_MIPS_RLD_MAP      0x70000016  // d_ptr
 
 bool ElfFixup::FixupDynamic(ElfFile& elf_file, uintptr_t base_address) {
   // TODO: C++0x auto.
diff --git a/compiler/elf_writer_mclinker.h b/compiler/elf_writer_mclinker.h
index bdadf8f206..5da178c0c4 100644
--- a/compiler/elf_writer_mclinker.h
+++ b/compiler/elf_writer_mclinker.h
@@ -30,7 +30,7 @@ class LDSymbol;
 class Linker;
 class LinkerConfig;
 class Module;
-} // namespace mcld
+}  // namespace mcld
 
 namespace art {
 
diff --git a/compiler/elf_writer_quick.cc b/compiler/elf_writer_quick.cc
index f2db5d834c..29963fee54 100644
--- a/compiler/elf_writer_quick.cc
+++ b/compiler/elf_writer_quick.cc
@@ -137,7 +137,7 @@ bool ElfWriterQuick::Write(OatWriter& oat_writer,
   // .dynsym
   uint32_t dynsym_alignment = sizeof(llvm::ELF::Elf32_Word);
   uint32_t dynsym_offset = expected_offset = RoundUp(expected_offset, dynsym_alignment);
-  const uint8_t SYM_UNDEF       = 0; // aka STN_UNDEF
+  const uint8_t SYM_UNDEF       = 0;  // aka STN_UNDEF
   const uint8_t SYM_OATDATA     = 1;
   const uint8_t SYM_OATEXEC     = 2;
   const uint8_t SYM_OATLASTWORD = 3;
@@ -510,7 +510,7 @@ bool ElfWriterQuick::Write(OatWriter& oat_writer,
   section_headers[SH_HASH].sh_link      = SH_DYNSYM;
   section_headers[SH_HASH].sh_info      = 0;
   section_headers[SH_HASH].sh_addralign = hash_alignment;
-  section_headers[SH_HASH].sh_entsize   = sizeof(llvm::ELF::Elf32_Word); // This is Elf32_Word even on 64-bit
+  section_headers[SH_HASH].sh_entsize   = sizeof(llvm::ELF::Elf32_Word);  // This is Elf32_Word even on 64-bit
 
   section_headers[SH_RODATA].sh_name      = shstrtab_rodata_offset;
   section_headers[SH_RODATA].sh_type      = llvm::ELF::SHT_PROGBITS;
diff --git a/compiler/image_writer.cc b/compiler/image_writer.cc
index 1612f7eb33..e73d021c0c 100644
--- a/compiler/image_writer.cc
+++ b/compiler/image_writer.cc
@@ -119,7 +119,7 @@ bool ImageWriter::Write(const std::string& image_filename,
     return false;
   }
 #ifndef NDEBUG
-  { // NOLINT(whitespace/braces)
+  {  // NOLINT(whitespace/braces)
     ScopedObjectAccess soa(Thread::Current());
     CheckNonImageClassesRemoved();
   }
@@ -397,7 +397,7 @@ void ImageWriter::CalculateNewObjectOffsets(size_t oat_loaded_size, size_t oat_d
 
   // leave space for the header, but do not write it yet, we need to
   // know where image_roots is going to end up
-  image_end_ += RoundUp(sizeof(ImageHeader), 8); // 64-bit-alignment
+  image_end_ += RoundUp(sizeof(ImageHeader), 8);  // 64-bit-alignment
 
   {
     WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
@@ -462,7 +462,7 @@ void ImageWriter::CopyAndFixupObjectsCallback(Object* object, void* arg) {
   DCHECK_LT(offset + n, image_writer->image_->Size());
   memcpy(dst, src, n);
   Object* copy = reinterpret_cast<Object*>(dst);
-  copy->SetField32(Object::MonitorOffset(), 0, false); // We may have inflated the lock during compilation.
+  copy->SetField32(Object::MonitorOffset(), 0, false);  // We may have inflated the lock during compilation.
   image_writer->FixupObject(obj, copy);
 }
 
diff --git a/compiler/jni/portable/jni_compiler.cc b/compiler/jni/portable/jni_compiler.cc
index 0e5837846c..e05f291a73 100644
--- a/compiler/jni/portable/jni_compiler.cc
+++ b/compiler/jni/portable/jni_compiler.cc
@@ -148,8 +148,8 @@ CompiledMethod* JniCompiler::Compile() {
 
   // Variables for GetElementPtr
   ::llvm::Value* gep_index[] = {
-    irb_.getInt32(0), // No displacement for shadow frame pointer
-    irb_.getInt32(1), // SIRT
+    irb_.getInt32(0),  // No displacement for shadow frame pointer
+    irb_.getInt32(1),  // SIRT
     NULL,
   };
 
@@ -185,7 +185,7 @@ CompiledMethod* JniCompiler::Compile() {
   }
 
   ::llvm::Value* saved_local_ref_cookie;
-  { // JniMethodStart
+  {  // JniMethodStart
     RuntimeId func_id = is_synchronized ? JniMethodStartSynchronized
                                         : JniMethodStart;
     ::llvm::SmallVector< ::llvm::Value*, 2> args;
@@ -200,7 +200,7 @@ CompiledMethod* JniCompiler::Compile() {
   // Call!!!
   ::llvm::Value* retval = irb_.CreateCall(code_addr, args);
 
-  { // JniMethodEnd
+  {  // JniMethodEnd
     bool is_return_ref = return_shorty == 'L';
     RuntimeId func_id =
         is_return_ref ? (is_synchronized ? JniMethodEndWithReferenceSynchronized
@@ -281,7 +281,7 @@ void JniCompiler::CreateFunction(const std::string& func_name) {
   // Get argument type
   std::vector< ::llvm::Type*> args_type;
 
-  args_type.push_back(irb_.getJObjectTy()); // method object pointer
+  args_type.push_back(irb_.getJObjectTy());  // method object pointer
 
   if (!is_static || is_native_function) {
     // "this" object pointer for non-static
@@ -296,5 +296,5 @@ void JniCompiler::CreateFunction(const std::string& func_name) {
   return ::llvm::FunctionType::get(ret_type, args_type, false);
 }
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
diff --git a/compiler/llvm/backend_types.h b/compiler/llvm/backend_types.h
index 095040e5eb..8ca88ddeab 100644
--- a/compiler/llvm/backend_types.h
+++ b/compiler/llvm/backend_types.h
@@ -97,8 +97,8 @@ inline JType GetJTypeFromShorty(char shorty_jty) {
   }
 }
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
 
 
 #endif  // ART_COMPILER_LLVM_BACKEND_TYPES_H_
diff --git a/compiler/llvm/compiler_llvm.cc b/compiler/llvm/compiler_llvm.cc
index 4475b25043..6b19a37b6f 100644
--- a/compiler/llvm/compiler_llvm.cc
+++ b/compiler/llvm/compiler_llvm.cc
@@ -57,7 +57,7 @@ void InitializeLLVM() {
   llvm::llvm_start_multithreaded();
 
   // NOTE: Uncomment following line to show the time consumption of LLVM passes
-  //llvm::TimePassesIsEnabled = true;
+  // llvm::TimePassesIsEnabled = true;
 
   // Initialize LLVM target-specific options.
   art::llvm::InitialBackendOptions();
@@ -96,7 +96,7 @@ void InitializeLLVM() {
 // Two reasons: (1) the order of the destruction of static objects, or
 //              (2) dlopen/dlclose side-effect on static objects.
 
-} // anonymous namespace
+}  // anonymous namespace
 
 
 namespace art {
@@ -171,8 +171,8 @@ CompileNativeMethod(DexCompilationUnit* dex_compilation_unit) {
 }
 
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
 
 inline static art::llvm::CompilerLLVM* ContextOf(art::CompilerDriver& driver) {
   void *compiler_context = driver.GetCompilerContext();
diff --git a/compiler/llvm/compiler_llvm.h b/compiler/llvm/compiler_llvm.h
index 77841d8564..20934ab209 100644
--- a/compiler/llvm/compiler_llvm.h
+++ b/compiler/llvm/compiler_llvm.h
@@ -97,7 +97,7 @@ class CompilerLLVM {
 };
 
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
 
 #endif  // ART_COMPILER_LLVM_COMPILER_LLVM_H_
diff --git a/compiler/llvm/gbc_expander.cc b/compiler/llvm/gbc_expander.cc
index c990ee629a..a727d06cb2 100644
--- a/compiler/llvm/gbc_expander.cc
+++ b/compiler/llvm/gbc_expander.cc
@@ -439,7 +439,7 @@ bool GBCExpanderPass::runOnFunction(llvm::Function& func) {
   shadow_frame_ = NULL;
   old_shadow_frame_ = NULL;
   func_ = &func;
-  changed_ = false; // Assume unchanged
+  changed_ = false;  // Assume unchanged
 
   shadow_frame_vreg_addresses_.resize(dex_compilation_unit_->GetCodeItem()->registers_size_, NULL);
   basic_blocks_.resize(dex_compilation_unit_->GetCodeItem()->insns_size_in_code_units_);
@@ -456,7 +456,7 @@ bool GBCExpanderPass::runOnFunction(llvm::Function& func) {
   }
 
   // Insert stack overflow check
-  InsertStackOverflowCheck(func); // TODO: Use intrinsic.
+  InsertStackOverflowCheck(func);  // TODO: Use intrinsic.
 
   // Rewrite the intrinsics
   RewriteFunction();
@@ -565,7 +565,7 @@ void GBCExpanderPass::RewriteFunction() {
         llvm::PHINode *phi = llvm::dyn_cast<llvm::PHINode>(inst_iter);
 
         if (!phi) {
-          break; // Meet non-phi instruction.  Done.
+          break;  // Meet non-phi instruction.  Done.
         }
 
         if (handler_phi[phi] == NULL) {
@@ -611,7 +611,7 @@ void GBCExpanderPass::UpdatePhiInstruction(llvm::BasicBlock* old_basic_block,
   llvm::TerminatorInst* term_inst = new_basic_block->getTerminator();
 
   if (!term_inst) {
-    return; // No terminating instruction in new_basic_block.  Nothing to do.
+    return;  // No terminating instruction in new_basic_block.  Nothing to do.
   }
 
   // Iterate every succeeding basic block
@@ -627,7 +627,7 @@ void GBCExpanderPass::UpdatePhiInstruction(llvm::BasicBlock* old_basic_block,
       llvm::PHINode *phi = llvm::dyn_cast<llvm::PHINode>(inst_iter);
 
       if (!phi) {
-        break; // Meet non-phi instruction.  Done.
+        break;  // Meet non-phi instruction.  Done.
       }
 
       // Update the incoming block of this phi instruction
@@ -895,7 +895,7 @@ llvm::Value* GBCExpanderPass::EmitInvoke(llvm::CallInst& call_inst) {
   // Load the actual parameter
   std::vector<llvm::Value*> args;
 
-  args.push_back(callee_method_object_addr); // method object for callee
+  args.push_back(callee_method_object_addr);  // method object for callee
 
   for (uint32_t i = 3; i < call_inst.getNumArgOperands(); ++i) {
     args.push_back(call_inst.getArgOperand(i));
@@ -1378,9 +1378,9 @@ void GBCExpanderPass::Expand_SetVReg(llvm::Value* entry_idx,
     DCHECK(shadow_frame_ != NULL);
 
     llvm::Value* gep_index[] = {
-      irb_.getInt32(0), // No pointer displacement
-      irb_.getInt32(1), // VRegs
-      entry_idx // Pointer field
+      irb_.getInt32(0),  // No pointer displacement
+      irb_.getInt32(1),  // VRegs
+      entry_idx  // Pointer field
     };
 
     // A shadow frame address must dominate every use in the function so we
@@ -1601,7 +1601,7 @@ void GBCExpanderPass::Expand_HLArrayPut(llvm::CallInst& call_inst,
 
   llvm::Value* array_elem_addr = EmitArrayGEP(array_addr, index_value, elem_jty);
 
-  if (elem_jty == kObject) { // If put an object, check the type, and mark GC card table.
+  if (elem_jty == kObject) {  // If put an object, check the type, and mark GC card table.
     llvm::Function* runtime_func = irb_.GetRuntime(CheckPutArrayElement);
 
     irb_.CreateCall2(runtime_func, new_value, array_addr);
@@ -1744,7 +1744,7 @@ void GBCExpanderPass::Expand_HLIPut(llvm::CallInst& call_inst,
       irb_.CreateMemoryBarrier(art::kLoadLoad);
     }
 
-    if (field_jty == kObject) { // If put an object, mark the GC card table.
+    if (field_jty == kObject) {  // If put an object, mark the GC card table.
       EmitMarkGCCard(new_value, object_addr);
     }
   }
@@ -2050,7 +2050,7 @@ void GBCExpanderPass::Expand_HLSput(llvm::CallInst& call_inst,
       irb_.CreateMemoryBarrier(art::kStoreLoad);
     }
 
-    if (field_jty == kObject) { // If put an object, mark the GC card table.
+    if (field_jty == kObject) {  // If put an object, mark the GC card table.
       EmitMarkGCCard(new_value, static_storage_addr);
     }
   }
@@ -2368,8 +2368,8 @@ llvm::Value* GBCExpanderPass::Expand_HLFilledNewArray(llvm::CallInst& call_inst)
     const char* type_desc =
         dex_compilation_unit_->GetDexFile()->StringByTypeIdx(type_idx, &type_desc_len);
 
-    DCHECK_GE(type_desc_len, 2u); // should be guaranteed by verifier
-    DCHECK_EQ(type_desc[0], '['); // should be guaranteed by verifier
+    DCHECK_GE(type_desc_len, 2u);  // should be guaranteed by verifier
+    DCHECK_EQ(type_desc[0], '[');  // should be guaranteed by verifier
     bool is_elem_int_ty = (type_desc[1] == 'I');
 
     uint32_t alignment;
@@ -2683,10 +2683,10 @@ llvm::FunctionType* GBCExpanderPass::GetFunctionType(llvm::Type* ret_type, uint3
   // Get argument type
   std::vector<llvm::Type*> args_type;
 
-  args_type.push_back(irb_.getJObjectTy()); // method object pointer
+  args_type.push_back(irb_.getJObjectTy());  // method object pointer
 
   if (!is_static) {
-    args_type.push_back(irb_.getJType('L')); // "this" object pointer
+    args_type.push_back(irb_.getJType('L'));  // "this" object pointer
   }
 
   for (uint32_t i = 1; i < shorty_size; ++i) {
@@ -2732,11 +2732,11 @@ int32_t GBCExpanderPass::GetTryItemOffset(uint32_t dex_pc) {
     } else if (dex_pc >= end) {
       min = mid + 1;
     } else {
-      return mid; // found
+      return mid;  // found
     }
   }
 
-  return -1; // not found
+  return -1;  // not found
 }
 
 llvm::BasicBlock* GBCExpanderPass::GetLandingPadBasicBlock(uint32_t dex_pc) {
@@ -2744,7 +2744,7 @@ llvm::BasicBlock* GBCExpanderPass::GetLandingPadBasicBlock(uint32_t dex_pc) {
   int32_t ti_offset = GetTryItemOffset(dex_pc);
 
   if (ti_offset == -1) {
-    return NULL; // No landing pad is available for this address.
+    return NULL;  // No landing pad is available for this address.
   }
 
   // Check for the existing landing pad basic block
@@ -3783,7 +3783,7 @@ GBCExpanderPass::ExpandIntrinsic(IntrinsicHelper::IntrinsicId intr_id,
     //==- Unknown Cases ----------------------------------------------------==//
     case IntrinsicHelper::MaxIntrinsicId:
     case IntrinsicHelper::UnknownId:
-    //default:
+    // default:
       // NOTE: "default" is intentionally commented so that C/C++ compiler will
       // give some warning on unmatched cases.
       // NOTE: We should not implement these cases.
@@ -3793,7 +3793,7 @@ GBCExpanderPass::ExpandIntrinsic(IntrinsicHelper::IntrinsicId intr_id,
   return NULL;
 }  // NOLINT(readability/fn_size)
 
-} // anonymous namespace
+}  // anonymous namespace
 
 namespace art {
 namespace llvm {
@@ -3804,5 +3804,5 @@ CreateGBCExpanderPass(const IntrinsicHelper& intrinsic_helper, IRBuilder& irb,
   return new GBCExpanderPass(intrinsic_helper, irb, driver, dex_compilation_unit);
 }
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
diff --git a/compiler/llvm/generated/art_module.cc b/compiler/llvm/generated/art_module.cc
index bcd90b96a1..f3c5a5a6c6 100644
--- a/compiler/llvm/generated/art_module.cc
+++ b/compiler/llvm/generated/art_module.cc
@@ -380,7 +380,7 @@ if (!func___art_type_list) {
 func___art_type_list = Function::Create(
  /*Type=*/FuncTy_0,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"__art_type_list", mod); // (external, no body)
+ /*Name=*/"__art_type_list", mod);  // (external, no body)
 func___art_type_list->setCallingConv(CallingConv::C);
 }
 AttributeSet func___art_type_list_PAL;
@@ -391,7 +391,7 @@ if (!func_art_portable_get_current_thread_from_code) {
 func_art_portable_get_current_thread_from_code = Function::Create(
  /*Type=*/FuncTy_3,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_get_current_thread_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_get_current_thread_from_code", mod);  // (external, no body)
 func_art_portable_get_current_thread_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_get_current_thread_from_code_PAL;
@@ -402,7 +402,7 @@ if (!func_art_portable_set_current_thread_from_code) {
 func_art_portable_set_current_thread_from_code = Function::Create(
  /*Type=*/FuncTy_4,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_set_current_thread_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_set_current_thread_from_code", mod);  // (external, no body)
 func_art_portable_set_current_thread_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_set_current_thread_from_code_PAL;
@@ -413,7 +413,7 @@ if (!func_art_portable_lock_object_from_code) {
 func_art_portable_lock_object_from_code = Function::Create(
  /*Type=*/FuncTy_5,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_lock_object_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_lock_object_from_code", mod);  // (external, no body)
 func_art_portable_lock_object_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_lock_object_from_code_PAL;
@@ -424,7 +424,7 @@ if (!func_art_portable_unlock_object_from_code) {
 func_art_portable_unlock_object_from_code = Function::Create(
  /*Type=*/FuncTy_5,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_unlock_object_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_unlock_object_from_code", mod);  // (external, no body)
 func_art_portable_unlock_object_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_unlock_object_from_code_PAL;
@@ -435,7 +435,7 @@ if (!func_art_portable_test_suspend_from_code) {
 func_art_portable_test_suspend_from_code = Function::Create(
  /*Type=*/FuncTy_6,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_test_suspend_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_test_suspend_from_code", mod);  // (external, no body)
 func_art_portable_test_suspend_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_test_suspend_from_code_PAL;
@@ -446,7 +446,7 @@ if (!func_art_portable_push_shadow_frame_from_code) {
 func_art_portable_push_shadow_frame_from_code = Function::Create(
  /*Type=*/FuncTy_7,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_push_shadow_frame_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_push_shadow_frame_from_code", mod);  // (external, no body)
 func_art_portable_push_shadow_frame_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_push_shadow_frame_from_code_PAL;
@@ -457,7 +457,7 @@ if (!func_art_portable_pop_shadow_frame_from_code) {
 func_art_portable_pop_shadow_frame_from_code = Function::Create(
  /*Type=*/FuncTy_8,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_pop_shadow_frame_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_pop_shadow_frame_from_code", mod);  // (external, no body)
 func_art_portable_pop_shadow_frame_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_pop_shadow_frame_from_code_PAL;
@@ -468,7 +468,7 @@ if (!func_art_portable_get_and_clear_exception) {
 func_art_portable_get_and_clear_exception = Function::Create(
  /*Type=*/FuncTy_4,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_get_and_clear_exception", mod); // (external, no body)
+ /*Name=*/"art_portable_get_and_clear_exception", mod);  // (external, no body)
 func_art_portable_get_and_clear_exception->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_get_and_clear_exception_PAL;
@@ -479,7 +479,7 @@ if (!func_art_portable_throw_div_zero_from_code) {
 func_art_portable_throw_div_zero_from_code = Function::Create(
  /*Type=*/FuncTy_9,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_throw_div_zero_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_throw_div_zero_from_code", mod);  // (external, no body)
 func_art_portable_throw_div_zero_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_throw_div_zero_from_code_PAL;
@@ -490,7 +490,7 @@ if (!func_art_portable_throw_array_bounds_from_code) {
 func_art_portable_throw_array_bounds_from_code = Function::Create(
  /*Type=*/FuncTy_10,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_throw_array_bounds_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_throw_array_bounds_from_code", mod);  // (external, no body)
 func_art_portable_throw_array_bounds_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_throw_array_bounds_from_code_PAL;
@@ -501,7 +501,7 @@ if (!func_art_portable_throw_no_such_method_from_code) {
 func_art_portable_throw_no_such_method_from_code = Function::Create(
  /*Type=*/FuncTy_11,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_throw_no_such_method_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_throw_no_such_method_from_code", mod);  // (external, no body)
 func_art_portable_throw_no_such_method_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_throw_no_such_method_from_code_PAL;
@@ -512,7 +512,7 @@ if (!func_art_portable_throw_null_pointer_exception_from_code) {
 func_art_portable_throw_null_pointer_exception_from_code = Function::Create(
  /*Type=*/FuncTy_11,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_throw_null_pointer_exception_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_throw_null_pointer_exception_from_code", mod);  // (external, no body)
 func_art_portable_throw_null_pointer_exception_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_throw_null_pointer_exception_from_code_PAL;
@@ -523,7 +523,7 @@ if (!func_art_portable_throw_stack_overflow_from_code) {
 func_art_portable_throw_stack_overflow_from_code = Function::Create(
  /*Type=*/FuncTy_9,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_throw_stack_overflow_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_throw_stack_overflow_from_code", mod);  // (external, no body)
 func_art_portable_throw_stack_overflow_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_throw_stack_overflow_from_code_PAL;
@@ -534,7 +534,7 @@ if (!func_art_portable_throw_exception_from_code) {
 func_art_portable_throw_exception_from_code = Function::Create(
  /*Type=*/FuncTy_6,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_throw_exception_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_throw_exception_from_code", mod);  // (external, no body)
 func_art_portable_throw_exception_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_throw_exception_from_code_PAL;
@@ -545,7 +545,7 @@ if (!func_art_portable_find_catch_block_from_code) {
 func_art_portable_find_catch_block_from_code = Function::Create(
  /*Type=*/FuncTy_12,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_find_catch_block_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_find_catch_block_from_code", mod);  // (external, no body)
 func_art_portable_find_catch_block_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_find_catch_block_from_code_PAL;
@@ -556,7 +556,7 @@ if (!func_art_portable_alloc_object_from_code) {
 func_art_portable_alloc_object_from_code = Function::Create(
  /*Type=*/FuncTy_13,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_alloc_object_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_alloc_object_from_code", mod);  // (external, no body)
 func_art_portable_alloc_object_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_alloc_object_from_code_PAL;
@@ -567,7 +567,7 @@ if (!func_art_portable_alloc_object_from_code_with_access_check) {
 func_art_portable_alloc_object_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_13,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_alloc_object_from_code_with_access_check", mod); // (external, no body)
+ /*Name=*/"art_portable_alloc_object_from_code_with_access_check", mod);  // (external, no body)
 func_art_portable_alloc_object_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_alloc_object_from_code_with_access_check_PAL;
@@ -578,7 +578,7 @@ if (!func_art_portable_alloc_array_from_code) {
 func_art_portable_alloc_array_from_code = Function::Create(
  /*Type=*/FuncTy_14,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_alloc_array_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_alloc_array_from_code", mod);  // (external, no body)
 func_art_portable_alloc_array_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_alloc_array_from_code_PAL;
@@ -589,7 +589,7 @@ if (!func_art_portable_alloc_array_from_code_with_access_check) {
 func_art_portable_alloc_array_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_14,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_alloc_array_from_code_with_access_check", mod); // (external, no body)
+ /*Name=*/"art_portable_alloc_array_from_code_with_access_check", mod);  // (external, no body)
 func_art_portable_alloc_array_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_alloc_array_from_code_with_access_check_PAL;
@@ -600,7 +600,7 @@ if (!func_art_portable_check_and_alloc_array_from_code) {
 func_art_portable_check_and_alloc_array_from_code = Function::Create(
  /*Type=*/FuncTy_14,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_check_and_alloc_array_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_check_and_alloc_array_from_code", mod);  // (external, no body)
 func_art_portable_check_and_alloc_array_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_check_and_alloc_array_from_code_PAL;
@@ -611,7 +611,7 @@ if (!func_art_portable_check_and_alloc_array_from_code_with_access_check) {
 func_art_portable_check_and_alloc_array_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_14,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_check_and_alloc_array_from_code_with_access_check", mod); // (external, no body)
+ /*Name=*/"art_portable_check_and_alloc_array_from_code_with_access_check", mod);  // (external, no body)
 func_art_portable_check_and_alloc_array_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_check_and_alloc_array_from_code_with_access_check_PAL;
@@ -622,7 +622,7 @@ if (!func_art_portable_find_instance_field_from_code) {
 func_art_portable_find_instance_field_from_code = Function::Create(
  /*Type=*/FuncTy_15,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_find_instance_field_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_find_instance_field_from_code", mod);  // (external, no body)
 func_art_portable_find_instance_field_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_find_instance_field_from_code_PAL;
@@ -633,7 +633,7 @@ if (!func_art_portable_find_static_field_from_code) {
 func_art_portable_find_static_field_from_code = Function::Create(
  /*Type=*/FuncTy_15,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_find_static_field_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_find_static_field_from_code", mod);  // (external, no body)
 func_art_portable_find_static_field_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_find_static_field_from_code_PAL;
@@ -644,7 +644,7 @@ if (!func_art_portable_find_static_method_from_code_with_access_check) {
 func_art_portable_find_static_method_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_16,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_find_static_method_from_code_with_access_check", mod); // (external, no body)
+ /*Name=*/"art_portable_find_static_method_from_code_with_access_check", mod);  // (external, no body)
 func_art_portable_find_static_method_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_find_static_method_from_code_with_access_check_PAL;
@@ -655,7 +655,7 @@ if (!func_art_portable_find_direct_method_from_code_with_access_check) {
 func_art_portable_find_direct_method_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_16,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_find_direct_method_from_code_with_access_check", mod); // (external, no body)
+ /*Name=*/"art_portable_find_direct_method_from_code_with_access_check", mod);  // (external, no body)
 func_art_portable_find_direct_method_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_find_direct_method_from_code_with_access_check_PAL;
@@ -666,7 +666,7 @@ if (!func_art_portable_find_virtual_method_from_code_with_access_check) {
 func_art_portable_find_virtual_method_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_16,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_find_virtual_method_from_code_with_access_check", mod); // (external, no body)
+ /*Name=*/"art_portable_find_virtual_method_from_code_with_access_check", mod);  // (external, no body)
 func_art_portable_find_virtual_method_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_find_virtual_method_from_code_with_access_check_PAL;
@@ -677,7 +677,7 @@ if (!func_art_portable_find_super_method_from_code_with_access_check) {
 func_art_portable_find_super_method_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_16,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_find_super_method_from_code_with_access_check", mod); // (external, no body)
+ /*Name=*/"art_portable_find_super_method_from_code_with_access_check", mod);  // (external, no body)
 func_art_portable_find_super_method_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_find_super_method_from_code_with_access_check_PAL;
@@ -688,7 +688,7 @@ if (!func_art_portable_find_interface_method_from_code_with_access_check) {
 func_art_portable_find_interface_method_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_16,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_find_interface_method_from_code_with_access_check", mod); // (external, no body)
+ /*Name=*/"art_portable_find_interface_method_from_code_with_access_check", mod);  // (external, no body)
 func_art_portable_find_interface_method_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_find_interface_method_from_code_with_access_check_PAL;
@@ -699,7 +699,7 @@ if (!func_art_portable_find_interface_method_from_code) {
 func_art_portable_find_interface_method_from_code = Function::Create(
  /*Type=*/FuncTy_16,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_find_interface_method_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_find_interface_method_from_code", mod);  // (external, no body)
 func_art_portable_find_interface_method_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_find_interface_method_from_code_PAL;
@@ -710,7 +710,7 @@ if (!func_art_portable_initialize_static_storage_from_code) {
 func_art_portable_initialize_static_storage_from_code = Function::Create(
  /*Type=*/FuncTy_13,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_initialize_static_storage_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_initialize_static_storage_from_code", mod);  // (external, no body)
 func_art_portable_initialize_static_storage_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_initialize_static_storage_from_code_PAL;
@@ -721,7 +721,7 @@ if (!func_art_portable_initialize_type_from_code) {
 func_art_portable_initialize_type_from_code = Function::Create(
  /*Type=*/FuncTy_13,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_initialize_type_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_initialize_type_from_code", mod);  // (external, no body)
 func_art_portable_initialize_type_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_initialize_type_from_code_PAL;
@@ -732,7 +732,7 @@ if (!func_art_portable_initialize_type_and_verify_access_from_code) {
 func_art_portable_initialize_type_and_verify_access_from_code = Function::Create(
  /*Type=*/FuncTy_13,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_initialize_type_and_verify_access_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_initialize_type_and_verify_access_from_code", mod);  // (external, no body)
 func_art_portable_initialize_type_and_verify_access_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_initialize_type_and_verify_access_from_code_PAL;
@@ -743,7 +743,7 @@ if (!func_art_portable_resolve_string_from_code) {
 func_art_portable_resolve_string_from_code = Function::Create(
  /*Type=*/FuncTy_17,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_resolve_string_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_resolve_string_from_code", mod);  // (external, no body)
 func_art_portable_resolve_string_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_resolve_string_from_code_PAL;
@@ -754,7 +754,7 @@ if (!func_art_portable_set32_static_from_code) {
 func_art_portable_set32_static_from_code = Function::Create(
  /*Type=*/FuncTy_18,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_set32_static_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_set32_static_from_code", mod);  // (external, no body)
 func_art_portable_set32_static_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_set32_static_from_code_PAL;
@@ -765,7 +765,7 @@ if (!func_art_portable_set64_static_from_code) {
 func_art_portable_set64_static_from_code = Function::Create(
  /*Type=*/FuncTy_19,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_set64_static_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_set64_static_from_code", mod);  // (external, no body)
 func_art_portable_set64_static_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_set64_static_from_code_PAL;
@@ -776,7 +776,7 @@ if (!func_art_portable_set_obj_static_from_code) {
 func_art_portable_set_obj_static_from_code = Function::Create(
  /*Type=*/FuncTy_20,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_set_obj_static_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_set_obj_static_from_code", mod);  // (external, no body)
 func_art_portable_set_obj_static_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_set_obj_static_from_code_PAL;
@@ -787,7 +787,7 @@ if (!func_art_portable_get32_static_from_code) {
 func_art_portable_get32_static_from_code = Function::Create(
  /*Type=*/FuncTy_21,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_get32_static_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_get32_static_from_code", mod);  // (external, no body)
 func_art_portable_get32_static_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_get32_static_from_code_PAL;
@@ -798,7 +798,7 @@ if (!func_art_portable_get64_static_from_code) {
 func_art_portable_get64_static_from_code = Function::Create(
  /*Type=*/FuncTy_22,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_get64_static_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_get64_static_from_code", mod);  // (external, no body)
 func_art_portable_get64_static_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_get64_static_from_code_PAL;
@@ -809,7 +809,7 @@ if (!func_art_portable_get_obj_static_from_code) {
 func_art_portable_get_obj_static_from_code = Function::Create(
  /*Type=*/FuncTy_23,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_get_obj_static_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_get_obj_static_from_code", mod);  // (external, no body)
 func_art_portable_get_obj_static_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_get_obj_static_from_code_PAL;
@@ -820,7 +820,7 @@ if (!func_art_portable_set32_instance_from_code) {
 func_art_portable_set32_instance_from_code = Function::Create(
  /*Type=*/FuncTy_24,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_set32_instance_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_set32_instance_from_code", mod);  // (external, no body)
 func_art_portable_set32_instance_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_set32_instance_from_code_PAL;
@@ -831,7 +831,7 @@ if (!func_art_portable_set64_instance_from_code) {
 func_art_portable_set64_instance_from_code = Function::Create(
  /*Type=*/FuncTy_25,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_set64_instance_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_set64_instance_from_code", mod);  // (external, no body)
 func_art_portable_set64_instance_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_set64_instance_from_code_PAL;
@@ -842,7 +842,7 @@ if (!func_art_portable_set_obj_instance_from_code) {
 func_art_portable_set_obj_instance_from_code = Function::Create(
  /*Type=*/FuncTy_26,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_set_obj_instance_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_set_obj_instance_from_code", mod);  // (external, no body)
 func_art_portable_set_obj_instance_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_set_obj_instance_from_code_PAL;
@@ -853,7 +853,7 @@ if (!func_art_portable_get32_instance_from_code) {
 func_art_portable_get32_instance_from_code = Function::Create(
  /*Type=*/FuncTy_20,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_get32_instance_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_get32_instance_from_code", mod);  // (external, no body)
 func_art_portable_get32_instance_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_get32_instance_from_code_PAL;
@@ -864,7 +864,7 @@ if (!func_art_portable_get64_instance_from_code) {
 func_art_portable_get64_instance_from_code = Function::Create(
  /*Type=*/FuncTy_27,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_get64_instance_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_get64_instance_from_code", mod);  // (external, no body)
 func_art_portable_get64_instance_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_get64_instance_from_code_PAL;
@@ -875,7 +875,7 @@ if (!func_art_portable_get_obj_instance_from_code) {
 func_art_portable_get_obj_instance_from_code = Function::Create(
  /*Type=*/FuncTy_13,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_get_obj_instance_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_get_obj_instance_from_code", mod);  // (external, no body)
 func_art_portable_get_obj_instance_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_get_obj_instance_from_code_PAL;
@@ -886,7 +886,7 @@ if (!func_art_portable_decode_jobject_in_thread) {
 func_art_portable_decode_jobject_in_thread = Function::Create(
  /*Type=*/FuncTy_28,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_decode_jobject_in_thread", mod); // (external, no body)
+ /*Name=*/"art_portable_decode_jobject_in_thread", mod);  // (external, no body)
 func_art_portable_decode_jobject_in_thread->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_decode_jobject_in_thread_PAL;
@@ -897,7 +897,7 @@ if (!func_art_portable_fill_array_data_from_code) {
 func_art_portable_fill_array_data_from_code = Function::Create(
  /*Type=*/FuncTy_29,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_fill_array_data_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_fill_array_data_from_code", mod);  // (external, no body)
 func_art_portable_fill_array_data_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_fill_array_data_from_code_PAL;
@@ -908,7 +908,7 @@ if (!func_art_portable_is_assignable_from_code) {
 func_art_portable_is_assignable_from_code = Function::Create(
  /*Type=*/FuncTy_30,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_is_assignable_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_is_assignable_from_code", mod);  // (external, no body)
 func_art_portable_is_assignable_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_is_assignable_from_code_PAL;
@@ -919,7 +919,7 @@ if (!func_art_portable_check_cast_from_code) {
 func_art_portable_check_cast_from_code = Function::Create(
  /*Type=*/FuncTy_5,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_check_cast_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_check_cast_from_code", mod);  // (external, no body)
 func_art_portable_check_cast_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_check_cast_from_code_PAL;
@@ -930,7 +930,7 @@ if (!func_art_portable_check_put_array_element_from_code) {
 func_art_portable_check_put_array_element_from_code = Function::Create(
  /*Type=*/FuncTy_5,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_check_put_array_element_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_check_put_array_element_from_code", mod);  // (external, no body)
 func_art_portable_check_put_array_element_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_check_put_array_element_from_code_PAL;
@@ -941,7 +941,7 @@ if (!func_art_d2l) {
 func_art_d2l = Function::Create(
  /*Type=*/FuncTy_31,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_d2l", mod); // (external, no body)
+ /*Name=*/"art_d2l", mod);  // (external, no body)
 func_art_d2l->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_d2l_PAL;
@@ -952,7 +952,7 @@ if (!func_art_d2i) {
 func_art_d2i = Function::Create(
  /*Type=*/FuncTy_32,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_d2i", mod); // (external, no body)
+ /*Name=*/"art_d2i", mod);  // (external, no body)
 func_art_d2i->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_d2i_PAL;
@@ -963,7 +963,7 @@ if (!func_art_f2l) {
 func_art_f2l = Function::Create(
  /*Type=*/FuncTy_33,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_f2l", mod); // (external, no body)
+ /*Name=*/"art_f2l", mod);  // (external, no body)
 func_art_f2l->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_f2l_PAL;
@@ -974,7 +974,7 @@ if (!func_art_f2i) {
 func_art_f2i = Function::Create(
  /*Type=*/FuncTy_34,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_f2i", mod); // (external, no body)
+ /*Name=*/"art_f2i", mod);  // (external, no body)
 func_art_f2i->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_f2i_PAL;
@@ -985,7 +985,7 @@ if (!func_art_portable_jni_method_start) {
 func_art_portable_jni_method_start = Function::Create(
  /*Type=*/FuncTy_35,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_jni_method_start", mod); // (external, no body)
+ /*Name=*/"art_portable_jni_method_start", mod);  // (external, no body)
 func_art_portable_jni_method_start->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_jni_method_start_PAL;
@@ -996,7 +996,7 @@ if (!func_art_portable_jni_method_start_synchronized) {
 func_art_portable_jni_method_start_synchronized = Function::Create(
  /*Type=*/FuncTy_30,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_jni_method_start_synchronized", mod); // (external, no body)
+ /*Name=*/"art_portable_jni_method_start_synchronized", mod);  // (external, no body)
 func_art_portable_jni_method_start_synchronized->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_jni_method_start_synchronized_PAL;
@@ -1007,7 +1007,7 @@ if (!func_art_portable_jni_method_end) {
 func_art_portable_jni_method_end = Function::Create(
  /*Type=*/FuncTy_15,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_jni_method_end", mod); // (external, no body)
+ /*Name=*/"art_portable_jni_method_end", mod);  // (external, no body)
 func_art_portable_jni_method_end->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_jni_method_end_PAL;
@@ -1018,7 +1018,7 @@ if (!func_art_portable_jni_method_end_synchronized) {
 func_art_portable_jni_method_end_synchronized = Function::Create(
  /*Type=*/FuncTy_36,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_jni_method_end_synchronized", mod); // (external, no body)
+ /*Name=*/"art_portable_jni_method_end_synchronized", mod);  // (external, no body)
 func_art_portable_jni_method_end_synchronized->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_jni_method_end_synchronized_PAL;
@@ -1029,7 +1029,7 @@ if (!func_art_portable_jni_method_end_with_reference) {
 func_art_portable_jni_method_end_with_reference = Function::Create(
  /*Type=*/FuncTy_37,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_jni_method_end_with_reference", mod); // (external, no body)
+ /*Name=*/"art_portable_jni_method_end_with_reference", mod);  // (external, no body)
 func_art_portable_jni_method_end_with_reference->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_jni_method_end_with_reference_PAL;
@@ -1040,7 +1040,7 @@ if (!func_art_portable_jni_method_end_with_reference_synchronized) {
 func_art_portable_jni_method_end_with_reference_synchronized = Function::Create(
  /*Type=*/FuncTy_38,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_jni_method_end_with_reference_synchronized", mod); // (external, no body)
+ /*Name=*/"art_portable_jni_method_end_with_reference_synchronized", mod);  // (external, no body)
 func_art_portable_jni_method_end_with_reference_synchronized->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_jni_method_end_with_reference_synchronized_PAL;
@@ -1051,7 +1051,7 @@ if (!func_art_portable_is_exception_pending_from_code) {
 func_art_portable_is_exception_pending_from_code = Function::Create(
  /*Type=*/FuncTy_39,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_is_exception_pending_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_is_exception_pending_from_code", mod);  // (external, no body)
 func_art_portable_is_exception_pending_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_is_exception_pending_from_code_PAL;
@@ -1062,7 +1062,7 @@ if (!func_art_portable_mark_gc_card_from_code) {
 func_art_portable_mark_gc_card_from_code = Function::Create(
  /*Type=*/FuncTy_5,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_mark_gc_card_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_mark_gc_card_from_code", mod);  // (external, no body)
 func_art_portable_mark_gc_card_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_mark_gc_card_from_code_PAL;
@@ -1073,7 +1073,7 @@ if (!func_art_portable_proxy_invoke_handler_from_code) {
 func_art_portable_proxy_invoke_handler_from_code = Function::Create(
  /*Type=*/FuncTy_40,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_portable_proxy_invoke_handler_from_code", mod); // (external, no body)
+ /*Name=*/"art_portable_proxy_invoke_handler_from_code", mod);  // (external, no body)
 func_art_portable_proxy_invoke_handler_from_code->setCallingConv(CallingConv::C);
 }
 AttributeSet func_art_portable_proxy_invoke_handler_from_code_PAL;
@@ -1092,5 +1092,5 @@ return mod;
 
 }
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
diff --git a/compiler/llvm/intrinsic_helper.cc b/compiler/llvm/intrinsic_helper.cc
index a34cb330bc..e5e7998f6c 100644
--- a/compiler/llvm/intrinsic_helper.cc
+++ b/compiler/llvm/intrinsic_helper.cc
@@ -174,5 +174,5 @@ IntrinsicHelper::IntrinsicHelper(::llvm::LLVMContext& context,
   return;
 }
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
diff --git a/compiler/llvm/intrinsic_helper.h b/compiler/llvm/intrinsic_helper.h
index bb123fd575..657db402fa 100644
--- a/compiler/llvm/intrinsic_helper.h
+++ b/compiler/llvm/intrinsic_helper.h
@@ -151,7 +151,7 @@ class IntrinsicHelper {
   ::llvm::DenseMap<const ::llvm::Function*, IntrinsicId> intrinsic_funcs_map_;
 };
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
 
 #endif  // ART_COMPILER_LLVM_INTRINSIC_HELPER_H_
diff --git a/compiler/llvm/ir_builder.cc b/compiler/llvm/ir_builder.cc
index a65cf2bdae..9644ebd976 100644
--- a/compiler/llvm/ir_builder.cc
+++ b/compiler/llvm/ir_builder.cc
@@ -126,5 +126,5 @@ IRBuilder::IRBuilder(::llvm::LLVMContext& context, ::llvm::Module& module,
 }
 
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
diff --git a/compiler/llvm/ir_builder.h b/compiler/llvm/ir_builder.h
index c81ba278a8..03498efcbb 100644
--- a/compiler/llvm/ir_builder.h
+++ b/compiler/llvm/ir_builder.h
@@ -482,7 +482,7 @@ class IRBuilder : public LLVMIRBuilder {
 };
 
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
 
 #endif  // ART_COMPILER_LLVM_IR_BUILDER_H_
diff --git a/compiler/llvm/llvm_compilation_unit.cc b/compiler/llvm/llvm_compilation_unit.cc
index d4568b5a4c..9296fc7050 100644
--- a/compiler/llvm/llvm_compilation_unit.cc
+++ b/compiler/llvm/llvm_compilation_unit.cc
@@ -134,7 +134,7 @@ LlvmCompilationUnit::LlvmCompilationUnit(const CompilerLLVM* compiler_llvm, size
 
 
 LlvmCompilationUnit::~LlvmCompilationUnit() {
-  ::llvm::LLVMContext* llvm_context = context_.release(); // Managed by llvm_info_
+  ::llvm::LLVMContext* llvm_context = context_.release();  // Managed by llvm_info_
   CHECK(llvm_context != NULL);
 }
 
@@ -274,9 +274,9 @@ bool LlvmCompilationUnit::MaterializeToRawOStream(::llvm::raw_ostream& out_strea
   ::llvm::PassManagerBuilder pm_builder;
   // TODO: Use inliner after we can do IPO.
   pm_builder.Inliner = NULL;
-  //pm_builder.Inliner = ::llvm::createFunctionInliningPass();
-  //pm_builder.Inliner = ::llvm::createAlwaysInlinerPass();
-  //pm_builder.Inliner = ::llvm::createPartialInliningPass();
+  // pm_builder.Inliner = ::llvm::createFunctionInliningPass();
+  // pm_builder.Inliner = ::llvm::createAlwaysInlinerPass();
+  // pm_builder.Inliner = ::llvm::createPartialInliningPass();
   pm_builder.OptLevel = 3;
   pm_builder.DisableSimplifyLibCalls = 1;
   pm_builder.DisableUnitAtATime = 1;
@@ -338,5 +338,5 @@ void LlvmCompilationUnit::CheckCodeAlign(uint32_t align) const {
 }
 
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
diff --git a/compiler/llvm/llvm_compilation_unit.h b/compiler/llvm/llvm_compilation_unit.h
index 9de132379b..ced9f812c0 100644
--- a/compiler/llvm/llvm_compilation_unit.h
+++ b/compiler/llvm/llvm_compilation_unit.h
@@ -109,7 +109,7 @@ class LlvmCompilationUnit {
   UniquePtr< ::llvm::LLVMContext> context_;
   UniquePtr<IRBuilder> irb_;
   UniquePtr<RuntimeSupportBuilder> runtime_support_;
-  ::llvm::Module* module_; // Managed by context_
+  ::llvm::Module* module_;  // Managed by context_
   UniquePtr<IntrinsicHelper> intrinsic_helper_;
   UniquePtr<LLVMInfo> llvm_info_;
   CompilerDriver* driver_;
@@ -132,7 +132,7 @@ class LlvmCompilationUnit {
   friend class CompilerLLVM;  // For LlvmCompilationUnit constructor
 };
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
 
 #endif  // ART_COMPILER_LLVM_LLVM_COMPILATION_UNIT_H_
diff --git a/compiler/llvm/md_builder.cc b/compiler/llvm/md_builder.cc
index 1bd76dddba..4331557a4a 100644
--- a/compiler/llvm/md_builder.cc
+++ b/compiler/llvm/md_builder.cc
@@ -113,5 +113,5 @@ namespace llvm {
 }
 
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
diff --git a/compiler/llvm/md_builder.h b/compiler/llvm/md_builder.h
index 65c52c937d..1246f9bd2b 100644
--- a/compiler/llvm/md_builder.h
+++ b/compiler/llvm/md_builder.h
@@ -65,7 +65,7 @@ class MDBuilder : public LLVMMDBuilder {
 };
 
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
 
 #endif  // ART_COMPILER_LLVM_MD_BUILDER_H_
diff --git a/compiler/llvm/runtime_support_builder.cc b/compiler/llvm/runtime_support_builder.cc
index e6479e0fd8..729980309d 100644
--- a/compiler/llvm/runtime_support_builder.cc
+++ b/compiler/llvm/runtime_support_builder.cc
@@ -276,5 +276,5 @@ void RuntimeSupportBuilder::EmitMarkGCCard(::llvm::Value* value, ::llvm::Value*
 }
 
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
diff --git a/compiler/llvm/runtime_support_builder.h b/compiler/llvm/runtime_support_builder.h
index c3c0856bd0..e92ac0a908 100644
--- a/compiler/llvm/runtime_support_builder.h
+++ b/compiler/llvm/runtime_support_builder.h
@@ -92,7 +92,7 @@ class RuntimeSupportBuilder {
 };
 
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
 
 #endif  // ART_COMPILER_LLVM_RUNTIME_SUPPORT_BUILDER_H_
diff --git a/compiler/llvm/runtime_support_builder_arm.cc b/compiler/llvm/runtime_support_builder_arm.cc
index 5a9d2b896a..569d825272 100644
--- a/compiler/llvm/runtime_support_builder_arm.cc
+++ b/compiler/llvm/runtime_support_builder_arm.cc
@@ -52,7 +52,7 @@ char LDRSTRSuffixByType(art::llvm::IRBuilder& irb, Type* type) {
   }
 }
 
-} // namespace
+}  // namespace
 
 namespace art {
 namespace llvm {
@@ -135,5 +135,5 @@ void RuntimeSupportBuilderARM::EmitUnlockObject(Value* object) {
   irb_.CreateCall(func);
 }
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
diff --git a/compiler/llvm/runtime_support_builder_arm.h b/compiler/llvm/runtime_support_builder_arm.h
index 6aa23b2306..5a353d7f30 100644
--- a/compiler/llvm/runtime_support_builder_arm.h
+++ b/compiler/llvm/runtime_support_builder_arm.h
@@ -40,7 +40,7 @@ class RuntimeSupportBuilderARM : public RuntimeSupportBuilder {
   virtual void EmitUnlockObject(::llvm::Value* object);
 };
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
 
 #endif  // ART_COMPILER_LLVM_RUNTIME_SUPPORT_BUILDER_ARM_H_
diff --git a/compiler/llvm/runtime_support_builder_thumb2.cc b/compiler/llvm/runtime_support_builder_thumb2.cc
index b8a5f05416..f0cb4a2d7b 100644
--- a/compiler/llvm/runtime_support_builder_thumb2.cc
+++ b/compiler/llvm/runtime_support_builder_thumb2.cc
@@ -77,7 +77,7 @@ void RuntimeSupportBuilderThumb2::EmitLockObject(Value* object) {
   irb_.CreateBr(basic_block_cont);
 
   irb_.SetInsertPoint(basic_block_cont);
-  { // Memory barrier
+  {  // Memory barrier
     FunctionType* asm_ty = FunctionType::get(/*Result=*/Type::getVoidTy(context_),
                                               /*isVarArg=*/false);
     InlineAsm* func = InlineAsm::get(asm_ty, "dmb sy", "", true);
@@ -86,5 +86,5 @@ void RuntimeSupportBuilderThumb2::EmitLockObject(Value* object) {
 }
 
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
diff --git a/compiler/llvm/runtime_support_builder_thumb2.h b/compiler/llvm/runtime_support_builder_thumb2.h
index 941bd6b2bb..c47a2744ef 100644
--- a/compiler/llvm/runtime_support_builder_thumb2.h
+++ b/compiler/llvm/runtime_support_builder_thumb2.h
@@ -31,7 +31,7 @@ class RuntimeSupportBuilderThumb2 : public RuntimeSupportBuilderARM {
   virtual void EmitLockObject(::llvm::Value* object);
 };
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
 
 #endif  // ART_COMPILER_LLVM_RUNTIME_SUPPORT_BUILDER_THUMB2_H_
diff --git a/compiler/llvm/runtime_support_builder_x86.cc b/compiler/llvm/runtime_support_builder_x86.cc
index c056e58cb9..3d11f9df5b 100644
--- a/compiler/llvm/runtime_support_builder_x86.cc
+++ b/compiler/llvm/runtime_support_builder_x86.cc
@@ -80,5 +80,5 @@ Value* RuntimeSupportBuilderX86::EmitSetCurrentThread(Value*) {
 }
 
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
diff --git a/compiler/llvm/runtime_support_builder_x86.h b/compiler/llvm/runtime_support_builder_x86.h
index 831d022ce5..5f36e7ce18 100644
--- a/compiler/llvm/runtime_support_builder_x86.h
+++ b/compiler/llvm/runtime_support_builder_x86.h
@@ -36,7 +36,7 @@ class RuntimeSupportBuilderX86 : public RuntimeSupportBuilder {
   virtual ::llvm::Value* EmitSetCurrentThread(::llvm::Value* thread);
 };
 
-} // namespace llvm
-} // namespace art
+}  // namespace llvm
+}  // namespace art
 
 #endif  // ART_COMPILER_LLVM_RUNTIME_SUPPORT_BUILDER_X86_H_
diff --git a/compiler/llvm/runtime_support_llvm_func.h b/compiler/llvm/runtime_support_llvm_func.h
index c0e76addc6..2634c683f1 100644
--- a/compiler/llvm/runtime_support_llvm_func.h
+++ b/compiler/llvm/runtime_support_llvm_func.h
@@ -31,8 +31,8 @@ namespace runtime_support {
     MAX_ID
   };
 
-} // namespace runtime_support
-} // namespace llvm
-} // namespace art
+}  // namespace runtime_support
+}  // namespace llvm
+}  // namespace art
 
 #endif  // ART_COMPILER_LLVM_RUNTIME_SUPPORT_LLVM_FUNC_H_
diff --git a/compiler/sea_ir/code_gen.cc b/compiler/sea_ir/code_gen.cc
index 41bf9a6f00..f359849d4d 100644
--- a/compiler/sea_ir/code_gen.cc
+++ b/compiler/sea_ir/code_gen.cc
@@ -111,7 +111,7 @@ void CodeGenVisitor::Visit(Region* region) {
 
 void CodeGenVisitor::Visit(InstructionNode* instruction) {
   std::string instr = instruction->GetInstruction()->DumpString(NULL);
-  DCHECK(0); // This whole function is useful only during development.
+  DCHECK(0);  // This whole function is useful only during development.
 }
 void CodeGenVisitor::Visit(ConstInstructionNode* instruction) {
   std::string instr = instruction->GetInstruction()->DumpString(NULL);
@@ -270,4 +270,4 @@ void CodeGenPostpassVisitor::Visit(SignatureNode* signature) {
   DCHECK_EQ(signature->GetDefinitions().size(), 1u) << "Signature nodes must correspond to a single parameter register.";
 }
 
-} // end namespace sea_ir
+}  // namespace sea_ir
diff --git a/compiler/sea_ir/code_gen.h b/compiler/sea_ir/code_gen.h
index 0f0b2f7af6..aba8d5c7f8 100644
--- a/compiler/sea_ir/code_gen.h
+++ b/compiler/sea_ir/code_gen.h
@@ -103,7 +103,7 @@ class CodeGenPrepassVisitor: public CodeGenPassVisitor {
   void Visit(ConstInstructionNode* instruction) { }
   void Visit(ReturnInstructionNode* instruction) { }
   void Visit(IfNeInstructionNode* instruction) { }
-  //void Visit(AddIntLitInstructionNode* instruction) { }
+  // void Visit(AddIntLitInstructionNode* instruction) { }
   void Visit(MoveResultInstructionNode* instruction) { }
   void Visit(InvokeStaticInstructionNode* instruction) { }
   void Visit(AddIntInstructionNode* instruction) { }
@@ -122,7 +122,7 @@ class CodeGenPostpassVisitor: public CodeGenPassVisitor {
   void Visit(ConstInstructionNode* instruction) { }
   void Visit(ReturnInstructionNode* instruction) { }
   void Visit(IfNeInstructionNode* instruction) { }
-  //void Visit(AddIntLitInstructionNode* instruction) { }
+  // void Visit(AddIntLitInstructionNode* instruction) { }
   void Visit(MoveResultInstructionNode* instruction) { }
   void Visit(InvokeStaticInstructionNode* instruction) { }
   void Visit(AddIntInstructionNode* instruction) { }
@@ -141,7 +141,7 @@ class CodeGenVisitor: public CodeGenPassVisitor {
   void Visit(ConstInstructionNode* instruction);
   void Visit(ReturnInstructionNode* instruction);
   void Visit(IfNeInstructionNode* instruction);
-  //void Visit(AddIntLitInstructionNode* instruction);
+  // void Visit(AddIntLitInstructionNode* instruction);
   void Visit(MoveResultInstructionNode* instruction);
   void Visit(InvokeStaticInstructionNode* instruction);
   void Visit(AddIntInstructionNode* instruction);
@@ -149,5 +149,5 @@ class CodeGenVisitor: public CodeGenPassVisitor {
   void Visit(IfEqzInstructionNode* instruction);
   void Visit(PhiInstructionNode* region) { }
 };
-} // end namespace sea_ir
+}  // namespace sea_ir
 #endif  // ART_COMPILER_SEA_IR_CODE_GEN_H_
diff --git a/compiler/sea_ir/frontend.cc b/compiler/sea_ir/frontend.cc
index bae3cb296c..8fc1cf8315 100644
--- a/compiler/sea_ir/frontend.cc
+++ b/compiler/sea_ir/frontend.cc
@@ -62,7 +62,7 @@ CompiledMethod* SeaIrCompileOneMethod(CompilerDriver& compiler,
 #if defined(ART_USE_PORTABLE_COMPILER)
                        , llvm_compilation_unit
 #endif
-                       ); // NOLINT
+                       );  // NOLINT
 }
 
 extern "C" art::CompiledMethod*
@@ -79,4 +79,4 @@ extern "C" art::CompiledMethod*
 }
 #endif
 
-} // end namespace art
+}  // namespace art
diff --git a/compiler/sea_ir/instruction_nodes.h b/compiler/sea_ir/instruction_nodes.h
index f6d2dd8d3d..5c9cfe19dc 100644
--- a/compiler/sea_ir/instruction_nodes.h
+++ b/compiler/sea_ir/instruction_nodes.h
@@ -144,7 +144,7 @@ class UnnamedConstInstructionNode: public ConstInstructionNode {
         std::stringstream ss;
         ss << def_it->first;
         result.append(ss.str());
-        result += "\"] ; // ssa edge\n";
+        result += "\"] ;  // ssa edge\n";
       }
     }
   }
@@ -179,7 +179,7 @@ class MoveResultInstructionNode: public InstructionNode {
  public:
   explicit MoveResultInstructionNode(const art::Instruction* inst): InstructionNode(inst) { }
   std::vector<int> GetUses() {
-    std::vector<int> uses; // Using vector<> instead of set<> because order matters.
+    std::vector<int> uses;  // Using vector<> instead of set<> because order matters.
     uses.push_back(RETURN_REGISTER);
     return uses;
   }
@@ -246,5 +246,5 @@ class IfEqzInstructionNode: public InstructionNode {
     v->Traverse(this);
   }
 };
-} // end namespace sea_ir
+}  // namespace sea_ir
 #endif  // ART_COMPILER_SEA_IR_INSTRUCTION_NODES_H_
diff --git a/compiler/sea_ir/instruction_tools.cc b/compiler/sea_ir/instruction_tools.cc
index 5433591457..9627497805 100644
--- a/compiler/sea_ir/instruction_tools.cc
+++ b/compiler/sea_ir/instruction_tools.cc
@@ -794,4 +794,4 @@ const int InstructionTools::instruction_attributes_[] = {
   // FF UNUSED_FF
   DF_NOP
 };
-} // end namespace sea_ir
+}  // namespace sea_ir
diff --git a/compiler/sea_ir/instruction_tools.h b/compiler/sea_ir/instruction_tools.h
index 0c227532b8..d3871008a4 100644
--- a/compiler/sea_ir/instruction_tools.h
+++ b/compiler/sea_ir/instruction_tools.h
@@ -121,5 +121,5 @@ class InstructionTools {
   static bool IsDefinition(const art::Instruction* instruction);
   static const int instruction_attributes_[];
 };
-} // end namespace sea_ir
+}  // namespace sea_ir
 #endif  // ART_COMPILER_SEA_IR_INSTRUCTION_TOOLS_H_
diff --git a/compiler/sea_ir/sea.cc b/compiler/sea_ir/sea.cc
index d1db7b6223..3488afd5be 100644
--- a/compiler/sea_ir/sea.cc
+++ b/compiler/sea_ir/sea.cc
@@ -153,16 +153,16 @@ Region* SeaGraph::Intersect(Region* i, Region* j) {
   while (finger1 != finger2) {
     while (finger1->GetRPO() > finger2->GetRPO()) {
       DCHECK(NULL != finger1);
-      finger1 = finger1->GetIDominator(); // should have: finger1 != NULL
+      finger1 = finger1->GetIDominator();  // should have: finger1 != NULL
       DCHECK(NULL != finger1);
     }
     while (finger1->GetRPO() < finger2->GetRPO()) {
       DCHECK(NULL != finger2);
-      finger2 = finger2->GetIDominator(); // should have: finger1 != NULL
+      finger2 = finger2->GetIDominator();  // should have: finger1 != NULL
       DCHECK(NULL != finger2);
     }
   }
-  return finger1; // finger1 should be equal to finger2 at this point.
+  return finger1;  // finger1 should be equal to finger2 at this point.
 }
 
 void SeaGraph::ComputeDownExposedDefs() {
@@ -248,7 +248,7 @@ void SeaGraph::BuildMethodSeaGraph(const art::DexFile::CodeItem* code_item,
         int32_t offset = inst->GetTargetOffset();
         std::map<const uint16_t*, Region*>::iterator it = target_regions.find(&code[i + offset]);
         DCHECK(it != target_regions.end());
-        AddEdge(r, it->second); // Add edge to branch target.
+        AddEdge(r, it->second);  // Add edge to branch target.
       }
 
       std::map<const uint16_t*, Region*>::iterator it = target_regions.find(&code[i]);
@@ -257,7 +257,7 @@ void SeaGraph::BuildMethodSeaGraph(const art::DexFile::CodeItem* code_item,
         Region* nextRegion = it->second;
         if (last_node->GetInstruction()->IsBranch()
             && last_node->GetInstruction()->CanFlowThrough()) {
-          AddEdge(r, it->second); // Add flow-through edge.
+          AddEdge(r, it->second);  // Add flow-through edge.
         }
         r = nextRegion;
       }
@@ -421,7 +421,7 @@ void SeaGraph::CompileMethod(const art::DexFile::CodeItem* code_item,
   uint32_t class_def_idx, uint32_t method_idx, const art::DexFile& dex_file) {
   // Two passes: Builds the intermediate structure (non-SSA) of the sea-ir for the function.
   BuildMethodSeaGraph(code_item, dex_file, class_def_idx, method_idx);
-  //Pass: Compute reverse post-order of regions.
+  // Pass: Compute reverse post-order of regions.
   ComputeRPO();
   // Multiple passes: compute immediate dominators.
   ComputeIDominators();
@@ -502,14 +502,14 @@ void Region::ToDot(std::string& result) const {
   for (std::vector<PhiInstructionNode*>::const_iterator cit = phi_instructions_.begin();
       cit != phi_instructions_.end(); cit++) {
     (*cit)->ToDot(result);
-    result += StringId() + " -> " + (*cit)->StringId() + "; // phi-function \n";
+    result += StringId() + " -> " + (*cit)->StringId() + ";  // phi-function \n";
   }
 
   // Save instruction nodes.
   for (std::vector<InstructionNode*>::const_iterator cit = instructions_.begin();
       cit != instructions_.end(); cit++) {
     (*cit)->ToDot(result);
-    result += StringId() + " -> " + (*cit)->StringId() + "; // region -> instruction \n";
+    result += StringId() + " -> " + (*cit)->StringId() + ";  // region -> instruction \n";
   }
 
   for (std::vector<Region*>::const_iterator cit = successors_.begin(); cit != successors_.end();
@@ -527,14 +527,14 @@ void Region::ToDot(std::string& result) const {
         reaching_set_it++) {
       result += (*reaching_set_it)->StringId() +
          " -> " + StringId() +
-         " [style=dotted]; // Reaching def.\n";
+         " [style=dotted];  // Reaching def.\n";
     }
   }
   // Save dominance frontier.
   for (std::set<Region*>::const_iterator cit = df_.begin(); cit != df_.end(); cit++) {
     result += StringId() +
         " -> " + (*cit)->StringId() +
-        " [color=gray]; // Dominance frontier.\n";
+        " [color=gray];  // Dominance frontier.\n";
   }
   result += "// End Region.\n";
 }
@@ -711,7 +711,7 @@ void InstructionNode::ToDot(std::string& result) const {
     if (NULL != def_it->second) {
       result += def_it->second->StringId() + " -> " + StringId() +"[color=red,label=\"";
       result += art::StringPrintf("%d", def_it->first);
-      result += "\"] ; // ssa edge\n";
+      result += "\"] ;  // ssa edge\n";
     }
   }
 }
@@ -740,7 +740,7 @@ std::vector<int> InstructionNode::GetDefinitions() const {
 }
 
 std::vector<int> InstructionNode::GetUses() {
-  std::vector<int> uses; // Using vector<> instead of set<> because order matters.
+  std::vector<int> uses;  // Using vector<> instead of set<> because order matters.
   if (!InstructionTools::IsDefinition(instruction_) && (instruction_->HasVRegA())) {
     int vA = instruction_->VRegA();
     uses.push_back(vA);
@@ -770,8 +770,8 @@ void PhiInstructionNode::ToDot(std::string& result) const {
         def_it != defs_from_pred->end(); def_it++) {
         result += (*def_it)->StringId() + " -> " + StringId() +"[color=red,label=\"vR = ";
         result += art::StringPrintf("%d", GetRegisterNumber());
-        result += "\"] ; // phi-ssa edge\n";
+        result += "\"] ;  // phi-ssa edge\n";
     }
   }
 }
-} // end namespace sea_ir
+}  // namespace sea_ir
diff --git a/compiler/sea_ir/sea.h b/compiler/sea_ir/sea.h
index a0a8086568..25ab1fed10 100644
--- a/compiler/sea_ir/sea.h
+++ b/compiler/sea_ir/sea.h
@@ -256,7 +256,7 @@ class SeaGraph: IVisitable {
   static void ComputeRPO(Region* crt_bb, int& crt_rpo);
   // Returns the "lowest common ancestor" of @i and @j in the dominator tree.
   static Region* Intersect(Region* i, Region* j);
-  //Returns the vector of parameters of the function.
+  // Returns the vector of parameters of the function.
   std::vector<SignatureNode*>* GetParameterNodes() {
     return &parameters_;
   }
@@ -320,5 +320,5 @@ class SeaGraph: IVisitable {
   std::vector<Region*> regions_;
   std::vector<SignatureNode*> parameters_;
 };
-} // end namespace sea_ir
+}  // namespace sea_ir
 #endif  // ART_COMPILER_SEA_IR_SEA_H_
diff --git a/compiler/sea_ir/sea_node.h b/compiler/sea_ir/sea_node.h
index efc1b0d15a..5d28f8aa72 100644
--- a/compiler/sea_ir/sea_node.h
+++ b/compiler/sea_ir/sea_node.h
@@ -76,5 +76,5 @@ class SeaNode: public IVisitable {
   // operators because that would lead to duplication of their unique ids.
   DISALLOW_COPY_AND_ASSIGN(SeaNode);
 };
-} // end namespace sea_ir
+}  // namespace sea_ir
 #endif  // ART_COMPILER_SEA_IR_SEA_NODE_H_
diff --git a/compiler/sea_ir/visitor.h b/compiler/sea_ir/visitor.h
index 985900856f..a4fec7b8a9 100644
--- a/compiler/sea_ir/visitor.h
+++ b/compiler/sea_ir/visitor.h
@@ -59,7 +59,7 @@ class IRVisitor {
   virtual void Visit(ConstInstructionNode* instruction) = 0;
   virtual void Visit(ReturnInstructionNode* instruction) = 0;
   virtual void Visit(IfNeInstructionNode* instruction) = 0;
-  //virtual void Visit(AddIntLitInstructionNode* instruction) = 0;
+  // virtual void Visit(AddIntLitInstructionNode* instruction) = 0;
   virtual void Visit(MoveResultInstructionNode* instruction) = 0;
   virtual void Visit(InvokeStaticInstructionNode* instruction) = 0;
   virtual void Visit(AddIntInstructionNode* instruction) = 0;
@@ -90,5 +90,5 @@ class IRVisitor {
  protected:
   std::vector<Region*> ordered_regions_;
 };
-} // end namespace sea_ir
+}  // namespace sea_ir
 #endif  // ART_COMPILER_SEA_IR_VISITOR_H_
diff --git a/compiler/stubs/portable/stubs.cc b/compiler/stubs/portable/stubs.cc
index a7eea5183b..69568d7a19 100644
--- a/compiler/stubs/portable/stubs.cc
+++ b/compiler/stubs/portable/stubs.cc
@@ -55,7 +55,7 @@ const std::vector<uint8_t>* CreatePortableResolutionTrampoline() {
 
   return resolution_trampoline.release();
 }
-} // namespace arm
+}  // namespace arm
 
 namespace mips {
 const std::vector<uint8_t>* CreatePortableResolutionTrampoline() {
@@ -72,7 +72,7 @@ const std::vector<uint8_t>* CreatePortableResolutionTrampoline() {
                     ENTRYPOINT_OFFSET(pPortableResolutionTrampolineFromCode));
   __ Move(A3, S1);  // Pass Thread::Current() in A3
   __ Move(A2, SP);  // Pass SP for Method** callee_addr
-  __ Jalr(T9); // Call to resolution trampoline (callee, receiver, callee_addr, Thread*)
+  __ Jalr(T9);  // Call to resolution trampoline (callee, receiver, callee_addr, Thread*)
 
   // Restore frame, argument registers, and RA.
   __ LoadFromOffset(kLoadWord, A0, SP, 0);
@@ -84,9 +84,9 @@ const std::vector<uint8_t>* CreatePortableResolutionTrampoline() {
 
   Label resolve_fail;
   __ EmitBranch(V0, ZERO, &resolve_fail, true);
-  __ Jr(V0); // If V0 != 0 tail call method's code
+  __ Jr(V0);  // If V0 != 0 tail call method's code
   __ Bind(&resolve_fail, false);
-  __ Jr(RA); // Return to caller to handle exception
+  __ Jr(RA);  // Return to caller to handle exception
 
   assembler->EmitSlowPaths();
   size_t cs = assembler->CodeSize();
@@ -96,7 +96,7 @@ const std::vector<uint8_t>* CreatePortableResolutionTrampoline() {
 
   return resolution_trampoline.release();
 }
-} // namespace mips
+}  // namespace mips
 
 namespace x86 {
 const std::vector<uint8_t>* CreatePortableResolutionTrampoline() {
@@ -132,6 +132,6 @@ const std::vector<uint8_t>* CreatePortableResolutionTrampoline() {
 
   return resolution_trampoline.release();
 }
-} // namespace x86
+}  // namespace x86
 
-} // namespace art
+}  // namespace art
diff --git a/compiler/stubs/quick/stubs.cc b/compiler/stubs/quick/stubs.cc
index 790b5d61d3..8fc2a81d24 100644
--- a/compiler/stubs/quick/stubs.cc
+++ b/compiler/stubs/quick/stubs.cc
@@ -95,7 +95,7 @@ const std::vector<uint8_t>* CreateInterpreterToQuickEntry() {
 
   return entry_stub.release();
 }
-} // namespace arm
+}  // namespace arm
 
 namespace mips {
 const std::vector<uint8_t>* CreateQuickResolutionTrampoline() {
@@ -126,7 +126,7 @@ const std::vector<uint8_t>* CreateQuickResolutionTrampoline() {
   __ LoadFromOffset(kLoadWord, T9, S1, ENTRYPOINT_OFFSET(pQuickResolutionTrampolineFromCode));
   __ Move(A3, S1);  // Pass Thread::Current() in A3
   __ Move(A2, SP);  // Pass SP for Method** callee_addr
-  __ Jalr(T9); // Call to resolution trampoline (method_idx, receiver, sp, Thread*)
+  __ Jalr(T9);  // Call to resolution trampoline (method_idx, receiver, sp, Thread*)
 
   // Restore registers which may have been modified by GC
   __ LoadFromOffset(kLoadWord, A0, SP, 0);
@@ -144,7 +144,7 @@ const std::vector<uint8_t>* CreateQuickResolutionTrampoline() {
   __ LoadFromOffset(kLoadWord, RA, SP, 60);
   __ AddConstant(SP, SP, 64);
 
-  __ Move(T9, V0); // Put method's code in T9
+  __ Move(T9, V0);  // Put method's code in T9
   __ Jr(T9);  // Leaf call to method's code
 
   __ Break();
@@ -187,7 +187,7 @@ const std::vector<uint8_t>* CreateInterpreterToQuickEntry() {
 
   return entry_stub.release();
 }
-} // namespace mips
+}  // namespace mips
 
 namespace x86 {
 const std::vector<uint8_t>* CreateQuickResolutionTrampoline() {
@@ -258,6 +258,6 @@ const std::vector<uint8_t>* CreateInterpreterToQuickEntry() {
 
   return entry_stub.release();
 }
-} // namespace x86
+}  // namespace x86
 
-} // namespace art
+}  // namespace art
diff --git a/compiler/utils/scoped_hashtable.h b/compiler/utils/scoped_hashtable.h
index e38b90eab4..ccec7bafa4 100644
--- a/compiler/utils/scoped_hashtable.h
+++ b/compiler/utils/scoped_hashtable.h
@@ -66,6 +66,6 @@ class ScopedHashtable {
  private:
   std::list<std::map<K, V> > scopes;
 };
-} // end namespace utils
+}  // namespace utils
 
 #endif  // ART_COMPILER_UTILS_SCOPED_HASHTABLE_H_
diff --git a/compiler/utils/scoped_hashtable_test.cc b/compiler/utils/scoped_hashtable_test.cc
index 072da8c5bd..d5f9f7d035 100644
--- a/compiler/utils/scoped_hashtable_test.cc
+++ b/compiler/utils/scoped_hashtable_test.cc
@@ -65,4 +65,4 @@ TEST_F(ScopedHashtableTest, Basics) {
   EXPECT_TRUE(NULL == sht.Lookup(2));
 }
 
-} // end namespace art
+}  // namespace art
diff --git a/dalvikvm/dalvikvm.cc b/dalvikvm/dalvikvm.cc
index 16720992b3..4607f9ae54 100644
--- a/dalvikvm/dalvikvm.cc
+++ b/dalvikvm/dalvikvm.cc
@@ -205,7 +205,7 @@ static int dalvikvm(int argc, char** argv) {
   return rc;
 }
 
-} // namespace art
+}  // namespace art
 
 int main(int argc, char** argv) {
   return art::dalvikvm(argc, argv);
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index 1a6a98a2af..f79ddb1935 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -851,7 +851,7 @@ static int dex2oat(int argc, char** argv) {
 
 #if ART_SMALL_MODE
   options.push_back(std::make_pair("-small", reinterpret_cast<void*>(NULL)));
-#endif // ART_SMALL_MODE
+#endif  // ART_SMALL_MODE
 
 
 #ifdef ART_SEA_IR_MODE
@@ -1049,7 +1049,7 @@ static int dex2oat(int argc, char** argv) {
 
   // We wrote the oat file successfully, and want to keep it.
   LOG(INFO) << "Oat file written successfully (stripped): " << oat_location;
-#endif // ART_USE_PORTABLE_COMPILER
+#endif  // ART_USE_PORTABLE_COMPILER
 
   if (dump_timings && timings.GetTotalNs() > MsToNs(1000)) {
     LOG(INFO) << Dumpable<TimingLogger>(timings);
@@ -1058,7 +1058,7 @@ static int dex2oat(int argc, char** argv) {
 }
 
 
-} // namespace art
+}  // namespace art
 
 int main(int argc, char** argv) {
   return art::dex2oat(argc, argv);
diff --git a/jdwpspy/Net.cpp b/jdwpspy/Net.cpp
index 5c789d81ab..38d4e260af 100644
--- a/jdwpspy/Net.cpp
+++ b/jdwpspy/Net.cpp
@@ -510,7 +510,7 @@ static void dumpPacket(const unsigned char* packetBuf, const char* srcName,
         printf("%s   --> %s\n", prefix, getCommandName(cmdSet, cmd));
     } else {
         std::ostringstream ss;
-        ss << "TODO"; // get access to the operator<<, or regenerate it for jdwpspy?
+        ss << "TODO";  // get access to the operator<<, or regenerate it for jdwpspy?
         printf("%s REPLY   dataLen=%-5u id=0x%08x flags=0x%02x err=%d (%s) [%02d:%02d]\n",
             prefix, dataLen, id, flags, error, ss.str().c_str(), min,sec);
     }
diff --git a/oatdump/oatdump.cc b/oatdump/oatdump.cc
index 85eb89bbb3..0a34686ce7 100644
--- a/oatdump/oatdump.cc
+++ b/oatdump/oatdump.cc
@@ -1473,7 +1473,7 @@ static int oatdump(int argc, char** argv) {
   return EXIT_SUCCESS;
 }
 
-} // namespace art
+}  // namespace art
 
 int main(int argc, char** argv) {
   return art::oatdump(argc, argv);
diff --git a/runtime/base/histogram_test.cc b/runtime/base/histogram_test.cc
index 5592f1cedc..218c022141 100644
--- a/runtime/base/histogram_test.cc
+++ b/runtime/base/histogram_test.cc
@@ -22,16 +22,16 @@
 
 namespace art {
 
-//Simple usage:
-//  Histogram *hist = new Histogram("SimplePercentiles");
-//  Percentile PerValue
-//  hist->AddValue(121);
-//  hist->AddValue(132);
-//  hist->AddValue(140);
-//  hist->AddValue(145);
-//  hist->AddValue(155);
-//  hist->CreateHistogram();
-//  PerValue = hist->PercentileVal(0.50); finds the 50th percentile(median).
+// Simple usage:
+//   Histogram *hist = new Histogram("SimplePercentiles");
+//   Percentile PerValue
+//   hist->AddValue(121);
+//   hist->AddValue(132);
+//   hist->AddValue(140);
+//   hist->AddValue(145);
+//   hist->AddValue(155);
+//   hist->CreateHistogram();
+//   PerValue = hist->PercentileVal(0.50); finds the 50th percentile(median).
 
 TEST(Histtest, MeanTest) {
   UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("MeanTest"));
@@ -105,7 +105,7 @@ TEST(Histtest, UpdateRange) {
   hist->AddValue(110);
   hist->AddValue(121);
   hist->AddValue(132);
-  hist->AddValue(140);  //Median  value
+  hist->AddValue(140);  // Median  value
   hist->AddValue(145);
   hist->AddValue(155);
   hist->AddValue(163);
@@ -148,7 +148,7 @@ TEST(Histtest, Reset) {
   hist->AddValue(110);
   hist->AddValue(121);
   hist->AddValue(132);
-  hist->AddValue(140);  //Median  value
+  hist->AddValue(140);  // Median  value
   hist->AddValue(145);
   hist->AddValue(155);
   hist->AddValue(163);
@@ -188,7 +188,7 @@ TEST(Histtest, MultipleCreateHist) {
   hist->AddValue(110);
   hist->AddValue(121);
   hist->AddValue(132);
-  hist->AddValue(140);  //Median  value
+  hist->AddValue(140);  // Median  value
   hist->AddValue(145);
   hist->AddValue(155);
   hist->AddValue(163);
@@ -265,4 +265,4 @@ TEST(Histtest, SpikyValues) {
   EXPECT_EQ(expected, stream.str());
 }
 
-} // namespace art
+}  // namespace art
diff --git a/runtime/base/logging.cc b/runtime/base/logging.cc
index bf19e8d734..83ecca8c88 100644
--- a/runtime/base/logging.cc
+++ b/runtime/base/logging.cc
@@ -126,7 +126,7 @@ LogMessageData::LogMessageData(const char* file, int line, LogSeverity severity,
 
 LogMessage::~LogMessage() {
   if (data_->severity < gMinimumLogSeverity) {
-    return; // No need to format something we're not going to output.
+    return;  // No need to format something we're not going to output.
   }
 
   // Finish constructing the message.
diff --git a/runtime/base/logging.h b/runtime/base/logging.h
index af2cdb3d1c..d641ae4f2b 100644
--- a/runtime/base/logging.h
+++ b/runtime/base/logging.h
@@ -299,7 +299,7 @@ class ToStr {
 // The members of this struct are the valid arguments to VLOG and VLOG_IS_ON in code,
 // and the "-verbose:" command line argument.
 struct LogVerbosity {
-  bool class_linker; // Enabled with "-verbose:class".
+  bool class_linker;  // Enabled with "-verbose:class".
   bool compiler;
   bool heap;
   bool gc;
@@ -307,7 +307,7 @@ struct LogVerbosity {
   bool jni;
   bool monitor;
   bool startup;
-  bool third_party_jni; // Enabled with "-verbose:third-party-jni".
+  bool third_party_jni;  // Enabled with "-verbose:third-party-jni".
   bool threads;
 };
 
diff --git a/runtime/base/macros.h b/runtime/base/macros.h
index 44a7f1e939..879c10c1ae 100644
--- a/runtime/base/macros.h
+++ b/runtime/base/macros.h
@@ -196,6 +196,6 @@ template<typename T> void UNUSED(const T&) {}
 #define SHARED_TRYLOCK_FUNCTION(...)
 #define UNLOCK_FUNCTION(...)
 
-#endif // defined(__SUPPORT_TS_ANNOTATION__)
+#endif  // defined(__SUPPORT_TS_ANNOTATION__)
 
 #endif  // ART_RUNTIME_BASE_MACROS_H_
diff --git a/runtime/base/mutex-inl.h b/runtime/base/mutex-inl.h
index b3f5092c76..1337dff068 100644
--- a/runtime/base/mutex-inl.h
+++ b/runtime/base/mutex-inl.h
@@ -167,7 +167,7 @@ inline void ReaderWriterMutex::SharedUnlock(Thread* self) {
     if (LIKELY(cur_state > 0)) {
       // Reduce state by 1.
       done = android_atomic_release_cas(cur_state, cur_state - 1, &state_) == 0;
-      if (done && (cur_state - 1) == 0) { // cas may fail due to noise?
+      if (done && (cur_state - 1) == 0) {  // cas may fail due to noise?
         if (num_pending_writers_ > 0 || num_pending_readers_ > 0) {
           // Wake any exclusive waiters as there are now no readers.
           futex(&state_, FUTEX_WAKE, -1, NULL, NULL, 0);
diff --git a/runtime/base/mutex.cc b/runtime/base/mutex.cc
index 1a6020b89b..d822eedb67 100644
--- a/runtime/base/mutex.cc
+++ b/runtime/base/mutex.cc
@@ -400,7 +400,7 @@ void Mutex::ExclusiveUnlock(Thread* self) {
       exclusive_owner_ = 0;
       // Change state to 0.
       done = android_atomic_release_cas(cur_state, 0, &state_) == 0;
-      if (done) { // Spurious fail?
+      if (done) {  // Spurious fail?
         // Wake a contender
         if (num_contenders_ > 0) {
           futex(&state_, FUTEX_WAKE, 1, NULL, NULL, 0);
@@ -478,7 +478,7 @@ ReaderWriterMutex::ReaderWriterMutex(const char* name, LockLevel level)
 #if ART_USE_FUTEXES
     , state_(0), exclusive_owner_(0), num_pending_readers_(0), num_pending_writers_(0)
 #endif
-{ // NOLINT(whitespace/braces)
+{  // NOLINT(whitespace/braces)
 #if !ART_USE_FUTEXES
   CHECK_MUTEX_CALL(pthread_rwlock_init, (&rwlock_, NULL));
 #endif
@@ -551,7 +551,7 @@ void ReaderWriterMutex::ExclusiveUnlock(Thread* self) {
       exclusive_owner_ = 0;
       // Change state from -1 to 0.
       done = android_atomic_release_cas(-1, 0, &state_) == 0;
-      if (done) { // cmpxchg may fail due to noise?
+      if (done) {  // cmpxchg may fail due to noise?
         // Wake any waiters.
         if (num_pending_readers_ > 0 || num_pending_writers_ > 0) {
           futex(&state_, FUTEX_WAKE, -1, NULL, NULL, 0);
@@ -756,7 +756,7 @@ void ConditionVariable::Broadcast(Thread* self) {
   DCHECK_EQ(guard_.GetExclusiveOwnerTid(), SafeGetTid(self));
 #if ART_USE_FUTEXES
   if (num_waiters_ > 0) {
-    android_atomic_inc(&sequence_); // Indicate the broadcast occurred.
+    android_atomic_inc(&sequence_);  // Indicate the broadcast occurred.
     bool done = false;
     do {
       int32_t cur_sequence = sequence_;
@@ -782,7 +782,7 @@ void ConditionVariable::Signal(Thread* self) {
   guard_.AssertExclusiveHeld(self);
 #if ART_USE_FUTEXES
   if (num_waiters_ > 0) {
-    android_atomic_inc(&sequence_); // Indicate a signal occurred.
+    android_atomic_inc(&sequence_);  // Indicate a signal occurred.
     // Futex wake 1 waiter who will then come and in contend on mutex. It'd be nice to requeue them
     // to avoid this, however, requeueing can only move all waiters.
     int num_woken = futex(&sequence_, FUTEX_WAKE, 1, NULL, NULL, 0);
diff --git a/runtime/base/unix_file/mapped_file_test.cc b/runtime/base/unix_file/mapped_file_test.cc
index a3b097dcae..3dda02f59f 100644
--- a/runtime/base/unix_file/mapped_file_test.cc
+++ b/runtime/base/unix_file/mapped_file_test.cc
@@ -212,7 +212,7 @@ TEST_F(MappedFileTest, WriteMappedReadWrite) {
   EXPECT_EQ(0, memcmp(kContent.c_str(), file.data(), kContent.size()));
 }
 
-#if 0 // death tests don't work on android yet
+#if 0  // death tests don't work on android yet
 
 class MappedFileDeathTest : public MappedFileTest {};
 
diff --git a/runtime/check_jni.cc b/runtime/check_jni.cc
index 7429ab11a9..089e306586 100644
--- a/runtime/check_jni.cc
+++ b/runtime/check_jni.cc
@@ -419,37 +419,37 @@ class ScopedCheck {
       std::string msg;
       for (const char* fmt = fmt0; *fmt;) {
         char ch = *fmt++;
-        if (ch == 'B') { // jbyte
+        if (ch == 'B') {  // jbyte
           jbyte b = va_arg(ap, int);
           if (b >= 0 && b < 10) {
             StringAppendF(&msg, "%d", b);
           } else {
             StringAppendF(&msg, "%#x (%d)", b, b);
           }
-        } else if (ch == 'C') { // jchar
+        } else if (ch == 'C') {  // jchar
           jchar c = va_arg(ap, int);
           if (c < 0x7f && c >= ' ') {
             StringAppendF(&msg, "U+%x ('%c')", c, c);
           } else {
             StringAppendF(&msg, "U+%x", c);
           }
-        } else if (ch == 'F' || ch == 'D') { // jfloat, jdouble
+        } else if (ch == 'F' || ch == 'D') {  // jfloat, jdouble
           StringAppendF(&msg, "%g", va_arg(ap, double));
-        } else if (ch == 'I' || ch == 'S') { // jint, jshort
+        } else if (ch == 'I' || ch == 'S') {  // jint, jshort
           StringAppendF(&msg, "%d", va_arg(ap, int));
-        } else if (ch == 'J') { // jlong
+        } else if (ch == 'J') {  // jlong
           StringAppendF(&msg, "%lld", va_arg(ap, jlong));
-        } else if (ch == 'Z') { // jboolean
+        } else if (ch == 'Z') {  // jboolean
           StringAppendF(&msg, "%s", va_arg(ap, int) ? "true" : "false");
-        } else if (ch == 'V') { // void
+        } else if (ch == 'V') {  // void
           msg += "void";
-        } else if (ch == 'v') { // JavaVM*
+        } else if (ch == 'v') {  // JavaVM*
           JavaVM* vm = va_arg(ap, JavaVM*);
           StringAppendF(&msg, "(JavaVM*)%p", vm);
-        } else if (ch == 'E') { // JNIEnv*
+        } else if (ch == 'E') {  // JNIEnv*
           JNIEnv* env = va_arg(ap, JNIEnv*);
           StringAppendF(&msg, "(JNIEnv*)%p", env);
-        } else if (ch == 'L' || ch == 'a' || ch == 's') { // jobject, jarray, jstring
+        } else if (ch == 'L' || ch == 'a' || ch == 's') {  // jobject, jarray, jstring
           // For logging purposes, these are identical.
           jobject o = va_arg(ap, jobject);
           if (o == NULL) {
@@ -457,10 +457,10 @@ class ScopedCheck {
           } else {
             StringAppendF(&msg, "%p", o);
           }
-        } else if (ch == 'b') { // jboolean (JNI-style)
+        } else if (ch == 'b') {  // jboolean (JNI-style)
           jboolean b = va_arg(ap, int);
           msg += (b ? "JNI_TRUE" : "JNI_FALSE");
-        } else if (ch == 'c') { // jclass
+        } else if (ch == 'c') {  // jclass
           jclass jc = va_arg(ap, jclass);
           mirror::Class* c = reinterpret_cast<mirror::Class*>(Thread::Current()->DecodeJObject(jc));
           if (c == NULL) {
@@ -475,34 +475,34 @@ class ScopedCheck {
               StringAppendF(&msg, " (%p)", jc);
             }
           }
-        } else if (ch == 'f') { // jfieldID
+        } else if (ch == 'f') {  // jfieldID
           jfieldID fid = va_arg(ap, jfieldID);
           mirror::Field* f = reinterpret_cast<mirror::Field*>(fid);
           msg += PrettyField(f);
           if (!entry) {
             StringAppendF(&msg, " (%p)", fid);
           }
-        } else if (ch == 'z') { // non-negative jsize
+        } else if (ch == 'z') {  // non-negative jsize
           // You might expect jsize to be size_t, but it's not; it's the same as jint.
           // We only treat this specially so we can do the non-negative check.
           // TODO: maybe this wasn't worth it?
           jint i = va_arg(ap, jint);
           StringAppendF(&msg, "%d", i);
-        } else if (ch == 'm') { // jmethodID
+        } else if (ch == 'm') {  // jmethodID
           jmethodID mid = va_arg(ap, jmethodID);
           mirror::AbstractMethod* m = reinterpret_cast<mirror::AbstractMethod*>(mid);
           msg += PrettyMethod(m);
           if (!entry) {
             StringAppendF(&msg, " (%p)", mid);
           }
-        } else if (ch == 'p') { // void* ("pointer")
+        } else if (ch == 'p') {  // void* ("pointer")
           void* p = va_arg(ap, void*);
           if (p == NULL) {
             msg += "NULL";
           } else {
             StringAppendF(&msg, "(void*) %p", p);
           }
-        } else if (ch == 'r') { // jint (release mode)
+        } else if (ch == 'r') {  // jint (release mode)
           jint releaseMode = va_arg(ap, jint);
           if (releaseMode == 0) {
             msg += "0";
@@ -513,7 +513,7 @@ class ScopedCheck {
           } else {
             StringAppendF(&msg, "invalid release mode %d", releaseMode);
           }
-        } else if (ch == 'u') { // const char* (Modified UTF-8)
+        } else if (ch == 'u') {  // const char* (Modified UTF-8)
           const char* utf = va_arg(ap, const char*);
           if (utf == NULL) {
             msg += "NULL";
@@ -573,11 +573,11 @@ class ScopedCheck {
         } else if (ch == 'z') {
           CheckLengthPositive(va_arg(ap, jsize));
         } else if (strchr("BCISZbfmpEv", ch) != NULL) {
-          va_arg(ap, uint32_t); // Skip this argument.
+          va_arg(ap, uint32_t);  // Skip this argument.
         } else if (ch == 'D' || ch == 'F') {
-          va_arg(ap, double); // Skip this argument.
+          va_arg(ap, double);  // Skip this argument.
         } else if (ch == 'J') {
-          va_arg(ap, uint64_t); // Skip this argument.
+          va_arg(ap, uint64_t);  // Skip this argument.
         } else if (ch == '.') {
         } else {
           LOG(FATAL) << "Unknown check format specifier: " << ch;
@@ -797,7 +797,7 @@ class ScopedCheck {
       // Don't check here; we allow nested gets.
       threadEnv->critical++;
       break;
-    case kFlag_CritRelease: // this is a "release" call
+    case kFlag_CritRelease:  // this is a "release" call
       threadEnv->critical--;
       if (threadEnv->critical < 0) {
         JniAbortF(function_name_, "thread %s called too many critical releases", ToStr<Thread>(*self).c_str());
@@ -1007,7 +1007,7 @@ struct GuardedCopy {
       memcpy(buf, &pExtra->magic, 4);
       JniAbortF(functionName,
           "guard magic does not match (found 0x%02x%02x%02x%02x) -- incorrect data pointer %p?",
-          buf[3], buf[2], buf[1], buf[0], dataBuf); // Assumes little-endian.
+          buf[3], buf[2], buf[1], buf[0], dataBuf);  // Assumes little-endian.
     }
 
     size_t len = pExtra->original_length;
@@ -1529,7 +1529,7 @@ CALL(void, Void, , , VOID_RETURN, "V");
   }
 
   static jstring NewStringUTF(JNIEnv* env, const char* bytes) {
-    CHECK_JNI_ENTRY(kFlag_NullableUtf, "Eu", env, bytes); // TODO: show pointer and truncate string.
+    CHECK_JNI_ENTRY(kFlag_NullableUtf, "Eu", env, bytes);  // TODO: show pointer and truncate string.
     return CHECK_JNI_EXIT("s", baseEnv(env)->NewStringUTF(env, bytes));
   }
 
@@ -1547,11 +1547,11 @@ CALL(void, Void, , , VOID_RETURN, "V");
         *isCopy = JNI_TRUE;
       }
     }
-    return CHECK_JNI_EXIT("u", result); // TODO: show pointer and truncate string.
+    return CHECK_JNI_EXIT("u", result);  // TODO: show pointer and truncate string.
   }
 
   static void ReleaseStringUTFChars(JNIEnv* env, jstring string, const char* utf) {
-    CHECK_JNI_ENTRY(kFlag_ExcepOkay | kFlag_Release, "Esu", env, string, utf); // TODO: show pointer and truncate string.
+    CHECK_JNI_ENTRY(kFlag_ExcepOkay | kFlag_Release, "Esu", env, string, utf);  // TODO: show pointer and truncate string.
     if (sc.ForceCopy()) {
       GuardedCopy::Check(__FUNCTION__, utf, false);
       utf = reinterpret_cast<const char*>(GuardedCopy::Destroy(const_cast<char*>(utf)));
@@ -1681,7 +1681,7 @@ PRIMITIVE_ARRAY_FUNCTIONS(jdouble, Double, 'D');
   static jint MonitorEnter(JNIEnv* env, jobject obj) {
     CHECK_JNI_ENTRY(kFlag_Default, "EL", env, obj);
     if (!sc.CheckInstance(ScopedCheck::kObject, obj)) {
-      return JNI_ERR; // Only for jni_internal_test. Real code will have aborted already.
+      return JNI_ERR;  // Only for jni_internal_test. Real code will have aborted already.
     }
     return CHECK_JNI_EXIT("I", baseEnv(env)->MonitorEnter(env, obj));
   }
@@ -1689,7 +1689,7 @@ PRIMITIVE_ARRAY_FUNCTIONS(jdouble, Double, 'D');
   static jint MonitorExit(JNIEnv* env, jobject obj) {
     CHECK_JNI_ENTRY(kFlag_Default | kFlag_ExcepOkay, "EL", env, obj);
     if (!sc.CheckInstance(ScopedCheck::kObject, obj)) {
-      return JNI_ERR; // Only for jni_internal_test. Real code will have aborted already.
+      return JNI_ERR;  // Only for jni_internal_test. Real code will have aborted already.
     }
     return CHECK_JNI_EXIT("I", baseEnv(env)->MonitorExit(env, obj));
   }
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 15d6d366ab..40033b7743 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -1422,7 +1422,7 @@ size_t ClassLinker::SizeOfClass(const DexFile& dex_file,
   // follow with reference fields which must be contiguous at start
   size += (num_ref * sizeof(uint32_t));
   // if there are 64-bit fields to add, make sure they are aligned
-  if (num_64 != 0 && size != RoundUp(size, 8)) { // for 64-bit alignment
+  if (num_64 != 0 && size != RoundUp(size, 8)) {  // for 64-bit alignment
     if (num_32 != 0) {
       // use an available 32-bit field for padding
       num_32--;
@@ -3476,7 +3476,7 @@ bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
     Primitive::Type type = fh.GetTypeAsPrimitiveType();
     bool isPrimitive = type != Primitive::kPrimNot;
     if (isPrimitive) {
-      break; // past last reference, move on to the next phase
+      break;  // past last reference, move on to the next phase
     }
     grouped_and_sorted_fields.pop_front();
     num_reference_fields++;
@@ -3554,7 +3554,7 @@ bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
     bool is_primitive = type != Primitive::kPrimNot;
     if (StringPiece(ClassHelper(klass.get(), this).GetDescriptor()) == "Ljava/lang/ref/Reference;" &&
         StringPiece(fh.GetName()) == "referent") {
-      is_primitive = true; // We lied above, so we have to expect a lie here.
+      is_primitive = true;  // We lied above, so we have to expect a lie here.
     }
     if (is_primitive) {
       if (!seen_non_ref) {
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index 3993cb214b..fdf75c2301 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -328,8 +328,8 @@ class ClassLinker {
   const void* GetOatCodeFor(const DexFile& dex_file, uint32_t method_idx)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  pid_t GetClassesLockOwner(); // For SignalCatcher.
-  pid_t GetDexLockOwner(); // For SignalCatcher.
+  pid_t GetClassesLockOwner();  // For SignalCatcher.
+  pid_t GetDexLockOwner();  // For SignalCatcher.
 
   bool IsDirty() const {
     return is_dirty_;
diff --git a/runtime/common_test.h b/runtime/common_test.h
index 09ad7fd7b7..842f959cd5 100644
--- a/runtime/common_test.h
+++ b/runtime/common_test.h
@@ -55,11 +55,11 @@ static const byte kBase64Map[256] = {
   255, 255, 255, 255, 255, 255, 255,  62, 255, 255, 255,  63,
   52,  53,  54,  55,  56,  57,  58,  59,  60,  61, 255, 255,
   255, 254, 255, 255, 255,   0,   1,   2,   3,   4,   5,   6,
-    7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18, // NOLINT
-   19,  20,  21,  22,  23,  24,  25, 255, 255, 255, 255, 255, // NOLINT
+    7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  // NOLINT
+   19,  20,  21,  22,  23,  24,  25, 255, 255, 255, 255, 255,  // NOLINT
   255,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,
-   37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48, // NOLINT
-   49,  50,  51, 255, 255, 255, 255, 255, 255, 255, 255, 255, // NOLINT
+   37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  // NOLINT
+   49,  50,  51, 255, 255, 255, 255, 255, 255, 255, 255, 255,  // NOLINT
   255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
   255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
   255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
diff --git a/runtime/compiled_method.cc b/runtime/compiled_method.cc
index 49706ae8eb..c64c71ed3f 100644
--- a/runtime/compiled_method.cc
+++ b/runtime/compiled_method.cc
@@ -121,7 +121,7 @@ CompiledMethod::CompiledMethod(InstructionSet instruction_set,
   DCHECK_EQ(vmap_table.size(),
             static_cast<uint32_t>(__builtin_popcount(core_spill_mask)
                                   + __builtin_popcount(fp_spill_mask)));
-  CHECK_LE(vmap_table.size(), (1U << 16) - 1); // length must fit in 2^16-1
+  CHECK_LE(vmap_table.size(), (1U << 16) - 1);  // length must fit in 2^16-1
 
   std::vector<uint32_t> length_prefixed_mapping_table;
   length_prefixed_mapping_table.push_back(mapping_table.size());
diff --git a/runtime/debugger.cc b/runtime/debugger.cc
index deed540cda..7ebd6a3ae0 100644
--- a/runtime/debugger.cc
+++ b/runtime/debugger.cc
@@ -56,8 +56,8 @@
 
 namespace art {
 
-static const size_t kMaxAllocRecordStackDepth = 16; // Max 255.
-static const size_t kDefaultNumAllocRecords = 64*1024; // Must be a power of 2.
+static const size_t kMaxAllocRecordStackDepth = 16;  // Max 255.
+static const size_t kDefaultNumAllocRecords = 64*1024;  // Must be a power of 2.
 
 struct AllocRecordStackTraceElement {
   mirror::AbstractMethod* method;
@@ -72,7 +72,7 @@ struct AllocRecord {
   mirror::Class* type;
   size_t byte_count;
   uint16_t thin_lock_id;
-  AllocRecordStackTraceElement stack[kMaxAllocRecordStackDepth]; // Unused entries have NULL method.
+  AllocRecordStackTraceElement stack[kMaxAllocRecordStackDepth];  // Unused entries have NULL method.
 
   size_t GetDepth() {
     size_t depth = 0;
@@ -104,7 +104,7 @@ struct SingleStepControl {
   JDWP::JdwpStepDepth step_depth;
 
   const mirror::AbstractMethod* method;
-  int32_t line_number; // Or -1 for native methods.
+  int32_t line_number;  // Or -1 for native methods.
   std::set<uint32_t> dex_pcs;
   int stack_depth;
 };
@@ -185,7 +185,7 @@ static ObjectRegistry* gRegistry = NULL;
 
 // Recent allocation tracking.
 static Mutex gAllocTrackerLock DEFAULT_MUTEX_ACQUIRED_AFTER("AllocTracker lock");
-AllocRecord* Dbg::recent_allocation_records_ PT_GUARDED_BY(gAllocTrackerLock) = NULL; // TODO: CircularBuffer<AllocRecord>
+AllocRecord* Dbg::recent_allocation_records_ PT_GUARDED_BY(gAllocTrackerLock) = NULL;  // TODO: CircularBuffer<AllocRecord>
 static size_t gAllocRecordMax GUARDED_BY(gAllocTrackerLock) = 0;
 static size_t gAllocRecordHead GUARDED_BY(gAllocTrackerLock) = 0;
 static size_t gAllocRecordCount GUARDED_BY(gAllocTrackerLock) = 0;
@@ -600,7 +600,7 @@ std::string Dbg::GetClassName(JDWP::RefTypeId class_id) {
     return StringPrintf("invalid object %p", reinterpret_cast<void*>(class_id));
   }
   if (!o->IsClass()) {
-    return StringPrintf("non-class %p", o); // This is only used for debugging output anyway.
+    return StringPrintf("non-class %p", o);  // This is only used for debugging output anyway.
   }
   return DescriptorToName(ClassHelper(o->AsClass()).GetDescriptor());
 }
@@ -1861,7 +1861,7 @@ JDWP::JdwpError Dbg::GetThreadFrames(JDWP::ObjectId thread_id, size_t start_fram
     // annotalysis.
     virtual bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
       if (GetMethod()->IsRuntimeMethod()) {
-        return true; // The debugger can't do anything useful with a frame that has no Method*.
+        return true;  // The debugger can't do anything useful with a frame that has no Method*.
       }
       if (depth_ >= start_frame_ + frame_count_) {
         return false;
@@ -2511,14 +2511,14 @@ JDWP::JdwpError Dbg::ConfigureStep(JDWP::ObjectId thread_id, JDWP::JdwpStepSize
         }
         // Otherwise, if we're already in a valid range for this line,
         // just keep going (shouldn't really happen)...
-      } else if (context->last_pc_valid) { // and the line number is new
+      } else if (context->last_pc_valid) {  // and the line number is new
         // Add everything from the last entry up until here to the set
         for (uint32_t dex_pc = context->last_pc; dex_pc < address; ++dex_pc) {
           gSingleStepControl.dex_pcs.insert(dex_pc);
         }
         context->last_pc_valid = false;
       }
-      return false; // There may be multiple entries for any given line.
+      return false;  // There may be multiple entries for any given line.
     }
 
     // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
@@ -2655,7 +2655,7 @@ JDWP::JdwpError Dbg::InvokeMethod(JDWP::ObjectId thread_id, JDWP::ObjectId objec
     }
     if (suspend_count > 1) {
       LOG(ERROR) << *targetThread << " suspend count too deep for method invocation: " << suspend_count;
-      return JDWP::ERR_THREAD_SUSPENDED; // Probably not expected here.
+      return JDWP::ERR_THREAD_SUSPENDED;  // Probably not expected here.
     }
 
     JDWP::JdwpError status;
@@ -3033,7 +3033,7 @@ void Dbg::DdmSetThreadNotification(bool enable) {
     }
     {
       ScopedObjectAccess soa(self);
-      typedef std::list<Thread*>::const_iterator It; // TODO: C++0x auto
+      typedef std::list<Thread*>::const_iterator It;  // TODO: C++0x auto
       for (It it = threads.begin(), end = threads.end(); it != end; ++it) {
         Dbg::DdmSendThreadNotification(*it, CHUNK_TYPE("THCR"));
       }
@@ -3144,11 +3144,11 @@ void Dbg::DdmSendHeapInfo(HpifWhen reason) {
   gc::Heap* heap = Runtime::Current()->GetHeap();
   std::vector<uint8_t> bytes;
   JDWP::Append4BE(bytes, heap_count);
-  JDWP::Append4BE(bytes, 1); // Heap id (bogus; we only have one heap).
+  JDWP::Append4BE(bytes, 1);  // Heap id (bogus; we only have one heap).
   JDWP::Append8BE(bytes, MilliTime());
   JDWP::Append1BE(bytes, reason);
-  JDWP::Append4BE(bytes, heap->GetMaxMemory()); // Max allowed heap size in bytes.
-  JDWP::Append4BE(bytes, heap->GetTotalMemory()); // Current heap size in bytes.
+  JDWP::Append4BE(bytes, heap->GetMaxMemory());  // Max allowed heap size in bytes.
+  JDWP::Append4BE(bytes, heap->GetTotalMemory());  // Current heap size in bytes.
   JDWP::Append4BE(bytes, heap->GetBytesAllocated());
   JDWP::Append4BE(bytes, heap->GetObjectsAllocated());
   CHECK_EQ(bytes.size(), 4U + (heap_count * (4 + 8 + 1 + 4 + 4 + 4 + 4)));
@@ -3207,11 +3207,11 @@ class HeapChunkContext {
     }
 
     // Start a new HPSx chunk.
-    JDWP::Write4BE(&p_, 1); // Heap id (bogus; we only have one heap).
-    JDWP::Write1BE(&p_, 8); // Size of allocation unit, in bytes.
+    JDWP::Write4BE(&p_, 1);  // Heap id (bogus; we only have one heap).
+    JDWP::Write1BE(&p_, 8);  // Size of allocation unit, in bytes.
 
-    JDWP::Write4BE(&p_, reinterpret_cast<uintptr_t>(chunk_ptr)); // virtual address of segment start.
-    JDWP::Write4BE(&p_, 0); // offset of this piece (relative to the virtual address).
+    JDWP::Write4BE(&p_, reinterpret_cast<uintptr_t>(chunk_ptr));  // virtual address of segment start.
+    JDWP::Write4BE(&p_, 0);  // offset of this piece (relative to the virtual address).
     // [u4]: length of piece, in allocation units
     // We won't know this until we're done, so save the offset and stuff in a dummy value.
     pieceLenField_ = p_;
@@ -3414,7 +3414,7 @@ void Dbg::DdmSendHeapSegments(bool native) {
 
   // First, send a heap start chunk.
   uint8_t heap_id[4];
-  JDWP::Set4BE(&heap_id[0], 1); // Heap id (bogus; we only have one heap).
+  JDWP::Set4BE(&heap_id[0], 1);  // Heap id (bogus; we only have one heap).
   Dbg::DdmSendChunk(native ? CHUNK_TYPE("NHST") : CHUNK_TYPE("HPST"), sizeof(heap_id), heap_id);
 
   // Send a series of heap segment chunks.
@@ -3600,7 +3600,7 @@ class StringTable {
   }
 
   size_t IndexOf(const char* s) const {
-    typedef std::set<std::string>::const_iterator It; // TODO: C++0x auto
+    typedef std::set<std::string>::const_iterator It;  // TODO: C++0x auto
     It it = table_.find(s);
     if (it == table_.end()) {
       LOG(FATAL) << "IndexOf(\"" << s << "\") failed";
@@ -3613,7 +3613,7 @@ class StringTable {
   }
 
   void WriteTo(std::vector<uint8_t>& bytes) const {
-    typedef std::set<std::string>::const_iterator It; // TODO: C++0x auto
+    typedef std::set<std::string>::const_iterator It;  // TODO: C++0x auto
     for (It it = table_.begin(); it != table_.end(); ++it) {
       const char* s = (*it).c_str();
       size_t s_len = CountModifiedUtf8Chars(s);
@@ -3730,7 +3730,7 @@ jbyteArray Dbg::GetRecentAllocations() {
     // (2b) number of source file name strings
     JDWP::Append2BE(bytes, gAllocRecordCount);
     size_t string_table_offset = bytes.size();
-    JDWP::Append4BE(bytes, 0); // We'll patch this later...
+    JDWP::Append4BE(bytes, 0);  // We'll patch this later...
     JDWP::Append2BE(bytes, class_names.Size());
     JDWP::Append2BE(bytes, method_names.Size());
     JDWP::Append2BE(bytes, filenames.Size());
diff --git a/runtime/debugger.h b/runtime/debugger.h
index 9005fda392..6b7e2ba6e8 100644
--- a/runtime/debugger.h
+++ b/runtime/debugger.h
@@ -270,7 +270,7 @@ class Dbg {
 
   static JDWP::JdwpError GetThreadStatus(JDWP::ObjectId thread_id, JDWP::JdwpThreadStatus* pThreadStatus, JDWP::JdwpSuspendStatus* pSuspendStatus);
   static JDWP::JdwpError GetThreadDebugSuspendCount(JDWP::ObjectId thread_id, JDWP::ExpandBuf* pReply);
-  //static void WaitForSuspend(JDWP::ObjectId thread_id);
+  // static void WaitForSuspend(JDWP::ObjectId thread_id);
 
   // Fills 'thread_ids' with the threads in the given thread group. If thread_group_id == 0,
   // returns all threads.
diff --git a/runtime/dex_file.cc b/runtime/dex_file.cc
index cd34c3c89e..cbdc430b8c 100644
--- a/runtime/dex_file.cc
+++ b/runtime/dex_file.cc
@@ -234,7 +234,7 @@ const DexFile* DexFile::OpenMemory(const byte* base,
                                    const std::string& location,
                                    uint32_t location_checksum,
                                    MemMap* mem_map) {
-  CHECK_ALIGNED(base, 4); // various dex file structures must be word aligned
+  CHECK_ALIGNED(base, 4);  // various dex file structures must be word aligned
   UniquePtr<DexFile> dex_file(new DexFile(base, size, location, location_checksum, mem_map));
   if (!dex_file->Init()) {
     return NULL;
diff --git a/runtime/dex_file.h b/runtime/dex_file.h
index 8edeb18418..76947e5cee 100644
--- a/runtime/dex_file.h
+++ b/runtime/dex_file.h
@@ -62,7 +62,7 @@ class DexFile {
   // Raw header_item.
   struct Header {
     uint8_t magic_[8];
-    uint32_t checksum_; // See also location_checksum_
+    uint32_t checksum_;  // See also location_checksum_
     uint8_t signature_[kSha1DigestSize];
     uint32_t file_size_;  // size of entire file
     uint32_t header_size_;  // offset to start of next section
diff --git a/runtime/dex_file_verifier.cc b/runtime/dex_file_verifier.cc
index 6df4411565..09e929c2d0 100644
--- a/runtime/dex_file_verifier.cc
+++ b/runtime/dex_file_verifier.cc
@@ -1299,7 +1299,7 @@ bool DexFileVerifier::CheckIntraSection() {
 }
 
 bool DexFileVerifier::CheckOffsetToTypeMap(uint32_t offset, uint16_t type) {
-  typedef SafeMap<uint32_t, uint16_t>::iterator It; // TODO: C++0x auto
+  typedef SafeMap<uint32_t, uint16_t>::iterator It;  // TODO: C++0x auto
   It it = offset_to_type_map_.find(offset);
   if (it == offset_to_type_map_.end()) {
     LOG(ERROR) << StringPrintf("No data map entry found @ %x; expected %x", offset, type);
diff --git a/runtime/dex_instruction-inl.h b/runtime/dex_instruction-inl.h
index 2cb5235417..6e21273358 100644
--- a/runtime/dex_instruction-inl.h
+++ b/runtime/dex_instruction-inl.h
@@ -131,7 +131,7 @@ inline uint16_t Instruction::VRegA_32x() const {
 
 inline uint4_t Instruction::VRegA_35c() const {
   DCHECK_EQ(FormatOf(Opcode()), k35c);
-  return InstB(); // This is labeled A in the spec.
+  return InstB();  // This is labeled A in the spec.
 }
 
 inline uint8_t Instruction::VRegA_3rc() const {
@@ -295,7 +295,7 @@ inline void Instruction::GetArgs(uint32_t arg[5]) const {
    * method constant (or equivalent) is always in vB.
    */
   uint16_t regList = Fetch16(2);
-  uint4_t count = InstB(); // This is labeled A in the spec.
+  uint4_t count = InstB();  // This is labeled A in the spec.
 
   /*
    * Copy the argument registers into the arg[] array, and
@@ -310,13 +310,13 @@ inline void Instruction::GetArgs(uint32_t arg[5]) const {
     case 3: arg[2] = (regList >> 8) & 0x0f;
     case 2: arg[1] = (regList >> 4) & 0x0f;
     case 1: arg[0] = regList & 0x0f; break;
-    case 0: break; // Valid, but no need to do anything.
+    case 0: break;  // Valid, but no need to do anything.
     default:
       LOG(ERROR) << "Invalid arg count in 35c (" << count << ")";
       return;
   }
 }
 
-} // namespace art
+}  // namespace art
 
 #endif  // ART_RUNTIME_DEX_INSTRUCTION_INL_H_
diff --git a/runtime/dex_instruction.cc b/runtime/dex_instruction.cc
index dcaa4cc27e..09fa19e4d5 100644
--- a/runtime/dex_instruction.cc
+++ b/runtime/dex_instruction.cc
@@ -220,7 +220,7 @@ void Instruction::Decode(uint32_t &vA, uint32_t &vB, uint64_t &vB_wide, uint32_t
       break;
     case k11n:       // op vA, #+B
       vA = INST_A(insn);
-      vB = (int32_t) (INST_B(insn) << 28) >> 28; // sign extend 4-bit value
+      vB = (int32_t) (INST_B(insn) << 28) >> 28;  // sign extend 4-bit value
       break;
     case k11x:       // op vAA
       vA = INST_AA(insn);
@@ -302,7 +302,7 @@ void Instruction::Decode(uint32_t &vA, uint32_t &vB, uint64_t &vB_wide, uint32_t
         uint16_t regList;
         int count;
 
-        vA = INST_B(insn); // This is labeled A in the spec.
+        vA = INST_B(insn);  // This is labeled A in the spec.
         vB = FETCH(1);
         regList = FETCH(2);
 
@@ -321,7 +321,7 @@ void Instruction::Decode(uint32_t &vA, uint32_t &vB, uint64_t &vB_wide, uint32_t
         case 3: arg[2] = (regList >> 8) & 0x0f;
         case 2: arg[1] = (regList >> 4) & 0x0f;
         case 1: vC = arg[0] = regList & 0x0f; break;
-        case 0: break; // Valid, but no need to do anything.
+        case 0: break;  // Valid, but no need to do anything.
         default:
           LOG(ERROR) << "Invalid arg count in 35c (" << count << ")";
           return;
@@ -561,7 +561,7 @@ std::string Instruction::DumpString(const DexFile* file) const {
               }
               os << "v" << arg[i];
             }
-            os << "}, // vtable@" << method_idx;
+            os << "},  // vtable@" << method_idx;
             break;
           }  // else fall-through
         default:
diff --git a/runtime/dex_instruction.h b/runtime/dex_instruction.h
index b0d85e672e..6be249c76a 100644
--- a/runtime/dex_instruction.h
+++ b/runtime/dex_instruction.h
@@ -82,7 +82,7 @@ class Instruction {
   // TODO: the code layout below is deliberate to avoid this enum being picked up by
   //       generate-operator-out.py.
   enum Code
-  { // NOLINT(whitespace/braces)
+  {  // NOLINT(whitespace/braces)
 #define INSTRUCTION_ENUM(opcode, cname, p, f, r, i, a, v) cname = opcode,
 #include "dex_instruction_list.h"
     DEX_INSTRUCTION_LIST(INSTRUCTION_ENUM)
@@ -124,7 +124,7 @@ class Instruction {
     kThrow    = 0x08,  // could cause an exception to be thrown
     kReturn   = 0x10,  // returns, no additional statements
     kInvoke   = 0x20,  // a flavor of invoke
-    kUnconditional = 0x40, // unconditional branch
+    kUnconditional = 0x40,  // unconditional branch
   };
 
   enum VerifyFlag {
diff --git a/runtime/dex_instruction_list.h b/runtime/dex_instruction_list.h
index 31d51c9b41..c2cd65ade5 100644
--- a/runtime/dex_instruction_list.h
+++ b/runtime/dex_instruction_list.h
@@ -302,4 +302,4 @@
   V(k51l)
 
 #endif  // ART_RUNTIME_DEX_INSTRUCTION_LIST_H_
-#undef ART_RUNTIME_DEX_INSTRUCTION_LIST_H_ // the guard in this file is just for cpplint
+#undef ART_RUNTIME_DEX_INSTRUCTION_LIST_H_  // the guard in this file is just for cpplint
diff --git a/runtime/disassembler_arm.cc b/runtime/disassembler_arm.cc
index a7319a5486..879d3ac71c 100644
--- a/runtime/disassembler_arm.cc
+++ b/runtime/disassembler_arm.cc
@@ -133,7 +133,7 @@ struct Rm {
 std::ostream& operator<<(std::ostream& os, const Rm& r) {
   os << r.rm;
   if (r.shift != 0) {
-    os << "-shift-" << r.shift; // TODO
+    os << "-shift-" << r.shift;  // TODO
   }
   return os;
 }
@@ -185,16 +185,16 @@ void DisassemblerArm::DumpArm(std::ostream& os, const uint8_t* instr_ptr) {
   std::ostringstream args;
   switch (op1) {
     case 0:
-    case 1: // Data processing instructions.
+    case 1:  // Data processing instructions.
       {
-        if ((instruction & 0x0ff000f0) == 0x01200070) { // BKPT
+        if ((instruction & 0x0ff000f0) == 0x01200070) {  // BKPT
           opcode = "bkpt";
           uint32_t imm12 = (instruction >> 8) & 0xfff;
           uint32_t imm4 = (instruction & 0xf);
           args << '#' << ((imm12 << 4) | imm4);
           break;
         }
-        if ((instruction & 0x0fffffd0) == 0x012fff10) { // BX and BLX (register)
+        if ((instruction & 0x0fffffd0) == 0x012fff10) {  // BX and BLX (register)
           opcode = (((instruction >> 5) & 1) ? "blx" : "bx");
           args << ArmRegister(instruction & 0xf);
           break;
@@ -203,7 +203,7 @@ void DisassemblerArm::DumpArm(std::ostream& os, const uint8_t* instr_ptr) {
         bool s = (instruction & (1 << 20)) != 0;
         uint32_t op = (instruction >> 21) & 0xf;
         opcode = kDataProcessingOperations[op];
-        bool implicit_s = ((op & ~3) == 8); // TST, TEQ, CMP, and CMN.
+        bool implicit_s = ((op & ~3) == 8);  // TST, TEQ, CMP, and CMN.
         if (implicit_s) {
           // Rd is unused (and not shown), and we don't show the 's' suffix either.
         } else {
@@ -219,7 +219,7 @@ void DisassemblerArm::DumpArm(std::ostream& os, const uint8_t* instr_ptr) {
         }
       }
       break;
-    case 2: // Load/store word and unsigned byte.
+    case 2:  // Load/store word and unsigned byte.
       {
         bool p = (instruction & (1 << 24)) != 0;
         bool b = (instruction & (1 << 22)) != 0;
@@ -249,7 +249,7 @@ void DisassemblerArm::DumpArm(std::ostream& os, const uint8_t* instr_ptr) {
         }
       }
       break;
-    case 4: // Load/store multiple.
+    case 4:  // Load/store multiple.
       {
         bool p = (instruction & (1 << 24)) != 0;
         bool u = (instruction & (1 << 23)) != 0;
@@ -259,12 +259,12 @@ void DisassemblerArm::DumpArm(std::ostream& os, const uint8_t* instr_ptr) {
         args << ArmRegister(instruction, 16) << (w ? "!" : "") << ", " << RegisterList(instruction);
       }
       break;
-    case 5: // Branch/branch with link.
+    case 5:  // Branch/branch with link.
       {
         bool bl = (instruction & (1 << 24)) != 0;
         opcode = (bl ? "bl" : "b");
         int32_t imm26 = (instruction & 0xffffff) << 2;
-        int32_t imm32 = (imm26 << 6) >> 6; // Sign extend.
+        int32_t imm32 = (imm26 << 6) >> 6;  // Sign extend.
         DumpBranchTarget(args, instr_ptr + 8, imm32);
       }
       break;
@@ -344,10 +344,10 @@ size_t DisassemblerArm::DumpThumb32(std::ostream& os, const uint8_t* instr_ptr)
           }
           args << RegisterList(instr);
         }
-      } else if ((op2 & 0x64) == 4) { // 00x x1xx
+      } else if ((op2 & 0x64) == 4) {  // 00x x1xx
         uint32_t op3 = (instr >> 23) & 3;
         uint32_t op4 = (instr >> 20) & 3;
-        //uint32_t op5 = (instr >> 4) & 0xF;
+        // uint32_t op5 = (instr >> 4) & 0xF;
         ArmRegister Rn(instr, 16);
         ArmRegister Rt(instr, 12);
         uint32_t imm8 = instr & 0xFF;
@@ -495,8 +495,8 @@ size_t DisassemblerArm::DumpThumb32(std::ostream& os, const uint8_t* instr_ptr)
         uint32_t op3 = (instr >> 20) & 0x3F;
         uint32_t coproc = (instr >> 8) & 0xF;
         uint32_t op4 = (instr >> 4) & 0x1;
-        if ((op3 == 2 || op3 == 2 || op3 == 6 || op3 == 7) || // 00x1x
-            (op3 >= 8 && op3 <= 15) || (op3 >= 16 && op3 <= 31)) { // 001xxx, 01xxxx
+        if ((op3 == 2 || op3 == 2 || op3 == 6 || op3 == 7) ||  // 00x1x
+            (op3 >= 8 && op3 <= 15) || (op3 >= 16 && op3 <= 31)) {  // 001xxx, 01xxxx
           // Extension register load/store instructions
           // |111|1|110|00000|0000|1111|110|000000000|
           // |5 3|2|109|87654|3  0|54 2|10 |87 54   0|
@@ -519,13 +519,13 @@ size_t DisassemblerArm::DumpThumb32(std::ostream& os, const uint8_t* instr_ptr)
             uint32_t d = (S == 0 ? ((Vd << 1) | D) : (Vd | (D << 4)));
             if (P == 0 && U == 0 && W == 0) {
               // TODO: 64bit transfers between ARM core and extension registers.
-            } else if (P == 0 && U == 1 && Rn.r == 13) { // VPOP
+            } else if (P == 0 && U == 1 && Rn.r == 13) {  // VPOP
               opcode << "vpop" << (S == 0 ? ".f64" : ".f32");
               args << d << " .. " << (d + imm8);
             } else if (P == 1 && W == 0) {  // VLDR
               opcode << "vldr" << (S == 0 ? ".f64" : ".f32");
               args << d << ", [" << Rn << ", #" << imm8 << "]";
-            } else { // VLDM
+            } else {  // VLDM
               opcode << "vldm" << (S == 0 ? ".f64" : ".f32");
               args << Rn << ", " << d << " .. " << (d + imm8);
             }
@@ -553,7 +553,7 @@ size_t DisassemblerArm::DumpThumb32(std::ostream& os, const uint8_t* instr_ptr)
               uint32_t Vm = instr & 0xF;
               bool dp_operation = sz == 1;
               switch (opc2) {
-                case 0x1: // Vneg/Vsqrt
+                case 0x1:  // Vneg/Vsqrt
                   //  1110 11101 D 11 0001 dddd 101s o1M0 mmmm
                   opcode << (opc3 == 1 ? "vneg" : "vsqrt") << (dp_operation ? ".f64" : ".f32");
                   if (dp_operation) {
@@ -562,7 +562,7 @@ size_t DisassemblerArm::DumpThumb32(std::ostream& os, const uint8_t* instr_ptr)
                     args << "f" << ((Vd << 1) | D) << ", " << "f" << ((Vm << 1) | M);
                   }
                   break;
-                case 0x4: case 0x5:  { // Vector compare
+                case 0x4: case 0x5:  {  // Vector compare
                   // 1110 11101 D 11 0100 dddd 101 sE1M0 mmmm
                   opcode << (opc3 == 1 ? "vcmp" : "vcmpe") << (dp_operation ? ".f64" : ".f32");
                   if (dp_operation) {
@@ -733,7 +733,7 @@ size_t DisassemblerArm::DumpThumb32(std::ostream& os, const uint8_t* instr_ptr)
         // |111|10| op2   |    |1|op3|op4 |        |
 
         uint32_t op3 = (instr >> 12) & 7;
-        //uint32_t op4 = (instr >> 8) & 0xF;
+        // uint32_t op4 = (instr >> 8) & 0xF;
         switch (op3) {
           case 0:
             if ((op2 & 0x38) != 0x38) {
@@ -852,7 +852,7 @@ size_t DisassemblerArm::DumpThumb32(std::ostream& os, const uint8_t* instr_ptr)
           // |---|--|---|---|-|----|----|------|------|
           // |111|11|000|op3|0|    |    |  op4 |      |
           uint32_t op3 = (instr >> 21) & 7;
-          //uint32_t op4 = (instr >> 6) & 0x3F;
+          // uint32_t op4 = (instr >> 6) & 0x3F;
           switch (op3) {
             case 0x0: case 0x4: {
               // STRB Rt,[Rn,#+/-imm8]     - 111 11 00 0 0 00 0 nnnn tttt 1 PUWii ii iiii
@@ -931,7 +931,7 @@ size_t DisassemblerArm::DumpThumb32(std::ostream& os, const uint8_t* instr_ptr)
 
           break;
         }
-        case 0x03: case 0x0B: case 0x13: case 0x1B: { // 00xx011
+        case 0x03: case 0x0B: case 0x13: case 0x1B: {  // 00xx011
           // Load halfword
           // |111|11|10|0 0|00|0|0000|1111|110000|000000|
           // |5 3|21|09|8 7|65|4|3  0|5  2|10   6|5    0|
@@ -975,7 +975,7 @@ size_t DisassemblerArm::DumpThumb32(std::ostream& os, const uint8_t* instr_ptr)
           }
           break;
         }
-        case 0x05: case 0x0D: case 0x15: case 0x1D: { // 00xx101
+        case 0x05: case 0x0D: case 0x15: case 0x1D: {  // 00xx101
           // Load word
           // |111|11|10|0 0|00|0|0000|1111|110000|000000|
           // |5 3|21|09|8 7|65|4|3  0|5  2|10   6|5    0|
@@ -1286,7 +1286,7 @@ size_t DisassemblerArm::DumpThumb16(std::ostream& os, const uint8_t* instr_ptr)
             // Flesh out the base "it" opcode with the specific collection of 't's and 'e's,
             // and store up the actual condition codes we'll want to add to the next few opcodes.
             size_t count = 3 - CTZ(mask);
-            it_conditions_.resize(count + 2); // Plus the implicit 't', plus the "" for the IT itself.
+            it_conditions_.resize(count + 2);  // Plus the implicit 't', plus the "" for the IT itself.
             for (size_t i = 0; i < count; ++i) {
               bool positive_cond = ((first_cond & 1) != 0);
               bool positive_mask = ((mask & (1 << (3 - i))) != 0);
@@ -1298,10 +1298,10 @@ size_t DisassemblerArm::DumpThumb16(std::ostream& os, const uint8_t* instr_ptr)
                 it_conditions_[i] = kConditionCodeNames[first_cond ^ 1];
               }
             }
-            it_conditions_[count] = kConditionCodeNames[first_cond]; // The implicit 't'.
+            it_conditions_[count] = kConditionCodeNames[first_cond];  // The implicit 't'.
 
-            it_conditions_[count + 1] = ""; // No condition code for the IT itself...
-            DumpCond(args, first_cond); // ...because it's considered an argument.
+            it_conditions_[count + 1] = "";  // No condition code for the IT itself...
+            DumpCond(args, first_cond);  // ...because it's considered an argument.
           }
           break;
         }
@@ -1312,7 +1312,7 @@ size_t DisassemblerArm::DumpThumb16(std::ostream& os, const uint8_t* instr_ptr)
         ((instr & 0xE000) == 0x8000)) {
       // Load/store single data item
       uint16_t opA = instr >> 12;
-      //uint16_t opB = (instr >> 9) & 7;
+      // uint16_t opB = (instr >> 9) & 7;
       switch (opA) {
         case 0x6: {
           // STR Rt, [Rn, #imm] - 01100 iiiii nnn ttt
diff --git a/runtime/disassembler_mips.cc b/runtime/disassembler_mips.cc
index 7fba4a8678..25bbae68ef 100644
--- a/runtime/disassembler_mips.cc
+++ b/runtime/disassembler_mips.cc
@@ -59,13 +59,13 @@ static const MipsInstruction gMipsInstructions[] = {
   { kRTypeMask, 6, "srlv", "DTS", },
   { kRTypeMask, 7, "srav", "DTS", },
   { kRTypeMask, 8, "jr", "S", },
-  { kRTypeMask | (0x1f << 11), 9 | (31 << 11), "jalr", "S", }, // rd = 31 is implicit.
-  { kRTypeMask, 9, "jalr", "DS", }, // General case.
+  { kRTypeMask | (0x1f << 11), 9 | (31 << 11), "jalr", "S", },  // rd = 31 is implicit.
+  { kRTypeMask, 9, "jalr", "DS", },  // General case.
   { kRTypeMask | (0x1f << 6), 10, "movz", "DST", },
   { kRTypeMask | (0x1f << 6), 11, "movn", "DST", },
-  { kRTypeMask, 12, "syscall", "", }, // TODO: code
-  { kRTypeMask, 13, "break", "", }, // TODO: code
-  { kRTypeMask, 15, "sync", "", }, // TODO: type
+  { kRTypeMask, 12, "syscall", "", },  // TODO: code
+  { kRTypeMask, 13, "break", "", },  // TODO: code
+  { kRTypeMask, 15, "sync", "", },  // TODO: type
   { kRTypeMask, 16, "mfhi", "D", },
   { kRTypeMask, 17, "mthi", "S", },
   { kRTypeMask, 18, "mflo", "D", },
@@ -99,7 +99,7 @@ static const MipsInstruction gMipsInstructions[] = {
   { kSpecial2Mask | 0xffff, (28 << kOpcodeShift) | 2, "mul", "DST" },
   { kSpecial2Mask | 0xffff, (28 << kOpcodeShift) | 4, "msub", "ST" },
   { kSpecial2Mask | 0xffff, (28 << kOpcodeShift) | 5, "msubu", "ST" },
-  { kSpecial2Mask | 0x3f, (28 << kOpcodeShift) | 0x3f, "sdbbp", "" }, // TODO: code
+  { kSpecial2Mask | 0x3f, (28 << kOpcodeShift) | 0x3f, "sdbbp", "" },  // TODO: code
 
   // J-type instructions.
   { kJTypeMask, 2 << kOpcodeShift, "j", "L" },
@@ -171,17 +171,17 @@ static uint32_t ReadU32(const uint8_t* ptr) {
 static void DumpMips(std::ostream& os, const uint8_t* instr_ptr) {
   uint32_t instruction = ReadU32(instr_ptr);
 
-  uint32_t rs = (instruction >> 21) & 0x1f; // I-type, R-type.
-  uint32_t rt = (instruction >> 16) & 0x1f; // I-type, R-type.
-  uint32_t rd = (instruction >> 11) & 0x1f; // R-type.
-  uint32_t sa = (instruction >>  6) & 0x1f; // R-type.
+  uint32_t rs = (instruction >> 21) & 0x1f;  // I-type, R-type.
+  uint32_t rt = (instruction >> 16) & 0x1f;  // I-type, R-type.
+  uint32_t rd = (instruction >> 11) & 0x1f;  // R-type.
+  uint32_t sa = (instruction >>  6) & 0x1f;  // R-type.
 
   std::string opcode;
   std::ostringstream args;
 
   // TODO: remove this!
   uint32_t op = (instruction >> 26) & 0x3f;
-  uint32_t function = (instruction & 0x3f); // R-type.
+  uint32_t function = (instruction & 0x3f);  // R-type.
   opcode = StringPrintf("op=%d fn=%d", op, function);
 
   for (size_t i = 0; i < arraysize(gMipsInstructions); ++i) {
@@ -189,22 +189,22 @@ static void DumpMips(std::ostream& os, const uint8_t* instr_ptr) {
       opcode = gMipsInstructions[i].name;
       for (const char* args_fmt = gMipsInstructions[i].args_fmt; *args_fmt; ++args_fmt) {
         switch (*args_fmt) {
-          case 'A': // sa (shift amount).
+          case 'A':  // sa (shift amount).
             args << sa;
             break;
-          case 'B': // Branch offset.
+          case 'B':  // Branch offset.
             {
               int32_t offset = static_cast<int16_t>(instruction & 0xffff);
               offset <<= 2;
-              offset += 4; // Delay slot.
+              offset += 4;  // Delay slot.
               args << StringPrintf("%p  ; %+d", instr_ptr + offset, offset);
             }
             break;
           case 'D': args << 'r' << rd; break;
           case 'd': args << 'f' << rd; break;
-          case 'f': // Floating point "fmt".
+          case 'f':  // Floating point "fmt".
             {
-              size_t fmt = (instruction >> 21) & 0x7; // TODO: other fmts?
+              size_t fmt = (instruction >> 21) & 0x7;  // TODO: other fmts?
               switch (fmt) {
                 case 0: opcode += ".s"; break;
                 case 1: opcode += ".d"; break;
@@ -213,16 +213,16 @@ static void DumpMips(std::ostream& os, const uint8_t* instr_ptr) {
                 case 6: opcode += ".ps"; break;
                 default: opcode += ".?"; break;
               }
-              continue; // No ", ".
+              continue;  // No ", ".
             }
             break;
-          case 'I': // Upper 16-bit immediate.
+          case 'I':  // Upper 16-bit immediate.
             args << reinterpret_cast<void*>((instruction & 0xffff) << 16);
             break;
-          case 'i': // Sign-extended lower 16-bit immediate.
+          case 'i':  // Sign-extended lower 16-bit immediate.
             args << static_cast<int16_t>(instruction & 0xffff);
             break;
-          case 'L': // Jump label.
+          case 'L':  // Jump label.
             {
               // TODO: is this right?
               uint32_t instr_index = (instruction & 0x1ffffff);
@@ -231,7 +231,7 @@ static void DumpMips(std::ostream& os, const uint8_t* instr_ptr) {
               args << reinterpret_cast<void*>(target);
             }
             break;
-          case 'O': // +x(rs)
+          case 'O':  // +x(rs)
             {
               int32_t offset = static_cast<int16_t>(instruction & 0xffff);
               args << StringPrintf("%+d(r%d)", offset, rs);
diff --git a/runtime/disassembler_x86.cc b/runtime/disassembler_x86.cc
index 48f7b6b6e9..e5cdb7b297 100644
--- a/runtime/disassembler_x86.cc
+++ b/runtime/disassembler_x86.cc
@@ -744,7 +744,7 @@ DISASSEMBLER_ENTRY(cmp,
                      prefixed_opcode.str().c_str())
      << args.str() << '\n';
   return instr - begin_instr;
-} // NOLINT(readability/fn_size)
+}  // NOLINT(readability/fn_size)
 
 }  // namespace x86
 }  // namespace art
diff --git a/runtime/exception_test.cc b/runtime/exception_test.cc
index 54341e3a45..a7a6d46c98 100644
--- a/runtime/exception_test.cc
+++ b/runtime/exception_test.cc
@@ -217,7 +217,7 @@ TEST_F(ExceptionTest, StackTraceElement) {
   EXPECT_EQ(22, trace_array->Get(1)->GetLineNumber());
 
 #if !defined(ART_USE_PORTABLE_COMPILER)
-  thread->SetTopOfStack(NULL, 0); // Disarm the assertion that no code is running when we detach.
+  thread->SetTopOfStack(NULL, 0);  // Disarm the assertion that no code is running when we detach.
 #else
   thread->PopShadowFrame();
   thread->PopShadowFrame();
diff --git a/runtime/gc/accounting/card_table.cc b/runtime/gc/accounting/card_table.cc
index 4f2ae26c37..85034a0f27 100644
--- a/runtime/gc/accounting/card_table.cc
+++ b/runtime/gc/accounting/card_table.cc
@@ -88,7 +88,7 @@ CardTable::CardTable(MemMap* mem_map, byte* biased_begin, size_t offset)
 void CardTable::ClearSpaceCards(space::ContinuousSpace* space) {
   // TODO: clear just the range of the table that has been modified
   byte* card_start = CardFromAddr(space->Begin());
-  byte* card_end = CardFromAddr(space->End()); // Make sure to round up.
+  byte* card_end = CardFromAddr(space->End());  // Make sure to round up.
   memset(reinterpret_cast<void*>(card_start), kCardClean, card_end - card_start);
 }
 
diff --git a/runtime/gc/accounting/space_bitmap-inl.h b/runtime/gc/accounting/space_bitmap-inl.h
index d074a0f578..a4cfe3c567 100644
--- a/runtime/gc/accounting/space_bitmap-inl.h
+++ b/runtime/gc/accounting/space_bitmap-inl.h
@@ -59,7 +59,7 @@ void SpaceBitmap::VisitMarkedRange(uintptr_t visit_begin, uintptr_t visit_end,
                                    const FingerVisitor& finger_visitor) const {
   DCHECK_LT(visit_begin, visit_end);
 
-  const size_t word_span = kAlignment * kBitsPerWord; // Equals IndexToOffset(1).
+  const size_t word_span = kAlignment * kBitsPerWord;  // Equals IndexToOffset(1).
   const size_t bit_index_start = (visit_begin - heap_begin_) / kAlignment;
   const size_t bit_index_end = (visit_end - heap_begin_ - 1) / kAlignment;
 
diff --git a/runtime/gc/collector/mark_sweep.cc b/runtime/gc/collector/mark_sweep.cc
index c8e60322d6..5736e3817b 100644
--- a/runtime/gc/collector/mark_sweep.cc
+++ b/runtime/gc/collector/mark_sweep.cc
@@ -61,7 +61,7 @@ namespace collector {
 
 // Performance options.
 static const bool kParallelMarkStack = true;
-static const bool kDisableFinger = true; // TODO: Fix, bit rotten.
+static const bool kDisableFinger = true;  // TODO: Fix, bit rotten.
 static const bool kUseMarkStackPrefetch = true;
 
 // Profiling and information flags.
@@ -1253,7 +1253,7 @@ void MarkSweep::ProcessMarkStackParallel() {
   thread_pool->StartWorkers(self);
   thread_pool->Wait(self, true, true);
   mark_stack_->Reset();
-  //LOG(INFO) << "Idle wait time " << PrettyDuration(thread_pool->GetWaitTime());
+  // LOG(INFO) << "Idle wait time " << PrettyDuration(thread_pool->GetWaitTime());
   CHECK_EQ(work_chunks_created_, work_chunks_deleted_) << " some of the work chunks were leaked";
 }
 
diff --git a/runtime/gc/collector/mark_sweep.h b/runtime/gc/collector/mark_sweep.h
index 34136d454d..d386fd6a64 100644
--- a/runtime/gc/collector/mark_sweep.h
+++ b/runtime/gc/collector/mark_sweep.h
@@ -424,7 +424,7 @@ class MarkSweep : public GarbageCollector {
 
   bool clear_soft_references_;
 
-  friend class AddIfReachesAllocSpaceVisitor; // Used by mod-union table.
+  friend class AddIfReachesAllocSpaceVisitor;  // Used by mod-union table.
   friend class CheckBitmapVisitor;
   friend class CheckObjectVisitor;
   friend class CheckReferenceVisitor;
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index edc5529eec..0c1c6312a8 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -523,7 +523,7 @@ bool Heap::IsHeapAddress(const mirror::Object* obj) {
 }
 
 bool Heap::IsLiveObjectLocked(const mirror::Object* obj) {
-  //Locks::heap_bitmap_lock_->AssertReaderHeld(Thread::Current());
+  // Locks::heap_bitmap_lock_->AssertReaderHeld(Thread::Current());
   if (obj == NULL) {
     return false;
   }
diff --git a/runtime/gc/space/dlmalloc_space.cc b/runtime/gc/space/dlmalloc_space.cc
index 9f853943ff..ee88edaaae 100644
--- a/runtime/gc/space/dlmalloc_space.cc
+++ b/runtime/gc/space/dlmalloc_space.cc
@@ -20,7 +20,7 @@
 #include "thread.h"
 #include "utils.h"
 
-//#include <valgrind/memcheck.h>
+// #include <valgrind/memcheck.h>
 #include <valgrind.h>
 
 namespace art {
@@ -49,7 +49,7 @@ class ValgrindDlMallocSpace : public DlMallocSpace {
   virtual mirror::Object* AllocWithGrowth(Thread* self, size_t num_bytes) {
     void* obj_with_rdz = DlMallocSpace::AllocWithGrowth(self, num_bytes + (2 * kValgrindRedZoneBytes));
     if (obj_with_rdz != NULL) {
-      //VALGRIND_MAKE_MEM_UNDEFINED();
+      // VALGRIND_MAKE_MEM_UNDEFINED();
       mirror::Object* result = reinterpret_cast<mirror::Object*>(reinterpret_cast<byte*>(obj_with_rdz) +
                                                                  kValgrindRedZoneBytes);
       VALGRIND_MEMPOOL_ALLOC(GetMspace(), result, num_bytes);
diff --git a/runtime/gc/space/space.h b/runtime/gc/space/space.h
index 011e15567a..bc6e8185b1 100644
--- a/runtime/gc/space/space.h
+++ b/runtime/gc/space/space.h
@@ -36,7 +36,7 @@ namespace gc {
 
 namespace accounting {
   class SpaceBitmap;
-} // namespace accounting
+}  // namespace accounting
 
 class Heap;
 
diff --git a/runtime/hprof/hprof.cc b/runtime/hprof/hprof.cc
index 3c8099a917..d3bb2e8f5f 100644
--- a/runtime/hprof/hprof.cc
+++ b/runtime/hprof/hprof.cc
@@ -641,7 +641,7 @@ class Hprof {
 
     // U4: low word of the 64-bit time.
     U4_TO_BUF_BE(buf, 0, (uint32_t)(nowMs & 0xffffffffULL));
-    fwrite(buf, 1, sizeof(uint32_t), header_fp_); //xxx fix the time
+    fwrite(buf, 1, sizeof(uint32_t), header_fp_);  // xxx fix the time
   }
 
   void WriteStackTraces() {
@@ -665,7 +665,7 @@ class Hprof {
 
   uint32_t gc_thread_serial_number_;
   uint8_t gc_scan_state_;
-  HprofHeapId current_heap_; // Which heap we're currently dumping.
+  HprofHeapId current_heap_;  // Which heap we're currently dumping.
   size_t objects_in_segment_;
 
   FILE* header_fp_;
@@ -805,7 +805,7 @@ int Hprof::MarkRootObject(const mirror::Object* obj, jobject jniObj) {
     rec->AddU1(heapTag);
     rec->AddId((HprofObjectId)obj);
     rec->AddU4(gc_thread_serial_number_);
-    rec->AddU4((uint32_t)-1);    //xxx
+    rec->AddU4((uint32_t)-1);    // xxx
     break;
 
   case HPROF_CLASS_DUMP:
@@ -834,7 +834,7 @@ static int StackTraceSerialNumber(const mirror::Object* /*obj*/) {
 
 int Hprof::DumpHeapObject(mirror::Object* obj) {
   HprofRecord* rec = &current_record_;
-  HprofHeapId desiredHeap = false ? HPROF_HEAP_ZYGOTE : HPROF_HEAP_APP; // TODO: zygote objects?
+  HprofHeapId desiredHeap = false ? HPROF_HEAP_ZYGOTE : HPROF_HEAP_APP;  // TODO: zygote objects?
 
   if (objects_in_segment_ >= OBJECTS_PER_SEGMENT || rec->Size() >= BYTES_PER_SEGMENT) {
     StartNewHeapDumpSegment();
@@ -876,7 +876,7 @@ int Hprof::DumpHeapObject(mirror::Object* obj) {
       // obj is a ClassObject.
       size_t sFieldCount = thisClass->NumStaticFields();
       if (sFieldCount != 0) {
-        int byteLength = sFieldCount*sizeof(JValue); // TODO bogus; fields are packed
+        int byteLength = sFieldCount*sizeof(JValue);  // TODO bogus; fields are packed
         // Create a byte array to reflect the allocation of the
         // StaticField array at the end of this class.
         rec->AddU1(HPROF_PRIMITIVE_ARRAY_DUMP);
@@ -901,14 +901,14 @@ int Hprof::DumpHeapObject(mirror::Object* obj) {
       if (thisClass->IsClassClass()) {
         // ClassObjects have their static fields appended, so aren't all the same size.
         // But they're at least this size.
-        rec->AddU4(sizeof(mirror::Class)); // instance size
+        rec->AddU4(sizeof(mirror::Class));  // instance size
       } else if (thisClass->IsArrayClass() || thisClass->IsPrimitive()) {
         rec->AddU4(0);
       } else {
-        rec->AddU4(thisClass->GetObjectSize()); // instance size
+        rec->AddU4(thisClass->GetObjectSize());  // instance size
       }
 
-      rec->AddU2(0); // empty const pool
+      rec->AddU2(0);  // empty const pool
 
       FieldHelper fh;
 
@@ -1041,7 +1041,7 @@ int Hprof::DumpHeapObject(mirror::Object* obj) {
 
 void Hprof::VisitRoot(const mirror::Object* obj) {
   uint32_t threadId = 0;  // TODO
-  /*RootType*/ size_t type = 0; // TODO
+  /*RootType*/ size_t type = 0;  // TODO
 
   static const HprofHeapTag xlate[] = {
     HPROF_ROOT_UNKNOWN,
diff --git a/runtime/indirect_reference_table.cc b/runtime/indirect_reference_table.cc
index 0287d745c5..0616d28802 100644
--- a/runtime/indirect_reference_table.cc
+++ b/runtime/indirect_reference_table.cc
@@ -309,7 +309,7 @@ bool IndirectReferenceTable::Remove(uint32_t cookie, IndirectRef iref) {
 }
 
 void IndirectReferenceTable::VisitRoots(RootVisitor* visitor, void* arg) {
-  typedef IndirectReferenceTable::iterator It; // TODO: C++0x auto
+  typedef IndirectReferenceTable::iterator It;  // TODO: C++0x auto
   for (It it = begin(), end = this->end(); it != end; ++it) {
     visitor(**it, arg);
   }
diff --git a/runtime/indirect_reference_table.h b/runtime/indirect_reference_table.h
index 34b0f3abe2..97706b82bb 100644
--- a/runtime/indirect_reference_table.h
+++ b/runtime/indirect_reference_table.h
@@ -109,10 +109,10 @@ static mirror::Object* const kClearedJniWeakGlobal = reinterpret_cast<mirror::Ob
  * For convenience these match up with enum jobjectRefType from jni.h.
  */
 enum IndirectRefKind {
-  kSirtOrInvalid = 0, // <<stack indirect reference table or invalid reference>>
-  kLocal         = 1, // <<local reference>>
-  kGlobal        = 2, // <<global reference>>
-  kWeakGlobal    = 3  // <<weak global reference>>
+  kSirtOrInvalid = 0,  // <<stack indirect reference table or invalid reference>>
+  kLocal         = 1,  // <<local reference>>
+  kGlobal        = 2,  // <<global reference>>
+  kWeakGlobal    = 3   // <<weak global reference>>
 };
 std::ostream& operator<<(std::ostream& os, const IndirectRefKind& rhs);
 
diff --git a/runtime/instrumentation.cc b/runtime/instrumentation.cc
index 8a05aa4725..e99fbd8d53 100644
--- a/runtime/instrumentation.cc
+++ b/runtime/instrumentation.cc
@@ -122,7 +122,7 @@ static void InstrumentationInstallStack(Thread* thread, void* arg)
           LOG(INFO) << "  Skipping upcall. Frame " << GetFrameId();
         }
         last_return_pc_ = 0;
-        return true; // Ignore upcalls.
+        return true;  // Ignore upcalls.
       }
       if (m->IsRuntimeMethod()) {
         if (kVerboseInstrumentation) {
@@ -206,7 +206,7 @@ static void InstrumentationRestoreStack(Thread* thread, void* arg)
         }
         return true;  // Ignore upcalls.
       }
-      typedef std::deque<instrumentation::InstrumentationStackFrame>::const_iterator It; // TODO: C++0x auto
+      typedef std::deque<instrumentation::InstrumentationStackFrame>::const_iterator It;  // TODO: C++0x auto
       bool removed_stub = false;
       // TODO: make this search more efficient?
       for (It it = instrumentation_stack_->begin(), end = instrumentation_stack_->end(); it != end;
@@ -407,7 +407,7 @@ const void* Instrumentation::GetQuickCodeFor(const mirror::AbstractMethod* metho
 void Instrumentation::MethodEnterEventImpl(Thread* thread, mirror::Object* this_object,
                                            const mirror::AbstractMethod* method,
                                            uint32_t dex_pc) const {
-  typedef std::list<InstrumentationListener*>::const_iterator It; // TODO: C++0x auto
+  typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
   It it = method_entry_listeners_.begin();
   bool is_end = (it == method_entry_listeners_.end());
   // Implemented this way to prevent problems caused by modification of the list while iterating.
@@ -422,7 +422,7 @@ void Instrumentation::MethodEnterEventImpl(Thread* thread, mirror::Object* this_
 void Instrumentation::MethodExitEventImpl(Thread* thread, mirror::Object* this_object,
                                           const mirror::AbstractMethod* method,
                                           uint32_t dex_pc, const JValue& return_value) const {
-  typedef std::list<InstrumentationListener*>::const_iterator It; // TODO: C++0x auto
+  typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
   It it = method_exit_listeners_.begin();
   bool is_end = (it == method_exit_listeners_.end());
   // Implemented this way to prevent problems caused by modification of the list while iterating.
@@ -438,7 +438,7 @@ void Instrumentation::MethodUnwindEvent(Thread* thread, mirror::Object* this_obj
                                         const mirror::AbstractMethod* method,
                                         uint32_t dex_pc) const {
   if (have_method_unwind_listeners_) {
-    typedef std::list<InstrumentationListener*>::const_iterator It; // TODO: C++0x auto
+    typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
     for (It it = method_unwind_listeners_.begin(), end = method_unwind_listeners_.end(); it != end;
         ++it) {
       (*it)->MethodUnwind(thread, method, dex_pc);
@@ -454,7 +454,7 @@ void Instrumentation::DexPcMovedEventImpl(Thread* thread, mirror::Object* this_o
   // around the problem and in general we may have to move to something like reference counting to
   // ensure listeners are deleted correctly.
   std::list<InstrumentationListener*> copy(dex_pc_listeners_);
-  typedef std::list<InstrumentationListener*>::const_iterator It; // TODO: C++0x auto
+  typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
   for (It it = copy.begin(), end = copy.end(); it != end; ++it) {
     (*it)->DexPcMoved(thread, this_object, method, dex_pc);
   }
@@ -467,7 +467,7 @@ void Instrumentation::ExceptionCaughtEvent(Thread* thread, const ThrowLocation&
   if (have_exception_caught_listeners_) {
     DCHECK_EQ(thread->GetException(NULL), exception_object);
     thread->ClearException();
-    typedef std::list<InstrumentationListener*>::const_iterator It; // TODO: C++0x auto
+    typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
     for (It it = exception_caught_listeners_.begin(), end = exception_caught_listeners_.end();
         it != end; ++it) {
       (*it)->ExceptionCaught(thread, throw_location, catch_method, catch_dex_pc, exception_object);
diff --git a/runtime/intern_table.cc b/runtime/intern_table.cc
index d1ad2dbadc..e2c1a64dec 100644
--- a/runtime/intern_table.cc
+++ b/runtime/intern_table.cc
@@ -40,7 +40,7 @@ void InternTable::DumpForSigQuit(std::ostream& os) const {
 
 void InternTable::VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty) {
   MutexLock mu(Thread::Current(), intern_table_lock_);
-  typedef Table::const_iterator It; // TODO: C++0x auto
+  typedef Table::const_iterator It;  // TODO: C++0x auto
   for (It it = strong_interns_.begin(), end = strong_interns_.end(); it != end; ++it) {
     visitor(it->second, arg);
   }
@@ -52,7 +52,7 @@ void InternTable::VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty)
 
 mirror::String* InternTable::Lookup(Table& table, mirror::String* s, uint32_t hash_code) {
   intern_table_lock_.AssertHeld(Thread::Current());
-  typedef Table::const_iterator It; // TODO: C++0x auto
+  typedef Table::const_iterator It;  // TODO: C++0x auto
   for (It it = table.find(hash_code), end = table.end(); it != end; ++it) {
     mirror::String* existing_string = it->second;
     if (existing_string->Equals(s)) {
@@ -75,7 +75,7 @@ void InternTable::RegisterStrong(mirror::String* s) {
 
 void InternTable::Remove(Table& table, const mirror::String* s, uint32_t hash_code) {
   intern_table_lock_.AssertHeld(Thread::Current());
-  typedef Table::iterator It; // TODO: C++0x auto
+  typedef Table::iterator It;  // TODO: C++0x auto
   for (It it = table.find(hash_code), end = table.end(); it != end; ++it) {
     if (it->second == s) {
       table.erase(it);
@@ -166,7 +166,7 @@ bool InternTable::ContainsWeak(mirror::String* s) {
 
 void InternTable::SweepInternTableWeaks(IsMarkedTester is_marked, void* arg) {
   MutexLock mu(Thread::Current(), intern_table_lock_);
-  typedef Table::iterator It; // TODO: C++0x auto
+  typedef Table::iterator It;  // TODO: C++0x auto
   for (It it = weak_interns_.begin(), end = weak_interns_.end(); it != end;) {
     mirror::Object* object = it->second;
     if (!is_marked(object, arg)) {
diff --git a/runtime/intern_table_test.cc b/runtime/intern_table_test.cc
index f6b040def2..ffb93eb672 100644
--- a/runtime/intern_table_test.cc
+++ b/runtime/intern_table_test.cc
@@ -58,7 +58,7 @@ class TestPredicate {
  public:
   bool IsMarked(const mirror::Object* s) const {
     bool erased = false;
-    typedef std::vector<const mirror::String*>::iterator It; // TODO: C++0x auto
+    typedef std::vector<const mirror::String*>::iterator It;  // TODO: C++0x auto
     for (It it = expected_.begin(), end = expected_.end(); it != end; ++it) {
       if (*it == s) {
         expected_.erase(it);
diff --git a/runtime/interpreter/interpreter.cc b/runtime/interpreter/interpreter.cc
index 09a0fc7364..30c7a46204 100644
--- a/runtime/interpreter/interpreter.cc
+++ b/runtime/interpreter/interpreter.cc
@@ -74,7 +74,7 @@ static void UnstartedRuntimeInvoke(Thread* self, MethodHelper& mh,
   std::string name(PrettyMethod(shadow_frame->GetMethod()));
   if (name == "java.lang.Class java.lang.Class.forName(java.lang.String)") {
     std::string descriptor(DotToDescriptor(shadow_frame->GetVRegReference(arg_offset)->AsString()->ToModifiedUtf8().c_str()));
-    ClassLoader* class_loader = NULL; // shadow_frame.GetMethod()->GetDeclaringClass()->GetClassLoader();
+    ClassLoader* class_loader = NULL;  // shadow_frame.GetMethod()->GetDeclaringClass()->GetClassLoader();
     Class* found = Runtime::Current()->GetClassLinker()->FindClass(descriptor.c_str(),
                                                                    class_loader);
     CHECK(found != NULL) << "Class.forName failed in un-started runtime for class: "
@@ -659,7 +659,7 @@ static inline void DoIGetQuick(Thread* self, ShadowFrame& shadow_frame,
     return;
   }
   MemberOffset field_offset(inst->VRegC_22c());
-  const bool is_volatile = false; // iget-x-quick only on non volatile fields.
+  const bool is_volatile = false;  // iget-x-quick only on non volatile fields.
   const uint32_t vregA = inst->VRegA_22c();
   switch (field_type) {
     case Primitive::kPrimInt:
@@ -752,7 +752,7 @@ static inline void DoIPutQuick(Thread* self, ShadowFrame& shadow_frame,
     return;
   }
   MemberOffset field_offset(inst->VRegC_22c());
-  const bool is_volatile = false; // iput-x-quick only on non volatile fields.
+  const bool is_volatile = false;  // iput-x-quick only on non volatile fields.
   const uint32_t vregA = inst->VRegA_22c();
   switch (field_type) {
     case Primitive::kPrimInt:
diff --git a/runtime/invoke_type.h b/runtime/invoke_type.h
index cdf9be87d9..de07c72ef0 100644
--- a/runtime/invoke_type.h
+++ b/runtime/invoke_type.h
@@ -22,11 +22,11 @@
 namespace art {
 
 enum InvokeType {
-  kStatic,    // <<static>>
-  kDirect,    // <<direct>>
-  kVirtual,   // <<virtual>>
-  kSuper,     // <<super>>
-  kInterface, // <<interface>>
+  kStatic,     // <<static>>
+  kDirect,     // <<direct>>
+  kVirtual,    // <<virtual>>
+  kSuper,      // <<super>>
+  kInterface,  // <<interface>>
   kMaxInvokeType = kInterface
 };
 
diff --git a/runtime/jdwp/jdwp.h b/runtime/jdwp/jdwp.h
index ca118a2dab..010a2079b4 100644
--- a/runtime/jdwp/jdwp.h
+++ b/runtime/jdwp/jdwp.h
@@ -152,7 +152,7 @@ struct JdwpState {
    * events at the same time, so we grab a mutex in the "set" call, and
    * release it in the "clear" call.
    */
-  //ObjectId GetWaitForEventThread();
+  // ObjectId GetWaitForEventThread();
   void SetWaitForEventThread(ObjectId threadId);
   void ClearWaitForEventThread();
 
@@ -291,7 +291,7 @@ struct JdwpState {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   void SendBufferedRequest(uint32_t type, const std::vector<iovec>& iov);
 
- public: // TODO: fix privacy
+ public:  // TODO: fix privacy
   const JdwpOptions* options_;
 
  private:
@@ -308,7 +308,7 @@ struct JdwpState {
  private:
   bool run;
 
- public: // TODO: fix privacy
+ public:  // TODO: fix privacy
   JdwpNetStateBase* netState;
 
  private:
@@ -326,7 +326,7 @@ struct JdwpState {
   // Linked list of events requested by the debugger (breakpoints, class prep, etc).
   Mutex event_list_lock_;
   JdwpEvent* event_list_ GUARDED_BY(event_list_lock_);
-  int event_list_size_ GUARDED_BY(event_list_lock_); // Number of elements in event_list_.
+  int event_list_size_ GUARDED_BY(event_list_lock_);  // Number of elements in event_list_.
 
   // Used to synchronize suspension of the event thread (to avoid receiving "resume"
   // events before the thread has finished suspending itself).
diff --git a/runtime/jdwp/jdwp_constants.h b/runtime/jdwp/jdwp_constants.h
index a8db325c66..9fc896d8eb 100644
--- a/runtime/jdwp/jdwp_constants.h
+++ b/runtime/jdwp/jdwp_constants.h
@@ -111,7 +111,7 @@ enum JdwpEventKind {
   EK_EXCEPTION            = 4,
   EK_USER_DEFINED         = 5,
   EK_THREAD_START         = 6,
-  EK_THREAD_DEATH         = 7, // Formerly known as THREAD_END.
+  EK_THREAD_DEATH         = 7,  // Formerly known as THREAD_END.
   EK_CLASS_PREPARE        = 8,
   EK_CLASS_UNLOAD         = 9,
   EK_CLASS_LOAD           = 10,
@@ -125,9 +125,9 @@ enum JdwpEventKind {
   EK_MONITOR_CONTENDED_ENTERED     = 44,
   EK_MONITOR_WAIT         = 45,
   EK_MONITOR_WAITED       = 46,
-  EK_VM_START             = 90, // Formerly known as VM_INIT.
+  EK_VM_START             = 90,  // Formerly known as VM_INIT.
   EK_VM_DEATH             = 99,
-  EK_VM_DISCONNECTED      = 100, // "Never sent across JDWP".
+  EK_VM_DISCONNECTED      = 100,  // "Never sent across JDWP".
 };
 std::ostream& operator<<(std::ostream& os, const JdwpEventKind& value);
 
@@ -146,7 +146,7 @@ enum JdwpModKind {
   MK_FIELD_ONLY           = 9,
   MK_STEP                 = 10,
   MK_INSTANCE_ONLY        = 11,
-  MK_SOURCE_NAME_MATCH    = 12, // Since Java 6.
+  MK_SOURCE_NAME_MATCH    = 12,  // Since Java 6.
 };
 std::ostream& operator<<(std::ostream& os, const JdwpModKind& value);
 
diff --git a/runtime/jdwp/jdwp_event.cc b/runtime/jdwp/jdwp_event.cc
index ef5a7d3822..345549d1a0 100644
--- a/runtime/jdwp/jdwp_event.cc
+++ b/runtime/jdwp/jdwp_event.cc
@@ -248,7 +248,7 @@ void JdwpState::UnregisterEventById(uint32_t requestId) {
     pEvent = pEvent->next;
   }
 
-  //LOGD("Odd: no match when removing event reqId=0x%04x", requestId);
+  // ALOGD("Odd: no match when removing event reqId=0x%04x", requestId);
 }
 
 /*
@@ -679,7 +679,7 @@ bool JdwpState::PostVMStart() {
 
   ExpandBuf* pReq = eventPrep();
   {
-    MutexLock mu(Thread::Current(), event_list_lock_); // probably don't need this here
+    MutexLock mu(Thread::Current(), event_list_lock_);  // probably don't need this here
 
     VLOG(jdwp) << "EVENT: " << EK_VM_START;
     VLOG(jdwp) << "  suspend_policy=" << suspend_policy;
@@ -773,7 +773,7 @@ bool JdwpState::PostLocationEvent(const JdwpLocation* pLoc, ObjectId thisPtr, in
       FindMatchingEvents(EK_METHOD_EXIT, &basket, match_list, &match_count);
 
       // TODO: match EK_METHOD_EXIT_WITH_RETURN_VALUE too; we need to include the 'value', though.
-      //FindMatchingEvents(EK_METHOD_EXIT_WITH_RETURN_VALUE, &basket, match_list, &match_count);
+      // FindMatchingEvents(EK_METHOD_EXIT_WITH_RETURN_VALUE, &basket, match_list, &match_count);
     }
     if (match_count != 0) {
       VLOG(jdwp) << "EVENT: " << match_list[0]->eventKind << "(" << match_count << " total) "
diff --git a/runtime/jdwp/jdwp_handler.cc b/runtime/jdwp/jdwp_handler.cc
index 9af2f833bc..a2efc48c84 100644
--- a/runtime/jdwp/jdwp_handler.cc
+++ b/runtime/jdwp/jdwp_handler.cc
@@ -1030,7 +1030,7 @@ static JdwpError TR_Frames(JdwpState*, Request& request, ExpandBuf* pReply)
   }
 
   if (actual_frame_count <= 0) {
-    return ERR_THREAD_NOT_SUSPENDED; // 0 means no managed frames (which means "in native").
+    return ERR_THREAD_NOT_SUSPENDED;  // 0 means no managed frames (which means "in native").
   }
 
   if (start_frame > actual_frame_count) {
@@ -1315,7 +1315,7 @@ static JdwpError ER_Set(JdwpState* state, Request& request, ExpandBuf* pReply)
     case MK_EXCEPTION_ONLY:
       {
         // Modifies EK_EXCEPTION events,
-        mod.exceptionOnly.refTypeId = request.ReadRefTypeId(); // null => all exceptions.
+        mod.exceptionOnly.refTypeId = request.ReadRefTypeId();  // null => all exceptions.
         mod.exceptionOnly.caught = request.ReadEnum1<uint8_t>("caught");
         mod.exceptionOnly.uncaught = request.ReadEnum1<uint8_t>("uncaught");
       }
@@ -1622,7 +1622,7 @@ static const JdwpHandlerMap gHandlers[] = {
   { 17,   1,  COR_ReflectedType, "ClassObjectReference.ReflectedType" },
 
   /* Event command set (64) */
-  { 64, 100,  NULL, "Event.Composite" }, // sent from VM to debugger, never received by VM
+  { 64, 100,  NULL, "Event.Composite" },  // sent from VM to debugger, never received by VM
 
   { 199,  1,  DDM_Chunk,        "DDM.Chunk" },
 };
diff --git a/runtime/jdwp/jdwp_priv.h b/runtime/jdwp/jdwp_priv.h
index f919f97699..4e6aadac1a 100644
--- a/runtime/jdwp/jdwp_priv.h
+++ b/runtime/jdwp/jdwp_priv.h
@@ -72,9 +72,9 @@ class JdwpNetStateBase {
   ssize_t WritePacket(ExpandBuf* pReply);
   ssize_t WriteBufferedPacket(const std::vector<iovec>& iov);
 
-  int clientSock; // Active connection to debugger.
+  int clientSock;  // Active connection to debugger.
 
-  int wake_pipe_[2]; // Used to break out of select.
+  int wake_pipe_[2];  // Used to break out of select.
 
   uint8_t input_buffer_[8192];
   size_t input_count_;
diff --git a/runtime/jdwp/jdwp_request.cc b/runtime/jdwp/jdwp_request.cc
index 440b51b6e3..a9dd1e1790 100644
--- a/runtime/jdwp/jdwp_request.cc
+++ b/runtime/jdwp/jdwp_request.cc
@@ -140,7 +140,7 @@ JdwpTypeTag Request::ReadTypeTag() {
 
 JdwpLocation Request::ReadLocation() {
   JdwpLocation location;
-  memset(&location, 0, sizeof(location)); // Allows memcmp(3) later.
+  memset(&location, 0, sizeof(location));  // Allows memcmp(3) later.
   location.type_tag = ReadTypeTag();
   location.class_id = ReadObjectId("class");
   location.method_id = ReadMethodId();
diff --git a/runtime/jdwp/object_registry.cc b/runtime/jdwp/object_registry.cc
index 54e7a8e486..be2219c311 100644
--- a/runtime/jdwp/object_registry.cc
+++ b/runtime/jdwp/object_registry.cc
@@ -173,15 +173,15 @@ bool ObjectRegistry::IsCollected(JDWP::ObjectId id) {
   MutexLock mu(self, lock_);
   id_iterator it = id_to_entry_.find(id);
   if (it == id_to_entry_.end()) {
-    return true; // TODO: can we report that this was an invalid id?
+    return true;  // TODO: can we report that this was an invalid id?
   }
 
   ObjectRegistryEntry& entry = *(it->second);
   if (entry.jni_reference_type == JNIWeakGlobalRefType) {
     JNIEnv* env = self->GetJniEnv();
-    return env->IsSameObject(entry.jni_reference, NULL); // Has the jweak been collected?
+    return env->IsSameObject(entry.jni_reference, NULL);  // Has the jweak been collected?
   } else {
-    return false; // We hold a strong reference, so we know this is live.
+    return false;  // We hold a strong reference, so we know this is live.
   }
 }
 
diff --git a/runtime/jni_internal.cc b/runtime/jni_internal.cc
index 72d9aea2f9..858ac34134 100644
--- a/runtime/jni_internal.cc
+++ b/runtime/jni_internal.cc
@@ -69,20 +69,20 @@ using ::art::mirror::Throwable;
 
 namespace art {
 
-static const size_t kMonitorsInitial = 32; // Arbitrary.
-static const size_t kMonitorsMax = 4096; // Arbitrary sanity check.
+static const size_t kMonitorsInitial = 32;  // Arbitrary.
+static const size_t kMonitorsMax = 4096;  // Arbitrary sanity check.
 
-static const size_t kLocalsInitial = 64; // Arbitrary.
-static const size_t kLocalsMax = 512; // Arbitrary sanity check.
+static const size_t kLocalsInitial = 64;  // Arbitrary.
+static const size_t kLocalsMax = 512;  // Arbitrary sanity check.
 
-static const size_t kPinTableInitial = 16; // Arbitrary.
-static const size_t kPinTableMax = 1024; // Arbitrary sanity check.
+static const size_t kPinTableInitial = 16;  // Arbitrary.
+static const size_t kPinTableMax = 1024;  // Arbitrary sanity check.
 
-static size_t gGlobalsInitial = 512; // Arbitrary.
-static size_t gGlobalsMax = 51200; // Arbitrary sanity check. (Must fit in 16 bits.)
+static size_t gGlobalsInitial = 512;  // Arbitrary.
+static size_t gGlobalsMax = 51200;  // Arbitrary sanity check. (Must fit in 16 bits.)
 
-static const size_t kWeakGlobalsInitial = 16; // Arbitrary.
-static const size_t kWeakGlobalsMax = 51200; // Arbitrary sanity check. (Must fit in 16 bits.)
+static const size_t kWeakGlobalsInitial = 16;  // Arbitrary.
+static const size_t kWeakGlobalsMax = 51200;  // Arbitrary sanity check. (Must fit in 16 bits.)
 
 static jweak AddWeakGlobalReference(ScopedObjectAccess& soa, Object* obj)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -591,7 +591,7 @@ class Libraries {
   }
 
  private:
-  typedef SafeMap<std::string, SharedLibrary*>::const_iterator It; // TODO: C++0x auto
+  typedef SafeMap<std::string, SharedLibrary*>::const_iterator It;  // TODO: C++0x auto
 
   SafeMap<std::string, SharedLibrary*> libraries_;
 };
@@ -1796,7 +1796,7 @@ class JNI {
     String* s = soa.Decode<String*>(java_string);
     size_t byte_count = s->GetUtfLength();
     char* bytes = new char[byte_count + 1];
-    CHECK(bytes != NULL); // bionic aborts anyway.
+    CHECK(bytes != NULL);  // bionic aborts anyway.
     const uint16_t* chars = s->GetCharArray()->GetData() + s->GetOffset();
     ConvertUtf16ToModifiedUtf8(bytes, chars, s->GetLength());
     bytes[byte_count] = '\0';
@@ -2705,7 +2705,7 @@ JavaVMExt::JavaVMExt(Runtime* runtime, Runtime::ParsedOptions* options)
       check_jni_abort_hook(NULL),
       check_jni_abort_hook_data(NULL),
       check_jni(false),
-      force_copy(false), // TODO: add a way to enable this
+      force_copy(false),  // TODO: add a way to enable this
       trace(options->jni_trace_),
       work_around_app_jni_bugs(false),
       pins_lock("JNI pin table lock", kPinTableLock),
diff --git a/runtime/jvalue.h b/runtime/jvalue.h
index 0c1aadb462..b39567b297 100644
--- a/runtime/jvalue.h
+++ b/runtime/jvalue.h
@@ -32,7 +32,7 @@ union PACKED(4) JValue {
 
   int8_t GetB() const { return b; }
   void SetB(int8_t new_b) {
-    i = ((static_cast<int32_t>(new_b) << 24) >> 24); // Sign-extend.
+    i = ((static_cast<int32_t>(new_b) << 24) >> 24);  // Sign-extend.
   }
 
   uint16_t GetC() const { return c; }
@@ -55,7 +55,7 @@ union PACKED(4) JValue {
 
   int16_t GetS() const { return s; }
   void SetS(int16_t new_s) {
-    i = ((static_cast<int32_t>(new_s) << 16) >> 16); // Sign-extend.
+    i = ((static_cast<int32_t>(new_s) << 16) >> 16);  // Sign-extend.
   }
 
   uint8_t GetZ() const { return z; }
diff --git a/runtime/locks.h b/runtime/locks.h
index df3f27b4bc..88d05db0cb 100644
--- a/runtime/locks.h
+++ b/runtime/locks.h
@@ -57,7 +57,7 @@ enum LockLevel {
   kMutatorLock,
   kZygoteCreationLock,
 
-  kLockLevelCount // Must come last.
+  kLockLevelCount  // Must come last.
 };
 std::ostream& operator<<(std::ostream& os, const LockLevel& rhs);
 
diff --git a/runtime/log_severity.h b/runtime/log_severity.h
index bb7679d218..31682dfeee 100644
--- a/runtime/log_severity.h
+++ b/runtime/log_severity.h
@@ -20,6 +20,6 @@
 typedef int LogSeverity;
 
 const int VERBOSE = 0, DEBUG = 1, INFO = 2, WARNING = 3, ERROR = 4, FATAL = 5;
-const int INTERNAL_FATAL = 6; // For Runtime::Abort.
+const int INTERNAL_FATAL = 6;  // For Runtime::Abort.
 
 #endif  // ART_RUNTIME_LOG_SEVERITY_H_
diff --git a/runtime/mem_map.cc b/runtime/mem_map.cc
index a0f389cb1e..619b73cf8a 100644
--- a/runtime/mem_map.cc
+++ b/runtime/mem_map.cc
@@ -52,9 +52,9 @@ static void CheckMapRequest(byte* addr, size_t byte_count) {
 
   map_info_t* map_info_list = load_map_info_list(getpid());
   for (map_info_t* m = map_info_list; m != NULL; m = m->next) {
-    CHECK(!(base >= m->start && base < m->end)      // start of new within old
-        && !(limit > m->start && limit < m->end)  // end of new within old
-        && !(base <= m->start && limit > m->end)) // start/end of new includes all of old
+    CHECK(!(base >= m->start && base < m->end)     // start of new within old
+        && !(limit > m->start && limit < m->end)   // end of new within old
+        && !(base <= m->start && limit > m->end))  // start/end of new includes all of old
         << StringPrintf("Requested region 0x%08x-0x%08x overlaps with existing map 0x%08x-0x%08x (%s)\n",
                         base, limit,
                         static_cast<uint32_t>(m->start), static_cast<uint32_t>(m->end), m->name)
diff --git a/runtime/mirror/dex_cache.h b/runtime/mirror/dex_cache.h
index fd3f5f44b8..9c0f09ba21 100644
--- a/runtime/mirror/dex_cache.h
+++ b/runtime/mirror/dex_cache.h
@@ -172,7 +172,7 @@ class MANAGED DexCache : public Object {
   ObjectArray<String>* strings_;
   uint32_t dex_file_;
 
-  friend struct art::DexCacheOffsets; // for verifying offset information
+  friend struct art::DexCacheOffsets;  // for verifying offset information
   DISALLOW_IMPLICIT_CONSTRUCTORS(DexCache);
 };
 
diff --git a/runtime/mirror/field.cc b/runtime/mirror/field.cc
index a96e8c8d54..12f395f6b6 100644
--- a/runtime/mirror/field.cc
+++ b/runtime/mirror/field.cc
@@ -42,7 +42,7 @@ void Field::ResetClass() {
 
 void Field::SetOffset(MemberOffset num_bytes) {
   DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-#if 0 // TODO enable later in boot and under !NDEBUG
+#if 0  // TODO enable later in boot and under !NDEBUG
   FieldHelper fh(this);
   Primitive::Type type = fh.GetTypeAsPrimitiveType();
   if (type == Primitive::kPrimDouble || type == Primitive::kPrimLong) {
diff --git a/runtime/mirror/throwable.h b/runtime/mirror/throwable.h
index 909228e4d9..27f6e1289a 100644
--- a/runtime/mirror/throwable.h
+++ b/runtime/mirror/throwable.h
@@ -59,7 +59,7 @@ class MANAGED Throwable : public Object {
   // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
   Throwable* cause_;
   String* detail_message_;
-  Object* stack_state_; // Note this is Java volatile:
+  Object* stack_state_;  // Note this is Java volatile:
   Object* stack_trace_;
   Object* suppressed_exceptions_;
 
diff --git a/runtime/monitor.cc b/runtime/monitor.cc
index 11790e5c9e..09a952b3cf 100644
--- a/runtime/monitor.cc
+++ b/runtime/monitor.cc
@@ -698,7 +698,7 @@ bool Monitor::MonitorExit(Thread* self, mirror::Object* obj) {
   volatile int32_t* thinp = obj->GetRawLockWordAddress();
 
   DCHECK(self != NULL);
-  //DCHECK_EQ(self->GetState(), kRunnable);
+  // DCHECK_EQ(self->GetState(), kRunnable);
   DCHECK(obj != NULL);
 
   /*
@@ -918,7 +918,7 @@ void Monitor::VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::O
   const DexFile::CodeItem* code_item = mh.GetCodeItem();
   CHECK(code_item != NULL) << PrettyMethod(m);
   if (code_item->tries_size_ == 0) {
-    return; // No "tries" implies no synchronization, so no held locks to report.
+    return;  // No "tries" implies no synchronization, so no held locks to report.
   }
 
   // Ask the verifier for the dex pcs of all the monitor-enter instructions corresponding to
@@ -979,7 +979,7 @@ void MonitorList::Add(Monitor* m) {
 
 void MonitorList::SweepMonitorList(IsMarkedTester is_marked, void* arg) {
   MutexLock mu(Thread::Current(), monitor_list_lock_);
-  typedef std::list<Monitor*>::iterator It; // TODO: C++0x auto
+  typedef std::list<Monitor*>::iterator It;  // TODO: C++0x auto
   It it = list_.begin();
   while (it != list_.end()) {
     Monitor* m = *it;
diff --git a/runtime/native/dalvik_system_VMDebug.cc b/runtime/native/dalvik_system_VMDebug.cc
index 992998eb66..60624c2704 100644
--- a/runtime/native/dalvik_system_VMDebug.cc
+++ b/runtime/native/dalvik_system_VMDebug.cc
@@ -101,12 +101,12 @@ static void VMDebug_stopMethodTracing(JNIEnv*, jclass) {
 
 static void VMDebug_startEmulatorTracing(JNIEnv*, jclass) {
   UNIMPLEMENTED(WARNING);
-  //dvmEmulatorTraceStart();
+  // dvmEmulatorTraceStart();
 }
 
 static void VMDebug_stopEmulatorTracing(JNIEnv*, jclass) {
   UNIMPLEMENTED(WARNING);
-  //dvmEmulatorTraceStop();
+  // dvmEmulatorTraceStop();
 }
 
 static jboolean VMDebug_isDebuggerConnected(JNIEnv*, jclass) {
diff --git a/runtime/native/dalvik_system_Zygote.cc b/runtime/native/dalvik_system_Zygote.cc
index 12dafe074a..4108559238 100644
--- a/runtime/native/dalvik_system_Zygote.cc
+++ b/runtime/native/dalvik_system_Zygote.cc
@@ -492,7 +492,7 @@ static pid_t ForkAndSpecializeCommon(JNIEnv* env, uid_t uid, gid_t gid, jintArra
     SetSchedulerPolicy();
 
 #if defined(HAVE_ANDROID_OS)
-    { // NOLINT(whitespace/braces)
+    {  // NOLINT(whitespace/braces)
       const char* se_info_c_str = NULL;
       UniquePtr<ScopedUtfChars> se_info;
       if (java_se_info != NULL) {
diff --git a/runtime/native/java_lang_Thread.cc b/runtime/native/java_lang_Thread.cc
index 8ef190aa3f..e85ef09a13 100644
--- a/runtime/native/java_lang_Thread.cc
+++ b/runtime/native/java_lang_Thread.cc
@@ -85,7 +85,7 @@ static jint Thread_nativeGetStatus(JNIEnv* env, jobject java_thread, jboolean ha
     case kSuspended:                      return kJavaRunnable;
     // Don't add a 'default' here so the compiler can spot incompatible enum changes.
   }
-  return -1; // Unreachable.
+  return -1;  // Unreachable.
 }
 
 static jboolean Thread_nativeHoldsLock(JNIEnv* env, jobject java_thread, jobject java_object) {
diff --git a/runtime/oat/runtime/arm/context_arm.cc b/runtime/oat/runtime/arm/context_arm.cc
index 4e42e94e60..6b9538e801 100644
--- a/runtime/oat/runtime/arm/context_arm.cc
+++ b/runtime/oat/runtime/arm/context_arm.cc
@@ -71,7 +71,7 @@ void ArmContext::FillCalleeSaves(const StackVisitor& fr) {
 
 void ArmContext::SetGPR(uint32_t reg, uintptr_t value) {
   DCHECK_LT(reg, static_cast<uint32_t>(kNumberOfCoreRegisters));
-  DCHECK_NE(gprs_[reg], &gZero); // Can't overwrite this static value since they are never reset.
+  DCHECK_NE(gprs_[reg], &gZero);  // Can't overwrite this static value since they are never reset.
   DCHECK(gprs_[reg] != NULL);
   *gprs_[reg] = value;
 }
diff --git a/runtime/oat/runtime/mips/context_mips.cc b/runtime/oat/runtime/mips/context_mips.cc
index cbd63d806e..a78e5ee80d 100644
--- a/runtime/oat/runtime/mips/context_mips.cc
+++ b/runtime/oat/runtime/mips/context_mips.cc
@@ -70,7 +70,7 @@ void MipsContext::FillCalleeSaves(const StackVisitor& fr) {
 
 void MipsContext::SetGPR(uint32_t reg, uintptr_t value) {
   CHECK_LT(reg, static_cast<uint32_t>(kNumberOfCoreRegisters));
-  CHECK_NE(gprs_[reg], &gZero); // Can't overwrite this static value since they are never reset.
+  CHECK_NE(gprs_[reg], &gZero);  // Can't overwrite this static value since they are never reset.
   CHECK(gprs_[reg] != NULL);
   *gprs_[reg] = value;
 }
diff --git a/runtime/oat/runtime/support_interpreter.cc b/runtime/oat/runtime/support_interpreter.cc
index fc59e2b77f..78b7e10b2a 100644
--- a/runtime/oat/runtime/support_interpreter.cc
+++ b/runtime/oat/runtime/support_interpreter.cc
@@ -83,7 +83,7 @@ extern "C" uint64_t artInterpreterEntry(mirror::AbstractMethod* method, Thread*
   const DexFile::CodeItem* code_item = mh.GetCodeItem();
   uint16_t num_regs = code_item->registers_size_;
   void* memory = alloca(ShadowFrame::ComputeSize(num_regs));
-  ShadowFrame* shadow_frame(ShadowFrame::Create(num_regs, NULL, // No last shadow coming from quick.
+  ShadowFrame* shadow_frame(ShadowFrame::Create(num_regs, NULL,  // No last shadow coming from quick.
                                                 method, 0, memory));
   size_t first_arg_reg = code_item->registers_size_ - code_item->ins_size_;
   BuildShadowFrameVisitor shadow_frame_builder(mh, sp, *shadow_frame, first_arg_reg);
diff --git a/runtime/oat/runtime/support_jni.cc b/runtime/oat/runtime/support_jni.cc
index 25f6930dd0..2d31160a4b 100644
--- a/runtime/oat/runtime/support_jni.cc
+++ b/runtime/oat/runtime/support_jni.cc
@@ -148,7 +148,7 @@ extern "C" const void* artWorkAroundAppJniBugs(Thread* self, intptr_t* sp)
       }
     } else {
       if (reg_num == 2) {
-        arg_ptr++; // move through register arguments
+        arg_ptr++;  // move through register arguments
         reg_num++;
       } else if (reg_num == 3) {
         arg_ptr = sp + 8;  // skip to outgoing stack arguments
diff --git a/runtime/oat/runtime/support_stubs.cc b/runtime/oat/runtime/support_stubs.cc
index 096cb9c622..f2af6d28dc 100644
--- a/runtime/oat/runtime/support_stubs.cc
+++ b/runtime/oat/runtime/support_stubs.cc
@@ -116,7 +116,7 @@ extern "C" const void* artPortableResolutionTrampoline(mirror::AbstractMethod* c
     if (LIKELY(called_class->IsInitialized())) {
       code = called->GetEntryPointFromCompiledCode();
       // TODO: remove this after we solve the link issue.
-      { // for lazy link.
+      {  // for lazy link.
         if (code == NULL) {
           code = linker->GetOatCodeFor(called);
         }
@@ -130,7 +130,7 @@ extern "C" const void* artPortableResolutionTrampoline(mirror::AbstractMethod* c
         // No trampoline for non-static methods.
         code = called->GetEntryPointFromCompiledCode();
         // TODO: remove this after we solve the link issue.
-        { // for lazy link.
+        {  // for lazy link.
           if (code == NULL) {
             code = linker->GetOatCodeFor(called);
           }
diff --git a/runtime/oat/runtime/x86/oat_support_entrypoints_x86.cc b/runtime/oat/runtime/x86/oat_support_entrypoints_x86.cc
index a90a583e9f..7dfb07c21e 100644
--- a/runtime/oat/runtime/x86/oat_support_entrypoints_x86.cc
+++ b/runtime/oat/runtime/x86/oat_support_entrypoints_x86.cc
@@ -165,16 +165,16 @@ void InitEntryPoints(EntryPoints* points) {
   points->pUnlockObjectFromCode = art_quick_unlock_object_from_code;
 
   // Math
-  //points->pCmpgDouble = NULL; // Not needed on x86.
-  //points->pCmpgFloat = NULL; // Not needed on x86.
-  //points->pCmplDouble = NULL; // Not needed on x86.
-  //points->pCmplFloat = NULL; // Not needed on x86.
+  // points->pCmpgDouble = NULL;  // Not needed on x86.
+  // points->pCmpgFloat = NULL;  // Not needed on x86.
+  // points->pCmplDouble = NULL;  // Not needed on x86.
+  // points->pCmplFloat = NULL;  // Not needed on x86.
   points->pFmod = art_quick_fmod_from_code;
   points->pL2d = art_quick_l2d_from_code;
   points->pFmodf = art_quick_fmodf_from_code;
   points->pL2f = art_quick_l2f_from_code;
-  //points->pD2iz = NULL; // Not needed on x86.
-  //points->pF2iz = NULL; // Not needed on x86.
+  // points->pD2iz = NULL;  // Not needed on x86.
+  // points->pF2iz = NULL;  // Not needed on x86.
   points->pIdivmod = art_quick_idivmod_from_code;
   points->pD2l = art_quick_d2l_from_code;
   points->pF2l = art_quick_f2l_from_code;
diff --git a/runtime/oat_test.cc b/runtime/oat_test.cc
index 3f2e43e985..ebb228e111 100644
--- a/runtime/oat_test.cc
+++ b/runtime/oat_test.cc
@@ -160,7 +160,7 @@ TEST_F(OatTest, OatHeaderIsValid) {
     char* magic = const_cast<char*>(oat_header.GetMagic());
     strcpy(magic, "");  // bad magic
     ASSERT_FALSE(oat_header.IsValid());
-    strcpy(magic, "oat\n000"); // bad version
+    strcpy(magic, "oat\n000");  // bad version
     ASSERT_FALSE(oat_header.IsValid());
 }
 
diff --git a/runtime/reference_table.cc b/runtime/reference_table.cc
index 192535ab02..de64c26155 100644
--- a/runtime/reference_table.cc
+++ b/runtime/reference_table.cc
@@ -232,7 +232,7 @@ void ReferenceTable::Dump(std::ostream& os, const Table& entries) {
 }
 
 void ReferenceTable::VisitRoots(RootVisitor* visitor, void* arg) {
-  typedef Table::const_iterator It; // TODO: C++0x auto
+  typedef Table::const_iterator It;  // TODO: C++0x auto
   for (It it = entries_.begin(), end = entries_.end(); it != end; ++it) {
     visitor(*it, arg);
   }
diff --git a/runtime/reference_table.h b/runtime/reference_table.h
index 4b6b50e183..e369fd0de5 100644
--- a/runtime/reference_table.h
+++ b/runtime/reference_table.h
@@ -53,7 +53,7 @@ class ReferenceTable {
   typedef std::vector<const mirror::Object*> Table;
   static void Dump(std::ostream& os, const Table& entries)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  friend class IndirectReferenceTable; // For Dump.
+  friend class IndirectReferenceTable;  // For Dump.
 
   std::string name_;
   Table entries_;
diff --git a/runtime/reflection.cc b/runtime/reflection.cc
index 359b539fff..8e478ff969 100644
--- a/runtime/reflection.cc
+++ b/runtime/reflection.cc
@@ -270,7 +270,7 @@ mirror::Object* BoxPrimitive(Primitive::Type src_class, const JValue& value) {
 static std::string UnboxingFailureKind(mirror::AbstractMethod* m, int index, mirror::Field* f)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   if (m != NULL && index != -1) {
-    ++index; // Humans count from 1.
+    ++index;  // Humans count from 1.
     return StringPrintf("method %s argument %d", PrettyMethod(m, false).c_str(), index);
   }
   if (f != NULL) {
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index cf6e537df0..0c13ad23ed 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -63,7 +63,7 @@
 #include "verifier/method_verifier.h"
 #include "well_known_classes.h"
 
-#include "JniConstants.h" // Last to avoid LOG redefinition in ics-mr1-plus-art.
+#include "JniConstants.h"  // Last to avoid LOG redefinition in ics-mr1-plus-art.
 
 namespace art {
 
@@ -340,7 +340,7 @@ Runtime::ParsedOptions* Runtime::ParsedOptions::Create(const Options& options, b
   parsed->heap_growth_limit_ = 0;  // 0 means no growth limit.
   // Default to number of processors minus one since the main GC thread also does work.
   parsed->heap_gc_threads_ = sysconf(_SC_NPROCESSORS_CONF) - 1;
-  parsed->stack_size_ = 0; // 0 means default.
+  parsed->stack_size_ = 0;  // 0 means default.
 
   parsed->is_compiler_ = false;
   parsed->is_zygote_ = false;
@@ -352,23 +352,23 @@ Runtime::ParsedOptions* Runtime::ParsedOptions::Create(const Options& options, b
 
   parsed->hook_vfprintf_ = vfprintf;
   parsed->hook_exit_ = exit;
-  parsed->hook_abort_ = NULL; // We don't call abort(3) by default; see Runtime::Abort.
+  parsed->hook_abort_ = NULL;  // We don't call abort(3) by default; see Runtime::Abort.
 
   parsed->small_mode_ = false;
   parsed->small_mode_method_threshold_ = Runtime::kDefaultSmallModeMethodThreshold;
   parsed->small_mode_method_dex_size_limit_ = Runtime::kDefaultSmallModeMethodDexSizeLimit;
 
   parsed->sea_ir_mode_ = false;
-//  gLogVerbosity.class_linker = true; // TODO: don't check this in!
-//  gLogVerbosity.compiler = true; // TODO: don't check this in!
-//  gLogVerbosity.heap = true; // TODO: don't check this in!
-//  gLogVerbosity.gc = true; // TODO: don't check this in!
-//  gLogVerbosity.jdwp = true; // TODO: don't check this in!
-//  gLogVerbosity.jni = true; // TODO: don't check this in!
-//  gLogVerbosity.monitor = true; // TODO: don't check this in!
-//  gLogVerbosity.startup = true; // TODO: don't check this in!
-//  gLogVerbosity.third_party_jni = true; // TODO: don't check this in!
-//  gLogVerbosity.threads = true; // TODO: don't check this in!
+//  gLogVerbosity.class_linker = true;  // TODO: don't check this in!
+//  gLogVerbosity.compiler = true;  // TODO: don't check this in!
+//  gLogVerbosity.heap = true;  // TODO: don't check this in!
+//  gLogVerbosity.gc = true;  // TODO: don't check this in!
+//  gLogVerbosity.jdwp = true;  // TODO: don't check this in!
+//  gLogVerbosity.jni = true;  // TODO: don't check this in!
+//  gLogVerbosity.monitor = true;  // TODO: don't check this in!
+//  gLogVerbosity.startup = true;  // TODO: don't check this in!
+//  gLogVerbosity.third_party_jni = true;  // TODO: don't check this in!
+//  gLogVerbosity.threads = true;  // TODO: don't check this in!
 
   parsed->method_trace_ = false;
   parsed->method_trace_file_ = "/data/method-trace-file.bin";
@@ -582,7 +582,7 @@ Runtime::ParsedOptions* Runtime::ParsedOptions::Create(const Options& options, b
         // TODO: print usage via vfprintf
         LOG(ERROR) << "Unrecognized option " << option;
         // TODO: this should exit, but for now tolerate unknown options
-        //return NULL;
+        // return NULL;
       }
     }
   }
@@ -613,7 +613,7 @@ bool Runtime::Create(const Options& options, bool ignore_unrecognized) {
   if (Runtime::instance_ != NULL) {
     return false;
   }
-  InitLogging(NULL); // Calls Locks::Init() as a side effect.
+  InitLogging(NULL);  // Calls Locks::Init() as a side effect.
   instance_ = new Runtime;
   if (!instance_->Init(options, ignore_unrecognized)) {
     delete instance_;
@@ -1036,7 +1036,7 @@ int32_t Runtime::GetStat(int kind) {
     return 0;  // backward compatibility
   default:
     LOG(FATAL) << "Unknown statistic " << kind;
-    return -1; // unreachable
+    return -1;  // unreachable
   }
 }
 
diff --git a/runtime/runtime_linux.cc b/runtime/runtime_linux.cc
index a4fc3af606..47b72e9b17 100644
--- a/runtime/runtime_linux.cc
+++ b/runtime/runtime_linux.cc
@@ -245,7 +245,7 @@ void HandleUnexpectedSignal(int signal_number, siginfo_t* info, void* raw_contex
   OsInfo os_info;
   const char* cmd_line = GetCmdLine();
   if (cmd_line == NULL) {
-    cmd_line = "<unset>"; // Because no-one called InitLogging.
+    cmd_line = "<unset>";  // Because no-one called InitLogging.
   }
   pid_t tid = GetTid();
   std::string thread_name(GetThreadName(tid));
diff --git a/runtime/runtime_support.cc b/runtime/runtime_support.cc
index c933621981..d28aad1e8f 100644
--- a/runtime/runtime_support.cc
+++ b/runtime/runtime_support.cc
@@ -49,7 +49,7 @@ int64_t art_d2l(double d) {
     return static_cast<int64_t>(0x7fffffffffffffffULL);
   } else if (d <= kMinLong) {
     return static_cast<int64_t>(0x8000000000000000ULL);
-  } else if (d != d)  { // NaN case
+  } else if (d != d)  {  // NaN case
     return 0;
   } else {
     return static_cast<int64_t>(d);
@@ -63,7 +63,7 @@ int64_t art_f2l(float f) {
     return static_cast<int64_t>(0x7fffffffffffffffULL);
   } else if (f <= kMinLong) {
     return static_cast<int64_t>(0x8000000000000000ULL);
-  } else if (f != f) { // NaN case
+  } else if (f != f) {  // NaN case
     return 0;
   } else {
     return static_cast<int64_t>(f);
@@ -77,7 +77,7 @@ int32_t art_d2i(double d) {
     return static_cast<int32_t>(0x7fffffffUL);
   } else if (d <= kMinInt) {
     return static_cast<int32_t>(0x80000000UL);
-  } else if (d != d)  { // NaN case
+  } else if (d != d)  {  // NaN case
     return 0;
   } else {
     return static_cast<int32_t>(d);
@@ -91,7 +91,7 @@ int32_t art_f2i(float f) {
     return static_cast<int32_t>(0x7fffffffUL);
   } else if (f <= kMinInt) {
     return static_cast<int32_t>(0x80000000UL);
-  } else if (f != f) { // NaN case
+  } else if (f != f) {  // NaN case
     return 0;
   } else {
     return static_cast<int32_t>(f);
diff --git a/runtime/runtime_support_llvm_func_list.h b/runtime/runtime_support_llvm_func_list.h
index d371421a16..8b635cbd2c 100644
--- a/runtime/runtime_support_llvm_func_list.h
+++ b/runtime/runtime_support_llvm_func_list.h
@@ -79,4 +79,4 @@
   V(JniMethodEndWithReferenceSynchronized, art_portable_jni_method_end_with_reference_synchronized)
 
 #endif  // ART_RUNTIME_RUNTIME_SUPPORT_LLVM_FUNC_LIST_H_
-#undef ART_RUNTIME_RUNTIME_SUPPORT_LLVM_FUNC_LIST_H_ // the guard in this file is just for cpplint
+#undef ART_RUNTIME_RUNTIME_SUPPORT_LLVM_FUNC_LIST_H_  // the guard in this file is just for cpplint
diff --git a/runtime/safe_map.h b/runtime/safe_map.h
index 4b5202ab5c..89da927cc2 100644
--- a/runtime/safe_map.h
+++ b/runtime/safe_map.h
@@ -70,7 +70,7 @@ class SafeMap {
   // Used to insert a new mapping.
   void Put(const K& k, const V& v) {
     std::pair<iterator, bool> result = map_.insert(std::make_pair(k, v));
-    DCHECK(result.second); // Check we didn't accidentally overwrite an existing value.
+    DCHECK(result.second);  // Check we didn't accidentally overwrite an existing value.
   }
 
   // Used to insert a new mapping or overwrite an existing mapping. Note that if the value type
diff --git a/runtime/scoped_thread_state_change.h b/runtime/scoped_thread_state_change.h
index 2643f66c42..853d684bed 100644
--- a/runtime/scoped_thread_state_change.h
+++ b/runtime/scoped_thread_state_change.h
@@ -179,7 +179,7 @@ class ScopedObjectAccessUnchecked : public ScopedThreadStateChange {
     uint32_t cookie = Env()->local_ref_cookie;
     IndirectRef ref = locals.Add(cookie, obj);
 
-#if 0 // TODO: fix this to understand PushLocalFrame, so we can turn it on.
+#if 0  // TODO: fix this to understand PushLocalFrame, so we can turn it on.
     if (Env()->check_jni) {
       size_t entry_count = locals.Capacity();
       if (entry_count > 16) {
diff --git a/runtime/signal_catcher.cc b/runtime/signal_catcher.cc
index a630db810a..15eb27deb2 100644
--- a/runtime/signal_catcher.cc
+++ b/runtime/signal_catcher.cc
@@ -44,7 +44,7 @@ static void DumpCmdLine(std::ostream& os) {
   // On Android, /proc/self/cmdline will have been rewritten to something like "system_server".
   std::string current_cmd_line;
   if (ReadFileToString("/proc/self/cmdline", &current_cmd_line)) {
-    current_cmd_line.resize(current_cmd_line.size() - 1); // Lose the trailing '\0'.
+    current_cmd_line.resize(current_cmd_line.size() - 1);  // Lose the trailing '\0'.
     std::replace(current_cmd_line.begin(), current_cmd_line.end(), '\0', ' ');
 
     os << "Cmdline: " << current_cmd_line;
diff --git a/runtime/stack.cc b/runtime/stack.cc
index 9ce65daee6..286a2a6a5e 100644
--- a/runtime/stack.cc
+++ b/runtime/stack.cc
@@ -134,7 +134,7 @@ size_t StackVisitor::GetNativePcOffset() const {
 
 uint32_t StackVisitor::GetVReg(mirror::AbstractMethod* m, uint16_t vreg, VRegKind kind) const {
   if (cur_quick_frame_ != NULL) {
-    DCHECK(context_ != NULL); // You can't reliably read registers without a context.
+    DCHECK(context_ != NULL);  // You can't reliably read registers without a context.
     DCHECK(m == GetMethod());
     const VmapTable vmap_table(m->GetVmapTableRaw());
     uint32_t vmap_offset;
@@ -146,7 +146,7 @@ uint32_t StackVisitor::GetVReg(mirror::AbstractMethod* m, uint16_t vreg, VRegKin
       return GetGPR(vmap_table.ComputeRegister(spill_mask, vmap_offset, kind));
     } else {
       const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
-      DCHECK(code_item != NULL) << PrettyMethod(m); // Can't be NULL or how would we compile its instructions?
+      DCHECK(code_item != NULL) << PrettyMethod(m);  // Can't be NULL or how would we compile its instructions?
       size_t frame_size = m->GetFrameSizeInBytes();
       return GetVReg(cur_quick_frame_, code_item, m->GetCoreSpillMask(), m->GetFpSpillMask(),
                      frame_size, vreg);
@@ -159,7 +159,7 @@ uint32_t StackVisitor::GetVReg(mirror::AbstractMethod* m, uint16_t vreg, VRegKin
 void StackVisitor::SetVReg(mirror::AbstractMethod* m, uint16_t vreg, uint32_t new_value,
                            VRegKind kind) {
   if (cur_quick_frame_ != NULL) {
-    DCHECK(context_ != NULL); // You can't reliably write registers without a context.
+    DCHECK(context_ != NULL);  // You can't reliably write registers without a context.
     DCHECK(m == GetMethod());
     const VmapTable vmap_table(m->GetVmapTableRaw());
     uint32_t vmap_offset;
@@ -171,7 +171,7 @@ void StackVisitor::SetVReg(mirror::AbstractMethod* m, uint16_t vreg, uint32_t ne
       SetGPR(reg, new_value);
     } else {
       const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
-      DCHECK(code_item != NULL) << PrettyMethod(m); // Can't be NULL or how would we compile its instructions?
+      DCHECK(code_item != NULL) << PrettyMethod(m);  // Can't be NULL or how would we compile its instructions?
       uint32_t core_spills = m->GetCoreSpillMask();
       uint32_t fp_spills = m->GetFpSpillMask();
       size_t frame_size = m->GetFrameSizeInBytes();
diff --git a/runtime/stack.h b/runtime/stack.h
index 99ba898362..0b94f27c4b 100644
--- a/runtime/stack.h
+++ b/runtime/stack.h
@@ -514,7 +514,7 @@ class StackVisitor {
                            uint32_t core_spills, uint32_t fp_spills,
                            size_t frame_size, int reg) {
     DCHECK_EQ(frame_size & (kStackAlignment - 1), 0U);
-    int num_spills = __builtin_popcount(core_spills) + __builtin_popcount(fp_spills) + 1; // Filler.
+    int num_spills = __builtin_popcount(core_spills) + __builtin_popcount(fp_spills) + 1;  // Filler.
     int num_ins = code_item->ins_size_;
     int num_regs = code_item->registers_size_ - num_ins;
     int locals_start = frame_size - ((num_spills + num_regs) * sizeof(uint32_t));
@@ -525,7 +525,7 @@ class StackVisitor {
     } else if (reg < num_regs) {
       return locals_start + (reg * sizeof(uint32_t));        // Dalvik local reg.
     } else {
-      return frame_size + ((reg - num_regs) * sizeof(uint32_t)) + sizeof(uint32_t); // Dalvik in.
+      return frame_size + ((reg - num_regs) * sizeof(uint32_t)) + sizeof(uint32_t);  // Dalvik in.
     }
   }
 
@@ -543,7 +543,7 @@ class StackVisitor {
 
   StackIndirectReferenceTable* GetCurrentSirt() const {
     mirror::AbstractMethod** sp = GetCurrentQuickFrame();
-    ++sp; // Skip Method*; SIRT comes next;
+    ++sp;  // Skip Method*; SIRT comes next;
     return reinterpret_cast<StackIndirectReferenceTable*>(sp);
   }
 
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 9b7d194b8a..0b3a5b4959 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -87,7 +87,7 @@ static void UnimplementedEntryPoint() {
 #endif
 
 void Thread::InitFunctionPointers() {
-#if !defined(__APPLE__) // The Mac GCC is too old to accept this code.
+#if !defined(__APPLE__)  // The Mac GCC is too old to accept this code.
   // Insert a placeholder so we can easily tell if we call an unimplemented entry point.
   uintptr_t* begin = reinterpret_cast<uintptr_t*>(&entrypoints_);
   uintptr_t* end = reinterpret_cast<uintptr_t*>(reinterpret_cast<uint8_t*>(begin) + sizeof(entrypoints_));
@@ -572,7 +572,7 @@ void Thread::FullSuspendCheck() {
 }
 
 Thread* Thread::SuspendForDebugger(jobject peer, bool request_suspension, bool* timed_out) {
-  static const useconds_t kTimeoutUs = 30 * 1000000; // 30s.
+  static const useconds_t kTimeoutUs = 30 * 1000000;  // 30s.
   useconds_t total_delay_us = 0;
   useconds_t delay_us = 0;
   bool did_suspend_request = false;
@@ -725,7 +725,7 @@ void Thread::DumpState(std::ostream& os, const Thread* thread, pid_t tid) {
   // Grab the scheduler stats for this thread.
   std::string scheduler_stats;
   if (ReadFileToString(StringPrintf("/proc/self/task/%d/schedstat", tid), &scheduler_stats)) {
-    scheduler_stats.resize(scheduler_stats.size() - 1); // Lose the trailing '\n'.
+    scheduler_stats.resize(scheduler_stats.size() - 1);  // Lose the trailing '\n'.
   } else {
     scheduler_stats = "0 0 0";
   }
@@ -1297,7 +1297,7 @@ class BuildInternalStackTraceVisitor : public StackVisitor {
 
   bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     if (method_trace_ == NULL || dex_pc_trace_ == NULL) {
-      return true; // We're probably trying to fillInStackTrace for an OutOfMemoryError.
+      return true;  // We're probably trying to fillInStackTrace for an OutOfMemoryError.
     }
     if (skip_depth_ > 0) {
       skip_depth_--;
@@ -1452,7 +1452,7 @@ void Thread::ThrowNewExceptionV(const ThrowLocation& throw_location,
 
 void Thread::ThrowNewException(const ThrowLocation& throw_location, const char* exception_class_descriptor,
                                const char* msg) {
-  AssertNoPendingException(); // Callers should either clear or call ThrowNewWrappedException.
+  AssertNoPendingException();  // Callers should either clear or call ThrowNewWrappedException.
   ThrowNewWrappedException(throw_location, exception_class_descriptor, msg);
 }
 
@@ -1557,7 +1557,7 @@ void Thread::ThrowOutOfMemoryError(const char* msg) {
     ThrowNewException(throw_location, "Ljava/lang/OutOfMemoryError;", msg);
     throwing_OutOfMemoryError_ = false;
   } else {
-    Dump(LOG(ERROR)); // The pre-allocated OOME has no stack, so help out and log one.
+    Dump(LOG(ERROR));  // The pre-allocated OOME has no stack, so help out and log one.
     SetException(throw_location, Runtime::Current()->GetPreAllocatedOutOfMemoryError());
   }
 }
@@ -1664,7 +1664,7 @@ static const EntryPointInfo gThreadEntryPointInfo[] = {
 #undef ENTRY_POINT_INFO
 
 void Thread::DumpThreadOffset(std::ostream& os, uint32_t offset, size_t size_of_pointers) {
-  CHECK_EQ(size_of_pointers, 4U); // TODO: support 64-bit targets.
+  CHECK_EQ(size_of_pointers, 4U);  // TODO: support 64-bit targets.
 
 #define DO_THREAD_OFFSET(x) \
     if (offset == static_cast<uint32_t>(OFFSETOF_VOLATILE_MEMBER(Thread, x))) { \
@@ -1680,8 +1680,8 @@ void Thread::DumpThreadOffset(std::ostream& os, uint32_t offset, size_t size_of_
   DO_THREAD_OFFSET(stack_end_);
   DO_THREAD_OFFSET(suspend_count_);
   DO_THREAD_OFFSET(thin_lock_id_);
-  //DO_THREAD_OFFSET(top_of_managed_stack_);
-  //DO_THREAD_OFFSET(top_of_managed_stack_pc_);
+  // DO_THREAD_OFFSET(top_of_managed_stack_);
+  // DO_THREAD_OFFSET(top_of_managed_stack_pc_);
   DO_THREAD_OFFSET(top_sirt_);
 #undef DO_THREAD_OFFSET
 
@@ -2012,7 +2012,7 @@ class ReferenceMapVisitor : public StackVisitor {
         CHECK(native_gc_map != NULL) << PrettyMethod(m);
         mh_.ChangeMethod(m);
         const DexFile::CodeItem* code_item = mh_.GetCodeItem();
-        DCHECK(code_item != NULL) << PrettyMethod(m); // Can't be NULL or how would we compile its instructions?
+        DCHECK(code_item != NULL) << PrettyMethod(m);  // Can't be NULL or how would we compile its instructions?
         NativePcOffsetToReferenceMap map(native_gc_map);
         size_t num_regs = std::min(map.RegWidth() * 8,
                                    static_cast<size_t>(code_item->registers_size_));
diff --git a/runtime/thread.h b/runtime/thread.h
index 388178fe39..b9393a3052 100644
--- a/runtime/thread.h
+++ b/runtime/thread.h
@@ -580,7 +580,7 @@ class PACKED(4) Thread {
   friend class ThreadList;  // For ~Thread and Destroy.
 
   void CreatePeer(const char* name, bool as_daemon, jobject thread_group);
-  friend class Runtime; // For CreatePeer.
+  friend class Runtime;  // For CreatePeer.
 
   // Avoid use, callers should use SetState. Used only by SignalCatcher::HandleSigQuit, ~Thread and
   // Dbg::Disconnected.
@@ -590,7 +590,7 @@ class PACKED(4) Thread {
     return old_state;
   }
   friend class SignalCatcher;  // For SetStateUnsafe.
-  friend class Dbg;  // For SetStateUnsafe.
+  friend class Dbg;  // F or SetStateUnsafe.
 
   void VerifyStackImpl() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -600,7 +600,7 @@ class PACKED(4) Thread {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Out-of-line conveniences for debugging in gdb.
-  static Thread* CurrentFromGdb(); // Like Thread::Current.
+  static Thread* CurrentFromGdb();  // Like Thread::Current.
   // Like Thread::Dump(std::cerr).
   void DumpFromGdb() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
diff --git a/runtime/thread_linux.cc b/runtime/thread_linux.cc
index 1bd708ae45..ee66ccc29a 100644
--- a/runtime/thread_linux.cc
+++ b/runtime/thread_linux.cc
@@ -56,7 +56,7 @@ void Thread::TearDownAlternateSignalStack() {
   // Tell the kernel to stop using it.
   ss.ss_sp = NULL;
   ss.ss_flags = SS_DISABLE;
-  ss.ss_size = SIGSTKSZ; // Avoid ENOMEM failure with Mac OS' buggy libc.
+  ss.ss_size = SIGSTKSZ;  // Avoid ENOMEM failure with Mac OS' buggy libc.
   SigAltStack(&ss, NULL);
 
   // Free it.
diff --git a/runtime/thread_list.cc b/runtime/thread_list.cc
index 7aa835a387..9c28c87b84 100644
--- a/runtime/thread_list.cc
+++ b/runtime/thread_list.cc
@@ -474,7 +474,7 @@ void ThreadList::WaitForOtherNonDaemonThreadsToExit() {
 void ThreadList::SuspendAllDaemonThreads() {
   Thread* self = Thread::Current();
   MutexLock mu(self, *Locks::thread_list_lock_);
-  { // Tell all the daemons it's time to suspend.
+  {  // Tell all the daemons it's time to suspend.
     MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
     for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
       Thread* thread = *it;
@@ -591,7 +591,7 @@ uint32_t ThreadList::AllocThreadId(Thread* self) {
   for (size_t i = 0; i < allocated_ids_.size(); ++i) {
     if (!allocated_ids_[i]) {
       allocated_ids_.set(i);
-      return i + 1; // Zero is reserved to mean "invalid".
+      return i + 1;  // Zero is reserved to mean "invalid".
     }
   }
   LOG(FATAL) << "Out of internal thread ids";
@@ -600,7 +600,7 @@ uint32_t ThreadList::AllocThreadId(Thread* self) {
 
 void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) {
   MutexLock mu(self, allocated_ids_lock_);
-  --id; // Zero is reserved to mean "invalid".
+  --id;  // Zero is reserved to mean "invalid".
   DCHECK(allocated_ids_[id]) << id;
   allocated_ids_.reset(id);
 }
diff --git a/runtime/thread_list.h b/runtime/thread_list.h
index 87abbda479..d95f191553 100644
--- a/runtime/thread_list.h
+++ b/runtime/thread_list.h
@@ -43,7 +43,7 @@ class ThreadList {
   void DumpLocked(std::ostream& os)  // For thread suspend timeout dumps.
       EXCLUSIVE_LOCKS_REQUIRED(Locks::thread_list_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  pid_t GetLockOwner(); // For SignalCatcher.
+  pid_t GetLockOwner();  // For SignalCatcher.
 
   // Thread suspension support.
   void ResumeAll()
@@ -102,7 +102,7 @@ class ThreadList {
   Thread* FindThreadByThinLockId(uint32_t thin_lock_id);
 
  private:
-  typedef std::list<Thread*>::const_iterator It; // TODO: C++0x auto
+  typedef std::list<Thread*>::const_iterator It;  // TODO: C++0x auto
 
   uint32_t AllocThreadId(Thread* self);
   void ReleaseThreadId(Thread* self, uint32_t id) LOCKS_EXCLUDED(allocated_ids_lock_);
diff --git a/runtime/thread_state.h b/runtime/thread_state.h
index fc4812a427..4d4bfb751e 100644
--- a/runtime/thread_state.h
+++ b/runtime/thread_state.h
@@ -20,26 +20,26 @@
 namespace art {
 
 enum ThreadState {
-  //                                  Thread.State   JDWP state
-  kTerminated,                     // TERMINATED     TS_ZOMBIE    Thread.run has returned, but Thread* still around
-  kRunnable,                       // RUNNABLE       TS_RUNNING   runnable
-  kTimedWaiting,                   // TIMED_WAITING  TS_WAIT      in Object.wait() with a timeout
-  kSleeping,                       // TIMED_WAITING  TS_SLEEPING  in Thread.sleep()
-  kBlocked,                        // BLOCKED        TS_MONITOR   blocked on a monitor
-  kWaiting,                        // WAITING        TS_WAIT      in Object.wait()
-  kWaitingForGcToComplete,         // WAITING        TS_WAIT      blocked waiting for GC
-  kWaitingForCheckPointsToRun,     // WAITING        TS_WAIT      GC waiting for checkpoints to run
-  kWaitingPerformingGc,            // WAITING        TS_WAIT      performing GC
-  kWaitingForDebuggerSend,         // WAITING        TS_WAIT      blocked waiting for events to be sent
-  kWaitingForDebuggerToAttach,     // WAITING        TS_WAIT      blocked waiting for debugger to attach
-  kWaitingInMainDebuggerLoop,      // WAITING        TS_WAIT      blocking/reading/processing debugger events
-  kWaitingForDebuggerSuspension,   // WAITING        TS_WAIT      waiting for debugger suspend all
-  kWaitingForJniOnLoad,            // WAITING        TS_WAIT      waiting for execution of dlopen and JNI on load code
-  kWaitingForSignalCatcherOutput,  // WAITING        TS_WAIT      waiting for signal catcher IO to complete
-  kWaitingInMainSignalCatcherLoop, // WAITING        TS_WAIT      blocking/reading/processing signals
-  kStarting,                       // NEW            TS_WAIT      native thread started, not yet ready to run managed code
-  kNative,                         // RUNNABLE       TS_RUNNING   running in a JNI native method
-  kSuspended,                      // RUNNABLE       TS_RUNNING   suspended by GC or debugger
+  //                                   Thread.State   JDWP state
+  kTerminated,                      // TERMINATED     TS_ZOMBIE    Thread.run has returned, but Thread* still around
+  kRunnable,                        // RUNNABLE       TS_RUNNING   runnable
+  kTimedWaiting,                    // TIMED_WAITING  TS_WAIT      in Object.wait() with a timeout
+  kSleeping,                        // TIMED_WAITING  TS_SLEEPING  in Thread.sleep()
+  kBlocked,                         // BLOCKED        TS_MONITOR   blocked on a monitor
+  kWaiting,                         // WAITING        TS_WAIT      in Object.wait()
+  kWaitingForGcToComplete,          // WAITING        TS_WAIT      blocked waiting for GC
+  kWaitingForCheckPointsToRun,      // WAITING        TS_WAIT      GC waiting for checkpoints to run
+  kWaitingPerformingGc,             // WAITING        TS_WAIT      performing GC
+  kWaitingForDebuggerSend,          // WAITING        TS_WAIT      blocked waiting for events to be sent
+  kWaitingForDebuggerToAttach,      // WAITING        TS_WAIT      blocked waiting for debugger to attach
+  kWaitingInMainDebuggerLoop,       // WAITING        TS_WAIT      blocking/reading/processing debugger events
+  kWaitingForDebuggerSuspension,    // WAITING        TS_WAIT      waiting for debugger suspend all
+  kWaitingForJniOnLoad,             // WAITING        TS_WAIT      waiting for execution of dlopen and JNI on load code
+  kWaitingForSignalCatcherOutput,   // WAITING        TS_WAIT      waiting for signal catcher IO to complete
+  kWaitingInMainSignalCatcherLoop,  // WAITING        TS_WAIT      blocking/reading/processing signals
+  kStarting,                        // NEW            TS_WAIT      native thread started, not yet ready to run managed code
+  kNative,                          // RUNNABLE       TS_RUNNING   running in a JNI native method
+  kSuspended,                       // RUNNABLE       TS_RUNNING   suspended by GC or debugger
 };
 
 }  // namespace art
diff --git a/runtime/trace.cc b/runtime/trace.cc
index 2227b8dde7..177fd48f7d 100644
--- a/runtime/trace.cc
+++ b/runtime/trace.cc
@@ -75,11 +75,11 @@ namespace art {
 // All values are stored in little-endian order.
 
 enum TraceAction {
-    kTraceMethodEnter = 0x00,      // method entry
-    kTraceMethodExit = 0x01,       // method exit
-    kTraceUnroll = 0x02,     // method exited by exception unrolling
+    kTraceMethodEnter = 0x00,       // method entry
+    kTraceMethodExit = 0x01,        // method exit
+    kTraceUnroll = 0x02,            // method exited by exception unrolling
     // 0x03 currently unused
-    kTraceMethodActionMask = 0x03, // two bits
+    kTraceMethodActionMask = 0x03,  // two bits
 };
 
 static const char     kTraceTokenChar             = '*';
@@ -87,8 +87,8 @@ static const uint16_t kTraceHeaderLength          = 32;
 static const uint32_t kTraceMagicValue            = 0x574f4c53;
 static const uint16_t kTraceVersionSingleClock    = 2;
 static const uint16_t kTraceVersionDualClock      = 3;
-static const uint16_t kTraceRecordSizeSingleClock = 10; // using v2
-static const uint16_t kTraceRecordSizeDualClock   = 14; // using v3 with two timestamps
+static const uint16_t kTraceRecordSizeSingleClock = 10;  // using v2
+static const uint16_t kTraceRecordSizeDualClock   = 14;  // using v3 with two timestamps
 
 #if defined(HAVE_POSIX_CLOCKS)
 ProfilerClockSource Trace::default_clock_source_ = kProfilerClockSourceDual;
@@ -487,7 +487,7 @@ void Trace::GetVisitedMethods(size_t buf_size,
 
 void Trace::DumpMethodList(std::ostream& os,
                            const std::set<mirror::AbstractMethod*>& visited_methods) {
-  typedef std::set<mirror::AbstractMethod*>::const_iterator It; // TODO: C++0x auto
+  typedef std::set<mirror::AbstractMethod*>::const_iterator It;  // TODO: C++0x auto
   MethodHelper mh;
   for (It it = visited_methods.begin(); it != visited_methods.end(); ++it) {
     mirror::AbstractMethod* method = *it;
diff --git a/runtime/utils.cc b/runtime/utils.cc
index 723be92d8a..71e502df29 100644
--- a/runtime/utils.cc
+++ b/runtime/utils.cc
@@ -46,12 +46,12 @@
 #endif
 
 #if defined(__APPLE__)
-#include "AvailabilityMacros.h" // For MAC_OS_X_VERSION_MAX_ALLOWED
+#include "AvailabilityMacros.h"  // For MAC_OS_X_VERSION_MAX_ALLOWED
 #include <sys/syscall.h>
 #endif
 
-#include <corkscrew/backtrace.h> // For DumpNativeStack.
-#include <corkscrew/demangle.h> // For DumpNativeStack.
+#include <corkscrew/backtrace.h>  // For DumpNativeStack.
+#include <corkscrew/demangle.h>  // For DumpNativeStack.
 
 #if defined(__linux__)
 #include <linux/unistd.h>
@@ -73,7 +73,7 @@ pid_t GetTid() {
 std::string GetThreadName(pid_t tid) {
   std::string result;
   if (ReadFileToString(StringPrintf("/proc/self/task/%d/comm", tid), &result)) {
-    result.resize(result.size() - 1); // Lose the trailing '\n'.
+    result.resize(result.size() - 1);  // Lose the trailing '\n'.
   } else {
     result = "<unknown>";
   }
@@ -253,7 +253,7 @@ std::string PrettyDescriptor(const std::string& descriptor) {
   // Reference or primitive?
   if (*c == 'L') {
     // "[[La/b/C;" -> "a.b.C[][]".
-    c++; // Skip the 'L'.
+    c++;  // Skip the 'L'.
   } else {
     // "[[B" -> "byte[][]".
     // To make life easier, we make primitives look like unqualified
@@ -267,7 +267,7 @@ std::string PrettyDescriptor(const std::string& descriptor) {
     case 'J': c = "long;"; break;
     case 'S': c = "short;"; break;
     case 'Z': c = "boolean;"; break;
-    case 'V': c = "void;"; break; // Used when decoding return types.
+    case 'V': c = "void;"; break;  // Used when decoding return types.
     default: return descriptor;
     }
   }
@@ -339,7 +339,7 @@ std::string PrettyArguments(const char* signature) {
   std::string result;
   result += '(';
   CHECK_EQ(*signature, '(');
-  ++signature; // Skip the '('.
+  ++signature;  // Skip the '('.
   while (*signature != ')') {
     size_t argument_length = 0;
     while (signature[argument_length] == '[') {
@@ -358,7 +358,7 @@ std::string PrettyArguments(const char* signature) {
     signature += argument_length;
   }
   CHECK_EQ(*signature, ')');
-  ++signature; // Skip the ')'.
+  ++signature;  // Skip the ')'.
   result += ')';
   return result;
 }
@@ -366,7 +366,7 @@ std::string PrettyArguments(const char* signature) {
 std::string PrettyReturnType(const char* signature) {
   const char* return_type = strchr(signature, ')');
   CHECK(return_type != NULL);
-  ++return_type; // Skip ')'.
+  ++return_type;  // Skip ')'.
   return PrettyDescriptor(return_type);
 }
 
@@ -664,10 +664,10 @@ std::string JniLongName(const mirror::AbstractMethod* m) {
 
 // Helper for IsValidPartOfMemberNameUtf8(), a bit vector indicating valid low ascii.
 uint32_t DEX_MEMBER_VALID_LOW_ASCII[4] = {
-  0x00000000, // 00..1f low control characters; nothing valid
-  0x03ff2010, // 20..3f digits and symbols; valid: '0'..'9', '$', '-'
-  0x87fffffe, // 40..5f uppercase etc.; valid: 'A'..'Z', '_'
-  0x07fffffe  // 60..7f lowercase etc.; valid: 'a'..'z'
+  0x00000000,  // 00..1f low control characters; nothing valid
+  0x03ff2010,  // 20..3f digits and symbols; valid: '0'..'9', '$', '-'
+  0x87fffffe,  // 40..5f uppercase etc.; valid: 'A'..'Z', '_'
+  0x07fffffe   // 60..7f lowercase etc.; valid: 'a'..'z'
 };
 
 // Helper for IsValidPartOfMemberNameUtf8(); do not call directly.
@@ -826,7 +826,7 @@ bool IsValidClassName(const char* s, ClassNameType type, char separator) {
    * name.
    */
 
-  bool sepOrFirst = true; // first character or just encountered a separator.
+  bool sepOrFirst = true;  // first character or just encountered a separator.
   for (;;) {
     uint8_t c = (uint8_t) *s;
     switch (c) {
@@ -1002,7 +1002,7 @@ std::string GetSchedulerGroupName(pid_t tid) {
     Split(cgroup_fields[1], ',', cgroups);
     for (size_t i = 0; i < cgroups.size(); ++i) {
       if (cgroups[i] == "cpu") {
-        return cgroup_fields[2].substr(1); // Skip the leading slash.
+        return cgroup_fields[2].substr(1);  // Skip the leading slash.
       }
     }
   }
@@ -1060,7 +1060,7 @@ void DumpNativeStack(std::ostream& os, pid_t tid, const char* prefix, bool inclu
 
   const size_t MAX_DEPTH = 32;
   UniquePtr<backtrace_frame_t[]> frames(new backtrace_frame_t[MAX_DEPTH]);
-  size_t ignore_count = 2; // Don't include unwind_backtrace_thread or DumpNativeStack.
+  size_t ignore_count = 2;  // Don't include unwind_backtrace_thread or DumpNativeStack.
   ssize_t frame_count = unwind_backtrace_thread(tid, frames.get(), ignore_count, MAX_DEPTH);
   if (frame_count == -1) {
     os << prefix << "(unwind_backtrace_thread failed for thread " << tid << ")\n";
@@ -1207,7 +1207,7 @@ std::string GetDalvikCacheFilenameOrDie(const std::string& location) {
   if (location[0] != '/') {
     LOG(FATAL) << "Expected path in location to be absolute: "<< location;
   }
-  std::string cache_file(location, 1); // skip leading slash
+  std::string cache_file(location, 1);  // skip leading slash
   if (!IsValidDexFilename(location)) {
     cache_file += "/";
     cache_file += DexFile::kClassesDex;
diff --git a/runtime/verifier/dex_gc_map.h b/runtime/verifier/dex_gc_map.h
index be7415e1d6..2a95ba2284 100644
--- a/runtime/verifier/dex_gc_map.h
+++ b/runtime/verifier/dex_gc_map.h
@@ -30,9 +30,9 @@ namespace verifier {
  */
 enum RegisterMapFormat {
   kRegMapFormatUnknown = 0,
-  kRegMapFormatNone = 1,      // Indicates no map data follows.
-  kRegMapFormatCompact8 = 2,  // Compact layout, 8-bit addresses.
-  kRegMapFormatCompact16 = 3, // Compact layout, 16-bit addresses.
+  kRegMapFormatNone = 1,       // Indicates no map data follows.
+  kRegMapFormatCompact8 = 2,   // Compact layout, 8-bit addresses.
+  kRegMapFormatCompact16 = 3,  // Compact layout, 16-bit addresses.
 };
 
 // Lightweight wrapper for Dex PC to reference bit maps.
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index 2bf78d8509..aa6b29cfd8 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -298,7 +298,7 @@ void MethodVerifier::FindLocksAtDexPc(mirror::AbstractMethod* m, uint32_t dex_pc
 
 void MethodVerifier::FindLocksAtDexPc() {
   CHECK(monitor_enter_dex_pcs_ != NULL);
-  CHECK(code_item_ != NULL); // This only makes sense for methods with code.
+  CHECK(code_item_ != NULL);  // This only makes sense for methods with code.
 
   // Strictly speaking, we ought to be able to get away with doing a subset of the full method
   // verification. In practice, the phase we want relies on data structures set up by all the
@@ -317,7 +317,7 @@ mirror::Field* MethodVerifier::FindAccessedFieldAtDexPc(mirror::AbstractMethod*
 }
 
 mirror::Field* MethodVerifier::FindAccessedFieldAtDexPc(uint32_t dex_pc) {
-  CHECK(code_item_ != NULL); // This only makes sense for methods with code.
+  CHECK(code_item_ != NULL);  // This only makes sense for methods with code.
 
   // Strictly speaking, we ought to be able to get away with doing a subset of the full method
   // verification. In practice, the phase we want relies on data structures set up by all the
@@ -345,7 +345,7 @@ mirror::AbstractMethod* MethodVerifier::FindInvokedMethodAtDexPc(mirror::Abstrac
 }
 
 mirror::AbstractMethod* MethodVerifier::FindInvokedMethodAtDexPc(uint32_t dex_pc) {
-  CHECK(code_item_ != NULL); // This only makes sense for methods with code.
+  CHECK(code_item_ != NULL);  // This only makes sense for methods with code.
 
   // Strictly speaking, we ought to be able to get away with doing a subset of the full method
   // verification. In practice, the phase we want relies on data structures set up by all the
@@ -1091,7 +1091,7 @@ bool MethodVerifier::SetTypesFromSignature() {
   size_t expected_args = code_item_->ins_size_;   /* long/double count as two */
 
   DCHECK_GE(arg_start, 0);      /* should have been verified earlier */
-  //Include the "this" pointer.
+  // Include the "this" pointer.
   size_t cur_arg = 0;
   if (!IsStatic()) {
     // If this is a constructor for a class other than java.lang.Object, mark the first ("this")
@@ -1175,7 +1175,7 @@ bool MethodVerifier::SetTypesFromSignature() {
   bool result;
   if (IsPrimitiveDescriptor(descriptor[0]) || descriptor[0] == 'V') {
     result = descriptor[1] == '\0';
-  } else if (descriptor[0] == '[') { // single/multi-dimensional array of object/primitive
+  } else if (descriptor[0] == '[') {  // single/multi-dimensional array of object/primitive
     size_t i = 0;
     do {
       i++;
@@ -1322,7 +1322,7 @@ bool MethodVerifier::CodeFlowVerifyInstruction(uint32_t* start_guess) {
   // interested in is itself a monitor-enter instruction (which is a likely place
   // for a thread to be suspended).
   if (monitor_enter_dex_pcs_ != NULL && work_insn_idx_ == interesting_dex_pc_) {
-    monitor_enter_dex_pcs_->clear(); // The new work line is more accurate than the previous one.
+    monitor_enter_dex_pcs_->clear();  // The new work line is more accurate than the previous one.
     for (size_t i = 0; i < work_line_->GetMonitorEnterCount(); ++i) {
       monitor_enter_dex_pcs_->push_back(work_line_->GetMonitorEnterDexPc(i));
     }
@@ -2696,7 +2696,7 @@ bool MethodVerifier::CodeFlowVerifyInstruction(uint32_t* start_guess) {
   DCHECK(insn_flags_[*start_guess].IsOpcode());
 
   return true;
-} // NOLINT(readability/fn_size)
+}  // NOLINT(readability/fn_size)
 
 const RegType& MethodVerifier::ResolveClassAndCheckAccess(uint32_t class_idx) {
   const char* descriptor = dex_file_->StringByTypeIdx(class_idx);
@@ -3232,7 +3232,7 @@ mirror::Field* MethodVerifier::GetStaticField(int field_idx) {
   const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
   // Check access to class
   const RegType& klass_type = ResolveClassAndCheckAccess(field_id.class_idx_);
-  if (klass_type.IsConflict()) { // bad class
+  if (klass_type.IsConflict()) {  // bad class
     AppendToLastFailMessage(StringPrintf(" in attempt to access static field %d (%s) in %s",
                                          field_idx, dex_file_->GetFieldName(field_id),
                                          dex_file_->GetFieldDeclaringClassDescriptor(field_id)));
diff --git a/runtime/verifier/method_verifier.h b/runtime/verifier/method_verifier.h
index 57d630de5a..e1bcbb19e5 100644
--- a/runtime/verifier/method_verifier.h
+++ b/runtime/verifier/method_verifier.h
@@ -70,17 +70,17 @@ std::ostream& operator<<(std::ostream& os, const MethodType& rhs);
  * to be rewritten to fail at runtime.
  */
 enum VerifyError {
-  VERIFY_ERROR_BAD_CLASS_HARD, // VerifyError; hard error that skips compilation.
-  VERIFY_ERROR_BAD_CLASS_SOFT, // VerifyError; soft error that verifies again at runtime.
-
-  VERIFY_ERROR_NO_CLASS,       // NoClassDefFoundError.
-  VERIFY_ERROR_NO_FIELD,       // NoSuchFieldError.
-  VERIFY_ERROR_NO_METHOD,      // NoSuchMethodError.
-  VERIFY_ERROR_ACCESS_CLASS,   // IllegalAccessError.
-  VERIFY_ERROR_ACCESS_FIELD,   // IllegalAccessError.
-  VERIFY_ERROR_ACCESS_METHOD,  // IllegalAccessError.
-  VERIFY_ERROR_CLASS_CHANGE,   // IncompatibleClassChangeError.
-  VERIFY_ERROR_INSTANTIATION,  // InstantiationError.
+  VERIFY_ERROR_BAD_CLASS_HARD,  // VerifyError; hard error that skips compilation.
+  VERIFY_ERROR_BAD_CLASS_SOFT,  // VerifyError; soft error that verifies again at runtime.
+
+  VERIFY_ERROR_NO_CLASS,        // NoClassDefFoundError.
+  VERIFY_ERROR_NO_FIELD,        // NoSuchFieldError.
+  VERIFY_ERROR_NO_METHOD,       // NoSuchMethodError.
+  VERIFY_ERROR_ACCESS_CLASS,    // IllegalAccessError.
+  VERIFY_ERROR_ACCESS_FIELD,    // IllegalAccessError.
+  VERIFY_ERROR_ACCESS_METHOD,   // IllegalAccessError.
+  VERIFY_ERROR_CLASS_CHANGE,    // IncompatibleClassChangeError.
+  VERIFY_ERROR_INSTANTIATION,   // InstantiationError.
 };
 std::ostream& operator<<(std::ostream& os, const VerifyError& rhs);
 
diff --git a/runtime/verifier/reg_type_cache.cc b/runtime/verifier/reg_type_cache.cc
index 2cc3d5915a..2c18132c0b 100644
--- a/runtime/verifier/reg_type_cache.cc
+++ b/runtime/verifier/reg_type_cache.cc
@@ -171,7 +171,7 @@ const RegType& RegTypeCache::From(mirror::ClassLoader* loader, const char* descr
   if (klass != NULL) {
     // Class resolved, first look for the class in the list of entries
     // Class was not found, must create new type.
-    //To pass the verification, the type should be imprecise,
+    // To pass the verification, the type should be imprecise,
     // instantiable or an interface with the precise type set to false.
     DCHECK(!precise || klass->IsInstantiable());
     // Create a precise type if:
diff --git a/runtime/verifier/reg_type_test.cc b/runtime/verifier/reg_type_test.cc
index a24c3c9120..dc320be379 100644
--- a/runtime/verifier/reg_type_test.cc
+++ b/runtime/verifier/reg_type_test.cc
@@ -58,7 +58,7 @@ TEST_F(RegTypeTest, Pairs) {
   const RegType& precise_const = cache.FromCat1Const(static_cast<int32_t>(val >> 32), true);
   const RegType& long_lo = cache.LongLo();
   const RegType& long_hi = cache.LongHi();
-  //Check sanity of types.
+  // Check sanity of types.
   EXPECT_TRUE(precise_lo.IsLowHalf());
   EXPECT_FALSE(precise_hi.IsLowHalf());
   EXPECT_FALSE(precise_lo.IsHighHalf());
diff --git a/runtime/zip_archive.cc b/runtime/zip_archive.cc
index 9cf7a09155..2a48dc6d77 100644
--- a/runtime/zip_archive.cc
+++ b/runtime/zip_archive.cc
@@ -228,7 +228,7 @@ static bool InflateToMemory(uint8_t* begin, size_t size,
     }
   } while (zerr == Z_OK);
 
-  DCHECK_EQ(zerr, Z_STREAM_END); // other errors should've been caught
+  DCHECK_EQ(zerr, Z_STREAM_END);  // other errors should've been caught
 
   // paranoia
   if (zstream->Get().total_out != uncompressed_length) {
diff --git a/test/ReferenceMap/stack_walk_refmap_jni.cc b/test/ReferenceMap/stack_walk_refmap_jni.cc
index 7b6483da00..10ca5638d0 100644
--- a/test/ReferenceMap/stack_walk_refmap_jni.cc
+++ b/test/ReferenceMap/stack_walk_refmap_jni.cc
@@ -168,71 +168,71 @@ struct ReferenceMap2Visitor : public StackVisitor {
 //      |0001: const/4 v7, #int 0 // #0
 //      |0002: const/4 v6, #int 1 // #1
 //
-//0:[Unknown],1:[Unknown],2:[Unknown],3:[Unknown],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
-//      |0003: new-array v1, v4, [Ljava/lang/Object; // type@0007
+// 0:[Unknown],1:[Unknown],2:[Unknown],3:[Unknown],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+//      |0003: new-array v1, v4, [Ljava/lang/Object;  // type@0007
 //      |0005: const/4 v2, #int 0 // #0
 
-//0:[Unknown],1:[Reference: java.lang.Object[]],2:[Zero],3:[Unknown],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
-//      |0006: new-instance v3, Ljava/lang/Object; // type@0003
+// 0:[Unknown],1:[Reference: java.lang.Object[]],2:[Zero],3:[Unknown],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+//      |0006: new-instance v3, Ljava/lang/Object;  // type@0003
 
-//[Unknown],1:[Reference: java.lang.Object[]],2:[Zero],3:[Uninitialized Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// [Unknown],1:[Reference: java.lang.Object[]],2:[Zero],3:[Uninitialized Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |0008: +invoke-object-init/range {}, Ljava/lang/Object;.<init>:()V // method@0005
 //      |000b: const/4 v4, #int 2 // #2
 
-//0:[Unknown],1:[Reference: java.lang.Object[]],2:[Zero],3:[Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Unknown],1:[Reference: java.lang.Object[]],2:[Zero],3:[Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |000c: aput-object v3, v1, v4
 
-//0:[Unknown],1:[Reference: java.lang.Object[]],2:[Zero],3:[Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Unknown],1:[Reference: java.lang.Object[]],2:[Zero],3:[Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |000e: aput-object v3, v1, v6
 
-//0:[Unknown],1:[Reference: java.lang.Object[]],2:[Zero],3:[Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Unknown],1:[Reference: java.lang.Object[]],2:[Zero],3:[Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |0010: +invoke-virtual-quick {v8, v7}, [000c] // vtable #000c
 
-//0:[Conflict],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Conflict],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |0013: return-object v3
 //      |0014: move-exception v0
 
-//0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |0015: if-nez v2, 001f // +000a
 //      |0017: const/4 v4, #int 1 // #1
 
-//0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[32-bit Constant: 1],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
-//      |0018: new-instance v5, Ljava/lang/Object; // type@0003
+// 0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[32-bit Constant: 1],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+//      |0018: new-instance v5, Ljava/lang/Object;  // type@0003
 
-//0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[32-bit Constant: 1],5:[Uninitialized Reference: java.lang.Object],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[32-bit Constant: 1],5:[Uninitialized Reference: java.lang.Object],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |001a: +invoke-object-init/range {}, Ljava/lang/Object;.<init>:()V // method@0005
 
-//0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[32-bit Constant: 1],5:[Reference: java.lang.Object],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[32-bit Constant: 1],5:[Reference: java.lang.Object],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |001d: aput-object v5, v1, v4
 
-//0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[32-bit Constant: 2],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[32-bit Constant: 2],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |001f: aput-object v2, v1, v6
 
-//0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[32-bit Constant: 2],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[32-bit Constant: 2],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |0021: +invoke-virtual-quick {v8, v7}, [000c] // vtable #000c
 //      |0024: move-object v3, v2
 
-//0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |0025: goto 0013 // -0012
 //      |0026: move-exception v4
 
-//0:[Conflict],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[Reference: java.lang.Throwable],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Conflict],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[Reference: java.lang.Throwable],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |0027: aput-object v2, v1, v6
 
-//0:[Conflict],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[Reference: java.lang.Throwable],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Conflict],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[Reference: java.lang.Throwable],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |0029: +invoke-virtual-quick {v8, v7}, [000c] // vtable #000c
 
-//0:[Conflict],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[Reference: java.lang.Throwable],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Conflict],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Conflict],4:[Reference: java.lang.Throwable],5:[Conflict],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |002c: throw v4
 //      |002d: move-exception v4
 //      |002e: move-object v2, v3
 
-//0:[Unknown],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Reference: java.lang.Object],4:[Reference: java.lang.Throwable],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Unknown],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Reference: java.lang.Object],4:[Reference: java.lang.Throwable],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |002f: goto 0027 // -0008
 //      |0030: move-exception v0
 //      |0031: move-object v2, v3
 
-//0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
+// 0:[Reference: java.lang.Exception],1:[Reference: java.lang.Object[]],2:[Reference: java.lang.Object],3:[Reference: java.lang.Object],4:[32-bit Constant: 2],5:[Unknown],6:[32-bit Constant: 1],7:[Zero],8:[Reference: ReferenceMap],
 //      |0032: goto 0015 // -001d
 //      catches       : 3
 //        0x0006 - 0x000b
diff --git a/test/StackWalk/stack_walk_jni.cc b/test/StackWalk/stack_walk_jni.cc
index a4db359318..8f4aae61fd 100644
--- a/test/StackWalk/stack_walk_jni.cc
+++ b/test/StackWalk/stack_walk_jni.cc
@@ -127,4 +127,4 @@ extern "C" JNIEXPORT jint JNICALL Java_StackWalk2_refmap2(JNIEnv*, jobject, jint
   return count + 1;
 }
 
-} // namespace art
+}  // namespace art
-- 
cgit v1.2.3-59-g8ed1b


From 75021222d9c03a80fa5c136db0d5fb8d82d04031 Mon Sep 17 00:00:00 2001
From: Sebastien Hertz <shertz@google.com>
Date: Tue, 16 Jul 2013 18:34:50 +0200
Subject: Adds a DEX-to-DEX compilation level.

This CL adds a DEX-to-DEX compilation level which allows the DEX-to-DEX
compiler to ensure correctness on classes with soft-failed verification.

Bug: 9307738
Change-Id: If051336bf81370bca55872c8c75ccd573d8ca391
---
 compiler/dex/dex_to_dex_compiler.cc | 35 ++++++++++++--------
 compiler/driver/compiler_driver.cc  | 64 +++++++++++++++++++++----------------
 compiler/driver/compiler_driver.h   | 17 ++++++++--
 3 files changed, 74 insertions(+), 42 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/dex/dex_to_dex_compiler.cc b/compiler/dex/dex_to_dex_compiler.cc
index 3c491ce20f..1ee29cbae1 100644
--- a/compiler/dex/dex_to_dex_compiler.cc
+++ b/compiler/dex/dex_to_dex_compiler.cc
@@ -36,9 +36,11 @@ const bool kEnableCheckCastEllision = true;
 class DexCompiler {
  public:
   DexCompiler(art::CompilerDriver& compiler,
-              const DexCompilationUnit& unit)
+              const DexCompilationUnit& unit,
+              DexToDexCompilationLevel dex_to_dex_compilation_level)
     : driver_(compiler),
-      unit_(unit) {}
+      unit_(unit),
+      dex_to_dex_compilation_level_(dex_to_dex_compilation_level) {}
 
   ~DexCompiler() {}
 
@@ -55,6 +57,10 @@ class DexCompiler {
     return *const_cast<DexFile*>(unit_.GetDexFile());
   }
 
+  bool PerformOptimizations() const {
+    return dex_to_dex_compilation_level_ >= kOptimize;
+  }
+
   // Compiles a RETURN-VOID into a RETURN-VOID-BARRIER within a constructor where
   // a barrier is required.
   void CompileReturnVoid(Instruction* inst, uint32_t dex_pc);
@@ -84,6 +90,7 @@ class DexCompiler {
 
   CompilerDriver& driver_;
   const DexCompilationUnit& unit_;
+  const DexToDexCompilationLevel dex_to_dex_compilation_level_;
 
   DISALLOW_COPY_AND_ASSIGN(DexCompiler);
 };
@@ -138,6 +145,7 @@ class ScopedDexWriteAccess {
 };
 
 void DexCompiler::Compile() {
+  DCHECK_GE(dex_to_dex_compilation_level_, kRequired);
   const DexFile::CodeItem* code_item = unit_.GetCodeItem();
   const uint16_t* insns = code_item->insns_;
   const uint32_t insns_size = code_item->insns_size_in_code_units_;
@@ -220,7 +228,7 @@ void DexCompiler::CompileReturnVoid(Instruction* inst, uint32_t dex_pc) {
 }
 
 Instruction* DexCompiler::CompileCheckCast(Instruction* inst, uint32_t dex_pc) {
-  if (!kEnableCheckCastEllision) {
+  if (!kEnableCheckCastEllision || !PerformOptimizations()) {
     return inst;
   }
   MethodReference referrer(&GetDexFile(), unit_.GetDexMethodIndex());
@@ -253,7 +261,7 @@ void DexCompiler::CompileInstanceFieldAccess(Instruction* inst,
                                              uint32_t dex_pc,
                                              Instruction::Code new_opcode,
                                              bool is_put) {
-  if (!kEnableQuickening) {
+  if (!kEnableQuickening || !PerformOptimizations()) {
     return;
   }
   uint32_t field_idx = inst->VRegC_22c();
@@ -280,7 +288,7 @@ void DexCompiler::CompileInvokeVirtual(Instruction* inst,
                                 uint32_t dex_pc,
                                 Instruction::Code new_opcode,
                                 bool is_range) {
-  if (!kEnableQuickening) {
+  if (!kEnableQuickening || !PerformOptimizations()) {
     return;
   }
   uint32_t method_idx = is_range ? inst->VRegB_3rc() : inst->VRegB_35c();
@@ -320,14 +328,15 @@ void DexCompiler::CompileInvokeVirtual(Instruction* inst,
 }  // namespace optimizer
 }  // namespace art
 
-extern "C" art::CompiledMethod*
-    ArtCompileDEX(art::CompilerDriver& compiler, const art::DexFile::CodeItem* code_item,
+extern "C" void ArtCompileDEX(art::CompilerDriver& compiler, const art::DexFile::CodeItem* code_item,
                   uint32_t access_flags, art::InvokeType invoke_type,
                   uint32_t class_def_idx, uint32_t method_idx, jobject class_loader,
-                  const art::DexFile& dex_file) {
-  art::DexCompilationUnit unit(NULL, class_loader, art::Runtime::Current()->GetClassLinker(),
-                               dex_file, code_item, class_def_idx, method_idx, access_flags);
-  art::optimizer::DexCompiler dex_compiler(compiler, unit);
-  dex_compiler.Compile();
-  return NULL;
+                  const art::DexFile& dex_file,
+                  art::DexToDexCompilationLevel dex_to_dex_compilation_level) {
+  if (dex_to_dex_compilation_level != art::kDontDexToDexCompile) {
+    art::DexCompilationUnit unit(NULL, class_loader, art::Runtime::Current()->GetClassLinker(),
+                                 dex_file, code_item, class_def_idx, method_idx, access_flags);
+    art::optimizer::DexCompiler dex_compiler(compiler, unit, dex_to_dex_compilation_level);
+    dex_compiler.Compile();
+  }
 }
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 49aba4d6a9..38d00a0804 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -369,7 +369,7 @@ CompilerDriver::CompilerDriver(CompilerBackend compiler_backend, InstructionSet
     compiler_ = reinterpret_cast<CompilerFn>(ArtQuickCompileMethod);
   }
 
-  dex_to_dex_compiler_ = reinterpret_cast<CompilerFn>(ArtCompileDEX);
+  dex_to_dex_compiler_ = reinterpret_cast<DexToDexCompilerFn>(ArtCompileDEX);
 
 #ifdef ART_SEA_IR_MODE
   sea_ir_compiler_ = NULL;
@@ -505,16 +505,10 @@ void CompilerDriver::CompileAll(jobject class_loader,
   }
 }
 
-static bool IsDexToDexCompilationAllowed(mirror::ClassLoader* class_loader,
-                                         const DexFile& dex_file,
-                                         const DexFile::ClassDef& class_def)
+static DexToDexCompilationLevel GetDexToDexCompilationlevel(mirror::ClassLoader* class_loader,
+                                                            const DexFile& dex_file,
+                                                            const DexFile::ClassDef& class_def)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  // Do not allow DEX-to-DEX compilation of image classes. This is to prevent the
-  // verifier from passing on "quick" instruction at compilation time. It must
-  // only pass on quick instructions at runtime.
-  if (class_loader == NULL) {
-    return false;
-  }
   const char* descriptor = dex_file.GetClassDescriptor(class_def);
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   mirror::Class* klass = class_linker->FindClass(descriptor, class_loader);
@@ -522,10 +516,27 @@ static bool IsDexToDexCompilationAllowed(mirror::ClassLoader* class_loader,
     Thread* self = Thread::Current();
     CHECK(self->IsExceptionPending());
     self->ClearException();
-    return false;
+    return kDontDexToDexCompile;
+  }
+  // The verifier can only run on "quick" instructions at runtime (see usage of
+  // FindAccessedFieldAtDexPc and FindInvokedMethodAtDexPc in ThrowNullPointerExceptionFromDexPC
+  // function). Since image classes can be verified again while compiling an application,
+  // we must prevent the DEX-to-DEX compiler from introducing them.
+  // TODO: find a way to enable "quick" instructions for image classes and remove this check.
+  bool compiling_image_classes = (class_loader == NULL);
+  if (compiling_image_classes) {
+    return kRequired;
+  } else if (klass->IsVerified()) {
+    // Class is verified so we can enable DEX-to-DEX compilation for performance.
+    return kOptimize;
+  } else if (klass->IsCompileTimeVerified()) {
+    // Class verification has soft-failed. Anyway, ensure at least correctness.
+    DCHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
+    return kRequired;
+  } else {
+    // Class verification has failed: do not run DEX-to-DEX compilation.
+    return kDontDexToDexCompile;
   }
-  // DEX-to-DEX compilation is only allowed on preverified classes.
-  return klass->IsVerified();
 }
 
 void CompilerDriver::CompileOne(const mirror::AbstractMethod* method, base::TimingLogger& timings) {
@@ -556,15 +567,15 @@ void CompilerDriver::CompileOne(const mirror::AbstractMethod* method, base::Timi
   uint32_t method_idx = method->GetDexMethodIndex();
   const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset());
   // Can we run DEX-to-DEX compiler on this class ?
-  bool allow_dex_compilation;
+  DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile;
   {
     ScopedObjectAccess soa(Thread::Current());
     const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_idx);
     mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(jclass_loader);
-    allow_dex_compilation = IsDexToDexCompilationAllowed(class_loader, *dex_file, class_def);
+    dex_to_dex_compilation_level = GetDexToDexCompilationlevel(class_loader, *dex_file, class_def);
   }
   CompileMethod(code_item, method->GetAccessFlags(), method->GetInvokeType(),
-                class_def_idx, method_idx, jclass_loader, *dex_file, allow_dex_compilation);
+                class_def_idx, method_idx, jclass_loader, *dex_file, dex_to_dex_compilation_level);
 
   self->GetJniEnv()->DeleteGlobalRef(jclass_loader);
 
@@ -2171,11 +2182,11 @@ void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, siz
     return;
   }
   // Can we run DEX-to-DEX compiler on this class ?
-  bool allow_dex_compilation;
+  DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile;
   {
     ScopedObjectAccess soa(Thread::Current());
     mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(jclass_loader);
-    allow_dex_compilation = IsDexToDexCompilationAllowed(class_loader, dex_file, class_def);
+    dex_to_dex_compilation_level = GetDexToDexCompilationlevel(class_loader, dex_file, class_def);
   }
   ClassDataItemIterator it(dex_file, class_data);
   // Skip fields
@@ -2198,7 +2209,7 @@ void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, siz
     previous_direct_method_idx = method_idx;
     manager->GetCompiler()->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
                                           it.GetMethodInvokeType(class_def), class_def_index,
-                                          method_idx, jclass_loader, dex_file, allow_dex_compilation);
+                                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
     it.Next();
   }
   // Compile virtual methods
@@ -2214,7 +2225,7 @@ void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, siz
     previous_virtual_method_idx = method_idx;
     manager->GetCompiler()->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
                                           it.GetMethodInvokeType(class_def), class_def_index,
-                                          method_idx, jclass_loader, dex_file, allow_dex_compilation);
+                                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
     it.Next();
   }
   DCHECK(!it.HasNext());
@@ -2231,7 +2242,7 @@ void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t
                                    InvokeType invoke_type, uint32_t class_def_idx,
                                    uint32_t method_idx, jobject class_loader,
                                    const DexFile& dex_file,
-                                   bool allow_dex_to_dex_compilation) {
+                                   DexToDexCompilationLevel dex_to_dex_compilation_level) {
   CompiledMethod* compiled_method = NULL;
   uint64_t start_ns = NanoTime();
 
@@ -2253,13 +2264,12 @@ void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t
       compiled_method = (*compiler)(*this, code_item, access_flags, invoke_type, class_def_idx,
                                     method_idx, class_loader, dex_file);
       CHECK(compiled_method != NULL) << PrettyMethod(method_idx, dex_file);
-    } else if (allow_dex_to_dex_compilation) {
+    } else if (dex_to_dex_compilation_level != kDontDexToDexCompile) {
       // TODO: add a mode to disable DEX-to-DEX compilation ?
-      compiled_method = (*dex_to_dex_compiler_)(*this, code_item, access_flags,
-                                                invoke_type, class_def_idx,
-                                                method_idx, class_loader, dex_file);
-      // No native code is generated.
-      CHECK(compiled_method == NULL) << PrettyMethod(method_idx, dex_file);
+      (*dex_to_dex_compiler_)(*this, code_item, access_flags,
+                              invoke_type, class_def_idx,
+                              method_idx, class_loader, dex_file,
+                              dex_to_dex_compilation_level);
     }
   }
   uint64_t duration_ns = NanoTime() - start_ns;
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index a7a47ed876..18f852dc6f 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -48,6 +48,12 @@ enum CompilerBackend {
   kNoBackend
 };
 
+enum DexToDexCompilationLevel {
+  kDontDexToDexCompile,   // Only meaning wrt image time interpretation.
+  kRequired,              // Dex-to-dex compilation required for correctness.
+  kOptimize               // Perform required transformation and peep-hole optimizations.
+};
+
 // Thread-local storage compiler worker threads
 class CompilerTls {
   public:
@@ -324,7 +330,7 @@ class CompilerDriver {
   void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
                      InvokeType invoke_type, uint32_t class_def_idx, uint32_t method_idx,
                      jobject class_loader, const DexFile& dex_file,
-                     bool allow_dex_to_dex_compilation)
+                     DexToDexCompilationLevel dex_to_dex_compilation_level)
       LOCKS_EXCLUDED(compiled_methods_lock_);
 
   static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index)
@@ -375,12 +381,19 @@ class CompilerDriver {
                                         uint32_t access_flags, InvokeType invoke_type,
                                         uint32_t class_dex_idx, uint32_t method_idx,
                                         jobject class_loader, const DexFile& dex_file);
+
+  typedef void (*DexToDexCompilerFn)(CompilerDriver& driver,
+                                     const DexFile::CodeItem* code_item,
+                                     uint32_t access_flags, InvokeType invoke_type,
+                                     uint32_t class_dex_idx, uint32_t method_idx,
+                                     jobject class_loader, const DexFile& dex_file,
+                                     DexToDexCompilationLevel dex_to_dex_compilation_level);
   CompilerFn compiler_;
 #ifdef ART_SEA_IR_MODE
   CompilerFn sea_ir_compiler_;
 #endif
 
-  CompilerFn dex_to_dex_compiler_;
+  DexToDexCompilerFn dex_to_dex_compiler_;
 
   void* compiler_context_;
 
-- 
cgit v1.2.3-59-g8ed1b


From 848871b4d8481229c32e0d048a9856e5a9a17ef9 Mon Sep 17 00:00:00 2001
From: Ian Rogers <irogers@google.com>
Date: Mon, 5 Aug 2013 10:56:33 -0700
Subject: Entry point clean up.

Create set of entry points needed for image methods to avoid fix-up at load time:
 - interpreter - bridge to interpreter, bridge to compiled code
 - jni - dlsym lookup
 - quick - resolution and bridge to interpreter
 - portable - resolution and bridge to interpreter

Fix JNI work around to use JNI work around argument rewriting code that'd been
accidentally disabled.
Remove abstact method error stub, use interpreter bridge instead.
Consolidate trampoline (previously stub) generation in generic helper.
Simplify trampolines to jump directly into assembly code, keeps stack crawlable.
Dex: replace use of int with ThreadOffset for values that are thread offsets.
Tidy entry point routines between interpreter, jni, quick and portable.

Change-Id: I52a7c2bbb1b7e0ff8a3c3100b774212309d0828e
---
 compiler/Android.mk                                |   3 +-
 compiler/dex/quick/arm/call_arm.cc                 |   6 +-
 compiler/dex/quick/arm/codegen_arm.h               |   6 +-
 compiler/dex/quick/arm/int_arm.cc                  |   6 +-
 compiler/dex/quick/arm/target_arm.cc               |   4 +-
 compiler/dex/quick/arm/utility_arm.cc              |   2 +-
 compiler/dex/quick/gen_common.cc                   |  96 ++--
 compiler/dex/quick/gen_invoke.cc                   |  67 +--
 compiler/dex/quick/mips/call_mips.cc               |   6 +-
 compiler/dex/quick/mips/codegen_mips.h             |   6 +-
 compiler/dex/quick/mips/fp_mips.cc                 |   2 +-
 compiler/dex/quick/mips/int_mips.cc                |   4 +-
 compiler/dex/quick/mips/target_mips.cc             |   4 +-
 compiler/dex/quick/mips/utility_mips.cc            |   2 +-
 compiler/dex/quick/mir_to_lir.h                    |  44 +-
 compiler/dex/quick/x86/call_x86.cc                 |   8 +-
 compiler/dex/quick/x86/codegen_x86.h               |   8 +-
 compiler/dex/quick/x86/int_x86.cc                  |  12 +-
 compiler/dex/quick/x86/target_x86.cc               |   2 +-
 compiler/dex/quick/x86/utility_x86.cc              |   4 +-
 compiler/driver/compiler_driver.cc                 |  78 +--
 compiler/driver/compiler_driver.h                  |  23 +-
 compiler/image_writer.cc                           | 107 ++--
 compiler/image_writer.h                            |  11 +-
 compiler/jni/quick/jni_compiler.cc                 |   6 +-
 compiler/oat_writer.cc                             | 128 +++--
 compiler/oat_writer.h                              |  16 +-
 compiler/stubs/portable/stubs.cc                   | 138 -----
 compiler/stubs/quick/stubs.cc                      | 263 ----------
 compiler/stubs/stubs.h                             |  59 ---
 compiler/utils/arm/assembler_arm.cc                |  10 +-
 compiler/utils/mips/assembler_mips.cc              |  33 +-
 runtime/Android.mk                                 |   7 +-
 runtime/arch/arm/asm_support_arm.S                 |   7 +
 runtime/arch/arm/entrypoints_init_arm.cc           | 193 +++----
 runtime/arch/arm/jni_entrypoints_arm.S             |   7 +-
 runtime/arch/arm/portable_entrypoints_arm.S        |   3 +
 runtime/arch/arm/quick_entrypoints_arm.S           | 183 +++----
 runtime/arch/mips/asm_support_mips.S               |   8 +
 runtime/arch/mips/entrypoints_init_mips.cc         | 192 +++----
 runtime/arch/mips/jni_entrypoints_mips.S           |   4 +-
 runtime/arch/mips/portable_entrypoints_mips.S      |  12 +-
 runtime/arch/mips/quick_entrypoints_mips.S         | 186 +++----
 runtime/arch/x86/asm_support_x86.S                 |  12 +
 runtime/arch/x86/entrypoints_init_x86.cc           | 246 ++++-----
 runtime/arch/x86/portable_entrypoints_x86.S        |  19 +-
 runtime/arch/x86/quick_entrypoints_x86.S           | 209 ++++----
 runtime/class_linker.cc                            |  99 ++--
 runtime/class_linker.h                             |  20 +-
 runtime/common_test.h                              |  11 +-
 runtime/entrypoints/entrypoint_utils.h             |  71 +--
 .../interpreter/interpreter_entrypoints.cc         |  43 ++
 .../interpreter/interpreter_entrypoints.h          |  47 ++
 runtime/entrypoints/jni/jni_entrypoints.cc         |  87 +++-
 runtime/entrypoints/jni/jni_entrypoints.h          |  37 ++
 .../entrypoints/portable/portable_entrypoints.h    |   8 +-
 runtime/entrypoints/quick/quick_argument_visitor.h | 138 -----
 runtime/entrypoints/quick/quick_entrypoints.h      |  74 ++-
 .../quick/quick_instrumentation_entrypoints.cc     |   2 +-
 .../quick/quick_interpreter_entrypoints.cc         | 128 -----
 runtime/entrypoints/quick/quick_jni_entrypoints.cc |  74 ---
 .../entrypoints/quick/quick_proxy_entrypoints.cc   | 126 -----
 .../entrypoints/quick/quick_stub_entrypoints.cc    | 295 -----------
 .../quick/quick_trampoline_entrypoints.cc          | 558 +++++++++++++++++++++
 runtime/instrumentation.cc                         |  26 +-
 runtime/interpreter/interpreter.cc                 |  16 +-
 runtime/interpreter/interpreter.h                  |   6 +-
 runtime/jni_internal.h                             |   4 +
 runtime/mirror/abstract_method-inl.h               |   4 +-
 runtime/mirror/abstract_method.cc                  |   7 +-
 runtime/native/dalvik_system_VMRuntime.cc          |   7 -
 runtime/oat.cc                                     | 112 ++++-
 runtime/oat.h                                      |  33 +-
 runtime/oat_test.cc                                |   2 +-
 runtime/object_utils.h                             |   4 +
 runtime/stack.cc                                   |   2 +-
 runtime/thread.cc                                  |  82 +--
 runtime/thread.h                                   |  30 +-
 78 files changed, 2129 insertions(+), 2476 deletions(-)
 delete mode 100644 compiler/stubs/portable/stubs.cc
 delete mode 100644 compiler/stubs/quick/stubs.cc
 delete mode 100644 compiler/stubs/stubs.h
 create mode 100644 runtime/entrypoints/interpreter/interpreter_entrypoints.cc
 create mode 100644 runtime/entrypoints/interpreter/interpreter_entrypoints.h
 create mode 100644 runtime/entrypoints/jni/jni_entrypoints.h
 delete mode 100644 runtime/entrypoints/quick/quick_argument_visitor.h
 delete mode 100644 runtime/entrypoints/quick/quick_interpreter_entrypoints.cc
 delete mode 100644 runtime/entrypoints/quick/quick_proxy_entrypoints.cc
 delete mode 100644 runtime/entrypoints/quick/quick_stub_entrypoints.cc
 create mode 100644 runtime/entrypoints/quick/quick_trampoline_entrypoints.cc

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/Android.mk b/compiler/Android.mk
index 82103f8fe7..417fe6d32a 100644
--- a/compiler/Android.mk
+++ b/compiler/Android.mk
@@ -74,8 +74,7 @@ LIBART_COMPILER_SRC_FILES := \
 	llvm/runtime_support_builder_arm.cc \
 	llvm/runtime_support_builder_thumb2.cc \
 	llvm/runtime_support_builder_x86.cc \
-	stubs/portable/stubs.cc \
-	stubs/quick/stubs.cc \
+	trampolines/trampoline_compiler.cc \
 	utils/arm/assembler_arm.cc \
 	utils/arm/managed_register_arm.cc \
 	utils/assembler.cc \
diff --git a/compiler/dex/quick/arm/call_arm.cc b/compiler/dex/quick/arm/call_arm.cc
index 745e43dc38..2d8e24f58e 100644
--- a/compiler/dex/quick/arm/call_arm.cc
+++ b/compiler/dex/quick/arm/call_arm.cc
@@ -432,7 +432,7 @@ void ArmMir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src) {
   // Making a call - use explicit registers
   FlushAllRegs();   /* Everything to home location */
   LoadValueDirectFixed(rl_src, r0);
-  LoadWordDisp(rARM_SELF, QUICK_ENTRYPOINT_OFFSET(pHandleFillArrayDataFromCode),
+  LoadWordDisp(rARM_SELF, QUICK_ENTRYPOINT_OFFSET(pHandleFillArrayData).Int32Value(),
                rARM_LR);
   // Materialize a pointer to the fill data image
   NewLIR3(kThumb2Adr, r1, 0, reinterpret_cast<uintptr_t>(tab_rec));
@@ -488,7 +488,7 @@ void ArmMir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src) {
   OpRegImm(kOpCmp, r1, 0);
   OpIT(kCondNe, "T");
   // Go expensive route - artLockObjectFromCode(self, obj);
-  LoadWordDisp(rARM_SELF, QUICK_ENTRYPOINT_OFFSET(pLockObjectFromCode), rARM_LR);
+  LoadWordDisp(rARM_SELF, QUICK_ENTRYPOINT_OFFSET(pLockObject).Int32Value(), rARM_LR);
   ClobberCalleeSave();
   LIR* call_inst = OpReg(kOpBlx, rARM_LR);
   MarkSafepointPC(call_inst);
@@ -519,7 +519,7 @@ void ArmMir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src) {
   OpIT(kCondEq, "EE");
   StoreWordDisp(r0, mirror::Object::MonitorOffset().Int32Value(), r3);
   // Go expensive route - UnlockObjectFromCode(obj);
-  LoadWordDisp(rARM_SELF, QUICK_ENTRYPOINT_OFFSET(pUnlockObjectFromCode), rARM_LR);
+  LoadWordDisp(rARM_SELF, QUICK_ENTRYPOINT_OFFSET(pUnlockObject).Int32Value(), rARM_LR);
   ClobberCalleeSave();
   LIR* call_inst = OpReg(kOpBlx, rARM_LR);
   MarkSafepointPC(call_inst);
diff --git a/compiler/dex/quick/arm/codegen_arm.h b/compiler/dex/quick/arm/codegen_arm.h
index 1599941ef6..f1ccfa015e 100644
--- a/compiler/dex/quick/arm/codegen_arm.h
+++ b/compiler/dex/quick/arm/codegen_arm.h
@@ -28,7 +28,7 @@ class ArmMir2Lir : public Mir2Lir {
     // Required for target - codegen helpers.
     bool SmallLiteralDivide(Instruction::Code dalvik_opcode, RegLocation rl_src,
                                     RegLocation rl_dest, int lit);
-    int LoadHelper(int offset);
+    int LoadHelper(ThreadOffset offset);
     LIR* LoadBaseDisp(int rBase, int displacement, int r_dest, OpSize size, int s_reg);
     LIR* LoadBaseDispWide(int rBase, int displacement, int r_dest_lo, int r_dest_hi,
                           int s_reg);
@@ -153,12 +153,12 @@ class ArmMir2Lir : public Mir2Lir {
     LIR* OpRegRegImm(OpKind op, int r_dest, int r_src1, int value);
     LIR* OpRegRegReg(OpKind op, int r_dest, int r_src1, int r_src2);
     LIR* OpTestSuspend(LIR* target);
-    LIR* OpThreadMem(OpKind op, int thread_offset);
+    LIR* OpThreadMem(OpKind op, ThreadOffset thread_offset);
     LIR* OpVldm(int rBase, int count);
     LIR* OpVstm(int rBase, int count);
     void OpLea(int rBase, int reg1, int reg2, int scale, int offset);
     void OpRegCopyWide(int dest_lo, int dest_hi, int src_lo, int src_hi);
-    void OpTlsCmp(int offset, int val);
+    void OpTlsCmp(ThreadOffset offset, int val);
 
     RegLocation ArgLoc(RegLocation loc);
     LIR* LoadBaseDispBody(int rBase, int displacement, int r_dest, int r_dest_hi, OpSize size,
diff --git a/compiler/dex/quick/arm/int_arm.cc b/compiler/dex/quick/arm/int_arm.cc
index 9db1016efa..c258019daa 100644
--- a/compiler/dex/quick/arm/int_arm.cc
+++ b/compiler/dex/quick/arm/int_arm.cc
@@ -498,7 +498,7 @@ void ArmMir2Lir::OpLea(int rBase, int reg1, int reg2, int scale, int offset) {
   LOG(FATAL) << "Unexpected use of OpLea for Arm";
 }
 
-void ArmMir2Lir::OpTlsCmp(int offset, int val) {
+void ArmMir2Lir::OpTlsCmp(ThreadOffset offset, int val) {
   LOG(FATAL) << "Unexpected use of OpTlsCmp for Arm";
 }
 
@@ -665,7 +665,7 @@ void ArmMir2Lir::GenMulLong(RegLocation rl_dest, RegLocation rl_src1,
      */
     RegLocation rl_result;
     if (BadOverlap(rl_src1, rl_dest) || (BadOverlap(rl_src2, rl_dest))) {
-      int func_offset = QUICK_ENTRYPOINT_OFFSET(pLmul);
+      ThreadOffset func_offset = QUICK_ENTRYPOINT_OFFSET(pLmul);
       FlushAllRegs();
       CallRuntimeHelperRegLocationRegLocation(func_offset, rl_src1, rl_src2, false);
       rl_result = GetReturnWide(false);
@@ -956,7 +956,7 @@ void ArmMir2Lir::GenArrayObjPut(int opt_flags, RegLocation rl_array,
 
   // Get the array's class.
   LoadWordDisp(r_array, mirror::Object::ClassOffset().Int32Value(), r_array_class);
-  CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(pCanPutArrayElementFromCode), r_value,
+  CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(pCanPutArrayElement), r_value,
                           r_array_class, true);
   // Redo LoadValues in case they didn't survive the call.
   LoadValueDirectFixed(rl_array, r_array);  // Reload array
diff --git a/compiler/dex/quick/arm/target_arm.cc b/compiler/dex/quick/arm/target_arm.cc
index 6f3779879c..47d3d974ef 100644
--- a/compiler/dex/quick/arm/target_arm.cc
+++ b/compiler/dex/quick/arm/target_arm.cc
@@ -714,8 +714,8 @@ void ArmMir2Lir::FreeCallTemps() {
   FreeTemp(r3);
 }
 
-int ArmMir2Lir::LoadHelper(int offset) {
-  LoadWordDisp(rARM_SELF, offset, rARM_LR);
+int ArmMir2Lir::LoadHelper(ThreadOffset offset) {
+  LoadWordDisp(rARM_SELF, offset.Int32Value(), rARM_LR);
   return rARM_LR;
 }
 
diff --git a/compiler/dex/quick/arm/utility_arm.cc b/compiler/dex/quick/arm/utility_arm.cc
index afc8a66d8a..c63de69284 100644
--- a/compiler/dex/quick/arm/utility_arm.cc
+++ b/compiler/dex/quick/arm/utility_arm.cc
@@ -1029,7 +1029,7 @@ LIR* ArmMir2Lir::OpFpRegCopy(int r_dest, int r_src) {
   return res;
 }
 
-LIR* ArmMir2Lir::OpThreadMem(OpKind op, int thread_offset) {
+LIR* ArmMir2Lir::OpThreadMem(OpKind op, ThreadOffset thread_offset) {
   LOG(FATAL) << "Unexpected use of OpThreadMem for Arm";
   return NULL;
 }
diff --git a/compiler/dex/quick/gen_common.cc b/compiler/dex/quick/gen_common.cc
index ebe10bb57e..298d3898c8 100644
--- a/compiler/dex/quick/gen_common.cc
+++ b/compiler/dex/quick/gen_common.cc
@@ -208,12 +208,12 @@ void Mir2Lir::GenIntNarrowing(Instruction::Code opcode, RegLocation rl_dest,
 void Mir2Lir::GenNewArray(uint32_t type_idx, RegLocation rl_dest,
                           RegLocation rl_src) {
   FlushAllRegs();  /* Everything to home location */
-  int func_offset;
+  ThreadOffset func_offset(-1);
   if (cu_->compiler_driver->CanAccessTypeWithoutChecks(cu_->method_idx, *cu_->dex_file,
                                                        type_idx)) {
-    func_offset = QUICK_ENTRYPOINT_OFFSET(pAllocArrayFromCode);
+    func_offset = QUICK_ENTRYPOINT_OFFSET(pAllocArray);
   } else {
-    func_offset= QUICK_ENTRYPOINT_OFFSET(pAllocArrayFromCodeWithAccessCheck);
+    func_offset= QUICK_ENTRYPOINT_OFFSET(pAllocArrayWithAccessCheck);
   }
   CallRuntimeHelperImmMethodRegLocation(func_offset, type_idx, rl_src, true);
   RegLocation rl_result = GetReturn(false);
@@ -230,12 +230,12 @@ void Mir2Lir::GenFilledNewArray(CallInfo* info) {
   int elems = info->num_arg_words;
   int type_idx = info->index;
   FlushAllRegs();  /* Everything to home location */
-  int func_offset;
+  ThreadOffset func_offset(-1);
   if (cu_->compiler_driver->CanAccessTypeWithoutChecks(cu_->method_idx, *cu_->dex_file,
                                                        type_idx)) {
-    func_offset = QUICK_ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCode);
+    func_offset = QUICK_ENTRYPOINT_OFFSET(pCheckAndAllocArray);
   } else {
-    func_offset = QUICK_ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCodeWithAccessCheck);
+    func_offset = QUICK_ENTRYPOINT_OFFSET(pCheckAndAllocArrayWithAccessCheck);
   }
   CallRuntimeHelperImmMethodImm(func_offset, type_idx, elems, true);
   FreeTemp(TargetReg(kArg2));
@@ -408,9 +408,10 @@ void Mir2Lir::GenSput(uint32_t field_idx, RegLocation rl_src, bool is_long_or_do
     FreeTemp(rBase);
   } else {
     FlushAllRegs();  // Everything to home locations
-    int setter_offset = is_long_or_double ? QUICK_ENTRYPOINT_OFFSET(pSet64Static) :
-        (is_object ? QUICK_ENTRYPOINT_OFFSET(pSetObjStatic)
-        : QUICK_ENTRYPOINT_OFFSET(pSet32Static));
+    ThreadOffset setter_offset =
+        is_long_or_double ? QUICK_ENTRYPOINT_OFFSET(pSet64Static)
+                          : (is_object ? QUICK_ENTRYPOINT_OFFSET(pSetObjStatic)
+                                       : QUICK_ENTRYPOINT_OFFSET(pSet32Static));
     CallRuntimeHelperImmRegLocation(setter_offset, field_idx, rl_src, true);
   }
 }
@@ -483,9 +484,10 @@ void Mir2Lir::GenSget(uint32_t field_idx, RegLocation rl_dest,
     }
   } else {
     FlushAllRegs();  // Everything to home locations
-    int getterOffset = is_long_or_double ? QUICK_ENTRYPOINT_OFFSET(pGet64Static) :
-        (is_object ? QUICK_ENTRYPOINT_OFFSET(pGetObjStatic)
-        : QUICK_ENTRYPOINT_OFFSET(pGet32Static));
+    ThreadOffset getterOffset =
+        is_long_or_double ? QUICK_ENTRYPOINT_OFFSET(pGet64Static)
+                          :(is_object ? QUICK_ENTRYPOINT_OFFSET(pGetObjStatic)
+                                      : QUICK_ENTRYPOINT_OFFSET(pGet32Static));
     CallRuntimeHelperImm(getterOffset, field_idx, true);
     if (is_long_or_double) {
       RegLocation rl_result = GetReturnWide(rl_dest.fp);
@@ -499,7 +501,7 @@ void Mir2Lir::GenSget(uint32_t field_idx, RegLocation rl_dest,
 
 void Mir2Lir::HandleSuspendLaunchPads() {
   int num_elems = suspend_launchpads_.Size();
-  int helper_offset = QUICK_ENTRYPOINT_OFFSET(pTestSuspendFromCode);
+  ThreadOffset helper_offset = QUICK_ENTRYPOINT_OFFSET(pTestSuspend);
   for (int i = 0; i < num_elems; i++) {
     ResetRegPool();
     ResetDefTracking();
@@ -539,13 +541,13 @@ void Mir2Lir::HandleThrowLaunchPads() {
     LIR* lab = throw_launchpads_.Get(i);
     current_dalvik_offset_ = lab->operands[1];
     AppendLIR(lab);
-    int func_offset = 0;
+    ThreadOffset func_offset(-1);
     int v1 = lab->operands[2];
     int v2 = lab->operands[3];
     bool target_x86 = (cu_->instruction_set == kX86);
     switch (lab->operands[0]) {
       case kThrowNullPointer:
-        func_offset = QUICK_ENTRYPOINT_OFFSET(pThrowNullPointerFromCode);
+        func_offset = QUICK_ENTRYPOINT_OFFSET(pThrowNullPointer);
         break;
       case kThrowConstantArrayBounds:  // v1 is length reg (for Arm/Mips), v2 constant index
         // v1 holds the constant array index.  Mips/Arm uses v2 for length, x86 reloads.
@@ -557,7 +559,7 @@ void Mir2Lir::HandleThrowLaunchPads() {
         // Make sure the following LoadConstant doesn't mess with kArg1.
         LockTemp(TargetReg(kArg1));
         LoadConstant(TargetReg(kArg0), v2);
-        func_offset = QUICK_ENTRYPOINT_OFFSET(pThrowArrayBoundsFromCode);
+        func_offset = QUICK_ENTRYPOINT_OFFSET(pThrowArrayBounds);
         break;
       case kThrowArrayBounds:
         // Move v1 (array index) to kArg0 and v2 (array length) to kArg1
@@ -590,18 +592,18 @@ void Mir2Lir::HandleThrowLaunchPads() {
             OpRegCopy(TargetReg(kArg0), v1);
           }
         }
-        func_offset = QUICK_ENTRYPOINT_OFFSET(pThrowArrayBoundsFromCode);
+        func_offset = QUICK_ENTRYPOINT_OFFSET(pThrowArrayBounds);
         break;
       case kThrowDivZero:
-        func_offset = QUICK_ENTRYPOINT_OFFSET(pThrowDivZeroFromCode);
+        func_offset = QUICK_ENTRYPOINT_OFFSET(pThrowDivZero);
         break;
       case kThrowNoSuchMethod:
         OpRegCopy(TargetReg(kArg0), v1);
         func_offset =
-          QUICK_ENTRYPOINT_OFFSET(pThrowNoSuchMethodFromCode);
+          QUICK_ENTRYPOINT_OFFSET(pThrowNoSuchMethod);
         break;
       case kThrowStackOverflow:
-        func_offset = QUICK_ENTRYPOINT_OFFSET(pThrowStackOverflowFromCode);
+        func_offset = QUICK_ENTRYPOINT_OFFSET(pThrowStackOverflow);
         // Restore stack alignment
         if (target_x86) {
           OpRegImm(kOpAdd, TargetReg(kSp), frame_size_);
@@ -664,9 +666,10 @@ void Mir2Lir::GenIGet(uint32_t field_idx, int opt_flags, OpSize size,
       StoreValue(rl_dest, rl_result);
     }
   } else {
-    int getterOffset = is_long_or_double ? QUICK_ENTRYPOINT_OFFSET(pGet64Instance) :
-        (is_object ? QUICK_ENTRYPOINT_OFFSET(pGetObjInstance)
-        : QUICK_ENTRYPOINT_OFFSET(pGet32Instance));
+    ThreadOffset getterOffset =
+        is_long_or_double ? QUICK_ENTRYPOINT_OFFSET(pGet64Instance)
+                          : (is_object ? QUICK_ENTRYPOINT_OFFSET(pGetObjInstance)
+                                       : QUICK_ENTRYPOINT_OFFSET(pGet32Instance));
     CallRuntimeHelperImmRegLocation(getterOffset, field_idx, rl_obj, true);
     if (is_long_or_double) {
       RegLocation rl_result = GetReturnWide(rl_dest.fp);
@@ -719,9 +722,10 @@ void Mir2Lir::GenIPut(uint32_t field_idx, int opt_flags, OpSize size,
       }
     }
   } else {
-    int setter_offset = is_long_or_double ? QUICK_ENTRYPOINT_OFFSET(pSet64Instance) :
-        (is_object ? QUICK_ENTRYPOINT_OFFSET(pSetObjInstance)
-        : QUICK_ENTRYPOINT_OFFSET(pSet32Instance));
+    ThreadOffset setter_offset =
+        is_long_or_double ? QUICK_ENTRYPOINT_OFFSET(pSet64Instance)
+                          : (is_object ? QUICK_ENTRYPOINT_OFFSET(pSetObjInstance)
+                                       : QUICK_ENTRYPOINT_OFFSET(pSet32Instance));
     CallRuntimeHelperImmRegLocationRegLocation(setter_offset, field_idx, rl_obj, rl_src, true);
   }
 }
@@ -735,7 +739,7 @@ void Mir2Lir::GenConstClass(uint32_t type_idx, RegLocation rl_dest) {
                                                    type_idx)) {
     // Call out to helper which resolves type and verifies access.
     // Resolved type returned in kRet0.
-    CallRuntimeHelperImmReg(QUICK_ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
+    CallRuntimeHelperImmReg(QUICK_ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccess),
                             type_idx, rl_method.low_reg, true);
     RegLocation rl_result = GetReturn(false);
     StoreValue(rl_dest, rl_result);
@@ -764,7 +768,7 @@ void Mir2Lir::GenConstClass(uint32_t type_idx, RegLocation rl_dest) {
       // TUNING: move slow path to end & remove unconditional branch
       LIR* target1 = NewLIR0(kPseudoTargetLabel);
       // Call out to helper, which will return resolved type in kArg0
-      CallRuntimeHelperImmReg(QUICK_ENTRYPOINT_OFFSET(pInitializeTypeFromCode), type_idx,
+      CallRuntimeHelperImmReg(QUICK_ENTRYPOINT_OFFSET(pInitializeType), type_idx,
                               rl_method.low_reg, true);
       RegLocation rl_result = GetReturn(false);
       StoreValue(rl_dest, rl_result);
@@ -797,7 +801,7 @@ void Mir2Lir::GenConstString(uint32_t string_idx, RegLocation rl_dest) {
     LoadWordDisp(TargetReg(kArg2),
                  mirror::AbstractMethod::DexCacheStringsOffset().Int32Value(), TargetReg(kArg0));
     // Might call out to helper, which will return resolved string in kRet0
-    int r_tgt = CallHelperSetup(QUICK_ENTRYPOINT_OFFSET(pResolveStringFromCode));
+    int r_tgt = CallHelperSetup(QUICK_ENTRYPOINT_OFFSET(pResolveString));
     LoadWordDisp(TargetReg(kArg0), offset_of_string, TargetReg(kRet0));
     LoadConstant(TargetReg(kArg1), string_idx);
     if (cu_->instruction_set == kThumb2) {
@@ -821,7 +825,7 @@ void Mir2Lir::GenConstString(uint32_t string_idx, RegLocation rl_dest) {
       branch->target = target;
     } else {
       DCHECK_EQ(cu_->instruction_set, kX86);
-      CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(pResolveStringFromCode), TargetReg(kArg2),
+      CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(pResolveString), TargetReg(kArg2),
                               TargetReg(kArg1), true);
     }
     GenBarrier();
@@ -845,12 +849,12 @@ void Mir2Lir::GenNewInstance(uint32_t type_idx, RegLocation rl_dest) {
   FlushAllRegs();  /* Everything to home location */
   // alloc will always check for resolution, do we also need to verify
   // access because the verifier was unable to?
-  int func_offset;
+  ThreadOffset func_offset(-1);
   if (cu_->compiler_driver->CanAccessInstantiableTypeWithoutChecks(
       cu_->method_idx, *cu_->dex_file, type_idx)) {
-    func_offset = QUICK_ENTRYPOINT_OFFSET(pAllocObjectFromCode);
+    func_offset = QUICK_ENTRYPOINT_OFFSET(pAllocObject);
   } else {
-    func_offset = QUICK_ENTRYPOINT_OFFSET(pAllocObjectFromCodeWithAccessCheck);
+    func_offset = QUICK_ENTRYPOINT_OFFSET(pAllocObjectWithAccessCheck);
   }
   CallRuntimeHelperImmMethod(func_offset, type_idx, true);
   RegLocation rl_result = GetReturn(false);
@@ -929,7 +933,7 @@ void Mir2Lir::GenInstanceofCallingHelper(bool needs_access_check, bool type_know
   if (needs_access_check) {
     // Check we have access to type_idx and if not throw IllegalAccessError,
     // returns Class* in kArg0
-    CallRuntimeHelperImm(QUICK_ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
+    CallRuntimeHelperImm(QUICK_ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccess),
                          type_idx, true);
     OpRegCopy(class_reg, TargetReg(kRet0));  // Align usage with fast path
     LoadValueDirectFixed(rl_src, TargetReg(kArg0));  // kArg0 <= ref
@@ -951,7 +955,7 @@ void Mir2Lir::GenInstanceofCallingHelper(bool needs_access_check, bool type_know
       LIR* hop_branch = OpCmpImmBranch(kCondNe, class_reg, 0, NULL);
       // Not resolved
       // Call out to helper, which will return resolved type in kRet0
-      CallRuntimeHelperImm(QUICK_ENTRYPOINT_OFFSET(pInitializeTypeFromCode), type_idx, true);
+      CallRuntimeHelperImm(QUICK_ENTRYPOINT_OFFSET(pInitializeType), type_idx, true);
       OpRegCopy(TargetReg(kArg2), TargetReg(kRet0));  // Align usage with fast path
       LoadValueDirectFixed(rl_src, TargetReg(kArg0));  /* reload Ref */
       // Rejoin code paths
@@ -986,7 +990,7 @@ void Mir2Lir::GenInstanceofCallingHelper(bool needs_access_check, bool type_know
     }
   } else {
     if (cu_->instruction_set == kThumb2) {
-      int r_tgt = LoadHelper(QUICK_ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
+      int r_tgt = LoadHelper(QUICK_ENTRYPOINT_OFFSET(pInstanceofNonTrivial));
       if (!type_known_abstract) {
       /* Uses conditional nullification */
         OpRegReg(kOpCmp, TargetReg(kArg1), TargetReg(kArg2));  // Same?
@@ -1003,13 +1007,13 @@ void Mir2Lir::GenInstanceofCallingHelper(bool needs_access_check, bool type_know
         branchover = OpCmpBranch(kCondEq, TargetReg(kArg1), TargetReg(kArg2), NULL);
       }
       if (cu_->instruction_set != kX86) {
-        int r_tgt = LoadHelper(QUICK_ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
+        int r_tgt = LoadHelper(QUICK_ENTRYPOINT_OFFSET(pInstanceofNonTrivial));
         OpRegCopy(TargetReg(kArg0), TargetReg(kArg2));    // .ne case - arg0 <= class
         OpReg(kOpBlx, r_tgt);    // .ne case: helper(class, ref->class)
         FreeTemp(r_tgt);
       } else {
         OpRegCopy(TargetReg(kArg0), TargetReg(kArg2));
-        OpThreadMem(kOpBlx, QUICK_ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
+        OpThreadMem(kOpBlx, QUICK_ENTRYPOINT_OFFSET(pInstanceofNonTrivial));
       }
     }
   }
@@ -1069,7 +1073,7 @@ void Mir2Lir::GenCheckCast(uint32_t insn_idx, uint32_t type_idx, RegLocation rl_
     // Check we have access to type_idx and if not throw IllegalAccessError,
     // returns Class* in kRet0
     // InitializeTypeAndVerifyAccess(idx, method)
-    CallRuntimeHelperImmReg(QUICK_ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
+    CallRuntimeHelperImmReg(QUICK_ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccess),
                             type_idx, TargetReg(kArg1), true);
     OpRegCopy(class_reg, TargetReg(kRet0));  // Align usage with fast path
   } else if (use_declaring_class) {
@@ -1089,7 +1093,7 @@ void Mir2Lir::GenCheckCast(uint32_t insn_idx, uint32_t type_idx, RegLocation rl_
       // Not resolved
       // Call out to helper, which will return resolved type in kArg0
       // InitializeTypeFromCode(idx, method)
-      CallRuntimeHelperImmReg(QUICK_ENTRYPOINT_OFFSET(pInitializeTypeFromCode), type_idx,
+      CallRuntimeHelperImmReg(QUICK_ENTRYPOINT_OFFSET(pInitializeType), type_idx,
                               TargetReg(kArg1), true);
       OpRegCopy(class_reg, TargetReg(kRet0));  // Align usage with fast path
       // Rejoin code paths
@@ -1109,7 +1113,7 @@ void Mir2Lir::GenCheckCast(uint32_t insn_idx, uint32_t type_idx, RegLocation rl_
   if (!type_known_abstract) {
     branch2 = OpCmpBranch(kCondEq, TargetReg(kArg1), class_reg, NULL);
   }
-  CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(pCheckCastFromCode), TargetReg(kArg1),
+  CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(pCheckCast), TargetReg(kArg1),
                           TargetReg(kArg2), true);
   /* branch target here */
   LIR* target = NewLIR0(kPseudoTargetLabel);
@@ -1168,7 +1172,7 @@ void Mir2Lir::GenLong3Addr(OpKind first_op, OpKind second_op, RegLocation rl_des
 
 void Mir2Lir::GenShiftOpLong(Instruction::Code opcode, RegLocation rl_dest,
                              RegLocation rl_src1, RegLocation rl_shift) {
-  int func_offset = -1;  // Make gcc happy
+  ThreadOffset func_offset(-1);
 
   switch (opcode) {
     case Instruction::SHL_LONG:
@@ -1303,7 +1307,7 @@ void Mir2Lir::GenArithOpInt(Instruction::Code opcode, RegLocation rl_dest,
       }
       rl_result = GenDivRem(rl_dest, rl_src1.low_reg, rl_src2.low_reg, op == kOpDiv);
     } else {
-      int func_offset = QUICK_ENTRYPOINT_OFFSET(pIdivmod);
+      ThreadOffset func_offset = QUICK_ENTRYPOINT_OFFSET(pIdivmod);
       FlushAllRegs();   /* Send everything to home location */
       LoadValueDirectFixed(rl_src2, TargetReg(kArg1));
       int r_tgt = CallHelperSetup(func_offset);
@@ -1558,7 +1562,7 @@ void Mir2Lir::GenArithOpIntLit(Instruction::Code opcode, RegLocation rl_dest, Re
         FlushAllRegs();   /* Everything to home location */
         LoadValueDirectFixed(rl_src, TargetReg(kArg0));
         Clobber(TargetReg(kArg0));
-        int func_offset = QUICK_ENTRYPOINT_OFFSET(pIdivmod);
+        ThreadOffset func_offset = QUICK_ENTRYPOINT_OFFSET(pIdivmod);
         CallRuntimeHelperRegImm(func_offset, TargetReg(kArg0), lit, false);
         if (is_div)
           rl_result = GetReturn(false);
@@ -1589,7 +1593,7 @@ void Mir2Lir::GenArithOpLong(Instruction::Code opcode, RegLocation rl_dest,
   OpKind second_op = kOpBkpt;
   bool call_out = false;
   bool check_zero = false;
-  int func_offset;
+  ThreadOffset func_offset(-1);
   int ret_reg = TargetReg(kRet0);
 
   switch (opcode) {
@@ -1709,7 +1713,7 @@ void Mir2Lir::GenArithOpLong(Instruction::Code opcode, RegLocation rl_dest,
   }
 }
 
-void Mir2Lir::GenConversionCall(int func_offset,
+void Mir2Lir::GenConversionCall(ThreadOffset func_offset,
                                 RegLocation rl_dest, RegLocation rl_src) {
   /*
    * Don't optimize the register usage since it calls out to support
diff --git a/compiler/dex/quick/gen_invoke.cc b/compiler/dex/quick/gen_invoke.cc
index 1b34e99a72..20d683a947 100644
--- a/compiler/dex/quick/gen_invoke.cc
+++ b/compiler/dex/quick/gen_invoke.cc
@@ -37,12 +37,12 @@ namespace art {
  * has a memory call operation, part 1 is a NOP for x86.  For other targets,
  * load arguments between the two parts.
  */
-int Mir2Lir::CallHelperSetup(int helper_offset) {
+int Mir2Lir::CallHelperSetup(ThreadOffset helper_offset) {
   return (cu_->instruction_set == kX86) ? 0 : LoadHelper(helper_offset);
 }
 
 /* NOTE: if r_tgt is a temp, it will be freed following use */
-LIR* Mir2Lir::CallHelper(int r_tgt, int helper_offset, bool safepoint_pc) {
+LIR* Mir2Lir::CallHelper(int r_tgt, ThreadOffset helper_offset, bool safepoint_pc) {
   LIR* call_inst;
   if (cu_->instruction_set == kX86) {
     call_inst = OpThreadMem(kOpBlx, helper_offset);
@@ -56,21 +56,22 @@ LIR* Mir2Lir::CallHelper(int r_tgt, int helper_offset, bool safepoint_pc) {
   return call_inst;
 }
 
-void Mir2Lir::CallRuntimeHelperImm(int helper_offset, int arg0, bool safepoint_pc) {
+void Mir2Lir::CallRuntimeHelperImm(ThreadOffset helper_offset, int arg0, bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   LoadConstant(TargetReg(kArg0), arg0);
   ClobberCalleeSave();
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperReg(int helper_offset, int arg0, bool safepoint_pc) {
+void Mir2Lir::CallRuntimeHelperReg(ThreadOffset helper_offset, int arg0, bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   OpRegCopy(TargetReg(kArg0), arg0);
   ClobberCalleeSave();
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperRegLocation(int helper_offset, RegLocation arg0, bool safepoint_pc) {
+void Mir2Lir::CallRuntimeHelperRegLocation(ThreadOffset helper_offset, RegLocation arg0,
+                                           bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   if (arg0.wide == 0) {
     LoadValueDirectFixed(arg0, TargetReg(kArg0));
@@ -81,7 +82,7 @@ void Mir2Lir::CallRuntimeHelperRegLocation(int helper_offset, RegLocation arg0,
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperImmImm(int helper_offset, int arg0, int arg1,
+void Mir2Lir::CallRuntimeHelperImmImm(ThreadOffset helper_offset, int arg0, int arg1,
                                       bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   LoadConstant(TargetReg(kArg0), arg0);
@@ -90,7 +91,7 @@ void Mir2Lir::CallRuntimeHelperImmImm(int helper_offset, int arg0, int arg1,
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperImmRegLocation(int helper_offset, int arg0,
+void Mir2Lir::CallRuntimeHelperImmRegLocation(ThreadOffset helper_offset, int arg0,
                                               RegLocation arg1, bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   if (arg1.wide == 0) {
@@ -103,7 +104,7 @@ void Mir2Lir::CallRuntimeHelperImmRegLocation(int helper_offset, int arg0,
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperRegLocationImm(int helper_offset, RegLocation arg0, int arg1,
+void Mir2Lir::CallRuntimeHelperRegLocationImm(ThreadOffset helper_offset, RegLocation arg0, int arg1,
                                               bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   LoadValueDirectFixed(arg0, TargetReg(kArg0));
@@ -112,7 +113,7 @@ void Mir2Lir::CallRuntimeHelperRegLocationImm(int helper_offset, RegLocation arg
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperImmReg(int helper_offset, int arg0, int arg1,
+void Mir2Lir::CallRuntimeHelperImmReg(ThreadOffset helper_offset, int arg0, int arg1,
                                       bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   OpRegCopy(TargetReg(kArg1), arg1);
@@ -121,8 +122,8 @@ void Mir2Lir::CallRuntimeHelperImmReg(int helper_offset, int arg0, int arg1,
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperRegImm(int helper_offset, int arg0, int arg1,
-                             bool safepoint_pc) {
+void Mir2Lir::CallRuntimeHelperRegImm(ThreadOffset helper_offset, int arg0, int arg1,
+                                      bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   OpRegCopy(TargetReg(kArg0), arg0);
   LoadConstant(TargetReg(kArg1), arg1);
@@ -130,7 +131,7 @@ void Mir2Lir::CallRuntimeHelperRegImm(int helper_offset, int arg0, int arg1,
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperImmMethod(int helper_offset, int arg0, bool safepoint_pc) {
+void Mir2Lir::CallRuntimeHelperImmMethod(ThreadOffset helper_offset, int arg0, bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   LoadCurrMethodDirect(TargetReg(kArg1));
   LoadConstant(TargetReg(kArg0), arg0);
@@ -138,7 +139,7 @@ void Mir2Lir::CallRuntimeHelperImmMethod(int helper_offset, int arg0, bool safep
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperRegLocationRegLocation(int helper_offset, RegLocation arg0,
+void Mir2Lir::CallRuntimeHelperRegLocationRegLocation(ThreadOffset helper_offset, RegLocation arg0,
                                                       RegLocation arg1, bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   if (arg0.wide == 0) {
@@ -168,7 +169,8 @@ void Mir2Lir::CallRuntimeHelperRegLocationRegLocation(int helper_offset, RegLoca
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperRegReg(int helper_offset, int arg0, int arg1, bool safepoint_pc) {
+void Mir2Lir::CallRuntimeHelperRegReg(ThreadOffset helper_offset, int arg0, int arg1,
+                                      bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   DCHECK_NE(TargetReg(kArg0), arg1);  // check copy into arg0 won't clobber arg1
   OpRegCopy(TargetReg(kArg0), arg0);
@@ -177,7 +179,7 @@ void Mir2Lir::CallRuntimeHelperRegReg(int helper_offset, int arg0, int arg1, boo
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperRegRegImm(int helper_offset, int arg0, int arg1,
+void Mir2Lir::CallRuntimeHelperRegRegImm(ThreadOffset helper_offset, int arg0, int arg1,
                                          int arg2, bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   DCHECK_NE(TargetReg(kArg0), arg1);  // check copy into arg0 won't clobber arg1
@@ -188,7 +190,7 @@ void Mir2Lir::CallRuntimeHelperRegRegImm(int helper_offset, int arg0, int arg1,
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperImmMethodRegLocation(int helper_offset,
+void Mir2Lir::CallRuntimeHelperImmMethodRegLocation(ThreadOffset helper_offset,
                                                     int arg0, RegLocation arg2, bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   LoadValueDirectFixed(arg2, TargetReg(kArg2));
@@ -198,7 +200,7 @@ void Mir2Lir::CallRuntimeHelperImmMethodRegLocation(int helper_offset,
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperImmMethodImm(int helper_offset, int arg0,
+void Mir2Lir::CallRuntimeHelperImmMethodImm(ThreadOffset helper_offset, int arg0,
                                             int arg2, bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
   LoadCurrMethodDirect(TargetReg(kArg1));
@@ -208,7 +210,7 @@ void Mir2Lir::CallRuntimeHelperImmMethodImm(int helper_offset, int arg0,
   CallHelper(r_tgt, helper_offset, safepoint_pc);
 }
 
-void Mir2Lir::CallRuntimeHelperImmRegLocationRegLocation(int helper_offset,
+void Mir2Lir::CallRuntimeHelperImmRegLocationRegLocation(ThreadOffset helper_offset,
                                                          int arg0, RegLocation arg1,
                                                          RegLocation arg2, bool safepoint_pc) {
   int r_tgt = CallHelperSetup(helper_offset);
@@ -470,14 +472,14 @@ static int NextInterfaceCallInsn(CompilationUnit* cu, CallInfo* info, int state,
     // Disable sharpening
     direct_method = 0;
   }
-  int trampoline = (cu->instruction_set == kX86) ? 0
-      : QUICK_ENTRYPOINT_OFFSET(pInvokeInterfaceTrampoline);
+  ThreadOffset trampoline = QUICK_ENTRYPOINT_OFFSET(pInvokeInterfaceTrampoline);
 
   if (direct_method != 0) {
     switch (state) {
       case 0:  // Load the trampoline target [sets kInvokeTgt].
         if (cu->instruction_set != kX86) {
-          cg->LoadWordDisp(cg->TargetReg(kSelf), trampoline, cg->TargetReg(kInvokeTgt));
+          cg->LoadWordDisp(cg->TargetReg(kSelf), trampoline.Int32Value(),
+                           cg->TargetReg(kInvokeTgt));
         }
         // Get the interface Method* [sets kArg0]
         if (direct_method != static_cast<unsigned int>(-1)) {
@@ -506,7 +508,8 @@ static int NextInterfaceCallInsn(CompilationUnit* cu, CallInfo* info, int state,
         cg->LoadCurrMethodDirect(cg->TargetReg(kArg0));
         // Load the trampoline target [sets kInvokeTgt].
         if (cu->instruction_set != kX86) {
-          cg->LoadWordDisp(cg->TargetReg(kSelf), trampoline, cg->TargetReg(kInvokeTgt));
+          cg->LoadWordDisp(cg->TargetReg(kSelf), trampoline.Int32Value(),
+                           cg->TargetReg(kInvokeTgt));
         }
         break;
     case 1:  // Get method->dex_cache_resolved_methods_ [set/use kArg0]
@@ -528,7 +531,7 @@ static int NextInterfaceCallInsn(CompilationUnit* cu, CallInfo* info, int state,
   return state + 1;
 }
 
-static int NextInvokeInsnSP(CompilationUnit* cu, CallInfo* info, int trampoline,
+static int NextInvokeInsnSP(CompilationUnit* cu, CallInfo* info, ThreadOffset trampoline,
                             int state, const MethodReference& target_method,
                             uint32_t method_idx) {
   Mir2Lir* cg = static_cast<Mir2Lir*>(cu->cg.get());
@@ -539,7 +542,7 @@ static int NextInvokeInsnSP(CompilationUnit* cu, CallInfo* info, int trampoline,
   if (state == 0) {
     if (cu->instruction_set != kX86) {
       // Load trampoline target
-      cg->LoadWordDisp(cg->TargetReg(kSelf), trampoline, cg->TargetReg(kInvokeTgt));
+      cg->LoadWordDisp(cg->TargetReg(kSelf), trampoline.Int32Value(), cg->TargetReg(kInvokeTgt));
     }
     // Load kArg0 with method index
     CHECK_EQ(cu->dex_file, target_method.dex_file);
@@ -555,7 +558,7 @@ static int NextStaticCallInsnSP(CompilationUnit* cu, CallInfo* info,
                                 uint32_t method_idx,
                                 uintptr_t unused, uintptr_t unused2,
                                 InvokeType unused3) {
-  int trampoline = QUICK_ENTRYPOINT_OFFSET(pInvokeStaticTrampolineWithAccessCheck);
+  ThreadOffset trampoline = QUICK_ENTRYPOINT_OFFSET(pInvokeStaticTrampolineWithAccessCheck);
   return NextInvokeInsnSP(cu, info, trampoline, state, target_method, 0);
 }
 
@@ -563,7 +566,7 @@ static int NextDirectCallInsnSP(CompilationUnit* cu, CallInfo* info, int state,
                                 const MethodReference& target_method,
                                 uint32_t method_idx, uintptr_t unused,
                                 uintptr_t unused2, InvokeType unused3) {
-  int trampoline = QUICK_ENTRYPOINT_OFFSET(pInvokeDirectTrampolineWithAccessCheck);
+  ThreadOffset trampoline = QUICK_ENTRYPOINT_OFFSET(pInvokeDirectTrampolineWithAccessCheck);
   return NextInvokeInsnSP(cu, info, trampoline, state, target_method, 0);
 }
 
@@ -571,7 +574,7 @@ static int NextSuperCallInsnSP(CompilationUnit* cu, CallInfo* info, int state,
                                const MethodReference& target_method,
                                uint32_t method_idx, uintptr_t unused,
                                uintptr_t unused2, InvokeType unused3) {
-  int trampoline = QUICK_ENTRYPOINT_OFFSET(pInvokeSuperTrampolineWithAccessCheck);
+  ThreadOffset trampoline = QUICK_ENTRYPOINT_OFFSET(pInvokeSuperTrampolineWithAccessCheck);
   return NextInvokeInsnSP(cu, info, trampoline, state, target_method, 0);
 }
 
@@ -579,7 +582,7 @@ static int NextVCallInsnSP(CompilationUnit* cu, CallInfo* info, int state,
                            const MethodReference& target_method,
                            uint32_t method_idx, uintptr_t unused,
                            uintptr_t unused2, InvokeType unused3) {
-  int trampoline = QUICK_ENTRYPOINT_OFFSET(pInvokeVirtualTrampolineWithAccessCheck);
+  ThreadOffset trampoline = QUICK_ENTRYPOINT_OFFSET(pInvokeVirtualTrampolineWithAccessCheck);
   return NextInvokeInsnSP(cu, info, trampoline, state, target_method, 0);
 }
 
@@ -589,7 +592,7 @@ static int NextInterfaceCallInsnWithAccessCheck(CompilationUnit* cu,
                                                 uint32_t unused,
                                                 uintptr_t unused2, uintptr_t unused3,
                                                 InvokeType unused4) {
-  int trampoline = QUICK_ENTRYPOINT_OFFSET(pInvokeInterfaceTrampolineWithAccessCheck);
+  ThreadOffset trampoline = QUICK_ENTRYPOINT_OFFSET(pInvokeInterfaceTrampolineWithAccessCheck);
   return NextInvokeInsnSP(cu, info, trampoline, state, target_method, 0);
 }
 
@@ -1108,9 +1111,9 @@ bool Mir2Lir::GenInlinedStringCompareTo(CallInfo* info) {
 bool Mir2Lir::GenInlinedCurrentThread(CallInfo* info) {
   RegLocation rl_dest = InlineTarget(info);
   RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
-  int offset = Thread::PeerOffset().Int32Value();
+  ThreadOffset offset = Thread::PeerOffset();
   if (cu_->instruction_set == kThumb2 || cu_->instruction_set == kMips) {
-    LoadWordDisp(TargetReg(kSelf), offset, rl_result.low_reg);
+    LoadWordDisp(TargetReg(kSelf), offset.Int32Value(), rl_result.low_reg);
   } else {
     CHECK(cu_->instruction_set == kX86);
     reinterpret_cast<X86Mir2Lir*>(this)->OpRegThreadMem(kOpMov, rl_result.low_reg, offset);
@@ -1406,7 +1409,7 @@ void Mir2Lir::GenInvoke(CallInfo* info) {
       call_inst = OpMem(kOpBlx, TargetReg(kArg0),
                         mirror::AbstractMethod::GetEntryPointFromCompiledCodeOffset().Int32Value());
     } else {
-      int trampoline = 0;
+      ThreadOffset trampoline(-1);
       switch (info->type) {
       case kInterface:
         trampoline = fast_path ? QUICK_ENTRYPOINT_OFFSET(pInvokeInterfaceTrampoline)
diff --git a/compiler/dex/quick/mips/call_mips.cc b/compiler/dex/quick/mips/call_mips.cc
index 846c055ac2..eaae0e1964 100644
--- a/compiler/dex/quick/mips/call_mips.cc
+++ b/compiler/dex/quick/mips/call_mips.cc
@@ -247,7 +247,7 @@ void MipsMir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src) {
   GenBarrier();
   NewLIR0(kMipsCurrPC);  // Really a jal to .+8
   // Now, fill the branch delay slot with the helper load
-  int r_tgt = LoadHelper(QUICK_ENTRYPOINT_OFFSET(pHandleFillArrayDataFromCode));
+  int r_tgt = LoadHelper(QUICK_ENTRYPOINT_OFFSET(pHandleFillArrayData));
   GenBarrier();  // Scheduling barrier
 
   // Construct BaseLabel and set up table base register
@@ -272,7 +272,7 @@ void MipsMir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src) {
   LockCallTemps();  // Prepare for explicit register usage
   GenNullCheck(rl_src.s_reg_low, rMIPS_ARG0, opt_flags);
   // Go expensive route - artLockObjectFromCode(self, obj);
-  int r_tgt = LoadHelper(QUICK_ENTRYPOINT_OFFSET(pLockObjectFromCode));
+  int r_tgt = LoadHelper(QUICK_ENTRYPOINT_OFFSET(pLockObject));
   ClobberCalleeSave();
   LIR* call_inst = OpReg(kOpBlx, r_tgt);
   MarkSafepointPC(call_inst);
@@ -287,7 +287,7 @@ void MipsMir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src) {
   LockCallTemps();  // Prepare for explicit register usage
   GenNullCheck(rl_src.s_reg_low, rMIPS_ARG0, opt_flags);
   // Go expensive route - UnlockObjectFromCode(obj);
-  int r_tgt = LoadHelper(QUICK_ENTRYPOINT_OFFSET(pUnlockObjectFromCode));
+  int r_tgt = LoadHelper(QUICK_ENTRYPOINT_OFFSET(pUnlockObject));
   ClobberCalleeSave();
   LIR* call_inst = OpReg(kOpBlx, r_tgt);
   MarkSafepointPC(call_inst);
diff --git a/compiler/dex/quick/mips/codegen_mips.h b/compiler/dex/quick/mips/codegen_mips.h
index 802ff625c9..6100396e5f 100644
--- a/compiler/dex/quick/mips/codegen_mips.h
+++ b/compiler/dex/quick/mips/codegen_mips.h
@@ -29,7 +29,7 @@ class MipsMir2Lir : public Mir2Lir {
     // Required for target - codegen utilities.
     bool SmallLiteralDivide(Instruction::Code dalvik_opcode, RegLocation rl_src,
                                     RegLocation rl_dest, int lit);
-    int LoadHelper(int offset);
+    int LoadHelper(ThreadOffset offset);
     LIR* LoadBaseDisp(int rBase, int displacement, int r_dest, OpSize size, int s_reg);
     LIR* LoadBaseDispWide(int rBase, int displacement, int r_dest_lo, int r_dest_hi,
                                   int s_reg);
@@ -154,12 +154,12 @@ class MipsMir2Lir : public Mir2Lir {
     LIR* OpRegRegImm(OpKind op, int r_dest, int r_src1, int value);
     LIR* OpRegRegReg(OpKind op, int r_dest, int r_src1, int r_src2);
     LIR* OpTestSuspend(LIR* target);
-    LIR* OpThreadMem(OpKind op, int thread_offset);
+    LIR* OpThreadMem(OpKind op, ThreadOffset thread_offset);
     LIR* OpVldm(int rBase, int count);
     LIR* OpVstm(int rBase, int count);
     void OpLea(int rBase, int reg1, int reg2, int scale, int offset);
     void OpRegCopyWide(int dest_lo, int dest_hi, int src_lo, int src_hi);
-    void OpTlsCmp(int offset, int val);
+    void OpTlsCmp(ThreadOffset offset, int val);
 
     LIR* LoadBaseDispBody(int rBase, int displacement, int r_dest, int r_dest_hi, OpSize size,
                           int s_reg);
diff --git a/compiler/dex/quick/mips/fp_mips.cc b/compiler/dex/quick/mips/fp_mips.cc
index 320301726b..9e2fea94de 100644
--- a/compiler/dex/quick/mips/fp_mips.cc
+++ b/compiler/dex/quick/mips/fp_mips.cc
@@ -176,7 +176,7 @@ void MipsMir2Lir::GenConversion(Instruction::Code opcode, RegLocation rl_dest,
 void MipsMir2Lir::GenCmpFP(Instruction::Code opcode, RegLocation rl_dest,
                            RegLocation rl_src1, RegLocation rl_src2) {
   bool wide = true;
-  int offset = -1;  // Make gcc happy.
+  ThreadOffset offset(-1);
 
   switch (opcode) {
     case Instruction::CMPL_FLOAT:
diff --git a/compiler/dex/quick/mips/int_mips.cc b/compiler/dex/quick/mips/int_mips.cc
index bd044c66bd..4a48c87ed9 100644
--- a/compiler/dex/quick/mips/int_mips.cc
+++ b/compiler/dex/quick/mips/int_mips.cc
@@ -254,7 +254,7 @@ void MipsMir2Lir::OpLea(int rBase, int reg1, int reg2, int scale, int offset) {
   LOG(FATAL) << "Unexpected use of OpLea for Arm";
 }
 
-void MipsMir2Lir::OpTlsCmp(int offset, int val) {
+void MipsMir2Lir::OpTlsCmp(ThreadOffset offset, int val) {
   LOG(FATAL) << "Unexpected use of OpTlsCmp for Arm";
 }
 
@@ -579,7 +579,7 @@ void MipsMir2Lir::GenArrayObjPut(int opt_flags, RegLocation rl_array,
 
   // Get the array's class.
   LoadWordDisp(r_array, mirror::Object::ClassOffset().Int32Value(), r_array_class);
-  CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(pCanPutArrayElementFromCode), r_value,
+  CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(pCanPutArrayElement), r_value,
                           r_array_class, true);
   // Redo LoadValues in case they didn't survive the call.
   LoadValueDirectFixed(rl_array, r_array);  // Reload array
diff --git a/compiler/dex/quick/mips/target_mips.cc b/compiler/dex/quick/mips/target_mips.cc
index 0a17fb1078..7a9e91a994 100644
--- a/compiler/dex/quick/mips/target_mips.cc
+++ b/compiler/dex/quick/mips/target_mips.cc
@@ -505,8 +505,8 @@ void MipsMir2Lir::FreeRegLocTemps(RegLocation rl_keep, RegLocation rl_free) {
  * ensure that all branch instructions can be restarted if
  * there is a trap in the shadow.  Allocate a temp register.
  */
-int MipsMir2Lir::LoadHelper(int offset) {
-  LoadWordDisp(rMIPS_SELF, offset, r_T9);
+int MipsMir2Lir::LoadHelper(ThreadOffset offset) {
+  LoadWordDisp(rMIPS_SELF, offset.Int32Value(), r_T9);
   return r_T9;
 }
 
diff --git a/compiler/dex/quick/mips/utility_mips.cc b/compiler/dex/quick/mips/utility_mips.cc
index 68b26f1936..5d9ae33921 100644
--- a/compiler/dex/quick/mips/utility_mips.cc
+++ b/compiler/dex/quick/mips/utility_mips.cc
@@ -632,7 +632,7 @@ LIR* MipsMir2Lir::StoreBaseDispWide(int rBase, int displacement,
   return StoreBaseDispBody(rBase, displacement, r_src_lo, r_src_hi, kLong);
 }
 
-LIR* MipsMir2Lir::OpThreadMem(OpKind op, int thread_offset) {
+LIR* MipsMir2Lir::OpThreadMem(OpKind op, ThreadOffset thread_offset) {
   LOG(FATAL) << "Unexpected use of OpThreadMem for MIPS";
   return NULL;
 }
diff --git a/compiler/dex/quick/mir_to_lir.h b/compiler/dex/quick/mir_to_lir.h
index a34e9295e9..2794bf5e5b 100644
--- a/compiler/dex/quick/mir_to_lir.h
+++ b/compiler/dex/quick/mir_to_lir.h
@@ -424,42 +424,42 @@ class Mir2Lir : public Backend {
                           RegLocation rl_src, int lit);
     void GenArithOpLong(Instruction::Code opcode, RegLocation rl_dest,
                         RegLocation rl_src1, RegLocation rl_src2);
-    void GenConversionCall(int func_offset, RegLocation rl_dest,
+    void GenConversionCall(ThreadOffset func_offset, RegLocation rl_dest,
                            RegLocation rl_src);
     void GenSuspendTest(int opt_flags);
     void GenSuspendTestAndBranch(int opt_flags, LIR* target);
 
     // Shared by all targets - implemented in gen_invoke.cc.
-    int CallHelperSetup(int helper_offset);
-    LIR* CallHelper(int r_tgt, int helper_offset, bool safepoint_pc);
-    void CallRuntimeHelperImm(int helper_offset, int arg0, bool safepoint_pc);
-    void CallRuntimeHelperReg(int helper_offset, int arg0, bool safepoint_pc);
-    void CallRuntimeHelperRegLocation(int helper_offset, RegLocation arg0,
-                                       bool safepoint_pc);
-    void CallRuntimeHelperImmImm(int helper_offset, int arg0, int arg1,
+    int CallHelperSetup(ThreadOffset helper_offset);
+    LIR* CallHelper(int r_tgt, ThreadOffset helper_offset, bool safepoint_pc);
+    void CallRuntimeHelperImm(ThreadOffset helper_offset, int arg0, bool safepoint_pc);
+    void CallRuntimeHelperReg(ThreadOffset helper_offset, int arg0, bool safepoint_pc);
+    void CallRuntimeHelperRegLocation(ThreadOffset helper_offset, RegLocation arg0,
+                                      bool safepoint_pc);
+    void CallRuntimeHelperImmImm(ThreadOffset helper_offset, int arg0, int arg1,
                                  bool safepoint_pc);
-    void CallRuntimeHelperImmRegLocation(int helper_offset, int arg0,
+    void CallRuntimeHelperImmRegLocation(ThreadOffset helper_offset, int arg0,
                                          RegLocation arg1, bool safepoint_pc);
-    void CallRuntimeHelperRegLocationImm(int helper_offset, RegLocation arg0,
+    void CallRuntimeHelperRegLocationImm(ThreadOffset helper_offset, RegLocation arg0,
                                          int arg1, bool safepoint_pc);
-    void CallRuntimeHelperImmReg(int helper_offset, int arg0, int arg1,
+    void CallRuntimeHelperImmReg(ThreadOffset helper_offset, int arg0, int arg1,
                                  bool safepoint_pc);
-    void CallRuntimeHelperRegImm(int helper_offset, int arg0, int arg1,
+    void CallRuntimeHelperRegImm(ThreadOffset helper_offset, int arg0, int arg1,
                                  bool safepoint_pc);
-    void CallRuntimeHelperImmMethod(int helper_offset, int arg0,
+    void CallRuntimeHelperImmMethod(ThreadOffset helper_offset, int arg0,
                                     bool safepoint_pc);
-    void CallRuntimeHelperRegLocationRegLocation(int helper_offset,
+    void CallRuntimeHelperRegLocationRegLocation(ThreadOffset helper_offset,
                                                  RegLocation arg0, RegLocation arg1,
                                                  bool safepoint_pc);
-    void CallRuntimeHelperRegReg(int helper_offset, int arg0, int arg1,
+    void CallRuntimeHelperRegReg(ThreadOffset helper_offset, int arg0, int arg1,
                                  bool safepoint_pc);
-    void CallRuntimeHelperRegRegImm(int helper_offset, int arg0, int arg1,
+    void CallRuntimeHelperRegRegImm(ThreadOffset helper_offset, int arg0, int arg1,
                                     int arg2, bool safepoint_pc);
-    void CallRuntimeHelperImmMethodRegLocation(int helper_offset, int arg0,
+    void CallRuntimeHelperImmMethodRegLocation(ThreadOffset helper_offset, int arg0,
                                                RegLocation arg2, bool safepoint_pc);
-    void CallRuntimeHelperImmMethodImm(int helper_offset, int arg0, int arg2,
+    void CallRuntimeHelperImmMethodImm(ThreadOffset helper_offset, int arg0, int arg2,
                                        bool safepoint_pc);
-    void CallRuntimeHelperImmRegLocationRegLocation(int helper_offset,
+    void CallRuntimeHelperImmRegLocationRegLocation(ThreadOffset helper_offset,
                                                     int arg0, RegLocation arg1, RegLocation arg2,
                                                     bool safepoint_pc);
     void GenInvoke(CallInfo* info);
@@ -526,7 +526,7 @@ class Mir2Lir : public Backend {
     // Required for target - codegen helpers.
     virtual bool SmallLiteralDivide(Instruction::Code dalvik_opcode,
                                     RegLocation rl_src, RegLocation rl_dest, int lit) = 0;
-    virtual int LoadHelper(int offset) = 0;
+    virtual int LoadHelper(ThreadOffset offset) = 0;
     virtual LIR* LoadBaseDisp(int rBase, int displacement, int r_dest, OpSize size, int s_reg) = 0;
     virtual LIR* LoadBaseDispWide(int rBase, int displacement, int r_dest_lo, int r_dest_hi,
                                   int s_reg) = 0;
@@ -674,14 +674,14 @@ class Mir2Lir : public Backend {
     virtual LIR* OpRegRegReg(OpKind op, int r_dest, int r_src1,
                              int r_src2) = 0;
     virtual LIR* OpTestSuspend(LIR* target) = 0;
-    virtual LIR* OpThreadMem(OpKind op, int thread_offset) = 0;
+    virtual LIR* OpThreadMem(OpKind op, ThreadOffset thread_offset) = 0;
     virtual LIR* OpVldm(int rBase, int count) = 0;
     virtual LIR* OpVstm(int rBase, int count) = 0;
     virtual void OpLea(int rBase, int reg1, int reg2, int scale,
                        int offset) = 0;
     virtual void OpRegCopyWide(int dest_lo, int dest_hi, int src_lo,
                                int src_hi) = 0;
-    virtual void OpTlsCmp(int offset, int val) = 0;
+    virtual void OpTlsCmp(ThreadOffset offset, int val) = 0;
     virtual bool InexpensiveConstantInt(int32_t value) = 0;
     virtual bool InexpensiveConstantFloat(int32_t value) = 0;
     virtual bool InexpensiveConstantLong(int64_t value) = 0;
diff --git a/compiler/dex/quick/x86/call_x86.cc b/compiler/dex/quick/x86/call_x86.cc
index 1c395def55..6e3e55fc4e 100644
--- a/compiler/dex/quick/x86/call_x86.cc
+++ b/compiler/dex/quick/x86/call_x86.cc
@@ -148,7 +148,7 @@ void X86Mir2Lir::GenFillArrayData(uint32_t table_offset, RegLocation rl_src) {
   NewLIR1(kX86StartOfMethod, rX86_ARG2);
   NewLIR2(kX86PcRelAdr, rX86_ARG1, reinterpret_cast<uintptr_t>(tab_rec));
   NewLIR2(kX86Add32RR, rX86_ARG1, rX86_ARG2);
-  CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(pHandleFillArrayDataFromCode), rX86_ARG0,
+  CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(pHandleFillArrayData), rX86_ARG0,
                           rX86_ARG1, true);
 }
 
@@ -165,7 +165,7 @@ void X86Mir2Lir::GenMonitorEnter(int opt_flags, RegLocation rl_src) {
   NewLIR3(kX86LockCmpxchgMR, rCX, mirror::Object::MonitorOffset().Int32Value(), rDX);
   LIR* branch = NewLIR2(kX86Jcc8, 0, kX86CondEq);
   // If lock is held, go the expensive route - artLockObjectFromCode(self, obj);
-  CallRuntimeHelperReg(QUICK_ENTRYPOINT_OFFSET(pLockObjectFromCode), rCX, true);
+  CallRuntimeHelperReg(QUICK_ENTRYPOINT_OFFSET(pLockObject), rCX, true);
   branch->target = NewLIR0(kPseudoTargetLabel);
 }
 
@@ -185,7 +185,7 @@ void X86Mir2Lir::GenMonitorExit(int opt_flags, RegLocation rl_src) {
   LIR* branch2 = NewLIR1(kX86Jmp8, 0);
   branch->target = NewLIR0(kPseudoTargetLabel);
   // Otherwise, go the expensive route - UnlockObjectFromCode(obj);
-  CallRuntimeHelperReg(QUICK_ENTRYPOINT_OFFSET(pUnlockObjectFromCode), rAX, true);
+  CallRuntimeHelperReg(QUICK_ENTRYPOINT_OFFSET(pUnlockObject), rAX, true);
   branch2->target = NewLIR0(kPseudoTargetLabel);
 }
 
@@ -243,7 +243,7 @@ void X86Mir2Lir::GenEntrySequence(RegLocation* ArgLocs, RegLocation rl_method) {
   if (!skip_overflow_check) {
     // cmp rX86_SP, fs:[stack_end_]; jcc throw_launchpad
     LIR* tgt = RawLIR(0, kPseudoThrowTarget, kThrowStackOverflow, 0, 0, 0, 0);
-    OpRegThreadMem(kOpCmp, rX86_SP, Thread::StackEndOffset().Int32Value());
+    OpRegThreadMem(kOpCmp, rX86_SP, Thread::StackEndOffset());
     OpCondBranch(kCondUlt, tgt);
     // Remember branch target - will process later
     throw_launchpads_.Insert(tgt);
diff --git a/compiler/dex/quick/x86/codegen_x86.h b/compiler/dex/quick/x86/codegen_x86.h
index edb5ae57c2..21328d5440 100644
--- a/compiler/dex/quick/x86/codegen_x86.h
+++ b/compiler/dex/quick/x86/codegen_x86.h
@@ -29,7 +29,7 @@ class X86Mir2Lir : public Mir2Lir {
     // Required for target - codegen helpers.
     bool SmallLiteralDivide(Instruction::Code dalvik_opcode, RegLocation rl_src,
                                     RegLocation rl_dest, int lit);
-    int LoadHelper(int offset);
+    int LoadHelper(ThreadOffset offset);
     LIR* LoadBaseDisp(int rBase, int displacement, int r_dest, OpSize size, int s_reg);
     LIR* LoadBaseDispWide(int rBase, int displacement, int r_dest_lo, int r_dest_hi,
                                   int s_reg);
@@ -154,14 +154,14 @@ class X86Mir2Lir : public Mir2Lir {
     LIR* OpRegRegImm(OpKind op, int r_dest, int r_src1, int value);
     LIR* OpRegRegReg(OpKind op, int r_dest, int r_src1, int r_src2);
     LIR* OpTestSuspend(LIR* target);
-    LIR* OpThreadMem(OpKind op, int thread_offset);
+    LIR* OpThreadMem(OpKind op, ThreadOffset thread_offset);
     LIR* OpVldm(int rBase, int count);
     LIR* OpVstm(int rBase, int count);
     void OpLea(int rBase, int reg1, int reg2, int scale, int offset);
     void OpRegCopyWide(int dest_lo, int dest_hi, int src_lo, int src_hi);
-    void OpTlsCmp(int offset, int val);
+    void OpTlsCmp(ThreadOffset offset, int val);
 
-    void OpRegThreadMem(OpKind op, int r_dest, int thread_offset);
+    void OpRegThreadMem(OpKind op, int r_dest, ThreadOffset thread_offset);
     void SpillCoreRegs();
     void UnSpillCoreRegs();
     static const X86EncodingMap EncodingMap[kX86Last];
diff --git a/compiler/dex/quick/x86/int_x86.cc b/compiler/dex/quick/x86/int_x86.cc
index 0b4b4be04e..377d134c80 100644
--- a/compiler/dex/quick/x86/int_x86.cc
+++ b/compiler/dex/quick/x86/int_x86.cc
@@ -240,8 +240,8 @@ void X86Mir2Lir::OpLea(int rBase, int reg1, int reg2, int scale, int offset) {
   NewLIR5(kX86Lea32RA, rBase, reg1, reg2, scale, offset);
 }
 
-void X86Mir2Lir::OpTlsCmp(int offset, int val) {
-  NewLIR2(kX86Cmp16TI8, offset, val);
+void X86Mir2Lir::OpTlsCmp(ThreadOffset offset, int val) {
+  NewLIR2(kX86Cmp16TI8, offset.Int32Value(), val);
 }
 
 bool X86Mir2Lir::GenInlinedCas32(CallInfo* info, bool need_write_barrier) {
@@ -285,7 +285,7 @@ void X86Mir2Lir::GenDivZeroCheck(int reg_lo, int reg_hi) {
 
 // Test suspend flag, return target of taken suspend branch
 LIR* X86Mir2Lir::OpTestSuspend(LIR* target) {
-  OpTlsCmp(Thread::ThreadFlagsOffset().Int32Value(), 0);
+  OpTlsCmp(Thread::ThreadFlagsOffset(), 0);
   return OpCondBranch((target == NULL) ? kCondNe : kCondEq, target);
 }
 
@@ -403,7 +403,7 @@ void X86Mir2Lir::GenNegLong(RegLocation rl_dest, RegLocation rl_src) {
   StoreValueWide(rl_dest, rl_result);
 }
 
-void X86Mir2Lir::OpRegThreadMem(OpKind op, int r_dest, int thread_offset) {
+void X86Mir2Lir::OpRegThreadMem(OpKind op, int r_dest, ThreadOffset thread_offset) {
   X86OpCode opcode = kX86Bkpt;
   switch (op) {
   case kOpCmp: opcode = kX86Cmp32RT;  break;
@@ -412,7 +412,7 @@ void X86Mir2Lir::OpRegThreadMem(OpKind op, int r_dest, int thread_offset) {
     LOG(FATAL) << "Bad opcode: " << op;
     break;
   }
-  NewLIR2(opcode, r_dest, thread_offset);
+  NewLIR2(opcode, r_dest, thread_offset.Int32Value());
 }
 
 /*
@@ -532,7 +532,7 @@ void X86Mir2Lir::GenArrayObjPut(int opt_flags, RegLocation rl_array,
 
   // Get the array's class.
   LoadWordDisp(r_array, mirror::Object::ClassOffset().Int32Value(), r_array_class);
-  CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(pCanPutArrayElementFromCode), r_value,
+  CallRuntimeHelperRegReg(QUICK_ENTRYPOINT_OFFSET(pCanPutArrayElement), r_value,
                           r_array_class, true);
   // Redo LoadValues in case they didn't survive the call.
   LoadValueDirectFixed(rl_array, r_array);  // Reload array
diff --git a/compiler/dex/quick/x86/target_x86.cc b/compiler/dex/quick/x86/target_x86.cc
index 2c9b3c837c..699f3ae5bb 100644
--- a/compiler/dex/quick/x86/target_x86.cc
+++ b/compiler/dex/quick/x86/target_x86.cc
@@ -524,7 +524,7 @@ Mir2Lir* X86CodeGenerator(CompilationUnit* const cu, MIRGraph* const mir_graph,
 }
 
 // Not used in x86
-int X86Mir2Lir::LoadHelper(int offset) {
+int X86Mir2Lir::LoadHelper(ThreadOffset offset) {
   LOG(FATAL) << "Unexpected use of LoadHelper in x86";
   return INVALID_REG;
 }
diff --git a/compiler/dex/quick/x86/utility_x86.cc b/compiler/dex/quick/x86/utility_x86.cc
index e15995fef4..c519bfec44 100644
--- a/compiler/dex/quick/x86/utility_x86.cc
+++ b/compiler/dex/quick/x86/utility_x86.cc
@@ -292,7 +292,7 @@ LIR* X86Mir2Lir::OpRegRegImm(OpKind op, int r_dest, int r_src,
   return OpRegImm(op, r_dest, value);
 }
 
-LIR* X86Mir2Lir::OpThreadMem(OpKind op, int thread_offset) {
+LIR* X86Mir2Lir::OpThreadMem(OpKind op, ThreadOffset thread_offset) {
   X86OpCode opcode = kX86Bkpt;
   switch (op) {
     case kOpBlx: opcode = kX86CallT;  break;
@@ -300,7 +300,7 @@ LIR* X86Mir2Lir::OpThreadMem(OpKind op, int thread_offset) {
       LOG(FATAL) << "Bad opcode: " << op;
       break;
   }
-  return NewLIR1(opcode, thread_offset);
+  return NewLIR1(opcode, thread_offset.Int32Value());
 }
 
 LIR* X86Mir2Lir::OpMem(OpKind op, int rBase, int disp) {
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 38d00a0804..8b09df7e92 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -41,9 +41,9 @@
 #include "mirror/throwable.h"
 #include "scoped_thread_state_change.h"
 #include "ScopedLocalRef.h"
-#include "stubs/stubs.h"
 #include "thread.h"
 #include "thread_pool.h"
+#include "trampolines/trampoline_compiler.h"
 #include "verifier/method_verifier.h"
 
 #if defined(ART_USE_PORTABLE_COMPILER)
@@ -433,64 +433,38 @@ CompilerTls* CompilerDriver::GetTls() {
   return res;
 }
 
+const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToInterpreterBridge() const {
+  return CreateTrampoline(instruction_set_, kInterpreterAbi,
+                          INTERPRETER_ENTRYPOINT_OFFSET(pInterpreterToInterpreterBridge));
+}
+
+const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToCompiledCodeBridge() const {
+  return CreateTrampoline(instruction_set_, kInterpreterAbi,
+                          INTERPRETER_ENTRYPOINT_OFFSET(pInterpreterToCompiledCodeBridge));
+}
+
+const std::vector<uint8_t>* CompilerDriver::CreateJniDlsymLookup() const {
+  return CreateTrampoline(instruction_set_, kJniAbi, JNI_ENTRYPOINT_OFFSET(pDlsymLookup));
+}
+
 const std::vector<uint8_t>* CompilerDriver::CreatePortableResolutionTrampoline() const {
-  switch (instruction_set_) {
-    case kArm:
-    case kThumb2:
-      return arm::CreatePortableResolutionTrampoline();
-    case kMips:
-      return mips::CreatePortableResolutionTrampoline();
-    case kX86:
-      return x86::CreatePortableResolutionTrampoline();
-    default:
-      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
-      return NULL;
-  }
+  return CreateTrampoline(instruction_set_, kPortableAbi,
+                          PORTABLE_ENTRYPOINT_OFFSET(pPortableResolutionTrampoline));
 }
 
-const std::vector<uint8_t>* CompilerDriver::CreateQuickResolutionTrampoline() const {
-  switch (instruction_set_) {
-    case kArm:
-    case kThumb2:
-      return arm::CreateQuickResolutionTrampoline();
-    case kMips:
-      return mips::CreateQuickResolutionTrampoline();
-    case kX86:
-      return x86::CreateQuickResolutionTrampoline();
-    default:
-      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
-      return NULL;
-  }
+const std::vector<uint8_t>* CompilerDriver::CreatePortableToInterpreterBridge() const {
+  return CreateTrampoline(instruction_set_, kPortableAbi,
+                          PORTABLE_ENTRYPOINT_OFFSET(pPortableToInterpreterBridge));
 }
 
-const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToInterpreterEntry() const {
-  switch (instruction_set_) {
-    case kArm:
-    case kThumb2:
-      return arm::CreateInterpreterToInterpreterEntry();
-    case kMips:
-      return mips::CreateInterpreterToInterpreterEntry();
-    case kX86:
-      return x86::CreateInterpreterToInterpreterEntry();
-    default:
-      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
-      return NULL;
-  }
+const std::vector<uint8_t>* CompilerDriver::CreateQuickResolutionTrampoline() const {
+  return CreateTrampoline(instruction_set_, kQuickAbi,
+                          QUICK_ENTRYPOINT_OFFSET(pQuickResolutionTrampoline));
 }
 
-const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToQuickEntry() const {
-  switch (instruction_set_) {
-    case kArm:
-    case kThumb2:
-      return arm::CreateInterpreterToQuickEntry();
-    case kMips:
-      return mips::CreateInterpreterToQuickEntry();
-    case kX86:
-      return x86::CreateInterpreterToQuickEntry();
-    default:
-      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
-      return NULL;
-  }
+const std::vector<uint8_t>* CompilerDriver::CreateQuickToInterpreterBridge() const {
+  return CreateTrampoline(instruction_set_, kQuickAbi,
+                          QUICK_ENTRYPOINT_OFFSET(pQuickToInterpreterBridge));
 }
 
 void CompilerDriver::CompileAll(jobject class_loader,
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index 18f852dc6f..b5222c99b8 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -48,6 +48,17 @@ enum CompilerBackend {
   kNoBackend
 };
 
+enum EntryPointCallingConvention {
+  // ABI of invocations to a method's interpreter entry point.
+  kInterpreterAbi,
+  // ABI of calls to a method's native code, only used for native methods.
+  kJniAbi,
+  // ABI of calls to a method's portable code entry point.
+  kPortableAbi,
+  // ABI of calls to a method's quick code entry point.
+  kQuickAbi
+};
+
 enum DexToDexCompilationLevel {
   kDontDexToDexCompile,   // Only meaning wrt image time interpretation.
   kRequired,              // Dex-to-dex compilation required for correctness.
@@ -110,13 +121,19 @@ class CompilerDriver {
   CompilerTls* GetTls();
 
   // Generate the trampolines that are invoked by unresolved direct methods.
+  const std::vector<uint8_t>* CreateInterpreterToInterpreterBridge() const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  const std::vector<uint8_t>* CreateInterpreterToCompiledCodeBridge() const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  const std::vector<uint8_t>* CreateJniDlsymLookup() const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   const std::vector<uint8_t>* CreatePortableResolutionTrampoline() const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  const std::vector<uint8_t>* CreateQuickResolutionTrampoline() const
+  const std::vector<uint8_t>* CreatePortableToInterpreterBridge() const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  const std::vector<uint8_t>* CreateInterpreterToInterpreterEntry() const
+  const std::vector<uint8_t>* CreateQuickResolutionTrampoline() const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  const std::vector<uint8_t>* CreateInterpreterToQuickEntry() const
+  const std::vector<uint8_t>* CreateQuickToInterpreterBridge() const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   CompiledClass* GetCompiledClass(ClassReference ref) const
diff --git a/compiler/image_writer.cc b/compiler/image_writer.cc
index e73d021c0c..550d642753 100644
--- a/compiler/image_writer.cc
+++ b/compiler/image_writer.cc
@@ -90,11 +90,23 @@ bool ImageWriter::Write(const std::string& image_filename,
     return false;
   }
   class_linker->RegisterOatFile(*oat_file_);
-  interpreter_to_interpreter_entry_offset_ = oat_file_->GetOatHeader().GetInterpreterToInterpreterEntryOffset();
-  interpreter_to_quick_entry_offset_ = oat_file_->GetOatHeader().GetInterpreterToQuickEntryOffset();
-  portable_resolution_trampoline_offset_ = oat_file_->GetOatHeader().GetPortableResolutionTrampolineOffset();
-  quick_resolution_trampoline_offset_ = oat_file_->GetOatHeader().GetQuickResolutionTrampolineOffset();
 
+  interpreter_to_interpreter_bridge_offset_ =
+      oat_file_->GetOatHeader().GetInterpreterToInterpreterBridgeOffset();
+  interpreter_to_compiled_code_bridge_offset_ =
+      oat_file_->GetOatHeader().GetInterpreterToCompiledCodeBridgeOffset();
+
+  jni_dlsym_lookup_offset_ = oat_file_->GetOatHeader().GetJniDlsymLookupOffset();
+
+  portable_resolution_trampoline_offset_ =
+      oat_file_->GetOatHeader().GetPortableResolutionTrampolineOffset();
+  portable_to_interpreter_bridge_offset_ =
+      oat_file_->GetOatHeader().GetPortableToInterpreterBridgeOffset();
+
+  quick_resolution_trampoline_offset_ =
+      oat_file_->GetOatHeader().GetQuickResolutionTrampolineOffset();
+  quick_to_interpreter_bridge_offset_ =
+      oat_file_->GetOatHeader().GetQuickToInterpreterBridgeOffset();
   {
     Thread::Current()->TransitionFromSuspendedToRunnable();
     PruneNonImageClasses();  // Remove junk
@@ -490,57 +502,62 @@ void ImageWriter::FixupClass(const Class* orig, Class* copy) {
 void ImageWriter::FixupMethod(const AbstractMethod* orig, AbstractMethod* copy) {
   FixupInstanceFields(orig, copy);
 
-  // OatWriter replaces the code_ with an offset value.
-  // Here we readjust to a pointer relative to oat_begin_
-  if (orig->IsAbstract()) {
-    // Code for abstract methods is set to the abstract method error stub when we load the image.
-    copy->SetEntryPointFromCompiledCode(NULL);
-    copy->SetEntryPointFromInterpreter(reinterpret_cast<EntryPointFromInterpreter*>
-                                       (GetOatAddress(interpreter_to_interpreter_entry_offset_)));
-    return;
-  } else {
-    copy->SetEntryPointFromInterpreter(reinterpret_cast<EntryPointFromInterpreter*>
-                                       (GetOatAddress(interpreter_to_quick_entry_offset_)));
-  }
+  // OatWriter replaces the code_ with an offset value. Here we re-adjust to a pointer relative to
+  // oat_begin_
 
-  if (orig == Runtime::Current()->GetResolutionMethod()) {
+  // The resolution method has a special trampoline to call.
+  if (UNLIKELY(orig == Runtime::Current()->GetResolutionMethod())) {
 #if defined(ART_USE_PORTABLE_COMPILER)
     copy->SetEntryPointFromCompiledCode(GetOatAddress(portable_resolution_trampoline_offset_));
 #else
     copy->SetEntryPointFromCompiledCode(GetOatAddress(quick_resolution_trampoline_offset_));
 #endif
-    return;
-  }
-
-  // Use original code if it exists. Otherwise, set the code pointer to the resolution trampoline.
-  const byte* code = GetOatAddress(orig->GetOatCodeOffset());
-  if (code != NULL) {
-    copy->SetEntryPointFromCompiledCode(code);
   } else {
+    // We assume all methods have code. If they don't currently then we set them to the use the
+    // resolution trampoline. Abstract methods never have code and so we need to make sure their
+    // use results in an AbstractMethodError. We use the interpreter to achieve this.
+    if (UNLIKELY(orig->IsAbstract())) {
 #if defined(ART_USE_PORTABLE_COMPILER)
-    copy->SetEntryPointFromCompiledCode(GetOatAddress(portable_resolution_trampoline_offset_));
+      copy->SetEntryPointFromCompiledCode(GetOatAddress(portable_to_interpreter_bridge_offset_));
 #else
-    copy->SetEntryPointFromCompiledCode(GetOatAddress(quick_resolution_trampoline_offset_));
+      copy->SetEntryPointFromCompiledCode(GetOatAddress(quick_to_interpreter_bridge_offset_));
 #endif
-  }
-
-  if (orig->IsNative()) {
-    // The native method's pointer is set to a stub to lookup via dlsym when we load the image.
-    // Note this is not the code_ pointer, that is handled above.
-    copy->SetNativeMethod(NULL);
-  } else {
-    // normal (non-abstract non-native) methods have mapping tables to relocate
-    uint32_t mapping_table_off = orig->GetOatMappingTableOffset();
-    const byte* mapping_table = GetOatAddress(mapping_table_off);
-    copy->SetMappingTable(reinterpret_cast<const uint32_t*>(mapping_table));
-
-    uint32_t vmap_table_offset = orig->GetOatVmapTableOffset();
-    const byte* vmap_table = GetOatAddress(vmap_table_offset);
-    copy->SetVmapTable(reinterpret_cast<const uint16_t*>(vmap_table));
-
-    uint32_t native_gc_map_offset = orig->GetOatNativeGcMapOffset();
-    const byte* native_gc_map = GetOatAddress(native_gc_map_offset);
-    copy->SetNativeGcMap(reinterpret_cast<const uint8_t*>(native_gc_map));
+      copy->SetEntryPointFromInterpreter(reinterpret_cast<EntryPointFromInterpreter*>
+      (GetOatAddress(interpreter_to_interpreter_bridge_offset_)));
+    } else {
+      copy->SetEntryPointFromInterpreter(reinterpret_cast<EntryPointFromInterpreter*>
+      (GetOatAddress(interpreter_to_compiled_code_bridge_offset_)));
+      // Use original code if it exists. Otherwise, set the code pointer to the resolution
+      // trampoline.
+      const byte* code = GetOatAddress(orig->GetOatCodeOffset());
+      if (code != NULL) {
+        copy->SetEntryPointFromCompiledCode(code);
+      } else {
+#if defined(ART_USE_PORTABLE_COMPILER)
+        copy->SetEntryPointFromCompiledCode(GetOatAddress(portable_resolution_trampoline_offset_));
+#else
+        copy->SetEntryPointFromCompiledCode(GetOatAddress(quick_resolution_trampoline_offset_));
+#endif
+      }
+      if (orig->IsNative()) {
+        // The native method's pointer is set to a stub to lookup via dlsym.
+        // Note this is not the code_ pointer, that is handled above.
+        copy->SetNativeMethod(GetOatAddress(jni_dlsym_lookup_offset_));
+      } else {
+        // Normal (non-abstract non-native) methods have various tables to relocate.
+        uint32_t mapping_table_off = orig->GetOatMappingTableOffset();
+        const byte* mapping_table = GetOatAddress(mapping_table_off);
+        copy->SetMappingTable(reinterpret_cast<const uint32_t*>(mapping_table));
+
+        uint32_t vmap_table_offset = orig->GetOatVmapTableOffset();
+        const byte* vmap_table = GetOatAddress(vmap_table_offset);
+        copy->SetVmapTable(reinterpret_cast<const uint16_t*>(vmap_table));
+
+        uint32_t native_gc_map_offset = orig->GetOatNativeGcMapOffset();
+        const byte* native_gc_map = GetOatAddress(native_gc_map_offset);
+        copy->SetNativeGcMap(reinterpret_cast<const uint8_t*>(native_gc_map));
+      }
+    }
   }
 }
 
diff --git a/compiler/image_writer.h b/compiler/image_writer.h
index e43ec6338f..545534fff7 100644
--- a/compiler/image_writer.h
+++ b/compiler/image_writer.h
@@ -39,8 +39,8 @@ class ImageWriter {
  public:
   explicit ImageWriter(const CompilerDriver& compiler_driver)
       : compiler_driver_(compiler_driver), oat_file_(NULL), image_end_(0), image_begin_(NULL),
-        oat_data_begin_(NULL), interpreter_to_interpreter_entry_offset_(0),
-        interpreter_to_quick_entry_offset_(0), portable_resolution_trampoline_offset_(0),
+        oat_data_begin_(NULL), interpreter_to_interpreter_bridge_offset_(0),
+        interpreter_to_compiled_code_bridge_offset_(0), portable_resolution_trampoline_offset_(0),
         quick_resolution_trampoline_offset_(0) {}
 
   ~ImageWriter() {}
@@ -195,10 +195,13 @@ class ImageWriter {
   const byte* oat_data_begin_;
 
   // Offset from oat_data_begin_ to the stubs.
-  uint32_t interpreter_to_interpreter_entry_offset_;
-  uint32_t interpreter_to_quick_entry_offset_;
+  uint32_t interpreter_to_interpreter_bridge_offset_;
+  uint32_t interpreter_to_compiled_code_bridge_offset_;
+  uint32_t jni_dlsym_lookup_offset_;
   uint32_t portable_resolution_trampoline_offset_;
+  uint32_t portable_to_interpreter_bridge_offset_;
   uint32_t quick_resolution_trampoline_offset_;
+  uint32_t quick_to_interpreter_bridge_offset_;
 
   // DexCaches seen while scanning for fixing up CodeAndDirectMethods
   typedef std::set<mirror::DexCache*> Set;
diff --git a/compiler/jni/quick/jni_compiler.cc b/compiler/jni/quick/jni_compiler.cc
index b069fbd4a1..9713fe9da9 100644
--- a/compiler/jni/quick/jni_compiler.cc
+++ b/compiler/jni/quick/jni_compiler.cc
@@ -172,8 +172,8 @@ CompiledMethod* ArtJniCompileMethodInternal(CompilerDriver& compiler,
   //    can occur. The result is the saved JNI local state that is restored by the exit call. We
   //    abuse the JNI calling convention here, that is guaranteed to support passing 2 pointer
   //    arguments.
-  uintptr_t jni_start = is_synchronized ? QUICK_ENTRYPOINT_OFFSET(pJniMethodStartSynchronized)
-                                        : QUICK_ENTRYPOINT_OFFSET(pJniMethodStart);
+  ThreadOffset jni_start = is_synchronized ? QUICK_ENTRYPOINT_OFFSET(pJniMethodStartSynchronized)
+                                           : QUICK_ENTRYPOINT_OFFSET(pJniMethodStart);
   main_jni_conv->ResetIterator(FrameOffset(main_out_arg_size));
   FrameOffset locked_object_sirt_offset(0);
   if (is_synchronized) {
@@ -301,7 +301,7 @@ CompiledMethod* ArtJniCompileMethodInternal(CompilerDriver& compiler,
   // 12. Call into JNI method end possibly passing a returned reference, the method and the current
   //     thread.
   end_jni_conv->ResetIterator(FrameOffset(end_out_arg_size));
-  uintptr_t jni_end;
+  ThreadOffset jni_end(-1);
   if (reference_return) {
     // Pass result.
     jni_end = is_synchronized ? QUICK_ENTRYPOINT_OFFSET(pJniMethodEndWithReferenceSynchronized)
diff --git a/compiler/oat_writer.cc b/compiler/oat_writer.cc
index 5eb837b25c..21c5317b69 100644
--- a/compiler/oat_writer.cc
+++ b/compiler/oat_writer.cc
@@ -51,11 +51,14 @@ OatWriter::OatWriter(const std::vector<const DexFile*>& dex_files,
     size_oat_header_(0),
     size_oat_header_image_file_location_(0),
     size_dex_file_(0),
-    size_interpreter_to_interpreter_entry_(0),
-    size_interpreter_to_quick_entry_(0),
+    size_interpreter_to_interpreter_bridge_(0),
+    size_interpreter_to_compiled_code_bridge_(0),
+    size_jni_dlsym_lookup_(0),
     size_portable_resolution_trampoline_(0),
+    size_portable_to_interpreter_bridge_(0),
     size_quick_resolution_trampoline_(0),
-    size_stubs_alignment_(0),
+    size_quick_to_interpreter_bridge_(0),
+    size_trampoline_alignment_(0),
     size_code_size_(0),
     size_code_(0),
     size_code_alignment_(0),
@@ -176,30 +179,30 @@ size_t OatWriter::InitOatCode(size_t offset) {
   size_executable_offset_alignment_ = offset - old_offset;
   if (compiler_driver_->IsImage()) {
     InstructionSet instruction_set = compiler_driver_->GetInstructionSet();
-    oat_header_->SetInterpreterToInterpreterEntryOffset(offset);
-    interpreter_to_interpreter_entry_.reset(
-        compiler_driver_->CreateInterpreterToInterpreterEntry());
-    offset += interpreter_to_interpreter_entry_->size();
-
-    offset = CompiledCode::AlignCode(offset, instruction_set);
-    oat_header_->SetInterpreterToQuickEntryOffset(offset);
-    interpreter_to_quick_entry_.reset(compiler_driver_->CreateInterpreterToQuickEntry());
-    offset += interpreter_to_quick_entry_->size();
-
-    offset = CompiledCode::AlignCode(offset, instruction_set);
-    oat_header_->SetPortableResolutionTrampolineOffset(offset);
-    portable_resolution_trampoline_.reset(compiler_driver_->CreatePortableResolutionTrampoline());
-    offset += portable_resolution_trampoline_->size();
-
-    offset = CompiledCode::AlignCode(offset, instruction_set);
-    oat_header_->SetQuickResolutionTrampolineOffset(offset);
-    quick_resolution_trampoline_.reset(compiler_driver_->CreateQuickResolutionTrampoline());
-    offset += quick_resolution_trampoline_->size();
+
+    #define DO_TRAMPOLINE(field, fn_name) \
+      offset = CompiledCode::AlignCode(offset, instruction_set); \
+      oat_header_->Set ## fn_name ## Offset(offset); \
+      field.reset(compiler_driver_->Create ## fn_name()); \
+      offset += field->size();
+
+    DO_TRAMPOLINE(interpreter_to_interpreter_bridge_, InterpreterToInterpreterBridge);
+    DO_TRAMPOLINE(interpreter_to_compiled_code_bridge_, InterpreterToCompiledCodeBridge);
+    DO_TRAMPOLINE(jni_dlsym_lookup_, JniDlsymLookup);
+    DO_TRAMPOLINE(portable_resolution_trampoline_, PortableResolutionTrampoline);
+    DO_TRAMPOLINE(portable_to_interpreter_bridge_, PortableToInterpreterBridge);
+    DO_TRAMPOLINE(quick_resolution_trampoline_, QuickResolutionTrampoline);
+    DO_TRAMPOLINE(quick_to_interpreter_bridge_, QuickToInterpreterBridge);
+
+    #undef DO_TRAMPOLINE
   } else {
-    oat_header_->SetInterpreterToInterpreterEntryOffset(0);
-    oat_header_->SetInterpreterToQuickEntryOffset(0);
+    oat_header_->SetInterpreterToInterpreterBridgeOffset(0);
+    oat_header_->SetInterpreterToCompiledCodeBridgeOffset(0);
+    oat_header_->SetJniDlsymLookupOffset(0);
     oat_header_->SetPortableResolutionTrampolineOffset(0);
+    oat_header_->SetPortableToInterpreterBridgeOffset(0);
     oat_header_->SetQuickResolutionTrampolineOffset(0);
+    oat_header_->SetQuickToInterpreterBridgeOffset(0);
   }
   return offset;
 }
@@ -469,11 +472,14 @@ bool OatWriter::Write(OutputStream& out) {
     DO_STAT(size_oat_header_);
     DO_STAT(size_oat_header_image_file_location_);
     DO_STAT(size_dex_file_);
-    DO_STAT(size_interpreter_to_interpreter_entry_);
-    DO_STAT(size_interpreter_to_quick_entry_);
+    DO_STAT(size_interpreter_to_interpreter_bridge_);
+    DO_STAT(size_interpreter_to_compiled_code_bridge_);
+    DO_STAT(size_jni_dlsym_lookup_);
     DO_STAT(size_portable_resolution_trampoline_);
+    DO_STAT(size_portable_to_interpreter_bridge_);
     DO_STAT(size_quick_resolution_trampoline_);
-    DO_STAT(size_stubs_alignment_);
+    DO_STAT(size_quick_to_interpreter_bridge_);
+    DO_STAT(size_trampoline_alignment_);
     DO_STAT(size_code_size_);
     DO_STAT(size_code_);
     DO_STAT(size_code_alignment_);
@@ -545,52 +551,30 @@ size_t OatWriter::WriteCode(OutputStream& out, const size_t file_offset) {
   DCHECK_OFFSET();
   if (compiler_driver_->IsImage()) {
     InstructionSet instruction_set = compiler_driver_->GetInstructionSet();
-    if (!out.WriteFully(&(*interpreter_to_interpreter_entry_)[0],
-                        interpreter_to_interpreter_entry_->size())) {
-      PLOG(ERROR) << "Failed to write interpreter to interpreter entry to " << out.GetLocation();
-      return false;
-    }
-    size_interpreter_to_interpreter_entry_ += interpreter_to_interpreter_entry_->size();
-    relative_offset += interpreter_to_interpreter_entry_->size();
-    DCHECK_OFFSET();
-
-    uint32_t aligned_offset = CompiledCode::AlignCode(relative_offset, instruction_set);
-    uint32_t alignment_padding = aligned_offset - relative_offset;
-    out.Seek(alignment_padding, kSeekCurrent);
-    size_stubs_alignment_ += alignment_padding;
-    if (!out.WriteFully(&(*interpreter_to_quick_entry_)[0], interpreter_to_quick_entry_->size())) {
-      PLOG(ERROR) << "Failed to write interpreter to quick entry to " << out.GetLocation();
-      return false;
-    }
-    size_interpreter_to_quick_entry_ += interpreter_to_quick_entry_->size();
-    relative_offset += alignment_padding + interpreter_to_quick_entry_->size();
-    DCHECK_OFFSET();
 
-    aligned_offset = CompiledCode::AlignCode(relative_offset, instruction_set);
-    alignment_padding = aligned_offset - relative_offset;
-    out.Seek(alignment_padding, kSeekCurrent);
-    size_stubs_alignment_ += alignment_padding;
-    if (!out.WriteFully(&(*portable_resolution_trampoline_)[0],
-                        portable_resolution_trampoline_->size())) {
-      PLOG(ERROR) << "Failed to write portable resolution trampoline to " << out.GetLocation();
-      return false;
-    }
-    size_portable_resolution_trampoline_ += portable_resolution_trampoline_->size();
-    relative_offset += alignment_padding + portable_resolution_trampoline_->size();
-    DCHECK_OFFSET();
-
-    aligned_offset = CompiledCode::AlignCode(relative_offset, instruction_set);
-    alignment_padding = aligned_offset - relative_offset;
-    out.Seek(alignment_padding, kSeekCurrent);
-    size_stubs_alignment_ += alignment_padding;
-    if (!out.WriteFully(&(*quick_resolution_trampoline_)[0],
-                        quick_resolution_trampoline_->size())) {
-      PLOG(ERROR) << "Failed to write quick resolution trampoline to " << out.GetLocation();
-      return false;
-    }
-    size_quick_resolution_trampoline_ += quick_resolution_trampoline_->size();
-    relative_offset += alignment_padding + quick_resolution_trampoline_->size();
-    DCHECK_OFFSET();
+    #define DO_TRAMPOLINE(field) \
+      do { \
+        uint32_t aligned_offset = CompiledCode::AlignCode(relative_offset, instruction_set); \
+        uint32_t alignment_padding = aligned_offset - relative_offset; \
+        out.Seek(alignment_padding, kSeekCurrent); \
+        size_trampoline_alignment_ += alignment_padding; \
+        if (!out.WriteFully(&(*field)[0], field->size())) { \
+          PLOG(ERROR) << "Failed to write " # field " to " << out.GetLocation(); \
+          return false; \
+        } \
+        size_ ## field += field->size(); \
+        relative_offset += alignment_padding + field->size(); \
+        DCHECK_OFFSET(); \
+      } while (false)
+
+    DO_TRAMPOLINE(interpreter_to_interpreter_bridge_);
+    DO_TRAMPOLINE(interpreter_to_compiled_code_bridge_);
+    DO_TRAMPOLINE(jni_dlsym_lookup_);
+    DO_TRAMPOLINE(portable_resolution_trampoline_);
+    DO_TRAMPOLINE(portable_to_interpreter_bridge_);
+    DO_TRAMPOLINE(quick_resolution_trampoline_);
+    DO_TRAMPOLINE(quick_to_interpreter_bridge_);
+    #undef DO_TRAMPOLINE
   }
   return relative_offset;
 }
diff --git a/compiler/oat_writer.h b/compiler/oat_writer.h
index f2c5626b4d..e6cc0bce80 100644
--- a/compiler/oat_writer.h
+++ b/compiler/oat_writer.h
@@ -181,10 +181,13 @@ class OatWriter {
   OatHeader* oat_header_;
   std::vector<OatDexFile*> oat_dex_files_;
   std::vector<OatClass*> oat_classes_;
-  UniquePtr<const std::vector<uint8_t> > interpreter_to_interpreter_entry_;
-  UniquePtr<const std::vector<uint8_t> > interpreter_to_quick_entry_;
+  UniquePtr<const std::vector<uint8_t> > interpreter_to_interpreter_bridge_;
+  UniquePtr<const std::vector<uint8_t> > interpreter_to_compiled_code_bridge_;
+  UniquePtr<const std::vector<uint8_t> > jni_dlsym_lookup_;
   UniquePtr<const std::vector<uint8_t> > portable_resolution_trampoline_;
+  UniquePtr<const std::vector<uint8_t> > portable_to_interpreter_bridge_;
   UniquePtr<const std::vector<uint8_t> > quick_resolution_trampoline_;
+  UniquePtr<const std::vector<uint8_t> > quick_to_interpreter_bridge_;
 
   // output stats
   uint32_t size_dex_file_alignment_;
@@ -192,11 +195,14 @@ class OatWriter {
   uint32_t size_oat_header_;
   uint32_t size_oat_header_image_file_location_;
   uint32_t size_dex_file_;
-  uint32_t size_interpreter_to_interpreter_entry_;
-  uint32_t size_interpreter_to_quick_entry_;
+  uint32_t size_interpreter_to_interpreter_bridge_;
+  uint32_t size_interpreter_to_compiled_code_bridge_;
+  uint32_t size_jni_dlsym_lookup_;
   uint32_t size_portable_resolution_trampoline_;
+  uint32_t size_portable_to_interpreter_bridge_;
   uint32_t size_quick_resolution_trampoline_;
-  uint32_t size_stubs_alignment_;
+  uint32_t size_quick_to_interpreter_bridge_;
+  uint32_t size_trampoline_alignment_;
   uint32_t size_code_size_;
   uint32_t size_code_;
   uint32_t size_code_alignment_;
diff --git a/compiler/stubs/portable/stubs.cc b/compiler/stubs/portable/stubs.cc
deleted file mode 100644
index def43e2bd2..0000000000
--- a/compiler/stubs/portable/stubs.cc
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright (C) 2011 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.
- */
-
-#include "stubs/stubs.h"
-
-#include "entrypoints/quick/quick_entrypoints.h"
-#include "jni_internal.h"
-#include "utils/arm/assembler_arm.h"
-#include "utils/mips/assembler_mips.h"
-#include "utils/x86/assembler_x86.h"
-#include "stack_indirect_reference_table.h"
-#include "sirt_ref.h"
-
-#define __ assembler->
-
-namespace art {
-
-namespace arm {
-const std::vector<uint8_t>* CreatePortableResolutionTrampoline() {
-  UniquePtr<ArmAssembler> assembler(static_cast<ArmAssembler*>(Assembler::Create(kArm)));
-  RegList save = (1 << R0) | (1 << R1) | (1 << R2) | (1 << R3) | (1 << LR);
-
-  __ PushList(save);
-  __ LoadFromOffset(kLoadWord, R12, TR,
-                    PORTABLE_ENTRYPOINT_OFFSET(pPortableResolutionTrampolineFromCode));
-  __ mov(R3, ShifterOperand(TR));  // Pass Thread::Current() in R3
-  __ mov(R2, ShifterOperand(SP));  // Pass sp for Method** callee_addr
-  __ IncreaseFrameSize(12);         // 3 words of space for alignment
-  // Call to resolution trampoline (callee, receiver, callee_addr, Thread*)
-  __ blx(R12);
-  __ mov(R12, ShifterOperand(R0));  // Save code address returned into R12
-  __ DecreaseFrameSize(12);
-  __ PopList(save);
-  __ cmp(R12, ShifterOperand(0));
-  __ bx(R12, NE);                   // If R12 != 0 tail call method's code
-  __ bx(LR);                        // Return to caller to handle exception
-
-  assembler->EmitSlowPaths();
-  size_t cs = assembler->CodeSize();
-  UniquePtr<std::vector<uint8_t> > resolution_trampoline(new std::vector<uint8_t>(cs));
-  MemoryRegion code(&(*resolution_trampoline)[0], resolution_trampoline->size());
-  assembler->FinalizeInstructions(code);
-
-  return resolution_trampoline.release();
-}
-}  // namespace arm
-
-namespace mips {
-const std::vector<uint8_t>* CreatePortableResolutionTrampoline() {
-  UniquePtr<MipsAssembler> assembler(static_cast<MipsAssembler*>(Assembler::Create(kMips)));
-  // Build frame and save argument registers and RA.
-  __ AddConstant(SP, SP, -32);
-  __ StoreToOffset(kStoreWord, RA, SP, 28);
-  __ StoreToOffset(kStoreWord, A3, SP, 12);
-  __ StoreToOffset(kStoreWord, A2, SP, 8);
-  __ StoreToOffset(kStoreWord, A1, SP, 4);
-  __ StoreToOffset(kStoreWord, A0, SP, 0);
-
-  __ LoadFromOffset(kLoadWord, T9, S1,
-                    PORTABLE_ENTRYPOINT_OFFSET(pPortableResolutionTrampolineFromCode));
-  __ Move(A3, S1);  // Pass Thread::Current() in A3
-  __ Move(A2, SP);  // Pass SP for Method** callee_addr
-  __ Jalr(T9);  // Call to resolution trampoline (callee, receiver, callee_addr, Thread*)
-
-  // Restore frame, argument registers, and RA.
-  __ LoadFromOffset(kLoadWord, A0, SP, 0);
-  __ LoadFromOffset(kLoadWord, A1, SP, 4);
-  __ LoadFromOffset(kLoadWord, A2, SP, 8);
-  __ LoadFromOffset(kLoadWord, A3, SP, 12);
-  __ LoadFromOffset(kLoadWord, RA, SP, 28);
-  __ AddConstant(SP, SP, 32);
-
-  Label resolve_fail;
-  __ EmitBranch(V0, ZERO, &resolve_fail, true);
-  __ Jr(V0);  // If V0 != 0 tail call method's code
-  __ Bind(&resolve_fail, false);
-  __ Jr(RA);  // Return to caller to handle exception
-
-  assembler->EmitSlowPaths();
-  size_t cs = assembler->CodeSize();
-  UniquePtr<std::vector<uint8_t> > resolution_trampoline(new std::vector<uint8_t>(cs));
-  MemoryRegion code(&(*resolution_trampoline)[0], resolution_trampoline->size());
-  assembler->FinalizeInstructions(code);
-
-  return resolution_trampoline.release();
-}
-}  // namespace mips
-
-namespace x86 {
-const std::vector<uint8_t>* CreatePortableResolutionTrampoline() {
-  UniquePtr<X86Assembler> assembler(static_cast<X86Assembler*>(Assembler::Create(kX86)));
-
-  __ pushl(EBP);
-  __ movl(EBP, ESP);          // save ESP
-  __ subl(ESP, Immediate(8));  // Align stack
-  __ movl(EAX, Address(EBP, 8));  // Method* called
-  __ leal(EDX, Address(EBP, 8));  // Method** called_addr
-  __ fs()->pushl(Address::Absolute(Thread::SelfOffset()));  // pass thread
-  __ pushl(EDX);  // pass called_addr
-  __ pushl(ECX);  // pass receiver
-  __ pushl(EAX);  // pass called
-  // Call to resolve method.
-  __ Call(ThreadOffset(PORTABLE_ENTRYPOINT_OFFSET(pPortableResolutionTrampolineFromCode)),
-          X86ManagedRegister::FromCpuRegister(ECX));
-  __ leave();
-
-  Label resolve_fail;  // forward declaration
-  __ cmpl(EAX, Immediate(0));
-  __ j(kEqual, &resolve_fail);
-  __ jmp(EAX);
-  // Tail call to intended method.
-  __ Bind(&resolve_fail);
-  __ ret();
-
-  assembler->EmitSlowPaths();
-  size_t cs = assembler->CodeSize();
-  UniquePtr<std::vector<uint8_t> > resolution_trampoline(new std::vector<uint8_t>(cs));
-  MemoryRegion code(&(*resolution_trampoline)[0], resolution_trampoline->size());
-  assembler->FinalizeInstructions(code);
-
-  return resolution_trampoline.release();
-}
-}  // namespace x86
-
-}  // namespace art
diff --git a/compiler/stubs/quick/stubs.cc b/compiler/stubs/quick/stubs.cc
deleted file mode 100644
index 912f1c0746..0000000000
--- a/compiler/stubs/quick/stubs.cc
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * Copyright (C) 2011 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.
- */
-
-#include "stubs/stubs.h"
-
-#include "entrypoints/quick/quick_entrypoints.h"
-#include "jni_internal.h"
-#include "utils/arm/assembler_arm.h"
-#include "utils/mips/assembler_mips.h"
-#include "utils/x86/assembler_x86.h"
-#include "sirt_ref.h"
-#include "stack_indirect_reference_table.h"
-
-#define __ assembler->
-
-namespace art {
-
-namespace arm {
-const std::vector<uint8_t>* CreateQuickResolutionTrampoline() {
-  UniquePtr<ArmAssembler> assembler(static_cast<ArmAssembler*>(Assembler::Create(kArm)));
-  // | Out args |
-  // | Method*  | <- SP on entry
-  // | LR       |    return address into caller
-  // | ...      |    callee saves
-  // | R3       |    possible argument
-  // | R2       |    possible argument
-  // | R1       |    possible argument
-  // | R0       |    junk on call to QuickResolutionTrampolineFromCode, holds result Method*
-  // | Method*  |    Callee save Method* set up by QuickResoltuionTrampolineFromCode
-  // Save callee saves and ready frame for exception delivery
-  RegList save = (1 << R1) | (1 << R2) | (1 << R3) | (1 << R5) | (1 << R6) | (1 << R7) | (1 << R8) |
-                 (1 << R10) | (1 << R11) | (1 << LR);
-  // TODO: enable when GetCalleeSaveMethod is available at stub generation time
-  // DCHECK_EQ(save, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetCoreSpillMask());
-  __ PushList(save);
-  __ LoadFromOffset(kLoadWord, R12, TR, QUICK_ENTRYPOINT_OFFSET(pQuickResolutionTrampolineFromCode));
-  __ mov(R3, ShifterOperand(TR));  // Pass Thread::Current() in R3
-  __ IncreaseFrameSize(8);         // 2 words of space for alignment
-  __ mov(R2, ShifterOperand(SP));  // Pass SP
-  // Call to resolution trampoline (method_idx, receiver, sp, Thread*)
-  __ blx(R12);
-  __ mov(R12, ShifterOperand(R0));  // Save code address returned into R12
-  // Restore registers which may have been modified by GC, "R0" will hold the Method*
-  __ DecreaseFrameSize(4);
-  __ PopList((1 << R0) | save);
-  __ bx(R12);  // Leaf call to method's code
-  __ bkpt(0);
-
-  assembler->EmitSlowPaths();
-  size_t cs = assembler->CodeSize();
-  UniquePtr<std::vector<uint8_t> > resolution_trampoline(new std::vector<uint8_t>(cs));
-  MemoryRegion code(&(*resolution_trampoline)[0], resolution_trampoline->size());
-  assembler->FinalizeInstructions(code);
-
-  return resolution_trampoline.release();
-}
-
-const std::vector<uint8_t>* CreateInterpreterToInterpreterEntry() {
-  UniquePtr<ArmAssembler> assembler(static_cast<ArmAssembler*>(Assembler::Create(kArm)));
-
-  __ LoadFromOffset(kLoadWord, PC, R0, QUICK_ENTRYPOINT_OFFSET(pInterpreterToInterpreterEntry));
-  __ bkpt(0);
-
-  size_t cs = assembler->CodeSize();
-  UniquePtr<std::vector<uint8_t> > entry_stub(new std::vector<uint8_t>(cs));
-  MemoryRegion code(&(*entry_stub)[0], entry_stub->size());
-  assembler->FinalizeInstructions(code);
-
-  return entry_stub.release();
-}
-
-const std::vector<uint8_t>* CreateInterpreterToQuickEntry() {
-  UniquePtr<ArmAssembler> assembler(static_cast<ArmAssembler*>(Assembler::Create(kArm)));
-
-  __ LoadFromOffset(kLoadWord, PC, R0, QUICK_ENTRYPOINT_OFFSET(pInterpreterToQuickEntry));
-  __ bkpt(0);
-
-  size_t cs = assembler->CodeSize();
-  UniquePtr<std::vector<uint8_t> > entry_stub(new std::vector<uint8_t>(cs));
-  MemoryRegion code(&(*entry_stub)[0], entry_stub->size());
-  assembler->FinalizeInstructions(code);
-
-  return entry_stub.release();
-}
-}  // namespace arm
-
-namespace mips {
-const std::vector<uint8_t>* CreateQuickResolutionTrampoline() {
-  UniquePtr<MipsAssembler> assembler(static_cast<MipsAssembler*>(Assembler::Create(kMips)));
-  // | Out args   |
-  // | Method*    | <- SP on entry
-  // | RA         |    return address into caller
-  // | ...        |    callee saves
-  // | A3         |    possible argument
-  // | A2         |    possible argument
-  // | A1         |    possible argument
-  // | A0/Method* |    Callee save Method* set up by UnresolvedDirectMethodTrampolineFromCode
-  // Save callee saves and ready frame for exception delivery
-  __ AddConstant(SP, SP, -64);
-  __ StoreToOffset(kStoreWord, RA, SP, 60);
-  __ StoreToOffset(kStoreWord, FP, SP, 56);
-  __ StoreToOffset(kStoreWord, GP, SP, 52);
-  __ StoreToOffset(kStoreWord, S7, SP, 48);
-  __ StoreToOffset(kStoreWord, S6, SP, 44);
-  __ StoreToOffset(kStoreWord, S5, SP, 40);
-  __ StoreToOffset(kStoreWord, S4, SP, 36);
-  __ StoreToOffset(kStoreWord, S3, SP, 32);
-  __ StoreToOffset(kStoreWord, S2, SP, 28);
-  __ StoreToOffset(kStoreWord, A3, SP, 12);
-  __ StoreToOffset(kStoreWord, A2, SP, 8);
-  __ StoreToOffset(kStoreWord, A1, SP, 4);
-
-  __ LoadFromOffset(kLoadWord, T9, S1, QUICK_ENTRYPOINT_OFFSET(pQuickResolutionTrampolineFromCode));
-  __ Move(A3, S1);  // Pass Thread::Current() in A3
-  __ Move(A2, SP);  // Pass SP for Method** callee_addr
-  __ Jalr(T9);  // Call to resolution trampoline (method_idx, receiver, sp, Thread*)
-
-  // Restore registers which may have been modified by GC
-  __ LoadFromOffset(kLoadWord, A0, SP, 0);
-  __ LoadFromOffset(kLoadWord, A1, SP, 4);
-  __ LoadFromOffset(kLoadWord, A2, SP, 8);
-  __ LoadFromOffset(kLoadWord, A3, SP, 12);
-  __ LoadFromOffset(kLoadWord, S2, SP, 28);
-  __ LoadFromOffset(kLoadWord, S3, SP, 32);
-  __ LoadFromOffset(kLoadWord, S4, SP, 36);
-  __ LoadFromOffset(kLoadWord, S5, SP, 40);
-  __ LoadFromOffset(kLoadWord, S6, SP, 44);
-  __ LoadFromOffset(kLoadWord, S7, SP, 48);
-  __ LoadFromOffset(kLoadWord, GP, SP, 52);
-  __ LoadFromOffset(kLoadWord, FP, SP, 56);
-  __ LoadFromOffset(kLoadWord, RA, SP, 60);
-  __ AddConstant(SP, SP, 64);
-
-  __ Move(T9, V0);  // Put method's code in T9
-  __ Jr(T9);  // Leaf call to method's code
-
-  __ Break();
-
-  assembler->EmitSlowPaths();
-  size_t cs = assembler->CodeSize();
-  UniquePtr<std::vector<uint8_t> > resolution_trampoline(new std::vector<uint8_t>(cs));
-  MemoryRegion code(&(*resolution_trampoline)[0], resolution_trampoline->size());
-  assembler->FinalizeInstructions(code);
-
-  return resolution_trampoline.release();
-}
-
-const std::vector<uint8_t>* CreateInterpreterToInterpreterEntry() {
-  UniquePtr<MipsAssembler> assembler(static_cast<MipsAssembler*>(Assembler::Create(kMips)));
-
-  __ LoadFromOffset(kLoadWord, T9, A0, QUICK_ENTRYPOINT_OFFSET(pInterpreterToInterpreterEntry));
-  __ Jr(T9);
-  __ Break();
-
-  size_t cs = assembler->CodeSize();
-  UniquePtr<std::vector<uint8_t> > entry_stub(new std::vector<uint8_t>(cs));
-  MemoryRegion code(&(*entry_stub)[0], entry_stub->size());
-  assembler->FinalizeInstructions(code);
-
-  return entry_stub.release();
-}
-
-const std::vector<uint8_t>* CreateInterpreterToQuickEntry() {
-  UniquePtr<MipsAssembler> assembler(static_cast<MipsAssembler*>(Assembler::Create(kMips)));
-
-  __ LoadFromOffset(kLoadWord, T9, A0, QUICK_ENTRYPOINT_OFFSET(pInterpreterToInterpreterEntry));
-  __ Jr(T9);
-  __ Break();
-
-  size_t cs = assembler->CodeSize();
-  UniquePtr<std::vector<uint8_t> > entry_stub(new std::vector<uint8_t>(cs));
-  MemoryRegion code(&(*entry_stub)[0], entry_stub->size());
-  assembler->FinalizeInstructions(code);
-
-  return entry_stub.release();
-}
-}  // namespace mips
-
-namespace x86 {
-const std::vector<uint8_t>* CreateQuickResolutionTrampoline() {
-  UniquePtr<X86Assembler> assembler(static_cast<X86Assembler*>(Assembler::Create(kX86)));
-  // Set up the callee save frame to conform with Runtime::CreateCalleeSaveMethod(kRefsAndArgs)
-  // return address
-  __ pushl(EDI);
-  __ pushl(ESI);
-  __ pushl(EBP);
-  __ pushl(EBX);
-  __ pushl(EDX);
-  __ pushl(ECX);
-  __ pushl(EAX);  // <-- callee save Method* to go here
-  __ movl(EDX, ESP);          // save ESP
-  __ fs()->pushl(Address::Absolute(Thread::SelfOffset()));  // pass Thread*
-  __ pushl(EDX);              // pass ESP for Method*
-  __ pushl(ECX);              // pass receiver
-  __ pushl(EAX);              // pass Method*
-
-  // Call to resolve method.
-  __ Call(ThreadOffset(QUICK_ENTRYPOINT_OFFSET(pQuickResolutionTrampolineFromCode)),
-          X86ManagedRegister::FromCpuRegister(ECX));
-
-  __ movl(EDI, EAX);  // save code pointer in EDI
-  __ addl(ESP, Immediate(16));  // Pop arguments
-  __ popl(EAX);  // Restore args.
-  __ popl(ECX);
-  __ popl(EDX);
-  __ popl(EBX);
-  __ popl(EBP);  // Restore callee saves.
-  __ popl(ESI);
-  // Swap EDI callee save with code pointer
-  __ xchgl(EDI, Address(ESP, 0));
-  // Tail call to intended method.
-  __ ret();
-
-  assembler->EmitSlowPaths();
-  size_t cs = assembler->CodeSize();
-  UniquePtr<std::vector<uint8_t> > resolution_trampoline(new std::vector<uint8_t>(cs));
-  MemoryRegion code(&(*resolution_trampoline)[0], resolution_trampoline->size());
-  assembler->FinalizeInstructions(code);
-
-  return resolution_trampoline.release();
-}
-
-const std::vector<uint8_t>* CreateInterpreterToInterpreterEntry() {
-  UniquePtr<X86Assembler> assembler(static_cast<X86Assembler*>(Assembler::Create(kX86)));
-
-  __ fs()->jmp(Address::Absolute(ThreadOffset(QUICK_ENTRYPOINT_OFFSET(pInterpreterToInterpreterEntry))));
-
-  size_t cs = assembler->CodeSize();
-  UniquePtr<std::vector<uint8_t> > entry_stub(new std::vector<uint8_t>(cs));
-  MemoryRegion code(&(*entry_stub)[0], entry_stub->size());
-  assembler->FinalizeInstructions(code);
-
-  return entry_stub.release();
-}
-
-const std::vector<uint8_t>* CreateInterpreterToQuickEntry() {
-  UniquePtr<X86Assembler> assembler(static_cast<X86Assembler*>(Assembler::Create(kX86)));
-
-  __ fs()->jmp(Address::Absolute(ThreadOffset(QUICK_ENTRYPOINT_OFFSET(pInterpreterToQuickEntry))));
-
-  size_t cs = assembler->CodeSize();
-  UniquePtr<std::vector<uint8_t> > entry_stub(new std::vector<uint8_t>(cs));
-  MemoryRegion code(&(*entry_stub)[0], entry_stub->size());
-  assembler->FinalizeInstructions(code);
-
-  return entry_stub.release();
-}
-}  // namespace x86
-
-}  // namespace art
diff --git a/compiler/stubs/stubs.h b/compiler/stubs/stubs.h
deleted file mode 100644
index d85eae8e1e..0000000000
--- a/compiler/stubs/stubs.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * 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_STUBS_STUBS_H_
-#define ART_COMPILER_STUBS_STUBS_H_
-
-#include "runtime.h"
-
-namespace art {
-
-namespace arm {
-const std::vector<uint8_t>* CreatePortableResolutionTrampoline()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-const std::vector<uint8_t>* CreateQuickResolutionTrampoline()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-const std::vector<uint8_t>* CreateInterpreterToInterpreterEntry()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-const std::vector<uint8_t>* CreateInterpreterToQuickEntry()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-}
-
-namespace mips {
-const std::vector<uint8_t>* CreatePortableResolutionTrampoline()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-const std::vector<uint8_t>* CreateQuickResolutionTrampoline()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-const std::vector<uint8_t>* CreateInterpreterToInterpreterEntry()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-const std::vector<uint8_t>* CreateInterpreterToQuickEntry()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-}
-
-namespace x86 {
-const std::vector<uint8_t>* CreatePortableResolutionTrampoline()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-const std::vector<uint8_t>* CreateQuickResolutionTrampoline()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-const std::vector<uint8_t>* CreateInterpreterToInterpreterEntry()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-const std::vector<uint8_t>* CreateInterpreterToQuickEntry()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-}
-
-}  // namespace art
-
-#endif  // ART_COMPILER_STUBS_STUBS_H_
diff --git a/compiler/utils/arm/assembler_arm.cc b/compiler/utils/arm/assembler_arm.cc
index fa202c3017..f0d11d8f90 100644
--- a/compiler/utils/arm/assembler_arm.cc
+++ b/compiler/utils/arm/assembler_arm.cc
@@ -1246,10 +1246,10 @@ bool Address::CanHoldStoreOffset(StoreOperandType type, int offset) {
 // Implementation note: this method must emit at most one instruction when
 // Address::CanHoldLoadOffset.
 void ArmAssembler::LoadFromOffset(LoadOperandType type,
-                               Register reg,
-                               Register base,
-                               int32_t offset,
-                               Condition cond) {
+                                  Register reg,
+                                  Register base,
+                                  int32_t offset,
+                                  Condition cond) {
   if (!Address::CanHoldLoadOffset(type, offset)) {
     CHECK(base != IP);
     LoadImmediate(IP, offset, cond);
@@ -1884,7 +1884,7 @@ void ArmExceptionSlowPath::Emit(Assembler* sasm) {
   // Don't care about preserving R0 as this call won't return
   __ mov(R0, ShifterOperand(scratch_.AsCoreRegister()));
   // Set up call to Thread::Current()->pDeliverException
-  __ LoadFromOffset(kLoadWord, R12, TR, QUICK_ENTRYPOINT_OFFSET(pDeliverException));
+  __ LoadFromOffset(kLoadWord, R12, TR, QUICK_ENTRYPOINT_OFFSET(pDeliverException).Int32Value());
   __ blx(R12);
   // Call never returns
   __ bkpt(0);
diff --git a/compiler/utils/mips/assembler_mips.cc b/compiler/utils/mips/assembler_mips.cc
index 931d7ab0f7..2be3d56cfa 100644
--- a/compiler/utils/mips/assembler_mips.cc
+++ b/compiler/utils/mips/assembler_mips.cc
@@ -813,14 +813,7 @@ void MipsAssembler::Copy(ManagedRegister dest_base, Offset dest_offset, FrameOff
 
 void MipsAssembler::Copy(FrameOffset /*dest*/, FrameOffset /*src_base*/, Offset /*src_offset*/,
                          ManagedRegister /*mscratch*/, size_t /*size*/) {
-  UNIMPLEMENTED(FATAL) << "no arm implementation";
-#if 0
-  Register scratch = mscratch.AsMips().AsCoreRegister();
-  CHECK_EQ(size, 4u);
-  movl(scratch, Address(ESP, src_base));
-  movl(scratch, Address(scratch, src_offset));
-  movl(Address(ESP, dest), scratch);
-#endif
+  UNIMPLEMENTED(FATAL) << "no mips implementation";
 }
 
 void MipsAssembler::Copy(ManagedRegister dest, Offset dest_offset,
@@ -834,24 +827,11 @@ void MipsAssembler::Copy(ManagedRegister dest, Offset dest_offset,
 
 void MipsAssembler::Copy(FrameOffset /*dest*/, Offset /*dest_offset*/, FrameOffset /*src*/, Offset /*src_offset*/,
                          ManagedRegister /*mscratch*/, size_t /*size*/) {
-  UNIMPLEMENTED(FATAL) << "no arm implementation";
-#if 0
-  Register scratch = mscratch.AsMips().AsCoreRegister();
-  CHECK_EQ(size, 4u);
-  CHECK_EQ(dest.Int32Value(), src.Int32Value());
-  movl(scratch, Address(ESP, src));
-  pushl(Address(scratch, src_offset));
-  popl(Address(scratch, dest_offset));
-#endif
+  UNIMPLEMENTED(FATAL) << "no mips implementation";
 }
 
 void MipsAssembler::MemoryBarrier(ManagedRegister) {
-  UNIMPLEMENTED(FATAL) << "NEEDS TO BE IMPLEMENTED";
-#if 0
-#if ANDROID_SMP != 0
-  mfence();
-#endif
-#endif
+  UNIMPLEMENTED(FATAL) << "no mips implementation";
 }
 
 void MipsAssembler::CreateSirtEntry(ManagedRegister mout_reg,
@@ -953,10 +933,7 @@ void MipsAssembler::Call(FrameOffset base, Offset offset, ManagedRegister mscrat
 }
 
 void MipsAssembler::Call(ThreadOffset /*offset*/, ManagedRegister /*mscratch*/) {
-  UNIMPLEMENTED(FATAL) << "no arm implementation";
-#if 0
-  fs()->call(Address::Absolute(offset));
-#endif
+  UNIMPLEMENTED(FATAL) << "no mips implementation";
 }
 
 void MipsAssembler::GetCurrentThread(ManagedRegister tr) {
@@ -988,7 +965,7 @@ void MipsExceptionSlowPath::Emit(Assembler* sasm) {
   // Don't care about preserving A0 as this call won't return
   __ Move(A0, scratch_.AsCoreRegister());
   // Set up call to Thread::Current()->pDeliverException
-  __ LoadFromOffset(kLoadWord, T9, S1, QUICK_ENTRYPOINT_OFFSET(pDeliverException));
+  __ LoadFromOffset(kLoadWord, T9, S1, QUICK_ENTRYPOINT_OFFSET(pDeliverException).Int32Value());
   __ Jr(T9);
   // Call never returns
   __ Break();
diff --git a/runtime/Android.mk b/runtime/Android.mk
index 51bb3eb2d3..4f25c00546 100644
--- a/runtime/Android.mk
+++ b/runtime/Android.mk
@@ -142,6 +142,7 @@ LIBART_COMMON_SRC_FILES += \
 	arch/x86/registers_x86.cc \
 	arch/mips/registers_mips.cc \
 	entrypoints/entrypoint_utils.cc \
+	entrypoints/interpreter/interpreter_entrypoints.cc \
 	entrypoints/jni/jni_entrypoints.cc \
 	entrypoints/math_entrypoints.cc \
 	entrypoints/portable/portable_alloc_entrypoints.cc \
@@ -163,15 +164,13 @@ LIBART_COMMON_SRC_FILES += \
 	entrypoints/quick/quick_field_entrypoints.cc \
 	entrypoints/quick/quick_fillarray_entrypoints.cc \
 	entrypoints/quick/quick_instrumentation_entrypoints.cc \
-	entrypoints/quick/quick_interpreter_entrypoints.cc \
 	entrypoints/quick/quick_invoke_entrypoints.cc \
 	entrypoints/quick/quick_jni_entrypoints.cc \
 	entrypoints/quick/quick_lock_entrypoints.cc \
 	entrypoints/quick/quick_math_entrypoints.cc \
-	entrypoints/quick/quick_proxy_entrypoints.cc \
-	entrypoints/quick/quick_stub_entrypoints.cc \
 	entrypoints/quick/quick_thread_entrypoints.cc \
-	entrypoints/quick/quick_throw_entrypoints.cc
+	entrypoints/quick/quick_throw_entrypoints.cc \
+	entrypoints/quick/quick_trampoline_entrypoints.cc
 
 LIBART_TARGET_SRC_FILES := \
 	$(LIBART_COMMON_SRC_FILES) \
diff --git a/runtime/arch/arm/asm_support_arm.S b/runtime/arch/arm/asm_support_arm.S
index ed655e95b1..559788f1ba 100644
--- a/runtime/arch/arm/asm_support_arm.S
+++ b/runtime/arch/arm/asm_support_arm.S
@@ -35,4 +35,11 @@
     .size \name, .-\name
 .endm
 
+.macro UNIMPLEMENTED name
+    ENTRY \name
+    bkpt
+    bkpt
+    END \name
+.endm
+
 #endif  // ART_RUNTIME_ARCH_X86_ASM_SUPPORT_X86_S_
diff --git a/runtime/arch/arm/entrypoints_init_arm.cc b/runtime/arch/arm/entrypoints_init_arm.cc
index b71a158289..848bacca52 100644
--- a/runtime/arch/arm/entrypoints_init_arm.cc
+++ b/runtime/arch/arm/entrypoints_init_arm.cc
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "entrypoints/interpreter/interpreter_entrypoints.h"
 #include "entrypoints/portable/portable_entrypoints.h"
 #include "entrypoints/quick/quick_entrypoints.h"
 #include "entrypoints/entrypoint_utils.h"
@@ -21,49 +22,61 @@
 
 namespace art {
 
+// Interpreter entrypoints.
+extern "C" void artInterpreterToInterpreterBridge(Thread* self, MethodHelper& mh,
+                                                 const DexFile::CodeItem* code_item,
+                                                 ShadowFrame* shadow_frame, JValue* result);
+extern "C" void artInterperterToCompiledCodeBridge(Thread* self, MethodHelper& mh,
+                                           const DexFile::CodeItem* code_item,
+                                           ShadowFrame* shadow_frame, JValue* result);
+
+// Portable entrypoints.
+extern "C" void art_portable_resolution_trampoline(mirror::AbstractMethod*);
+extern "C" void art_portable_to_interpreter_bridge(mirror::AbstractMethod*);
+
 // Alloc entrypoints.
-extern "C" void* art_quick_alloc_array_from_code(uint32_t, void*, int32_t);
-extern "C" void* art_quick_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
-extern "C" void* art_quick_alloc_object_from_code(uint32_t type_idx, void* method);
-extern "C" void* art_quick_alloc_object_from_code_with_access_check(uint32_t type_idx, void* method);
-extern "C" void* art_quick_check_and_alloc_array_from_code(uint32_t, void*, int32_t);
-extern "C" void* art_quick_check_and_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_array(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_array_with_access_check(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_object(uint32_t type_idx, void* method);
+extern "C" void* art_quick_alloc_object_with_access_check(uint32_t type_idx, void* method);
+extern "C" void* art_quick_check_and_alloc_array(uint32_t, void*, int32_t);
+extern "C" void* art_quick_check_and_alloc_array_with_access_check(uint32_t, void*, int32_t);
 
 // Cast entrypoints.
 extern "C" uint32_t artIsAssignableFromCode(const mirror::Class* klass,
                                             const mirror::Class* ref_class);
-extern "C" void art_quick_can_put_array_element_from_code(void*, void*);
-extern "C" void art_quick_check_cast_from_code(void*, void*);
+extern "C" void art_quick_can_put_array_element(void*, void*);
+extern "C" void art_quick_check_cast(void*, void*);
 
 // DexCache entrypoints.
-extern "C" void* art_quick_initialize_static_storage_from_code(uint32_t, void*);
-extern "C" void* art_quick_initialize_type_from_code(uint32_t, void*);
-extern "C" void* art_quick_initialize_type_and_verify_access_from_code(uint32_t, void*);
-extern "C" void* art_quick_resolve_string_from_code(void*, uint32_t);
+extern "C" void* art_quick_initialize_static_storage(uint32_t, void*);
+extern "C" void* art_quick_initialize_type(uint32_t, void*);
+extern "C" void* art_quick_initialize_type_and_verify_access(uint32_t, void*);
+extern "C" void* art_quick_resolve_string(void*, uint32_t);
 
 // Exception entrypoints.
 extern "C" void* GetAndClearException(Thread*);
 
 // Field entrypoints.
-extern "C" int art_quick_set32_instance_from_code(uint32_t, void*, int32_t);
-extern "C" int art_quick_set32_static_from_code(uint32_t, int32_t);
-extern "C" int art_quick_set64_instance_from_code(uint32_t, void*, int64_t);
-extern "C" int art_quick_set64_static_from_code(uint32_t, int64_t);
-extern "C" int art_quick_set_obj_instance_from_code(uint32_t, void*, void*);
-extern "C" int art_quick_set_obj_static_from_code(uint32_t, void*);
-extern "C" int32_t art_quick_get32_instance_from_code(uint32_t, void*);
-extern "C" int32_t art_quick_get32_static_from_code(uint32_t);
-extern "C" int64_t art_quick_get64_instance_from_code(uint32_t, void*);
-extern "C" int64_t art_quick_get64_static_from_code(uint32_t);
-extern "C" void* art_quick_get_obj_instance_from_code(uint32_t, void*);
-extern "C" void* art_quick_get_obj_static_from_code(uint32_t);
+extern "C" int art_quick_set32_instance(uint32_t, void*, int32_t);
+extern "C" int art_quick_set32_static(uint32_t, int32_t);
+extern "C" int art_quick_set64_instance(uint32_t, void*, int64_t);
+extern "C" int art_quick_set64_static(uint32_t, int64_t);
+extern "C" int art_quick_set_obj_instance(uint32_t, void*, void*);
+extern "C" int art_quick_set_obj_static(uint32_t, void*);
+extern "C" int32_t art_quick_get32_instance(uint32_t, void*);
+extern "C" int32_t art_quick_get32_static(uint32_t);
+extern "C" int64_t art_quick_get64_instance(uint32_t, void*);
+extern "C" int64_t art_quick_get64_static(uint32_t);
+extern "C" void* art_quick_get_obj_instance(uint32_t, void*);
+extern "C" void* art_quick_get_obj_static(uint32_t);
 
 // FillArray entrypoint.
-extern "C" void art_quick_handle_fill_data_from_code(void*, void*);
+extern "C" void art_quick_handle_fill_data(void*, void*);
 
 // Lock entrypoints.
-extern "C" void art_quick_lock_object_from_code(void*);
-extern "C" void art_quick_unlock_object_from_code(void*);
+extern "C" void art_quick_lock_object(void*);
+extern "C" void art_quick_unlock_object(void*);
 
 // Math entrypoints.
 extern int32_t CmpgDouble(double a, double b);
@@ -93,26 +106,14 @@ extern "C" uint64_t art_quick_shl_long(uint64_t, uint32_t);
 extern "C" uint64_t art_quick_shr_long(uint64_t, uint32_t);
 extern "C" uint64_t art_quick_ushr_long(uint64_t, uint32_t);
 
-// Interpreter entrypoints.
-extern "C" void artInterpreterToInterpreterEntry(Thread* self, MethodHelper& mh,
-                                                 const DexFile::CodeItem* code_item,
-                                                 ShadowFrame* shadow_frame, JValue* result);
-extern "C" void artInterpreterToQuickEntry(Thread* self, MethodHelper& mh,
-                                           const DexFile::CodeItem* code_item,
-                                           ShadowFrame* shadow_frame, JValue* result);
-
 // Intrinsic entrypoints.
 extern "C" int32_t __memcmp16(void*, void*, int32_t);
 extern "C" int32_t art_quick_indexof(void*, uint32_t, uint32_t, uint32_t);
 extern "C" int32_t art_quick_string_compareto(void*, void*);
 
 // Invoke entrypoints.
-extern "C" const void* artPortableResolutionTrampoline(mirror::AbstractMethod* called,
-                                                       mirror::Object* receiver,
-                                                       mirror::AbstractMethod** sp, Thread* thread);
-extern "C" const void* artQuickResolutionTrampoline(mirror::AbstractMethod* called,
-                                                    mirror::Object* receiver,
-                                                    mirror::AbstractMethod** sp, Thread* thread);
+extern "C" void art_quick_resolution_trampoline(mirror::AbstractMethod*);
+extern "C" void art_quick_to_interpreter_bridge(mirror::AbstractMethod*);
 extern "C" void art_quick_invoke_direct_trampoline_with_access_check(uint32_t, void*);
 extern "C" void art_quick_invoke_interface_trampoline(uint32_t, void*);
 extern "C" void art_quick_invoke_interface_trampoline_with_access_check(uint32_t, void*);
@@ -125,49 +126,61 @@ extern void CheckSuspendFromCode(Thread* thread);
 extern "C" void art_quick_test_suspend();
 
 // Throw entrypoints.
-extern "C" void art_quick_deliver_exception_from_code(void*);
-extern "C" void art_quick_throw_array_bounds_from_code(int32_t index, int32_t limit);
-extern "C" void art_quick_throw_div_zero_from_code();
-extern "C" void art_quick_throw_no_such_method_from_code(int32_t method_idx);
-extern "C" void art_quick_throw_null_pointer_exception_from_code();
-extern "C" void art_quick_throw_stack_overflow_from_code(void*);
-
-void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
+extern "C" void art_quick_deliver_exception(void*);
+extern "C" void art_quick_throw_array_bounds(int32_t index, int32_t limit);
+extern "C" void art_quick_throw_div_zero();
+extern "C" void art_quick_throw_no_such_method(int32_t method_idx);
+extern "C" void art_quick_throw_null_pointer_exception();
+extern "C" void art_quick_throw_stack_overflow(void*);
+
+void InitEntryPoints(InterpreterEntryPoints* ipoints, JniEntryPoints* jpoints,
+                     PortableEntryPoints* ppoints, QuickEntryPoints* qpoints) {
+  // Interpreter
+  ipoints->pInterpreterToInterpreterBridge = artInterpreterToInterpreterBridge;
+  ipoints->pInterpreterToCompiledCodeBridge = artInterperterToCompiledCodeBridge;
+
+  // JNI
+  jpoints->pDlsymLookup = art_jni_dlsym_lookup_stub;
+
+  // Portable
+  ppoints->pPortableResolutionTrampoline = art_portable_resolution_trampoline;
+  ppoints->pPortableToInterpreterBridge = art_portable_to_interpreter_bridge;
+
   // Alloc
-  qpoints->pAllocArrayFromCode = art_quick_alloc_array_from_code;
-  qpoints->pAllocArrayFromCodeWithAccessCheck = art_quick_alloc_array_from_code_with_access_check;
-  qpoints->pAllocObjectFromCode = art_quick_alloc_object_from_code;
-  qpoints->pAllocObjectFromCodeWithAccessCheck = art_quick_alloc_object_from_code_with_access_check;
-  qpoints->pCheckAndAllocArrayFromCode = art_quick_check_and_alloc_array_from_code;
-  qpoints->pCheckAndAllocArrayFromCodeWithAccessCheck = art_quick_check_and_alloc_array_from_code_with_access_check;
+  qpoints->pAllocArray = art_quick_alloc_array;
+  qpoints->pAllocArrayWithAccessCheck = art_quick_alloc_array_with_access_check;
+  qpoints->pAllocObject = art_quick_alloc_object;
+  qpoints->pAllocObjectWithAccessCheck = art_quick_alloc_object_with_access_check;
+  qpoints->pCheckAndAllocArray = art_quick_check_and_alloc_array;
+  qpoints->pCheckAndAllocArrayWithAccessCheck = art_quick_check_and_alloc_array_with_access_check;
 
   // Cast
-  qpoints->pInstanceofNonTrivialFromCode = artIsAssignableFromCode;
-  qpoints->pCanPutArrayElementFromCode = art_quick_can_put_array_element_from_code;
-  qpoints->pCheckCastFromCode = art_quick_check_cast_from_code;
+  qpoints->pInstanceofNonTrivial = artIsAssignableFromCode;
+  qpoints->pCanPutArrayElement = art_quick_can_put_array_element;
+  qpoints->pCheckCast = art_quick_check_cast;
 
   // DexCache
-  qpoints->pInitializeStaticStorage = art_quick_initialize_static_storage_from_code;
-  qpoints->pInitializeTypeAndVerifyAccessFromCode = art_quick_initialize_type_and_verify_access_from_code;
-  qpoints->pInitializeTypeFromCode = art_quick_initialize_type_from_code;
-  qpoints->pResolveStringFromCode = art_quick_resolve_string_from_code;
+  qpoints->pInitializeStaticStorage = art_quick_initialize_static_storage;
+  qpoints->pInitializeTypeAndVerifyAccess = art_quick_initialize_type_and_verify_access;
+  qpoints->pInitializeType = art_quick_initialize_type;
+  qpoints->pResolveString = art_quick_resolve_string;
 
   // Field
-  qpoints->pSet32Instance = art_quick_set32_instance_from_code;
-  qpoints->pSet32Static = art_quick_set32_static_from_code;
-  qpoints->pSet64Instance = art_quick_set64_instance_from_code;
-  qpoints->pSet64Static = art_quick_set64_static_from_code;
-  qpoints->pSetObjInstance = art_quick_set_obj_instance_from_code;
-  qpoints->pSetObjStatic = art_quick_set_obj_static_from_code;
-  qpoints->pGet32Instance = art_quick_get32_instance_from_code;
-  qpoints->pGet64Instance = art_quick_get64_instance_from_code;
-  qpoints->pGetObjInstance = art_quick_get_obj_instance_from_code;
-  qpoints->pGet32Static = art_quick_get32_static_from_code;
-  qpoints->pGet64Static = art_quick_get64_static_from_code;
-  qpoints->pGetObjStatic = art_quick_get_obj_static_from_code;
+  qpoints->pSet32Instance = art_quick_set32_instance;
+  qpoints->pSet32Static = art_quick_set32_static;
+  qpoints->pSet64Instance = art_quick_set64_instance;
+  qpoints->pSet64Static = art_quick_set64_static;
+  qpoints->pSetObjInstance = art_quick_set_obj_instance;
+  qpoints->pSetObjStatic = art_quick_set_obj_static;
+  qpoints->pGet32Instance = art_quick_get32_instance;
+  qpoints->pGet64Instance = art_quick_get64_instance;
+  qpoints->pGetObjInstance = art_quick_get_obj_instance;
+  qpoints->pGet32Static = art_quick_get32_static;
+  qpoints->pGet64Static = art_quick_get64_static;
+  qpoints->pGetObjStatic = art_quick_get_obj_static;
 
   // FillArray
-  qpoints->pHandleFillArrayDataFromCode = art_quick_handle_fill_data_from_code;
+  qpoints->pHandleFillArrayData = art_quick_handle_fill_data;
 
   // JNI
   qpoints->pJniMethodStart = JniMethodStart;
@@ -178,8 +191,8 @@ void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
   qpoints->pJniMethodEndWithReferenceSynchronized = JniMethodEndWithReferenceSynchronized;
 
   // Locks
-  qpoints->pLockObjectFromCode = art_quick_lock_object_from_code;
-  qpoints->pUnlockObjectFromCode = art_quick_unlock_object_from_code;
+  qpoints->pLockObject = art_quick_lock_object;
+  qpoints->pUnlockObject = art_quick_unlock_object;
 
   // Math
   qpoints->pCmpgDouble = CmpgDouble;
@@ -203,10 +216,6 @@ void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
   qpoints->pShrLong = art_quick_shr_long;
   qpoints->pUshrLong = art_quick_ushr_long;
 
-  // Interpreter
-  qpoints->pInterpreterToInterpreterEntry = artInterpreterToInterpreterEntry;
-  qpoints->pInterpreterToQuickEntry = artInterpreterToQuickEntry;
-
   // Intrinsics
   qpoints->pIndexOf = art_quick_indexof;
   qpoints->pMemcmp16 = __memcmp16;
@@ -214,7 +223,8 @@ void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
   qpoints->pMemcpy = memcpy;
 
   // Invocation
-  qpoints->pQuickResolutionTrampolineFromCode = artQuickResolutionTrampoline;
+  qpoints->pQuickResolutionTrampoline = art_quick_resolution_trampoline;
+  qpoints->pQuickToInterpreterBridge = art_quick_to_interpreter_bridge;
   qpoints->pInvokeDirectTrampolineWithAccessCheck = art_quick_invoke_direct_trampoline_with_access_check;
   qpoints->pInvokeInterfaceTrampoline = art_quick_invoke_interface_trampoline;
   qpoints->pInvokeInterfaceTrampolineWithAccessCheck = art_quick_invoke_interface_trampoline_with_access_check;
@@ -223,19 +233,16 @@ void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
   qpoints->pInvokeVirtualTrampolineWithAccessCheck = art_quick_invoke_virtual_trampoline_with_access_check;
 
   // Thread
-  qpoints->pCheckSuspendFromCode = CheckSuspendFromCode;
-  qpoints->pTestSuspendFromCode = art_quick_test_suspend;
+  qpoints->pCheckSuspend = CheckSuspendFromCode;
+  qpoints->pTestSuspend = art_quick_test_suspend;
 
   // Throws
-  qpoints->pDeliverException = art_quick_deliver_exception_from_code;
-  qpoints->pThrowArrayBoundsFromCode = art_quick_throw_array_bounds_from_code;
-  qpoints->pThrowDivZeroFromCode = art_quick_throw_div_zero_from_code;
-  qpoints->pThrowNoSuchMethodFromCode = art_quick_throw_no_such_method_from_code;
-  qpoints->pThrowNullPointerFromCode = art_quick_throw_null_pointer_exception_from_code;
-  qpoints->pThrowStackOverflowFromCode = art_quick_throw_stack_overflow_from_code;
-
-  // Portable
-  ppoints->pPortableResolutionTrampolineFromCode = artPortableResolutionTrampoline;
+  qpoints->pDeliverException = art_quick_deliver_exception;
+  qpoints->pThrowArrayBounds = art_quick_throw_array_bounds;
+  qpoints->pThrowDivZero = art_quick_throw_div_zero;
+  qpoints->pThrowNoSuchMethod = art_quick_throw_no_such_method;
+  qpoints->pThrowNullPointer = art_quick_throw_null_pointer_exception;
+  qpoints->pThrowStackOverflow = art_quick_throw_stack_overflow;
 };
 
 }  // namespace art
diff --git a/runtime/arch/arm/jni_entrypoints_arm.S b/runtime/arch/arm/jni_entrypoints_arm.S
index 0af470c540..f51f12183c 100644
--- a/runtime/arch/arm/jni_entrypoints_arm.S
+++ b/runtime/arch/arm/jni_entrypoints_arm.S
@@ -30,8 +30,7 @@ ENTRY art_jni_dlsym_lookup_stub
     sub    sp, #12                        @ pad stack pointer to align frame
     .pad #12
     .cfi_adjust_cfa_offset 12
-    mov    r0, r9                         @ pass Thread::Current
-    blx    artFindNativeMethod            @ (Thread*)
+    blx    artFindNativeMethod
     mov    r12, r0                        @ save result in r12
     add    sp, #12                        @ restore stack pointer
     .cfi_adjust_cfa_offset -12
@@ -46,7 +45,7 @@ END art_jni_dlsym_lookup_stub
      * Entry point of native methods when JNI bug compatibility is enabled.
      */
     .extern artWorkAroundAppJniBugs
-ENTRY art_quick_work_around_app_jni_bugs
+ENTRY art_work_around_app_jni_bugs
     @ save registers that may contain arguments and LR that will be crushed by a call
     push {r0-r3, lr}
     .save {r0-r3, lr}
@@ -64,4 +63,4 @@ ENTRY art_quick_work_around_app_jni_bugs
     pop {r0-r3, lr}  @ restore possibly modified argument registers
     .cfi_adjust_cfa_offset -16
     bx  r12          @ tail call into JNI routine
-END art_quick_work_around_app_jni_bugs
+END art_work_around_app_jni_bugs
diff --git a/runtime/arch/arm/portable_entrypoints_arm.S b/runtime/arch/arm/portable_entrypoints_arm.S
index 56333bab96..adfd22b331 100644
--- a/runtime/arch/arm/portable_entrypoints_arm.S
+++ b/runtime/arch/arm/portable_entrypoints_arm.S
@@ -96,3 +96,6 @@ ENTRY art_portable_proxy_invoke_handler
     .cfi_adjust_cfa_offset -48
     bx      lr                     @ return
 END art_portable_proxy_invoke_handler
+
+UNIMPLEMENTED art_portable_resolution_trampoline
+UNIMPLEMENTED art_portable_to_interpreter_bridge
diff --git a/runtime/arch/arm/quick_entrypoints_arm.S b/runtime/arch/arm/quick_entrypoints_arm.S
index 4de8c4d9f3..d9bb433c85 100644
--- a/runtime/arch/arm/quick_entrypoints_arm.S
+++ b/runtime/arch/arm/quick_entrypoints_arm.S
@@ -159,33 +159,33 @@ END \c_name
      * Called by managed code, saves callee saves and then calls artThrowException
      * that will place a mock Method* at the bottom of the stack. Arg1 holds the exception.
      */
-ONE_ARG_RUNTIME_EXCEPTION art_quick_deliver_exception_from_code, artDeliverExceptionFromCode
+ONE_ARG_RUNTIME_EXCEPTION art_quick_deliver_exception, artDeliverExceptionFromCode
 
     /*
      * Called by managed code to create and deliver a NullPointerException.
      */
-NO_ARG_RUNTIME_EXCEPTION art_quick_throw_null_pointer_exception_from_code, artThrowNullPointerExceptionFromCode
+NO_ARG_RUNTIME_EXCEPTION art_quick_throw_null_pointer_exception, artThrowNullPointerExceptionFromCode
 
     /*
      * Called by managed code to create and deliver an ArithmeticException.
      */
-NO_ARG_RUNTIME_EXCEPTION art_quick_throw_div_zero_from_code, artThrowDivZeroFromCode
+NO_ARG_RUNTIME_EXCEPTION art_quick_throw_div_zero, artThrowDivZeroFromCode
 
     /*
      * Called by managed code to create and deliver an ArrayIndexOutOfBoundsException. Arg1 holds
      * index, arg2 holds limit.
      */
-TWO_ARG_RUNTIME_EXCEPTION art_quick_throw_array_bounds_from_code, artThrowArrayBoundsFromCode
+TWO_ARG_RUNTIME_EXCEPTION art_quick_throw_array_bounds, artThrowArrayBoundsFromCode
 
     /*
      * Called by managed code to create and deliver a StackOverflowError.
      */
-NO_ARG_RUNTIME_EXCEPTION art_quick_throw_stack_overflow_from_code, artThrowStackOverflowFromCode
+NO_ARG_RUNTIME_EXCEPTION art_quick_throw_stack_overflow, artThrowStackOverflowFromCode
 
     /*
      * Called by managed code to create and deliver a NoSuchMethodError.
      */
-ONE_ARG_RUNTIME_EXCEPTION art_quick_throw_no_such_method_from_code, artThrowNoSuchMethodFromCode
+ONE_ARG_RUNTIME_EXCEPTION art_quick_throw_no_such_method, artThrowNoSuchMethodFromCode
 
     /*
      * All generated callsites for interface invokes and invocation slow paths will load arguments
@@ -296,7 +296,7 @@ END art_quick_do_long_jump
      * failure.
      */
     .extern artHandleFillArrayDataFromCode
-ENTRY art_quick_handle_fill_data_from_code
+ENTRY art_quick_handle_fill_data
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case exception allocation triggers GC
     mov    r2, r9                          @ pass Thread::Current
     mov    r3, sp                          @ pass SP
@@ -305,25 +305,25 @@ ENTRY art_quick_handle_fill_data_from_code
     cmp    r0, #0                          @ success?
     bxeq   lr                              @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_handle_fill_data_from_code
+END art_quick_handle_fill_data
 
     /*
      * Entry from managed code that calls artLockObjectFromCode, may block for GC.
      */
     .extern artLockObjectFromCode
-ENTRY art_quick_lock_object_from_code
+ENTRY art_quick_lock_object
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case we block
     mov    r1, r9                     @ pass Thread::Current
     mov    r2, sp                     @ pass SP
     bl     artLockObjectFromCode      @ (Object* obj, Thread*, SP)
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME_AND_RETURN
-END art_quick_lock_object_from_code
+END art_quick_lock_object
 
     /*
      * Entry from managed code that calls artUnlockObjectFromCode and delivers exception on failure.
      */
     .extern artUnlockObjectFromCode
-ENTRY art_quick_unlock_object_from_code
+ENTRY art_quick_unlock_object
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case exception allocation triggers GC
     mov    r1, r9                   @ pass Thread::Current
     mov    r2, sp                   @ pass SP
@@ -332,13 +332,13 @@ ENTRY art_quick_unlock_object_from_code
     cmp    r0, #0                   @ success?
     bxeq   lr                       @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_unlock_object_from_code
+END art_quick_unlock_object
 
     /*
      * Entry from managed code that calls artCheckCastFromCode and delivers exception on failure.
      */
     .extern artCheckCastFromCode
-ENTRY art_quick_check_cast_from_code
+ENTRY art_quick_check_cast
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME    @ save callee saves in case exception allocation triggers GC
     mov    r2, r9                       @ pass Thread::Current
     mov    r3, sp                       @ pass SP
@@ -347,14 +347,14 @@ ENTRY art_quick_check_cast_from_code
     cmp    r0, #0                       @ success?
     bxeq   lr                           @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_check_cast_from_code
+END art_quick_check_cast
 
     /*
      * Entry from managed code that calls artCanPutArrayElementFromCode and delivers exception on
      * failure.
      */
     .extern artCanPutArrayElementFromCode
-ENTRY art_quick_can_put_array_element_from_code
+ENTRY art_quick_can_put_array_element
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME    @ save callee saves in case exception allocation triggers GC
     mov    r2, r9                         @ pass Thread::Current
     mov    r3, sp                         @ pass SP
@@ -363,7 +363,7 @@ ENTRY art_quick_can_put_array_element_from_code
     cmp    r0, #0                         @ success?
     bxeq   lr                             @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_can_put_array_element_from_code
+END art_quick_can_put_array_element
 
     /*
      * Entry from managed code when uninitialized static storage, this stub will run the class
@@ -371,7 +371,7 @@ END art_quick_can_put_array_element_from_code
      * returned.
      */
     .extern artInitializeStaticStorageFromCode
-ENTRY art_quick_initialize_static_storage_from_code
+ENTRY art_quick_initialize_static_storage
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME           @ save callee saves in case of GC
     mov    r2, r9                              @ pass Thread::Current
     mov    r3, sp                              @ pass SP
@@ -381,13 +381,13 @@ ENTRY art_quick_initialize_static_storage_from_code
     cmp    r0, #0                              @ success if result is non-null
     bxne   lr                                  @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_initialize_static_storage_from_code
+END art_quick_initialize_static_storage
 
     /*
      * Entry from managed code when dex cache misses for a type_idx
      */
     .extern artInitializeTypeFromCode
-ENTRY art_quick_initialize_type_from_code
+ENTRY art_quick_initialize_type
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME           @ save callee saves in case of GC
     mov    r2, r9                              @ pass Thread::Current
     mov    r3, sp                              @ pass SP
@@ -397,14 +397,14 @@ ENTRY art_quick_initialize_type_from_code
     cmp    r0, #0                              @ success if result is non-null
     bxne   lr                                  @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_initialize_type_from_code
+END art_quick_initialize_type
 
     /*
      * Entry from managed code when type_idx needs to be checked for access and dex cache may also
      * miss.
      */
     .extern artInitializeTypeAndVerifyAccessFromCode
-ENTRY art_quick_initialize_type_and_verify_access_from_code
+ENTRY art_quick_initialize_type_and_verify_access
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME           @ save callee saves in case of GC
     mov    r2, r9                              @ pass Thread::Current
     mov    r3, sp                              @ pass SP
@@ -414,13 +414,13 @@ ENTRY art_quick_initialize_type_and_verify_access_from_code
     cmp    r0, #0                              @ success if result is non-null
     bxne   lr                                  @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_initialize_type_and_verify_access_from_code
+END art_quick_initialize_type_and_verify_access
 
     /*
      * Called by managed code to resolve a static field and load a 32-bit primitive value.
      */
     .extern artGet32StaticFromCode
-ENTRY art_quick_get32_static_from_code
+ENTRY art_quick_get32_static
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r1, [sp, #32]                 @ pass referrer
     mov    r2, r9                        @ pass Thread::Current
@@ -431,13 +431,13 @@ ENTRY art_quick_get32_static_from_code
     cmp    r12, #0                       @ success if no exception is pending
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_get32_static_from_code
+END art_quick_get32_static
 
     /*
      * Called by managed code to resolve a static field and load a 64-bit primitive value.
      */
     .extern artGet64StaticFromCode
-ENTRY art_quick_get64_static_from_code
+ENTRY art_quick_get64_static
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r1, [sp, #32]                 @ pass referrer
     mov    r2, r9                        @ pass Thread::Current
@@ -448,13 +448,13 @@ ENTRY art_quick_get64_static_from_code
     cmp    r12, #0                       @ success if no exception is pending
     bxeq    lr                           @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_get64_static_from_code
+END art_quick_get64_static
 
     /*
      * Called by managed code to resolve a static field and load an object reference.
      */
     .extern artGetObjStaticFromCode
-ENTRY art_quick_get_obj_static_from_code
+ENTRY art_quick_get_obj_static
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r1, [sp, #32]                 @ pass referrer
     mov    r2, r9                        @ pass Thread::Current
@@ -465,13 +465,13 @@ ENTRY art_quick_get_obj_static_from_code
     cmp    r12, #0                       @ success if no exception is pending
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_get_obj_static_from_code
+END art_quick_get_obj_static
 
     /*
      * Called by managed code to resolve an instance field and load a 32-bit primitive value.
      */
     .extern artGet32InstanceFromCode
-ENTRY art_quick_get32_instance_from_code
+ENTRY art_quick_get32_instance
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r2, [sp, #32]                 @ pass referrer
     mov    r3, r9                        @ pass Thread::Current
@@ -484,13 +484,13 @@ ENTRY art_quick_get32_instance_from_code
     cmp    r12, #0                       @ success if no exception is pending
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_get32_instance_from_code
+END art_quick_get32_instance
 
     /*
      * Called by managed code to resolve an instance field and load a 64-bit primitive value.
      */
     .extern artGet64InstanceFromCode
-ENTRY art_quick_get64_instance_from_code
+ENTRY art_quick_get64_instance
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r2, [sp, #32]                 @ pass referrer
     mov    r3, r9                        @ pass Thread::Current
@@ -506,13 +506,13 @@ ENTRY art_quick_get64_instance_from_code
     cmp    r12, #0                       @ success if no exception is pending
     bxeq    lr                           @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_get64_instance_from_code
+END art_quick_get64_instance
 
     /*
      * Called by managed code to resolve an instance field and load an object reference.
      */
     .extern artGetObjInstanceFromCode
-ENTRY art_quick_get_obj_instance_from_code
+ENTRY art_quick_get_obj_instance
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r2, [sp, #32]                 @ pass referrer
     mov    r3, r9                        @ pass Thread::Current
@@ -528,13 +528,13 @@ ENTRY art_quick_get_obj_instance_from_code
     cmp    r12, #0                       @ success if no exception is pending
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_get_obj_instance_from_code
+END art_quick_get_obj_instance
 
     /*
      * Called by managed code to resolve a static field and store a 32-bit primitive value.
      */
     .extern artSet32StaticFromCode
-ENTRY art_quick_set32_static_from_code
+ENTRY art_quick_set32_static
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r2, [sp, #32]                 @ pass referrer
     mov    r3, r9                        @ pass Thread::Current
@@ -549,14 +549,14 @@ ENTRY art_quick_set32_static_from_code
     cmp    r0, #0                        @ success if result is 0
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_set32_static_from_code
+END art_quick_set32_static
 
     /*
      * Called by managed code to resolve a static field and store a 64-bit primitive value.
      * On entry r0 holds field index, r1:r2 hold new_val
      */
     .extern artSet64StaticFromCode
-ENTRY art_quick_set64_static_from_code
+ENTRY art_quick_set64_static
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     mov    r3, r2                        @ pass one half of wide argument
     mov    r2, r1                        @ pass other half of wide argument
@@ -575,13 +575,13 @@ ENTRY art_quick_set64_static_from_code
     cmp    r0, #0                        @ success if result is 0
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_set64_static_from_code
+END art_quick_set64_static
 
     /*
      * Called by managed code to resolve a static field and store an object reference.
      */
     .extern artSetObjStaticFromCode
-ENTRY art_quick_set_obj_static_from_code
+ENTRY art_quick_set_obj_static
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r2, [sp, #32]                 @ pass referrer
     mov    r3, r9                        @ pass Thread::Current
@@ -596,13 +596,13 @@ ENTRY art_quick_set_obj_static_from_code
     cmp    r0, #0                        @ success if result is 0
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_set_obj_static_from_code
+END art_quick_set_obj_static
 
     /*
      * Called by managed code to resolve an instance field and store a 32-bit primitive value.
      */
     .extern artSet32InstanceFromCode
-ENTRY art_quick_set32_instance_from_code
+ENTRY art_quick_set32_instance
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r3, [sp, #32]                 @ pass referrer
     mov    r12, sp                       @ save SP
@@ -621,13 +621,13 @@ ENTRY art_quick_set32_instance_from_code
     cmp    r0, #0                        @ success if result is 0
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_set32_instance_from_code
+END art_quick_set32_instance
 
     /*
      * Called by managed code to resolve an instance field and store a 64-bit primitive value.
      */
     .extern artSet32InstanceFromCode
-ENTRY art_quick_set64_instance_from_code
+ENTRY art_quick_set64_instance
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     mov    r12, sp                       @ save SP
     sub    sp, #8                        @ grow frame for alignment with stack args
@@ -644,13 +644,13 @@ ENTRY art_quick_set64_instance_from_code
     cmp    r0, #0                        @ success if result is 0
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_set64_instance_from_code
+END art_quick_set64_instance
 
     /*
      * Called by managed code to resolve an instance field and store an object reference.
      */
     .extern artSetObjInstanceFromCode
-ENTRY art_quick_set_obj_instance_from_code
+ENTRY art_quick_set_obj_instance
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r3, [sp, #32]                 @ pass referrer
     mov    r12, sp                       @ save SP
@@ -668,7 +668,7 @@ ENTRY art_quick_set_obj_instance_from_code
     cmp    r0, #0                        @ success if result is 0
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_set_obj_instance_from_code
+END art_quick_set_obj_instance
 
     /*
      * Entry from managed code to resolve a string, this stub will allocate a String and deliver an
@@ -677,7 +677,7 @@ END art_quick_set_obj_instance_from_code
      * performed.
      */
     .extern artResolveStringFromCode
-ENTRY art_quick_resolve_string_from_code
+ENTRY art_quick_resolve_string
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r2, r9                     @ pass Thread::Current
     mov    r3, sp                     @ pass SP
@@ -687,13 +687,13 @@ ENTRY art_quick_resolve_string_from_code
     cmp    r0, #0                     @ success if result is non-null
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_resolve_string_from_code
+END art_quick_resolve_string
 
     /*
      * Called by managed code to allocate an object
      */
     .extern artAllocObjectFromCode
-ENTRY art_quick_alloc_object_from_code
+ENTRY art_quick_alloc_object
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r2, r9                     @ pass Thread::Current
     mov    r3, sp                     @ pass SP
@@ -702,14 +702,14 @@ ENTRY art_quick_alloc_object_from_code
     cmp    r0, #0                     @ success if result is non-null
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_alloc_object_from_code
+END art_quick_alloc_object
 
     /*
      * Called by managed code to allocate an object when the caller doesn't know whether it has
      * access to the created type.
      */
     .extern artAllocObjectFromCodeWithAccessCheck
-ENTRY art_quick_alloc_object_from_code_with_access_check
+ENTRY art_quick_alloc_object_with_access_check
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r2, r9                     @ pass Thread::Current
     mov    r3, sp                     @ pass SP
@@ -718,13 +718,13 @@ ENTRY art_quick_alloc_object_from_code_with_access_check
     cmp    r0, #0                     @ success if result is non-null
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_alloc_object_from_code_with_access_check
+END art_quick_alloc_object_with_access_check
 
     /*
      * Called by managed code to allocate an array.
      */
     .extern artAllocArrayFromCode
-ENTRY art_quick_alloc_array_from_code
+ENTRY art_quick_alloc_array
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r3, r9                     @ pass Thread::Current
     mov    r12, sp
@@ -739,14 +739,14 @@ ENTRY art_quick_alloc_array_from_code
     cmp    r0, #0                     @ success if result is non-null
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_alloc_array_from_code
+END art_quick_alloc_array
 
     /*
      * Called by managed code to allocate an array when the caller doesn't know whether it has
      * access to the created type.
      */
     .extern artAllocArrayFromCodeWithAccessCheck
-ENTRY art_quick_alloc_array_from_code_with_access_check
+ENTRY art_quick_alloc_array_with_access_check
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r3, r9                     @ pass Thread::Current
     mov    r12, sp
@@ -761,13 +761,13 @@ ENTRY art_quick_alloc_array_from_code_with_access_check
     cmp    r0, #0                     @ success if result is non-null
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_alloc_array_from_code_with_access_check
+END art_quick_alloc_array_with_access_check
 
     /*
      * Called by managed code to allocate an array in a special case for FILLED_NEW_ARRAY.
      */
     .extern artCheckAndAllocArrayFromCode
-ENTRY art_quick_check_and_alloc_array_from_code
+ENTRY art_quick_check_and_alloc_array
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r3, r9                     @ pass Thread::Current
     mov    r12, sp
@@ -782,13 +782,13 @@ ENTRY art_quick_check_and_alloc_array_from_code
     cmp    r0, #0                     @ success if result is non-null
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_check_and_alloc_array_from_code
+END art_quick_check_and_alloc_array
 
     /*
      * Called by managed code to allocate an array in a special case for FILLED_NEW_ARRAY.
      */
     .extern artCheckAndAllocArrayFromCodeWithAccessCheck
-ENTRY art_quick_check_and_alloc_array_from_code_with_access_check
+ENTRY art_quick_check_and_alloc_array_with_access_check
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r3, r9                     @ pass Thread::Current
     mov    r12, sp
@@ -803,7 +803,7 @@ ENTRY art_quick_check_and_alloc_array_from_code_with_access_check
     cmp    r0, #0                     @ success if result is non-null
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_check_and_alloc_array_from_code_with_access_check
+END art_quick_check_and_alloc_array_with_access_check
 
     /*
      * Called by managed code when the value in rSUSPEND has been decremented to 0.
@@ -842,13 +842,33 @@ ENTRY art_quick_proxy_invoke_handler
     DELIVER_PENDING_EXCEPTION
 END art_quick_proxy_invoke_handler
 
-    .extern artInterpreterEntry
-ENTRY art_quick_interpreter_entry
+    .extern artQuickResolutionTrampoline
+ENTRY art_quick_resolution_trampoline
+    SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
+    mov     r2, r9                 @ pass Thread::Current
+    mov     r3, sp                 @ pass SP
+    blx     artQuickResolutionTrampoline  @ (Method* called, receiver, Thread*, SP)
+    cmp     r0, #0                 @ is code pointer null?
+    beq     1f                     @ goto exception
+    mov     r12, r0
+    ldr  r0, [sp, #0]              @ load resolved method in r0
+    ldr  r1, [sp, #8]              @ restore non-callee save r1
+    ldrd r2, [sp, #12]             @ restore non-callee saves r2-r3
+    ldr  lr, [sp, #44]             @ restore lr
+    add  sp, #48                   @ rewind sp
+    .cfi_adjust_cfa_offset -48
+    bx      r12                    @ tail-call into actual code
+1:
+    RESTORE_REF_AND_ARGS_CALLEE_SAVE_FRAME
+    DELIVER_PENDING_EXCEPTION
+END art_quick_resolution_trampoline
+
+    .extern artQuickToInterpreterBridge
+ENTRY art_quick_to_interpreter_bridge
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
-    str     r0, [sp, #0]           @ place proxy method at bottom of frame
     mov     r1, r9                 @ pass Thread::Current
     mov     r2, sp                 @ pass SP
-    blx     artInterpreterEntry    @ (Method* method, Thread*, SP)
+    blx     artQuickToInterpreterBridge    @ (Method* method, Thread*, SP)
     ldr     r12, [r9, #THREAD_EXCEPTION_OFFSET]  @ load Thread::Current()->exception_
     ldr     lr,  [sp, #44]         @ restore lr
     add     sp,  #48               @ pop frame
@@ -856,14 +876,14 @@ ENTRY art_quick_interpreter_entry
     cmp     r12, #0                @ success if no exception is pending
     bxeq    lr                     @ return on success
     DELIVER_PENDING_EXCEPTION
-END art_quick_interpreter_entry
+END art_quick_to_interpreter_bridge
 
     /*
      * Routine that intercepts method calls and returns.
      */
     .extern artInstrumentationMethodEntryFromCode
     .extern artInstrumentationMethodExitFromCode
-ENTRY art_quick_instrumentation_entry_from_code
+ENTRY art_quick_instrumentation_entry
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
     str   r0, [sp, #4]     @ preserve r0
     mov   r12, sp          @ remember sp
@@ -879,11 +899,11 @@ ENTRY art_quick_instrumentation_entry_from_code
     mov   r12, r0        @ r12 holds reference to code
     ldr   r0, [sp, #4]   @ restore r0
     RESTORE_REF_AND_ARGS_CALLEE_SAVE_FRAME
-    blx   r12            @ call method with lr set to art_quick_instrumentation_exit_from_code
-END art_quick_instrumentation_entry_from_code
-    .type art_quick_instrumentation_exit_from_code, #function
-    .global art_quick_instrumentation_exit_from_code
-art_quick_instrumentation_exit_from_code:
+    blx   r12            @ call method with lr set to art_quick_instrumentation_exit
+END art_quick_instrumentation_entry
+    .type art_quick_instrumentation_exit, #function
+    .global art_quick_instrumentation_exit
+art_quick_instrumentation_exit:
     .cfi_startproc
     .fnstart
     mov   lr, #0         @ link register is to here, so clobber with 0 for later checks
@@ -912,7 +932,7 @@ art_quick_instrumentation_exit_from_code:
     add sp, #32          @ remove callee save frame
     .cfi_adjust_cfa_offset -32
     bx    r2             @ return
-END art_quick_instrumentation_exit_from_code
+END art_quick_instrumentation_exit
 
     /*
      * Instrumentation has requested that we deoptimize into the interpreter. The deoptimization
@@ -926,25 +946,6 @@ ENTRY art_quick_deoptimize
     blx    artDeoptimize  @ artDeoptimize(Thread*, SP)
 END art_quick_deoptimize
 
-    /*
-     * Portable abstract method error stub. r0 contains method* on entry. SP unused in portable.
-     */
-    .extern artThrowAbstractMethodErrorFromCode
-ENTRY art_portable_abstract_method_error_stub
-    mov    r1, r9         @ pass Thread::Current
-    b      artThrowAbstractMethodErrorFromCode  @ (Method*, Thread*, SP)
-END art_portable_abstract_method_error_stub
-
-    /*
-     * Quick abstract method error stub. r0 contains method* on entry.
-     */
-ENTRY art_quick_abstract_method_error_stub
-    SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
-    mov    r1, r9         @ pass Thread::Current
-    mov    r2, sp         @ pass SP
-    b      artThrowAbstractMethodErrorFromCode  @ (Method*, Thread*, SP)
-END art_quick_abstract_method_error_stub
-
     /*
      * Signed 64-bit integer multiply.
      *
diff --git a/runtime/arch/mips/asm_support_mips.S b/runtime/arch/mips/asm_support_mips.S
index 8a34b9dbd0..fe932d20c2 100644
--- a/runtime/arch/mips/asm_support_mips.S
+++ b/runtime/arch/mips/asm_support_mips.S
@@ -38,4 +38,12 @@
     .cpload $t9
 .endm
 
+.macro UNIMPLEMENTED name
+    ENTRY \name
+    break
+    break
+    END \name
+.endm
+
+
 #endif  // ART_RUNTIME_ARCH_MIPS_ASM_SUPPORT_MIPS_S_
diff --git a/runtime/arch/mips/entrypoints_init_mips.cc b/runtime/arch/mips/entrypoints_init_mips.cc
index 0a62a4096d..a18079b628 100644
--- a/runtime/arch/mips/entrypoints_init_mips.cc
+++ b/runtime/arch/mips/entrypoints_init_mips.cc
@@ -21,49 +21,61 @@
 
 namespace art {
 
+// Interpreter entrypoints.
+extern "C" void artInterpreterToInterpreterBridge(Thread* self, MethodHelper& mh,
+                                                 const DexFile::CodeItem* code_item,
+                                                 ShadowFrame* shadow_frame, JValue* result);
+extern "C" void artInterperterToCompiledCodeBridge(Thread* self, MethodHelper& mh,
+                                           const DexFile::CodeItem* code_item,
+                                           ShadowFrame* shadow_frame, JValue* result);
+
+// Portable entrypoints.
+extern "C" void art_portable_resolution_trampoline(mirror::AbstractMethod*);
+extern "C" void art_portable_to_interpreter_bridge(mirror::AbstractMethod*);
+
 // Alloc entrypoints.
-extern "C" void* art_quick_alloc_array_from_code(uint32_t, void*, int32_t);
-extern "C" void* art_quick_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
-extern "C" void* art_quick_alloc_object_from_code(uint32_t type_idx, void* method);
-extern "C" void* art_quick_alloc_object_from_code_with_access_check(uint32_t type_idx, void* method);
-extern "C" void* art_quick_check_and_alloc_array_from_code(uint32_t, void*, int32_t);
-extern "C" void* art_quick_check_and_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_array(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_array_with_access_check(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_object(uint32_t type_idx, void* method);
+extern "C" void* art_quick_alloc_object_with_access_check(uint32_t type_idx, void* method);
+extern "C" void* art_quick_check_and_alloc_array(uint32_t, void*, int32_t);
+extern "C" void* art_quick_check_and_alloc_array_with_access_check(uint32_t, void*, int32_t);
 
 // Cast entrypoints.
 extern "C" uint32_t artIsAssignableFromCode(const mirror::Class* klass,
                                             const mirror::Class* ref_class);
-extern "C" void art_quick_can_put_array_element_from_code(void*, void*);
-extern "C" void art_quick_check_cast_from_code(void*, void*);
+extern "C" void art_quick_can_put_array_element(void*, void*);
+extern "C" void art_quick_check_cast(void*, void*);
 
 // DexCache entrypoints.
-extern "C" void* art_quick_initialize_static_storage_from_code(uint32_t, void*);
-extern "C" void* art_quick_initialize_type_from_code(uint32_t, void*);
-extern "C" void* art_quick_initialize_type_and_verify_access_from_code(uint32_t, void*);
-extern "C" void* art_quick_resolve_string_from_code(void*, uint32_t);
+extern "C" void* art_quick_initialize_static_storage(uint32_t, void*);
+extern "C" void* art_quick_initialize_type(uint32_t, void*);
+extern "C" void* art_quick_initialize_type_and_verify_access(uint32_t, void*);
+extern "C" void* art_quick_resolve_string(void*, uint32_t);
 
 // Exception entrypoints.
 extern "C" void* GetAndClearException(Thread*);
 
 // Field entrypoints.
-extern "C" int art_quick_set32_instance_from_code(uint32_t, void*, int32_t);
-extern "C" int art_quick_set32_static_from_code(uint32_t, int32_t);
-extern "C" int art_quick_set64_instance_from_code(uint32_t, void*, int64_t);
-extern "C" int art_quick_set64_static_from_code(uint32_t, int64_t);
-extern "C" int art_quick_set_obj_instance_from_code(uint32_t, void*, void*);
-extern "C" int art_quick_set_obj_static_from_code(uint32_t, void*);
-extern "C" int32_t art_quick_get32_instance_from_code(uint32_t, void*);
-extern "C" int32_t art_quick_get32_static_from_code(uint32_t);
-extern "C" int64_t art_quick_get64_instance_from_code(uint32_t, void*);
-extern "C" int64_t art_quick_get64_static_from_code(uint32_t);
-extern "C" void* art_quick_get_obj_instance_from_code(uint32_t, void*);
-extern "C" void* art_quick_get_obj_static_from_code(uint32_t);
+extern "C" int art_quick_set32_instance(uint32_t, void*, int32_t);
+extern "C" int art_quick_set32_static(uint32_t, int32_t);
+extern "C" int art_quick_set64_instance(uint32_t, void*, int64_t);
+extern "C" int art_quick_set64_static(uint32_t, int64_t);
+extern "C" int art_quick_set_obj_instance(uint32_t, void*, void*);
+extern "C" int art_quick_set_obj_static(uint32_t, void*);
+extern "C" int32_t art_quick_get32_instance(uint32_t, void*);
+extern "C" int32_t art_quick_get32_static(uint32_t);
+extern "C" int64_t art_quick_get64_instance(uint32_t, void*);
+extern "C" int64_t art_quick_get64_static(uint32_t);
+extern "C" void* art_quick_get_obj_instance(uint32_t, void*);
+extern "C" void* art_quick_get_obj_static(uint32_t);
 
 // FillArray entrypoint.
-extern "C" void art_quick_handle_fill_data_from_code(void*, void*);
+extern "C" void art_quick_handle_fill_data(void*, void*);
 
 // Lock entrypoints.
-extern "C" void art_quick_lock_object_from_code(void*);
-extern "C" void art_quick_unlock_object_from_code(void*);
+extern "C" void art_quick_lock_object(void*);
+extern "C" void art_quick_unlock_object(void*);
 
 // Math entrypoints.
 extern int32_t CmpgDouble(double a, double b);
@@ -95,26 +107,14 @@ extern "C" uint64_t art_quick_shl_long(uint64_t, uint32_t);
 extern "C" uint64_t art_quick_shr_long(uint64_t, uint32_t);
 extern "C" uint64_t art_quick_ushr_long(uint64_t, uint32_t);
 
-// Interpreter entrypoints.
-extern "C" void artInterpreterToInterpreterEntry(Thread* self, MethodHelper& mh,
-                                                 const DexFile::CodeItem* code_item,
-                                                 ShadowFrame* shadow_frame, JValue* result);
-extern "C" void artInterpreterToQuickEntry(Thread* self, MethodHelper& mh,
-                                           const DexFile::CodeItem* code_item,
-                                           ShadowFrame* shadow_frame, JValue* result);
-
 // Intrinsic entrypoints.
 extern "C" int32_t __memcmp16(void*, void*, int32_t);
 extern "C" int32_t art_quick_indexof(void*, uint32_t, uint32_t, uint32_t);
 extern "C" int32_t art_quick_string_compareto(void*, void*);
 
 // Invoke entrypoints.
-extern "C" const void* artPortableResolutionTrampoline(mirror::AbstractMethod* called,
-                                                       mirror::Object* receiver,
-                                                       mirror::AbstractMethod** sp, Thread* thread);
-extern "C" const void* artQuickResolutionTrampoline(mirror::AbstractMethod* called,
-                                                    mirror::Object* receiver,
-                                                    mirror::AbstractMethod** sp, Thread* thread);
+extern "C" void art_quick_resolution_trampoline(mirror::AbstractMethod*);
+extern "C" void art_quick_to_interpreter_bridge(mirror::AbstractMethod*);
 extern "C" void art_quick_invoke_direct_trampoline_with_access_check(uint32_t, void*);
 extern "C" void art_quick_invoke_interface_trampoline(uint32_t, void*);
 extern "C" void art_quick_invoke_interface_trampoline_with_access_check(uint32_t, void*);
@@ -127,49 +127,61 @@ extern void CheckSuspendFromCode(Thread* thread);
 extern "C" void art_quick_test_suspend();
 
 // Throw entrypoints.
-extern "C" void art_quick_deliver_exception_from_code(void*);
-extern "C" void art_quick_throw_array_bounds_from_code(int32_t index, int32_t limit);
-extern "C" void art_quick_throw_div_zero_from_code();
-extern "C" void art_quick_throw_no_such_method_from_code(int32_t method_idx);
-extern "C" void art_quick_throw_null_pointer_exception_from_code();
-extern "C" void art_quick_throw_stack_overflow_from_code(void*);
-
-void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
+extern "C" void art_quick_deliver_exception(void*);
+extern "C" void art_quick_throw_array_bounds(int32_t index, int32_t limit);
+extern "C" void art_quick_throw_div_zero();
+extern "C" void art_quick_throw_no_such_method(int32_t method_idx);
+extern "C" void art_quick_throw_null_pointer_exception();
+extern "C" void art_quick_throw_stack_overflow(void*);
+
+void InitEntryPoints(InterpreterEntryPoints* ipoints, JniEntryPoints* jpoints,
+                     PortableEntryPoints* ppoints, QuickEntryPoints* qpoints) {
+  // Interpreter
+  ipoints->pInterpreterToInterpreterBridge = artInterpreterToInterpreterBridge;
+  ipoints->pInterpreterToCompiledCodeBridge = artInterperterToCompiledCodeBridge;
+
+  // JNI
+  jpoints->pDlsymLookup = art_jni_dlsym_lookup_stub;
+
+  // Portable
+  ppoints->pPortableResolutionTrampoline = art_portable_resolution_trampoline;
+  ppoints->pPortableToInterpreterBridge = art_portable_to_interpreter_bridge;
+
   // Alloc
-  qpoints->pAllocArrayFromCode = art_quick_alloc_array_from_code;
-  qpoints->pAllocArrayFromCodeWithAccessCheck = art_quick_alloc_array_from_code_with_access_check;
-  qpoints->pAllocObjectFromCode = art_quick_alloc_object_from_code;
-  qpoints->pAllocObjectFromCodeWithAccessCheck = art_quick_alloc_object_from_code_with_access_check;
-  qpoints->pCheckAndAllocArrayFromCode = art_quick_check_and_alloc_array_from_code;
-  qpoints->pCheckAndAllocArrayFromCodeWithAccessCheck = art_quick_check_and_alloc_array_from_code_with_access_check;
+  qpoints->pAllocArray = art_quick_alloc_array;
+  qpoints->pAllocArrayWithAccessCheck = art_quick_alloc_array_with_access_check;
+  qpoints->pAllocObject = art_quick_alloc_object;
+  qpoints->pAllocObjectWithAccessCheck = art_quick_alloc_object_with_access_check;
+  qpoints->pCheckAndAllocArray = art_quick_check_and_alloc_array;
+  qpoints->pCheckAndAllocArrayWithAccessCheck = art_quick_check_and_alloc_array_with_access_check;
 
   // Cast
-  qpoints->pInstanceofNonTrivialFromCode = artIsAssignableFromCode;
-  qpoints->pCanPutArrayElementFromCode = art_quick_can_put_array_element_from_code;
-  qpoints->pCheckCastFromCode = art_quick_check_cast_from_code;
+  qpoints->pInstanceofNonTrivial = artIsAssignableFromCode;
+  qpoints->pCanPutArrayElement = art_quick_can_put_array_element;
+  qpoints->pCheckCast = art_quick_check_cast;
 
   // DexCache
-  qpoints->pInitializeStaticStorage = art_quick_initialize_static_storage_from_code;
-  qpoints->pInitializeTypeAndVerifyAccessFromCode = art_quick_initialize_type_and_verify_access_from_code;
-  qpoints->pInitializeTypeFromCode = art_quick_initialize_type_from_code;
-  qpoints->pResolveStringFromCode = art_quick_resolve_string_from_code;
+  qpoints->pInitializeStaticStorage = art_quick_initialize_static_storage;
+  qpoints->pInitializeTypeAndVerifyAccess = art_quick_initialize_type_and_verify_access;
+  qpoints->pInitializeType = art_quick_initialize_type;
+  qpoints->pResolveString = art_quick_resolve_string;
 
   // Field
-  qpoints->pSet32Instance = art_quick_set32_instance_from_code;
-  qpoints->pSet32Static = art_quick_set32_static_from_code;
-  qpoints->pSet64Instance = art_quick_set64_instance_from_code;
-  qpoints->pSet64Static = art_quick_set64_static_from_code;
-  qpoints->pSetObjInstance = art_quick_set_obj_instance_from_code;
-  qpoints->pSetObjStatic = art_quick_set_obj_static_from_code;
-  qpoints->pGet32Instance = art_quick_get32_instance_from_code;
-  qpoints->pGet64Instance = art_quick_get64_instance_from_code;
-  qpoints->pGetObjInstance = art_quick_get_obj_instance_from_code;
-  qpoints->pGet32Static = art_quick_get32_static_from_code;
-  qpoints->pGet64Static = art_quick_get64_static_from_code;
-  qpoints->pGetObjStatic = art_quick_get_obj_static_from_code;
+  qpoints->pSet32Instance = art_quick_set32_instance;
+  qpoints->pSet32Static = art_quick_set32_static;
+  qpoints->pSet64Instance = art_quick_set64_instance;
+  qpoints->pSet64Static = art_quick_set64_static;
+  qpoints->pSetObjInstance = art_quick_set_obj_instance;
+  qpoints->pSetObjStatic = art_quick_set_obj_static;
+  qpoints->pGet32Instance = art_quick_get32_instance;
+  qpoints->pGet64Instance = art_quick_get64_instance;
+  qpoints->pGetObjInstance = art_quick_get_obj_instance;
+  qpoints->pGet32Static = art_quick_get32_static;
+  qpoints->pGet64Static = art_quick_get64_static;
+  qpoints->pGetObjStatic = art_quick_get_obj_static;
 
   // FillArray
-  qpoints->pHandleFillArrayDataFromCode = art_quick_handle_fill_data_from_code;
+  qpoints->pHandleFillArrayData = art_quick_handle_fill_data;
 
   // JNI
   qpoints->pJniMethodStart = JniMethodStart;
@@ -180,8 +192,8 @@ void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
   qpoints->pJniMethodEndWithReferenceSynchronized = JniMethodEndWithReferenceSynchronized;
 
   // Locks
-  qpoints->pLockObjectFromCode = art_quick_lock_object_from_code;
-  qpoints->pUnlockObjectFromCode = art_quick_unlock_object_from_code;
+  qpoints->pLockObject = art_quick_lock_object;
+  qpoints->pUnlockObject = art_quick_unlock_object;
 
   // Math
   qpoints->pCmpgDouble = CmpgDouble;
@@ -204,10 +216,6 @@ void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
   qpoints->pShrLong = art_quick_shr_long;
   qpoints->pUshrLong = art_quick_ushr_long;
 
-  // Interpreter
-  qpoints->pInterpreterToInterpreterEntry = artInterpreterToInterpreterEntry;
-  qpoints->pInterpreterToQuickEntry = artInterpreterToQuickEntry;
-
   // Intrinsics
   qpoints->pIndexOf = art_quick_indexof;
   qpoints->pMemcmp16 = __memcmp16;
@@ -215,7 +223,8 @@ void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
   qpoints->pMemcpy = memcpy;
 
   // Invocation
-  qpoints->pQuickResolutionTrampolineFromCode = artQuickResolutionTrampoline;
+  qpoints->pQuickResolutionTrampoline = art_quick_resolution_trampoline;
+  qpoints->pQuickToInterpreterBridge = art_quick_to_interpreter_bridge;
   qpoints->pInvokeDirectTrampolineWithAccessCheck = art_quick_invoke_direct_trampoline_with_access_check;
   qpoints->pInvokeInterfaceTrampoline = art_quick_invoke_interface_trampoline;
   qpoints->pInvokeInterfaceTrampolineWithAccessCheck = art_quick_invoke_interface_trampoline_with_access_check;
@@ -224,19 +233,16 @@ void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
   qpoints->pInvokeVirtualTrampolineWithAccessCheck = art_quick_invoke_virtual_trampoline_with_access_check;
 
   // Thread
-  qpoints->pCheckSuspendFromCode = CheckSuspendFromCode;
-  qpoints->pTestSuspendFromCode = art_quick_test_suspend;
+  qpoints->pCheckSuspend = CheckSuspendFromCode;
+  qpoints->pTestSuspend = art_quick_test_suspend;
 
   // Throws
-  qpoints->pDeliverException = art_quick_deliver_exception_from_code;
-  qpoints->pThrowArrayBoundsFromCode = art_quick_throw_array_bounds_from_code;
-  qpoints->pThrowDivZeroFromCode = art_quick_throw_div_zero_from_code;
-  qpoints->pThrowNoSuchMethodFromCode = art_quick_throw_no_such_method_from_code;
-  qpoints->pThrowNullPointerFromCode = art_quick_throw_null_pointer_exception_from_code;
-  qpoints->pThrowStackOverflowFromCode = art_quick_throw_stack_overflow_from_code;
-
-  // Portable
-  ppoints->pPortableResolutionTrampolineFromCode = artPortableResolutionTrampoline;
+  qpoints->pDeliverException = art_quick_deliver_exception;
+  qpoints->pThrowArrayBounds = art_quick_throw_array_bounds;
+  qpoints->pThrowDivZero = art_quick_throw_div_zero;
+  qpoints->pThrowNoSuchMethod = art_quick_throw_no_such_method;
+  qpoints->pThrowNullPointer = art_quick_throw_null_pointer_exception;
+  qpoints->pThrowStackOverflow = art_quick_throw_stack_overflow;
 };
 
 }  // namespace art
diff --git a/runtime/arch/mips/jni_entrypoints_mips.S b/runtime/arch/mips/jni_entrypoints_mips.S
index fca6d777ab..ad7c021762 100644
--- a/runtime/arch/mips/jni_entrypoints_mips.S
+++ b/runtime/arch/mips/jni_entrypoints_mips.S
@@ -59,7 +59,7 @@ END art_jni_dlsym_lookup_stub
      * Entry point of native methods when JNI bug compatibility is enabled.
      */
     .extern artWorkAroundAppJniBugs
-ENTRY art_quick_work_around_app_jni_bugs
+ENTRY art_work_around_app_jni_bugs
     GENERATE_GLOBAL_POINTER
     # save registers that may contain arguments and LR that will be crushed by a call
     addiu    $sp, $sp, -32
@@ -86,4 +86,4 @@ ENTRY art_quick_work_around_app_jni_bugs
     jr       $t9              # tail call into JNI routine
     addiu    $sp, $sp, 32
     .cfi_adjust_cfa_offset -32
-END art_quick_work_around_app_jni_bugs
+END art_work_around_app_jni_bugs
diff --git a/runtime/arch/mips/portable_entrypoints_mips.S b/runtime/arch/mips/portable_entrypoints_mips.S
index e7a9b0fb60..9208a8a4f5 100644
--- a/runtime/arch/mips/portable_entrypoints_mips.S
+++ b/runtime/arch/mips/portable_entrypoints_mips.S
@@ -61,13 +61,5 @@ ENTRY art_portable_proxy_invoke_handler
     .cfi_adjust_cfa_offset -64
 END art_portable_proxy_invoke_handler
 
-    /*
-     * Portable abstract method error stub. $a0 contains method* on entry. SP unused in portable.
-     */
-    .extern artThrowAbstractMethodErrorFromCode
-ENTRY art_portable_abstract_method_error_stub
-    GENERATE_GLOBAL_POINTER
-    la       $t9, artThrowAbstractMethodErrorFromCode
-    jr       $t9            # (Method*, Thread*, SP)
-    move     $a1, $s1       # pass Thread::Current
-END art_portable_abstract_method_error_stub
+UNIMPLEMENTED art_portable_resolution_trampoline
+UNIMPLEMENTED art_portable_to_interpreter_bridge
diff --git a/runtime/arch/mips/quick_entrypoints_mips.S b/runtime/arch/mips/quick_entrypoints_mips.S
index d32a2b4a15..004fda60f1 100644
--- a/runtime/arch/mips/quick_entrypoints_mips.S
+++ b/runtime/arch/mips/quick_entrypoints_mips.S
@@ -143,7 +143,7 @@
     lw     $a1, 4($sp)            # restore non-callee save $a1
     lw     $a2, 8($sp)            # restore non-callee save $a2
     lw     $a3, 12($sp)           # restore non-callee save $a3
-    addiu  $sp, $sp, 64           # strip frame
+    addiu  $sp, $sp, 64           # pop frame
     .cfi_adjust_cfa_offset -64
 .endm
 
@@ -268,79 +268,79 @@ END art_quick_do_long_jump
      * the bottom of the stack. artDeliverExceptionFromCode will place the callee save Method* at
      * the bottom of the thread. On entry r0 holds Throwable*
      */
-ENTRY art_quick_deliver_exception_from_code
+ENTRY art_quick_deliver_exception
     GENERATE_GLOBAL_POINTER
     SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
     move $a1, rSELF                 # pass Thread::Current
     la   $t9, artDeliverExceptionFromCode
     jr   $t9                        # artDeliverExceptionFromCode(Throwable*, Thread*, $sp)
     move $a2, $sp                   # pass $sp
-END art_quick_deliver_exception_from_code
+END art_quick_deliver_exception
 
     /*
      * Called by managed code to create and deliver a NullPointerException
      */
     .extern artThrowNullPointerExceptionFromCode
-ENTRY art_quick_throw_null_pointer_exception_from_code
+ENTRY art_quick_throw_null_pointer_exception
     GENERATE_GLOBAL_POINTER
     SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
     move $a0, rSELF                 # pass Thread::Current
     la   $t9, artThrowNullPointerExceptionFromCode
     jr   $t9                        # artThrowNullPointerExceptionFromCode(Thread*, $sp)
     move $a1, $sp                   # pass $sp
-END art_quick_throw_null_pointer_exception_from_code
+END art_quick_throw_null_pointer_exception
 
     /*
      * Called by managed code to create and deliver an ArithmeticException
      */
     .extern artThrowDivZeroFromCode
-ENTRY art_quick_throw_div_zero_from_code
+ENTRY art_quick_throw_div_zero
     GENERATE_GLOBAL_POINTER
     SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
     move $a0, rSELF                 # pass Thread::Current
     la   $t9, artThrowDivZeroFromCode
     jr   $t9                        # artThrowDivZeroFromCode(Thread*, $sp)
     move $a1, $sp                   # pass $sp
-END art_quick_throw_div_zero_from_code
+END art_quick_throw_div_zero
 
     /*
      * Called by managed code to create and deliver an ArrayIndexOutOfBoundsException
      */
     .extern artThrowArrayBoundsFromCode
-ENTRY art_quick_throw_array_bounds_from_code
+ENTRY art_quick_throw_array_bounds
     GENERATE_GLOBAL_POINTER
     SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
     move $a2, rSELF                 # pass Thread::Current
     la   $t9, artThrowArrayBoundsFromCode
     jr   $t9                        # artThrowArrayBoundsFromCode(index, limit, Thread*, $sp)
     move $a3, $sp                   # pass $sp
-END art_quick_throw_array_bounds_from_code
+END art_quick_throw_array_bounds
 
     /*
      * Called by managed code to create and deliver a StackOverflowError.
      */
     .extern artThrowStackOverflowFromCode
-ENTRY art_quick_throw_stack_overflow_from_code
+ENTRY art_quick_throw_stack_overflow
     GENERATE_GLOBAL_POINTER
     SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
     move $a0, rSELF                 # pass Thread::Current
     la   $t9, artThrowStackOverflowFromCode
     jr   $t9                        # artThrowStackOverflowFromCode(Thread*, $sp)
     move $a1, $sp                   # pass $sp
-END art_quick_throw_stack_overflow_from_code
+END art_quick_throw_stack_overflow
 
     /*
      * Called by managed code to create and deliver a NoSuchMethodError.
      */
     .extern artThrowNoSuchMethodFromCode
-ENTRY art_quick_throw_no_such_method_from_code
+ENTRY art_quick_throw_no_such_method
     GENERATE_GLOBAL_POINTER
     SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
     move $a1, rSELF                 # pass Thread::Current
     la   $t9, artThrowNoSuchMethodFromCode
     jr   $t9                        # artThrowNoSuchMethodFromCode(method_idx, Thread*, $sp)
     move $a2, $sp                   # pass $sp
-END art_quick_throw_no_such_method_from_code
+END art_quick_throw_no_such_method
 
     /*
      * All generated callsites for interface invokes and invocation slow paths will load arguments
@@ -466,67 +466,67 @@ END art_quick_invoke_stub
      * failure.
      */
     .extern artHandleFillArrayDataFromCode
-ENTRY art_quick_handle_fill_data_from_code
+ENTRY art_quick_handle_fill_data
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case exception allocation triggers GC
     move    $a2, rSELF                         # pass Thread::Current
     jal     artHandleFillArrayDataFromCode     # (Array*, const DexFile::Payload*, Thread*, $sp)
     move    $a3, $sp                           # pass $sp
     RETURN_IF_ZERO
-END art_quick_handle_fill_data_from_code
+END art_quick_handle_fill_data
 
     /*
      * Entry from managed code that calls artLockObjectFromCode, may block for GC.
      */
     .extern artLockObjectFromCode
-ENTRY art_quick_lock_object_from_code
+ENTRY art_quick_lock_object
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME      # save callee saves in case we block
     move    $a1, rSELF                    # pass Thread::Current
     jal     artLockObjectFromCode         # (Object* obj, Thread*, $sp)
     move    $a2, $sp                      # pass $sp
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME_AND_RETURN
-END art_quick_lock_object_from_code
+END art_quick_lock_object
 
     /*
      * Entry from managed code that calls artUnlockObjectFromCode and delivers exception on failure.
      */
     .extern artUnlockObjectFromCode
-ENTRY art_quick_unlock_object_from_code
+ENTRY art_quick_unlock_object
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case exception allocation triggers GC
     move    $a1, rSELF                # pass Thread::Current
     jal     artUnlockObjectFromCode   # (Object* obj, Thread*, $sp)
     move    $a2, $sp                  # pass $sp
     RETURN_IF_ZERO
-END art_quick_unlock_object_from_code
+END art_quick_unlock_object
 
     /*
      * Entry from managed code that calls artCheckCastFromCode and delivers exception on failure.
      */
     .extern artCheckCastFromCode
-ENTRY art_quick_check_cast_from_code
+ENTRY art_quick_check_cast
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case exception allocation triggers GC
     move    $a2, rSELF                # pass Thread::Current
     jal     artCheckCastFromCode      # (Class* a, Class* b, Thread*, $sp)
     move    $a3, $sp                  # pass $sp
     RETURN_IF_ZERO
-END art_quick_check_cast_from_code
+END art_quick_check_cast
 
     /*
      * Entry from managed code that calls artCanPutArrayElementFromCode and delivers exception on
      * failure.
      */
     .extern artCanPutArrayElementFromCode
-ENTRY art_quick_can_put_array_element_from_code
+ENTRY art_quick_can_put_array_element
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME    # save callee saves in case exception allocation triggers GC
     move    $a2, rSELF                     # pass Thread::Current
     jal     artCanPutArrayElementFromCode  # (Object* element, Class* array_class, Thread*, $sp)
     move    $a3, $sp                       # pass $sp
     RETURN_IF_ZERO
-END art_quick_can_put_array_element_from_code
+END art_quick_can_put_array_element
 
     /*
      * Entry from managed code when uninitialized static storage, this stub will run the class
@@ -534,7 +534,7 @@ END art_quick_can_put_array_element_from_code
      * returned.
      */
     .extern artInitializeStaticStorageFromCode
-ENTRY art_quick_initialize_static_storage_from_code
+ENTRY art_quick_initialize_static_storage
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME            # save callee saves in case of GC
     move    $a2, rSELF                          # pass Thread::Current
@@ -542,13 +542,13 @@ ENTRY art_quick_initialize_static_storage_from_code
     jal     artInitializeStaticStorageFromCode
     move    $a3, $sp                            # pass $sp
     RETURN_IF_NONZERO
-END art_quick_initialize_static_storage_from_code
+END art_quick_initialize_static_storage
 
     /*
      * Entry from managed code when dex cache misses for a type_idx.
      */
     .extern artInitializeTypeFromCode
-ENTRY art_quick_initialize_type_from_code
+ENTRY art_quick_initialize_type
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME           # save callee saves in case of GC
     move    $a2, rSELF                         # pass Thread::Current
@@ -556,14 +556,14 @@ ENTRY art_quick_initialize_type_from_code
     jal     artInitializeTypeFromCode
     move    $a3, $sp                           # pass $sp
     RETURN_IF_NONZERO
-END art_quick_initialize_type_from_code
+END art_quick_initialize_type
 
     /*
      * Entry from managed code when type_idx needs to be checked for access and dex cache may also
      * miss.
      */
     .extern artInitializeTypeAndVerifyAccessFromCode
-ENTRY art_quick_initialize_type_and_verify_access_from_code
+ENTRY art_quick_initialize_type_and_verify_access
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME           # save callee saves in case of GC
     move    $a2, rSELF                         # pass Thread::Current
@@ -571,13 +571,13 @@ ENTRY art_quick_initialize_type_and_verify_access_from_code
     jal     artInitializeTypeAndVerifyAccessFromCode
     move    $a3, $sp                           # pass $sp
     RETURN_IF_NONZERO
-END art_quick_initialize_type_and_verify_access_from_code
+END art_quick_initialize_type_and_verify_access
 
     /*
      * Called by managed code to resolve a static field and load a 32-bit primitive value.
      */
     .extern artGet32StaticFromCode
-ENTRY art_quick_get32_static_from_code
+ENTRY art_quick_get32_static
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a1, 64($sp)                  # pass referrer's Method*
@@ -585,13 +585,13 @@ ENTRY art_quick_get32_static_from_code
     jal    artGet32StaticFromCode        # (uint32_t field_idx, const Method* referrer, Thread*, $sp)
     move   $a3, $sp                      # pass $sp
     RETURN_IF_NO_EXCEPTION
-END art_quick_get32_static_from_code
+END art_quick_get32_static
 
     /*
      * Called by managed code to resolve a static field and load a 64-bit primitive value.
      */
     .extern artGet64StaticFromCode
-ENTRY art_quick_get64_static_from_code
+ENTRY art_quick_get64_static
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a1, 64($sp)                  # pass referrer's Method*
@@ -599,13 +599,13 @@ ENTRY art_quick_get64_static_from_code
     jal    artGet64StaticFromCode        # (uint32_t field_idx, const Method* referrer, Thread*, $sp)
     move   $a3, $sp                      # pass $sp
     RETURN_IF_NO_EXCEPTION
-END art_quick_get64_static_from_code
+END art_quick_get64_static
 
     /*
      * Called by managed code to resolve a static field and load an object reference.
      */
     .extern artGetObjStaticFromCode
-ENTRY art_quick_get_obj_static_from_code
+ENTRY art_quick_get_obj_static
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a1, 64($sp)                  # pass referrer's Method*
@@ -613,13 +613,13 @@ ENTRY art_quick_get_obj_static_from_code
     jal    artGetObjStaticFromCode       # (uint32_t field_idx, const Method* referrer, Thread*, $sp)
     move   $a3, $sp                      # pass $sp
     RETURN_IF_NO_EXCEPTION
-END art_quick_get_obj_static_from_code
+END art_quick_get_obj_static
 
     /*
      * Called by managed code to resolve an instance field and load a 32-bit primitive value.
      */
     .extern artGet32InstanceFromCode
-ENTRY art_quick_get32_instance_from_code
+ENTRY art_quick_get32_instance
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a2, 64($sp)                  # pass referrer's Method*
@@ -627,13 +627,13 @@ ENTRY art_quick_get32_instance_from_code
     jal    artGet32InstanceFromCode      # (field_idx, Object*, referrer, Thread*, $sp)
     sw     $sp, 16($sp)                  # pass $sp
     RETURN_IF_NO_EXCEPTION
-END art_quick_get32_instance_from_code
+END art_quick_get32_instance
 
     /*
      * Called by managed code to resolve an instance field and load a 64-bit primitive value.
      */
     .extern artGet64InstanceFromCode
-ENTRY art_quick_get64_instance_from_code
+ENTRY art_quick_get64_instance
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a2, 64($sp)                  # pass referrer's Method*
@@ -641,13 +641,13 @@ ENTRY art_quick_get64_instance_from_code
     jal    artGet64InstanceFromCode      # (field_idx, Object*, referrer, Thread*, $sp)
     sw     $sp, 16($sp)                  # pass $sp
     RETURN_IF_NO_EXCEPTION
-END art_quick_get64_instance_from_code
+END art_quick_get64_instance
 
     /*
      * Called by managed code to resolve an instance field and load an object reference.
      */
     .extern artGetObjInstanceFromCode
-ENTRY art_quick_get_obj_instance_from_code
+ENTRY art_quick_get_obj_instance
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a2, 64($sp)                  # pass referrer's Method*
@@ -655,13 +655,13 @@ ENTRY art_quick_get_obj_instance_from_code
     jal    artGetObjInstanceFromCode     # (field_idx, Object*, referrer, Thread*, $sp)
     sw     $sp, 16($sp)                  # pass $sp
     RETURN_IF_NO_EXCEPTION
-END art_quick_get_obj_instance_from_code
+END art_quick_get_obj_instance
 
     /*
      * Called by managed code to resolve a static field and store a 32-bit primitive value.
      */
     .extern artSet32StaticFromCode
-ENTRY art_quick_set32_static_from_code
+ENTRY art_quick_set32_static
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a2, 64($sp)                  # pass referrer's Method*
@@ -669,13 +669,13 @@ ENTRY art_quick_set32_static_from_code
     jal    artSet32StaticFromCode        # (field_idx, new_val, referrer, Thread*, $sp)
     sw     $sp, 16($sp)                  # pass $sp
     RETURN_IF_ZERO
-END art_quick_set32_static_from_code
+END art_quick_set32_static
 
     /*
      * Called by managed code to resolve a static field and store a 64-bit primitive value.
      */
     .extern artSet32StaticFromCode
-ENTRY art_quick_set64_static_from_code
+ENTRY art_quick_set64_static
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a1, 64($sp)                  # pass referrer's Method*
@@ -683,13 +683,13 @@ ENTRY art_quick_set64_static_from_code
     jal    artSet64StaticFromCode        # (field_idx, referrer, new_val, Thread*, $sp)
     sw     $sp, 20($sp)                  # pass $sp
     RETURN_IF_ZERO
-END art_quick_set64_static_from_code
+END art_quick_set64_static
 
     /*
      * Called by managed code to resolve a static field and store an object reference.
      */
     .extern artSetObjStaticFromCode
-ENTRY art_quick_set_obj_static_from_code
+ENTRY art_quick_set_obj_static
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a2, 64($sp)                  # pass referrer's Method*
@@ -697,13 +697,13 @@ ENTRY art_quick_set_obj_static_from_code
     jal    artSetObjStaticFromCode       # (field_idx, new_val, referrer, Thread*, $sp)
     sw     $sp, 16($sp)                  # pass $sp
     RETURN_IF_ZERO
-END art_quick_set_obj_static_from_code
+END art_quick_set_obj_static
 
     /*
      * Called by managed code to resolve an instance field and store a 32-bit primitive value.
      */
     .extern artSet32InstanceFromCode
-ENTRY art_quick_set32_instance_from_code
+ENTRY art_quick_set32_instance
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a3, 64($sp)                  # pass referrer's Method*
@@ -711,26 +711,26 @@ ENTRY art_quick_set32_instance_from_code
     jal    artSet32InstanceFromCode      # (field_idx, Object*, new_val, referrer, Thread*, $sp)
     sw     $sp, 20($sp)                  # pass $sp
     RETURN_IF_ZERO
-END art_quick_set32_instance_from_code
+END art_quick_set32_instance
 
     /*
      * Called by managed code to resolve an instance field and store a 64-bit primitive value.
      */
     .extern artSet32InstanceFromCode
-ENTRY art_quick_set64_instance_from_code
+ENTRY art_quick_set64_instance
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     sw     rSELF, 16($sp)                # pass Thread::Current
     jal    artSet64InstanceFromCode      # (field_idx, Object*, new_val, Thread*, $sp)
     sw     $sp, 20($sp)                  # pass $sp
     RETURN_IF_ZERO
-END art_quick_set64_instance_from_code
+END art_quick_set64_instance
 
     /*
      * Called by managed code to resolve an instance field and store an object reference.
      */
     .extern artSetObjInstanceFromCode
-ENTRY art_quick_set_obj_instance_from_code
+ENTRY art_quick_set_obj_instance
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a3, 64($sp)                  # pass referrer's Method*
@@ -738,7 +738,7 @@ ENTRY art_quick_set_obj_instance_from_code
     jal    artSetObjInstanceFromCode     # (field_idx, Object*, new_val, referrer, Thread*, $sp)
     sw     $sp, 20($sp)                  # pass $sp
     RETURN_IF_ZERO
-END art_quick_set_obj_instance_from_code
+END art_quick_set_obj_instance
 
     /*
      * Entry from managed code to resolve a string, this stub will allocate a String and deliver an
@@ -747,7 +747,7 @@ END art_quick_set_obj_instance_from_code
      * performed.
      */
     .extern artResolveStringFromCode
-ENTRY art_quick_resolve_string_from_code
+ENTRY art_quick_resolve_string
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a2, rSELF                # pass Thread::Current
@@ -755,40 +755,40 @@ ENTRY art_quick_resolve_string_from_code
     jal     artResolveStringFromCode
     move    $a3, $sp                  # pass $sp
     RETURN_IF_NONZERO
-END art_quick_resolve_string_from_code
+END art_quick_resolve_string
 
     /*
      * Called by managed code to allocate an object.
      */
     .extern artAllocObjectFromCode
-ENTRY art_quick_alloc_object_from_code
+ENTRY art_quick_alloc_object
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a2, rSELF                # pass Thread::Current
     jal     artAllocObjectFromCode    # (uint32_t type_idx, Method* method, Thread*, $sp)
     move    $a3, $sp                  # pass $sp
     RETURN_IF_NONZERO
-END art_quick_alloc_object_from_code
+END art_quick_alloc_object
 
     /*
      * Called by managed code to allocate an object when the caller doesn't know whether it has
      * access to the created type.
      */
     .extern artAllocObjectFromCodeWithAccessCheck
-ENTRY art_quick_alloc_object_from_code_with_access_check
+ENTRY art_quick_alloc_object_with_access_check
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a2, rSELF                # pass Thread::Current
     jal     artAllocObjectFromCodeWithAccessCheck  # (uint32_t type_idx, Method* method, Thread*, $sp)
     move    $a3, $sp                  # pass $sp
     RETURN_IF_NONZERO
-END art_quick_alloc_object_from_code_with_access_check
+END art_quick_alloc_object_with_access_check
 
     /*
      * Called by managed code to allocate an array.
      */
     .extern artAllocArrayFromCode
-ENTRY art_quick_alloc_array_from_code
+ENTRY art_quick_alloc_array
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a3, rSELF                # pass Thread::Current
@@ -796,14 +796,14 @@ ENTRY art_quick_alloc_array_from_code
     jal     artAllocArrayFromCode
     sw      $sp, 16($sp)              # pass $sp
     RETURN_IF_NONZERO
-END art_quick_alloc_array_from_code
+END art_quick_alloc_array
 
     /*
      * Called by managed code to allocate an array when the caller doesn't know whether it has
      * access to the created type.
      */
     .extern artAllocArrayFromCodeWithAccessCheck
-ENTRY art_quick_alloc_array_from_code_with_access_check
+ENTRY art_quick_alloc_array_with_access_check
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a3, rSELF                # pass Thread::Current
@@ -811,13 +811,13 @@ ENTRY art_quick_alloc_array_from_code_with_access_check
     jal     artAllocArrayFromCodeWithAccessCheck
     sw      $sp, 16($sp)              # pass $sp
     RETURN_IF_NONZERO
-END art_quick_alloc_array_from_code_with_access_check
+END art_quick_alloc_array_with_access_check
 
     /*
      * Called by managed code to allocate an array in a special case for FILLED_NEW_ARRAY.
      */
     .extern artCheckAndAllocArrayFromCode
-ENTRY art_quick_check_and_alloc_array_from_code
+ENTRY art_quick_check_and_alloc_array
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a3, rSELF                # pass Thread::Current
@@ -825,13 +825,13 @@ ENTRY art_quick_check_and_alloc_array_from_code
     jal     artCheckAndAllocArrayFromCode
     sw      $sp, 16($sp)              # pass $sp
     RETURN_IF_NONZERO
-END art_quick_check_and_alloc_array_from_code
+END art_quick_check_and_alloc_array
 
     /*
      * Called by managed code to allocate an array in a special case for FILLED_NEW_ARRAY.
      */
     .extern artCheckAndAllocArrayFromCodeWithAccessCheck
-ENTRY art_quick_check_and_alloc_array_from_code_with_access_check
+ENTRY art_quick_check_and_alloc_array_with_access_check
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a3, rSELF                # pass Thread::Current
@@ -839,7 +839,7 @@ ENTRY art_quick_check_and_alloc_array_from_code_with_access_check
     jal     artCheckAndAllocArrayFromCodeWithAccessCheck
     sw      $sp, 16($sp)              # pass $sp
     RETURN_IF_NONZERO
-END art_quick_check_and_alloc_array_from_code_with_access_check
+END art_quick_check_and_alloc_array_with_access_check
 
     /*
      * Called by managed code when the value in rSUSPEND has been decremented to 0.
@@ -884,13 +884,33 @@ ENTRY art_quick_proxy_invoke_handler
     DELIVER_PENDING_EXCEPTION
 END art_quick_proxy_invoke_handler
 
-    .extern artInterpreterEntry
-ENTRY art_quick_interpreter_entry
+    .extern artQuickResolutionTrampoline
+ENTRY art_quick_resolution_trampoline
+    GENERATE_GLOBAL_POINTER
+    SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
+    move    $a2, rSELF             # pass Thread::Current
+    jal     artQuickProxyInvokeHandler  # (Method* called, receiver, Thread*, SP)
+    move    $a3, $sp               # pass $sp
+    lw      $gp, 52($sp)           # restore $gp
+    lw      $ra, 60($sp)           # restore $ra
+    beqz    $v0, 1f
+    lw      $a0, 0($sp)            # load resolved method to $a0
+    lw      $a1, 4($sp)            # restore non-callee save $a1
+    lw      $a2, 8($sp)            # restore non-callee save $a2
+    lw      $a3, 12($sp)           # restore non-callee save $a3
+    jr      $v0                    # tail call to method
+1:
+    addiu   $sp, $sp, 64           # pop frame
+    .cfi_adjust_cfa_offset -64
+    DELIVER_PENDING_EXCEPTION
+END art_quick_resolution_trampoline
+
+    .extern artQuickToInterpreterBridge
+ENTRY art_quick_to_interpreter_bridge
     GENERATE_GLOBAL_POINTER
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
-    sw      $a0, 0($sp)            # place proxy method at bottom of frame
     move    $a1, rSELF             # pass Thread::Current
-    jal     artInterpreterEntry    # (Method* method, Thread*, SP)
+    jal     artQuickToInterpreterBridge    # (Method* method, Thread*, SP)
     move    $a2, $sp               # pass $sp
     lw      $t0, THREAD_EXCEPTION_OFFSET(rSELF) # load Thread::Current()->exception_
     lw      $gp, 52($sp)           # restore $gp
@@ -902,14 +922,14 @@ ENTRY art_quick_interpreter_entry
     nop
 1:
     DELIVER_PENDING_EXCEPTION
-END art_quick_interpreter_entry
+END art_quick_to_interpreter_bridge
 
     /*
      * Routine that intercepts method calls and returns.
      */
     .extern artInstrumentationMethodEntryFromCode
     .extern artInstrumentationMethodExitFromCode
-ENTRY art_quick_instrumentation_entry_from_code
+ENTRY art_quick_instrumentation_entry
     GENERATE_GLOBAL_POINTER
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
     move     $t0, $sp       # remember bottom of caller's frame
@@ -927,10 +947,10 @@ ENTRY art_quick_instrumentation_entry_from_code
     RESTORE_REF_AND_ARGS_CALLEE_SAVE_FRAME
     jalr     $t9            # call method
     nop
-END art_quick_instrumentation_entry_from_code
+END art_quick_instrumentation_entry
     /* intentional fallthrough */
-    .global art_quick_instrumentation_exit_from_code
-art_quick_instrumentation_exit_from_code:
+    .global art_quick_instrumentation_exit
+art_quick_instrumentation_exit:
     .cfi_startproc
     addiu    $t9, $ra, 4    # put current address into $t9 to rebuild $gp
     GENERATE_GLOBAL_POINTER
@@ -960,7 +980,7 @@ art_quick_instrumentation_exit_from_code:
     jr       $t0            # return
     addiu    $sp, $sp, 112  # 48 bytes of args + 64 bytes of callee save frame
     .cfi_adjust_cfa_offset -112
-END art_quick_instrumentation_exit_from_code
+END art_quick_instrumentation_exit
 
     /*
      * Instrumentation has requested that we deoptimize into the interpreter. The deoptimization
@@ -977,18 +997,6 @@ ENTRY art_quick_deoptimize
     move     $a1, $sp       # pass $sp
 END art_quick_deoptimize
 
-    /*
-     * Quick abstract method error stub. $a0 contains method* on entry.
-     */
-ENTRY art_quick_abstract_method_error_stub
-    GENERATE_GLOBAL_POINTER
-    SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
-    move     $a1, $s1       # pass Thread::Current
-    la       $t9, artThrowAbstractMethodErrorFromCode
-    jr       $t9            # (Method*, Thread*, SP)
-    move     $a2, $sp       # pass SP
-END art_quick_abstract_method_error_stub
-
     /*
      * Long integer shift.  This is different from the generic 32/64-bit
      * binary operations because vAA/vBB are 64-bit but vCC (the shift
diff --git a/runtime/arch/x86/asm_support_x86.S b/runtime/arch/x86/asm_support_x86.S
index 7e6dce9c6a..7a3fdfad30 100644
--- a/runtime/arch/x86/asm_support_x86.S
+++ b/runtime/arch/x86/asm_support_x86.S
@@ -88,4 +88,16 @@ MACRO1(POP, reg)
   .cfi_restore REG_VAR(reg,0)
 END_MACRO
 
+MACRO1(UNIMPLEMENTED,name)
+    .type VAR(name, 0), @function
+    .globl VAR(name, 0)
+    ALIGN_FUNCTION_ENTRY
+VAR(name, 0):
+    .cfi_startproc
+    int3
+    int3
+    .cfi_endproc
+    .size \name, .-\name
+END_MACRO
+
 #endif  // ART_RUNTIME_ARCH_X86_ASM_SUPPORT_X86_S_
diff --git a/runtime/arch/x86/entrypoints_init_x86.cc b/runtime/arch/x86/entrypoints_init_x86.cc
index d47dfef047..91526741cf 100644
--- a/runtime/arch/x86/entrypoints_init_x86.cc
+++ b/runtime/arch/x86/entrypoints_init_x86.cc
@@ -20,69 +20,73 @@
 
 namespace art {
 
+// Interpreter entrypoints.
+extern "C" void artInterpreterToInterpreterBridge(Thread* self, MethodHelper& mh,
+                                                  const DexFile::CodeItem* code_item,
+                                                  ShadowFrame* shadow_frame, JValue* result);
+extern "C" void artInterperterToCompiledCodeBridge(Thread* self, MethodHelper& mh,
+                                           const DexFile::CodeItem* code_item,
+                                           ShadowFrame* shadow_frame, JValue* result);
+
+// Portable entrypoints.
+extern "C" void art_portable_resolution_trampoline(mirror::AbstractMethod*);
+extern "C" void art_portable_to_interpreter_bridge(mirror::AbstractMethod*);
+
 // Alloc entrypoints.
-extern "C" void* art_quick_alloc_array_from_code(uint32_t, void*, int32_t);
-extern "C" void* art_quick_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
-extern "C" void* art_quick_alloc_object_from_code(uint32_t type_idx, void* method);
-extern "C" void* art_quick_alloc_object_from_code_with_access_check(uint32_t type_idx, void* method);
-extern "C" void* art_quick_check_and_alloc_array_from_code(uint32_t, void*, int32_t);
-extern "C" void* art_quick_check_and_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_array(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_array_with_access_check(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_object(uint32_t type_idx, void* method);
+extern "C" void* art_quick_alloc_object_with_access_check(uint32_t type_idx, void* method);
+extern "C" void* art_quick_check_and_alloc_array(uint32_t, void*, int32_t);
+extern "C" void* art_quick_check_and_alloc_array_with_access_check(uint32_t, void*, int32_t);
 
 // Cast entrypoints.
-extern "C" uint32_t art_quick_is_assignable_from_code(const mirror::Class* klass,
+extern "C" uint32_t art_quick_is_assignable(const mirror::Class* klass,
                                                 const mirror::Class* ref_class);
-extern "C" void art_quick_can_put_array_element_from_code(void*, void*);
-extern "C" void art_quick_check_cast_from_code(void*, void*);
+extern "C" void art_quick_can_put_array_element(void*, void*);
+extern "C" void art_quick_check_cast(void*, void*);
 
 // DexCache entrypoints.
-extern "C" void* art_quick_initialize_static_storage_from_code(uint32_t, void*);
-extern "C" void* art_quick_initialize_type_from_code(uint32_t, void*);
-extern "C" void* art_quick_initialize_type_and_verify_access_from_code(uint32_t, void*);
-extern "C" void* art_quick_resolve_string_from_code(void*, uint32_t);
+extern "C" void* art_quick_initialize_static_storage(uint32_t, void*);
+extern "C" void* art_quick_initialize_type(uint32_t, void*);
+extern "C" void* art_quick_initialize_type_and_verify_access(uint32_t, void*);
+extern "C" void* art_quick_resolve_string(void*, uint32_t);
 
 // Field entrypoints.
-extern "C" int art_quick_set32_instance_from_code(uint32_t, void*, int32_t);
-extern "C" int art_quick_set32_static_from_code(uint32_t, int32_t);
-extern "C" int art_quick_set64_instance_from_code(uint32_t, void*, int64_t);
-extern "C" int art_quick_set64_static_from_code(uint32_t, int64_t);
-extern "C" int art_quick_set_obj_instance_from_code(uint32_t, void*, void*);
-extern "C" int art_quick_set_obj_static_from_code(uint32_t, void*);
-extern "C" int32_t art_quick_get32_instance_from_code(uint32_t, void*);
-extern "C" int32_t art_quick_get32_static_from_code(uint32_t);
-extern "C" int64_t art_quick_get64_instance_from_code(uint32_t, void*);
-extern "C" int64_t art_quick_get64_static_from_code(uint32_t);
-extern "C" void* art_quick_get_obj_instance_from_code(uint32_t, void*);
-extern "C" void* art_quick_get_obj_static_from_code(uint32_t);
+extern "C" int art_quick_set32_instance(uint32_t, void*, int32_t);
+extern "C" int art_quick_set32_static(uint32_t, int32_t);
+extern "C" int art_quick_set64_instance(uint32_t, void*, int64_t);
+extern "C" int art_quick_set64_static(uint32_t, int64_t);
+extern "C" int art_quick_set_obj_instance(uint32_t, void*, void*);
+extern "C" int art_quick_set_obj_static(uint32_t, void*);
+extern "C" int32_t art_quick_get32_instance(uint32_t, void*);
+extern "C" int32_t art_quick_get32_static(uint32_t);
+extern "C" int64_t art_quick_get64_instance(uint32_t, void*);
+extern "C" int64_t art_quick_get64_static(uint32_t);
+extern "C" void* art_quick_get_obj_instance(uint32_t, void*);
+extern "C" void* art_quick_get_obj_static(uint32_t);
 
 // FillArray entrypoint.
-extern "C" void art_quick_handle_fill_data_from_code(void*, void*);
+extern "C" void art_quick_handle_fill_data(void*, void*);
 
 // Lock entrypoints.
-extern "C" void art_quick_lock_object_from_code(void*);
-extern "C" void art_quick_unlock_object_from_code(void*);
+extern "C" void art_quick_lock_object(void*);
+extern "C" void art_quick_unlock_object(void*);
 
 // Math entrypoints.
-extern "C" double art_quick_fmod_from_code(double, double);
-extern "C" float art_quick_fmodf_from_code(float, float);
-extern "C" double art_quick_l2d_from_code(int64_t);
-extern "C" float art_quick_l2f_from_code(int64_t);
-extern "C" int64_t art_quick_d2l_from_code(double);
-extern "C" int64_t art_quick_f2l_from_code(float);
-extern "C" int32_t art_quick_idivmod_from_code(int32_t, int32_t);
-extern "C" int64_t art_quick_ldiv_from_code(int64_t, int64_t);
-extern "C" int64_t art_quick_ldivmod_from_code(int64_t, int64_t);
-extern "C" int64_t art_quick_lmul_from_code(int64_t, int64_t);
-extern "C" uint64_t art_quick_lshl_from_code(uint64_t, uint32_t);
-extern "C" uint64_t art_quick_lshr_from_code(uint64_t, uint32_t);
-extern "C" uint64_t art_quick_lushr_from_code(uint64_t, uint32_t);
-
-// Interpreter entrypoints.
-extern "C" void artInterpreterToInterpreterEntry(Thread* self, MethodHelper& mh,
-                                                 const DexFile::CodeItem* code_item,
-                                                 ShadowFrame* shadow_frame, JValue* result);
-extern "C" void artInterpreterToQuickEntry(Thread* self, MethodHelper& mh,
-                                           const DexFile::CodeItem* code_item,
-                                           ShadowFrame* shadow_frame, JValue* result);
+extern "C" double art_quick_fmod(double, double);
+extern "C" float art_quick_fmodf(float, float);
+extern "C" double art_quick_l2d(int64_t);
+extern "C" float art_quick_l2f(int64_t);
+extern "C" int64_t art_quick_d2l(double);
+extern "C" int64_t art_quick_f2l(float);
+extern "C" int32_t art_quick_idivmod(int32_t, int32_t);
+extern "C" int64_t art_quick_ldiv(int64_t, int64_t);
+extern "C" int64_t art_quick_ldivmod(int64_t, int64_t);
+extern "C" int64_t art_quick_lmul(int64_t, int64_t);
+extern "C" uint64_t art_quick_lshl(uint64_t, uint32_t);
+extern "C" uint64_t art_quick_lshr(uint64_t, uint32_t);
+extern "C" uint64_t art_quick_lushr(uint64_t, uint32_t);
 
 // Intrinsic entrypoints.
 extern "C" int32_t art_quick_memcmp16(void*, void*, int32_t);
@@ -91,12 +95,8 @@ extern "C" int32_t art_quick_string_compareto(void*, void*);
 extern "C" void* art_quick_memcpy(void*, const void*, size_t);
 
 // Invoke entrypoints.
-extern "C" const void* artPortableResolutionTrampoline(mirror::AbstractMethod* called,
-                                                       mirror::Object* receiver,
-                                                       mirror::AbstractMethod** sp, Thread* thread);
-extern "C" const void* artQuickResolutionTrampoline(mirror::AbstractMethod* called,
-                                                    mirror::Object* receiver,
-                                                    mirror::AbstractMethod** sp, Thread* thread);
+extern "C" void art_quick_resolution_trampoline(mirror::AbstractMethod*);
+extern "C" void art_quick_to_interpreter_bridge(mirror::AbstractMethod*);
 extern "C" void art_quick_invoke_direct_trampoline_with_access_check(uint32_t, void*);
 extern "C" void art_quick_invoke_interface_trampoline(uint32_t, void*);
 extern "C" void art_quick_invoke_interface_trampoline_with_access_check(uint32_t, void*);
@@ -109,49 +109,61 @@ extern void CheckSuspendFromCode(Thread* thread);
 extern "C" void art_quick_test_suspend();
 
 // Throw entrypoints.
-extern "C" void art_quick_deliver_exception_from_code(void*);
-extern "C" void art_quick_throw_array_bounds_from_code(int32_t index, int32_t limit);
-extern "C" void art_quick_throw_div_zero_from_code();
-extern "C" void art_quick_throw_no_such_method_from_code(int32_t method_idx);
-extern "C" void art_quick_throw_null_pointer_exception_from_code();
-extern "C" void art_quick_throw_stack_overflow_from_code(void*);
-
-void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
+extern "C" void art_quick_deliver_exception(void*);
+extern "C" void art_quick_throw_array_bounds(int32_t index, int32_t limit);
+extern "C" void art_quick_throw_div_zero();
+extern "C" void art_quick_throw_no_such_method(int32_t method_idx);
+extern "C" void art_quick_throw_null_pointer_exception();
+extern "C" void art_quick_throw_stack_overflow(void*);
+
+void InitEntryPoints(InterpreterEntryPoints* ipoints, JniEntryPoints* jpoints,
+                     PortableEntryPoints* ppoints, QuickEntryPoints* qpoints) {
+  // Interpreter
+  ipoints->pInterpreterToInterpreterBridge = artInterpreterToInterpreterBridge;
+  ipoints->pInterpreterToCompiledCodeBridge = artInterperterToCompiledCodeBridge;
+
+  // JNI
+  jpoints->pDlsymLookup = art_jni_dlsym_lookup_stub;
+
+  // Portable
+  ppoints->pPortableResolutionTrampoline = art_portable_resolution_trampoline;
+  ppoints->pPortableToInterpreterBridge = art_portable_to_interpreter_bridge;
+
   // Alloc
-  qpoints->pAllocArrayFromCode = art_quick_alloc_array_from_code;
-  qpoints->pAllocArrayFromCodeWithAccessCheck = art_quick_alloc_array_from_code_with_access_check;
-  qpoints->pAllocObjectFromCode = art_quick_alloc_object_from_code;
-  qpoints->pAllocObjectFromCodeWithAccessCheck = art_quick_alloc_object_from_code_with_access_check;
-  qpoints->pCheckAndAllocArrayFromCode = art_quick_check_and_alloc_array_from_code;
-  qpoints->pCheckAndAllocArrayFromCodeWithAccessCheck = art_quick_check_and_alloc_array_from_code_with_access_check;
+  qpoints->pAllocArray = art_quick_alloc_array;
+  qpoints->pAllocArrayWithAccessCheck = art_quick_alloc_array_with_access_check;
+  qpoints->pAllocObject = art_quick_alloc_object;
+  qpoints->pAllocObjectWithAccessCheck = art_quick_alloc_object_with_access_check;
+  qpoints->pCheckAndAllocArray = art_quick_check_and_alloc_array;
+  qpoints->pCheckAndAllocArrayWithAccessCheck = art_quick_check_and_alloc_array_with_access_check;
 
   // Cast
-  qpoints->pInstanceofNonTrivialFromCode = art_quick_is_assignable_from_code;
-  qpoints->pCanPutArrayElementFromCode = art_quick_can_put_array_element_from_code;
-  qpoints->pCheckCastFromCode = art_quick_check_cast_from_code;
+  qpoints->pInstanceofNonTrivial = art_quick_is_assignable;
+  qpoints->pCanPutArrayElement = art_quick_can_put_array_element;
+  qpoints->pCheckCast = art_quick_check_cast;
 
   // DexCache
-  qpoints->pInitializeStaticStorage = art_quick_initialize_static_storage_from_code;
-  qpoints->pInitializeTypeAndVerifyAccessFromCode = art_quick_initialize_type_and_verify_access_from_code;
-  qpoints->pInitializeTypeFromCode = art_quick_initialize_type_from_code;
-  qpoints->pResolveStringFromCode = art_quick_resolve_string_from_code;
+  qpoints->pInitializeStaticStorage = art_quick_initialize_static_storage;
+  qpoints->pInitializeTypeAndVerifyAccess = art_quick_initialize_type_and_verify_access;
+  qpoints->pInitializeType = art_quick_initialize_type;
+  qpoints->pResolveString = art_quick_resolve_string;
 
   // Field
-  qpoints->pSet32Instance = art_quick_set32_instance_from_code;
-  qpoints->pSet32Static = art_quick_set32_static_from_code;
-  qpoints->pSet64Instance = art_quick_set64_instance_from_code;
-  qpoints->pSet64Static = art_quick_set64_static_from_code;
-  qpoints->pSetObjInstance = art_quick_set_obj_instance_from_code;
-  qpoints->pSetObjStatic = art_quick_set_obj_static_from_code;
-  qpoints->pGet32Instance = art_quick_get32_instance_from_code;
-  qpoints->pGet64Instance = art_quick_get64_instance_from_code;
-  qpoints->pGetObjInstance = art_quick_get_obj_instance_from_code;
-  qpoints->pGet32Static = art_quick_get32_static_from_code;
-  qpoints->pGet64Static = art_quick_get64_static_from_code;
-  qpoints->pGetObjStatic = art_quick_get_obj_static_from_code;
+  qpoints->pSet32Instance = art_quick_set32_instance;
+  qpoints->pSet32Static = art_quick_set32_static;
+  qpoints->pSet64Instance = art_quick_set64_instance;
+  qpoints->pSet64Static = art_quick_set64_static;
+  qpoints->pSetObjInstance = art_quick_set_obj_instance;
+  qpoints->pSetObjStatic = art_quick_set_obj_static;
+  qpoints->pGet32Instance = art_quick_get32_instance;
+  qpoints->pGet64Instance = art_quick_get64_instance;
+  qpoints->pGetObjInstance = art_quick_get_obj_instance;
+  qpoints->pGet32Static = art_quick_get32_static;
+  qpoints->pGet64Static = art_quick_get64_static;
+  qpoints->pGetObjStatic = art_quick_get_obj_static;
 
   // FillArray
-  qpoints->pHandleFillArrayDataFromCode = art_quick_handle_fill_data_from_code;
+  qpoints->pHandleFillArrayData = art_quick_handle_fill_data;
 
   // JNI
   qpoints->pJniMethodStart = JniMethodStart;
@@ -162,33 +174,29 @@ void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
   qpoints->pJniMethodEndWithReferenceSynchronized = JniMethodEndWithReferenceSynchronized;
 
   // Locks
-  qpoints->pLockObjectFromCode = art_quick_lock_object_from_code;
-  qpoints->pUnlockObjectFromCode = art_quick_unlock_object_from_code;
+  qpoints->pLockObject = art_quick_lock_object;
+  qpoints->pUnlockObject = art_quick_unlock_object;
 
   // Math
   // points->pCmpgDouble = NULL;  // Not needed on x86.
   // points->pCmpgFloat = NULL;  // Not needed on x86.
   // points->pCmplDouble = NULL;  // Not needed on x86.
   // points->pCmplFloat = NULL;  // Not needed on x86.
-  qpoints->pFmod = art_quick_fmod_from_code;
-  qpoints->pL2d = art_quick_l2d_from_code;
-  qpoints->pFmodf = art_quick_fmodf_from_code;
-  qpoints->pL2f = art_quick_l2f_from_code;
+  qpoints->pFmod = art_quick_fmod;
+  qpoints->pL2d = art_quick_l2d;
+  qpoints->pFmodf = art_quick_fmodf;
+  qpoints->pL2f = art_quick_l2f;
   // points->pD2iz = NULL;  // Not needed on x86.
   // points->pF2iz = NULL;  // Not needed on x86.
-  qpoints->pIdivmod = art_quick_idivmod_from_code;
-  qpoints->pD2l = art_quick_d2l_from_code;
-  qpoints->pF2l = art_quick_f2l_from_code;
-  qpoints->pLdiv = art_quick_ldiv_from_code;
-  qpoints->pLdivmod = art_quick_ldivmod_from_code;
-  qpoints->pLmul = art_quick_lmul_from_code;
-  qpoints->pShlLong = art_quick_lshl_from_code;
-  qpoints->pShrLong = art_quick_lshr_from_code;
-  qpoints->pUshrLong = art_quick_lushr_from_code;
-
-  // Interpreter
-  qpoints->pInterpreterToInterpreterEntry = artInterpreterToInterpreterEntry;
-  qpoints->pInterpreterToQuickEntry = artInterpreterToQuickEntry;
+  qpoints->pIdivmod = art_quick_idivmod;
+  qpoints->pD2l = art_quick_d2l;
+  qpoints->pF2l = art_quick_f2l;
+  qpoints->pLdiv = art_quick_ldiv;
+  qpoints->pLdivmod = art_quick_ldivmod;
+  qpoints->pLmul = art_quick_lmul;
+  qpoints->pShlLong = art_quick_lshl;
+  qpoints->pShrLong = art_quick_lshr;
+  qpoints->pUshrLong = art_quick_lushr;
 
   // Intrinsics
   qpoints->pIndexOf = art_quick_indexof;
@@ -197,7 +205,8 @@ void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
   qpoints->pMemcpy = art_quick_memcpy;
 
   // Invocation
-  qpoints->pQuickResolutionTrampolineFromCode = artQuickResolutionTrampoline;
+  qpoints->pQuickResolutionTrampoline = art_quick_resolution_trampoline;
+  qpoints->pQuickToInterpreterBridge = art_quick_to_interpreter_bridge;
   qpoints->pInvokeDirectTrampolineWithAccessCheck = art_quick_invoke_direct_trampoline_with_access_check;
   qpoints->pInvokeInterfaceTrampoline = art_quick_invoke_interface_trampoline;
   qpoints->pInvokeInterfaceTrampolineWithAccessCheck = art_quick_invoke_interface_trampoline_with_access_check;
@@ -206,19 +215,16 @@ void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints) {
   qpoints->pInvokeVirtualTrampolineWithAccessCheck = art_quick_invoke_virtual_trampoline_with_access_check;
 
   // Thread
-  qpoints->pCheckSuspendFromCode = CheckSuspendFromCode;
-  qpoints->pTestSuspendFromCode = art_quick_test_suspend;
+  qpoints->pCheckSuspend = CheckSuspendFromCode;
+  qpoints->pTestSuspend = art_quick_test_suspend;
 
   // Throws
-  qpoints->pDeliverException = art_quick_deliver_exception_from_code;
-  qpoints->pThrowArrayBoundsFromCode = art_quick_throw_array_bounds_from_code;
-  qpoints->pThrowDivZeroFromCode = art_quick_throw_div_zero_from_code;
-  qpoints->pThrowNoSuchMethodFromCode = art_quick_throw_no_such_method_from_code;
-  qpoints->pThrowNullPointerFromCode = art_quick_throw_null_pointer_exception_from_code;
-  qpoints->pThrowStackOverflowFromCode = art_quick_throw_stack_overflow_from_code;
-
-  // Portable
-  ppoints->pPortableResolutionTrampolineFromCode = artPortableResolutionTrampoline;
+  qpoints->pDeliverException = art_quick_deliver_exception;
+  qpoints->pThrowArrayBounds = art_quick_throw_array_bounds;
+  qpoints->pThrowDivZero = art_quick_throw_div_zero;
+  qpoints->pThrowNoSuchMethod = art_quick_throw_no_such_method;
+  qpoints->pThrowNullPointer = art_quick_throw_null_pointer_exception;
+  qpoints->pThrowStackOverflow = art_quick_throw_stack_overflow;
 };
 
 }  // namespace art
diff --git a/runtime/arch/x86/portable_entrypoints_x86.S b/runtime/arch/x86/portable_entrypoints_x86.S
index a0fca6cee3..0313d4b882 100644
--- a/runtime/arch/x86/portable_entrypoints_x86.S
+++ b/runtime/arch/x86/portable_entrypoints_x86.S
@@ -90,20 +90,5 @@ DEFINE_FUNCTION art_portable_proxy_invoke_handler
     ret
 END_FUNCTION art_portable_proxy_invoke_handler
 
-    /*
-     * Portable abstract method error stub. method* is at %esp + 4 on entry.
-     */
-DEFINE_FUNCTION art_portable_abstract_method_error_stub
-    PUSH ebp
-    movl %esp, %ebp               // Remember SP.
-    .cfi_def_cfa_register ebp
-    subl LITERAL(12), %esp        // Align stack.
-    PUSH esp                      // Pass sp (not used).
-    pushl %fs:THREAD_SELF_OFFSET  // Pass Thread::Current().
-    pushl 8(%ebp)                 // Pass Method*.
-    call SYMBOL(artThrowAbstractMethodErrorFromCode)  // (Method*, Thread*, SP)
-    leave                         // Restore the stack and %ebp.
-    .cfi_def_cfa esp, 4
-    .cfi_restore ebp
-    ret                           // Return to caller to handle pending exception.
-END_FUNCTION art_portable_abstract_method_error_stub
+UNIMPLEMENTED art_portable_resolution_trampoline
+UNIMPLEMENTED art_portable_to_interpreter_bridge
diff --git a/runtime/arch/x86/quick_entrypoints_x86.S b/runtime/arch/x86/quick_entrypoints_x86.S
index 89ea71a902..dbf552faaf 100644
--- a/runtime/arch/x86/quick_entrypoints_x86.S
+++ b/runtime/arch/x86/quick_entrypoints_x86.S
@@ -135,34 +135,34 @@ END_MACRO
     /*
      * Called by managed code to create and deliver a NullPointerException.
      */
-NO_ARG_RUNTIME_EXCEPTION art_quick_throw_null_pointer_exception_from_code, artThrowNullPointerExceptionFromCode
+NO_ARG_RUNTIME_EXCEPTION art_quick_throw_null_pointer_exception, artThrowNullPointerExceptionFromCode
 
     /*
      * Called by managed code to create and deliver an ArithmeticException.
      */
-NO_ARG_RUNTIME_EXCEPTION art_quick_throw_div_zero_from_code, artThrowDivZeroFromCode
+NO_ARG_RUNTIME_EXCEPTION art_quick_throw_div_zero, artThrowDivZeroFromCode
 
     /*
      * Called by managed code to create and deliver a StackOverflowError.
      */
-NO_ARG_RUNTIME_EXCEPTION art_quick_throw_stack_overflow_from_code, artThrowStackOverflowFromCode
+NO_ARG_RUNTIME_EXCEPTION art_quick_throw_stack_overflow, artThrowStackOverflowFromCode
 
     /*
      * Called by managed code, saves callee saves and then calls artThrowException
      * that will place a mock Method* at the bottom of the stack. Arg1 holds the exception.
      */
-ONE_ARG_RUNTIME_EXCEPTION art_quick_deliver_exception_from_code, artDeliverExceptionFromCode
+ONE_ARG_RUNTIME_EXCEPTION art_quick_deliver_exception, artDeliverExceptionFromCode
 
     /*
      * Called by managed code to create and deliver a NoSuchMethodError.
      */
-ONE_ARG_RUNTIME_EXCEPTION art_quick_throw_no_such_method_from_code, artThrowNoSuchMethodFromCode
+ONE_ARG_RUNTIME_EXCEPTION art_quick_throw_no_such_method, artThrowNoSuchMethodFromCode
 
     /*
      * Called by managed code to create and deliver an ArrayIndexOutOfBoundsException. Arg1 holds
      * index, arg2 holds limit.
      */
-TWO_ARG_RUNTIME_EXCEPTION art_quick_throw_array_bounds_from_code, artThrowArrayBoundsFromCode
+TWO_ARG_RUNTIME_EXCEPTION art_quick_throw_array_bounds, artThrowArrayBoundsFromCode
 
     /*
      * All generated callsites for interface invokes and invocation slow paths will load arguments
@@ -382,24 +382,24 @@ MACRO0(RETURN_OR_DELIVER_PENDING_EXCEPTION)
     DELIVER_PENDING_EXCEPTION
 END_MACRO
 
-TWO_ARG_DOWNCALL art_quick_alloc_object_from_code, artAllocObjectFromCode, RETURN_IF_EAX_NOT_ZERO
-TWO_ARG_DOWNCALL art_quick_alloc_object_from_code_with_access_check, artAllocObjectFromCodeWithAccessCheck, RETURN_IF_EAX_NOT_ZERO
-THREE_ARG_DOWNCALL art_quick_alloc_array_from_code, artAllocArrayFromCode, RETURN_IF_EAX_NOT_ZERO
-THREE_ARG_DOWNCALL art_quick_alloc_array_from_code_with_access_check, artAllocArrayFromCodeWithAccessCheck, RETURN_IF_EAX_NOT_ZERO
-THREE_ARG_DOWNCALL art_quick_check_and_alloc_array_from_code, artCheckAndAllocArrayFromCode, RETURN_IF_EAX_NOT_ZERO
-THREE_ARG_DOWNCALL art_quick_check_and_alloc_array_from_code_with_access_check, artCheckAndAllocArrayFromCodeWithAccessCheck, RETURN_IF_EAX_NOT_ZERO
+TWO_ARG_DOWNCALL art_quick_alloc_object, artAllocObjectFromCode, RETURN_IF_EAX_NOT_ZERO
+TWO_ARG_DOWNCALL art_quick_alloc_object_with_access_check, artAllocObjectFromCodeWithAccessCheck, RETURN_IF_EAX_NOT_ZERO
+THREE_ARG_DOWNCALL art_quick_alloc_array, artAllocArrayFromCode, RETURN_IF_EAX_NOT_ZERO
+THREE_ARG_DOWNCALL art_quick_alloc_array_with_access_check, artAllocArrayFromCodeWithAccessCheck, RETURN_IF_EAX_NOT_ZERO
+THREE_ARG_DOWNCALL art_quick_check_and_alloc_array, artCheckAndAllocArrayFromCode, RETURN_IF_EAX_NOT_ZERO
+THREE_ARG_DOWNCALL art_quick_check_and_alloc_array_with_access_check, artCheckAndAllocArrayFromCodeWithAccessCheck, RETURN_IF_EAX_NOT_ZERO
 
-TWO_ARG_DOWNCALL art_quick_resolve_string_from_code, artResolveStringFromCode, RETURN_IF_EAX_NOT_ZERO
-TWO_ARG_DOWNCALL art_quick_initialize_static_storage_from_code, artInitializeStaticStorageFromCode, RETURN_IF_EAX_NOT_ZERO
-TWO_ARG_DOWNCALL art_quick_initialize_type_from_code, artInitializeTypeFromCode, RETURN_IF_EAX_NOT_ZERO
-TWO_ARG_DOWNCALL art_quick_initialize_type_and_verify_access_from_code, artInitializeTypeAndVerifyAccessFromCode, RETURN_IF_EAX_NOT_ZERO
+TWO_ARG_DOWNCALL art_quick_resolve_string, artResolveStringFromCode, RETURN_IF_EAX_NOT_ZERO
+TWO_ARG_DOWNCALL art_quick_initialize_static_storage, artInitializeStaticStorageFromCode, RETURN_IF_EAX_NOT_ZERO
+TWO_ARG_DOWNCALL art_quick_initialize_type, artInitializeTypeFromCode, RETURN_IF_EAX_NOT_ZERO
+TWO_ARG_DOWNCALL art_quick_initialize_type_and_verify_access, artInitializeTypeAndVerifyAccessFromCode, RETURN_IF_EAX_NOT_ZERO
 
-ONE_ARG_DOWNCALL art_quick_lock_object_from_code, artLockObjectFromCode, ret
-ONE_ARG_DOWNCALL art_quick_unlock_object_from_code, artUnlockObjectFromCode, RETURN_IF_EAX_ZERO
+ONE_ARG_DOWNCALL art_quick_lock_object, artLockObjectFromCode, ret
+ONE_ARG_DOWNCALL art_quick_unlock_object, artUnlockObjectFromCode, RETURN_IF_EAX_ZERO
 
-TWO_ARG_DOWNCALL art_quick_handle_fill_data_from_code, artHandleFillArrayDataFromCode, RETURN_IF_EAX_ZERO
+TWO_ARG_DOWNCALL art_quick_handle_fill_data, artHandleFillArrayDataFromCode, RETURN_IF_EAX_ZERO
 
-DEFINE_FUNCTION art_quick_is_assignable_from_code
+DEFINE_FUNCTION art_quick_is_assignable
     PUSH eax                     // alignment padding
     PUSH ecx                    // pass arg2
     PUSH eax                     // pass arg1
@@ -407,7 +407,7 @@ DEFINE_FUNCTION art_quick_is_assignable_from_code
     addl LITERAL(12), %esp        // pop arguments
     .cfi_adjust_cfa_offset -12
     ret
-END_FUNCTION art_quick_is_assignable_from_code
+END_FUNCTION art_quick_is_assignable
 
 DEFINE_FUNCTION art_quick_memcpy
     PUSH edx                      // pass arg3
@@ -419,12 +419,12 @@ DEFINE_FUNCTION art_quick_memcpy
     ret
 END_FUNCTION art_quick_memcpy
 
-TWO_ARG_DOWNCALL art_quick_check_cast_from_code, artCheckCastFromCode, RETURN_IF_EAX_ZERO
-TWO_ARG_DOWNCALL art_quick_can_put_array_element_from_code, artCanPutArrayElementFromCode, RETURN_IF_EAX_ZERO
+TWO_ARG_DOWNCALL art_quick_check_cast, artCheckCastFromCode, RETURN_IF_EAX_ZERO
+TWO_ARG_DOWNCALL art_quick_can_put_array_element, artCanPutArrayElementFromCode, RETURN_IF_EAX_ZERO
 
 NO_ARG_DOWNCALL art_quick_test_suspend, artTestSuspendFromCode, ret
 
-DEFINE_FUNCTION art_quick_fmod_from_code
+DEFINE_FUNCTION art_quick_fmod
     subl LITERAL(12), %esp        // alignment padding
     .cfi_adjust_cfa_offset 12
     PUSH ebx                      // pass arg4 b.hi
@@ -437,9 +437,9 @@ DEFINE_FUNCTION art_quick_fmod_from_code
     addl LITERAL(28), %esp        // pop arguments
     .cfi_adjust_cfa_offset -28
     ret
-END_FUNCTION art_quick_fmod_from_code
+END_FUNCTION art_quick_fmod
 
-DEFINE_FUNCTION art_quick_fmodf_from_code
+DEFINE_FUNCTION art_quick_fmodf
     PUSH eax                      // alignment padding
     PUSH ecx                      // pass arg2 b
     PUSH eax                      // pass arg1 a
@@ -449,9 +449,9 @@ DEFINE_FUNCTION art_quick_fmodf_from_code
     addl LITERAL(12), %esp        // pop arguments
     .cfi_adjust_cfa_offset -12
     ret
-END_FUNCTION art_quick_fmodf_from_code
+END_FUNCTION art_quick_fmodf
 
-DEFINE_FUNCTION art_quick_l2d_from_code
+DEFINE_FUNCTION art_quick_l2d
     PUSH ecx                      // push arg2 a.hi
     PUSH eax                      // push arg1 a.lo
     fildll (%esp)                 // load as integer and push into st0
@@ -460,9 +460,9 @@ DEFINE_FUNCTION art_quick_l2d_from_code
     addl LITERAL(8), %esp         // pop arguments
     .cfi_adjust_cfa_offset -8
     ret
-END_FUNCTION art_quick_l2d_from_code
+END_FUNCTION art_quick_l2d
 
-DEFINE_FUNCTION art_quick_l2f_from_code
+DEFINE_FUNCTION art_quick_l2f
     PUSH ecx                      // push arg2 a.hi
     PUSH eax                      // push arg1 a.lo
     fildll (%esp)                 // load as integer and push into st0
@@ -471,9 +471,9 @@ DEFINE_FUNCTION art_quick_l2f_from_code
     addl LITERAL(8), %esp         // pop argument
     .cfi_adjust_cfa_offset -8
     ret
-END_FUNCTION art_quick_l2f_from_code
+END_FUNCTION art_quick_l2f
 
-DEFINE_FUNCTION art_quick_d2l_from_code
+DEFINE_FUNCTION art_quick_d2l
     PUSH eax                      // alignment padding
     PUSH ecx                      // pass arg2 a.hi
     PUSH eax                      // pass arg1 a.lo
@@ -481,9 +481,9 @@ DEFINE_FUNCTION art_quick_d2l_from_code
     addl LITERAL(12), %esp        // pop arguments
     .cfi_adjust_cfa_offset -12
     ret
-END_FUNCTION art_quick_d2l_from_code
+END_FUNCTION art_quick_d2l
 
-DEFINE_FUNCTION art_quick_f2l_from_code
+DEFINE_FUNCTION art_quick_f2l
     subl LITERAL(8), %esp         // alignment padding
     .cfi_adjust_cfa_offset 8
     PUSH eax                      // pass arg1 a
@@ -491,9 +491,9 @@ DEFINE_FUNCTION art_quick_f2l_from_code
     addl LITERAL(12), %esp        // pop arguments
     .cfi_adjust_cfa_offset -12
     ret
-END_FUNCTION art_quick_f2l_from_code
+END_FUNCTION art_quick_f2l
 
-DEFINE_FUNCTION art_quick_idivmod_from_code
+DEFINE_FUNCTION art_quick_idivmod
     cmpl LITERAL(0x80000000), %eax
     je check_arg2  // special case
 args_ok:
@@ -505,9 +505,9 @@ check_arg2:
     jne args_ok
     xorl %edx, %edx
     ret         // eax already holds min int
-END_FUNCTION art_quick_idivmod_from_code
+END_FUNCTION art_quick_idivmod
 
-DEFINE_FUNCTION art_quick_ldiv_from_code
+DEFINE_FUNCTION art_quick_ldiv
     subl LITERAL(12), %esp        // alignment padding
     .cfi_adjust_cfa_offset 12
     PUSH ebx                     // pass arg4 b.hi
@@ -518,9 +518,9 @@ DEFINE_FUNCTION art_quick_ldiv_from_code
     addl LITERAL(28), %esp        // pop arguments
     .cfi_adjust_cfa_offset -28
     ret
-END_FUNCTION art_quick_ldiv_from_code
+END_FUNCTION art_quick_ldiv
 
-DEFINE_FUNCTION art_quick_ldivmod_from_code
+DEFINE_FUNCTION art_quick_ldivmod
     subl LITERAL(12), %esp        // alignment padding
     .cfi_adjust_cfa_offset 12
     PUSH ebx                     // pass arg4 b.hi
@@ -531,18 +531,18 @@ DEFINE_FUNCTION art_quick_ldivmod_from_code
     addl LITERAL(28), %esp        // pop arguments
     .cfi_adjust_cfa_offset -28
     ret
-END_FUNCTION art_quick_ldivmod_from_code
+END_FUNCTION art_quick_ldivmod
 
-DEFINE_FUNCTION art_quick_lmul_from_code
+DEFINE_FUNCTION art_quick_lmul
     imul %eax, %ebx              // ebx = a.lo(eax) * b.hi(ebx)
     imul %edx, %ecx              // ecx = b.lo(edx) * a.hi(ecx)
     mul  %edx                    // edx:eax = a.lo(eax) * b.lo(edx)
     add  %ebx, %ecx
     add  %ecx, %edx              // edx += (a.lo * b.hi) + (b.lo * a.hi)
     ret
-END_FUNCTION art_quick_lmul_from_code
+END_FUNCTION art_quick_lmul
 
-DEFINE_FUNCTION art_quick_lshl_from_code
+DEFINE_FUNCTION art_quick_lshl
     // ecx:eax << edx
     xchg %edx, %ecx
     shld %cl,%eax,%edx
@@ -553,9 +553,9 @@ DEFINE_FUNCTION art_quick_lshl_from_code
     xor %eax, %eax
 1:
     ret
-END_FUNCTION art_quick_lshl_from_code
+END_FUNCTION art_quick_lshl
 
-DEFINE_FUNCTION art_quick_lshr_from_code
+DEFINE_FUNCTION art_quick_lshr
     // ecx:eax >> edx
     xchg %edx, %ecx
     shrd %cl,%edx,%eax
@@ -566,9 +566,9 @@ DEFINE_FUNCTION art_quick_lshr_from_code
     sar LITERAL(31), %edx
 1:
     ret
-END_FUNCTION art_quick_lshr_from_code
+END_FUNCTION art_quick_lshr
 
-DEFINE_FUNCTION art_quick_lushr_from_code
+DEFINE_FUNCTION art_quick_lushr
     // ecx:eax >>> edx
     xchg %edx, %ecx
     shrd %cl,%edx,%eax
@@ -579,9 +579,9 @@ DEFINE_FUNCTION art_quick_lushr_from_code
     xor %edx, %edx
 1:
     ret
-END_FUNCTION art_quick_lushr_from_code
+END_FUNCTION art_quick_lushr
 
-DEFINE_FUNCTION art_quick_set32_instance_from_code
+DEFINE_FUNCTION art_quick_set32_instance
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     subl LITERAL(8), %esp         // alignment padding
@@ -599,9 +599,9 @@ DEFINE_FUNCTION art_quick_set32_instance_from_code
     .cfi_adjust_cfa_offset -32
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_IF_EAX_ZERO            // return or deliver exception
-END_FUNCTION art_quick_set32_instance_from_code
+END_FUNCTION art_quick_set32_instance
 
-DEFINE_FUNCTION art_quick_set64_instance_from_code
+DEFINE_FUNCTION art_quick_set64_instance
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  // save ref containing registers for GC
     subl LITERAL(8), %esp         // alignment padding
     .cfi_adjust_cfa_offset 8
@@ -618,9 +618,9 @@ DEFINE_FUNCTION art_quick_set64_instance_from_code
     .cfi_adjust_cfa_offset -32
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME  // restore frame up to return address
     RETURN_IF_EAX_ZERO            // return or deliver exception
-END_FUNCTION art_quick_set64_instance_from_code
+END_FUNCTION art_quick_set64_instance
 
-DEFINE_FUNCTION art_quick_set_obj_instance_from_code
+DEFINE_FUNCTION art_quick_set_obj_instance
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     subl LITERAL(8), %esp         // alignment padding
@@ -638,9 +638,9 @@ DEFINE_FUNCTION art_quick_set_obj_instance_from_code
     .cfi_adjust_cfa_offset -32
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_IF_EAX_ZERO            // return or deliver exception
-END_FUNCTION art_quick_set_obj_instance_from_code
+END_FUNCTION art_quick_set_obj_instance
 
-DEFINE_FUNCTION art_quick_get32_instance_from_code
+DEFINE_FUNCTION art_quick_get32_instance
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     mov 32(%esp), %edx            // get referrer
@@ -657,9 +657,9 @@ DEFINE_FUNCTION art_quick_get32_instance_from_code
     .cfi_adjust_cfa_offset -32
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
-END_FUNCTION art_quick_get32_instance_from_code
+END_FUNCTION art_quick_get32_instance
 
-DEFINE_FUNCTION art_quick_get64_instance_from_code
+DEFINE_FUNCTION art_quick_get64_instance
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     mov 32(%esp), %edx            // get referrer
@@ -676,9 +676,9 @@ DEFINE_FUNCTION art_quick_get64_instance_from_code
     .cfi_adjust_cfa_offset -32
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
-END_FUNCTION art_quick_get64_instance_from_code
+END_FUNCTION art_quick_get64_instance
 
-DEFINE_FUNCTION art_quick_get_obj_instance_from_code
+DEFINE_FUNCTION art_quick_get_obj_instance
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     mov 32(%esp), %edx            // get referrer
@@ -695,9 +695,9 @@ DEFINE_FUNCTION art_quick_get_obj_instance_from_code
     .cfi_adjust_cfa_offset -32
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
-END_FUNCTION art_quick_get_obj_instance_from_code
+END_FUNCTION art_quick_get_obj_instance
 
-DEFINE_FUNCTION art_quick_set32_static_from_code
+DEFINE_FUNCTION art_quick_set32_static
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     mov 32(%esp), %edx            // get referrer
@@ -714,9 +714,9 @@ DEFINE_FUNCTION art_quick_set32_static_from_code
     .cfi_adjust_cfa_offset -32
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_IF_EAX_ZERO            // return or deliver exception
-END_FUNCTION art_quick_set32_static_from_code
+END_FUNCTION art_quick_set32_static
 
-DEFINE_FUNCTION art_quick_set64_static_from_code
+DEFINE_FUNCTION art_quick_set64_static
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     subl LITERAL(8), %esp         // alignment padding
@@ -734,9 +734,9 @@ DEFINE_FUNCTION art_quick_set64_static_from_code
     .cfi_adjust_cfa_offset -32
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME  // restore frame up to return address
     RETURN_IF_EAX_ZERO            // return or deliver exception
-END_FUNCTION art_quick_set64_static_from_code
+END_FUNCTION art_quick_set64_static
 
-DEFINE_FUNCTION art_quick_set_obj_static_from_code
+DEFINE_FUNCTION art_quick_set_obj_static
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     mov 32(%esp), %edx            // get referrer
@@ -752,9 +752,9 @@ DEFINE_FUNCTION art_quick_set_obj_static_from_code
     addl LITERAL(32), %esp        // pop arguments
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME  // restore frame up to return address
     RETURN_IF_EAX_ZERO            // return or deliver exception
-END_FUNCTION art_quick_set_obj_static_from_code
+END_FUNCTION art_quick_set_obj_static
 
-DEFINE_FUNCTION art_quick_get32_static_from_code
+DEFINE_FUNCTION art_quick_get32_static
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %edx                // remember SP
     mov 32(%esp), %ecx            // get referrer
@@ -768,9 +768,9 @@ DEFINE_FUNCTION art_quick_get32_static_from_code
     .cfi_adjust_cfa_offset -16
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
-END_FUNCTION art_quick_get32_static_from_code
+END_FUNCTION art_quick_get32_static
 
-DEFINE_FUNCTION art_quick_get64_static_from_code
+DEFINE_FUNCTION art_quick_get64_static
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  // save ref containing registers for GC
     mov %esp, %edx                // remember SP
     mov 32(%esp), %ecx            // get referrer
@@ -784,9 +784,9 @@ DEFINE_FUNCTION art_quick_get64_static_from_code
     .cfi_adjust_cfa_offset -16
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
-END_FUNCTION art_quick_get64_static_from_code
+END_FUNCTION art_quick_get64_static
 
-DEFINE_FUNCTION art_quick_get_obj_static_from_code
+DEFINE_FUNCTION art_quick_get_obj_static
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %edx                // remember SP
     mov 32(%esp), %ecx            // get referrer
@@ -800,7 +800,7 @@ DEFINE_FUNCTION art_quick_get_obj_static_from_code
     .cfi_adjust_cfa_offset -16
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
-END_FUNCTION art_quick_get_obj_static_from_code
+END_FUNCTION art_quick_get_obj_static
 
 DEFINE_FUNCTION art_quick_proxy_invoke_handler
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME   // save frame and Method*
@@ -818,7 +818,32 @@ DEFINE_FUNCTION art_quick_proxy_invoke_handler
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
 END_FUNCTION art_quick_proxy_invoke_handler
 
-DEFINE_FUNCTION art_quick_interpreter_entry
+DEFINE_FUNCTION art_quick_resolution_trampoline
+    SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
+    PUSH esp                      // pass SP
+    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
+    .cfi_adjust_cfa_offset 4
+    PUSH ecx                      // pass receiver
+    PUSH eax                      // pass method
+    call SYMBOL(artQuickResolutionTrampoline) // (Method* called, receiver, Thread*, SP)
+    movl %eax, %edi               // remember code pointer in EDI
+    addl LITERAL(16), %esp        // pop arguments
+    test %eax, %eax               // if code pointer is NULL goto deliver pending exception
+    jz 1f
+    POP eax                       // called method
+    POP ecx                       // restore args
+    POP edx
+    POP ebx
+    POP ebp                       // restore callee saves except EDI
+    POP esi
+    xchgl 0(%esp),%edi            // restore EDI and place code pointer as only value on stack
+    ret                           // tail call into method
+1:
+    RESTORE_REF_AND_ARGS_CALLEE_SAVE_FRAME
+    DELIVER_PENDING_EXCEPTION
+END_FUNCTION art_quick_resolution_trampoline
+
+DEFINE_FUNCTION art_quick_to_interpreter_bridge
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME   // save frame
     mov %esp, %edx                // remember SP
     PUSH eax                      // alignment padding
@@ -826,19 +851,19 @@ DEFINE_FUNCTION art_quick_interpreter_entry
     pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
     .cfi_adjust_cfa_offset 4
     PUSH eax                      // pass  method
-    call SYMBOL(artInterpreterEntry)  // (method, Thread*, SP)
+    call SYMBOL(artQuickToInterpreterBridge)  // (method, Thread*, SP)
     movd %eax, %xmm0              // place return value also into floating point return value
     movd %edx, %xmm1
     punpckldq %xmm1, %xmm0
     addl LITERAL(44), %esp        // pop arguments
     .cfi_adjust_cfa_offset -44
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
-END_FUNCTION art_quick_interpreter_entry
+END_FUNCTION art_quick_to_interpreter_bridge
 
     /*
      * Routine that intercepts method calls and returns.
      */
-DEFINE_FUNCTION art_quick_instrumentation_entry_from_code
+DEFINE_FUNCTION art_quick_instrumentation_entry
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
     movl  %esp, %edx              // Save SP.
     PUSH eax                      // Save eax which will be clobbered by the callee-save method.
@@ -855,7 +880,7 @@ DEFINE_FUNCTION art_quick_instrumentation_entry_from_code
     addl  LITERAL(28), %esp       // Pop arguments upto saved Method*.
     movl 28(%esp), %edi           // Restore edi.
     movl %eax, 28(%esp)           // Place code* over edi, just under return pc.
-    movl LITERAL(SYMBOL(art_quick_instrumentation_exit_from_code)), 32(%esp)
+    movl LITERAL(SYMBOL(art_quick_instrumentation_exit)), 32(%esp)
                                   // Place instrumentation exit as return pc.
     movl (%esp), %eax             // Restore eax.
     movl 8(%esp), %ecx            // Restore ecx.
@@ -865,9 +890,9 @@ DEFINE_FUNCTION art_quick_instrumentation_entry_from_code
     movl 24(%esp), %esi           // Restore esi.
     addl LITERAL(28), %esp        // Wind stack back upto code*.
     ret                           // Call method (and pop).
-END_FUNCTION art_quick_instrumentation_entry_from_code
+END_FUNCTION art_quick_instrumentation_entry
 
-DEFINE_FUNCTION art_quick_instrumentation_exit_from_code
+DEFINE_FUNCTION art_quick_instrumentation_exit
     pushl LITERAL(0)              // Push a fake return PC as there will be none on the stack.
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME
     mov  %esp, %ecx               // Remember SP
@@ -900,7 +925,7 @@ DEFINE_FUNCTION art_quick_instrumentation_exit_from_code
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME
     addl LITERAL(4), %esp         // Remove fake return pc.
     jmp   *%ecx                   // Return.
-END_FUNCTION art_quick_instrumentation_exit_from_code
+END_FUNCTION art_quick_instrumentation_exit
 
     /*
      * Instrumentation has requested that we deoptimize into the interpreter. The deoptimization
@@ -919,21 +944,6 @@ DEFINE_FUNCTION art_quick_deoptimize
     int3                          // Unreachable.
 END_FUNCTION art_quick_deoptimize
 
-    /*
-     * Quick abstract method error stub. %eax contains method* on entry.
-     */
-DEFINE_FUNCTION art_quick_abstract_method_error_stub
-    SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
-    movl %esp, %ecx               // Remember SP.
-    PUSH eax                      // Align frame.
-    PUSH ecx                      // Pass SP for Method*.
-    pushl %fs:THREAD_SELF_OFFSET  // Pass Thread::Current().
-    .cfi_adjust_cfa_offset 4
-    PUSH eax                      // Pass Method*.
-    call SYMBOL(artThrowAbstractMethodErrorFromCode)  // (Method*, Thread*, SP)
-    int3                          // Unreachable.
-END_FUNCTION art_quick_abstract_method_error_stub
-
     /*
      * String's indexOf.
      *
@@ -1030,12 +1040,5 @@ not_equal:
     ret
 END_FUNCTION art_quick_string_compareto
 
-MACRO1(UNIMPLEMENTED,name)
-    .globl VAR(name, 0)
-    ALIGN_FUNCTION_ENTRY
-VAR(name, 0):
-    int3
-END_MACRO
-
     // TODO: implement these!
 UNIMPLEMENTED art_quick_memcmp16
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 84f186d4b3..962977559a 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -71,7 +71,7 @@
 
 namespace art {
 
-extern "C" void artInterpreterToQuickEntry(Thread* self, MethodHelper& mh,
+extern "C" void artInterperterToCompiledCodeBridge(Thread* self, MethodHelper& mh,
                                            const DexFile::CodeItem* code_item,
                                            ShadowFrame* shadow_frame, JValue* result);
 
@@ -920,6 +920,43 @@ const OatFile* ClassLinker::FindOatFileFromOatLocationLocked(const std::string&
   return oat_file;
 }
 
+static void InitFromImageCallbackCommon(mirror::Object* obj, ClassLinker* class_linker,
+                                        bool interpret_only_mode)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  DCHECK(obj != NULL);
+  DCHECK(class_linker != NULL);
+
+  if (obj->GetClass()->IsStringClass()) {
+    class_linker->GetInternTable()->RegisterStrong(obj->AsString());
+  } else if (obj->IsClass()) {
+    // Restore class to ClassLinker::classes_ table.
+    mirror::Class* klass = obj->AsClass();
+    ClassHelper kh(klass, class_linker);
+    mirror::Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
+    DCHECK(existing == NULL) << kh.GetDescriptor();
+  } else if (interpret_only_mode && obj->IsMethod()) {
+    mirror::AbstractMethod* method = obj->AsMethod();
+    if (!method->IsNative()) {
+      method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
+      if (method != Runtime::Current()->GetResolutionMethod()) {
+        method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
+      }
+    }
+  }
+}
+
+static void InitFromImageCallback(mirror::Object* obj, void* arg)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
+  InitFromImageCallbackCommon(obj, class_linker, false);
+}
+
+static void InitFromImageInterpretOnlyCallback(mirror::Object* obj, void* arg)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
+  InitFromImageCallbackCommon(obj, class_linker, true);
+}
+
 void ClassLinker::InitFromImage() {
   VLOG(startup) << "ClassLinker::InitFromImage entering";
   CHECK(!init_done_);
@@ -973,7 +1010,11 @@ void ClassLinker::InitFromImage() {
   {
     ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
     heap->FlushAllocStack();
-    heap->GetLiveBitmap()->Walk(InitFromImageCallback, this);
+    if (Runtime::Current()->GetInstrumentation()->InterpretOnly()) {
+      heap->GetLiveBitmap()->Walk(InitFromImageInterpretOnlyCallback, this);
+    } else {
+      heap->GetLiveBitmap()->Walk(InitFromImageCallback, this);
+    }
   }
 
   // reinit class_roots_
@@ -1001,40 +1042,6 @@ void ClassLinker::InitFromImage() {
   VLOG(startup) << "ClassLinker::InitFromImage exiting";
 }
 
-void ClassLinker::InitFromImageCallback(mirror::Object* obj, void* arg) {
-  DCHECK(obj != NULL);
-  DCHECK(arg != NULL);
-  ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
-
-  if (obj->GetClass()->IsStringClass()) {
-    class_linker->intern_table_->RegisterStrong(obj->AsString());
-    return;
-  }
-  if (obj->IsClass()) {
-    // restore class to ClassLinker::classes_ table
-    mirror::Class* klass = obj->AsClass();
-    ClassHelper kh(klass, class_linker);
-    mirror::Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
-    DCHECK(existing == NULL) << kh.GetDescriptor();
-    return;
-  }
-
-  if (obj->IsMethod()) {
-    mirror::AbstractMethod* method = obj->AsMethod();
-    // Set entry points to interpreter for methods in interpreter only mode.
-    if (Runtime::Current()->GetInstrumentation()->InterpretOnly() && !method->IsNative()) {
-      method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterEntry);
-      if (method != Runtime::Current()->GetResolutionMethod()) {
-        method->SetEntryPointFromCompiledCode(GetInterpreterEntryPoint());
-      }
-    }
-    // Populate native method pointer with jni lookup stub.
-    if (method->IsNative()) {
-      method->UnregisterNative(Thread::Current());
-    }
-  }
-}
-
 // Keep in sync with InitCallback. Anything we visit, we need to
 // reinit references to when reinitializing a ClassLinker from a
 // mapped image.
@@ -1534,7 +1541,7 @@ const void* ClassLinker::GetOatCodeFor(const mirror::AbstractMethod* method) {
   const void* result = GetOatMethodFor(method).GetCode();
   if (result == NULL) {
     // No code? You must mean to go into the interpreter.
-    result = GetInterpreterEntryPoint();
+    result = GetCompiledCodeToInterpreterBridge();
   }
   return result;
 }
@@ -1595,7 +1602,7 @@ void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) {
     const bool enter_interpreter = NeedsInterpreter(method, code);
     if (enter_interpreter) {
       // Use interpreter entry point.
-      code = GetInterpreterEntryPoint();
+      code = GetCompiledCodeToInterpreterBridge();
     }
     runtime->GetInstrumentation()->UpdateMethodsCode(method, code);
   }
@@ -1616,13 +1623,13 @@ static void LinkCode(SirtRef<mirror::AbstractMethod>& method, const OatFile::Oat
   Runtime* runtime = Runtime::Current();
   bool enter_interpreter = NeedsInterpreter(method.get(), method->GetEntryPointFromCompiledCode());
   if (enter_interpreter) {
-    method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterEntry);
+    method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
   } else {
-    method->SetEntryPointFromInterpreter(artInterpreterToQuickEntry);
+    method->SetEntryPointFromInterpreter(artInterperterToCompiledCodeBridge);
   }
 
   if (method->IsAbstract()) {
-    method->SetEntryPointFromCompiledCode(GetAbstractMethodErrorStub());
+    method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
     return;
   }
 
@@ -1633,7 +1640,7 @@ static void LinkCode(SirtRef<mirror::AbstractMethod>& method, const OatFile::Oat
     method->SetEntryPointFromCompiledCode(GetResolutionTrampoline(runtime->GetClassLinker()));
   } else if (enter_interpreter) {
     // Set entry point from compiled code if there's no code or in interpreter only mode.
-    method->SetEntryPointFromCompiledCode(GetInterpreterEntryPoint());
+    method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
   }
 
   if (method->IsNative()) {
@@ -2601,12 +2608,8 @@ mirror::AbstractMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<mir
   method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
   method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
   method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
-#if !defined(ART_USE_PORTABLE_COMPILER)
-  method->SetEntryPointFromCompiledCode(reinterpret_cast<void*>(art_quick_proxy_invoke_handler));
-#else
-  method->SetEntryPointFromCompiledCode(reinterpret_cast<void*>(art_portable_proxy_invoke_handler));
-#endif
-  method->SetEntryPointFromInterpreter(artInterpreterToQuickEntry);
+  method->SetEntryPointFromCompiledCode(GetProxyInvokeHandler());
+  method->SetEntryPointFromInterpreter(artInterperterToCompiledCodeBridge);
 
   return method;
 }
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index fdf75c2301..060c26c3a7 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -347,6 +347,17 @@ class ClassLinker {
     return quick_resolution_trampoline_;
   }
 
+  InternTable* GetInternTable() const {
+    return intern_table_;
+  }
+
+  // Attempts to insert a class into a class table.  Returns NULL if
+  // the class was inserted, otherwise returns an existing class with
+  // the same descriptor and ClassLoader.
+  mirror::Class* InsertClass(const StringPiece& descriptor, mirror::Class* klass, bool image_class)
+      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
  private:
   explicit ClassLinker(InternTable*);
 
@@ -362,8 +373,6 @@ class ClassLinker {
   OatFile& GetImageOatFile(gc::space::ImageSpace* space)
       LOCKS_EXCLUDED(dex_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  static void InitFromImageCallback(mirror::Object* obj, void* arg)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void FinishInit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -423,13 +432,6 @@ class ClassLinker {
   const OatFile::OatClass* GetOatClass(const DexFile& dex_file, const char* descriptor)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  // Attempts to insert a class into a class table.  Returns NULL if
-  // the class was inserted, otherwise returns an existing class with
-  // the same descriptor and ClassLoader.
-  mirror::Class* InsertClass(const StringPiece& descriptor, mirror::Class* klass, bool image_class)
-      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
   void RegisterDexFileLocked(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
       EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
diff --git a/runtime/common_test.h b/runtime/common_test.h
index 7ee6fe20b2..a54361706a 100644
--- a/runtime/common_test.h
+++ b/runtime/common_test.h
@@ -192,10 +192,7 @@ class CommonTest : public testing::Test {
       compiled_method =
           compiler_driver_->GetCompiledMethod(MethodReference(&dex_file,
                                                               method->GetDexMethodIndex()));
-
-#ifndef ART_LIGHT_MODE
       CHECK(compiled_method != NULL) << PrettyMethod(method);
-#endif
     }
     if (compiled_method != NULL) {
       const std::vector<uint8_t>& code = compiled_method->GetCode();
@@ -213,12 +210,8 @@ class CommonTest : public testing::Test {
       oat_method.LinkMethod(method);
     } else {
       const void* method_code;
-      if (method->IsAbstract()) {
-        method_code = GetAbstractMethodErrorStub();
-      } else {
-        // No code? You must mean to go into the interpreter.
-        method_code = GetInterpreterEntryPoint();
-      }
+      // No code? You must mean to go into the interpreter.
+      method_code = GetCompiledCodeToInterpreterBridge();
       LOG(INFO) << "MakeExecutable " << PrettyMethod(method) << " code=" << method_code;
       OatFile::OatMethod oat_method = CreateOatMethod(method_code,
                                                       kStackAlignment,
diff --git a/runtime/entrypoints/entrypoint_utils.h b/runtime/entrypoints/entrypoint_utils.h
index 3f28b5e41f..b6781c02b9 100644
--- a/runtime/entrypoints/entrypoint_utils.h
+++ b/runtime/entrypoints/entrypoint_utils.h
@@ -30,24 +30,13 @@
 #include "object_utils.h"
 #include "thread.h"
 
-extern "C" void art_interpreter_invoke_handler();
-extern "C" void art_jni_dlsym_lookup_stub();
-extern "C" void art_portable_abstract_method_error_stub();
-extern "C" void art_portable_proxy_invoke_handler();
-extern "C" void art_quick_abstract_method_error_stub();
-extern "C" void art_quick_deoptimize();
-extern "C" void art_quick_instrumentation_entry_from_code(void*);
-extern "C" void art_quick_instrumentation_exit_from_code();
-extern "C" void art_quick_interpreter_entry(void*);
-extern "C" void art_quick_proxy_invoke_handler();
-extern "C" void art_work_around_app_jni_bugs();
-
 namespace art {
+
 namespace mirror {
-class Class;
-class Field;
-class Object;
-}
+  class Class;
+  class Field;
+  class Object;
+}  // namespace mirror
 
 // Given the context of a calling Method, use its DexCache to resolve a type to a Class. If it
 // cannot be resolved, throw an error. If it can, use it to create an instance.
@@ -350,25 +339,43 @@ JValue InvokeProxyInvocationHandler(ScopedObjectAccessUnchecked& soa, const char
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 // Entry point for deoptimization.
-static inline uintptr_t GetDeoptimizationEntryPoint() {
+extern "C" void art_quick_deoptimize();
+static inline uintptr_t GetQuickDeoptimizationEntryPoint() {
   return reinterpret_cast<uintptr_t>(art_quick_deoptimize);
 }
 
 // Return address of instrumentation stub.
-static inline void* GetInstrumentationEntryPoint() {
-  return reinterpret_cast<void*>(art_quick_instrumentation_entry_from_code);
+extern "C" void art_quick_instrumentation_entry(void*);
+static inline void* GetQuickInstrumentationEntryPoint() {
+  return reinterpret_cast<void*>(art_quick_instrumentation_entry);
 }
 
 // The return_pc of instrumentation exit stub.
-static inline uintptr_t GetInstrumentationExitPc() {
-  return reinterpret_cast<uintptr_t>(art_quick_instrumentation_exit_from_code);
+extern "C" void art_quick_instrumentation_exit();
+static inline uintptr_t GetQuickInstrumentationExitPc() {
+  return reinterpret_cast<uintptr_t>(art_quick_instrumentation_exit);
+}
+
+extern "C" void art_portable_to_interpreter_bridge(mirror::AbstractMethod*);
+static inline const void* GetPortableToInterpreterBridge() {
+  return reinterpret_cast<void*>(art_portable_to_interpreter_bridge);
+}
+
+extern "C" void art_quick_to_interpreter_bridge(mirror::AbstractMethod*);
+static inline const void* GetQuickToInterpreterBridge() {
+  return reinterpret_cast<void*>(art_quick_to_interpreter_bridge);
 }
 
 // Return address of interpreter stub.
-static inline void* GetInterpreterEntryPoint() {
-  return reinterpret_cast<void*>(art_quick_interpreter_entry);
+static inline const void* GetCompiledCodeToInterpreterBridge() {
+#if defined(ART_USE_PORTABLE_COMPILER)
+  return GetPortableToInterpreterBridge();
+#else
+  return GetQuickToInterpreterBridge();
+#endif
 }
 
+
 static inline const void* GetPortableResolutionTrampoline(ClassLinker* class_linker) {
   return class_linker->GetPortableResolutionTrampoline();
 }
@@ -386,23 +393,25 @@ static inline const void* GetResolutionTrampoline(ClassLinker* class_linker) {
 #endif
 }
 
-static inline void* GetPortableAbstractMethodErrorStub() {
-  return reinterpret_cast<void*>(art_portable_abstract_method_error_stub);
+extern "C" void art_portable_proxy_invoke_handler();
+static inline const void* GetPortableProxyInvokeHandler() {
+  return reinterpret_cast<void*>(art_portable_proxy_invoke_handler);
 }
 
-static inline void* GetQuickAbstractMethodErrorStub() {
-  return reinterpret_cast<void*>(art_quick_abstract_method_error_stub);
+extern "C" void art_quick_proxy_invoke_handler();
+static inline const void* GetQuickProxyInvokeHandler() {
+  return reinterpret_cast<void*>(art_quick_proxy_invoke_handler);
 }
 
-// Return address of abstract method error stub for defined compiler.
-static inline void* GetAbstractMethodErrorStub() {
+static inline const void* GetProxyInvokeHandler() {
 #if defined(ART_USE_PORTABLE_COMPILER)
-  return GetPortableAbstractMethodErrorStub();
+  return GetPortableProxyInvokeHandler();
 #else
-  return GetQuickAbstractMethodErrorStub();
+  return GetQuickProxyInvokeHandler();
 #endif
 }
 
+extern "C" void* art_jni_dlsym_lookup_stub(JNIEnv*, jobject);
 static inline void* GetJniDlsymLookupStub() {
   return reinterpret_cast<void*>(art_jni_dlsym_lookup_stub);
 }
diff --git a/runtime/entrypoints/interpreter/interpreter_entrypoints.cc b/runtime/entrypoints/interpreter/interpreter_entrypoints.cc
new file mode 100644
index 0000000000..d99c43e052
--- /dev/null
+++ b/runtime/entrypoints/interpreter/interpreter_entrypoints.cc
@@ -0,0 +1,43 @@
+/*
+ * 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.
+ */
+
+#include "class_linker.h"
+#include "interpreter/interpreter.h"
+#include "invoke_arg_array_builder.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object-inl.h"
+#include "object_utils.h"
+#include "runtime.h"
+#include "stack.h"
+
+namespace art {
+
+extern "C" void artInterperterToCompiledCodeBridge(Thread* self, MethodHelper& mh,
+                                                   const DexFile::CodeItem* code_item,
+                                                   ShadowFrame* shadow_frame, JValue* result)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  mirror::AbstractMethod* method = shadow_frame->GetMethod();
+  // Ensure static methods are initialized.
+  if (method->IsStatic()) {
+    Runtime::Current()->GetClassLinker()->EnsureInitialized(method->GetDeclaringClass(), true, true);
+  }
+  uint16_t arg_offset = (code_item == NULL) ? 0 : code_item->registers_size_ - code_item->ins_size_;
+  ArgArray arg_array(mh.GetShorty(), mh.GetShortyLength());
+  arg_array.BuildArgArray(shadow_frame, arg_offset);
+  method->Invoke(self, arg_array.GetArray(), arg_array.GetNumBytes(), result, mh.GetShorty()[0]);
+}
+
+}  // namespace art
diff --git a/runtime/entrypoints/interpreter/interpreter_entrypoints.h b/runtime/entrypoints/interpreter/interpreter_entrypoints.h
new file mode 100644
index 0000000000..c7df4e6b0a
--- /dev/null
+++ b/runtime/entrypoints/interpreter/interpreter_entrypoints.h
@@ -0,0 +1,47 @@
+/*
+ * 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_RUNTIME_ENTRYPOINTS_INTERPRETER_INTERPRETER_ENTRYPOINTS_H_
+#define ART_RUNTIME_ENTRYPOINTS_INTERPRETER_INTERPRETER_ENTRYPOINTS_H_
+
+#include "base/macros.h"
+#include "dex_file.h"
+#include "offsets.h"
+
+#define INTERPRETER_ENTRYPOINT_OFFSET(x) \
+    ThreadOffset(static_cast<uintptr_t>(OFFSETOF_MEMBER(Thread, interpreter_entrypoints_)) + \
+                 static_cast<uintptr_t>(OFFSETOF_MEMBER(InterpreterEntryPoints, x)))
+
+namespace art {
+
+union JValue;
+class MethodHelper;
+class ShadowFrame;
+class Thread;
+
+// Pointers to functions that are called by interpreter trampolines via thread-local storage.
+struct PACKED(4) InterpreterEntryPoints {
+  void (*pInterpreterToInterpreterBridge)(Thread* self, MethodHelper& mh,
+                                          const DexFile::CodeItem* code_item,
+                                          ShadowFrame* shadow_frame, JValue* result);
+  void (*pInterpreterToCompiledCodeBridge)(Thread* self, MethodHelper& mh,
+                                           const DexFile::CodeItem* code_item,
+                                           ShadowFrame* shadow_frame, JValue* result);
+};
+
+}  // namespace art
+
+#endif  // ART_RUNTIME_ENTRYPOINTS_INTERPRETER_INTERPRETER_ENTRYPOINTS_H_
diff --git a/runtime/entrypoints/jni/jni_entrypoints.cc b/runtime/entrypoints/jni/jni_entrypoints.cc
index 98f7b1283c..88b4936255 100644
--- a/runtime/entrypoints/jni/jni_entrypoints.cc
+++ b/runtime/entrypoints/jni/jni_entrypoints.cc
@@ -15,23 +15,26 @@
  */
 
 #include "base/logging.h"
-#include "mirror/abstract_method.h"
+#include "entrypoints/entrypoint_utils.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object-inl.h"
+#include "object_utils.h"
 #include "scoped_thread_state_change.h"
 #include "thread.h"
 
 namespace art {
 
 // Used by the JNI dlsym stub to find the native method to invoke if none is registered.
-extern "C" void* artFindNativeMethod(Thread* self) {
+extern "C" void* artFindNativeMethod() {
+  Thread* self = Thread::Current();
   Locks::mutator_lock_->AssertNotHeld(self);  // We come here as Native.
-  DCHECK(Thread::Current() == self);
   ScopedObjectAccess soa(self);
 
   mirror::AbstractMethod* method = self->GetCurrentMethod(NULL);
   DCHECK(method != NULL);
 
-  // Lookup symbol address for method, on failure we'll return NULL with an
-  // exception set, otherwise we return the address of the method we found.
+  // Lookup symbol address for method, on failure we'll return NULL with an exception set,
+  // otherwise we return the address of the method we found.
   void* native_code = soa.Vm()->FindCodeForNativeMethod(method);
   if (native_code == NULL) {
     DCHECK(self->IsExceptionPending());
@@ -43,4 +46,78 @@ extern "C" void* artFindNativeMethod(Thread* self) {
   }
 }
 
+static void WorkAroundJniBugsForJobject(intptr_t* arg_ptr) {
+  intptr_t value = *arg_ptr;
+  mirror::Object** value_as_jni_rep = reinterpret_cast<mirror::Object**>(value);
+  mirror::Object* value_as_work_around_rep = value_as_jni_rep != NULL ? *value_as_jni_rep : NULL;
+  CHECK(Runtime::Current()->GetHeap()->IsHeapAddress(value_as_work_around_rep))
+      << value_as_work_around_rep;
+  *arg_ptr = reinterpret_cast<intptr_t>(value_as_work_around_rep);
+}
+
+extern "C" const void* artWorkAroundAppJniBugs(Thread* self, intptr_t* sp)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  DCHECK(Thread::Current() == self);
+  // TODO: this code is specific to ARM
+  // On entry the stack pointed by sp is:
+  // | arg3   | <- Calling JNI method's frame (and extra bit for out args)
+  // | LR     |
+  // | R3     |    arg2
+  // | R2     |    arg1
+  // | R1     |    jclass/jobject
+  // | R0     |    JNIEnv
+  // | unused |
+  // | unused |
+  // | unused | <- sp
+  mirror::AbstractMethod* jni_method = self->GetCurrentMethod(NULL);
+  DCHECK(jni_method->IsNative()) << PrettyMethod(jni_method);
+  intptr_t* arg_ptr = sp + 4;  // pointer to r1 on stack
+  // Fix up this/jclass argument
+  WorkAroundJniBugsForJobject(arg_ptr);
+  arg_ptr++;
+  // Fix up jobject arguments
+  MethodHelper mh(jni_method);
+  int reg_num = 2;  // Current register being processed, -1 for stack arguments.
+  for (uint32_t i = 1; i < mh.GetShortyLength(); i++) {
+    char shorty_char = mh.GetShorty()[i];
+    if (shorty_char == 'L') {
+      WorkAroundJniBugsForJobject(arg_ptr);
+    }
+    if (shorty_char == 'J' || shorty_char == 'D') {
+      if (reg_num == 2) {
+        arg_ptr = sp + 8;  // skip to out arguments
+        reg_num = -1;
+      } else if (reg_num == 3) {
+        arg_ptr = sp + 10;  // skip to out arguments plus 2 slots as long must be aligned
+        reg_num = -1;
+      } else {
+        DCHECK_EQ(reg_num, -1);
+        if ((reinterpret_cast<intptr_t>(arg_ptr) & 7) == 4) {
+          arg_ptr += 3;  // unaligned, pad and move through stack arguments
+        } else {
+          arg_ptr += 2;  // aligned, move through stack arguments
+        }
+      }
+    } else {
+      if (reg_num == 2) {
+        arg_ptr++;  // move through register arguments
+        reg_num++;
+      } else if (reg_num == 3) {
+        arg_ptr = sp + 8;  // skip to outgoing stack arguments
+        reg_num = -1;
+      } else {
+        DCHECK_EQ(reg_num, -1);
+        arg_ptr++;  // move through stack arguments
+      }
+    }
+  }
+  // Load expected destination, see Method::RegisterNative
+  const void* code = reinterpret_cast<const void*>(jni_method->GetNativeGcMap());
+  if (UNLIKELY(code == NULL)) {
+    code = GetJniDlsymLookupStub();
+    jni_method->RegisterNative(self, code);
+  }
+  return code;
+}
+
 }  // namespace art
diff --git a/runtime/entrypoints/jni/jni_entrypoints.h b/runtime/entrypoints/jni/jni_entrypoints.h
new file mode 100644
index 0000000000..0a53447cb4
--- /dev/null
+++ b/runtime/entrypoints/jni/jni_entrypoints.h
@@ -0,0 +1,37 @@
+/*
+ * 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_RUNTIME_ENTRYPOINTS_JNI_JNI_ENTRYPOINTS_H_
+#define ART_RUNTIME_ENTRYPOINTS_JNI_JNI_ENTRYPOINTS_H_
+
+#include "base/macros.h"
+#include "offsets.h"
+
+#define JNI_ENTRYPOINT_OFFSET(x) \
+    ThreadOffset(static_cast<uintptr_t>(OFFSETOF_MEMBER(Thread, jni_entrypoints_)) + \
+                 static_cast<uintptr_t>(OFFSETOF_MEMBER(JniEntryPoints, x)))
+
+namespace art {
+
+// Pointers to functions that are called by JNI trampolines via thread-local storage.
+struct PACKED(4) JniEntryPoints {
+  // Called when the JNI method isn't registered.
+  void* (*pDlsymLookup)(JNIEnv* env, jobject);
+};
+
+}  // namespace art
+
+#endif  // ART_RUNTIME_ENTRYPOINTS_JNI_JNI_ENTRYPOINTS_H_
diff --git a/runtime/entrypoints/portable/portable_entrypoints.h b/runtime/entrypoints/portable/portable_entrypoints.h
index a229c76dbd..ec9e4f8a7d 100644
--- a/runtime/entrypoints/portable/portable_entrypoints.h
+++ b/runtime/entrypoints/portable/portable_entrypoints.h
@@ -28,15 +28,15 @@ namespace mirror {
 class Thread;
 
 #define PORTABLE_ENTRYPOINT_OFFSET(x) \
-    (static_cast<uintptr_t>(OFFSETOF_MEMBER(Thread, portable_entrypoints_)) + \
-        static_cast<uintptr_t>(OFFSETOF_MEMBER(PortableEntryPoints, x)))
+    ThreadOffset(static_cast<uintptr_t>(OFFSETOF_MEMBER(Thread, portable_entrypoints_)) + \
+                 static_cast<uintptr_t>(OFFSETOF_MEMBER(PortableEntryPoints, x)))
 
 // Pointers to functions that are called by code generated by compiler's adhering to the portable
 // compiler ABI.
 struct PACKED(4) PortableEntryPoints {
   // Invocation
-  const void* (*pPortableResolutionTrampolineFromCode)(mirror::AbstractMethod*, mirror::Object*,
-                                                       mirror::AbstractMethod**, Thread*);
+  void (*pPortableResolutionTrampoline)(mirror::AbstractMethod*);
+  void (*pPortableToInterpreterBridge)(mirror::AbstractMethod*);
 };
 
 }  // namespace art
diff --git a/runtime/entrypoints/quick/quick_argument_visitor.h b/runtime/entrypoints/quick/quick_argument_visitor.h
deleted file mode 100644
index 35fa97269c..0000000000
--- a/runtime/entrypoints/quick/quick_argument_visitor.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright (C) 2013 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_RUNTIME_ENTRYPOINTS_QUICK_QUICK_ARGUMENT_VISITOR_H_
-#define ART_RUNTIME_ENTRYPOINTS_QUICK_QUICK_ARGUMENT_VISITOR_H_
-
-#include "object_utils.h"
-
-namespace art {
-
-// Visits the arguments as saved to the stack by a Runtime::kRefAndArgs callee save frame.
-class QuickArgumentVisitor {
- public:
-// Offset to first (not the Method*) argument in a Runtime::kRefAndArgs callee save frame.
-// Size of Runtime::kRefAndArgs callee save frame.
-// Size of Method* and register parameters in out stack arguments.
-#if defined(__arm__)
-#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__R1_OFFSET 8
-#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE 48
-#define QUICK_STACK_ARG_SKIP 16
-#elif defined(__mips__)
-#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__R1_OFFSET 4
-#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE 64
-#define QUICK_STACK_ARG_SKIP 16
-#elif defined(__i386__)
-#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__R1_OFFSET 4
-#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE 32
-#define QUICK_STACK_ARG_SKIP 16
-#else
-#error "Unsupported architecture"
-#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__R1_OFFSET 0
-#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE 0
-#define QUICK_STACK_ARG_SKIP 0
-#endif
-
-  QuickArgumentVisitor(MethodHelper& caller_mh, mirror::AbstractMethod** sp)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) :
-    caller_mh_(caller_mh),
-    args_in_regs_(ComputeArgsInRegs(caller_mh)),
-    num_params_(caller_mh.NumArgs()),
-    reg_args_(reinterpret_cast<byte*>(sp) + QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__R1_OFFSET),
-    stack_args_(reinterpret_cast<byte*>(sp) + QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE
-                + QUICK_STACK_ARG_SKIP),
-    cur_args_(reg_args_),
-    cur_arg_index_(0),
-    param_index_(0),
-    is_split_long_or_double_(false) {
-  }
-
-  virtual ~QuickArgumentVisitor() {}
-
-  virtual void Visit() = 0;
-
-  bool IsParamAReference() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return caller_mh_.IsParamAReference(param_index_);
-  }
-
-  bool IsParamALongOrDouble() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return caller_mh_.IsParamALongOrDouble(param_index_);
-  }
-
-  Primitive::Type GetParamPrimitiveType() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return caller_mh_.GetParamPrimitiveType(param_index_);
-  }
-
-  byte* GetParamAddress() const {
-    return cur_args_ + (cur_arg_index_ * kPointerSize);
-  }
-
-  bool IsSplitLongOrDouble() const {
-    return is_split_long_or_double_;
-  }
-
-  uint64_t ReadSplitLongParam() const {
-    DCHECK(IsSplitLongOrDouble());
-    uint64_t low_half = *reinterpret_cast<uint32_t*>(GetParamAddress());
-    uint64_t high_half = *reinterpret_cast<uint32_t*>(stack_args_);
-    return (low_half & 0xffffffffULL) | (high_half << 32);
-  }
-
-  void VisitArguments() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    for (cur_arg_index_ = 0;  cur_arg_index_ < args_in_regs_ && param_index_ < num_params_; ) {
-      is_split_long_or_double_ = (cur_arg_index_ == 2) && IsParamALongOrDouble();
-      Visit();
-      cur_arg_index_ += (IsParamALongOrDouble() ? 2 : 1);
-      param_index_++;
-    }
-    cur_args_ = stack_args_;
-    cur_arg_index_ = is_split_long_or_double_ ? 1 : 0;
-    is_split_long_or_double_ = false;
-    while (param_index_ < num_params_) {
-      Visit();
-      cur_arg_index_ += (IsParamALongOrDouble() ? 2 : 1);
-      param_index_++;
-    }
-  }
-
- private:
-  static size_t ComputeArgsInRegs(MethodHelper& mh) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    size_t args_in_regs = 0;
-    size_t num_params = mh.NumArgs();
-    for (size_t i = 0; i < num_params; i++) {
-      args_in_regs = args_in_regs + (mh.IsParamALongOrDouble(i) ? 2 : 1);
-      if (args_in_regs > 3) {
-        args_in_regs = 3;
-        break;
-      }
-    }
-    return args_in_regs;
-  }
-  MethodHelper& caller_mh_;
-  const size_t args_in_regs_;
-  const size_t num_params_;
-  byte* const reg_args_;
-  byte* const stack_args_;
-  byte* cur_args_;
-  size_t cur_arg_index_;
-  size_t param_index_;
-  // Does a 64bit parameter straddle the register and stack arguments?
-  bool is_split_long_or_double_;
-};
-
-}  // namespace art
-
-#endif  // ART_RUNTIME_ENTRYPOINTS_QUICK_QUICK_ARGUMENT_VISITOR_H_
diff --git a/runtime/entrypoints/quick/quick_entrypoints.h b/runtime/entrypoints/quick/quick_entrypoints.h
index 74b8cfd09b..e76679b91f 100644
--- a/runtime/entrypoints/quick/quick_entrypoints.h
+++ b/runtime/entrypoints/quick/quick_entrypoints.h
@@ -17,44 +17,45 @@
 #ifndef ART_RUNTIME_ENTRYPOINTS_QUICK_QUICK_ENTRYPOINTS_H_
 #define ART_RUNTIME_ENTRYPOINTS_QUICK_QUICK_ENTRYPOINTS_H_
 
-#include "dex_file-inl.h"
-#include "runtime.h"
+#include <jni.h>
+
+#include "base/macros.h"
+#include "offsets.h"
 
 #define QUICK_ENTRYPOINT_OFFSET(x) \
-    (static_cast<uintptr_t>(OFFSETOF_MEMBER(Thread, quick_entrypoints_)) + \
-        static_cast<uintptr_t>(OFFSETOF_MEMBER(QuickEntryPoints, x)))
+    ThreadOffset(static_cast<uintptr_t>(OFFSETOF_MEMBER(Thread, quick_entrypoints_)) + \
+                 static_cast<uintptr_t>(OFFSETOF_MEMBER(QuickEntryPoints, x)))
 
 namespace art {
+
 namespace mirror {
   class AbstractMethod;
   class Class;
   class Object;
 }  // namespace mirror
-class DvmDex;
-class MethodHelper;
-class ShadowFrame;
+
 class Thread;
 
 // Pointers to functions that are called by quick compiler generated code via thread-local storage.
 struct PACKED(4) QuickEntryPoints {
   // Alloc
-  void* (*pAllocArrayFromCode)(uint32_t, void*, int32_t);
-  void* (*pAllocArrayFromCodeWithAccessCheck)(uint32_t, void*, int32_t);
-  void* (*pAllocObjectFromCode)(uint32_t, void*);
-  void* (*pAllocObjectFromCodeWithAccessCheck)(uint32_t, void*);
-  void* (*pCheckAndAllocArrayFromCode)(uint32_t, void*, int32_t);
-  void* (*pCheckAndAllocArrayFromCodeWithAccessCheck)(uint32_t, void*, int32_t);
+  void* (*pAllocArray)(uint32_t, void*, int32_t);
+  void* (*pAllocArrayWithAccessCheck)(uint32_t, void*, int32_t);
+  void* (*pAllocObject)(uint32_t, void*);
+  void* (*pAllocObjectWithAccessCheck)(uint32_t, void*);
+  void* (*pCheckAndAllocArray)(uint32_t, void*, int32_t);
+  void* (*pCheckAndAllocArrayWithAccessCheck)(uint32_t, void*, int32_t);
 
   // Cast
-  uint32_t (*pInstanceofNonTrivialFromCode)(const mirror::Class*, const mirror::Class*);
-  void (*pCanPutArrayElementFromCode)(void*, void*);
-  void (*pCheckCastFromCode)(void*, void*);
+  uint32_t (*pInstanceofNonTrivial)(const mirror::Class*, const mirror::Class*);
+  void (*pCanPutArrayElement)(void*, void*);
+  void (*pCheckCast)(void*, void*);
 
   // DexCache
   void* (*pInitializeStaticStorage)(uint32_t, void*);
-  void* (*pInitializeTypeAndVerifyAccessFromCode)(uint32_t, void*);
-  void* (*pInitializeTypeFromCode)(uint32_t, void*);
-  void* (*pResolveStringFromCode)(void*, uint32_t);
+  void* (*pInitializeTypeAndVerifyAccess)(uint32_t, void*);
+  void* (*pInitializeType)(uint32_t, void*);
+  void* (*pResolveString)(void*, uint32_t);
 
   // Field
   int (*pSet32Instance)(uint32_t, void*, int32_t);  // field_idx, obj, src
@@ -71,7 +72,7 @@ struct PACKED(4) QuickEntryPoints {
   void* (*pGetObjStatic)(uint32_t);
 
   // FillArray
-  void (*pHandleFillArrayDataFromCode)(void*, void*);
+  void (*pHandleFillArrayData)(void*, void*);
 
   // JNI
   uint32_t (*pJniMethodStart)(Thread*);
@@ -83,8 +84,8 @@ struct PACKED(4) QuickEntryPoints {
                                                     jobject locked, Thread* self);
 
   // Locks
-  void (*pLockObjectFromCode)(void*);
-  void (*pUnlockObjectFromCode)(void*);
+  void (*pLockObject)(void*);
+  void (*pUnlockObject)(void*);
 
   // Math
   int32_t (*pCmpgDouble)(double, double);
@@ -108,14 +109,6 @@ struct PACKED(4) QuickEntryPoints {
   uint64_t (*pShrLong)(uint64_t, uint32_t);
   uint64_t (*pUshrLong)(uint64_t, uint32_t);
 
-  // Interpreter
-  void (*pInterpreterToInterpreterEntry)(Thread* self, MethodHelper& mh,
-                                         const DexFile::CodeItem* code_item,
-                                         ShadowFrame* shadow_frame, JValue* result);
-  void (*pInterpreterToQuickEntry)(Thread* self, MethodHelper& mh,
-                                   const DexFile::CodeItem* code_item,
-                                   ShadowFrame* shadow_frame, JValue* result);
-
   // Intrinsics
   int32_t (*pIndexOf)(void*, uint32_t, uint32_t, uint32_t);
   int32_t (*pMemcmp16)(void*, void*, int32_t);
@@ -123,8 +116,8 @@ struct PACKED(4) QuickEntryPoints {
   void* (*pMemcpy)(void*, const void*, size_t);
 
   // Invocation
-  const void* (*pQuickResolutionTrampolineFromCode)(mirror::AbstractMethod*, mirror::Object*,
-                                                    mirror::AbstractMethod**, Thread*);
+  void (*pQuickResolutionTrampoline)(mirror::AbstractMethod*);
+  void (*pQuickToInterpreterBridge)(mirror::AbstractMethod*);
   void (*pInvokeDirectTrampolineWithAccessCheck)(uint32_t, void*);
   void (*pInvokeInterfaceTrampoline)(uint32_t, void*);
   void (*pInvokeInterfaceTrampolineWithAccessCheck)(uint32_t, void*);
@@ -133,22 +126,21 @@ struct PACKED(4) QuickEntryPoints {
   void (*pInvokeVirtualTrampolineWithAccessCheck)(uint32_t, void*);
 
   // Thread
-  void (*pCheckSuspendFromCode)(Thread*);  // Stub that is called when the suspend count is non-zero
-  void (*pTestSuspendFromCode)();  // Stub that is periodically called to test the suspend count
+  void (*pCheckSuspend)(Thread*);  // Stub that is called when the suspend count is non-zero
+  void (*pTestSuspend)();  // Stub that is periodically called to test the suspend count
 
   // Throws
   void (*pDeliverException)(void*);
-  void (*pThrowArrayBoundsFromCode)(int32_t, int32_t);
-  void (*pThrowDivZeroFromCode)();
-  void (*pThrowNoSuchMethodFromCode)(int32_t);
-  void (*pThrowNullPointerFromCode)();
-  void (*pThrowStackOverflowFromCode)(void*);
+  void (*pThrowArrayBounds)(int32_t, int32_t);
+  void (*pThrowDivZero)();
+  void (*pThrowNoSuchMethod)(int32_t);
+  void (*pThrowNullPointer)();
+  void (*pThrowStackOverflow)(void*);
 };
 
 
 // JNI entrypoints.
-extern uint32_t JniMethodStart(Thread* self)
-    UNLOCK_FUNCTION(Locks::mutator_lock_) HOT_ATTR;
+extern uint32_t JniMethodStart(Thread* self) UNLOCK_FUNCTION(Locks::mutator_lock_) HOT_ATTR;
 extern uint32_t JniMethodStartSynchronized(jobject to_lock, Thread* self)
     UNLOCK_FUNCTION(Locks::mutator_lock_) HOT_ATTR;
 extern void JniMethodEnd(uint32_t saved_local_ref_cookie, Thread* self)
diff --git a/runtime/entrypoints/quick/quick_instrumentation_entrypoints.cc b/runtime/entrypoints/quick/quick_instrumentation_entrypoints.cc
index 7ecd296742..0e61942209 100644
--- a/runtime/entrypoints/quick/quick_instrumentation_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_instrumentation_entrypoints.cc
@@ -32,7 +32,7 @@ extern "C" const void* artInstrumentationMethodEntryFromCode(mirror::AbstractMet
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
   instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
   const void* result = instrumentation->GetQuickCodeFor(method);
-  bool interpreter_entry = (result == GetInterpreterEntryPoint());
+  bool interpreter_entry = (result == GetQuickToInterpreterBridge());
   instrumentation->PushInstrumentationStackFrame(self, method->IsStatic() ? NULL : this_object,
                                                  method, lr, interpreter_entry);
   CHECK(result != NULL) << PrettyMethod(method);
diff --git a/runtime/entrypoints/quick/quick_interpreter_entrypoints.cc b/runtime/entrypoints/quick/quick_interpreter_entrypoints.cc
deleted file mode 100644
index 656df8de5b..0000000000
--- a/runtime/entrypoints/quick/quick_interpreter_entrypoints.cc
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * 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.
- */
-
-#include "quick_argument_visitor.h"
-#include "callee_save_frame.h"
-#include "dex_file-inl.h"
-#include "interpreter/interpreter.h"
-#include "invoke_arg_array_builder.h"
-#include "mirror/abstract_method-inl.h"
-#include "mirror/class-inl.h"
-#include "mirror/object-inl.h"
-#include "mirror/object_array-inl.h"
-#include "object_utils.h"
-
-namespace art {
-
-// Visits arguments on the stack placing them into the shadow frame.
-class BuildShadowFrameVisitor : public QuickArgumentVisitor {
- public:
-  BuildShadowFrameVisitor(MethodHelper& caller_mh, mirror::AbstractMethod** sp,
-                          ShadowFrame& sf, size_t first_arg_reg) :
-    QuickArgumentVisitor(caller_mh, sp), sf_(sf), cur_reg_(first_arg_reg) {}
-
-  virtual void Visit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    Primitive::Type type = GetParamPrimitiveType();
-    switch (type) {
-      case Primitive::kPrimLong:  // Fall-through.
-      case Primitive::kPrimDouble:
-        if (IsSplitLongOrDouble()) {
-          sf_.SetVRegLong(cur_reg_, ReadSplitLongParam());
-        } else {
-          sf_.SetVRegLong(cur_reg_, *reinterpret_cast<jlong*>(GetParamAddress()));
-        }
-        ++cur_reg_;
-        break;
-      case Primitive::kPrimNot:
-        sf_.SetVRegReference(cur_reg_, *reinterpret_cast<mirror::Object**>(GetParamAddress()));
-        break;
-      case Primitive::kPrimBoolean:  // Fall-through.
-      case Primitive::kPrimByte:     // Fall-through.
-      case Primitive::kPrimChar:     // Fall-through.
-      case Primitive::kPrimShort:    // Fall-through.
-      case Primitive::kPrimInt:      // Fall-through.
-      case Primitive::kPrimFloat:
-        sf_.SetVReg(cur_reg_, *reinterpret_cast<jint*>(GetParamAddress()));
-        break;
-      case Primitive::kPrimVoid:
-        LOG(FATAL) << "UNREACHABLE";
-        break;
-    }
-    ++cur_reg_;
-  }
-
- private:
-  ShadowFrame& sf_;
-  size_t cur_reg_;
-
-  DISALLOW_COPY_AND_ASSIGN(BuildShadowFrameVisitor);
-};
-
-extern "C" uint64_t artInterpreterEntry(mirror::AbstractMethod* method, Thread* self,
-                                        mirror::AbstractMethod** sp)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  // Ensure we don't get thread suspension until the object arguments are safely in the shadow
-  // frame.
-  const char* old_cause = self->StartAssertNoThreadSuspension("Building interpreter shadow frame");
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
-
-  MethodHelper mh(method);
-  const DexFile::CodeItem* code_item = mh.GetCodeItem();
-  uint16_t num_regs = code_item->registers_size_;
-  void* memory = alloca(ShadowFrame::ComputeSize(num_regs));
-  ShadowFrame* shadow_frame(ShadowFrame::Create(num_regs, NULL,  // No last shadow coming from quick.
-                                                method, 0, memory));
-  size_t first_arg_reg = code_item->registers_size_ - code_item->ins_size_;
-  BuildShadowFrameVisitor shadow_frame_builder(mh, sp, *shadow_frame, first_arg_reg);
-  shadow_frame_builder.VisitArguments();
-  // Push a transition back into managed code onto the linked list in thread.
-  ManagedStack fragment;
-  self->PushManagedStackFragment(&fragment);
-  self->PushShadowFrame(shadow_frame);
-  self->EndAssertNoThreadSuspension(old_cause);
-
-  if (method->IsStatic() && !method->GetDeclaringClass()->IsInitializing()) {
-    // Ensure static method's class is initialized.
-    if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(method->GetDeclaringClass(),
-                                                                 true, true)) {
-      DCHECK(Thread::Current()->IsExceptionPending());
-      self->PopManagedStackFragment(fragment);
-      return 0;
-    }
-  }
-
-  JValue result = interpreter::EnterInterpreterFromStub(self, mh, code_item, *shadow_frame);
-  // Pop transition.
-  self->PopManagedStackFragment(fragment);
-  return result.GetJ();
-}
-
-extern "C" void artInterpreterToQuickEntry(Thread* self, MethodHelper& mh,
-                                           const DexFile::CodeItem* code_item,
-                                           ShadowFrame* shadow_frame, JValue* result)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::AbstractMethod* method = shadow_frame->GetMethod();
-  // Ensure static methods are initialized.
-  if (method->IsStatic()) {
-    Runtime::Current()->GetClassLinker()->EnsureInitialized(method->GetDeclaringClass(), true, true);
-  }
-  uint16_t arg_offset = (code_item == NULL) ? 0 : code_item->registers_size_ - code_item->ins_size_;
-  ArgArray arg_array(mh.GetShorty(), mh.GetShortyLength());
-  arg_array.BuildArgArray(shadow_frame, arg_offset);
-  method->Invoke(self, arg_array.GetArray(), arg_array.GetNumBytes(), result, mh.GetShorty()[0]);
-}
-
-}  // namespace art
diff --git a/runtime/entrypoints/quick/quick_jni_entrypoints.cc b/runtime/entrypoints/quick/quick_jni_entrypoints.cc
index 23a28f9cce..9907c043ee 100644
--- a/runtime/entrypoints/quick/quick_jni_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_jni_entrypoints.cc
@@ -94,78 +94,4 @@ extern mirror::Object* JniMethodEndWithReferenceSynchronized(jobject result,
   return o;
 }
 
-static void WorkAroundJniBugsForJobject(intptr_t* arg_ptr) {
-  intptr_t value = *arg_ptr;
-  mirror::Object** value_as_jni_rep = reinterpret_cast<mirror::Object**>(value);
-  mirror::Object* value_as_work_around_rep = value_as_jni_rep != NULL ? *value_as_jni_rep : NULL;
-  CHECK(Runtime::Current()->GetHeap()->IsHeapAddress(value_as_work_around_rep))
-      << value_as_work_around_rep;
-  *arg_ptr = reinterpret_cast<intptr_t>(value_as_work_around_rep);
-}
-
-extern "C" const void* artWorkAroundAppJniBugs(Thread* self, intptr_t* sp)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  DCHECK(Thread::Current() == self);
-  // TODO: this code is specific to ARM
-  // On entry the stack pointed by sp is:
-  // | arg3   | <- Calling JNI method's frame (and extra bit for out args)
-  // | LR     |
-  // | R3     |    arg2
-  // | R2     |    arg1
-  // | R1     |    jclass/jobject
-  // | R0     |    JNIEnv
-  // | unused |
-  // | unused |
-  // | unused | <- sp
-  mirror::AbstractMethod* jni_method = self->GetCurrentMethod(NULL);
-  DCHECK(jni_method->IsNative()) << PrettyMethod(jni_method);
-  intptr_t* arg_ptr = sp + 4;  // pointer to r1 on stack
-  // Fix up this/jclass argument
-  WorkAroundJniBugsForJobject(arg_ptr);
-  arg_ptr++;
-  // Fix up jobject arguments
-  MethodHelper mh(jni_method);
-  int reg_num = 2;  // Current register being processed, -1 for stack arguments.
-  for (uint32_t i = 1; i < mh.GetShortyLength(); i++) {
-    char shorty_char = mh.GetShorty()[i];
-    if (shorty_char == 'L') {
-      WorkAroundJniBugsForJobject(arg_ptr);
-    }
-    if (shorty_char == 'J' || shorty_char == 'D') {
-      if (reg_num == 2) {
-        arg_ptr = sp + 8;  // skip to out arguments
-        reg_num = -1;
-      } else if (reg_num == 3) {
-        arg_ptr = sp + 10;  // skip to out arguments plus 2 slots as long must be aligned
-        reg_num = -1;
-      } else {
-        DCHECK_EQ(reg_num, -1);
-        if ((reinterpret_cast<intptr_t>(arg_ptr) & 7) == 4) {
-          arg_ptr += 3;  // unaligned, pad and move through stack arguments
-        } else {
-          arg_ptr += 2;  // aligned, move through stack arguments
-        }
-      }
-    } else {
-      if (reg_num == 2) {
-        arg_ptr++;  // move through register arguments
-        reg_num++;
-      } else if (reg_num == 3) {
-        arg_ptr = sp + 8;  // skip to outgoing stack arguments
-        reg_num = -1;
-      } else {
-        DCHECK_EQ(reg_num, -1);
-        arg_ptr++;  // move through stack arguments
-      }
-    }
-  }
-  // Load expected destination, see Method::RegisterNative
-  const void* code = reinterpret_cast<const void*>(jni_method->GetNativeGcMap());
-  if (UNLIKELY(code == NULL)) {
-    code = GetJniDlsymLookupStub();
-    jni_method->RegisterNative(self, code);
-  }
-  return code;
-}
-
 }  // namespace art
diff --git a/runtime/entrypoints/quick/quick_proxy_entrypoints.cc b/runtime/entrypoints/quick/quick_proxy_entrypoints.cc
deleted file mode 100644
index 4e3d749e27..0000000000
--- a/runtime/entrypoints/quick/quick_proxy_entrypoints.cc
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * 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.
- */
-
-#include "quick_argument_visitor.h"
-#include "dex_file-inl.h"
-#include "entrypoints/entrypoint_utils.h"
-#include "mirror/abstract_method-inl.h"
-#include "mirror/object_array-inl.h"
-#include "mirror/object-inl.h"
-#include "object_utils.h"
-#include "reflection.h"
-#include "scoped_thread_state_change.h"
-#include "thread.h"
-#include "well_known_classes.h"
-
-#include "ScopedLocalRef.h"
-
-namespace art {
-
-// Visits arguments on the stack placing them into the args vector, Object* arguments are converted
-// to jobjects.
-class BuildQuickArgumentVisitor : public QuickArgumentVisitor {
- public:
-  BuildQuickArgumentVisitor(MethodHelper& caller_mh, mirror::AbstractMethod** sp,
-                            ScopedObjectAccessUnchecked& soa, std::vector<jvalue>& args) :
-    QuickArgumentVisitor(caller_mh, sp), soa_(soa), args_(args) {}
-
-  virtual void Visit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    jvalue val;
-    Primitive::Type type = GetParamPrimitiveType();
-    switch (type) {
-      case Primitive::kPrimNot: {
-        mirror::Object* obj = *reinterpret_cast<mirror::Object**>(GetParamAddress());
-        val.l = soa_.AddLocalReference<jobject>(obj);
-        break;
-      }
-      case Primitive::kPrimLong:  // Fall-through.
-      case Primitive::kPrimDouble:
-        if (IsSplitLongOrDouble()) {
-          val.j = ReadSplitLongParam();
-        } else {
-          val.j = *reinterpret_cast<jlong*>(GetParamAddress());
-        }
-        break;
-      case Primitive::kPrimBoolean:  // Fall-through.
-      case Primitive::kPrimByte:     // Fall-through.
-      case Primitive::kPrimChar:     // Fall-through.
-      case Primitive::kPrimShort:    // Fall-through.
-      case Primitive::kPrimInt:      // Fall-through.
-      case Primitive::kPrimFloat:
-        val.i =  *reinterpret_cast<jint*>(GetParamAddress());
-        break;
-      case Primitive::kPrimVoid:
-        LOG(FATAL) << "UNREACHABLE";
-        val.j = 0;
-        break;
-    }
-    args_.push_back(val);
-  }
-
- private:
-  ScopedObjectAccessUnchecked& soa_;
-  std::vector<jvalue>& args_;
-
-  DISALLOW_COPY_AND_ASSIGN(BuildQuickArgumentVisitor);
-};
-
-// Handler for invocation on proxy methods. On entry a frame will exist for the proxy object method
-// which is responsible for recording callee save registers. We explicitly place into jobjects the
-// incoming reference arguments (so they survive GC). We invoke the invocation handler, which is a
-// field within the proxy object, which will box the primitive arguments and deal with error cases.
-extern "C" uint64_t artQuickProxyInvokeHandler(mirror::AbstractMethod* proxy_method,
-                                          mirror::Object* receiver,
-                                          Thread* self, mirror::AbstractMethod** sp)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  // Ensure we don't get thread suspension until the object arguments are safely in jobjects.
-  const char* old_cause =
-      self->StartAssertNoThreadSuspension("Adding to IRT proxy object arguments");
-  // Register the top of the managed stack, making stack crawlable.
-  DCHECK_EQ(*sp, proxy_method);
-  self->SetTopOfStack(sp, 0);
-  DCHECK_EQ(proxy_method->GetFrameSizeInBytes(),
-            Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
-  self->VerifyStack();
-  // Start new JNI local reference state.
-  JNIEnvExt* env = self->GetJniEnv();
-  ScopedObjectAccessUnchecked soa(env);
-  ScopedJniEnvLocalRefState env_state(env);
-  // Create local ref. copies of proxy method and the receiver.
-  jobject rcvr_jobj = soa.AddLocalReference<jobject>(receiver);
-
-  // Placing arguments into args vector and remove the receiver.
-  MethodHelper proxy_mh(proxy_method);
-  std::vector<jvalue> args;
-  BuildQuickArgumentVisitor local_ref_visitor(proxy_mh, sp, soa, args);
-  local_ref_visitor.VisitArguments();
-  args.erase(args.begin());
-
-  // Convert proxy method into expected interface method.
-  mirror::AbstractMethod* interface_method = proxy_method->FindOverriddenMethod();
-  DCHECK(interface_method != NULL);
-  DCHECK(!interface_method->IsProxyMethod()) << PrettyMethod(interface_method);
-  jobject interface_method_jobj = soa.AddLocalReference<jobject>(interface_method);
-
-  // All naked Object*s should now be in jobjects, so its safe to go into the main invoke code
-  // that performs allocations.
-  self->EndAssertNoThreadSuspension(old_cause);
-  JValue result = InvokeProxyInvocationHandler(soa, proxy_mh.GetShorty(),
-                                               rcvr_jobj, interface_method_jobj, args);
-  return result.GetJ();
-}
-
-}  // namespace art
diff --git a/runtime/entrypoints/quick/quick_stub_entrypoints.cc b/runtime/entrypoints/quick/quick_stub_entrypoints.cc
deleted file mode 100644
index d78bbf3bc8..0000000000
--- a/runtime/entrypoints/quick/quick_stub_entrypoints.cc
+++ /dev/null
@@ -1,295 +0,0 @@
-/*
- * 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.
- */
-
-#include "callee_save_frame.h"
-#include "class_linker-inl.h"
-#include "dex_file-inl.h"
-#include "dex_instruction-inl.h"
-#include "mirror/class-inl.h"
-#include "mirror/abstract_method-inl.h"
-#include "mirror/object_array-inl.h"
-#include "mirror/object-inl.h"
-#include "object_utils.h"
-#include "scoped_thread_state_change.h"
-
-// Architecture specific assembler helper to deliver exception.
-extern "C" void art_quick_deliver_exception_from_code(void*);
-
-namespace art {
-
-// Lazily resolve a method for quick. Called by stub code.
-extern "C" const void* artQuickResolutionTrampoline(mirror::AbstractMethod* called,
-                                                    mirror::Object* receiver,
-                                                    mirror::AbstractMethod** sp, Thread* thread)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-#if defined(__arm__)
-  // On entry the stack pointed by sp is:
-  // | argN       |  |
-  // | ...        |  |
-  // | arg4       |  |
-  // | arg3 spill |  |  Caller's frame
-  // | arg2 spill |  |
-  // | arg1 spill |  |
-  // | Method*    | ---
-  // | LR         |
-  // | ...        |    callee saves
-  // | R3         |    arg3
-  // | R2         |    arg2
-  // | R1         |    arg1
-  // | R0         |
-  // | Method*    |  <- sp
-  DCHECK_EQ(48U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
-  mirror::AbstractMethod** caller_sp = reinterpret_cast<mirror::AbstractMethod**>(reinterpret_cast<byte*>(sp) + 48);
-  uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp) + kPointerSize);
-  uint32_t pc_offset = 10;
-  uintptr_t caller_pc = regs[pc_offset];
-#elif defined(__i386__)
-  // On entry the stack pointed by sp is:
-  // | argN        |  |
-  // | ...         |  |
-  // | arg4        |  |
-  // | arg3 spill  |  |  Caller's frame
-  // | arg2 spill  |  |
-  // | arg1 spill  |  |
-  // | Method*     | ---
-  // | Return      |
-  // | EBP,ESI,EDI |    callee saves
-  // | EBX         |    arg3
-  // | EDX         |    arg2
-  // | ECX         |    arg1
-  // | EAX/Method* |  <- sp
-  DCHECK_EQ(32U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
-  mirror::AbstractMethod** caller_sp = reinterpret_cast<mirror::AbstractMethod**>(reinterpret_cast<byte*>(sp) + 32);
-  uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp));
-  uintptr_t caller_pc = regs[7];
-#elif defined(__mips__)
-  // On entry the stack pointed by sp is:
-  // | argN       |  |
-  // | ...        |  |
-  // | arg4       |  |
-  // | arg3 spill |  |  Caller's frame
-  // | arg2 spill |  |
-  // | arg1 spill |  |
-  // | Method*    | ---
-  // | RA         |
-  // | ...        |    callee saves
-  // | A3         |    arg3
-  // | A2         |    arg2
-  // | A1         |    arg1
-  // | A0/Method* |  <- sp
-  DCHECK_EQ(64U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
-  mirror::AbstractMethod** caller_sp = reinterpret_cast<mirror::AbstractMethod**>(reinterpret_cast<byte*>(sp) + 64);
-  uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp));
-  uint32_t pc_offset = 15;
-  uintptr_t caller_pc = regs[pc_offset];
-#else
-  UNIMPLEMENTED(FATAL);
-  mirror::AbstractMethod** caller_sp = NULL;
-  uintptr_t* regs = NULL;
-  uintptr_t caller_pc = 0;
-#endif
-  FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsAndArgs);
-  // Start new JNI local reference state
-  JNIEnvExt* env = thread->GetJniEnv();
-  ScopedObjectAccessUnchecked soa(env);
-  ScopedJniEnvLocalRefState env_state(env);
-
-  // Compute details about the called method (avoid GCs)
-  ClassLinker* linker = Runtime::Current()->GetClassLinker();
-  mirror::AbstractMethod* caller = *caller_sp;
-  InvokeType invoke_type;
-  uint32_t dex_method_idx;
-#if !defined(__i386__)
-  const char* shorty;
-  uint32_t shorty_len;
-#endif
-  if (called->IsRuntimeMethod()) {
-    uint32_t dex_pc = caller->ToDexPc(caller_pc);
-    const DexFile::CodeItem* code = MethodHelper(caller).GetCodeItem();
-    CHECK_LT(dex_pc, code->insns_size_in_code_units_);
-    const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
-    Instruction::Code instr_code = instr->Opcode();
-    bool is_range;
-    switch (instr_code) {
-      case Instruction::INVOKE_DIRECT:
-        invoke_type = kDirect;
-        is_range = false;
-        break;
-      case Instruction::INVOKE_DIRECT_RANGE:
-        invoke_type = kDirect;
-        is_range = true;
-        break;
-      case Instruction::INVOKE_STATIC:
-        invoke_type = kStatic;
-        is_range = false;
-        break;
-      case Instruction::INVOKE_STATIC_RANGE:
-        invoke_type = kStatic;
-        is_range = true;
-        break;
-      case Instruction::INVOKE_SUPER:
-        invoke_type = kSuper;
-        is_range = false;
-        break;
-      case Instruction::INVOKE_SUPER_RANGE:
-        invoke_type = kSuper;
-        is_range = true;
-        break;
-      case Instruction::INVOKE_VIRTUAL:
-        invoke_type = kVirtual;
-        is_range = false;
-        break;
-      case Instruction::INVOKE_VIRTUAL_RANGE:
-        invoke_type = kVirtual;
-        is_range = true;
-        break;
-      case Instruction::INVOKE_INTERFACE:
-        invoke_type = kInterface;
-        is_range = false;
-        break;
-      case Instruction::INVOKE_INTERFACE_RANGE:
-        invoke_type = kInterface;
-        is_range = true;
-        break;
-      default:
-        LOG(FATAL) << "Unexpected call into trampoline: " << instr->DumpString(NULL);
-        // Avoid used uninitialized warnings.
-        invoke_type = kDirect;
-        is_range = false;
-    }
-    dex_method_idx = (is_range) ? instr->VRegB_3rc() : instr->VRegB_35c();
-#if !defined(__i386__)
-    shorty = linker->MethodShorty(dex_method_idx, caller, &shorty_len);
-#endif
-  } else {
-    invoke_type = kStatic;
-    dex_method_idx = called->GetDexMethodIndex();
-#if !defined(__i386__)
-    MethodHelper mh(called);
-    shorty = mh.GetShorty();
-    shorty_len = mh.GetShortyLength();
-#endif
-  }
-#if !defined(__i386__)
-  // Discover shorty (avoid GCs)
-  size_t args_in_regs = 0;
-  for (size_t i = 1; i < shorty_len; i++) {
-    char c = shorty[i];
-    args_in_regs = args_in_regs + (c == 'J' || c == 'D' ? 2 : 1);
-    if (args_in_regs > 3) {
-      args_in_regs = 3;
-      break;
-    }
-  }
-  // Place into local references incoming arguments from the caller's register arguments
-  size_t cur_arg = 1;   // skip method_idx in R0, first arg is in R1
-  if (invoke_type != kStatic) {
-    mirror::Object* obj = reinterpret_cast<mirror::Object*>(regs[cur_arg]);
-    cur_arg++;
-    if (args_in_regs < 3) {
-      // If we thought we had fewer than 3 arguments in registers, account for the receiver
-      args_in_regs++;
-    }
-    soa.AddLocalReference<jobject>(obj);
-  }
-  size_t shorty_index = 1;  // skip return value
-  // Iterate while arguments and arguments in registers (less 1 from cur_arg which is offset to skip
-  // R0)
-  while ((cur_arg - 1) < args_in_regs && shorty_index < shorty_len) {
-    char c = shorty[shorty_index];
-    shorty_index++;
-    if (c == 'L') {
-      mirror::Object* obj = reinterpret_cast<mirror::Object*>(regs[cur_arg]);
-      soa.AddLocalReference<jobject>(obj);
-    }
-    cur_arg = cur_arg + (c == 'J' || c == 'D' ? 2 : 1);
-  }
-  // Place into local references incoming arguments from the caller's stack arguments
-  cur_arg += pc_offset + 1;  // skip LR/RA, Method* and spills for R1-R3/A1-A3 and callee saves
-  while (shorty_index < shorty_len) {
-    char c = shorty[shorty_index];
-    shorty_index++;
-    if (c == 'L') {
-      mirror::Object* obj = reinterpret_cast<mirror::Object*>(regs[cur_arg]);
-      soa.AddLocalReference<jobject>(obj);
-    }
-    cur_arg = cur_arg + (c == 'J' || c == 'D' ? 2 : 1);
-  }
-#endif
-  // Resolve method filling in dex cache
-  if (called->IsRuntimeMethod()) {
-    called = linker->ResolveMethod(dex_method_idx, caller, invoke_type);
-  }
-  const void* code = NULL;
-  if (LIKELY(!thread->IsExceptionPending())) {
-    // Incompatible class change should have been handled in resolve method.
-    CHECK(!called->CheckIncompatibleClassChange(invoke_type));
-    // Refine called method based on receiver.
-    if (invoke_type == kVirtual) {
-      called = receiver->GetClass()->FindVirtualMethodForVirtual(called);
-    } else if (invoke_type == kInterface) {
-      called = receiver->GetClass()->FindVirtualMethodForInterface(called);
-    }
-    // Ensure that the called method's class is initialized.
-    mirror::Class* called_class = called->GetDeclaringClass();
-    linker->EnsureInitialized(called_class, true, true);
-    if (LIKELY(called_class->IsInitialized())) {
-      code = called->GetEntryPointFromCompiledCode();
-    } else if (called_class->IsInitializing()) {
-      if (invoke_type == kStatic) {
-        // Class is still initializing, go to oat and grab code (trampoline must be left in place
-        // until class is initialized to stop races between threads).
-        code = linker->GetOatCodeFor(called);
-      } else {
-        // No trampoline for non-static methods.
-        code = called->GetEntryPointFromCompiledCode();
-      }
-    } else {
-      DCHECK(called_class->IsErroneous());
-    }
-  }
-  if (UNLIKELY(code == NULL)) {
-    // Something went wrong in ResolveMethod or EnsureInitialized,
-    // go into deliver exception with the pending exception in r0
-    CHECK(thread->IsExceptionPending());
-    code = reinterpret_cast<void*>(art_quick_deliver_exception_from_code);
-    regs[0] = reinterpret_cast<uintptr_t>(thread->GetException(NULL));
-    thread->ClearException();
-  } else {
-    // Expect class to at least be initializing.
-    DCHECK(called->GetDeclaringClass()->IsInitializing());
-    // Don't want infinite recursion.
-    DCHECK(code != GetResolutionTrampoline(linker));
-    // Set up entry into main method
-    regs[0] = reinterpret_cast<uintptr_t>(called);
-  }
-  return code;
-}
-
-// Called by the abstract method error stub.
-extern "C" void artThrowAbstractMethodErrorFromCode(mirror::AbstractMethod* method, Thread* self,
-                                                    mirror::AbstractMethod** sp)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-#if !defined(ART_USE_PORTABLE_COMPILER)
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
-#else
-  UNUSED(sp);
-#endif
-  ThrowAbstractMethodError(method);
-  self->QuickDeliverException();
-}
-
-}  // namespace art
diff --git a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
new file mode 100644
index 0000000000..9bf02e8c8e
--- /dev/null
+++ b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
@@ -0,0 +1,558 @@
+/*
+ * 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.
+ */
+
+#include "callee_save_frame.h"
+#include "dex_file-inl.h"
+#include "dex_instruction-inl.h"
+#include "interpreter/interpreter.h"
+#include "invoke_arg_array_builder.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/class-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
+#include "object_utils.h"
+#include "runtime.h"
+
+namespace art {
+
+// Visits the arguments as saved to the stack by a Runtime::kRefAndArgs callee save frame.
+class QuickArgumentVisitor {
+ public:
+// Offset to first (not the Method*) argument in a Runtime::kRefAndArgs callee save frame.
+// Size of Runtime::kRefAndArgs callee save frame.
+// Size of Method* and register parameters in out stack arguments.
+#if defined(__arm__)
+  // The callee save frame is pointed to by SP.
+  // | argN       |  |
+  // | ...        |  |
+  // | arg4       |  |
+  // | arg3 spill |  |  Caller's frame
+  // | arg2 spill |  |
+  // | arg1 spill |  |
+  // | Method*    | ---
+  // | LR         |
+  // | ...        |    callee saves
+  // | R3         |    arg3
+  // | R2         |    arg2
+  // | R1         |    arg1
+  // | R0         |
+  // | Method*    |  <- sp
+#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__R1_OFFSET 8
+#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__LR_OFFSET 44
+#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE 48
+#define QUICK_STACK_ARG_SKIP 16
+#elif defined(__mips__)
+  // The callee save frame is pointed to by SP.
+  // | argN       |  |
+  // | ...        |  |
+  // | arg4       |  |
+  // | arg3 spill |  |  Caller's frame
+  // | arg2 spill |  |
+  // | arg1 spill |  |
+  // | Method*    | ---
+  // | RA         |
+  // | ...        |    callee saves
+  // | A3         |    arg3
+  // | A2         |    arg2
+  // | A1         |    arg1
+  // | A0/Method* |  <- sp
+#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__R1_OFFSET 4
+#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__LR_OFFSET 60
+#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE 64
+#define QUICK_STACK_ARG_SKIP 16
+#elif defined(__i386__)
+  // The callee save frame is pointed to by SP.
+  // | argN        |  |
+  // | ...         |  |
+  // | arg4        |  |
+  // | arg3 spill  |  |  Caller's frame
+  // | arg2 spill  |  |
+  // | arg1 spill  |  |
+  // | Method*     | ---
+  // | Return      |
+  // | EBP,ESI,EDI |    callee saves
+  // | EBX         |    arg3
+  // | EDX         |    arg2
+  // | ECX         |    arg1
+  // | EAX/Method* |  <- sp
+#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__R1_OFFSET 4
+#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__LR_OFFSET 28
+#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE 32
+#define QUICK_STACK_ARG_SKIP 16
+#else
+#error "Unsupported architecture"
+#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__R1_OFFSET 0
+#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__LR_OFFSET 0
+#define QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE 0
+#define QUICK_STACK_ARG_SKIP 0
+#endif
+
+  static mirror::AbstractMethod* GetCallingMethod(mirror::AbstractMethod** sp) {
+    byte* previous_sp = reinterpret_cast<byte*>(sp) +
+        QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE;
+    return *reinterpret_cast<mirror::AbstractMethod**>(previous_sp);
+  }
+
+  static uintptr_t GetCallingPc(mirror::AbstractMethod** sp) {
+    byte* lr = reinterpret_cast<byte*>(sp) + QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__LR_OFFSET;
+    return *reinterpret_cast<uintptr_t*>(lr);
+  }
+
+  QuickArgumentVisitor(mirror::AbstractMethod** sp, bool is_static,
+                       const char* shorty, uint32_t shorty_len)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) :
+    is_static_(is_static), shorty_(shorty), shorty_len_(shorty_len),
+    args_in_regs_(ComputeArgsInRegs(is_static, shorty, shorty_len)),
+    num_params_((is_static ? 0 : 1) + shorty_len - 1),  // +1 for this, -1 for return type
+    reg_args_(reinterpret_cast<byte*>(sp) + QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__R1_OFFSET),
+    stack_args_(reinterpret_cast<byte*>(sp) + QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE
+                + QUICK_STACK_ARG_SKIP),
+    cur_args_(reg_args_),
+    cur_arg_index_(0),
+    param_index_(0),
+    is_split_long_or_double_(false) {
+    DCHECK_EQ(static_cast<size_t>(QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE),
+              Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
+  }
+
+  virtual ~QuickArgumentVisitor() {}
+
+  virtual void Visit() = 0;
+
+  Primitive::Type GetParamPrimitiveType() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    size_t index = param_index_;
+    if (is_static_) {
+      index++;  // 0th argument must skip return value at start of the shorty
+    } else if (index == 0) {
+      return Primitive::kPrimNot;
+    }
+    CHECK_LT(index, shorty_len_);
+    return Primitive::GetType(shorty_[index]);
+  }
+
+  byte* GetParamAddress() const {
+    return cur_args_ + (cur_arg_index_ * kPointerSize);
+  }
+
+  bool IsSplitLongOrDouble() const {
+    return is_split_long_or_double_;
+  }
+
+  bool IsParamAReference() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    return GetParamPrimitiveType() == Primitive::kPrimNot;
+  }
+
+  bool IsParamALongOrDouble() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    Primitive::Type type = GetParamPrimitiveType();
+    return type == Primitive::kPrimLong || type == Primitive::kPrimDouble;
+  }
+
+  uint64_t ReadSplitLongParam() const {
+    DCHECK(IsSplitLongOrDouble());
+    uint64_t low_half = *reinterpret_cast<uint32_t*>(GetParamAddress());
+    uint64_t high_half = *reinterpret_cast<uint32_t*>(stack_args_);
+    return (low_half & 0xffffffffULL) | (high_half << 32);
+  }
+
+  void VisitArguments() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    for (cur_arg_index_ = 0;  cur_arg_index_ < args_in_regs_ && param_index_ < num_params_; ) {
+      is_split_long_or_double_ = (cur_arg_index_ == 2) && IsParamALongOrDouble();
+      Visit();
+      cur_arg_index_ += (IsParamALongOrDouble() ? 2 : 1);
+      param_index_++;
+    }
+    cur_args_ = stack_args_;
+    cur_arg_index_ = is_split_long_or_double_ ? 1 : 0;
+    is_split_long_or_double_ = false;
+    while (param_index_ < num_params_) {
+      Visit();
+      cur_arg_index_ += (IsParamALongOrDouble() ? 2 : 1);
+      param_index_++;
+    }
+  }
+
+ private:
+  static size_t ComputeArgsInRegs(bool is_static, const char* shorty, uint32_t shorty_len)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    size_t args_in_regs = (is_static ? 0 : 1);
+    for (size_t i = 0; i < shorty_len; i++) {
+      char s = shorty[i];
+      if (s == 'J' || s == 'D') {
+        args_in_regs += 2;
+      } else {
+        args_in_regs++;
+      }
+      if (args_in_regs > 3) {
+        args_in_regs = 3;
+        break;
+      }
+    }
+    return args_in_regs;
+  }
+
+  const bool is_static_;
+  const char* const shorty_;
+  const uint32_t shorty_len_;
+  const size_t args_in_regs_;
+  const size_t num_params_;
+  byte* const reg_args_;
+  byte* const stack_args_;
+  byte* cur_args_;
+  size_t cur_arg_index_;
+  size_t param_index_;
+  // Does a 64bit parameter straddle the register and stack arguments?
+  bool is_split_long_or_double_;
+};
+
+// Visits arguments on the stack placing them into the shadow frame.
+class BuildShadowFrameVisitor : public QuickArgumentVisitor {
+ public:
+  BuildShadowFrameVisitor(mirror::AbstractMethod** sp, bool is_static, const char* shorty,
+                          uint32_t shorty_len, ShadowFrame& sf, size_t first_arg_reg) :
+    QuickArgumentVisitor(sp, is_static, shorty, shorty_len), sf_(sf), cur_reg_(first_arg_reg) {}
+
+  virtual void Visit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    Primitive::Type type = GetParamPrimitiveType();
+    switch (type) {
+      case Primitive::kPrimLong:  // Fall-through.
+      case Primitive::kPrimDouble:
+        if (IsSplitLongOrDouble()) {
+          sf_.SetVRegLong(cur_reg_, ReadSplitLongParam());
+        } else {
+          sf_.SetVRegLong(cur_reg_, *reinterpret_cast<jlong*>(GetParamAddress()));
+        }
+        ++cur_reg_;
+        break;
+      case Primitive::kPrimNot:
+        sf_.SetVRegReference(cur_reg_, *reinterpret_cast<mirror::Object**>(GetParamAddress()));
+        break;
+      case Primitive::kPrimBoolean:  // Fall-through.
+      case Primitive::kPrimByte:     // Fall-through.
+      case Primitive::kPrimChar:     // Fall-through.
+      case Primitive::kPrimShort:    // Fall-through.
+      case Primitive::kPrimInt:      // Fall-through.
+      case Primitive::kPrimFloat:
+        sf_.SetVReg(cur_reg_, *reinterpret_cast<jint*>(GetParamAddress()));
+        break;
+      case Primitive::kPrimVoid:
+        LOG(FATAL) << "UNREACHABLE";
+        break;
+    }
+    ++cur_reg_;
+  }
+
+ private:
+  ShadowFrame& sf_;
+  size_t cur_reg_;
+
+  DISALLOW_COPY_AND_ASSIGN(BuildShadowFrameVisitor);
+};
+
+extern "C" uint64_t artQuickToInterpreterBridge(mirror::AbstractMethod* method, Thread* self,
+                                                mirror::AbstractMethod** sp)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  // Ensure we don't get thread suspension until the object arguments are safely in the shadow
+  // frame.
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
+
+  if (method->IsAbstract()) {
+    ThrowAbstractMethodError(method);
+    return 0;
+  } else {
+    const char* old_cause = self->StartAssertNoThreadSuspension("Building interpreter shadow frame");
+    MethodHelper mh(method);
+    const DexFile::CodeItem* code_item = mh.GetCodeItem();
+    uint16_t num_regs = code_item->registers_size_;
+    void* memory = alloca(ShadowFrame::ComputeSize(num_regs));
+    ShadowFrame* shadow_frame(ShadowFrame::Create(num_regs, NULL,  // No last shadow coming from quick.
+                                                  method, 0, memory));
+    size_t first_arg_reg = code_item->registers_size_ - code_item->ins_size_;
+    BuildShadowFrameVisitor shadow_frame_builder(sp, mh.IsStatic(), mh.GetShorty(),
+                                                 mh.GetShortyLength(),
+                                                 *shadow_frame, first_arg_reg);
+    shadow_frame_builder.VisitArguments();
+    // Push a transition back into managed code onto the linked list in thread.
+    ManagedStack fragment;
+    self->PushManagedStackFragment(&fragment);
+    self->PushShadowFrame(shadow_frame);
+    self->EndAssertNoThreadSuspension(old_cause);
+
+    if (method->IsStatic() && !method->GetDeclaringClass()->IsInitializing()) {
+      // Ensure static method's class is initialized.
+      if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(method->GetDeclaringClass(),
+                                                                   true, true)) {
+        DCHECK(Thread::Current()->IsExceptionPending());
+        self->PopManagedStackFragment(fragment);
+        return 0;
+      }
+    }
+
+    JValue result = interpreter::EnterInterpreterFromStub(self, mh, code_item, *shadow_frame);
+    // Pop transition.
+    self->PopManagedStackFragment(fragment);
+    return result.GetJ();
+  }
+}
+
+// Visits arguments on the stack placing them into the args vector, Object* arguments are converted
+// to jobjects.
+class BuildQuickArgumentVisitor : public QuickArgumentVisitor {
+ public:
+  BuildQuickArgumentVisitor(mirror::AbstractMethod** sp, bool is_static, const char* shorty,
+                            uint32_t shorty_len, ScopedObjectAccessUnchecked* soa,
+                            std::vector<jvalue>* args) :
+    QuickArgumentVisitor(sp, is_static, shorty, shorty_len), soa_(soa), args_(args) {}
+
+  virtual void Visit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    jvalue val;
+    Primitive::Type type = GetParamPrimitiveType();
+    switch (type) {
+      case Primitive::kPrimNot: {
+        mirror::Object* obj = *reinterpret_cast<mirror::Object**>(GetParamAddress());
+        val.l = soa_->AddLocalReference<jobject>(obj);
+        break;
+      }
+      case Primitive::kPrimLong:  // Fall-through.
+      case Primitive::kPrimDouble:
+        if (IsSplitLongOrDouble()) {
+          val.j = ReadSplitLongParam();
+        } else {
+          val.j = *reinterpret_cast<jlong*>(GetParamAddress());
+        }
+        break;
+      case Primitive::kPrimBoolean:  // Fall-through.
+      case Primitive::kPrimByte:     // Fall-through.
+      case Primitive::kPrimChar:     // Fall-through.
+      case Primitive::kPrimShort:    // Fall-through.
+      case Primitive::kPrimInt:      // Fall-through.
+      case Primitive::kPrimFloat:
+        val.i =  *reinterpret_cast<jint*>(GetParamAddress());
+        break;
+      case Primitive::kPrimVoid:
+        LOG(FATAL) << "UNREACHABLE";
+        val.j = 0;
+        break;
+    }
+    args_->push_back(val);
+  }
+
+ private:
+  ScopedObjectAccessUnchecked* soa_;
+  std::vector<jvalue>* args_;
+
+  DISALLOW_COPY_AND_ASSIGN(BuildQuickArgumentVisitor);
+};
+
+// Handler for invocation on proxy methods. On entry a frame will exist for the proxy object method
+// which is responsible for recording callee save registers. We explicitly place into jobjects the
+// incoming reference arguments (so they survive GC). We invoke the invocation handler, which is a
+// field within the proxy object, which will box the primitive arguments and deal with error cases.
+extern "C" uint64_t artQuickProxyInvokeHandler(mirror::AbstractMethod* proxy_method,
+                                               mirror::Object* receiver,
+                                               Thread* self, mirror::AbstractMethod** sp)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  // Ensure we don't get thread suspension until the object arguments are safely in jobjects.
+  const char* old_cause =
+      self->StartAssertNoThreadSuspension("Adding to IRT proxy object arguments");
+  // Register the top of the managed stack, making stack crawlable.
+  DCHECK_EQ(*sp, proxy_method);
+  self->SetTopOfStack(sp, 0);
+  DCHECK_EQ(proxy_method->GetFrameSizeInBytes(),
+            Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
+  self->VerifyStack();
+  // Start new JNI local reference state.
+  JNIEnvExt* env = self->GetJniEnv();
+  ScopedObjectAccessUnchecked soa(env);
+  ScopedJniEnvLocalRefState env_state(env);
+  // Create local ref. copies of proxy method and the receiver.
+  jobject rcvr_jobj = soa.AddLocalReference<jobject>(receiver);
+
+  // Placing arguments into args vector and remove the receiver.
+  MethodHelper proxy_mh(proxy_method);
+  std::vector<jvalue> args;
+  BuildQuickArgumentVisitor local_ref_visitor(sp, proxy_mh.IsStatic(), proxy_mh.GetShorty(),
+                                              proxy_mh.GetShortyLength(), &soa, &args);
+  local_ref_visitor.VisitArguments();
+  args.erase(args.begin());
+
+  // Convert proxy method into expected interface method.
+  mirror::AbstractMethod* interface_method = proxy_method->FindOverriddenMethod();
+  DCHECK(interface_method != NULL);
+  DCHECK(!interface_method->IsProxyMethod()) << PrettyMethod(interface_method);
+  jobject interface_method_jobj = soa.AddLocalReference<jobject>(interface_method);
+
+  // All naked Object*s should now be in jobjects, so its safe to go into the main invoke code
+  // that performs allocations.
+  self->EndAssertNoThreadSuspension(old_cause);
+  JValue result = InvokeProxyInvocationHandler(soa, proxy_mh.GetShorty(),
+                                               rcvr_jobj, interface_method_jobj, args);
+  return result.GetJ();
+}
+
+// Read object references held in arguments from quick frames and place in a JNI local references,
+// so they don't get garbage collected.
+class RememberFoGcArgumentVisitor : public QuickArgumentVisitor {
+ public:
+  RememberFoGcArgumentVisitor(mirror::AbstractMethod** sp, bool is_static, const char* shorty,
+                              uint32_t shorty_len, ScopedObjectAccessUnchecked* soa) :
+    QuickArgumentVisitor(sp, is_static, shorty, shorty_len), soa_(soa) {}
+
+  virtual void Visit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    if (IsParamAReference()) {
+      soa_->AddLocalReference<jobject>(*reinterpret_cast<mirror::Object**>(GetParamAddress()));
+    }
+  }
+
+ private:
+  ScopedObjectAccessUnchecked* soa_;
+
+  DISALLOW_COPY_AND_ASSIGN(RememberFoGcArgumentVisitor);
+};
+
+// Lazily resolve a method for quick. Called by stub code.
+extern "C" const void* artQuickResolutionTrampoline(mirror::AbstractMethod* called,
+                                                    mirror::Object* receiver,
+                                                    Thread* thread, mirror::AbstractMethod** sp)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsAndArgs);
+  // Start new JNI local reference state
+  JNIEnvExt* env = thread->GetJniEnv();
+  ScopedObjectAccessUnchecked soa(env);
+  ScopedJniEnvLocalRefState env_state(env);
+  const char* old_cause = thread->StartAssertNoThreadSuspension("Quick method resolution set up");
+
+  // Compute details about the called method (avoid GCs)
+  ClassLinker* linker = Runtime::Current()->GetClassLinker();
+  mirror::AbstractMethod* caller = QuickArgumentVisitor::GetCallingMethod(sp);
+  InvokeType invoke_type;
+  const DexFile* dex_file;
+  uint32_t dex_method_idx;
+  if (called->IsRuntimeMethod()) {
+    uint32_t dex_pc = caller->ToDexPc(QuickArgumentVisitor::GetCallingPc(sp));
+    const DexFile::CodeItem* code;
+    {
+      MethodHelper mh(caller);
+      dex_file = &mh.GetDexFile();
+      code = mh.GetCodeItem();
+    }
+    CHECK_LT(dex_pc, code->insns_size_in_code_units_);
+    const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
+    Instruction::Code instr_code = instr->Opcode();
+    bool is_range;
+    switch (instr_code) {
+      case Instruction::INVOKE_DIRECT:
+        invoke_type = kDirect;
+        is_range = false;
+        break;
+      case Instruction::INVOKE_DIRECT_RANGE:
+        invoke_type = kDirect;
+        is_range = true;
+        break;
+      case Instruction::INVOKE_STATIC:
+        invoke_type = kStatic;
+        is_range = false;
+        break;
+      case Instruction::INVOKE_STATIC_RANGE:
+        invoke_type = kStatic;
+        is_range = true;
+        break;
+      case Instruction::INVOKE_SUPER:
+        invoke_type = kSuper;
+        is_range = false;
+        break;
+      case Instruction::INVOKE_SUPER_RANGE:
+        invoke_type = kSuper;
+        is_range = true;
+        break;
+      case Instruction::INVOKE_VIRTUAL:
+        invoke_type = kVirtual;
+        is_range = false;
+        break;
+      case Instruction::INVOKE_VIRTUAL_RANGE:
+        invoke_type = kVirtual;
+        is_range = true;
+        break;
+      case Instruction::INVOKE_INTERFACE:
+        invoke_type = kInterface;
+        is_range = false;
+        break;
+      case Instruction::INVOKE_INTERFACE_RANGE:
+        invoke_type = kInterface;
+        is_range = true;
+        break;
+      default:
+        LOG(FATAL) << "Unexpected call into trampoline: " << instr->DumpString(NULL);
+        // Avoid used uninitialized warnings.
+        invoke_type = kDirect;
+        is_range = false;
+    }
+    dex_method_idx = (is_range) ? instr->VRegB_3rc() : instr->VRegB_35c();
+
+  } else {
+    invoke_type = kStatic;
+    dex_file = &MethodHelper(called).GetDexFile();
+    dex_method_idx = called->GetDexMethodIndex();
+  }
+  uint32_t shorty_len;
+  const char* shorty =
+      dex_file->GetMethodShorty(dex_file->GetMethodId(dex_method_idx), &shorty_len);
+  RememberFoGcArgumentVisitor visitor(sp, invoke_type == kStatic, shorty, shorty_len, &soa);
+  visitor.VisitArguments();
+  thread->EndAssertNoThreadSuspension(old_cause);
+  // Resolve method filling in dex cache.
+  if (called->IsRuntimeMethod()) {
+    called = linker->ResolveMethod(dex_method_idx, caller, invoke_type);
+  }
+  const void* code = NULL;
+  if (LIKELY(!thread->IsExceptionPending())) {
+    // Incompatible class change should have been handled in resolve method.
+    CHECK(!called->CheckIncompatibleClassChange(invoke_type));
+    // Refine called method based on receiver.
+    if (invoke_type == kVirtual) {
+      called = receiver->GetClass()->FindVirtualMethodForVirtual(called);
+    } else if (invoke_type == kInterface) {
+      called = receiver->GetClass()->FindVirtualMethodForInterface(called);
+    }
+    // Ensure that the called method's class is initialized.
+    mirror::Class* called_class = called->GetDeclaringClass();
+    linker->EnsureInitialized(called_class, true, true);
+    if (LIKELY(called_class->IsInitialized())) {
+      code = called->GetEntryPointFromCompiledCode();
+    } else if (called_class->IsInitializing()) {
+      if (invoke_type == kStatic) {
+        // Class is still initializing, go to oat and grab code (trampoline must be left in place
+        // until class is initialized to stop races between threads).
+        code = linker->GetOatCodeFor(called);
+      } else {
+        // No trampoline for non-static methods.
+        code = called->GetEntryPointFromCompiledCode();
+      }
+    } else {
+      DCHECK(called_class->IsErroneous());
+    }
+  }
+  CHECK_EQ(code == NULL, thread->IsExceptionPending());
+#ifdef MOVING_GARBAGE_COLLECTOR
+  // TODO: locally saved objects may have moved during a GC during resolution. Need to update the
+  //       registers so that the stale objects aren't passed to the method we've resolved.
+    UNIMPLEMENTED(WARNING);
+#endif
+  // Place called method in callee-save frame to be placed as first argument to quick method.
+  *sp = called;
+  return code;
+}
+
+}  // namespace art
diff --git a/runtime/instrumentation.cc b/runtime/instrumentation.cc
index c0b85f41fd..c3b66b3f79 100644
--- a/runtime/instrumentation.cc
+++ b/runtime/instrumentation.cc
@@ -60,7 +60,7 @@ bool Instrumentation::InstallStubsForClass(mirror::Class* klass) {
       const void* new_code;
       if (uninstall) {
         if (forced_interpret_only_ && !method->IsNative() && !method->IsProxyMethod()) {
-          new_code = GetInterpreterEntryPoint();
+          new_code = GetCompiledCodeToInterpreterBridge();
         } else if (is_initialized || !method->IsStatic() || method->IsConstructor()) {
           new_code = class_linker->GetOatCodeFor(method);
         } else {
@@ -68,9 +68,9 @@ bool Instrumentation::InstallStubsForClass(mirror::Class* klass) {
         }
       } else {  // !uninstall
         if (!interpreter_stubs_installed_ || method->IsNative()) {
-          new_code = GetInstrumentationEntryPoint();
+          new_code = GetQuickInstrumentationEntryPoint();
         } else {
-          new_code = GetInterpreterEntryPoint();
+          new_code = GetCompiledCodeToInterpreterBridge();
         }
       }
       method->SetEntryPointFromCompiledCode(new_code);
@@ -82,15 +82,15 @@ bool Instrumentation::InstallStubsForClass(mirror::Class* klass) {
       const void* new_code;
       if (uninstall) {
         if (forced_interpret_only_ && !method->IsNative() && !method->IsProxyMethod()) {
-          new_code = GetInterpreterEntryPoint();
+          new_code = GetCompiledCodeToInterpreterBridge();
         } else {
           new_code = class_linker->GetOatCodeFor(method);
         }
       } else {  // !uninstall
         if (!interpreter_stubs_installed_ || method->IsNative()) {
-          new_code = GetInstrumentationEntryPoint();
+          new_code = GetQuickInstrumentationEntryPoint();
         } else {
-          new_code = GetInterpreterEntryPoint();
+          new_code = GetCompiledCodeToInterpreterBridge();
         }
       }
       method->SetEntryPointFromCompiledCode(new_code);
@@ -159,7 +159,7 @@ static void InstrumentationInstallStack(Thread* thread, void* arg)
     LOG(INFO) << "Installing exit stubs in " << thread_name;
   }
   UniquePtr<Context> context(Context::Create());
-  uintptr_t instrumentation_exit_pc = GetInstrumentationExitPc();
+  uintptr_t instrumentation_exit_pc = GetQuickInstrumentationExitPc();
   InstallStackVisitor visitor(thread, context.get(), instrumentation_exit_pc);
   visitor.WalkStack(true);
 
@@ -251,7 +251,7 @@ static void InstrumentationRestoreStack(Thread* thread, void* arg)
   std::deque<instrumentation::InstrumentationStackFrame>* stack = thread->GetInstrumentationStack();
   if (stack->size() > 0) {
     Instrumentation* instrumentation = reinterpret_cast<Instrumentation*>(arg);
-    uintptr_t instrumentation_exit_pc = GetInstrumentationExitPc();
+    uintptr_t instrumentation_exit_pc = GetQuickInstrumentationExitPc();
     RestoreStackVisitor visitor(thread, instrumentation_exit_pc, instrumentation);
     visitor.WalkStack(true);
     CHECK_EQ(visitor.frames_removed_, stack->size());
@@ -384,9 +384,9 @@ void Instrumentation::UpdateMethodsCode(mirror::AbstractMethod* method, const vo
     method->SetEntryPointFromCompiledCode(code);
   } else {
     if (!interpreter_stubs_installed_ || method->IsNative()) {
-      method->SetEntryPointFromCompiledCode(GetInstrumentationEntryPoint());
+      method->SetEntryPointFromCompiledCode(GetQuickInstrumentationEntryPoint());
     } else {
-      method->SetEntryPointFromCompiledCode(GetInterpreterEntryPoint());
+      method->SetEntryPointFromCompiledCode(GetCompiledCodeToInterpreterBridge());
     }
   }
 }
@@ -396,8 +396,8 @@ const void* Instrumentation::GetQuickCodeFor(const mirror::AbstractMethod* metho
   if (LIKELY(!instrumentation_stubs_installed_)) {
     const void* code = method->GetEntryPointFromCompiledCode();
     DCHECK(code != NULL);
-    if (LIKELY(code != GetResolutionTrampoline(runtime->GetClassLinker()) &&
-               code != GetInterpreterEntryPoint())) {
+    if (LIKELY(code != GetQuickResolutionTrampoline(runtime->GetClassLinker()) &&
+               code != GetQuickToInterpreterBridge())) {
       return code;
     }
   }
@@ -548,7 +548,7 @@ uint64_t Instrumentation::PopInstrumentationStackFrame(Thread* self, uintptr_t*
           << " result is " << std::hex << return_value.GetJ();
     }
     self->SetDeoptimizationReturnValue(return_value);
-    return static_cast<uint64_t>(GetDeoptimizationEntryPoint()) |
+    return static_cast<uint64_t>(GetQuickDeoptimizationEntryPoint()) |
         (static_cast<uint64_t>(*return_pc) << 32);
   } else {
     if (kVerboseInstrumentation) {
diff --git a/runtime/interpreter/interpreter.cc b/runtime/interpreter/interpreter.cc
index ef4b95c037..6e35d937fb 100644
--- a/runtime/interpreter/interpreter.cc
+++ b/runtime/interpreter/interpreter.cc
@@ -148,7 +148,7 @@ static void UnstartedRuntimeInvoke(Thread* self, MethodHelper& mh,
     }
   } else {
     // Not special, continue with regular interpreter execution.
-    artInterpreterToInterpreterEntry(self, mh, code_item, shadow_frame, result);
+    artInterpreterToInterpreterBridge(self, mh, code_item, shadow_frame, result);
   }
 }
 
@@ -3039,6 +3039,10 @@ static JValue Execute(Thread* self, MethodHelper& mh, const DexFile::CodeItem* c
 
 static inline JValue Execute(Thread* self, MethodHelper& mh, const DexFile::CodeItem* code_item,
                              ShadowFrame& shadow_frame, JValue result_register) {
+  DCHECK(shadow_frame.GetMethod() == mh.GetMethod() ||
+         shadow_frame.GetMethod()->GetDeclaringClass()->IsProxyClass());
+  DCHECK(!shadow_frame.GetMethod()->IsAbstract());
+  DCHECK(!shadow_frame.GetMethod()->IsNative());
   if (shadow_frame.GetMethod()->IsPreverified()) {
     // Enter the "without access check" interpreter.
     return ExecuteImpl<false>(self, mh, code_item, shadow_frame, result_register);
@@ -3150,8 +3154,7 @@ void EnterInterpreterFromDeoptimize(Thread* self, ShadowFrame* shadow_frame, JVa
 }
 
 JValue EnterInterpreterFromStub(Thread* self, MethodHelper& mh, const DexFile::CodeItem* code_item,
-                                ShadowFrame& shadow_frame)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+                                ShadowFrame& shadow_frame) {
   DCHECK_EQ(self, Thread::Current());
   if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEnd())) {
     ThrowStackOverflowError(self);
@@ -3161,10 +3164,9 @@ JValue EnterInterpreterFromStub(Thread* self, MethodHelper& mh, const DexFile::C
   return Execute(self, mh, code_item, shadow_frame, JValue());
 }
 
-void artInterpreterToInterpreterEntry(Thread* self, MethodHelper& mh,
-                                      const DexFile::CodeItem* code_item,
-                                      ShadowFrame* shadow_frame, JValue* result)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+extern "C" void artInterpreterToInterpreterBridge(Thread* self, MethodHelper& mh,
+                                                  const DexFile::CodeItem* code_item,
+                                                  ShadowFrame* shadow_frame, JValue* result) {
   if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEnd())) {
     ThrowStackOverflowError(self);
     return;
diff --git a/runtime/interpreter/interpreter.h b/runtime/interpreter/interpreter.h
index 17884b9a63..af4a1472ee 100644
--- a/runtime/interpreter/interpreter.h
+++ b/runtime/interpreter/interpreter.h
@@ -47,9 +47,9 @@ extern JValue EnterInterpreterFromStub(Thread* self, MethodHelper& mh,
                                        ShadowFrame& shadow_frame)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-extern "C" void artInterpreterToInterpreterEntry(Thread* self, MethodHelper& mh,
-                                                const DexFile::CodeItem* code_item,
-                                                ShadowFrame* shadow_frame, JValue* result)
+extern "C" void artInterpreterToInterpreterBridge(Thread* self, MethodHelper& mh,
+                                                  const DexFile::CodeItem* code_item,
+                                                  ShadowFrame* shadow_frame, JValue* result)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 }  // namespace interpreter
diff --git a/runtime/jni_internal.h b/runtime/jni_internal.h
index ad66ada329..fcac4811c6 100644
--- a/runtime/jni_internal.h
+++ b/runtime/jni_internal.h
@@ -144,6 +144,10 @@ struct JNIEnvExt : public JNIEnv {
     return Offset(OFFSETOF_MEMBER(JNIEnvExt, local_ref_cookie));
   }
 
+  static Offset SelfOffset() {
+    return Offset(OFFSETOF_MEMBER(JNIEnvExt, self));
+  }
+
   Thread* const self;
   JavaVMExt* vm;
 
diff --git a/runtime/mirror/abstract_method-inl.h b/runtime/mirror/abstract_method-inl.h
index d235e3eed8..8fde99be3b 100644
--- a/runtime/mirror/abstract_method-inl.h
+++ b/runtime/mirror/abstract_method-inl.h
@@ -114,11 +114,11 @@ inline void AbstractMethod::AssertPcIsWithinCode(uintptr_t pc) const {
   if (IsNative() || IsRuntimeMethod() || IsProxyMethod()) {
     return;
   }
-  if (pc == GetInstrumentationExitPc()) {
+  if (pc == GetQuickInstrumentationExitPc()) {
     return;
   }
   const void* code = GetEntryPointFromCompiledCode();
-  if (code == GetInterpreterEntryPoint() || code == GetInstrumentationEntryPoint()) {
+  if (code == GetCompiledCodeToInterpreterBridge() || code == GetQuickInstrumentationEntryPoint()) {
     return;
   }
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
diff --git a/runtime/mirror/abstract_method.cc b/runtime/mirror/abstract_method.cc
index 4d7f99e076..93065e7f4e 100644
--- a/runtime/mirror/abstract_method.cc
+++ b/runtime/mirror/abstract_method.cc
@@ -321,6 +321,7 @@ bool AbstractMethod::IsRegistered() const {
   return native_method != jni_stub;
 }
 
+extern "C" void art_work_around_app_jni_bugs(JNIEnv*, jobject);
 void AbstractMethod::RegisterNative(Thread* self, const void* native_method) {
   DCHECK(Thread::Current() == self);
   CHECK(IsNative()) << PrettyMethod(this);
@@ -332,10 +333,10 @@ void AbstractMethod::RegisterNative(Thread* self, const void* native_method) {
     // around JNI bugs, that include not giving Object** SIRT references to native methods. Direct
     // the native method to runtime support and store the target somewhere runtime support will
     // find it.
-#if defined(__arm__) && !defined(ART_USE_PORTABLE_COMPILER)
-    SetNativeMethod(native_method);
-#else
+#if defined(__i386__)
     UNIMPLEMENTED(FATAL);
+#else
+    SetNativeMethod(reinterpret_cast<void*>(art_work_around_app_jni_bugs));
 #endif
     SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, gc_map_),
         reinterpret_cast<const uint8_t*>(native_method), false);
diff --git a/runtime/native/dalvik_system_VMRuntime.cc b/runtime/native/dalvik_system_VMRuntime.cc
index b352d0845e..32ab4f9b8d 100644
--- a/runtime/native/dalvik_system_VMRuntime.cc
+++ b/runtime/native/dalvik_system_VMRuntime.cc
@@ -144,8 +144,6 @@ static void VMRuntime_setTargetSdkVersion(JNIEnv* env, jobject, jint targetSdkVe
   if (targetSdkVersion > 0 && targetSdkVersion <= 13 /* honeycomb-mr2 */) {
     Runtime* runtime = Runtime::Current();
     JavaVMExt* vm = runtime->GetJavaVM();
-
-#if !defined(ART_USE_PORTABLE_COMPILER)
     if (vm->check_jni) {
       LOG(WARNING) << "Turning off CheckJNI so we can turn on JNI app bug workarounds...";
       Thread* self = static_cast<JNIEnvExt*>(env)->self;
@@ -158,11 +156,6 @@ static void VMRuntime_setTargetSdkVersion(JNIEnv* env, jobject, jint targetSdkVe
               << targetSdkVersion << "...";
 
     vm->work_around_app_jni_bugs = true;
-#else
-    UNUSED(env);
-    LOG(WARNING) << "LLVM does not work-around app jni bugs.";
-    vm->work_around_app_jni_bugs = false;
-#endif
   }
 }
 
diff --git a/runtime/oat.cc b/runtime/oat.cc
index e606953ed5..c01f77c364 100644
--- a/runtime/oat.cc
+++ b/runtime/oat.cc
@@ -22,7 +22,7 @@
 namespace art {
 
 const uint8_t OatHeader::kOatMagic[] = { 'o', 'a', 't', '\n' };
-const uint8_t OatHeader::kOatVersion[] = { '0', '0', '6', '\0' };
+const uint8_t OatHeader::kOatVersion[] = { '0', '0', '7', '\0' };
 
 OatHeader::OatHeader() {
   memset(this, 0, sizeof(*this));
@@ -57,10 +57,13 @@ OatHeader::OatHeader(InstructionSet instruction_set,
   UpdateChecksum(image_file_location.data(), image_file_location_size_);
 
   executable_offset_ = 0;
-  interpreter_to_interpreter_entry_offset_ = 0;
-  interpreter_to_quick_entry_offset_ = 0;
+  interpreter_to_interpreter_bridge_offset_ = 0;
+  interpreter_to_compiled_code_bridge_offset_ = 0;
+  jni_dlsym_lookup_offset_ = 0;
   portable_resolution_trampoline_offset_ = 0;
+  portable_to_interpreter_bridge_offset_ = 0;
   quick_resolution_trampoline_offset_ = 0;
+  quick_to_interpreter_bridge_offset_ = 0;
 }
 
 bool OatHeader::IsValid() const {
@@ -111,42 +114,61 @@ void OatHeader::SetExecutableOffset(uint32_t executable_offset) {
   UpdateChecksum(&executable_offset_, sizeof(executable_offset));
 }
 
-const void* OatHeader::GetInterpreterToInterpreterEntry() const {
-  return reinterpret_cast<const uint8_t*>(this) + GetInterpreterToInterpreterEntryOffset();
+const void* OatHeader::GetInterpreterToInterpreterBridge() const {
+  return reinterpret_cast<const uint8_t*>(this) + GetInterpreterToInterpreterBridgeOffset();
 }
 
-uint32_t OatHeader::GetInterpreterToInterpreterEntryOffset() const {
+uint32_t OatHeader::GetInterpreterToInterpreterBridgeOffset() const {
   DCHECK(IsValid());
-  CHECK_GE(interpreter_to_interpreter_entry_offset_, executable_offset_);
-  return interpreter_to_interpreter_entry_offset_;
+  CHECK_GE(interpreter_to_interpreter_bridge_offset_, executable_offset_);
+  return interpreter_to_interpreter_bridge_offset_;
 }
 
-void OatHeader::SetInterpreterToInterpreterEntryOffset(uint32_t offset) {
+void OatHeader::SetInterpreterToInterpreterBridgeOffset(uint32_t offset) {
   CHECK(offset == 0 || offset >= executable_offset_);
   DCHECK(IsValid());
-  DCHECK_EQ(interpreter_to_interpreter_entry_offset_, 0U) << offset;
+  DCHECK_EQ(interpreter_to_interpreter_bridge_offset_, 0U) << offset;
 
-  interpreter_to_interpreter_entry_offset_ = offset;
-  UpdateChecksum(&interpreter_to_interpreter_entry_offset_, sizeof(offset));
+  interpreter_to_interpreter_bridge_offset_ = offset;
+  UpdateChecksum(&interpreter_to_interpreter_bridge_offset_, sizeof(offset));
 }
 
-const void* OatHeader::GetInterpreterToQuickEntry() const {
-  return reinterpret_cast<const uint8_t*>(this) + GetInterpreterToQuickEntryOffset();
+const void* OatHeader::GetInterpreterToCompiledCodeBridge() const {
+  return reinterpret_cast<const uint8_t*>(this) + GetInterpreterToCompiledCodeBridgeOffset();
 }
 
-uint32_t OatHeader::GetInterpreterToQuickEntryOffset() const {
+uint32_t OatHeader::GetInterpreterToCompiledCodeBridgeOffset() const {
   DCHECK(IsValid());
-  CHECK_GE(interpreter_to_quick_entry_offset_, interpreter_to_interpreter_entry_offset_);
-  return interpreter_to_quick_entry_offset_;
+  CHECK_GE(interpreter_to_compiled_code_bridge_offset_, interpreter_to_interpreter_bridge_offset_);
+  return interpreter_to_compiled_code_bridge_offset_;
 }
 
-void OatHeader::SetInterpreterToQuickEntryOffset(uint32_t offset) {
-  CHECK(offset == 0 || offset >= interpreter_to_interpreter_entry_offset_);
+void OatHeader::SetInterpreterToCompiledCodeBridgeOffset(uint32_t offset) {
+  CHECK(offset == 0 || offset >= interpreter_to_interpreter_bridge_offset_);
   DCHECK(IsValid());
-  DCHECK_EQ(interpreter_to_quick_entry_offset_, 0U) << offset;
+  DCHECK_EQ(interpreter_to_compiled_code_bridge_offset_, 0U) << offset;
 
-  interpreter_to_quick_entry_offset_ = offset;
-  UpdateChecksum(&interpreter_to_quick_entry_offset_, sizeof(offset));
+  interpreter_to_compiled_code_bridge_offset_ = offset;
+  UpdateChecksum(&interpreter_to_compiled_code_bridge_offset_, sizeof(offset));
+}
+
+const void* OatHeader::GetJniDlsymLookup() const {
+  return reinterpret_cast<const uint8_t*>(this) + GetJniDlsymLookupOffset();
+}
+
+uint32_t OatHeader::GetJniDlsymLookupOffset() const {
+  DCHECK(IsValid());
+  CHECK_GE(jni_dlsym_lookup_offset_, interpreter_to_compiled_code_bridge_offset_);
+  return jni_dlsym_lookup_offset_;
+}
+
+void OatHeader::SetJniDlsymLookupOffset(uint32_t offset) {
+  CHECK(offset == 0 || offset >= interpreter_to_compiled_code_bridge_offset_);
+  DCHECK(IsValid());
+  DCHECK_EQ(jni_dlsym_lookup_offset_, 0U) << offset;
+
+  jni_dlsym_lookup_offset_ = offset;
+  UpdateChecksum(&jni_dlsym_lookup_offset_, sizeof(offset));
 }
 
 const void* OatHeader::GetPortableResolutionTrampoline() const {
@@ -155,12 +177,12 @@ const void* OatHeader::GetPortableResolutionTrampoline() const {
 
 uint32_t OatHeader::GetPortableResolutionTrampolineOffset() const {
   DCHECK(IsValid());
-  CHECK_GE(portable_resolution_trampoline_offset_, interpreter_to_quick_entry_offset_);
+  CHECK_GE(portable_resolution_trampoline_offset_, jni_dlsym_lookup_offset_);
   return portable_resolution_trampoline_offset_;
 }
 
 void OatHeader::SetPortableResolutionTrampolineOffset(uint32_t offset) {
-  CHECK(offset == 0 || offset >= interpreter_to_quick_entry_offset_);
+  CHECK(offset == 0 || offset >= jni_dlsym_lookup_offset_);
   DCHECK(IsValid());
   DCHECK_EQ(portable_resolution_trampoline_offset_, 0U) << offset;
 
@@ -168,18 +190,37 @@ void OatHeader::SetPortableResolutionTrampolineOffset(uint32_t offset) {
   UpdateChecksum(&portable_resolution_trampoline_offset_, sizeof(offset));
 }
 
+const void* OatHeader::GetPortableToInterpreterBridge() const {
+  return reinterpret_cast<const uint8_t*>(this) + GetPortableToInterpreterBridgeOffset();
+}
+
+uint32_t OatHeader::GetPortableToInterpreterBridgeOffset() const {
+  DCHECK(IsValid());
+  CHECK_GE(portable_to_interpreter_bridge_offset_, portable_resolution_trampoline_offset_);
+  return portable_to_interpreter_bridge_offset_;
+}
+
+void OatHeader::SetPortableToInterpreterBridgeOffset(uint32_t offset) {
+  CHECK(offset == 0 || offset >= portable_resolution_trampoline_offset_);
+  DCHECK(IsValid());
+  DCHECK_EQ(portable_to_interpreter_bridge_offset_, 0U) << offset;
+
+  portable_to_interpreter_bridge_offset_ = offset;
+  UpdateChecksum(&portable_to_interpreter_bridge_offset_, sizeof(offset));
+}
+
 const void* OatHeader::GetQuickResolutionTrampoline() const {
   return reinterpret_cast<const uint8_t*>(this) + GetQuickResolutionTrampolineOffset();
 }
 
 uint32_t OatHeader::GetQuickResolutionTrampolineOffset() const {
   DCHECK(IsValid());
-  CHECK_GE(quick_resolution_trampoline_offset_, portable_resolution_trampoline_offset_);
+  CHECK_GE(quick_resolution_trampoline_offset_, portable_to_interpreter_bridge_offset_);
   return quick_resolution_trampoline_offset_;
 }
 
 void OatHeader::SetQuickResolutionTrampolineOffset(uint32_t offset) {
-  CHECK(offset == 0 || offset >= portable_resolution_trampoline_offset_);
+  CHECK(offset == 0 || offset >= portable_to_interpreter_bridge_offset_);
   DCHECK(IsValid());
   DCHECK_EQ(quick_resolution_trampoline_offset_, 0U) << offset;
 
@@ -187,6 +228,25 @@ void OatHeader::SetQuickResolutionTrampolineOffset(uint32_t offset) {
   UpdateChecksum(&quick_resolution_trampoline_offset_, sizeof(offset));
 }
 
+const void* OatHeader::GetQuickToInterpreterBridge() const {
+  return reinterpret_cast<const uint8_t*>(this) + GetQuickToInterpreterBridgeOffset();
+}
+
+uint32_t OatHeader::GetQuickToInterpreterBridgeOffset() const {
+  DCHECK(IsValid());
+  CHECK_GE(quick_to_interpreter_bridge_offset_, quick_resolution_trampoline_offset_);
+  return quick_to_interpreter_bridge_offset_;
+}
+
+void OatHeader::SetQuickToInterpreterBridgeOffset(uint32_t offset) {
+  CHECK(offset == 0 || offset >= quick_resolution_trampoline_offset_);
+  DCHECK(IsValid());
+  DCHECK_EQ(quick_to_interpreter_bridge_offset_, 0U) << offset;
+
+  quick_to_interpreter_bridge_offset_ = offset;
+  UpdateChecksum(&quick_to_interpreter_bridge_offset_, sizeof(offset));
+}
+
 uint32_t OatHeader::GetImageFileLocationOatChecksum() const {
   CHECK(IsValid());
   return image_file_location_oat_checksum_;
diff --git a/runtime/oat.h b/runtime/oat.h
index 4bd1871a71..a5c6bed5fc 100644
--- a/runtime/oat.h
+++ b/runtime/oat.h
@@ -44,18 +44,32 @@ class PACKED(4) OatHeader {
   }
   uint32_t GetExecutableOffset() const;
   void SetExecutableOffset(uint32_t executable_offset);
-  const void* GetInterpreterToInterpreterEntry() const;
-  uint32_t GetInterpreterToInterpreterEntryOffset() const;
-  void SetInterpreterToInterpreterEntryOffset(uint32_t offset);
-  const void* GetInterpreterToQuickEntry() const;
-  uint32_t GetInterpreterToQuickEntryOffset() const;
-  void SetInterpreterToQuickEntryOffset(uint32_t offset);
+
+  const void* GetInterpreterToInterpreterBridge() const;
+  uint32_t GetInterpreterToInterpreterBridgeOffset() const;
+  void SetInterpreterToInterpreterBridgeOffset(uint32_t offset);
+  const void* GetInterpreterToCompiledCodeBridge() const;
+  uint32_t GetInterpreterToCompiledCodeBridgeOffset() const;
+  void SetInterpreterToCompiledCodeBridgeOffset(uint32_t offset);
+
+  const void* GetJniDlsymLookup() const;
+  uint32_t GetJniDlsymLookupOffset() const;
+  void SetJniDlsymLookupOffset(uint32_t offset);
+
   const void* GetPortableResolutionTrampoline() const;
   uint32_t GetPortableResolutionTrampolineOffset() const;
   void SetPortableResolutionTrampolineOffset(uint32_t offset);
+  const void* GetPortableToInterpreterBridge() const;
+  uint32_t GetPortableToInterpreterBridgeOffset() const;
+  void SetPortableToInterpreterBridgeOffset(uint32_t offset);
+
   const void* GetQuickResolutionTrampoline() const;
   uint32_t GetQuickResolutionTrampolineOffset() const;
   void SetQuickResolutionTrampolineOffset(uint32_t offset);
+  const void* GetQuickToInterpreterBridge() const;
+  uint32_t GetQuickToInterpreterBridgeOffset() const;
+  void SetQuickToInterpreterBridgeOffset(uint32_t offset);
+
   InstructionSet GetInstructionSet() const;
   uint32_t GetImageFileLocationOatChecksum() const;
   uint32_t GetImageFileLocationOatDataBegin() const;
@@ -74,10 +88,13 @@ class PACKED(4) OatHeader {
   InstructionSet instruction_set_;
   uint32_t dex_file_count_;
   uint32_t executable_offset_;
-  uint32_t interpreter_to_interpreter_entry_offset_;
-  uint32_t interpreter_to_quick_entry_offset_;
+  uint32_t interpreter_to_interpreter_bridge_offset_;
+  uint32_t interpreter_to_compiled_code_bridge_offset_;
+  uint32_t jni_dlsym_lookup_offset_;
   uint32_t portable_resolution_trampoline_offset_;
+  uint32_t portable_to_interpreter_bridge_offset_;
   uint32_t quick_resolution_trampoline_offset_;
+  uint32_t quick_to_interpreter_bridge_offset_;
 
   uint32_t image_file_location_oat_checksum_;
   uint32_t image_file_location_oat_data_begin_;
diff --git a/runtime/oat_test.cc b/runtime/oat_test.cc
index 5d0dca9e4c..68595c896d 100644
--- a/runtime/oat_test.cc
+++ b/runtime/oat_test.cc
@@ -141,7 +141,7 @@ TEST_F(OatTest, WriteRead) {
 TEST_F(OatTest, OatHeaderSizeCheck) {
   // If this test is failing and you have to update these constants,
   // it is time to update OatHeader::kOatVersion
-  EXPECT_EQ(52U, sizeof(OatHeader));
+  EXPECT_EQ(64U, sizeof(OatHeader));
   EXPECT_EQ(28U, sizeof(OatMethodOffsets));
 }
 
diff --git a/runtime/object_utils.h b/runtime/object_utils.h
index fa7763e11f..3639a80e77 100644
--- a/runtime/object_utils.h
+++ b/runtime/object_utils.h
@@ -411,6 +411,10 @@ class MethodHelper {
     shorty_ = NULL;
   }
 
+  const mirror::AbstractMethod* GetMethod() const {
+    return method_;
+  }
+
   const char* GetName() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
     uint32_t dex_method_idx = method_->GetDexMethodIndex();
diff --git a/runtime/stack.cc b/runtime/stack.cc
index a74bcdbf0c..7f3f40ce5a 100644
--- a/runtime/stack.cc
+++ b/runtime/stack.cc
@@ -308,7 +308,7 @@ void StackVisitor::WalkStack(bool include_transitions) {
         if (UNLIKELY(exit_stubs_installed)) {
           // While profiling, the return pc is restored from the side stack, except when walking
           // the stack for an exception where the side stack will be unwound in VisitFrame.
-          if (GetInstrumentationExitPc() == return_pc) {
+          if (GetQuickInstrumentationExitPc() == return_pc) {
             instrumentation::InstrumentationStackFrame instrumentation_frame =
                 GetInstrumentationStackFrame(instrumentation_stack_depth);
             instrumentation_stack_depth++;
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 97a1410892..c79caa21f8 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -86,23 +86,25 @@ static void UnimplementedEntryPoint() {
 }
 #endif
 
-void InitEntryPoints(QuickEntryPoints* qpoints, PortableEntryPoints* ppoints);
+void InitEntryPoints(InterpreterEntryPoints* ipoints, JniEntryPoints* jpoints,
+                     PortableEntryPoints* ppoints, QuickEntryPoints* qpoints);
 
-void Thread::InitFunctionPointers() {
+void Thread::InitTlsEntryPoints() {
 #if !defined(__APPLE__)  // The Mac GCC is too old to accept this code.
   // Insert a placeholder so we can easily tell if we call an unimplemented entry point.
-  uintptr_t* begin = reinterpret_cast<uintptr_t*>(&quick_entrypoints_);
+  uintptr_t* begin = reinterpret_cast<uintptr_t*>(&interpreter_entrypoints_);
   uintptr_t* end = reinterpret_cast<uintptr_t*>(reinterpret_cast<uint8_t*>(begin) + sizeof(quick_entrypoints_));
   for (uintptr_t* it = begin; it != end; ++it) {
     *it = reinterpret_cast<uintptr_t>(UnimplementedEntryPoint);
   }
-  begin = reinterpret_cast<uintptr_t*>(&portable_entrypoints_);
+  begin = reinterpret_cast<uintptr_t*>(&interpreter_entrypoints_);
   end = reinterpret_cast<uintptr_t*>(reinterpret_cast<uint8_t*>(begin) + sizeof(portable_entrypoints_));
   for (uintptr_t* it = begin; it != end; ++it) {
     *it = reinterpret_cast<uintptr_t>(UnimplementedEntryPoint);
   }
 #endif
-  InitEntryPoints(&quick_entrypoints_, &portable_entrypoints_);
+  InitEntryPoints(&interpreter_entrypoints_, &jni_entrypoints_, &portable_entrypoints_,
+                  &quick_entrypoints_);
 }
 
 void Thread::SetDeoptimizationShadowFrame(ShadowFrame* sf) {
@@ -292,7 +294,7 @@ void Thread::Init(ThreadList* thread_list, JavaVMExt* java_vm) {
   CHECK(Thread::Current() == NULL);
   SetUpAlternateSignalStack();
   InitCpu();
-  InitFunctionPointers();
+  InitTlsEntryPoints();
   InitCardTable();
   InitTid();
   // Set pthread_self_ ahead of pthread_setspecific, that makes Thread::Current function, this
@@ -1589,22 +1591,29 @@ struct EntryPointInfo {
   uint32_t offset;
   const char* name;
 };
-#define QUICK_ENTRY_POINT_INFO(x) { QUICK_ENTRYPOINT_OFFSET(x), #x }
-#define PORTABLE_ENTRY_POINT_INFO(x) { PORTABLE_ENTRYPOINT_OFFSET(x), #x }
+#define INTERPRETER_ENTRY_POINT_INFO(x) { INTERPRETER_ENTRYPOINT_OFFSET(x).Uint32Value(), #x }
+#define JNI_ENTRY_POINT_INFO(x)         { JNI_ENTRYPOINT_OFFSET(x).Uint32Value(), #x }
+#define PORTABLE_ENTRY_POINT_INFO(x)    { PORTABLE_ENTRYPOINT_OFFSET(x).Uint32Value(), #x }
+#define QUICK_ENTRY_POINT_INFO(x)       { QUICK_ENTRYPOINT_OFFSET(x).Uint32Value(), #x }
 static const EntryPointInfo gThreadEntryPointInfo[] = {
-  QUICK_ENTRY_POINT_INFO(pAllocArrayFromCode),
-  QUICK_ENTRY_POINT_INFO(pAllocArrayFromCodeWithAccessCheck),
-  QUICK_ENTRY_POINT_INFO(pAllocObjectFromCode),
-  QUICK_ENTRY_POINT_INFO(pAllocObjectFromCodeWithAccessCheck),
-  QUICK_ENTRY_POINT_INFO(pCheckAndAllocArrayFromCode),
-  QUICK_ENTRY_POINT_INFO(pCheckAndAllocArrayFromCodeWithAccessCheck),
-  QUICK_ENTRY_POINT_INFO(pInstanceofNonTrivialFromCode),
-  QUICK_ENTRY_POINT_INFO(pCanPutArrayElementFromCode),
-  QUICK_ENTRY_POINT_INFO(pCheckCastFromCode),
+  INTERPRETER_ENTRY_POINT_INFO(pInterpreterToInterpreterBridge),
+  INTERPRETER_ENTRY_POINT_INFO(pInterpreterToCompiledCodeBridge),
+  JNI_ENTRY_POINT_INFO(pDlsymLookup),
+  PORTABLE_ENTRY_POINT_INFO(pPortableResolutionTrampoline),
+  PORTABLE_ENTRY_POINT_INFO(pPortableToInterpreterBridge),
+  QUICK_ENTRY_POINT_INFO(pAllocArray),
+  QUICK_ENTRY_POINT_INFO(pAllocArrayWithAccessCheck),
+  QUICK_ENTRY_POINT_INFO(pAllocObject),
+  QUICK_ENTRY_POINT_INFO(pAllocObjectWithAccessCheck),
+  QUICK_ENTRY_POINT_INFO(pCheckAndAllocArray),
+  QUICK_ENTRY_POINT_INFO(pCheckAndAllocArrayWithAccessCheck),
+  QUICK_ENTRY_POINT_INFO(pInstanceofNonTrivial),
+  QUICK_ENTRY_POINT_INFO(pCanPutArrayElement),
+  QUICK_ENTRY_POINT_INFO(pCheckCast),
   QUICK_ENTRY_POINT_INFO(pInitializeStaticStorage),
-  QUICK_ENTRY_POINT_INFO(pInitializeTypeAndVerifyAccessFromCode),
-  QUICK_ENTRY_POINT_INFO(pInitializeTypeFromCode),
-  QUICK_ENTRY_POINT_INFO(pResolveStringFromCode),
+  QUICK_ENTRY_POINT_INFO(pInitializeTypeAndVerifyAccess),
+  QUICK_ENTRY_POINT_INFO(pInitializeType),
+  QUICK_ENTRY_POINT_INFO(pResolveString),
   QUICK_ENTRY_POINT_INFO(pSet32Instance),
   QUICK_ENTRY_POINT_INFO(pSet32Static),
   QUICK_ENTRY_POINT_INFO(pSet64Instance),
@@ -1617,15 +1626,15 @@ static const EntryPointInfo gThreadEntryPointInfo[] = {
   QUICK_ENTRY_POINT_INFO(pGet64Static),
   QUICK_ENTRY_POINT_INFO(pGetObjInstance),
   QUICK_ENTRY_POINT_INFO(pGetObjStatic),
-  QUICK_ENTRY_POINT_INFO(pHandleFillArrayDataFromCode),
+  QUICK_ENTRY_POINT_INFO(pHandleFillArrayData),
   QUICK_ENTRY_POINT_INFO(pJniMethodStart),
   QUICK_ENTRY_POINT_INFO(pJniMethodStartSynchronized),
   QUICK_ENTRY_POINT_INFO(pJniMethodEnd),
   QUICK_ENTRY_POINT_INFO(pJniMethodEndSynchronized),
   QUICK_ENTRY_POINT_INFO(pJniMethodEndWithReference),
   QUICK_ENTRY_POINT_INFO(pJniMethodEndWithReferenceSynchronized),
-  QUICK_ENTRY_POINT_INFO(pLockObjectFromCode),
-  QUICK_ENTRY_POINT_INFO(pUnlockObjectFromCode),
+  QUICK_ENTRY_POINT_INFO(pLockObject),
+  QUICK_ENTRY_POINT_INFO(pUnlockObject),
   QUICK_ENTRY_POINT_INFO(pCmpgDouble),
   QUICK_ENTRY_POINT_INFO(pCmpgFloat),
   QUICK_ENTRY_POINT_INFO(pCmplDouble),
@@ -1646,28 +1655,26 @@ static const EntryPointInfo gThreadEntryPointInfo[] = {
   QUICK_ENTRY_POINT_INFO(pShlLong),
   QUICK_ENTRY_POINT_INFO(pShrLong),
   QUICK_ENTRY_POINT_INFO(pUshrLong),
-  QUICK_ENTRY_POINT_INFO(pInterpreterToInterpreterEntry),
-  QUICK_ENTRY_POINT_INFO(pInterpreterToQuickEntry),
   QUICK_ENTRY_POINT_INFO(pIndexOf),
   QUICK_ENTRY_POINT_INFO(pMemcmp16),
   QUICK_ENTRY_POINT_INFO(pStringCompareTo),
   QUICK_ENTRY_POINT_INFO(pMemcpy),
-  QUICK_ENTRY_POINT_INFO(pQuickResolutionTrampolineFromCode),
+  QUICK_ENTRY_POINT_INFO(pQuickResolutionTrampoline),
+  QUICK_ENTRY_POINT_INFO(pQuickToInterpreterBridge),
   QUICK_ENTRY_POINT_INFO(pInvokeDirectTrampolineWithAccessCheck),
   QUICK_ENTRY_POINT_INFO(pInvokeInterfaceTrampoline),
   QUICK_ENTRY_POINT_INFO(pInvokeInterfaceTrampolineWithAccessCheck),
   QUICK_ENTRY_POINT_INFO(pInvokeStaticTrampolineWithAccessCheck),
   QUICK_ENTRY_POINT_INFO(pInvokeSuperTrampolineWithAccessCheck),
   QUICK_ENTRY_POINT_INFO(pInvokeVirtualTrampolineWithAccessCheck),
-  QUICK_ENTRY_POINT_INFO(pCheckSuspendFromCode),
-  QUICK_ENTRY_POINT_INFO(pTestSuspendFromCode),
+  QUICK_ENTRY_POINT_INFO(pCheckSuspend),
+  QUICK_ENTRY_POINT_INFO(pTestSuspend),
   QUICK_ENTRY_POINT_INFO(pDeliverException),
-  QUICK_ENTRY_POINT_INFO(pThrowArrayBoundsFromCode),
-  QUICK_ENTRY_POINT_INFO(pThrowDivZeroFromCode),
-  QUICK_ENTRY_POINT_INFO(pThrowNoSuchMethodFromCode),
-  QUICK_ENTRY_POINT_INFO(pThrowNullPointerFromCode),
-  QUICK_ENTRY_POINT_INFO(pThrowStackOverflowFromCode),
-  PORTABLE_ENTRY_POINT_INFO(pPortableResolutionTrampolineFromCode),
+  QUICK_ENTRY_POINT_INFO(pThrowArrayBounds),
+  QUICK_ENTRY_POINT_INFO(pThrowDivZero),
+  QUICK_ENTRY_POINT_INFO(pThrowNoSuchMethod),
+  QUICK_ENTRY_POINT_INFO(pThrowNullPointer),
+  QUICK_ENTRY_POINT_INFO(pThrowStackOverflow),
 };
 #undef QUICK_ENTRY_POINT_INFO
 
@@ -1695,8 +1702,9 @@ void Thread::DumpThreadOffset(std::ostream& os, uint32_t offset, size_t size_of_
 
   size_t entry_point_count = arraysize(gThreadEntryPointInfo);
   CHECK_EQ(entry_point_count * size_of_pointers,
-           sizeof(QuickEntryPoints) + sizeof(PortableEntryPoints));
-  uint32_t expected_offset = OFFSETOF_MEMBER(Thread, quick_entrypoints_);
+           sizeof(InterpreterEntryPoints) + sizeof(JniEntryPoints) + sizeof(PortableEntryPoints) +
+           sizeof(QuickEntryPoints));
+  uint32_t expected_offset = OFFSETOF_MEMBER(Thread, interpreter_entrypoints_);
   for (size_t i = 0; i < entry_point_count; ++i) {
     CHECK_EQ(gThreadEntryPointInfo[i].offset, expected_offset) << gThreadEntryPointInfo[i].name;
     expected_offset += size_of_pointers;
@@ -1739,7 +1747,7 @@ class CatchBlockStackVisitor : public StackVisitor {
       return false;  // End stack walk.
     } else {
       if (UNLIKELY(method_tracing_active_ &&
-                   GetInstrumentationExitPc() == GetReturnPc())) {
+                   GetQuickInstrumentationExitPc() == GetReturnPc())) {
         // Keep count of the number of unwinds during instrumentation.
         instrumentation_frames_to_pop_++;
       }
diff --git a/runtime/thread.h b/runtime/thread.h
index ff0fe228c0..8b6771e60c 100644
--- a/runtime/thread.h
+++ b/runtime/thread.h
@@ -26,6 +26,8 @@
 #include <string>
 
 #include "base/macros.h"
+#include "entrypoints/interpreter/interpreter_entrypoints.h"
+#include "entrypoints/jni/jni_entrypoints.h"
 #include "entrypoints/portable/portable_entrypoints.h"
 #include "entrypoints/quick/quick_entrypoints.h"
 #include "globals.h"
@@ -43,17 +45,17 @@
 namespace art {
 
 namespace mirror {
-class AbstractMethod;
-class Array;
-class Class;
-class ClassLoader;
-class Object;
-template<class T> class ObjectArray;
-template<class T> class PrimitiveArray;
-typedef PrimitiveArray<int32_t> IntArray;
-class StackTraceElement;
-class StaticStorageBase;
-class Throwable;
+  class AbstractMethod;
+  class Array;
+  class Class;
+  class ClassLoader;
+  class Object;
+  template<class T> class ObjectArray;
+  template<class T> class PrimitiveArray;
+  typedef PrimitiveArray<int32_t> IntArray;
+  class StackTraceElement;
+  class StaticStorageBase;
+  class Throwable;
 }  // namespace mirror
 class BaseMutex;
 class ClassLinker;
@@ -614,7 +616,7 @@ class PACKED(4) Thread {
   void Init(ThreadList*, JavaVMExt*) EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_);
   void InitCardTable();
   void InitCpu();
-  void InitFunctionPointers();
+  void InitTlsEntryPoints();
   void InitTid();
   void InitPthreadKeySelf();
   void InitStackHwm();
@@ -776,8 +778,10 @@ class PACKED(4) Thread {
  public:
   // Entrypoint function pointers
   // TODO: move this near the top, since changing its offset requires all oats to be recompiled!
-  QuickEntryPoints quick_entrypoints_;
+  InterpreterEntryPoints interpreter_entrypoints_;
+  JniEntryPoints jni_entrypoints_;
   PortableEntryPoints portable_entrypoints_;
+  QuickEntryPoints quick_entrypoints_;
 
  private:
   // How many times has our pthread key's destructor been called?
-- 
cgit v1.2.3-59-g8ed1b


From a024a0686c3b0fea13f362bff70d65981e5febc5 Mon Sep 17 00:00:00 2001
From: buzbee <buzbee@google.com>
Date: Wed, 31 Jul 2013 10:47:37 -0700
Subject: Compilation filter

This CL introduces a static compilation filter mechanism intended
to allow us to reduce compilation time and space requirements until
we have a profiling mechanism in place.

It supports 5 modes of filtering:

   o interpret-only (compile nothing)
   o deferred-compilation (compile only those methods believe to be
     compute-intensive)
   o space (optimized for space)
   o balanced (best return on space investment)
   o speed (compile everything)

A future CL will allow the default filtering mode to be set
via system property.  For now, you can pass it in via command
line as follows:

   dalvikvm -compiler-filter:[interpret-only|defer-compilation|
                              space|balanced|speed]

or dex2oat --runtime-arg -compiler-filter:[one of the above modes]

Creating a file named art/SMALL_ART will force the filter
default to interpret-only.  Later on we'll move this capability
to a persistent system property.

or modify kDefaultCompilerFilter in runtime.h

It also changes the compiler driver to allow the compilers to
decline to compile a method by return NULL.

Change-Id: Ic73411818f8bb845a4a19a05b0395c50902c534f
---
 compiler/Android.mk                 |    1 +
 compiler/dex/frontend.cc            |    5 +
 compiler/dex/frontend.h             |    1 +
 compiler/dex/mir_analysis.cc        | 1056 +++++++++++++++++++++++++++++++++++
 compiler/dex/mir_graph.h            |   45 ++
 compiler/driver/compiler_driver.cc  |   10 +-
 dex2oat/dex2oat.cc                  |   18 +-
 runtime/class_linker.cc             |   24 +
 runtime/runtime.cc                  |   44 +-
 runtime/runtime.h                   |   73 ++-
 runtime/verifier/method_verifier.cc |   11 +-
 11 files changed, 1228 insertions(+), 60 deletions(-)
 create mode 100644 compiler/dex/mir_analysis.cc

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/Android.mk b/compiler/Android.mk
index df77853abf..fec1e11c47 100644
--- a/compiler/Android.mk
+++ b/compiler/Android.mk
@@ -53,6 +53,7 @@ LIBART_COMPILER_SRC_FILES := \
 	dex/mir_optimization.cc \
 	dex/frontend.cc \
 	dex/mir_graph.cc \
+	dex/mir_analysis.cc \
 	dex/vreg_analysis.cc \
 	dex/ssa_transformation.cc \
 	driver/compiler_driver.cc \
diff --git a/compiler/dex/frontend.cc b/compiler/dex/frontend.cc
index 9cc4d18d37..8da1520c30 100644
--- a/compiler/dex/frontend.cc
+++ b/compiler/dex/frontend.cc
@@ -103,6 +103,7 @@ static uint32_t kCompilerDebugFlags = 0 |     // Enable debug/testing modes
   // (1 << kDebugDumpBitcodeFile) |
   // (1 << kDebugVerifyBitcode) |
   // (1 << kDebugShowSummaryMemoryUsage) |
+  // (1 << kDebugShowFilterStats) |
   0;
 
 static CompiledMethod* CompileMethod(CompilerDriver& compiler,
@@ -180,6 +181,10 @@ static CompiledMethod* CompileMethod(CompilerDriver& compiler,
   cu->mir_graph->InlineMethod(code_item, access_flags, invoke_type, class_def_idx, method_idx,
                               class_loader, dex_file);
 
+  if (cu->mir_graph->SkipCompilation(Runtime::Current()->GetCompilerFilter())) {
+    return NULL;
+  }
+
   /* Do a code layout pass */
   cu->mir_graph->CodeLayout();
 
diff --git a/compiler/dex/frontend.h b/compiler/dex/frontend.h
index 5c68ab4244..bafa46892c 100644
--- a/compiler/dex/frontend.h
+++ b/compiler/dex/frontend.h
@@ -77,6 +77,7 @@ enum debugControlVector {
   kDebugDumpBitcodeFile,
   kDebugVerifyBitcode,
   kDebugShowSummaryMemoryUsage,
+  kDebugShowFilterStats,
 };
 
 class LLVMInfo {
diff --git a/compiler/dex/mir_analysis.cc b/compiler/dex/mir_analysis.cc
new file mode 100644
index 0000000000..8321ff63d3
--- /dev/null
+++ b/compiler/dex/mir_analysis.cc
@@ -0,0 +1,1056 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+
+#include "compiler_internals.h"
+#include "dataflow_iterator-inl.h"
+
+namespace art {
+
+  // Instruction characteristics used to statically identify computation-intensive methods.
+const uint32_t MIRGraph::analysis_attributes_[kMirOpLast] = {
+  // 00 NOP
+  AN_NONE,
+
+  // 01 MOVE vA, vB
+  AN_MOVE,
+
+  // 02 MOVE_FROM16 vAA, vBBBB
+  AN_MOVE,
+
+  // 03 MOVE_16 vAAAA, vBBBB
+  AN_MOVE,
+
+  // 04 MOVE_WIDE vA, vB
+  AN_MOVE,
+
+  // 05 MOVE_WIDE_FROM16 vAA, vBBBB
+  AN_MOVE,
+
+  // 06 MOVE_WIDE_16 vAAAA, vBBBB
+  AN_MOVE,
+
+  // 07 MOVE_OBJECT vA, vB
+  AN_MOVE,
+
+  // 08 MOVE_OBJECT_FROM16 vAA, vBBBB
+  AN_MOVE,
+
+  // 09 MOVE_OBJECT_16 vAAAA, vBBBB
+  AN_MOVE,
+
+  // 0A MOVE_RESULT vAA
+  AN_MOVE,
+
+  // 0B MOVE_RESULT_WIDE vAA
+  AN_MOVE,
+
+  // 0C MOVE_RESULT_OBJECT vAA
+  AN_MOVE,
+
+  // 0D MOVE_EXCEPTION vAA
+  AN_MOVE,
+
+  // 0E RETURN_VOID
+  AN_BRANCH,
+
+  // 0F RETURN vAA
+  AN_BRANCH,
+
+  // 10 RETURN_WIDE vAA
+  AN_BRANCH,
+
+  // 11 RETURN_OBJECT vAA
+  AN_BRANCH,
+
+  // 12 CONST_4 vA, #+B
+  AN_SIMPLECONST,
+
+  // 13 CONST_16 vAA, #+BBBB
+  AN_SIMPLECONST,
+
+  // 14 CONST vAA, #+BBBBBBBB
+  AN_SIMPLECONST,
+
+  // 15 CONST_HIGH16 VAA, #+BBBB0000
+  AN_SIMPLECONST,
+
+  // 16 CONST_WIDE_16 vAA, #+BBBB
+  AN_SIMPLECONST,
+
+  // 17 CONST_WIDE_32 vAA, #+BBBBBBBB
+  AN_SIMPLECONST,
+
+  // 18 CONST_WIDE vAA, #+BBBBBBBBBBBBBBBB
+  AN_SIMPLECONST,
+
+  // 19 CONST_WIDE_HIGH16 vAA, #+BBBB000000000000
+  AN_SIMPLECONST,
+
+  // 1A CONST_STRING vAA, string@BBBB
+  AN_NONE,
+
+  // 1B CONST_STRING_JUMBO vAA, string@BBBBBBBB
+  AN_NONE,
+
+  // 1C CONST_CLASS vAA, type@BBBB
+  AN_NONE,
+
+  // 1D MONITOR_ENTER vAA
+  AN_NONE,
+
+  // 1E MONITOR_EXIT vAA
+  AN_NONE,
+
+  // 1F CHK_CAST vAA, type@BBBB
+  AN_NONE,
+
+  // 20 INSTANCE_OF vA, vB, type@CCCC
+  AN_NONE,
+
+  // 21 ARRAY_LENGTH vA, vB
+  AN_ARRAYOP,
+
+  // 22 NEW_INSTANCE vAA, type@BBBB
+  AN_HEAVYWEIGHT,
+
+  // 23 NEW_ARRAY vA, vB, type@CCCC
+  AN_HEAVYWEIGHT,
+
+  // 24 FILLED_NEW_ARRAY {vD, vE, vF, vG, vA}
+  AN_HEAVYWEIGHT,
+
+  // 25 FILLED_NEW_ARRAY_RANGE {vCCCC .. vNNNN}, type@BBBB
+  AN_HEAVYWEIGHT,
+
+  // 26 FILL_ARRAY_DATA vAA, +BBBBBBBB
+  AN_NONE,
+
+  // 27 THROW vAA
+  AN_HEAVYWEIGHT | AN_BRANCH,
+
+  // 28 GOTO
+  AN_BRANCH,
+
+  // 29 GOTO_16
+  AN_BRANCH,
+
+  // 2A GOTO_32
+  AN_BRANCH,
+
+  // 2B PACKED_SWITCH vAA, +BBBBBBBB
+  AN_NONE,
+
+  // 2C SPARSE_SWITCH vAA, +BBBBBBBB
+  AN_NONE,
+
+  // 2D CMPL_FLOAT vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // 2E CMPG_FLOAT vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // 2F CMPL_DOUBLE vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // 30 CMPG_DOUBLE vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // 31 CMP_LONG vAA, vBB, vCC
+  AN_MATH | AN_LONG,
+
+  // 32 IF_EQ vA, vB, +CCCC
+  AN_MATH | AN_BRANCH | AN_INT,
+
+  // 33 IF_NE vA, vB, +CCCC
+  AN_MATH | AN_BRANCH | AN_INT,
+
+  // 34 IF_LT vA, vB, +CCCC
+  AN_MATH | AN_BRANCH | AN_INT,
+
+  // 35 IF_GE vA, vB, +CCCC
+  AN_MATH | AN_BRANCH | AN_INT,
+
+  // 36 IF_GT vA, vB, +CCCC
+  AN_MATH | AN_BRANCH | AN_INT,
+
+  // 37 IF_LE vA, vB, +CCCC
+  AN_MATH | AN_BRANCH | AN_INT,
+
+  // 38 IF_EQZ vAA, +BBBB
+  AN_MATH | AN_BRANCH | AN_INT,
+
+  // 39 IF_NEZ vAA, +BBBB
+  AN_MATH | AN_BRANCH | AN_INT,
+
+  // 3A IF_LTZ vAA, +BBBB
+  AN_MATH | AN_BRANCH | AN_INT,
+
+  // 3B IF_GEZ vAA, +BBBB
+  AN_MATH | AN_BRANCH | AN_INT,
+
+  // 3C IF_GTZ vAA, +BBBB
+  AN_MATH | AN_BRANCH | AN_INT,
+
+  // 3D IF_LEZ vAA, +BBBB
+  AN_MATH | AN_BRANCH | AN_INT,
+
+  // 3E UNUSED_3E
+  AN_NONE,
+
+  // 3F UNUSED_3F
+  AN_NONE,
+
+  // 40 UNUSED_40
+  AN_NONE,
+
+  // 41 UNUSED_41
+  AN_NONE,
+
+  // 42 UNUSED_42
+  AN_NONE,
+
+  // 43 UNUSED_43
+  AN_NONE,
+
+  // 44 AGET vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 45 AGET_WIDE vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 46 AGET_OBJECT vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 47 AGET_BOOLEAN vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 48 AGET_BYTE vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 49 AGET_CHAR vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 4A AGET_SHORT vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 4B APUT vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 4C APUT_WIDE vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 4D APUT_OBJECT vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 4E APUT_BOOLEAN vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 4F APUT_BYTE vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 50 APUT_CHAR vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 51 APUT_SHORT vAA, vBB, vCC
+  AN_ARRAYOP,
+
+  // 52 IGET vA, vB, field@CCCC
+  AN_NONE,
+
+  // 53 IGET_WIDE vA, vB, field@CCCC
+  AN_NONE,
+
+  // 54 IGET_OBJECT vA, vB, field@CCCC
+  AN_NONE,
+
+  // 55 IGET_BOOLEAN vA, vB, field@CCCC
+  AN_NONE,
+
+  // 56 IGET_BYTE vA, vB, field@CCCC
+  AN_NONE,
+
+  // 57 IGET_CHAR vA, vB, field@CCCC
+  AN_NONE,
+
+  // 58 IGET_SHORT vA, vB, field@CCCC
+  AN_NONE,
+
+  // 59 IPUT vA, vB, field@CCCC
+  AN_NONE,
+
+  // 5A IPUT_WIDE vA, vB, field@CCCC
+  AN_NONE,
+
+  // 5B IPUT_OBJECT vA, vB, field@CCCC
+  AN_NONE,
+
+  // 5C IPUT_BOOLEAN vA, vB, field@CCCC
+  AN_NONE,
+
+  // 5D IPUT_BYTE vA, vB, field@CCCC
+  AN_NONE,
+
+  // 5E IPUT_CHAR vA, vB, field@CCCC
+  AN_NONE,
+
+  // 5F IPUT_SHORT vA, vB, field@CCCC
+  AN_NONE,
+
+  // 60 SGET vAA, field@BBBB
+  AN_NONE,
+
+  // 61 SGET_WIDE vAA, field@BBBB
+  AN_NONE,
+
+  // 62 SGET_OBJECT vAA, field@BBBB
+  AN_NONE,
+
+  // 63 SGET_BOOLEAN vAA, field@BBBB
+  AN_NONE,
+
+  // 64 SGET_BYTE vAA, field@BBBB
+  AN_NONE,
+
+  // 65 SGET_CHAR vAA, field@BBBB
+  AN_NONE,
+
+  // 66 SGET_SHORT vAA, field@BBBB
+  AN_NONE,
+
+  // 67 SPUT vAA, field@BBBB
+  AN_NONE,
+
+  // 68 SPUT_WIDE vAA, field@BBBB
+  AN_NONE,
+
+  // 69 SPUT_OBJECT vAA, field@BBBB
+  AN_NONE,
+
+  // 6A SPUT_BOOLEAN vAA, field@BBBB
+  AN_NONE,
+
+  // 6B SPUT_BYTE vAA, field@BBBB
+  AN_NONE,
+
+  // 6C SPUT_CHAR vAA, field@BBBB
+  AN_NONE,
+
+  // 6D SPUT_SHORT vAA, field@BBBB
+  AN_NONE,
+
+  // 6E INVOKE_VIRTUAL {vD, vE, vF, vG, vA}
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // 6F INVOKE_SUPER {vD, vE, vF, vG, vA}
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // 70 INVOKE_DIRECT {vD, vE, vF, vG, vA}
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // 71 INVOKE_STATIC {vD, vE, vF, vG, vA}
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // 72 INVOKE_INTERFACE {vD, vE, vF, vG, vA}
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // 73 UNUSED_73
+  AN_NONE,
+
+  // 74 INVOKE_VIRTUAL_RANGE {vCCCC .. vNNNN}
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // 75 INVOKE_SUPER_RANGE {vCCCC .. vNNNN}
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // 76 INVOKE_DIRECT_RANGE {vCCCC .. vNNNN}
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // 77 INVOKE_STATIC_RANGE {vCCCC .. vNNNN}
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // 78 INVOKE_INTERFACE_RANGE {vCCCC .. vNNNN}
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // 79 UNUSED_79
+  AN_NONE,
+
+  // 7A UNUSED_7A
+  AN_NONE,
+
+  // 7B NEG_INT vA, vB
+  AN_MATH | AN_INT,
+
+  // 7C NOT_INT vA, vB
+  AN_MATH | AN_INT,
+
+  // 7D NEG_LONG vA, vB
+  AN_MATH | AN_LONG,
+
+  // 7E NOT_LONG vA, vB
+  AN_MATH | AN_LONG,
+
+  // 7F NEG_FLOAT vA, vB
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // 80 NEG_DOUBLE vA, vB
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // 81 INT_TO_LONG vA, vB
+  AN_MATH | AN_INT | AN_LONG,
+
+  // 82 INT_TO_FLOAT vA, vB
+  AN_MATH | AN_FP | AN_INT | AN_SINGLE,
+
+  // 83 INT_TO_DOUBLE vA, vB
+  AN_MATH | AN_FP | AN_INT | AN_DOUBLE,
+
+  // 84 LONG_TO_INT vA, vB
+  AN_MATH | AN_INT | AN_LONG,
+
+  // 85 LONG_TO_FLOAT vA, vB
+  AN_MATH | AN_FP | AN_LONG | AN_SINGLE,
+
+  // 86 LONG_TO_DOUBLE vA, vB
+  AN_MATH | AN_FP | AN_LONG | AN_DOUBLE,
+
+  // 87 FLOAT_TO_INT vA, vB
+  AN_MATH | AN_FP | AN_INT | AN_SINGLE,
+
+  // 88 FLOAT_TO_LONG vA, vB
+  AN_MATH | AN_FP | AN_LONG | AN_SINGLE,
+
+  // 89 FLOAT_TO_DOUBLE vA, vB
+  AN_MATH | AN_FP | AN_SINGLE | AN_DOUBLE,
+
+  // 8A DOUBLE_TO_INT vA, vB
+  AN_MATH | AN_FP | AN_INT | AN_DOUBLE,
+
+  // 8B DOUBLE_TO_LONG vA, vB
+  AN_MATH | AN_FP | AN_LONG | AN_DOUBLE,
+
+  // 8C DOUBLE_TO_FLOAT vA, vB
+  AN_MATH | AN_FP | AN_SINGLE | AN_DOUBLE,
+
+  // 8D INT_TO_BYTE vA, vB
+  AN_MATH | AN_INT,
+
+  // 8E INT_TO_CHAR vA, vB
+  AN_MATH | AN_INT,
+
+  // 8F INT_TO_SHORT vA, vB
+  AN_MATH | AN_INT,
+
+  // 90 ADD_INT vAA, vBB, vCC
+  AN_MATH | AN_INT,
+
+  // 91 SUB_INT vAA, vBB, vCC
+  AN_MATH | AN_INT,
+
+  // 92 MUL_INT vAA, vBB, vCC
+  AN_MATH | AN_INT,
+
+  // 93 DIV_INT vAA, vBB, vCC
+  AN_MATH | AN_INT,
+
+  // 94 REM_INT vAA, vBB, vCC
+  AN_MATH | AN_INT,
+
+  // 95 AND_INT vAA, vBB, vCC
+  AN_MATH | AN_INT,
+
+  // 96 OR_INT vAA, vBB, vCC
+  AN_MATH | AN_INT,
+
+  // 97 XOR_INT vAA, vBB, vCC
+  AN_MATH | AN_INT,
+
+  // 98 SHL_INT vAA, vBB, vCC
+  AN_MATH | AN_INT,
+
+  // 99 SHR_INT vAA, vBB, vCC
+  AN_MATH | AN_INT,
+
+  // 9A USHR_INT vAA, vBB, vCC
+  AN_MATH | AN_INT,
+
+  // 9B ADD_LONG vAA, vBB, vCC
+  AN_MATH | AN_LONG,
+
+  // 9C SUB_LONG vAA, vBB, vCC
+  AN_MATH | AN_LONG,
+
+  // 9D MUL_LONG vAA, vBB, vCC
+  AN_MATH | AN_LONG,
+
+  // 9E DIV_LONG vAA, vBB, vCC
+  AN_MATH | AN_LONG,
+
+  // 9F REM_LONG vAA, vBB, vCC
+  AN_MATH | AN_LONG,
+
+  // A0 AND_LONG vAA, vBB, vCC
+  AN_MATH | AN_LONG,
+
+  // A1 OR_LONG vAA, vBB, vCC
+  AN_MATH | AN_LONG,
+
+  // A2 XOR_LONG vAA, vBB, vCC
+  AN_MATH | AN_LONG,
+
+  // A3 SHL_LONG vAA, vBB, vCC
+  AN_MATH | AN_LONG,
+
+  // A4 SHR_LONG vAA, vBB, vCC
+  AN_MATH | AN_LONG,
+
+  // A5 USHR_LONG vAA, vBB, vCC
+  AN_MATH | AN_LONG,
+
+  // A6 ADD_FLOAT vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // A7 SUB_FLOAT vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // A8 MUL_FLOAT vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // A9 DIV_FLOAT vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // AA REM_FLOAT vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // AB ADD_DOUBLE vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // AC SUB_DOUBLE vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // AD MUL_DOUBLE vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // AE DIV_DOUBLE vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // AF REM_DOUBLE vAA, vBB, vCC
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // B0 ADD_INT_2ADDR vA, vB
+  AN_MATH | AN_INT,
+
+  // B1 SUB_INT_2ADDR vA, vB
+  AN_MATH | AN_INT,
+
+  // B2 MUL_INT_2ADDR vA, vB
+  AN_MATH | AN_INT,
+
+  // B3 DIV_INT_2ADDR vA, vB
+  AN_MATH | AN_INT,
+
+  // B4 REM_INT_2ADDR vA, vB
+  AN_MATH | AN_INT,
+
+  // B5 AND_INT_2ADDR vA, vB
+  AN_MATH | AN_INT,
+
+  // B6 OR_INT_2ADDR vA, vB
+  AN_MATH | AN_INT,
+
+  // B7 XOR_INT_2ADDR vA, vB
+  AN_MATH | AN_INT,
+
+  // B8 SHL_INT_2ADDR vA, vB
+  AN_MATH | AN_INT,
+
+  // B9 SHR_INT_2ADDR vA, vB
+  AN_MATH | AN_INT,
+
+  // BA USHR_INT_2ADDR vA, vB
+  AN_MATH | AN_INT,
+
+  // BB ADD_LONG_2ADDR vA, vB
+  AN_MATH | AN_LONG,
+
+  // BC SUB_LONG_2ADDR vA, vB
+  AN_MATH | AN_LONG,
+
+  // BD MUL_LONG_2ADDR vA, vB
+  AN_MATH | AN_LONG,
+
+  // BE DIV_LONG_2ADDR vA, vB
+  AN_MATH | AN_LONG,
+
+  // BF REM_LONG_2ADDR vA, vB
+  AN_MATH | AN_LONG,
+
+  // C0 AND_LONG_2ADDR vA, vB
+  AN_MATH | AN_LONG,
+
+  // C1 OR_LONG_2ADDR vA, vB
+  AN_MATH | AN_LONG,
+
+  // C2 XOR_LONG_2ADDR vA, vB
+  AN_MATH | AN_LONG,
+
+  // C3 SHL_LONG_2ADDR vA, vB
+  AN_MATH | AN_LONG,
+
+  // C4 SHR_LONG_2ADDR vA, vB
+  AN_MATH | AN_LONG,
+
+  // C5 USHR_LONG_2ADDR vA, vB
+  AN_MATH | AN_LONG,
+
+  // C6 ADD_FLOAT_2ADDR vA, vB
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // C7 SUB_FLOAT_2ADDR vA, vB
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // C8 MUL_FLOAT_2ADDR vA, vB
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // C9 DIV_FLOAT_2ADDR vA, vB
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // CA REM_FLOAT_2ADDR vA, vB
+  AN_MATH | AN_FP | AN_SINGLE,
+
+  // CB ADD_DOUBLE_2ADDR vA, vB
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // CC SUB_DOUBLE_2ADDR vA, vB
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // CD MUL_DOUBLE_2ADDR vA, vB
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // CE DIV_DOUBLE_2ADDR vA, vB
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // CF REM_DOUBLE_2ADDR vA, vB
+  AN_MATH | AN_FP | AN_DOUBLE,
+
+  // D0 ADD_INT_LIT16 vA, vB, #+CCCC
+  AN_MATH | AN_INT,
+
+  // D1 RSUB_INT vA, vB, #+CCCC
+  AN_MATH | AN_INT,
+
+  // D2 MUL_INT_LIT16 vA, vB, #+CCCC
+  AN_MATH | AN_INT,
+
+  // D3 DIV_INT_LIT16 vA, vB, #+CCCC
+  AN_MATH | AN_INT,
+
+  // D4 REM_INT_LIT16 vA, vB, #+CCCC
+  AN_MATH | AN_INT,
+
+  // D5 AND_INT_LIT16 vA, vB, #+CCCC
+  AN_MATH | AN_INT,
+
+  // D6 OR_INT_LIT16 vA, vB, #+CCCC
+  AN_MATH | AN_INT,
+
+  // D7 XOR_INT_LIT16 vA, vB, #+CCCC
+  AN_MATH | AN_INT,
+
+  // D8 ADD_INT_LIT8 vAA, vBB, #+CC
+  AN_MATH | AN_INT,
+
+  // D9 RSUB_INT_LIT8 vAA, vBB, #+CC
+  AN_MATH | AN_INT,
+
+  // DA MUL_INT_LIT8 vAA, vBB, #+CC
+  AN_MATH | AN_INT,
+
+  // DB DIV_INT_LIT8 vAA, vBB, #+CC
+  AN_MATH | AN_INT,
+
+  // DC REM_INT_LIT8 vAA, vBB, #+CC
+  AN_MATH | AN_INT,
+
+  // DD AND_INT_LIT8 vAA, vBB, #+CC
+  AN_MATH | AN_INT,
+
+  // DE OR_INT_LIT8 vAA, vBB, #+CC
+  AN_MATH | AN_INT,
+
+  // DF XOR_INT_LIT8 vAA, vBB, #+CC
+  AN_MATH | AN_INT,
+
+  // E0 SHL_INT_LIT8 vAA, vBB, #+CC
+  AN_MATH | AN_INT,
+
+  // E1 SHR_INT_LIT8 vAA, vBB, #+CC
+  AN_MATH | AN_INT,
+
+  // E2 USHR_INT_LIT8 vAA, vBB, #+CC
+  AN_MATH | AN_INT,
+
+  // E3 IGET_VOLATILE
+  AN_NONE,
+
+  // E4 IPUT_VOLATILE
+  AN_NONE,
+
+  // E5 SGET_VOLATILE
+  AN_NONE,
+
+  // E6 SPUT_VOLATILE
+  AN_NONE,
+
+  // E7 IGET_OBJECT_VOLATILE
+  AN_NONE,
+
+  // E8 IGET_WIDE_VOLATILE
+  AN_NONE,
+
+  // E9 IPUT_WIDE_VOLATILE
+  AN_NONE,
+
+  // EA SGET_WIDE_VOLATILE
+  AN_NONE,
+
+  // EB SPUT_WIDE_VOLATILE
+  AN_NONE,
+
+  // EC BREAKPOINT
+  AN_NONE,
+
+  // ED THROW_VERIFICATION_ERROR
+  AN_HEAVYWEIGHT | AN_BRANCH,
+
+  // EE EXECUTE_INLINE
+  AN_NONE,
+
+  // EF EXECUTE_INLINE_RANGE
+  AN_NONE,
+
+  // F0 INVOKE_OBJECT_INIT_RANGE
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // F1 RETURN_VOID_BARRIER
+  AN_BRANCH,
+
+  // F2 IGET_QUICK
+  AN_NONE,
+
+  // F3 IGET_WIDE_QUICK
+  AN_NONE,
+
+  // F4 IGET_OBJECT_QUICK
+  AN_NONE,
+
+  // F5 IPUT_QUICK
+  AN_NONE,
+
+  // F6 IPUT_WIDE_QUICK
+  AN_NONE,
+
+  // F7 IPUT_OBJECT_QUICK
+  AN_NONE,
+
+  // F8 INVOKE_VIRTUAL_QUICK
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // F9 INVOKE_VIRTUAL_QUICK_RANGE
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // FA INVOKE_SUPER_QUICK
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // FB INVOKE_SUPER_QUICK_RANGE
+  AN_INVOKE | AN_HEAVYWEIGHT,
+
+  // FC IPUT_OBJECT_VOLATILE
+  AN_NONE,
+
+  // FD SGET_OBJECT_VOLATILE
+  AN_NONE,
+
+  // FE SPUT_OBJECT_VOLATILE
+  AN_NONE,
+
+  // FF UNUSED_FF
+  AN_NONE,
+
+  // Beginning of extended MIR opcodes
+  // 100 MIR_PHI
+  AN_NONE,
+
+  // 101 MIR_COPY
+  AN_NONE,
+
+  // 102 MIR_FUSED_CMPL_FLOAT
+  AN_NONE,
+
+  // 103 MIR_FUSED_CMPG_FLOAT
+  AN_NONE,
+
+  // 104 MIR_FUSED_CMPL_DOUBLE
+  AN_NONE,
+
+  // 105 MIR_FUSED_CMPG_DOUBLE
+  AN_NONE,
+
+  // 106 MIR_FUSED_CMP_LONG
+  AN_NONE,
+
+  // 107 MIR_NOP
+  AN_NONE,
+
+  // 108 MIR_NULL_CHECK
+  AN_NONE,
+
+  // 109 MIR_RANGE_CHECK
+  AN_NONE,
+
+  // 110 MIR_DIV_ZERO_CHECK
+  AN_NONE,
+
+  // 111 MIR_CHECK
+  AN_NONE,
+
+  // 112 MIR_CHECKPART2
+  AN_NONE,
+
+  // 113 MIR_SELECT
+  AN_NONE,
+};
+
+struct MethodStats {
+  int dex_instructions;
+  int math_ops;
+  int fp_ops;
+  int array_ops;
+  int branch_ops;
+  int heavyweight_ops;
+  bool has_computational_loop;
+  float math_ratio;
+  float fp_ratio;
+  float array_ratio;
+  float branch_ratio;
+  float heavyweight_ratio;
+};
+
+void MIRGraph::AnalyzeBlock(BasicBlock* bb, MethodStats* stats) {
+  if (bb->visited || (bb->block_type != kDalvikByteCode)) {
+    return;
+  }
+  bool computational_block = true;
+  bool has_math = false;
+  /*
+   * For the purposes of this scan, we want to treat the set of basic blocks broken
+   * by an exception edge as a single basic block.  We'll scan forward along the fallthrough
+   * edges until we reach an explicit branch or return.
+   */
+  BasicBlock* ending_bb = bb;
+  if (ending_bb->last_mir_insn != NULL) {
+    uint32_t ending_flags = analysis_attributes_[ending_bb->last_mir_insn->dalvikInsn.opcode];
+    while ((ending_flags & AN_BRANCH) == 0) {
+      ending_bb = ending_bb->fall_through;
+      ending_flags = analysis_attributes_[ending_bb->last_mir_insn->dalvikInsn.opcode];
+    }
+  }
+  /*
+   * Ideally, we'd weight the operations by loop nesting level, but to do so we'd
+   * first need to do some expensive loop detection - and the point of this is to make
+   * an informed guess before investing in computation.  However, we can cheaply detect
+   * many simple loop forms without having to do full dataflow analysis.
+   */
+  int loop_scale_factor = 1;
+  // Simple for and while loops
+  if ((ending_bb->taken != NULL) && (ending_bb->fall_through == NULL)) {
+    if ((ending_bb->taken->taken == bb) || (ending_bb->taken->fall_through == bb)) {
+      loop_scale_factor = 25;
+    }
+  }
+  // Simple do-while loop
+  if ((ending_bb->taken != NULL) && (ending_bb->taken == bb)) {
+    loop_scale_factor = 25;
+  }
+
+  BasicBlock* tbb = bb;
+  bool done = false;
+  while (!done) {
+    tbb->visited = true;
+    for (MIR* mir = tbb->first_mir_insn; mir != NULL; mir = mir->next) {
+      if (static_cast<uint32_t>(mir->dalvikInsn.opcode) >= kMirOpFirst) {
+        // Skip any MIR pseudo-op.
+        continue;
+      }
+      uint32_t flags = analysis_attributes_[mir->dalvikInsn.opcode];
+      stats->dex_instructions += loop_scale_factor;
+      if ((flags & AN_BRANCH) == 0) {
+        computational_block &= ((flags & AN_COMPUTATIONAL) != 0);
+      } else {
+        stats->branch_ops += loop_scale_factor;
+      }
+      if ((flags & AN_MATH) != 0) {
+        stats->math_ops += loop_scale_factor;
+        has_math = true;
+      }
+      if ((flags & AN_FP) != 0) {
+        stats->fp_ops += loop_scale_factor;
+      }
+      if ((flags & AN_ARRAYOP) != 0) {
+        stats->array_ops += loop_scale_factor;
+      }
+      if ((flags & AN_HEAVYWEIGHT) != 0) {
+        stats->heavyweight_ops += loop_scale_factor;
+      }
+    }
+    if (tbb == ending_bb) {
+      done = true;
+    } else {
+      tbb = tbb->fall_through;
+    }
+  }
+  if (has_math && computational_block && (loop_scale_factor > 1)) {
+    stats->has_computational_loop = true;
+  }
+}
+
+bool MIRGraph::ComputeSkipCompilation(MethodStats* stats, bool skip_default) {
+  float count = stats->dex_instructions;
+  stats->math_ratio = stats->math_ops / count;
+  stats->fp_ratio = stats->fp_ops / count;
+  stats->branch_ratio = stats->branch_ops / count;
+  stats->array_ratio = stats->array_ops / count;
+  stats->heavyweight_ratio = stats->heavyweight_ops / count;
+
+  if (cu_->enable_debug & (1 << kDebugShowFilterStats)) {
+    LOG(INFO) << "STATS " << stats->dex_instructions << ", math:"
+              << stats->math_ratio << ", fp:"
+              << stats->fp_ratio << ", br:"
+              << stats->branch_ratio << ", hw:"
+              << stats-> heavyweight_ratio << ", arr:"
+              << stats->array_ratio << ", hot:"
+              << stats->has_computational_loop << ", "
+              << PrettyMethod(cu_->method_idx, *cu_->dex_file);
+  }
+
+  // Computation intensive?
+  if (stats->has_computational_loop && (stats->heavyweight_ratio < 0.04)) {
+    return false;
+  }
+
+  // Complex, logic-intensive?
+  if ((GetNumDalvikInsns() > Runtime::Current()->GetSmallMethodThreshold()) &&
+      stats->branch_ratio > 0.3) {
+    return false;
+  }
+
+  // Significant floating point?
+  if (stats->fp_ratio > 0.05) {
+    return false;
+  }
+
+  // Significant generic math?
+  if (stats->math_ratio > 0.3) {
+    return false;
+  }
+
+  // If array-intensive, compiling is probably worthwhile.
+  if (stats->array_ratio > 0.1) {
+    return false;
+  }
+
+  // If high proportion of expensive operations, skip.
+  if (stats->heavyweight_ratio > 0.3) {
+    return true;
+  }
+
+  return skip_default;
+}
+
+ /*
+  * Will eventually want this to be a bit more sophisticated and happen at verification time.
+  * Ultimate goal is to drive with profile data.
+  */
+bool MIRGraph::SkipCompilation(Runtime::CompilerFilter compiler_filter) {
+  if (compiler_filter == Runtime::kSpeed) {
+    // If going for speed, compile everything.
+    return false;
+  }
+
+  if (compiler_filter == Runtime::kInterpretOnly) {
+    LOG(WARNING) << "InterpretOnly should ideally be filtered out prior to parsing.";
+    return true;
+  }
+
+  // Filter 1: Skip huge methods (generally machine-generated initialization methods).
+  if (GetNumDalvikInsns() > Runtime::Current()->GetHugeMethodThreshold()) {
+    // Ain't nobody got time for that.
+    return true;
+  }
+
+  // Filter 2: Skip class initializers.
+  if (((cu_->access_flags & kAccConstructor) != 0) && ((cu_->access_flags & kAccStatic) != 0)) {
+    return true;
+  }
+
+  // Filter 3: if this method is a special pattern, go ahead and emit the canned pattern.
+  if (IsSpecialCase()) {
+    return false;
+  }
+
+  /* In balanced mode, we generally assume that we'll be compiling, and then detect
+   * methods that won't benefit and remove them.  In space or deferred mode, we do the
+   * opposite: assume no compilation and then add back presumed hot methods.
+   */
+  bool skip_compilation = (compiler_filter == Runtime::kBalanced) ? false : true;
+
+
+  // Filter 4: go ahead and compile the small ones.
+  size_t small_cutoff = 0;
+  switch (compiler_filter) {
+    case Runtime::kBalanced:
+      small_cutoff = Runtime::Current()->GetSmallMethodThreshold();
+      break;
+    case Runtime::kSpace:
+      small_cutoff = Runtime::Current()->GetTinyMethodThreshold();
+      break;
+    case Runtime::kDeferCompilation:
+      small_cutoff = 0;
+      break;
+    default:
+      LOG(FATAL) << "Unexpected compiler_filter_: " << compiler_filter;
+  }
+  if (GetNumDalvikInsns() < small_cutoff) {
+    return false;
+  }
+
+  // Analyze graph for:
+  //  o floating point computation
+  //  o basic blocks contained in loop with heavy arithmetic.
+  //  o proportion of conditional branches.
+
+  MethodStats stats;
+  memset(&stats, 0, sizeof(stats));
+
+  ClearAllVisitedFlags();
+  AllNodesIterator iter(this, false /* not iterative */);
+  for (BasicBlock* bb = iter.Next(); bb != NULL; bb = iter.Next()) {
+    AnalyzeBlock(bb, &stats);
+  }
+
+  return ComputeSkipCompilation(&stats, skip_compilation);
+}
+
+}  // namespace art
diff --git a/compiler/dex/mir_graph.h b/compiler/dex/mir_graph.h
index e9ec949f23..84ab2590b0 100644
--- a/compiler/dex/mir_graph.h
+++ b/compiler/dex/mir_graph.h
@@ -25,6 +25,38 @@
 
 namespace art {
 
+enum InstructionAnalysisAttributePos {
+  kUninterestingOp = 0,
+  kArithmeticOp,
+  kFPOp,
+  kSingleOp,
+  kDoubleOp,
+  kIntOp,
+  kLongOp,
+  kBranchOp,
+  kInvokeOp,
+  kArrayOp,
+  kHeavyweightOp,
+  kSimpleConstOp,
+  kMoveOp
+};
+
+#define AN_NONE (1 << kUninterestingOp)
+#define AN_MATH (1 << kArithmeticOp)
+#define AN_FP (1 << kFPOp)
+#define AN_LONG (1 << kLongOp)
+#define AN_INT (1 << kIntOp)
+#define AN_SINGLE (1 << kSingleOp)
+#define AN_DOUBLE (1 << kDoubleOp)
+#define AN_FLOATMATH (1 << kFPOp)
+#define AN_BRANCH (1 << kBranchOp)
+#define AN_INVOKE (1 << kInvokeOp)
+#define AN_ARRAYOP (1 << kArrayOp)
+#define AN_HEAVYWEIGHT (1 << kHeavyweightOp)
+#define AN_SIMPLECONST (1 << kSimpleConstOp)
+#define AN_MOVE (1 << kMoveOp)
+#define AN_COMPUTATIONAL (AN_MATH | AN_ARRAYOP | AN_MOVE | AN_SIMPLECONST)
+
 enum DataFlowAttributePos {
   kUA = 0,
   kUB,
@@ -312,6 +344,12 @@ class MIRGraph {
   MIRGraph(CompilationUnit* cu, ArenaAllocator* arena);
   ~MIRGraph();
 
+  /*
+   * Examine the graph to determine whether it's worthwile to spend the time compiling
+   * this method.
+   */
+  bool SkipCompilation(Runtime::CompilerFilter compiler_filter);
+
   /*
    * Parse dex method and add MIR at current insert point.  Returns id (which is
    * actually the index of the method in the m_units_ array).
@@ -337,6 +375,10 @@ class MIRGraph {
     return num_blocks_;
   }
 
+  size_t GetNumDalvikInsns() const {
+    return cu_->code_item->insns_size_in_code_units_;
+  }
+
   ArenaBitVector* GetTryBlockAddr() const {
     return try_block_addr_;
   }
@@ -559,6 +601,7 @@ class MIRGraph {
 
   static const int oat_data_flow_attributes_[kMirOpLast];
   static const char* extended_mir_op_names_[kMirOpLast - kMirOpFirst];
+  static const uint32_t analysis_attributes_[kMirOpLast];
 
  private:
   int FindCommonParent(int block1, int block2);
@@ -621,6 +664,8 @@ class MIRGraph {
   void DoConstantPropogation(BasicBlock* bb);
   void CountChecks(BasicBlock* bb);
   bool CombineBlocks(BasicBlock* bb);
+  void AnalyzeBlock(BasicBlock* bb, struct MethodStats* stats);
+  bool ComputeSkipCompilation(struct MethodStats* stats, bool skip_default);
 
   CompilationUnit* const cu_;
   GrowableArray<int>* ssa_base_vregs_;
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 38d00a0804..e7ba402b21 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -334,8 +334,8 @@ extern "C" void compilerLLVMSetBitcodeFileName(art::CompilerDriver& driver,
                                                std::string const& filename);
 
 CompilerDriver::CompilerDriver(CompilerBackend compiler_backend, InstructionSet instruction_set,
-                               bool image, DescriptorSet* image_classes,
-                               size_t thread_count, bool dump_stats)
+                               bool image, DescriptorSet* image_classes, size_t thread_count,
+                               bool dump_stats)
     : compiler_backend_(compiler_backend),
       instruction_set_(instruction_set),
       freezing_constructor_lock_("freezing constructor lock"),
@@ -2253,6 +2253,10 @@ void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t
   } else {
     bool compile = verifier::MethodVerifier::IsCandidateForCompilation(code_item, access_flags);
     if (compile) {
+      // If we're doing the image, override the compiler filter to force full compilation.
+      if ((image_classes_.get() != NULL) && (image_classes_->size() != 0)) {
+        Runtime::Current()->SetCompilerFilter(Runtime::kSpeed);
+      }
       CompilerFn compiler = compiler_;
 #ifdef ART_SEA_IR_MODE
       bool use_sea = Runtime::Current()->IsSeaIRMode();
@@ -2261,9 +2265,9 @@ void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t
         compiler = sea_ir_compiler_;
       }
 #endif
+      // NOTE: if compiler declines to compile this method, it will return NULL.
       compiled_method = (*compiler)(*this, code_item, access_flags, invoke_type, class_def_idx,
                                     method_idx, class_loader, dex_file);
-      CHECK(compiled_method != NULL) << PrettyMethod(method_idx, dex_file);
     } else if (dex_to_dex_compilation_level != kDontDexToDexCompile) {
       // TODO: add a mode to disable DEX-to-DEX compilation ?
       (*dex_to_dex_compiler_)(*this, code_item, access_flags,
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index c8c43476dc..b33997448e 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -847,11 +847,6 @@ static int dex2oat(int argc, char** argv) {
     options.push_back(std::make_pair(runtime_args[i], reinterpret_cast<void*>(NULL)));
   }
 
-#if ART_SMALL_MODE
-  options.push_back(std::make_pair("-small", reinterpret_cast<void*>(NULL)));
-#endif  // ART_SMALL_MODE
-
-
 #ifdef ART_SEA_IR_MODE
   options.push_back(std::make_pair("-sea_ir", reinterpret_cast<void*>(NULL)));
 #endif
@@ -910,18 +905,19 @@ static int dex2oat(int argc, char** argv) {
     }
   }
 
-  // If we're in small mode, but the program is small, turn off small mode.
-  // It doesn't make a difference for the boot image, so let's skip the check
-  // altogether.
-  if (Runtime::Current()->IsSmallMode() && !image) {
+  /*
+   * If we're not in interpret-only mode, go ahead and compile small applications. Don't
+   * bother to check if we're doing the image.
+   */
+  if (!image && (Runtime::Current()->GetCompilerFilter() != Runtime::kInterpretOnly)) {
     size_t num_methods = 0;
     for (size_t i = 0; i != dex_files.size(); ++i) {
       const DexFile* dex_file = dex_files[i];
       CHECK(dex_file != NULL);
       num_methods += dex_file->NumMethodIds();
     }
-    if (num_methods <= Runtime::Current()->GetSmallModeMethodThreshold()) {
-      Runtime::Current()->SetSmallMode(false);
+    if (num_methods <= Runtime::Current()->GetNumDexMethodsThreshold()) {
+      Runtime::Current()->SetCompilerFilter(Runtime::kSpeed);
       LOG(INFO) << "Below method threshold, compiling anyways";
     }
   }
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 84f186d4b3..6052993c6b 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -609,6 +609,28 @@ bool ClassLinker::GenerateOatFile(const std::string& dex_filename,
   oat_location_option_string += oat_cache_filename;
   const char* oat_location_option = oat_location_option_string.c_str();
 
+  std::string oat_compiler_filter_string("-compiler-filter:");
+  switch (Runtime::Current()->GetCompilerFilter()) {
+    case Runtime::kInterpretOnly:
+      oat_compiler_filter_string += "interpret-only";
+      break;
+    case Runtime::kDeferCompilation:
+      oat_compiler_filter_string += "defer-compilation";
+      break;
+    case Runtime::kSpace:
+      oat_compiler_filter_string += "space";
+      break;
+    case Runtime::kBalanced:
+      oat_compiler_filter_string += "balanced";
+      break;
+    case Runtime::kSpeed:
+      oat_compiler_filter_string += "speed";
+      break;
+    default:
+      LOG(FATAL) << "Unexpected case.";
+  }
+  const char* oat_compiler_filter_option = oat_compiler_filter_string.c_str();
+
   // fork and exec dex2oat
   pid_t pid = fork();
   if (pid == 0) {
@@ -622,6 +644,7 @@ bool ClassLinker::GenerateOatFile(const std::string& dex_filename,
                        << " --runtime-arg -Xmx64m"
                        << " --runtime-arg -classpath"
                        << " --runtime-arg " << class_path
+                       << " --runtime-arg " << oat_compiler_filter_option
 #if !defined(ART_TARGET)
                        << " --host"
 #endif
@@ -635,6 +658,7 @@ bool ClassLinker::GenerateOatFile(const std::string& dex_filename,
           "--runtime-arg", "-Xmx64m",
           "--runtime-arg", "-classpath",
           "--runtime-arg", class_path,
+          "--runtime-arg", oat_compiler_filter_option,
 #if !defined(ART_TARGET)
           "--host",
 #endif
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index 5298181f19..70d8816401 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -355,9 +355,12 @@ Runtime::ParsedOptions* Runtime::ParsedOptions::Create(const Options& options, b
   parsed->hook_exit_ = exit;
   parsed->hook_abort_ = NULL;  // We don't call abort(3) by default; see Runtime::Abort.
 
-  parsed->small_mode_ = false;
-  parsed->small_mode_method_threshold_ = Runtime::kDefaultSmallModeMethodThreshold;
-  parsed->small_mode_method_dex_size_limit_ = Runtime::kDefaultSmallModeMethodDexSizeLimit;
+  parsed->compiler_filter_ = Runtime::kDefaultCompilerFilter;
+  parsed->huge_method_threshold_ = Runtime::kDefaultHugeMethodThreshold;
+  parsed->large_method_threshold_ = Runtime::kDefaultLargeMethodThreshold;
+  parsed->small_method_threshold_ = Runtime::kDefaultSmallMethodThreshold;
+  parsed->tiny_method_threshold_ = Runtime::kDefaultTinyMethodThreshold;
+  parsed->num_dex_methods_threshold_ = Runtime::kDefaultNumDexMethodsThreshold;
 
   parsed->sea_ir_mode_ = false;
 //  gLogVerbosity.class_linker = true;  // TODO: don't check this in!
@@ -572,14 +575,28 @@ Runtime::ParsedOptions* Runtime::ParsedOptions::Create(const Options& options, b
       Trace::SetDefaultClockSource(kProfilerClockSourceWall);
     } else if (option == "-Xprofile:dualclock") {
       Trace::SetDefaultClockSource(kProfilerClockSourceDual);
-    } else if (option == "-small") {
-      parsed->small_mode_ = true;
+    } else if (option == "-compiler-filter:interpret-only") {
+      parsed->compiler_filter_ = kInterpretOnly;
+    } else if (option == "-compiler-filter:defer-compilation") {
+      parsed->compiler_filter_ = kDeferCompilation;
+    } else if (option == "-compiler-filter:space") {
+      parsed->compiler_filter_ = kSpace;
+    } else if (option == "-compiler-filter:balanced") {
+      parsed->compiler_filter_ = kBalanced;
+    } else if (option == "-compiler-filter:speed") {
+      parsed->compiler_filter_ = kSpeed;
     } else if (option == "-sea_ir") {
       parsed->sea_ir_mode_ = true;
-    } else if (StartsWith(option, "-small-mode-methods-max:")) {
-      parsed->small_mode_method_threshold_ = ParseIntegerOrDie(option);
-    } else if (StartsWith(option, "-small-mode-methods-size-max:")) {
-      parsed->small_mode_method_dex_size_limit_ = ParseIntegerOrDie(option);
+    } else if (StartsWith(option, "-huge-method-max:")) {
+      parsed->huge_method_threshold_ = ParseIntegerOrDie(option);
+    } else if (StartsWith(option, "-large-method-max:")) {
+      parsed->large_method_threshold_ = ParseIntegerOrDie(option);
+    } else if (StartsWith(option, "-small-method-max:")) {
+      parsed->small_method_threshold_ = ParseIntegerOrDie(option);
+    } else if (StartsWith(option, "-tiny-method-max:")) {
+      parsed->tiny_method_threshold_ = ParseIntegerOrDie(option);
+    } else if (StartsWith(option, "-num-dex-methods-max:")) {
+      parsed->num_dex_methods_threshold_ = ParseIntegerOrDie(option);
     } else {
       if (!ignore_unrecognized) {
         // TODO: print usage via vfprintf
@@ -809,9 +826,12 @@ bool Runtime::Init(const Options& raw_options, bool ignore_unrecognized) {
   is_zygote_ = options->is_zygote_;
   is_concurrent_gc_enabled_ = options->is_concurrent_gc_enabled_;
 
-  small_mode_ = options->small_mode_;
-  small_mode_method_threshold_ = options->small_mode_method_threshold_;
-  small_mode_method_dex_size_limit_ = options->small_mode_method_dex_size_limit_;
+  compiler_filter_ = options->compiler_filter_;
+  huge_method_threshold_ = options->huge_method_threshold_;
+  large_method_threshold_ = options->large_method_threshold_;
+  small_method_threshold_ = options->small_method_threshold_;
+  tiny_method_threshold_ = options->tiny_method_threshold_;
+  num_dex_methods_threshold_ = options->num_dex_methods_threshold_;
 
   sea_ir_mode_ = options->sea_ir_mode_;
   vfprintf_ = options->hook_vfprintf_;
diff --git a/runtime/runtime.h b/runtime/runtime.h
index 47fff29cb6..d67265a42d 100644
--- a/runtime/runtime.h
+++ b/runtime/runtime.h
@@ -63,15 +63,25 @@ class Runtime {
  public:
   typedef std::vector<std::pair<std::string, const void*> > Options;
 
-  // In small mode, apps with fewer than this number of methods will be compiled
-  // anyways.
-  // TODO: come up with a reasonable default.
-  static const size_t kDefaultSmallModeMethodThreshold = 0;
+  enum CompilerFilter {
+    kInterpretOnly,       // Compile nothing.
+    kDeferCompilation,    // Temporary minimal compilation, will redo during device idle time.
+    kSpace,               // Maximize space savings.
+    kBalanced,            // Try to get the best performance return on compilation investment.
+    kSpeed                // Compile all methods.
+  };
 
-  // In small mode, methods smaller than this dex op count limit will get compiled
-  // anyways.
-  // TODO: come up with a reasonable default.
-  static const size_t kDefaultSmallModeMethodDexSizeLimit = 300;
+  // Guide heuristics to determine whether to compile method if profile data not available.
+#if ART_SMALL_MODE
+  static const CompilerFilter kDefaultCompilerFilter = kInterpretOnly;
+#else
+  static const CompilerFilter kDefaultCompilerFilter = kSpeed;
+#endif
+  static const size_t kDefaultHugeMethodThreshold = 6000;
+  static const size_t kDefaultLargeMethodThreshold = 1000;
+  static const size_t kDefaultSmallMethodThreshold = 200;
+  static const size_t kDefaultTinyMethodThreshold = 10;
+  static const size_t kDefaultNumDexMethodsThreshold = 900;
 
   class ParsedOptions {
    public:
@@ -108,11 +118,12 @@ class Runtime {
     void (*hook_exit_)(jint status);
     void (*hook_abort_)();
     std::vector<std::string> properties_;
-    bool small_mode_;
-
-    size_t small_mode_method_threshold_;
-    size_t small_mode_method_dex_size_limit_;
-
+    CompilerFilter compiler_filter_;
+    size_t huge_method_threshold_;
+    size_t large_method_threshold_;
+    size_t small_method_threshold_;
+    size_t tiny_method_threshold_;
+    size_t num_dex_methods_threshold_;
     bool sea_ir_mode_;
 
    private:
@@ -145,21 +156,32 @@ class Runtime {
     sea_ir_mode_ = sea_ir_mode;
   }
 
-  bool IsSmallMode() const {
-      return small_mode_;
+  CompilerFilter GetCompilerFilter() const {
+    return compiler_filter_;
   }
 
+  void SetCompilerFilter(CompilerFilter compiler_filter) {
+    compiler_filter_ = compiler_filter;
+  }
+
+  size_t GetHugeMethodThreshold() const {
+    return huge_method_threshold_;
+  }
+
+  size_t GetLargeMethodThreshold() const {
+    return large_method_threshold_;
+  }
 
-  void SetSmallMode(bool small_mode) {
-      small_mode_ = small_mode;
+  size_t GetSmallMethodThreshold() const {
+    return small_method_threshold_;
   }
 
-  size_t GetSmallModeMethodThreshold() const {
-      return small_mode_method_threshold_;
+  size_t GetTinyMethodThreshold() const {
+    return tiny_method_threshold_;
   }
 
-  size_t GetSmallModeMethodDexSizeLimit() const {
-      return small_mode_method_dex_size_limit_;
+  size_t GetNumDexMethodsThreshold() const {
+      return num_dex_methods_threshold_;
   }
 
   const std::string& GetHostPrefix() const {
@@ -384,9 +406,12 @@ class Runtime {
   bool is_zygote_;
   bool is_concurrent_gc_enabled_;
 
-  bool small_mode_;
-  size_t small_mode_method_threshold_;
-  size_t small_mode_method_dex_size_limit_;
+  CompilerFilter compiler_filter_;
+  size_t huge_method_threshold_;
+  size_t large_method_threshold_;
+  size_t small_method_threshold_;
+  size_t tiny_method_threshold_;
+  size_t num_dex_methods_threshold_;
 
   bool sea_ir_mode_;
 
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index 9f0d911aa5..f1de565046 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -4180,16 +4180,7 @@ bool MethodVerifier::IsCandidateForCompilation(const DexFile::CodeItem* code_ite
   if (((access_flags & kAccConstructor) != 0) && ((access_flags & kAccStatic) != 0)) {
     return false;
   }
-
-  const Runtime* runtime = Runtime::Current();
-  if (runtime->IsSmallMode() && runtime->UseCompileTimeClassPath()) {
-    // In Small mode, we only compile small methods.
-    const uint32_t code_size = code_item->insns_size_in_code_units_;
-    return (code_size < runtime->GetSmallModeMethodDexSizeLimit());
-  } else {
-    // In normal mode, we compile everything.
-    return true;
-  }
+  return (Runtime::Current()->GetCompilerFilter() != Runtime::kInterpretOnly);
 }
 
 ReaderWriterMutex* MethodVerifier::dex_gc_maps_lock_ = NULL;
-- 
cgit v1.2.3-59-g8ed1b


From 155ecba1c9b56ce1b468135e6a591a3fe9258c52 Mon Sep 17 00:00:00 2001
From: buzbee <buzbee@google.com>
Date: Mon, 12 Aug 2013 16:15:53 -0700
Subject: Fix SMALL_ART

On all art builds, the images classes must be compiled.  When doing
a small art build, it is necessary to override the default compiler
filter to force compilation.  A merge mistake broke this logic
for dalvik-dev.

Change-Id: I88186bd89d0ccb4316ee0910e9324ddc3e6a1f75
---
 compiler/driver/compiler_driver.cc | 4 ----
 dex2oat/dex2oat.cc                 | 5 +++++
 2 files changed, 5 insertions(+), 4 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 56b629c576..ae001004df 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -2227,10 +2227,6 @@ void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t
   } else {
     bool compile = verifier::MethodVerifier::IsCandidateForCompilation(code_item, access_flags);
     if (compile) {
-      // If we're doing the image, override the compiler filter to force full compilation.
-      if ((image_classes_.get() != NULL) && (image_classes_->size() != 0)) {
-        Runtime::Current()->SetCompilerFilter(Runtime::kSpeed);
-      }
       CompilerFn compiler = compiler_;
 #ifdef ART_SEA_IR_MODE
       bool use_sea = Runtime::Current()->IsSeaIRMode();
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index b33997448e..b85378d9ec 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -905,6 +905,11 @@ static int dex2oat(int argc, char** argv) {
     }
   }
 
+  // If we're doing the image, override the compiler filter to force full compilation.
+  if (image && Runtime::Current()->GetCompilerFilter() == Runtime::kInterpretOnly) {
+    Runtime::Current()->SetCompilerFilter(Runtime::kSpeed);
+  }
+
   /*
    * If we're not in interpret-only mode, go ahead and compile small applications. Don't
    * bother to check if we're doing the image.
-- 
cgit v1.2.3-59-g8ed1b


From 67f99418f648c3a95256ed3dcd8e8b64eef0b372 Mon Sep 17 00:00:00 2001
From: Anwar Ghuloum <anwarg@google.com>
Date: Mon, 12 Aug 2013 14:19:48 -0700
Subject: Yet more timing logger cleanup

Some cleanup of timing logger placement, additional systrace placement for
threaded compilation work, tweaking/hiding of some type names per previous
review comments.

Change-Id: Ic7db2e02747282ac7f474b9a060df9803bfdfa5e
---
 compiler/driver/compiler_driver.cc | 11 ++++++++---
 runtime/base/timing_logger.cc      |  8 ++++----
 runtime/base/timing_logger.h       |  8 ++++----
 runtime/gc/heap.cc                 | 28 ++++++++++++----------------
 4 files changed, 28 insertions(+), 27 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index ae001004df..144271d581 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -16,8 +16,10 @@
 
 #include "compiler_driver.h"
 
-#include <vector>
+#define ATRACE_TAG ATRACE_TAG_DALVIK
+#include <utils/Trace.h>
 
+#include <vector>
 #include <unistd.h>
 
 #include "base/stl_util.h"
@@ -1562,14 +1564,14 @@ void CompilerDriver::Verify(jobject class_loader, const std::vector<const DexFil
 
 static void VerifyClass(const ParallelCompilationManager* manager, size_t class_def_index)
     LOCKS_EXCLUDED(Locks::mutator_lock_) {
+  ATRACE_CALL();
   ScopedObjectAccess soa(Thread::Current());
   const DexFile::ClassDef& class_def = manager->GetDexFile()->GetClassDef(class_def_index);
   const char* descriptor = manager->GetDexFile()->GetClassDescriptor(class_def);
   mirror::Class* klass =
       manager->GetClassLinker()->FindClass(descriptor,
                                            soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader()));
-  if (klass == NULL) {
-    CHECK(soa.Self()->IsExceptionPending());
+  if (klass == NULL) {    CHECK(soa.Self()->IsExceptionPending());
     soa.Self()->ClearException();
 
     /*
@@ -1600,6 +1602,7 @@ static void VerifyClass(const ParallelCompilationManager* manager, size_t class_
     soa.Self()->ClearException();
   }
 
+
   CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous())
       << PrettyDescriptor(klass) << ": state=" << klass->GetStatus();
   soa.Self()->AssertNoPendingException();
@@ -2135,6 +2138,7 @@ void CompilerDriver::Compile(jobject class_loader, const std::vector<const DexFi
 }
 
 void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, size_t class_def_index) {
+  ATRACE_CALL();
   jobject jclass_loader = manager->GetClassLoader();
   const DexFile& dex_file = *manager->GetDexFile();
   const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
@@ -2155,6 +2159,7 @@ void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, siz
     // empty class, probably a marker interface
     return;
   }
+
   // Can we run DEX-to-DEX compiler on this class ?
   DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile;
   {
diff --git a/runtime/base/timing_logger.cc b/runtime/base/timing_logger.cc
index 1dcad0ec91..11dc54271e 100644
--- a/runtime/base/timing_logger.cc
+++ b/runtime/base/timing_logger.cc
@@ -77,7 +77,7 @@ uint64_t CumulativeLogger::GetTotalTime() const {
 void CumulativeLogger::AddLogger(const base::TimingLogger &logger) {
   MutexLock mu(Thread::Current(), lock_);
   const base::TimingLogger::SplitTimings& splits = logger.GetSplits();
-  for (base::TimingLogger::SplitsIterator it = splits.begin(), end = splits.end();
+  for (base::TimingLogger::SplitTimingsIterator it = splits.begin(), end = splits.end();
        it != end; ++it) {
     base::TimingLogger::SplitTiming split = *it;
     uint64_t split_time = split.first;
@@ -155,7 +155,7 @@ void TimingLogger::NewSplit(const char* new_split_label) {
 
 uint64_t TimingLogger::GetTotalNs() const {
   uint64_t total_ns = 0;
-  for (base::TimingLogger::SplitsIterator it = splits_.begin(), end = splits_.end();
+  for (base::TimingLogger::SplitTimingsIterator it = splits_.begin(), end = splits_.end();
        it != end; ++it) {
     base::TimingLogger::SplitTiming split = *it;
     total_ns += split.first;
@@ -166,7 +166,7 @@ uint64_t TimingLogger::GetTotalNs() const {
 void TimingLogger::Dump(std::ostream &os) const {
   uint64_t longest_split = 0;
   uint64_t total_ns = 0;
-  for (base::TimingLogger::SplitsIterator it = splits_.begin(), end = splits_.end();
+  for (base::TimingLogger::SplitTimingsIterator it = splits_.begin(), end = splits_.end();
        it != end; ++it) {
     base::TimingLogger::SplitTiming split = *it;
     uint64_t split_time = split.first;
@@ -177,7 +177,7 @@ void TimingLogger::Dump(std::ostream &os) const {
   TimeUnit tu = GetAppropriateTimeUnit(longest_split);
   uint64_t divisor = GetNsToTimeUnitDivisor(tu);
   // Print formatted splits.
-  for (base::TimingLogger::SplitsIterator it = splits_.begin(), end = splits_.end();
+  for (base::TimingLogger::SplitTimingsIterator it = splits_.begin(), end = splits_.end();
        it != end; ++it) {
     base::TimingLogger::SplitTiming split = *it;
     uint64_t split_time = split.first;
diff --git a/runtime/base/timing_logger.h b/runtime/base/timing_logger.h
index 777d3f09ae..07d1ee00e0 100644
--- a/runtime/base/timing_logger.h
+++ b/runtime/base/timing_logger.h
@@ -33,9 +33,6 @@ namespace base {
 
 class CumulativeLogger {
  public:
-  typedef std::map<std::string, Histogram<uint64_t> *> Histograms;
-  typedef std::map<std::string, Histogram<uint64_t> *>::const_iterator HistogramsIterator;
-
   explicit CumulativeLogger(const std::string& name);
   void prepare_stats();
   ~CumulativeLogger();
@@ -50,6 +47,9 @@ class CumulativeLogger {
   void AddLogger(const base::TimingLogger& logger) LOCKS_EXCLUDED(lock_);
 
  private:
+  typedef std::map<std::string, Histogram<uint64_t> *> Histograms;
+  typedef std::map<std::string, Histogram<uint64_t> *>::const_iterator HistogramsIterator;
+
   void AddPair(const std::string &label, uint64_t delta_time)
       EXCLUSIVE_LOCKS_REQUIRED(lock_);
   void DumpHistogram(std::ostream &os) EXCLUSIVE_LOCKS_REQUIRED(lock_);
@@ -73,7 +73,7 @@ class TimingLogger {
   // Splits are nanosecond times and split names.
   typedef std::pair<uint64_t, const char*> SplitTiming;
   typedef std::vector<SplitTiming> SplitTimings;
-  typedef std::vector<SplitTiming>::const_iterator SplitsIterator;
+  typedef std::vector<SplitTiming>::const_iterator SplitTimingsIterator;
 
   explicit TimingLogger(const char* name, bool precise, bool verbose);
 
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index 6dcdab9b60..df1f3fe92e 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -1171,6 +1171,12 @@ void Heap::MarkAllocStack(accounting::SpaceBitmap* bitmap, accounting::SpaceSetM
   }
 }
 
+
+const char* gc_cause_and_type_strings[3][4] = {
+    {"", "GC Alloc Sticky", "GC Alloc Partial", "GC Alloc Full"},
+    {"", "GC Background Sticky", "GC Background Partial", "GC Background Full"},
+    {"", "GC Explicit Sticky", "GC Explicit Partial", "GC Explicit Full"}};
+
 collector::GcType Heap::CollectGarbageInternal(collector::GcType gc_type, GcCause gc_cause,
                                                bool clear_soft_references) {
   Thread* self = Thread::Current();
@@ -1225,20 +1231,12 @@ collector::GcType Heap::CollectGarbageInternal(collector::GcType gc_type, GcCaus
     gc_type = collector::kGcTypePartial;
   }
 
-  switch (gc_cause) {
-    case kGcCauseForAlloc:
-      ATRACE_BEGIN("GC (alloc)");
-      break;
-    case kGcCauseBackground:
-      ATRACE_BEGIN("GC (background)");
-      break;
-    case kGcCauseExplicit:
-      ATRACE_BEGIN("GC (explicit)");
-      break;
-  }
-
   DCHECK_LT(gc_type, collector::kGcTypeMax);
   DCHECK_NE(gc_type, collector::kGcTypeNone);
+  DCHECK_LE(gc_cause, kGcCauseExplicit);
+
+  ATRACE_BEGIN(gc_cause_and_type_strings[gc_cause][gc_type]);
+
   collector::MarkSweep* collector = NULL;
   typedef std::vector<collector::MarkSweep*>::iterator It;
   for (It it = mark_sweep_collectors_.begin(), end = mark_sweep_collectors_.end();
@@ -1658,11 +1656,10 @@ void Heap::PreGcVerification(collector::GarbageCollector* gc) {
 }
 
 void Heap::PreSweepingGcVerification(collector::GarbageCollector* gc) {
-  ThreadList* thread_list = Runtime::Current()->GetThreadList();
-
   // Called before sweeping occurs since we want to make sure we are not going so reclaim any
   // reachable objects.
   if (verify_post_gc_heap_) {
+    ThreadList* thread_list = Runtime::Current()->GetThreadList();
     Thread* self = Thread::Current();
     CHECK_NE(self->GetState(), kRunnable);
     Locks::mutator_lock_->SharedUnlock(self);
@@ -1682,9 +1679,8 @@ void Heap::PreSweepingGcVerification(collector::GarbageCollector* gc) {
 }
 
 void Heap::PostGcVerification(collector::GarbageCollector* gc) {
-  Thread* self = Thread::Current();
-
   if (verify_system_weaks_) {
+    Thread* self = Thread::Current();
     ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
     collector::MarkSweep* mark_sweep = down_cast<collector::MarkSweep*>(gc);
     mark_sweep->VerifySystemWeaks();
-- 
cgit v1.2.3-59-g8ed1b


From ea46f950e7a51585db293cd7f047de190a482414 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Tue, 30 Jul 2013 01:26:50 -0700
Subject: Refactor java.lang.reflect implementation

Cherry-picked from commit ed41d5c44299ec5d44b8514f6e17f802f48094d1.

Move to ArtMethod/Field instead of AbstractMethod/Field and have
java.lang.reflect APIs delegate to ArtMethod/ArtField.

Bug: 10014286.

Change-Id: Iafc1d8c5b62562c9af8fb9fd8c5e1d61270536e7
---
 compiler/dex/dex_to_dex_compiler.cc                |   4 +-
 compiler/dex/quick/gen_common.cc                   |  26 +-
 compiler/dex/quick/gen_invoke.cc                   |  10 +-
 compiler/driver/compiler_driver.cc                 |  34 +-
 compiler/driver/compiler_driver.h                  |   6 +-
 compiler/driver/compiler_driver_test.cc            |   6 +-
 compiler/elf_writer.cc                             |   2 +-
 compiler/elf_writer_mclinker.cc                    |   6 +-
 compiler/image_writer.cc                           |  46 +-
 compiler/image_writer.h                            |   2 +-
 compiler/jni/jni_compiler_test.cc                  |   4 +-
 compiler/jni/portable/jni_compiler.cc              |   6 +-
 compiler/jni/portable/jni_compiler.h               |   2 +-
 compiler/jni/quick/jni_compiler.cc                 |   4 +-
 compiler/llvm/compiler_llvm.h                      |   2 +-
 compiler/llvm/gbc_expander.cc                      |  20 +-
 compiler/oat_writer.cc                             |   4 +-
 dex2oat/dex2oat.cc                                 |   4 +-
 oatdump/oatdump.cc                                 |  46 +-
 runtime/Android.mk                                 |   4 +-
 runtime/arch/arm/context_arm.cc                    |   4 +-
 runtime/arch/arm/entrypoints_init_arm.cc           |   8 +-
 runtime/arch/mips/context_mips.cc                  |   4 +-
 runtime/arch/mips/entrypoints_init_mips.cc         |   8 +-
 runtime/arch/x86/context_x86.cc                    |   4 +-
 runtime/arch/x86/entrypoints_init_x86.cc           |   8 +-
 runtime/check_jni.cc                               |  38 +-
 runtime/class_linker-inl.h                         |  48 +--
 runtime/class_linker.cc                            | 379 +++++++----------
 runtime/class_linker.h                             | 103 +++--
 runtime/class_linker_test.cc                       | 470 ++++++++++----------
 runtime/common_test.h                              |  10 +-
 runtime/common_throws.cc                           |  51 +--
 runtime/common_throws.h                            |  34 +-
 runtime/debugger.cc                                | 110 ++---
 runtime/debugger.h                                 |  10 +-
 runtime/dex_file.cc                                |   9 +-
 runtime/dex_file.h                                 |  12 +-
 runtime/entrypoints/entrypoint_utils.cc            |  46 +-
 runtime/entrypoints/entrypoint_utils.h             |  52 +--
 .../interpreter/interpreter_entrypoints.cc         |   4 +-
 runtime/entrypoints/jni/jni_entrypoints.cc         |   6 +-
 .../portable/portable_alloc_entrypoints.cc         |  14 +-
 .../portable/portable_dexcache_entrypoints.cc      |  10 +-
 .../entrypoints/portable/portable_entrypoints.h    |   6 +-
 .../portable/portable_field_entrypoints.cc         |  60 +--
 .../portable/portable_fillarray_entrypoints.cc     |   4 +-
 .../portable/portable_invoke_entrypoints.cc        |  20 +-
 .../portable/portable_jni_entrypoints.cc           |   2 +-
 .../portable/portable_thread_entrypoints.cc        |   6 +-
 .../portable/portable_throw_entrypoints.cc         |   4 +-
 .../portable/portable_trampoline_entrypoints.cc    |  24 +-
 runtime/entrypoints/quick/callee_save_frame.h      |   4 +-
 .../entrypoints/quick/quick_alloc_entrypoints.cc   |  26 +-
 .../entrypoints/quick/quick_cast_entrypoints.cc    |   4 +-
 .../quick/quick_deoptimization_entrypoints.cc      |   4 +-
 .../quick/quick_dexcache_entrypoints.cc            |  18 +-
 runtime/entrypoints/quick/quick_entrypoints.h      |  10 +-
 .../entrypoints/quick/quick_field_entrypoints.cc   | 112 ++---
 .../quick/quick_fillarray_entrypoints.cc           |   2 +-
 .../quick/quick_instrumentation_entrypoints.cc     |  10 +-
 .../entrypoints/quick/quick_invoke_entrypoints.cc  |  36 +-
 runtime/entrypoints/quick/quick_jni_entrypoints.cc |   2 +-
 .../entrypoints/quick/quick_lock_entrypoints.cc    |   4 +-
 .../entrypoints/quick/quick_thread_entrypoints.cc  |   2 +-
 .../entrypoints/quick/quick_throw_entrypoints.cc   |  14 +-
 .../quick/quick_trampoline_entrypoints.cc          |  32 +-
 runtime/exception_test.cc                          |   4 +-
 runtime/gc/accounting/mod_union_table.cc           |   2 +-
 runtime/gc/accounting/space_bitmap.cc              |  10 +-
 runtime/gc/collector/mark_sweep-inl.h              |   6 +-
 runtime/gc/collector/mark_sweep.cc                 |  10 +-
 runtime/gc/heap.cc                                 |   8 +-
 runtime/gc/space/image_space.cc                    |  10 +-
 runtime/hprof/hprof.cc                             |   9 +-
 runtime/instrumentation.cc                         |  32 +-
 runtime/instrumentation.h                          |  52 +--
 runtime/interpreter/interpreter.cc                 |  70 +--
 runtime/interpreter/interpreter.h                  |   6 +-
 runtime/invoke_arg_array_builder.h                 |   2 +-
 runtime/jdwp/jdwp.h                                |   2 +-
 runtime/jdwp/object_registry.h                     |   2 +-
 runtime/jni_internal.cc                            | 120 ++++--
 runtime/jni_internal.h                             |  12 +-
 runtime/jni_internal_test.cc                       | 110 +++--
 runtime/mirror/abstract_method-inl.h               | 203 ---------
 runtime/mirror/abstract_method.cc                  | 350 ---------------
 runtime/mirror/abstract_method.h                   | 471 ---------------------
 runtime/mirror/art_field-inl.h                     | 221 ++++++++++
 runtime/mirror/art_field.cc                        |  56 +++
 runtime/mirror/art_field.h                         | 165 ++++++++
 runtime/mirror/art_method-inl.h                    | 203 +++++++++
 runtime/mirror/art_method.cc                       | 342 +++++++++++++++
 runtime/mirror/art_method.h                        | 457 ++++++++++++++++++++
 runtime/mirror/class-inl.h                         |  87 ++--
 runtime/mirror/class.cc                            |  97 +++--
 runtime/mirror/class.h                             | 102 ++---
 runtime/mirror/dex_cache-inl.h                     |   4 +-
 runtime/mirror/dex_cache.cc                        |  12 +-
 runtime/mirror/dex_cache.h                         |  30 +-
 runtime/mirror/field-inl.h                         | 221 ----------
 runtime/mirror/field.cc                            |  56 ---
 runtime/mirror/field.h                             | 168 --------
 runtime/mirror/iftable.h                           |  12 +-
 runtime/mirror/object-inl.h                        |  40 +-
 runtime/mirror/object.cc                           |  14 +-
 runtime/mirror/object.h                            |  16 +-
 runtime/mirror/object_array-inl.h                  |   2 +-
 runtime/mirror/object_test.cc                      |  40 +-
 runtime/mirror/throwable.cc                        |   4 +-
 runtime/monitor.cc                                 |  10 +-
 runtime/monitor.h                                  |   8 +-
 runtime/monitor_android.cc                         |   2 +-
 runtime/native/dalvik_system_VMStack.cc            |   2 +-
 runtime/native/java_lang_reflect_Constructor.cc    |  10 +-
 runtime/native/java_lang_reflect_Field.cc          |  23 +-
 runtime/native/java_lang_reflect_Method.cc         |  23 +-
 runtime/native/java_lang_reflect_Proxy.cc          |   6 +-
 runtime/nth_caller_visitor.h                       |   6 +-
 runtime/oat_file.cc                                |   6 +-
 runtime/oat_file.h                                 |   4 +-
 runtime/oat_test.cc                                |   4 +-
 runtime/object_utils.h                             |  26 +-
 runtime/reflection.cc                              |  17 +-
 runtime/reflection.h                               |  12 +-
 runtime/runtime.cc                                 |  29 +-
 runtime/runtime.h                                  |  22 +-
 runtime/scoped_thread_state_change.h               |  12 +-
 runtime/stack.cc                                   |  29 +-
 runtime/stack.h                                    |  38 +-
 runtime/thread.cc                                  |  54 +--
 runtime/thread.h                                   |   6 +-
 runtime/throw_location.cc                          |   2 +-
 runtime/throw_location.h                           |   8 +-
 runtime/trace.cc                                   |  34 +-
 runtime/trace.h                                    |  18 +-
 runtime/utils.cc                                   |  13 +-
 runtime/utils.h                                    |  12 +-
 runtime/utils_test.cc                              |   4 +-
 runtime/verifier/method_verifier.cc                |  80 ++--
 runtime/verifier/method_verifier.h                 |  43 +-
 runtime/well_known_classes.cc                      |  24 +-
 runtime/well_known_classes.h                       |  11 +-
 test/046-reflect/expected.txt                      |   9 +-
 test/046-reflect/src/Main.java                     |  43 +-
 test/100-reflect2/expected.txt                     |   2 +-
 test/ReferenceMap/stack_walk_refmap_jni.cc         |   6 +-
 test/StackWalk/stack_walk_jni.cc                   |   6 +-
 148 files changed, 3300 insertions(+), 3290 deletions(-)
 delete mode 100644 runtime/mirror/abstract_method-inl.h
 delete mode 100644 runtime/mirror/abstract_method.cc
 delete mode 100644 runtime/mirror/abstract_method.h
 create mode 100644 runtime/mirror/art_field-inl.h
 create mode 100644 runtime/mirror/art_field.cc
 create mode 100644 runtime/mirror/art_field.h
 create mode 100644 runtime/mirror/art_method-inl.h
 create mode 100644 runtime/mirror/art_method.cc
 create mode 100644 runtime/mirror/art_method.h
 delete mode 100644 runtime/mirror/field-inl.h
 delete mode 100644 runtime/mirror/field.cc
 delete mode 100644 runtime/mirror/field.h

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/dex/dex_to_dex_compiler.cc b/compiler/dex/dex_to_dex_compiler.cc
index 60e638c584..a0e2c1e9aa 100644
--- a/compiler/dex/dex_to_dex_compiler.cc
+++ b/compiler/dex/dex_to_dex_compiler.cc
@@ -20,10 +20,10 @@
 #include "dex_instruction-inl.h"
 #include "driver/compiler_driver.h"
 #include "driver/dex_compilation_unit.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/dex_cache.h"
-#include "mirror/field-inl.h"
 
 namespace art {
 namespace optimizer {
diff --git a/compiler/dex/quick/gen_common.cc b/compiler/dex/quick/gen_common.cc
index 298d3898c8..e5c7fb150e 100644
--- a/compiler/dex/quick/gen_common.cc
+++ b/compiler/dex/quick/gen_common.cc
@@ -347,7 +347,7 @@ void Mir2Lir::GenSput(uint32_t field_idx, RegLocation rl_src, bool is_long_or_do
       RegLocation rl_method  = LoadCurrMethod();
       rBase = AllocTemp();
       LoadWordDisp(rl_method.low_reg,
-                   mirror::AbstractMethod::DeclaringClassOffset().Int32Value(), rBase);
+                   mirror::ArtMethod::DeclaringClassOffset().Int32Value(), rBase);
       if (IsTemp(rl_method.low_reg)) {
         FreeTemp(rl_method.low_reg);
       }
@@ -365,7 +365,7 @@ void Mir2Lir::GenSput(uint32_t field_idx, RegLocation rl_src, bool is_long_or_do
       rBase = TargetReg(kArg0);
       LockTemp(rBase);
       LoadWordDisp(r_method,
-                   mirror::AbstractMethod::DexCacheInitializedStaticStorageOffset().Int32Value(),
+                   mirror::ArtMethod::DexCacheInitializedStaticStorageOffset().Int32Value(),
                    rBase);
       LoadWordDisp(rBase,
                    mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value() +
@@ -433,7 +433,7 @@ void Mir2Lir::GenSget(uint32_t field_idx, RegLocation rl_dest,
       RegLocation rl_method  = LoadCurrMethod();
       rBase = AllocTemp();
       LoadWordDisp(rl_method.low_reg,
-                   mirror::AbstractMethod::DeclaringClassOffset().Int32Value(), rBase);
+                   mirror::ArtMethod::DeclaringClassOffset().Int32Value(), rBase);
     } else {
       // Medium path, static storage base in a different class which requires checks that the other
       // class is initialized
@@ -448,7 +448,7 @@ void Mir2Lir::GenSget(uint32_t field_idx, RegLocation rl_dest,
       rBase = TargetReg(kArg0);
       LockTemp(rBase);
       LoadWordDisp(r_method,
-                   mirror::AbstractMethod::DexCacheInitializedStaticStorageOffset().Int32Value(),
+                   mirror::ArtMethod::DexCacheInitializedStaticStorageOffset().Int32Value(),
                    rBase);
       LoadWordDisp(rBase, mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value() +
                    sizeof(int32_t*) * ssb_index, rBase);
@@ -746,7 +746,7 @@ void Mir2Lir::GenConstClass(uint32_t type_idx, RegLocation rl_dest) {
   } else {
     // We're don't need access checks, load type from dex cache
     int32_t dex_cache_offset =
-        mirror::AbstractMethod::DexCacheResolvedTypesOffset().Int32Value();
+        mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value();
     LoadWordDisp(rl_method.low_reg, dex_cache_offset, res_reg);
     int32_t offset_of_type =
         mirror::Array::DataOffset(sizeof(mirror::Class*)).Int32Value() + (sizeof(mirror::Class*)
@@ -799,7 +799,7 @@ void Mir2Lir::GenConstString(uint32_t string_idx, RegLocation rl_dest) {
     LockCallTemps();  // Using explicit registers
     LoadCurrMethodDirect(TargetReg(kArg2));
     LoadWordDisp(TargetReg(kArg2),
-                 mirror::AbstractMethod::DexCacheStringsOffset().Int32Value(), TargetReg(kArg0));
+                 mirror::ArtMethod::DexCacheStringsOffset().Int32Value(), TargetReg(kArg0));
     // Might call out to helper, which will return resolved string in kRet0
     int r_tgt = CallHelperSetup(QUICK_ENTRYPOINT_OFFSET(pResolveString));
     LoadWordDisp(TargetReg(kArg0), offset_of_string, TargetReg(kRet0));
@@ -835,7 +835,7 @@ void Mir2Lir::GenConstString(uint32_t string_idx, RegLocation rl_dest) {
     int res_reg = AllocTemp();
     RegLocation rl_result = EvalLoc(rl_dest, kCoreReg, true);
     LoadWordDisp(rl_method.low_reg,
-                 mirror::AbstractMethod::DexCacheStringsOffset().Int32Value(), res_reg);
+                 mirror::ArtMethod::DexCacheStringsOffset().Int32Value(), res_reg);
     LoadWordDisp(res_reg, offset_of_string, rl_result.low_reg);
     StoreValue(rl_dest, rl_result);
   }
@@ -884,11 +884,11 @@ void Mir2Lir::GenInstanceofFinal(bool use_declaring_class, uint32_t type_idx, Re
 
   LoadCurrMethodDirect(check_class);
   if (use_declaring_class) {
-    LoadWordDisp(check_class, mirror::AbstractMethod::DeclaringClassOffset().Int32Value(),
+    LoadWordDisp(check_class, mirror::ArtMethod::DeclaringClassOffset().Int32Value(),
                  check_class);
     LoadWordDisp(object.low_reg,  mirror::Object::ClassOffset().Int32Value(), object_class);
   } else {
-    LoadWordDisp(check_class, mirror::AbstractMethod::DexCacheResolvedTypesOffset().Int32Value(),
+    LoadWordDisp(check_class, mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value(),
                  check_class);
     LoadWordDisp(object.low_reg,  mirror::Object::ClassOffset().Int32Value(), object_class);
     int32_t offset_of_type =
@@ -940,12 +940,12 @@ void Mir2Lir::GenInstanceofCallingHelper(bool needs_access_check, bool type_know
   } else if (use_declaring_class) {
     LoadValueDirectFixed(rl_src, TargetReg(kArg0));  // kArg0 <= ref
     LoadWordDisp(TargetReg(kArg1),
-                 mirror::AbstractMethod::DeclaringClassOffset().Int32Value(), class_reg);
+                 mirror::ArtMethod::DeclaringClassOffset().Int32Value(), class_reg);
   } else {
     // Load dex cache entry into class_reg (kArg2)
     LoadValueDirectFixed(rl_src, TargetReg(kArg0));  // kArg0 <= ref
     LoadWordDisp(TargetReg(kArg1),
-                 mirror::AbstractMethod::DexCacheResolvedTypesOffset().Int32Value(), class_reg);
+                 mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value(), class_reg);
     int32_t offset_of_type =
         mirror::Array::DataOffset(sizeof(mirror::Class*)).Int32Value() + (sizeof(mirror::Class*)
         * type_idx);
@@ -1078,11 +1078,11 @@ void Mir2Lir::GenCheckCast(uint32_t insn_idx, uint32_t type_idx, RegLocation rl_
     OpRegCopy(class_reg, TargetReg(kRet0));  // Align usage with fast path
   } else if (use_declaring_class) {
     LoadWordDisp(TargetReg(kArg1),
-                 mirror::AbstractMethod::DeclaringClassOffset().Int32Value(), class_reg);
+                 mirror::ArtMethod::DeclaringClassOffset().Int32Value(), class_reg);
   } else {
     // Load dex cache entry into class_reg (kArg2)
     LoadWordDisp(TargetReg(kArg1),
-                 mirror::AbstractMethod::DexCacheResolvedTypesOffset().Int32Value(), class_reg);
+                 mirror::ArtMethod::DexCacheResolvedTypesOffset().Int32Value(), class_reg);
     int32_t offset_of_type =
         mirror::Array::DataOffset(sizeof(mirror::Class*)).Int32Value() +
         (sizeof(mirror::Class*) * type_idx);
diff --git a/compiler/dex/quick/gen_invoke.cc b/compiler/dex/quick/gen_invoke.cc
index 20d683a947..073b550d78 100644
--- a/compiler/dex/quick/gen_invoke.cc
+++ b/compiler/dex/quick/gen_invoke.cc
@@ -365,7 +365,7 @@ static int NextSDCallInsn(CompilationUnit* cu, CallInfo* info,
       break;
     case 1:  // Get method->dex_cache_resolved_methods_
       cg->LoadWordDisp(cg->TargetReg(kArg0),
-        mirror::AbstractMethod::DexCacheResolvedMethodsOffset().Int32Value(), cg->TargetReg(kArg0));
+        mirror::ArtMethod::DexCacheResolvedMethodsOffset().Int32Value(), cg->TargetReg(kArg0));
       // Set up direct code if known.
       if (direct_code != 0) {
         if (direct_code != static_cast<unsigned int>(-1)) {
@@ -395,7 +395,7 @@ static int NextSDCallInsn(CompilationUnit* cu, CallInfo* info,
       if (cu->instruction_set != kX86) {
         if (direct_code == 0) {
           cg->LoadWordDisp(cg->TargetReg(kArg0),
-                           mirror::AbstractMethod::GetEntryPointFromCompiledCodeOffset().Int32Value(),
+                           mirror::ArtMethod::GetEntryPointFromCompiledCodeOffset().Int32Value(),
                            cg->TargetReg(kInvokeTgt));
         }
         break;
@@ -448,7 +448,7 @@ static int NextVCallInsn(CompilationUnit* cu, CallInfo* info,
     case 4:  // Get the compiled code address [uses kArg0, sets kInvokeTgt]
       if (cu->instruction_set != kX86) {
         cg->LoadWordDisp(cg->TargetReg(kArg0),
-                         mirror::AbstractMethod::GetEntryPointFromCompiledCodeOffset().Int32Value(),
+                         mirror::ArtMethod::GetEntryPointFromCompiledCodeOffset().Int32Value(),
                          cg->TargetReg(kInvokeTgt));
         break;
       }
@@ -514,7 +514,7 @@ static int NextInterfaceCallInsn(CompilationUnit* cu, CallInfo* info, int state,
         break;
     case 1:  // Get method->dex_cache_resolved_methods_ [set/use kArg0]
       cg->LoadWordDisp(cg->TargetReg(kArg0),
-                       mirror::AbstractMethod::DexCacheResolvedMethodsOffset().Int32Value(),
+                       mirror::ArtMethod::DexCacheResolvedMethodsOffset().Int32Value(),
                        cg->TargetReg(kArg0));
       break;
     case 2:  // Grab target method* [set/use kArg0]
@@ -1407,7 +1407,7 @@ void Mir2Lir::GenInvoke(CallInfo* info) {
   } else {
     if (fast_path && info->type != kInterface) {
       call_inst = OpMem(kOpBlx, TargetReg(kArg0),
-                        mirror::AbstractMethod::GetEntryPointFromCompiledCodeOffset().Int32Value());
+                        mirror::ArtMethod::GetEntryPointFromCompiledCodeOffset().Int32Value());
     } else {
       ThreadOffset trampoline(-1);
       switch (info->type) {
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 144271d581..82f51f200a 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -33,11 +33,11 @@
 #include "gc/accounting/card_table-inl.h"
 #include "gc/accounting/heap_bitmap.h"
 #include "gc/space/space.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class_loader.h"
 #include "mirror/class-inl.h"
 #include "mirror/dex_cache-inl.h"
-#include "mirror/field-inl.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/throwable.h"
@@ -515,7 +515,7 @@ static DexToDexCompilationLevel GetDexToDexCompilationlevel(mirror::ClassLoader*
   }
 }
 
-void CompilerDriver::CompileOne(const mirror::AbstractMethod* method, base::TimingLogger& timings) {
+void CompilerDriver::CompileOne(const mirror::ArtMethod* method, base::TimingLogger& timings) {
   DCHECK(!Runtime::Current()->IsStarted());
   Thread* self = Thread::Current();
   jobject jclass_loader;
@@ -632,12 +632,12 @@ static bool ResolveCatchBlockExceptionsClassVisitor(mirror::Class* c, void* arg)
       reinterpret_cast<std::set<std::pair<uint16_t, const DexFile*> >*>(arg);
   MethodHelper mh;
   for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
-    mirror::AbstractMethod* m = c->GetVirtualMethod(i);
+    mirror::ArtMethod* m = c->GetVirtualMethod(i);
     mh.ChangeMethod(m);
     ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
   }
   for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
-    mirror::AbstractMethod* m = c->GetDirectMethod(i);
+    mirror::ArtMethod* m = c->GetDirectMethod(i);
     mh.ChangeMethod(m);
     ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
   }
@@ -895,7 +895,7 @@ static mirror::Class* ComputeCompilingMethodsClass(ScopedObjectAccess& soa,
                                               dex_cache, class_loader);
 }
 
-static mirror::Field* ComputeFieldReferencedFromCompilingMethod(ScopedObjectAccess& soa,
+static mirror::ArtField* ComputeFieldReferencedFromCompilingMethod(ScopedObjectAccess& soa,
                                                                 const DexCompilationUnit* mUnit,
                                                                 uint32_t field_idx)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -905,7 +905,7 @@ static mirror::Field* ComputeFieldReferencedFromCompilingMethod(ScopedObjectAcce
                                                class_loader, false);
 }
 
-static mirror::AbstractMethod* ComputeMethodReferencedFromCompilingMethod(ScopedObjectAccess& soa,
+static mirror::ArtMethod* ComputeMethodReferencedFromCompilingMethod(ScopedObjectAccess& soa,
                                                                           const DexCompilationUnit* mUnit,
                                                                           uint32_t method_idx,
                                                                           InvokeType type)
@@ -923,7 +923,7 @@ bool CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompi
   field_offset = -1;
   is_volatile = true;
   // Try to resolve field and ignore if an Incompatible Class Change Error (ie is static).
-  mirror::Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
+  mirror::ArtField* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
   if (resolved_field != NULL && !resolved_field->IsStatic()) {
     mirror::Class* referrer_class =
         ComputeCompilingMethodsClass(soa, resolved_field->GetDeclaringClass()->GetDexCache(),
@@ -974,7 +974,7 @@ bool CompilerDriver::ComputeStaticFieldInfo(uint32_t field_idx, const DexCompila
   is_referrers_class = false;
   is_volatile = true;
   // Try to resolve field and ignore if an Incompatible Class Change Error (ie isn't static).
-  mirror::Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
+  mirror::ArtField* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
   if (resolved_field != NULL && resolved_field->IsStatic()) {
     mirror::Class* referrer_class =
         ComputeCompilingMethodsClass(soa, resolved_field->GetDeclaringClass()->GetDexCache(),
@@ -1051,7 +1051,7 @@ bool CompilerDriver::ComputeStaticFieldInfo(uint32_t field_idx, const DexCompila
 
 void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type,
                                                    mirror::Class* referrer_class,
-                                                   mirror::AbstractMethod* method,
+                                                   mirror::ArtMethod* method,
                                                    uintptr_t& direct_code,
                                                    uintptr_t& direct_method,
                                                    bool update_stats) {
@@ -1114,7 +1114,7 @@ bool CompilerDriver::ComputeInvokeInfo(const DexCompilationUnit* mUnit, const ui
   vtable_idx = -1;
   direct_code = 0;
   direct_method = 0;
-  mirror::AbstractMethod* resolved_method =
+  mirror::ArtMethod* resolved_method =
       ComputeMethodReferencedFromCompilingMethod(soa, mUnit, target_method.dex_method_index,
                                                  invoke_type);
   if (resolved_method != NULL) {
@@ -1179,7 +1179,7 @@ bool CompilerDriver::ComputeInvokeInfo(const DexCompilationUnit* mUnit, const ui
                 mUnit->GetClassLinker()->FindDexCache(*devirt_map_target->dex_file);
             mirror::ClassLoader* class_loader =
                 soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader());
-            mirror::AbstractMethod* called_method =
+            mirror::ArtMethod* called_method =
                 mUnit->GetClassLinker()->ResolveMethod(*devirt_map_target->dex_file,
                                                        devirt_map_target->dex_method_index,
                                                        target_dex_cache, class_loader, NULL,
@@ -1471,7 +1471,7 @@ static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manag
   mirror::DexCache* dex_cache = class_linker->FindDexCache(dex_file);
   ClassDataItemIterator it(dex_file, class_data);
   while (it.HasNextStaticField()) {
-    mirror::Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
+    mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
                                                       class_loader, true);
     if (field == NULL) {
       CHECK(self->IsExceptionPending());
@@ -1487,7 +1487,7 @@ static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manag
       requires_constructor_barrier = true;
     }
 
-    mirror::Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
+    mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
                                                       class_loader, false);
     if (field == NULL) {
       CHECK(self->IsExceptionPending());
@@ -1500,7 +1500,7 @@ static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manag
                                                           class_def_index);
   }
   while (it.HasNextDirectMethod()) {
-    mirror::AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
+    mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
                                                                  dex_cache, class_loader, NULL,
                                                                  it.GetMethodInvokeType(class_def));
     if (method == NULL) {
@@ -1510,7 +1510,7 @@ static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manag
     it.Next();
   }
   while (it.HasNextVirtualMethod()) {
-    mirror::AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
+    mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
                                                                  dex_cache, class_loader, NULL,
                                                                  it.GetMethodInvokeType(class_def));
     if (method == NULL) {
@@ -2073,7 +2073,7 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
             LOG(INFO) << "Initializing: " << descriptor;
             if (StringPiece(descriptor) == "Ljava/lang/Void;") {
               // Hand initialize j.l.Void to avoid Dex file operations in un-started runtime.
-              mirror::ObjectArray<mirror::Field>* fields = klass->GetSFields();
+              mirror::ObjectArray<mirror::ArtField>* fields = klass->GetSFields();
               CHECK_EQ(fields->GetLength(), 1);
               fields->Get(0)->SetObj(klass, manager->GetClassLinker()->FindPrimitiveClass('V'));
               klass->SetStatus(mirror::Class::kStatusInitialized);
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index b5222c99b8..21a44eaf12 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -99,7 +99,7 @@ class CompilerDriver {
       LOCKS_EXCLUDED(Locks::mutator_lock_);
 
   // Compile a single Method
-  void CompileOne(const mirror::AbstractMethod* method, base::TimingLogger& timings)
+  void CompileOne(const mirror::ArtMethod* method, base::TimingLogger& timings)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   InstructionSet GetInstructionSet() const {
@@ -301,7 +301,7 @@ class CompilerDriver {
   // Compute constant code and method pointers when possible
   void GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type,
                                      mirror::Class* referrer_class,
-                                     mirror::AbstractMethod* method,
+                                     mirror::ArtMethod* method,
                                      uintptr_t& direct_code, uintptr_t& direct_method,
                                      bool update_stats)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -425,7 +425,7 @@ class CompilerDriver {
   CompilerEnableAutoElfLoadingFn compiler_enable_auto_elf_loading_;
 
   typedef const void* (*CompilerGetMethodCodeAddrFn)
-      (const CompilerDriver& driver, const CompiledMethod* cm, const mirror::AbstractMethod* method);
+      (const CompilerDriver& driver, const CompiledMethod* cm, const mirror::ArtMethod* method);
   CompilerGetMethodCodeAddrFn compiler_get_method_code_addr_;
 
   bool support_boot_image_fixup_;
diff --git a/compiler/driver/compiler_driver_test.cc b/compiler/driver/compiler_driver_test.cc
index 8ee9cf6442..c6687bb4aa 100644
--- a/compiler/driver/compiler_driver_test.cc
+++ b/compiler/driver/compiler_driver_test.cc
@@ -24,10 +24,10 @@
 #include "common_test.h"
 #include "dex_file.h"
 #include "gc/heap.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class.h"
 #include "mirror/class-inl.h"
 #include "mirror/dex_cache-inl.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/object-inl.h"
 
@@ -115,7 +115,7 @@ TEST_F(CompilerDriverTest, DISABLED_LARGE_CompileDexLibCore) {
   }
   EXPECT_EQ(dex->NumMethodIds(), dex_cache->NumResolvedMethods());
   for (size_t i = 0; i < dex_cache->NumResolvedMethods(); i++) {
-    mirror::AbstractMethod* method = dex_cache->GetResolvedMethod(i);
+    mirror::ArtMethod* method = dex_cache->GetResolvedMethod(i);
     EXPECT_TRUE(method != NULL) << "method_idx=" << i
                                 << " " << dex->GetMethodDeclaringClassDescriptor(dex->GetMethodId(i))
                                 << " " << dex->GetMethodName(dex->GetMethodId(i));
@@ -126,7 +126,7 @@ TEST_F(CompilerDriverTest, DISABLED_LARGE_CompileDexLibCore) {
   }
   EXPECT_EQ(dex->NumFieldIds(), dex_cache->NumResolvedFields());
   for (size_t i = 0; i < dex_cache->NumResolvedFields(); i++) {
-    mirror::Field* field = dex_cache->GetResolvedField(i);
+    mirror::ArtField* field = dex_cache->GetResolvedField(i);
     EXPECT_TRUE(field != NULL) << "field_idx=" << i
                                << " " << dex->GetFieldDeclaringClassDescriptor(dex->GetFieldId(i))
                                << " " << dex->GetFieldName(dex->GetFieldId(i));
diff --git a/compiler/elf_writer.cc b/compiler/elf_writer.cc
index 70d17de102..d3c13dd791 100644
--- a/compiler/elf_writer.cc
+++ b/compiler/elf_writer.cc
@@ -24,7 +24,7 @@
 #include "elf_file.h"
 #include "invoke_type.h"
 #include "llvm/utils_llvm.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object-inl.h"
 #include "oat.h"
 #include "scoped_thread_state_change.h"
diff --git a/compiler/elf_writer_mclinker.cc b/compiler/elf_writer_mclinker.cc
index 2a9bc35559..e496ace27a 100644
--- a/compiler/elf_writer_mclinker.cc
+++ b/compiler/elf_writer_mclinker.cc
@@ -33,8 +33,8 @@
 #include "driver/compiler_driver.h"
 #include "elf_file.h"
 #include "globals.h"
-#include "mirror/abstract_method.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object-inl.h"
 #include "oat_writer.h"
 #include "scoped_thread_state_change.h"
@@ -353,7 +353,7 @@ void ElfWriterMclinker::FixupOatMethodOffsets(const std::vector<const DexFile*>&
     const DexFile& dex_file = it.GetDexFile();
     uint32_t method_idx = it.GetMemberIndex();
     InvokeType invoke_type = it.GetInvokeType();
-    mirror::AbstractMethod* method = NULL;
+    mirror::ArtMethod* method = NULL;
     if (compiler_driver_->IsImage()) {
       ClassLinker* linker = Runtime::Current()->GetClassLinker();
       mirror::DexCache* dex_cache = linker->FindDexCache(dex_file);
diff --git a/compiler/image_writer.cc b/compiler/image_writer.cc
index 3432c8cbee..a40e3fc149 100644
--- a/compiler/image_writer.cc
+++ b/compiler/image_writer.cc
@@ -35,12 +35,12 @@
 #include "globals.h"
 #include "image.h"
 #include "intern_table.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/array-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
 #include "mirror/dex_cache-inl.h"
-#include "mirror/field-inl.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "oat.h"
@@ -52,11 +52,11 @@
 #include "UniquePtr.h"
 #include "utils.h"
 
-using ::art::mirror::AbstractMethod;
+using ::art::mirror::ArtField;
+using ::art::mirror::ArtMethod;
 using ::art::mirror::Class;
 using ::art::mirror::DexCache;
 using ::art::mirror::EntryPointFromInterpreter;
-using ::art::mirror::Field;
 using ::art::mirror::Object;
 using ::art::mirror::ObjectArray;
 using ::art::mirror::String;
@@ -257,7 +257,7 @@ void ImageWriter::PruneNonImageClasses() {
   }
 
   // Clear references to removed classes from the DexCaches.
-  AbstractMethod* resolution_method = runtime->GetResolutionMethod();
+  ArtMethod* resolution_method = runtime->GetResolutionMethod();
   typedef Set::const_iterator CacheIt;  // TODO: C++0x auto
   for (CacheIt it = dex_caches_.begin(), end = dex_caches_.end(); it != end; ++it) {
     DexCache* dex_cache = *it;
@@ -269,13 +269,13 @@ void ImageWriter::PruneNonImageClasses() {
       }
     }
     for (size_t i = 0; i < dex_cache->NumResolvedMethods(); i++) {
-      AbstractMethod* method = dex_cache->GetResolvedMethod(i);
+      ArtMethod* method = dex_cache->GetResolvedMethod(i);
       if (method != NULL && !IsImageClass(method->GetDeclaringClass())) {
         dex_cache->SetResolvedMethod(i, resolution_method);
       }
     }
     for (size_t i = 0; i < dex_cache->NumResolvedFields(); i++) {
-      Field* field = dex_cache->GetResolvedField(i);
+      ArtField* field = dex_cache->GetResolvedField(i);
       if (field != NULL && !IsImageClass(field->GetDeclaringClass())) {
         dex_cache->SetResolvedField(i, NULL);
       }
@@ -487,8 +487,8 @@ void ImageWriter::FixupObject(const Object* orig, Object* copy) {
     FixupClass(orig->AsClass(), down_cast<Class*>(copy));
   } else if (orig->IsObjectArray()) {
     FixupObjectArray(orig->AsObjectArray<Object>(), down_cast<ObjectArray<Object>*>(copy));
-  } else if (orig->IsMethod()) {
-    FixupMethod(orig->AsMethod(), down_cast<AbstractMethod*>(copy));
+  } else if (orig->IsArtMethod()) {
+    FixupMethod(orig->AsArtMethod(), down_cast<ArtMethod*>(copy));
   } else {
     FixupInstanceFields(orig, copy);
   }
@@ -499,7 +499,7 @@ void ImageWriter::FixupClass(const Class* orig, Class* copy) {
   FixupStaticFields(orig, copy);
 }
 
-void ImageWriter::FixupMethod(const AbstractMethod* orig, AbstractMethod* copy) {
+void ImageWriter::FixupMethod(const ArtMethod* orig, ArtMethod* copy) {
   FixupInstanceFields(orig, copy);
 
   // OatWriter replaces the code_ with an offset value. Here we re-adjust to a pointer relative to
@@ -614,9 +614,9 @@ void ImageWriter::FixupFields(const Object* orig,
                                      ? klass->NumReferenceStaticFields()
                                      : klass->NumReferenceInstanceFields());
       for (size_t i = 0; i < num_reference_fields; ++i) {
-        Field* field = (is_static
-                        ? klass->GetStaticField(i)
-                        : klass->GetInstanceField(i));
+        ArtField* field = (is_static
+                           ? klass->GetStaticField(i)
+                           : klass->GetInstanceField(i));
         MemberOffset field_offset = field->GetOffset();
         const Object* ref = orig->GetFieldObject<const Object*>(field_offset, false);
         // Use SetFieldPtr to avoid card marking since we are writing to the image.
@@ -626,7 +626,7 @@ void ImageWriter::FixupFields(const Object* orig,
   }
   if (!is_static && orig->IsReferenceInstance()) {
     // Fix-up referent, that isn't marked as an object field, for References.
-    Field* field = orig->GetClass()->FindInstanceField("referent", "Ljava/lang/Object;");
+    ArtField* field = orig->GetClass()->FindInstanceField("referent", "Ljava/lang/Object;");
     MemberOffset field_offset = field->GetOffset();
     const Object* ref = orig->GetFieldObject<const Object*>(field_offset, false);
     // Use SetFieldPtr to avoid card marking since we are writing to the image.
@@ -634,16 +634,16 @@ void ImageWriter::FixupFields(const Object* orig,
   }
 }
 
-static AbstractMethod* GetTargetMethod(const CompilerDriver::PatchInformation* patch)
+static ArtMethod* GetTargetMethod(const CompilerDriver::PatchInformation* patch)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   DexCache* dex_cache = class_linker->FindDexCache(patch->GetDexFile());
-  AbstractMethod* method = class_linker->ResolveMethod(patch->GetDexFile(),
-                                               patch->GetTargetMethodIdx(),
-                                               dex_cache,
-                                               NULL,
-                                               NULL,
-                                               patch->GetTargetInvokeType());
+  ArtMethod* method = class_linker->ResolveMethod(patch->GetDexFile(),
+                                                  patch->GetTargetMethodIdx(),
+                                                  dex_cache,
+                                                  NULL,
+                                                  NULL,
+                                                  patch->GetTargetInvokeType());
   CHECK(method != NULL)
     << patch->GetDexFile().GetLocation() << " " << patch->GetTargetMethodIdx();
   CHECK(!method->IsRuntimeMethod())
@@ -664,7 +664,7 @@ void ImageWriter::PatchOatCodeAndMethods() {
   const Patches& code_to_patch = compiler_driver_.GetCodeToPatch();
   for (size_t i = 0; i < code_to_patch.size(); i++) {
     const CompilerDriver::PatchInformation* patch = code_to_patch[i];
-    AbstractMethod* target = GetTargetMethod(patch);
+    ArtMethod* target = GetTargetMethod(patch);
     uint32_t code = reinterpret_cast<uint32_t>(class_linker->GetOatCodeFor(target));
     uint32_t code_base = reinterpret_cast<uint32_t>(&oat_file_->GetOatHeader());
     uint32_t code_offset = code - code_base;
@@ -674,7 +674,7 @@ void ImageWriter::PatchOatCodeAndMethods() {
   const Patches& methods_to_patch = compiler_driver_.GetMethodsToPatch();
   for (size_t i = 0; i < methods_to_patch.size(); i++) {
     const CompilerDriver::PatchInformation* patch = methods_to_patch[i];
-    AbstractMethod* target = GetTargetMethod(patch);
+    ArtMethod* target = GetTargetMethod(patch);
     SetPatchLocation(patch, reinterpret_cast<uint32_t>(GetImageAddress(target)));
   }
 
diff --git a/compiler/image_writer.h b/compiler/image_writer.h
index 545534fff7..750109d1d9 100644
--- a/compiler/image_writer.h
+++ b/compiler/image_writer.h
@@ -152,7 +152,7 @@ class ImageWriter {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   void FixupClass(const mirror::Class* orig, mirror::Class* copy)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void FixupMethod(const mirror::AbstractMethod* orig, mirror::AbstractMethod* copy)
+  void FixupMethod(const mirror::ArtMethod* orig, mirror::ArtMethod* copy)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   void FixupObject(const mirror::Object* orig, mirror::Object* copy)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
diff --git a/compiler/jni/jni_compiler_test.cc b/compiler/jni/jni_compiler_test.cc
index 4b6967faa0..a653ab42a9 100644
--- a/compiler/jni/jni_compiler_test.cc
+++ b/compiler/jni/jni_compiler_test.cc
@@ -21,9 +21,9 @@
 #include "indirect_reference_table.h"
 #include "jni_internal.h"
 #include "mem_map.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/stack_trace_element.h"
@@ -51,7 +51,7 @@ class JniCompilerTest : public CommonTest {
     // Compile the native method before starting the runtime
     mirror::Class* c = class_linker_->FindClass("LMyClassNatives;",
                                                 soa.Decode<mirror::ClassLoader*>(class_loader));
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     if (direct) {
       method = c->FindDirectMethod(method_name, method_sig);
     } else {
diff --git a/compiler/jni/portable/jni_compiler.cc b/compiler/jni/portable/jni_compiler.cc
index e05f291a73..58ee1c1602 100644
--- a/compiler/jni/portable/jni_compiler.cc
+++ b/compiler/jni/portable/jni_compiler.cc
@@ -27,7 +27,7 @@
 #include "llvm/llvm_compilation_unit.h"
 #include "llvm/runtime_support_llvm_func.h"
 #include "llvm/utils_llvm.h"
-#include "mirror/abstract_method.h"
+#include "mirror/art_method.h"
 #include "runtime.h"
 #include "stack.h"
 #include "thread.h"
@@ -91,7 +91,7 @@ CompiledMethod* JniCompiler::Compile() {
     // Load class object
     this_object_or_class_object =
         irb_.LoadFromObjectOffset(method_object_addr,
-                                  mirror::AbstractMethod::DeclaringClassOffset().Int32Value(),
+                                  mirror::ArtMethod::DeclaringClassOffset().Int32Value(),
                                   irb_.getJObjectTy(),
                                   kTBAAConstJObject);
   }
@@ -135,7 +135,7 @@ CompiledMethod* JniCompiler::Compile() {
   // Get callee code_addr
   ::llvm::Value* code_addr =
       irb_.LoadFromObjectOffset(method_object_addr,
-                                mirror::AbstractMethod::NativeMethodOffset().Int32Value(),
+                                mirror::ArtMethod::NativeMethodOffset().Int32Value(),
                                 GetFunctionType(dex_compilation_unit_->GetDexMethodIndex(),
                                                 is_static, true)->getPointerTo(),
                                 kTBAARuntimeInfo);
diff --git a/compiler/jni/portable/jni_compiler.h b/compiler/jni/portable/jni_compiler.h
index 9bdf35ef10..49cc9f4abf 100644
--- a/compiler/jni/portable/jni_compiler.h
+++ b/compiler/jni/portable/jni_compiler.h
@@ -28,7 +28,7 @@ namespace art {
   class DexFile;
   class DexCompilationUnit;
   namespace mirror {
-    class AbstractMethod;
+    class ArtMethod;
     class ClassLoader;
     class DexCache;
   }  // namespace mirror
diff --git a/compiler/jni/quick/jni_compiler.cc b/compiler/jni/quick/jni_compiler.cc
index 9713fe9da9..069def60f9 100644
--- a/compiler/jni/quick/jni_compiler.cc
+++ b/compiler/jni/quick/jni_compiler.cc
@@ -119,7 +119,7 @@ CompiledMethod* ArtJniCompileMethodInternal(CompilerDriver& compiler,
     // Check sirt offset is within frame
     CHECK_LT(sirt_offset.Uint32Value(), frame_size);
     __ LoadRef(main_jni_conv->InterproceduralScratchRegister(),
-               mr_conv->MethodRegister(), mirror::AbstractMethod::DeclaringClassOffset());
+               mr_conv->MethodRegister(), mirror::ArtMethod::DeclaringClassOffset());
     __ VerifyObject(main_jni_conv->InterproceduralScratchRegister(), false);
     __ StoreRef(sirt_offset, main_jni_conv->InterproceduralScratchRegister());
     main_jni_conv->Next();  // in SIRT so move to next argument
@@ -270,7 +270,7 @@ CompiledMethod* ArtJniCompileMethodInternal(CompilerDriver& compiler,
   }
 
   // 9. Plant call to native code associated with method.
-  __ Call(main_jni_conv->MethodStackOffset(), mirror::AbstractMethod::NativeMethodOffset(),
+  __ Call(main_jni_conv->MethodStackOffset(), mirror::ArtMethod::NativeMethodOffset(),
           mr_conv->InterproceduralScratchRegister());
 
   // 10. Fix differences in result widths.
diff --git a/compiler/llvm/compiler_llvm.h b/compiler/llvm/compiler_llvm.h
index 20934ab209..65bc16bcd8 100644
--- a/compiler/llvm/compiler_llvm.h
+++ b/compiler/llvm/compiler_llvm.h
@@ -34,7 +34,7 @@ namespace art {
   class CompilerDriver;
   class DexCompilationUnit;
   namespace mirror {
-    class AbstractMethod;
+    class ArtMethod;
     class ClassLoader;
   }  // namespace mirror
 }  // namespace art
diff --git a/compiler/llvm/gbc_expander.cc b/compiler/llvm/gbc_expander.cc
index a727d06cb2..4f6fa0a2df 100644
--- a/compiler/llvm/gbc_expander.cc
+++ b/compiler/llvm/gbc_expander.cc
@@ -20,7 +20,7 @@
 #include "intrinsic_helper.h"
 #include "ir_builder.h"
 #include "method_reference.h"
-#include "mirror/abstract_method.h"
+#include "mirror/art_method.h"
 #include "mirror/array.h"
 #include "mirror/string.h"
 #include "thread.h"
@@ -722,7 +722,7 @@ llvm::Value* GBCExpanderPass::EmitLoadDexCacheAddr(art::MemberOffset offset) {
 llvm::Value*
 GBCExpanderPass::EmitLoadDexCacheStaticStorageFieldAddr(uint32_t type_idx) {
   llvm::Value* static_storage_dex_cache_addr =
-    EmitLoadDexCacheAddr(art::mirror::AbstractMethod::DexCacheInitializedStaticStorageOffset());
+    EmitLoadDexCacheAddr(art::mirror::ArtMethod::DexCacheInitializedStaticStorageOffset());
 
   llvm::Value* type_idx_value = irb_.getPtrEquivInt(type_idx);
 
@@ -732,7 +732,7 @@ GBCExpanderPass::EmitLoadDexCacheStaticStorageFieldAddr(uint32_t type_idx) {
 llvm::Value*
 GBCExpanderPass::EmitLoadDexCacheResolvedTypeFieldAddr(uint32_t type_idx) {
   llvm::Value* resolved_type_dex_cache_addr =
-    EmitLoadDexCacheAddr(art::mirror::AbstractMethod::DexCacheResolvedTypesOffset());
+    EmitLoadDexCacheAddr(art::mirror::ArtMethod::DexCacheResolvedTypesOffset());
 
   llvm::Value* type_idx_value = irb_.getPtrEquivInt(type_idx);
 
@@ -742,7 +742,7 @@ GBCExpanderPass::EmitLoadDexCacheResolvedTypeFieldAddr(uint32_t type_idx) {
 llvm::Value* GBCExpanderPass::
 EmitLoadDexCacheResolvedMethodFieldAddr(uint32_t method_idx) {
   llvm::Value* resolved_method_dex_cache_addr =
-    EmitLoadDexCacheAddr(art::mirror::AbstractMethod::DexCacheResolvedMethodsOffset());
+    EmitLoadDexCacheAddr(art::mirror::ArtMethod::DexCacheResolvedMethodsOffset());
 
   llvm::Value* method_idx_value = irb_.getPtrEquivInt(method_idx);
 
@@ -752,7 +752,7 @@ EmitLoadDexCacheResolvedMethodFieldAddr(uint32_t method_idx) {
 llvm::Value* GBCExpanderPass::
 EmitLoadDexCacheStringFieldAddr(uint32_t string_idx) {
   llvm::Value* string_dex_cache_addr =
-    EmitLoadDexCacheAddr(art::mirror::AbstractMethod::DexCacheStringsOffset());
+    EmitLoadDexCacheAddr(art::mirror::ArtMethod::DexCacheStringsOffset());
 
   llvm::Value* string_idx_value = irb_.getPtrEquivInt(string_idx);
 
@@ -911,7 +911,7 @@ llvm::Value* GBCExpanderPass::EmitInvoke(llvm::CallInst& call_inst) {
   } else {
     code_addr =
         irb_.LoadFromObjectOffset(callee_method_object_addr,
-                                  art::mirror::AbstractMethod::GetEntryPointFromCompiledCodeOffset().Int32Value(),
+                                  art::mirror::ArtMethod::GetEntryPointFromCompiledCodeOffset().Int32Value(),
                                   func_type->getPointerTo(), kTBAARuntimeInfo);
   }
 
@@ -1207,7 +1207,7 @@ void GBCExpanderPass::Expand_SPutFast(llvm::Value* static_storage_addr,
 llvm::Value*
 GBCExpanderPass::Expand_LoadDeclaringClassSSB(llvm::Value* method_object_addr) {
   return irb_.LoadFromObjectOffset(method_object_addr,
-                                   art::mirror::AbstractMethod::DeclaringClassOffset().Int32Value(),
+                                   art::mirror::ArtMethod::DeclaringClassOffset().Int32Value(),
                                    irb_.getJObjectTy(),
                                    kTBAAConstJObject);
 }
@@ -1259,7 +1259,7 @@ llvm::Value* GBCExpanderPass::Expand_Invoke(llvm::CallInst& call_inst) {
 
   llvm::Value* code_addr =
     irb_.LoadFromObjectOffset(callee_method_object_addr,
-                              art::mirror::AbstractMethod::GetEntryPointFromCompiledCodeOffset().Int32Value(),
+                              art::mirror::ArtMethod::GetEntryPointFromCompiledCodeOffset().Int32Value(),
                               callee_method_type->getPointerTo(),
                               kTBAARuntimeInfo);
 
@@ -1938,7 +1938,7 @@ llvm::Value* GBCExpanderPass::Expand_HLSget(llvm::CallInst& call_inst,
 
       static_storage_addr =
         irb_.LoadFromObjectOffset(method_object_addr,
-                                  art::mirror::AbstractMethod::DeclaringClassOffset().Int32Value(),
+                                  art::mirror::ArtMethod::DeclaringClassOffset().Int32Value(),
                                   irb_.getJObjectTy(),
                                   kTBAAConstJObject);
     } else {
@@ -2023,7 +2023,7 @@ void GBCExpanderPass::Expand_HLSput(llvm::CallInst& call_inst,
 
       static_storage_addr =
         irb_.LoadFromObjectOffset(method_object_addr,
-                                  art::mirror::AbstractMethod::DeclaringClassOffset().Int32Value(),
+                                  art::mirror::ArtMethod::DeclaringClassOffset().Int32Value(),
                                   irb_.getJObjectTy(),
                                   kTBAAConstJObject);
     } else {
diff --git a/compiler/oat_writer.cc b/compiler/oat_writer.cc
index ce88cf6dd6..f813843bd3 100644
--- a/compiler/oat_writer.cc
+++ b/compiler/oat_writer.cc
@@ -23,7 +23,7 @@
 #include "class_linker.h"
 #include "dex_file-inl.h"
 #include "gc/space/space.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/array.h"
 #include "mirror/class_loader.h"
 #include "mirror/object-inl.h"
@@ -400,7 +400,7 @@ size_t OatWriter::InitOatCodeMethod(size_t offset, size_t oat_class_index,
     mirror::DexCache* dex_cache = linker->FindDexCache(*dex_file);
     // Unchecked as we hold mutator_lock_ on entry.
     ScopedObjectAccessUnchecked soa(Thread::Current());
-    mirror::AbstractMethod* method = linker->ResolveMethod(*dex_file, method_idx, dex_cache,
+    mirror::ArtMethod* method = linker->ResolveMethod(*dex_file, method_idx, dex_cache,
                                                            NULL, NULL, invoke_type);
     CHECK(method != NULL);
     method->SetFrameSizeInBytes(frame_size_in_bytes);
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index b85378d9ec..c372d000df 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -37,7 +37,7 @@
 #include "gc/space/space-inl.h"
 #include "image_writer.h"
 #include "leb128.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
 #include "mirror/object-inl.h"
@@ -862,7 +862,7 @@ static int dex2oat(int argc, char** argv) {
   // give it away now and then switch to a more managable ScopedObjectAccess.
   Thread::Current()->TransitionFromRunnableToSuspended(kNative);
   // Whilst we're in native take the opportunity to initialize well known classes.
-  WellKnownClasses::InitClasses(Thread::Current()->GetJniEnv());
+  WellKnownClasses::Init(Thread::Current()->GetJniEnv());
   ScopedObjectAccess soa(Thread::Current());
 
   // If --image-classes was specified, calculate the full list of classes to include in the image
diff --git a/oatdump/oatdump.cc b/oatdump/oatdump.cc
index a6f295f46d..67398afd5f 100644
--- a/oatdump/oatdump.cc
+++ b/oatdump/oatdump.cc
@@ -36,10 +36,10 @@
 #include "image.h"
 #include "indenter.h"
 #include "mapping_table.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/array-inl.h"
 #include "mirror/class-inl.h"
-#include "mirror/field-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "oat.h"
@@ -169,7 +169,7 @@ class OatDumper {
     return oat_file_.GetOatHeader().GetInstructionSet();
   }
 
-  const void* GetOatCode(mirror::AbstractMethod* m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  const void* GetOatCode(mirror::ArtMethod* m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     MethodHelper mh(m);
     for (size_t i = 0; i < oat_dex_files_.size(); i++) {
       const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
@@ -804,18 +804,18 @@ class ImageDumper {
     } else if (type->IsClassClass()) {
       mirror::Class* klass = value->AsClass();
       os << StringPrintf("%p   Class: %s\n", klass, PrettyDescriptor(klass).c_str());
-    } else if (type->IsFieldClass()) {
-      mirror::Field* field = value->AsField();
+    } else if (type->IsArtFieldClass()) {
+      mirror::ArtField* field = value->AsArtField();
       os << StringPrintf("%p   Field: %s\n", field, PrettyField(field).c_str());
-    } else if (type->IsMethodClass()) {
-      mirror::AbstractMethod* method = value->AsMethod();
+    } else if (type->IsArtMethodClass()) {
+      mirror::ArtMethod* method = value->AsArtMethod();
       os << StringPrintf("%p   Method: %s\n", method, PrettyMethod(method).c_str());
     } else {
       os << StringPrintf("%p   %s\n", value, PrettyDescriptor(type).c_str());
     }
   }
 
-  static void PrintField(std::ostream& os, mirror::Field* field, mirror::Object* obj)
+  static void PrintField(std::ostream& os, mirror::ArtField* field, mirror::Object* obj)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     FieldHelper fh(field);
     const char* descriptor = fh.GetTypeDescriptor();
@@ -856,10 +856,10 @@ class ImageDumper {
     if (super != NULL) {
       DumpFields(os, obj, super);
     }
-    mirror::ObjectArray<mirror::Field>* fields = klass->GetIFields();
+    mirror::ObjectArray<mirror::ArtField>* fields = klass->GetIFields();
     if (fields != NULL) {
       for (int32_t i = 0; i < fields->GetLength(); i++) {
-        mirror::Field* field = fields->Get(i);
+        mirror::ArtField* field = fields->Get(i);
         PrintField(os, field, obj);
       }
     }
@@ -869,7 +869,7 @@ class ImageDumper {
     return image_space_.Contains(object);
   }
 
-  const void* GetOatCodeBegin(mirror::AbstractMethod* m)
+  const void* GetOatCodeBegin(mirror::ArtMethod* m)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     const void* code = m->GetEntryPointFromCompiledCode();
     if (code == GetResolutionTrampoline(Runtime::Current()->GetClassLinker())) {
@@ -881,7 +881,7 @@ class ImageDumper {
     return code;
   }
 
-  uint32_t GetOatCodeSize(mirror::AbstractMethod* m)
+  uint32_t GetOatCodeSize(mirror::ArtMethod* m)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     const uint32_t* oat_code_begin = reinterpret_cast<const uint32_t*>(GetOatCodeBegin(m));
     if (oat_code_begin == NULL) {
@@ -890,7 +890,7 @@ class ImageDumper {
     return oat_code_begin[-1];
   }
 
-  const void* GetOatCodeEnd(mirror::AbstractMethod* m)
+  const void* GetOatCodeEnd(mirror::ArtMethod* m)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     const uint8_t* oat_code_begin = reinterpret_cast<const uint8_t*>(GetOatCodeBegin(m));
     if (oat_code_begin == NULL) {
@@ -922,12 +922,12 @@ class ImageDumper {
       mirror::Class* klass = obj->AsClass();
       os << StringPrintf("%p: java.lang.Class \"%s\" (", obj, PrettyDescriptor(klass).c_str())
          << klass->GetStatus() << ")\n";
-    } else if (obj->IsField()) {
+    } else if (obj->IsArtField()) {
       os << StringPrintf("%p: java.lang.reflect.Field %s\n", obj,
-                         PrettyField(obj->AsField()).c_str());
-    } else if (obj->IsMethod()) {
+                         PrettyField(obj->AsArtField()).c_str());
+    } else if (obj->IsArtMethod()) {
       os << StringPrintf("%p: java.lang.reflect.Method %s\n", obj,
-                         PrettyMethod(obj->AsMethod()).c_str());
+                         PrettyMethod(obj->AsArtMethod()).c_str());
     } else if (obj_class->IsStringClass()) {
       os << StringPrintf("%p: java.lang.String %s\n", obj,
                          PrintableString(obj->AsString()->ToModifiedUtf8()).c_str());
@@ -960,18 +960,18 @@ class ImageDumper {
         PrettyObjectValue(indent_os, value_class, value);
       }
     } else if (obj->IsClass()) {
-      mirror::ObjectArray<mirror::Field>* sfields = obj->AsClass()->GetSFields();
+      mirror::ObjectArray<mirror::ArtField>* sfields = obj->AsClass()->GetSFields();
       if (sfields != NULL) {
         indent_os << "STATICS:\n";
         Indenter indent2_filter(indent_os.rdbuf(), kIndentChar, kIndentBy1Count);
         std::ostream indent2_os(&indent2_filter);
         for (int32_t i = 0; i < sfields->GetLength(); i++) {
-          mirror::Field* field = sfields->Get(i);
+          mirror::ArtField* field = sfields->Get(i);
           PrintField(indent2_os, field, field->GetDeclaringClass());
         }
       }
-    } else if (obj->IsMethod()) {
-      mirror::AbstractMethod* method = obj->AsMethod();
+    } else if (obj->IsArtMethod()) {
+      mirror::ArtMethod* method = obj->AsArtMethod();
       if (method->IsNative()) {
         DCHECK(method->GetNativeGcMap() == NULL) << PrettyMethod(method);
         DCHECK(method->GetMappingTable() == NULL) << PrettyMethod(method);
@@ -1085,7 +1085,7 @@ class ImageDumper {
 
     size_t dex_instruction_bytes;
 
-    std::vector<mirror::AbstractMethod*> method_outlier;
+    std::vector<mirror::ArtMethod*> method_outlier;
     std::vector<size_t> method_outlier_size;
     std::vector<double> method_outlier_expansion;
     std::vector<std::pair<std::string, size_t> > oat_dex_file_sizes;
@@ -1138,7 +1138,7 @@ class ImageDumper {
       return (static_cast<double>(size) / static_cast<double>(object_bytes)) * 100;
     }
 
-    void ComputeOutliers(size_t total_size, double expansion, mirror::AbstractMethod* method) {
+    void ComputeOutliers(size_t total_size, double expansion, mirror::ArtMethod* method) {
       method_outlier_size.push_back(total_size);
       method_outlier_expansion.push_back(expansion);
       method_outlier.push_back(method);
diff --git a/runtime/Android.mk b/runtime/Android.mk
index 69e13e58f5..b34abe4282 100644
--- a/runtime/Android.mk
+++ b/runtime/Android.mk
@@ -78,11 +78,11 @@ LIBART_COMMON_SRC_FILES := \
 	locks.cc \
 	mem_map.cc \
 	memory_region.cc \
-	mirror/abstract_method.cc \
+	mirror/art_field.cc \
+	mirror/art_method.cc \
 	mirror/array.cc \
 	mirror/class.cc \
 	mirror/dex_cache.cc \
-	mirror/field.cc \
 	mirror/object.cc \
 	mirror/stack_trace_element.cc \
 	mirror/string.cc \
diff --git a/runtime/arch/arm/context_arm.cc b/runtime/arch/arm/context_arm.cc
index 6b9538e801..102e1269b5 100644
--- a/runtime/arch/arm/context_arm.cc
+++ b/runtime/arch/arm/context_arm.cc
@@ -16,7 +16,7 @@
 
 #include "context_arm.h"
 
-#include "mirror/abstract_method.h"
+#include "mirror/art_method.h"
 #include "mirror/object-inl.h"
 #include "stack.h"
 #include "thread.h"
@@ -41,7 +41,7 @@ void ArmContext::Reset() {
 }
 
 void ArmContext::FillCalleeSaves(const StackVisitor& fr) {
-  mirror::AbstractMethod* method = fr.GetMethod();
+  mirror::ArtMethod* method = fr.GetMethod();
   uint32_t core_spills = method->GetCoreSpillMask();
   uint32_t fp_core_spills = method->GetFpSpillMask();
   size_t spill_count = __builtin_popcount(core_spills);
diff --git a/runtime/arch/arm/entrypoints_init_arm.cc b/runtime/arch/arm/entrypoints_init_arm.cc
index 810a6832b6..9e6902de3f 100644
--- a/runtime/arch/arm/entrypoints_init_arm.cc
+++ b/runtime/arch/arm/entrypoints_init_arm.cc
@@ -31,8 +31,8 @@ extern "C" void artInterpreterToCompiledCodeBridge(Thread* self, MethodHelper& m
                                            ShadowFrame* shadow_frame, JValue* result);
 
 // Portable entrypoints.
-extern "C" void art_portable_resolution_trampoline(mirror::AbstractMethod*);
-extern "C" void art_portable_to_interpreter_bridge(mirror::AbstractMethod*);
+extern "C" void art_portable_resolution_trampoline(mirror::ArtMethod*);
+extern "C" void art_portable_to_interpreter_bridge(mirror::ArtMethod*);
 
 // Alloc entrypoints.
 extern "C" void* art_quick_alloc_array(uint32_t, void*, int32_t);
@@ -112,8 +112,8 @@ extern "C" int32_t art_quick_indexof(void*, uint32_t, uint32_t, uint32_t);
 extern "C" int32_t art_quick_string_compareto(void*, void*);
 
 // Invoke entrypoints.
-extern "C" void art_quick_resolution_trampoline(mirror::AbstractMethod*);
-extern "C" void art_quick_to_interpreter_bridge(mirror::AbstractMethod*);
+extern "C" void art_quick_resolution_trampoline(mirror::ArtMethod*);
+extern "C" void art_quick_to_interpreter_bridge(mirror::ArtMethod*);
 extern "C" void art_quick_invoke_direct_trampoline_with_access_check(uint32_t, void*);
 extern "C" void art_quick_invoke_interface_trampoline(uint32_t, void*);
 extern "C" void art_quick_invoke_interface_trampoline_with_access_check(uint32_t, void*);
diff --git a/runtime/arch/mips/context_mips.cc b/runtime/arch/mips/context_mips.cc
index a78e5ee80d..b957708769 100644
--- a/runtime/arch/mips/context_mips.cc
+++ b/runtime/arch/mips/context_mips.cc
@@ -16,7 +16,7 @@
 
 #include "context_mips.h"
 
-#include "mirror/abstract_method.h"
+#include "mirror/art_method.h"
 #include "mirror/object-inl.h"
 #include "stack.h"
 
@@ -40,7 +40,7 @@ void MipsContext::Reset() {
 }
 
 void MipsContext::FillCalleeSaves(const StackVisitor& fr) {
-  mirror::AbstractMethod* method = fr.GetMethod();
+  mirror::ArtMethod* method = fr.GetMethod();
   uint32_t core_spills = method->GetCoreSpillMask();
   uint32_t fp_core_spills = method->GetFpSpillMask();
   size_t spill_count = __builtin_popcount(core_spills);
diff --git a/runtime/arch/mips/entrypoints_init_mips.cc b/runtime/arch/mips/entrypoints_init_mips.cc
index a0d3995bce..40d7cd913c 100644
--- a/runtime/arch/mips/entrypoints_init_mips.cc
+++ b/runtime/arch/mips/entrypoints_init_mips.cc
@@ -30,8 +30,8 @@ extern "C" void artInterpreterToCompiledCodeBridge(Thread* self, MethodHelper& m
                                            ShadowFrame* shadow_frame, JValue* result);
 
 // Portable entrypoints.
-extern "C" void art_portable_resolution_trampoline(mirror::AbstractMethod*);
-extern "C" void art_portable_to_interpreter_bridge(mirror::AbstractMethod*);
+extern "C" void art_portable_resolution_trampoline(mirror::ArtMethod*);
+extern "C" void art_portable_to_interpreter_bridge(mirror::ArtMethod*);
 
 // Alloc entrypoints.
 extern "C" void* art_quick_alloc_array(uint32_t, void*, int32_t);
@@ -113,8 +113,8 @@ extern "C" int32_t art_quick_indexof(void*, uint32_t, uint32_t, uint32_t);
 extern "C" int32_t art_quick_string_compareto(void*, void*);
 
 // Invoke entrypoints.
-extern "C" void art_quick_resolution_trampoline(mirror::AbstractMethod*);
-extern "C" void art_quick_to_interpreter_bridge(mirror::AbstractMethod*);
+extern "C" void art_quick_resolution_trampoline(mirror::ArtMethod*);
+extern "C" void art_quick_to_interpreter_bridge(mirror::ArtMethod*);
 extern "C" void art_quick_invoke_direct_trampoline_with_access_check(uint32_t, void*);
 extern "C" void art_quick_invoke_interface_trampoline(uint32_t, void*);
 extern "C" void art_quick_invoke_interface_trampoline_with_access_check(uint32_t, void*);
diff --git a/runtime/arch/x86/context_x86.cc b/runtime/arch/x86/context_x86.cc
index c728ae97ec..66a51f7492 100644
--- a/runtime/arch/x86/context_x86.cc
+++ b/runtime/arch/x86/context_x86.cc
@@ -16,7 +16,7 @@
 
 #include "context_x86.h"
 
-#include "mirror/abstract_method.h"
+#include "mirror/art_method.h"
 #include "mirror/object-inl.h"
 #include "stack.h"
 
@@ -36,7 +36,7 @@ void X86Context::Reset() {
 }
 
 void X86Context::FillCalleeSaves(const StackVisitor& fr) {
-  mirror::AbstractMethod* method = fr.GetMethod();
+  mirror::ArtMethod* method = fr.GetMethod();
   uint32_t core_spills = method->GetCoreSpillMask();
   size_t spill_count = __builtin_popcount(core_spills);
   DCHECK_EQ(method->GetFpSpillMask(), 0u);
diff --git a/runtime/arch/x86/entrypoints_init_x86.cc b/runtime/arch/x86/entrypoints_init_x86.cc
index 9b54d55bfc..abc2990cc0 100644
--- a/runtime/arch/x86/entrypoints_init_x86.cc
+++ b/runtime/arch/x86/entrypoints_init_x86.cc
@@ -29,8 +29,8 @@ extern "C" void artInterpreterToCompiledCodeBridge(Thread* self, MethodHelper& m
                                            ShadowFrame* shadow_frame, JValue* result);
 
 // Portable entrypoints.
-extern "C" void art_portable_resolution_trampoline(mirror::AbstractMethod*);
-extern "C" void art_portable_to_interpreter_bridge(mirror::AbstractMethod*);
+extern "C" void art_portable_resolution_trampoline(mirror::ArtMethod*);
+extern "C" void art_portable_to_interpreter_bridge(mirror::ArtMethod*);
 
 // Alloc entrypoints.
 extern "C" void* art_quick_alloc_array(uint32_t, void*, int32_t);
@@ -95,8 +95,8 @@ extern "C" int32_t art_quick_string_compareto(void*, void*);
 extern "C" void* art_quick_memcpy(void*, const void*, size_t);
 
 // Invoke entrypoints.
-extern "C" void art_quick_resolution_trampoline(mirror::AbstractMethod*);
-extern "C" void art_quick_to_interpreter_bridge(mirror::AbstractMethod*);
+extern "C" void art_quick_resolution_trampoline(mirror::ArtMethod*);
+extern "C" void art_quick_to_interpreter_bridge(mirror::ArtMethod*);
 extern "C" void art_quick_invoke_direct_trampoline_with_access_check(uint32_t, void*);
 extern "C" void art_quick_invoke_interface_trampoline(uint32_t, void*);
 extern "C" void art_quick_invoke_interface_trampoline_with_access_check(uint32_t, void*);
diff --git a/runtime/check_jni.cc b/runtime/check_jni.cc
index 073d67b823..6a7ceeed0b 100644
--- a/runtime/check_jni.cc
+++ b/runtime/check_jni.cc
@@ -24,9 +24,9 @@
 #include "class_linker-inl.h"
 #include "dex_file-inl.h"
 #include "gc/space/space.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
-#include "mirror/field-inl.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/throwable.h"
@@ -44,7 +44,7 @@ namespace art {
 static void JniAbort(const char* jni_function_name, const char* msg) {
   Thread* self = Thread::Current();
   ScopedObjectAccess soa(self);
-  mirror::AbstractMethod* current_method = self->GetCurrentMethod(NULL);
+  mirror::ArtMethod* current_method = self->GetCurrentMethod(NULL);
 
   std::ostringstream os;
   os << "JNI DETECTED ERROR IN APPLICATION: " << msg;
@@ -131,7 +131,7 @@ static const char* gBuiltInPrefixes[] = {
   NULL
 };
 
-static bool ShouldTrace(JavaVMExt* vm, const mirror::AbstractMethod* method)
+static bool ShouldTrace(JavaVMExt* vm, const mirror::ArtMethod* method)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // If both "-Xcheck:jni" and "-Xjnitrace:" are enabled, we print trace messages
   // when a native method that matches the -Xjnitrace argument calls a JNI function
@@ -204,7 +204,7 @@ class ScopedCheck {
    */
   void CheckFieldType(jobject java_object, jfieldID fid, char prim, bool isStatic)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::Field* f = CheckFieldID(fid);
+    mirror::ArtField* f = CheckFieldID(fid);
     if (f == NULL) {
       return;
     }
@@ -259,7 +259,7 @@ class ScopedCheck {
       return;
     }
 
-    mirror::Field* f = CheckFieldID(fid);
+    mirror::ArtField* f = CheckFieldID(fid);
     if (f == NULL) {
       return;
     }
@@ -286,7 +286,7 @@ class ScopedCheck {
    */
   void CheckSig(jmethodID mid, const char* expectedType, bool isStatic)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* m = CheckMethodID(mid);
+    mirror::ArtMethod* m = CheckMethodID(mid);
     if (m == NULL) {
       return;
     }
@@ -313,7 +313,7 @@ class ScopedCheck {
   void CheckStaticFieldID(jclass java_class, jfieldID fid)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     mirror::Class* c = soa_.Decode<mirror::Class*>(java_class);
-    const mirror::Field* f = CheckFieldID(fid);
+    const mirror::ArtField* f = CheckFieldID(fid);
     if (f == NULL) {
       return;
     }
@@ -334,7 +334,7 @@ class ScopedCheck {
    */
   void CheckStaticMethod(jclass java_class, jmethodID mid)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    const mirror::AbstractMethod* m = CheckMethodID(mid);
+    const mirror::ArtMethod* m = CheckMethodID(mid);
     if (m == NULL) {
       return;
     }
@@ -354,7 +354,7 @@ class ScopedCheck {
    */
   void CheckVirtualMethod(jobject java_object, jmethodID mid)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    const mirror::AbstractMethod* m = CheckMethodID(mid);
+    const mirror::ArtMethod* m = CheckMethodID(mid);
     if (m == NULL) {
       return;
     }
@@ -404,7 +404,7 @@ class ScopedCheck {
   void Check(bool entry, const char* fmt0, ...) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     va_list ap;
 
-    const mirror::AbstractMethod* traceMethod = NULL;
+    const mirror::ArtMethod* traceMethod = NULL;
     if (has_method_ && (!soa_.Vm()->trace.empty() || VLOG_IS_ON(third_party_jni))) {
       // We need to guard some of the invocation interface's calls: a bad caller might
       // use DetachCurrentThread or GetEnv on a thread that's not yet attached.
@@ -477,7 +477,7 @@ class ScopedCheck {
           }
         } else if (ch == 'f') {  // jfieldID
           jfieldID fid = va_arg(ap, jfieldID);
-          mirror::Field* f = reinterpret_cast<mirror::Field*>(fid);
+          mirror::ArtField* f = reinterpret_cast<mirror::ArtField*>(fid);
           msg += PrettyField(f);
           if (!entry) {
             StringAppendF(&msg, " (%p)", fid);
@@ -490,7 +490,7 @@ class ScopedCheck {
           StringAppendF(&msg, "%d", i);
         } else if (ch == 'm') {  // jmethodID
           jmethodID mid = va_arg(ap, jmethodID);
-          mirror::AbstractMethod* m = reinterpret_cast<mirror::AbstractMethod*>(mid);
+          mirror::ArtMethod* m = reinterpret_cast<mirror::ArtMethod*>(mid);
           msg += PrettyMethod(m);
           if (!entry) {
             StringAppendF(&msg, " (%p)", mid);
@@ -700,13 +700,13 @@ class ScopedCheck {
     }
   }
 
-  mirror::Field* CheckFieldID(jfieldID fid) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  mirror::ArtField* CheckFieldID(jfieldID fid) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     if (fid == NULL) {
       JniAbortF(function_name_, "jfieldID was NULL");
       return NULL;
     }
-    mirror::Field* f = soa_.DecodeField(fid);
-    if (!Runtime::Current()->GetHeap()->IsHeapAddress(f) || !f->IsField()) {
+    mirror::ArtField* f = soa_.DecodeField(fid);
+    if (!Runtime::Current()->GetHeap()->IsHeapAddress(f) || !f->IsArtField()) {
       Runtime::Current()->GetHeap()->DumpSpaces();
       JniAbortF(function_name_, "invalid jfieldID: %p", fid);
       return NULL;
@@ -714,13 +714,13 @@ class ScopedCheck {
     return f;
   }
 
-  mirror::AbstractMethod* CheckMethodID(jmethodID mid) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  mirror::ArtMethod* CheckMethodID(jmethodID mid) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     if (mid == NULL) {
       JniAbortF(function_name_, "jmethodID was NULL");
       return NULL;
     }
-    mirror::AbstractMethod* m = soa_.DecodeMethod(mid);
-    if (!Runtime::Current()->GetHeap()->IsHeapAddress(m) || !m->IsMethod()) {
+    mirror::ArtMethod* m = soa_.DecodeMethod(mid);
+    if (!Runtime::Current()->GetHeap()->IsHeapAddress(m) || !m->IsArtMethod()) {
       Runtime::Current()->GetHeap()->DumpSpaces();
       JniAbortF(function_name_, "invalid jmethodID: %p", mid);
       return NULL;
diff --git a/runtime/class_linker-inl.h b/runtime/class_linker-inl.h
index 4d01b66f0a..ad568b1cdb 100644
--- a/runtime/class_linker-inl.h
+++ b/runtime/class_linker-inl.h
@@ -19,15 +19,15 @@
 
 #include "class_linker.h"
 
+#include "mirror/art_field.h"
 #include "mirror/dex_cache.h"
-#include "mirror/field.h"
 #include "mirror/iftable.h"
 #include "mirror/object_array.h"
 
 namespace art {
 
 inline mirror::String* ClassLinker::ResolveString(uint32_t string_idx,
-                                           const mirror::AbstractMethod* referrer) {
+                                           const mirror::ArtMethod* referrer) {
   mirror::String* resolved_string = referrer->GetDexCacheStrings()->Get(string_idx);
   if (UNLIKELY(resolved_string == NULL)) {
     mirror::Class* declaring_class = referrer->GetDeclaringClass();
@@ -39,7 +39,7 @@ inline mirror::String* ClassLinker::ResolveString(uint32_t string_idx,
 }
 
 inline mirror::Class* ClassLinker::ResolveType(uint16_t type_idx,
-                                               const mirror::AbstractMethod* referrer) {
+                                               const mirror::ArtMethod* referrer) {
   mirror::Class* resolved_type = referrer->GetDexCacheResolvedTypes()->Get(type_idx);
   if (UNLIKELY(resolved_type == NULL)) {
     mirror::Class* declaring_class = referrer->GetDeclaringClass();
@@ -51,7 +51,7 @@ inline mirror::Class* ClassLinker::ResolveType(uint16_t type_idx,
   return resolved_type;
 }
 
-inline mirror::Class* ClassLinker::ResolveType(uint16_t type_idx, const mirror::Field* referrer) {
+inline mirror::Class* ClassLinker::ResolveType(uint16_t type_idx, const mirror::ArtField* referrer) {
   mirror::Class* declaring_class = referrer->GetDeclaringClass();
   mirror::DexCache* dex_cache = declaring_class->GetDexCache();
   mirror::Class* resolved_type = dex_cache->GetResolvedType(type_idx);
@@ -63,10 +63,10 @@ inline mirror::Class* ClassLinker::ResolveType(uint16_t type_idx, const mirror::
   return resolved_type;
 }
 
-inline mirror::AbstractMethod* ClassLinker::ResolveMethod(uint32_t method_idx,
-                                                          const mirror::AbstractMethod* referrer,
-                                                          InvokeType type) {
-  mirror::AbstractMethod* resolved_method =
+inline mirror::ArtMethod* ClassLinker::ResolveMethod(uint32_t method_idx,
+                                                     const mirror::ArtMethod* referrer,
+                                                     InvokeType type) {
+  mirror::ArtMethod* resolved_method =
       referrer->GetDexCacheResolvedMethods()->Get(method_idx);
   if (UNLIKELY(resolved_method == NULL || resolved_method->IsRuntimeMethod())) {
     mirror::Class* declaring_class = referrer->GetDeclaringClass();
@@ -78,10 +78,10 @@ inline mirror::AbstractMethod* ClassLinker::ResolveMethod(uint32_t method_idx,
   return resolved_method;
 }
 
-inline mirror::Field* ClassLinker::ResolveField(uint32_t field_idx,
-                                                const mirror::AbstractMethod* referrer,
-                                                bool is_static) {
-  mirror::Field* resolved_field =
+inline mirror::ArtField* ClassLinker::ResolveField(uint32_t field_idx,
+                                                   const mirror::ArtMethod* referrer,
+                                                   bool is_static) {
+  mirror::ArtField* resolved_field =
       referrer->GetDeclaringClass()->GetDexCache()->GetResolvedField(field_idx);
   if (UNLIKELY(resolved_field == NULL)) {
     mirror::Class* declaring_class = referrer->GetDeclaringClass();
@@ -109,16 +109,10 @@ inline mirror::ObjectArray<mirror::String>* ClassLinker::AllocStringArray(Thread
                                                     length);
 }
 
-inline mirror::ObjectArray<mirror::AbstractMethod>* ClassLinker::AllocAbstractMethodArray(Thread* self,
-                                                                                          size_t length) {
-  return mirror::ObjectArray<mirror::AbstractMethod>::Alloc(self,
-      GetClassRoot(kJavaLangReflectAbstractMethodArrayClass), length);
-}
-
-inline mirror::ObjectArray<mirror::AbstractMethod>* ClassLinker::AllocMethodArray(Thread* self,
-                                                                                  size_t length) {
-  return mirror::ObjectArray<mirror::AbstractMethod>::Alloc(self,
-      GetClassRoot(kJavaLangReflectMethodArrayClass), length);
+inline mirror::ObjectArray<mirror::ArtMethod>* ClassLinker::AllocArtMethodArray(Thread* self,
+                                                                                size_t length) {
+  return mirror::ObjectArray<mirror::ArtMethod>::Alloc(self,
+      GetClassRoot(kJavaLangReflectArtMethodArrayClass), length);
 }
 
 inline mirror::IfTable* ClassLinker::AllocIfTable(Thread* self, size_t ifcount) {
@@ -126,11 +120,11 @@ inline mirror::IfTable* ClassLinker::AllocIfTable(Thread* self, size_t ifcount)
       mirror::IfTable::Alloc(self, GetClassRoot(kObjectArrayClass), ifcount * mirror::IfTable::kMax));
 }
 
-inline mirror::ObjectArray<mirror::Field>* ClassLinker::AllocFieldArray(Thread* self,
-                                                                        size_t length) {
-  return mirror::ObjectArray<mirror::Field>::Alloc(self,
-                                                   GetClassRoot(kJavaLangReflectFieldArrayClass),
-                                                   length);
+inline mirror::ObjectArray<mirror::ArtField>* ClassLinker::AllocArtFieldArray(Thread* self,
+                                                                              size_t length) {
+  return mirror::ObjectArray<mirror::ArtField>::Alloc(self,
+                                                      GetClassRoot(kJavaLangReflectArtFieldArrayClass),
+                                                      length);
 }
 
 inline mirror::Class* ClassLinker::GetClassRoot(ClassRoot class_root)
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index c7a8f7e3d4..1e21736d66 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -43,14 +43,13 @@
 #include "leb128.h"
 #include "oat.h"
 #include "oat_file.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
 #include "mirror/dex_cache-inl.h"
-#include "mirror/field-inl.h"
 #include "mirror/iftable-inl.h"
-#include "mirror/abstract_method.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/proxy.h"
@@ -145,15 +144,12 @@ const char* ClassLinker::class_roots_descriptors_[] = {
   "Ljava/lang/String;",
   "Ljava/lang/DexCache;",
   "Ljava/lang/ref/Reference;",
-  "Ljava/lang/reflect/Constructor;",
-  "Ljava/lang/reflect/Field;",
-  "Ljava/lang/reflect/AbstractMethod;",
-  "Ljava/lang/reflect/Method;",
+  "Ljava/lang/reflect/ArtField;",
+  "Ljava/lang/reflect/ArtMethod;",
   "Ljava/lang/reflect/Proxy;",
   "[Ljava/lang/String;",
-  "[Ljava/lang/reflect/AbstractMethod;",
-  "[Ljava/lang/reflect/Field;",
-  "[Ljava/lang/reflect/Method;",
+  "[Ljava/lang/reflect/ArtField;",
+  "[Ljava/lang/reflect/ArtMethod;",
   "Ljava/lang/ClassLoader;",
   "Ljava/lang/Throwable;",
   "Ljava/lang/ClassNotFoundException;",
@@ -292,56 +288,38 @@ void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class
   java_lang_DexCache->SetStatus(mirror::Class::kStatusResolved);
 
   // Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
-  SirtRef<mirror::Class> java_lang_reflect_Field(self, AllocClass(self, java_lang_Class.get(),
-                                                          sizeof(mirror::FieldClass)));
-  CHECK(java_lang_reflect_Field.get() != NULL);
-  java_lang_reflect_Field->SetObjectSize(sizeof(mirror::Field));
-  SetClassRoot(kJavaLangReflectField, java_lang_reflect_Field.get());
-  java_lang_reflect_Field->SetStatus(mirror::Class::kStatusResolved);
-  mirror::Field::SetClass(java_lang_reflect_Field.get());
-
-  SirtRef<mirror::Class> java_lang_reflect_AbstractMethod(self, AllocClass(self, java_lang_Class.get(),
-                                                                           sizeof(mirror::AbstractMethodClass)));
-  CHECK(java_lang_reflect_AbstractMethod.get() != NULL);
-  java_lang_reflect_AbstractMethod->SetObjectSize(sizeof(mirror::AbstractMethod));
-  SetClassRoot(kJavaLangReflectAbstractMethod, java_lang_reflect_AbstractMethod.get());
-  java_lang_reflect_AbstractMethod->SetStatus(mirror::Class::kStatusResolved);
-
-  SirtRef<mirror::Class> java_lang_reflect_Constructor(self, AllocClass(self, java_lang_Class.get(),
-                                                                        sizeof(mirror::AbstractMethodClass)));
-  CHECK(java_lang_reflect_Constructor.get() != NULL);
-  java_lang_reflect_Constructor->SetObjectSize(sizeof(mirror::Constructor));
-  java_lang_reflect_Constructor->SetSuperClass(java_lang_reflect_AbstractMethod.get());
-  SetClassRoot(kJavaLangReflectConstructor, java_lang_reflect_Constructor.get());
-  java_lang_reflect_Constructor->SetStatus(mirror::Class::kStatusResolved);
-
-  SirtRef<mirror::Class> java_lang_reflect_Method(self, AllocClass(self, java_lang_Class.get(),
-                                                                   sizeof(mirror::AbstractMethodClass)));
-  CHECK(java_lang_reflect_Method.get() != NULL);
-  java_lang_reflect_Method->SetObjectSize(sizeof(mirror::Method));
-  java_lang_reflect_Method->SetSuperClass(java_lang_reflect_AbstractMethod.get());
-  SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method.get());
-  java_lang_reflect_Method->SetStatus(mirror::Class::kStatusResolved);
-
-  mirror::AbstractMethod::SetClasses(java_lang_reflect_Constructor.get(),
-                                     java_lang_reflect_Method.get());
+  SirtRef<mirror::Class> java_lang_reflect_ArtField(self, AllocClass(self, java_lang_Class.get(),
+                                                                     sizeof(mirror::ArtFieldClass)));
+  CHECK(java_lang_reflect_ArtField.get() != NULL);
+  java_lang_reflect_ArtField->SetObjectSize(sizeof(mirror::ArtField));
+  SetClassRoot(kJavaLangReflectArtField, java_lang_reflect_ArtField.get());
+  java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusResolved);
+  mirror::ArtField::SetClass(java_lang_reflect_ArtField.get());
+
+  SirtRef<mirror::Class> java_lang_reflect_ArtMethod(self, AllocClass(self, java_lang_Class.get(),
+                                                                      sizeof(mirror::ArtMethodClass)));
+  CHECK(java_lang_reflect_ArtMethod.get() != NULL);
+  java_lang_reflect_ArtMethod->SetObjectSize(sizeof(mirror::ArtMethod));
+  SetClassRoot(kJavaLangReflectArtMethod, java_lang_reflect_ArtMethod.get());
+  java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusResolved);
+
+  mirror::ArtMethod::SetClass(java_lang_reflect_ArtMethod.get());
 
   // Set up array classes for string, field, method
-  SirtRef<mirror::Class> object_array_string(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
+  SirtRef<mirror::Class> object_array_string(self, AllocClass(self, java_lang_Class.get(),
+                                                              sizeof(mirror::Class)));
   object_array_string->SetComponentType(java_lang_String.get());
   SetClassRoot(kJavaLangStringArrayClass, object_array_string.get());
 
-  SirtRef<mirror::Class> object_array_abstract_method(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
-  object_array_abstract_method->SetComponentType(java_lang_reflect_AbstractMethod.get());
-  SetClassRoot(kJavaLangReflectAbstractMethodArrayClass, object_array_abstract_method.get());
+  SirtRef<mirror::Class> object_array_art_method(self, AllocClass(self, java_lang_Class.get(),
+                                                                  sizeof(mirror::Class)));
+  object_array_art_method->SetComponentType(java_lang_reflect_ArtMethod.get());
+  SetClassRoot(kJavaLangReflectArtMethodArrayClass, object_array_art_method.get());
 
-  SirtRef<mirror::Class> object_array_field(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
-  object_array_field->SetComponentType(java_lang_reflect_Field.get());
-  SetClassRoot(kJavaLangReflectFieldArrayClass, object_array_field.get());
-
-  SirtRef<mirror::Class> object_array_method(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
-  object_array_method->SetComponentType(java_lang_reflect_Method.get());
-  SetClassRoot(kJavaLangReflectMethodArrayClass, object_array_method.get());
+  SirtRef<mirror::Class> object_array_art_field(self, AllocClass(self, java_lang_Class.get(),
+                                                                 sizeof(mirror::Class)));
+  object_array_art_field->SetComponentType(java_lang_reflect_ArtField.get());
+  SetClassRoot(kJavaLangReflectArtFieldArrayClass, object_array_art_field.get());
 
   // Setup boot_class_path_ and register class_path now that we can use AllocObjectArray to create
   // DexCache instances. Needs to be after String, Field, Method arrays since AllocDexCache uses
@@ -422,42 +400,29 @@ void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class
   kh.ChangeClass(object_array_class.get());
   CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
   CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
-  // Run Class, Constructor, Field, and Method through FindSystemClass. This initializes their
+  // Run Class, ArtField, and ArtMethod through FindSystemClass. This initializes their
   // dex_cache_ fields and register them in classes_.
   mirror::Class* Class_class = FindSystemClass("Ljava/lang/Class;");
   CHECK_EQ(java_lang_Class.get(), Class_class);
 
-  java_lang_reflect_AbstractMethod->SetStatus(mirror::Class::kStatusNotReady);
-  mirror::Class* Abstract_method_class = FindSystemClass("Ljava/lang/reflect/AbstractMethod;");
-  CHECK_EQ(java_lang_reflect_AbstractMethod.get(), Abstract_method_class);
-
-  // Method extends AbstractMethod so must reset after.
-  java_lang_reflect_Method->SetStatus(mirror::Class::kStatusNotReady);
-  mirror::Class* Method_class = FindSystemClass("Ljava/lang/reflect/Method;");
-  CHECK_EQ(java_lang_reflect_Method.get(), Method_class);
+  java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusNotReady);
+  mirror::Class* Art_method_class = FindSystemClass("Ljava/lang/reflect/ArtMethod;");
+  CHECK_EQ(java_lang_reflect_ArtMethod.get(), Art_method_class);
 
-  // Constructor extends AbstractMethod so must reset after.
-  java_lang_reflect_Constructor->SetStatus(mirror::Class::kStatusNotReady);
-  mirror::Class* Constructor_class = FindSystemClass("Ljava/lang/reflect/Constructor;");
-  CHECK_EQ(java_lang_reflect_Constructor.get(), Constructor_class);
-
-  java_lang_reflect_Field->SetStatus(mirror::Class::kStatusNotReady);
-  mirror::Class* Field_class = FindSystemClass("Ljava/lang/reflect/Field;");
-  CHECK_EQ(java_lang_reflect_Field.get(), Field_class);
+  java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusNotReady);
+  mirror::Class* Art_field_class = FindSystemClass("Ljava/lang/reflect/ArtField;");
+  CHECK_EQ(java_lang_reflect_ArtField.get(), Art_field_class);
 
   mirror::Class* String_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangStringArrayClass]);
   CHECK_EQ(object_array_string.get(), String_array_class);
 
-  mirror::Class* Abstract_method_array_class =
-      FindSystemClass(class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]);
-  CHECK_EQ(object_array_abstract_method.get(), Abstract_method_array_class);
-
-  mirror::Class* Field_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangReflectFieldArrayClass]);
-  CHECK_EQ(object_array_field.get(), Field_array_class);
+  mirror::Class* Art_method_array_class =
+      FindSystemClass(class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]);
+  CHECK_EQ(object_array_art_method.get(), Art_method_array_class);
 
-  mirror::Class* Method_array_class =
-      FindSystemClass(class_roots_descriptors_[kJavaLangReflectMethodArrayClass]);
-  CHECK_EQ(object_array_method.get(), Method_array_class);
+  mirror::Class* Art_field_array_class =
+      FindSystemClass(class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]);
+  CHECK_EQ(object_array_art_field.get(), Art_field_array_class);
 
   // End of special init trickery, subsequent classes may be loaded via FindSystemClass.
 
@@ -516,31 +481,31 @@ void ClassLinker::FinishInit() {
 
   const DexFile& java_lang_dex = *java_lang_ref_Reference->GetDexCache()->GetDexFile();
 
-  mirror::Field* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
+  mirror::ArtField* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
   FieldHelper fh(pendingNext, this);
   CHECK_STREQ(fh.GetName(), "pendingNext");
   CHECK_EQ(java_lang_dex.GetFieldId(pendingNext->GetDexFieldIndex()).type_idx_,
            java_lang_ref_Reference->GetDexTypeIndex());
 
-  mirror::Field* queue = java_lang_ref_Reference->GetInstanceField(1);
+  mirror::ArtField* queue = java_lang_ref_Reference->GetInstanceField(1);
   fh.ChangeField(queue);
   CHECK_STREQ(fh.GetName(), "queue");
   CHECK_EQ(java_lang_dex.GetFieldId(queue->GetDexFieldIndex()).type_idx_,
            java_lang_ref_ReferenceQueue->GetDexTypeIndex());
 
-  mirror::Field* queueNext = java_lang_ref_Reference->GetInstanceField(2);
+  mirror::ArtField* queueNext = java_lang_ref_Reference->GetInstanceField(2);
   fh.ChangeField(queueNext);
   CHECK_STREQ(fh.GetName(), "queueNext");
   CHECK_EQ(java_lang_dex.GetFieldId(queueNext->GetDexFieldIndex()).type_idx_,
            java_lang_ref_Reference->GetDexTypeIndex());
 
-  mirror::Field* referent = java_lang_ref_Reference->GetInstanceField(3);
+  mirror::ArtField* referent = java_lang_ref_Reference->GetInstanceField(3);
   fh.ChangeField(referent);
   CHECK_STREQ(fh.GetName(), "referent");
   CHECK_EQ(java_lang_dex.GetFieldId(referent->GetDexFieldIndex()).type_idx_,
            GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
 
-  mirror::Field* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
+  mirror::ArtField* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
   fh.ChangeField(zombie);
   CHECK_STREQ(fh.GetName(), "zombie");
   CHECK_EQ(java_lang_dex.GetFieldId(zombie->GetDexFieldIndex()).type_idx_,
@@ -958,8 +923,8 @@ static void InitFromImageCallbackCommon(mirror::Object* obj, ClassLinker* class_
     ClassHelper kh(klass, class_linker);
     mirror::Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
     DCHECK(existing == NULL) << kh.GetDescriptor();
-  } else if (interpret_only_mode && obj->IsMethod()) {
-    mirror::AbstractMethod* method = obj->AsMethod();
+  } else if (interpret_only_mode && obj->IsArtMethod()) {
+    mirror::ArtMethod* method = obj->AsArtMethod();
     if (!method->IsNative()) {
       method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
       if (method != Runtime::Current()->GetResolutionMethod()) {
@@ -1027,8 +992,7 @@ void ClassLinker::InitFromImage() {
 
   // Set classes on AbstractMethod early so that IsMethod tests can be performed during the live
   // bitmap walk.
-  mirror::AbstractMethod::SetClasses(GetClassRoot(kJavaLangReflectConstructor),
-                                     GetClassRoot(kJavaLangReflectMethod));
+  mirror::ArtMethod::SetClass(GetClassRoot(kJavaLangReflectArtMethod));
 
   // reinit clases_ table
   {
@@ -1049,7 +1013,7 @@ void ClassLinker::InitFromImage() {
   array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
   DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
   // String class root was set above
-  mirror::Field::SetClass(GetClassRoot(kJavaLangReflectField));
+  mirror::ArtField::SetClass(GetClassRoot(kJavaLangReflectArtField));
   mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
   mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
   mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
@@ -1132,8 +1096,8 @@ void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* ar
 ClassLinker::~ClassLinker() {
   mirror::Class::ResetClass();
   mirror::String::ResetClass();
-  mirror::Field::ResetClass();
-  mirror::AbstractMethod::ResetClasses();
+  mirror::ArtField::ResetClass();
+  mirror::ArtMethod::ResetClass();
   mirror::BooleanArray::ResetArrayClass();
   mirror::ByteArray::ResetArrayClass();
   mirror::CharArray::ResetArrayClass();
@@ -1172,13 +1136,13 @@ mirror::DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_fi
   if (types.get() == NULL) {
     return NULL;
   }
-  SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
-      methods(self, AllocAbstractMethodArray(self, dex_file.NumMethodIds()));
+  SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
+      methods(self, AllocArtMethodArray(self, dex_file.NumMethodIds()));
   if (methods.get() == NULL) {
     return NULL;
   }
-  SirtRef<mirror::ObjectArray<mirror::Field> >
-      fields(self, AllocFieldArray(self, dex_file.NumFieldIds()));
+  SirtRef<mirror::ObjectArray<mirror::ArtField> >
+      fields(self, AllocArtFieldArray(self, dex_file.NumFieldIds()));
   if (fields.get() == NULL) {
     return NULL;
   }
@@ -1214,16 +1178,12 @@ mirror::Class* ClassLinker::AllocClass(Thread* self, size_t class_size) {
   return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
 }
 
-mirror::Field* ClassLinker::AllocField(Thread* self) {
-  return down_cast<mirror::Field*>(GetClassRoot(kJavaLangReflectField)->AllocObject(self));
+mirror::ArtField* ClassLinker::AllocArtField(Thread* self) {
+  return down_cast<mirror::ArtField*>(GetClassRoot(kJavaLangReflectArtField)->AllocObject(self));
 }
 
-mirror::Method* ClassLinker::AllocMethod(Thread* self) {
-  return down_cast<mirror::Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject(self));
-}
-
-mirror::Constructor* ClassLinker::AllocConstructor(Thread* self) {
-  return down_cast<mirror::Constructor*>(GetClassRoot(kJavaLangReflectConstructor)->AllocObject(self));
+mirror::ArtMethod* ClassLinker::AllocArtMethod(Thread* self) {
+  return down_cast<mirror::ArtMethod*>(GetClassRoot(kJavaLangReflectArtMethod)->AllocObject(self));
 }
 
 mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray(Thread* self,
@@ -1364,14 +1324,10 @@ mirror::Class* ClassLinker::DefineClass(const StringPiece& descriptor,
       klass.reset(GetClassRoot(kJavaLangString));
     } else if (descriptor == "Ljava/lang/DexCache;") {
       klass.reset(GetClassRoot(kJavaLangDexCache));
-    } else if (descriptor == "Ljava/lang/reflect/Field;") {
-      klass.reset(GetClassRoot(kJavaLangReflectField));
-    } else if (descriptor == "Ljava/lang/reflect/AbstractMethod;") {
-      klass.reset(GetClassRoot(kJavaLangReflectAbstractMethod));
-    } else if (descriptor == "Ljava/lang/reflect/Constructor;") {
-      klass.reset(GetClassRoot(kJavaLangReflectConstructor));
-    } else if (descriptor == "Ljava/lang/reflect/Method;") {
-      klass.reset(GetClassRoot(kJavaLangReflectMethod));
+    } else if (descriptor == "Ljava/lang/reflect/ArtField;") {
+      klass.reset(GetClassRoot(kJavaLangReflectArtField));
+    } else if (descriptor == "Ljava/lang/reflect/ArtMethod;") {
+      klass.reset(GetClassRoot(kJavaLangReflectArtMethod));
     } else {
       klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
     }
@@ -1519,7 +1475,7 @@ static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, uint32
   return 0;
 }
 
-const OatFile::OatMethod ClassLinker::GetOatMethodFor(const mirror::AbstractMethod* method) {
+const OatFile::OatMethod ClassLinker::GetOatMethodFor(const mirror::ArtMethod* method) {
   // 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();
@@ -1553,7 +1509,7 @@ const OatFile::OatMethod ClassLinker::GetOatMethodFor(const mirror::AbstractMeth
 }
 
 // Special case to get oat code without overwriting a trampoline.
-const void* ClassLinker::GetOatCodeFor(const mirror::AbstractMethod* method) {
+const void* ClassLinker::GetOatCodeFor(const mirror::ArtMethod* method) {
   CHECK(!method->IsAbstract()) << PrettyMethod(method);
   if (method->IsProxyMethod()) {
 #if !defined(ART_USE_PORTABLE_COMPILER)
@@ -1580,7 +1536,7 @@ const void* ClassLinker::GetOatCodeFor(const DexFile& dex_file, uint32_t method_
 }
 
 // Returns true if the method must run with interpreter, false otherwise.
-static bool NeedsInterpreter(const mirror::AbstractMethod* method, const void* code) {
+static bool NeedsInterpreter(const mirror::ArtMethod* method, const void* code) {
   if (code == NULL) {
     // No code: need interpreter.
     return true;
@@ -1617,7 +1573,7 @@ void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) {
   }
   // Link the code of methods skipped by LinkCode
   for (size_t method_index = 0; it.HasNextDirectMethod(); ++method_index, it.Next()) {
-    mirror::AbstractMethod* method = klass->GetDirectMethod(method_index);
+    mirror::ArtMethod* method = klass->GetDirectMethod(method_index);
     if (!method->IsStatic()) {
       // Only update static methods.
       continue;
@@ -1633,7 +1589,7 @@ void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) {
   // Ignore virtual methods on the iterator.
 }
 
-static void LinkCode(SirtRef<mirror::AbstractMethod>& method, const OatFile::OatClass* oat_class,
+static void LinkCode(SirtRef<mirror::ArtMethod>& method, const OatFile::OatClass* oat_class,
                      uint32_t method_index)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Method shouldn't have already been linked.
@@ -1707,18 +1663,18 @@ void ClassLinker::LoadClass(const DexFile& dex_file,
   ClassDataItemIterator it(dex_file, class_data);
   Thread* self = Thread::Current();
   if (it.NumStaticFields() != 0) {
-    klass->SetSFields(AllocFieldArray(self, it.NumStaticFields()));
+    klass->SetSFields(AllocArtFieldArray(self, it.NumStaticFields()));
   }
   if (it.NumInstanceFields() != 0) {
-    klass->SetIFields(AllocFieldArray(self, it.NumInstanceFields()));
+    klass->SetIFields(AllocArtFieldArray(self, it.NumInstanceFields()));
   }
   for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
-    SirtRef<mirror::Field> sfield(self, AllocField(self));
+    SirtRef<mirror::ArtField> sfield(self, AllocArtField(self));
     klass->SetStaticField(i, sfield.get());
     LoadField(dex_file, it, klass, sfield);
   }
   for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
-    SirtRef<mirror::Field> ifield(self, AllocField(self));
+    SirtRef<mirror::ArtField> ifield(self, AllocArtField(self));
     klass->SetInstanceField(i, ifield.get());
     LoadField(dex_file, it, klass, ifield);
   }
@@ -1731,15 +1687,15 @@ void ClassLinker::LoadClass(const DexFile& dex_file,
   // Load methods.
   if (it.NumDirectMethods() != 0) {
     // TODO: append direct methods to class object
-    klass->SetDirectMethods(AllocAbstractMethodArray(self, it.NumDirectMethods()));
+    klass->SetDirectMethods(AllocArtMethodArray(self, it.NumDirectMethods()));
   }
   if (it.NumVirtualMethods() != 0) {
     // TODO: append direct methods to class object
-    klass->SetVirtualMethods(AllocMethodArray(self, it.NumVirtualMethods()));
+    klass->SetVirtualMethods(AllocArtMethodArray(self, it.NumVirtualMethods()));
   }
   size_t class_def_method_index = 0;
   for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
-    SirtRef<mirror::AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
+    SirtRef<mirror::ArtMethod> method(self, LoadMethod(self, dex_file, it, klass));
     klass->SetDirectMethod(i, method.get());
     if (oat_class.get() != NULL) {
       LinkCode(method, oat_class.get(), class_def_method_index);
@@ -1748,7 +1704,7 @@ void ClassLinker::LoadClass(const DexFile& dex_file,
     class_def_method_index++;
   }
   for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
-    SirtRef<mirror::AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
+    SirtRef<mirror::ArtMethod> method(self, LoadMethod(self, dex_file, it, klass));
     klass->SetVirtualMethod(i, method.get());
     DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
     if (oat_class.get() != NULL) {
@@ -1760,27 +1716,22 @@ void ClassLinker::LoadClass(const DexFile& dex_file,
 }
 
 void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
-                            SirtRef<mirror::Class>& klass, SirtRef<mirror::Field>& dst) {
+                            SirtRef<mirror::Class>& klass, SirtRef<mirror::ArtField>& dst) {
   uint32_t field_idx = it.GetMemberIndex();
   dst->SetDexFieldIndex(field_idx);
   dst->SetDeclaringClass(klass.get());
   dst->SetAccessFlags(it.GetMemberAccessFlags());
 }
 
-mirror::AbstractMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
+mirror::ArtMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
                                                 const ClassDataItemIterator& it,
                                                 SirtRef<mirror::Class>& klass) {
   uint32_t dex_method_idx = it.GetMemberIndex();
   const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
   StringPiece method_name(dex_file.GetMethodName(method_id));
 
-  mirror::AbstractMethod* dst = NULL;
-  if (method_name == "<init>") {
-    dst = AllocConstructor(self);
-  } else {
-    dst = AllocMethod(self);
-  }
-  DCHECK(dst->IsMethod()) << PrettyDescriptor(dst->GetClass());
+  mirror::ArtMethod* dst = AllocArtMethod(self);
+  DCHECK(dst->IsArtMethod()) << PrettyDescriptor(dst->GetClass());
 
   const char* old_cause = self->StartAssertNoThreadSuspension("LoadMethod");
   dst->SetDexMethodIndex(dex_method_idx);
@@ -1824,7 +1775,7 @@ mirror::AbstractMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex
   dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
   dst->SetDexCacheInitializedStaticStorage(klass->GetDexCache()->GetInitializedStaticStorage());
 
-  CHECK(dst->IsMethod());
+  CHECK(dst->IsArtMethod());
 
   self->EndAssertNoThreadSuspension(old_cause);
   return dst;
@@ -1918,7 +1869,7 @@ mirror::DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
   return NULL;
 }
 
-void ClassLinker::FixupDexCaches(mirror::AbstractMethod* resolution_method) const {
+void ClassLinker::FixupDexCaches(mirror::ArtMethod* resolution_method) const {
   ReaderMutexLock mu(Thread::Current(), dex_lock_);
   for (size_t i = 0; i != dex_caches_.size(); ++i) {
     dex_caches_[i]->Fixup(resolution_method);
@@ -2007,12 +1958,10 @@ mirror::Class* ClassLinker::CreateArrayClass(const std::string& descriptor,
       new_class.reset(GetClassRoot(kObjectArrayClass));
     } else if (descriptor == class_roots_descriptors_[kJavaLangStringArrayClass]) {
       new_class.reset(GetClassRoot(kJavaLangStringArrayClass));
-    } else if (descriptor == class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]) {
-      new_class.reset(GetClassRoot(kJavaLangReflectAbstractMethodArrayClass));
-    } else if (descriptor == class_roots_descriptors_[kJavaLangReflectFieldArrayClass]) {
-      new_class.reset(GetClassRoot(kJavaLangReflectFieldArrayClass));
-    } else if (descriptor == class_roots_descriptors_[kJavaLangReflectMethodArrayClass]) {
-      new_class.reset(GetClassRoot(kJavaLangReflectMethodArrayClass));
+    } else if (descriptor == class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]) {
+      new_class.reset(GetClassRoot(kJavaLangReflectArtMethodArrayClass));
+    } else if (descriptor == class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]) {
+      new_class.reset(GetClassRoot(kJavaLangReflectArtFieldArrayClass));
     } else if (descriptor == "[C") {
       new_class.reset(GetClassRoot(kCharArrayClass));
     } else if (descriptor == "[I") {
@@ -2428,7 +2377,7 @@ void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, mir
 }
 
 void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file,
-                                                     mirror::AbstractMethod* method) {
+                                                     mirror::ArtMethod* method) {
   // similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
   const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
   if (code_item == NULL) {
@@ -2457,14 +2406,14 @@ void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file,
   }
 }
 
-static void CheckProxyConstructor(mirror::AbstractMethod* constructor);
-static void CheckProxyMethod(mirror::AbstractMethod* method,
-                             SirtRef<mirror::AbstractMethod>& prototype);
+static void CheckProxyConstructor(mirror::ArtMethod* constructor);
+static void CheckProxyMethod(mirror::ArtMethod* method,
+                             SirtRef<mirror::ArtMethod>& prototype);
 
 mirror::Class* ClassLinker::CreateProxyClass(mirror::String* name,
                                              mirror::ObjectArray<mirror::Class>* interfaces,
                                              mirror::ClassLoader* loader,
-                                             mirror::ObjectArray<mirror::AbstractMethod>* methods,
+                                             mirror::ObjectArray<mirror::ArtMethod>* methods,
                                              mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >* throws) {
   Thread* self = Thread::Current();
   SirtRef<mirror::Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
@@ -2484,30 +2433,30 @@ mirror::Class* ClassLinker::CreateProxyClass(mirror::String* name,
   klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
 
   // Instance fields are inherited, but we add a couple of static fields...
-  klass->SetSFields(AllocFieldArray(self, 2));
+  klass->SetSFields(AllocArtFieldArray(self, 2));
   // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
   // our proxy, so Class.getInterfaces doesn't return the flattened set.
-  SirtRef<mirror::Field> interfaces_sfield(self, AllocField(self));
+  SirtRef<mirror::ArtField> interfaces_sfield(self, AllocArtField(self));
   klass->SetStaticField(0, interfaces_sfield.get());
   interfaces_sfield->SetDexFieldIndex(0);
   interfaces_sfield->SetDeclaringClass(klass.get());
   interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
   // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
-  SirtRef<mirror::Field> throws_sfield(self, AllocField(self));
+  SirtRef<mirror::ArtField> throws_sfield(self, AllocArtField(self));
   klass->SetStaticField(1, throws_sfield.get());
   throws_sfield->SetDexFieldIndex(1);
   throws_sfield->SetDeclaringClass(klass.get());
   throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
 
   // Proxies have 1 direct method, the constructor
-  klass->SetDirectMethods(AllocAbstractMethodArray(self, 1));
+  klass->SetDirectMethods(AllocArtMethodArray(self, 1));
   klass->SetDirectMethod(0, CreateProxyConstructor(self, klass, proxy_class));
 
   // Create virtual method using specified prototypes
   size_t num_virtual_methods = methods->GetLength();
-  klass->SetVirtualMethods(AllocMethodArray(self, num_virtual_methods));
+  klass->SetVirtualMethods(AllocArtMethodArray(self, num_virtual_methods));
   for (size_t i = 0; i < num_virtual_methods; ++i) {
-    SirtRef<mirror::AbstractMethod> prototype(self, methods->Get(i));
+    SirtRef<mirror::ArtMethod> prototype(self, methods->Get(i));
     klass->SetVirtualMethod(i, CreateProxyMethod(self, klass, prototype));
   }
 
@@ -2532,7 +2481,7 @@ mirror::Class* ClassLinker::CreateProxyClass(mirror::String* name,
     CHECK(klass->GetIFields() == NULL);
     CheckProxyConstructor(klass->GetDirectMethod(0));
     for (size_t i = 0; i < num_virtual_methods; ++i) {
-      SirtRef<mirror::AbstractMethod> prototype(self, methods->Get(i));
+      SirtRef<mirror::ArtMethod> prototype(self, methods->Get(i));
       CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
     }
 
@@ -2559,8 +2508,8 @@ std::string ClassLinker::GetDescriptorForProxy(const mirror::Class* proxy_class)
   return DotToDescriptor(name->ToModifiedUtf8().c_str());
 }
 
-mirror::AbstractMethod* ClassLinker::FindMethodForProxy(const mirror::Class* proxy_class,
-                                                        const mirror::AbstractMethod* proxy_method) {
+mirror::ArtMethod* ClassLinker::FindMethodForProxy(const mirror::Class* proxy_class,
+                                                        const mirror::ArtMethod* proxy_method) {
   DCHECK(proxy_class->IsProxyClass());
   DCHECK(proxy_method->IsProxyMethod());
   // Locate the dex cache of the original interface/Object
@@ -2577,31 +2526,31 @@ mirror::AbstractMethod* ClassLinker::FindMethodForProxy(const mirror::Class* pro
   }
   CHECK(dex_cache != NULL);
   uint32_t method_idx = proxy_method->GetDexMethodIndex();
-  mirror::AbstractMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
+  mirror::ArtMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
   CHECK(resolved_method != NULL);
   return resolved_method;
 }
 
 
-mirror::AbstractMethod* ClassLinker::CreateProxyConstructor(Thread* self,
-                                                            SirtRef<mirror::Class>& klass,
-                                                            mirror::Class* proxy_class) {
+mirror::ArtMethod* ClassLinker::CreateProxyConstructor(Thread* self,
+                                                       SirtRef<mirror::Class>& klass,
+                                                       mirror::Class* proxy_class) {
   // Create constructor for Proxy that must initialize h
-  mirror::ObjectArray<mirror::AbstractMethod>* proxy_direct_methods =
+  mirror::ObjectArray<mirror::ArtMethod>* proxy_direct_methods =
       proxy_class->GetDirectMethods();
-  CHECK_EQ(proxy_direct_methods->GetLength(), 15);
-  mirror::AbstractMethod* proxy_constructor = proxy_direct_methods->Get(2);
+  CHECK_EQ(proxy_direct_methods->GetLength(), 16);
+  mirror::ArtMethod* proxy_constructor = proxy_direct_methods->Get(2);
   // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
   // code_ too)
-  mirror::AbstractMethod* constructor =
-      down_cast<mirror::AbstractMethod*>(proxy_constructor->Clone(self));
+  mirror::ArtMethod* constructor =
+      down_cast<mirror::ArtMethod*>(proxy_constructor->Clone(self));
   // Make this constructor public and fix the class to be our Proxy version
   constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
   constructor->SetDeclaringClass(klass.get());
   return constructor;
 }
 
-static void CheckProxyConstructor(mirror::AbstractMethod* constructor)
+static void CheckProxyConstructor(mirror::ArtMethod* constructor)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   CHECK(constructor->IsConstructor());
   MethodHelper mh(constructor);
@@ -2610,15 +2559,15 @@ static void CheckProxyConstructor(mirror::AbstractMethod* constructor)
   DCHECK(constructor->IsPublic());
 }
 
-mirror::AbstractMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
-                                                       SirtRef<mirror::AbstractMethod>& prototype) {
+mirror::ArtMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
+                                                       SirtRef<mirror::ArtMethod>& prototype) {
   // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
   // prototype method
   prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
                                                                    prototype.get());
   // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
   // as necessary
-  mirror::AbstractMethod* method = down_cast<mirror::AbstractMethod*>(prototype->Clone(self));
+  mirror::ArtMethod* method = down_cast<mirror::ArtMethod*>(prototype->Clone(self));
 
   // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
   // the intersection of throw exceptions as defined in Proxy
@@ -2627,7 +2576,7 @@ mirror::AbstractMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<mir
 
   // At runtime the method looks like a reference and argument saving method, clone the code
   // related parameters from this method.
-  mirror::AbstractMethod* refs_and_args =
+  mirror::ArtMethod* refs_and_args =
       Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
   method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
   method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
@@ -2638,8 +2587,8 @@ mirror::AbstractMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<mir
   return method;
 }
 
-static void CheckProxyMethod(mirror::AbstractMethod* method,
-                             SirtRef<mirror::AbstractMethod>& prototype)
+static void CheckProxyMethod(mirror::ArtMethod* method,
+                             SirtRef<mirror::ArtMethod>& prototype)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Basic sanity
   CHECK(!prototype->IsFinal());
@@ -2669,7 +2618,7 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, boo
 
   Thread* self = Thread::Current();
 
-  mirror::AbstractMethod* clinit = NULL;
+  mirror::ArtMethod* clinit = NULL;
   {
     // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
     ObjectLock lock(self, klass);
@@ -2842,7 +2791,7 @@ bool ClassLinker::ValidateSuperClassDescriptors(const mirror::Class* klass) {
       klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
     const mirror::Class* super = klass->GetSuperClass();
     for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
-      const mirror::AbstractMethod* method = klass->GetVTable()->Get(i);
+      const mirror::ArtMethod* method = klass->GetVTable()->Get(i);
       if (method != super->GetVTable()->Get(i) &&
           !IsSameMethodSignatureInDifferentClassContexts(method, super, klass)) {
         ThrowLinkageError(klass, "Class %s method %s resolves differently in superclass %s",
@@ -2857,7 +2806,7 @@ bool ClassLinker::ValidateSuperClassDescriptors(const mirror::Class* klass) {
     mirror::Class* interface = iftable->GetInterface(i);
     if (klass->GetClassLoader() != interface->GetClassLoader()) {
       for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
-        const mirror::AbstractMethod* method = iftable->GetMethodArray(i)->Get(j);
+        const mirror::ArtMethod* method = iftable->GetMethodArray(i)->Get(j);
         if (!IsSameMethodSignatureInDifferentClassContexts(method, interface,
                                                            method->GetDeclaringClass())) {
           ThrowLinkageError(klass, "Class %s method %s resolves differently in interface %s",
@@ -2874,7 +2823,7 @@ bool ClassLinker::ValidateSuperClassDescriptors(const mirror::Class* klass) {
 
 // Returns true if classes referenced by the signature of the method are the
 // same classes in klass1 as they are in klass2.
-bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const mirror::AbstractMethod* method,
+bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const mirror::ArtMethod* method,
                                                                 const mirror::Class* klass1,
                                                                 const mirror::Class* klass2) {
   if (klass1 == klass2) {
@@ -2969,7 +2918,7 @@ bool ClassLinker::EnsureInitialized(mirror::Class* c, bool can_run_clinit, bool
 }
 
 void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
-                                    mirror::Class* c, SafeMap<uint32_t, mirror::Field*>& field_map) {
+                                    mirror::Class* c, SafeMap<uint32_t, mirror::ArtField*>& field_map) {
   mirror::ClassLoader* cl = c->GetClassLoader();
   const byte* class_data = dex_file.GetClassData(dex_class_def);
   ClassDataItemIterator it(dex_file, class_data);
@@ -2997,7 +2946,7 @@ bool ClassLinker::InitializeStaticFields(mirror::Class* klass) {
 
   if (it.HasNext()) {
     // We reordered the fields, so we need to be able to map the field indexes to the right fields.
-    SafeMap<uint32_t, mirror::Field*> field_map;
+    SafeMap<uint32_t, mirror::ArtField*> field_map;
     ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
     for (size_t i = 0; it.HasNext(); i++, it.Next()) {
       it.ReadValueToField(field_map.Get(i));
@@ -3161,17 +3110,17 @@ bool ClassLinker::LinkVirtualMethods(SirtRef<mirror::Class>& klass) {
     size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
     CHECK_LE(actual_count, max_count);
     // TODO: do not assign to the vtable field until it is fully constructed.
-    SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
+    SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
       vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(self, max_count));
     // See if any of our virtual methods override the superclass.
     MethodHelper local_mh(NULL, this);
     MethodHelper super_mh(NULL, this);
     for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
-      mirror::AbstractMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
+      mirror::ArtMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
       local_mh.ChangeMethod(local_method);
       size_t j = 0;
       for (; j < actual_count; ++j) {
-        mirror::AbstractMethod* super_method = vtable->Get(j);
+        mirror::ArtMethod* super_method = vtable->Get(j);
         super_mh.ChangeMethod(super_method);
         if (local_mh.HasSameNameAndSignature(&super_mh)) {
           if (klass->CanAccessMember(super_method->GetDeclaringClass(), super_method->GetAccessFlags())) {
@@ -3215,10 +3164,10 @@ bool ClassLinker::LinkVirtualMethods(SirtRef<mirror::Class>& klass) {
       ThrowClassFormatError(klass.get(), "Too many methods: %d", num_virtual_methods);
       return false;
     }
-    SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
-        vtable(self, AllocMethodArray(self, num_virtual_methods));
+    SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
+        vtable(self, AllocArtMethodArray(self, num_virtual_methods));
     for (size_t i = 0; i < num_virtual_methods; ++i) {
-      mirror::AbstractMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
+      mirror::ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
       vtable->Set(i, virtual_method);
       virtual_method->SetMethodIndex(i & 0xFFFF);
     }
@@ -3328,19 +3277,19 @@ bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
   if (klass->IsInterface()) {
     return true;
   }
-  std::vector<mirror::AbstractMethod*> miranda_list;
+  std::vector<mirror::ArtMethod*> miranda_list;
   MethodHelper vtable_mh(NULL, this);
   MethodHelper interface_mh(NULL, this);
   for (size_t i = 0; i < ifcount; ++i) {
     mirror::Class* interface = iftable->GetInterface(i);
     size_t num_methods = interface->NumVirtualMethods();
     if (num_methods > 0) {
-      mirror::ObjectArray<mirror::AbstractMethod>* method_array =
-          AllocMethodArray(self, num_methods);
+      mirror::ObjectArray<mirror::ArtMethod>* method_array =
+          AllocArtMethodArray(self, num_methods);
       iftable->SetMethodArray(i, method_array);
-      mirror::ObjectArray<mirror::AbstractMethod>* vtable = klass->GetVTableDuringLinking();
+      mirror::ObjectArray<mirror::ArtMethod>* vtable = klass->GetVTableDuringLinking();
       for (size_t j = 0; j < num_methods; ++j) {
-        mirror::AbstractMethod* interface_method = interface->GetVirtualMethod(j);
+        mirror::ArtMethod* interface_method = interface->GetVirtualMethod(j);
         interface_mh.ChangeMethod(interface_method);
         int32_t k;
         // For each method listed in the interface's method list, find the
@@ -3352,7 +3301,7 @@ bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
         // those don't end up in the virtual method table, so it shouldn't
         // matter which direction we go.  We walk it backward anyway.)
         for (k = vtable->GetLength() - 1; k >= 0; --k) {
-          mirror::AbstractMethod* vtable_method = vtable->Get(k);
+          mirror::ArtMethod* vtable_method = vtable->Get(k);
           vtable_mh.ChangeMethod(vtable_method);
           if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
             if (!vtable_method->IsAbstract() && !vtable_method->IsPublic()) {
@@ -3367,9 +3316,9 @@ bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
           }
         }
         if (k < 0) {
-          SirtRef<mirror::AbstractMethod> miranda_method(self, NULL);
+          SirtRef<mirror::ArtMethod> miranda_method(self, NULL);
           for (size_t mir = 0; mir < miranda_list.size(); mir++) {
-            mirror::AbstractMethod* mir_method = miranda_list[mir];
+            mirror::ArtMethod* mir_method = miranda_list[mir];
             vtable_mh.ChangeMethod(mir_method);
             if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
               miranda_method.reset(miranda_list[mir]);
@@ -3378,7 +3327,7 @@ bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
           }
           if (miranda_method.get() == NULL) {
             // point the interface table at a phantom slot
-            miranda_method.reset(down_cast<mirror::AbstractMethod*>(interface_method->Clone(self)));
+            miranda_method.reset(down_cast<mirror::ArtMethod*>(interface_method->Clone(self)));
             miranda_list.push_back(miranda_method.get());
           }
           method_array->Set(j, miranda_method.get());
@@ -3390,17 +3339,17 @@ bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
     int old_method_count = klass->NumVirtualMethods();
     int new_method_count = old_method_count + miranda_list.size();
     klass->SetVirtualMethods((old_method_count == 0)
-                             ? AllocMethodArray(self, new_method_count)
+                             ? AllocArtMethodArray(self, new_method_count)
                              : klass->GetVirtualMethods()->CopyOf(self, new_method_count));
 
-    SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
+    SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
         vtable(self, klass->GetVTableDuringLinking());
     CHECK(vtable.get() != NULL);
     int old_vtable_count = vtable->GetLength();
     int new_vtable_count = old_vtable_count + miranda_list.size();
     vtable.reset(vtable->CopyOf(self, new_vtable_count));
     for (size_t i = 0; i < miranda_list.size(); ++i) {
-      mirror::AbstractMethod* method = miranda_list[i];
+      mirror::ArtMethod* method = miranda_list[i];
       // Leave the declaring class alone as type indices are relative to it
       method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
       method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
@@ -3411,7 +3360,7 @@ bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
     klass->SetVTable(vtable.get());
   }
 
-  mirror::ObjectArray<mirror::AbstractMethod>* vtable = klass->GetVTableDuringLinking();
+  mirror::ObjectArray<mirror::ArtMethod>* vtable = klass->GetVTableDuringLinking();
   for (int i = 0; i < vtable->GetLength(); ++i) {
     CHECK(vtable->Get(i) != NULL);
   }
@@ -3439,7 +3388,7 @@ struct LinkFieldsComparator {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
       : fh_(fh) {}
   // No thread safety analysis as will be called from STL. Checked lock held in constructor.
-  bool operator()(const mirror::Field* field1, const mirror::Field* field2)
+  bool operator()(const mirror::ArtField* field1, const mirror::ArtField* field2)
       NO_THREAD_SAFETY_ANALYSIS {
     // First come reference fields, then 64-bit, and finally 32-bit
     fh_->ChangeField(field1);
@@ -3471,7 +3420,7 @@ bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
   size_t num_fields =
       is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
 
-  mirror::ObjectArray<mirror::Field>* fields =
+  mirror::ObjectArray<mirror::ArtField>* fields =
       is_static ? klass->GetSFields() : klass->GetIFields();
 
   // Initialize size and field_offset
@@ -3493,7 +3442,7 @@ bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
 
   // we want a relatively stable order so that adding new fields
   // minimizes disruption of C++ version such as Class and Method.
-  std::deque<mirror::Field*> grouped_and_sorted_fields;
+  std::deque<mirror::ArtField*> grouped_and_sorted_fields;
   for (size_t i = 0; i < num_fields; i++) {
     grouped_and_sorted_fields.push_back(fields->Get(i));
   }
@@ -3506,7 +3455,7 @@ bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
   size_t current_field = 0;
   size_t num_reference_fields = 0;
   for (; current_field < num_fields; current_field++) {
-    mirror::Field* field = grouped_and_sorted_fields.front();
+    mirror::ArtField* field = grouped_and_sorted_fields.front();
     fh.ChangeField(field);
     Primitive::Type type = fh.GetTypeAsPrimitiveType();
     bool isPrimitive = type != Primitive::kPrimNot;
@@ -3525,7 +3474,7 @@ bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
   // into place.  If we can't find one, we'll have to pad it.
   if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
     for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
-      mirror::Field* field = grouped_and_sorted_fields[i];
+      mirror::ArtField* field = grouped_and_sorted_fields[i];
       fh.ChangeField(field);
       Primitive::Type type = fh.GetTypeAsPrimitiveType();
       CHECK(type != Primitive::kPrimNot);  // should only be working on primitive types
@@ -3546,7 +3495,7 @@ bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
   // finish assigning field offsets to all fields.
   DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
   while (!grouped_and_sorted_fields.empty()) {
-    mirror::Field* field = grouped_and_sorted_fields.front();
+    mirror::ArtField* field = grouped_and_sorted_fields.front();
     grouped_and_sorted_fields.pop_front();
     fh.ChangeField(field);
     Primitive::Type type = fh.GetTypeAsPrimitiveType();
@@ -3576,12 +3525,12 @@ bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
   // non-reference fields, and all double-wide fields are aligned.
   bool seen_non_ref = false;
   for (size_t i = 0; i < num_fields; i++) {
-    mirror::Field* field = fields->Get(i);
+    mirror::ArtField* field = fields->Get(i);
     if (false) {  // enable to debug field layout
       LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
                 << " class=" << PrettyClass(klass.get())
                 << " field=" << PrettyField(field)
-                << " offset=" << field->GetField32(MemberOffset(mirror::Field::OffsetOffset()),
+                << " offset=" << field->GetField32(MemberOffset(mirror::ArtField::OffsetOffset()),
                                                    false);
     }
     fh.ChangeField(field);
@@ -3644,14 +3593,14 @@ void ClassLinker::CreateReferenceOffsets(SirtRef<mirror::Class>& klass, bool is_
   size_t num_reference_fields =
       is_static ? klass->NumReferenceStaticFieldsDuringLinking()
                 : klass->NumReferenceInstanceFieldsDuringLinking();
-  const mirror::ObjectArray<mirror::Field>* fields =
+  const mirror::ObjectArray<mirror::ArtField>* fields =
       is_static ? klass->GetSFields() : klass->GetIFields();
   // All of the fields that contain object references are guaranteed
   // to be at the beginning of the fields list.
   for (size_t i = 0; i < num_reference_fields; ++i) {
     // Note that byte_offset is the offset from the beginning of
     // object, not the offset into instance data
-    const mirror::Field* field = fields->Get(i);
+    const mirror::ArtField* field = fields->Get(i);
     MemberOffset byte_offset = field->GetOffsetDuringLinking();
     CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
     if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
@@ -3716,15 +3665,15 @@ mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file,
   return resolved;
 }
 
-mirror::AbstractMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
+mirror::ArtMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
                                                    uint32_t method_idx,
                                                    mirror::DexCache* dex_cache,
                                                    mirror::ClassLoader* class_loader,
-                                                   const mirror::AbstractMethod* referrer,
+                                                   const mirror::ArtMethod* referrer,
                                                    InvokeType type) {
   DCHECK(dex_cache != NULL);
   // Check for hit in the dex cache.
-  mirror::AbstractMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
+  mirror::ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
   if (resolved != NULL) {
     return resolved;
   }
@@ -3863,13 +3812,13 @@ mirror::AbstractMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
   }
 }
 
-mirror::Field* ClassLinker::ResolveField(const DexFile& dex_file,
+mirror::ArtField* ClassLinker::ResolveField(const DexFile& dex_file,
                                          uint32_t field_idx,
                                          mirror::DexCache* dex_cache,
                                          mirror::ClassLoader* class_loader,
                                          bool is_static) {
   DCHECK(dex_cache != NULL);
-  mirror::Field* resolved = dex_cache->GetResolvedField(field_idx);
+  mirror::ArtField* resolved = dex_cache->GetResolvedField(field_idx);
   if (resolved != NULL) {
     return resolved;
   }
@@ -3903,12 +3852,12 @@ mirror::Field* ClassLinker::ResolveField(const DexFile& dex_file,
   return resolved;
 }
 
-mirror::Field* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
+mirror::ArtField* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
                                             uint32_t field_idx,
                                             mirror::DexCache* dex_cache,
                                             mirror::ClassLoader* class_loader) {
   DCHECK(dex_cache != NULL);
-  mirror::Field* resolved = dex_cache->GetResolvedField(field_idx);
+  mirror::ArtField* resolved = dex_cache->GetResolvedField(field_idx);
   if (resolved != NULL) {
     return resolved;
   }
@@ -3930,7 +3879,7 @@ mirror::Field* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
   return resolved;
 }
 
-const char* ClassLinker::MethodShorty(uint32_t method_idx, mirror::AbstractMethod* referrer,
+const char* ClassLinker::MethodShorty(uint32_t method_idx, mirror::ArtMethod* referrer,
                                       uint32_t* length) {
   mirror::Class* declaring_class = referrer->GetDeclaringClass();
   mirror::DexCache* dex_cache = declaring_class->GetDexCache();
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index 67be2ff028..d0cc562ca5 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -106,7 +106,7 @@ class ClassLinker {
   // Resolve a String with the given index from the DexFile, storing the
   // result in the DexCache. The referrer is used to identify the
   // target DexCache and ClassLoader to use for resolution.
-  mirror::String* ResolveString(uint32_t string_idx, const mirror::AbstractMethod* referrer)
+  mirror::String* ResolveString(uint32_t string_idx, const mirror::ArtMethod* referrer)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Resolve a String with the given index from the DexFile, storing the
@@ -130,10 +130,10 @@ class ClassLinker {
   // Resolve a Type with the given index from the DexFile, storing the
   // result in the DexCache. The referrer is used to identify the
   // target DexCache and ClassLoader to use for resolution.
-  mirror::Class* ResolveType(uint16_t type_idx, const mirror::AbstractMethod* referrer)
+  mirror::Class* ResolveType(uint16_t type_idx, const mirror::ArtMethod* referrer)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::Class* ResolveType(uint16_t type_idx, const mirror::Field* referrer)
+  mirror::Class* ResolveType(uint16_t type_idx, const mirror::ArtField* referrer)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Resolve a type with the given ID from the DexFile, storing the
@@ -151,20 +151,20 @@ class ClassLinker {
   // in ResolveType. What is unique is the method type argument which
   // is used to determine if this method is a direct, static, or
   // virtual method.
-  mirror::AbstractMethod* ResolveMethod(const DexFile& dex_file,
-                                        uint32_t method_idx,
-                                        mirror::DexCache* dex_cache,
-                                        mirror::ClassLoader* class_loader,
-                                        const mirror::AbstractMethod* referrer,
-                                        InvokeType type)
+  mirror::ArtMethod* ResolveMethod(const DexFile& dex_file,
+                                   uint32_t method_idx,
+                                   mirror::DexCache* dex_cache,
+                                   mirror::ClassLoader* class_loader,
+                                   const mirror::ArtMethod* referrer,
+                                   InvokeType type)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::AbstractMethod* ResolveMethod(uint32_t method_idx, const mirror::AbstractMethod* referrer,
-                                        InvokeType type)
+  mirror::ArtMethod* ResolveMethod(uint32_t method_idx, const mirror::ArtMethod* referrer,
+                                   InvokeType type)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::Field* ResolveField(uint32_t field_idx, const mirror::AbstractMethod* referrer,
-                              bool is_static)
+  mirror::ArtField* ResolveField(uint32_t field_idx, const mirror::ArtMethod* referrer,
+                                 bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Resolve a field with a given ID from the DexFile, storing the
@@ -172,25 +172,25 @@ class ClassLinker {
   // in ResolveType. What is unique is the is_static argument which is
   // used to determine if we are resolving a static or non-static
   // field.
-  mirror::Field* ResolveField(const DexFile& dex_file,
-                      uint32_t field_idx,
-                      mirror::DexCache* dex_cache,
-                      mirror::ClassLoader* class_loader,
-                      bool is_static)
+  mirror::ArtField* ResolveField(const DexFile& dex_file,
+                                 uint32_t field_idx,
+                                 mirror::DexCache* dex_cache,
+                                 mirror::ClassLoader* class_loader,
+                                 bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Resolve a field with a given ID from the DexFile, storing the
   // result in DexCache. The ClassLinker and ClassLoader are used as
   // in ResolveType. No is_static argument is provided so that Java
   // field resolution semantics are followed.
-  mirror::Field* ResolveFieldJLS(const DexFile& dex_file,
-                                 uint32_t field_idx,
-                                 mirror::DexCache* dex_cache,
-                                 mirror::ClassLoader* class_loader)
+  mirror::ArtField* ResolveFieldJLS(const DexFile& dex_file,
+                                    uint32_t field_idx,
+                                    mirror::DexCache* dex_cache,
+                                    mirror::ClassLoader* class_loader)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Get shorty from method index without resolution. Used to do handlerization.
-  const char* MethodShorty(uint32_t method_idx, mirror::AbstractMethod* referrer, uint32_t* length)
+  const char* MethodShorty(uint32_t method_idx, mirror::ArtMethod* referrer, uint32_t* length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Returns true on success, false if there's an exception pending.
@@ -232,7 +232,7 @@ class ClassLinker {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   bool IsDexFileRegistered(const DexFile& dex_file) const
       LOCKS_EXCLUDED(dex_lock_);
-  void FixupDexCaches(mirror::AbstractMethod* resolution_method) const
+  void FixupDexCaches(mirror::ArtMethod* resolution_method) const
       LOCKS_EXCLUDED(dex_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -283,16 +283,13 @@ class ClassLinker {
   mirror::ObjectArray<mirror::String>* AllocStringArray(Thread* self, size_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::ObjectArray<mirror::AbstractMethod>* AllocAbstractMethodArray(Thread* self, size_t length)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  mirror::ObjectArray<mirror::AbstractMethod>* AllocMethodArray(Thread* self, size_t length)
+  mirror::ObjectArray<mirror::ArtMethod>* AllocArtMethodArray(Thread* self, size_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   mirror::IfTable* AllocIfTable(Thread* self, size_t ifcount)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::ObjectArray<mirror::Field>* AllocFieldArray(Thread* self, size_t length)
+  mirror::ObjectArray<mirror::ArtField>* AllocArtFieldArray(Thread* self, size_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   mirror::ObjectArray<mirror::StackTraceElement>* AllocStackTraceElementArray(Thread* self,
@@ -305,23 +302,23 @@ class ClassLinker {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   void ResolveClassExceptionHandlerTypes(const DexFile& dex_file, mirror::Class* klass)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, mirror::AbstractMethod* klass)
+  void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, mirror::ArtMethod* klass)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   mirror::Class* CreateProxyClass(mirror::String* name, mirror::ObjectArray<mirror::Class>* interfaces,
                                   mirror::ClassLoader* loader,
-                                  mirror::ObjectArray<mirror::AbstractMethod>* methods,
+                                  mirror::ObjectArray<mirror::ArtMethod>* methods,
                                   mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >* throws)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   std::string GetDescriptorForProxy(const mirror::Class* proxy_class)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  mirror::AbstractMethod* FindMethodForProxy(const mirror::Class* proxy_class,
-                                             const mirror::AbstractMethod* proxy_method)
+  mirror::ArtMethod* FindMethodForProxy(const mirror::Class* proxy_class,
+                                        const mirror::ArtMethod* proxy_method)
       LOCKS_EXCLUDED(dex_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Get the oat code for a method when its class isn't yet initialized
-  const void* GetOatCodeFor(const mirror::AbstractMethod* method)
+  const void* GetOatCodeFor(const mirror::ArtMethod* method)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Get the oat code for a method from a method index.
@@ -361,7 +358,7 @@ class ClassLinker {
  private:
   explicit ClassLinker(InternTable*);
 
-  const OatFile::OatMethod GetOatMethodFor(const mirror::AbstractMethod* method)
+  const OatFile::OatMethod GetOatMethodFor(const mirror::ArtMethod* method)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Initialize class linker by bootstraping from dex files
@@ -386,9 +383,8 @@ class ClassLinker {
   mirror::Class* AllocClass(Thread* self, size_t class_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   mirror::DexCache* AllocDexCache(Thread* self, const DexFile& dex_file)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  mirror::Field* AllocField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  mirror::Method* AllocMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  mirror::Constructor* AllocConstructor(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  mirror::ArtField* AllocArtField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  mirror::ArtMethod* AllocArtMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -405,7 +401,7 @@ class ClassLinker {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
-                         mirror::Class* c, SafeMap<uint32_t, mirror::Field*>& field_map)
+                         mirror::Class* c, SafeMap<uint32_t, mirror::ArtField*>& field_map)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   size_t SizeOfClass(const DexFile& dex_file,
@@ -418,12 +414,12 @@ class ClassLinker {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it,
-                 SirtRef<mirror::Class>& klass, SirtRef<mirror::Field>& dst)
+                 SirtRef<mirror::Class>& klass, SirtRef<mirror::ArtField>& dst)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::AbstractMethod* LoadMethod(Thread* self, const DexFile& dex_file,
-                                     const ClassDataItemIterator& dex_method,
-                                     SirtRef<mirror::Class>& klass)
+  mirror::ArtMethod* LoadMethod(Thread* self, const DexFile& dex_file,
+                                const ClassDataItemIterator& dex_method,
+                                SirtRef<mirror::Class>& klass)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void FixupStaticTrampolines(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -455,7 +451,7 @@ class ClassLinker {
                                                 const mirror::Class* klass2)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  bool IsSameMethodSignatureInDifferentClassContexts(const mirror::AbstractMethod* method,
+  bool IsSameMethodSignatureInDifferentClassContexts(const mirror::ArtMethod* method,
                                                      const mirror::Class* klass1,
                                                      const mirror::Class* klass2)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -519,11 +515,11 @@ class ClassLinker {
       EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::AbstractMethod* CreateProxyConstructor(Thread* self, SirtRef<mirror::Class>& klass,
-                                                 mirror::Class* proxy_class)
+  mirror::ArtMethod* CreateProxyConstructor(Thread* self, SirtRef<mirror::Class>& klass,
+                                            mirror::Class* proxy_class)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  mirror::AbstractMethod* CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
-                                            SirtRef<mirror::AbstractMethod>& prototype)
+  mirror::ArtMethod* CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
+                                       SirtRef<mirror::ArtMethod>& prototype)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   std::vector<const DexFile*> boot_class_path_;
@@ -554,15 +550,12 @@ class ClassLinker {
     kJavaLangString,
     kJavaLangDexCache,
     kJavaLangRefReference,
-    kJavaLangReflectConstructor,
-    kJavaLangReflectField,
-    kJavaLangReflectAbstractMethod,
-    kJavaLangReflectMethod,
+    kJavaLangReflectArtField,
+    kJavaLangReflectArtMethod,
     kJavaLangReflectProxy,
     kJavaLangStringArrayClass,
-    kJavaLangReflectAbstractMethodArrayClass,
-    kJavaLangReflectFieldArrayClass,
-    kJavaLangReflectMethodArrayClass,
+    kJavaLangReflectArtFieldArrayClass,
+    kJavaLangReflectArtMethodArrayClass,
     kJavaLangClassLoader,
     kJavaLangThrowable,
     kJavaLangClassNotFoundException,
diff --git a/runtime/class_linker_test.cc b/runtime/class_linker_test.cc
index 4659fd1982..6442f5ad63 100644
--- a/runtime/class_linker_test.cc
+++ b/runtime/class_linker_test.cc
@@ -24,42 +24,17 @@
 #include "dex_file.h"
 #include "entrypoints/entrypoint_utils.h"
 #include "gc/heap.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/dex_cache.h"
-#include "mirror/field-inl.h"
-#include "mirror/abstract_method.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/proxy.h"
 #include "mirror/stack_trace_element.h"
 #include "sirt_ref.h"
 
-using ::art::mirror::AbstractMethod;
-using ::art::mirror::AbstractMethodClass;
-using ::art::mirror::CharArray;
-using ::art::mirror::Class;
-using ::art::mirror::ClassClass;
-using ::art::mirror::ClassLoader;
-using ::art::mirror::Constructor;
-using ::art::mirror::DexCache;
-using ::art::mirror::DoubleArray;
-using ::art::mirror::Field;
-using ::art::mirror::FieldClass;
-using ::art::mirror::IfTable;
-using ::art::mirror::IntArray;
-using ::art::mirror::LongArray;
-using ::art::mirror::Method;
-using ::art::mirror::Object;
-using ::art::mirror::ObjectArray;
-using ::art::mirror::Proxy;
-using ::art::mirror::ShortArray;
-using ::art::mirror::StackTraceElement;
-using ::art::mirror::StaticStorageBase;
-using ::art::mirror::String;
-using ::art::mirror::StringClass;
-using ::art::mirror::Throwable;
-
 namespace art {
 
 class ClassLinkerTest : public CommonTest {
@@ -69,9 +44,9 @@ class ClassLinkerTest : public CommonTest {
     EXPECT_TRUE(class_linker_->FindSystemClass(descriptor.c_str()) == NULL);
     Thread* self = Thread::Current();
     EXPECT_TRUE(self->IsExceptionPending());
-    Object* exception = self->GetException(NULL);
+    mirror::Object* exception = self->GetException(NULL);
     self->ClearException();
-    Class* exception_class = class_linker_->FindSystemClass("Ljava/lang/NoClassDefFoundError;");
+    mirror::Class* exception_class = class_linker_->FindSystemClass("Ljava/lang/NoClassDefFoundError;");
     EXPECT_TRUE(exception->InstanceOf(exception_class));
   }
 
@@ -80,7 +55,7 @@ class ClassLinkerTest : public CommonTest {
     AssertPrimitiveClass(descriptor, class_linker_->FindSystemClass(descriptor.c_str()));
   }
 
-  void AssertPrimitiveClass(const std::string& descriptor, const Class* primitive)
+  void AssertPrimitiveClass(const std::string& descriptor, const mirror::Class* primitive)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     ClassHelper primitive_ch(primitive);
     ASSERT_TRUE(primitive != NULL);
@@ -91,7 +66,7 @@ class ClassLinkerTest : public CommonTest {
     EXPECT_TRUE(primitive->GetSuperClass() == NULL);
     EXPECT_FALSE(primitive->HasSuperClass());
     EXPECT_TRUE(primitive->GetClassLoader() == NULL);
-    EXPECT_EQ(Class::kStatusInitialized, primitive->GetStatus());
+    EXPECT_EQ(mirror::Class::kStatusInitialized, primitive->GetStatus());
     EXPECT_FALSE(primitive->IsErroneous());
     EXPECT_TRUE(primitive->IsLoaded());
     EXPECT_TRUE(primitive->IsResolved());
@@ -118,9 +93,9 @@ class ClassLinkerTest : public CommonTest {
 
   void AssertArrayClass(const std::string& array_descriptor,
                         const std::string& component_type,
-                        ClassLoader* class_loader)
+                        mirror::ClassLoader* class_loader)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    Class* array = class_linker_->FindClass(array_descriptor.c_str(), class_loader);
+    mirror::Class* array = class_linker_->FindClass(array_descriptor.c_str(), class_loader);
     ClassHelper array_component_ch(array->GetComponentType());
     EXPECT_STREQ(component_type.c_str(), array_component_ch.GetDescriptor());
     EXPECT_EQ(class_loader, array->GetClassLoader());
@@ -128,7 +103,7 @@ class ClassLinkerTest : public CommonTest {
     AssertArrayClass(array_descriptor, array);
   }
 
-  void AssertArrayClass(const std::string& array_descriptor, Class* array)
+  void AssertArrayClass(const std::string& array_descriptor, mirror::Class* array)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     ClassHelper kh(array);
     ASSERT_TRUE(array != NULL);
@@ -142,7 +117,7 @@ class ClassLinkerTest : public CommonTest {
     ASSERT_TRUE(array->GetComponentType() != NULL);
     kh.ChangeClass(array->GetComponentType());
     ASSERT_TRUE(kh.GetDescriptor() != NULL);
-    EXPECT_EQ(Class::kStatusInitialized, array->GetStatus());
+    EXPECT_EQ(mirror::Class::kStatusInitialized, array->GetStatus());
     EXPECT_FALSE(array->IsErroneous());
     EXPECT_TRUE(array->IsLoaded());
     EXPECT_TRUE(array->IsResolved());
@@ -163,7 +138,7 @@ class ClassLinkerTest : public CommonTest {
     EXPECT_EQ(2U, kh.NumDirectInterfaces());
     EXPECT_TRUE(array->GetVTable() != NULL);
     EXPECT_EQ(2, array->GetIfTableCount());
-    IfTable* iftable = array->GetIfTable();
+    mirror::IfTable* iftable = array->GetIfTable();
     ASSERT_TRUE(iftable != NULL);
     kh.ChangeClass(kh.GetDirectInterface(0));
     EXPECT_STREQ(kh.GetDescriptor(), "Ljava/lang/Cloneable;");
@@ -172,7 +147,7 @@ class ClassLinkerTest : public CommonTest {
     EXPECT_STREQ(kh.GetDescriptor(), "Ljava/io/Serializable;");
   }
 
-  void AssertMethod(AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  void AssertMethod(mirror::ArtMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     MethodHelper mh(method);
     EXPECT_TRUE(method != NULL);
     EXPECT_TRUE(method->GetClass() != NULL);
@@ -193,7 +168,7 @@ class ClassLinkerTest : public CommonTest {
               method->GetDexCacheInitializedStaticStorage());
   }
 
-  void AssertField(Class* klass, Field* field)
+  void AssertField(mirror::Class* klass, mirror::ArtField* field)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     FieldHelper fh(field);
     EXPECT_TRUE(field != NULL);
@@ -203,7 +178,7 @@ class ClassLinkerTest : public CommonTest {
     EXPECT_TRUE(fh.GetType() != NULL);
   }
 
-  void AssertClass(const std::string& descriptor, Class* klass)
+  void AssertClass(const std::string& descriptor, mirror::Class* klass)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     ClassHelper kh(klass);
     EXPECT_STREQ(descriptor.c_str(), kh.GetDescriptor());
@@ -222,7 +197,7 @@ class ClassLinkerTest : public CommonTest {
     EXPECT_FALSE(klass->IsArrayClass());
     EXPECT_TRUE(klass->GetComponentType() == NULL);
     EXPECT_TRUE(klass->IsInSamePackage(klass));
-    EXPECT_TRUE(Class::IsInSamePackage(kh.GetDescriptor(), kh.GetDescriptor()));
+    EXPECT_TRUE(mirror::Class::IsInSamePackage(kh.GetDescriptor(), kh.GetDescriptor()));
     if (klass->IsInterface()) {
       EXPECT_TRUE(klass->IsAbstract());
       if (klass->NumDirectMethods() == 1) {
@@ -238,9 +213,9 @@ class ClassLinkerTest : public CommonTest {
       }
     }
     EXPECT_EQ(klass->IsInterface(), klass->GetVTable() == NULL);
-    const IfTable* iftable = klass->GetIfTable();
+    const mirror::IfTable* iftable = klass->GetIfTable();
     for (int i = 0; i < klass->GetIfTableCount(); i++) {
-      Class* interface = iftable->GetInterface(i);
+      mirror::Class* interface = iftable->GetInterface(i);
       ASSERT_TRUE(interface != NULL);
       if (klass->IsInterface()) {
         EXPECT_EQ(0U, iftable->GetMethodArrayCount(i));
@@ -266,27 +241,27 @@ class ClassLinkerTest : public CommonTest {
     EXPECT_TRUE(klass->CanAccess(klass));
 
     for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
-      AbstractMethod* method = klass->GetDirectMethod(i);
+      mirror::ArtMethod* method = klass->GetDirectMethod(i);
       AssertMethod(method);
       EXPECT_TRUE(method->IsDirect());
       EXPECT_EQ(klass, method->GetDeclaringClass());
     }
 
     for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
-      AbstractMethod* method = klass->GetVirtualMethod(i);
+      mirror::ArtMethod* method = klass->GetVirtualMethod(i);
       AssertMethod(method);
       EXPECT_FALSE(method->IsDirect());
       EXPECT_TRUE(method->GetDeclaringClass()->IsAssignableFrom(klass));
     }
 
     for (size_t i = 0; i < klass->NumInstanceFields(); i++) {
-      Field* field = klass->GetInstanceField(i);
+      mirror::ArtField* field = klass->GetInstanceField(i);
       AssertField(klass, field);
       EXPECT_FALSE(field->IsStatic());
     }
 
     for (size_t i = 0; i < klass->NumStaticFields(); i++) {
-      Field* field = klass->GetStaticField(i);
+      mirror::ArtField* field = klass->GetStaticField(i);
       AssertField(klass, field);
       EXPECT_TRUE(field->IsStatic());
     }
@@ -295,17 +270,17 @@ class ClassLinkerTest : public CommonTest {
     EXPECT_GE(klass->NumInstanceFields(), klass->NumReferenceInstanceFields());
     FieldHelper fh;
     for (size_t i = 0; i < klass->NumReferenceInstanceFields(); i++) {
-      Field* field = klass->GetInstanceField(i);
+      mirror::ArtField* field = klass->GetInstanceField(i);
       fh.ChangeField(field);
       ASSERT_TRUE(!fh.IsPrimitiveType());
-      Class* field_type = fh.GetType();
+      mirror::Class* field_type = fh.GetType();
       ASSERT_TRUE(field_type != NULL);
       ASSERT_TRUE(!field_type->IsPrimitive());
     }
     for (size_t i = klass->NumReferenceInstanceFields(); i < klass->NumInstanceFields(); i++) {
-      Field* field = klass->GetInstanceField(i);
+      mirror::ArtField* field = klass->GetInstanceField(i);
       fh.ChangeField(field);
-      Class* field_type = fh.GetType();
+      mirror::Class* field_type = fh.GetType();
       ASSERT_TRUE(field_type != NULL);
       if (!fh.IsPrimitiveType() || !field_type->IsPrimitive()) {
         // While Reference.referent is not primitive, the ClassLinker
@@ -315,7 +290,7 @@ class ClassLinkerTest : public CommonTest {
     }
 
     size_t total_num_reference_instance_fields = 0;
-    Class* k = klass;
+    mirror::Class* k = klass;
     while (k != NULL) {
       total_num_reference_instance_fields += k->NumReferenceInstanceFields();
       k = k->GetSuperClass();
@@ -324,10 +299,10 @@ class ClassLinkerTest : public CommonTest {
               total_num_reference_instance_fields == 0);
   }
 
-  void AssertDexFileClass(ClassLoader* class_loader, const std::string& descriptor)
+  void AssertDexFileClass(mirror::ClassLoader* class_loader, const std::string& descriptor)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     ASSERT_TRUE(descriptor != NULL);
-    Class* klass = class_linker_->FindSystemClass(descriptor.c_str());
+    mirror::Class* klass = class_linker_->FindSystemClass(descriptor.c_str());
     ASSERT_TRUE(klass != NULL);
     EXPECT_STREQ(descriptor.c_str(), ClassHelper(klass).GetDescriptor());
     EXPECT_EQ(class_loader, klass->GetClassLoader());
@@ -340,7 +315,7 @@ class ClassLinkerTest : public CommonTest {
     }
   }
 
-  void AssertDexFile(const DexFile* dex, ClassLoader* class_loader)
+  void AssertDexFile(const DexFile* dex, mirror::ClassLoader* class_loader)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     ASSERT_TRUE(dex != NULL);
 
@@ -358,14 +333,14 @@ class ClassLinkerTest : public CommonTest {
     }
     class_linker_->VisitRoots(TestRootVisitor, NULL, false);
     // Verify the dex cache has resolution methods in all resolved method slots
-    DexCache* dex_cache = class_linker_->FindDexCache(*dex);
-    ObjectArray<AbstractMethod>* resolved_methods = dex_cache->GetResolvedMethods();
+    mirror::DexCache* dex_cache = class_linker_->FindDexCache(*dex);
+    mirror::ObjectArray<mirror::ArtMethod>* resolved_methods = dex_cache->GetResolvedMethods();
     for (size_t i = 0; i < static_cast<size_t>(resolved_methods->GetLength()); i++) {
       EXPECT_TRUE(resolved_methods->Get(i) != NULL);
     }
   }
 
-  static void TestRootVisitor(const Object* root, void*) {
+  static void TestRootVisitor(const mirror::Object* root, void*) {
     EXPECT_TRUE(root != NULL);
   }
 };
@@ -385,7 +360,7 @@ struct CheckOffsets {
   std::vector<CheckOffset> offsets;
 
   bool Check() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    Class* klass = Runtime::Current()->GetClassLinker()->FindSystemClass(class_descriptor.c_str());
+    mirror::Class* klass = Runtime::Current()->GetClassLinker()->FindSystemClass(class_descriptor.c_str());
     CHECK(klass != NULL) << class_descriptor;
 
     bool error = false;
@@ -412,7 +387,7 @@ struct CheckOffsets {
 
     FieldHelper fh;
     for (size_t i = 0; i < offsets.size(); i++) {
-      Field* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
+      mirror::ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
       fh.ChangeField(field);
       StringPiece field_name(fh.GetName());
       if (field_name != offsets[i].java_name) {
@@ -422,7 +397,7 @@ struct CheckOffsets {
     if (error) {
       for (size_t i = 0; i < offsets.size(); i++) {
         CheckOffset& offset = offsets[i];
-        Field* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
+        mirror::ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
         fh.ChangeField(field);
         StringPiece field_name(fh.GetName());
         if (field_name != offsets[i].java_name) {
@@ -437,7 +412,7 @@ struct CheckOffsets {
 
     for (size_t i = 0; i < offsets.size(); i++) {
       CheckOffset& offset = offsets[i];
-      Field* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
+      mirror::ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
       if (field->GetOffset().Uint32Value() != offset.cpp_offset) {
         error = true;
       }
@@ -445,7 +420,7 @@ struct CheckOffsets {
     if (error) {
       for (size_t i = 0; i < offsets.size(); i++) {
         CheckOffset& offset = offsets[i];
-        Field* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
+        mirror::ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
         if (field->GetOffset().Uint32Value() != offset.cpp_offset) {
           LOG(ERROR) << "OFFSET MISMATCH NEXT LINE:";
         }
@@ -464,195 +439,179 @@ struct CheckOffsets {
 // Note that ClassLinkerTest.ValidateFieldOrderOfJavaCppUnionClasses
 // is first since if it is failing, others are unlikely to succeed.
 
-struct ObjectOffsets : public CheckOffsets<Object> {
-  ObjectOffsets() : CheckOffsets<Object>(false, "Ljava/lang/Object;") {
+struct ObjectOffsets : public CheckOffsets<mirror::Object> {
+  ObjectOffsets() : CheckOffsets<mirror::Object>(false, "Ljava/lang/Object;") {
     // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Object, klass_),   "shadow$_klass_"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Object, klass_),   "shadow$_klass_"));
 
     // alphabetical 32-bit
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Object, monitor_), "shadow$_monitor_"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Object, monitor_), "shadow$_monitor_"));
   };
 };
 
-struct FieldOffsets : public CheckOffsets<Field> {
-  FieldOffsets() : CheckOffsets<Field>(false, "Ljava/lang/reflect/Field;") {
+struct ArtFieldOffsets : public CheckOffsets<mirror::ArtField> {
+  ArtFieldOffsets() : CheckOffsets<mirror::ArtField>(false, "Ljava/lang/reflect/ArtField;") {
     // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, declaring_class_), "declaringClass"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtField, declaring_class_), "declaringClass"));
 
     // alphabetical 32-bit
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, access_flags_),    "accessFlags"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, field_dex_idx_),   "fieldDexIndex"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, offset_),          "offset"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtField, access_flags_),    "accessFlags"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtField, field_dex_idx_),   "fieldDexIndex"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtField, offset_),          "offset"));
   };
 };
 
-struct AbstractMethodOffsets : public CheckOffsets<AbstractMethod> {
-  AbstractMethodOffsets() : CheckOffsets<AbstractMethod>(false, "Ljava/lang/reflect/AbstractMethod;") {
+struct ArtMethodOffsets : public CheckOffsets<mirror::ArtMethod> {
+  ArtMethodOffsets() : CheckOffsets<mirror::ArtMethod>(false, "Ljava/lang/reflect/ArtMethod;") {
     // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, declaring_class_),                      "declaringClass"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, dex_cache_initialized_static_storage_), "dexCacheInitializedStaticStorage"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, dex_cache_resolved_methods_),           "dexCacheResolvedMethods"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, dex_cache_resolved_types_),             "dexCacheResolvedTypes"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, dex_cache_strings_),                    "dexCacheStrings"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, declaring_class_),                      "declaringClass"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, dex_cache_initialized_static_storage_), "dexCacheInitializedStaticStorage"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, dex_cache_resolved_methods_),           "dexCacheResolvedMethods"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, dex_cache_resolved_types_),             "dexCacheResolvedTypes"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, dex_cache_strings_),                    "dexCacheStrings"));
 
     // alphabetical 32-bit
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, access_flags_),                   "accessFlags"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, code_item_offset_),               "codeItemOffset"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, core_spill_mask_),                "coreSpillMask"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, entry_point_from_compiled_code_), "entryPointFromCompiledCode"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, entry_point_from_interpreter_),   "entryPointFromInterpreter"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, fp_spill_mask_),                  "fpSpillMask"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, frame_size_in_bytes_),            "frameSizeInBytes"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, gc_map_),                         "gcMap"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, mapping_table_),                  "mappingTable"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, method_dex_index_),               "methodDexIndex"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, method_index_),                   "methodIndex"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, native_method_),                  "nativeMethod"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, vmap_table_),                     "vmapTable"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, access_flags_),                   "accessFlags"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, code_item_offset_),               "codeItemOffset"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, core_spill_mask_),                "coreSpillMask"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, entry_point_from_compiled_code_), "entryPointFromCompiledCode"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, entry_point_from_interpreter_),   "entryPointFromInterpreter"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, fp_spill_mask_),                  "fpSpillMask"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, frame_size_in_bytes_),            "frameSizeInBytes"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, gc_map_),                         "gcMap"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, mapping_table_),                  "mappingTable"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, method_dex_index_),               "methodDexIndex"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, method_index_),                   "methodIndex"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, native_method_),                  "nativeMethod"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ArtMethod, vmap_table_),                     "vmapTable"));
   };
 };
 
-struct ConstructorOffsets : public CheckOffsets<Constructor> {
-  // java.lang.reflect.Constructor is a subclass of java.lang.reflect.AbstractMethod
-  ConstructorOffsets() : CheckOffsets<Constructor>(false, "Ljava/lang/reflect/Constructor;") {
-  }
-};
-
-struct MethodOffsets : public CheckOffsets<Method> {
-  // java.lang.reflect.Method is a subclass of java.lang.reflect.AbstractMethod
-  MethodOffsets() : CheckOffsets<Method>(false, "Ljava/lang/reflect/Method;") {
-  }
-};
-
-struct ClassOffsets : public CheckOffsets<Class> {
-  ClassOffsets() : CheckOffsets<Class>(false, "Ljava/lang/Class;") {
+struct ClassOffsets : public CheckOffsets<mirror::Class> {
+  ClassOffsets() : CheckOffsets<mirror::Class>(false, "Ljava/lang/Class;") {
     // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, class_loader_),                  "classLoader"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, component_type_),                "componentType"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, dex_cache_),                     "dexCache"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, direct_methods_),                "directMethods"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, ifields_),                       "iFields"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, iftable_),                       "ifTable"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, name_),                          "name"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, sfields_),                       "sFields"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, super_class_),                   "superClass"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, verify_error_class_),            "verifyErrorClass"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, virtual_methods_),               "virtualMethods"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, vtable_),                        "vtable"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, class_loader_),                  "classLoader"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, component_type_),                "componentType"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, dex_cache_),                     "dexCache"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, direct_methods_),                "directMethods"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, ifields_),                       "iFields"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, iftable_),                       "ifTable"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, name_),                          "name"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, sfields_),                       "sFields"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, super_class_),                   "superClass"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, verify_error_class_),            "verifyErrorClass"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, virtual_methods_),               "virtualMethods"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, vtable_),                        "vtable"));
 
     // alphabetical 32-bit
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, access_flags_),                  "accessFlags"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, class_size_),                    "classSize"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, clinit_thread_id_),              "clinitThreadId"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, dex_type_idx_),                  "dexTypeIndex"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, num_reference_instance_fields_), "numReferenceInstanceFields"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, num_reference_static_fields_),   "numReferenceStaticFields"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, object_size_),                   "objectSize"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, primitive_type_),                "primitiveType"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, reference_instance_offsets_),    "referenceInstanceOffsets"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, reference_static_offsets_),      "referenceStaticOffsets"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, status_),                        "status"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, access_flags_),                  "accessFlags"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, class_size_),                    "classSize"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, clinit_thread_id_),              "clinitThreadId"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, dex_type_idx_),                  "dexTypeIndex"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, num_reference_instance_fields_), "numReferenceInstanceFields"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, num_reference_static_fields_),   "numReferenceStaticFields"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, object_size_),                   "objectSize"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, primitive_type_),                "primitiveType"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, reference_instance_offsets_),    "referenceInstanceOffsets"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, reference_static_offsets_),      "referenceStaticOffsets"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, status_),                        "status"));
   };
 };
 
-struct StringOffsets : public CheckOffsets<String> {
-  StringOffsets() : CheckOffsets<String>(false, "Ljava/lang/String;") {
+struct StringOffsets : public CheckOffsets<mirror::String> {
+  StringOffsets() : CheckOffsets<mirror::String>(false, "Ljava/lang/String;") {
     // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(String, array_),     "value"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::String, array_),     "value"));
 
     // alphabetical 32-bit
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(String, count_),     "count"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(String, hash_code_), "hashCode"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(String, offset_),    "offset"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::String, count_),     "count"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::String, hash_code_), "hashCode"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::String, offset_),    "offset"));
   };
 };
 
-struct ThrowableOffsets : public CheckOffsets<Throwable> {
-  ThrowableOffsets() : CheckOffsets<Throwable>(false, "Ljava/lang/Throwable;") {
+struct ThrowableOffsets : public CheckOffsets<mirror::Throwable> {
+  ThrowableOffsets() : CheckOffsets<mirror::Throwable>(false, "Ljava/lang/Throwable;") {
     // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Throwable, cause_),                 "cause"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Throwable, detail_message_),        "detailMessage"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Throwable, stack_state_),           "stackState"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Throwable, stack_trace_),           "stackTrace"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Throwable, suppressed_exceptions_), "suppressedExceptions"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Throwable, cause_),                 "cause"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Throwable, detail_message_),        "detailMessage"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Throwable, stack_state_),           "stackState"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Throwable, stack_trace_),           "stackTrace"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Throwable, suppressed_exceptions_), "suppressedExceptions"));
   };
 };
 
-struct StackTraceElementOffsets : public CheckOffsets<StackTraceElement> {
-  StackTraceElementOffsets() : CheckOffsets<StackTraceElement>(false, "Ljava/lang/StackTraceElement;") {
+struct StackTraceElementOffsets : public CheckOffsets<mirror::StackTraceElement> {
+  StackTraceElementOffsets() : CheckOffsets<mirror::StackTraceElement>(false, "Ljava/lang/StackTraceElement;") {
     // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StackTraceElement, declaring_class_), "declaringClass"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StackTraceElement, file_name_),       "fileName"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StackTraceElement, method_name_),     "methodName"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StackTraceElement, line_number_),     "lineNumber"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, declaring_class_), "declaringClass"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, file_name_),       "fileName"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, method_name_),     "methodName"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, line_number_),     "lineNumber"));
   };
 };
 
-struct ClassLoaderOffsets : public CheckOffsets<ClassLoader> {
-  ClassLoaderOffsets() : CheckOffsets<ClassLoader>(false, "Ljava/lang/ClassLoader;") {
+struct ClassLoaderOffsets : public CheckOffsets<mirror::ClassLoader> {
+  ClassLoaderOffsets() : CheckOffsets<mirror::ClassLoader>(false, "Ljava/lang/ClassLoader;") {
     // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(ClassLoader, packages_),   "packages"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(ClassLoader, parent_),     "parent"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(ClassLoader, proxyCache_), "proxyCache"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ClassLoader, packages_),   "packages"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ClassLoader, parent_),     "parent"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ClassLoader, proxyCache_), "proxyCache"));
   };
 };
 
-struct ProxyOffsets : public CheckOffsets<Proxy> {
-  ProxyOffsets() : CheckOffsets<Proxy>(false, "Ljava/lang/reflect/Proxy;") {
+struct ProxyOffsets : public CheckOffsets<mirror::Proxy> {
+  ProxyOffsets() : CheckOffsets<mirror::Proxy>(false, "Ljava/lang/reflect/Proxy;") {
     // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Proxy, h_), "h"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Proxy, h_), "h"));
   };
 };
 
-struct ClassClassOffsets : public CheckOffsets<ClassClass> {
-  ClassClassOffsets() : CheckOffsets<ClassClass>(true, "Ljava/lang/Class;") {
+struct ClassClassOffsets : public CheckOffsets<mirror::ClassClass> {
+  ClassClassOffsets() : CheckOffsets<mirror::ClassClass>(true, "Ljava/lang/Class;") {
     // padding 32-bit
-    CHECK_EQ(OFFSETOF_MEMBER(ClassClass, padding_) + 4,
-             OFFSETOF_MEMBER(ClassClass, serialVersionUID_));
+    CHECK_EQ(OFFSETOF_MEMBER(mirror::ClassClass, padding_) + 4,
+             OFFSETOF_MEMBER(mirror::ClassClass, serialVersionUID_));
 
     // alphabetical 64-bit
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(ClassClass, serialVersionUID_), "serialVersionUID"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ClassClass, serialVersionUID_), "serialVersionUID"));
   };
 };
 
-struct StringClassOffsets : public CheckOffsets<StringClass> {
-  StringClassOffsets() : CheckOffsets<StringClass>(true, "Ljava/lang/String;") {
+struct StringClassOffsets : public CheckOffsets<mirror::StringClass> {
+  StringClassOffsets() : CheckOffsets<mirror::StringClass>(true, "Ljava/lang/String;") {
     // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StringClass, ASCII_),                  "ASCII"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StringClass, CASE_INSENSITIVE_ORDER_), "CASE_INSENSITIVE_ORDER"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StringClass, ASCII_),                  "ASCII"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StringClass, CASE_INSENSITIVE_ORDER_), "CASE_INSENSITIVE_ORDER"));
 
     // padding 32-bit
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StringClass, REPLACEMENT_CHAR_),       "REPLACEMENT_CHAR"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StringClass, REPLACEMENT_CHAR_),       "REPLACEMENT_CHAR"));
 
     // alphabetical 64-bit
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StringClass, serialVersionUID_),       "serialVersionUID"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StringClass, serialVersionUID_),       "serialVersionUID"));
   };
 };
 
-struct FieldClassOffsets : public CheckOffsets<FieldClass> {
-  FieldClassOffsets() : CheckOffsets<FieldClass>(true, "Ljava/lang/reflect/Field;") {
-    // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(FieldClass, ORDER_BY_NAME_AND_DECLARING_CLASS_), "ORDER_BY_NAME_AND_DECLARING_CLASS"));
+struct ArtFieldClassOffsets : public CheckOffsets<mirror::ArtFieldClass> {
+  ArtFieldClassOffsets() : CheckOffsets<mirror::ArtFieldClass>(true, "Ljava/lang/reflect/ArtField;") {
   };
 };
 
-struct MethodClassOffsets : public CheckOffsets<AbstractMethodClass> {
-  MethodClassOffsets() : CheckOffsets<AbstractMethodClass>(true, "Ljava/lang/reflect/Method;") {
-    // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethodClass, ORDER_BY_SIGNATURE_), "ORDER_BY_SIGNATURE"));
+struct ArtMethodClassOffsets : public CheckOffsets<mirror::ArtMethodClass> {
+  ArtMethodClassOffsets() : CheckOffsets<mirror::ArtMethodClass>(true, "Ljava/lang/reflect/ArtMethod;") {
   };
 };
 
-struct DexCacheOffsets : public CheckOffsets<DexCache> {
-  DexCacheOffsets() : CheckOffsets<DexCache>(false, "Ljava/lang/DexCache;") {
+struct DexCacheOffsets : public CheckOffsets<mirror::DexCache> {
+  DexCacheOffsets() : CheckOffsets<mirror::DexCache>(false, "Ljava/lang/DexCache;") {
     // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, initialized_static_storage_), "initializedStaticStorage"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, location_),                   "location"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, resolved_fields_),            "resolvedFields"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, resolved_methods_),           "resolvedMethods"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, resolved_types_),             "resolvedTypes"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, strings_),                    "strings"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, dex_file_),                   "dexFile"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::DexCache, initialized_static_storage_), "initializedStaticStorage"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::DexCache, location_),                   "location"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_fields_),            "resolvedFields"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_methods_),           "resolvedMethods"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_types_),             "resolvedTypes"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::DexCache, strings_),                    "strings"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::DexCache, dex_file_),                   "dexFile"));
   };
 };
 
@@ -662,10 +621,8 @@ struct DexCacheOffsets : public CheckOffsets<DexCache> {
 TEST_F(ClassLinkerTest, ValidateFieldOrderOfJavaCppUnionClasses) {
   ScopedObjectAccess soa(Thread::Current());
   EXPECT_TRUE(ObjectOffsets().Check());
-  EXPECT_TRUE(ConstructorOffsets().Check());
-  EXPECT_TRUE(MethodOffsets().Check());
-  EXPECT_TRUE(FieldOffsets().Check());
-  EXPECT_TRUE(AbstractMethodOffsets().Check());
+  EXPECT_TRUE(ArtFieldOffsets().Check());
+  EXPECT_TRUE(ArtMethodOffsets().Check());
   EXPECT_TRUE(ClassOffsets().Check());
   EXPECT_TRUE(StringOffsets().Check());
   EXPECT_TRUE(ThrowableOffsets().Check());
@@ -676,8 +633,8 @@ TEST_F(ClassLinkerTest, ValidateFieldOrderOfJavaCppUnionClasses) {
 
   EXPECT_TRUE(ClassClassOffsets().Check());
   EXPECT_TRUE(StringClassOffsets().Check());
-  EXPECT_TRUE(FieldClassOffsets().Check());
-  EXPECT_TRUE(MethodClassOffsets().Check());
+  EXPECT_TRUE(ArtFieldClassOffsets().Check());
+  EXPECT_TRUE(ArtMethodClassOffsets().Check());
 }
 
 TEST_F(ClassLinkerTest, FindClassNonexistent) {
@@ -688,14 +645,14 @@ TEST_F(ClassLinkerTest, FindClassNonexistent) {
 
 TEST_F(ClassLinkerTest, FindClassNested) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<ClassLoader> class_loader(soa.Self(), soa.Decode<ClassLoader*>(LoadDex("Nested")));
+  SirtRef<mirror::ClassLoader> class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(LoadDex("Nested")));
 
-  Class* outer = class_linker_->FindClass("LNested;", class_loader.get());
+  mirror::Class* outer = class_linker_->FindClass("LNested;", class_loader.get());
   ASSERT_TRUE(outer != NULL);
   EXPECT_EQ(0U, outer->NumVirtualMethods());
   EXPECT_EQ(1U, outer->NumDirectMethods());
 
-  Class* inner = class_linker_->FindClass("LNested$Inner;", class_loader.get());
+  mirror::Class* inner = class_linker_->FindClass("LNested$Inner;", class_loader.get());
   ASSERT_TRUE(inner != NULL);
   EXPECT_EQ(0U, inner->NumVirtualMethods());
   EXPECT_EQ(1U, inner->NumDirectMethods());
@@ -717,7 +674,7 @@ TEST_F(ClassLinkerTest, FindClass_Primitives) {
 
 TEST_F(ClassLinkerTest, FindClass) {
   ScopedObjectAccess soa(Thread::Current());
-  Class* JavaLangObject = class_linker_->FindSystemClass("Ljava/lang/Object;");
+  mirror::Class* JavaLangObject = class_linker_->FindSystemClass("Ljava/lang/Object;");
   ClassHelper kh(JavaLangObject);
   ASSERT_TRUE(JavaLangObject != NULL);
   ASSERT_TRUE(JavaLangObject->GetClass() != NULL);
@@ -727,12 +684,12 @@ TEST_F(ClassLinkerTest, FindClass) {
   EXPECT_TRUE(JavaLangObject->GetSuperClass() == NULL);
   EXPECT_FALSE(JavaLangObject->HasSuperClass());
   EXPECT_TRUE(JavaLangObject->GetClassLoader() == NULL);
-  EXPECT_EQ(Class::kStatusResolved, JavaLangObject->GetStatus());
+  EXPECT_EQ(mirror::Class::kStatusInitialized, JavaLangObject->GetStatus());
   EXPECT_FALSE(JavaLangObject->IsErroneous());
   EXPECT_TRUE(JavaLangObject->IsLoaded());
   EXPECT_TRUE(JavaLangObject->IsResolved());
-  EXPECT_FALSE(JavaLangObject->IsVerified());
-  EXPECT_FALSE(JavaLangObject->IsInitialized());
+  EXPECT_TRUE(JavaLangObject->IsVerified());
+  EXPECT_TRUE(JavaLangObject->IsInitialized());
   EXPECT_FALSE(JavaLangObject->IsArrayInstance());
   EXPECT_FALSE(JavaLangObject->IsArrayClass());
   EXPECT_TRUE(JavaLangObject->GetComponentType() == NULL);
@@ -752,9 +709,9 @@ TEST_F(ClassLinkerTest, FindClass) {
   EXPECT_EQ(0U, JavaLangObject->NumStaticFields());
   EXPECT_EQ(0U, kh.NumDirectInterfaces());
 
-  SirtRef<ClassLoader> class_loader(soa.Self(), soa.Decode<ClassLoader*>(LoadDex("MyClass")));
+  SirtRef<mirror::ClassLoader> class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(LoadDex("MyClass")));
   AssertNonExistentClass("LMyClass;");
-  Class* MyClass = class_linker_->FindClass("LMyClass;", class_loader.get());
+  mirror::Class* MyClass = class_linker_->FindClass("LMyClass;", class_loader.get());
   kh.ChangeClass(MyClass);
   ASSERT_TRUE(MyClass != NULL);
   ASSERT_TRUE(MyClass->GetClass() != NULL);
@@ -764,7 +721,7 @@ TEST_F(ClassLinkerTest, FindClass) {
   EXPECT_TRUE(MyClass->GetSuperClass() == JavaLangObject);
   EXPECT_TRUE(MyClass->HasSuperClass());
   EXPECT_EQ(class_loader.get(), MyClass->GetClassLoader());
-  EXPECT_EQ(Class::kStatusResolved, MyClass->GetStatus());
+  EXPECT_EQ(mirror::Class::kStatusResolved, MyClass->GetStatus());
   EXPECT_FALSE(MyClass->IsErroneous());
   EXPECT_TRUE(MyClass->IsLoaded());
   EXPECT_TRUE(MyClass->IsResolved());
@@ -805,12 +762,13 @@ TEST_F(ClassLinkerTest, LibCore) {
 // start of the object
 TEST_F(ClassLinkerTest, ValidateObjectArrayElementsOffset) {
   ScopedObjectAccess soa(Thread::Current());
-  Class* array_class = class_linker_->FindSystemClass("[Ljava/lang/String;");
-  ObjectArray<String>* array = ObjectArray<String>::Alloc(soa.Self(), array_class, 0);
+  mirror::Class* array_class = class_linker_->FindSystemClass("[Ljava/lang/String;");
+  mirror::ObjectArray<mirror::String>* array =
+      mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), array_class, 0);
   uint32_t array_offset = reinterpret_cast<uint32_t>(array);
   uint32_t data_offset =
-      array_offset + ObjectArray<String>::DataOffset(sizeof(String*)).Uint32Value();
-  if (sizeof(String*) == sizeof(int32_t)) {
+      array_offset + mirror::ObjectArray<mirror::String>::DataOffset(sizeof(mirror::String*)).Uint32Value();
+  if (sizeof(mirror::String*) == sizeof(int32_t)) {
     EXPECT_TRUE(IsAligned<4>(data_offset));  // Check 4 byte alignment.
   } else {
     EXPECT_TRUE(IsAligned<8>(data_offset));  // Check 8 byte alignment.
@@ -819,27 +777,27 @@ TEST_F(ClassLinkerTest, ValidateObjectArrayElementsOffset) {
 
 TEST_F(ClassLinkerTest, ValidatePrimitiveArrayElementsOffset) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<LongArray> long_array(soa.Self(), LongArray::Alloc(soa.Self(), 0));
+  SirtRef<mirror::LongArray> long_array(soa.Self(), mirror::LongArray::Alloc(soa.Self(), 0));
   EXPECT_EQ(class_linker_->FindSystemClass("[J"), long_array->GetClass());
   uintptr_t data_offset = reinterpret_cast<uintptr_t>(long_array->GetData());
   EXPECT_TRUE(IsAligned<8>(data_offset));  // Longs require 8 byte alignment
 
-  SirtRef<DoubleArray> double_array(soa.Self(), DoubleArray::Alloc(soa.Self(), 0));
+  SirtRef<mirror::DoubleArray> double_array(soa.Self(), mirror::DoubleArray::Alloc(soa.Self(), 0));
   EXPECT_EQ(class_linker_->FindSystemClass("[D"), double_array->GetClass());
   data_offset = reinterpret_cast<uintptr_t>(double_array->GetData());
   EXPECT_TRUE(IsAligned<8>(data_offset));  // Doubles require 8 byte alignment
 
-  SirtRef<IntArray> int_array(soa.Self(), IntArray::Alloc(soa.Self(), 0));
+  SirtRef<mirror::IntArray> int_array(soa.Self(), mirror::IntArray::Alloc(soa.Self(), 0));
   EXPECT_EQ(class_linker_->FindSystemClass("[I"), int_array->GetClass());
   data_offset = reinterpret_cast<uintptr_t>(int_array->GetData());
   EXPECT_TRUE(IsAligned<4>(data_offset));  // Ints require 4 byte alignment
 
-  SirtRef<CharArray> char_array(soa.Self(), CharArray::Alloc(soa.Self(), 0));
+  SirtRef<mirror::CharArray> char_array(soa.Self(), mirror::CharArray::Alloc(soa.Self(), 0));
   EXPECT_EQ(class_linker_->FindSystemClass("[C"), char_array->GetClass());
   data_offset = reinterpret_cast<uintptr_t>(char_array->GetData());
   EXPECT_TRUE(IsAligned<2>(data_offset));  // Chars require 2 byte alignment
 
-  SirtRef<ShortArray> short_array(soa.Self(), ShortArray::Alloc(soa.Self(), 0));
+  SirtRef<mirror::ShortArray> short_array(soa.Self(), mirror::ShortArray::Alloc(soa.Self(), 0));
   EXPECT_EQ(class_linker_->FindSystemClass("[S"), short_array->GetClass());
   data_offset = reinterpret_cast<uintptr_t>(short_array->GetData());
   EXPECT_TRUE(IsAligned<2>(data_offset));  // Shorts require 2 byte alignment
@@ -851,7 +809,7 @@ TEST_F(ClassLinkerTest, ValidateBoxedTypes) {
   // Validate that the "value" field is always the 0th field in each of java.lang's box classes.
   // This lets UnboxPrimitive avoid searching for the field by name at runtime.
   ScopedObjectAccess soa(Thread::Current());
-  Class* c;
+  mirror::Class* c;
   c = class_linker_->FindClass("Ljava/lang/Boolean;", NULL);
   FieldHelper fh(c->GetIFields()->Get(0));
   EXPECT_STREQ("value", fh.GetName());
@@ -880,10 +838,10 @@ TEST_F(ClassLinkerTest, ValidateBoxedTypes) {
 
 TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<ClassLoader> class_loader_1(soa.Self(), soa.Decode<ClassLoader*>(LoadDex("MyClass")));
-  SirtRef<ClassLoader> class_loader_2(soa.Self(), soa.Decode<ClassLoader*>(LoadDex("MyClass")));
-  Class* MyClass_1 = class_linker_->FindClass("LMyClass;", class_loader_1.get());
-  Class* MyClass_2 = class_linker_->FindClass("LMyClass;", class_loader_2.get());
+  SirtRef<mirror::ClassLoader> class_loader_1(soa.Self(), soa.Decode<mirror::ClassLoader*>(LoadDex("MyClass")));
+  SirtRef<mirror::ClassLoader> class_loader_2(soa.Self(), soa.Decode<mirror::ClassLoader*>(LoadDex("MyClass")));
+  mirror::Class* MyClass_1 = class_linker_->FindClass("LMyClass;", class_loader_1.get());
+  mirror::Class* MyClass_2 = class_linker_->FindClass("LMyClass;", class_loader_2.get());
   EXPECT_TRUE(MyClass_1 != NULL);
   EXPECT_TRUE(MyClass_2 != NULL);
   EXPECT_NE(MyClass_1, MyClass_2);
@@ -891,72 +849,72 @@ TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) {
 
 TEST_F(ClassLinkerTest, StaticFields) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<ClassLoader> class_loader(soa.Self(), soa.Decode<ClassLoader*>(LoadDex("Statics")));
-  Class* statics = class_linker_->FindClass("LStatics;", class_loader.get());
+  SirtRef<mirror::ClassLoader> class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(LoadDex("Statics")));
+  mirror::Class* statics = class_linker_->FindClass("LStatics;", class_loader.get());
   class_linker_->EnsureInitialized(statics, true, true);
 
   // Static final primitives that are initialized by a compile-time constant
   // expression resolve to a copy of a constant value from the constant pool.
   // So <clinit> should be null.
-  AbstractMethod* clinit = statics->FindDirectMethod("<clinit>", "()V");
+  mirror::ArtMethod* clinit = statics->FindDirectMethod("<clinit>", "()V");
   EXPECT_TRUE(clinit == NULL);
 
   EXPECT_EQ(9U, statics->NumStaticFields());
 
-  Field* s0 = statics->FindStaticField("s0", "Z");
+  mirror::ArtField* s0 = statics->FindStaticField("s0", "Z");
   FieldHelper fh(s0);
-  EXPECT_STREQ(ClassHelper(s0->GetClass()).GetDescriptor(), "Ljava/lang/reflect/Field;");
+  EXPECT_STREQ(ClassHelper(s0->GetClass()).GetDescriptor(), "Ljava/lang/reflect/ArtField;");
   EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimBoolean);
   EXPECT_EQ(true, s0->GetBoolean(statics));
   s0->SetBoolean(statics, false);
 
-  Field* s1 = statics->FindStaticField("s1", "B");
+  mirror::ArtField* s1 = statics->FindStaticField("s1", "B");
   fh.ChangeField(s1);
   EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimByte);
   EXPECT_EQ(5, s1->GetByte(statics));
   s1->SetByte(statics, 6);
 
-  Field* s2 = statics->FindStaticField("s2", "C");
+  mirror::ArtField* s2 = statics->FindStaticField("s2", "C");
   fh.ChangeField(s2);
   EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimChar);
   EXPECT_EQ('a', s2->GetChar(statics));
   s2->SetChar(statics, 'b');
 
-  Field* s3 = statics->FindStaticField("s3", "S");
+  mirror::ArtField* s3 = statics->FindStaticField("s3", "S");
   fh.ChangeField(s3);
   EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimShort);
   EXPECT_EQ(-536, s3->GetShort(statics));
   s3->SetShort(statics, -535);
 
-  Field* s4 = statics->FindStaticField("s4", "I");
+  mirror::ArtField* s4 = statics->FindStaticField("s4", "I");
   fh.ChangeField(s4);
   EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimInt);
   EXPECT_EQ(2000000000, s4->GetInt(statics));
   s4->SetInt(statics, 2000000001);
 
-  Field* s5 = statics->FindStaticField("s5", "J");
+  mirror::ArtField* s5 = statics->FindStaticField("s5", "J");
   fh.ChangeField(s5);
   EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimLong);
   EXPECT_EQ(0x1234567890abcdefLL, s5->GetLong(statics));
   s5->SetLong(statics, 0x34567890abcdef12LL);
 
-  Field* s6 = statics->FindStaticField("s6", "F");
+  mirror::ArtField* s6 = statics->FindStaticField("s6", "F");
   fh.ChangeField(s6);
   EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimFloat);
   EXPECT_EQ(0.5, s6->GetFloat(statics));
   s6->SetFloat(statics, 0.75);
 
-  Field* s7 = statics->FindStaticField("s7", "D");
+  mirror::ArtField* s7 = statics->FindStaticField("s7", "D");
   fh.ChangeField(s7);
   EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimDouble);
   EXPECT_EQ(16777217, s7->GetDouble(statics));
   s7->SetDouble(statics, 16777219);
 
-  Field* s8 = statics->FindStaticField("s8", "Ljava/lang/String;");
+  mirror::ArtField* s8 = statics->FindStaticField("s8", "Ljava/lang/String;");
   fh.ChangeField(s8);
   EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimNot);
   EXPECT_TRUE(s8->GetObject(statics)->AsString()->Equals("android"));
-  s8->SetObject(s8->GetDeclaringClass(), String::AllocFromModifiedUtf8(soa.Self(), "robot"));
+  s8->SetObject(s8->GetDeclaringClass(), mirror::String::AllocFromModifiedUtf8(soa.Self(), "robot"));
 
   // TODO: Remove EXPECT_FALSE when GCC can handle EXPECT_EQ
   // http://code.google.com/p/googletest/issues/detail?id=322
@@ -973,27 +931,27 @@ TEST_F(ClassLinkerTest, StaticFields) {
 
 TEST_F(ClassLinkerTest, Interfaces) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<ClassLoader> class_loader(soa.Self(), soa.Decode<ClassLoader*>(LoadDex("Interfaces")));
-  Class* I = class_linker_->FindClass("LInterfaces$I;", class_loader.get());
-  Class* J = class_linker_->FindClass("LInterfaces$J;", class_loader.get());
-  Class* K = class_linker_->FindClass("LInterfaces$K;", class_loader.get());
-  Class* A = class_linker_->FindClass("LInterfaces$A;", class_loader.get());
-  Class* B = class_linker_->FindClass("LInterfaces$B;", class_loader.get());
+  SirtRef<mirror::ClassLoader> class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(LoadDex("Interfaces")));
+  mirror::Class* I = class_linker_->FindClass("LInterfaces$I;", class_loader.get());
+  mirror::Class* J = class_linker_->FindClass("LInterfaces$J;", class_loader.get());
+  mirror::Class* K = class_linker_->FindClass("LInterfaces$K;", class_loader.get());
+  mirror::Class* A = class_linker_->FindClass("LInterfaces$A;", class_loader.get());
+  mirror::Class* B = class_linker_->FindClass("LInterfaces$B;", class_loader.get());
   EXPECT_TRUE(I->IsAssignableFrom(A));
   EXPECT_TRUE(J->IsAssignableFrom(A));
   EXPECT_TRUE(J->IsAssignableFrom(K));
   EXPECT_TRUE(K->IsAssignableFrom(B));
   EXPECT_TRUE(J->IsAssignableFrom(B));
 
-  AbstractMethod* Ii = I->FindVirtualMethod("i", "()V");
-  AbstractMethod* Jj1 = J->FindVirtualMethod("j1", "()V");
-  AbstractMethod* Jj2 = J->FindVirtualMethod("j2", "()V");
-  AbstractMethod* Kj1 = K->FindInterfaceMethod("j1", "()V");
-  AbstractMethod* Kj2 = K->FindInterfaceMethod("j2", "()V");
-  AbstractMethod* Kk = K->FindInterfaceMethod("k", "()V");
-  AbstractMethod* Ai = A->FindVirtualMethod("i", "()V");
-  AbstractMethod* Aj1 = A->FindVirtualMethod("j1", "()V");
-  AbstractMethod* Aj2 = A->FindVirtualMethod("j2", "()V");
+  mirror::ArtMethod* Ii = I->FindVirtualMethod("i", "()V");
+  mirror::ArtMethod* Jj1 = J->FindVirtualMethod("j1", "()V");
+  mirror::ArtMethod* Jj2 = J->FindVirtualMethod("j2", "()V");
+  mirror::ArtMethod* Kj1 = K->FindInterfaceMethod("j1", "()V");
+  mirror::ArtMethod* Kj2 = K->FindInterfaceMethod("j2", "()V");
+  mirror::ArtMethod* Kk = K->FindInterfaceMethod("k", "()V");
+  mirror::ArtMethod* Ai = A->FindVirtualMethod("i", "()V");
+  mirror::ArtMethod* Aj1 = A->FindVirtualMethod("j1", "()V");
+  mirror::ArtMethod* Aj2 = A->FindVirtualMethod("j2", "()V");
   ASSERT_TRUE(Ii != NULL);
   ASSERT_TRUE(Jj1 != NULL);
   ASSERT_TRUE(Jj2 != NULL);
@@ -1015,10 +973,10 @@ TEST_F(ClassLinkerTest, Interfaces) {
   EXPECT_EQ(Aj1, A->FindVirtualMethodForVirtualOrInterface(Jj1));
   EXPECT_EQ(Aj2, A->FindVirtualMethodForVirtualOrInterface(Jj2));
 
-  Field* Afoo = A->FindStaticField("foo", "Ljava/lang/String;");
-  Field* Bfoo = B->FindStaticField("foo", "Ljava/lang/String;");
-  Field* Jfoo = J->FindStaticField("foo", "Ljava/lang/String;");
-  Field* Kfoo = K->FindStaticField("foo", "Ljava/lang/String;");
+  mirror::ArtField* Afoo = A->FindStaticField("foo", "Ljava/lang/String;");
+  mirror::ArtField* Bfoo = B->FindStaticField("foo", "Ljava/lang/String;");
+  mirror::ArtField* Jfoo = J->FindStaticField("foo", "Ljava/lang/String;");
+  mirror::ArtField* Kfoo = K->FindStaticField("foo", "Ljava/lang/String;");
   ASSERT_TRUE(Afoo != NULL);
   EXPECT_EQ(Afoo, Bfoo);
   EXPECT_EQ(Afoo, Jfoo);
@@ -1033,30 +991,30 @@ TEST_F(ClassLinkerTest, ResolveVerifyAndClinit) {
 
   ScopedObjectAccess soa(Thread::Current());
   jobject jclass_loader = LoadDex("StaticsFromCode");
-  SirtRef<ClassLoader> class_loader(soa.Self(), soa.Decode<ClassLoader*>(jclass_loader));
+  SirtRef<mirror::ClassLoader> class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(jclass_loader));
   const DexFile* dex_file = Runtime::Current()->GetCompileTimeClassPath(jclass_loader)[0];
   CHECK(dex_file != NULL);
 
-  Class* klass = class_linker_->FindClass("LStaticsFromCode;", class_loader.get());
-  AbstractMethod* clinit = klass->FindDirectMethod("<clinit>", "()V");
-  AbstractMethod* getS0 = klass->FindDirectMethod("getS0", "()Ljava/lang/Object;");
+  mirror::Class* klass = class_linker_->FindClass("LStaticsFromCode;", class_loader.get());
+  mirror::ArtMethod* clinit = klass->FindDirectMethod("<clinit>", "()V");
+  mirror::ArtMethod* getS0 = klass->FindDirectMethod("getS0", "()Ljava/lang/Object;");
   const DexFile::StringId* string_id = dex_file->FindStringId("LStaticsFromCode;");
   ASSERT_TRUE(string_id != NULL);
   const DexFile::TypeId* type_id = dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id));
   ASSERT_TRUE(type_id != NULL);
   uint32_t type_idx = dex_file->GetIndexForTypeId(*type_id);
   EXPECT_TRUE(clinit->GetDexCacheInitializedStaticStorage()->Get(type_idx) == NULL);
-  StaticStorageBase* uninit = ResolveVerifyAndClinit(type_idx, clinit, Thread::Current(), true, false);
+  mirror::StaticStorageBase* uninit = ResolveVerifyAndClinit(type_idx, clinit, Thread::Current(), true, false);
   EXPECT_TRUE(uninit != NULL);
   EXPECT_TRUE(clinit->GetDexCacheInitializedStaticStorage()->Get(type_idx) == NULL);
-  StaticStorageBase* init = ResolveVerifyAndClinit(type_idx, getS0, Thread::Current(), true, false);
+  mirror::StaticStorageBase* init = ResolveVerifyAndClinit(type_idx, getS0, Thread::Current(), true, false);
   EXPECT_TRUE(init != NULL);
   EXPECT_EQ(init, clinit->GetDexCacheInitializedStaticStorage()->Get(type_idx));
 }
 
 TEST_F(ClassLinkerTest, FinalizableBit) {
   ScopedObjectAccess soa(Thread::Current());
-  Class* c;
+  mirror::Class* c;
 
   // Object has a finalize method, but we know it's empty.
   c = class_linker_->FindSystemClass("Ljava/lang/Object;");
@@ -1092,7 +1050,7 @@ TEST_F(ClassLinkerTest, ClassRootDescriptors) {
   ScopedObjectAccess soa(Thread::Current());
   ClassHelper kh;
   for (int i = 0; i < ClassLinker::kClassRootsMax; i++) {
-    Class* klass = class_linker_->GetClassRoot(ClassLinker::ClassRoot(i));
+    mirror::Class* klass = class_linker_->GetClassRoot(ClassLinker::ClassRoot(i));
     kh.ChangeClass(klass);
     EXPECT_TRUE(kh.GetDescriptor() != NULL);
     EXPECT_STREQ(kh.GetDescriptor(),
diff --git a/runtime/common_test.h b/runtime/common_test.h
index 7110e117f3..ced2af9670 100644
--- a/runtime/common_test.h
+++ b/runtime/common_test.h
@@ -181,7 +181,7 @@ class CommonTest : public testing::Test {
                                 reinterpret_cast<uint32_t>(gc_map));
   }
 
-  void MakeExecutable(mirror::AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  void MakeExecutable(mirror::ArtMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     CHECK(method != NULL);
     LOG(INFO) << "MakeExecutable " << PrettyMethod(method);
 
@@ -348,7 +348,7 @@ class CommonTest : public testing::Test {
     compiler_driver_->SetSupportBootImageFixup(false);
 
     // We're back in native, take the opportunity to initialize well known classes.
-    WellKnownClasses::InitClasses(Thread::Current()->GetJniEnv());
+    WellKnownClasses::Init(Thread::Current()->GetJniEnv());
     // Create the heap thread pool so that the GC runs in parallel for tests. Normally, the thread
     // pool is created by the runtime.
     runtime_->GetHeap()->CreateThreadPool();
@@ -464,7 +464,7 @@ class CommonTest : public testing::Test {
     }
   }
 
-  void CompileMethod(mirror::AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  void CompileMethod(mirror::ArtMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     CHECK(method != NULL);
     base::TimingLogger timings("CommonTest::CompileMethod", false, false);
     timings.StartSplit("CompileOne");
@@ -480,7 +480,7 @@ class CommonTest : public testing::Test {
     std::string class_descriptor(DotToDescriptor(class_name));
     mirror::Class* klass = class_linker_->FindClass(class_descriptor.c_str(), class_loader);
     CHECK(klass != NULL) << "Class not found " << class_name;
-    mirror::AbstractMethod* method = klass->FindDirectMethod(method_name, signature);
+    mirror::ArtMethod* method = klass->FindDirectMethod(method_name, signature);
     CHECK(method != NULL) << "Direct method not found: "
                           << class_name << "." << method_name << signature;
     CompileMethod(method);
@@ -494,7 +494,7 @@ class CommonTest : public testing::Test {
     std::string class_descriptor(DotToDescriptor(class_name));
     mirror::Class* klass = class_linker_->FindClass(class_descriptor.c_str(), class_loader);
     CHECK(klass != NULL) << "Class not found " << class_name;
-    mirror::AbstractMethod* method = klass->FindVirtualMethod(method_name, signature);
+    mirror::ArtMethod* method = klass->FindVirtualMethod(method_name, signature);
     CHECK(method != NULL) << "Virtual method not found: "
                           << class_name << "." << method_name << signature;
     CompileMethod(method);
diff --git a/runtime/common_throws.cc b/runtime/common_throws.cc
index 2a55e3138b..26ce5be1ec 100644
--- a/runtime/common_throws.cc
+++ b/runtime/common_throws.cc
@@ -21,7 +21,7 @@
 #include "dex_file-inl.h"
 #include "dex_instruction-inl.h"
 #include "invoke_type.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
@@ -68,7 +68,7 @@ static void ThrowException(const ThrowLocation* throw_location, const char* exce
 
 // AbstractMethodError
 
-void ThrowAbstractMethodError(const mirror::AbstractMethod* method) {
+void ThrowAbstractMethodError(const mirror::ArtMethod* method) {
   ThrowException(NULL, "Ljava/lang/AbstractMethodError;", NULL,
                  StringPrintf("abstract method \"%s\"",
                               PrettyMethod(method).c_str()).c_str());
@@ -136,8 +136,8 @@ void ThrowIllegalAccessErrorClass(mirror::Class* referrer, mirror::Class* access
 }
 
 void ThrowIllegalAccessErrorClassForMethodDispatch(mirror::Class* referrer, mirror::Class* accessed,
-                                                   const mirror::AbstractMethod* caller,
-                                                   const mirror::AbstractMethod* called,
+                                                   const mirror::ArtMethod* caller,
+                                                   const mirror::ArtMethod* called,
                                                    InvokeType type) {
   std::ostringstream msg;
   msg << "Illegal class access ('" << PrettyDescriptor(referrer) << "' attempting to access '"
@@ -146,26 +146,27 @@ void ThrowIllegalAccessErrorClassForMethodDispatch(mirror::Class* referrer, mirr
   ThrowException(NULL, "Ljava/lang/IllegalAccessError;", referrer, msg.str().c_str());
 }
 
-void ThrowIllegalAccessErrorMethod(mirror::Class* referrer, mirror::AbstractMethod* accessed) {
+void ThrowIllegalAccessErrorMethod(mirror::Class* referrer, mirror::ArtMethod* accessed) {
   std::ostringstream msg;
   msg << "Method '" << PrettyMethod(accessed) << "' is inaccessible to class '"
       << PrettyDescriptor(referrer) << "'";
   ThrowException(NULL, "Ljava/lang/IllegalAccessError;", referrer, msg.str().c_str());
 }
 
-void ThrowIllegalAccessErrorField(mirror::Class* referrer, mirror::Field* accessed) {
+void ThrowIllegalAccessErrorField(mirror::Class* referrer, mirror::ArtField* accessed) {
   std::ostringstream msg;
   msg << "Field '" << PrettyField(accessed, false) << "' is inaccessible to class '"
       << PrettyDescriptor(referrer) << "'";
   ThrowException(NULL, "Ljava/lang/IllegalAccessError;", referrer, msg.str().c_str());
 }
 
-void ThrowIllegalAccessErrorFinalField(const mirror::AbstractMethod* referrer,
-                                       mirror::Field* accessed) {
+void ThrowIllegalAccessErrorFinalField(const mirror::ArtMethod* referrer,
+                                       mirror::ArtField* accessed) {
   std::ostringstream msg;
   msg << "Final field '" << PrettyField(accessed, false) << "' cannot be written to by method '"
       << PrettyMethod(referrer) << "'";
-  ThrowException(NULL, "Ljava/lang/IllegalAccessError;", referrer != NULL ? referrer->GetClass() : NULL,
+  ThrowException(NULL, "Ljava/lang/IllegalAccessError;",
+                 referrer != NULL ? referrer->GetClass() : NULL,
                  msg.str().c_str());
 }
 
@@ -186,8 +187,8 @@ void ThrowIllegalArgumentException(const ThrowLocation* throw_location, const ch
 // IncompatibleClassChangeError
 
 void ThrowIncompatibleClassChangeError(InvokeType expected_type, InvokeType found_type,
-                                       mirror::AbstractMethod* method,
-                                       const mirror::AbstractMethod* referrer) {
+                                       mirror::ArtMethod* method,
+                                       const mirror::ArtMethod* referrer) {
   std::ostringstream msg;
   msg << "The method '" << PrettyMethod(method) << "' was expected to be of type "
       << expected_type << " but instead was found to be of type " << found_type;
@@ -196,9 +197,9 @@ void ThrowIncompatibleClassChangeError(InvokeType expected_type, InvokeType foun
                  msg.str().c_str());
 }
 
-void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const mirror::AbstractMethod* interface_method,
+void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const mirror::ArtMethod* interface_method,
                                                                 mirror::Object* this_object,
-                                                                const mirror::AbstractMethod* referrer) {
+                                                                const mirror::ArtMethod* referrer) {
   // Referrer is calling interface_method on this_object, however, the interface_method isn't
   // implemented by this_object.
   CHECK(this_object != NULL);
@@ -212,8 +213,8 @@ void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const mirror::Ab
                  msg.str().c_str());
 }
 
-void ThrowIncompatibleClassChangeErrorField(const mirror::Field* resolved_field, bool is_static,
-                                            const mirror::AbstractMethod* referrer) {
+void ThrowIncompatibleClassChangeErrorField(const mirror::ArtField* resolved_field, bool is_static,
+                                            const mirror::ArtMethod* referrer) {
   std::ostringstream msg;
   msg << "Expected '" << PrettyField(resolved_field) << "' to be a "
       << (is_static ? "static" : "instance") << " field" << " rather than a "
@@ -241,7 +242,8 @@ void ThrowLinkageError(const mirror::Class* referrer, const char* fmt, ...) {
 // NegativeArraySizeException
 
 void ThrowNegativeArraySizeException(int size) {
-  ThrowException(NULL, "Ljava/lang/NegativeArraySizeException;", NULL, StringPrintf("%d", size).c_str());
+  ThrowException(NULL, "Ljava/lang/NegativeArraySizeException;", NULL,
+                 StringPrintf("%d", size).c_str());
 }
 
 void ThrowNegativeArraySizeException(const char* msg) {
@@ -285,7 +287,7 @@ void ThrowNoSuchMethodError(uint32_t method_idx) {
 // NullPointerException
 
 void ThrowNullPointerExceptionForFieldAccess(const ThrowLocation& throw_location,
-                                             mirror::Field* field, bool is_read) {
+                                             mirror::ArtField* field, bool is_read) {
   std::ostringstream msg;
   msg << "Attempt to " << (is_read ? "read from" : "write to")
       << " field '" << PrettyField(field, true) << "' on a null object reference";
@@ -303,7 +305,8 @@ static void ThrowNullPointerExceptionForMethodAccessImpl(const ThrowLocation& th
   ThrowException(&throw_location, "Ljava/lang/NullPointerException;", NULL, msg.str().c_str());
 }
 
-void ThrowNullPointerExceptionForMethodAccess(const ThrowLocation& throw_location, uint32_t method_idx,
+void ThrowNullPointerExceptionForMethodAccess(const ThrowLocation& throw_location,
+                                              uint32_t method_idx,
                                               InvokeType type) {
   mirror::DexCache* dex_cache = throw_location.GetMethod()->GetDeclaringClass()->GetDexCache();
   const DexFile& dex_file = *dex_cache->GetDexFile();
@@ -312,7 +315,7 @@ void ThrowNullPointerExceptionForMethodAccess(const ThrowLocation& throw_locatio
 }
 
 void ThrowNullPointerExceptionForMethodAccess(const ThrowLocation& throw_location,
-                                              mirror::AbstractMethod* method,
+                                              mirror::ArtMethod* method,
                                               InvokeType type) {
   mirror::DexCache* dex_cache = method->GetDeclaringClass()->GetDexCache();
   const DexFile& dex_file = *dex_cache->GetDexFile();
@@ -348,7 +351,7 @@ void ThrowNullPointerExceptionFromDexPC(const ThrowLocation& throw_location) {
     case Instruction::INVOKE_VIRTUAL_RANGE_QUICK: {
       // Since we replaced the method index, we ask the verifier to tell us which
       // method is invoked at this location.
-      mirror::AbstractMethod* method =
+      mirror::ArtMethod* method =
           verifier::MethodVerifier::FindInvokedMethodAtDexPc(throw_location.GetMethod(),
                                                              throw_location.GetDexPc());
       if (method != NULL) {
@@ -368,7 +371,7 @@ void ThrowNullPointerExceptionFromDexPC(const ThrowLocation& throw_location) {
     case Instruction::IGET_BYTE:
     case Instruction::IGET_CHAR:
     case Instruction::IGET_SHORT: {
-      mirror::Field* field =
+      mirror::ArtField* field =
           Runtime::Current()->GetClassLinker()->ResolveField(instr->VRegC_22c(),
                                                              throw_location.GetMethod(), false);
       ThrowNullPointerExceptionForFieldAccess(throw_location, field, true /* read */);
@@ -379,7 +382,7 @@ void ThrowNullPointerExceptionFromDexPC(const ThrowLocation& throw_location) {
     case Instruction::IGET_OBJECT_QUICK: {
       // Since we replaced the field index, we ask the verifier to tell us which
       // field is accessed at this location.
-      mirror::Field* field =
+      mirror::ArtField* field =
           verifier::MethodVerifier::FindAccessedFieldAtDexPc(throw_location.GetMethod(),
                                                              throw_location.GetDexPc());
       if (field != NULL) {
@@ -399,7 +402,7 @@ void ThrowNullPointerExceptionFromDexPC(const ThrowLocation& throw_location) {
     case Instruction::IPUT_BYTE:
     case Instruction::IPUT_CHAR:
     case Instruction::IPUT_SHORT: {
-      mirror::Field* field =
+      mirror::ArtField* field =
           Runtime::Current()->GetClassLinker()->ResolveField(instr->VRegC_22c(),
                                                              throw_location.GetMethod(), false);
       ThrowNullPointerExceptionForFieldAccess(throw_location, field, false /* write */);
@@ -410,7 +413,7 @@ void ThrowNullPointerExceptionFromDexPC(const ThrowLocation& throw_location) {
     case Instruction::IPUT_OBJECT_QUICK: {
       // Since we replaced the field index, we ask the verifier to tell us which
       // field is accessed at this location.
-      mirror::Field* field =
+      mirror::ArtField* field =
           verifier::MethodVerifier::FindAccessedFieldAtDexPc(throw_location.GetMethod(),
                                                              throw_location.GetDexPc());
       if (field != NULL) {
diff --git a/runtime/common_throws.h b/runtime/common_throws.h
index b7f2754df1..99c6343cdd 100644
--- a/runtime/common_throws.h
+++ b/runtime/common_throws.h
@@ -22,9 +22,9 @@
 
 namespace art {
 namespace mirror {
-class AbstractMethod;
+class ArtField;
+class ArtMethod;
 class Class;
-class Field;
 class Object;
 }  // namespace mirror
 class StringPiece;
@@ -32,7 +32,7 @@ class ThrowLocation;
 
 // AbstractMethodError
 
-void ThrowAbstractMethodError(const mirror::AbstractMethod* method)
+void ThrowAbstractMethodError(const mirror::ArtMethod* method)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 // ArithmeticException
@@ -74,19 +74,19 @@ void ThrowIllegalAccessErrorClass(mirror::Class* referrer, mirror::Class* access
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 void ThrowIllegalAccessErrorClassForMethodDispatch(mirror::Class* referrer, mirror::Class* accessed,
-                                                   const mirror::AbstractMethod* caller,
-                                                   const mirror::AbstractMethod* called,
+                                                   const mirror::ArtMethod* caller,
+                                                   const mirror::ArtMethod* called,
                                                    InvokeType type)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-void ThrowIllegalAccessErrorMethod(mirror::Class* referrer, mirror::AbstractMethod* accessed)
+void ThrowIllegalAccessErrorMethod(mirror::Class* referrer, mirror::ArtMethod* accessed)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-void ThrowIllegalAccessErrorField(mirror::Class* referrer, mirror::Field* accessed)
+void ThrowIllegalAccessErrorField(mirror::Class* referrer, mirror::ArtField* accessed)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-void ThrowIllegalAccessErrorFinalField(const mirror::AbstractMethod* referrer,
-                                       mirror::Field* accessed)
+void ThrowIllegalAccessErrorFinalField(const mirror::ArtMethod* referrer,
+                                       mirror::ArtField* accessed)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 void ThrowIllegalAccessError(mirror::Class* referrer, const char* fmt, ...)
@@ -101,17 +101,17 @@ void ThrowIllegalArgumentException(const ThrowLocation* throw_location, const ch
 // IncompatibleClassChangeError
 
 void ThrowIncompatibleClassChangeError(InvokeType expected_type, InvokeType found_type,
-                                       mirror::AbstractMethod* method,
-                                       const mirror::AbstractMethod* referrer)
+                                       mirror::ArtMethod* method,
+                                       const mirror::ArtMethod* referrer)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const mirror::AbstractMethod* interface_method,
+void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const mirror::ArtMethod* interface_method,
                                                                 mirror::Object* this_object,
-                                                                const mirror::AbstractMethod* referrer)
+                                                                const mirror::ArtMethod* referrer)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-void ThrowIncompatibleClassChangeErrorField(const mirror::Field* resolved_field, bool is_static,
-                                            const mirror::AbstractMethod* referrer)
+void ThrowIncompatibleClassChangeErrorField(const mirror::ArtField* resolved_field, bool is_static,
+                                            const mirror::ArtMethod* referrer)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 void ThrowIncompatibleClassChangeError(const mirror::Class* referrer, const char* fmt, ...)
@@ -149,7 +149,7 @@ void ThrowNoSuchMethodError(uint32_t method_idx)
 // NullPointerException
 
 void ThrowNullPointerExceptionForFieldAccess(const ThrowLocation& throw_location,
-                                             mirror::Field* field,
+                                             mirror::ArtField* field,
                                              bool is_read)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -159,7 +159,7 @@ void ThrowNullPointerExceptionForMethodAccess(const ThrowLocation& throw_locatio
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 void ThrowNullPointerExceptionForMethodAccess(const ThrowLocation& throw_location,
-                                              mirror::AbstractMethod* method,
+                                              mirror::ArtMethod* method,
                                               InvokeType type)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
diff --git a/runtime/debugger.cc b/runtime/debugger.cc
index 3591a5097b..569a370b3f 100644
--- a/runtime/debugger.cc
+++ b/runtime/debugger.cc
@@ -30,11 +30,11 @@
 #include "gc/space/space-inl.h"
 #include "invoke_arg_array_builder.h"
 #include "jdwp/object_registry.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
-#include "mirror/field-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/throwable.h"
@@ -60,7 +60,7 @@ static const size_t kMaxAllocRecordStackDepth = 16;  // Max 255.
 static const size_t kDefaultNumAllocRecords = 64*1024;  // Must be a power of 2.
 
 struct AllocRecordStackTraceElement {
-  mirror::AbstractMethod* method;
+  mirror::ArtMethod* method;
   uint32_t dex_pc;
 
   int32_t LineNumber() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -84,9 +84,9 @@ struct AllocRecord {
 };
 
 struct Breakpoint {
-  mirror::AbstractMethod* method;
+  mirror::ArtMethod* method;
   uint32_t dex_pc;
-  Breakpoint(mirror::AbstractMethod* method, uint32_t dex_pc) : method(method), dex_pc(dex_pc) {}
+  Breakpoint(mirror::ArtMethod* method, uint32_t dex_pc) : method(method), dex_pc(dex_pc) {}
 };
 
 static std::ostream& operator<<(std::ostream& os, const Breakpoint& rhs)
@@ -103,7 +103,7 @@ struct SingleStepControl {
   JDWP::JdwpStepSize step_size;
   JDWP::JdwpStepDepth step_depth;
 
-  const mirror::AbstractMethod* method;
+  const mirror::ArtMethod* method;
   int32_t line_number;  // Or -1 for native methods.
   std::set<uint32_t> dex_pcs;
   int stack_depth;
@@ -115,7 +115,7 @@ class DebugInstrumentationListener : public instrumentation::InstrumentationList
   virtual ~DebugInstrumentationListener() {}
 
   virtual void MethodEntered(Thread* thread, mirror::Object* this_object,
-                             const mirror::AbstractMethod* method, uint32_t dex_pc)
+                             const mirror::ArtMethod* method, uint32_t dex_pc)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     if (method->IsNative()) {
       // TODO: post location events is a suspension point and native method entry stubs aren't.
@@ -125,7 +125,7 @@ class DebugInstrumentationListener : public instrumentation::InstrumentationList
   }
 
   virtual void MethodExited(Thread* thread, mirror::Object* this_object,
-                            const mirror::AbstractMethod* method,
+                            const mirror::ArtMethod* method,
                             uint32_t dex_pc, const JValue& return_value)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     UNUSED(return_value);
@@ -136,7 +136,7 @@ class DebugInstrumentationListener : public instrumentation::InstrumentationList
     Dbg::PostLocationEvent(method, dex_pc, this_object, Dbg::kMethodExit);
   }
 
-  virtual void MethodUnwind(Thread* thread, const mirror::AbstractMethod* method,
+  virtual void MethodUnwind(Thread* thread, const mirror::ArtMethod* method,
                             uint32_t dex_pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     // We're not recorded to listen to this kind of event, so complain.
     LOG(ERROR) << "Unexpected method unwind event in debugger " << PrettyMethod(method)
@@ -144,13 +144,13 @@ class DebugInstrumentationListener : public instrumentation::InstrumentationList
   }
 
   virtual void DexPcMoved(Thread* thread, mirror::Object* this_object,
-                          const mirror::AbstractMethod* method, uint32_t new_dex_pc)
+                          const mirror::ArtMethod* method, uint32_t new_dex_pc)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     Dbg::UpdateDebugger(thread, this_object, method, new_dex_pc);
   }
 
   virtual void ExceptionCaught(Thread* thread, const ThrowLocation& throw_location,
-                               mirror::AbstractMethod* catch_method, uint32_t catch_dex_pc,
+                               mirror::ArtMethod* catch_method, uint32_t catch_dex_pc,
                                mirror::Throwable* exception_object)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     Dbg::PostException(thread, throw_location, catch_method, catch_dex_pc, exception_object);
@@ -194,7 +194,7 @@ static size_t gAllocRecordCount GUARDED_BY(gAllocTrackerLock) = 0;
 static std::vector<Breakpoint> gBreakpoints GUARDED_BY(Locks::breakpoint_lock_);
 static SingleStepControl gSingleStepControl GUARDED_BY(Locks::breakpoint_lock_);
 
-static bool IsBreakpoint(const mirror::AbstractMethod* m, uint32_t dex_pc)
+static bool IsBreakpoint(const mirror::ArtMethod* m, uint32_t dex_pc)
     LOCKS_EXCLUDED(Locks::breakpoint_lock_)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
@@ -1131,7 +1131,7 @@ bool Dbg::MatchType(JDWP::RefTypeId instance_class_id, JDWP::RefTypeId class_id)
   return c1->IsAssignableFrom(c2);
 }
 
-static JDWP::FieldId ToFieldId(const mirror::Field* f)
+static JDWP::FieldId ToFieldId(const mirror::ArtField* f)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
 #ifdef MOVING_GARBAGE_COLLECTOR
   UNIMPLEMENTED(FATAL);
@@ -1140,7 +1140,7 @@ static JDWP::FieldId ToFieldId(const mirror::Field* f)
 #endif
 }
 
-static JDWP::MethodId ToMethodId(const mirror::AbstractMethod* m)
+static JDWP::MethodId ToMethodId(const mirror::ArtMethod* m)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
 #ifdef MOVING_GARBAGE_COLLECTOR
   UNIMPLEMENTED(FATAL);
@@ -1149,25 +1149,25 @@ static JDWP::MethodId ToMethodId(const mirror::AbstractMethod* m)
 #endif
 }
 
-static mirror::Field* FromFieldId(JDWP::FieldId fid)
+static mirror::ArtField* FromFieldId(JDWP::FieldId fid)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
 #ifdef MOVING_GARBAGE_COLLECTOR
   UNIMPLEMENTED(FATAL);
 #else
-  return reinterpret_cast<mirror::Field*>(static_cast<uintptr_t>(fid));
+  return reinterpret_cast<mirror::ArtField*>(static_cast<uintptr_t>(fid));
 #endif
 }
 
-static mirror::AbstractMethod* FromMethodId(JDWP::MethodId mid)
+static mirror::ArtMethod* FromMethodId(JDWP::MethodId mid)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
 #ifdef MOVING_GARBAGE_COLLECTOR
   UNIMPLEMENTED(FATAL);
 #else
-  return reinterpret_cast<mirror::AbstractMethod*>(static_cast<uintptr_t>(mid));
+  return reinterpret_cast<mirror::ArtMethod*>(static_cast<uintptr_t>(mid));
 #endif
 }
 
-static void SetLocation(JDWP::JdwpLocation& location, mirror::AbstractMethod* m, uint32_t dex_pc)
+static void SetLocation(JDWP::JdwpLocation& location, mirror::ArtMethod* m, uint32_t dex_pc)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   if (m == NULL) {
     memset(&location, 0, sizeof(location));
@@ -1182,13 +1182,13 @@ static void SetLocation(JDWP::JdwpLocation& location, mirror::AbstractMethod* m,
 
 std::string Dbg::GetMethodName(JDWP::MethodId method_id)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::AbstractMethod* m = FromMethodId(method_id);
+  mirror::ArtMethod* m = FromMethodId(method_id);
   return MethodHelper(m).GetName();
 }
 
 std::string Dbg::GetFieldName(JDWP::FieldId field_id)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* f = FromFieldId(field_id);
+  mirror::ArtField* f = FromFieldId(field_id);
   return FieldHelper(f).GetName();
 }
 
@@ -1230,7 +1230,7 @@ static uint16_t MangleSlot(uint16_t slot, const char* name) {
   return newSlot;
 }
 
-static uint16_t DemangleSlot(uint16_t slot, mirror::AbstractMethod* m)
+static uint16_t DemangleSlot(uint16_t slot, mirror::ArtMethod* m)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   if (slot == kEclipseWorkaroundSlot) {
     return 0;
@@ -1255,7 +1255,7 @@ JDWP::JdwpError Dbg::OutputDeclaredFields(JDWP::RefTypeId class_id, bool with_ge
   expandBufAdd4BE(pReply, instance_field_count + static_field_count);
 
   for (size_t i = 0; i < instance_field_count + static_field_count; ++i) {
-    mirror::Field* f = (i < instance_field_count) ? c->GetInstanceField(i) : c->GetStaticField(i - instance_field_count);
+    mirror::ArtField* f = (i < instance_field_count) ? c->GetInstanceField(i) : c->GetStaticField(i - instance_field_count);
     FieldHelper fh(f);
     expandBufAddFieldId(pReply, ToFieldId(f));
     expandBufAddUtf8String(pReply, fh.GetName());
@@ -1283,7 +1283,7 @@ JDWP::JdwpError Dbg::OutputDeclaredMethods(JDWP::RefTypeId class_id, bool with_g
   expandBufAdd4BE(pReply, direct_method_count + virtual_method_count);
 
   for (size_t i = 0; i < direct_method_count + virtual_method_count; ++i) {
-    mirror::AbstractMethod* m = (i < direct_method_count) ? c->GetDirectMethod(i) : c->GetVirtualMethod(i - direct_method_count);
+    mirror::ArtMethod* m = (i < direct_method_count) ? c->GetDirectMethod(i) : c->GetVirtualMethod(i - direct_method_count);
     MethodHelper mh(m);
     expandBufAddMethodId(pReply, ToMethodId(m));
     expandBufAddUtf8String(pReply, mh.GetName());
@@ -1327,7 +1327,7 @@ void Dbg::OutputLineTable(JDWP::RefTypeId, JDWP::MethodId method_id, JDWP::Expan
       return true;
     }
   };
-  mirror::AbstractMethod* m = FromMethodId(method_id);
+  mirror::ArtMethod* m = FromMethodId(method_id);
   MethodHelper mh(m);
   uint64_t start, end;
   if (m->IsNative()) {
@@ -1381,14 +1381,14 @@ void Dbg::OutputVariableTable(JDWP::RefTypeId, JDWP::MethodId method_id, bool wi
       ++pContext->variable_count;
     }
   };
-  mirror::AbstractMethod* m = FromMethodId(method_id);
+  mirror::ArtMethod* m = FromMethodId(method_id);
   MethodHelper mh(m);
   const DexFile::CodeItem* code_item = mh.GetCodeItem();
 
   // arg_count considers doubles and longs to take 2 units.
   // variable_count considers everything to take 1 unit.
   std::string shorty(mh.GetShorty());
-  expandBufAdd4BE(pReply, mirror::AbstractMethod::NumArgRegisters(shorty));
+  expandBufAdd4BE(pReply, mirror::ArtMethod::NumArgRegisters(shorty));
 
   // We don't know the total number of variables yet, so leave a blank and update it later.
   size_t variable_count_offset = expandBufGetLength(pReply);
@@ -1408,7 +1408,7 @@ void Dbg::OutputVariableTable(JDWP::RefTypeId, JDWP::MethodId method_id, bool wi
 JDWP::JdwpError Dbg::GetBytecodes(JDWP::RefTypeId, JDWP::MethodId method_id,
                                   std::vector<uint8_t>& bytecodes)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::AbstractMethod* m = FromMethodId(method_id);
+  mirror::ArtMethod* m = FromMethodId(method_id);
   if (m == NULL) {
     return JDWP::ERR_INVALID_METHODID;
   }
@@ -1445,7 +1445,7 @@ static JDWP::JdwpError GetFieldValueImpl(JDWP::RefTypeId ref_type_id, JDWP::Obje
   if ((!is_static && o == NULL) || o == ObjectRegistry::kInvalidObject) {
     return JDWP::ERR_INVALID_OBJECT;
   }
-  mirror::Field* f = FromFieldId(field_id);
+  mirror::ArtField* f = FromFieldId(field_id);
 
   mirror::Class* receiver_class = c;
   if (receiver_class == NULL && o != NULL) {
@@ -1511,7 +1511,7 @@ static JDWP::JdwpError SetFieldValueImpl(JDWP::ObjectId object_id, JDWP::FieldId
   if ((!is_static && o == NULL) || o == ObjectRegistry::kInvalidObject) {
     return JDWP::ERR_INVALID_OBJECT;
   }
-  mirror::Field* f = FromFieldId(field_id);
+  mirror::ArtField* f = FromFieldId(field_id);
 
   // The RI only enforces the static/non-static mismatch in one direction.
   // TODO: should we change the tests and check both?
@@ -1580,7 +1580,7 @@ JDWP::JdwpError Dbg::GetThreadName(JDWP::ObjectId thread_id, std::string& name)
 
   // We still need to report the zombie threads' names, so we can't just call Thread::GetThreadName.
   mirror::Object* thread_object = gRegistry->Get<mirror::Object*>(thread_id);
-  mirror::Field* java_lang_Thread_name_field =
+  mirror::ArtField* java_lang_Thread_name_field =
       soa.DecodeField(WellKnownClasses::java_lang_Thread_name);
   mirror::String* s =
       reinterpret_cast<mirror::String*>(java_lang_Thread_name_field->GetObject(thread_object));
@@ -1612,7 +1612,7 @@ JDWP::JdwpError Dbg::GetThreadGroup(JDWP::ObjectId thread_id, JDWP::ExpandBuf* p
 
   mirror::Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/Thread;");
   CHECK(c != NULL);
-  mirror::Field* f = c->FindInstanceField("group", "Ljava/lang/ThreadGroup;");
+  mirror::ArtField* f = c->FindInstanceField("group", "Ljava/lang/ThreadGroup;");
   CHECK(f != NULL);
   mirror::Object* group = f->GetObject(thread_object);
   CHECK(group != NULL);
@@ -1629,7 +1629,7 @@ std::string Dbg::GetThreadGroupName(JDWP::ObjectId thread_group_id) {
 
   mirror::Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/ThreadGroup;");
   CHECK(c != NULL);
-  mirror::Field* f = c->FindInstanceField("name", "Ljava/lang/String;");
+  mirror::ArtField* f = c->FindInstanceField("name", "Ljava/lang/String;");
   CHECK(f != NULL);
   mirror::String* s = reinterpret_cast<mirror::String*>(f->GetObject(thread_group));
   return s->ToModifiedUtf8();
@@ -1641,7 +1641,7 @@ JDWP::ObjectId Dbg::GetThreadGroupParent(JDWP::ObjectId thread_group_id) {
 
   mirror::Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/ThreadGroup;");
   CHECK(c != NULL);
-  mirror::Field* f = c->FindInstanceField("parent", "Ljava/lang/ThreadGroup;");
+  mirror::ArtField* f = c->FindInstanceField("parent", "Ljava/lang/ThreadGroup;");
   CHECK(f != NULL);
   mirror::Object* parent = f->GetObject(thread_group);
   return gRegistry->Add(parent);
@@ -1649,14 +1649,14 @@ JDWP::ObjectId Dbg::GetThreadGroupParent(JDWP::ObjectId thread_group_id) {
 
 JDWP::ObjectId Dbg::GetSystemThreadGroupId() {
   ScopedObjectAccessUnchecked soa(Thread::Current());
-  mirror::Field* f = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup);
+  mirror::ArtField* f = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup);
   mirror::Object* group = f->GetObject(f->GetDeclaringClass());
   return gRegistry->Add(group);
 }
 
 JDWP::ObjectId Dbg::GetMainThreadGroupId() {
   ScopedObjectAccess soa(Thread::Current());
-  mirror::Field* f = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup);
+  mirror::ArtField* f = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup);
   mirror::Object* group = f->GetObject(f->GetDeclaringClass());
   return gRegistry->Add(group);
 }
@@ -1793,12 +1793,12 @@ void Dbg::GetChildThreadGroups(JDWP::ObjectId thread_group_id, std::vector<JDWP:
   mirror::Object* thread_group = gRegistry->Get<mirror::Object*>(thread_group_id);
 
   // Get the ArrayList<ThreadGroup> "groups" out of this thread group...
-  mirror::Field* groups_field = thread_group->GetClass()->FindInstanceField("groups", "Ljava/util/List;");
+  mirror::ArtField* groups_field = thread_group->GetClass()->FindInstanceField("groups", "Ljava/util/List;");
   mirror::Object* groups_array_list = groups_field->GetObject(thread_group);
 
   // Get the array and size out of the ArrayList<ThreadGroup>...
-  mirror::Field* array_field = groups_array_list->GetClass()->FindInstanceField("array", "[Ljava/lang/Object;");
-  mirror::Field* size_field = groups_array_list->GetClass()->FindInstanceField("size", "I");
+  mirror::ArtField* array_field = groups_array_list->GetClass()->FindInstanceField("array", "[Ljava/lang/Object;");
+  mirror::ArtField* size_field = groups_array_list->GetClass()->FindInstanceField("size", "I");
   mirror::ObjectArray<mirror::Object>* groups_array =
       array_field->GetObject(groups_array_list)->AsObjectArray<mirror::Object>();
   const int32_t size = size_field->GetInt(groups_array_list);
@@ -2017,7 +2017,7 @@ void Dbg::GetLocalValue(JDWP::ObjectId thread_id, JDWP::FrameId frame_id, int sl
         return true;  // Not our frame, carry on.
       }
       // TODO: check that the tag is compatible with the actual type of the slot!
-      mirror::AbstractMethod* m = GetMethod();
+      mirror::ArtMethod* m = GetMethod();
       uint16_t reg = DemangleSlot(slot_, m);
 
       switch (tag_) {
@@ -2156,7 +2156,7 @@ void Dbg::SetLocalValue(JDWP::ObjectId thread_id, JDWP::FrameId frame_id, int sl
         return true;  // Not our frame, carry on.
       }
       // TODO: check that the tag is compatible with the actual type of the slot!
-      mirror::AbstractMethod* m = GetMethod();
+      mirror::ArtMethod* m = GetMethod();
       uint16_t reg = DemangleSlot(slot_, m);
 
       switch (tag_) {
@@ -2226,7 +2226,7 @@ void Dbg::SetLocalValue(JDWP::ObjectId thread_id, JDWP::FrameId frame_id, int sl
   visitor.WalkStack();
 }
 
-void Dbg::PostLocationEvent(const mirror::AbstractMethod* m, int dex_pc,
+void Dbg::PostLocationEvent(const mirror::ArtMethod* m, int dex_pc,
                             mirror::Object* this_object, int event_flags) {
   mirror::Class* c = m->GetDeclaringClass();
 
@@ -2246,7 +2246,7 @@ void Dbg::PostLocationEvent(const mirror::AbstractMethod* m, int dex_pc,
 }
 
 void Dbg::PostException(Thread* thread, const ThrowLocation& throw_location,
-                        mirror::AbstractMethod* catch_method,
+                        mirror::ArtMethod* catch_method,
                         uint32_t catch_dex_pc, mirror::Throwable* exception_object) {
   if (!IsDebuggerActive()) {
     return;
@@ -2280,7 +2280,7 @@ void Dbg::PostClassPrepare(mirror::Class* c) {
 }
 
 void Dbg::UpdateDebugger(Thread* thread, mirror::Object* this_object,
-                         const mirror::AbstractMethod* m, uint32_t dex_pc) {
+                         const mirror::ArtMethod* m, uint32_t dex_pc) {
   if (!IsDebuggerActive() || dex_pc == static_cast<uint32_t>(-2) /* fake method exit */) {
     return;
   }
@@ -2361,14 +2361,14 @@ void Dbg::UpdateDebugger(Thread* thread, mirror::Object* this_object,
 
 void Dbg::WatchLocation(const JDWP::JdwpLocation* location) {
   MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
-  mirror::AbstractMethod* m = FromMethodId(location->method_id);
+  mirror::ArtMethod* m = FromMethodId(location->method_id);
   gBreakpoints.push_back(Breakpoint(m, location->dex_pc));
   VLOG(jdwp) << "Set breakpoint #" << (gBreakpoints.size() - 1) << ": " << gBreakpoints[gBreakpoints.size() - 1];
 }
 
 void Dbg::UnwatchLocation(const JDWP::JdwpLocation* location) {
   MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
-  mirror::AbstractMethod* m = FromMethodId(location->method_id);
+  mirror::ArtMethod* m = FromMethodId(location->method_id);
   for (size_t i = 0; i < gBreakpoints.size(); ++i) {
     if (gBreakpoints[i].method == m && gBreakpoints[i].dex_pc == location->dex_pc) {
       VLOG(jdwp) << "Removed breakpoint #" << i << ": " << gBreakpoints[i];
@@ -2468,7 +2468,7 @@ JDWP::JdwpError Dbg::ConfigureStep(JDWP::ObjectId thread_id, JDWP::JdwpStepSize
     // annotalysis.
     bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
       Locks::breakpoint_lock_->AssertHeld(Thread::Current());
-      const mirror::AbstractMethod* m = GetMethod();
+      const mirror::ArtMethod* m = GetMethod();
       if (!m->IsRuntimeMethod()) {
         ++gSingleStepControl.stack_depth;
         if (gSingleStepControl.method == NULL) {
@@ -2538,7 +2538,7 @@ JDWP::JdwpError Dbg::ConfigureStep(JDWP::ObjectId thread_id, JDWP::JdwpStepSize
     uint32_t last_pc;
   };
   gSingleStepControl.dex_pcs.clear();
-  const mirror::AbstractMethod* m = gSingleStepControl.method;
+  const mirror::ArtMethod* m = gSingleStepControl.method;
   if (m->IsNative()) {
     gSingleStepControl.line_number = -1;
   } else {
@@ -2675,7 +2675,7 @@ JDWP::JdwpError Dbg::InvokeMethod(JDWP::ObjectId thread_id, JDWP::ObjectId objec
       return status;
     }
 
-    mirror::AbstractMethod* m = FromMethodId(method_id);
+    mirror::ArtMethod* m = FromMethodId(method_id);
     if (m->IsStatic() != (receiver == NULL)) {
       return JDWP::ERR_INVALID_METHODID;
     }
@@ -2798,7 +2798,7 @@ void Dbg::ExecuteMethod(DebugInvokeReq* pReq) {
   // We can be called while an exception is pending. We need
   // to preserve that across the method invocation.
   SirtRef<mirror::Object> old_throw_this_object(soa.Self(), NULL);
-  SirtRef<mirror::AbstractMethod> old_throw_method(soa.Self(), NULL);
+  SirtRef<mirror::ArtMethod> old_throw_method(soa.Self(), NULL);
   SirtRef<mirror::Throwable> old_exception(soa.Self(), NULL);
   uint32_t old_throw_dex_pc;
   {
@@ -2812,9 +2812,9 @@ void Dbg::ExecuteMethod(DebugInvokeReq* pReq) {
   }
 
   // Translate the method through the vtable, unless the debugger wants to suppress it.
-  mirror::AbstractMethod* m = pReq->method_;
+  mirror::ArtMethod* m = pReq->method_;
   if ((pReq->options_ & JDWP::INVOKE_NONVIRTUAL) == 0 && pReq->receiver_ != NULL) {
-    mirror::AbstractMethod* actual_method = pReq->class_->FindVirtualMethodForVirtualOrInterface(pReq->method_);
+    mirror::ArtMethod* actual_method = pReq->class_->FindVirtualMethodForVirtualOrInterface(pReq->method_);
     if (actual_method != m) {
       VLOG(jdwp) << "ExecuteMethod translated " << PrettyMethod(m) << " to " << PrettyMethod(actual_method);
       m = actual_method;
@@ -3491,7 +3491,7 @@ struct AllocRecordStackVisitor : public StackVisitor {
     if (depth >= kMaxAllocRecordStackDepth) {
       return false;
     }
-    mirror::AbstractMethod* m = GetMethod();
+    mirror::ArtMethod* m = GetMethod();
     if (!m->IsRuntimeMethod()) {
       record->stack[depth].method = m;
       record->stack[depth].dex_pc = GetDexPc();
@@ -3574,7 +3574,7 @@ void Dbg::DumpRecentAllocations() {
               << PrettyClass(record->type);
 
     for (size_t stack_frame = 0; stack_frame < kMaxAllocRecordStackDepth; ++stack_frame) {
-      const mirror::AbstractMethod* m = record->stack[stack_frame].method;
+      const mirror::ArtMethod* m = record->stack[stack_frame].method;
       if (m == NULL) {
         break;
       }
@@ -3695,7 +3695,7 @@ jbyteArray Dbg::GetRecentAllocations() {
 
       MethodHelper mh;
       for (size_t i = 0; i < kMaxAllocRecordStackDepth; i++) {
-        mirror::AbstractMethod* m = record->stack[i].method;
+        mirror::ArtMethod* m = record->stack[i].method;
         if (m != NULL) {
           mh.ChangeMethod(m);
           class_names.Add(mh.GetDeclaringClassDescriptor());
diff --git a/runtime/debugger.h b/runtime/debugger.h
index 6b7e2ba6e8..2282305ac2 100644
--- a/runtime/debugger.h
+++ b/runtime/debugger.h
@@ -32,7 +32,7 @@
 
 namespace art {
 namespace mirror {
-class AbstractMethod;
+class ArtMethod;
 class Class;
 class Object;
 class Throwable;
@@ -64,7 +64,7 @@ struct DebugInvokeReq {
   mirror::Object* receiver_;      /* not used for ClassType.InvokeMethod */
   mirror::Object* thread_;
   mirror::Class* class_;
-  mirror::AbstractMethod* method_;
+  mirror::ArtMethod* method_;
   uint32_t arg_count_;
   uint64_t* arg_values_;   /* will be NULL if arg_count_ == 0 */
   uint32_t options_;
@@ -324,11 +324,11 @@ class Dbg {
     kMethodEntry    = 0x04,
     kMethodExit     = 0x08,
   };
-  static void PostLocationEvent(const mirror::AbstractMethod* method, int pcOffset,
+  static void PostLocationEvent(const mirror::ArtMethod* method, int pcOffset,
                                 mirror::Object* thisPtr, int eventFlags)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   static void PostException(Thread* thread, const ThrowLocation& throw_location,
-                            mirror::AbstractMethod* catch_method,
+                            mirror::ArtMethod* catch_method,
                             uint32_t catch_dex_pc, mirror::Throwable* exception)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   static void PostThreadStart(Thread* t)
@@ -339,7 +339,7 @@ class Dbg {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   static void UpdateDebugger(Thread* thread, mirror::Object* this_object,
-                             const mirror::AbstractMethod* method, uint32_t new_dex_pc)
+                             const mirror::ArtMethod* method, uint32_t new_dex_pc)
       LOCKS_EXCLUDED(Locks::breakpoint_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
diff --git a/runtime/dex_file.cc b/runtime/dex_file.cc
index aaff0fc6da..45b34270f9 100644
--- a/runtime/dex_file.cc
+++ b/runtime/dex_file.cc
@@ -31,9 +31,8 @@
 #include "dex_file_verifier.h"
 #include "globals.h"
 #include "leb128.h"
-#include "mirror/abstract_method-inl.h"
-#include "mirror/field.h"
-#include "mirror/field-inl.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/string.h"
 #include "os.h"
 #include "safe_map.h"
@@ -624,7 +623,7 @@ std::string DexFile::CreateMethodSignature(uint32_t proto_idx, int32_t* unicode_
   return descriptor;
 }
 
-int32_t DexFile::GetLineNumFromPC(const mirror::AbstractMethod* method, uint32_t rel_pc) const {
+int32_t DexFile::GetLineNumFromPC(const mirror::ArtMethod* method, uint32_t rel_pc) const {
   // For native method, lineno should be -2 to indicate it is native. Note that
   // "line number == -2" is how libcore tells from StackTraceElement.
   if (method->GetCodeItemOffset() == 0) {
@@ -1024,7 +1023,7 @@ void EncodedStaticFieldValueIterator::Next() {
   ptr_ += width;
 }
 
-void EncodedStaticFieldValueIterator::ReadValueToField(mirror::Field* field) const {
+void EncodedStaticFieldValueIterator::ReadValueToField(mirror::ArtField* field) const {
   switch (type_) {
     case kBoolean: field->SetBoolean(field->GetDeclaringClass(), jval_.z); break;
     case kByte:    field->SetByte(field->GetDeclaringClass(), jval_.b); break;
diff --git a/runtime/dex_file.h b/runtime/dex_file.h
index a60a1398d8..006b692c85 100644
--- a/runtime/dex_file.h
+++ b/runtime/dex_file.h
@@ -34,10 +34,10 @@
 namespace art {
 
 namespace mirror {
-class AbstractMethod;
-class ClassLoader;
-class DexCache;
-class Field;
+  class ArtField;
+  class ArtMethod;
+  class ClassLoader;
+  class DexCache;
 }  // namespace mirror
 class ClassLinker;
 class ZipArchive;
@@ -786,7 +786,7 @@ class DexFile {
   // Returns -2 for native methods (as expected in exception traces).
   //
   // This is used by runtime; therefore use art::Method not art::DexFile::Method.
-  int32_t GetLineNumFromPC(const mirror::AbstractMethod* method, uint32_t rel_pc) const
+  int32_t GetLineNumFromPC(const mirror::ArtMethod* method, uint32_t rel_pc) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void DecodeDebugInfo(const CodeItem* code_item, bool is_static, uint32_t method_idx,
@@ -1135,7 +1135,7 @@ class EncodedStaticFieldValueIterator {
                                   ClassLinker* linker, const DexFile::ClassDef& class_def)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void ReadValueToField(mirror::Field* field) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void ReadValueToField(mirror::ArtField* field) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   bool HasNext() { return pos_ < array_size_; }
 
diff --git a/runtime/entrypoints/entrypoint_utils.cc b/runtime/entrypoints/entrypoint_utils.cc
index c29784151c..6b8c41ed41 100644
--- a/runtime/entrypoints/entrypoint_utils.cc
+++ b/runtime/entrypoints/entrypoint_utils.cc
@@ -19,9 +19,9 @@
 #include "class_linker-inl.h"
 #include "dex_file-inl.h"
 #include "gc/accounting/card_table-inl.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
-#include "mirror/field-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/proxy.h"
@@ -33,7 +33,7 @@
 namespace art {
 
 // Helper function to allocate array for FILLED_NEW_ARRAY.
-mirror::Array* CheckAndAllocArrayFromCode(uint32_t type_idx, mirror::AbstractMethod* referrer,
+mirror::Array* CheckAndAllocArrayFromCode(uint32_t type_idx, mirror::ArtMethod* referrer,
                                           int32_t component_count, Thread* self,
                                           bool access_check) {
   if (UNLIKELY(component_count < 0)) {
@@ -73,7 +73,7 @@ mirror::Array* CheckAndAllocArrayFromCode(uint32_t type_idx, mirror::AbstractMet
   }
 }
 
-mirror::Field* FindFieldFromCode(uint32_t field_idx, const mirror::AbstractMethod* referrer,
+mirror::ArtField* FindFieldFromCode(uint32_t field_idx, const mirror::ArtMethod* referrer,
                                  Thread* self, FindFieldType type, size_t expected_size,
                                  bool access_check) {
   bool is_primitive;
@@ -91,7 +91,7 @@ mirror::Field* FindFieldFromCode(uint32_t field_idx, const mirror::AbstractMetho
     default:                     is_primitive = true;  is_set = true;  is_static = true;  break;
   }
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  mirror::Field* resolved_field = class_linker->ResolveField(field_idx, referrer, is_static);
+  mirror::ArtField* resolved_field = class_linker->ResolveField(field_idx, referrer, is_static);
   if (UNLIKELY(resolved_field == NULL)) {
     DCHECK(self->IsExceptionPending());  // Throw exception and unwind.
     return NULL;  // Failure.
@@ -158,12 +158,12 @@ mirror::Field* FindFieldFromCode(uint32_t field_idx, const mirror::AbstractMetho
 }
 
 // Slow path method resolution
-mirror::AbstractMethod* FindMethodFromCode(uint32_t method_idx, mirror::Object* this_object,
-                                           mirror::AbstractMethod* referrer,
+mirror::ArtMethod* FindMethodFromCode(uint32_t method_idx, mirror::Object* this_object,
+                                           mirror::ArtMethod* referrer,
                                            Thread* self, bool access_check, InvokeType type) {
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   bool is_direct = type == kStatic || type == kDirect;
-  mirror::AbstractMethod* resolved_method = class_linker->ResolveMethod(method_idx, referrer, type);
+  mirror::ArtMethod* resolved_method = class_linker->ResolveMethod(method_idx, referrer, type);
   if (UNLIKELY(resolved_method == NULL)) {
     DCHECK(self->IsExceptionPending());  // Throw exception and unwind.
     return NULL;  // Failure.
@@ -179,7 +179,7 @@ mirror::AbstractMethod* FindMethodFromCode(uint32_t method_idx, mirror::Object*
       if (is_direct) {
         return resolved_method;
       } else if (type == kInterface) {
-        mirror::AbstractMethod* interface_method =
+        mirror::ArtMethod* interface_method =
             this_object->GetClass()->FindVirtualMethodForInterface(resolved_method);
         if (UNLIKELY(interface_method == NULL)) {
           ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(resolved_method, this_object,
@@ -189,7 +189,7 @@ mirror::AbstractMethod* FindMethodFromCode(uint32_t method_idx, mirror::Object*
           return interface_method;
         }
       } else {
-        mirror::ObjectArray<mirror::AbstractMethod>* vtable;
+        mirror::ObjectArray<mirror::ArtMethod>* vtable;
         uint16_t vtable_index = resolved_method->GetMethodIndex();
         if (type == kSuper) {
           vtable = referrer->GetDeclaringClass()->GetSuperClass()->GetVTable();
@@ -231,7 +231,7 @@ mirror::AbstractMethod* FindMethodFromCode(uint32_t method_idx, mirror::Object*
       if (is_direct) {
         return resolved_method;
       } else if (type == kInterface) {
-        mirror::AbstractMethod* interface_method =
+        mirror::ArtMethod* interface_method =
             this_object->GetClass()->FindVirtualMethodForInterface(resolved_method);
         if (UNLIKELY(interface_method == NULL)) {
           ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(resolved_method, this_object,
@@ -241,7 +241,7 @@ mirror::AbstractMethod* FindMethodFromCode(uint32_t method_idx, mirror::Object*
           return interface_method;
         }
       } else {
-        mirror::ObjectArray<mirror::AbstractMethod>* vtable;
+        mirror::ObjectArray<mirror::ArtMethod>* vtable;
         uint16_t vtable_index = resolved_method->GetMethodIndex();
         if (type == kSuper) {
           mirror::Class* super_class = referring_class->GetSuperClass();
@@ -326,17 +326,15 @@ JValue InvokeProxyInvocationHandler(ScopedObjectAccessUnchecked& soa, const char
     }
   }
 
-  // Call InvocationHandler.invoke(Object proxy, Method method, Object[] args).
-  jobject inv_hand = soa.Env()->GetObjectField(rcvr_jobj,
-                                               WellKnownClasses::java_lang_reflect_Proxy_h);
+  // Call Proxy.invoke(Proxy proxy, ArtMethod method, Object[] args).
   jvalue invocation_args[3];
   invocation_args[0].l = rcvr_jobj;
   invocation_args[1].l = interface_method_jobj;
   invocation_args[2].l = args_jobj;
   jobject result =
-      soa.Env()->CallObjectMethodA(inv_hand,
-                                   WellKnownClasses::java_lang_reflect_InvocationHandler_invoke,
-                                   invocation_args);
+      soa.Env()->CallStaticObjectMethodA(WellKnownClasses::java_lang_reflect_Proxy,
+                                         WellKnownClasses::java_lang_reflect_Proxy_invoke,
+                                         invocation_args);
 
   // Unbox result and handle error conditions.
   if (LIKELY(!soa.Self()->IsExceptionPending())) {
@@ -346,10 +344,10 @@ JValue InvokeProxyInvocationHandler(ScopedObjectAccessUnchecked& soa, const char
     } else {
       mirror::Object* result_ref = soa.Decode<mirror::Object*>(result);
       mirror::Object* rcvr = soa.Decode<mirror::Object*>(rcvr_jobj);
-      mirror::AbstractMethod* interface_method =
-          soa.Decode<mirror::AbstractMethod*>(interface_method_jobj);
+      mirror::ArtMethod* interface_method =
+          soa.Decode<mirror::ArtMethod*>(interface_method_jobj);
       mirror::Class* result_type = MethodHelper(interface_method).GetReturnType();
-      mirror::AbstractMethod* proxy_method;
+      mirror::ArtMethod* proxy_method;
       if (interface_method->GetDeclaringClass()->IsInterface()) {
         proxy_method = rcvr->GetClass()->FindVirtualMethodForInterface(interface_method);
       } else {
@@ -373,9 +371,9 @@ JValue InvokeProxyInvocationHandler(ScopedObjectAccessUnchecked& soa, const char
       mirror::Object* rcvr = soa.Decode<mirror::Object*>(rcvr_jobj);
       mirror::SynthesizedProxyClass* proxy_class =
           down_cast<mirror::SynthesizedProxyClass*>(rcvr->GetClass());
-      mirror::AbstractMethod* interface_method =
-          soa.Decode<mirror::AbstractMethod*>(interface_method_jobj);
-      mirror::AbstractMethod* proxy_method =
+      mirror::ArtMethod* interface_method =
+          soa.Decode<mirror::ArtMethod*>(interface_method_jobj);
+      mirror::ArtMethod* proxy_method =
           rcvr->GetClass()->FindVirtualMethodForInterface(interface_method);
       int throws_index = -1;
       size_t num_virt_methods = proxy_class->NumVirtualMethods();
diff --git a/runtime/entrypoints/entrypoint_utils.h b/runtime/entrypoints/entrypoint_utils.h
index b6781c02b9..2b73af437e 100644
--- a/runtime/entrypoints/entrypoint_utils.h
+++ b/runtime/entrypoints/entrypoint_utils.h
@@ -23,7 +23,7 @@
 #include "indirect_reference_table.h"
 #include "invoke_type.h"
 #include "jni_internal.h"
-#include "mirror/abstract_method.h"
+#include "mirror/art_method.h"
 #include "mirror/array.h"
 #include "mirror/class-inl.h"
 #include "mirror/throwable.h"
@@ -34,7 +34,7 @@ namespace art {
 
 namespace mirror {
   class Class;
-  class Field;
+  class ArtField;
   class Object;
 }  // namespace mirror
 
@@ -42,7 +42,7 @@ namespace mirror {
 // cannot be resolved, throw an error. If it can, use it to create an instance.
 // When verification/compiler hasn't been able to verify access, optionally perform an access
 // check.
-static inline mirror::Object* AllocObjectFromCode(uint32_t type_idx, mirror::AbstractMethod* method,
+static inline mirror::Object* AllocObjectFromCode(uint32_t type_idx, mirror::ArtMethod* method,
                                                   Thread* self,
                                                   bool access_check)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -80,7 +80,7 @@ static inline mirror::Object* AllocObjectFromCode(uint32_t type_idx, mirror::Abs
 // it cannot be resolved, throw an error. If it can, use it to create an array.
 // When verification/compiler hasn't been able to verify access, optionally perform an access
 // check.
-static inline mirror::Array* AllocArrayFromCode(uint32_t type_idx, mirror::AbstractMethod* method,
+static inline mirror::Array* AllocArrayFromCode(uint32_t type_idx, mirror::ArtMethod* method,
                                                 int32_t component_count,
                                                 Thread* self, bool access_check)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -107,7 +107,7 @@ static inline mirror::Array* AllocArrayFromCode(uint32_t type_idx, mirror::Abstr
   return mirror::Array::Alloc(self, klass, component_count);
 }
 
-extern mirror::Array* CheckAndAllocArrayFromCode(uint32_t type_idx, mirror::AbstractMethod* method,
+extern mirror::Array* CheckAndAllocArrayFromCode(uint32_t type_idx, mirror::ArtMethod* method,
                                                  int32_t component_count,
                                                  Thread* self, bool access_check)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -125,17 +125,17 @@ enum FindFieldType {
 };
 
 // Slow field find that can initialize classes and may throw exceptions.
-extern mirror::Field* FindFieldFromCode(uint32_t field_idx, const mirror::AbstractMethod* referrer,
-                                        Thread* self, FindFieldType type, size_t expected_size,
-                                        bool access_check)
+extern mirror::ArtField* FindFieldFromCode(uint32_t field_idx, const mirror::ArtMethod* referrer,
+                                           Thread* self, FindFieldType type, size_t expected_size,
+                                           bool access_check)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 // Fast path field resolution that can't initialize classes or throw exceptions.
-static inline mirror::Field* FindFieldFast(uint32_t field_idx,
-                                           const mirror::AbstractMethod* referrer,
-                                           FindFieldType type, size_t expected_size)
+static inline mirror::ArtField* FindFieldFast(uint32_t field_idx,
+                                              const mirror::ArtMethod* referrer,
+                                              FindFieldType type, size_t expected_size)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* resolved_field =
+  mirror::ArtField* resolved_field =
       referrer->GetDeclaringClass()->GetDexCache()->GetResolvedField(field_idx);
   if (UNLIKELY(resolved_field == NULL)) {
     return NULL;
@@ -186,16 +186,16 @@ static inline mirror::Field* FindFieldFast(uint32_t field_idx,
 }
 
 // Fast path method resolution that can't throw exceptions.
-static inline mirror::AbstractMethod* FindMethodFast(uint32_t method_idx,
-                                                     mirror::Object* this_object,
-                                                     const mirror::AbstractMethod* referrer,
-                                                     bool access_check, InvokeType type)
+static inline mirror::ArtMethod* FindMethodFast(uint32_t method_idx,
+                                                mirror::Object* this_object,
+                                                const mirror::ArtMethod* referrer,
+                                                bool access_check, InvokeType type)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   bool is_direct = type == kStatic || type == kDirect;
   if (UNLIKELY(this_object == NULL && !is_direct)) {
     return NULL;
   }
-  mirror::AbstractMethod* resolved_method =
+  mirror::ArtMethod* resolved_method =
       referrer->GetDeclaringClass()->GetDexCache()->GetResolvedMethod(method_idx);
   if (UNLIKELY(resolved_method == NULL)) {
     return NULL;
@@ -228,13 +228,13 @@ static inline mirror::AbstractMethod* FindMethodFast(uint32_t method_idx,
   }
 }
 
-extern mirror::AbstractMethod* FindMethodFromCode(uint32_t method_idx, mirror::Object* this_object,
-                                                  mirror::AbstractMethod* referrer,
-                                                  Thread* self, bool access_check, InvokeType type)
+extern mirror::ArtMethod* FindMethodFromCode(uint32_t method_idx, mirror::Object* this_object,
+                                             mirror::ArtMethod* referrer,
+                                             Thread* self, bool access_check, InvokeType type)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 static inline mirror::Class* ResolveVerifyAndClinit(uint32_t type_idx,
-                                                    const mirror::AbstractMethod* referrer,
+                                                    const mirror::ArtMethod* referrer,
                                                     Thread* self, bool can_run_clinit,
                                                     bool verify_access)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -271,7 +271,7 @@ static inline mirror::Class* ResolveVerifyAndClinit(uint32_t type_idx,
 
 extern void ThrowStackOverflowError(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-static inline mirror::String* ResolveStringFromCode(const mirror::AbstractMethod* referrer,
+static inline mirror::String* ResolveStringFromCode(const mirror::ArtMethod* referrer,
                                                     uint32_t string_idx)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
@@ -307,7 +307,7 @@ static inline void CheckReferenceResult(mirror::Object* o, Thread* self)
   if (o == NULL) {
     return;
   }
-  mirror::AbstractMethod* m = self->GetCurrentMethod(NULL);
+  mirror::ArtMethod* m = self->GetCurrentMethod(NULL);
   if (o == kInvalidIndirectRefObject) {
     JniAbortF(NULL, "invalid reference returned from %s", PrettyMethod(m).c_str());
   }
@@ -334,7 +334,7 @@ static inline void CheckSuspend(Thread* thread) SHARED_LOCKS_REQUIRED(Locks::mut
 }
 
 JValue InvokeProxyInvocationHandler(ScopedObjectAccessUnchecked& soa, const char* shorty,
-                                    jobject rcvr_jobj, jobject interface_method_jobj,
+                                    jobject rcvr_jobj, jobject interface_art_method_jobj,
                                     std::vector<jvalue>& args)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -356,12 +356,12 @@ static inline uintptr_t GetQuickInstrumentationExitPc() {
   return reinterpret_cast<uintptr_t>(art_quick_instrumentation_exit);
 }
 
-extern "C" void art_portable_to_interpreter_bridge(mirror::AbstractMethod*);
+extern "C" void art_portable_to_interpreter_bridge(mirror::ArtMethod*);
 static inline const void* GetPortableToInterpreterBridge() {
   return reinterpret_cast<void*>(art_portable_to_interpreter_bridge);
 }
 
-extern "C" void art_quick_to_interpreter_bridge(mirror::AbstractMethod*);
+extern "C" void art_quick_to_interpreter_bridge(mirror::ArtMethod*);
 static inline const void* GetQuickToInterpreterBridge() {
   return reinterpret_cast<void*>(art_quick_to_interpreter_bridge);
 }
diff --git a/runtime/entrypoints/interpreter/interpreter_entrypoints.cc b/runtime/entrypoints/interpreter/interpreter_entrypoints.cc
index 67f6d98493..f319a0084b 100644
--- a/runtime/entrypoints/interpreter/interpreter_entrypoints.cc
+++ b/runtime/entrypoints/interpreter/interpreter_entrypoints.cc
@@ -17,7 +17,7 @@
 #include "class_linker.h"
 #include "interpreter/interpreter.h"
 #include "invoke_arg_array_builder.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object-inl.h"
 #include "object_utils.h"
 #include "runtime.h"
@@ -29,7 +29,7 @@ extern "C" void artInterpreterToCompiledCodeBridge(Thread* self, MethodHelper& m
                                                    const DexFile::CodeItem* code_item,
                                                    ShadowFrame* shadow_frame, JValue* result)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::AbstractMethod* method = shadow_frame->GetMethod();
+  mirror::ArtMethod* method = shadow_frame->GetMethod();
   // Ensure static methods are initialized.
   if (method->IsStatic()) {
     Runtime::Current()->GetClassLinker()->EnsureInitialized(method->GetDeclaringClass(), true, true);
diff --git a/runtime/entrypoints/jni/jni_entrypoints.cc b/runtime/entrypoints/jni/jni_entrypoints.cc
index 88b4936255..83d3a584c5 100644
--- a/runtime/entrypoints/jni/jni_entrypoints.cc
+++ b/runtime/entrypoints/jni/jni_entrypoints.cc
@@ -16,7 +16,7 @@
 
 #include "base/logging.h"
 #include "entrypoints/entrypoint_utils.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object-inl.h"
 #include "object_utils.h"
 #include "scoped_thread_state_change.h"
@@ -30,7 +30,7 @@ extern "C" void* artFindNativeMethod() {
   Locks::mutator_lock_->AssertNotHeld(self);  // We come here as Native.
   ScopedObjectAccess soa(self);
 
-  mirror::AbstractMethod* method = self->GetCurrentMethod(NULL);
+  mirror::ArtMethod* method = self->GetCurrentMethod(NULL);
   DCHECK(method != NULL);
 
   // Lookup symbol address for method, on failure we'll return NULL with an exception set,
@@ -69,7 +69,7 @@ extern "C" const void* artWorkAroundAppJniBugs(Thread* self, intptr_t* sp)
   // | unused |
   // | unused |
   // | unused | <- sp
-  mirror::AbstractMethod* jni_method = self->GetCurrentMethod(NULL);
+  mirror::ArtMethod* jni_method = self->GetCurrentMethod(NULL);
   DCHECK(jni_method->IsNative()) << PrettyMethod(jni_method);
   intptr_t* arg_ptr = sp + 4;  // pointer to r1 on stack
   // Fix up this/jclass argument
diff --git a/runtime/entrypoints/portable/portable_alloc_entrypoints.cc b/runtime/entrypoints/portable/portable_alloc_entrypoints.cc
index 286926909c..91b7353bab 100644
--- a/runtime/entrypoints/portable/portable_alloc_entrypoints.cc
+++ b/runtime/entrypoints/portable/portable_alloc_entrypoints.cc
@@ -15,27 +15,27 @@
  */
 
 #include "entrypoints/entrypoint_utils.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object-inl.h"
 
 namespace art {
 
 extern "C" mirror::Object* art_portable_alloc_object_from_code(uint32_t type_idx,
-                                                               mirror::AbstractMethod* referrer,
+                                                               mirror::ArtMethod* referrer,
                                                                Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return AllocObjectFromCode(type_idx, referrer, thread, false);
 }
 
 extern "C" mirror::Object* art_portable_alloc_object_from_code_with_access_check(uint32_t type_idx,
-                                                                                 mirror::AbstractMethod* referrer,
+                                                                                 mirror::ArtMethod* referrer,
                                                                                  Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return AllocObjectFromCode(type_idx, referrer, thread, true);
 }
 
 extern "C" mirror::Object* art_portable_alloc_array_from_code(uint32_t type_idx,
-                                                              mirror::AbstractMethod* referrer,
+                                                              mirror::ArtMethod* referrer,
                                                               uint32_t length,
                                                               Thread* self)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -43,7 +43,7 @@ extern "C" mirror::Object* art_portable_alloc_array_from_code(uint32_t type_idx,
 }
 
 extern "C" mirror::Object* art_portable_alloc_array_from_code_with_access_check(uint32_t type_idx,
-                                                                                mirror::AbstractMethod* referrer,
+                                                                                mirror::ArtMethod* referrer,
                                                                                 uint32_t length,
                                                                                 Thread* self)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -51,7 +51,7 @@ extern "C" mirror::Object* art_portable_alloc_array_from_code_with_access_check(
 }
 
 extern "C" mirror::Object* art_portable_check_and_alloc_array_from_code(uint32_t type_idx,
-                                                                        mirror::AbstractMethod* referrer,
+                                                                        mirror::ArtMethod* referrer,
                                                                         uint32_t length,
                                                                         Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -59,7 +59,7 @@ extern "C" mirror::Object* art_portable_check_and_alloc_array_from_code(uint32_t
 }
 
 extern "C" mirror::Object* art_portable_check_and_alloc_array_from_code_with_access_check(uint32_t type_idx,
-                                                                                          mirror::AbstractMethod* referrer,
+                                                                                          mirror::ArtMethod* referrer,
                                                                                           uint32_t length,
                                                                                           Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
diff --git a/runtime/entrypoints/portable/portable_dexcache_entrypoints.cc b/runtime/entrypoints/portable/portable_dexcache_entrypoints.cc
index bdab587797..b37ebcf785 100644
--- a/runtime/entrypoints/portable/portable_dexcache_entrypoints.cc
+++ b/runtime/entrypoints/portable/portable_dexcache_entrypoints.cc
@@ -16,27 +16,27 @@
 
 #include "entrypoints/entrypoint_utils.h"
 #include "gc/accounting/card_table-inl.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object-inl.h"
 
 namespace art {
 
 extern "C" mirror::Object* art_portable_initialize_static_storage_from_code(uint32_t type_idx,
-                                                                            mirror::AbstractMethod* referrer,
+                                                                            mirror::ArtMethod* referrer,
                                                                             Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return ResolveVerifyAndClinit(type_idx, referrer, thread, true, false);
 }
 
 extern "C" mirror::Object* art_portable_initialize_type_from_code(uint32_t type_idx,
-                                                                  mirror::AbstractMethod* referrer,
+                                                                  mirror::ArtMethod* referrer,
                                                                   Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return ResolveVerifyAndClinit(type_idx, referrer, thread, false, false);
 }
 
 extern "C" mirror::Object* art_portable_initialize_type_and_verify_access_from_code(uint32_t type_idx,
-                                                                                    mirror::AbstractMethod* referrer,
+                                                                                    mirror::ArtMethod* referrer,
                                                                                     Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Called when caller isn't guaranteed to have access to a type and the dex cache may be
@@ -44,7 +44,7 @@ extern "C" mirror::Object* art_portable_initialize_type_and_verify_access_from_c
   return ResolveVerifyAndClinit(type_idx, referrer, thread, false, true);
 }
 
-extern "C" mirror::Object* art_portable_resolve_string_from_code(mirror::AbstractMethod* referrer,
+extern "C" mirror::Object* art_portable_resolve_string_from_code(mirror::ArtMethod* referrer,
                                                                  uint32_t string_idx)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return ResolveStringFromCode(referrer, string_idx);
diff --git a/runtime/entrypoints/portable/portable_entrypoints.h b/runtime/entrypoints/portable/portable_entrypoints.h
index ec9e4f8a7d..d4564471ac 100644
--- a/runtime/entrypoints/portable/portable_entrypoints.h
+++ b/runtime/entrypoints/portable/portable_entrypoints.h
@@ -22,7 +22,7 @@
 
 namespace art {
 namespace mirror {
-  class AbstractMethod;
+  class ArtMethod;
   class Object;
 }  // namespace mirror
 class Thread;
@@ -35,8 +35,8 @@ class Thread;
 // compiler ABI.
 struct PACKED(4) PortableEntryPoints {
   // Invocation
-  void (*pPortableResolutionTrampoline)(mirror::AbstractMethod*);
-  void (*pPortableToInterpreterBridge)(mirror::AbstractMethod*);
+  void (*pPortableResolutionTrampoline)(mirror::ArtMethod*);
+  void (*pPortableToInterpreterBridge)(mirror::ArtMethod*);
 };
 
 }  // namespace art
diff --git a/runtime/entrypoints/portable/portable_field_entrypoints.cc b/runtime/entrypoints/portable/portable_field_entrypoints.cc
index aa0f03ce8b..bd6f79584b 100644
--- a/runtime/entrypoints/portable/portable_field_entrypoints.cc
+++ b/runtime/entrypoints/portable/portable_field_entrypoints.cc
@@ -15,17 +15,17 @@
  */
 
 #include "entrypoints/entrypoint_utils.h"
-#include "mirror/abstract_method-inl.h"
-#include "mirror/field-inl.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object-inl.h"
 
 namespace art {
 
 extern "C" int32_t art_portable_set32_static_from_code(uint32_t field_idx,
-                                                       mirror::AbstractMethod* referrer,
+                                                       mirror::ArtMethod* referrer,
                                                        int32_t new_value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx,
+  mirror::ArtField* field = FindFieldFast(field_idx,
                                referrer,
                                StaticPrimitiveWrite,
                                sizeof(uint32_t));
@@ -47,10 +47,10 @@ extern "C" int32_t art_portable_set32_static_from_code(uint32_t field_idx,
 }
 
 extern "C" int32_t art_portable_set64_static_from_code(uint32_t field_idx,
-                                                       mirror::AbstractMethod* referrer,
+                                                       mirror::ArtMethod* referrer,
                                                        int64_t new_value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(uint64_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(uint64_t));
   if (LIKELY(field != NULL)) {
     field->Set64(field->GetDeclaringClass(), new_value);
     return 0;
@@ -69,11 +69,11 @@ extern "C" int32_t art_portable_set64_static_from_code(uint32_t field_idx,
 }
 
 extern "C" int32_t art_portable_set_obj_static_from_code(uint32_t field_idx,
-                                                         mirror::AbstractMethod* referrer,
+                                                         mirror::ArtMethod* referrer,
                                                          mirror::Object* new_value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticObjectWrite,
-                                       sizeof(mirror::Object*));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, StaticObjectWrite,
+                                          sizeof(mirror::Object*));
   if (LIKELY(field != NULL)) {
     field->SetObj(field->GetDeclaringClass(), new_value);
     return 0;
@@ -88,9 +88,9 @@ extern "C" int32_t art_portable_set_obj_static_from_code(uint32_t field_idx,
 }
 
 extern "C" int32_t art_portable_get32_static_from_code(uint32_t field_idx,
-                                                       mirror::AbstractMethod* referrer)
+                                                       mirror::ArtMethod* referrer)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(uint32_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(uint32_t));
   if (LIKELY(field != NULL)) {
     return field->Get32(field->GetDeclaringClass());
   }
@@ -103,9 +103,9 @@ extern "C" int32_t art_portable_get32_static_from_code(uint32_t field_idx,
 }
 
 extern "C" int64_t art_portable_get64_static_from_code(uint32_t field_idx,
-                                                       mirror::AbstractMethod* referrer)
+                                                       mirror::ArtMethod* referrer)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(uint64_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(uint64_t));
   if (LIKELY(field != NULL)) {
     return field->Get64(field->GetDeclaringClass());
   }
@@ -118,10 +118,10 @@ extern "C" int64_t art_portable_get64_static_from_code(uint32_t field_idx,
 }
 
 extern "C" mirror::Object* art_portable_get_obj_static_from_code(uint32_t field_idx,
-                                                                 mirror::AbstractMethod* referrer)
+                                                                 mirror::ArtMethod* referrer)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticObjectRead,
-                                       sizeof(mirror::Object*));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, StaticObjectRead,
+                                          sizeof(mirror::Object*));
   if (LIKELY(field != NULL)) {
     return field->GetObj(field->GetDeclaringClass());
   }
@@ -134,10 +134,10 @@ extern "C" mirror::Object* art_portable_get_obj_static_from_code(uint32_t field_
 }
 
 extern "C" int32_t art_portable_set32_instance_from_code(uint32_t field_idx,
-                                                         mirror::AbstractMethod* referrer,
+                                                         mirror::ArtMethod* referrer,
                                                          mirror::Object* obj, uint32_t new_value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(uint32_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(uint32_t));
   if (LIKELY(field != NULL)) {
     field->Set32(obj, new_value);
     return 0;
@@ -152,10 +152,10 @@ extern "C" int32_t art_portable_set32_instance_from_code(uint32_t field_idx,
 }
 
 extern "C" int32_t art_portable_set64_instance_from_code(uint32_t field_idx,
-                                                         mirror::AbstractMethod* referrer,
+                                                         mirror::ArtMethod* referrer,
                                                          mirror::Object* obj, int64_t new_value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(uint64_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(uint64_t));
   if (LIKELY(field != NULL)) {
     field->Set64(obj, new_value);
     return 0;
@@ -170,12 +170,12 @@ extern "C" int32_t art_portable_set64_instance_from_code(uint32_t field_idx,
 }
 
 extern "C" int32_t art_portable_set_obj_instance_from_code(uint32_t field_idx,
-                                                           mirror::AbstractMethod* referrer,
+                                                           mirror::ArtMethod* referrer,
                                                            mirror::Object* obj,
                                                            mirror::Object* new_value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, InstanceObjectWrite,
-                                       sizeof(mirror::Object*));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, InstanceObjectWrite,
+                                          sizeof(mirror::Object*));
   if (LIKELY(field != NULL)) {
     field->SetObj(obj, new_value);
     return 0;
@@ -190,10 +190,10 @@ extern "C" int32_t art_portable_set_obj_instance_from_code(uint32_t field_idx,
 }
 
 extern "C" int32_t art_portable_get32_instance_from_code(uint32_t field_idx,
-                                                         mirror::AbstractMethod* referrer,
+                                                         mirror::ArtMethod* referrer,
                                                          mirror::Object* obj)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(uint32_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(uint32_t));
   if (LIKELY(field != NULL)) {
     return field->Get32(obj);
   }
@@ -206,10 +206,10 @@ extern "C" int32_t art_portable_get32_instance_from_code(uint32_t field_idx,
 }
 
 extern "C" int64_t art_portable_get64_instance_from_code(uint32_t field_idx,
-                                                         mirror::AbstractMethod* referrer,
+                                                         mirror::ArtMethod* referrer,
                                                          mirror::Object* obj)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(uint64_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(uint64_t));
   if (LIKELY(field != NULL)) {
     return field->Get64(obj);
   }
@@ -222,11 +222,11 @@ extern "C" int64_t art_portable_get64_instance_from_code(uint32_t field_idx,
 }
 
 extern "C" mirror::Object* art_portable_get_obj_instance_from_code(uint32_t field_idx,
-                                                                   mirror::AbstractMethod* referrer,
+                                                                   mirror::ArtMethod* referrer,
                                                                    mirror::Object* obj)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, InstanceObjectRead,
-                                       sizeof(mirror::Object*));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, InstanceObjectRead,
+                                          sizeof(mirror::Object*));
   if (LIKELY(field != NULL)) {
     return field->GetObj(obj);
   }
diff --git a/runtime/entrypoints/portable/portable_fillarray_entrypoints.cc b/runtime/entrypoints/portable/portable_fillarray_entrypoints.cc
index 771608b604..8cf4eed88f 100644
--- a/runtime/entrypoints/portable/portable_fillarray_entrypoints.cc
+++ b/runtime/entrypoints/portable/portable_fillarray_entrypoints.cc
@@ -16,12 +16,12 @@
 
 #include "dex_instruction.h"
 #include "entrypoints/entrypoint_utils.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object-inl.h"
 
 namespace art {
 
-extern "C" void art_portable_fill_array_data_from_code(mirror::AbstractMethod* method,
+extern "C" void art_portable_fill_array_data_from_code(mirror::ArtMethod* method,
                                                        uint32_t dex_pc,
                                                        mirror::Array* array,
                                                        uint32_t payload_offset)
diff --git a/runtime/entrypoints/portable/portable_invoke_entrypoints.cc b/runtime/entrypoints/portable/portable_invoke_entrypoints.cc
index 5911ba3d8b..14cbd84186 100644
--- a/runtime/entrypoints/portable/portable_invoke_entrypoints.cc
+++ b/runtime/entrypoints/portable/portable_invoke_entrypoints.cc
@@ -15,20 +15,20 @@
  */
 
 #include "entrypoints/entrypoint_utils.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/dex_cache-inl.h"
 #include "mirror/object-inl.h"
 
 namespace art {
 
-static mirror::AbstractMethod* FindMethodHelper(uint32_t method_idx,
+static mirror::ArtMethod* FindMethodHelper(uint32_t method_idx,
                                                 mirror::Object* this_object,
-                                                mirror::AbstractMethod* caller_method,
+                                                mirror::ArtMethod* caller_method,
                                                 bool access_check,
                                                 InvokeType type,
                                                 Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::AbstractMethod* method = FindMethodFast(method_idx,
+  mirror::ArtMethod* method = FindMethodFast(method_idx,
                                                   this_object,
                                                   caller_method,
                                                   access_check,
@@ -55,7 +55,7 @@ static mirror::AbstractMethod* FindMethodHelper(uint32_t method_idx,
 
 extern "C" mirror::Object* art_portable_find_static_method_from_code_with_access_check(uint32_t method_idx,
                                                                                        mirror::Object* this_object,
-                                                                                       mirror::AbstractMethod* referrer,
+                                                                                       mirror::ArtMethod* referrer,
                                                                                        Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return FindMethodHelper(method_idx, this_object, referrer, true, kStatic, thread);
@@ -63,7 +63,7 @@ extern "C" mirror::Object* art_portable_find_static_method_from_code_with_access
 
 extern "C" mirror::Object* art_portable_find_direct_method_from_code_with_access_check(uint32_t method_idx,
                                                                                        mirror::Object* this_object,
-                                                                                       mirror::AbstractMethod* referrer,
+                                                                                       mirror::ArtMethod* referrer,
                                                                                        Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return FindMethodHelper(method_idx, this_object, referrer, true, kDirect, thread);
@@ -71,7 +71,7 @@ extern "C" mirror::Object* art_portable_find_direct_method_from_code_with_access
 
 extern "C" mirror::Object* art_portable_find_virtual_method_from_code_with_access_check(uint32_t method_idx,
                                                                                         mirror::Object* this_object,
-                                                                                        mirror::AbstractMethod* referrer,
+                                                                                        mirror::ArtMethod* referrer,
                                                                                         Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return FindMethodHelper(method_idx, this_object, referrer, true, kVirtual, thread);
@@ -79,7 +79,7 @@ extern "C" mirror::Object* art_portable_find_virtual_method_from_code_with_acces
 
 extern "C" mirror::Object* art_portable_find_super_method_from_code_with_access_check(uint32_t method_idx,
                                                                                       mirror::Object* this_object,
-                                                                                      mirror::AbstractMethod* referrer,
+                                                                                      mirror::ArtMethod* referrer,
                                                                                       Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return FindMethodHelper(method_idx, this_object, referrer, true, kSuper, thread);
@@ -87,7 +87,7 @@ extern "C" mirror::Object* art_portable_find_super_method_from_code_with_access_
 
 extern "C" mirror::Object* art_portable_find_interface_method_from_code_with_access_check(uint32_t method_idx,
                                                                                           mirror::Object* this_object,
-                                                                                          mirror::AbstractMethod* referrer,
+                                                                                          mirror::ArtMethod* referrer,
                                                                                           Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return FindMethodHelper(method_idx, this_object, referrer, true, kInterface, thread);
@@ -95,7 +95,7 @@ extern "C" mirror::Object* art_portable_find_interface_method_from_code_with_acc
 
 extern "C" mirror::Object* art_portable_find_interface_method_from_code(uint32_t method_idx,
                                                                         mirror::Object* this_object,
-                                                                        mirror::AbstractMethod* referrer,
+                                                                        mirror::ArtMethod* referrer,
                                                                         Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return FindMethodHelper(method_idx, this_object, referrer, false, kInterface, thread);
diff --git a/runtime/entrypoints/portable/portable_jni_entrypoints.cc b/runtime/entrypoints/portable/portable_jni_entrypoints.cc
index 8df16ae931..de1e32ef17 100644
--- a/runtime/entrypoints/portable/portable_jni_entrypoints.cc
+++ b/runtime/entrypoints/portable/portable_jni_entrypoints.cc
@@ -15,7 +15,7 @@
  */
 
 #include "entrypoints/entrypoint_utils.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object-inl.h"
 #include "thread-inl.h"
 
diff --git a/runtime/entrypoints/portable/portable_thread_entrypoints.cc b/runtime/entrypoints/portable/portable_thread_entrypoints.cc
index dac73885a5..8a2c8998aa 100644
--- a/runtime/entrypoints/portable/portable_thread_entrypoints.cc
+++ b/runtime/entrypoints/portable/portable_thread_entrypoints.cc
@@ -15,7 +15,7 @@
  */
 
 #include "entrypoints/entrypoint_utils.h"
-#include "mirror/abstract_method.h"
+#include "mirror/art_method.h"
 #include "mirror/object-inl.h"
 #include "verifier/dex_gc_map.h"
 #include "stack.h"
@@ -31,7 +31,7 @@ class ShadowFrameCopyVisitor : public StackVisitor {
     if (IsShadowFrame()) {
       ShadowFrame* cur_frame = GetCurrentShadowFrame();
       size_t num_regs = cur_frame->NumberOfVRegs();
-      mirror::AbstractMethod* method = cur_frame->GetMethod();
+      mirror::ArtMethod* method = cur_frame->GetMethod();
       uint32_t dex_pc = cur_frame->GetDexPC();
       ShadowFrame* new_frame = ShadowFrame::Create(num_regs, NULL, method, dex_pc);
 
@@ -88,7 +88,7 @@ extern "C" void art_portable_test_suspend_from_code(Thread* self)
 
 extern "C" ShadowFrame* art_portable_push_shadow_frame_from_code(Thread* thread,
                                                                  ShadowFrame* new_shadow_frame,
-                                                                 mirror::AbstractMethod* method,
+                                                                 mirror::ArtMethod* method,
                                                                  uint32_t num_vregs) {
   ShadowFrame* old_frame = thread->PushShadowFrame(new_shadow_frame);
   new_shadow_frame->SetMethod(method);
diff --git a/runtime/entrypoints/portable/portable_throw_entrypoints.cc b/runtime/entrypoints/portable/portable_throw_entrypoints.cc
index 64a67ebb4c..2a0df9b896 100644
--- a/runtime/entrypoints/portable/portable_throw_entrypoints.cc
+++ b/runtime/entrypoints/portable/portable_throw_entrypoints.cc
@@ -16,7 +16,7 @@
 
 #include "dex_instruction.h"
 #include "entrypoints/entrypoint_utils.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object-inl.h"
 
 namespace art {
@@ -68,7 +68,7 @@ extern "C" void* art_portable_get_and_clear_exception(Thread* self)
   return exception;
 }
 
-extern "C" int32_t art_portable_find_catch_block_from_code(mirror::AbstractMethod* current_method,
+extern "C" int32_t art_portable_find_catch_block_from_code(mirror::ArtMethod* current_method,
                                                            uint32_t ti_offset)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   Thread* self = Thread::Current();  // TODO: make an argument.
diff --git a/runtime/entrypoints/portable/portable_trampoline_entrypoints.cc b/runtime/entrypoints/portable/portable_trampoline_entrypoints.cc
index c02ace88c1..e1ce11a825 100644
--- a/runtime/entrypoints/portable/portable_trampoline_entrypoints.cc
+++ b/runtime/entrypoints/portable/portable_trampoline_entrypoints.cc
@@ -20,7 +20,7 @@
 #include "dex_instruction-inl.h"
 #include "entrypoints/entrypoint_utils.h"
 #include "interpreter/interpreter.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object-inl.h"
 #include "object_utils.h"
 #include "scoped_thread_state_change.h"
@@ -52,7 +52,7 @@ class PortableArgumentVisitor {
 #define PORTABLE_STACK_ARG_SKIP 0
 #endif
 
-  PortableArgumentVisitor(MethodHelper& caller_mh, mirror::AbstractMethod** sp)
+  PortableArgumentVisitor(MethodHelper& caller_mh, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) :
     caller_mh_(caller_mh),
     args_in_regs_(ComputeArgsInRegs(caller_mh)),
@@ -140,7 +140,7 @@ class PortableArgumentVisitor {
 // Visits arguments on the stack placing them into the shadow frame.
 class BuildPortableShadowFrameVisitor : public PortableArgumentVisitor {
  public:
-  BuildPortableShadowFrameVisitor(MethodHelper& caller_mh, mirror::AbstractMethod** sp,
+  BuildPortableShadowFrameVisitor(MethodHelper& caller_mh, mirror::ArtMethod** sp,
       ShadowFrame& sf, size_t first_arg_reg) :
     PortableArgumentVisitor(caller_mh, sp), sf_(sf), cur_reg_(first_arg_reg) { }
   virtual void Visit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -176,8 +176,8 @@ class BuildPortableShadowFrameVisitor : public PortableArgumentVisitor {
   DISALLOW_COPY_AND_ASSIGN(BuildPortableShadowFrameVisitor);
 };
 
-extern "C" uint64_t artPortableToInterpreterBridge(mirror::AbstractMethod* method, Thread* self,
-                                                mirror::AbstractMethod** sp)
+extern "C" uint64_t artPortableToInterpreterBridge(mirror::ArtMethod* method, Thread* self,
+                                                   mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Ensure we don't get thread suspension until the object arguments are safely in the shadow
   // frame.
@@ -225,7 +225,7 @@ extern "C" uint64_t artPortableToInterpreterBridge(mirror::AbstractMethod* metho
 // to jobjects.
 class BuildPortableArgumentVisitor : public PortableArgumentVisitor {
  public:
-  BuildPortableArgumentVisitor(MethodHelper& caller_mh, mirror::AbstractMethod** sp,
+  BuildPortableArgumentVisitor(MethodHelper& caller_mh, mirror::ArtMethod** sp,
                                ScopedObjectAccessUnchecked& soa, std::vector<jvalue>& args) :
     PortableArgumentVisitor(caller_mh, sp), soa_(soa), args_(args) {}
 
@@ -269,9 +269,9 @@ class BuildPortableArgumentVisitor : public PortableArgumentVisitor {
 // which is responsible for recording callee save registers. We explicitly place into jobjects the
 // incoming reference arguments (so they survive GC). We invoke the invocation handler, which is a
 // field within the proxy object, which will box the primitive arguments and deal with error cases.
-extern "C" uint64_t artPortableProxyInvokeHandler(mirror::AbstractMethod* proxy_method,
+extern "C" uint64_t artPortableProxyInvokeHandler(mirror::ArtMethod* proxy_method,
                                                   mirror::Object* receiver,
-                                                  Thread* self, mirror::AbstractMethod** sp)
+                                                  Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Ensure we don't get thread suspension until the object arguments are safely in jobjects.
   const char* old_cause =
@@ -292,7 +292,7 @@ extern "C" uint64_t artPortableProxyInvokeHandler(mirror::AbstractMethod* proxy_
   args.erase(args.begin());
 
   // Convert proxy method into expected interface method.
-  mirror::AbstractMethod* interface_method = proxy_method->FindOverriddenMethod();
+  mirror::ArtMethod* interface_method = proxy_method->FindOverriddenMethod();
   DCHECK(interface_method != NULL);
   DCHECK(!interface_method->IsProxyMethod()) << PrettyMethod(interface_method);
   jobject interface_method_jobj = soa.AddLocalReference<jobject>(interface_method);
@@ -306,13 +306,13 @@ extern "C" uint64_t artPortableProxyInvokeHandler(mirror::AbstractMethod* proxy_
 }
 
 // Lazily resolve a method for portable. Called by stub code.
-extern "C" const void* artPortableResolutionTrampoline(mirror::AbstractMethod* called,
+extern "C" const void* artPortableResolutionTrampoline(mirror::ArtMethod* called,
                                                        mirror::Object* receiver,
                                                        Thread* thread,
-                                                       mirror::AbstractMethod** called_addr)
+                                                       mirror::ArtMethod** called_addr)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   uint32_t dex_pc;
-  mirror::AbstractMethod* caller = thread->GetCurrentMethod(&dex_pc);
+  mirror::ArtMethod* caller = thread->GetCurrentMethod(&dex_pc);
 
   ClassLinker* linker = Runtime::Current()->GetClassLinker();
   InvokeType invoke_type;
diff --git a/runtime/entrypoints/quick/callee_save_frame.h b/runtime/entrypoints/quick/callee_save_frame.h
index 0cb578ddd0..8f7004920d 100644
--- a/runtime/entrypoints/quick/callee_save_frame.h
+++ b/runtime/entrypoints/quick/callee_save_frame.h
@@ -22,11 +22,11 @@
 
 namespace art {
 namespace mirror {
-class AbstractMethod;
+class ArtMethod;
 }  // namespace mirror
 
 // Place a special frame at the TOS that will save the callee saves for the given type.
-static void FinishCalleeSaveFrameSetup(Thread* self, mirror::AbstractMethod** sp,
+static void FinishCalleeSaveFrameSetup(Thread* self, mirror::ArtMethod** sp,
                                        Runtime::CalleeSaveType type)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Be aware the store below may well stomp on an incoming argument.
diff --git a/runtime/entrypoints/quick/quick_alloc_entrypoints.cc b/runtime/entrypoints/quick/quick_alloc_entrypoints.cc
index 9ed802a2bb..420e63a1bb 100644
--- a/runtime/entrypoints/quick/quick_alloc_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_alloc_entrypoints.cc
@@ -16,61 +16,61 @@
 
 #include "callee_save_frame.h"
 #include "entrypoints/entrypoint_utils.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/object-inl.h"
 
 namespace art {
 
-extern "C" mirror::Object* artAllocObjectFromCode(uint32_t type_idx, mirror::AbstractMethod* method,
-                                                  Thread* self, mirror::AbstractMethod** sp)
+extern "C" mirror::Object* artAllocObjectFromCode(uint32_t type_idx, mirror::ArtMethod* method,
+                                                  Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return AllocObjectFromCode(type_idx, method, self, false);
 }
 
 extern "C" mirror::Object* artAllocObjectFromCodeWithAccessCheck(uint32_t type_idx,
-                                                                 mirror::AbstractMethod* method,
+                                                                 mirror::ArtMethod* method,
                                                                  Thread* self,
-                                                                 mirror::AbstractMethod** sp)
+                                                                 mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return AllocObjectFromCode(type_idx, method, self, true);
 }
 
-extern "C" mirror::Array* artAllocArrayFromCode(uint32_t type_idx, mirror::AbstractMethod* method,
+extern "C" mirror::Array* artAllocArrayFromCode(uint32_t type_idx, mirror::ArtMethod* method,
                                                 int32_t component_count, Thread* self,
-                                                mirror::AbstractMethod** sp)
+                                                mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return AllocArrayFromCode(type_idx, method, component_count, self, false);
 }
 
 extern "C" mirror::Array* artAllocArrayFromCodeWithAccessCheck(uint32_t type_idx,
-                                                               mirror::AbstractMethod* method,
+                                                               mirror::ArtMethod* method,
                                                                int32_t component_count,
                                                                Thread* self,
-                                                               mirror::AbstractMethod** sp)
+                                                               mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return AllocArrayFromCode(type_idx, method, component_count, self, true);
 }
 
 extern "C" mirror::Array* artCheckAndAllocArrayFromCode(uint32_t type_idx,
-                                                        mirror::AbstractMethod* method,
+                                                        mirror::ArtMethod* method,
                                                         int32_t component_count, Thread* self,
-                                                        mirror::AbstractMethod** sp)
+                                                        mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return CheckAndAllocArrayFromCode(type_idx, method, component_count, self, false);
 }
 
 extern "C" mirror::Array* artCheckAndAllocArrayFromCodeWithAccessCheck(uint32_t type_idx,
-                                                                       mirror::AbstractMethod* method,
+                                                                       mirror::ArtMethod* method,
                                                                        int32_t component_count,
                                                                        Thread* self,
-                                                                       mirror::AbstractMethod** sp)
+                                                                       mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return CheckAndAllocArrayFromCode(type_idx, method, component_count, self, true);
diff --git a/runtime/entrypoints/quick/quick_cast_entrypoints.cc b/runtime/entrypoints/quick/quick_cast_entrypoints.cc
index b810bb70a6..9ffa736614 100644
--- a/runtime/entrypoints/quick/quick_cast_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_cast_entrypoints.cc
@@ -33,7 +33,7 @@ extern "C" uint32_t artIsAssignableFromCode(const mirror::Class* klass,
 
 // Check whether it is safe to cast one class to the other, throw exception and return -1 on failure
 extern "C" int artCheckCastFromCode(mirror::Class* src_type, mirror::Class* dest_type,
-                                    Thread* self, mirror::AbstractMethod** sp)
+                                    Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK(src_type->IsClass()) << PrettyClass(src_type);
   DCHECK(dest_type->IsClass()) << PrettyClass(dest_type);
@@ -50,7 +50,7 @@ extern "C" int artCheckCastFromCode(mirror::Class* src_type, mirror::Class* dest
 // Returns 0 on success and -1 if an exception is pending.
 extern "C" int artCanPutArrayElementFromCode(const mirror::Object* element,
                                              const mirror::Class* array_class,
-                                             Thread* self, mirror::AbstractMethod** sp)
+                                             Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK(array_class != NULL);
   // element can't be NULL as we catch this is screened in runtime_support
diff --git a/runtime/entrypoints/quick/quick_deoptimization_entrypoints.cc b/runtime/entrypoints/quick/quick_deoptimization_entrypoints.cc
index 43fc9d2a2d..51c647adf1 100644
--- a/runtime/entrypoints/quick/quick_deoptimization_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_deoptimization_entrypoints.cc
@@ -17,7 +17,7 @@
 #include "callee_save_frame.h"
 #include "dex_file-inl.h"
 #include "interpreter/interpreter.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/object-inl.h"
@@ -28,7 +28,7 @@
 
 namespace art {
 
-extern "C" void artDeoptimize(Thread* self, mirror::AbstractMethod** sp)
+extern "C" void artDeoptimize(Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
   self->SetException(ThrowLocation(), reinterpret_cast<mirror::Throwable*>(-1));
diff --git a/runtime/entrypoints/quick/quick_dexcache_entrypoints.cc b/runtime/entrypoints/quick/quick_dexcache_entrypoints.cc
index 6400161b3e..003047a5f8 100644
--- a/runtime/entrypoints/quick/quick_dexcache_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_dexcache_entrypoints.cc
@@ -19,16 +19,16 @@
 #include "class_linker-inl.h"
 #include "dex_file-inl.h"
 #include "gc/accounting/card_table-inl.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/object-inl.h"
 
 namespace art {
 
 extern "C" mirror::Class* artInitializeStaticStorageFromCode(uint32_t type_idx,
-                                                             const mirror::AbstractMethod* referrer,
+                                                             const mirror::ArtMethod* referrer,
                                                              Thread* self,
-                                                             mirror::AbstractMethod** sp)
+                                                             mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Called to ensure static storage base is initialized for direct static field reads and writes.
   // A class may be accessing another class' fields when it doesn't have access, as access has been
@@ -38,8 +38,8 @@ extern "C" mirror::Class* artInitializeStaticStorageFromCode(uint32_t type_idx,
 }
 
 extern "C" mirror::Class* artInitializeTypeFromCode(uint32_t type_idx,
-                                                    const mirror::AbstractMethod* referrer,
-                                                    Thread* self, mirror::AbstractMethod** sp)
+                                                    const mirror::ArtMethod* referrer,
+                                                    Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Called when method->dex_cache_resolved_types_[] misses.
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
@@ -47,9 +47,9 @@ extern "C" mirror::Class* artInitializeTypeFromCode(uint32_t type_idx,
 }
 
 extern "C" mirror::Class* artInitializeTypeAndVerifyAccessFromCode(uint32_t type_idx,
-                                                                   const mirror::AbstractMethod* referrer,
+                                                                   const mirror::ArtMethod* referrer,
                                                                    Thread* self,
-                                                                   mirror::AbstractMethod** sp)
+                                                                   mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Called when caller isn't guaranteed to have access to a type and the dex cache may be
   // unpopulated.
@@ -57,9 +57,9 @@ extern "C" mirror::Class* artInitializeTypeAndVerifyAccessFromCode(uint32_t type
   return ResolveVerifyAndClinit(type_idx, referrer, self, false, true);
 }
 
-extern "C" mirror::String* artResolveStringFromCode(mirror::AbstractMethod* referrer,
+extern "C" mirror::String* artResolveStringFromCode(mirror::ArtMethod* referrer,
                                                     int32_t string_idx,
-                                                    Thread* self, mirror::AbstractMethod** sp)
+                                                    Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return ResolveStringFromCode(referrer, string_idx);
diff --git a/runtime/entrypoints/quick/quick_entrypoints.h b/runtime/entrypoints/quick/quick_entrypoints.h
index e76679b91f..9d3b8ef27c 100644
--- a/runtime/entrypoints/quick/quick_entrypoints.h
+++ b/runtime/entrypoints/quick/quick_entrypoints.h
@@ -29,9 +29,9 @@
 namespace art {
 
 namespace mirror {
-  class AbstractMethod;
-  class Class;
-  class Object;
+class ArtMethod;
+class Class;
+class Object;
 }  // namespace mirror
 
 class Thread;
@@ -116,8 +116,8 @@ struct PACKED(4) QuickEntryPoints {
   void* (*pMemcpy)(void*, const void*, size_t);
 
   // Invocation
-  void (*pQuickResolutionTrampoline)(mirror::AbstractMethod*);
-  void (*pQuickToInterpreterBridge)(mirror::AbstractMethod*);
+  void (*pQuickResolutionTrampoline)(mirror::ArtMethod*);
+  void (*pQuickToInterpreterBridge)(mirror::ArtMethod*);
   void (*pInvokeDirectTrampolineWithAccessCheck)(uint32_t, void*);
   void (*pInvokeInterfaceTrampoline)(uint32_t, void*);
   void (*pInvokeInterfaceTrampolineWithAccessCheck)(uint32_t, void*);
diff --git a/runtime/entrypoints/quick/quick_field_entrypoints.cc b/runtime/entrypoints/quick/quick_field_entrypoints.cc
index a4e9dc9b27..0ec1eb7920 100644
--- a/runtime/entrypoints/quick/quick_field_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_field_entrypoints.cc
@@ -17,19 +17,20 @@
 #include "callee_save_frame.h"
 #include "dex_file-inl.h"
 #include "entrypoints/entrypoint_utils.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
-#include "mirror/field-inl.h"
 
 #include <stdint.h>
 
 namespace art {
 
 extern "C" uint32_t artGet32StaticFromCode(uint32_t field_idx,
-                                           const mirror::AbstractMethod* referrer,
-                                           Thread* self, mirror::AbstractMethod** sp)
+                                           const mirror::ArtMethod* referrer,
+                                           Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(int32_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead,
+                                          sizeof(int32_t));
   if (LIKELY(field != NULL)) {
     return field->Get32(field->GetDeclaringClass());
   }
@@ -42,10 +43,11 @@ extern "C" uint32_t artGet32StaticFromCode(uint32_t field_idx,
 }
 
 extern "C" uint64_t artGet64StaticFromCode(uint32_t field_idx,
-                                           const mirror::AbstractMethod* referrer,
-                                           Thread* self, mirror::AbstractMethod** sp)
+                                           const mirror::ArtMethod* referrer,
+                                           Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(int64_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead,
+                                          sizeof(int64_t));
   if (LIKELY(field != NULL)) {
     return field->Get64(field->GetDeclaringClass());
   }
@@ -58,16 +60,17 @@ extern "C" uint64_t artGet64StaticFromCode(uint32_t field_idx,
 }
 
 extern "C" mirror::Object* artGetObjStaticFromCode(uint32_t field_idx,
-                                                   const mirror::AbstractMethod* referrer,
-                                                   Thread* self, mirror::AbstractMethod** sp)
+                                                   const mirror::ArtMethod* referrer,
+                                                   Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticObjectRead,
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, StaticObjectRead,
                                        sizeof(mirror::Object*));
   if (LIKELY(field != NULL)) {
     return field->GetObj(field->GetDeclaringClass());
   }
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-  field = FindFieldFromCode(field_idx, referrer, self, StaticObjectRead, sizeof(mirror::Object*), true);
+  field = FindFieldFromCode(field_idx, referrer, self, StaticObjectRead, sizeof(mirror::Object*),
+                            true);
   if (LIKELY(field != NULL)) {
     return field->GetObj(field->GetDeclaringClass());
   }
@@ -75,15 +78,17 @@ extern "C" mirror::Object* artGetObjStaticFromCode(uint32_t field_idx,
 }
 
 extern "C" uint32_t artGet32InstanceFromCode(uint32_t field_idx, mirror::Object* obj,
-                                             const mirror::AbstractMethod* referrer, Thread* self,
-                                             mirror::AbstractMethod** sp)
+                                             const mirror::ArtMethod* referrer, Thread* self,
+                                             mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(int32_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead,
+                                          sizeof(int32_t));
   if (LIKELY(field != NULL && obj != NULL)) {
     return field->Get32(obj);
   }
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-  field = FindFieldFromCode(field_idx, referrer, self, InstancePrimitiveRead, sizeof(int32_t), true);
+  field = FindFieldFromCode(field_idx, referrer, self, InstancePrimitiveRead, sizeof(int32_t),
+                            true);
   if (LIKELY(field != NULL)) {
     if (UNLIKELY(obj == NULL)) {
       ThrowLocation throw_location = self->GetCurrentLocationForThrow();
@@ -96,15 +101,17 @@ extern "C" uint32_t artGet32InstanceFromCode(uint32_t field_idx, mirror::Object*
 }
 
 extern "C" uint64_t artGet64InstanceFromCode(uint32_t field_idx, mirror::Object* obj,
-                                             const mirror::AbstractMethod* referrer, Thread* self,
-                                             mirror::AbstractMethod** sp)
+                                             const mirror::ArtMethod* referrer, Thread* self,
+                                             mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(int64_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead,
+                                          sizeof(int64_t));
   if (LIKELY(field != NULL && obj != NULL)) {
     return field->Get64(obj);
   }
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-  field = FindFieldFromCode(field_idx, referrer, self, InstancePrimitiveRead, sizeof(int64_t), true);
+  field = FindFieldFromCode(field_idx, referrer, self, InstancePrimitiveRead, sizeof(int64_t),
+                            true);
   if (LIKELY(field != NULL)) {
     if (UNLIKELY(obj == NULL)) {
       ThrowLocation throw_location = self->GetCurrentLocationForThrow();
@@ -117,16 +124,18 @@ extern "C" uint64_t artGet64InstanceFromCode(uint32_t field_idx, mirror::Object*
 }
 
 extern "C" mirror::Object* artGetObjInstanceFromCode(uint32_t field_idx, mirror::Object* obj,
-                                                     const mirror::AbstractMethod* referrer,
+                                                     const mirror::ArtMethod* referrer,
                                                      Thread* self,
-                                                     mirror::AbstractMethod** sp)
+                                                     mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, InstanceObjectRead, sizeof(mirror::Object*));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, InstanceObjectRead,
+                                          sizeof(mirror::Object*));
   if (LIKELY(field != NULL && obj != NULL)) {
     return field->GetObj(obj);
   }
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-  field = FindFieldFromCode(field_idx, referrer, self, InstanceObjectRead, sizeof(mirror::Object*), true);
+  field = FindFieldFromCode(field_idx, referrer, self, InstanceObjectRead, sizeof(mirror::Object*),
+                            true);
   if (LIKELY(field != NULL)) {
     if (UNLIKELY(obj == NULL)) {
       ThrowLocation throw_location = self->GetCurrentLocationForThrow();
@@ -139,10 +148,11 @@ extern "C" mirror::Object* artGetObjInstanceFromCode(uint32_t field_idx, mirror:
 }
 
 extern "C" int artSet32StaticFromCode(uint32_t field_idx, uint32_t new_value,
-                                      const mirror::AbstractMethod* referrer, Thread* self,
-                                      mirror::AbstractMethod** sp)
+                                      const mirror::ArtMethod* referrer, Thread* self,
+                                      mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(int32_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite,
+                                          sizeof(int32_t));
   if (LIKELY(field != NULL)) {
     field->Set32(field->GetDeclaringClass(), new_value);
     return 0;  // success
@@ -156,10 +166,11 @@ extern "C" int artSet32StaticFromCode(uint32_t field_idx, uint32_t new_value,
   return -1;  // failure
 }
 
-extern "C" int artSet64StaticFromCode(uint32_t field_idx, const mirror::AbstractMethod* referrer,
-                                      uint64_t new_value, Thread* self, mirror::AbstractMethod** sp)
+extern "C" int artSet64StaticFromCode(uint32_t field_idx, const mirror::ArtMethod* referrer,
+                                      uint64_t new_value, Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(int64_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite,
+                                          sizeof(int64_t));
   if (LIKELY(field != NULL)) {
     field->Set64(field->GetDeclaringClass(), new_value);
     return 0;  // success
@@ -174,11 +185,11 @@ extern "C" int artSet64StaticFromCode(uint32_t field_idx, const mirror::Abstract
 }
 
 extern "C" int artSetObjStaticFromCode(uint32_t field_idx, mirror::Object* new_value,
-                                       const mirror::AbstractMethod* referrer, Thread* self,
-                                       mirror::AbstractMethod** sp)
+                                       const mirror::ArtMethod* referrer, Thread* self,
+                                       mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticObjectWrite,
-                                       sizeof(mirror::Object*));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, StaticObjectWrite,
+                                          sizeof(mirror::Object*));
   if (LIKELY(field != NULL)) {
     if (LIKELY(!FieldHelper(field).IsPrimitiveType())) {
       field->SetObj(field->GetDeclaringClass(), new_value);
@@ -195,16 +206,18 @@ extern "C" int artSetObjStaticFromCode(uint32_t field_idx, mirror::Object* new_v
 }
 
 extern "C" int artSet32InstanceFromCode(uint32_t field_idx, mirror::Object* obj, uint32_t new_value,
-                                        const mirror::AbstractMethod* referrer, Thread* self,
-                                        mirror::AbstractMethod** sp)
+                                        const mirror::ArtMethod* referrer, Thread* self,
+                                        mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(int32_t));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite,
+                                          sizeof(int32_t));
   if (LIKELY(field != NULL && obj != NULL)) {
     field->Set32(obj, new_value);
     return 0;  // success
   }
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-  field = FindFieldFromCode(field_idx, referrer, self, InstancePrimitiveWrite, sizeof(int32_t), true);
+  field = FindFieldFromCode(field_idx, referrer, self, InstancePrimitiveWrite, sizeof(int32_t),
+                            true);
   if (LIKELY(field != NULL)) {
     if (UNLIKELY(obj == NULL)) {
       ThrowLocation throw_location = self->GetCurrentLocationForThrow();
@@ -218,20 +231,21 @@ extern "C" int artSet32InstanceFromCode(uint32_t field_idx, mirror::Object* obj,
 }
 
 extern "C" int artSet64InstanceFromCode(uint32_t field_idx, mirror::Object* obj, uint64_t new_value,
-                                        Thread* self, mirror::AbstractMethod** sp)
+                                        Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::AbstractMethod* callee_save = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsOnly);
-  mirror::AbstractMethod* referrer =
-      sp[callee_save->GetFrameSizeInBytes() / sizeof(mirror::AbstractMethod*)];
-  mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite,
-                                       sizeof(int64_t));
+  mirror::ArtMethod* callee_save = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsOnly);
+  mirror::ArtMethod* referrer =
+      sp[callee_save->GetFrameSizeInBytes() / sizeof(mirror::ArtMethod*)];
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite,
+                                          sizeof(int64_t));
   if (LIKELY(field != NULL  && obj != NULL)) {
     field->Set64(obj, new_value);
     return 0;  // success
   }
   *sp = callee_save;
   self->SetTopOfStack(sp, 0);
-  field = FindFieldFromCode(field_idx, referrer, self, InstancePrimitiveWrite, sizeof(int64_t), true);
+  field = FindFieldFromCode(field_idx, referrer, self, InstancePrimitiveWrite, sizeof(int64_t),
+                            true);
   if (LIKELY(field != NULL)) {
     if (UNLIKELY(obj == NULL)) {
       ThrowLocation throw_location = self->GetCurrentLocationForThrow();
@@ -246,11 +260,11 @@ extern "C" int artSet64InstanceFromCode(uint32_t field_idx, mirror::Object* obj,
 
 extern "C" int artSetObjInstanceFromCode(uint32_t field_idx, mirror::Object* obj,
                                          mirror::Object* new_value,
-                                         const mirror::AbstractMethod* referrer, Thread* self,
-                                         mirror::AbstractMethod** sp)
+                                         const mirror::ArtMethod* referrer, Thread* self,
+                                         mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::Field* field = FindFieldFast(field_idx, referrer, InstanceObjectWrite,
-                                       sizeof(mirror::Object*));
+  mirror::ArtField* field = FindFieldFast(field_idx, referrer, InstanceObjectWrite,
+                                          sizeof(mirror::Object*));
   if (LIKELY(field != NULL && obj != NULL)) {
     field->SetObj(obj, new_value);
     return 0;  // success
diff --git a/runtime/entrypoints/quick/quick_fillarray_entrypoints.cc b/runtime/entrypoints/quick/quick_fillarray_entrypoints.cc
index b81ad12b7b..ca0c92e6d5 100644
--- a/runtime/entrypoints/quick/quick_fillarray_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_fillarray_entrypoints.cc
@@ -39,7 +39,7 @@ namespace art {
  */
 extern "C" int artHandleFillArrayDataFromCode(mirror::Array* array,
                                               const Instruction::ArrayDataPayload* payload,
-                                              Thread* self, mirror::AbstractMethod** sp)
+                                              Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   DCHECK_EQ(payload->ident, static_cast<uint16_t>(Instruction::kArrayDataSignature));
diff --git a/runtime/entrypoints/quick/quick_instrumentation_entrypoints.cc b/runtime/entrypoints/quick/quick_instrumentation_entrypoints.cc
index 0e61942209..633f580bd6 100644
--- a/runtime/entrypoints/quick/quick_instrumentation_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_instrumentation_entrypoints.cc
@@ -16,17 +16,17 @@
 
 #include "callee_save_frame.h"
 #include "instrumentation.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/object-inl.h"
 #include "runtime.h"
 #include "thread-inl.h"
 
 namespace art {
 
-extern "C" const void* artInstrumentationMethodEntryFromCode(mirror::AbstractMethod* method,
+extern "C" const void* artInstrumentationMethodEntryFromCode(mirror::ArtMethod* method,
                                                              mirror::Object* this_object,
                                                              Thread* self,
-                                                             mirror::AbstractMethod** sp,
+                                                             mirror::ArtMethod** sp,
                                                              uintptr_t lr)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
@@ -39,7 +39,7 @@ extern "C" const void* artInstrumentationMethodEntryFromCode(mirror::AbstractMet
   return result;
 }
 
-extern "C" uint64_t artInstrumentationMethodExitFromCode(Thread* self, mirror::AbstractMethod** sp,
+extern "C" uint64_t artInstrumentationMethodExitFromCode(Thread* self, mirror::ArtMethod** sp,
                                                          uint64_t gpr_result, uint64_t fpr_result)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // TODO: use FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly) not the hand inlined below.
@@ -47,7 +47,7 @@ extern "C" uint64_t artInstrumentationMethodExitFromCode(Thread* self, mirror::A
   //       stack.
   // Be aware the store below may well stomp on an incoming argument.
   Locks::mutator_lock_->AssertSharedHeld(self);
-  mirror::AbstractMethod* callee_save = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsOnly);
+  mirror::ArtMethod* callee_save = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsOnly);
   *sp = callee_save;
   uintptr_t* return_pc = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp) +
                                                       callee_save->GetReturnPcOffsetInBytes());
diff --git a/runtime/entrypoints/quick/quick_invoke_entrypoints.cc b/runtime/entrypoints/quick/quick_invoke_entrypoints.cc
index 53b3628e2f..1d8022f803 100644
--- a/runtime/entrypoints/quick/quick_invoke_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_invoke_entrypoints.cc
@@ -17,21 +17,21 @@
 #include "callee_save_frame.h"
 #include "dex_instruction-inl.h"
 #include "entrypoints/entrypoint_utils.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/dex_cache-inl.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 
 namespace art {
 
 // Determine target of interface dispatch. This object is known non-null.
-extern "C" uint64_t artInvokeInterfaceTrampoline(mirror::AbstractMethod* interface_method,
+extern "C" uint64_t artInvokeInterfaceTrampoline(mirror::ArtMethod* interface_method,
                                                  mirror::Object* this_object,
-                                                 mirror::AbstractMethod* caller_method,
-                                                 Thread* self, mirror::AbstractMethod** sp)
+                                                 mirror::ArtMethod* caller_method,
+                                                 Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::AbstractMethod* method;
+  mirror::ArtMethod* method;
   if (LIKELY(interface_method->GetDexMethodIndex() != DexFile::kDexNoIndex16)) {
     method = this_object->GetClass()->FindVirtualMethodForInterface(interface_method);
     if (UNLIKELY(method == NULL)) {
@@ -144,11 +144,11 @@ extern "C" uint64_t artInvokeInterfaceTrampoline(mirror::AbstractMethod* interfa
 
 
 static uint64_t artInvokeCommon(uint32_t method_idx, mirror::Object* this_object,
-                                mirror::AbstractMethod* caller_method,
-                                Thread* self, mirror::AbstractMethod** sp, bool access_check,
+                                mirror::ArtMethod* caller_method,
+                                Thread* self, mirror::ArtMethod** sp, bool access_check,
                                 InvokeType type)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  mirror::AbstractMethod* method = FindMethodFast(method_idx, this_object, caller_method,
+  mirror::ArtMethod* method = FindMethodFast(method_idx, this_object, caller_method,
                                                   access_check, type);
   if (UNLIKELY(method == NULL)) {
     FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
@@ -179,9 +179,9 @@ static uint64_t artInvokeCommon(uint32_t method_idx, mirror::Object* this_object
 // See comments in runtime_support_asm.S
 extern "C" uint64_t artInvokeInterfaceTrampolineWithAccessCheck(uint32_t method_idx,
                                                                 mirror::Object* this_object,
-                                                                mirror::AbstractMethod* caller_method,
+                                                                mirror::ArtMethod* caller_method,
                                                                 Thread* self,
-                                                                mirror::AbstractMethod** sp)
+                                                                mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kInterface);
 }
@@ -189,36 +189,36 @@ extern "C" uint64_t artInvokeInterfaceTrampolineWithAccessCheck(uint32_t method_
 
 extern "C" uint64_t artInvokeDirectTrampolineWithAccessCheck(uint32_t method_idx,
                                                              mirror::Object* this_object,
-                                                             mirror::AbstractMethod* caller_method,
+                                                             mirror::ArtMethod* caller_method,
                                                              Thread* self,
-                                                             mirror::AbstractMethod** sp)
+                                                             mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kDirect);
 }
 
 extern "C" uint64_t artInvokeStaticTrampolineWithAccessCheck(uint32_t method_idx,
                                                              mirror::Object* this_object,
-                                                             mirror::AbstractMethod* caller_method,
+                                                             mirror::ArtMethod* caller_method,
                                                              Thread* self,
-                                                             mirror::AbstractMethod** sp)
+                                                             mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kStatic);
 }
 
 extern "C" uint64_t artInvokeSuperTrampolineWithAccessCheck(uint32_t method_idx,
                                                             mirror::Object* this_object,
-                                                            mirror::AbstractMethod* caller_method,
+                                                            mirror::ArtMethod* caller_method,
                                                             Thread* self,
-                                                            mirror::AbstractMethod** sp)
+                                                            mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kSuper);
 }
 
 extern "C" uint64_t artInvokeVirtualTrampolineWithAccessCheck(uint32_t method_idx,
                                                               mirror::Object* this_object,
-                                                              mirror::AbstractMethod* caller_method,
+                                                              mirror::ArtMethod* caller_method,
                                                               Thread* self,
-                                                              mirror::AbstractMethod** sp)
+                                                              mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kVirtual);
 }
diff --git a/runtime/entrypoints/quick/quick_jni_entrypoints.cc b/runtime/entrypoints/quick/quick_jni_entrypoints.cc
index 9907c043ee..27ae59b9b0 100644
--- a/runtime/entrypoints/quick/quick_jni_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_jni_entrypoints.cc
@@ -16,8 +16,8 @@
 
 #include "dex_file-inl.h"
 #include "entrypoints/entrypoint_utils.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
diff --git a/runtime/entrypoints/quick/quick_lock_entrypoints.cc b/runtime/entrypoints/quick/quick_lock_entrypoints.cc
index 79bb7a69f1..36ca6044a2 100644
--- a/runtime/entrypoints/quick/quick_lock_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_lock_entrypoints.cc
@@ -20,7 +20,7 @@
 namespace art {
 
 extern "C" int artUnlockObjectFromCode(mirror::Object* obj, Thread* self,
-                                       mirror::AbstractMethod** sp)
+                                       mirror::ArtMethod** sp)
     UNLOCK_FUNCTION(monitor_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   DCHECK(obj != NULL);  // Assumed to have been checked before entry
@@ -29,7 +29,7 @@ extern "C" int artUnlockObjectFromCode(mirror::Object* obj, Thread* self,
 }
 
 extern "C" void artLockObjectFromCode(mirror::Object* obj, Thread* thread,
-                                      mirror::AbstractMethod** sp)
+                                      mirror::ArtMethod** sp)
     EXCLUSIVE_LOCK_FUNCTION(monitor_lock_) {
   FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsOnly);
   DCHECK(obj != NULL);        // Assumed to have been checked before entry
diff --git a/runtime/entrypoints/quick/quick_thread_entrypoints.cc b/runtime/entrypoints/quick/quick_thread_entrypoints.cc
index b4d6c0ba8d..53e725edba 100644
--- a/runtime/entrypoints/quick/quick_thread_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_thread_entrypoints.cc
@@ -28,7 +28,7 @@ void CheckSuspendFromCode(Thread* thread)
   CheckSuspend(thread);
 }
 
-extern "C" void artTestSuspendFromCode(Thread* thread, mirror::AbstractMethod** sp)
+extern "C" void artTestSuspendFromCode(Thread* thread, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Called when suspend count check value is 0 and thread->suspend_count_ != 0
   FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsOnly);
diff --git a/runtime/entrypoints/quick/quick_throw_entrypoints.cc b/runtime/entrypoints/quick/quick_throw_entrypoints.cc
index 3bfa2f2611..f67b2fc4ab 100644
--- a/runtime/entrypoints/quick/quick_throw_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_throw_entrypoints.cc
@@ -24,7 +24,7 @@
 namespace art {
 
 // Deliver an exception that's pending on thread helping set up a callee save frame on the way.
-extern "C" void artDeliverPendingExceptionFromCode(Thread* thread, mirror::AbstractMethod** sp)
+extern "C" void artDeliverPendingExceptionFromCode(Thread* thread, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
   thread->QuickDeliverException();
@@ -32,7 +32,7 @@ extern "C" void artDeliverPendingExceptionFromCode(Thread* thread, mirror::Abstr
 
 // Called by generated call to throw an exception.
 extern "C" void artDeliverExceptionFromCode(mirror::Throwable* exception, Thread* self,
-                                            mirror::AbstractMethod** sp)
+                                            mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   /*
    * exception may be NULL, in which case this routine should
@@ -54,7 +54,7 @@ extern "C" void artDeliverExceptionFromCode(mirror::Throwable* exception, Thread
 
 // Called by generated call to throw a NPE exception.
 extern "C" void artThrowNullPointerExceptionFromCode(Thread* self,
-                                                     mirror::AbstractMethod** sp)
+                                                     mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
   ThrowLocation throw_location = self->GetCurrentLocationForThrow();
@@ -64,7 +64,7 @@ extern "C" void artThrowNullPointerExceptionFromCode(Thread* self,
 
 // Called by generated call to throw an arithmetic divide by zero exception.
 extern "C" void artThrowDivZeroFromCode(Thread* self,
-                                        mirror::AbstractMethod** sp)
+                                        mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
   ThrowArithmeticExceptionDivideByZero();
@@ -73,14 +73,14 @@ extern "C" void artThrowDivZeroFromCode(Thread* self,
 
 // Called by generated call to throw an array index out of bounds exception.
 extern "C" void artThrowArrayBoundsFromCode(int index, int length, Thread* self,
-                                            mirror::AbstractMethod** sp)
+                                            mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
   ThrowArrayIndexOutOfBoundsException(index, length);
   self->QuickDeliverException();
 }
 
-extern "C" void artThrowStackOverflowFromCode(Thread* self, mirror::AbstractMethod** sp)
+extern "C" void artThrowStackOverflowFromCode(Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
   ThrowStackOverflowError(self);
@@ -88,7 +88,7 @@ extern "C" void artThrowStackOverflowFromCode(Thread* self, mirror::AbstractMeth
 }
 
 extern "C" void artThrowNoSuchMethodFromCode(int32_t method_idx, Thread* self,
-                                             mirror::AbstractMethod** sp)
+                                             mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
   ThrowNoSuchMethodError(method_idx);
diff --git a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
index 9bf02e8c8e..392bcc5257 100644
--- a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
@@ -19,7 +19,7 @@
 #include "dex_instruction-inl.h"
 #include "interpreter/interpreter.h"
 #include "invoke_arg_array_builder.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
@@ -100,18 +100,18 @@ class QuickArgumentVisitor {
 #define QUICK_STACK_ARG_SKIP 0
 #endif
 
-  static mirror::AbstractMethod* GetCallingMethod(mirror::AbstractMethod** sp) {
+  static mirror::ArtMethod* GetCallingMethod(mirror::ArtMethod** sp) {
     byte* previous_sp = reinterpret_cast<byte*>(sp) +
         QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE;
-    return *reinterpret_cast<mirror::AbstractMethod**>(previous_sp);
+    return *reinterpret_cast<mirror::ArtMethod**>(previous_sp);
   }
 
-  static uintptr_t GetCallingPc(mirror::AbstractMethod** sp) {
+  static uintptr_t GetCallingPc(mirror::ArtMethod** sp) {
     byte* lr = reinterpret_cast<byte*>(sp) + QUICK_CALLEE_SAVE_FRAME__REF_AND_ARGS__LR_OFFSET;
     return *reinterpret_cast<uintptr_t*>(lr);
   }
 
-  QuickArgumentVisitor(mirror::AbstractMethod** sp, bool is_static,
+  QuickArgumentVisitor(mirror::ArtMethod** sp, bool is_static,
                        const char* shorty, uint32_t shorty_len)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) :
     is_static_(is_static), shorty_(shorty), shorty_len_(shorty_len),
@@ -220,7 +220,7 @@ class QuickArgumentVisitor {
 // Visits arguments on the stack placing them into the shadow frame.
 class BuildShadowFrameVisitor : public QuickArgumentVisitor {
  public:
-  BuildShadowFrameVisitor(mirror::AbstractMethod** sp, bool is_static, const char* shorty,
+  BuildShadowFrameVisitor(mirror::ArtMethod** sp, bool is_static, const char* shorty,
                           uint32_t shorty_len, ShadowFrame& sf, size_t first_arg_reg) :
     QuickArgumentVisitor(sp, is_static, shorty, shorty_len), sf_(sf), cur_reg_(first_arg_reg) {}
 
@@ -261,8 +261,8 @@ class BuildShadowFrameVisitor : public QuickArgumentVisitor {
   DISALLOW_COPY_AND_ASSIGN(BuildShadowFrameVisitor);
 };
 
-extern "C" uint64_t artQuickToInterpreterBridge(mirror::AbstractMethod* method, Thread* self,
-                                                mirror::AbstractMethod** sp)
+extern "C" uint64_t artQuickToInterpreterBridge(mirror::ArtMethod* method, Thread* self,
+                                                mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Ensure we don't get thread suspension until the object arguments are safely in the shadow
   // frame.
@@ -311,7 +311,7 @@ extern "C" uint64_t artQuickToInterpreterBridge(mirror::AbstractMethod* method,
 // to jobjects.
 class BuildQuickArgumentVisitor : public QuickArgumentVisitor {
  public:
-  BuildQuickArgumentVisitor(mirror::AbstractMethod** sp, bool is_static, const char* shorty,
+  BuildQuickArgumentVisitor(mirror::ArtMethod** sp, bool is_static, const char* shorty,
                             uint32_t shorty_len, ScopedObjectAccessUnchecked* soa,
                             std::vector<jvalue>* args) :
     QuickArgumentVisitor(sp, is_static, shorty, shorty_len), soa_(soa), args_(args) {}
@@ -360,9 +360,9 @@ class BuildQuickArgumentVisitor : public QuickArgumentVisitor {
 // which is responsible for recording callee save registers. We explicitly place into jobjects the
 // incoming reference arguments (so they survive GC). We invoke the invocation handler, which is a
 // field within the proxy object, which will box the primitive arguments and deal with error cases.
-extern "C" uint64_t artQuickProxyInvokeHandler(mirror::AbstractMethod* proxy_method,
+extern "C" uint64_t artQuickProxyInvokeHandler(mirror::ArtMethod* proxy_method,
                                                mirror::Object* receiver,
-                                               Thread* self, mirror::AbstractMethod** sp)
+                                               Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Ensure we don't get thread suspension until the object arguments are safely in jobjects.
   const char* old_cause =
@@ -389,7 +389,7 @@ extern "C" uint64_t artQuickProxyInvokeHandler(mirror::AbstractMethod* proxy_met
   args.erase(args.begin());
 
   // Convert proxy method into expected interface method.
-  mirror::AbstractMethod* interface_method = proxy_method->FindOverriddenMethod();
+  mirror::ArtMethod* interface_method = proxy_method->FindOverriddenMethod();
   DCHECK(interface_method != NULL);
   DCHECK(!interface_method->IsProxyMethod()) << PrettyMethod(interface_method);
   jobject interface_method_jobj = soa.AddLocalReference<jobject>(interface_method);
@@ -406,7 +406,7 @@ extern "C" uint64_t artQuickProxyInvokeHandler(mirror::AbstractMethod* proxy_met
 // so they don't get garbage collected.
 class RememberFoGcArgumentVisitor : public QuickArgumentVisitor {
  public:
-  RememberFoGcArgumentVisitor(mirror::AbstractMethod** sp, bool is_static, const char* shorty,
+  RememberFoGcArgumentVisitor(mirror::ArtMethod** sp, bool is_static, const char* shorty,
                               uint32_t shorty_len, ScopedObjectAccessUnchecked* soa) :
     QuickArgumentVisitor(sp, is_static, shorty, shorty_len), soa_(soa) {}
 
@@ -423,9 +423,9 @@ class RememberFoGcArgumentVisitor : public QuickArgumentVisitor {
 };
 
 // Lazily resolve a method for quick. Called by stub code.
-extern "C" const void* artQuickResolutionTrampoline(mirror::AbstractMethod* called,
+extern "C" const void* artQuickResolutionTrampoline(mirror::ArtMethod* called,
                                                     mirror::Object* receiver,
-                                                    Thread* thread, mirror::AbstractMethod** sp)
+                                                    Thread* thread, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsAndArgs);
   // Start new JNI local reference state
@@ -436,7 +436,7 @@ extern "C" const void* artQuickResolutionTrampoline(mirror::AbstractMethod* call
 
   // Compute details about the called method (avoid GCs)
   ClassLinker* linker = Runtime::Current()->GetClassLinker();
-  mirror::AbstractMethod* caller = QuickArgumentVisitor::GetCallingMethod(sp);
+  mirror::ArtMethod* caller = QuickArgumentVisitor::GetCallingMethod(sp);
   InvokeType invoke_type;
   const DexFile* dex_file;
   uint32_t dex_method_idx;
diff --git a/runtime/exception_test.cc b/runtime/exception_test.cc
index 933b74ace1..e48208d771 100644
--- a/runtime/exception_test.cc
+++ b/runtime/exception_test.cc
@@ -95,8 +95,8 @@ class ExceptionTest : public CommonTest {
   UnsignedLeb128EncodingVector fake_vmap_table_data_;
   std::vector<uint8_t> fake_gc_map_;
 
-  mirror::AbstractMethod* method_f_;
-  mirror::AbstractMethod* method_g_;
+  mirror::ArtMethod* method_f_;
+  mirror::ArtMethod* method_g_;
 
  private:
   mirror::Class* my_klass_;
diff --git a/runtime/gc/accounting/mod_union_table.cc b/runtime/gc/accounting/mod_union_table.cc
index 0363acb477..3bbc3810a0 100644
--- a/runtime/gc/accounting/mod_union_table.cc
+++ b/runtime/gc/accounting/mod_union_table.cc
@@ -22,9 +22,9 @@
 #include "gc/collector/mark_sweep-inl.h"
 #include "gc/heap.h"
 #include "gc/space/space.h"
+#include "mirror/art_field-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/class-inl.h"
-#include "mirror/field-inl.h"
 #include "mirror/object_array-inl.h"
 #include "space_bitmap-inl.h"
 #include "thread.h"
diff --git a/runtime/gc/accounting/space_bitmap.cc b/runtime/gc/accounting/space_bitmap.cc
index 6edc067cc7..702e162262 100644
--- a/runtime/gc/accounting/space_bitmap.cc
+++ b/runtime/gc/accounting/space_bitmap.cc
@@ -17,8 +17,8 @@
 #include "base/logging.h"
 #include "dex_file-inl.h"
 #include "heap_bitmap.h"
+#include "mirror/art_field-inl.h"
 #include "mirror/class-inl.h"
-#include "mirror/field-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "object_utils.h"
@@ -182,10 +182,10 @@ static void WalkInstanceFields(SpaceBitmap* visited, SpaceBitmap::Callback* call
     WalkInstanceFields(visited, callback, obj, super, arg);
   }
   // Walk instance fields
-  mirror::ObjectArray<mirror::Field>* fields = klass->GetIFields();
+  mirror::ObjectArray<mirror::ArtField>* fields = klass->GetIFields();
   if (fields != NULL) {
     for (int32_t i = 0; i < fields->GetLength(); i++) {
-      mirror::Field* field = fields->Get(i);
+      mirror::ArtField* field = fields->Get(i);
       FieldHelper fh(field);
       if (!fh.IsPrimitiveType()) {
         mirror::Object* value = field->GetObj(obj);
@@ -212,10 +212,10 @@ static void WalkFieldsInOrder(SpaceBitmap* visited, SpaceBitmap::Callback* callb
   WalkInstanceFields(visited, callback, obj, klass, arg);
   // Walk static fields of a Class
   if (obj->IsClass()) {
-    mirror::ObjectArray<mirror::Field>* fields = klass->GetSFields();
+    mirror::ObjectArray<mirror::ArtField>* fields = klass->GetSFields();
     if (fields != NULL) {
       for (int32_t i = 0; i < fields->GetLength(); i++) {
-        mirror::Field* field = fields->Get(i);
+        mirror::ArtField* field = fields->Get(i);
         FieldHelper fh(field);
         if (!fh.IsPrimitiveType()) {
           mirror::Object* value = field->GetObj(NULL);
diff --git a/runtime/gc/collector/mark_sweep-inl.h b/runtime/gc/collector/mark_sweep-inl.h
index 6b1b617eb4..e158952119 100644
--- a/runtime/gc/collector/mark_sweep-inl.h
+++ b/runtime/gc/collector/mark_sweep-inl.h
@@ -20,8 +20,8 @@
 #include "gc/collector/mark_sweep.h"
 
 #include "gc/heap.h"
+#include "mirror/art_field.h"
 #include "mirror/class.h"
-#include "mirror/field.h"
 #include "mirror/object_array.h"
 
 namespace art {
@@ -136,8 +136,8 @@ inline void MarkSweep::VisitFieldsReferences(const mirror::Object* obj, uint32_t
                                      ? klass->NumReferenceStaticFields()
                                      : klass->NumReferenceInstanceFields());
       for (size_t i = 0; i < num_reference_fields; ++i) {
-        mirror::Field* field = (is_static ? klass->GetStaticField(i)
-                                          : klass->GetInstanceField(i));
+        mirror::ArtField* field = (is_static ? klass->GetStaticField(i)
+                                   : klass->GetInstanceField(i));
         MemberOffset field_offset = field->GetOffset();
         const mirror::Object* ref = obj->GetFieldObject<const mirror::Object*>(field_offset, false);
         visitor(obj, ref, field_offset, is_static);
diff --git a/runtime/gc/collector/mark_sweep.cc b/runtime/gc/collector/mark_sweep.cc
index 7b78720392..61570ae393 100644
--- a/runtime/gc/collector/mark_sweep.cc
+++ b/runtime/gc/collector/mark_sweep.cc
@@ -37,11 +37,11 @@
 #include "jni_internal.h"
 #include "monitor.h"
 #include "mark_sweep-inl.h"
+#include "mirror/art_field.h"
+#include "mirror/art_field-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
 #include "mirror/dex_cache.h"
-#include "mirror/field.h"
-#include "mirror/field-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array.h"
 #include "mirror/object_array-inl.h"
@@ -50,8 +50,8 @@
 #include "thread_list.h"
 #include "verifier/method_verifier.h"
 
+using ::art::mirror::ArtField;
 using ::art::mirror::Class;
-using ::art::mirror::Field;
 using ::art::mirror::Object;
 using ::art::mirror::ObjectArray;
 
@@ -1072,11 +1072,11 @@ void MarkSweep::CheckReference(const Object* obj, const Object* ref, MemberOffse
 
         const Class* klass = is_static ? obj->AsClass() : obj->GetClass();
         DCHECK(klass != NULL);
-        const ObjectArray<Field>* fields = is_static ? klass->GetSFields() : klass->GetIFields();
+        const ObjectArray<ArtField>* fields = is_static ? klass->GetSFields() : klass->GetIFields();
         DCHECK(fields != NULL);
         bool found = false;
         for (int32_t i = 0; i < fields->GetLength(); ++i) {
-          const Field* cur = fields->Get(i);
+          const ArtField* cur = fields->Get(i);
           if (cur->GetOffset().Int32Value() == offset.Int32Value()) {
             LOG(WARNING) << "Field referencing the alloc space was " << PrettyField(cur);
             found = true;
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index df1f3fe92e..a2453b8405 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -41,8 +41,8 @@
 #include "gc/space/space-inl.h"
 #include "image.h"
 #include "invoke_arg_array_builder.h"
+#include "mirror/art_field-inl.h"
 #include "mirror/class-inl.h"
-#include "mirror/field-inl.h"
 #include "mirror/object.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
@@ -1512,11 +1512,11 @@ class VerifyReferenceCardVisitor {
           if (!obj->IsObjectArray()) {
             const mirror::Class* klass = is_static ? obj->AsClass() : obj->GetClass();
             CHECK(klass != NULL);
-            const mirror::ObjectArray<mirror::Field>* fields = is_static ? klass->GetSFields()
-                                                                         : klass->GetIFields();
+            const mirror::ObjectArray<mirror::ArtField>* fields = is_static ? klass->GetSFields()
+                                                                            : klass->GetIFields();
             CHECK(fields != NULL);
             for (int32_t i = 0; i < fields->GetLength(); ++i) {
-              const mirror::Field* cur = fields->Get(i);
+              const mirror::ArtField* cur = fields->Get(i);
               if (cur->GetOffset().Int32Value() == offset.Int32Value()) {
                 LOG(ERROR) << (is_static ? "Static " : "") << "field in the live stack is "
                           << PrettyField(cur);
diff --git a/runtime/gc/space/image_space.cc b/runtime/gc/space/image_space.cc
index 8ff7025c34..22562df512 100644
--- a/runtime/gc/space/image_space.cc
+++ b/runtime/gc/space/image_space.cc
@@ -22,7 +22,7 @@
 #include "base/stl_util.h"
 #include "base/unix_file/fd_file.h"
 #include "gc/accounting/space_bitmap-inl.h"
-#include "mirror/abstract_method.h"
+#include "mirror/art_method.h"
 #include "mirror/class-inl.h"
 #include "mirror/object-inl.h"
 #include "oat_file.h"
@@ -187,14 +187,14 @@ ImageSpace* ImageSpace::Init(const std::string& image_file_name, bool validate_o
 
   Runtime* runtime = Runtime::Current();
   mirror::Object* resolution_method = image_header.GetImageRoot(ImageHeader::kResolutionMethod);
-  runtime->SetResolutionMethod(down_cast<mirror::AbstractMethod*>(resolution_method));
+  runtime->SetResolutionMethod(down_cast<mirror::ArtMethod*>(resolution_method));
 
   mirror::Object* callee_save_method = image_header.GetImageRoot(ImageHeader::kCalleeSaveMethod);
-  runtime->SetCalleeSaveMethod(down_cast<mirror::AbstractMethod*>(callee_save_method), Runtime::kSaveAll);
+  runtime->SetCalleeSaveMethod(down_cast<mirror::ArtMethod*>(callee_save_method), Runtime::kSaveAll);
   callee_save_method = image_header.GetImageRoot(ImageHeader::kRefsOnlySaveMethod);
-  runtime->SetCalleeSaveMethod(down_cast<mirror::AbstractMethod*>(callee_save_method), Runtime::kRefsOnly);
+  runtime->SetCalleeSaveMethod(down_cast<mirror::ArtMethod*>(callee_save_method), Runtime::kRefsOnly);
   callee_save_method = image_header.GetImageRoot(ImageHeader::kRefsAndArgsSaveMethod);
-  runtime->SetCalleeSaveMethod(down_cast<mirror::AbstractMethod*>(callee_save_method), Runtime::kRefsAndArgs);
+  runtime->SetCalleeSaveMethod(down_cast<mirror::ArtMethod*>(callee_save_method), Runtime::kRefsAndArgs);
 
   UniquePtr<ImageSpace> space(new ImageSpace(image_file_name, map.release()));
 
diff --git a/runtime/hprof/hprof.cc b/runtime/hprof/hprof.cc
index d3bb2e8f5f..0b2e741527 100644
--- a/runtime/hprof/hprof.cc
+++ b/runtime/hprof/hprof.cc
@@ -48,10 +48,9 @@
 #include "gc/heap.h"
 #include "gc/space/space.h"
 #include "globals.h"
+#include "mirror/art_field-inl.h"
 #include "mirror/class.h"
 #include "mirror/class-inl.h"
-#include "mirror/field.h"
-#include "mirror/field-inl.h"
 #include "mirror/object-inl.h"
 #include "object_utils.h"
 #include "os.h"
@@ -922,7 +921,7 @@ int Hprof::DumpHeapObject(mirror::Object* obj) {
         rec->AddId(CLASS_STATICS_ID(obj));
 
         for (size_t i = 0; i < sFieldCount; ++i) {
-          mirror::Field* f = thisClass->GetStaticField(i);
+          mirror::ArtField* f = thisClass->GetStaticField(i);
           fh.ChangeField(f);
 
           size_t size;
@@ -947,7 +946,7 @@ int Hprof::DumpHeapObject(mirror::Object* obj) {
       int iFieldCount = thisClass->IsObjectClass() ? 0 : thisClass->NumInstanceFields();
       rec->AddU2((uint16_t)iFieldCount);
       for (int i = 0; i < iFieldCount; ++i) {
-        mirror::Field* f = thisClass->GetInstanceField(i);
+        mirror::ArtField* f = thisClass->GetInstanceField(i);
         fh.ChangeField(f);
         HprofBasicType t = SignatureToBasicTypeAndSize(fh.GetTypeDescriptor(), NULL);
         rec->AddId(LookupStringId(fh.GetName()));
@@ -1010,7 +1009,7 @@ int Hprof::DumpHeapObject(mirror::Object* obj) {
       while (!sclass->IsObjectClass()) {
         int ifieldCount = sclass->NumInstanceFields();
         for (int i = 0; i < ifieldCount; ++i) {
-          mirror::Field* f = sclass->GetInstanceField(i);
+          mirror::ArtField* f = sclass->GetInstanceField(i);
           fh.ChangeField(f);
           size_t size;
           SignatureToBasicTypeAndSize(fh.GetTypeDescriptor(), &size);
diff --git a/runtime/instrumentation.cc b/runtime/instrumentation.cc
index c3b66b3f79..ae3a165a70 100644
--- a/runtime/instrumentation.cc
+++ b/runtime/instrumentation.cc
@@ -23,9 +23,9 @@
 #include "class_linker.h"
 #include "debugger.h"
 #include "dex_file-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/dex_cache.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/object-inl.h"
 #include "nth_caller_visitor.h"
@@ -55,7 +55,7 @@ bool Instrumentation::InstallStubsForClass(mirror::Class* klass) {
   }
   bool is_initialized = klass->IsInitialized();
   for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
-    mirror::AbstractMethod* method = klass->GetDirectMethod(i);
+    mirror::ArtMethod* method = klass->GetDirectMethod(i);
     if (!method->IsAbstract()) {
       const void* new_code;
       if (uninstall) {
@@ -77,7 +77,7 @@ bool Instrumentation::InstallStubsForClass(mirror::Class* klass) {
     }
   }
   for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
-    mirror::AbstractMethod* method = klass->GetVirtualMethod(i);
+    mirror::ArtMethod* method = klass->GetVirtualMethod(i);
     if (!method->IsAbstract()) {
       const void* new_code;
       if (uninstall) {
@@ -109,7 +109,7 @@ static void InstrumentationInstallStack(Thread* thread, void* arg)
           instrumentation_exit_pc_(instrumentation_exit_pc), last_return_pc_(0) {}
 
     virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-      mirror::AbstractMethod* m = GetMethod();
+      mirror::ArtMethod* m = GetMethod();
       if (GetCurrentQuickFrame() == NULL) {
         if (kVerboseInstrumentation) {
           LOG(INFO) << "  Ignoring a shadow frame. Frame " << GetFrameId()
@@ -169,7 +169,7 @@ static void InstrumentationInstallStack(Thread* thread, void* arg)
   for (It it = thread->GetInstrumentationStack()->rbegin(),
        end = thread->GetInstrumentationStack()->rend(); it != end; ++it) {
     mirror::Object* this_object = (*it).this_object_;
-    mirror::AbstractMethod* method = (*it).method_;
+    mirror::ArtMethod* method = (*it).method_;
     uint32_t dex_pc = visitor.dex_pcs_.back();
     visitor.dex_pcs_.pop_back();
     instrumentation->MethodEnterEvent(thread, this_object, method, dex_pc);
@@ -193,7 +193,7 @@ static void InstrumentationRestoreStack(Thread* thread, void* arg)
       if (instrumentation_stack_->size() == 0) {
         return false;  // Stop.
       }
-      mirror::AbstractMethod* m = GetMethod();
+      mirror::ArtMethod* m = GetMethod();
       if (GetCurrentQuickFrame() == NULL) {
         if (kVerboseInstrumentation) {
           LOG(INFO) << "  Ignoring a shadow frame. Frame " << GetFrameId() << " Method=" << PrettyMethod(m);
@@ -379,7 +379,7 @@ void Instrumentation::ConfigureStubs(bool require_entry_exit_stubs, bool require
   }
 }
 
-void Instrumentation::UpdateMethodsCode(mirror::AbstractMethod* method, const void* code) const {
+void Instrumentation::UpdateMethodsCode(mirror::ArtMethod* method, const void* code) const {
   if (LIKELY(!instrumentation_stubs_installed_)) {
     method->SetEntryPointFromCompiledCode(code);
   } else {
@@ -391,7 +391,7 @@ void Instrumentation::UpdateMethodsCode(mirror::AbstractMethod* method, const vo
   }
 }
 
-const void* Instrumentation::GetQuickCodeFor(const mirror::AbstractMethod* method) const {
+const void* Instrumentation::GetQuickCodeFor(const mirror::ArtMethod* method) const {
   Runtime* runtime = Runtime::Current();
   if (LIKELY(!instrumentation_stubs_installed_)) {
     const void* code = method->GetEntryPointFromCompiledCode();
@@ -405,7 +405,7 @@ const void* Instrumentation::GetQuickCodeFor(const mirror::AbstractMethod* metho
 }
 
 void Instrumentation::MethodEnterEventImpl(Thread* thread, mirror::Object* this_object,
-                                           const mirror::AbstractMethod* method,
+                                           const mirror::ArtMethod* method,
                                            uint32_t dex_pc) const {
   typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
   It it = method_entry_listeners_.begin();
@@ -420,7 +420,7 @@ void Instrumentation::MethodEnterEventImpl(Thread* thread, mirror::Object* this_
 }
 
 void Instrumentation::MethodExitEventImpl(Thread* thread, mirror::Object* this_object,
-                                          const mirror::AbstractMethod* method,
+                                          const mirror::ArtMethod* method,
                                           uint32_t dex_pc, const JValue& return_value) const {
   typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
   It it = method_exit_listeners_.begin();
@@ -435,7 +435,7 @@ void Instrumentation::MethodExitEventImpl(Thread* thread, mirror::Object* this_o
 }
 
 void Instrumentation::MethodUnwindEvent(Thread* thread, mirror::Object* this_object,
-                                        const mirror::AbstractMethod* method,
+                                        const mirror::ArtMethod* method,
                                         uint32_t dex_pc) const {
   if (have_method_unwind_listeners_) {
     typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
@@ -447,7 +447,7 @@ void Instrumentation::MethodUnwindEvent(Thread* thread, mirror::Object* this_obj
 }
 
 void Instrumentation::DexPcMovedEventImpl(Thread* thread, mirror::Object* this_object,
-                                          const mirror::AbstractMethod* method,
+                                          const mirror::ArtMethod* method,
                                           uint32_t dex_pc) const {
   // TODO: STL copy-on-write collection? The copy below is due to the debug listener having an
   // action where it can remove itself as a listener and break the iterator. The copy only works
@@ -461,7 +461,7 @@ void Instrumentation::DexPcMovedEventImpl(Thread* thread, mirror::Object* this_o
 }
 
 void Instrumentation::ExceptionCaughtEvent(Thread* thread, const ThrowLocation& throw_location,
-                                           mirror::AbstractMethod* catch_method,
+                                           mirror::ArtMethod* catch_method,
                                            uint32_t catch_dex_pc,
                                            mirror::Throwable* exception_object) {
   if (have_exception_caught_listeners_) {
@@ -489,7 +489,7 @@ static void CheckStackDepth(Thread* self, const InstrumentationStackFrame& instr
 }
 
 void Instrumentation::PushInstrumentationStackFrame(Thread* self, mirror::Object* this_object,
-                                                    mirror::AbstractMethod* method,
+                                                    mirror::ArtMethod* method,
                                                     uintptr_t lr, bool interpreter_entry) {
   // We have a callee-save frame meaning this value is guaranteed to never be 0.
   size_t frame_id = StackVisitor::ComputeNumFrames(self);
@@ -516,7 +516,7 @@ uint64_t Instrumentation::PopInstrumentationStackFrame(Thread* self, uintptr_t*
   *return_pc = instrumentation_frame.return_pc_;
   CheckStackDepth(self, instrumentation_frame, 0);
 
-  mirror::AbstractMethod* method = instrumentation_frame.method_;
+  mirror::ArtMethod* method = instrumentation_frame.method_;
   char return_shorty = MethodHelper(method).GetShorty()[0];
   JValue return_value;
   if (return_shorty == 'V') {
@@ -567,7 +567,7 @@ void Instrumentation::PopMethodForUnwind(Thread* self, bool is_deoptimization) c
   // TODO: bring back CheckStackDepth(self, instrumentation_frame, 2);
   stack->pop_front();
 
-  mirror::AbstractMethod* method = instrumentation_frame.method_;
+  mirror::ArtMethod* method = instrumentation_frame.method_;
   if (is_deoptimization) {
     if (kVerboseInstrumentation) {
       LOG(INFO) << "Popping for deoptimization " << PrettyMethod(method);
diff --git a/runtime/instrumentation.h b/runtime/instrumentation.h
index 798b7ab56d..6c80b41b64 100644
--- a/runtime/instrumentation.h
+++ b/runtime/instrumentation.h
@@ -25,10 +25,10 @@
 
 namespace art {
 namespace mirror {
-class AbstractMethod;
-class Class;
-class Object;
-class Throwable;
+  class ArtMethod;
+  class Class;
+  class Object;
+  class Throwable;
 }  // namespace mirror
 union JValue;
 class Thread;
@@ -47,30 +47,30 @@ struct InstrumentationListener {
 
   // Call-back for when a method is entered.
   virtual void MethodEntered(Thread* thread, mirror::Object* this_object,
-                             const mirror::AbstractMethod* method,
+                             const mirror::ArtMethod* method,
                              uint32_t dex_pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) = 0;
 
   // Call-back for when a method is exited.
   // TODO: its likely passing the return value would be useful, however, we may need to get and
   //       parse the shorty to determine what kind of register holds the result.
   virtual void MethodExited(Thread* thread, mirror::Object* this_object,
-                            const mirror::AbstractMethod* method, uint32_t dex_pc,
+                            const mirror::ArtMethod* method, uint32_t dex_pc,
                             const JValue& return_value)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) = 0;
 
   // Call-back for when a method is popped due to an exception throw. A method will either cause a
   // MethodExited call-back or a MethodUnwind call-back when its activation is removed.
-  virtual void MethodUnwind(Thread* thread, const mirror::AbstractMethod* method,
+  virtual void MethodUnwind(Thread* thread, const mirror::ArtMethod* method,
                             uint32_t dex_pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) = 0;
 
   // Call-back for when the dex pc moves in a method.
   virtual void DexPcMoved(Thread* thread, mirror::Object* this_object,
-                          const mirror::AbstractMethod* method, uint32_t new_dex_pc)
+                          const mirror::ArtMethod* method, uint32_t new_dex_pc)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) = 0;
 
   // Call-back when an exception is caught.
   virtual void ExceptionCaught(Thread* thread, const ThrowLocation& throw_location,
-                               mirror::AbstractMethod* catch_method, uint32_t catch_dex_pc,
+                               mirror::ArtMethod* catch_method, uint32_t catch_dex_pc,
                                mirror::Throwable* exception_object)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) = 0;
 };
@@ -111,12 +111,12 @@ class Instrumentation {
       LOCKS_EXCLUDED(Locks::thread_list_lock_, Locks::classlinker_classes_lock_);
 
   // Update the code of a method respecting any installed stubs.
-  void UpdateMethodsCode(mirror::AbstractMethod* method, const void* code) const;
+  void UpdateMethodsCode(mirror::ArtMethod* method, const void* code) const;
 
   // Get the quick code for the given method. More efficient than asking the class linker as it
   // will short-cut to GetCode if instrumentation and static method resolution stubs aren't
   // installed.
-  const void* GetQuickCodeFor(const mirror::AbstractMethod* method) const
+  const void* GetQuickCodeFor(const mirror::ArtMethod* method) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void ForceInterpretOnly() {
@@ -124,7 +124,7 @@ class Instrumentation {
     forced_interpret_only_ = true;
   }
 
-  // Called by AbstractMethod::Invoke to determine dispatch mechanism.
+  // Called by ArtMethod::Invoke to determine dispatch mechanism.
   bool InterpretOnly() const {
     return interpret_only_;
   }
@@ -152,7 +152,7 @@ class Instrumentation {
   // Inform listeners that a method has been entered. A dex PC is provided as we may install
   // listeners into executing code and get method enter events for methods already on the stack.
   void MethodEnterEvent(Thread* thread, mirror::Object* this_object,
-                        const mirror::AbstractMethod* method, uint32_t dex_pc) const
+                        const mirror::ArtMethod* method, uint32_t dex_pc) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     if (UNLIKELY(HasMethodEntryListeners())) {
       MethodEnterEventImpl(thread, this_object, method, dex_pc);
@@ -161,7 +161,7 @@ class Instrumentation {
 
   // Inform listeners that a method has been exited.
   void MethodExitEvent(Thread* thread, mirror::Object* this_object,
-                       const mirror::AbstractMethod* method, uint32_t dex_pc,
+                       const mirror::ArtMethod* method, uint32_t dex_pc,
                        const JValue& return_value) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     if (UNLIKELY(HasMethodExitListeners())) {
@@ -171,12 +171,12 @@ class Instrumentation {
 
   // Inform listeners that a method has been exited due to an exception.
   void MethodUnwindEvent(Thread* thread, mirror::Object* this_object,
-                         const mirror::AbstractMethod* method, uint32_t dex_pc) const
+                         const mirror::ArtMethod* method, uint32_t dex_pc) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Inform listeners that the dex pc has moved (only supported by the interpreter).
   void DexPcMovedEvent(Thread* thread, mirror::Object* this_object,
-                       const mirror::AbstractMethod* method, uint32_t dex_pc) const
+                       const mirror::ArtMethod* method, uint32_t dex_pc) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     if (UNLIKELY(HasDexPcListeners())) {
       DexPcMovedEventImpl(thread, this_object, method, dex_pc);
@@ -185,14 +185,14 @@ class Instrumentation {
 
   // Inform listeners that an exception was caught.
   void ExceptionCaughtEvent(Thread* thread, const ThrowLocation& throw_location,
-                            mirror::AbstractMethod* catch_method, uint32_t catch_dex_pc,
+                            mirror::ArtMethod* catch_method, uint32_t catch_dex_pc,
                             mirror::Throwable* exception_object)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Called when an instrumented method is entered. The intended link register (lr) is saved so
   // that returning causes a branch to the method exit stub. Generates method enter events.
   void PushInstrumentationStackFrame(Thread* self, mirror::Object* this_object,
-                                     mirror::AbstractMethod* method, uintptr_t lr,
+                                     mirror::ArtMethod* method, uintptr_t lr,
                                      bool interpreter_entry)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -216,23 +216,23 @@ class Instrumentation {
       LOCKS_EXCLUDED(Locks::thread_list_lock_, Locks::classlinker_classes_lock_);
 
   void MethodEnterEventImpl(Thread* thread, mirror::Object* this_object,
-                            const mirror::AbstractMethod* method, uint32_t dex_pc) const
+                            const mirror::ArtMethod* method, uint32_t dex_pc) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   void MethodExitEventImpl(Thread* thread, mirror::Object* this_object,
-                           const mirror::AbstractMethod* method,
+                           const mirror::ArtMethod* method,
                            uint32_t dex_pc, const JValue& return_value) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   void DexPcMovedEventImpl(Thread* thread, mirror::Object* this_object,
-                           const mirror::AbstractMethod* method, uint32_t dex_pc) const
+                           const mirror::ArtMethod* method, uint32_t dex_pc) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  // Have we hijacked AbstractMethod::code_ so that it calls instrumentation/interpreter code?
+  // Have we hijacked ArtMethod::code_ so that it calls instrumentation/interpreter code?
   bool instrumentation_stubs_installed_;
 
-  // Have we hijacked AbstractMethod::code_ to reference the enter/exit stubs?
+  // Have we hijacked ArtMethod::code_ to reference the enter/exit stubs?
   bool entry_exit_stubs_installed_;
 
-  // Have we hijacked AbstractMethod::code_ to reference the enter interpreter stub?
+  // Have we hijacked ArtMethod::code_ to reference the enter interpreter stub?
   bool interpreter_stubs_installed_;
 
   // Do we need the fidelity of events that we only get from running within the interpreter?
@@ -272,7 +272,7 @@ class Instrumentation {
 
 // An element in the instrumentation side stack maintained in art::Thread.
 struct InstrumentationStackFrame {
-  InstrumentationStackFrame(mirror::Object* this_object, mirror::AbstractMethod* method,
+  InstrumentationStackFrame(mirror::Object* this_object, mirror::ArtMethod* method,
                             uintptr_t return_pc, size_t frame_id, bool interpreter_entry)
       : this_object_(this_object), method_(method), return_pc_(return_pc), frame_id_(frame_id),
         interpreter_entry_(interpreter_entry) {
@@ -281,7 +281,7 @@ struct InstrumentationStackFrame {
   std::string Dump() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   mirror::Object* this_object_;
-  mirror::AbstractMethod* method_;
+  mirror::ArtMethod* method_;
   const uintptr_t return_pc_;
   const size_t frame_id_;
   const bool interpreter_entry_;
diff --git a/runtime/interpreter/interpreter.cc b/runtime/interpreter/interpreter.cc
index 6e35d937fb..59f0ac2e38 100644
--- a/runtime/interpreter/interpreter.cc
+++ b/runtime/interpreter/interpreter.cc
@@ -28,26 +28,27 @@
 #include "gc/accounting/card_table-inl.h"
 #include "invoke_arg_array_builder.h"
 #include "nth_caller_visitor.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class.h"
 #include "mirror/class-inl.h"
-#include "mirror/field-inl.h"
-#include "mirror/abstract_method.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "object_utils.h"
 #include "ScopedLocalRef.h"
 #include "scoped_thread_state_change.h"
 #include "thread.h"
+#include "well_known_classes.h"
 
-using ::art::mirror::AbstractMethod;
+using ::art::mirror::ArtField;
+using ::art::mirror::ArtMethod;
 using ::art::mirror::Array;
 using ::art::mirror::BooleanArray;
 using ::art::mirror::ByteArray;
 using ::art::mirror::CharArray;
 using ::art::mirror::Class;
 using ::art::mirror::ClassLoader;
-using ::art::mirror::Field;
 using ::art::mirror::IntArray;
 using ::art::mirror::LongArray;
 using ::art::mirror::Object;
@@ -82,22 +83,22 @@ static void UnstartedRuntimeInvoke(Thread* self, MethodHelper& mh,
     result->SetL(found);
   } else if (name == "java.lang.Object java.lang.Class.newInstance()") {
     Class* klass = shadow_frame->GetVRegReference(arg_offset)->AsClass();
-    AbstractMethod* c = klass->FindDeclaredDirectMethod("<init>", "()V");
+    ArtMethod* c = klass->FindDeclaredDirectMethod("<init>", "()V");
     CHECK(c != NULL);
-    Object* obj = klass->AllocObject(self);
-    CHECK(obj != NULL);
-    EnterInterpreterFromInvoke(self, c, obj, NULL, NULL);
-    result->SetL(obj);
+    SirtRef<Object> obj(self, klass->AllocObject(self));
+    CHECK(obj.get() != NULL);
+    EnterInterpreterFromInvoke(self, c, obj.get(), NULL, NULL);
+    result->SetL(obj.get());
   } else if (name == "java.lang.reflect.Field java.lang.Class.getDeclaredField(java.lang.String)") {
     // Special managed code cut-out to allow field lookup in a un-started runtime that'd fail
     // going the reflective Dex way.
     Class* klass = shadow_frame->GetVRegReference(arg_offset)->AsClass();
     String* name = shadow_frame->GetVRegReference(arg_offset + 1)->AsString();
-    Field* found = NULL;
+    ArtField* found = NULL;
     FieldHelper fh;
-    ObjectArray<Field>* fields = klass->GetIFields();
+    ObjectArray<ArtField>* fields = klass->GetIFields();
     for (int32_t i = 0; i < fields->GetLength() && found == NULL; ++i) {
-      Field* f = fields->Get(i);
+      ArtField* f = fields->Get(i);
       fh.ChangeField(f);
       if (name->Equals(fh.GetName())) {
         found = f;
@@ -106,7 +107,7 @@ static void UnstartedRuntimeInvoke(Thread* self, MethodHelper& mh,
     if (found == NULL) {
       fields = klass->GetSFields();
       for (int32_t i = 0; i < fields->GetLength() && found == NULL; ++i) {
-        Field* f = fields->Get(i);
+        ArtField* f = fields->Get(i);
         fh.ChangeField(f);
         if (name->Equals(fh.GetName())) {
           found = f;
@@ -118,7 +119,14 @@ static void UnstartedRuntimeInvoke(Thread* self, MethodHelper& mh,
       << name->ToModifiedUtf8() << " class=" << PrettyDescriptor(klass);
     // TODO: getDeclaredField calls GetType once the field is found to ensure a
     //       NoClassDefFoundError is thrown if the field's type cannot be resolved.
-    result->SetL(found);
+    Class* jlr_Field = self->DecodeJObject(WellKnownClasses::java_lang_reflect_Field)->AsClass();
+    SirtRef<Object> field(self, jlr_Field->AllocObject(self));
+    CHECK(field.get() != NULL);
+    ArtMethod* c = jlr_Field->FindDeclaredDirectMethod("<init>", "(Ljava/lang/reflect/ArtField;)V");
+    uint32_t args[1];
+    args[0] = reinterpret_cast<uint32_t>(found);
+    EnterInterpreterFromInvoke(self, c, field.get(), args, NULL);
+    result->SetL(field.get());
   } else if (name == "void java.lang.System.arraycopy(java.lang.Object, int, java.lang.Object, int, int)") {
     // Special case array copying without initializing System.
     Class* ctype = shadow_frame->GetVRegReference(arg_offset)->GetClass()->GetComponentType();
@@ -153,7 +161,7 @@ static void UnstartedRuntimeInvoke(Thread* self, MethodHelper& mh,
 }
 
 // Hand select a number of methods to be run in a not yet started runtime without using JNI.
-static void UnstartedRuntimeJni(Thread* self, AbstractMethod* method,
+static void UnstartedRuntimeJni(Thread* self, ArtMethod* method,
                                 Object* receiver, uint32_t* args, JValue* result)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   std::string name(PrettyMethod(method));
@@ -215,7 +223,7 @@ static void UnstartedRuntimeJni(Thread* self, AbstractMethod* method,
   }
 }
 
-static void InterpreterJni(Thread* self, AbstractMethod* method, StringPiece shorty,
+static void InterpreterJni(Thread* self, ArtMethod* method, StringPiece shorty,
                            Object* receiver, uint32_t* args, JValue* result)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // TODO: The following enters JNI code using a typedef-ed function rather than the JNI compiler,
@@ -417,8 +425,8 @@ static bool DoInvoke(Thread* self, ShadowFrame& shadow_frame,
   uint32_t method_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
   uint32_t vregC = (is_range) ? inst->VRegC_3rc() : inst->VRegC_35c();
   Object* receiver = (type == kStatic) ? NULL : shadow_frame.GetVRegReference(vregC);
-  AbstractMethod* method = FindMethodFromCode(method_idx, receiver, shadow_frame.GetMethod(), self,
-                                              do_access_check, type);
+  ArtMethod* method = FindMethodFromCode(method_idx, receiver, shadow_frame.GetMethod(), self,
+                                         do_access_check, type);
   if (UNLIKELY(method == NULL)) {
     CHECK(self->IsExceptionPending());
     result->SetJ(0);
@@ -438,7 +446,7 @@ static bool DoInvoke(Thread* self, ShadowFrame& shadow_frame,
     num_ins = code_item->ins_size_;
   } else {
     DCHECK(method->IsNative() || method->IsProxyMethod());
-    num_regs = num_ins = AbstractMethod::NumArgRegisters(mh.GetShorty());
+    num_regs = num_ins = ArtMethod::NumArgRegisters(mh.GetShorty());
     if (!method->IsStatic()) {
       num_regs++;
       num_ins++;
@@ -510,7 +518,7 @@ static bool DoInvokeVirtualQuick(Thread* self, ShadowFrame& shadow_frame,
   }
   uint32_t vtable_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
   // TODO: use ObjectArray<T>::GetWithoutChecks ?
-  AbstractMethod* method = receiver->GetClass()->GetVTable()->Get(vtable_idx);
+  ArtMethod* method = receiver->GetClass()->GetVTable()->Get(vtable_idx);
   if (UNLIKELY(method == NULL)) {
     CHECK(self->IsExceptionPending());
     result->SetJ(0);
@@ -530,7 +538,7 @@ static bool DoInvokeVirtualQuick(Thread* self, ShadowFrame& shadow_frame,
     num_ins = code_item->ins_size_;
   } else {
     DCHECK(method->IsNative() || method->IsProxyMethod());
-    num_regs = num_ins = AbstractMethod::NumArgRegisters(mh.GetShorty());
+    num_regs = num_ins = ArtMethod::NumArgRegisters(mh.GetShorty());
     if (!method->IsStatic()) {
       num_regs++;
       num_ins++;
@@ -601,9 +609,9 @@ static inline bool DoFieldGet(Thread* self, ShadowFrame& shadow_frame,
                               const Instruction* inst) {
   bool is_static = (find_type == StaticObjectRead) || (find_type == StaticPrimitiveRead);
   uint32_t field_idx = is_static ? inst->VRegB_21c() : inst->VRegC_22c();
-  Field* f = FindFieldFromCode(field_idx, shadow_frame.GetMethod(), self,
-                               find_type, Primitive::FieldSize(field_type),
-                               do_access_check);
+  ArtField* f = FindFieldFromCode(field_idx, shadow_frame.GetMethod(), self,
+                                  find_type, Primitive::FieldSize(field_type),
+                                  do_access_check);
   if (UNLIKELY(f == NULL)) {
     CHECK(self->IsExceptionPending());
     return false;
@@ -695,9 +703,9 @@ static inline bool DoFieldPut(Thread* self, const ShadowFrame& shadow_frame,
                               const Instruction* inst) {
   bool is_static = (find_type == StaticObjectWrite) || (find_type == StaticPrimitiveWrite);
   uint32_t field_idx = is_static ? inst->VRegB_21c() : inst->VRegC_22c();
-  Field* f = FindFieldFromCode(field_idx, shadow_frame.GetMethod(), self,
-                               find_type, Primitive::FieldSize(field_type),
-                               do_access_check);
+  ArtField* f = FindFieldFromCode(field_idx, shadow_frame.GetMethod(), self,
+                                  find_type, Primitive::FieldSize(field_type),
+                                  do_access_check);
   if (UNLIKELY(f == NULL)) {
     CHECK(self->IsExceptionPending());
     return false;
@@ -3052,7 +3060,7 @@ static inline JValue Execute(Thread* self, MethodHelper& mh, const DexFile::Code
   }
 }
 
-void EnterInterpreterFromInvoke(Thread* self, AbstractMethod* method, Object* receiver,
+void EnterInterpreterFromInvoke(Thread* self, ArtMethod* method, Object* receiver,
                                 uint32_t* args, JValue* result) {
   DCHECK_EQ(self, Thread::Current());
   if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEnd())) {
@@ -3072,7 +3080,7 @@ void EnterInterpreterFromInvoke(Thread* self, AbstractMethod* method, Object* re
     return;
   } else {
     DCHECK(method->IsNative());
-    num_regs = num_ins = AbstractMethod::NumArgRegisters(mh.GetShorty());
+    num_regs = num_ins = ArtMethod::NumArgRegisters(mh.GetShorty());
     if (!method->IsStatic()) {
       num_regs++;
       num_ins++;
@@ -3172,7 +3180,7 @@ extern "C" void artInterpreterToInterpreterBridge(Thread* self, MethodHelper& mh
     return;
   }
 
-  AbstractMethod* method = shadow_frame->GetMethod();
+  ArtMethod* method = shadow_frame->GetMethod();
   if (method->IsStatic() && !method->GetDeclaringClass()->IsInitializing()) {
     if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(method->GetDeclaringClass(),
                                                                  true, true)) {
diff --git a/runtime/interpreter/interpreter.h b/runtime/interpreter/interpreter.h
index af4a1472ee..49e8de08ec 100644
--- a/runtime/interpreter/interpreter.h
+++ b/runtime/interpreter/interpreter.h
@@ -22,7 +22,7 @@
 
 namespace art {
 namespace mirror {
-class AbstractMethod;
+class ArtMethod;
 class Object;
 }  // namespace mirror
 
@@ -33,8 +33,8 @@ class Thread;
 
 namespace interpreter {
 
-// Called by AbstractMethod::Invoke, shadow frames arguments are taken from the args array.
-extern void EnterInterpreterFromInvoke(Thread* self, mirror::AbstractMethod* method,
+// Called by ArtMethod::Invoke, shadow frames arguments are taken from the args array.
+extern void EnterInterpreterFromInvoke(Thread* self, mirror::ArtMethod* method,
                                        mirror::Object* receiver, uint32_t* args, JValue* result)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
diff --git a/runtime/invoke_arg_array_builder.h b/runtime/invoke_arg_array_builder.h
index 084d005e96..f615e8ebac 100644
--- a/runtime/invoke_arg_array_builder.h
+++ b/runtime/invoke_arg_array_builder.h
@@ -17,7 +17,7 @@
 #ifndef ART_RUNTIME_INVOKE_ARG_ARRAY_BUILDER_H_
 #define ART_RUNTIME_INVOKE_ARG_ARRAY_BUILDER_H_
 
-#include "mirror/abstract_method.h"
+#include "mirror/art_method.h"
 #include "mirror/object.h"
 #include "scoped_thread_state_change.h"
 
diff --git a/runtime/jdwp/jdwp.h b/runtime/jdwp/jdwp.h
index 010a2079b4..a1657d098b 100644
--- a/runtime/jdwp/jdwp.h
+++ b/runtime/jdwp/jdwp.h
@@ -32,7 +32,7 @@ struct iovec;
 
 namespace art {
 namespace mirror {
-class AbstractMethod;
+  class ArtMethod;
 }  // namespace mirror
 class Thread;
 
diff --git a/runtime/jdwp/object_registry.h b/runtime/jdwp/object_registry.h
index 345f0ad73a..7f162ca80b 100644
--- a/runtime/jdwp/object_registry.h
+++ b/runtime/jdwp/object_registry.h
@@ -22,9 +22,9 @@
 #include <map>
 
 #include "jdwp/jdwp.h"
+#include "mirror/art_field-inl.h"
 #include "mirror/class.h"
 #include "mirror/class-inl.h"
-#include "mirror/field-inl.h"
 #include "mirror/object-inl.h"
 #include "safe_map.h"
 
diff --git a/runtime/jni_internal.cc b/runtime/jni_internal.cc
index d1de6e6f5a..852dd00a77 100644
--- a/runtime/jni_internal.cc
+++ b/runtime/jni_internal.cc
@@ -32,10 +32,10 @@
 #include "interpreter/interpreter.h"
 #include "invoke_arg_array_builder.h"
 #include "jni.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
-#include "mirror/field-inl.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/throwable.h"
@@ -49,7 +49,8 @@
 #include "UniquePtr.h"
 #include "well_known_classes.h"
 
-using ::art::mirror::AbstractMethod;
+using ::art::mirror::ArtField;
+using ::art::mirror::ArtMethod;
 using ::art::mirror::Array;
 using ::art::mirror::BooleanArray;
 using ::art::mirror::ByteArray;
@@ -57,7 +58,6 @@ using ::art::mirror::CharArray;
 using ::art::mirror::Class;
 using ::art::mirror::ClassLoader;
 using ::art::mirror::DoubleArray;
-using ::art::mirror::Field;
 using ::art::mirror::FloatArray;
 using ::art::mirror::IntArray;
 using ::art::mirror::LongArray;
@@ -101,7 +101,7 @@ static bool IsBadJniVersion(int version) {
   return version != JNI_VERSION_1_2 && version != JNI_VERSION_1_4 && version != JNI_VERSION_1_6;
 }
 
-static void CheckMethodArguments(AbstractMethod* m, uint32_t* args)
+static void CheckMethodArguments(ArtMethod* m, uint32_t* args)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   MethodHelper mh(m);
   const DexFile::TypeList* params = mh.GetParameterTypeList();
@@ -144,7 +144,7 @@ static void CheckMethodArguments(AbstractMethod* m, uint32_t* args)
   }
 }
 
-void InvokeWithArgArray(const ScopedObjectAccess& soa, AbstractMethod* method,
+void InvokeWithArgArray(const ScopedObjectAccess& soa, ArtMethod* method,
                         ArgArray* arg_array, JValue* result, char result_type)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   uint32_t* args = arg_array->GetArray();
@@ -157,7 +157,7 @@ void InvokeWithArgArray(const ScopedObjectAccess& soa, AbstractMethod* method,
 static JValue InvokeWithVarArgs(const ScopedObjectAccess& soa, jobject obj,
                                 jmethodID mid, va_list args)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  AbstractMethod* method = soa.DecodeMethod(mid);
+  ArtMethod* method = soa.DecodeMethod(mid);
   Object* receiver = method->IsStatic() ? NULL : soa.Decode<Object*>(obj);
   MethodHelper mh(method);
   JValue result;
@@ -167,7 +167,7 @@ static JValue InvokeWithVarArgs(const ScopedObjectAccess& soa, jobject obj,
   return result;
 }
 
-static AbstractMethod* FindVirtualMethod(Object* receiver, AbstractMethod* method)
+static ArtMethod* FindVirtualMethod(Object* receiver, ArtMethod* method)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(method);
 }
@@ -176,7 +176,7 @@ static JValue InvokeVirtualOrInterfaceWithJValues(const ScopedObjectAccess& soa,
                                                   jobject obj, jmethodID mid, jvalue* args)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   Object* receiver = soa.Decode<Object*>(obj);
-  AbstractMethod* method = FindVirtualMethod(receiver, soa.DecodeMethod(mid));
+  ArtMethod* method = FindVirtualMethod(receiver, soa.DecodeMethod(mid));
   MethodHelper mh(method);
   JValue result;
   ArgArray arg_array(mh.GetShorty(), mh.GetShortyLength());
@@ -189,7 +189,7 @@ static JValue InvokeVirtualOrInterfaceWithVarArgs(const ScopedObjectAccess& soa,
                                                   jobject obj, jmethodID mid, va_list args)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   Object* receiver = soa.Decode<Object*>(obj);
-  AbstractMethod* method = FindVirtualMethod(receiver, soa.DecodeMethod(mid));
+  ArtMethod* method = FindVirtualMethod(receiver, soa.DecodeMethod(mid));
   MethodHelper mh(method);
   JValue result;
   ArgArray arg_array(mh.GetShorty(), mh.GetShortyLength());
@@ -239,7 +239,7 @@ static jmethodID FindMethodID(ScopedObjectAccess& soa, jclass jni_class,
     return NULL;
   }
 
-  AbstractMethod* method = NULL;
+  ArtMethod* method = NULL;
   if (is_static) {
     method = c->FindDirectMethod(name, sig);
   } else {
@@ -261,7 +261,7 @@ static jmethodID FindMethodID(ScopedObjectAccess& soa, jclass jni_class,
 
 static ClassLoader* GetClassLoader(const ScopedObjectAccess& soa)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  AbstractMethod* method = soa.Self()->GetCurrentMethod(NULL);
+  ArtMethod* method = soa.Self()->GetCurrentMethod(NULL);
   if (method == NULL ||
       method == soa.DecodeMethod(WellKnownClasses::java_lang_Runtime_nativeLoad)) {
     return soa.Self()->GetClassLoaderOverride();
@@ -277,7 +277,7 @@ static jfieldID FindFieldID(const ScopedObjectAccess& soa, jclass jni_class, con
     return NULL;
   }
 
-  Field* field = NULL;
+  ArtField* field = NULL;
   Class* field_type;
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   if (sig[1] != '\0') {
@@ -290,7 +290,7 @@ static jfieldID FindFieldID(const ScopedObjectAccess& soa, jclass jni_class, con
     // Failed to find type from the signature of the field.
     DCHECK(soa.Self()->IsExceptionPending());
     ThrowLocation throw_location;
-    SirtRef<mirror::Throwable> cause(soa.Self(), soa.Self()->GetException(&throw_location));
+    SirtRef<Throwable> cause(soa.Self(), soa.Self()->GetException(&throw_location));
     soa.Self()->ClearException();
     soa.Self()->ThrowNewExceptionF(throw_location, "Ljava/lang/NoSuchFieldError;",
                                    "no type \"%s\" found and so no field \"%s\" could be found in class "
@@ -561,7 +561,7 @@ class Libraries {
   }
 
   // See section 11.3 "Linking Native Methods" of the JNI spec.
-  void* FindNativeMethod(const AbstractMethod* m, std::string& detail)
+  void* FindNativeMethod(const ArtMethod* m, std::string& detail)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     std::string jni_short_name(JniShortName(m));
     std::string jni_long_name(JniLongName(m));
@@ -598,7 +598,7 @@ class Libraries {
 
 JValue InvokeWithJValues(const ScopedObjectAccess& soa, jobject obj, jmethodID mid,
                          jvalue* args) {
-  AbstractMethod* method = soa.DecodeMethod(mid);
+  ArtMethod* method = soa.DecodeMethod(mid);
   Object* receiver = method->IsStatic() ? NULL : soa.Decode<Object*>(obj);
   MethodHelper mh(method);
   JValue result;
@@ -620,10 +620,10 @@ class JNI {
   }
 
   static jclass FindClass(JNIEnv* env, const char* name) {
-    ScopedObjectAccess soa(env);
     Runtime* runtime = Runtime::Current();
     ClassLinker* class_linker = runtime->GetClassLinker();
     std::string descriptor(NormalizeJniClassDescriptor(name));
+    ScopedObjectAccess soa(env);
     Class* c = NULL;
     if (runtime->IsStarted()) {
       ClassLoader* cl = GetClassLoader(soa);
@@ -636,26 +636,50 @@ class JNI {
 
   static jmethodID FromReflectedMethod(JNIEnv* env, jobject java_method) {
     ScopedObjectAccess soa(env);
-    AbstractMethod* method = soa.Decode<AbstractMethod*>(java_method);
+    jobject art_method = env->GetObjectField(java_method,
+                                             WellKnownClasses::java_lang_reflect_AbstractMethod_artMethod);
+    ArtMethod* method = soa.Decode<ArtMethod*>(art_method);
+    DCHECK(method != NULL);
     return soa.EncodeMethod(method);
   }
 
   static jfieldID FromReflectedField(JNIEnv* env, jobject java_field) {
     ScopedObjectAccess soa(env);
-    Field* field = soa.Decode<Field*>(java_field);
+    jobject art_field = env->GetObjectField(java_field,
+                                            WellKnownClasses::java_lang_reflect_Field_artField);
+    ArtField* field = soa.Decode<ArtField*>(art_field);
+    DCHECK(field != NULL);
     return soa.EncodeField(field);
   }
 
   static jobject ToReflectedMethod(JNIEnv* env, jclass, jmethodID mid, jboolean) {
     ScopedObjectAccess soa(env);
-    AbstractMethod* method = soa.DecodeMethod(mid);
-    return soa.AddLocalReference<jobject>(method);
+    ArtMethod* m = soa.DecodeMethod(mid);
+    jobject art_method = soa.AddLocalReference<jobject>(m);
+    jobject reflect_method = env->AllocObject(WellKnownClasses::java_lang_reflect_Method);
+    if (env->ExceptionCheck()) {
+      return NULL;
+    }
+    SetObjectField(env,
+                   reflect_method,
+                   WellKnownClasses::java_lang_reflect_AbstractMethod_artMethod,
+                   art_method);
+    return reflect_method;
   }
 
   static jobject ToReflectedField(JNIEnv* env, jclass, jfieldID fid, jboolean) {
     ScopedObjectAccess soa(env);
-    Field* field = soa.DecodeField(fid);
-    return soa.AddLocalReference<jobject>(field);
+    ArtField* f = soa.DecodeField(fid);
+    jobject art_field = soa.AddLocalReference<jobject>(f);
+    jobject reflect_field = env->AllocObject(WellKnownClasses::java_lang_reflect_Field);
+    if (env->ExceptionCheck()) {
+      return NULL;
+    }
+    SetObjectField(env,
+                   reflect_field,
+                   WellKnownClasses::java_lang_reflect_Field_artField,
+                   art_field);
+    return reflect_field;
   }
 
   static jclass GetObjectClass(JNIEnv* env, jobject java_object) {
@@ -678,7 +702,6 @@ class JNI {
   }
 
   static jboolean IsInstanceOf(JNIEnv* env, jobject jobj, jclass java_class) {
-    ScopedObjectAccess soa(env);
     if (java_class == NULL) {
       JniAbortF("IsInstanceOf", "null class (second argument)");
     }
@@ -686,6 +709,7 @@ class JNI {
       // Note: JNI is different from regular Java instanceof in this respect
       return JNI_TRUE;
     } else {
+      ScopedObjectAccess soa(env);
       Object* obj = soa.Decode<Object*>(jobj);
       Class* c = soa.Decode<Class*>(java_class);
       return obj->InstanceOf(c) ? JNI_TRUE : JNI_FALSE;
@@ -718,13 +742,13 @@ class JNI {
   static void ExceptionDescribe(JNIEnv* env) {
     ScopedObjectAccess soa(env);
 
-    SirtRef<mirror::Object> old_throw_this_object(soa.Self(), NULL);
-    SirtRef<mirror::AbstractMethod> old_throw_method(soa.Self(), NULL);
-    SirtRef<mirror::Throwable> old_exception(soa.Self(), NULL);
+    SirtRef<Object> old_throw_this_object(soa.Self(), NULL);
+    SirtRef<ArtMethod> old_throw_method(soa.Self(), NULL);
+    SirtRef<Throwable> old_exception(soa.Self(), NULL);
     uint32_t old_throw_dex_pc;
     {
       ThrowLocation old_throw_location;
-      mirror::Throwable* old_exception_obj = soa.Self()->GetException(&old_throw_location);
+      Throwable* old_exception_obj = soa.Self()->GetException(&old_throw_location);
       old_throw_this_object.reset(old_throw_location.GetThis());
       old_throw_method.reset(old_throw_location.GetMethod());
       old_exception.reset(old_exception_obj);
@@ -855,8 +879,12 @@ class JNI {
   }
 
   static jboolean IsSameObject(JNIEnv* env, jobject obj1, jobject obj2) {
-    ScopedObjectAccess soa(env);
-    return (soa.Decode<Object*>(obj1) == soa.Decode<Object*>(obj2)) ? JNI_TRUE : JNI_FALSE;
+    if (obj1 == obj2) {
+      return JNI_TRUE;
+    } else {
+      ScopedObjectAccess soa(env);
+      return (soa.Decode<Object*>(obj1) == soa.Decode<Object*>(obj2)) ? JNI_TRUE : JNI_FALSE;
+    }
   }
 
   static jobject AllocObject(JNIEnv* env, jclass java_class) {
@@ -1316,8 +1344,8 @@ class JNI {
     va_end(ap);
   }
 
-  static void CallNonvirtualVoidMethodV(JNIEnv* env,
-      jobject obj, jclass, jmethodID mid, va_list args) {
+  static void CallNonvirtualVoidMethodV(JNIEnv* env, jobject obj, jclass, jmethodID mid,
+                                        va_list args) {
     ScopedObjectAccess soa(env);
     InvokeWithVarArgs(soa, obj, mid, args);
   }
@@ -1342,13 +1370,13 @@ class JNI {
   static jobject GetObjectField(JNIEnv* env, jobject obj, jfieldID fid) {
     ScopedObjectAccess soa(env);
     Object* o = soa.Decode<Object*>(obj);
-    Field* f = soa.DecodeField(fid);
+    ArtField* f = soa.DecodeField(fid);
     return soa.AddLocalReference<jobject>(f->GetObject(o));
   }
 
   static jobject GetStaticObjectField(JNIEnv* env, jclass, jfieldID fid) {
     ScopedObjectAccess soa(env);
-    Field* f = soa.DecodeField(fid);
+    ArtField* f = soa.DecodeField(fid);
     return soa.AddLocalReference<jobject>(f->GetObject(f->GetDeclaringClass()));
   }
 
@@ -1356,37 +1384,37 @@ class JNI {
     ScopedObjectAccess soa(env);
     Object* o = soa.Decode<Object*>(java_object);
     Object* v = soa.Decode<Object*>(java_value);
-    Field* f = soa.DecodeField(fid);
+    ArtField* f = soa.DecodeField(fid);
     f->SetObject(o, v);
   }
 
   static void SetStaticObjectField(JNIEnv* env, jclass, jfieldID fid, jobject java_value) {
     ScopedObjectAccess soa(env);
     Object* v = soa.Decode<Object*>(java_value);
-    Field* f = soa.DecodeField(fid);
+    ArtField* f = soa.DecodeField(fid);
     f->SetObject(f->GetDeclaringClass(), v);
   }
 
 #define GET_PRIMITIVE_FIELD(fn, instance) \
   ScopedObjectAccess soa(env); \
   Object* o = soa.Decode<Object*>(instance); \
-  Field* f = soa.DecodeField(fid); \
+  ArtField* f = soa.DecodeField(fid); \
   return f->fn(o)
 
 #define GET_STATIC_PRIMITIVE_FIELD(fn) \
   ScopedObjectAccess soa(env); \
-  Field* f = soa.DecodeField(fid); \
+  ArtField* f = soa.DecodeField(fid); \
   return f->fn(f->GetDeclaringClass())
 
 #define SET_PRIMITIVE_FIELD(fn, instance, value) \
   ScopedObjectAccess soa(env); \
   Object* o = soa.Decode<Object*>(instance); \
-  Field* f = soa.DecodeField(fid); \
+  ArtField* f = soa.DecodeField(fid); \
   f->fn(o, value)
 
 #define SET_STATIC_PRIMITIVE_FIELD(fn, value) \
   ScopedObjectAccess soa(env); \
-  Field* f = soa.DecodeField(fid); \
+  ArtField* f = soa.DecodeField(fid); \
   f->fn(f->GetDeclaringClass(), value)
 
   static jboolean GetBooleanField(JNIEnv* env, jobject obj, jfieldID fid) {
@@ -1806,7 +1834,7 @@ class JNI {
   static jsize GetArrayLength(JNIEnv* env, jarray java_array) {
     ScopedObjectAccess soa(env);
     Object* obj = soa.Decode<Object*>(java_array);
-    if (!obj->IsArrayInstance()) {
+    if (UNLIKELY(!obj->IsArrayInstance())) {
       JniAbortF("GetArrayLength", "not an array: %s", PrettyTypeOf(obj).c_str());
     }
     Array* array = obj->AsArray();
@@ -1863,12 +1891,12 @@ class JNI {
   }
 
   static jobjectArray NewObjectArray(JNIEnv* env, jsize length, jclass element_jclass, jobject initial_element) {
-    ScopedObjectAccess soa(env);
     if (length < 0) {
       JniAbortF("NewObjectArray", "negative array length: %d", length);
     }
 
     // Compute the array class corresponding to the given element class.
+    ScopedObjectAccess soa(env);
     Class* element_class = soa.Decode<Class*>(element_jclass);
     std::string descriptor;
     descriptor += "[";
@@ -2080,7 +2108,7 @@ class JNI {
         ++sig;
       }
 
-      AbstractMethod* m = c->FindDirectMethod(name, sig);
+      ArtMethod* m = c->FindDirectMethod(name, sig);
       if (m == NULL) {
         m = c->FindVirtualMethod(name, sig);
       }
@@ -2111,13 +2139,13 @@ class JNI {
     VLOG(jni) << "[Unregistering JNI native methods for " << PrettyClass(c) << "]";
 
     for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
-      AbstractMethod* m = c->GetDirectMethod(i);
+      ArtMethod* m = c->GetDirectMethod(i);
       if (m->IsNative()) {
         m->UnregisterNative(soa.Self());
       }
     }
     for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
-      AbstractMethod* m = c->GetVirtualMethod(i);
+      ArtMethod* m = c->GetVirtualMethod(i);
       if (m->IsNative()) {
         m->UnregisterNative(soa.Self());
       }
@@ -2899,7 +2927,7 @@ bool JavaVMExt::LoadNativeLibrary(const std::string& path, ClassLoader* class_lo
   return was_successful;
 }
 
-void* JavaVMExt::FindCodeForNativeMethod(AbstractMethod* m) {
+void* JavaVMExt::FindCodeForNativeMethod(ArtMethod* m) {
   CHECK(m->IsNative());
 
   Class* c = m->GetDeclaringClass();
diff --git a/runtime/jni_internal.h b/runtime/jni_internal.h
index fcac4811c6..e3ffc8421b 100644
--- a/runtime/jni_internal.h
+++ b/runtime/jni_internal.h
@@ -38,10 +38,10 @@
 
 namespace art {
 namespace mirror {
-class AbstractMethod;
-class ClassLoader;
-class Field;
-}
+  class ArtField;
+  class ArtMethod;
+  class ClassLoader;
+}  // namespace mirror
 class ArgArray;
 union JValue;
 class Libraries;
@@ -55,7 +55,7 @@ void RegisterNativeMethods(JNIEnv* env, const char* jni_class_name, const JNINat
 
 JValue InvokeWithJValues(const ScopedObjectAccess&, jobject obj, jmethodID mid, jvalue* args)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void InvokeWithArgArray(const ScopedObjectAccess& soa, mirror::AbstractMethod* method,
+void InvokeWithArgArray(const ScopedObjectAccess& soa, mirror::ArtMethod* method,
                         ArgArray *arg_array, JValue* result, char result_type)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -79,7 +79,7 @@ struct JavaVMExt : public JavaVM {
    * Returns a pointer to the code for the native method 'm', found
    * using dlsym(3) on every native library that's been loaded so far.
    */
-  void* FindCodeForNativeMethod(mirror::AbstractMethod* m)
+  void* FindCodeForNativeMethod(mirror::ArtMethod* m)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void DumpForSigQuit(std::ostream& os);
diff --git a/runtime/jni_internal_test.cc b/runtime/jni_internal_test.cc
index c8b9eb95e3..234e40ac46 100644
--- a/runtime/jni_internal_test.cc
+++ b/runtime/jni_internal_test.cc
@@ -22,7 +22,7 @@
 
 #include "common_test.h"
 #include "invoke_arg_array_builder.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/object-inl.h"
@@ -43,7 +43,8 @@ class JniInternalTest : public CommonTest {
 
     vm_->AttachCurrentThread(&env_, NULL);
 
-    ScopedLocalRef<jclass> aioobe(env_, env_->FindClass("java/lang/ArrayIndexOutOfBoundsException"));
+    ScopedLocalRef<jclass> aioobe(env_,
+                                  env_->FindClass("java/lang/ArrayIndexOutOfBoundsException"));
     CHECK(aioobe.get() != NULL);
     aioobe_ = reinterpret_cast<jclass>(env_->NewGlobalRef(aioobe.get()));
 
@@ -51,7 +52,8 @@ class JniInternalTest : public CommonTest {
     CHECK(ase.get() != NULL);
     ase_ = reinterpret_cast<jclass>(env_->NewGlobalRef(ase.get()));
 
-    ScopedLocalRef<jclass> sioobe(env_, env_->FindClass("java/lang/StringIndexOutOfBoundsException"));
+    ScopedLocalRef<jclass> sioobe(env_,
+                                  env_->FindClass("java/lang/StringIndexOutOfBoundsException"));
     CHECK(sioobe.get() != NULL);
     sioobe_ = reinterpret_cast<jclass>(env_->NewGlobalRef(sioobe.get()));
   }
@@ -76,7 +78,7 @@ class JniInternalTest : public CommonTest {
     CommonTest::TearDown();
   }
 
-  void DoCompile(mirror::AbstractMethod*& method,
+  void DoCompile(mirror::ArtMethod*& method,
                  mirror::Object*& receiver,
                  bool is_static, const char* method_name,
                  const char* method_signature)
@@ -95,7 +97,8 @@ class JniInternalTest : public CommonTest {
       CompileVirtualMethod(class_loader.get(), class_name, method_name, method_signature);
     }
 
-    mirror::Class* c = class_linker_->FindClass(DotToDescriptor(class_name).c_str(), class_loader.get());
+    mirror::Class* c = class_linker_->FindClass(DotToDescriptor(class_name).c_str(),
+                                                class_loader.get());
     CHECK(c != NULL);
 
     method = is_static ? c->FindDirectMethod(method_name, method_signature)
@@ -111,7 +114,7 @@ class JniInternalTest : public CommonTest {
   }
 
   void InvokeNopMethod(bool is_static) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     mirror::Object* receiver;
     DoCompile(method, receiver, is_static, "nop", "()V");
 
@@ -127,7 +130,7 @@ class JniInternalTest : public CommonTest {
 
   void InvokeIdentityByteMethod(bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     mirror::Object* receiver;
     DoCompile(method, receiver, is_static, "identity", "(I)I");
 
@@ -163,7 +166,7 @@ class JniInternalTest : public CommonTest {
 
   void InvokeIdentityIntMethod(bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     mirror::Object* receiver;
     DoCompile(method, receiver, is_static, "identity", "(I)I");
 
@@ -199,7 +202,7 @@ class JniInternalTest : public CommonTest {
 
   void InvokeIdentityDoubleMethod(bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     mirror::Object* receiver;
     DoCompile(method, receiver, is_static, "identity", "(D)D");
 
@@ -243,7 +246,7 @@ class JniInternalTest : public CommonTest {
 
   void InvokeSumIntIntMethod(bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     mirror::Object* receiver;
     DoCompile(method, receiver, is_static, "sum", "(II)I");
 
@@ -289,7 +292,7 @@ class JniInternalTest : public CommonTest {
 
   void InvokeSumIntIntIntMethod(bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     mirror::Object* receiver;
     DoCompile(method, receiver, is_static, "sum", "(III)I");
 
@@ -340,7 +343,7 @@ class JniInternalTest : public CommonTest {
 
   void InvokeSumIntIntIntIntMethod(bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     mirror::Object* receiver;
     DoCompile(method, receiver, is_static, "sum", "(IIII)I");
 
@@ -396,7 +399,7 @@ class JniInternalTest : public CommonTest {
 
   void InvokeSumIntIntIntIntIntMethod(bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     mirror::Object* receiver;
     DoCompile(method, receiver, is_static, "sum", "(IIIII)I");
 
@@ -457,7 +460,7 @@ class JniInternalTest : public CommonTest {
 
   void InvokeSumDoubleDoubleMethod(bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     mirror::Object* receiver;
     DoCompile(method, receiver, is_static, "sum", "(DD)D");
 
@@ -523,7 +526,7 @@ class JniInternalTest : public CommonTest {
 
   void InvokeSumDoubleDoubleDoubleMethod(bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     mirror::Object* receiver;
     DoCompile(method, receiver, is_static, "sum", "(DDD)D");
 
@@ -578,7 +581,7 @@ class JniInternalTest : public CommonTest {
 
   void InvokeSumDoubleDoubleDoubleDoubleMethod(bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     mirror::Object* receiver;
     DoCompile(method, receiver, is_static, "sum", "(DDDD)D");
 
@@ -642,7 +645,7 @@ class JniInternalTest : public CommonTest {
 
   void InvokeSumDoubleDoubleDoubleDoubleDoubleMethod(bool is_static)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method;
+    mirror::ArtMethod* method;
     mirror::Object* receiver;
     DoCompile(method, receiver, is_static, "sum", "(DDDDD)D");
 
@@ -891,6 +894,11 @@ TEST_F(JniInternalTest, GetMethodID) {
   method = env_->GetMethodID(jlstring, "valueOf", "(I)Ljava/lang/String;");
   EXPECT_EQ(static_cast<jmethodID>(NULL), method);
   EXPECT_EXCEPTION(jlnsme);
+
+  // Check that GetMethodID for java.lang.NoSuchMethodError.<init>(String) finds the constructor
+  method = env_->GetMethodID(jlnsme, "<init>", "(Ljava/lang/String;)V");
+  EXPECT_NE(static_cast<jmethodID>(NULL), method);
+  EXPECT_FALSE(env_->ExceptionCheck());
 }
 
 TEST_F(JniInternalTest, GetStaticMethodID) {
@@ -933,6 +941,9 @@ TEST_F(JniInternalTest, FromReflectedField_ToReflectedField) {
   // ...and back again.
   jfieldID fid2 = env_->FromReflectedField(field);
   ASSERT_TRUE(fid2 != NULL);
+  // Make sure we can actually use it.
+  jstring s = env_->NewStringUTF("poop");
+  ASSERT_EQ(4, env_->GetIntField(s, fid2));
 }
 
 TEST_F(JniInternalTest, FromReflectedMethod_ToReflectedMethod) {
@@ -948,6 +959,13 @@ TEST_F(JniInternalTest, FromReflectedMethod_ToReflectedMethod) {
   // ...and back again.
   jmethodID mid2 = env_->FromReflectedMethod(method);
   ASSERT_TRUE(mid2 != NULL);
+  // Make sure we can actually use it.
+  jstring s = env_->NewStringUTF("poop");
+  // TODO: this should return 4, but the runtime skips the method
+  // invoke because the runtime isn't started. In the future it would
+  // be nice to use interpretter for things like this. This still does
+  // validate that we have a sane jmethodID value.
+  ASSERT_EQ(0, env_->CallIntMethod(s, mid2));
 }
 
 void BogusMethod() {
@@ -986,7 +1004,13 @@ TEST_F(JniInternalTest, RegisterNatives) {
   env_->UnregisterNatives(jlobject);
 }
 
-#define EXPECT_PRIMITIVE_ARRAY(new_fn, get_region_fn, set_region_fn, get_elements_fn, release_elements_fn, scalar_type, expected_class_descriptor) \
+#define EXPECT_PRIMITIVE_ARRAY(new_fn, \
+                               get_region_fn, \
+                               set_region_fn, \
+                               get_elements_fn, \
+                               release_elements_fn, \
+                               scalar_type, \
+                               expected_class_descriptor) \
   jsize size = 4; \
   /* Allocate an array and check it has the right type and length. */ \
   scalar_type ## Array a = env_->new_fn(size); \
@@ -1017,47 +1041,60 @@ TEST_F(JniInternalTest, RegisterNatives) {
   env_->set_region_fn(a, 0, size, &src_buf[0]); \
   /* Copy back only part. */ \
   env_->get_region_fn(a, 1, size - 2, &dst_buf[1]); \
-  EXPECT_NE(memcmp(&src_buf[0], &dst_buf[0], size * sizeof(scalar_type)), 0) << "short copy equal"; \
+  EXPECT_NE(memcmp(&src_buf[0], &dst_buf[0], size * sizeof(scalar_type)), 0) \
+    << "short copy equal"; \
   /* Copy the missing pieces. */ \
   env_->get_region_fn(a, 0, 1, &dst_buf[0]); \
   env_->get_region_fn(a, size - 1, 1, &dst_buf[size - 1]); \
-  EXPECT_EQ(memcmp(&src_buf[0], &dst_buf[0], size * sizeof(scalar_type)), 0) << "fixed copy not equal"; \
+  EXPECT_EQ(memcmp(&src_buf[0], &dst_buf[0], size * sizeof(scalar_type)), 0) \
+    << "fixed copy not equal"; \
   /* Copy back the whole array. */ \
   env_->get_region_fn(a, 0, size, &dst_buf[0]); \
-  EXPECT_EQ(memcmp(&src_buf[0], &dst_buf[0], size * sizeof(scalar_type)), 0) << "full copy not equal"; \
+  EXPECT_EQ(memcmp(&src_buf[0], &dst_buf[0], size * sizeof(scalar_type)), 0) \
+    << "full copy not equal"; \
   /* GetPrimitiveArrayCritical */ \
   void* v = env_->GetPrimitiveArrayCritical(a, NULL); \
-  EXPECT_EQ(memcmp(&src_buf[0], v, size * sizeof(scalar_type)), 0) << "GetPrimitiveArrayCritical not equal"; \
+  EXPECT_EQ(memcmp(&src_buf[0], v, size * sizeof(scalar_type)), 0) \
+    << "GetPrimitiveArrayCritical not equal"; \
   env_->ReleasePrimitiveArrayCritical(a, v, 0); \
   /* GetXArrayElements */ \
   scalar_type* xs = env_->get_elements_fn(a, NULL); \
-  EXPECT_EQ(memcmp(&src_buf[0], xs, size * sizeof(scalar_type)), 0) << # get_elements_fn " not equal"; \
+  EXPECT_EQ(memcmp(&src_buf[0], xs, size * sizeof(scalar_type)), 0) \
+    << # get_elements_fn " not equal"; \
   env_->release_elements_fn(a, xs, 0); \
   EXPECT_EQ(reinterpret_cast<uintptr_t>(v), reinterpret_cast<uintptr_t>(xs))
 
 TEST_F(JniInternalTest, BooleanArrays) {
-  EXPECT_PRIMITIVE_ARRAY(NewBooleanArray, GetBooleanArrayRegion, SetBooleanArrayRegion, GetBooleanArrayElements, ReleaseBooleanArrayElements, jboolean, "[Z");
+  EXPECT_PRIMITIVE_ARRAY(NewBooleanArray, GetBooleanArrayRegion, SetBooleanArrayRegion,
+                         GetBooleanArrayElements, ReleaseBooleanArrayElements, jboolean, "[Z");
 }
 TEST_F(JniInternalTest, ByteArrays) {
-  EXPECT_PRIMITIVE_ARRAY(NewByteArray, GetByteArrayRegion, SetByteArrayRegion, GetByteArrayElements, ReleaseByteArrayElements, jbyte, "[B");
+  EXPECT_PRIMITIVE_ARRAY(NewByteArray, GetByteArrayRegion, SetByteArrayRegion,
+                         GetByteArrayElements, ReleaseByteArrayElements, jbyte, "[B");
 }
 TEST_F(JniInternalTest, CharArrays) {
-  EXPECT_PRIMITIVE_ARRAY(NewCharArray, GetCharArrayRegion, SetCharArrayRegion, GetCharArrayElements, ReleaseCharArrayElements, jchar, "[C");
+  EXPECT_PRIMITIVE_ARRAY(NewCharArray, GetCharArrayRegion, SetCharArrayRegion,
+                         GetCharArrayElements, ReleaseCharArrayElements, jchar, "[C");
 }
 TEST_F(JniInternalTest, DoubleArrays) {
-  EXPECT_PRIMITIVE_ARRAY(NewDoubleArray, GetDoubleArrayRegion, SetDoubleArrayRegion, GetDoubleArrayElements, ReleaseDoubleArrayElements, jdouble, "[D");
+  EXPECT_PRIMITIVE_ARRAY(NewDoubleArray, GetDoubleArrayRegion, SetDoubleArrayRegion,
+                         GetDoubleArrayElements, ReleaseDoubleArrayElements, jdouble, "[D");
 }
 TEST_F(JniInternalTest, FloatArrays) {
-  EXPECT_PRIMITIVE_ARRAY(NewFloatArray, GetFloatArrayRegion, SetFloatArrayRegion, GetFloatArrayElements, ReleaseFloatArrayElements, jfloat, "[F");
+  EXPECT_PRIMITIVE_ARRAY(NewFloatArray, GetFloatArrayRegion, SetFloatArrayRegion,
+                         GetFloatArrayElements, ReleaseFloatArrayElements, jfloat, "[F");
 }
 TEST_F(JniInternalTest, IntArrays) {
-  EXPECT_PRIMITIVE_ARRAY(NewIntArray, GetIntArrayRegion, SetIntArrayRegion, GetIntArrayElements, ReleaseIntArrayElements, jint, "[I");
+  EXPECT_PRIMITIVE_ARRAY(NewIntArray, GetIntArrayRegion, SetIntArrayRegion,
+                         GetIntArrayElements, ReleaseIntArrayElements, jint, "[I");
 }
 TEST_F(JniInternalTest, LongArrays) {
-  EXPECT_PRIMITIVE_ARRAY(NewLongArray, GetLongArrayRegion, SetLongArrayRegion, GetLongArrayElements, ReleaseLongArrayElements, jlong, "[J");
+  EXPECT_PRIMITIVE_ARRAY(NewLongArray, GetLongArrayRegion, SetLongArrayRegion,
+                         GetLongArrayElements, ReleaseLongArrayElements, jlong, "[J");
 }
 TEST_F(JniInternalTest, ShortArrays) {
-  EXPECT_PRIMITIVE_ARRAY(NewShortArray, GetShortArrayRegion, SetShortArrayRegion, GetShortArrayElements, ReleaseShortArrayElements, jshort, "[S");
+  EXPECT_PRIMITIVE_ARRAY(NewShortArray, GetShortArrayRegion, SetShortArrayRegion,
+                         GetShortArrayElements, ReleaseShortArrayElements, jshort, "[S");
 }
 
 TEST_F(JniInternalTest, NewObjectArray) {
@@ -1437,7 +1474,8 @@ TEST_F(JniInternalTest, DeleteLocalRef) {
     CheckJniAbortCatcher check_jni_abort_catcher;
     env_->DeleteLocalRef(s);
 
-    std::string expected(StringPrintf("native code passing in reference to invalid local reference: %p", s));
+    std::string expected(StringPrintf("native code passing in reference to "
+                                      "invalid local reference: %p", s));
     check_jni_abort_catcher.Check(expected.c_str());
   }
 
@@ -1520,7 +1558,8 @@ TEST_F(JniInternalTest, DeleteGlobalRef) {
     CheckJniAbortCatcher check_jni_abort_catcher;
     env_->DeleteGlobalRef(o);
 
-    std::string expected(StringPrintf("native code passing in reference to invalid global reference: %p", o));
+    std::string expected(StringPrintf("native code passing in reference to "
+                                      "invalid global reference: %p", o));
     check_jni_abort_catcher.Check(expected.c_str());
   }
 
@@ -1564,7 +1603,8 @@ TEST_F(JniInternalTest, DeleteWeakGlobalRef) {
     CheckJniAbortCatcher check_jni_abort_catcher;
     env_->DeleteWeakGlobalRef(o);
 
-    std::string expected(StringPrintf("native code passing in reference to invalid weak global reference: %p", o));
+    std::string expected(StringPrintf("native code passing in reference to "
+                                      "invalid weak global reference: %p", o));
     check_jni_abort_catcher.Check(expected.c_str());
   }
 
@@ -1588,7 +1628,7 @@ TEST_F(JniInternalTest, StaticMainMethod) {
   mirror::Class* klass = class_linker_->FindClass("LMain;", class_loader.get());
   ASSERT_TRUE(klass != NULL);
 
-  mirror::AbstractMethod* method = klass->FindDirectMethod("main", "([Ljava/lang/String;)V");
+  mirror::ArtMethod* method = klass->FindDirectMethod("main", "([Ljava/lang/String;)V");
   ASSERT_TRUE(method != NULL);
 
   ArgArray arg_array(NULL, 0);
diff --git a/runtime/mirror/abstract_method-inl.h b/runtime/mirror/abstract_method-inl.h
deleted file mode 100644
index d47b3ebccc..0000000000
--- a/runtime/mirror/abstract_method-inl.h
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * Copyright (C) 2011 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_RUNTIME_MIRROR_ABSTRACT_METHOD_INL_H_
-#define ART_RUNTIME_MIRROR_ABSTRACT_METHOD_INL_H_
-
-#include "abstract_method.h"
-
-#include "dex_file.h"
-#include "entrypoints/entrypoint_utils.h"
-#include "object_array.h"
-#include "runtime.h"
-
-namespace art {
-namespace mirror {
-
-inline Class* AbstractMethod::GetDeclaringClass() const {
-  Class* result = GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, declaring_class_), false);
-  DCHECK(result != NULL) << this;
-  DCHECK(result->IsIdxLoaded() || result->IsErroneous()) << this;
-  return result;
-}
-
-inline void AbstractMethod::SetDeclaringClass(Class *new_declaring_class) {
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, declaring_class_), new_declaring_class, false);
-}
-
-inline uint32_t AbstractMethod::GetAccessFlags() const {
-  DCHECK(GetDeclaringClass()->IsIdxLoaded() || GetDeclaringClass()->IsErroneous());
-  return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, access_flags_), false);
-}
-
-inline uint16_t AbstractMethod::GetMethodIndex() const {
-  DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
-  return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_), false);
-}
-
-inline uint32_t AbstractMethod::GetDexMethodIndex() const {
-  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-  return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_dex_index_), false);
-}
-
-inline ObjectArray<String>* AbstractMethod::GetDexCacheStrings() const {
-  return GetFieldObject<ObjectArray<String>*>(
-      OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_), false);
-}
-
-inline ObjectArray<AbstractMethod>* AbstractMethod::GetDexCacheResolvedMethods() const {
-  return GetFieldObject<ObjectArray<AbstractMethod>*>(
-      OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_methods_), false);
-}
-
-inline ObjectArray<Class>* AbstractMethod::GetDexCacheResolvedTypes() const {
-  return GetFieldObject<ObjectArray<Class>*>(
-      OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_types_), false);
-}
-
-inline ObjectArray<StaticStorageBase>* AbstractMethod::GetDexCacheInitializedStaticStorage() const {
-  return GetFieldObject<ObjectArray<StaticStorageBase>*>(
-      OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_initialized_static_storage_),
-      false);
-}
-
-inline uint32_t AbstractMethod::GetCodeSize() const {
-  DCHECK(!IsRuntimeMethod() && !IsProxyMethod()) << PrettyMethod(this);
-  uintptr_t code = reinterpret_cast<uintptr_t>(GetEntryPointFromCompiledCode());
-  if (code == 0) {
-    return 0;
-  }
-  // TODO: make this Thumb2 specific
-  code &= ~0x1;
-  return reinterpret_cast<uint32_t*>(code)[-1];
-}
-
-inline bool AbstractMethod::CheckIncompatibleClassChange(InvokeType type) {
-  switch (type) {
-    case kStatic:
-      return !IsStatic();
-    case kDirect:
-      return !IsDirect() || IsStatic();
-    case kVirtual: {
-      Class* methods_class = GetDeclaringClass();
-      return IsDirect() || (methods_class->IsInterface() && !IsMiranda());
-    }
-    case kSuper:
-      return false;  // TODO: appropriate checks for call to super class.
-    case kInterface: {
-      Class* methods_class = GetDeclaringClass();
-      return IsDirect() || !(methods_class->IsInterface() || methods_class->IsObjectClass());
-    }
-    default:
-      LOG(FATAL) << "Unreachable - invocation type: " << type;
-      return true;
-  }
-}
-
-inline void AbstractMethod::AssertPcIsWithinCode(uintptr_t pc) const {
-  if (!kIsDebugBuild) {
-    return;
-  }
-  if (IsNative() || IsRuntimeMethod() || IsProxyMethod()) {
-    return;
-  }
-  if (pc == GetQuickInstrumentationExitPc()) {
-    return;
-  }
-  const void* code = GetEntryPointFromCompiledCode();
-  if (code == GetCompiledCodeToInterpreterBridge() || code == GetQuickInstrumentationEntryPoint()) {
-    return;
-  }
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  if (code == GetResolutionTrampoline(class_linker)) {
-    return;
-  }
-  DCHECK(IsWithinCode(pc))
-      << PrettyMethod(this)
-      << " pc=" << std::hex << pc
-      << " code=" << code
-      << " size=" << GetCodeSize();
-}
-
-inline uint32_t AbstractMethod::GetOatCodeOffset() const {
-  DCHECK(!Runtime::Current()->IsStarted());
-  return reinterpret_cast<uint32_t>(GetEntryPointFromCompiledCode());
-}
-
-inline void AbstractMethod::SetOatCodeOffset(uint32_t code_offset) {
-  DCHECK(!Runtime::Current()->IsStarted());
-  SetEntryPointFromCompiledCode(reinterpret_cast<void*>(code_offset));
-}
-
-inline uint32_t AbstractMethod::GetOatMappingTableOffset() const {
-  DCHECK(!Runtime::Current()->IsStarted());
-  return reinterpret_cast<uint32_t>(GetMappingTable());
-}
-
-inline void AbstractMethod::SetOatMappingTableOffset(uint32_t mapping_table_offset) {
-  DCHECK(!Runtime::Current()->IsStarted());
-  SetMappingTable(reinterpret_cast<const uint8_t*>(mapping_table_offset));
-}
-
-inline uint32_t AbstractMethod::GetOatVmapTableOffset() const {
-  DCHECK(!Runtime::Current()->IsStarted());
-  return reinterpret_cast<uint32_t>(GetVmapTable());
-}
-
-inline void AbstractMethod::SetOatVmapTableOffset(uint32_t vmap_table_offset) {
-  DCHECK(!Runtime::Current()->IsStarted());
-  SetVmapTable(reinterpret_cast<uint8_t*>(vmap_table_offset));
-}
-
-inline void AbstractMethod::SetOatNativeGcMapOffset(uint32_t gc_map_offset) {
-  DCHECK(!Runtime::Current()->IsStarted());
-  SetNativeGcMap(reinterpret_cast<uint8_t*>(gc_map_offset));
-}
-
-inline uint32_t AbstractMethod::GetOatNativeGcMapOffset() const {
-  DCHECK(!Runtime::Current()->IsStarted());
-  return reinterpret_cast<uint32_t>(GetNativeGcMap());
-}
-
-inline bool AbstractMethod::IsRuntimeMethod() const {
-  return GetDexMethodIndex() == DexFile::kDexNoIndex16;
-}
-
-inline bool AbstractMethod::IsCalleeSaveMethod() const {
-  if (!IsRuntimeMethod()) {
-    return false;
-  }
-  Runtime* runtime = Runtime::Current();
-  bool result = false;
-  for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
-    if (this == runtime->GetCalleeSaveMethod(Runtime::CalleeSaveType(i))) {
-      result = true;
-      break;
-    }
-  }
-  return result;
-}
-
-inline bool AbstractMethod::IsResolutionMethod() const {
-  bool result = this == Runtime::Current()->GetResolutionMethod();
-  // Check that if we do think it is phony it looks like the resolution method.
-  DCHECK(!result || IsRuntimeMethod());
-  return result;
-}
-}  // namespace mirror
-}  // namespace art
-
-#endif  // ART_RUNTIME_MIRROR_ABSTRACT_METHOD_INL_H_
diff --git a/runtime/mirror/abstract_method.cc b/runtime/mirror/abstract_method.cc
deleted file mode 100644
index b3db5c2721..0000000000
--- a/runtime/mirror/abstract_method.cc
+++ /dev/null
@@ -1,350 +0,0 @@
-/*
- * Copyright (C) 2011 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.
- */
-
-#include "abstract_method.h"
-
-#include "abstract_method-inl.h"
-#include "base/stringpiece.h"
-#include "class-inl.h"
-#include "dex_file-inl.h"
-#include "dex_instruction.h"
-#include "gc/accounting/card_table-inl.h"
-#include "interpreter/interpreter.h"
-#include "jni_internal.h"
-#include "mapping_table.h"
-#include "object-inl.h"
-#include "object_array.h"
-#include "object_array-inl.h"
-#include "string.h"
-#include "object_utils.h"
-
-namespace art {
-namespace mirror {
-
-extern "C" void art_portable_invoke_stub(AbstractMethod*, uint32_t*, uint32_t, Thread*, JValue*, char);
-extern "C" void art_quick_invoke_stub(AbstractMethod*, uint32_t*, uint32_t, Thread*, JValue*, char);
-
-// TODO: get global references for these
-Class* AbstractMethod::java_lang_reflect_Constructor_ = NULL;
-Class* AbstractMethod::java_lang_reflect_Method_ = NULL;
-
-InvokeType AbstractMethod::GetInvokeType() const {
-  // TODO: kSuper?
-  if (GetDeclaringClass()->IsInterface()) {
-    return kInterface;
-  } else if (IsStatic()) {
-    return kStatic;
-  } else if (IsDirect()) {
-    return kDirect;
-  } else {
-    return kVirtual;
-  }
-}
-
-void AbstractMethod::SetClasses(Class* java_lang_reflect_Constructor, Class* java_lang_reflect_Method) {
-  CHECK(java_lang_reflect_Constructor_ == NULL);
-  CHECK(java_lang_reflect_Constructor != NULL);
-  java_lang_reflect_Constructor_ = java_lang_reflect_Constructor;
-
-  CHECK(java_lang_reflect_Method_ == NULL);
-  CHECK(java_lang_reflect_Method != NULL);
-  java_lang_reflect_Method_ = java_lang_reflect_Method;
-}
-
-void AbstractMethod::ResetClasses() {
-  CHECK(java_lang_reflect_Constructor_ != NULL);
-  java_lang_reflect_Constructor_ = NULL;
-
-  CHECK(java_lang_reflect_Method_ != NULL);
-  java_lang_reflect_Method_ = NULL;
-}
-
-void AbstractMethod::SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings) {
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_),
-                 new_dex_cache_strings, false);
-}
-
-void AbstractMethod::SetDexCacheResolvedMethods(ObjectArray<AbstractMethod>* new_dex_cache_methods) {
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_methods_),
-                 new_dex_cache_methods, false);
-}
-
-void AbstractMethod::SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_classes) {
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_types_),
-                 new_dex_cache_classes, false);
-}
-
-void AbstractMethod::SetDexCacheInitializedStaticStorage(ObjectArray<StaticStorageBase>* new_value) {
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_initialized_static_storage_),
-      new_value, false);
-}
-
-size_t AbstractMethod::NumArgRegisters(const StringPiece& shorty) {
-  CHECK_LE(1, shorty.length());
-  uint32_t num_registers = 0;
-  for (int i = 1; i < shorty.length(); ++i) {
-    char ch = shorty[i];
-    if (ch == 'D' || ch == 'J') {
-      num_registers += 2;
-    } else {
-      num_registers += 1;
-    }
-  }
-  return num_registers;
-}
-
-bool AbstractMethod::IsProxyMethod() const {
-  return GetDeclaringClass()->IsProxyClass();
-}
-
-AbstractMethod* AbstractMethod::FindOverriddenMethod() const {
-  if (IsStatic()) {
-    return NULL;
-  }
-  Class* declaring_class = GetDeclaringClass();
-  Class* super_class = declaring_class->GetSuperClass();
-  uint16_t method_index = GetMethodIndex();
-  ObjectArray<AbstractMethod>* super_class_vtable = super_class->GetVTable();
-  AbstractMethod* result = NULL;
-  // Did this method override a super class method? If so load the result from the super class'
-  // vtable
-  if (super_class_vtable != NULL && method_index < super_class_vtable->GetLength()) {
-    result = super_class_vtable->Get(method_index);
-  } else {
-    // Method didn't override superclass method so search interfaces
-    if (IsProxyMethod()) {
-      result = GetDexCacheResolvedMethods()->Get(GetDexMethodIndex());
-      CHECK_EQ(result,
-               Runtime::Current()->GetClassLinker()->FindMethodForProxy(GetDeclaringClass(), this));
-    } else {
-      MethodHelper mh(this);
-      MethodHelper interface_mh;
-      IfTable* iftable = GetDeclaringClass()->GetIfTable();
-      for (size_t i = 0; i < iftable->Count() && result == NULL; i++) {
-        Class* interface = iftable->GetInterface(i);
-        for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
-          AbstractMethod* interface_method = interface->GetVirtualMethod(j);
-          interface_mh.ChangeMethod(interface_method);
-          if (mh.HasSameNameAndSignature(&interface_mh)) {
-            result = interface_method;
-            break;
-          }
-        }
-      }
-    }
-  }
-#ifndef NDEBUG
-  MethodHelper result_mh(result);
-  DCHECK(result == NULL || MethodHelper(this).HasSameNameAndSignature(&result_mh));
-#endif
-  return result;
-}
-
-uintptr_t AbstractMethod::NativePcOffset(const uintptr_t pc) const {
-  const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
-  return pc - reinterpret_cast<uintptr_t>(code);
-}
-
-uint32_t AbstractMethod::ToDexPc(const uintptr_t pc) const {
-#if !defined(ART_USE_PORTABLE_COMPILER)
-  MappingTable table(GetMappingTable());
-  if (table.TotalSize() == 0) {
-    DCHECK(IsNative() || IsCalleeSaveMethod() || IsProxyMethod()) << PrettyMethod(this);
-    return DexFile::kDexNoIndex;   // Special no mapping case
-  }
-  const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
-  uint32_t sought_offset = pc - reinterpret_cast<uintptr_t>(code);
-  // Assume the caller wants a pc-to-dex mapping so check here first.
-  typedef MappingTable::PcToDexIterator It;
-  for (It cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
-    if (cur.NativePcOffset() == sought_offset) {
-      return cur.DexPc();
-    }
-  }
-  // Now check dex-to-pc mappings.
-  typedef MappingTable::DexToPcIterator It2;
-  for (It2 cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
-    if (cur.NativePcOffset() == sought_offset) {
-      return cur.DexPc();
-    }
-  }
-  LOG(FATAL) << "Failed to find Dex offset for PC offset " << reinterpret_cast<void*>(sought_offset)
-             << "(PC " << reinterpret_cast<void*>(pc) << ", code=" << code
-             << ") in " << PrettyMethod(this);
-  return DexFile::kDexNoIndex;
-#else
-  // Compiler LLVM doesn't use the machine pc, we just use dex pc instead.
-  return static_cast<uint32_t>(pc);
-#endif
-}
-
-uintptr_t AbstractMethod::ToNativePc(const uint32_t dex_pc) const {
-  MappingTable table(GetMappingTable());
-  if (table.TotalSize() == 0) {
-    DCHECK_EQ(dex_pc, 0U);
-    return 0;   // Special no mapping/pc == 0 case
-  }
-  // Assume the caller wants a dex-to-pc mapping so check here first.
-  typedef MappingTable::DexToPcIterator It;
-  for (It cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
-    if (cur.DexPc() == dex_pc) {
-      const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
-      return reinterpret_cast<uintptr_t>(code) + cur.NativePcOffset();
-    }
-  }
-  // Now check pc-to-dex mappings.
-  typedef MappingTable::PcToDexIterator It2;
-  for (It2 cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
-    if (cur.DexPc() == dex_pc) {
-      const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
-      return reinterpret_cast<uintptr_t>(code) + cur.NativePcOffset();
-    }
-  }
-  LOG(FATAL) << "Failed to find native offset for dex pc 0x" << std::hex << dex_pc
-             << " in " << PrettyMethod(this);
-  return 0;
-}
-
-uint32_t AbstractMethod::FindCatchBlock(Class* exception_type, uint32_t dex_pc,
-                                        bool* has_no_move_exception) const {
-  MethodHelper mh(this);
-  const DexFile::CodeItem* code_item = mh.GetCodeItem();
-  // Default to handler not found.
-  uint32_t found_dex_pc = DexFile::kDexNoIndex;
-  // Iterate over the catch handlers associated with dex_pc.
-  for (CatchHandlerIterator it(*code_item, dex_pc); it.HasNext(); it.Next()) {
-    uint16_t iter_type_idx = it.GetHandlerTypeIndex();
-    // Catch all case
-    if (iter_type_idx == DexFile::kDexNoIndex16) {
-      found_dex_pc = it.GetHandlerAddress();
-      break;
-    }
-    // Does this catch exception type apply?
-    Class* iter_exception_type = mh.GetDexCacheResolvedType(iter_type_idx);
-    if (iter_exception_type == NULL) {
-      // The verifier should take care of resolving all exception classes early
-      LOG(WARNING) << "Unresolved exception class when finding catch block: "
-        << mh.GetTypeDescriptorFromTypeIdx(iter_type_idx);
-    } else if (iter_exception_type->IsAssignableFrom(exception_type)) {
-      found_dex_pc = it.GetHandlerAddress();
-      break;
-    }
-  }
-  if (found_dex_pc != DexFile::kDexNoIndex) {
-    const Instruction* first_catch_instr =
-        Instruction::At(&mh.GetCodeItem()->insns_[found_dex_pc]);
-    *has_no_move_exception = (first_catch_instr->Opcode() != Instruction::MOVE_EXCEPTION);
-  }
-  return found_dex_pc;
-}
-
-void AbstractMethod::Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result,
-                            char result_type) {
-  if (kIsDebugBuild) {
-    self->AssertThreadSuspensionIsAllowable();
-    CHECK_EQ(kRunnable, self->GetState());
-  }
-
-  // Push a transition back into managed code onto the linked list in thread.
-  ManagedStack fragment;
-  self->PushManagedStackFragment(&fragment);
-
-  Runtime* runtime = Runtime::Current();
-  // Call the invoke stub, passing everything as arguments.
-  if (UNLIKELY(!runtime->IsStarted())) {
-    LOG(INFO) << "Not invoking " << PrettyMethod(this) << " for a runtime that isn't started";
-    if (result != NULL) {
-      result->SetJ(0);
-    }
-  } else {
-    const bool kLogInvocationStartAndReturn = false;
-    if (GetEntryPointFromCompiledCode() != NULL) {
-      if (kLogInvocationStartAndReturn) {
-        LOG(INFO) << StringPrintf("Invoking '%s' code=%p", PrettyMethod(this).c_str(), GetEntryPointFromCompiledCode());
-      }
-#ifdef ART_USE_PORTABLE_COMPILER
-      (*art_portable_invoke_stub)(this, args, args_size, self, result, result_type);
-#else
-      (*art_quick_invoke_stub)(this, args, args_size, self, result, result_type);
-#endif
-      if (UNLIKELY(reinterpret_cast<int32_t>(self->GetException(NULL)) == -1)) {
-        // Unusual case where we were running LLVM generated code and an
-        // exception was thrown to force the activations to be removed from the
-        // stack. Continue execution in the interpreter.
-        self->ClearException();
-        ShadowFrame* shadow_frame = self->GetAndClearDeoptimizationShadowFrame(result);
-        self->SetTopOfStack(NULL, 0);
-        self->SetTopOfShadowStack(shadow_frame);
-        interpreter::EnterInterpreterFromDeoptimize(self, shadow_frame, result);
-      }
-      if (kLogInvocationStartAndReturn) {
-        LOG(INFO) << StringPrintf("Returned '%s' code=%p", PrettyMethod(this).c_str(), GetEntryPointFromCompiledCode());
-      }
-    } else {
-      LOG(INFO) << "Not invoking '" << PrettyMethod(this)
-          << "' code=" << reinterpret_cast<const void*>(GetEntryPointFromCompiledCode());
-      if (result != NULL) {
-        result->SetJ(0);
-      }
-    }
-  }
-
-  // Pop transition.
-  self->PopManagedStackFragment(fragment);
-}
-
-bool AbstractMethod::IsRegistered() const {
-  void* native_method = GetFieldPtr<void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_method_), false);
-  CHECK(native_method != NULL);
-  void* jni_stub = GetJniDlsymLookupStub();
-  return native_method != jni_stub;
-}
-
-extern "C" void art_work_around_app_jni_bugs(JNIEnv*, jobject);
-void AbstractMethod::RegisterNative(Thread* self, const void* native_method) {
-  DCHECK(Thread::Current() == self);
-  CHECK(IsNative()) << PrettyMethod(this);
-  CHECK(native_method != NULL) << PrettyMethod(this);
-  if (!self->GetJniEnv()->vm->work_around_app_jni_bugs) {
-    SetNativeMethod(native_method);
-  } else {
-    // We've been asked to associate this method with the given native method but are working
-    // around JNI bugs, that include not giving Object** SIRT references to native methods. Direct
-    // the native method to runtime support and store the target somewhere runtime support will
-    // find it.
-#if defined(__i386__)
-    UNIMPLEMENTED(FATAL);
-#else
-    SetNativeMethod(reinterpret_cast<void*>(art_work_around_app_jni_bugs));
-#endif
-    SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, gc_map_),
-        reinterpret_cast<const uint8_t*>(native_method), false);
-  }
-}
-
-void AbstractMethod::UnregisterNative(Thread* self) {
-  CHECK(IsNative()) << PrettyMethod(this);
-  // restore stub to lookup native pointer via dlsym
-  RegisterNative(self, GetJniDlsymLookupStub());
-}
-
-void AbstractMethod::SetNativeMethod(const void* native_method) {
-  SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_method_),
-      native_method, false);
-}
-
-}  // namespace mirror
-}  // namespace art
diff --git a/runtime/mirror/abstract_method.h b/runtime/mirror/abstract_method.h
deleted file mode 100644
index 5b8c61cd06..0000000000
--- a/runtime/mirror/abstract_method.h
+++ /dev/null
@@ -1,471 +0,0 @@
-/*
- * Copyright (C) 2011 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_RUNTIME_MIRROR_ABSTRACT_METHOD_H_
-#define ART_RUNTIME_MIRROR_ABSTRACT_METHOD_H_
-
-#include "class.h"
-#include "dex_file.h"
-#include "invoke_type.h"
-#include "locks.h"
-#include "modifiers.h"
-#include "object.h"
-
-namespace art {
-
-struct AbstractMethodOffsets;
-struct ConstructorMethodOffsets;
-union JValue;
-struct MethodClassOffsets;
-class MethodHelper;
-struct MethodOffsets;
-class StringPiece;
-class ShadowFrame;
-
-namespace mirror {
-
-class StaticStorageBase;
-
-typedef void (EntryPointFromInterpreter)(Thread* self, MethodHelper& mh,
-    const DexFile::CodeItem* code_item, ShadowFrame* shadow_frame, JValue* result);
-
-// C++ mirror of java.lang.reflect.Method and java.lang.reflect.Constructor
-class MANAGED AbstractMethod : public Object {
- public:
-  Class* GetDeclaringClass() const;
-
-  void SetDeclaringClass(Class *new_declaring_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  static MemberOffset DeclaringClassOffset() {
-    return MemberOffset(OFFSETOF_MEMBER(AbstractMethod, declaring_class_));
-  }
-
-  static MemberOffset EntryPointFromCompiledCodeOffset() {
-    return MemberOffset(OFFSETOF_MEMBER(AbstractMethod, entry_point_from_compiled_code_));
-  }
-
-  uint32_t GetAccessFlags() const;
-
-  void SetAccessFlags(uint32_t new_access_flags) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, access_flags_), new_access_flags, false);
-  }
-
-  // Approximate what kind of method call would be used for this method.
-  InvokeType GetInvokeType() const;
-
-  // Returns true if the method is declared public.
-  bool IsPublic() const {
-    return (GetAccessFlags() & kAccPublic) != 0;
-  }
-
-  // Returns true if the method is declared private.
-  bool IsPrivate() const {
-    return (GetAccessFlags() & kAccPrivate) != 0;
-  }
-
-  // Returns true if the method is declared static.
-  bool IsStatic() const {
-    return (GetAccessFlags() & kAccStatic) != 0;
-  }
-
-  // Returns true if the method is a constructor.
-  bool IsConstructor() const {
-    return (GetAccessFlags() & kAccConstructor) != 0;
-  }
-
-  // Returns true if the method is static, private, or a constructor.
-  bool IsDirect() const {
-    return IsDirect(GetAccessFlags());
-  }
-
-  static bool IsDirect(uint32_t access_flags) {
-    return (access_flags & (kAccStatic | kAccPrivate | kAccConstructor)) != 0;
-  }
-
-  // Returns true if the method is declared synchronized.
-  bool IsSynchronized() const {
-    uint32_t synchonized = kAccSynchronized | kAccDeclaredSynchronized;
-    return (GetAccessFlags() & synchonized) != 0;
-  }
-
-  bool IsFinal() const {
-    return (GetAccessFlags() & kAccFinal) != 0;
-  }
-
-  bool IsMiranda() const {
-    return (GetAccessFlags() & kAccMiranda) != 0;
-  }
-
-  bool IsNative() const {
-    return (GetAccessFlags() & kAccNative) != 0;
-  }
-
-  bool IsAbstract() const {
-    return (GetAccessFlags() & kAccAbstract) != 0;
-  }
-
-  bool IsSynthetic() const {
-    return (GetAccessFlags() & kAccSynthetic) != 0;
-  }
-
-  bool IsProxyMethod() const;
-
-  bool IsPreverified() const {
-    return (GetAccessFlags() & kAccPreverified) != 0;
-  }
-
-  void SetPreverified() {
-    SetAccessFlags(GetAccessFlags() | kAccPreverified);
-  }
-
-  bool CheckIncompatibleClassChange(InvokeType type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  uint16_t GetMethodIndex() const;
-
-  size_t GetVtableIndex() const {
-    return GetMethodIndex();
-  }
-
-  void SetMethodIndex(uint16_t new_method_index) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_), new_method_index, false);
-  }
-
-  static MemberOffset MethodIndexOffset() {
-    return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_);
-  }
-
-  uint32_t GetCodeItemOffset() const {
-    return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_item_offset_), false);
-  }
-
-  void SetCodeItemOffset(uint32_t new_code_off) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_item_offset_), new_code_off, false);
-  }
-
-  // Number of 32bit registers that would be required to hold all the arguments
-  static size_t NumArgRegisters(const StringPiece& shorty);
-
-  uint32_t GetDexMethodIndex() const;
-
-  void SetDexMethodIndex(uint32_t new_idx) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_dex_index_), new_idx, false);
-  }
-
-  ObjectArray<String>* GetDexCacheStrings() const;
-  void SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  static MemberOffset DexCacheStringsOffset() {
-    return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_);
-  }
-
-  static MemberOffset DexCacheResolvedMethodsOffset() {
-    return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_methods_);
-  }
-
-  static MemberOffset DexCacheResolvedTypesOffset() {
-    return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_types_);
-  }
-
-  static MemberOffset DexCacheInitializedStaticStorageOffset() {
-    return OFFSET_OF_OBJECT_MEMBER(AbstractMethod,
-        dex_cache_initialized_static_storage_);
-  }
-
-  ObjectArray<AbstractMethod>* GetDexCacheResolvedMethods() const;
-  void SetDexCacheResolvedMethods(ObjectArray<AbstractMethod>* new_dex_cache_methods)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  ObjectArray<Class>* GetDexCacheResolvedTypes() const;
-  void SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_types)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  ObjectArray<StaticStorageBase>* GetDexCacheInitializedStaticStorage() const;
-  void SetDexCacheInitializedStaticStorage(ObjectArray<StaticStorageBase>* new_value)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  // Find the method that this method overrides
-  AbstractMethod* FindOverriddenMethod() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  void Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result, char result_type)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  EntryPointFromInterpreter* GetEntryPointFromInterpreter() const {
-    return GetFieldPtr<EntryPointFromInterpreter*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, entry_point_from_interpreter_), false);
-  }
-
-  void SetEntryPointFromInterpreter(EntryPointFromInterpreter* entry_point_from_interpreter) {
-    SetFieldPtr<EntryPointFromInterpreter*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, entry_point_from_interpreter_), entry_point_from_interpreter, false);
-  }
-
-  const void* GetEntryPointFromCompiledCode() const {
-    return GetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, entry_point_from_compiled_code_), false);
-  }
-
-  void SetEntryPointFromCompiledCode(const void* entry_point_from_compiled_code) {
-    SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, entry_point_from_compiled_code_), entry_point_from_compiled_code, false);
-  }
-
-  uint32_t GetCodeSize() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  bool IsWithinCode(uintptr_t pc) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    uintptr_t code = reinterpret_cast<uintptr_t>(GetEntryPointFromCompiledCode());
-    if (code == 0) {
-      return pc == 0;
-    }
-    /*
-     * During a stack walk, a return PC may point to the end of the code + 1
-     * (in the case that the last instruction is a call that isn't expected to
-     * return.  Thus, we check <= code + GetCodeSize().
-     */
-    return (code <= pc && pc <= code + GetCodeSize());
-  }
-
-  void AssertPcIsWithinCode(uintptr_t pc) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  uint32_t GetOatCodeOffset() const;
-
-  void SetOatCodeOffset(uint32_t code_offset);
-
-  static MemberOffset GetEntryPointFromCompiledCodeOffset() {
-    return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, entry_point_from_compiled_code_);
-  }
-
-  // Callers should wrap the uint8_t* in a MappingTable instance for convenient access.
-  const uint8_t* GetMappingTable() const {
-    return GetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, mapping_table_), false);
-  }
-
-  void SetMappingTable(const uint8_t* mapping_table) {
-    SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, mapping_table_),
-                                 mapping_table, false);
-  }
-
-  uint32_t GetOatMappingTableOffset() const;
-
-  void SetOatMappingTableOffset(uint32_t mapping_table_offset);
-
-  // Callers should wrap the uint8_t* in a VmapTable instance for convenient access.
-  const uint8_t* GetVmapTable() const {
-    return GetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, vmap_table_), false);
-  }
-
-  void SetVmapTable(const uint8_t* vmap_table) {
-    SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, vmap_table_), vmap_table, false);
-  }
-
-  uint32_t GetOatVmapTableOffset() const;
-
-  void SetOatVmapTableOffset(uint32_t vmap_table_offset);
-
-  const uint8_t* GetNativeGcMap() const {
-    return GetFieldPtr<uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, gc_map_), false);
-  }
-  void SetNativeGcMap(const uint8_t* data) {
-    SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, gc_map_), data, false);
-  }
-
-  // When building the oat need a convenient place to stuff the offset of the native GC map.
-  void SetOatNativeGcMapOffset(uint32_t gc_map_offset);
-  uint32_t GetOatNativeGcMapOffset() const;
-
-  size_t GetFrameSizeInBytes() const {
-    DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
-    size_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, frame_size_in_bytes_), false);
-    DCHECK_LE(static_cast<size_t>(kStackAlignment), result);
-    return result;
-  }
-
-  void SetFrameSizeInBytes(size_t new_frame_size_in_bytes) {
-    DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
-    SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, frame_size_in_bytes_),
-               new_frame_size_in_bytes, false);
-  }
-
-  size_t GetReturnPcOffsetInBytes() const {
-    return GetFrameSizeInBytes() - kPointerSize;
-  }
-
-  size_t GetSirtOffsetInBytes() const {
-    CHECK(IsNative());
-    return kPointerSize;
-  }
-
-  bool IsRegistered() const;
-
-  void RegisterNative(Thread* self, const void* native_method)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  void UnregisterNative(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  static MemberOffset NativeMethodOffset() {
-    return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_method_);
-  }
-
-  const void* GetNativeMethod() const {
-    return reinterpret_cast<const void*>(GetField32(NativeMethodOffset(), false));
-  }
-
-  void SetNativeMethod(const void*);
-
-  static MemberOffset GetMethodIndexOffset() {
-    return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_);
-  }
-
-  uint32_t GetCoreSpillMask() const {
-    return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, core_spill_mask_), false);
-  }
-
-  void SetCoreSpillMask(uint32_t core_spill_mask) {
-    // Computed during compilation
-    SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, core_spill_mask_), core_spill_mask, false);
-  }
-
-  uint32_t GetFpSpillMask() const {
-    return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, fp_spill_mask_), false);
-  }
-
-  void SetFpSpillMask(uint32_t fp_spill_mask) {
-    // Computed during compilation
-    SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, fp_spill_mask_), fp_spill_mask, false);
-  }
-
-  // Is this a CalleSaveMethod or ResolutionMethod and therefore doesn't adhere to normal
-  // conventions for a method of managed code. Returns false for Proxy methods.
-  bool IsRuntimeMethod() const;
-
-  // Is this a hand crafted method used for something like describing callee saves?
-  bool IsCalleeSaveMethod() const;
-
-  bool IsResolutionMethod() const;
-
-  uintptr_t NativePcOffset(const uintptr_t pc) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  // Converts a native PC to a dex PC.
-  uint32_t ToDexPc(const uintptr_t pc) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  // Converts a dex PC to a native PC.
-  uintptr_t ToNativePc(const uint32_t dex_pc) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  // Find the catch block for the given exception type and dex_pc. When a catch block is found,
-  // indicates whether the found catch block is responsible for clearing the exception or whether
-  // a move-exception instruction is present.
-  uint32_t FindCatchBlock(Class* exception_type, uint32_t dex_pc, bool* has_no_move_exception) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  static void SetClasses(Class* java_lang_reflect_Constructor, Class* java_lang_reflect_Method);
-
-  static Class* GetConstructorClass() {
-    return java_lang_reflect_Constructor_;
-  }
-
-  static Class* GetMethodClass() {
-    return java_lang_reflect_Method_;
-  }
-
-  static void ResetClasses();
-
- protected:
-  // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
-  // The class we are a part of
-  Class* declaring_class_;
-
-  // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
-  ObjectArray<StaticStorageBase>* dex_cache_initialized_static_storage_;
-
-  // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
-  ObjectArray<AbstractMethod>* dex_cache_resolved_methods_;
-
-  // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
-  ObjectArray<Class>* dex_cache_resolved_types_;
-
-  // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
-  ObjectArray<String>* dex_cache_strings_;
-
-  // Access flags; low 16 bits are defined by spec.
-  uint32_t access_flags_;
-
-  // Offset to the CodeItem.
-  uint32_t code_item_offset_;
-
-  // Architecture-dependent register spill mask
-  uint32_t core_spill_mask_;
-
-  // Compiled code associated with this method for callers from managed code.
-  // May be compiled managed code or a bridge for invoking a native method.
-  // TODO: Break apart this into portable and quick.
-  const void* entry_point_from_compiled_code_;
-
-  // Called by the interpreter to execute this method.
-  EntryPointFromInterpreter* entry_point_from_interpreter_;
-
-  // Architecture-dependent register spill mask
-  uint32_t fp_spill_mask_;
-
-  // Total size in bytes of the frame
-  size_t frame_size_in_bytes_;
-
-  // Garbage collection map of native PC offsets (quick) or dex PCs (portable) to reference bitmaps.
-  const uint8_t* gc_map_;
-
-  // Mapping from native pc to dex pc
-  const uint32_t* mapping_table_;
-
-  // Index into method_ids of the dex file associated with this method
-  uint32_t method_dex_index_;
-
-  // For concrete virtual methods, this is the offset of the method in Class::vtable_.
-  //
-  // For abstract methods in an interface class, this is the offset of the method in
-  // "iftable_->Get(n)->GetMethodArray()".
-  //
-  // For static and direct methods this is the index in the direct methods table.
-  uint32_t method_index_;
-
-  // The target native method registered with this method
-  const void* native_method_;
-
-  // When a register is promoted into a register, the spill mask holds which registers hold dex
-  // registers. The first promoted register's corresponding dex register is vmap_table_[1], the Nth
-  // is vmap_table_[N]. vmap_table_[0] holds the length of the table.
-  const uint16_t* vmap_table_;
-
-  static Class* java_lang_reflect_Constructor_;
-  static Class* java_lang_reflect_Method_;
-
-  friend struct art::AbstractMethodOffsets;  // for verifying offset information
-  friend struct art::ConstructorMethodOffsets;  // for verifying offset information
-  friend struct art::MethodOffsets;  // for verifying offset information
-  DISALLOW_IMPLICIT_CONSTRUCTORS(AbstractMethod);
-};
-
-class MANAGED Method : public AbstractMethod {};
-
-class MANAGED Constructor : public AbstractMethod {};
-
-class MANAGED AbstractMethodClass : public Class {
- private:
-  Object* ORDER_BY_SIGNATURE_;
-  friend struct art::MethodClassOffsets;  // for verifying offset information
-  DISALLOW_IMPLICIT_CONSTRUCTORS(AbstractMethodClass);
-};
-
-}  // namespace mirror
-}  // namespace art
-
-#endif  // ART_RUNTIME_MIRROR_ABSTRACT_METHOD_H_
diff --git a/runtime/mirror/art_field-inl.h b/runtime/mirror/art_field-inl.h
new file mode 100644
index 0000000000..d8c278c9ac
--- /dev/null
+++ b/runtime/mirror/art_field-inl.h
@@ -0,0 +1,221 @@
+/*
+ * Copyright (C) 2011 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_RUNTIME_MIRROR_ART_FIELD_INL_H_
+#define ART_RUNTIME_MIRROR_ART_FIELD_INL_H_
+
+#include "art_field.h"
+
+#include "base/logging.h"
+#include "gc/accounting/card_table-inl.h"
+#include "jvalue.h"
+#include "object-inl.h"
+#include "object_utils.h"
+#include "primitive.h"
+
+namespace art {
+namespace mirror {
+
+inline Class* ArtField::GetDeclaringClass() const {
+  Class* result = GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(ArtField, declaring_class_), false);
+  DCHECK(result != NULL);
+  DCHECK(result->IsLoaded() || result->IsErroneous());
+  return result;
+}
+
+inline void ArtField::SetDeclaringClass(Class *new_declaring_class) {
+  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(ArtField, declaring_class_), new_declaring_class, false);
+}
+
+inline uint32_t ArtField::GetAccessFlags() const {
+  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
+  return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtField, access_flags_), false);
+}
+
+inline MemberOffset ArtField::GetOffset() const {
+  DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
+  return MemberOffset(GetField32(OFFSET_OF_OBJECT_MEMBER(ArtField, offset_), false));
+}
+
+inline MemberOffset ArtField::GetOffsetDuringLinking() const {
+  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
+  return MemberOffset(GetField32(OFFSET_OF_OBJECT_MEMBER(ArtField, offset_), false));
+}
+
+inline uint32_t ArtField::Get32(const Object* object) const {
+  DCHECK(object != NULL) << PrettyField(this);
+  DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
+  return object->GetField32(GetOffset(), IsVolatile());
+}
+
+inline void ArtField::Set32(Object* object, uint32_t new_value) const {
+  DCHECK(object != NULL) << PrettyField(this);
+  DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
+  object->SetField32(GetOffset(), new_value, IsVolatile());
+}
+
+inline uint64_t ArtField::Get64(const Object* object) const {
+  DCHECK(object != NULL) << PrettyField(this);
+  DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
+  return object->GetField64(GetOffset(), IsVolatile());
+}
+
+inline void ArtField::Set64(Object* object, uint64_t new_value) const {
+  DCHECK(object != NULL) << PrettyField(this);
+  DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
+  object->SetField64(GetOffset(), new_value, IsVolatile());
+}
+
+inline Object* ArtField::GetObj(const Object* object) const {
+  DCHECK(object != NULL) << PrettyField(this);
+  DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
+  return object->GetFieldObject<Object*>(GetOffset(), IsVolatile());
+}
+
+inline void ArtField::SetObj(Object* object, const Object* new_value) const {
+  DCHECK(object != NULL) << PrettyField(this);
+  DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
+  object->SetFieldObject(GetOffset(), new_value, IsVolatile());
+}
+
+inline bool ArtField::GetBoolean(const Object* object) const {
+  DCHECK_EQ(Primitive::kPrimBoolean, FieldHelper(this).GetTypeAsPrimitiveType())
+      << PrettyField(this);
+  return Get32(object);
+}
+
+inline void ArtField::SetBoolean(Object* object, bool z) const {
+  DCHECK_EQ(Primitive::kPrimBoolean, FieldHelper(this).GetTypeAsPrimitiveType())
+      << PrettyField(this);
+  Set32(object, z);
+}
+
+inline int8_t ArtField::GetByte(const Object* object) const {
+  DCHECK_EQ(Primitive::kPrimByte, FieldHelper(this).GetTypeAsPrimitiveType())
+      << PrettyField(this);
+  return Get32(object);
+}
+
+inline void ArtField::SetByte(Object* object, int8_t b) const {
+  DCHECK_EQ(Primitive::kPrimByte, FieldHelper(this).GetTypeAsPrimitiveType())
+      << PrettyField(this);
+  Set32(object, b);
+}
+
+inline uint16_t ArtField::GetChar(const Object* object) const {
+  DCHECK_EQ(Primitive::kPrimChar, FieldHelper(this).GetTypeAsPrimitiveType())
+      << PrettyField(this);
+  return Get32(object);
+}
+
+inline void ArtField::SetChar(Object* object, uint16_t c) const {
+  DCHECK_EQ(Primitive::kPrimChar, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
+  Set32(object, c);
+}
+
+inline int16_t ArtField::GetShort(const Object* object) const {
+  DCHECK_EQ(Primitive::kPrimShort, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
+  return Get32(object);
+}
+
+inline void ArtField::SetShort(Object* object, int16_t s) const {
+  DCHECK_EQ(Primitive::kPrimShort, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
+  Set32(object, s);
+}
+
+inline int32_t ArtField::GetInt(const Object* object) const {
+#ifndef NDEBUG
+  Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
+  CHECK(type == Primitive::kPrimInt || type == Primitive::kPrimFloat) << PrettyField(this);
+#endif
+  return Get32(object);
+}
+
+inline void ArtField::SetInt(Object* object, int32_t i) const {
+#ifndef NDEBUG
+  Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
+  CHECK(type == Primitive::kPrimInt || type == Primitive::kPrimFloat) << PrettyField(this);
+#endif
+  Set32(object, i);
+}
+
+inline int64_t ArtField::GetLong(const Object* object) const {
+#ifndef NDEBUG
+  Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
+  CHECK(type == Primitive::kPrimLong || type == Primitive::kPrimDouble) << PrettyField(this);
+#endif
+  return Get64(object);
+}
+
+inline void ArtField::SetLong(Object* object, int64_t j) const {
+#ifndef NDEBUG
+  Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
+  CHECK(type == Primitive::kPrimLong || type == Primitive::kPrimDouble) << PrettyField(this);
+#endif
+  Set64(object, j);
+}
+
+inline float ArtField::GetFloat(const Object* object) const {
+  DCHECK_EQ(Primitive::kPrimFloat, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
+  JValue bits;
+  bits.SetI(Get32(object));
+  return bits.GetF();
+}
+
+inline void ArtField::SetFloat(Object* object, float f) const {
+  DCHECK_EQ(Primitive::kPrimFloat, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
+  JValue bits;
+  bits.SetF(f);
+  Set32(object, bits.GetI());
+}
+
+inline double ArtField::GetDouble(const Object* object) const {
+  DCHECK_EQ(Primitive::kPrimDouble, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
+  JValue bits;
+  bits.SetJ(Get64(object));
+  return bits.GetD();
+}
+
+inline void ArtField::SetDouble(Object* object, double d) const {
+  DCHECK_EQ(Primitive::kPrimDouble, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
+  JValue bits;
+  bits.SetD(d);
+  Set64(object, bits.GetJ());
+}
+
+inline Object* ArtField::GetObject(const Object* object) const {
+  DCHECK_EQ(Primitive::kPrimNot, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
+  return GetObj(object);
+}
+
+inline void ArtField::SetObject(Object* object, const Object* l) const {
+  DCHECK_EQ(Primitive::kPrimNot, FieldHelper(this).GetTypeAsPrimitiveType())
+       << PrettyField(this);
+  SetObj(object, l);
+}
+
+}  // namespace mirror
+}  // namespace art
+
+#endif  // ART_RUNTIME_MIRROR_ART_FIELD_INL_H_
diff --git a/runtime/mirror/art_field.cc b/runtime/mirror/art_field.cc
new file mode 100644
index 0000000000..a8bbe4bc6a
--- /dev/null
+++ b/runtime/mirror/art_field.cc
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "art_field.h"
+
+#include "art_field-inl.h"
+#include "gc/accounting/card_table-inl.h"
+#include "object-inl.h"
+#include "object_utils.h"
+#include "runtime.h"
+#include "utils.h"
+
+namespace art {
+namespace mirror {
+
+// TODO: get global references for these
+Class* ArtField::java_lang_reflect_ArtField_ = NULL;
+
+void ArtField::SetClass(Class* java_lang_reflect_ArtField) {
+  CHECK(java_lang_reflect_ArtField_ == NULL);
+  CHECK(java_lang_reflect_ArtField != NULL);
+  java_lang_reflect_ArtField_ = java_lang_reflect_ArtField;
+}
+
+void ArtField::ResetClass() {
+  CHECK(java_lang_reflect_ArtField_ != NULL);
+  java_lang_reflect_ArtField_ = NULL;
+}
+
+void ArtField::SetOffset(MemberOffset num_bytes) {
+  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
+#if 0  // TODO enable later in boot and under !NDEBUG
+  FieldHelper fh(this);
+  Primitive::Type type = fh.GetTypeAsPrimitiveType();
+  if (type == Primitive::kPrimDouble || type == Primitive::kPrimLong) {
+    DCHECK_ALIGNED(num_bytes.Uint32Value(), 8);
+  }
+#endif
+  SetField32(OFFSET_OF_OBJECT_MEMBER(ArtField, offset_), num_bytes.Uint32Value(), false);
+}
+
+}  // namespace mirror
+}  // namespace art
diff --git a/runtime/mirror/art_field.h b/runtime/mirror/art_field.h
new file mode 100644
index 0000000000..ae34cb1f84
--- /dev/null
+++ b/runtime/mirror/art_field.h
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2011 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_RUNTIME_MIRROR_ART_FIELD_H_
+#define ART_RUNTIME_MIRROR_ART_FIELD_H_
+
+#include "class.h"
+#include "modifiers.h"
+#include "object.h"
+
+namespace art {
+
+struct ArtFieldOffsets;
+
+namespace mirror {
+
+// C++ mirror of java.lang.reflect.ArtField
+class MANAGED ArtField : public Object {
+ public:
+  Class* GetDeclaringClass() const;
+
+  void SetDeclaringClass(Class *new_declaring_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  uint32_t GetAccessFlags() const;
+
+  void SetAccessFlags(uint32_t new_access_flags) {
+    SetField32(OFFSET_OF_OBJECT_MEMBER(ArtField, access_flags_), new_access_flags, false);
+  }
+
+  bool IsPublic() const {
+    return (GetAccessFlags() & kAccPublic) != 0;
+  }
+
+  bool IsStatic() const {
+    return (GetAccessFlags() & kAccStatic) != 0;
+  }
+
+  bool IsFinal() const {
+    return (GetAccessFlags() & kAccFinal) != 0;
+  }
+
+  uint32_t GetDexFieldIndex() const {
+    return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtField, field_dex_idx_), false);
+  }
+
+  void SetDexFieldIndex(uint32_t new_idx) {
+    SetField32(OFFSET_OF_OBJECT_MEMBER(ArtField, field_dex_idx_), new_idx, false);
+  }
+
+  // Offset to field within an Object
+  MemberOffset GetOffset() const;
+
+  static MemberOffset OffsetOffset() {
+    return MemberOffset(OFFSETOF_MEMBER(ArtField, offset_));
+  }
+
+  MemberOffset GetOffsetDuringLinking() const;
+
+  void SetOffset(MemberOffset num_bytes);
+
+  // field access, null object for static fields
+  bool GetBoolean(const Object* object) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetBoolean(Object* object, bool z) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  int8_t GetByte(const Object* object) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetByte(Object* object, int8_t b) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  uint16_t GetChar(const Object* object) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetChar(Object* object, uint16_t c) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  int16_t GetShort(const Object* object) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetShort(Object* object, int16_t s) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  int32_t GetInt(const Object* object) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetInt(Object* object, int32_t i) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  int64_t GetLong(const Object* object) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetLong(Object* object, int64_t j) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  float GetFloat(const Object* object) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetFloat(Object* object, float f) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  double GetDouble(const Object* object) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetDouble(Object* object, double d) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  Object* GetObject(const Object* object) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetObject(Object* object, const Object* l) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  // raw field accesses
+  uint32_t Get32(const Object* object) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void Set32(Object* object, uint32_t new_value) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  uint64_t Get64(const Object* object) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void Set64(Object* object, uint64_t new_value) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  Object* GetObj(const Object* object) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetObj(Object* object, const Object* new_value) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  static Class* GetJavaLangReflectArtField() {
+    DCHECK(java_lang_reflect_ArtField_ != NULL);
+    return java_lang_reflect_ArtField_;
+  }
+
+  static void SetClass(Class* java_lang_reflect_ArtField);
+  static void ResetClass();
+
+  bool IsVolatile() const {
+    return (GetAccessFlags() & kAccVolatile) != 0;
+  }
+
+ private:
+  // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
+  // The class we are a part of
+  Class* declaring_class_;
+
+  uint32_t access_flags_;
+
+  // Dex cache index of field id
+  uint32_t field_dex_idx_;
+
+  // Offset of field within an instance or in the Class' static fields
+  uint32_t offset_;
+
+  static Class* java_lang_reflect_ArtField_;
+
+  friend struct art::ArtFieldOffsets;  // for verifying offset information
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ArtField);
+};
+
+class MANAGED ArtFieldClass : public Class {
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ArtFieldClass);
+};
+
+}  // namespace mirror
+}  // namespace art
+
+#endif  // ART_RUNTIME_MIRROR_ART_FIELD_H_
diff --git a/runtime/mirror/art_method-inl.h b/runtime/mirror/art_method-inl.h
new file mode 100644
index 0000000000..4d8aa6f741
--- /dev/null
+++ b/runtime/mirror/art_method-inl.h
@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2011 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_RUNTIME_MIRROR_ART_METHOD_INL_H_
+#define ART_RUNTIME_MIRROR_ART_METHOD_INL_H_
+
+#include "art_method.h"
+
+#include "dex_file.h"
+#include "entrypoints/entrypoint_utils.h"
+#include "object_array.h"
+#include "runtime.h"
+
+namespace art {
+namespace mirror {
+
+inline Class* ArtMethod::GetDeclaringClass() const {
+  Class* result = GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, declaring_class_), false);
+  DCHECK(result != NULL) << this;
+  DCHECK(result->IsIdxLoaded() || result->IsErroneous()) << this;
+  return result;
+}
+
+inline void ArtMethod::SetDeclaringClass(Class *new_declaring_class) {
+  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(ArtMethod, declaring_class_), new_declaring_class, false);
+}
+
+inline uint32_t ArtMethod::GetAccessFlags() const {
+  DCHECK(GetDeclaringClass()->IsIdxLoaded() || GetDeclaringClass()->IsErroneous());
+  return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, access_flags_), false);
+}
+
+inline uint16_t ArtMethod::GetMethodIndex() const {
+  DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
+  return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_), false);
+}
+
+inline uint32_t ArtMethod::GetDexMethodIndex() const {
+  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
+  return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_dex_index_), false);
+}
+
+inline ObjectArray<String>* ArtMethod::GetDexCacheStrings() const {
+  return GetFieldObject<ObjectArray<String>*>(
+      OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_strings_), false);
+}
+
+inline ObjectArray<ArtMethod>* ArtMethod::GetDexCacheResolvedMethods() const {
+  return GetFieldObject<ObjectArray<ArtMethod>*>(
+      OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_methods_), false);
+}
+
+inline ObjectArray<Class>* ArtMethod::GetDexCacheResolvedTypes() const {
+  return GetFieldObject<ObjectArray<Class>*>(
+      OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_types_), false);
+}
+
+inline ObjectArray<StaticStorageBase>* ArtMethod::GetDexCacheInitializedStaticStorage() const {
+  return GetFieldObject<ObjectArray<StaticStorageBase>*>(
+      OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_initialized_static_storage_),
+      false);
+}
+
+inline uint32_t ArtMethod::GetCodeSize() const {
+  DCHECK(!IsRuntimeMethod() && !IsProxyMethod()) << PrettyMethod(this);
+  uintptr_t code = reinterpret_cast<uintptr_t>(GetEntryPointFromCompiledCode());
+  if (code == 0) {
+    return 0;
+  }
+  // TODO: make this Thumb2 specific
+  code &= ~0x1;
+  return reinterpret_cast<uint32_t*>(code)[-1];
+}
+
+inline bool ArtMethod::CheckIncompatibleClassChange(InvokeType type) {
+  switch (type) {
+    case kStatic:
+      return !IsStatic();
+    case kDirect:
+      return !IsDirect() || IsStatic();
+    case kVirtual: {
+      Class* methods_class = GetDeclaringClass();
+      return IsDirect() || (methods_class->IsInterface() && !IsMiranda());
+    }
+    case kSuper:
+      return false;  // TODO: appropriate checks for call to super class.
+    case kInterface: {
+      Class* methods_class = GetDeclaringClass();
+      return IsDirect() || !(methods_class->IsInterface() || methods_class->IsObjectClass());
+    }
+    default:
+      LOG(FATAL) << "Unreachable - invocation type: " << type;
+      return true;
+  }
+}
+
+inline void ArtMethod::AssertPcIsWithinCode(uintptr_t pc) const {
+  if (!kIsDebugBuild) {
+    return;
+  }
+  if (IsNative() || IsRuntimeMethod() || IsProxyMethod()) {
+    return;
+  }
+  if (pc == GetQuickInstrumentationExitPc()) {
+    return;
+  }
+  const void* code = GetEntryPointFromCompiledCode();
+  if (code == GetCompiledCodeToInterpreterBridge() || code == GetQuickInstrumentationEntryPoint()) {
+    return;
+  }
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  if (code == GetResolutionTrampoline(class_linker)) {
+    return;
+  }
+  DCHECK(IsWithinCode(pc))
+      << PrettyMethod(this)
+      << " pc=" << std::hex << pc
+      << " code=" << code
+      << " size=" << GetCodeSize();
+}
+
+inline uint32_t ArtMethod::GetOatCodeOffset() const {
+  DCHECK(!Runtime::Current()->IsStarted());
+  return reinterpret_cast<uint32_t>(GetEntryPointFromCompiledCode());
+}
+
+inline void ArtMethod::SetOatCodeOffset(uint32_t code_offset) {
+  DCHECK(!Runtime::Current()->IsStarted());
+  SetEntryPointFromCompiledCode(reinterpret_cast<void*>(code_offset));
+}
+
+inline uint32_t ArtMethod::GetOatMappingTableOffset() const {
+  DCHECK(!Runtime::Current()->IsStarted());
+  return reinterpret_cast<uint32_t>(GetMappingTable());
+}
+
+inline void ArtMethod::SetOatMappingTableOffset(uint32_t mapping_table_offset) {
+  DCHECK(!Runtime::Current()->IsStarted());
+  SetMappingTable(reinterpret_cast<const uint8_t*>(mapping_table_offset));
+}
+
+inline uint32_t ArtMethod::GetOatVmapTableOffset() const {
+  DCHECK(!Runtime::Current()->IsStarted());
+  return reinterpret_cast<uint32_t>(GetVmapTable());
+}
+
+inline void ArtMethod::SetOatVmapTableOffset(uint32_t vmap_table_offset) {
+  DCHECK(!Runtime::Current()->IsStarted());
+  SetVmapTable(reinterpret_cast<uint8_t*>(vmap_table_offset));
+}
+
+inline void ArtMethod::SetOatNativeGcMapOffset(uint32_t gc_map_offset) {
+  DCHECK(!Runtime::Current()->IsStarted());
+  SetNativeGcMap(reinterpret_cast<uint8_t*>(gc_map_offset));
+}
+
+inline uint32_t ArtMethod::GetOatNativeGcMapOffset() const {
+  DCHECK(!Runtime::Current()->IsStarted());
+  return reinterpret_cast<uint32_t>(GetNativeGcMap());
+}
+
+inline bool ArtMethod::IsRuntimeMethod() const {
+  return GetDexMethodIndex() == DexFile::kDexNoIndex16;
+}
+
+inline bool ArtMethod::IsCalleeSaveMethod() const {
+  if (!IsRuntimeMethod()) {
+    return false;
+  }
+  Runtime* runtime = Runtime::Current();
+  bool result = false;
+  for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
+    if (this == runtime->GetCalleeSaveMethod(Runtime::CalleeSaveType(i))) {
+      result = true;
+      break;
+    }
+  }
+  return result;
+}
+
+inline bool ArtMethod::IsResolutionMethod() const {
+  bool result = this == Runtime::Current()->GetResolutionMethod();
+  // Check that if we do think it is phony it looks like the resolution method.
+  DCHECK(!result || IsRuntimeMethod());
+  return result;
+}
+}  // namespace mirror
+}  // namespace art
+
+#endif  // ART_RUNTIME_MIRROR_ART_METHOD_INL_H_
diff --git a/runtime/mirror/art_method.cc b/runtime/mirror/art_method.cc
new file mode 100644
index 0000000000..cd05f41cc2
--- /dev/null
+++ b/runtime/mirror/art_method.cc
@@ -0,0 +1,342 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "art_method.h"
+
+#include "art_method-inl.h"
+#include "base/stringpiece.h"
+#include "class-inl.h"
+#include "dex_file-inl.h"
+#include "dex_instruction.h"
+#include "gc/accounting/card_table-inl.h"
+#include "interpreter/interpreter.h"
+#include "jni_internal.h"
+#include "mapping_table.h"
+#include "object-inl.h"
+#include "object_array.h"
+#include "object_array-inl.h"
+#include "string.h"
+#include "object_utils.h"
+
+namespace art {
+namespace mirror {
+
+extern "C" void art_portable_invoke_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*, char);
+extern "C" void art_quick_invoke_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*, char);
+
+// TODO: get global references for these
+Class* ArtMethod::java_lang_reflect_ArtMethod_ = NULL;
+
+InvokeType ArtMethod::GetInvokeType() const {
+  // TODO: kSuper?
+  if (GetDeclaringClass()->IsInterface()) {
+    return kInterface;
+  } else if (IsStatic()) {
+    return kStatic;
+  } else if (IsDirect()) {
+    return kDirect;
+  } else {
+    return kVirtual;
+  }
+}
+
+void ArtMethod::SetClass(Class* java_lang_reflect_ArtMethod) {
+  CHECK(java_lang_reflect_ArtMethod_ == NULL);
+  CHECK(java_lang_reflect_ArtMethod != NULL);
+  java_lang_reflect_ArtMethod_ = java_lang_reflect_ArtMethod;
+}
+
+void ArtMethod::ResetClass() {
+  CHECK(java_lang_reflect_ArtMethod_ != NULL);
+  java_lang_reflect_ArtMethod_ = NULL;
+}
+
+void ArtMethod::SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings) {
+  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_strings_),
+                 new_dex_cache_strings, false);
+}
+
+void ArtMethod::SetDexCacheResolvedMethods(ObjectArray<ArtMethod>* new_dex_cache_methods) {
+  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_methods_),
+                 new_dex_cache_methods, false);
+}
+
+void ArtMethod::SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_classes) {
+  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_types_),
+                 new_dex_cache_classes, false);
+}
+
+void ArtMethod::SetDexCacheInitializedStaticStorage(ObjectArray<StaticStorageBase>* new_value) {
+  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_initialized_static_storage_),
+      new_value, false);
+}
+
+size_t ArtMethod::NumArgRegisters(const StringPiece& shorty) {
+  CHECK_LE(1, shorty.length());
+  uint32_t num_registers = 0;
+  for (int i = 1; i < shorty.length(); ++i) {
+    char ch = shorty[i];
+    if (ch == 'D' || ch == 'J') {
+      num_registers += 2;
+    } else {
+      num_registers += 1;
+    }
+  }
+  return num_registers;
+}
+
+bool ArtMethod::IsProxyMethod() const {
+  return GetDeclaringClass()->IsProxyClass();
+}
+
+ArtMethod* ArtMethod::FindOverriddenMethod() const {
+  if (IsStatic()) {
+    return NULL;
+  }
+  Class* declaring_class = GetDeclaringClass();
+  Class* super_class = declaring_class->GetSuperClass();
+  uint16_t method_index = GetMethodIndex();
+  ObjectArray<ArtMethod>* super_class_vtable = super_class->GetVTable();
+  ArtMethod* result = NULL;
+  // Did this method override a super class method? If so load the result from the super class'
+  // vtable
+  if (super_class_vtable != NULL && method_index < super_class_vtable->GetLength()) {
+    result = super_class_vtable->Get(method_index);
+  } else {
+    // Method didn't override superclass method so search interfaces
+    if (IsProxyMethod()) {
+      result = GetDexCacheResolvedMethods()->Get(GetDexMethodIndex());
+      CHECK_EQ(result,
+               Runtime::Current()->GetClassLinker()->FindMethodForProxy(GetDeclaringClass(), this));
+    } else {
+      MethodHelper mh(this);
+      MethodHelper interface_mh;
+      IfTable* iftable = GetDeclaringClass()->GetIfTable();
+      for (size_t i = 0; i < iftable->Count() && result == NULL; i++) {
+        Class* interface = iftable->GetInterface(i);
+        for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
+          ArtMethod* interface_method = interface->GetVirtualMethod(j);
+          interface_mh.ChangeMethod(interface_method);
+          if (mh.HasSameNameAndSignature(&interface_mh)) {
+            result = interface_method;
+            break;
+          }
+        }
+      }
+    }
+  }
+#ifndef NDEBUG
+  MethodHelper result_mh(result);
+  DCHECK(result == NULL || MethodHelper(this).HasSameNameAndSignature(&result_mh));
+#endif
+  return result;
+}
+
+uintptr_t ArtMethod::NativePcOffset(const uintptr_t pc) const {
+  const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
+  return pc - reinterpret_cast<uintptr_t>(code);
+}
+
+uint32_t ArtMethod::ToDexPc(const uintptr_t pc) const {
+#if !defined(ART_USE_PORTABLE_COMPILER)
+  MappingTable table(GetMappingTable());
+  if (table.TotalSize() == 0) {
+    DCHECK(IsNative() || IsCalleeSaveMethod() || IsProxyMethod()) << PrettyMethod(this);
+    return DexFile::kDexNoIndex;   // Special no mapping case
+  }
+  const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
+  uint32_t sought_offset = pc - reinterpret_cast<uintptr_t>(code);
+  // Assume the caller wants a pc-to-dex mapping so check here first.
+  typedef MappingTable::PcToDexIterator It;
+  for (It cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
+    if (cur.NativePcOffset() == sought_offset) {
+      return cur.DexPc();
+    }
+  }
+  // Now check dex-to-pc mappings.
+  typedef MappingTable::DexToPcIterator It2;
+  for (It2 cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
+    if (cur.NativePcOffset() == sought_offset) {
+      return cur.DexPc();
+    }
+  }
+  LOG(FATAL) << "Failed to find Dex offset for PC offset " << reinterpret_cast<void*>(sought_offset)
+             << "(PC " << reinterpret_cast<void*>(pc) << ", code=" << code
+             << ") in " << PrettyMethod(this);
+  return DexFile::kDexNoIndex;
+#else
+  // Compiler LLVM doesn't use the machine pc, we just use dex pc instead.
+  return static_cast<uint32_t>(pc);
+#endif
+}
+
+uintptr_t ArtMethod::ToNativePc(const uint32_t dex_pc) const {
+  MappingTable table(GetMappingTable());
+  if (table.TotalSize() == 0) {
+    DCHECK_EQ(dex_pc, 0U);
+    return 0;   // Special no mapping/pc == 0 case
+  }
+  // Assume the caller wants a dex-to-pc mapping so check here first.
+  typedef MappingTable::DexToPcIterator It;
+  for (It cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
+    if (cur.DexPc() == dex_pc) {
+      const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
+      return reinterpret_cast<uintptr_t>(code) + cur.NativePcOffset();
+    }
+  }
+  // Now check pc-to-dex mappings.
+  typedef MappingTable::PcToDexIterator It2;
+  for (It2 cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
+    if (cur.DexPc() == dex_pc) {
+      const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
+      return reinterpret_cast<uintptr_t>(code) + cur.NativePcOffset();
+    }
+  }
+  LOG(FATAL) << "Failed to find native offset for dex pc 0x" << std::hex << dex_pc
+             << " in " << PrettyMethod(this);
+  return 0;
+}
+
+uint32_t ArtMethod::FindCatchBlock(Class* exception_type, uint32_t dex_pc,
+                                   bool* has_no_move_exception) const {
+  MethodHelper mh(this);
+  const DexFile::CodeItem* code_item = mh.GetCodeItem();
+  // Default to handler not found.
+  uint32_t found_dex_pc = DexFile::kDexNoIndex;
+  // Iterate over the catch handlers associated with dex_pc.
+  for (CatchHandlerIterator it(*code_item, dex_pc); it.HasNext(); it.Next()) {
+    uint16_t iter_type_idx = it.GetHandlerTypeIndex();
+    // Catch all case
+    if (iter_type_idx == DexFile::kDexNoIndex16) {
+      found_dex_pc = it.GetHandlerAddress();
+      break;
+    }
+    // Does this catch exception type apply?
+    Class* iter_exception_type = mh.GetDexCacheResolvedType(iter_type_idx);
+    if (iter_exception_type == NULL) {
+      // The verifier should take care of resolving all exception classes early
+      LOG(WARNING) << "Unresolved exception class when finding catch block: "
+        << mh.GetTypeDescriptorFromTypeIdx(iter_type_idx);
+    } else if (iter_exception_type->IsAssignableFrom(exception_type)) {
+      found_dex_pc = it.GetHandlerAddress();
+      break;
+    }
+  }
+  if (found_dex_pc != DexFile::kDexNoIndex) {
+    const Instruction* first_catch_instr =
+        Instruction::At(&mh.GetCodeItem()->insns_[found_dex_pc]);
+    *has_no_move_exception = (first_catch_instr->Opcode() != Instruction::MOVE_EXCEPTION);
+  }
+  return found_dex_pc;
+}
+
+void ArtMethod::Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result,
+                       char result_type) {
+  if (kIsDebugBuild) {
+    self->AssertThreadSuspensionIsAllowable();
+    CHECK_EQ(kRunnable, self->GetState());
+  }
+
+  // Push a transition back into managed code onto the linked list in thread.
+  ManagedStack fragment;
+  self->PushManagedStackFragment(&fragment);
+
+  Runtime* runtime = Runtime::Current();
+  // Call the invoke stub, passing everything as arguments.
+  if (UNLIKELY(!runtime->IsStarted())) {
+    LOG(INFO) << "Not invoking " << PrettyMethod(this) << " for a runtime that isn't started";
+    if (result != NULL) {
+      result->SetJ(0);
+    }
+  } else {
+    const bool kLogInvocationStartAndReturn = false;
+    if (GetEntryPointFromCompiledCode() != NULL) {
+      if (kLogInvocationStartAndReturn) {
+        LOG(INFO) << StringPrintf("Invoking '%s' code=%p", PrettyMethod(this).c_str(), GetEntryPointFromCompiledCode());
+      }
+#ifdef ART_USE_PORTABLE_COMPILER
+      (*art_portable_invoke_stub)(this, args, args_size, self, result, result_type);
+#else
+      (*art_quick_invoke_stub)(this, args, args_size, self, result, result_type);
+#endif
+      if (UNLIKELY(reinterpret_cast<int32_t>(self->GetException(NULL)) == -1)) {
+        // Unusual case where we were running LLVM generated code and an
+        // exception was thrown to force the activations to be removed from the
+        // stack. Continue execution in the interpreter.
+        self->ClearException();
+        ShadowFrame* shadow_frame = self->GetAndClearDeoptimizationShadowFrame(result);
+        self->SetTopOfStack(NULL, 0);
+        self->SetTopOfShadowStack(shadow_frame);
+        interpreter::EnterInterpreterFromDeoptimize(self, shadow_frame, result);
+      }
+      if (kLogInvocationStartAndReturn) {
+        LOG(INFO) << StringPrintf("Returned '%s' code=%p", PrettyMethod(this).c_str(), GetEntryPointFromCompiledCode());
+      }
+    } else {
+      LOG(INFO) << "Not invoking '" << PrettyMethod(this)
+          << "' code=" << reinterpret_cast<const void*>(GetEntryPointFromCompiledCode());
+      if (result != NULL) {
+        result->SetJ(0);
+      }
+    }
+  }
+
+  // Pop transition.
+  self->PopManagedStackFragment(fragment);
+}
+
+bool ArtMethod::IsRegistered() const {
+  void* native_method = GetFieldPtr<void*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, native_method_), false);
+  CHECK(native_method != NULL);
+  void* jni_stub = GetJniDlsymLookupStub();
+  return native_method != jni_stub;
+}
+
+extern "C" void art_work_around_app_jni_bugs(JNIEnv*, jobject);
+void ArtMethod::RegisterNative(Thread* self, const void* native_method) {
+  DCHECK(Thread::Current() == self);
+  CHECK(IsNative()) << PrettyMethod(this);
+  CHECK(native_method != NULL) << PrettyMethod(this);
+  if (!self->GetJniEnv()->vm->work_around_app_jni_bugs) {
+    SetNativeMethod(native_method);
+  } else {
+    // We've been asked to associate this method with the given native method but are working
+    // around JNI bugs, that include not giving Object** SIRT references to native methods. Direct
+    // the native method to runtime support and store the target somewhere runtime support will
+    // find it.
+#if defined(__i386__)
+    UNIMPLEMENTED(FATAL);
+#else
+    SetNativeMethod(reinterpret_cast<void*>(art_work_around_app_jni_bugs));
+#endif
+    SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, gc_map_),
+        reinterpret_cast<const uint8_t*>(native_method), false);
+  }
+}
+
+void ArtMethod::UnregisterNative(Thread* self) {
+  CHECK(IsNative()) << PrettyMethod(this);
+  // restore stub to lookup native pointer via dlsym
+  RegisterNative(self, GetJniDlsymLookupStub());
+}
+
+void ArtMethod::SetNativeMethod(const void* native_method) {
+  SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, native_method_),
+      native_method, false);
+}
+
+}  // namespace mirror
+}  // namespace art
diff --git a/runtime/mirror/art_method.h b/runtime/mirror/art_method.h
new file mode 100644
index 0000000000..7301f23747
--- /dev/null
+++ b/runtime/mirror/art_method.h
@@ -0,0 +1,457 @@
+/*
+ * Copyright (C) 2011 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_RUNTIME_MIRROR_ART_METHOD_H_
+#define ART_RUNTIME_MIRROR_ART_METHOD_H_
+
+#include "class.h"
+#include "dex_file.h"
+#include "invoke_type.h"
+#include "locks.h"
+#include "modifiers.h"
+#include "object.h"
+
+namespace art {
+
+struct ArtMethodOffsets;
+struct ConstructorMethodOffsets;
+union JValue;
+struct MethodClassOffsets;
+class MethodHelper;
+class StringPiece;
+class ShadowFrame;
+
+namespace mirror {
+
+class StaticStorageBase;
+
+typedef void (EntryPointFromInterpreter)(Thread* self, MethodHelper& mh,
+    const DexFile::CodeItem* code_item, ShadowFrame* shadow_frame, JValue* result);
+
+// C++ mirror of java.lang.reflect.Method and java.lang.reflect.Constructor
+class MANAGED ArtMethod : public Object {
+ public:
+  Class* GetDeclaringClass() const;
+
+  void SetDeclaringClass(Class *new_declaring_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  static MemberOffset DeclaringClassOffset() {
+    return MemberOffset(OFFSETOF_MEMBER(ArtMethod, declaring_class_));
+  }
+
+  static MemberOffset EntryPointFromCompiledCodeOffset() {
+    return MemberOffset(OFFSETOF_MEMBER(ArtMethod, entry_point_from_compiled_code_));
+  }
+
+  uint32_t GetAccessFlags() const;
+
+  void SetAccessFlags(uint32_t new_access_flags) {
+    SetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, access_flags_), new_access_flags, false);
+  }
+
+  // Approximate what kind of method call would be used for this method.
+  InvokeType GetInvokeType() const;
+
+  // Returns true if the method is declared public.
+  bool IsPublic() const {
+    return (GetAccessFlags() & kAccPublic) != 0;
+  }
+
+  // Returns true if the method is declared private.
+  bool IsPrivate() const {
+    return (GetAccessFlags() & kAccPrivate) != 0;
+  }
+
+  // Returns true if the method is declared static.
+  bool IsStatic() const {
+    return (GetAccessFlags() & kAccStatic) != 0;
+  }
+
+  // Returns true if the method is a constructor.
+  bool IsConstructor() const {
+    return (GetAccessFlags() & kAccConstructor) != 0;
+  }
+
+  // Returns true if the method is static, private, or a constructor.
+  bool IsDirect() const {
+    return IsDirect(GetAccessFlags());
+  }
+
+  static bool IsDirect(uint32_t access_flags) {
+    return (access_flags & (kAccStatic | kAccPrivate | kAccConstructor)) != 0;
+  }
+
+  // Returns true if the method is declared synchronized.
+  bool IsSynchronized() const {
+    uint32_t synchonized = kAccSynchronized | kAccDeclaredSynchronized;
+    return (GetAccessFlags() & synchonized) != 0;
+  }
+
+  bool IsFinal() const {
+    return (GetAccessFlags() & kAccFinal) != 0;
+  }
+
+  bool IsMiranda() const {
+    return (GetAccessFlags() & kAccMiranda) != 0;
+  }
+
+  bool IsNative() const {
+    return (GetAccessFlags() & kAccNative) != 0;
+  }
+
+  bool IsAbstract() const {
+    return (GetAccessFlags() & kAccAbstract) != 0;
+  }
+
+  bool IsSynthetic() const {
+    return (GetAccessFlags() & kAccSynthetic) != 0;
+  }
+
+  bool IsProxyMethod() const;
+
+  bool IsPreverified() const {
+    return (GetAccessFlags() & kAccPreverified) != 0;
+  }
+
+  void SetPreverified() {
+    SetAccessFlags(GetAccessFlags() | kAccPreverified);
+  }
+
+  bool CheckIncompatibleClassChange(InvokeType type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  uint16_t GetMethodIndex() const;
+
+  size_t GetVtableIndex() const {
+    return GetMethodIndex();
+  }
+
+  void SetMethodIndex(uint16_t new_method_index) {
+    SetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_), new_method_index, false);
+  }
+
+  static MemberOffset MethodIndexOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_);
+  }
+
+  uint32_t GetCodeItemOffset() const {
+    return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, code_item_offset_), false);
+  }
+
+  void SetCodeItemOffset(uint32_t new_code_off) {
+    SetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, code_item_offset_), new_code_off, false);
+  }
+
+  // Number of 32bit registers that would be required to hold all the arguments
+  static size_t NumArgRegisters(const StringPiece& shorty);
+
+  uint32_t GetDexMethodIndex() const;
+
+  void SetDexMethodIndex(uint32_t new_idx) {
+    SetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_dex_index_), new_idx, false);
+  }
+
+  ObjectArray<String>* GetDexCacheStrings() const;
+  void SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  static MemberOffset DexCacheStringsOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_strings_);
+  }
+
+  static MemberOffset DexCacheResolvedMethodsOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_methods_);
+  }
+
+  static MemberOffset DexCacheResolvedTypesOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_types_);
+  }
+
+  static MemberOffset DexCacheInitializedStaticStorageOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(ArtMethod,
+        dex_cache_initialized_static_storage_);
+  }
+
+  ObjectArray<ArtMethod>* GetDexCacheResolvedMethods() const;
+  void SetDexCacheResolvedMethods(ObjectArray<ArtMethod>* new_dex_cache_methods)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  ObjectArray<Class>* GetDexCacheResolvedTypes() const;
+  void SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_types)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  ObjectArray<StaticStorageBase>* GetDexCacheInitializedStaticStorage() const;
+  void SetDexCacheInitializedStaticStorage(ObjectArray<StaticStorageBase>* new_value)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  // Find the method that this method overrides
+  ArtMethod* FindOverriddenMethod() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  void Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result, char result_type)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  EntryPointFromInterpreter* GetEntryPointFromInterpreter() const {
+    return GetFieldPtr<EntryPointFromInterpreter*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_interpreter_), false);
+  }
+
+  void SetEntryPointFromInterpreter(EntryPointFromInterpreter* entry_point_from_interpreter) {
+    SetFieldPtr<EntryPointFromInterpreter*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_interpreter_), entry_point_from_interpreter, false);
+  }
+
+  const void* GetEntryPointFromCompiledCode() const {
+    return GetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_compiled_code_), false);
+  }
+
+  void SetEntryPointFromCompiledCode(const void* entry_point_from_compiled_code) {
+    SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_compiled_code_), entry_point_from_compiled_code, false);
+  }
+
+  uint32_t GetCodeSize() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  bool IsWithinCode(uintptr_t pc) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    uintptr_t code = reinterpret_cast<uintptr_t>(GetEntryPointFromCompiledCode());
+    if (code == 0) {
+      return pc == 0;
+    }
+    /*
+     * During a stack walk, a return PC may point to the end of the code + 1
+     * (in the case that the last instruction is a call that isn't expected to
+     * return.  Thus, we check <= code + GetCodeSize().
+     */
+    return (code <= pc && pc <= code + GetCodeSize());
+  }
+
+  void AssertPcIsWithinCode(uintptr_t pc) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  uint32_t GetOatCodeOffset() const;
+
+  void SetOatCodeOffset(uint32_t code_offset);
+
+  static MemberOffset GetEntryPointFromCompiledCodeOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_compiled_code_);
+  }
+
+  // Callers should wrap the uint8_t* in a MappingTable instance for convenient access.
+  const uint8_t* GetMappingTable() const {
+    return GetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, mapping_table_), false);
+  }
+
+  void SetMappingTable(const uint8_t* mapping_table) {
+    SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, mapping_table_),
+                                 mapping_table, false);
+  }
+
+  uint32_t GetOatMappingTableOffset() const;
+
+  void SetOatMappingTableOffset(uint32_t mapping_table_offset);
+
+  // Callers should wrap the uint8_t* in a VmapTable instance for convenient access.
+  const uint8_t* GetVmapTable() const {
+    return GetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, vmap_table_), false);
+  }
+
+  void SetVmapTable(const uint8_t* vmap_table) {
+    SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, vmap_table_), vmap_table, false);
+  }
+
+  uint32_t GetOatVmapTableOffset() const;
+
+  void SetOatVmapTableOffset(uint32_t vmap_table_offset);
+
+  const uint8_t* GetNativeGcMap() const {
+    return GetFieldPtr<uint8_t*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, gc_map_), false);
+  }
+  void SetNativeGcMap(const uint8_t* data) {
+    SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, gc_map_), data, false);
+  }
+
+  // When building the oat need a convenient place to stuff the offset of the native GC map.
+  void SetOatNativeGcMapOffset(uint32_t gc_map_offset);
+  uint32_t GetOatNativeGcMapOffset() const;
+
+  size_t GetFrameSizeInBytes() const {
+    DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
+    size_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, frame_size_in_bytes_), false);
+    DCHECK_LE(static_cast<size_t>(kStackAlignment), result);
+    return result;
+  }
+
+  void SetFrameSizeInBytes(size_t new_frame_size_in_bytes) {
+    DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
+    SetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, frame_size_in_bytes_),
+               new_frame_size_in_bytes, false);
+  }
+
+  size_t GetReturnPcOffsetInBytes() const {
+    return GetFrameSizeInBytes() - kPointerSize;
+  }
+
+  size_t GetSirtOffsetInBytes() const {
+    CHECK(IsNative());
+    return kPointerSize;
+  }
+
+  bool IsRegistered() const;
+
+  void RegisterNative(Thread* self, const void* native_method)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  void UnregisterNative(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  static MemberOffset NativeMethodOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(ArtMethod, native_method_);
+  }
+
+  const void* GetNativeMethod() const {
+    return reinterpret_cast<const void*>(GetField32(NativeMethodOffset(), false));
+  }
+
+  void SetNativeMethod(const void*);
+
+  static MemberOffset GetMethodIndexOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_);
+  }
+
+  uint32_t GetCoreSpillMask() const {
+    return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, core_spill_mask_), false);
+  }
+
+  void SetCoreSpillMask(uint32_t core_spill_mask) {
+    // Computed during compilation
+    SetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, core_spill_mask_), core_spill_mask, false);
+  }
+
+  uint32_t GetFpSpillMask() const {
+    return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, fp_spill_mask_), false);
+  }
+
+  void SetFpSpillMask(uint32_t fp_spill_mask) {
+    // Computed during compilation
+    SetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, fp_spill_mask_), fp_spill_mask, false);
+  }
+
+  // Is this a CalleSaveMethod or ResolutionMethod and therefore doesn't adhere to normal
+  // conventions for a method of managed code. Returns false for Proxy methods.
+  bool IsRuntimeMethod() const;
+
+  // Is this a hand crafted method used for something like describing callee saves?
+  bool IsCalleeSaveMethod() const;
+
+  bool IsResolutionMethod() const;
+
+  uintptr_t NativePcOffset(const uintptr_t pc) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  // Converts a native PC to a dex PC.
+  uint32_t ToDexPc(const uintptr_t pc) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  // Converts a dex PC to a native PC.
+  uintptr_t ToNativePc(const uint32_t dex_pc) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  // Find the catch block for the given exception type and dex_pc. When a catch block is found,
+  // indicates whether the found catch block is responsible for clearing the exception or whether
+  // a move-exception instruction is present.
+  uint32_t FindCatchBlock(Class* exception_type, uint32_t dex_pc, bool* has_no_move_exception) const
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+  static void SetClass(Class* java_lang_reflect_ArtMethod);
+
+  static Class* GetJavaLangReflectArtMethod() {
+    return java_lang_reflect_ArtMethod_;
+  }
+
+  static void ResetClass();
+
+ protected:
+  // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
+  // The class we are a part of
+  Class* declaring_class_;
+
+  // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
+  ObjectArray<StaticStorageBase>* dex_cache_initialized_static_storage_;
+
+  // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
+  ObjectArray<ArtMethod>* dex_cache_resolved_methods_;
+
+  // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
+  ObjectArray<Class>* dex_cache_resolved_types_;
+
+  // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
+  ObjectArray<String>* dex_cache_strings_;
+
+  // Access flags; low 16 bits are defined by spec.
+  uint32_t access_flags_;
+
+  // Offset to the CodeItem.
+  uint32_t code_item_offset_;
+
+  // Architecture-dependent register spill mask
+  uint32_t core_spill_mask_;
+
+  // Compiled code associated with this method for callers from managed code.
+  // May be compiled managed code or a bridge for invoking a native method.
+  // TODO: Break apart this into portable and quick.
+  const void* entry_point_from_compiled_code_;
+
+  // Called by the interpreter to execute this method.
+  EntryPointFromInterpreter* entry_point_from_interpreter_;
+
+  // Architecture-dependent register spill mask
+  uint32_t fp_spill_mask_;
+
+  // Total size in bytes of the frame
+  size_t frame_size_in_bytes_;
+
+  // Garbage collection map of native PC offsets (quick) or dex PCs (portable) to reference bitmaps.
+  const uint8_t* gc_map_;
+
+  // Mapping from native pc to dex pc
+  const uint32_t* mapping_table_;
+
+  // Index into method_ids of the dex file associated with this method
+  uint32_t method_dex_index_;
+
+  // For concrete virtual methods, this is the offset of the method in Class::vtable_.
+  //
+  // For abstract methods in an interface class, this is the offset of the method in
+  // "iftable_->Get(n)->GetMethodArray()".
+  //
+  // For static and direct methods this is the index in the direct methods table.
+  uint32_t method_index_;
+
+  // The target native method registered with this method
+  const void* native_method_;
+
+  // When a register is promoted into a register, the spill mask holds which registers hold dex
+  // registers. The first promoted register's corresponding dex register is vmap_table_[1], the Nth
+  // is vmap_table_[N]. vmap_table_[0] holds the length of the table.
+  const uint16_t* vmap_table_;
+
+  static Class* java_lang_reflect_ArtMethod_;
+
+  friend struct art::ArtMethodOffsets;  // for verifying offset information
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ArtMethod);
+};
+
+class MANAGED ArtMethodClass : public Class {
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ArtMethodClass);
+};
+
+}  // namespace mirror
+}  // namespace art
+
+#endif  // ART_RUNTIME_MIRROR_ART_METHOD_H_
diff --git a/runtime/mirror/class-inl.h b/runtime/mirror/class-inl.h
index 52906a2650..1e1138745d 100644
--- a/runtime/mirror/class-inl.h
+++ b/runtime/mirror/class-inl.h
@@ -19,10 +19,10 @@
 
 #include "class.h"
 
-#include "abstract_method.h"
+#include "art_field.h"
+#include "art_method.h"
 #include "class_loader.h"
 #include "dex_cache.h"
-#include "field.h"
 #include "iftable.h"
 #include "object_array-inl.h"
 #include "runtime.h"
@@ -54,30 +54,30 @@ inline DexCache* Class::GetDexCache() const {
   return GetFieldObject<DexCache*>(OFFSET_OF_OBJECT_MEMBER(Class, dex_cache_), false);
 }
 
-inline ObjectArray<AbstractMethod>* Class::GetDirectMethods() const {
+inline ObjectArray<ArtMethod>* Class::GetDirectMethods() const {
   DCHECK(IsLoaded() || IsErroneous());
-  return GetFieldObject<ObjectArray<AbstractMethod>*>(
+  return GetFieldObject<ObjectArray<ArtMethod>*>(
       OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false);
 }
 
-inline void Class::SetDirectMethods(ObjectArray<AbstractMethod>* new_direct_methods)
+inline void Class::SetDirectMethods(ObjectArray<ArtMethod>* new_direct_methods)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  DCHECK(NULL == GetFieldObject<ObjectArray<AbstractMethod>*>(
+  DCHECK(NULL == GetFieldObject<ObjectArray<ArtMethod>*>(
       OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false));
   DCHECK_NE(0, new_direct_methods->GetLength());
   SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_),
                  new_direct_methods, false);
 }
 
-inline AbstractMethod* Class::GetDirectMethod(int32_t i) const
+inline ArtMethod* Class::GetDirectMethod(int32_t i) const
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return GetDirectMethods()->Get(i);
 }
 
-inline void Class::SetDirectMethod(uint32_t i, AbstractMethod* f)  // TODO: uint16_t
+inline void Class::SetDirectMethod(uint32_t i, ArtMethod* f)  // TODO: uint16_t
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  ObjectArray<AbstractMethod>* direct_methods =
-      GetFieldObject<ObjectArray<AbstractMethod>*>(
+  ObjectArray<ArtMethod>* direct_methods =
+      GetFieldObject<ObjectArray<ArtMethod>*>(
           OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false);
   direct_methods->Set(i, f);
 }
@@ -87,13 +87,13 @@ inline size_t Class::NumDirectMethods() const {
   return (GetDirectMethods() != NULL) ? GetDirectMethods()->GetLength() : 0;
 }
 
-inline ObjectArray<AbstractMethod>* Class::GetVirtualMethods() const {
+inline ObjectArray<ArtMethod>* Class::GetVirtualMethods() const {
   DCHECK(IsLoaded() || IsErroneous());
-  return GetFieldObject<ObjectArray<AbstractMethod>*>(
+  return GetFieldObject<ObjectArray<ArtMethod>*>(
       OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_), false);
 }
 
-inline void Class::SetVirtualMethods(ObjectArray<AbstractMethod>* new_virtual_methods) {
+inline void Class::SetVirtualMethods(ObjectArray<ArtMethod>* new_virtual_methods) {
   // TODO: we reassign virtual methods to grow the table for miranda
   // methods.. they should really just be assigned once
   DCHECK_NE(0, new_virtual_methods->GetLength());
@@ -105,37 +105,37 @@ inline size_t Class::NumVirtualMethods() const {
   return (GetVirtualMethods() != NULL) ? GetVirtualMethods()->GetLength() : 0;
 }
 
-inline AbstractMethod* Class::GetVirtualMethod(uint32_t i) const
+inline ArtMethod* Class::GetVirtualMethod(uint32_t i) const
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK(IsResolved() || IsErroneous());
   return GetVirtualMethods()->Get(i);
 }
 
-inline AbstractMethod* Class::GetVirtualMethodDuringLinking(uint32_t i) const
+inline ArtMethod* Class::GetVirtualMethodDuringLinking(uint32_t i) const
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK(IsLoaded() || IsErroneous());
   return GetVirtualMethods()->Get(i);
 }
 
-inline void Class::SetVirtualMethod(uint32_t i, AbstractMethod* f)  // TODO: uint16_t
+inline void Class::SetVirtualMethod(uint32_t i, ArtMethod* f)  // TODO: uint16_t
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  ObjectArray<AbstractMethod>* virtual_methods =
-      GetFieldObject<ObjectArray<AbstractMethod>*>(
+  ObjectArray<ArtMethod>* virtual_methods =
+      GetFieldObject<ObjectArray<ArtMethod>*>(
           OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_), false);
   virtual_methods->Set(i, f);
 }
 
-inline ObjectArray<AbstractMethod>* Class::GetVTable() const {
+inline ObjectArray<ArtMethod>* Class::GetVTable() const {
   DCHECK(IsResolved() || IsErroneous());
-  return GetFieldObject<ObjectArray<AbstractMethod>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
+  return GetFieldObject<ObjectArray<ArtMethod>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
 }
 
-inline ObjectArray<AbstractMethod>* Class::GetVTableDuringLinking() const {
+inline ObjectArray<ArtMethod>* Class::GetVTableDuringLinking() const {
   DCHECK(IsLoaded() || IsErroneous());
-  return GetFieldObject<ObjectArray<AbstractMethod>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
+  return GetFieldObject<ObjectArray<ArtMethod>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
 }
 
-inline void Class::SetVTable(ObjectArray<AbstractMethod>* new_vtable)
+inline void Class::SetVTable(ObjectArray<ArtMethod>* new_vtable)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), new_vtable, false);
 }
@@ -208,7 +208,7 @@ inline bool Class::IsSubClass(const Class* klass) const {
   return false;
 }
 
-inline AbstractMethod* Class::FindVirtualMethodForInterface(AbstractMethod* method) const {
+inline ArtMethod* Class::FindVirtualMethodForInterface(ArtMethod* method) const {
   Class* declaring_class = method->GetDeclaringClass();
   DCHECK(declaring_class != NULL) << PrettyClass(this);
   DCHECK(declaring_class->IsInterface()) << PrettyMethod(method);
@@ -223,7 +223,7 @@ inline AbstractMethod* Class::FindVirtualMethodForInterface(AbstractMethod* meth
   return NULL;
 }
 
-inline AbstractMethod* Class::FindVirtualMethodForVirtual(AbstractMethod* method) const
+inline ArtMethod* Class::FindVirtualMethodForVirtual(ArtMethod* method) const
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK(!method->GetDeclaringClass()->IsInterface() || method->IsMiranda());
   // The argument method may from a super class.
@@ -231,13 +231,13 @@ inline AbstractMethod* Class::FindVirtualMethodForVirtual(AbstractMethod* method
   return GetVTable()->Get(method->GetMethodIndex());
 }
 
-inline AbstractMethod* Class::FindVirtualMethodForSuper(AbstractMethod* method) const
+inline ArtMethod* Class::FindVirtualMethodForSuper(ArtMethod* method) const
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK(!method->GetDeclaringClass()->IsInterface());
   return GetSuperClass()->GetVTable()->Get(method->GetMethodIndex());
 }
 
-inline AbstractMethod* Class::FindVirtualMethodForVirtualOrInterface(AbstractMethod* method) const {
+inline ArtMethod* Class::FindVirtualMethodForVirtualOrInterface(ArtMethod* method) const {
   if (method->IsDirect()) {
     return method;
   }
@@ -263,26 +263,26 @@ inline void Class::SetIfTable(IfTable* new_iftable) {
   SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, iftable_), new_iftable, false);
 }
 
-inline ObjectArray<Field>* Class::GetIFields() const {
+inline ObjectArray<ArtField>* Class::GetIFields() const {
   DCHECK(IsLoaded() || IsErroneous());
-  return GetFieldObject<ObjectArray<Field>*>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false);
+  return GetFieldObject<ObjectArray<ArtField>*>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false);
 }
 
-inline void Class::SetIFields(ObjectArray<Field>* new_ifields)
+inline void Class::SetIFields(ObjectArray<ArtField>* new_ifields)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  DCHECK(NULL == GetFieldObject<ObjectArray<Field>*>(
+  DCHECK(NULL == GetFieldObject<ObjectArray<ArtField>*>(
       OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false));
   SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), new_ifields, false);
 }
 
-inline ObjectArray<Field>* Class::GetSFields() const {
+inline ObjectArray<ArtField>* Class::GetSFields() const {
   DCHECK(IsLoaded() || IsErroneous());
-  return GetFieldObject<ObjectArray<Field>*>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false);
+  return GetFieldObject<ObjectArray<ArtField>*>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false);
 }
 
-inline void Class::SetSFields(ObjectArray<Field>* new_sfields)
+inline void Class::SetSFields(ObjectArray<ArtField>* new_sfields)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  DCHECK(NULL == GetFieldObject<ObjectArray<Field>*>(
+  DCHECK(NULL == GetFieldObject<ObjectArray<ArtField>*>(
       OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false));
   SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), new_sfields, false);
 }
@@ -291,14 +291,14 @@ inline size_t Class::NumStaticFields() const {
   return (GetSFields() != NULL) ? GetSFields()->GetLength() : 0;
 }
 
-inline Field* Class::GetStaticField(uint32_t i) const  // TODO: uint16_t
+inline ArtField* Class::GetStaticField(uint32_t i) const  // TODO: uint16_t
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return GetSFields()->Get(i);
 }
 
-inline void Class::SetStaticField(uint32_t i, Field* f)  // TODO: uint16_t
+inline void Class::SetStaticField(uint32_t i, ArtField* f)  // TODO: uint16_t
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  ObjectArray<Field>* sfields= GetFieldObject<ObjectArray<Field>*>(
+  ObjectArray<ArtField>* sfields= GetFieldObject<ObjectArray<ArtField>*>(
       OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false);
   sfields->Set(i, f);
 }
@@ -307,15 +307,15 @@ inline size_t Class::NumInstanceFields() const {
   return (GetIFields() != NULL) ? GetIFields()->GetLength() : 0;
 }
 
-inline Field* Class::GetInstanceField(uint32_t i) const  // TODO: uint16_t
+inline ArtField* Class::GetInstanceField(uint32_t i) const  // TODO: uint16_t
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK_NE(NumInstanceFields(), 0U);
   return GetIFields()->Get(i);
 }
 
-inline void Class::SetInstanceField(uint32_t i, Field* f)  // TODO: uint16_t
+inline void Class::SetInstanceField(uint32_t i, ArtField* f)  // TODO: uint16_t
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  ObjectArray<Field>* ifields= GetFieldObject<ObjectArray<Field>*>(
+  ObjectArray<ArtField>* ifields= GetFieldObject<ObjectArray<ArtField>*>(
       OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false);
   ifields->Set(i, f);
 }
@@ -330,9 +330,8 @@ inline uint32_t Class::GetAccessFlags() const {
   // circularity issue during loading the names of its members
   DCHECK(IsLoaded() || IsErroneous() ||
          this == String::GetJavaLangString() ||
-         this == Field::GetJavaLangReflectField() ||
-         this == AbstractMethod::GetConstructorClass() ||
-         this == AbstractMethod::GetMethodClass());
+         this == ArtField::GetJavaLangReflectArtField() ||
+         this == ArtMethod::GetJavaLangReflectArtMethod());
   return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), false);
 }
 
diff --git a/runtime/mirror/class.cc b/runtime/mirror/class.cc
index e490d97f80..29025f26c8 100644
--- a/runtime/mirror/class.cc
+++ b/runtime/mirror/class.cc
@@ -16,13 +16,13 @@
 
 #include "class.h"
 
-#include "abstract_method-inl.h"
+#include "art_field-inl.h"
+#include "art_method-inl.h"
 #include "class-inl.h"
 #include "class_linker.h"
 #include "class_loader.h"
 #include "dex_cache.h"
 #include "dex_file-inl.h"
-#include "field-inl.h"
 #include "gc/accounting/card_table-inl.h"
 #include "object-inl.h"
 #include "object_array-inl.h"
@@ -63,7 +63,7 @@ void Class::SetStatus(Status new_status) {
     // Stash current exception.
     Thread* self = Thread::Current();
     SirtRef<mirror::Object> old_throw_this_object(self, NULL);
-    SirtRef<mirror::AbstractMethod> old_throw_method(self, NULL);
+    SirtRef<mirror::ArtMethod> old_throw_method(self, NULL);
     SirtRef<mirror::Throwable> old_exception(self, NULL);
     uint32_t old_throw_dex_pc;
     {
@@ -316,24 +316,23 @@ bool Class::IsThrowableClass() const {
   return WellKnownClasses::ToClass(WellKnownClasses::java_lang_Throwable)->IsAssignableFrom(this);
 }
 
-bool Class::IsFieldClass() const {
+bool Class::IsArtFieldClass() const {
   Class* java_lang_Class = GetClass();
-  Class* java_lang_reflect_Field = java_lang_Class->GetInstanceField(0)->GetClass();
-  return this == java_lang_reflect_Field;
+  Class* java_lang_reflect_ArtField = java_lang_Class->GetInstanceField(0)->GetClass();
+  return this == java_lang_reflect_ArtField;
 }
 
-bool Class::IsMethodClass() const {
-  return (this == AbstractMethod::GetMethodClass()) ||
-          (this == AbstractMethod::GetConstructorClass());
+bool Class::IsArtMethodClass() const {
+  return this == ArtMethod::GetJavaLangReflectArtMethod();
 }
 
 void Class::SetClassLoader(ClassLoader* new_class_loader) {
   SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), new_class_loader, false);
 }
 
-AbstractMethod* Class::FindInterfaceMethod(const StringPiece& name, const StringPiece& signature) const {
+ArtMethod* Class::FindInterfaceMethod(const StringPiece& name, const StringPiece& signature) const {
   // Check the current class before checking the interfaces.
-  AbstractMethod* method = FindDeclaredVirtualMethod(name, signature);
+  ArtMethod* method = FindDeclaredVirtualMethod(name, signature);
   if (method != NULL) {
     return method;
   }
@@ -349,9 +348,9 @@ AbstractMethod* Class::FindInterfaceMethod(const StringPiece& name, const String
   return NULL;
 }
 
-AbstractMethod* Class::FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+ArtMethod* Class::FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
   // Check the current class before checking the interfaces.
-  AbstractMethod* method = FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
+  ArtMethod* method = FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
   if (method != NULL) {
     return method;
   }
@@ -368,10 +367,10 @@ AbstractMethod* Class::FindInterfaceMethod(const DexCache* dex_cache, uint32_t d
 }
 
 
-AbstractMethod* Class::FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const {
+ArtMethod* Class::FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const {
   MethodHelper mh;
   for (size_t i = 0; i < NumDirectMethods(); ++i) {
-    AbstractMethod* method = GetDirectMethod(i);
+    ArtMethod* method = GetDirectMethod(i);
     mh.ChangeMethod(method);
     if (name == mh.GetName() && signature == mh.GetSignature()) {
       return method;
@@ -380,10 +379,10 @@ AbstractMethod* Class::FindDeclaredDirectMethod(const StringPiece& name, const S
   return NULL;
 }
 
-AbstractMethod* Class::FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+ArtMethod* Class::FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
   if (GetDexCache() == dex_cache) {
     for (size_t i = 0; i < NumDirectMethods(); ++i) {
-      AbstractMethod* method = GetDirectMethod(i);
+      ArtMethod* method = GetDirectMethod(i);
       if (method->GetDexMethodIndex() == dex_method_idx) {
         return method;
       }
@@ -392,9 +391,9 @@ AbstractMethod* Class::FindDeclaredDirectMethod(const DexCache* dex_cache, uint3
   return NULL;
 }
 
-AbstractMethod* Class::FindDirectMethod(const StringPiece& name, const StringPiece& signature) const {
+ArtMethod* Class::FindDirectMethod(const StringPiece& name, const StringPiece& signature) const {
   for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
-    AbstractMethod* method = klass->FindDeclaredDirectMethod(name, signature);
+    ArtMethod* method = klass->FindDeclaredDirectMethod(name, signature);
     if (method != NULL) {
       return method;
     }
@@ -402,9 +401,9 @@ AbstractMethod* Class::FindDirectMethod(const StringPiece& name, const StringPie
   return NULL;
 }
 
-AbstractMethod* Class::FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+ArtMethod* Class::FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
   for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
-    AbstractMethod* method = klass->FindDeclaredDirectMethod(dex_cache, dex_method_idx);
+    ArtMethod* method = klass->FindDeclaredDirectMethod(dex_cache, dex_method_idx);
     if (method != NULL) {
       return method;
     }
@@ -412,11 +411,11 @@ AbstractMethod* Class::FindDirectMethod(const DexCache* dex_cache, uint32_t dex_
   return NULL;
 }
 
-AbstractMethod* Class::FindDeclaredVirtualMethod(const StringPiece& name,
+ArtMethod* Class::FindDeclaredVirtualMethod(const StringPiece& name,
                                          const StringPiece& signature) const {
   MethodHelper mh;
   for (size_t i = 0; i < NumVirtualMethods(); ++i) {
-    AbstractMethod* method = GetVirtualMethod(i);
+    ArtMethod* method = GetVirtualMethod(i);
     mh.ChangeMethod(method);
     if (name == mh.GetName() && signature == mh.GetSignature()) {
       return method;
@@ -425,10 +424,10 @@ AbstractMethod* Class::FindDeclaredVirtualMethod(const StringPiece& name,
   return NULL;
 }
 
-AbstractMethod* Class::FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+ArtMethod* Class::FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
   if (GetDexCache() == dex_cache) {
     for (size_t i = 0; i < NumVirtualMethods(); ++i) {
-      AbstractMethod* method = GetVirtualMethod(i);
+      ArtMethod* method = GetVirtualMethod(i);
       if (method->GetDexMethodIndex() == dex_method_idx) {
         return method;
       }
@@ -437,9 +436,9 @@ AbstractMethod* Class::FindDeclaredVirtualMethod(const DexCache* dex_cache, uint
   return NULL;
 }
 
-AbstractMethod* Class::FindVirtualMethod(const StringPiece& name, const StringPiece& signature) const {
+ArtMethod* Class::FindVirtualMethod(const StringPiece& name, const StringPiece& signature) const {
   for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
-    AbstractMethod* method = klass->FindDeclaredVirtualMethod(name, signature);
+    ArtMethod* method = klass->FindDeclaredVirtualMethod(name, signature);
     if (method != NULL) {
       return method;
     }
@@ -447,9 +446,9 @@ AbstractMethod* Class::FindVirtualMethod(const StringPiece& name, const StringPi
   return NULL;
 }
 
-AbstractMethod* Class::FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+ArtMethod* Class::FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
   for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
-    AbstractMethod* method = klass->FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
+    ArtMethod* method = klass->FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
     if (method != NULL) {
       return method;
     }
@@ -457,12 +456,12 @@ AbstractMethod* Class::FindVirtualMethod(const DexCache* dex_cache, uint32_t dex
   return NULL;
 }
 
-Field* Class::FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type) {
+ArtField* Class::FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type) {
   // Is the field in this class?
   // Interfaces are not relevant because they can't contain instance fields.
   FieldHelper fh;
   for (size_t i = 0; i < NumInstanceFields(); ++i) {
-    Field* f = GetInstanceField(i);
+    ArtField* f = GetInstanceField(i);
     fh.ChangeField(f);
     if (name == fh.GetName() && type == fh.GetTypeDescriptor()) {
       return f;
@@ -471,10 +470,10 @@ Field* Class::FindDeclaredInstanceField(const StringPiece& name, const StringPie
   return NULL;
 }
 
-Field* Class::FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) {
+ArtField* Class::FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) {
   if (GetDexCache() == dex_cache) {
     for (size_t i = 0; i < NumInstanceFields(); ++i) {
-      Field* f = GetInstanceField(i);
+      ArtField* f = GetInstanceField(i);
       if (f->GetDexFieldIndex() == dex_field_idx) {
         return f;
       }
@@ -483,11 +482,11 @@ Field* Class::FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_
   return NULL;
 }
 
-Field* Class::FindInstanceField(const StringPiece& name, const StringPiece& type) {
+ArtField* Class::FindInstanceField(const StringPiece& name, const StringPiece& type) {
   // Is the field in this class, or any of its superclasses?
   // Interfaces are not relevant because they can't contain instance fields.
   for (Class* c = this; c != NULL; c = c->GetSuperClass()) {
-    Field* f = c->FindDeclaredInstanceField(name, type);
+    ArtField* f = c->FindDeclaredInstanceField(name, type);
     if (f != NULL) {
       return f;
     }
@@ -495,11 +494,11 @@ Field* Class::FindInstanceField(const StringPiece& name, const StringPiece& type
   return NULL;
 }
 
-Field* Class::FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) {
+ArtField* Class::FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) {
   // Is the field in this class, or any of its superclasses?
   // Interfaces are not relevant because they can't contain instance fields.
   for (Class* c = this; c != NULL; c = c->GetSuperClass()) {
-    Field* f = c->FindDeclaredInstanceField(dex_cache, dex_field_idx);
+    ArtField* f = c->FindDeclaredInstanceField(dex_cache, dex_field_idx);
     if (f != NULL) {
       return f;
     }
@@ -507,11 +506,11 @@ Field* Class::FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_id
   return NULL;
 }
 
-Field* Class::FindDeclaredStaticField(const StringPiece& name, const StringPiece& type) {
+ArtField* Class::FindDeclaredStaticField(const StringPiece& name, const StringPiece& type) {
   DCHECK(type != NULL);
   FieldHelper fh;
   for (size_t i = 0; i < NumStaticFields(); ++i) {
-    Field* f = GetStaticField(i);
+    ArtField* f = GetStaticField(i);
     fh.ChangeField(f);
     if (name == fh.GetName() && type == fh.GetTypeDescriptor()) {
       return f;
@@ -520,10 +519,10 @@ Field* Class::FindDeclaredStaticField(const StringPiece& name, const StringPiece
   return NULL;
 }
 
-Field* Class::FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx) {
+ArtField* Class::FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx) {
   if (dex_cache == GetDexCache()) {
     for (size_t i = 0; i < NumStaticFields(); ++i) {
-      Field* f = GetStaticField(i);
+      ArtField* f = GetStaticField(i);
       if (f->GetDexFieldIndex() == dex_field_idx) {
         return f;
       }
@@ -532,13 +531,13 @@ Field* Class::FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_fi
   return NULL;
 }
 
-Field* Class::FindStaticField(const StringPiece& name, const StringPiece& type) {
+ArtField* Class::FindStaticField(const StringPiece& name, const StringPiece& type) {
   // Is the field in this class (or its interfaces), or any of its
   // superclasses (or their interfaces)?
   ClassHelper kh;
   for (Class* k = this; k != NULL; k = k->GetSuperClass()) {
     // Is the field in this class?
-    Field* f = k->FindDeclaredStaticField(name, type);
+    ArtField* f = k->FindDeclaredStaticField(name, type);
     if (f != NULL) {
       return f;
     }
@@ -555,11 +554,11 @@ Field* Class::FindStaticField(const StringPiece& name, const StringPiece& type)
   return NULL;
 }
 
-Field* Class::FindStaticField(const DexCache* dex_cache, uint32_t dex_field_idx) {
+ArtField* Class::FindStaticField(const DexCache* dex_cache, uint32_t dex_field_idx) {
   ClassHelper kh;
   for (Class* k = this; k != NULL; k = k->GetSuperClass()) {
     // Is the field in this class?
-    Field* f = k->FindDeclaredStaticField(dex_cache, dex_field_idx);
+    ArtField* f = k->FindDeclaredStaticField(dex_cache, dex_field_idx);
     if (f != NULL) {
       return f;
     }
@@ -576,12 +575,12 @@ Field* Class::FindStaticField(const DexCache* dex_cache, uint32_t dex_field_idx)
   return NULL;
 }
 
-Field* Class::FindField(const StringPiece& name, const StringPiece& type) {
+ArtField* Class::FindField(const StringPiece& name, const StringPiece& type) {
   // Find a field using the JLS field resolution order
   ClassHelper kh;
   for (Class* k = this; k != NULL; k = k->GetSuperClass()) {
     // Is the field in this class?
-    Field* f = k->FindDeclaredInstanceField(name, type);
+    ArtField* f = k->FindDeclaredInstanceField(name, type);
     if (f != NULL) {
       return f;
     }
@@ -602,11 +601,11 @@ Field* Class::FindField(const StringPiece& name, const StringPiece& type) {
   return NULL;
 }
 
-static void SetPreverifiedFlagOnMethods(mirror::ObjectArray<mirror::AbstractMethod>* methods)
+static void SetPreverifiedFlagOnMethods(mirror::ObjectArray<mirror::ArtMethod>* methods)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   if (methods != NULL) {
     for (int32_t index = 0, end = methods->GetLength(); index < end; ++index) {
-      mirror::AbstractMethod* method = methods->GetWithoutChecks(index);
+      mirror::ArtMethod* method = methods->GetWithoutChecks(index);
       DCHECK(method != NULL);
       method->SetPreverified();
     }
diff --git a/runtime/mirror/class.h b/runtime/mirror/class.h
index 1dd02c0256..638b67f485 100644
--- a/runtime/mirror/class.h
+++ b/runtime/mirror/class.h
@@ -63,9 +63,9 @@ class StringPiece;
 
 namespace mirror {
 
+class ArtField;
 class ClassLoader;
 class DexCache;
-class Field;
 class IfTable;
 
 // Type for the InitializedStaticStorage table. Currently the Class
@@ -341,9 +341,9 @@ class MANAGED Class : public StaticStorageBase {
 
   bool IsThrowableClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  bool IsFieldClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  bool IsArtFieldClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  bool IsMethodClass() const;
+  bool IsArtMethodClass() const;
 
   Class* GetComponentType() const {
     return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, component_type_), false);
@@ -502,42 +502,42 @@ class MANAGED Class : public StaticStorageBase {
 
   void SetDexCache(DexCache* new_dex_cache) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  ObjectArray<AbstractMethod>* GetDirectMethods() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  ObjectArray<ArtMethod>* GetDirectMethods() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void SetDirectMethods(ObjectArray<AbstractMethod>* new_direct_methods)
+  void SetDirectMethods(ObjectArray<ArtMethod>* new_direct_methods)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* GetDirectMethod(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  ArtMethod* GetDirectMethod(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void SetDirectMethod(uint32_t i, AbstractMethod* f)  // TODO: uint16_t
+  void SetDirectMethod(uint32_t i, ArtMethod* f)  // TODO: uint16_t
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Returns the number of static, private, and constructor methods.
   size_t NumDirectMethods() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  ObjectArray<AbstractMethod>* GetVirtualMethods() const
+  ObjectArray<ArtMethod>* GetVirtualMethods() const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void SetVirtualMethods(ObjectArray<AbstractMethod>* new_virtual_methods)
+  void SetVirtualMethods(ObjectArray<ArtMethod>* new_virtual_methods)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Returns the number of non-inherited virtual methods.
   size_t NumVirtualMethods() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* GetVirtualMethod(uint32_t i) const
+  ArtMethod* GetVirtualMethod(uint32_t i) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* GetVirtualMethodDuringLinking(uint32_t i) const
+  ArtMethod* GetVirtualMethodDuringLinking(uint32_t i) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void SetVirtualMethod(uint32_t i, AbstractMethod* f)  // TODO: uint16_t
+  void SetVirtualMethod(uint32_t i, ArtMethod* f)  // TODO: uint16_t
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  ObjectArray<AbstractMethod>* GetVTable() const;
+  ObjectArray<ArtMethod>* GetVTable() const;
 
-  ObjectArray<AbstractMethod>* GetVTableDuringLinking() const;
+  ObjectArray<ArtMethod>* GetVTableDuringLinking() const;
 
-  void SetVTable(ObjectArray<AbstractMethod>* new_vtable)
+  void SetVTable(ObjectArray<ArtMethod>* new_vtable)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   static MemberOffset VTableOffset() {
@@ -546,51 +546,51 @@ class MANAGED Class : public StaticStorageBase {
 
   // Given a method implemented by this class but potentially from a super class, return the
   // specific implementation method for this class.
-  AbstractMethod* FindVirtualMethodForVirtual(AbstractMethod* method) const
+  ArtMethod* FindVirtualMethodForVirtual(ArtMethod* method) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Given a method implemented by this class' super class, return the specific implementation
   // method for this class.
-  AbstractMethod* FindVirtualMethodForSuper(AbstractMethod* method) const
+  ArtMethod* FindVirtualMethodForSuper(ArtMethod* method) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Given a method implemented by this class, but potentially from a
   // super class or interface, return the specific implementation
   // method for this class.
-  AbstractMethod* FindVirtualMethodForInterface(AbstractMethod* method) const
+  ArtMethod* FindVirtualMethodForInterface(ArtMethod* method) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) ALWAYS_INLINE;
 
-  AbstractMethod* FindInterfaceMethod(const StringPiece& name, const StringPiece& descriptor) const
+  ArtMethod* FindInterfaceMethod(const StringPiece& name, const StringPiece& descriptor) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+  ArtMethod* FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* FindVirtualMethodForVirtualOrInterface(AbstractMethod* method) const
+  ArtMethod* FindVirtualMethodForVirtualOrInterface(ArtMethod* method) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature) const
+  ArtMethod* FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+  ArtMethod* FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* FindVirtualMethod(const StringPiece& name, const StringPiece& descriptor) const
+  ArtMethod* FindVirtualMethod(const StringPiece& name, const StringPiece& descriptor) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+  ArtMethod* FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const
+  ArtMethod* FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+  ArtMethod* FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* FindDirectMethod(const StringPiece& name, const StringPiece& signature) const
+  ArtMethod* FindDirectMethod(const StringPiece& name, const StringPiece& signature) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+  ArtMethod* FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   int32_t GetIfTableCount() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -600,16 +600,16 @@ class MANAGED Class : public StaticStorageBase {
   void SetIfTable(IfTable* new_iftable) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Get instance fields of the class (See also GetSFields).
-  ObjectArray<Field>* GetIFields() const;
+  ObjectArray<ArtField>* GetIFields() const;
 
-  void SetIFields(ObjectArray<Field>* new_ifields) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetIFields(ObjectArray<ArtField>* new_ifields) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   size_t NumInstanceFields() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  Field* GetInstanceField(uint32_t i) const  // TODO: uint16_t
+  ArtField* GetInstanceField(uint32_t i) const  // TODO: uint16_t
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void SetInstanceField(uint32_t i, Field* f)  // TODO: uint16_t
+  void SetInstanceField(uint32_t i, ArtField* f)  // TODO: uint16_t
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Returns the number of instance fields containing reference types.
@@ -662,15 +662,15 @@ class MANAGED Class : public StaticStorageBase {
   }
 
   // Gets the static fields of the class.
-  ObjectArray<Field>* GetSFields() const;
+  ObjectArray<ArtField>* GetSFields() const;
 
-  void SetSFields(ObjectArray<Field>* new_sfields) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetSFields(ObjectArray<ArtField>* new_sfields) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   size_t NumStaticFields() const;
 
-  Field* GetStaticField(uint32_t i) const;  // TODO: uint16_t
+  ArtField* GetStaticField(uint32_t i) const;  // TODO: uint16_t
 
-  void SetStaticField(uint32_t i, Field* f);  // TODO: uint16_t
+  void SetStaticField(uint32_t i, ArtField* f);  // TODO: uint16_t
 
   uint32_t GetReferenceStaticOffsets() const {
     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, reference_static_offsets_), false);
@@ -679,37 +679,37 @@ class MANAGED Class : public StaticStorageBase {
   void SetReferenceStaticOffsets(uint32_t new_reference_offsets);
 
   // Find a static or instance field using the JLS resolution order
-  Field* FindField(const StringPiece& name, const StringPiece& type)
+  ArtField* FindField(const StringPiece& name, const StringPiece& type)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Finds the given instance field in this class or a superclass.
-  Field* FindInstanceField(const StringPiece& name, const StringPiece& type)
+  ArtField* FindInstanceField(const StringPiece& name, const StringPiece& type)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Finds the given instance field in this class or a superclass, only searches classes that
   // have the same dex cache.
-  Field* FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx)
+  ArtField* FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  Field* FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type)
+  ArtField* FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  Field* FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx)
+  ArtField* FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Finds the given static field in this class or a superclass.
-  Field* FindStaticField(const StringPiece& name, const StringPiece& type)
+  ArtField* FindStaticField(const StringPiece& name, const StringPiece& type)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Finds the given static field in this class or superclass, only searches classes that
   // have the same dex cache.
-  Field* FindStaticField(const DexCache* dex_cache, uint32_t dex_field_idx)
+  ArtField* FindStaticField(const DexCache* dex_cache, uint32_t dex_field_idx)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  Field* FindDeclaredStaticField(const StringPiece& name, const StringPiece& type)
+  ArtField* FindDeclaredStaticField(const StringPiece& name, const StringPiece& type)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  Field* FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx)
+  ArtField* FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   pid_t GetClinitThreadId() const {
@@ -768,7 +768,7 @@ class MANAGED Class : public StaticStorageBase {
   DexCache* dex_cache_;
 
   // static, private, and <init> methods
-  ObjectArray<AbstractMethod>* direct_methods_;
+  ObjectArray<ArtMethod>* direct_methods_;
 
   // instance fields
   //
@@ -780,7 +780,7 @@ class MANAGED Class : public StaticStorageBase {
   // All instance fields that refer to objects are guaranteed to be at
   // the beginning of the field list.  num_reference_instance_fields_
   // specifies the number of reference fields.
-  ObjectArray<Field>* ifields_;
+  ObjectArray<ArtField>* ifields_;
 
   // The interface table (iftable_) contains pairs of a interface class and an array of the
   // interface methods. There is one pair per interface supported by this class.  That means one
@@ -799,7 +799,7 @@ class MANAGED Class : public StaticStorageBase {
   String* name_;
 
   // Static fields
-  ObjectArray<Field>* sfields_;
+  ObjectArray<ArtField>* sfields_;
 
   // The superclass, or NULL if this is java.lang.Object, an interface or primitive type.
   Class* super_class_;
@@ -808,13 +808,13 @@ class MANAGED Class : public StaticStorageBase {
   Class* verify_error_class_;
 
   // virtual methods defined in this class; invoked through vtable
-  ObjectArray<AbstractMethod>* virtual_methods_;
+  ObjectArray<ArtMethod>* virtual_methods_;
 
   // Virtual method table (vtable), for use by "invoke-virtual".  The vtable from the superclass is
   // copied in, and virtual methods from our class either replace those from the super or are
   // appended. For abstract classes, methods may be created in the vtable that aren't in
   // virtual_ methods_ for miranda methods.
-  ObjectArray<AbstractMethod>* vtable_;
+  ObjectArray<ArtMethod>* vtable_;
 
   // access flags; low 16 bits are defined by VM spec
   uint32_t access_flags_;
diff --git a/runtime/mirror/dex_cache-inl.h b/runtime/mirror/dex_cache-inl.h
index 369dc49ed0..da26be59b9 100644
--- a/runtime/mirror/dex_cache-inl.h
+++ b/runtime/mirror/dex_cache-inl.h
@@ -22,9 +22,9 @@
 namespace art {
 namespace mirror {
 
-inline AbstractMethod* DexCache::GetResolvedMethod(uint32_t method_idx) const
+inline ArtMethod* DexCache::GetResolvedMethod(uint32_t method_idx) const
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  AbstractMethod* method = GetResolvedMethods()->Get(method_idx);
+  ArtMethod* method = GetResolvedMethods()->Get(method_idx);
   // Hide resolution trampoline methods from the caller
   if (method != NULL && method->IsRuntimeMethod()) {
     DCHECK(method == Runtime::Current()->GetResolutionMethod());
diff --git a/runtime/mirror/dex_cache.cc b/runtime/mirror/dex_cache.cc
index 239dc5e0c3..00531e3076 100644
--- a/runtime/mirror/dex_cache.cc
+++ b/runtime/mirror/dex_cache.cc
@@ -16,7 +16,7 @@
 
 #include "dex_cache.h"
 
-#include "abstract_method-inl.h"
+#include "art_method-inl.h"
 #include "base/logging.h"
 #include "class_linker.h"
 #include "gc/accounting/card_table-inl.h"
@@ -35,8 +35,8 @@ void DexCache::Init(const DexFile* dex_file,
                     String* location,
                     ObjectArray<String>* strings,
                     ObjectArray<Class>* resolved_types,
-                    ObjectArray<AbstractMethod>* resolved_methods,
-                    ObjectArray<Field>* resolved_fields,
+                    ObjectArray<ArtMethod>* resolved_methods,
+                    ObjectArray<ArtField>* resolved_fields,
                     ObjectArray<StaticStorageBase>* initialized_static_storage) {
   CHECK(dex_file != NULL);
   CHECK(location != NULL);
@@ -58,7 +58,7 @@ void DexCache::Init(const DexFile* dex_file,
   Runtime* runtime = Runtime::Current();
   if (runtime->HasResolutionMethod()) {
     // Initialize the resolve methods array to contain trampolines for resolution.
-    AbstractMethod* trampoline = runtime->GetResolutionMethod();
+    ArtMethod* trampoline = runtime->GetResolutionMethod();
     size_t length = resolved_methods->GetLength();
     for (size_t i = 0; i < length; i++) {
       resolved_methods->SetWithoutChecks(i, trampoline);
@@ -66,10 +66,10 @@ void DexCache::Init(const DexFile* dex_file,
   }
 }
 
-void DexCache::Fixup(AbstractMethod* trampoline) {
+void DexCache::Fixup(ArtMethod* trampoline) {
   // Fixup the resolve methods array to contain trampoline for resolution.
   CHECK(trampoline != NULL);
-  ObjectArray<AbstractMethod>* resolved_methods = GetResolvedMethods();
+  ObjectArray<ArtMethod>* resolved_methods = GetResolvedMethods();
   size_t length = resolved_methods->GetLength();
   for (size_t i = 0; i < length; i++) {
     if (resolved_methods->GetWithoutChecks(i) == NULL) {
diff --git a/runtime/mirror/dex_cache.h b/runtime/mirror/dex_cache.h
index 9c0f09ba21..6cfab9e425 100644
--- a/runtime/mirror/dex_cache.h
+++ b/runtime/mirror/dex_cache.h
@@ -17,7 +17,7 @@
 #ifndef ART_RUNTIME_MIRROR_DEX_CACHE_H_
 #define ART_RUNTIME_MIRROR_DEX_CACHE_H_
 
-#include "abstract_method.h"
+#include "art_method.h"
 #include "class.h"
 #include "object.h"
 #include "object_array.h"
@@ -32,8 +32,8 @@ union JValue;
 
 namespace mirror {
 
+class ArtField;
 class Class;
-class Field;
 
 class MANAGED DexCacheClass : public Class {
  private:
@@ -46,12 +46,12 @@ class MANAGED DexCache : public Object {
             String* location,
             ObjectArray<String>* strings,
             ObjectArray<Class>* types,
-            ObjectArray<AbstractMethod>* methods,
-            ObjectArray<Field>* fields,
+            ObjectArray<ArtMethod>* methods,
+            ObjectArray<ArtField>* fields,
             ObjectArray<StaticStorageBase>* initialized_static_storage)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void Fixup(AbstractMethod* trampoline) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void Fixup(ArtMethod* trampoline) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   String* GetLocation() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(DexCache, location_), false);
@@ -110,20 +110,20 @@ class MANAGED DexCache : public Object {
     GetResolvedTypes()->Set(type_idx, resolved);
   }
 
-  AbstractMethod* GetResolvedMethod(uint32_t method_idx) const
+  ArtMethod* GetResolvedMethod(uint32_t method_idx) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void SetResolvedMethod(uint32_t method_idx, AbstractMethod* resolved)
+  void SetResolvedMethod(uint32_t method_idx, ArtMethod* resolved)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     GetResolvedMethods()->Set(method_idx, resolved);
   }
 
-  Field* GetResolvedField(uint32_t field_idx) const
+  ArtField* GetResolvedField(uint32_t field_idx) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     return GetResolvedFields()->Get(field_idx);
   }
 
-  void SetResolvedField(uint32_t field_idx, Field* resolved)
+  void SetResolvedField(uint32_t field_idx, ArtField* resolved)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     GetResolvedFields()->Set(field_idx, resolved);
   }
@@ -139,14 +139,14 @@ class MANAGED DexCache : public Object {
         OFFSET_OF_OBJECT_MEMBER(DexCache, resolved_types_), false);
   }
 
-  ObjectArray<AbstractMethod>* GetResolvedMethods() const
+  ObjectArray<ArtMethod>* GetResolvedMethods() const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return GetFieldObject< ObjectArray<AbstractMethod>* >(ResolvedMethodsOffset(), false);
+    return GetFieldObject< ObjectArray<ArtMethod>* >(ResolvedMethodsOffset(), false);
   }
 
-  ObjectArray<Field>* GetResolvedFields() const
+  ObjectArray<ArtField>* GetResolvedFields() const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return GetFieldObject< ObjectArray<Field>* >(ResolvedFieldsOffset(), false);
+    return GetFieldObject< ObjectArray<ArtField>* >(ResolvedFieldsOffset(), false);
   }
 
   ObjectArray<StaticStorageBase>* GetInitializedStaticStorage() const
@@ -166,8 +166,8 @@ class MANAGED DexCache : public Object {
  private:
   ObjectArray<StaticStorageBase>* initialized_static_storage_;
   String* location_;
-  ObjectArray<Object>* resolved_fields_;
-  ObjectArray<AbstractMethod>* resolved_methods_;
+  ObjectArray<ArtField>* resolved_fields_;
+  ObjectArray<ArtMethod>* resolved_methods_;
   ObjectArray<Class>* resolved_types_;
   ObjectArray<String>* strings_;
   uint32_t dex_file_;
diff --git a/runtime/mirror/field-inl.h b/runtime/mirror/field-inl.h
deleted file mode 100644
index 3e3d6db4a6..0000000000
--- a/runtime/mirror/field-inl.h
+++ /dev/null
@@ -1,221 +0,0 @@
-/*
- * Copyright (C) 2011 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_RUNTIME_MIRROR_FIELD_INL_H_
-#define ART_RUNTIME_MIRROR_FIELD_INL_H_
-
-#include "field.h"
-
-#include "base/logging.h"
-#include "gc/accounting/card_table-inl.h"
-#include "jvalue.h"
-#include "object-inl.h"
-#include "object_utils.h"
-#include "primitive.h"
-
-namespace art {
-namespace mirror {
-
-inline Class* Field::GetDeclaringClass() const {
-  Class* result = GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Field, declaring_class_), false);
-  DCHECK(result != NULL);
-  DCHECK(result->IsLoaded() || result->IsErroneous());
-  return result;
-}
-
-inline void Field::SetDeclaringClass(Class *new_declaring_class) {
-  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Field, declaring_class_), new_declaring_class, false);
-}
-
-inline uint32_t Field::GetAccessFlags() const {
-  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-  return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, access_flags_), false);
-}
-
-inline MemberOffset Field::GetOffset() const {
-  DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
-  return MemberOffset(GetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_), false));
-}
-
-inline MemberOffset Field::GetOffsetDuringLinking() const {
-  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-  return MemberOffset(GetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_), false));
-}
-
-inline uint32_t Field::Get32(const Object* object) const {
-  DCHECK(object != NULL) << PrettyField(this);
-  DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
-  return object->GetField32(GetOffset(), IsVolatile());
-}
-
-inline void Field::Set32(Object* object, uint32_t new_value) const {
-  DCHECK(object != NULL) << PrettyField(this);
-  DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
-  object->SetField32(GetOffset(), new_value, IsVolatile());
-}
-
-inline uint64_t Field::Get64(const Object* object) const {
-  DCHECK(object != NULL) << PrettyField(this);
-  DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
-  return object->GetField64(GetOffset(), IsVolatile());
-}
-
-inline void Field::Set64(Object* object, uint64_t new_value) const {
-  DCHECK(object != NULL) << PrettyField(this);
-  DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
-  object->SetField64(GetOffset(), new_value, IsVolatile());
-}
-
-inline Object* Field::GetObj(const Object* object) const {
-  DCHECK(object != NULL) << PrettyField(this);
-  DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
-  return object->GetFieldObject<Object*>(GetOffset(), IsVolatile());
-}
-
-inline void Field::SetObj(Object* object, const Object* new_value) const {
-  DCHECK(object != NULL) << PrettyField(this);
-  DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
-  object->SetFieldObject(GetOffset(), new_value, IsVolatile());
-}
-
-inline bool Field::GetBoolean(const Object* object) const {
-  DCHECK_EQ(Primitive::kPrimBoolean, FieldHelper(this).GetTypeAsPrimitiveType())
-      << PrettyField(this);
-  return Get32(object);
-}
-
-inline void Field::SetBoolean(Object* object, bool z) const {
-  DCHECK_EQ(Primitive::kPrimBoolean, FieldHelper(this).GetTypeAsPrimitiveType())
-      << PrettyField(this);
-  Set32(object, z);
-}
-
-inline int8_t Field::GetByte(const Object* object) const {
-  DCHECK_EQ(Primitive::kPrimByte, FieldHelper(this).GetTypeAsPrimitiveType())
-      << PrettyField(this);
-  return Get32(object);
-}
-
-inline void Field::SetByte(Object* object, int8_t b) const {
-  DCHECK_EQ(Primitive::kPrimByte, FieldHelper(this).GetTypeAsPrimitiveType())
-      << PrettyField(this);
-  Set32(object, b);
-}
-
-inline uint16_t Field::GetChar(const Object* object) const {
-  DCHECK_EQ(Primitive::kPrimChar, FieldHelper(this).GetTypeAsPrimitiveType())
-      << PrettyField(this);
-  return Get32(object);
-}
-
-inline void Field::SetChar(Object* object, uint16_t c) const {
-  DCHECK_EQ(Primitive::kPrimChar, FieldHelper(this).GetTypeAsPrimitiveType())
-       << PrettyField(this);
-  Set32(object, c);
-}
-
-inline int16_t Field::GetShort(const Object* object) const {
-  DCHECK_EQ(Primitive::kPrimShort, FieldHelper(this).GetTypeAsPrimitiveType())
-       << PrettyField(this);
-  return Get32(object);
-}
-
-inline void Field::SetShort(Object* object, int16_t s) const {
-  DCHECK_EQ(Primitive::kPrimShort, FieldHelper(this).GetTypeAsPrimitiveType())
-       << PrettyField(this);
-  Set32(object, s);
-}
-
-inline int32_t Field::GetInt(const Object* object) const {
-#ifndef NDEBUG
-  Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
-  CHECK(type == Primitive::kPrimInt || type == Primitive::kPrimFloat) << PrettyField(this);
-#endif
-  return Get32(object);
-}
-
-inline void Field::SetInt(Object* object, int32_t i) const {
-#ifndef NDEBUG
-  Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
-  CHECK(type == Primitive::kPrimInt || type == Primitive::kPrimFloat) << PrettyField(this);
-#endif
-  Set32(object, i);
-}
-
-inline int64_t Field::GetLong(const Object* object) const {
-#ifndef NDEBUG
-  Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
-  CHECK(type == Primitive::kPrimLong || type == Primitive::kPrimDouble) << PrettyField(this);
-#endif
-  return Get64(object);
-}
-
-inline void Field::SetLong(Object* object, int64_t j) const {
-#ifndef NDEBUG
-  Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
-  CHECK(type == Primitive::kPrimLong || type == Primitive::kPrimDouble) << PrettyField(this);
-#endif
-  Set64(object, j);
-}
-
-inline float Field::GetFloat(const Object* object) const {
-  DCHECK_EQ(Primitive::kPrimFloat, FieldHelper(this).GetTypeAsPrimitiveType())
-       << PrettyField(this);
-  JValue bits;
-  bits.SetI(Get32(object));
-  return bits.GetF();
-}
-
-inline void Field::SetFloat(Object* object, float f) const {
-  DCHECK_EQ(Primitive::kPrimFloat, FieldHelper(this).GetTypeAsPrimitiveType())
-       << PrettyField(this);
-  JValue bits;
-  bits.SetF(f);
-  Set32(object, bits.GetI());
-}
-
-inline double Field::GetDouble(const Object* object) const {
-  DCHECK_EQ(Primitive::kPrimDouble, FieldHelper(this).GetTypeAsPrimitiveType())
-       << PrettyField(this);
-  JValue bits;
-  bits.SetJ(Get64(object));
-  return bits.GetD();
-}
-
-inline void Field::SetDouble(Object* object, double d) const {
-  DCHECK_EQ(Primitive::kPrimDouble, FieldHelper(this).GetTypeAsPrimitiveType())
-       << PrettyField(this);
-  JValue bits;
-  bits.SetD(d);
-  Set64(object, bits.GetJ());
-}
-
-inline Object* Field::GetObject(const Object* object) const {
-  DCHECK_EQ(Primitive::kPrimNot, FieldHelper(this).GetTypeAsPrimitiveType())
-       << PrettyField(this);
-  return GetObj(object);
-}
-
-inline void Field::SetObject(Object* object, const Object* l) const {
-  DCHECK_EQ(Primitive::kPrimNot, FieldHelper(this).GetTypeAsPrimitiveType())
-       << PrettyField(this);
-  SetObj(object, l);
-}
-
-}  // namespace mirror
-}  // namespace art
-
-#endif  // ART_RUNTIME_MIRROR_FIELD_INL_H_
diff --git a/runtime/mirror/field.cc b/runtime/mirror/field.cc
deleted file mode 100644
index 12f395f6b6..0000000000
--- a/runtime/mirror/field.cc
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 2011 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.
- */
-
-#include "field.h"
-
-#include "field-inl.h"
-#include "gc/accounting/card_table-inl.h"
-#include "object-inl.h"
-#include "object_utils.h"
-#include "runtime.h"
-#include "utils.h"
-
-namespace art {
-namespace mirror {
-
-// TODO: get global references for these
-Class* Field::java_lang_reflect_Field_ = NULL;
-
-void Field::SetClass(Class* java_lang_reflect_Field) {
-  CHECK(java_lang_reflect_Field_ == NULL);
-  CHECK(java_lang_reflect_Field != NULL);
-  java_lang_reflect_Field_ = java_lang_reflect_Field;
-}
-
-void Field::ResetClass() {
-  CHECK(java_lang_reflect_Field_ != NULL);
-  java_lang_reflect_Field_ = NULL;
-}
-
-void Field::SetOffset(MemberOffset num_bytes) {
-  DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-#if 0  // TODO enable later in boot and under !NDEBUG
-  FieldHelper fh(this);
-  Primitive::Type type = fh.GetTypeAsPrimitiveType();
-  if (type == Primitive::kPrimDouble || type == Primitive::kPrimLong) {
-    DCHECK_ALIGNED(num_bytes.Uint32Value(), 8);
-  }
-#endif
-  SetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_), num_bytes.Uint32Value(), false);
-}
-
-}  // namespace mirror
-}  // namespace art
diff --git a/runtime/mirror/field.h b/runtime/mirror/field.h
deleted file mode 100644
index 6e508a362f..0000000000
--- a/runtime/mirror/field.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Copyright (C) 2011 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_RUNTIME_MIRROR_FIELD_H_
-#define ART_RUNTIME_MIRROR_FIELD_H_
-
-#include "class.h"
-#include "modifiers.h"
-#include "object.h"
-
-namespace art {
-
-struct FieldClassOffsets;
-struct FieldOffsets;
-
-namespace mirror {
-
-// C++ mirror of java.lang.reflect.Field
-class MANAGED Field : public Object {
- public:
-  Class* GetDeclaringClass() const;
-
-  void SetDeclaringClass(Class *new_declaring_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  uint32_t GetAccessFlags() const;
-
-  void SetAccessFlags(uint32_t new_access_flags) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(Field, access_flags_), new_access_flags, false);
-  }
-
-  bool IsPublic() const {
-    return (GetAccessFlags() & kAccPublic) != 0;
-  }
-
-  bool IsStatic() const {
-    return (GetAccessFlags() & kAccStatic) != 0;
-  }
-
-  bool IsFinal() const {
-    return (GetAccessFlags() & kAccFinal) != 0;
-  }
-
-  uint32_t GetDexFieldIndex() const {
-    return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, field_dex_idx_), false);
-  }
-
-  void SetDexFieldIndex(uint32_t new_idx) {
-    SetField32(OFFSET_OF_OBJECT_MEMBER(Field, field_dex_idx_), new_idx, false);
-  }
-
-  // Offset to field within an Object
-  MemberOffset GetOffset() const;
-
-  static MemberOffset OffsetOffset() {
-    return MemberOffset(OFFSETOF_MEMBER(Field, offset_));
-  }
-
-  MemberOffset GetOffsetDuringLinking() const;
-
-  void SetOffset(MemberOffset num_bytes);
-
-  // field access, null object for static fields
-  bool GetBoolean(const Object* object) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void SetBoolean(Object* object, bool z) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  int8_t GetByte(const Object* object) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void SetByte(Object* object, int8_t b) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  uint16_t GetChar(const Object* object) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void SetChar(Object* object, uint16_t c) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  int16_t GetShort(const Object* object) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void SetShort(Object* object, int16_t s) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  int32_t GetInt(const Object* object) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void SetInt(Object* object, int32_t i) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  int64_t GetLong(const Object* object) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void SetLong(Object* object, int64_t j) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  float GetFloat(const Object* object) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void SetFloat(Object* object, float f) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  double GetDouble(const Object* object) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void SetDouble(Object* object, double d) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  Object* GetObject(const Object* object) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void SetObject(Object* object, const Object* l) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  // raw field accesses
-  uint32_t Get32(const Object* object) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void Set32(Object* object, uint32_t new_value) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  uint64_t Get64(const Object* object) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void Set64(Object* object, uint64_t new_value) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  Object* GetObj(const Object* object) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  void SetObj(Object* object, const Object* new_value) const
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
-  static Class* GetJavaLangReflectField() {
-    DCHECK(java_lang_reflect_Field_ != NULL);
-    return java_lang_reflect_Field_;
-  }
-
-  static void SetClass(Class* java_lang_reflect_Field);
-  static void ResetClass();
-
-  bool IsVolatile() const {
-    return (GetAccessFlags() & kAccVolatile) != 0;
-  }
-
- private:
-  // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
-  // The class we are a part of
-  Class* declaring_class_;
-
-  uint32_t access_flags_;
-
-  // Dex cache index of field id
-  uint32_t field_dex_idx_;
-
-  // Offset of field within an instance or in the Class' static fields
-  uint32_t offset_;
-
-  static Class* java_lang_reflect_Field_;
-
-  friend struct art::FieldOffsets;  // for verifying offset information
-  DISALLOW_IMPLICIT_CONSTRUCTORS(Field);
-};
-
-class MANAGED FieldClass : public Class {
- private:
-  Object* ORDER_BY_NAME_AND_DECLARING_CLASS_;
-  friend struct art::FieldClassOffsets;  // for verifying offset information
-  DISALLOW_IMPLICIT_CONSTRUCTORS(FieldClass);
-};
-
-}  // namespace mirror
-}  // namespace art
-
-#endif  // ART_RUNTIME_MIRROR_FIELD_H_
diff --git a/runtime/mirror/iftable.h b/runtime/mirror/iftable.h
index aea8fddafe..421893d3db 100644
--- a/runtime/mirror/iftable.h
+++ b/runtime/mirror/iftable.h
@@ -32,24 +32,24 @@ class MANAGED IfTable : public ObjectArray<Object> {
 
   void SetInterface(int32_t i, Class* interface) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  ObjectArray<AbstractMethod>* GetMethodArray(int32_t i) const
+  ObjectArray<ArtMethod>* GetMethodArray(int32_t i) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    ObjectArray<AbstractMethod>* method_array =
-        down_cast<ObjectArray<AbstractMethod>*>(Get((i * kMax) + kMethodArray));
+    ObjectArray<ArtMethod>* method_array =
+        down_cast<ObjectArray<ArtMethod>*>(Get((i * kMax) + kMethodArray));
     DCHECK(method_array != NULL);
     return method_array;
   }
 
   size_t GetMethodArrayCount(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    ObjectArray<AbstractMethod>* method_array =
-        down_cast<ObjectArray<AbstractMethod>*>(Get((i * kMax) + kMethodArray));
+    ObjectArray<ArtMethod>* method_array =
+        down_cast<ObjectArray<ArtMethod>*>(Get((i * kMax) + kMethodArray));
     if (method_array == NULL) {
       return 0;
     }
     return method_array->GetLength();
   }
 
-  void SetMethodArray(int32_t i, ObjectArray<AbstractMethod>* new_ma)
+  void SetMethodArray(int32_t i, ObjectArray<ArtMethod>* new_ma)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     DCHECK(new_ma != NULL);
     DCHECK(Get((i * kMax) + kMethodArray) == NULL);
diff --git a/runtime/mirror/object-inl.h b/runtime/mirror/object-inl.h
index 5818a800bf..63396d2f59 100644
--- a/runtime/mirror/object-inl.h
+++ b/runtime/mirror/object-inl.h
@@ -19,10 +19,10 @@
 
 #include "object.h"
 
-#include "abstract_method.h"
+#include "art_field.h"
+#include "art_method.h"
 #include "atomic.h"
 #include "array-inl.h"
-#include "field.h"
 #include "class.h"
 #include "monitor.h"
 #include "runtime.h"
@@ -112,32 +112,32 @@ inline bool Object::IsArrayInstance() const {
   return GetClass()->IsArrayClass();
 }
 
-inline bool Object::IsField() const {
-  return GetClass()->IsFieldClass();
+inline bool Object::IsArtField() const {
+  return GetClass()->IsArtFieldClass();
 }
 
-inline Field* Object::AsField() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  DCHECK(IsField());
-  return down_cast<Field*>(this);
+inline ArtField* Object::AsArtField() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  DCHECK(IsArtField());
+  return down_cast<ArtField*>(this);
 }
 
-inline const Field* Object::AsField() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  DCHECK(IsField());
-  return down_cast<const Field*>(this);
+inline const ArtField* Object::AsArtField() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  DCHECK(IsArtField());
+  return down_cast<const ArtField*>(this);
 }
 
-inline bool Object::IsMethod() const {
-  return GetClass()->IsMethodClass();
+inline bool Object::IsArtMethod() const {
+  return GetClass()->IsArtMethodClass();
 }
 
-inline AbstractMethod* Object::AsMethod() {
-  DCHECK(IsMethod());
-  return down_cast<AbstractMethod*>(this);
+inline ArtMethod* Object::AsArtMethod() {
+  DCHECK(IsArtMethod());
+  return down_cast<ArtMethod*>(this);
 }
 
-inline const AbstractMethod* Object::AsMethod() const {
-  DCHECK(IsMethod());
-  return down_cast<const AbstractMethod*>(this);
+inline const ArtMethod* Object::AsArtMethod() const {
+  DCHECK(IsArtMethod());
+  return down_cast<const ArtMethod*>(this);
 }
 
 inline bool Object::IsReferenceInstance() const {
@@ -227,8 +227,8 @@ inline size_t Object::SizeOf() const {
   } else {
     result = GetClass()->GetObjectSize();
   }
-  DCHECK(!IsField()  || result == sizeof(Field));
-  DCHECK(!IsMethod() || result == sizeof(AbstractMethod));
+  DCHECK(!IsArtField()  || result == sizeof(ArtField));
+  DCHECK(!IsArtMethod() || result == sizeof(ArtMethod));
   return result;
 }
 
diff --git a/runtime/mirror/object.cc b/runtime/mirror/object.cc
index b2d6e71478..92c05b26ca 100644
--- a/runtime/mirror/object.cc
+++ b/runtime/mirror/object.cc
@@ -16,12 +16,12 @@
 
 #include "object.h"
 
+#include "art_field.h"
+#include "art_field-inl.h"
 #include "array-inl.h"
 #include "class.h"
 #include "class-inl.h"
 #include "class_linker-inl.h"
-#include "field.h"
-#include "field-inl.h"
 #include "gc/accounting/card_table-inl.h"
 #include "gc/heap.h"
 #include "iftable-inl.h"
@@ -67,7 +67,7 @@ Object* Object::Clone(Thread* self) {
     for (const Class* klass = c; klass != NULL; klass = klass->GetSuperClass()) {
       size_t num_reference_fields = klass->NumReferenceInstanceFields();
       for (size_t i = 0; i < num_reference_fields; ++i) {
-        Field* field = klass->GetInstanceField(i);
+        ArtField* field = klass->GetInstanceField(i);
         MemberOffset field_offset = field->GetOffset();
         const Object* ref = copy->GetFieldObject<const Object*>(field_offset, false);
         heap->WriteBarrierField(copy.get(), field_offset, ref);
@@ -90,11 +90,11 @@ void Object::CheckFieldAssignmentImpl(MemberOffset field_offset, const Object* n
     return;
   }
   for (const Class* cur = c; cur != NULL; cur = cur->GetSuperClass()) {
-    ObjectArray<Field>* fields = cur->GetIFields();
+    ObjectArray<ArtField>* fields = cur->GetIFields();
     if (fields != NULL) {
       size_t num_ref_ifields = cur->NumReferenceInstanceFields();
       for (size_t i = 0; i < num_ref_ifields; ++i) {
-        Field* field = fields->Get(i);
+        ArtField* field = fields->Get(i);
         if (field->GetOffset().Int32Value() == field_offset.Int32Value()) {
           FieldHelper fh(field);
           CHECK(fh.GetType()->IsAssignableFrom(new_value->GetClass()));
@@ -108,11 +108,11 @@ void Object::CheckFieldAssignmentImpl(MemberOffset field_offset, const Object* n
     return;
   }
   if (IsClass()) {
-    ObjectArray<Field>* fields = AsClass()->GetSFields();
+    ObjectArray<ArtField>* fields = AsClass()->GetSFields();
     if (fields != NULL) {
       size_t num_ref_sfields = AsClass()->NumReferenceStaticFields();
       for (size_t i = 0; i < num_ref_sfields; ++i) {
-        Field* field = fields->Get(i);
+        ArtField* field = fields->Get(i);
         if (field->GetOffset().Int32Value() == field_offset.Int32Value()) {
           FieldHelper fh(field);
           CHECK(fh.GetType()->IsAssignableFrom(new_value->GetClass()));
diff --git a/runtime/mirror/object.h b/runtime/mirror/object.h
index a40c906eb0..28a91dd8e5 100644
--- a/runtime/mirror/object.h
+++ b/runtime/mirror/object.h
@@ -31,10 +31,10 @@ class Thread;
 
 namespace mirror {
 
-class AbstractMethod;
+class ArtField;
+class ArtMethod;
 class Array;
 class Class;
-class Field;
 template<class T> class ObjectArray;
 template<class T> class PrimitiveArray;
 typedef PrimitiveArray<uint8_t> BooleanArray;
@@ -144,17 +144,17 @@ class MANAGED Object {
 
   Throwable* AsThrowable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  bool IsMethod() const;
+  bool IsArtMethod() const;
 
-  AbstractMethod* AsMethod();
+  ArtMethod* AsArtMethod();
 
-  const AbstractMethod* AsMethod() const;
+  const ArtMethod* AsArtMethod() const;
 
-  bool IsField() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  bool IsArtField() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  Field* AsField() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  ArtField* AsArtField() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  const Field* AsField() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  const ArtField* AsArtField() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   bool IsReferenceInstance() const;
 
diff --git a/runtime/mirror/object_array-inl.h b/runtime/mirror/object_array-inl.h
index 8675c31b37..6f22618340 100644
--- a/runtime/mirror/object_array-inl.h
+++ b/runtime/mirror/object_array-inl.h
@@ -20,8 +20,8 @@
 #include "object_array.h"
 
 #include "gc/heap.h"
+#include "mirror/art_field.h"
 #include "mirror/class.h"
-#include "mirror/field.h"
 #include "runtime.h"
 #include "thread.h"
 
diff --git a/runtime/mirror/object_test.cc b/runtime/mirror/object_test.cc
index 540ff9f68e..814305c3af 100644
--- a/runtime/mirror/object_test.cc
+++ b/runtime/mirror/object_test.cc
@@ -20,6 +20,7 @@
 #include <stdio.h>
 
 #include "array-inl.h"
+#include "art_field-inl.h"
 #include "asm_support.h"
 #include "class-inl.h"
 #include "class_linker.h"
@@ -27,11 +28,10 @@
 #include "common_test.h"
 #include "dex_file.h"
 #include "entrypoints/entrypoint_utils.h"
-#include "field-inl.h"
 #include "gc/accounting/card_table-inl.h"
 #include "gc/heap.h"
 #include "iftable-inl.h"
-#include "abstract_method-inl.h"
+#include "art_method-inl.h"
 #include "object-inl.h"
 #include "object_array-inl.h"
 #include "sirt_ref.h"
@@ -75,7 +75,7 @@ TEST_F(ObjectTest, AsmConstants) {
   ASSERT_EQ(STRING_OFFSET_OFFSET, String::OffsetOffset().Int32Value());
   ASSERT_EQ(STRING_DATA_OFFSET, Array::DataOffset(sizeof(uint16_t)).Int32Value());
 
-  ASSERT_EQ(METHOD_CODE_OFFSET, AbstractMethod::EntryPointFromCompiledCodeOffset().Int32Value());
+  ASSERT_EQ(METHOD_CODE_OFFSET, ArtMethod::EntryPointFromCompiledCodeOffset().Int32Value());
 }
 
 TEST_F(ObjectTest, IsInSamePackage) {
@@ -204,7 +204,7 @@ TEST_F(ObjectTest, CheckAndAllocArrayFromCode) {
   // pretend we are trying to call 'new char[3]' from String.toCharArray
   ScopedObjectAccess soa(Thread::Current());
   Class* java_util_Arrays = class_linker_->FindSystemClass("Ljava/util/Arrays;");
-  AbstractMethod* sort = java_util_Arrays->FindDirectMethod("sort", "([I)V");
+  ArtMethod* sort = java_util_Arrays->FindDirectMethod("sort", "([I)V");
   const DexFile::StringId* string_id = java_lang_dex_file_->FindStringId("[I");
   ASSERT_TRUE(string_id != NULL);
   const DexFile::TypeId* type_id = java_lang_dex_file_->FindTypeId(
@@ -261,7 +261,7 @@ TEST_F(ObjectTest, StaticFieldFromCode) {
 
   Class* klass =
       class_linker_->FindClass("LStaticsFromCode;", soa.Decode<ClassLoader*>(class_loader));
-  AbstractMethod* clinit = klass->FindDirectMethod("<clinit>", "()V");
+  ArtMethod* clinit = klass->FindDirectMethod("<clinit>", "()V");
   const DexFile::StringId* klass_string_id = dex_file->FindStringId("LStaticsFromCode;");
   ASSERT_TRUE(klass_string_id != NULL);
   const DexFile::TypeId* klass_type_id = dex_file->FindTypeId(
@@ -282,8 +282,8 @@ TEST_F(ObjectTest, StaticFieldFromCode) {
   ASSERT_TRUE(field_id != NULL);
   uint32_t field_idx = dex_file->GetIndexForFieldId(*field_id);
 
-  Field* field = FindFieldFromCode(field_idx, clinit, Thread::Current(), StaticObjectRead,
-                                   sizeof(Object*), true);
+  ArtField* field = FindFieldFromCode(field_idx, clinit, Thread::Current(), StaticObjectRead,
+                                      sizeof(Object*), true);
   Object* s0 = field->GetObj(klass);
   EXPECT_TRUE(s0 != NULL);
 
@@ -294,7 +294,7 @@ TEST_F(ObjectTest, StaticFieldFromCode) {
   field->SetObj(field->GetDeclaringClass(), NULL);
   EXPECT_EQ(NULL, field->GetObj(klass));
 
-  // TODO: more exhaustive tests of all 6 cases of Field::*FromCode
+  // TODO: more exhaustive tests of all 6 cases of ArtField::*FromCode
 }
 
 TEST_F(ObjectTest, String) {
@@ -395,29 +395,29 @@ TEST_F(ObjectTest, DescriptorCompare) {
   Class* klass2 = linker->FindClass("LProtoCompare2;", class_loader_2.get());
   ASSERT_TRUE(klass2 != NULL);
 
-  AbstractMethod* m1_1 = klass1->GetVirtualMethod(0);
+  ArtMethod* m1_1 = klass1->GetVirtualMethod(0);
   MethodHelper mh(m1_1);
   EXPECT_STREQ(mh.GetName(), "m1");
-  AbstractMethod* m2_1 = klass1->GetVirtualMethod(1);
+  ArtMethod* m2_1 = klass1->GetVirtualMethod(1);
   mh.ChangeMethod(m2_1);
   EXPECT_STREQ(mh.GetName(), "m2");
-  AbstractMethod* m3_1 = klass1->GetVirtualMethod(2);
+  ArtMethod* m3_1 = klass1->GetVirtualMethod(2);
   mh.ChangeMethod(m3_1);
   EXPECT_STREQ(mh.GetName(), "m3");
-  AbstractMethod* m4_1 = klass1->GetVirtualMethod(3);
+  ArtMethod* m4_1 = klass1->GetVirtualMethod(3);
   mh.ChangeMethod(m4_1);
   EXPECT_STREQ(mh.GetName(), "m4");
 
-  AbstractMethod* m1_2 = klass2->GetVirtualMethod(0);
+  ArtMethod* m1_2 = klass2->GetVirtualMethod(0);
   mh.ChangeMethod(m1_2);
   EXPECT_STREQ(mh.GetName(), "m1");
-  AbstractMethod* m2_2 = klass2->GetVirtualMethod(1);
+  ArtMethod* m2_2 = klass2->GetVirtualMethod(1);
   mh.ChangeMethod(m2_2);
   EXPECT_STREQ(mh.GetName(), "m2");
-  AbstractMethod* m3_2 = klass2->GetVirtualMethod(2);
+  ArtMethod* m3_2 = klass2->GetVirtualMethod(2);
   mh.ChangeMethod(m3_2);
   EXPECT_STREQ(mh.GetName(), "m3");
-  AbstractMethod* m4_2 = klass2->GetVirtualMethod(3);
+  ArtMethod* m4_2 = klass2->GetVirtualMethod(3);
   mh.ChangeMethod(m4_2);
   EXPECT_STREQ(mh.GetName(), "m4");
 
@@ -593,8 +593,8 @@ TEST_F(ObjectTest, FindInstanceField) {
   EXPECT_TRUE(c->FindInstanceField("Count", "I") == NULL);
 
   // Right name and type.
-  Field* f1 = c->FindDeclaredInstanceField("count", "I");
-  Field* f2 = c->FindInstanceField("count", "I");
+  ArtField* f1 = c->FindDeclaredInstanceField("count", "I");
+  ArtField* f2 = c->FindInstanceField("count", "I");
   EXPECT_TRUE(f1 != NULL);
   EXPECT_TRUE(f2 != NULL);
   EXPECT_EQ(f1, f2);
@@ -626,8 +626,8 @@ TEST_F(ObjectTest, FindStaticField) {
   EXPECT_TRUE(c->FindStaticField("cASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;") == NULL);
 
   // Right name and type.
-  Field* f1 = c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;");
-  Field* f2 = c->FindStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;");
+  ArtField* f1 = c->FindDeclaredStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;");
+  ArtField* f2 = c->FindStaticField("CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;");
   EXPECT_TRUE(f1 != NULL);
   EXPECT_TRUE(f2 != NULL);
   EXPECT_EQ(f1, f2);
diff --git a/runtime/mirror/throwable.cc b/runtime/mirror/throwable.cc
index 78b76dc6ef..961f6deed3 100644
--- a/runtime/mirror/throwable.cc
+++ b/runtime/mirror/throwable.cc
@@ -16,7 +16,7 @@
 
 #include "throwable.h"
 
-#include "abstract_method-inl.h"
+#include "art_method-inl.h"
 #include "class-inl.h"
 #include "dex_file-inl.h"
 #include "gc/accounting/card_table-inl.h"
@@ -65,7 +65,7 @@ std::string Throwable::Dump() const {
     IntArray* pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
     MethodHelper mh;
     for (int32_t i = 0; i < depth; ++i) {
-      AbstractMethod* method = down_cast<AbstractMethod*>(method_trace->Get(i));
+      ArtMethod* method = down_cast<ArtMethod*>(method_trace->Get(i));
       mh.ChangeMethod(method);
       uint32_t dex_pc = pc_trace->Get(i);
       int32_t line_number = mh.GetLineNumFromDexPC(dex_pc);
diff --git a/runtime/monitor.cc b/runtime/monitor.cc
index 09a952b3cf..48c05692b4 100644
--- a/runtime/monitor.cc
+++ b/runtime/monitor.cc
@@ -23,7 +23,7 @@
 #include "class_linker.h"
 #include "dex_file-inl.h"
 #include "dex_instruction.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
@@ -204,7 +204,7 @@ void Monitor::Lock(Thread* self) {
     uint64_t waitStart = 0;
     uint64_t waitEnd = 0;
     uint32_t wait_threshold = lock_profiling_threshold_;
-    const mirror::AbstractMethod* current_locking_method = NULL;
+    const mirror::ArtMethod* current_locking_method = NULL;
     uint32_t current_locking_dex_pc = 0;
     {
       ScopedThreadStateChange tsc(self, kBlocked);
@@ -433,7 +433,7 @@ void Monitor::WaitWithLock(Thread* self, int64_t ms, int32_t ns,
   int prev_lock_count = lock_count_;
   lock_count_ = 0;
   owner_ = NULL;
-  const mirror::AbstractMethod* saved_method = locking_method_;
+  const mirror::ArtMethod* saved_method = locking_method_;
   locking_method_ = NULL;
   uintptr_t saved_dex_pc = locking_dex_pc_;
   locking_dex_pc_ = 0;
@@ -888,7 +888,7 @@ mirror::Object* Monitor::GetContendedMonitor(Thread* thread) {
 
 void Monitor::VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::Object*, void*),
                          void* callback_context) {
-  mirror::AbstractMethod* m = stack_visitor->GetMethod();
+  mirror::ArtMethod* m = stack_visitor->GetMethod();
   CHECK(m != NULL);
 
   // Native methods are an easy special case.
@@ -948,7 +948,7 @@ void Monitor::VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::O
   }
 }
 
-void Monitor::TranslateLocation(const mirror::AbstractMethod* method, uint32_t dex_pc,
+void Monitor::TranslateLocation(const mirror::ArtMethod* method, uint32_t dex_pc,
                                 const char*& source_file, uint32_t& line_number) const {
   // If method is null, location is unknown
   if (method == NULL) {
diff --git a/runtime/monitor.h b/runtime/monitor.h
index 3b06217374..02c10a7a10 100644
--- a/runtime/monitor.h
+++ b/runtime/monitor.h
@@ -56,8 +56,8 @@ namespace art {
 #define LW_LOCK_OWNER(x) (((x) >> LW_LOCK_OWNER_SHIFT) & LW_LOCK_OWNER_MASK)
 
 namespace mirror {
-class AbstractMethod;
-class Object;
+  class ArtMethod;
+  class Object;
 }  // namespace mirror
 class Thread;
 class StackVisitor;
@@ -141,7 +141,7 @@ class Monitor {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Translates the provided method and pc into its declaring class' source file and line number.
-  void TranslateLocation(const mirror::AbstractMethod* method, uint32_t pc,
+  void TranslateLocation(const mirror::ArtMethod* method, uint32_t pc,
                          const char*& source_file, uint32_t& line_number) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -165,7 +165,7 @@ class Monitor {
   // Method and dex pc where the lock owner acquired the lock, used when lock
   // sampling is enabled. locking_method_ may be null if the lock is currently
   // unlocked, or if the lock is acquired by the system when the stack is empty.
-  const mirror::AbstractMethod* locking_method_ GUARDED_BY(monitor_lock_);
+  const mirror::ArtMethod* locking_method_ GUARDED_BY(monitor_lock_);
   uint32_t locking_dex_pc_ GUARDED_BY(monitor_lock_);
 
   friend class MonitorInfo;
diff --git a/runtime/monitor_android.cc b/runtime/monitor_android.cc
index 9265cd649d..8efa0721e8 100644
--- a/runtime/monitor_android.cc
+++ b/runtime/monitor_android.cc
@@ -78,7 +78,7 @@ void Monitor::LogContentionEvent(Thread* self, uint32_t wait_ms, uint32_t sample
 
   // Emit the source code file name, <= 37 bytes.
   uint32_t pc;
-  mirror::AbstractMethod* m = self->GetCurrentMethod(&pc);
+  mirror::ArtMethod* m = self->GetCurrentMethod(&pc);
   const char* filename;
   uint32_t line_number;
   TranslateLocation(m, pc, filename, line_number);
diff --git a/runtime/native/dalvik_system_VMStack.cc b/runtime/native/dalvik_system_VMStack.cc
index 1a80d6286b..eaf67b8f02 100644
--- a/runtime/native/dalvik_system_VMStack.cc
+++ b/runtime/native/dalvik_system_VMStack.cc
@@ -16,7 +16,7 @@
 
 #include "jni_internal.h"
 #include "nth_caller_visitor.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
 #include "mirror/object-inl.h"
diff --git a/runtime/native/java_lang_reflect_Constructor.cc b/runtime/native/java_lang_reflect_Constructor.cc
index 918021748b..85556ac16e 100644
--- a/runtime/native/java_lang_reflect_Constructor.cc
+++ b/runtime/native/java_lang_reflect_Constructor.cc
@@ -16,13 +16,14 @@
 
 #include "class_linker.h"
 #include "jni_internal.h"
+#include "mirror/art_method.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
-#include "mirror/abstract_method.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
 #include "object_utils.h"
 #include "reflection.h"
 #include "scoped_thread_state_change.h"
+#include "well_known_classes.h"
 
 namespace art {
 
@@ -35,7 +36,10 @@ namespace art {
  */
 static jobject Constructor_newInstance(JNIEnv* env, jobject javaMethod, jobjectArray javaArgs) {
   ScopedObjectAccess soa(env);
-  mirror::AbstractMethod* m = soa.Decode<mirror::Object*>(javaMethod)->AsMethod();
+  jobject art_method = soa.Env()->GetObjectField(
+      javaMethod, WellKnownClasses::java_lang_reflect_AbstractMethod_artMethod);
+
+  mirror::ArtMethod* m = soa.Decode<mirror::Object*>(art_method)->AsArtMethod();
   mirror::Class* c = m->GetDeclaringClass();
   if (UNLIKELY(c->IsAbstract())) {
     ThrowLocation throw_location = soa.Self()->GetCurrentLocationForThrow();
diff --git a/runtime/native/java_lang_reflect_Field.cc b/runtime/native/java_lang_reflect_Field.cc
index b0daa916c6..00f89b65ea 100644
--- a/runtime/native/java_lang_reflect_Field.cc
+++ b/runtime/native/java_lang_reflect_Field.cc
@@ -19,16 +19,15 @@
 #include "common_throws.h"
 #include "dex_file-inl.h"
 #include "jni_internal.h"
+#include "mirror/art_field-inl.h"
 #include "mirror/class-inl.h"
-#include "mirror/field.h"
-#include "mirror/field-inl.h"
 #include "object_utils.h"
 #include "reflection.h"
 #include "scoped_thread_state_change.h"
 
 namespace art {
 
-static bool GetFieldValue(const ScopedObjectAccess& soa, mirror::Object* o, mirror::Field* f,
+static bool GetFieldValue(const ScopedObjectAccess& soa, mirror::Object* o, mirror::ArtField* f,
                           JValue& value, bool allow_references)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK_EQ(value.GetJ(), 0LL);
@@ -78,7 +77,7 @@ static bool GetFieldValue(const ScopedObjectAccess& soa, mirror::Object* o, mirr
   return false;
 }
 
-static bool CheckReceiver(const ScopedObjectAccess& soa, jobject j_rcvr, mirror::Field* f,
+static bool CheckReceiver(const ScopedObjectAccess& soa, jobject j_rcvr, mirror::ArtField* f,
                           mirror::Object*& class_or_rcvr)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   if (f->IsStatic()) {
@@ -96,7 +95,7 @@ static bool CheckReceiver(const ScopedObjectAccess& soa, jobject j_rcvr, mirror:
 
 static jobject Field_get(JNIEnv* env, jobject javaField, jobject javaObj) {
   ScopedObjectAccess soa(env);
-  mirror::Field* f = soa.DecodeField(env->FromReflectedField(javaField));
+  mirror::ArtField* f = soa.DecodeField(env->FromReflectedField(javaField));
   mirror::Object* o = NULL;
   if (!CheckReceiver(soa, javaObj, f, o)) {
     return NULL;
@@ -111,9 +110,10 @@ static jobject Field_get(JNIEnv* env, jobject javaField, jobject javaObj) {
       soa.AddLocalReference<jobject>(BoxPrimitive(FieldHelper(f).GetTypeAsPrimitiveType(), value));
 }
 
-static JValue GetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char dst_descriptor) {
+static JValue GetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj,
+                                char dst_descriptor) {
   ScopedObjectAccess soa(env);
-  mirror::Field* f = soa.DecodeField(env->FromReflectedField(javaField));
+  mirror::ArtField* f = soa.DecodeField(env->FromReflectedField(javaField));
   mirror::Object* o = NULL;
   if (!CheckReceiver(soa, javaObj, f, o)) {
     return JValue();
@@ -127,7 +127,8 @@ static JValue GetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj,
 
   // Widen it if necessary (and possible).
   JValue wide_value;
-  mirror::Class* dst_type = Runtime::Current()->GetClassLinker()->FindPrimitiveClass(dst_descriptor);
+  mirror::Class* dst_type =
+      Runtime::Current()->GetClassLinker()->FindPrimitiveClass(dst_descriptor);
   if (!ConvertPrimitiveValue(NULL, false, FieldHelper(f).GetTypeAsPrimitiveType(),
                              dst_type->GetPrimitiveType(), field_value, wide_value)) {
     return JValue();
@@ -167,7 +168,7 @@ static jshort Field_getShort(JNIEnv* env, jobject javaField, jobject javaObj) {
   return GetPrimitiveField(env, javaField, javaObj, 'S').GetS();
 }
 
-static void SetFieldValue(mirror::Object* o, mirror::Field* f, const JValue& new_value,
+static void SetFieldValue(mirror::Object* o, mirror::ArtField* f, const JValue& new_value,
                           bool allow_references)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(f->GetDeclaringClass(),
@@ -221,7 +222,7 @@ static void SetFieldValue(mirror::Object* o, mirror::Field* f, const JValue& new
 
 static void Field_set(JNIEnv* env, jobject javaField, jobject javaObj, jobject javaValue) {
   ScopedObjectAccess soa(env);
-  mirror::Field* f = soa.DecodeField(env->FromReflectedField(javaField));
+  mirror::ArtField* f = soa.DecodeField(env->FromReflectedField(javaField));
 
   // Unbox the value, if necessary.
   mirror::Object* boxed_value = soa.Decode<mirror::Object*>(javaValue);
@@ -242,7 +243,7 @@ static void Field_set(JNIEnv* env, jobject javaField, jobject javaObj, jobject j
 static void SetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char src_descriptor,
                               const JValue& new_value) {
   ScopedObjectAccess soa(env);
-  mirror::Field* f = soa.DecodeField(env->FromReflectedField(javaField));
+  mirror::ArtField* f = soa.DecodeField(env->FromReflectedField(javaField));
   mirror::Object* o = NULL;
   if (!CheckReceiver(soa, javaObj, f, o)) {
     return;
diff --git a/runtime/native/java_lang_reflect_Method.cc b/runtime/native/java_lang_reflect_Method.cc
index 14dc6a44ee..d29de3debe 100644
--- a/runtime/native/java_lang_reflect_Method.cc
+++ b/runtime/native/java_lang_reflect_Method.cc
@@ -16,26 +16,31 @@
 
 #include "class_linker.h"
 #include "jni_internal.h"
+#include "mirror/art_method.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
-#include "mirror/abstract_method.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/proxy.h"
 #include "object_utils.h"
 #include "reflection.h"
 #include "scoped_thread_state_change.h"
+#include "well_known_classes.h"
 
 namespace art {
 
-static jobject Method_invoke(JNIEnv* env, jobject javaMethod, jobject javaReceiver, jobject javaArgs) {
+static jobject Method_invoke(JNIEnv* env,
+                             jobject javaMethod, jobject javaReceiver, jobject javaArgs) {
   ScopedObjectAccess soa(env);
   return InvokeMethod(soa, javaMethod, javaReceiver, javaArgs);
 }
 
 static jobject Method_getExceptionTypesNative(JNIEnv* env, jobject javaMethod) {
   ScopedObjectAccess soa(env);
-  mirror::AbstractMethod* proxy_method = soa.Decode<mirror::Object*>(javaMethod)->AsMethod();
+  jobject art_method = soa.Env()->GetObjectField(
+      javaMethod, WellKnownClasses::java_lang_reflect_AbstractMethod_artMethod);
+
+  mirror::ArtMethod* proxy_method = soa.Decode<mirror::Object*>(art_method)->AsArtMethod();
   CHECK(proxy_method->GetDeclaringClass()->IsProxyClass());
   mirror::SynthesizedProxyClass* proxy_class =
       down_cast<mirror::SynthesizedProxyClass*>(proxy_method->GetDeclaringClass());
@@ -48,20 +53,14 @@ static jobject Method_getExceptionTypesNative(JNIEnv* env, jobject javaMethod) {
     }
   }
   CHECK_NE(throws_index, -1);
-  mirror::ObjectArray<mirror::Class>* declared_exceptions = proxy_class->GetThrows()->Get(throws_index);
+  mirror::ObjectArray<mirror::Class>* declared_exceptions =
+          proxy_class->GetThrows()->Get(throws_index);
   return soa.AddLocalReference<jobject>(declared_exceptions->Clone(soa.Self()));
 }
 
-static jobject Method_findOverriddenMethodNative(JNIEnv* env, jobject javaMethod) {
-  ScopedObjectAccess soa(env);
-  mirror::AbstractMethod* method = soa.Decode<mirror::Object*>(javaMethod)->AsMethod();
-  return soa.AddLocalReference<jobject>(method->FindOverriddenMethod());
-}
-
 static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(Method, invoke, "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;"),
   NATIVE_METHOD(Method, getExceptionTypesNative, "()[Ljava/lang/Class;"),
-  NATIVE_METHOD(Method, findOverriddenMethodNative, "()Ljava/lang/reflect/Method;"),
 };
 
 void register_java_lang_reflect_Method(JNIEnv* env) {
diff --git a/runtime/native/java_lang_reflect_Proxy.cc b/runtime/native/java_lang_reflect_Proxy.cc
index 547ce7b38d..a92823a85d 100644
--- a/runtime/native/java_lang_reflect_Proxy.cc
+++ b/runtime/native/java_lang_reflect_Proxy.cc
@@ -31,8 +31,8 @@ static jclass Proxy_generateProxy(JNIEnv* env, jclass, jstring javaName,
   mirror::ObjectArray<mirror::Class>* interfaces =
       soa.Decode<mirror::ObjectArray<mirror::Class>*>(javaInterfaces);
   mirror::ClassLoader* loader = soa.Decode<mirror::ClassLoader*>(javaLoader);
-  mirror::ObjectArray<mirror::AbstractMethod>* methods =
-      soa.Decode<mirror::ObjectArray<mirror::AbstractMethod>*>(javaMethods);
+  mirror::ObjectArray<mirror::ArtMethod>* methods =
+      soa.Decode<mirror::ObjectArray<mirror::ArtMethod>*>(javaMethods);
   mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >* throws =
       soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >*>(javaThrows);
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
@@ -41,7 +41,7 @@ static jclass Proxy_generateProxy(JNIEnv* env, jclass, jstring javaName,
 }
 
 static JNINativeMethod gMethods[] = {
-  NATIVE_METHOD(Proxy, generateProxy, "(Ljava/lang/String;[Ljava/lang/Class;Ljava/lang/ClassLoader;[Ljava/lang/reflect/Method;[[Ljava/lang/Class;)Ljava/lang/Class;"),
+  NATIVE_METHOD(Proxy, generateProxy, "(Ljava/lang/String;[Ljava/lang/Class;Ljava/lang/ClassLoader;[Ljava/lang/reflect/ArtMethod;[[Ljava/lang/Class;)Ljava/lang/Class;"),
 };
 
 void register_java_lang_reflect_Proxy(JNIEnv* env) {
diff --git a/runtime/nth_caller_visitor.h b/runtime/nth_caller_visitor.h
index e3593d805d..794878a08e 100644
--- a/runtime/nth_caller_visitor.h
+++ b/runtime/nth_caller_visitor.h
@@ -17,7 +17,7 @@
 #ifndef ART_RUNTIME_NTH_CALLER_VISITOR_H_
 #define ART_RUNTIME_NTH_CALLER_VISITOR_H_
 
-#include "mirror/abstract_method.h"
+#include "mirror/art_method.h"
 #include "locks.h"
 #include "stack.h"
 
@@ -31,7 +31,7 @@ struct NthCallerVisitor : public StackVisitor {
         count(0), caller(NULL) {}
 
   bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* m = GetMethod();
+    mirror::ArtMethod* m = GetMethod();
     bool do_count = false;
     if (m == NULL || m->IsRuntimeMethod()) {
       // Upcall.
@@ -53,7 +53,7 @@ struct NthCallerVisitor : public StackVisitor {
   const size_t n;
   const bool include_runtime_and_upcalls_;
   size_t count;
-  mirror::AbstractMethod* caller;
+  mirror::ArtMethod* caller;
 };
 
 }  // namespace art
diff --git a/runtime/oat_file.cc b/runtime/oat_file.cc
index 93e98ad894..1f34317d26 100644
--- a/runtime/oat_file.cc
+++ b/runtime/oat_file.cc
@@ -22,9 +22,9 @@
 #include "base/unix_file/fd_file.h"
 #include "elf_file.h"
 #include "oat.h"
+#include "mirror/art_method.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class.h"
-#include "mirror/abstract_method.h"
-#include "mirror/abstract_method-inl.h"
 #include "mirror/object-inl.h"
 #include "os.h"
 #include "utils.h"
@@ -453,7 +453,7 @@ uint32_t OatFile::OatMethod::GetCodeSize() const {
 #endif
 }
 
-void OatFile::OatMethod::LinkMethod(mirror::AbstractMethod* method) const {
+void OatFile::OatMethod::LinkMethod(mirror::ArtMethod* method) const {
   CHECK(method != NULL);
   method->SetEntryPointFromCompiledCode(GetCode());
   method->SetFrameSizeInBytes(frame_size_in_bytes_);
diff --git a/runtime/oat_file.h b/runtime/oat_file.h
index 650301465b..325ebb2914 100644
--- a/runtime/oat_file.h
+++ b/runtime/oat_file.h
@@ -23,7 +23,7 @@
 #include "dex_file.h"
 #include "invoke_type.h"
 #include "mem_map.h"
-#include "mirror/abstract_method.h"
+#include "mirror/art_method.h"
 #include "oat.h"
 #include "os.h"
 
@@ -70,7 +70,7 @@ class OatFile {
 
   class OatMethod {
    public:
-    void LinkMethod(mirror::AbstractMethod* method) const;
+    void LinkMethod(mirror::ArtMethod* method) const;
 
     uint32_t GetCodeOffset() const {
       return code_offset_;
diff --git a/runtime/oat_test.cc b/runtime/oat_test.cc
index 68595c896d..74b5da9eff 100644
--- a/runtime/oat_test.cc
+++ b/runtime/oat_test.cc
@@ -15,7 +15,7 @@
  */
 
 #include "compiler/oat_writer.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/object-inl.h"
@@ -28,7 +28,7 @@ namespace art {
 
 class OatTest : public CommonTest {
  protected:
-  void CheckMethod(mirror::AbstractMethod* method,
+  void CheckMethod(mirror::ArtMethod* method,
                    const OatFile::OatMethod& oat_method,
                    const DexFile* dex_file)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
diff --git a/runtime/object_utils.h b/runtime/object_utils.h
index 3639a80e77..29102437a2 100644
--- a/runtime/object_utils.h
+++ b/runtime/object_utils.h
@@ -20,10 +20,10 @@
 #include "class_linker-inl.h"
 #include "dex_file.h"
 #include "monitor.h"
-#include "mirror/abstract_method.h"
+#include "mirror/art_field.h"
+#include "mirror/art_method.h"
 #include "mirror/class.h"
 #include "mirror/dex_cache.h"
-#include "mirror/field.h"
 #include "mirror/iftable.h"
 #include "mirror/string.h"
 
@@ -256,11 +256,11 @@ class ClassHelper {
 class FieldHelper {
  public:
   FieldHelper() : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), field_(NULL) {}
-  explicit FieldHelper(const mirror::Field* f) : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), field_(f) {}
-  FieldHelper(const mirror::Field* f, ClassLinker* l)
+  explicit FieldHelper(const mirror::ArtField* f) : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), field_(f) {}
+  FieldHelper(const mirror::ArtField* f, ClassLinker* l)
       : class_linker_(l), dex_cache_(NULL), dex_file_(NULL), field_(f) {}
 
-  void ChangeField(const mirror::Field* new_f) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  void ChangeField(const mirror::ArtField* new_f) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     DCHECK(new_f != NULL);
     if (dex_cache_ != NULL) {
       mirror::DexCache* new_f_dex_cache = new_f->GetDeclaringClass()->GetDexCache();
@@ -366,7 +366,7 @@ class FieldHelper {
   ClassLinker* class_linker_;
   mirror::DexCache* dex_cache_;
   const DexFile* dex_file_;
-  const mirror::Field* field_;
+  const mirror::ArtField* field_;
   std::string declaring_class_descriptor_;
 
   DISALLOW_COPY_AND_ASSIGN(FieldHelper);
@@ -378,21 +378,21 @@ class MethodHelper {
      : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), method_(NULL), shorty_(NULL),
        shorty_len_(0) {}
 
-  explicit MethodHelper(const mirror::AbstractMethod* m)
+  explicit MethodHelper(const mirror::ArtMethod* m)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
       : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), method_(NULL), shorty_(NULL),
         shorty_len_(0) {
     SetMethod(m);
   }
 
-  MethodHelper(const mirror::AbstractMethod* m, ClassLinker* l)
+  MethodHelper(const mirror::ArtMethod* m, ClassLinker* l)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
       : class_linker_(l), dex_cache_(NULL), dex_file_(NULL), method_(NULL), shorty_(NULL),
         shorty_len_(0) {
     SetMethod(m);
   }
 
-  void ChangeMethod(mirror::AbstractMethod* new_m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  void ChangeMethod(mirror::ArtMethod* new_m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     DCHECK(new_m != NULL);
     if (dex_cache_ != NULL) {
       mirror::Class* klass = new_m->GetDeclaringClass();
@@ -411,7 +411,7 @@ class MethodHelper {
     shorty_ = NULL;
   }
 
-  const mirror::AbstractMethod* GetMethod() const {
+  const mirror::ArtMethod* GetMethod() const {
     return method_;
   }
 
@@ -653,11 +653,11 @@ class MethodHelper {
  private:
   // Set the method_ field, for proxy methods looking up the interface method via the resolved
   // methods table.
-  void SetMethod(const mirror::AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  void SetMethod(const mirror::ArtMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     if (method != NULL) {
       mirror::Class* klass = method->GetDeclaringClass();
       if (UNLIKELY(klass->IsProxyClass())) {
-        mirror::AbstractMethod* interface_method =
+        mirror::ArtMethod* interface_method =
             method->GetDexCacheResolvedMethods()->Get(method->GetDexMethodIndex());
         DCHECK(interface_method != NULL);
         DCHECK(interface_method == GetClassLinker()->FindMethodForProxy(klass, method));
@@ -679,7 +679,7 @@ class MethodHelper {
   ClassLinker* class_linker_;
   mirror::DexCache* dex_cache_;
   const DexFile* dex_file_;
-  const mirror::AbstractMethod* method_;
+  const mirror::ArtMethod* method_;
   const char* shorty_;
   uint32_t shorty_len_;
 
diff --git a/runtime/reflection.cc b/runtime/reflection.cc
index 8e478ff969..3e58b4bd94 100644
--- a/runtime/reflection.cc
+++ b/runtime/reflection.cc
@@ -21,11 +21,10 @@
 #include "dex_file-inl.h"
 #include "invoke_arg_array_builder.h"
 #include "jni_internal.h"
-#include "mirror/abstract_method.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class.h"
 #include "mirror/class-inl.h"
-#include "mirror/field-inl.h"
 #include "mirror/object_array.h"
 #include "mirror/object_array-inl.h"
 #include "object_utils.h"
@@ -37,7 +36,7 @@ namespace art {
 jobject InvokeMethod(const ScopedObjectAccess& soa, jobject javaMethod, jobject javaReceiver,
                      jobject javaArgs) {
   jmethodID mid = soa.Env()->FromReflectedMethod(javaMethod);
-  mirror::AbstractMethod* m = soa.DecodeMethod(mid);
+  mirror::ArtMethod* m = soa.DecodeMethod(mid);
 
   mirror::Class* declaring_class = m->GetDeclaringClass();
   if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(declaring_class, true, true)) {
@@ -267,7 +266,7 @@ mirror::Object* BoxPrimitive(Primitive::Type src_class, const JValue& value) {
   return result.GetL();
 }
 
-static std::string UnboxingFailureKind(mirror::AbstractMethod* m, int index, mirror::Field* f)
+static std::string UnboxingFailureKind(mirror::ArtMethod* m, int index, mirror::ArtField* f)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   if (m != NULL && index != -1) {
     ++index;  // Humans count from 1.
@@ -281,7 +280,7 @@ static std::string UnboxingFailureKind(mirror::AbstractMethod* m, int index, mir
 
 static bool UnboxPrimitive(const ThrowLocation* throw_location, mirror::Object* o,
                            mirror::Class* dst_class, JValue& unboxed_value,
-                           mirror::AbstractMethod* m, int index, mirror::Field* f)
+                           mirror::ArtMethod* m, int index, mirror::ArtField* f)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   bool unbox_for_result = (f == NULL) && (index == -1);
   if (!dst_class->IsPrimitive()) {
@@ -327,7 +326,7 @@ static bool UnboxPrimitive(const ThrowLocation* throw_location, mirror::Object*
   std::string src_descriptor(ClassHelper(o->GetClass()).GetDescriptor());
   mirror::Class* src_class = NULL;
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  mirror::Field* primitive_field = o->GetClass()->GetIFields()->Get(0);
+  mirror::ArtField* primitive_field = o->GetClass()->GetIFields()->Get(0);
   if (src_descriptor == "Ljava/lang/Boolean;") {
     src_class = class_linker->FindPrimitiveClass('Z');
     boxed_value.SetZ(primitive_field->GetBoolean(o));
@@ -367,13 +366,13 @@ static bool UnboxPrimitive(const ThrowLocation* throw_location, mirror::Object*
 }
 
 bool UnboxPrimitiveForArgument(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value,
-                               mirror::AbstractMethod* m, size_t index) {
+                               mirror::ArtMethod* m, size_t index) {
   CHECK(m != NULL);
   return UnboxPrimitive(NULL, o, dst_class, unboxed_value, m, index, NULL);
 }
 
 bool UnboxPrimitiveForField(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value,
-                            mirror::Field* f) {
+                            mirror::ArtField* f) {
   CHECK(f != NULL);
   return UnboxPrimitive(NULL, o, dst_class, unboxed_value, NULL, -1, f);
 }
diff --git a/runtime/reflection.h b/runtime/reflection.h
index 56ab4712db..13c90af895 100644
--- a/runtime/reflection.h
+++ b/runtime/reflection.h
@@ -22,10 +22,10 @@
 
 namespace art {
 namespace mirror {
-class AbstractMethod;
-class Class;
-class Field;
-class Object;
+  class ArtField;
+  class ArtMethod;
+  class Class;
+  class Object;
 }  // namespace mirror
 union JValue;
 class ScopedObjectAccess;
@@ -34,10 +34,10 @@ class ThrowLocation;
 mirror::Object* BoxPrimitive(Primitive::Type src_class, const JValue& value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 bool UnboxPrimitiveForArgument(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value,
-                               mirror::AbstractMethod* m, size_t index)
+                               mirror::ArtMethod* m, size_t index)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 bool UnboxPrimitiveForField(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value,
-                            mirror::Field* f)
+                            mirror::ArtField* f)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 bool UnboxPrimitiveForResult(const ThrowLocation& throw_location, mirror::Object* o,
                              mirror::Class* dst_class, JValue& unboxed_value)
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index 70d8816401..7b12870872 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -42,12 +42,11 @@
 #include "intern_table.h"
 #include "invoke_arg_array_builder.h"
 #include "jni_internal.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/array.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
-#include "mirror/field.h"
-#include "mirror/field-inl.h"
 #include "mirror/throwable.h"
 #include "monitor.h"
 #include "oat_file.h"
@@ -654,7 +653,7 @@ static void CreateSystemClassLoader() {
       soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_ClassLoader);
   CHECK(Runtime::Current()->GetClassLinker()->EnsureInitialized(class_loader_class, true, true));
 
-  mirror::AbstractMethod* getSystemClassLoader =
+  mirror::ArtMethod* getSystemClassLoader =
       class_loader_class->FindDirectMethod("getSystemClassLoader", "()Ljava/lang/ClassLoader;");
   CHECK(getSystemClassLoader != NULL);
 
@@ -669,8 +668,8 @@ static void CreateSystemClassLoader() {
   mirror::Class* thread_class = soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_Thread);
   CHECK(Runtime::Current()->GetClassLinker()->EnsureInitialized(thread_class, true, true));
 
-  mirror::Field* contextClassLoader = thread_class->FindDeclaredInstanceField("contextClassLoader",
-                                                                              "Ljava/lang/ClassLoader;");
+  mirror::ArtField* contextClassLoader = thread_class->FindDeclaredInstanceField("contextClassLoader",
+                                                                                 "Ljava/lang/ClassLoader;");
   CHECK(contextClassLoader != NULL);
 
   contextClassLoader->SetObject(soa.Self()->GetPeer(), class_loader);
@@ -1125,11 +1124,11 @@ void Runtime::VisitRoots(RootVisitor* visitor, void* arg, bool only_dirty, bool
   VisitNonConcurrentRoots(visitor, arg);
 }
 
-mirror::AbstractMethod* Runtime::CreateResolutionMethod() {
-  mirror::Class* method_class = mirror::AbstractMethod::GetMethodClass();
+mirror::ArtMethod* Runtime::CreateResolutionMethod() {
+  mirror::Class* method_class = mirror::ArtMethod::GetJavaLangReflectArtMethod();
   Thread* self = Thread::Current();
-  SirtRef<mirror::AbstractMethod>
-      method(self, down_cast<mirror::AbstractMethod*>(method_class->AllocObject(self)));
+  SirtRef<mirror::ArtMethod>
+      method(self, down_cast<mirror::ArtMethod*>(method_class->AllocObject(self)));
   method->SetDeclaringClass(method_class);
   // TODO: use a special method for resolution method saves
   method->SetDexMethodIndex(DexFile::kDexNoIndex16);
@@ -1140,12 +1139,12 @@ mirror::AbstractMethod* Runtime::CreateResolutionMethod() {
   return method.get();
 }
 
-mirror::AbstractMethod* Runtime::CreateCalleeSaveMethod(InstructionSet instruction_set,
+mirror::ArtMethod* Runtime::CreateCalleeSaveMethod(InstructionSet instruction_set,
                                                         CalleeSaveType type) {
-  mirror::Class* method_class = mirror::AbstractMethod::GetMethodClass();
+  mirror::Class* method_class = mirror::ArtMethod::GetJavaLangReflectArtMethod();
   Thread* self = Thread::Current();
-  SirtRef<mirror::AbstractMethod>
-      method(self, down_cast<mirror::AbstractMethod*>(method_class->AllocObject(self)));
+  SirtRef<mirror::ArtMethod>
+      method(self, down_cast<mirror::ArtMethod*>(method_class->AllocObject(self)));
   method->SetDeclaringClass(method_class);
   // TODO: use a special method for callee saves
   method->SetDexMethodIndex(DexFile::kDexNoIndex16);
@@ -1205,7 +1204,7 @@ mirror::AbstractMethod* Runtime::CreateCalleeSaveMethod(InstructionSet instructi
   return method.get();
 }
 
-void Runtime::SetCalleeSaveMethod(mirror::AbstractMethod* method, CalleeSaveType type) {
+void Runtime::SetCalleeSaveMethod(mirror::ArtMethod* method, CalleeSaveType type) {
   DCHECK_LT(static_cast<int>(type), static_cast<int>(kLastCalleeSaveType));
   callee_save_methods_[type] = method;
 }
diff --git a/runtime/runtime.h b/runtime/runtime.h
index d67265a42d..b93ae9daeb 100644
--- a/runtime/runtime.h
+++ b/runtime/runtime.h
@@ -43,7 +43,7 @@ namespace gc {
   class Heap;
 }
 namespace mirror {
-  class AbstractMethod;
+  class ArtMethod;
   class ClassLoader;
   template<class T> class PrimitiveArray;
   typedef PrimitiveArray<int8_t> ByteArray;
@@ -310,7 +310,7 @@ class Runtime {
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Returns a special method that calls into a trampoline for runtime method resolution
-  mirror::AbstractMethod* GetResolutionMethod() const {
+  mirror::ArtMethod* GetResolutionMethod() const {
     CHECK(HasResolutionMethod());
     return resolution_method_;
   }
@@ -319,11 +319,11 @@ class Runtime {
     return resolution_method_ != NULL;
   }
 
-  void SetResolutionMethod(mirror::AbstractMethod* method) {
+  void SetResolutionMethod(mirror::ArtMethod* method) {
     resolution_method_ = method;
   }
 
-  mirror::AbstractMethod* CreateResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  mirror::ArtMethod* CreateResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Returns a special method that describes all callee saves being spilled to the stack.
   enum CalleeSaveType {
@@ -337,21 +337,21 @@ class Runtime {
     return callee_save_methods_[type] != NULL;
   }
 
-  mirror::AbstractMethod* GetCalleeSaveMethod(CalleeSaveType type) const {
+  mirror::ArtMethod* GetCalleeSaveMethod(CalleeSaveType type) const {
     DCHECK(HasCalleeSaveMethod(type));
     return callee_save_methods_[type];
   }
 
-  void SetCalleeSaveMethod(mirror::AbstractMethod* method, CalleeSaveType type);
+  void SetCalleeSaveMethod(mirror::ArtMethod* method, CalleeSaveType type);
 
-  mirror::AbstractMethod* CreateCalleeSaveMethod(InstructionSet instruction_set,
+  mirror::ArtMethod* CreateCalleeSaveMethod(InstructionSet instruction_set,
                                                  CalleeSaveType type)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::AbstractMethod* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set)
+  mirror::ArtMethod* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::AbstractMethod* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set)
+  mirror::ArtMethod* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   int32_t GetStat(int kind);
@@ -451,9 +451,9 @@ class Runtime {
 
   mirror::Throwable* pre_allocated_OutOfMemoryError_;
 
-  mirror::AbstractMethod* callee_save_methods_[kLastCalleeSaveType];
+  mirror::ArtMethod* callee_save_methods_[kLastCalleeSaveType];
 
-  mirror::AbstractMethod* resolution_method_;
+  mirror::ArtMethod* resolution_method_;
 
   // As returned by ClassLoader.getSystemClassLoader()
   mirror::ClassLoader* system_class_loader_;
diff --git a/runtime/scoped_thread_state_change.h b/runtime/scoped_thread_state_change.h
index 965e6b85ac..5f649b117b 100644
--- a/runtime/scoped_thread_state_change.h
+++ b/runtime/scoped_thread_state_change.h
@@ -204,7 +204,7 @@ class ScopedObjectAccessUnchecked : public ScopedThreadStateChange {
     return down_cast<T>(Self()->DecodeJObject(obj));
   }
 
-  mirror::Field* DecodeField(jfieldID fid) const
+  mirror::ArtField* DecodeField(jfieldID fid) const
       LOCKS_EXCLUDED(JavaVMExt::globals_lock,
                      JavaVMExt::weak_globals_lock)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -214,10 +214,10 @@ class ScopedObjectAccessUnchecked : public ScopedThreadStateChange {
     // TODO: we should make these unique weak globals if Field instances can ever move.
     UNIMPLEMENTED(WARNING);
 #endif
-    return reinterpret_cast<mirror::Field*>(fid);
+    return reinterpret_cast<mirror::ArtField*>(fid);
   }
 
-  jfieldID EncodeField(mirror::Field* field) const
+  jfieldID EncodeField(mirror::ArtField* field) const
       LOCKS_EXCLUDED(JavaVMExt::globals_lock,
                      JavaVMExt::weak_globals_lock)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -229,7 +229,7 @@ class ScopedObjectAccessUnchecked : public ScopedThreadStateChange {
     return reinterpret_cast<jfieldID>(field);
   }
 
-  mirror::AbstractMethod* DecodeMethod(jmethodID mid) const
+  mirror::ArtMethod* DecodeMethod(jmethodID mid) const
       LOCKS_EXCLUDED(JavaVMExt::globals_lock,
                      JavaVMExt::weak_globals_lock)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -239,10 +239,10 @@ class ScopedObjectAccessUnchecked : public ScopedThreadStateChange {
     // TODO: we should make these unique weak globals if Method instances can ever move.
     UNIMPLEMENTED(WARNING);
 #endif
-    return reinterpret_cast<mirror::AbstractMethod*>(mid);
+    return reinterpret_cast<mirror::ArtMethod*>(mid);
   }
 
-  jmethodID EncodeMethod(mirror::AbstractMethod* method) const
+  jmethodID EncodeMethod(mirror::ArtMethod* method) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     Locks::mutator_lock_->AssertSharedHeld(Self());
     DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
diff --git a/runtime/stack.cc b/runtime/stack.cc
index e1a752adb9..206bff3425 100644
--- a/runtime/stack.cc
+++ b/runtime/stack.cc
@@ -16,7 +16,7 @@
 
 #include "stack.h"
 
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/object.h"
 #include "mirror/object-inl.h"
@@ -29,7 +29,7 @@
 namespace art {
 
 mirror::Object* ShadowFrame::GetThisObject() const {
-  mirror::AbstractMethod* m = GetMethod();
+  mirror::ArtMethod* m = GetMethod();
   if (m->IsStatic()) {
     return NULL;
   } else if (m->IsNative()) {
@@ -43,7 +43,7 @@ mirror::Object* ShadowFrame::GetThisObject() const {
 }
 
 mirror::Object* ShadowFrame::GetThisObject(uint16_t num_ins) const {
-  mirror::AbstractMethod* m = GetMethod();
+  mirror::ArtMethod* m = GetMethod();
   if (m->IsStatic()) {
     return NULL;
   } else {
@@ -101,7 +101,7 @@ uint32_t StackVisitor::GetDexPc() const {
 }
 
 mirror::Object* StackVisitor::GetThisObject() const {
-  mirror::AbstractMethod* m = GetMethod();
+  mirror::ArtMethod* m = GetMethod();
   if (m->IsStatic()) {
     return NULL;
   } else if (m->IsNative()) {
@@ -132,7 +132,7 @@ size_t StackVisitor::GetNativePcOffset() const {
   return GetMethod()->NativePcOffset(cur_quick_frame_pc_);
 }
 
-uint32_t StackVisitor::GetVReg(mirror::AbstractMethod* m, uint16_t vreg, VRegKind kind) const {
+uint32_t StackVisitor::GetVReg(mirror::ArtMethod* m, uint16_t vreg, VRegKind kind) const {
   if (cur_quick_frame_ != NULL) {
     DCHECK(context_ != NULL);  // You can't reliably read registers without a context.
     DCHECK(m == GetMethod());
@@ -156,7 +156,7 @@ uint32_t StackVisitor::GetVReg(mirror::AbstractMethod* m, uint16_t vreg, VRegKin
   }
 }
 
-void StackVisitor::SetVReg(mirror::AbstractMethod* m, uint16_t vreg, uint32_t new_value,
+void StackVisitor::SetVReg(mirror::ArtMethod* m, uint16_t vreg, uint32_t new_value,
                            VRegKind kind) {
   if (cur_quick_frame_ != NULL) {
     DCHECK(context_ != NULL);  // You can't reliably write registers without a context.
@@ -195,14 +195,14 @@ void StackVisitor::SetGPR(uint32_t reg, uintptr_t value) {
 }
 
 uintptr_t StackVisitor::GetReturnPc() const {
-  mirror::AbstractMethod** sp = GetCurrentQuickFrame();
+  mirror::ArtMethod** sp = GetCurrentQuickFrame();
   DCHECK(sp != NULL);
   byte* pc_addr = reinterpret_cast<byte*>(sp) + GetMethod()->GetReturnPcOffsetInBytes();
   return *reinterpret_cast<uintptr_t*>(pc_addr);
 }
 
 void StackVisitor::SetReturnPc(uintptr_t new_ret_pc) {
-  mirror::AbstractMethod** sp = GetCurrentQuickFrame();
+  mirror::ArtMethod** sp = GetCurrentQuickFrame();
   CHECK(sp != NULL);
   byte* pc_addr = reinterpret_cast<byte*>(sp) + GetMethod()->GetReturnPcOffsetInBytes();
   *reinterpret_cast<uintptr_t*>(pc_addr) = new_ret_pc;
@@ -241,7 +241,7 @@ void StackVisitor::DescribeStack(Thread* thread) {
 
 std::string StackVisitor::DescribeLocation() const {
   std::string result("Visiting method '");
-  mirror::AbstractMethod* m = GetMethod();
+  mirror::ArtMethod* m = GetMethod();
   if (m == NULL) {
     return "upcall";
   }
@@ -259,9 +259,8 @@ instrumentation::InstrumentationStackFrame StackVisitor::GetInstrumentationStack
 
 void StackVisitor::SanityCheckFrame() const {
 #ifndef NDEBUG
-  mirror::AbstractMethod* method = GetMethod();
-  CHECK(method->GetClass() == mirror::AbstractMethod::GetMethodClass() ||
-        method->GetClass() == mirror::AbstractMethod::GetConstructorClass());
+  mirror::ArtMethod* method = GetMethod();
+  CHECK(method->GetClass() == mirror::ArtMethod::GetJavaLangReflectArtMethod());
   if (cur_quick_frame_ != NULL) {
     method->AssertPcIsWithinCode(cur_quick_frame_pc_);
     // Frame sanity.
@@ -291,7 +290,7 @@ void StackVisitor::WalkStack(bool include_transitions) {
     if (cur_quick_frame_ != NULL) {  // Handle quick stack frames.
       // Can't be both a shadow and a quick fragment.
       DCHECK(current_fragment->GetTopShadowFrame() == NULL);
-      mirror::AbstractMethod* method = *cur_quick_frame_;
+      mirror::ArtMethod* method = *cur_quick_frame_;
       while (method != NULL) {
         SanityCheckFrame();
         bool should_continue = VisitFrame();
@@ -316,7 +315,7 @@ void StackVisitor::WalkStack(bool include_transitions) {
             if (GetMethod() == Runtime::Current()->GetCalleeSaveMethod(Runtime::kSaveAll)) {
               // Skip runtime save all callee frames which are used to deliver exceptions.
             } else if (instrumentation_frame.interpreter_entry_) {
-              mirror::AbstractMethod* callee = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
+              mirror::ArtMethod* callee = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
               CHECK_EQ(GetMethod(), callee) << "Expected: " << PrettyMethod(callee) << " Found: "
                   << PrettyMethod(GetMethod());
             } else if (instrumentation_frame.method_ != GetMethod()) {
@@ -335,7 +334,7 @@ void StackVisitor::WalkStack(bool include_transitions) {
         }
         cur_quick_frame_pc_ = return_pc;
         byte* next_frame = reinterpret_cast<byte*>(cur_quick_frame_) + frame_size;
-        cur_quick_frame_ = reinterpret_cast<mirror::AbstractMethod**>(next_frame);
+        cur_quick_frame_ = reinterpret_cast<mirror::ArtMethod**>(next_frame);
         cur_depth_++;
         method = *cur_quick_frame_;
       }
diff --git a/runtime/stack.h b/runtime/stack.h
index 388e4014c1..8ecf8f0571 100644
--- a/runtime/stack.h
+++ b/runtime/stack.h
@@ -28,8 +28,8 @@
 namespace art {
 
 namespace mirror {
-class AbstractMethod;
-class Object;
+  class ArtMethod;
+  class Object;
 }  // namespace mirror
 
 class Context;
@@ -66,7 +66,7 @@ class ShadowFrame {
 
   // Create ShadowFrame in heap for deoptimization.
   static ShadowFrame* Create(uint32_t num_vregs, ShadowFrame* link,
-                             mirror::AbstractMethod* method, uint32_t dex_pc) {
+                             mirror::ArtMethod* method, uint32_t dex_pc) {
     uint8_t* memory = new uint8_t[ComputeSize(num_vregs)];
     ShadowFrame* sf = new (memory) ShadowFrame(num_vregs, link, method, dex_pc, true);
     return sf;
@@ -74,7 +74,7 @@ class ShadowFrame {
 
   // Create ShadowFrame for interpreter using provided memory.
   static ShadowFrame* Create(uint32_t num_vregs, ShadowFrame* link,
-                             mirror::AbstractMethod* method, uint32_t dex_pc, void* memory) {
+                             mirror::ArtMethod* method, uint32_t dex_pc, void* memory) {
     ShadowFrame* sf = new (memory) ShadowFrame(num_vregs, link, method, dex_pc, true);
     return sf;
   }
@@ -195,7 +195,7 @@ class ShadowFrame {
     }
   }
 
-  mirror::AbstractMethod* GetMethod() const {
+  mirror::ArtMethod* GetMethod() const {
     DCHECK_NE(method_, static_cast<void*>(NULL));
     return method_;
   }
@@ -206,7 +206,7 @@ class ShadowFrame {
 
   ThrowLocation GetCurrentLocationForThrow() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void SetMethod(mirror::AbstractMethod* method) {
+  void SetMethod(mirror::ArtMethod* method) {
 #if defined(ART_USE_PORTABLE_COMPILER)
     DCHECK_NE(method, static_cast<void*>(NULL));
     method_ = method;
@@ -248,7 +248,7 @@ class ShadowFrame {
   }
 
  private:
-  ShadowFrame(uint32_t num_vregs, ShadowFrame* link, mirror::AbstractMethod* method,
+  ShadowFrame(uint32_t num_vregs, ShadowFrame* link, mirror::ArtMethod* method,
               uint32_t dex_pc, bool has_reference_array)
       : number_of_vregs_(num_vregs), link_(link), method_(method), dex_pc_(dex_pc) {
     if (has_reference_array) {
@@ -285,9 +285,9 @@ class ShadowFrame {
   ShadowFrame* link_;
 #if defined(ART_USE_PORTABLE_COMPILER)
   // TODO: make const in the portable case.
-  mirror::AbstractMethod* method_;
+  mirror::ArtMethod* method_;
 #else
-  mirror::AbstractMethod* const method_;
+  mirror::ArtMethod* const method_;
 #endif
   uint32_t dex_pc_;
   uint32_t vregs_[0];
@@ -323,11 +323,11 @@ class PACKED(4) ManagedStack {
     return link_;
   }
 
-  mirror::AbstractMethod** GetTopQuickFrame() const {
+  mirror::ArtMethod** GetTopQuickFrame() const {
     return top_quick_frame_;
   }
 
-  void SetTopQuickFrame(mirror::AbstractMethod** top) {
+  void SetTopQuickFrame(mirror::ArtMethod** top) {
     DCHECK(top_shadow_frame_ == NULL);
     top_quick_frame_ = top;
   }
@@ -385,7 +385,7 @@ class PACKED(4) ManagedStack {
  private:
   ManagedStack* link_;
   ShadowFrame* top_shadow_frame_;
-  mirror::AbstractMethod** top_quick_frame_;
+  mirror::ArtMethod** top_quick_frame_;
   uintptr_t top_quick_frame_pc_;
 };
 
@@ -402,7 +402,7 @@ class StackVisitor {
   void WalkStack(bool include_transitions = false)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::AbstractMethod* GetMethod() const {
+  mirror::ArtMethod* GetMethod() const {
     if (cur_shadow_frame_ != NULL) {
       return cur_shadow_frame_->GetMethod();
     } else if (cur_quick_frame_ != NULL) {
@@ -450,16 +450,16 @@ class StackVisitor {
     return num_frames_;
   }
 
-  uint32_t GetVReg(mirror::AbstractMethod* m, uint16_t vreg, VRegKind kind) const
+  uint32_t GetVReg(mirror::ArtMethod* m, uint16_t vreg, VRegKind kind) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void SetVReg(mirror::AbstractMethod* m, uint16_t vreg, uint32_t new_value, VRegKind kind)
+  void SetVReg(mirror::ArtMethod* m, uint16_t vreg, uint32_t new_value, VRegKind kind)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   uintptr_t GetGPR(uint32_t reg) const;
   void SetGPR(uint32_t reg, uintptr_t value);
 
-  uint32_t GetVReg(mirror::AbstractMethod** cur_quick_frame, const DexFile::CodeItem* code_item,
+  uint32_t GetVReg(mirror::ArtMethod** cur_quick_frame, const DexFile::CodeItem* code_item,
                    uint32_t core_spills, uint32_t fp_spills, size_t frame_size,
                    uint16_t vreg) const {
     int offset = GetVRegOffset(code_item, core_spills, fp_spills, frame_size, vreg);
@@ -533,7 +533,7 @@ class StackVisitor {
     return cur_quick_frame_pc_;
   }
 
-  mirror::AbstractMethod** GetCurrentQuickFrame() const {
+  mirror::ArtMethod** GetCurrentQuickFrame() const {
     return cur_quick_frame_;
   }
 
@@ -542,7 +542,7 @@ class StackVisitor {
   }
 
   StackIndirectReferenceTable* GetCurrentSirt() const {
-    mirror::AbstractMethod** sp = GetCurrentQuickFrame();
+    mirror::ArtMethod** sp = GetCurrentQuickFrame();
     ++sp;  // Skip Method*; SIRT comes next;
     return reinterpret_cast<StackIndirectReferenceTable*>(sp);
   }
@@ -560,7 +560,7 @@ class StackVisitor {
 
   Thread* const thread_;
   ShadowFrame* cur_shadow_frame_;
-  mirror::AbstractMethod** cur_quick_frame_;
+  mirror::ArtMethod** cur_quick_frame_;
   uintptr_t cur_quick_frame_pc_;
   // Lazily computed, number of frames in the stack.
   size_t num_frames_;
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 07a003d330..7e3afb59a5 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -45,10 +45,10 @@
 #include "gc/space/space.h"
 #include "invoke_arg_array_builder.h"
 #include "jni_internal.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
-#include "mirror/field-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/stack_trace_element.h"
 #include "monitor.h"
@@ -168,7 +168,7 @@ void* Thread::CreateCallback(void* arg) {
     // Invoke the 'run' method of our java.lang.Thread.
     mirror::Object* receiver = self->opeer_;
     jmethodID mid = WellKnownClasses::java_lang_Thread_run;
-    mirror::AbstractMethod* m =
+    mirror::ArtMethod* m =
         receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
     JValue result;
     ArgArray arg_array(NULL, 0);
@@ -183,7 +183,7 @@ void* Thread::CreateCallback(void* arg) {
 
 Thread* Thread::FromManagedThread(const ScopedObjectAccessUnchecked& soa,
                                   mirror::Object* thread_peer) {
-  mirror::Field* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_nativePeer);
+  mirror::ArtField* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_nativePeer);
   Thread* result = reinterpret_cast<Thread*>(static_cast<uintptr_t>(f->GetInt(thread_peer)));
   // Sanity check that if we have a result it is either suspended or we hold the thread_list_lock_
   // to stop it from going away.
@@ -488,7 +488,7 @@ void Thread::Dump(std::ostream& os) const {
 }
 
 mirror::String* Thread::GetThreadName(const ScopedObjectAccessUnchecked& soa) const {
-  mirror::Field* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_name);
+  mirror::ArtField* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_name);
   return (opeer_ != NULL) ? reinterpret_cast<mirror::String*>(f->GetObject(opeer_)) : NULL;
 }
 
@@ -678,7 +678,7 @@ void Thread::DumpState(std::ostream& os, const Thread* thread, pid_t tid) {
         soa.DecodeField(WellKnownClasses::java_lang_Thread_group)->GetObject(thread->opeer_);
 
     if (thread_group != NULL) {
-      mirror::Field* group_name_field =
+      mirror::ArtField* group_name_field =
           soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_name);
       mirror::String* group_name_string =
           reinterpret_cast<mirror::String*>(group_name_field->GetObject(thread_group));
@@ -776,7 +776,7 @@ struct StackDumpVisitor : public StackVisitor {
   }
 
   bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* m = GetMethod();
+    mirror::ArtMethod* m = GetMethod();
     if (m->IsRuntimeMethod()) {
       return true;
     }
@@ -831,7 +831,7 @@ struct StackDumpVisitor : public StackVisitor {
   const Thread* thread;
   const bool can_allocate;
   MethodHelper mh;
-  mirror::AbstractMethod* last_method;
+  mirror::ArtMethod* last_method;
   int last_line_number;
   int repetition_count;
   int frame_count;
@@ -855,7 +855,7 @@ static bool ShouldShowNativeStack(const Thread* thread)
   // We don't just check kNative because native methods will be in state kSuspended if they're
   // calling back into the VM, or kBlocked if they're blocked on a monitor, or one of the
   // thread-startup states if it's early enough in their life cycle (http://b/7432159).
-  mirror::AbstractMethod* current_method = thread->GetCurrentMethod(NULL);
+  mirror::ArtMethod* current_method = thread->GetCurrentMethod(NULL);
   return current_method != NULL && current_method->IsNative();
 }
 
@@ -1238,7 +1238,7 @@ class CountStackDepthVisitor : public StackVisitor {
     // We want to skip frames up to and including the exception's constructor.
     // Note we also skip the frame if it doesn't have a method (namely the callee
     // save frame)
-    mirror::AbstractMethod* m = GetMethod();
+    mirror::ArtMethod* m = GetMethod();
     if (skipping_ && !m->IsRuntimeMethod() &&
         !mirror::Throwable::GetJavaLangThrowable()->IsAssignableFrom(m->GetDeclaringClass())) {
       skipping_ = false;
@@ -1313,7 +1313,7 @@ class BuildInternalStackTraceVisitor : public StackVisitor {
       skip_depth_--;
       return true;
     }
-    mirror::AbstractMethod* m = GetMethod();
+    mirror::ArtMethod* m = GetMethod();
     if (m->IsRuntimeMethod()) {
       return true;  // Ignore runtime frames (in particular callee save).
     }
@@ -1398,7 +1398,7 @@ jobjectArray Thread::InternalStackTraceToStackTraceElementArray(JNIEnv* env, job
   MethodHelper mh;
   for (int32_t i = 0; i < depth; ++i) {
     // Prepare parameters for StackTraceElement(String cls, String method, String file, int line)
-    mirror::AbstractMethod* method = down_cast<mirror::AbstractMethod*>(method_trace->Get(i));
+    mirror::ArtMethod* method = down_cast<mirror::ArtMethod*>(method_trace->Get(i));
     mh.ChangeMethod(method);
     uint32_t dex_pc = pc_trace->Get(i);
     int32_t line_number = mh.GetLineNumFromDexPC(dex_pc);
@@ -1472,7 +1472,7 @@ void Thread::ThrowNewWrappedException(const ThrowLocation& throw_location,
   DCHECK_EQ(this, Thread::Current());
   // Ensure we don't forget arguments over object allocation.
   SirtRef<mirror::Object> saved_throw_this(this, throw_location.GetThis());
-  SirtRef<mirror::AbstractMethod> saved_throw_method(this, throw_location.GetMethod());
+  SirtRef<mirror::ArtMethod> saved_throw_method(this, throw_location.GetMethod());
   // Ignore the cause throw location. TODO: should we report this as a re-throw?
   SirtRef<mirror::Throwable> cause(this, GetException(NULL));
   ClearException();
@@ -1520,7 +1520,7 @@ void Thread::ThrowNewWrappedException(const ThrowLocation& throw_location,
       signature = "(Ljava/lang/Throwable;)V";
     }
   }
-  mirror::AbstractMethod* exception_init_method =
+  mirror::ArtMethod* exception_init_method =
       exception_class->FindDeclaredDirectMethod("<init>", signature);
 
   CHECK(exception_init_method != NULL) << "No <init>" << signature << " in "
@@ -1740,7 +1740,7 @@ class CatchBlockStackVisitor : public StackVisitor {
   }
 
   bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* method = GetMethod();
+    mirror::ArtMethod* method = GetMethod();
     if (method == NULL) {
       // This is the upcall, we remember the frame and last pc so that we may long jump to them.
       handler_quick_frame_pc_ = GetCurrentQuickFramePc();
@@ -1764,7 +1764,7 @@ class CatchBlockStackVisitor : public StackVisitor {
     }
   }
 
-  bool HandleTryItems(mirror::AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  bool HandleTryItems(mirror::ArtMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     uint32_t dex_pc = DexFile::kDexNoIndex;
     if (method->IsNative()) {
       native_method_count_++;
@@ -1783,7 +1783,7 @@ class CatchBlockStackVisitor : public StackVisitor {
     return true;  // Continue stack walk.
   }
 
-  bool HandleDeoptimization(mirror::AbstractMethod* m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  bool HandleDeoptimization(mirror::ArtMethod* m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     MethodHelper mh(m);
     const DexFile::CodeItem* code_item = mh.GetCodeItem();
     CHECK(code_item != NULL);
@@ -1825,7 +1825,7 @@ class CatchBlockStackVisitor : public StackVisitor {
   }
 
   void DoLongJump() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* catch_method = *handler_quick_frame_;
+    mirror::ArtMethod* catch_method = *handler_quick_frame_;
     if (catch_method == NULL) {
       if (kDebugExceptionDelivery) {
         LOG(INFO) << "Handler is upcall";
@@ -1880,7 +1880,7 @@ class CatchBlockStackVisitor : public StackVisitor {
   // Location of the throw.
   const ThrowLocation& throw_location_;
   // Quick frame with found handler or last frame if no handler found.
-  mirror::AbstractMethod** handler_quick_frame_;
+  mirror::ArtMethod** handler_quick_frame_;
   // PC to branch to for the handler.
   uintptr_t handler_quick_frame_pc_;
   // Associated dex PC.
@@ -1940,7 +1940,7 @@ struct CurrentMethodVisitor : public StackVisitor {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
       : StackVisitor(thread, context), this_object_(NULL), method_(NULL), dex_pc_(0) {}
   virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* m = GetMethod();
+    mirror::ArtMethod* m = GetMethod();
     if (m->IsRuntimeMethod()) {
       // Continue if this is a runtime method.
       return true;
@@ -1953,11 +1953,11 @@ struct CurrentMethodVisitor : public StackVisitor {
     return false;
   }
   mirror::Object* this_object_;
-  mirror::AbstractMethod* method_;
+  mirror::ArtMethod* method_;
   uint32_t dex_pc_;
 };
 
-mirror::AbstractMethod* Thread::GetCurrentMethod(uint32_t* dex_pc) const {
+mirror::ArtMethod* Thread::GetCurrentMethod(uint32_t* dex_pc) const {
   CurrentMethodVisitor visitor(const_cast<Thread*>(this), NULL);
   visitor.WalkStack(false);
   if (dex_pc != NULL) {
@@ -1996,7 +1996,7 @@ class ReferenceMapVisitor : public StackVisitor {
     }
     ShadowFrame* shadow_frame = GetCurrentShadowFrame();
     if (shadow_frame != NULL) {
-      mirror::AbstractMethod* m = shadow_frame->GetMethod();
+      mirror::ArtMethod* m = shadow_frame->GetMethod();
       size_t num_regs = shadow_frame->NumberOfVRegs();
       if (m->IsNative() || shadow_frame->HasReferenceArray()) {
         // SIRT for JNI or References for interpreter.
@@ -2030,7 +2030,7 @@ class ReferenceMapVisitor : public StackVisitor {
         }
       }
     } else {
-      mirror::AbstractMethod* m = GetMethod();
+      mirror::ArtMethod* m = GetMethod();
       // Process register map (which native and runtime methods don't have)
       if (!m->IsNative() && !m->IsRuntimeMethod() && !m->IsProxyMethod()) {
         const uint8_t* native_gc_map = m->GetNativeGcMap();
@@ -2049,7 +2049,7 @@ class ReferenceMapVisitor : public StackVisitor {
           uint32_t fp_spills = m->GetFpSpillMask();
           size_t frame_size = m->GetFrameSizeInBytes();
           // For all dex registers in the bitmap
-          mirror::AbstractMethod** cur_quick_frame = GetCurrentQuickFrame();
+          mirror::ArtMethod** cur_quick_frame = GetCurrentQuickFrame();
           DCHECK(cur_quick_frame != NULL);
           for (size_t reg = 0; reg < num_regs; ++reg) {
             // Does this register hold a reference?
@@ -2164,7 +2164,7 @@ void Thread::VerifyRoots(VerifyRootVisitor* visitor, void* arg) {
     if (this_object != NULL) {
       VerifyRootWrapperCallback(this_object, &wrapperArg);
     }
-    mirror::AbstractMethod* method = (*it).method_;
+    mirror::ArtMethod* method = (*it).method_;
     VerifyRootWrapperCallback(method, &wrapperArg);
   }
 }
@@ -2199,7 +2199,7 @@ void Thread::VisitRoots(RootVisitor* visitor, void* arg) {
     if (this_object != NULL) {
       visitor(this_object, arg);
     }
-    mirror::AbstractMethod* method = (*it).method_;
+    mirror::ArtMethod* method = (*it).method_;
     visitor(method, arg);
   }
 }
diff --git a/runtime/thread.h b/runtime/thread.h
index 8b6771e60c..b9b93dd8f1 100644
--- a/runtime/thread.h
+++ b/runtime/thread.h
@@ -45,7 +45,7 @@
 namespace art {
 
 namespace mirror {
-  class AbstractMethod;
+  class ArtMethod;
   class Array;
   class Class;
   class ClassLoader;
@@ -318,13 +318,13 @@ class PACKED(4) Thread {
     long_jump_context_ = context;
   }
 
-  mirror::AbstractMethod* GetCurrentMethod(uint32_t* dex_pc) const
+  mirror::ArtMethod* GetCurrentMethod(uint32_t* dex_pc) const
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   ThrowLocation GetCurrentLocationForThrow() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void SetTopOfStack(void* stack, uintptr_t pc) {
-    mirror::AbstractMethod** top_method = reinterpret_cast<mirror::AbstractMethod**>(stack);
+    mirror::ArtMethod** top_method = reinterpret_cast<mirror::ArtMethod**>(stack);
     managed_stack_.SetTopQuickFrame(top_method);
     managed_stack_.SetTopQuickFramePc(pc);
   }
diff --git a/runtime/throw_location.cc b/runtime/throw_location.cc
index 84d2c9b446..6d1ca1b4f0 100644
--- a/runtime/throw_location.cc
+++ b/runtime/throw_location.cc
@@ -16,7 +16,7 @@
 
 #include "throw_location.h"
 
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/object-inl.h"
 #include "object_utils.h"
diff --git a/runtime/throw_location.h b/runtime/throw_location.h
index b2cd4d5803..5da446e9c5 100644
--- a/runtime/throw_location.h
+++ b/runtime/throw_location.h
@@ -26,7 +26,7 @@
 namespace art {
 
 namespace mirror {
-class AbstractMethod;
+class ArtMethod;
 class Object;
 }  // mirror
 
@@ -36,7 +36,7 @@ class PACKED(4) ThrowLocation {
     Clear();
   }
 
-  ThrowLocation(mirror::Object* throw_this_object, mirror::AbstractMethod* throw_method,
+  ThrowLocation(mirror::Object* throw_this_object, mirror::ArtMethod* throw_method,
                 uint32_t throw_dex_pc) :
       this_object_(throw_this_object),
       method_(throw_method),
@@ -46,7 +46,7 @@ class PACKED(4) ThrowLocation {
     return this_object_;
   }
 
-  mirror::AbstractMethod* GetMethod() const {
+  mirror::ArtMethod* GetMethod() const {
     return method_;
   }
 
@@ -68,7 +68,7 @@ class PACKED(4) ThrowLocation {
   // The 'this' reference of the throwing method.
   mirror::Object* this_object_;
   // The throwing method.
-  mirror::AbstractMethod* method_;
+  mirror::ArtMethod* method_;
   // The instruction within the throwing method.
   uint32_t dex_pc_;
 };
diff --git a/runtime/trace.cc b/runtime/trace.cc
index 2bce70f7c1..84df6a9e8b 100644
--- a/runtime/trace.cc
+++ b/runtime/trace.cc
@@ -24,7 +24,7 @@
 #include "debugger.h"
 #include "dex_file-inl.h"
 #include "instrumentation.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/dex_cache.h"
 #include "mirror/object_array-inl.h"
@@ -98,15 +98,15 @@ ProfilerClockSource Trace::default_clock_source_ = kProfilerClockSourceWall;
 
 Trace* Trace::the_trace_ = NULL;
 
-static mirror::AbstractMethod* DecodeTraceMethodId(uint32_t tmid) {
-  return reinterpret_cast<mirror::AbstractMethod*>(tmid & ~kTraceMethodActionMask);
+static mirror::ArtMethod* DecodeTraceMethodId(uint32_t tmid) {
+  return reinterpret_cast<mirror::ArtMethod*>(tmid & ~kTraceMethodActionMask);
 }
 
 static TraceAction DecodeTraceAction(uint32_t tmid) {
   return static_cast<TraceAction>(tmid & kTraceMethodActionMask);
 }
 
-static uint32_t EncodeTraceMethodAndAction(const mirror::AbstractMethod* method,
+static uint32_t EncodeTraceMethodAndAction(const mirror::ArtMethod* method,
                                            TraceAction action) {
   uint32_t tmid = reinterpret_cast<uint32_t>(method) | action;
   DCHECK_EQ(method, DecodeTraceMethodId(tmid));
@@ -311,7 +311,7 @@ static void DumpBuf(uint8_t* buf, size_t buf_size, ProfilerClockSource clock_sou
 
   while (ptr < end) {
     uint32_t tmid = ptr[2] | (ptr[3] << 8) | (ptr[4] << 16) | (ptr[5] << 24);
-    mirror::AbstractMethod* method = DecodeTraceMethodId(tmid);
+    mirror::ArtMethod* method = DecodeTraceMethodId(tmid);
     TraceAction action = DecodeTraceAction(tmid);
     LOG(INFO) << PrettyMethod(method) << " " << static_cast<int>(action);
     ptr += GetRecordSize(clock_source);
@@ -329,7 +329,7 @@ void Trace::FinishTracing() {
     Runtime::Current()->SetStatsEnabled(false);
   }
 
-  std::set<mirror::AbstractMethod*> visited_methods;
+  std::set<mirror::ArtMethod*> visited_methods;
   GetVisitedMethods(final_offset, &visited_methods);
 
   std::ostringstream os;
@@ -386,35 +386,35 @@ void Trace::FinishTracing() {
 }
 
 void Trace::DexPcMoved(Thread* thread, mirror::Object* this_object,
-                       const mirror::AbstractMethod* method, uint32_t new_dex_pc) {
+                       const mirror::ArtMethod* method, uint32_t new_dex_pc) {
   // We're not recorded to listen to this kind of event, so complain.
   LOG(ERROR) << "Unexpected dex PC event in tracing " << PrettyMethod(method) << " " << new_dex_pc;
 };
 
 void Trace::MethodEntered(Thread* thread, mirror::Object* this_object,
-                          const mirror::AbstractMethod* method, uint32_t dex_pc) {
+                          const mirror::ArtMethod* method, uint32_t dex_pc) {
   LogMethodTraceEvent(thread, method, instrumentation::Instrumentation::kMethodEntered);
 }
 
 void Trace::MethodExited(Thread* thread, mirror::Object* this_object,
-                         const mirror::AbstractMethod* method, uint32_t dex_pc,
+                         const mirror::ArtMethod* method, uint32_t dex_pc,
                          const JValue& return_value) {
   UNUSED(return_value);
   LogMethodTraceEvent(thread, method, instrumentation::Instrumentation::kMethodExited);
 }
 
-void Trace::MethodUnwind(Thread* thread, const mirror::AbstractMethod* method, uint32_t dex_pc) {
+void Trace::MethodUnwind(Thread* thread, const mirror::ArtMethod* method, uint32_t dex_pc) {
   LogMethodTraceEvent(thread, method, instrumentation::Instrumentation::kMethodUnwind);
 }
 
 void Trace::ExceptionCaught(Thread* thread, const ThrowLocation& throw_location,
-                            mirror::AbstractMethod* catch_method, uint32_t catch_dex_pc,
+                            mirror::ArtMethod* catch_method, uint32_t catch_dex_pc,
                             mirror::Throwable* exception_object)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   LOG(ERROR) << "Unexpected exception caught event in tracing";
 }
 
-void Trace::LogMethodTraceEvent(Thread* thread, const mirror::AbstractMethod* method,
+void Trace::LogMethodTraceEvent(Thread* thread, const mirror::ArtMethod* method,
                                 instrumentation::Instrumentation::InstrumentationEvent event) {
   // Advance cur_offset_ atomically.
   int32_t new_offset;
@@ -473,24 +473,24 @@ void Trace::LogMethodTraceEvent(Thread* thread, const mirror::AbstractMethod* me
 }
 
 void Trace::GetVisitedMethods(size_t buf_size,
-                              std::set<mirror::AbstractMethod*>* visited_methods) {
+                              std::set<mirror::ArtMethod*>* visited_methods) {
   uint8_t* ptr = buf_.get() + kTraceHeaderLength;
   uint8_t* end = buf_.get() + buf_size;
 
   while (ptr < end) {
     uint32_t tmid = ptr[2] | (ptr[3] << 8) | (ptr[4] << 16) | (ptr[5] << 24);
-    mirror::AbstractMethod* method = DecodeTraceMethodId(tmid);
+    mirror::ArtMethod* method = DecodeTraceMethodId(tmid);
     visited_methods->insert(method);
     ptr += GetRecordSize(clock_source_);
   }
 }
 
 void Trace::DumpMethodList(std::ostream& os,
-                           const std::set<mirror::AbstractMethod*>& visited_methods) {
-  typedef std::set<mirror::AbstractMethod*>::const_iterator It;  // TODO: C++0x auto
+                           const std::set<mirror::ArtMethod*>& visited_methods) {
+  typedef std::set<mirror::ArtMethod*>::const_iterator It;  // TODO: C++0x auto
   MethodHelper mh;
   for (It it = visited_methods.begin(); it != visited_methods.end(); ++it) {
-    mirror::AbstractMethod* method = *it;
+    mirror::ArtMethod* method = *it;
     mh.ChangeMethod(method);
     os << StringPrintf("%p\t%s\t%s\t%s\t%s\n", method,
         PrettyDescriptor(mh.GetDeclaringClassDescriptor()).c_str(), mh.GetName(),
diff --git a/runtime/trace.h b/runtime/trace.h
index bd9c140d26..ae583cae2d 100644
--- a/runtime/trace.h
+++ b/runtime/trace.h
@@ -31,7 +31,7 @@
 namespace art {
 
 namespace mirror {
-class AbstractMethod;
+  class ArtMethod;
 }  // namespace mirror
 class Thread;
 
@@ -63,19 +63,19 @@ class Trace : public instrumentation::InstrumentationListener {
   bool UseThreadCpuClock();
 
   virtual void MethodEntered(Thread* thread, mirror::Object* this_object,
-                             const mirror::AbstractMethod* method, uint32_t dex_pc)
+                             const mirror::ArtMethod* method, uint32_t dex_pc)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   virtual void MethodExited(Thread* thread, mirror::Object* this_object,
-                            const mirror::AbstractMethod* method, uint32_t dex_pc,
+                            const mirror::ArtMethod* method, uint32_t dex_pc,
                             const JValue& return_value)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  virtual void MethodUnwind(Thread* thread, const mirror::AbstractMethod* method, uint32_t dex_pc)
+  virtual void MethodUnwind(Thread* thread, const mirror::ArtMethod* method, uint32_t dex_pc)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   virtual void DexPcMoved(Thread* thread, mirror::Object* this_object,
-                          const mirror::AbstractMethod* method, uint32_t new_dex_pc)
+                          const mirror::ArtMethod* method, uint32_t new_dex_pc)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   virtual void ExceptionCaught(Thread* thread, const ThrowLocation& throw_location,
-                               mirror::AbstractMethod* catch_method, uint32_t catch_dex_pc,
+                               mirror::ArtMethod* catch_method, uint32_t catch_dex_pc,
                                mirror::Throwable* exception_object)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -84,12 +84,12 @@ class Trace : public instrumentation::InstrumentationListener {
 
   void FinishTracing() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void LogMethodTraceEvent(Thread* thread, const mirror::AbstractMethod* method,
+  void LogMethodTraceEvent(Thread* thread, const mirror::ArtMethod* method,
                            instrumentation::Instrumentation::InstrumentationEvent event);
 
   // Methods to output traced methods and threads.
-  void GetVisitedMethods(size_t end_offset, std::set<mirror::AbstractMethod*>* visited_methods);
-  void DumpMethodList(std::ostream& os, const std::set<mirror::AbstractMethod*>& visited_methods)
+  void GetVisitedMethods(size_t end_offset, std::set<mirror::ArtMethod*>* visited_methods);
+  void DumpMethodList(std::ostream& os, const std::set<mirror::ArtMethod*>& visited_methods)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   void DumpThreadList(std::ostream& os) LOCKS_EXCLUDED(Locks::thread_list_lock_);
 
diff --git a/runtime/utils.cc b/runtime/utils.cc
index 71e502df29..87cd21c478 100644
--- a/runtime/utils.cc
+++ b/runtime/utils.cc
@@ -25,11 +25,10 @@
 #include "UniquePtr.h"
 #include "base/unix_file/fd_file.h"
 #include "dex_file-inl.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/class_loader.h"
-#include "mirror/field.h"
-#include "mirror/field-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/string.h"
@@ -295,7 +294,7 @@ std::string PrettyDescriptor(Primitive::Type type) {
   return PrettyDescriptor(descriptor_string);
 }
 
-std::string PrettyField(const mirror::Field* f, bool with_type) {
+std::string PrettyField(const mirror::ArtField* f, bool with_type) {
   if (f == NULL) {
     return "null";
   }
@@ -370,7 +369,7 @@ std::string PrettyReturnType(const char* signature) {
   return PrettyDescriptor(return_type);
 }
 
-std::string PrettyMethod(const mirror::AbstractMethod* m, bool with_signature) {
+std::string PrettyMethod(const mirror::ArtMethod* m, bool with_signature) {
   if (m == NULL) {
     return "null";
   }
@@ -629,7 +628,7 @@ std::string DescriptorToName(const char* descriptor) {
   return descriptor;
 }
 
-std::string JniShortName(const mirror::AbstractMethod* m) {
+std::string JniShortName(const mirror::ArtMethod* m) {
   MethodHelper mh(m);
   std::string class_name(mh.GetDeclaringClassDescriptor());
   // Remove the leading 'L' and trailing ';'...
@@ -648,7 +647,7 @@ std::string JniShortName(const mirror::AbstractMethod* m) {
   return short_name;
 }
 
-std::string JniLongName(const mirror::AbstractMethod* m) {
+std::string JniLongName(const mirror::ArtMethod* m) {
   std::string long_name;
   long_name += JniShortName(m);
   long_name += "__";
diff --git a/runtime/utils.h b/runtime/utils.h
index 1c45048c13..9e724d0ac4 100644
--- a/runtime/utils.h
+++ b/runtime/utils.h
@@ -33,9 +33,9 @@ namespace art {
 class DexFile;
 
 namespace mirror {
+class ArtField;
+class ArtMethod;
 class Class;
-class Field;
-class AbstractMethod;
 class Object;
 class String;
 }  // namespace mirror
@@ -195,13 +195,13 @@ std::string PrettyDescriptor(const mirror::Class* klass)
 
 // Returns a human-readable signature for 'f'. Something like "a.b.C.f" or
 // "int a.b.C.f" (depending on the value of 'with_type').
-std::string PrettyField(const mirror::Field* f, bool with_type = true)
+std::string PrettyField(const mirror::ArtField* f, bool with_type = true)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type = true);
 
 // Returns a human-readable signature for 'm'. Something like "a.b.C.m" or
 // "a.b.C.m(II)V" (depending on the value of 'with_signature').
-std::string PrettyMethod(const mirror::AbstractMethod* m, bool with_signature = true)
+std::string PrettyMethod(const mirror::ArtMethod* m, bool with_signature = true)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature = true);
 
@@ -265,10 +265,10 @@ bool IsValidDescriptor(const char* s);       // "Ljava/lang/String;"
 bool IsValidMemberName(const char* s);
 
 // Returns the JNI native function name for the non-overloaded method 'm'.
-std::string JniShortName(const mirror::AbstractMethod* m)
+std::string JniShortName(const mirror::ArtMethod* m)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 // Returns the JNI native function name for the overloaded method 'm'.
-std::string JniLongName(const mirror::AbstractMethod* m)
+std::string JniLongName(const mirror::ArtMethod* m)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 bool ReadFileToString(const std::string& file_name, std::string* result);
diff --git a/runtime/utils_test.cc b/runtime/utils_test.cc
index 0966e717ca..2633964b57 100644
--- a/runtime/utils_test.cc
+++ b/runtime/utils_test.cc
@@ -130,7 +130,7 @@ TEST_F(UtilsTest, PrettyField) {
 
   mirror::Class* java_lang_String = class_linker_->FindSystemClass("Ljava/lang/String;");
 
-  mirror::Field* f;
+  mirror::ArtField* f;
   f = java_lang_String->FindDeclaredInstanceField("count", "I");
   EXPECT_EQ("int java.lang.String.count", PrettyField(f));
   EXPECT_EQ("java.lang.String.count", PrettyField(f, false));
@@ -199,7 +199,7 @@ TEST_F(UtilsTest, JniShortName_JniLongName) {
   ScopedObjectAccess soa(Thread::Current());
   mirror::Class* c = class_linker_->FindSystemClass("Ljava/lang/String;");
   ASSERT_TRUE(c != NULL);
-  mirror::AbstractMethod* m;
+  mirror::ArtMethod* m;
 
   m = c->FindVirtualMethod("charAt", "(I)C");
   ASSERT_TRUE(m != NULL);
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index fc595d90d9..02168446b1 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -29,11 +29,11 @@
 #include "indenter.h"
 #include "intern_table.h"
 #include "leb128.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_field-inl.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class.h"
 #include "mirror/class-inl.h"
 #include "mirror/dex_cache-inl.h"
-#include "mirror/field-inl.h"
 #include "mirror/object-inl.h"
 #include "mirror/object_array-inl.h"
 #include "object_utils.h"
@@ -139,7 +139,7 @@ MethodVerifier::FailureKind MethodVerifier::VerifyClass(const DexFile* dex_file,
     }
     previous_direct_method_idx = method_idx;
     InvokeType type = it.GetMethodInvokeType(class_def);
-    mirror::AbstractMethod* method =
+    mirror::ArtMethod* method =
         linker->ResolveMethod(*dex_file, method_idx, dex_cache, class_loader, NULL, type);
     if (method == NULL) {
       DCHECK(Thread::Current()->IsExceptionPending());
@@ -181,7 +181,7 @@ MethodVerifier::FailureKind MethodVerifier::VerifyClass(const DexFile* dex_file,
     }
     previous_virtual_method_idx = method_idx;
     InvokeType type = it.GetMethodInvokeType(class_def);
-    mirror::AbstractMethod* method =
+    mirror::ArtMethod* method =
         linker->ResolveMethod(*dex_file, method_idx, dex_cache, class_loader, NULL, type);
     if (method == NULL) {
       DCHECK(Thread::Current()->IsExceptionPending());
@@ -225,7 +225,7 @@ MethodVerifier::FailureKind MethodVerifier::VerifyMethod(uint32_t method_idx,
                                                          mirror::ClassLoader* class_loader,
                                                          uint32_t class_def_idx,
                                                          const DexFile::CodeItem* code_item,
-                                                         mirror::AbstractMethod* method,
+                                                         mirror::ArtMethod* method,
                                                          uint32_t method_access_flags,
                                                          bool allow_soft_failures) {
   MethodVerifier::FailureKind result = kNoFailure;
@@ -266,7 +266,7 @@ void MethodVerifier::VerifyMethodAndDump(std::ostream& os, uint32_t dex_method_i
                                          const DexFile* dex_file, mirror::DexCache* dex_cache,
                                          mirror::ClassLoader* class_loader, uint32_t class_def_idx,
                                          const DexFile::CodeItem* code_item,
-                                         mirror::AbstractMethod* method,
+                                         mirror::ArtMethod* method,
                                          uint32_t method_access_flags) {
   MethodVerifier verifier(dex_file, dex_cache, class_loader, class_def_idx, code_item,
                           dex_method_idx, method, method_access_flags, true, true);
@@ -279,7 +279,7 @@ void MethodVerifier::VerifyMethodAndDump(std::ostream& os, uint32_t dex_method_i
 MethodVerifier::MethodVerifier(const DexFile* dex_file, mirror::DexCache* dex_cache,
                                mirror::ClassLoader* class_loader, uint32_t class_def_idx,
                                const DexFile::CodeItem* code_item,
-                               uint32_t dex_method_idx, mirror::AbstractMethod* method,
+                               uint32_t dex_method_idx, mirror::ArtMethod* method,
                                uint32_t method_access_flags, bool can_load_classes,
                                bool allow_soft_failures)
     : reg_types_(can_load_classes),
@@ -305,7 +305,7 @@ MethodVerifier::MethodVerifier(const DexFile* dex_file, mirror::DexCache* dex_ca
       has_virtual_or_interface_invokes_(false) {
 }
 
-void MethodVerifier::FindLocksAtDexPc(mirror::AbstractMethod* m, uint32_t dex_pc,
+void MethodVerifier::FindLocksAtDexPc(mirror::ArtMethod* m, uint32_t dex_pc,
                                       std::vector<uint32_t>& monitor_enter_dex_pcs) {
   MethodHelper mh(m);
   MethodVerifier verifier(&mh.GetDexFile(), mh.GetDexCache(), mh.GetClassLoader(),
@@ -327,7 +327,7 @@ void MethodVerifier::FindLocksAtDexPc() {
   Verify();
 }
 
-mirror::Field* MethodVerifier::FindAccessedFieldAtDexPc(mirror::AbstractMethod* m,
+mirror::ArtField* MethodVerifier::FindAccessedFieldAtDexPc(mirror::ArtMethod* m,
                                                         uint32_t dex_pc) {
   MethodHelper mh(m);
   MethodVerifier verifier(&mh.GetDexFile(), mh.GetDexCache(), mh.GetClassLoader(),
@@ -336,7 +336,7 @@ mirror::Field* MethodVerifier::FindAccessedFieldAtDexPc(mirror::AbstractMethod*
   return verifier.FindAccessedFieldAtDexPc(dex_pc);
 }
 
-mirror::Field* MethodVerifier::FindAccessedFieldAtDexPc(uint32_t dex_pc) {
+mirror::ArtField* MethodVerifier::FindAccessedFieldAtDexPc(uint32_t dex_pc) {
   CHECK(code_item_ != NULL);  // This only makes sense for methods with code.
 
   // Strictly speaking, we ought to be able to get away with doing a subset of the full method
@@ -355,7 +355,7 @@ mirror::Field* MethodVerifier::FindAccessedFieldAtDexPc(uint32_t dex_pc) {
   return GetQuickFieldAccess(inst, register_line);
 }
 
-mirror::AbstractMethod* MethodVerifier::FindInvokedMethodAtDexPc(mirror::AbstractMethod* m,
+mirror::ArtMethod* MethodVerifier::FindInvokedMethodAtDexPc(mirror::ArtMethod* m,
                                                                  uint32_t dex_pc) {
   MethodHelper mh(m);
   MethodVerifier verifier(&mh.GetDexFile(), mh.GetDexCache(), mh.GetClassLoader(),
@@ -364,7 +364,7 @@ mirror::AbstractMethod* MethodVerifier::FindInvokedMethodAtDexPc(mirror::Abstrac
   return verifier.FindInvokedMethodAtDexPc(dex_pc);
 }
 
-mirror::AbstractMethod* MethodVerifier::FindInvokedMethodAtDexPc(uint32_t dex_pc) {
+mirror::ArtMethod* MethodVerifier::FindInvokedMethodAtDexPc(uint32_t dex_pc) {
   CHECK(code_item_ != NULL);  // This only makes sense for methods with code.
 
   // Strictly speaking, we ought to be able to get away with doing a subset of the full method
@@ -2113,7 +2113,7 @@ bool MethodVerifier::CodeFlowVerifyInstruction(uint32_t* start_guess) {
                        inst->Opcode() == Instruction::INVOKE_SUPER_RANGE);
       bool is_super =  (inst->Opcode() == Instruction::INVOKE_SUPER ||
                         inst->Opcode() == Instruction::INVOKE_SUPER_RANGE);
-      mirror::AbstractMethod* called_method = VerifyInvocationArgs(inst, METHOD_VIRTUAL,
+      mirror::ArtMethod* called_method = VerifyInvocationArgs(inst, METHOD_VIRTUAL,
                                                                    is_range, is_super);
       const char* descriptor;
       if (called_method == NULL) {
@@ -2136,7 +2136,7 @@ bool MethodVerifier::CodeFlowVerifyInstruction(uint32_t* start_guess) {
     case Instruction::INVOKE_DIRECT:
     case Instruction::INVOKE_DIRECT_RANGE: {
       bool is_range = (inst->Opcode() == Instruction::INVOKE_DIRECT_RANGE);
-      mirror::AbstractMethod* called_method = VerifyInvocationArgs(inst, METHOD_DIRECT,
+      mirror::ArtMethod* called_method = VerifyInvocationArgs(inst, METHOD_DIRECT,
                                                                    is_range, false);
       const char* return_type_descriptor;
       bool is_constructor;
@@ -2203,7 +2203,7 @@ bool MethodVerifier::CodeFlowVerifyInstruction(uint32_t* start_guess) {
     case Instruction::INVOKE_STATIC:
     case Instruction::INVOKE_STATIC_RANGE: {
         bool is_range = (inst->Opcode() == Instruction::INVOKE_STATIC_RANGE);
-        mirror::AbstractMethod* called_method = VerifyInvocationArgs(inst,
+        mirror::ArtMethod* called_method = VerifyInvocationArgs(inst,
                                                                      METHOD_STATIC,
                                                                      is_range,
                                                                      false);
@@ -2228,7 +2228,7 @@ bool MethodVerifier::CodeFlowVerifyInstruction(uint32_t* start_guess) {
     case Instruction::INVOKE_INTERFACE:
     case Instruction::INVOKE_INTERFACE_RANGE: {
       bool is_range =  (inst->Opcode() == Instruction::INVOKE_INTERFACE_RANGE);
-      mirror::AbstractMethod* abs_method = VerifyInvocationArgs(inst,
+      mirror::ArtMethod* abs_method = VerifyInvocationArgs(inst,
                                                                 METHOD_INTERFACE,
                                                                 is_range,
                                                                 false);
@@ -2536,7 +2536,7 @@ bool MethodVerifier::CodeFlowVerifyInstruction(uint32_t* start_guess) {
     case Instruction::INVOKE_VIRTUAL_QUICK:
     case Instruction::INVOKE_VIRTUAL_RANGE_QUICK: {
       bool is_range = (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE_QUICK);
-      mirror::AbstractMethod* called_method = VerifyInvokeVirtualQuickArgs(inst, is_range);
+      mirror::ArtMethod* called_method = VerifyInvokeVirtualQuickArgs(inst, is_range);
       if (called_method != NULL) {
         const char* descriptor = MethodHelper(called_method).GetReturnTypeDescriptor();
         const RegType& return_type = reg_types_.FromDescriptor(class_loader_, descriptor, false);
@@ -2871,7 +2871,7 @@ const RegType& MethodVerifier::GetCaughtExceptionType() {
   return *common_super;
 }
 
-mirror::AbstractMethod* MethodVerifier::ResolveMethodAndCheckAccess(uint32_t dex_method_idx,
+mirror::ArtMethod* MethodVerifier::ResolveMethodAndCheckAccess(uint32_t dex_method_idx,
                                                                     MethodType method_type) {
   const DexFile::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx);
   const RegType& klass_type = ResolveClassAndCheckAccess(method_id.class_idx_);
@@ -2886,7 +2886,7 @@ mirror::AbstractMethod* MethodVerifier::ResolveMethodAndCheckAccess(uint32_t dex
   }
   mirror::Class* klass = klass_type.GetClass();
   const RegType& referrer = GetDeclaringClass();
-  mirror::AbstractMethod* res_method = dex_cache_->GetResolvedMethod(dex_method_idx);
+  mirror::ArtMethod* res_method = dex_cache_->GetResolvedMethod(dex_method_idx);
   if (res_method == NULL) {
     const char* name = dex_file_->GetMethodName(method_id);
     std::string signature(dex_file_->CreateMethodSignature(method_id.proto_idx_, NULL));
@@ -2963,14 +2963,14 @@ mirror::AbstractMethod* MethodVerifier::ResolveMethodAndCheckAccess(uint32_t dex
   return res_method;
 }
 
-mirror::AbstractMethod* MethodVerifier::VerifyInvocationArgs(const Instruction* inst,
+mirror::ArtMethod* MethodVerifier::VerifyInvocationArgs(const Instruction* inst,
                                                              MethodType method_type,
                                                              bool is_range,
                                                              bool is_super) {
   // Resolve the method. This could be an abstract or concrete method depending on what sort of call
   // we're making.
   const uint32_t method_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
-  mirror::AbstractMethod* res_method = ResolveMethodAndCheckAccess(method_idx, method_type);
+  mirror::ArtMethod* res_method = ResolveMethodAndCheckAccess(method_idx, method_type);
   if (res_method == NULL) {  // error or class is unresolved
     return NULL;
   }
@@ -3078,7 +3078,7 @@ mirror::AbstractMethod* MethodVerifier::VerifyInvocationArgs(const Instruction*
   }
 }
 
-mirror::AbstractMethod* MethodVerifier::GetQuickInvokedMethod(const Instruction* inst,
+mirror::ArtMethod* MethodVerifier::GetQuickInvokedMethod(const Instruction* inst,
                                                               RegisterLine* reg_line,
                                                               bool is_range) {
   DCHECK(inst->Opcode() == Instruction::INVOKE_VIRTUAL_QUICK ||
@@ -3103,19 +3103,19 @@ mirror::AbstractMethod* MethodVerifier::GetQuickInvokedMethod(const Instruction*
   if (this_class == NULL) {
     return NULL;
   }
-  mirror::ObjectArray<mirror::AbstractMethod>* vtable = this_class->GetVTable();
+  mirror::ObjectArray<mirror::ArtMethod>* vtable = this_class->GetVTable();
   CHECK(vtable != NULL);
   uint16_t vtable_index = is_range ? inst->VRegB_3rc() : inst->VRegB_35c();
   CHECK(vtable_index < vtable->GetLength());
-  mirror::AbstractMethod* res_method = vtable->Get(vtable_index);
+  mirror::ArtMethod* res_method = vtable->Get(vtable_index);
   CHECK(!Thread::Current()->IsExceptionPending());
   return res_method;
 }
 
-mirror::AbstractMethod* MethodVerifier::VerifyInvokeVirtualQuickArgs(const Instruction* inst,
+mirror::ArtMethod* MethodVerifier::VerifyInvokeVirtualQuickArgs(const Instruction* inst,
                                                                      bool is_range) {
   DCHECK(Runtime::Current()->IsStarted());
-  mirror::AbstractMethod* res_method = GetQuickInvokedMethod(inst, work_line_.get(),
+  mirror::ArtMethod* res_method = GetQuickInvokedMethod(inst, work_line_.get(),
                                                              is_range);
   if (res_method == NULL) {
     Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Cannot infer method from " << inst->Name();
@@ -3368,7 +3368,7 @@ void MethodVerifier::VerifyAPut(const Instruction* inst,
   }
 }
 
-mirror::Field* MethodVerifier::GetStaticField(int field_idx) {
+mirror::ArtField* MethodVerifier::GetStaticField(int field_idx) {
   const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
   // Check access to class
   const RegType& klass_type = ResolveClassAndCheckAccess(field_id.class_idx_);
@@ -3381,7 +3381,7 @@ mirror::Field* MethodVerifier::GetStaticField(int field_idx) {
   if (klass_type.IsUnresolvedTypes()) {
     return NULL;  // Can't resolve Class so no more to do here, will do checking at runtime.
   }
-  mirror::Field* field = Runtime::Current()->GetClassLinker()->ResolveFieldJLS(*dex_file_,
+  mirror::ArtField* field = Runtime::Current()->GetClassLinker()->ResolveFieldJLS(*dex_file_,
                                                                                field_idx,
                                                                                dex_cache_,
                                                                                class_loader_);
@@ -3405,7 +3405,7 @@ mirror::Field* MethodVerifier::GetStaticField(int field_idx) {
   }
 }
 
-mirror::Field* MethodVerifier::GetInstanceField(const RegType& obj_type, int field_idx) {
+mirror::ArtField* MethodVerifier::GetInstanceField(const RegType& obj_type, int field_idx) {
   const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
   // Check access to class
   const RegType& klass_type = ResolveClassAndCheckAccess(field_id.class_idx_);
@@ -3418,7 +3418,7 @@ mirror::Field* MethodVerifier::GetInstanceField(const RegType& obj_type, int fie
   if (klass_type.IsUnresolvedTypes()) {
     return NULL;  // Can't resolve Class so no more to do here
   }
-  mirror::Field* field = Runtime::Current()->GetClassLinker()->ResolveFieldJLS(*dex_file_,
+  mirror::ArtField* field = Runtime::Current()->GetClassLinker()->ResolveFieldJLS(*dex_file_,
                                                                                field_idx,
                                                                                dex_cache_,
                                                                                class_loader_);
@@ -3471,7 +3471,7 @@ mirror::Field* MethodVerifier::GetInstanceField(const RegType& obj_type, int fie
 void MethodVerifier::VerifyISGet(const Instruction* inst, const RegType& insn_type,
                                  bool is_primitive, bool is_static) {
   uint32_t field_idx = is_static ? inst->VRegB_21c() : inst->VRegC_22c();
-  mirror::Field* field;
+  mirror::ArtField* field;
   if (is_static) {
     field = GetStaticField(field_idx);
   } else {
@@ -3525,7 +3525,7 @@ void MethodVerifier::VerifyISGet(const Instruction* inst, const RegType& insn_ty
 void MethodVerifier::VerifyISPut(const Instruction* inst, const RegType& insn_type,
                                  bool is_primitive, bool is_static) {
   uint32_t field_idx = is_static ? inst->VRegB_21c() : inst->VRegC_22c();
-  mirror::Field* field;
+  mirror::ArtField* field;
   if (is_static) {
     field = GetStaticField(field_idx);
   } else {
@@ -3567,13 +3567,13 @@ void MethodVerifier::VerifyISPut(const Instruction* inst, const RegType& insn_ty
 
 // Look for an instance field with this offset.
 // TODO: we may speed up the search if offsets are sorted by doing a quick search.
-static mirror::Field* FindInstanceFieldWithOffset(const mirror::Class* klass,
+static mirror::ArtField* FindInstanceFieldWithOffset(const mirror::Class* klass,
                                                   uint32_t field_offset)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  const mirror::ObjectArray<mirror::Field>* instance_fields = klass->GetIFields();
+  const mirror::ObjectArray<mirror::ArtField>* instance_fields = klass->GetIFields();
   if (instance_fields != NULL) {
     for (int32_t i = 0, e = instance_fields->GetLength(); i < e; ++i) {
-      mirror::Field* field = instance_fields->Get(i);
+      mirror::ArtField* field = instance_fields->Get(i);
       if (field->GetOffset().Uint32Value() == field_offset) {
         return field;
       }
@@ -3589,7 +3589,7 @@ static mirror::Field* FindInstanceFieldWithOffset(const mirror::Class* klass,
 
 // Returns the access field of a quick field access (iget/iput-quick) or NULL
 // if it cannot be found.
-mirror::Field* MethodVerifier::GetQuickFieldAccess(const Instruction* inst,
+mirror::ArtField* MethodVerifier::GetQuickFieldAccess(const Instruction* inst,
                                                    RegisterLine* reg_line) {
   DCHECK(inst->Opcode() == Instruction::IGET_QUICK ||
          inst->Opcode() == Instruction::IGET_WIDE_QUICK ||
@@ -3624,7 +3624,7 @@ mirror::Field* MethodVerifier::GetQuickFieldAccess(const Instruction* inst,
 void MethodVerifier::VerifyIGetQuick(const Instruction* inst, const RegType& insn_type,
                                      bool is_primitive) {
   DCHECK(Runtime::Current()->IsStarted());
-  mirror::Field* field = GetQuickFieldAccess(inst, work_line_.get());
+  mirror::ArtField* field = GetQuickFieldAccess(inst, work_line_.get());
   if (field == NULL) {
     Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Cannot infer field from " << inst->Name();
     return;
@@ -3668,7 +3668,7 @@ void MethodVerifier::VerifyIGetQuick(const Instruction* inst, const RegType& ins
 void MethodVerifier::VerifyIPutQuick(const Instruction* inst, const RegType& insn_type,
                                      bool is_primitive) {
   DCHECK(Runtime::Current()->IsStarted());
-  mirror::Field* field = GetQuickFieldAccess(inst, work_line_.get());
+  mirror::ArtField* field = GetQuickFieldAccess(inst, work_line_.get());
   if (field == NULL) {
     Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Cannot infer field from " << inst->Name();
     return;
@@ -3922,7 +3922,7 @@ MethodVerifier::PcToConcreteMethodMap* MethodVerifier::GenerateDevirtMap() {
       // We can't devirtualize abstract classes except on arrays of abstract classes.
       continue;
     }
-    mirror::AbstractMethod* abstract_method =
+    mirror::ArtMethod* abstract_method =
         dex_cache_->GetResolvedMethod(is_range ? inst->VRegB_3rc() : inst->VRegB_35c());
     if (abstract_method == NULL) {
       // If the method is not found in the cache this means that it was never found
@@ -3930,7 +3930,7 @@ MethodVerifier::PcToConcreteMethodMap* MethodVerifier::GenerateDevirtMap() {
       continue;
     }
     // Find the concrete method.
-    mirror::AbstractMethod* concrete_method = NULL;
+    mirror::ArtMethod* concrete_method = NULL;
     if (is_interface) {
       concrete_method = reg_type.GetClass()->FindVirtualMethodForInterface(abstract_method);
     }
diff --git a/runtime/verifier/method_verifier.h b/runtime/verifier/method_verifier.h
index e01f2c08c1..6171943a6c 100644
--- a/runtime/verifier/method_verifier.h
+++ b/runtime/verifier/method_verifier.h
@@ -156,7 +156,7 @@ class MethodVerifier {
   static void VerifyMethodAndDump(std::ostream& os, uint32_t method_idx, const DexFile* dex_file,
                                   mirror::DexCache* dex_cache, mirror::ClassLoader* class_loader,
                                   uint32_t class_def_idx, const DexFile::CodeItem* code_item,
-                                  mirror::AbstractMethod* method, uint32_t method_access_flags)
+                                  mirror::ArtMethod* method, uint32_t method_access_flags)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   uint8_t EncodePcToReferenceMapData() const;
@@ -197,20 +197,18 @@ class MethodVerifier {
 
   // Fills 'monitor_enter_dex_pcs' with the dex pcs of the monitor-enter instructions corresponding
   // to the locks held at 'dex_pc' in method 'm'.
-  static void FindLocksAtDexPc(mirror::AbstractMethod* m, uint32_t dex_pc,
+  static void FindLocksAtDexPc(mirror::ArtMethod* m, uint32_t dex_pc,
                                std::vector<uint32_t>& monitor_enter_dex_pcs)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Returns the accessed field corresponding to the quick instruction's field
   // offset at 'dex_pc' in method 'm'.
-  static mirror::Field* FindAccessedFieldAtDexPc(mirror::AbstractMethod* m,
-                                                 uint32_t dex_pc)
+  static mirror::ArtField* FindAccessedFieldAtDexPc(mirror::ArtMethod* m, uint32_t dex_pc)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Returns the invoked method corresponding to the quick instruction's vtable
   // index at 'dex_pc' in method 'm'.
-  static mirror::AbstractMethod* FindInvokedMethodAtDexPc(mirror::AbstractMethod* m,
-                                                          uint32_t dex_pc)
+  static mirror::ArtMethod* FindInvokedMethodAtDexPc(mirror::ArtMethod* m, uint32_t dex_pc)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   static void Init() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -226,7 +224,7 @@ class MethodVerifier {
   MethodVerifier(const DexFile* dex_file, mirror::DexCache* dex_cache,
                  mirror::ClassLoader* class_loader, uint32_t class_def_idx,
                  const DexFile::CodeItem* code_item,
-                 uint32_t method_idx, mirror::AbstractMethod* method,
+                 uint32_t method_idx, mirror::ArtMethod* method,
                  uint32_t access_flags, bool can_load_classes, bool allow_soft_failures)
           SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -266,16 +264,16 @@ class MethodVerifier {
                                   mirror::DexCache* dex_cache,
                                   mirror::ClassLoader* class_loader, uint32_t class_def_idx,
                                   const DexFile::CodeItem* code_item,
-                                  mirror::AbstractMethod* method, uint32_t method_access_flags,
+                                  mirror::ArtMethod* method, uint32_t method_access_flags,
                                   bool allow_soft_failures)
           SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void FindLocksAtDexPc() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::Field* FindAccessedFieldAtDexPc(uint32_t dex_pc)
+  mirror::ArtField* FindAccessedFieldAtDexPc(uint32_t dex_pc)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::AbstractMethod* FindInvokedMethodAtDexPc(uint32_t dex_pc)
+  mirror::ArtMethod* FindInvokedMethodAtDexPc(uint32_t dex_pc)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   /*
@@ -496,11 +494,11 @@ class MethodVerifier {
                   bool is_primitive) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Lookup instance field and fail for resolution violations
-  mirror::Field* GetInstanceField(const RegType& obj_type, int field_idx)
+  mirror::ArtField* GetInstanceField(const RegType& obj_type, int field_idx)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Lookup static field and fail for resolution violations
-  mirror::Field* GetStaticField(int field_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  mirror::ArtField* GetStaticField(int field_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Perform verification of an iget or sget instruction.
   void VerifyISGet(const Instruction* inst, const RegType& insn_type,
@@ -514,7 +512,7 @@ class MethodVerifier {
 
   // Returns the access field of a quick field access (iget/iput-quick) or NULL
   // if it cannot be found.
-  mirror::Field* GetQuickFieldAccess(const Instruction* inst, RegisterLine* reg_line)
+  mirror::ArtField* GetQuickFieldAccess(const Instruction* inst, RegisterLine* reg_line)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Perform verification of an iget-quick instruction.
@@ -545,7 +543,7 @@ class MethodVerifier {
    * the referrer can access the resolved method.
    * Does not throw exceptions.
    */
-  mirror::AbstractMethod* ResolveMethodAndCheckAccess(uint32_t method_idx, MethodType method_type)
+  mirror::ArtMethod* ResolveMethodAndCheckAccess(uint32_t method_idx, MethodType method_type)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   /*
@@ -570,18 +568,17 @@ class MethodVerifier {
    * Returns the resolved method on success, NULL on failure (with *failure
    * set appropriately).
    */
-  mirror::AbstractMethod* VerifyInvocationArgs(const Instruction* inst,
-                                               MethodType method_type,
-                                               bool is_range, bool is_super)
+  mirror::ArtMethod* VerifyInvocationArgs(const Instruction* inst,
+                                          MethodType method_type,
+                                          bool is_range, bool is_super)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::AbstractMethod* GetQuickInvokedMethod(const Instruction* inst,
-                                                RegisterLine* reg_line,
-                                                bool is_range)
+  mirror::ArtMethod* GetQuickInvokedMethod(const Instruction* inst,
+                                           RegisterLine* reg_line,
+                                           bool is_range)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  mirror::AbstractMethod* VerifyInvokeVirtualQuickArgs(const Instruction* inst,
-                                                       bool is_range)
+  mirror::ArtMethod* VerifyInvokeVirtualQuickArgs(const Instruction* inst, bool is_range)
   SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   /*
@@ -686,7 +683,7 @@ class MethodVerifier {
 
   const uint32_t dex_method_idx_;  // The method we're working on.
   // Its object representation if known.
-  mirror::AbstractMethod* mirror_method_ GUARDED_BY(Locks::mutator_lock_);
+  mirror::ArtMethod* mirror_method_ GUARDED_BY(Locks::mutator_lock_);
   const uint32_t method_access_flags_;  // Method's access flags.
   const DexFile* const dex_file_;  // The dex file containing the method.
   // The dex_cache for the declaring class of the method.
diff --git a/runtime/well_known_classes.cc b/runtime/well_known_classes.cc
index 434fcf00f5..8de020a975 100644
--- a/runtime/well_known_classes.cc
+++ b/runtime/well_known_classes.cc
@@ -32,8 +32,11 @@ jclass WellKnownClasses::java_lang_ClassNotFoundException;
 jclass WellKnownClasses::java_lang_Daemons;
 jclass WellKnownClasses::java_lang_Error;
 jclass WellKnownClasses::java_lang_Object;
-jclass WellKnownClasses::java_lang_reflect_InvocationHandler;
 jclass WellKnownClasses::java_lang_reflect_AbstractMethod;
+jclass WellKnownClasses::java_lang_reflect_ArtMethod;
+jclass WellKnownClasses::java_lang_reflect_Constructor;
+jclass WellKnownClasses::java_lang_reflect_Field;
+jclass WellKnownClasses::java_lang_reflect_Method;
 jclass WellKnownClasses::java_lang_reflect_Proxy;
 jclass WellKnownClasses::java_lang_RuntimeException;
 jclass WellKnownClasses::java_lang_StackOverflowError;
@@ -61,7 +64,7 @@ jmethodID WellKnownClasses::java_lang_Integer_valueOf;
 jmethodID WellKnownClasses::java_lang_Long_valueOf;
 jmethodID WellKnownClasses::java_lang_ref_FinalizerReference_add;
 jmethodID WellKnownClasses::java_lang_ref_ReferenceQueue_add;
-jmethodID WellKnownClasses::java_lang_reflect_InvocationHandler_invoke;
+jmethodID WellKnownClasses::java_lang_reflect_Proxy_invoke;
 jmethodID WellKnownClasses::java_lang_Runtime_nativeLoad;
 jmethodID WellKnownClasses::java_lang_Short_valueOf;
 jmethodID WellKnownClasses::java_lang_System_runFinalization = NULL;
@@ -83,6 +86,8 @@ jfieldID WellKnownClasses::java_lang_Thread_nativePeer;
 jfieldID WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup;
 jfieldID WellKnownClasses::java_lang_ThreadGroup_name;
 jfieldID WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup;
+jfieldID WellKnownClasses::java_lang_reflect_AbstractMethod_artMethod;
+jfieldID WellKnownClasses::java_lang_reflect_Field_artField;
 jfieldID WellKnownClasses::java_lang_reflect_Proxy_h;
 jfieldID WellKnownClasses::java_nio_DirectByteBuffer_capacity;
 jfieldID WellKnownClasses::java_nio_DirectByteBuffer_effectiveDirectAddress;
@@ -121,7 +126,7 @@ static jmethodID CachePrimitiveBoxingMethod(JNIEnv* env, char prim_name, const c
                      StringPrintf("(%c)L%s;", prim_name, boxed_name).c_str());
 }
 
-void WellKnownClasses::InitClasses(JNIEnv* env) {
+void WellKnownClasses::Init(JNIEnv* env) {
   com_android_dex_Dex = CacheClass(env, "com/android/dex/Dex");
   dalvik_system_PathClassLoader = CacheClass(env, "dalvik/system/PathClassLoader");
   java_lang_ClassLoader = CacheClass(env, "java/lang/ClassLoader");
@@ -129,8 +134,11 @@ void WellKnownClasses::InitClasses(JNIEnv* env) {
   java_lang_Daemons = CacheClass(env, "java/lang/Daemons");
   java_lang_Object = CacheClass(env, "java/lang/Object");
   java_lang_Error = CacheClass(env, "java/lang/Error");
-  java_lang_reflect_InvocationHandler = CacheClass(env, "java/lang/reflect/InvocationHandler");
   java_lang_reflect_AbstractMethod = CacheClass(env, "java/lang/reflect/AbstractMethod");
+  java_lang_reflect_ArtMethod = CacheClass(env, "java/lang/reflect/ArtMethod");
+  java_lang_reflect_Constructor = CacheClass(env, "java/lang/reflect/Constructor");
+  java_lang_reflect_Field = CacheClass(env, "java/lang/reflect/Field");
+  java_lang_reflect_Method = CacheClass(env, "java/lang/reflect/Method");
   java_lang_reflect_Proxy = CacheClass(env, "java/lang/reflect/Proxy");
   java_lang_RuntimeException = CacheClass(env, "java/lang/RuntimeException");
   java_lang_StackOverflowError = CacheClass(env, "java/lang/StackOverflowError");
@@ -142,10 +150,6 @@ void WellKnownClasses::InitClasses(JNIEnv* env) {
   java_nio_DirectByteBuffer = CacheClass(env, "java/nio/DirectByteBuffer");
   org_apache_harmony_dalvik_ddmc_Chunk = CacheClass(env, "org/apache/harmony/dalvik/ddmc/Chunk");
   org_apache_harmony_dalvik_ddmc_DdmServer = CacheClass(env, "org/apache/harmony/dalvik/ddmc/DdmServer");
-}
-
-void WellKnownClasses::Init(JNIEnv* env) {
-  InitClasses(env);
 
   com_android_dex_Dex_create = CacheMethod(env, com_android_dex_Dex, true, "create", "(Ljava/nio/ByteBuffer;)Lcom/android/dex/Dex;");
   java_lang_ClassNotFoundException_init = CacheMethod(env, java_lang_ClassNotFoundException, false, "<init>", "(Ljava/lang/String;Ljava/lang/Throwable;)V");
@@ -160,7 +164,7 @@ void WellKnownClasses::Init(JNIEnv* env) {
   ScopedLocalRef<jclass> java_lang_ref_ReferenceQueue(env, env->FindClass("java/lang/ref/ReferenceQueue"));
   java_lang_ref_ReferenceQueue_add = CacheMethod(env, java_lang_ref_ReferenceQueue.get(), true, "add", "(Ljava/lang/ref/Reference;)V");
 
-  java_lang_reflect_InvocationHandler_invoke = CacheMethod(env, java_lang_reflect_InvocationHandler, false, "invoke", "(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;");
+  java_lang_reflect_Proxy_invoke = CacheMethod(env, java_lang_reflect_Proxy, true, "invoke", "(Ljava/lang/reflect/Proxy;Ljava/lang/reflect/ArtMethod;[Ljava/lang/Object;)Ljava/lang/Object;");
   java_lang_Thread_init = CacheMethod(env, java_lang_Thread, false, "<init>", "(Ljava/lang/ThreadGroup;Ljava/lang/String;IZ)V");
   java_lang_Thread_run = CacheMethod(env, java_lang_Thread, false, "run", "()V");
   java_lang_Thread$UncaughtExceptionHandler_uncaughtException = CacheMethod(env, java_lang_Thread$UncaughtExceptionHandler, false, "uncaughtException", "(Ljava/lang/Thread;Ljava/lang/Throwable;)V");
@@ -179,6 +183,8 @@ void WellKnownClasses::Init(JNIEnv* env) {
   java_lang_ThreadGroup_mainThreadGroup = CacheField(env, java_lang_ThreadGroup, true, "mainThreadGroup", "Ljava/lang/ThreadGroup;");
   java_lang_ThreadGroup_name = CacheField(env, java_lang_ThreadGroup, false, "name", "Ljava/lang/String;");
   java_lang_ThreadGroup_systemThreadGroup = CacheField(env, java_lang_ThreadGroup, true, "systemThreadGroup", "Ljava/lang/ThreadGroup;");
+  java_lang_reflect_AbstractMethod_artMethod = CacheField(env, java_lang_reflect_AbstractMethod, false, "artMethod", "Ljava/lang/reflect/ArtMethod;");
+  java_lang_reflect_Field_artField = CacheField(env, java_lang_reflect_Field, false, "artField", "Ljava/lang/reflect/ArtField;");
   java_lang_reflect_Proxy_h = CacheField(env, java_lang_reflect_Proxy, false, "h", "Ljava/lang/reflect/InvocationHandler;");
   java_nio_DirectByteBuffer_capacity = CacheField(env, java_nio_DirectByteBuffer, false, "capacity", "I");
   java_nio_DirectByteBuffer_effectiveDirectAddress = CacheField(env, java_nio_DirectByteBuffer, false, "effectiveDirectAddress", "J");
diff --git a/runtime/well_known_classes.h b/runtime/well_known_classes.h
index fc2bffb485..bc928d0dbe 100644
--- a/runtime/well_known_classes.h
+++ b/runtime/well_known_classes.h
@@ -32,7 +32,7 @@ class Class;
 jmethodID CacheMethod(JNIEnv* env, jclass c, bool is_static, const char* name, const char* signature);
 
 struct WellKnownClasses {
-  static void InitClasses(JNIEnv* env);
+ public:
   static void Init(JNIEnv* env);  // Run before native methods are registered.
   static void LateInit(JNIEnv* env);  // Run after native methods are registered.
 
@@ -46,8 +46,11 @@ struct WellKnownClasses {
   static jclass java_lang_Daemons;
   static jclass java_lang_Error;
   static jclass java_lang_Object;
-  static jclass java_lang_reflect_InvocationHandler;
   static jclass java_lang_reflect_AbstractMethod;
+  static jclass java_lang_reflect_ArtMethod;
+  static jclass java_lang_reflect_Constructor;
+  static jclass java_lang_reflect_Field;
+  static jclass java_lang_reflect_Method;
   static jclass java_lang_reflect_Proxy;
   static jclass java_lang_RuntimeException;
   static jclass java_lang_StackOverflowError;
@@ -75,7 +78,7 @@ struct WellKnownClasses {
   static jmethodID java_lang_Long_valueOf;
   static jmethodID java_lang_ref_FinalizerReference_add;
   static jmethodID java_lang_ref_ReferenceQueue_add;
-  static jmethodID java_lang_reflect_InvocationHandler_invoke;
+  static jmethodID java_lang_reflect_Proxy_invoke;
   static jmethodID java_lang_Runtime_nativeLoad;
   static jmethodID java_lang_Short_valueOf;
   static jmethodID java_lang_System_runFinalization;
@@ -87,6 +90,8 @@ struct WellKnownClasses {
   static jmethodID org_apache_harmony_dalvik_ddmc_DdmServer_broadcast;
   static jmethodID org_apache_harmony_dalvik_ddmc_DdmServer_dispatch;
 
+  static jfieldID java_lang_reflect_AbstractMethod_artMethod;
+  static jfieldID java_lang_reflect_Field_artField;
   static jfieldID java_lang_reflect_Proxy_h;
   static jfieldID java_lang_Thread_daemon;
   static jfieldID java_lang_Thread_group;
diff --git a/test/046-reflect/expected.txt b/test/046-reflect/expected.txt
index 8de373caa6..fcfaf2ff3f 100644
--- a/test/046-reflect/expected.txt
+++ b/test/046-reflect/expected.txt
@@ -81,8 +81,9 @@ Field name is cantTouchThis
  Field type is int
  Access flags are 0x11
   cantTouchThis is 77
-  setAccessible is always true
   cantTouchThis is now 99
+  public final int Target.cantTouchThis accessible=false
+  public final int Target.cantTouchThis accessible=true
   cantTouchThis is now 87
   cantTouchThis is now 88
 cons modifiers=1
@@ -92,6 +93,8 @@ myMethod (I)I
  arg=17 anInt=7
 ReflectTest done!
 public method
+static java.lang.Object java.util.Collections.checkType(java.lang.Object,java.lang.Class) accessible=false
+static java.lang.Object java.util.Collections.checkType(java.lang.Object,java.lang.Class) accessible=true
 checkType invoking null
 checkType got expected exception
 calling const-class FieldNoisyInitUser.class
@@ -113,3 +116,7 @@ MethodNoisyInit is initializing
 generic field: java.util.List<java.lang.String>
 generic method fancyMethod params='[1] java.util.ArrayList<java.lang.String>' ret='java.util.Map<java.lang.Integer, java.lang.String>'
 generic ctor Main params='[1] java.util.ArrayList<java.lang.Integer>'
+fields are unique
+fields are .equals
+methods are unique
+methods are .equals
diff --git a/test/046-reflect/src/Main.java b/test/046-reflect/src/Main.java
index 9d4cacf499..dfb0d8fe9b 100644
--- a/test/046-reflect/src/Main.java
+++ b/test/046-reflect/src/Main.java
@@ -335,14 +335,15 @@ public class Main {
             System.out.println("  cantTouchThis is " + intVal);
             try {
                 field.setInt(instance, 99);
-                System.out.println("  setAccessible is always true");
             } catch (IllegalAccessException iae) {
                 System.out.println("ERROR: set-final failed");
             }
             intVal = field.getInt(instance);
             System.out.println("  cantTouchThis is now " + intVal);
 
+            System.out.println("  " + field + " accessible=" + field.isAccessible());
             field.setAccessible(true);
+            System.out.println("  " + field + " accessible=" + field.isAccessible());
             field.setInt(instance, 87);     // exercise int version
             intVal = field.getInt(instance);
             System.out.println("  cantTouchThis is now " + intVal);
@@ -378,8 +379,9 @@ public class Main {
             nsme.printStackTrace();
             return;
         }
-
+        System.out.println(m + " accessible=" + m.isAccessible());
         m.setAccessible(true);
+        System.out.println(m + " accessible=" + m.isAccessible());
         try {
             m.invoke(null, new Object(), Object.class);
         } catch (IllegalAccessException iae) {
@@ -518,6 +520,42 @@ public class Main {
         return stb.toString();
     }
 
+    public static void checkUnique() {
+        Field field1, field2;
+        try {
+            field1 = Main.class.getField("dummy");
+            field2 = Main.class.getField("dummy");
+        } catch (NoSuchFieldException nsfe) {
+            throw new RuntimeException(nsfe);
+        }
+        if (field1 == field2) {
+            System.out.println("ERROR: fields shouldn't have reference equality");
+        } else {
+            System.out.println("fields are unique");
+        }
+        if (field1.hashCode() == field2.hashCode() && field1.equals(field2)) {
+            System.out.println("fields are .equals");
+        } else {
+            System.out.println("ERROR: fields fail equality");
+        }
+        Method method1, method2;
+        try {
+            method1 = Main.class.getMethod("fancyMethod", new Class[] { ArrayList.class });
+            method2 = Main.class.getMethod("fancyMethod", new Class[] { ArrayList.class });
+        } catch (NoSuchMethodException nsme) {
+            throw new RuntimeException(nsme);
+        }
+        if (method1 == method2) {
+            System.out.println("ERROR: methods shouldn't have reference equality");
+        } else {
+            System.out.println("methods are unique");
+        }
+        if (method1.hashCode() == method2.hashCode() && method1.equals(method2)) {
+            System.out.println("methods are .equals");
+        } else {
+            System.out.println("ERROR: methods fail equality");
+        }
+    }
 
     public static void main(String[] args) throws Exception {
         Main test = new Main();
@@ -528,6 +566,7 @@ public class Main {
         checkClinitForFields();
         checkClinitForMethods();
         checkGeneric();
+        checkUnique();
     }
 }
 
diff --git a/test/100-reflect2/expected.txt b/test/100-reflect2/expected.txt
index f56fd98947..3d87ebc559 100644
--- a/test/100-reflect2/expected.txt
+++ b/test/100-reflect2/expected.txt
@@ -36,7 +36,7 @@ z (class java.lang.Character)
 14 (class java.lang.Short)
 [public java.lang.String(), java.lang.String(int,int,char[]), public java.lang.String(java.lang.String), public java.lang.String(java.lang.StringBuffer), public java.lang.String(java.lang.StringBuilder), public java.lang.String(byte[]), public java.lang.String(byte[],int), public java.lang.String(byte[],int,int), public java.lang.String(byte[],int,int,int), public java.lang.String(byte[],int,int,java.lang.String) throws java.io.UnsupportedEncodingException, public java.lang.String(byte[],int,int,java.nio.charset.Charset), public java.lang.String(byte[],java.lang.String) throws java.io.UnsupportedEncodingException, public java.lang.String(byte[],java.nio.charset.Charset), public java.lang.String(char[]), public java.lang.String(char[],int,int), public java.lang.String(int[],int,int)]
 [private final char[] java.lang.String.value, private final int java.lang.String.count, private int java.lang.String.hashCode, private final int java.lang.String.offset, private static final char[] java.lang.String.ASCII, public static final java.util.Comparator java.lang.String.CASE_INSENSITIVE_ORDER, private static final char java.lang.String.REPLACEMENT_CHAR, private static final long java.lang.String.serialVersionUID]
-[void java.lang.String._getChars(int,int,char[],int), public char java.lang.String.charAt(int), public int java.lang.String.codePointAt(int), public int java.lang.String.codePointBefore(int), public int java.lang.String.codePointCount(int,int), public volatile int java.lang.String.compareTo(java.lang.Object), public native int java.lang.String.compareTo(java.lang.String), public int java.lang.String.compareToIgnoreCase(java.lang.String), public java.lang.String java.lang.String.concat(java.lang.String), public boolean java.lang.String.contains(java.lang.CharSequence), public boolean java.lang.String.contentEquals(java.lang.CharSequence), public boolean java.lang.String.contentEquals(java.lang.StringBuffer), public boolean java.lang.String.endsWith(java.lang.String), public boolean java.lang.String.equals(java.lang.Object), public boolean java.lang.String.equalsIgnoreCase(java.lang.String), public void java.lang.String.getBytes(int,int,byte[],int), public [B java.lang.String.getBytes(), public [B java.lang.String.getBytes(java.lang.String) throws java.io.UnsupportedEncodingException, public [B java.lang.String.getBytes(java.nio.charset.Charset), public void java.lang.String.getChars(int,int,char[],int), public int java.lang.String.hashCode(), public int java.lang.String.indexOf(int), public int java.lang.String.indexOf(int,int), public int java.lang.String.indexOf(java.lang.String), public int java.lang.String.indexOf(java.lang.String,int), public native java.lang.String java.lang.String.intern(), public boolean java.lang.String.isEmpty(), public int java.lang.String.lastIndexOf(int), public int java.lang.String.lastIndexOf(int,int), public int java.lang.String.lastIndexOf(java.lang.String), public int java.lang.String.lastIndexOf(java.lang.String,int), public int java.lang.String.length(), public boolean java.lang.String.matches(java.lang.String), public int java.lang.String.offsetByCodePoints(int,int), public boolean java.lang.String.regionMatches(int,java.lang.String,int,int), public boolean java.lang.String.regionMatches(boolean,int,java.lang.String,int,int), public java.lang.String java.lang.String.replace(char,char), public java.lang.String java.lang.String.replace(java.lang.CharSequence,java.lang.CharSequence), public java.lang.String java.lang.String.replaceAll(java.lang.String,java.lang.String), public java.lang.String java.lang.String.replaceFirst(java.lang.String,java.lang.String), public [Ljava.lang.String; java.lang.String.split(java.lang.String), public [Ljava.lang.String; java.lang.String.split(java.lang.String,int), public boolean java.lang.String.startsWith(java.lang.String), public boolean java.lang.String.startsWith(java.lang.String,int), public java.lang.CharSequence java.lang.String.subSequence(int,int), public java.lang.String java.lang.String.substring(int), public java.lang.String java.lang.String.substring(int,int), public [C java.lang.String.toCharArray(), public java.lang.String java.lang.String.toLowerCase(), public java.lang.String java.lang.String.toLowerCase(java.util.Locale), public java.lang.String java.lang.String.toString(), public java.lang.String java.lang.String.toUpperCase(), public java.lang.String java.lang.String.toUpperCase(java.util.Locale), public java.lang.String java.lang.String.trim(), static void java.lang.String.<clinit>(), public static java.lang.String java.lang.String.copyValueOf(char[]), public static java.lang.String java.lang.String.copyValueOf(char[],int,int), private java.lang.StringIndexOutOfBoundsException java.lang.String.failedBoundsCheck(int,int,int), private native int java.lang.String.fastIndexOf(int,int), private char java.lang.String.foldCase(char), public static transient java.lang.String java.lang.String.format(java.lang.String,java.lang.Object[]), public static transient java.lang.String java.lang.String.format(java.util.Locale,java.lang.String,java.lang.Object[]), private java.lang.StringIndexOutOfBoundsException java.lang.String.indexAndLength(int), private static int java.lang.String.indexOf(java.lang.String,java.lang.String,int,int,char), private int java.lang.String.indexOfSupplementary(int,int), private int java.lang.String.lastIndexOfSupplementary(int,int), private java.lang.StringIndexOutOfBoundsException java.lang.String.startEndAndLength(int,int), public static java.lang.String java.lang.String.valueOf(char), public static java.lang.String java.lang.String.valueOf(double), public static java.lang.String java.lang.String.valueOf(float), public static java.lang.String java.lang.String.valueOf(int), public static java.lang.String java.lang.String.valueOf(long), public static java.lang.String java.lang.String.valueOf(java.lang.Object), public static java.lang.String java.lang.String.valueOf(boolean), public static java.lang.String java.lang.String.valueOf(char[]), public static java.lang.String java.lang.String.valueOf(char[],int,int)]
+[void java.lang.String._getChars(int,int,char[],int), public char java.lang.String.charAt(int), public int java.lang.String.codePointAt(int), public int java.lang.String.codePointBefore(int), public int java.lang.String.codePointCount(int,int), public volatile int java.lang.String.compareTo(java.lang.Object), public native int java.lang.String.compareTo(java.lang.String), public int java.lang.String.compareToIgnoreCase(java.lang.String), public java.lang.String java.lang.String.concat(java.lang.String), public boolean java.lang.String.contains(java.lang.CharSequence), public boolean java.lang.String.contentEquals(java.lang.CharSequence), public boolean java.lang.String.contentEquals(java.lang.StringBuffer), public boolean java.lang.String.endsWith(java.lang.String), public boolean java.lang.String.equals(java.lang.Object), public boolean java.lang.String.equalsIgnoreCase(java.lang.String), public void java.lang.String.getBytes(int,int,byte[],int), public [B java.lang.String.getBytes(), public [B java.lang.String.getBytes(java.lang.String) throws java.io.UnsupportedEncodingException, public [B java.lang.String.getBytes(java.nio.charset.Charset), public void java.lang.String.getChars(int,int,char[],int), public int java.lang.String.hashCode(), public int java.lang.String.indexOf(int), public int java.lang.String.indexOf(int,int), public int java.lang.String.indexOf(java.lang.String), public int java.lang.String.indexOf(java.lang.String,int), public native java.lang.String java.lang.String.intern(), public boolean java.lang.String.isEmpty(), public int java.lang.String.lastIndexOf(int), public int java.lang.String.lastIndexOf(int,int), public int java.lang.String.lastIndexOf(java.lang.String), public int java.lang.String.lastIndexOf(java.lang.String,int), public int java.lang.String.length(), public boolean java.lang.String.matches(java.lang.String), public int java.lang.String.offsetByCodePoints(int,int), public boolean java.lang.String.regionMatches(int,java.lang.String,int,int), public boolean java.lang.String.regionMatches(boolean,int,java.lang.String,int,int), public java.lang.String java.lang.String.replace(char,char), public java.lang.String java.lang.String.replace(java.lang.CharSequence,java.lang.CharSequence), public java.lang.String java.lang.String.replaceAll(java.lang.String,java.lang.String), public java.lang.String java.lang.String.replaceFirst(java.lang.String,java.lang.String), public [Ljava.lang.String; java.lang.String.split(java.lang.String), public [Ljava.lang.String; java.lang.String.split(java.lang.String,int), public boolean java.lang.String.startsWith(java.lang.String), public boolean java.lang.String.startsWith(java.lang.String,int), public java.lang.CharSequence java.lang.String.subSequence(int,int), public java.lang.String java.lang.String.substring(int), public java.lang.String java.lang.String.substring(int,int), public [C java.lang.String.toCharArray(), public java.lang.String java.lang.String.toLowerCase(), public java.lang.String java.lang.String.toLowerCase(java.util.Locale), public java.lang.String java.lang.String.toString(), public java.lang.String java.lang.String.toUpperCase(), public java.lang.String java.lang.String.toUpperCase(java.util.Locale), public java.lang.String java.lang.String.trim(), public static java.lang.String java.lang.String.copyValueOf(char[]), public static java.lang.String java.lang.String.copyValueOf(char[],int,int), private java.lang.StringIndexOutOfBoundsException java.lang.String.failedBoundsCheck(int,int,int), private native int java.lang.String.fastIndexOf(int,int), private char java.lang.String.foldCase(char), public static transient java.lang.String java.lang.String.format(java.lang.String,java.lang.Object[]), public static transient java.lang.String java.lang.String.format(java.util.Locale,java.lang.String,java.lang.Object[]), private java.lang.StringIndexOutOfBoundsException java.lang.String.indexAndLength(int), private static int java.lang.String.indexOf(java.lang.String,java.lang.String,int,int,char), private int java.lang.String.indexOfSupplementary(int,int), private int java.lang.String.lastIndexOfSupplementary(int,int), private java.lang.StringIndexOutOfBoundsException java.lang.String.startEndAndLength(int,int), public static java.lang.String java.lang.String.valueOf(char), public static java.lang.String java.lang.String.valueOf(double), public static java.lang.String java.lang.String.valueOf(float), public static java.lang.String java.lang.String.valueOf(int), public static java.lang.String java.lang.String.valueOf(long), public static java.lang.String java.lang.String.valueOf(java.lang.Object), public static java.lang.String java.lang.String.valueOf(boolean), public static java.lang.String java.lang.String.valueOf(char[]), public static java.lang.String java.lang.String.valueOf(char[],int,int)]
 []
 [interface java.io.Serializable, interface java.lang.Comparable, interface java.lang.CharSequence]
 0
diff --git a/test/ReferenceMap/stack_walk_refmap_jni.cc b/test/ReferenceMap/stack_walk_refmap_jni.cc
index 84f5f2ea29..1f6e307f26 100644
--- a/test/ReferenceMap/stack_walk_refmap_jni.cc
+++ b/test/ReferenceMap/stack_walk_refmap_jni.cc
@@ -20,8 +20,8 @@
 #include "class_linker.h"
 #include "dex_file-inl.h"
 #include "gc_map.h"
-#include "mirror/abstract_method.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/object_array-inl.h"
 #include "object_utils.h"
@@ -52,7 +52,7 @@ struct ReferenceMap2Visitor : public StackVisitor {
   }
 
   bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* m = GetMethod();
+    mirror::ArtMethod* m = GetMethod();
     if (!m || m->IsNative() || m->IsRuntimeMethod() || IsShadowFrame()) {
       return true;
     }
diff --git a/test/StackWalk/stack_walk_jni.cc b/test/StackWalk/stack_walk_jni.cc
index 8f4aae61fd..528586ed7b 100644
--- a/test/StackWalk/stack_walk_jni.cc
+++ b/test/StackWalk/stack_walk_jni.cc
@@ -19,8 +19,8 @@
 #include "UniquePtr.h"
 #include "class_linker.h"
 #include "gc_map.h"
-#include "mirror/abstract_method.h"
-#include "mirror/abstract_method-inl.h"
+#include "mirror/art_method.h"
+#include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/object-inl.h"
@@ -50,7 +50,7 @@ struct TestReferenceMapVisitor : public StackVisitor {
   }
 
   bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::AbstractMethod* m = GetMethod();
+    mirror::ArtMethod* m = GetMethod();
     CHECK(m != NULL);
     LOG(INFO) << "At " << PrettyMethod(m, false);
 
-- 
cgit v1.2.3-59-g8ed1b


From 75a43f10f55e2aa550de51e969cc1e60d583b632 Mon Sep 17 00:00:00 2001
From: Anwar Ghuloum <anwarg@google.com>
Date: Tue, 13 Aug 2013 17:22:14 -0700
Subject: Clean up logcat spam from compiler and verifier

Moved to VLOG(...), adding verifer tag for VLOG.

Change-Id: Ia9ac8aeaf5aa1f4881e384003e82a66e560c5692
---
 compiler/driver/compiler_driver.cc  |  6 +++---
 compiler/oat_writer.cc              |  4 ++--
 dex2oat/dex2oat.cc                  | 12 ++++++------
 runtime/base/logging.h              |  2 ++
 runtime/runtime.cc                  |  3 +++
 runtime/verifier/method_verifier.cc | 37 +++++++++++++++++++++----------------
 6 files changed, 37 insertions(+), 27 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 144271d581..47ef222bf8 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -64,7 +64,7 @@ static void DumpStat(size_t x, size_t y, const char* str) {
   if (x == 0 && y == 0) {
     return;
   }
-  LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases";
+  VLOG(compiler) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases";
 }
 
 class AOTCompilationStats {
@@ -724,7 +724,7 @@ static void MaybeAddToImageClasses(mirror::Class* klass, CompilerDriver::Descrip
     std::pair<CompilerDriver::DescriptorSet::iterator, bool> result =
         image_classes->insert(descriptor);
     if (result.second) {
-      LOG(INFO) << "Adding " << descriptor << " to image classes";
+        VLOG(compiler) << "Adding " << descriptor << " to image classes";
     } else {
       return;
     }
@@ -2070,7 +2070,7 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
             }
           }
           if (!is_black_listed) {
-            LOG(INFO) << "Initializing: " << descriptor;
+            VLOG(compiler) << "Initializing: " << descriptor;
             if (StringPiece(descriptor) == "Ljava/lang/Void;") {
               // Hand initialize j.l.Void to avoid Dex file operations in un-started runtime.
               mirror::ObjectArray<mirror::Field>* fields = klass->GetSFields();
diff --git a/compiler/oat_writer.cc b/compiler/oat_writer.cc
index ce88cf6dd6..b129026a24 100644
--- a/compiler/oat_writer.cc
+++ b/compiler/oat_writer.cc
@@ -464,7 +464,7 @@ bool OatWriter::Write(OutputStream& out) {
   if (kIsDebugBuild) {
     uint32_t size_total = 0;
     #define DO_STAT(x) \
-      LOG(INFO) << #x "=" << PrettySize(x) << " (" << x << "B)"; \
+      VLOG(compiler) << #x "=" << PrettySize(x) << " (" << x << "B)"; \
       size_total += x;
 
     DO_STAT(size_dex_file_alignment_);
@@ -495,7 +495,7 @@ bool OatWriter::Write(OutputStream& out) {
     DO_STAT(size_oat_class_method_offsets_);
     #undef DO_STAT
 
-    LOG(INFO) << "size_total=" << PrettySize(size_total) << " (" << size_total << "B)"; \
+    VLOG(compiler) << "size_total=" << PrettySize(size_total) << " (" << size_total << "B)"; \
     CHECK_EQ(file_offset + size_total, static_cast<uint32_t>(out.Seek(0, kSeekCurrent)));
     CHECK_EQ(size_, size_total);
   }
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index b85378d9ec..0f146a9baf 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -164,7 +164,7 @@ class Dex2Oat {
 
   ~Dex2Oat() {
     delete runtime_;
-    LOG(INFO) << "dex2oat took " << PrettyDuration(NanoTime() - start_ns_)
+    VLOG(compiler) << "dex2oat took " << PrettyDuration(NanoTime() - start_ns_)
               << " (threads: " << thread_count_ << ")";
   }
 
@@ -923,7 +923,7 @@ static int dex2oat(int argc, char** argv) {
     }
     if (num_methods <= Runtime::Current()->GetNumDexMethodsThreshold()) {
       Runtime::Current()->SetCompilerFilter(Runtime::kSpeed);
-      LOG(INFO) << "Below method threshold, compiling anyways";
+      VLOG(compiler) << "Below method threshold, compiling anyways";
     }
   }
 
@@ -945,7 +945,7 @@ static int dex2oat(int argc, char** argv) {
     return EXIT_FAILURE;
   }
 
-  LOG(INFO) << "Oat file written successfully (unstripped): " << oat_location;
+  VLOG(compiler) << "Oat file written successfully (unstripped): " << oat_location;
 
   // Notes on the interleaving of creating the image and oat file to
   // ensure the references between the two are correct.
@@ -1009,7 +1009,7 @@ static int dex2oat(int argc, char** argv) {
     if (!image_creation_success) {
       return EXIT_FAILURE;
     }
-    LOG(INFO) << "Image written successfully: " << image_filename;
+    VLOG(compiler) << "Image written successfully: " << image_filename;
   }
 
   if (is_host) {
@@ -1037,7 +1037,7 @@ static int dex2oat(int argc, char** argv) {
       CHECK(write_ok);
     }
     oat_file.reset(out.release());
-    LOG(INFO) << "Oat file copied successfully (stripped): " << oat_stripped;
+    VLOG(compiler) << "Oat file copied successfully (stripped): " << oat_stripped;
   }
 
 #if ART_USE_PORTABLE_COMPILER  // We currently only generate symbols on Portable
@@ -1049,7 +1049,7 @@ static int dex2oat(int argc, char** argv) {
 
 
   // We wrote the oat file successfully, and want to keep it.
-  LOG(INFO) << "Oat file written successfully (stripped): " << oat_location;
+  VLOG(compiler) << "Oat file written successfully (stripped): " << oat_location;
 #endif  // ART_USE_PORTABLE_COMPILER
 
   timings.EndSplit();
diff --git a/runtime/base/logging.h b/runtime/base/logging.h
index ade8d34ed6..8e40da0112 100644
--- a/runtime/base/logging.h
+++ b/runtime/base/logging.h
@@ -125,6 +125,7 @@
 
 #define VLOG_IS_ON(module) UNLIKELY(::art::gLogVerbosity.module)
 #define VLOG(module) if (VLOG_IS_ON(module)) ::art::LogMessage(__FILE__, __LINE__, INFO, -1).stream()
+#define VLOG_STREAM(module) ::art::LogMessage(__FILE__, __LINE__, INFO, -1).stream()
 
 //
 // Implementation details beyond this point.
@@ -306,6 +307,7 @@ class ToStr {
 // and the "-verbose:" command line argument.
 struct LogVerbosity {
   bool class_linker;  // Enabled with "-verbose:class".
+  bool verifier;
   bool compiler;
   bool heap;
   bool gc;
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index 70d8816401..7c354b5b66 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -365,6 +365,7 @@ Runtime::ParsedOptions* Runtime::ParsedOptions::Create(const Options& options, b
   parsed->sea_ir_mode_ = false;
 //  gLogVerbosity.class_linker = true;  // TODO: don't check this in!
 //  gLogVerbosity.compiler = true;  // TODO: don't check this in!
+//  gLogVerbosity.verifier = true;  // TODO: don't check this in!
 //  gLogVerbosity.heap = true;  // TODO: don't check this in!
 //  gLogVerbosity.gc = true;  // TODO: don't check this in!
 //  gLogVerbosity.jdwp = true;  // TODO: don't check this in!
@@ -522,6 +523,8 @@ Runtime::ParsedOptions* Runtime::ParsedOptions::Create(const Options& options, b
       for (size_t i = 0; i < verbose_options.size(); ++i) {
         if (verbose_options[i] == "class") {
           gLogVerbosity.class_linker = true;
+        } else if (verbose_options[i] == "verifier") {
+          gLogVerbosity.verifier = true;
         } else if (verbose_options[i] == "compiler") {
           gLogVerbosity.compiler = true;
         } else if (verbose_options[i] == "heap") {
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index fc595d90d9..6f3bae595b 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -45,6 +45,7 @@ namespace art {
 namespace verifier {
 
 static const bool gDebugVerify = false;
+// TODO: Add a constant to method_verifier to turn on verbose logging?
 
 void PcToRegisterLineTable::Init(RegisterTrackingMode mode, InstructionFlags* flags,
                                  uint32_t insns_size, uint16_t registers_size,
@@ -231,26 +232,28 @@ MethodVerifier::FailureKind MethodVerifier::VerifyMethod(uint32_t method_idx,
   MethodVerifier::FailureKind result = kNoFailure;
   uint64_t start_ns = NanoTime();
 
-  MethodVerifier verifier(dex_file, dex_cache, class_loader, class_def_idx, code_item, method_idx,
-                          method, method_access_flags, true, allow_soft_failures);
-  if (verifier.Verify()) {
+  MethodVerifier verifier_(dex_file, dex_cache, class_loader, class_def_idx, code_item, method_idx,
+                           method, method_access_flags, true, allow_soft_failures);
+  if (verifier_.Verify()) {
     // Verification completed, however failures may be pending that didn't cause the verification
     // to hard fail.
-    CHECK(!verifier.have_pending_hard_failure_);
-    if (verifier.failures_.size() != 0) {
-      verifier.DumpFailures(LOG(INFO) << "Soft verification failures in "
-                                      << PrettyMethod(method_idx, *dex_file) << "\n");
+    CHECK(!verifier_.have_pending_hard_failure_);
+    if (verifier_.failures_.size() != 0) {
+      if (VLOG_IS_ON(verifier)) {
+          verifier_.DumpFailures(VLOG_STREAM(verifier) << "Soft verification failures in "
+                                << PrettyMethod(method_idx, *dex_file) << "\n");
+      }
       result = kSoftFailure;
     }
   } else {
     // Bad method data.
-    CHECK_NE(verifier.failures_.size(), 0U);
-    CHECK(verifier.have_pending_hard_failure_);
-    verifier.DumpFailures(LOG(INFO) << "Verification error in "
+    CHECK_NE(verifier_.failures_.size(), 0U);
+    CHECK(verifier_.have_pending_hard_failure_);
+    verifier_.DumpFailures(LOG(INFO) << "Verification error in "
                                     << PrettyMethod(method_idx, *dex_file) << "\n");
     if (gDebugVerify) {
-      std::cout << "\n" << verifier.info_messages_.str();
-      verifier.Dump(std::cout);
+      std::cout << "\n" << verifier_.info_messages_.str();
+      verifier_.Dump(std::cout);
     }
     result = kHardFailure;
   }
@@ -1079,8 +1082,10 @@ bool MethodVerifier::VerifyCodeFlow() {
 
 std::ostream& MethodVerifier::DumpFailures(std::ostream& os) {
   DCHECK_EQ(failures_.size(), failure_messages_.size());
-  for (size_t i = 0; i < failures_.size(); ++i) {
-    os << failure_messages_[i]->str() << "\n";
+  if (VLOG_IS_ON(verifier)) {
+      for (size_t i = 0; i < failures_.size(); ++i) {
+          os << failure_messages_[i]->str() << "\n";
+      }
   }
   return os;
 }
@@ -3386,7 +3391,7 @@ mirror::Field* MethodVerifier::GetStaticField(int field_idx) {
                                                                                dex_cache_,
                                                                                class_loader_);
   if (field == NULL) {
-    LOG(INFO) << "Unable to resolve static field " << field_idx << " ("
+    VLOG(verifier) << "Unable to resolve static field " << field_idx << " ("
               << dex_file_->GetFieldName(field_id) << ") in "
               << dex_file_->GetFieldDeclaringClassDescriptor(field_id);
     DCHECK(Thread::Current()->IsExceptionPending());
@@ -3423,7 +3428,7 @@ mirror::Field* MethodVerifier::GetInstanceField(const RegType& obj_type, int fie
                                                                                dex_cache_,
                                                                                class_loader_);
   if (field == NULL) {
-    LOG(INFO) << "Unable to resolve instance field " << field_idx << " ("
+    VLOG(verifier) << "Unable to resolve instance field " << field_idx << " ("
               << dex_file_->GetFieldName(field_id) << ") in "
               << dex_file_->GetFieldDeclaringClassDescriptor(field_id);
     DCHECK(Thread::Current()->IsExceptionPending());
-- 
cgit v1.2.3-59-g8ed1b


From bd136a29f08486525d6abc7d0a0006ce5b4011c1 Mon Sep 17 00:00:00 2001
From: Dragos Sbirlea <dragoss@google.com>
Date: Tue, 13 Aug 2013 18:07:04 -0700
Subject: Get PORTABLE + SMALL on x86.

Implemented the portable resolution trampoline and
the portable to interpreter bridge.
Also work on integrating SEA_IR in the PORTABLE+SMALL framework.
Refactor some naming and correct indenting.

Change-Id: Ibd97da5e5b6f5148274c9bff368e3654b661ef51
---
 compiler/driver/compiler_driver.cc                 |  9 +++--
 compiler/sea_ir/debug/dot_gen.h                    |  3 +-
 compiler/sea_ir/frontend.cc                        | 35 ++++++++++++++++---
 compiler/sea_ir/ir/sea.cc                          |  9 +++--
 compiler/sea_ir/ir/sea.h                           |  5 +--
 runtime/arch/arm/portable_entrypoints_arm.S        |  4 +--
 runtime/arch/x86/portable_entrypoints_x86.S        | 40 +++++++++++++++++++---
 runtime/entrypoints/entrypoint_utils.cc            |  1 +
 runtime/entrypoints/entrypoint_utils.h             |  4 +--
 .../portable/portable_trampoline_entrypoints.cc    |  6 ++--
 .../quick/quick_trampoline_entrypoints.cc          | 15 +++++---
 11 files changed, 103 insertions(+), 28 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index b8727fe103..4659f7b7eb 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -2231,13 +2231,18 @@ void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t
   } else if ((access_flags & kAccAbstract) != 0) {
   } else {
     bool compile = verifier::MethodVerifier::IsCandidateForCompilation(code_item, access_flags);
+#ifdef ART_SEA_IR_MODE
+    bool use_sea = Runtime::Current()->IsSeaIRMode();
+    use_sea = use_sea && (std::string::npos != PrettyMethod(method_idx, dex_file).find("fibonacci"));
+    if (use_sea) compile = true;
+#endif
+
     if (compile) {
       CompilerFn compiler = compiler_;
 #ifdef ART_SEA_IR_MODE
-      bool use_sea = Runtime::Current()->IsSeaIRMode();
-      use_sea = use_sea && (std::string::npos != PrettyMethod(method_idx, dex_file).find("fibonacci"));
       if (use_sea) {
         compiler = sea_ir_compiler_;
+        LOG(INFO) << "Using SEA IR to compile..." << std::endl;
       }
 #endif
       // NOTE: if compiler declines to compile this method, it will return NULL.
diff --git a/compiler/sea_ir/debug/dot_gen.h b/compiler/sea_ir/debug/dot_gen.h
index 5270582c16..05d97fa319 100644
--- a/compiler/sea_ir/debug/dot_gen.h
+++ b/compiler/sea_ir/debug/dot_gen.h
@@ -20,6 +20,7 @@
 #include "safe_map.h"
 #include "base/stringprintf.h"
 #include "file_output_stream.h"
+#include "os.h"
 #include "sea_ir/ir/sea.h"
 #include "sea_ir/types/type_inference.h"
 
@@ -103,7 +104,7 @@ class DotConversion {
     LOG(INFO) << "Starting to write SEA string to file.";
     DotGenerationVisitor dgv = DotGenerationVisitor(&options_, types);
     graph->Accept(&dgv);
-    art::File* file = art::OS::OpenFile(filename.c_str(), O_RDWR | O_CREAT | O_TRUNC);
+    art::File* file = art::OS::OpenFileReadWrite(filename.c_str());
     art::FileOutputStream fos(file);
     std::string graph_as_string = dgv.GetResult();
     graph_as_string += "}";
diff --git a/compiler/sea_ir/frontend.cc b/compiler/sea_ir/frontend.cc
index e24d07d50c..421c3a44f1 100644
--- a/compiler/sea_ir/frontend.cc
+++ b/compiler/sea_ir/frontend.cc
@@ -16,18 +16,26 @@
 
 #ifdef ART_SEA_IR_MODE
 #include <llvm/Support/Threading.h>
+#include <llvm/Support/raw_ostream.h>
+#include <llvm/Bitcode/ReaderWriter.h>
+
 #include "base/logging.h"
+#include "llvm/llvm_compilation_unit.h"
 #include "dex/portable/mir_to_gbc.h"
 #include "driver/compiler_driver.h"
-#include "leb128.h"
-#include "llvm/llvm_compilation_unit.h"
+#include "verifier/method_verifier.h"
 #include "mirror/object.h"
+#include "utils.h"
+
 #include "runtime.h"
 #include "safe_map.h"
 
 #include "sea_ir/ir/sea.h"
 #include "sea_ir/debug/dot_gen.h"
 #include "sea_ir/types/types.h"
+#include "sea_ir/code_gen/code_gen.h"
+
+
 namespace art {
 
 static CompiledMethod* CompileMethodWithSeaIr(CompilerDriver& compiler,
@@ -44,12 +52,31 @@ static CompiledMethod* CompileMethodWithSeaIr(CompilerDriver& compiler,
   //       and silencing the cpplint.py warning, I just corrected the formatting.
   VLOG(compiler) << "Compiling " << PrettyMethod(method_idx, dex_file) << "...";
   sea_ir::SeaGraph* ir_graph = sea_ir::SeaGraph::GetGraph(dex_file);
-  ir_graph->CompileMethod(code_item, class_def_idx, method_idx, method_access_flags, dex_file);
+  sea_ir::CodeGenData* llvm_data =
+      ir_graph->CompileMethod(code_item, class_def_idx, method_idx, method_access_flags, dex_file);
   sea_ir::DotConversion dc;
   SafeMap<int, const sea_ir::Type*>*  types = ir_graph->ti_->GetTypeMap();
   dc.DumpSea(ir_graph, "/tmp/temp.dot", types);
   CHECK(0 && "No SEA compiled function exists yet.");
-  return NULL;
+
+  MethodReference mref(&dex_file, method_idx);
+
+  // TODO: Passing the LLVM code as string is ugly and inefficient,
+  //       but it is the way portable did it. I kept it for compatibility,
+  //       but actually it should not happen.
+  std::string llvm_code;
+  ::llvm::raw_string_ostream str_os(llvm_code);
+  ::llvm::WriteBitcodeToFile(&llvm_data->module_, str_os);
+
+  std::string symbol = "dex_";
+  symbol += MangleForJni(PrettyMethod(method_idx, dex_file));
+
+  CompiledMethod* compiled_method =  new CompiledMethod(
+                              compiler.GetInstructionSet(),
+                              llvm_code,
+                              *verifier::MethodVerifier::GetDexGcMap(mref),
+                              symbol);
+  return compiled_method;
 }
 
 CompiledMethod* SeaIrCompileOneMethod(CompilerDriver& compiler,
diff --git a/compiler/sea_ir/ir/sea.cc b/compiler/sea_ir/ir/sea.cc
index 08fe0e1fac..902839dd70 100644
--- a/compiler/sea_ir/ir/sea.cc
+++ b/compiler/sea_ir/ir/sea.cc
@@ -386,7 +386,7 @@ void SeaGraph::RenameAsSSA(Region* crt_region,
   scoped_table->CloseScope();
 }
 
-void SeaGraph::GenerateLLVM() {
+CodeGenData* SeaGraph::GenerateLLVM() {
   // Pass: Generate LLVM IR.
   CodeGenPrepassVisitor code_gen_prepass_visitor;
   std::cout << "Generating code..." << std::endl;
@@ -399,9 +399,11 @@ void SeaGraph::GenerateLLVM() {
   CodeGenPostpassVisitor code_gen_postpass_visitor(code_gen_visitor.GetData());
   Accept(&code_gen_postpass_visitor);
   code_gen_postpass_visitor.Write(std::string("my_file.llvm"));
+  return code_gen_postpass_visitor.GetData();
 }
 
-void SeaGraph::CompileMethod(const art::DexFile::CodeItem* code_item, uint32_t class_def_idx,
+CodeGenData* SeaGraph::CompileMethod(
+    const art::DexFile::CodeItem* code_item, uint32_t class_def_idx,
     uint32_t method_idx, uint32_t method_access_flags, const art::DexFile& dex_file) {
   // Two passes: Builds the intermediate structure (non-SSA) of the sea-ir for the function.
   BuildMethodSeaGraph(code_item, dex_file, class_def_idx, method_idx, method_access_flags);
@@ -420,7 +422,8 @@ void SeaGraph::CompileMethod(const art::DexFile::CodeItem* code_item, uint32_t c
   // Pass: type inference
   ti_->ComputeTypes(this);
   // Pass: Generate LLVM IR.
-  GenerateLLVM();
+  CodeGenData* cgd = GenerateLLVM();
+  return cgd;
 }
 
 void SeaGraph::ComputeDominanceFrontier() {
diff --git a/compiler/sea_ir/ir/sea.h b/compiler/sea_ir/ir/sea.h
index 0b20ed7d74..df420ed9c8 100644
--- a/compiler/sea_ir/ir/sea.h
+++ b/compiler/sea_ir/ir/sea.h
@@ -37,6 +37,7 @@ enum RegionNumbering {
 };
 
 class TypeInference;
+class CodeGenData;
 
 class Region;
 class InstructionNode;
@@ -260,7 +261,7 @@ class SeaGraph: IVisitable {
  public:
   static SeaGraph* GetGraph(const art::DexFile&);
 
-  void CompileMethod(const art::DexFile::CodeItem* code_item, uint32_t class_def_idx,
+  CodeGenData* CompileMethod(const art::DexFile::CodeItem* code_item, uint32_t class_def_idx,
       uint32_t method_idx, uint32_t method_access_flags, const art::DexFile& dex_file);
   // Returns all regions corresponding to this SeaGraph.
   std::vector<Region*>* GetRegions() {
@@ -337,7 +338,7 @@ class SeaGraph: IVisitable {
   void RenameAsSSA(Region* node, utils::ScopedHashtable<int, InstructionNode*>* scoped_table);
   // Generate LLVM IR for the method.
   // Precondition: ConvertToSSA().
-  void GenerateLLVM();
+  CodeGenData* GenerateLLVM();
 
   static SeaGraph graph_;
   std::vector<Region*> regions_;
diff --git a/runtime/arch/arm/portable_entrypoints_arm.S b/runtime/arch/arm/portable_entrypoints_arm.S
index f21ae28164..073efdc383 100644
--- a/runtime/arch/arm/portable_entrypoints_arm.S
+++ b/runtime/arch/arm/portable_entrypoints_arm.S
@@ -114,7 +114,7 @@ ENTRY art_portable_resolution_trampoline
     .cfi_rel_offset r10, 28
     .cfi_rel_offset r11, 32
     .cfi_rel_offset lr, 36
-    sub sp, #8                        @ 2 words of space, bottom word will hold Method*
+    sub sp, #8                     @ 2 words of space, bottom word will hold Method*
     .pad #8
     .cfi_adjust_cfa_offset 8
     mov     r2, r9                 @ pass Thread::Current
@@ -156,7 +156,7 @@ ENTRY art_portable_to_interpreter_bridge
     .cfi_rel_offset r10, 28
     .cfi_rel_offset r11, 32
     .cfi_rel_offset lr, 36
-    sub sp, #8                        @ 2 words of space, bottom word will hold Method*
+    sub sp, #8                     @ 2 words of space, bottom word will hold Method*
     .pad #8
     .cfi_adjust_cfa_offset 8
     mov     r1, r9                 @ pass Thread::Current
diff --git a/runtime/arch/x86/portable_entrypoints_x86.S b/runtime/arch/x86/portable_entrypoints_x86.S
index 0313d4b882..24fa98be15 100644
--- a/runtime/arch/x86/portable_entrypoints_x86.S
+++ b/runtime/arch/x86/portable_entrypoints_x86.S
@@ -68,13 +68,13 @@ END_FUNCTION art_portable_invoke_stub
 DEFINE_FUNCTION art_portable_proxy_invoke_handler
     // Fake callee save ref and args frame set up, note portable doesn't use callee save frames.
     // TODO: just save the registers that are needed in artPortableProxyInvokeHandler.
-    PUSH edi  // Save callee saves
+    PUSH edi                      // Save callee saves
     PUSH esi
     PUSH ebp
-    PUSH ebx  // Save args
+    PUSH ebx                      // Save args
     PUSH edx
     PUSH ecx
-    PUSH eax   // Align stack, eax will be clobbered by Method*
+    PUSH eax                      // Align stack, eax will be clobbered by Method*
     // Begin argument set up.
     PUSH esp                      // pass SP
     pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
@@ -90,5 +90,35 @@ DEFINE_FUNCTION art_portable_proxy_invoke_handler
     ret
 END_FUNCTION art_portable_proxy_invoke_handler
 
-UNIMPLEMENTED art_portable_resolution_trampoline
-UNIMPLEMENTED art_portable_to_interpreter_bridge
+DEFINE_FUNCTION art_portable_resolution_trampoline
+  pushl %ebp
+  movl %esp, %ebp                 // save ESP
+  subl LITERAL(8), %esp           // Align stack
+  movl 8(%ebp), %eax              // Method* called
+  leal 8(%ebp), %edx              // Method** called_addr
+  pushl %edx                      // pass called_addr
+  pushl %fs:THREAD_SELF_OFFSET    // pass thread
+  pushl %ecx                      // pass receiver
+  pushl %eax                      // pass called
+  call SYMBOL(artPortableResolutionTrampoline)
+  leave
+  cmpl LITERAL(0), %eax
+  je resolve_fail
+  jmp * %eax
+resolve_fail:
+  ret
+END_FUNCTION art_portable_resolution_trampoline
+
+DEFINE_FUNCTION art_portable_to_interpreter_bridge
+  pushl %ebp
+  movl %esp, %ebp                 // save ESP
+  subl LITERAL(12), %esp          // Align stack
+  movl 8(%ebp), %eax              // Method* called
+  leal 8(%ebp), %edx              // Method** called_addr
+  pushl %edx                      // pass called_addr
+  pushl %fs:THREAD_SELF_OFFSET    // pass thread
+  pushl %eax                      // pass called
+  call SYMBOL(artPortableToInterpreterBridge)
+  leave
+  ret
+END_FUNCTION art_quick_to_interpreter_bridge
diff --git a/runtime/entrypoints/entrypoint_utils.cc b/runtime/entrypoints/entrypoint_utils.cc
index bf0fffaad2..52f8c81ab6 100644
--- a/runtime/entrypoints/entrypoint_utils.cc
+++ b/runtime/entrypoints/entrypoint_utils.cc
@@ -23,6 +23,7 @@
 #include "mirror/art_method-inl.h"
 #include "mirror/class-inl.h"
 #include "mirror/object-inl.h"
+#include "object_utils.h"
 #include "mirror/object_array-inl.h"
 #include "mirror/proxy.h"
 #include "reflection.h"
diff --git a/runtime/entrypoints/entrypoint_utils.h b/runtime/entrypoints/entrypoint_utils.h
index 2b73af437e..8b58cb332c 100644
--- a/runtime/entrypoints/entrypoint_utils.h
+++ b/runtime/entrypoints/entrypoint_utils.h
@@ -16,7 +16,7 @@
 
 #ifndef ART_RUNTIME_ENTRYPOINTS_ENTRYPOINT_UTILS_H_
 #define ART_RUNTIME_ENTRYPOINTS_ENTRYPOINT_UTILS_H_
-
+#include "object_utils.h"
 #include "class_linker.h"
 #include "common_throws.h"
 #include "dex_file.h"
@@ -27,7 +27,7 @@
 #include "mirror/array.h"
 #include "mirror/class-inl.h"
 #include "mirror/throwable.h"
-#include "object_utils.h"
+
 #include "thread.h"
 
 namespace art {
diff --git a/runtime/entrypoints/portable/portable_trampoline_entrypoints.cc b/runtime/entrypoints/portable/portable_trampoline_entrypoints.cc
index e1ce11a825..61f7440456 100644
--- a/runtime/entrypoints/portable/portable_trampoline_entrypoints.cc
+++ b/runtime/entrypoints/portable/portable_trampoline_entrypoints.cc
@@ -42,8 +42,10 @@ class PortableArgumentVisitor {
 #define PORTABLE_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE 64
 #define PORTABLE_STACK_ARG_SKIP 16
 #elif defined(__i386__)
-#define PORTABLE_CALLEE_SAVE_FRAME__REF_AND_ARGS__R1_OFFSET 4
-#define PORTABLE_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE 32
+// For x86 there are no register arguments and the stack pointer will point directly to the called
+// method argument passed by the caller.
+#define PORTABLE_CALLEE_SAVE_FRAME__REF_AND_ARGS__R1_OFFSET 0
+#define PORTABLE_CALLEE_SAVE_FRAME__REF_AND_ARGS__FRAME_SIZE 0
 #define PORTABLE_STACK_ARG_SKIP 4
 #else
 #error "Unsupported architecture"
diff --git a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
index 392bcc5257..535d540d9a 100644
--- a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
@@ -15,8 +15,10 @@
  */
 
 #include "callee_save_frame.h"
+#include "common_throws.h"
 #include "dex_file-inl.h"
 #include "dex_instruction-inl.h"
+#include "entrypoints/entrypoint_utils.h"
 #include "interpreter/interpreter.h"
 #include "invoke_arg_array_builder.h"
 #include "mirror/art_method-inl.h"
@@ -26,6 +28,8 @@
 #include "object_utils.h"
 #include "runtime.h"
 
+
+
 namespace art {
 
 // Visits the arguments as saved to the stack by a Runtime::kRefAndArgs callee save frame.
@@ -218,10 +222,11 @@ class QuickArgumentVisitor {
 };
 
 // Visits arguments on the stack placing them into the shadow frame.
-class BuildShadowFrameVisitor : public QuickArgumentVisitor {
+class BuildQuickShadowFrameVisitor : public QuickArgumentVisitor {
  public:
-  BuildShadowFrameVisitor(mirror::ArtMethod** sp, bool is_static, const char* shorty,
-                          uint32_t shorty_len, ShadowFrame& sf, size_t first_arg_reg) :
+  BuildQuickShadowFrameVisitor(mirror::ArtMethod** sp,
+      bool is_static, const char* shorty,
+       uint32_t shorty_len, ShadowFrame& sf, size_t first_arg_reg) :
     QuickArgumentVisitor(sp, is_static, shorty, shorty_len), sf_(sf), cur_reg_(first_arg_reg) {}
 
   virtual void Visit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -258,7 +263,7 @@ class BuildShadowFrameVisitor : public QuickArgumentVisitor {
   ShadowFrame& sf_;
   size_t cur_reg_;
 
-  DISALLOW_COPY_AND_ASSIGN(BuildShadowFrameVisitor);
+  DISALLOW_COPY_AND_ASSIGN(BuildQuickShadowFrameVisitor);
 };
 
 extern "C" uint64_t artQuickToInterpreterBridge(mirror::ArtMethod* method, Thread* self,
@@ -280,7 +285,7 @@ extern "C" uint64_t artQuickToInterpreterBridge(mirror::ArtMethod* method, Threa
     ShadowFrame* shadow_frame(ShadowFrame::Create(num_regs, NULL,  // No last shadow coming from quick.
                                                   method, 0, memory));
     size_t first_arg_reg = code_item->registers_size_ - code_item->ins_size_;
-    BuildShadowFrameVisitor shadow_frame_builder(sp, mh.IsStatic(), mh.GetShorty(),
+    BuildQuickShadowFrameVisitor shadow_frame_builder(sp, mh.IsStatic(), mh.GetShorty(),
                                                  mh.GetShortyLength(),
                                                  *shadow_frame, first_arg_reg);
     shadow_frame_builder.VisitArguments();
-- 
cgit v1.2.3-59-g8ed1b


From 02e25119b15a6f619f17db99f5d05124a5807ff3 Mon Sep 17 00:00:00 2001
From: Mathieu Chartier <mathieuc@google.com>
Date: Wed, 14 Aug 2013 16:14:24 -0700
Subject: Fix up TODO: c++0x, update cpplint.

Needed to update cpplint to handle const auto.

Fixed a few cpplint errors that were being missed before.

Replaced most of the TODO c++0x with ranged based loops. Loops which
do not have a descriptive container name have a concrete type instead
of auto.

Change-Id: Id7cc0f27030f56057c544e94277300b3f298c9c5
---
 compiler/driver/compiler_driver.cc                 |   12 +-
 compiler/elf_fixup.cc                              |    1 -
 compiler/image_writer.cc                           |   48 +-
 compiler/image_writer.h                            |    3 +-
 compiler/sea_ir/ir/regions_test.cc                 |    2 +-
 compiler/sea_ir/types/type_data_test.cc            |    2 +-
 compiler/sea_ir/types/type_inference_visitor.cc    |    4 +-
 compiler/sea_ir/types/type_inference_visitor.h     |    2 +-
 .../sea_ir/types/type_inference_visitor_test.cc    |    2 +-
 compiler/utils/assembler.h                         |    1 +
 oatdump/oatdump.cc                                 |   37 +-
 runtime/base/histogram.h                           |    2 +-
 runtime/class_linker.cc                            |   49 +-
 runtime/debugger.cc                                |   13 +-
 runtime/dex_file_verifier.cc                       |    3 +-
 runtime/gc/accounting/gc_allocator.cc              |    6 +-
 runtime/gc/accounting/gc_allocator.h               |    6 +-
 runtime/gc/accounting/heap_bitmap-inl.h            |   16 +-
 runtime/gc/accounting/heap_bitmap.cc               |   46 +-
 runtime/gc/accounting/heap_bitmap.h                |   16 +-
 runtime/gc/accounting/mod_union_table.cc           |  149 +--
 runtime/gc/collector/garbage_collector.cc          |   13 +-
 runtime/gc/collector/mark_sweep.cc                 |   95 +-
 runtime/gc/collector/mark_sweep.h                  |    1 +
 runtime/gc/collector/partial_mark_sweep.cc         |    6 +-
 runtime/gc/collector/partial_mark_sweep.h          |    1 +
 runtime/gc/collector/sticky_mark_sweep.cc          |    6 +-
 runtime/gc/collector/sticky_mark_sweep.h           |    1 +
 runtime/gc/heap.cc                                 |   81 +-
 runtime/indirect_reference_table.cc                |    5 +-
 runtime/indirect_reference_table.h                 |   10 +-
 runtime/instrumentation.cc                         |   28 +-
 runtime/intern_table.cc                            |   15 +-
 runtime/intern_table_test.cc                       |    3 +-
 runtime/jni_internal.cc                            |   12 +-
 runtime/mirror/art_method.h                        |    1 +
 runtime/monitor.cc                                 |    4 +-
 runtime/native/dalvik_system_DexFile.cc            |   10 +-
 runtime/output_stream_test.cc                      |    2 +-
 runtime/reference_table.cc                         |    5 +-
 runtime/thread_list.cc                             |   57 +-
 runtime/thread_list.h                              |    2 -
 runtime/thread_pool.h                              |    3 +
 runtime/trace.cc                                   |    7 +-
 runtime/verifier/method_verifier.h                 |    2 +-
 runtime/verifier/reg_type.cc                       |    8 +-
 runtime/verifier/reg_type.h                        |    1 +
 runtime/verifier/register_line.cc                  |    5 +-
 tools/cpplint.py                                   | 1026 ++++++++++++++++----
 49 files changed, 1108 insertions(+), 722 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index b8727fe103..0ef0428619 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -664,8 +664,7 @@ void CompilerDriver::LoadImageClasses(base::TimingLogger& timings)
   Thread* self = Thread::Current();
   ScopedObjectAccess soa(self);
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  typedef DescriptorSet::iterator It;  // TODO: C++0x auto
-  for (It it = image_classes_->begin(), end = image_classes_->end(); it != end;) {
+  for (auto it = image_classes_->begin(), end = image_classes_->end(); it != end;) {
     std::string descriptor(*it);
     SirtRef<mirror::Class> klass(self, class_linker->FindSystemClass(descriptor.c_str()));
     if (klass.get() == NULL) {
@@ -687,12 +686,9 @@ void CompilerDriver::LoadImageClasses(base::TimingLogger& timings)
     unresolved_exception_types.clear();
     class_linker->VisitClasses(ResolveCatchBlockExceptionsClassVisitor,
                                &unresolved_exception_types);
-    typedef std::set<std::pair<uint16_t, const DexFile*> >::const_iterator It;  // TODO: C++0x auto
-    for (It it = unresolved_exception_types.begin(),
-         end = unresolved_exception_types.end();
-         it != end; ++it) {
-      uint16_t exception_type_idx = it->first;
-      const DexFile* dex_file = it->second;
+    for (const std::pair<uint16_t, const DexFile*>& exception_type : unresolved_exception_types) {
+      uint16_t exception_type_idx = exception_type.first;
+      const DexFile* dex_file = exception_type.second;
       mirror::DexCache* dex_cache = class_linker->FindDexCache(*dex_file);
       mirror:: ClassLoader* class_loader = NULL;
       SirtRef<mirror::Class> klass(self, class_linker->ResolveType(*dex_file, exception_type_idx,
diff --git a/compiler/elf_fixup.cc b/compiler/elf_fixup.cc
index 6c090fdbec..359c4936a6 100644
--- a/compiler/elf_fixup.cc
+++ b/compiler/elf_fixup.cc
@@ -80,7 +80,6 @@ bool ElfFixup::Fixup(File* file, uintptr_t oat_data_begin) {
 #define DT_MIPS_RLD_MAP      0x70000016  // d_ptr
 
 bool ElfFixup::FixupDynamic(ElfFile& elf_file, uintptr_t base_address) {
-  // TODO: C++0x auto.
   for (::llvm::ELF::Elf32_Word i = 0; i < elf_file.GetDynamicNum(); i++) {
     ::llvm::ELF::Elf32_Dyn& elf_dyn = elf_file.GetDynamic(i);
     ::llvm::ELF::Elf32_Word d_tag = elf_dyn.d_tag;
diff --git a/compiler/image_writer.cc b/compiler/image_writer.cc
index 4e9ae54d8e..548ea9eee4 100644
--- a/compiler/image_writer.cc
+++ b/compiler/image_writer.cc
@@ -74,10 +74,7 @@ bool ImageWriter::Write(const std::string& image_filename,
 
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   const std::vector<DexCache*>& all_dex_caches = class_linker->GetDexCaches();
-  for (size_t i = 0; i < all_dex_caches.size(); i++) {
-    DexCache* dex_cache = all_dex_caches[i];
-    dex_caches_.insert(dex_cache);
-  }
+  dex_caches_.insert(all_dex_caches.begin(), all_dex_caches.end());
 
   UniquePtr<File> oat_file(OS::OpenFileReadWrite(oat_filename.c_str()));
   if (oat_file.get() == NULL) {
@@ -117,11 +114,7 @@ bool ImageWriter::Write(const std::string& image_filename,
   gc::Heap* heap = Runtime::Current()->GetHeap();
   heap->CollectGarbage(false);  // Remove garbage.
   // Trim size of alloc spaces.
-  const std::vector<gc::space::ContinuousSpace*>& spaces = heap->GetContinuousSpaces();
-  // TODO: C++0x auto
-  typedef std::vector<gc::space::ContinuousSpace*>::const_iterator It;
-  for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-    gc::space::ContinuousSpace* space = *it;
+  for (const auto& space : heap->GetContinuousSpaces()) {
     if (space->IsDlMallocSpace()) {
       space->AsDlMallocSpace()->Trim();
     }
@@ -163,13 +156,8 @@ bool ImageWriter::Write(const std::string& image_filename,
 }
 
 bool ImageWriter::AllocMemory() {
-  gc::Heap* heap = Runtime::Current()->GetHeap();
-  const std::vector<gc::space::ContinuousSpace*>& spaces = heap->GetContinuousSpaces();
   size_t size = 0;
-  // TODO: C++0x auto
-  typedef std::vector<gc::space::ContinuousSpace*>::const_iterator It;
-  for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-    gc::space::ContinuousSpace* space = *it;
+  for (const auto& space : Runtime::Current()->GetHeap()->GetContinuousSpaces()) {
     if (space->IsDlMallocSpace()) {
       size += space->Size();
     }
@@ -203,9 +191,7 @@ void ImageWriter::ComputeEagerResolvedStringsCallback(Object* obj, void* arg) {
   String* string = obj->AsString();
   const uint16_t* utf16_string = string->GetCharArray()->GetData() + string->GetOffset();
   ImageWriter* writer = reinterpret_cast<ImageWriter*>(arg);
-  typedef Set::const_iterator CacheIt;  // TODO: C++0x auto
-  for (CacheIt it = writer->dex_caches_.begin(), end = writer->dex_caches_.end(); it != end; ++it) {
-    DexCache* dex_cache = *it;
+  for (DexCache* dex_cache : writer->dex_caches_) {
     const DexFile& dex_file = *dex_cache->GetDexFile();
     const DexFile::StringId* string_id = dex_file.FindStringId(utf16_string);
     if (string_id != NULL) {
@@ -251,16 +237,13 @@ void ImageWriter::PruneNonImageClasses() {
   class_linker->VisitClasses(NonImageClassesVisitor, &context);
 
   // Remove the undesired classes from the class roots.
-  typedef std::set<std::string>::const_iterator ClassIt;  // TODO: C++0x auto
-  for (ClassIt it = non_image_classes.begin(), end = non_image_classes.end(); it != end; ++it) {
-    class_linker->RemoveClass((*it).c_str(), NULL);
+  for (const std::string& it : non_image_classes) {
+    class_linker->RemoveClass(it.c_str(), NULL);
   }
 
   // Clear references to removed classes from the DexCaches.
   ArtMethod* resolution_method = runtime->GetResolutionMethod();
-  typedef Set::const_iterator CacheIt;  // TODO: C++0x auto
-  for (CacheIt it = dex_caches_.begin(), end = dex_caches_.end(); it != end; ++it) {
-    DexCache* dex_cache = *it;
+  for (DexCache* dex_cache : dex_caches_) {
     for (size_t i = 0; i < dex_cache->NumResolvedTypes(); i++) {
       Class* klass = dex_cache->GetResolvedType(i);
       if (klass != NULL && !IsImageClass(klass)) {
@@ -324,9 +307,8 @@ void ImageWriter::CheckNonImageClassesRemovedCallback(Object* obj, void* arg) {
 void ImageWriter::DumpImageClasses() {
   CompilerDriver::DescriptorSet* image_classes = compiler_driver_.GetImageClasses();
   CHECK(image_classes != NULL);
-  typedef std::set<std::string>::const_iterator It;  // TODO: C++0x auto
-  for (It it = image_classes->begin(), end = image_classes->end(); it != end; ++it) {
-    LOG(INFO) << " " << *it;
+  for (const std::string& image_class : *image_classes) {
+    LOG(INFO) << " " << image_class;
   }
 }
 
@@ -368,9 +350,8 @@ ObjectArray<Object>* ImageWriter::CreateImageRoots() const {
   ObjectArray<Object>* dex_caches = ObjectArray<Object>::Alloc(self, object_array_class,
                                                                dex_caches_.size());
   int i = 0;
-  typedef Set::const_iterator It;  // TODO: C++0x auto
-  for (It it = dex_caches_.begin(), end = dex_caches_.end(); it != end; ++it, ++i) {
-    dex_caches->Set(i, *it);
+  for (DexCache* dex_cache : dex_caches_) {
+    dex_caches->Set(i++, dex_cache);
   }
 
   // build an Object[] of the roots needed to restore the runtime
@@ -403,7 +384,7 @@ void ImageWriter::CalculateNewObjectOffsets(size_t oat_loaded_size, size_t oat_d
   SirtRef<ObjectArray<Object> > image_roots(self, CreateImageRoots());
 
   gc::Heap* heap = Runtime::Current()->GetHeap();
-  const std::vector<gc::space::ContinuousSpace*>& spaces = heap->GetContinuousSpaces();
+  const auto& spaces = heap->GetContinuousSpaces();
   DCHECK(!spaces.empty());
   DCHECK_EQ(0U, image_end_);
 
@@ -418,10 +399,7 @@ void ImageWriter::CalculateNewObjectOffsets(size_t oat_loaded_size, size_t oat_d
     // TODO: Add InOrderWalk to heap bitmap.
     const char* old = self->StartAssertNoThreadSuspension("ImageWriter");
     DCHECK(heap->GetLargeObjectsSpace()->GetLiveObjects()->IsEmpty());
-    // TODO: C++0x auto
-    typedef std::vector<gc::space::ContinuousSpace*>::const_iterator It;
-    for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-      gc::space::ContinuousSpace* space = *it;
+    for (const auto& space : spaces) {
       space->GetLiveBitmap()->InOrderWalk(CalculateNewObjectOffsetsCallback, this);
       DCHECK_LT(image_end_, image_->Size());
     }
diff --git a/compiler/image_writer.h b/compiler/image_writer.h
index 750109d1d9..6a126b84ab 100644
--- a/compiler/image_writer.h
+++ b/compiler/image_writer.h
@@ -204,8 +204,7 @@ class ImageWriter {
   uint32_t quick_to_interpreter_bridge_offset_;
 
   // DexCaches seen while scanning for fixing up CodeAndDirectMethods
-  typedef std::set<mirror::DexCache*> Set;
-  Set dex_caches_;
+  std::set<mirror::DexCache*> dex_caches_;
 };
 
 }  // namespace art
diff --git a/compiler/sea_ir/ir/regions_test.cc b/compiler/sea_ir/ir/regions_test.cc
index 9813465db8..8ca51e4851 100644
--- a/compiler/sea_ir/ir/regions_test.cc
+++ b/compiler/sea_ir/ir/regions_test.cc
@@ -56,4 +56,4 @@ TEST_F(RegionsTest, Basics) {
   EXPECT_EQ(root, preds->at(0));
 }
 
-}  // namespace art
+}  // namespace sea_ir
diff --git a/compiler/sea_ir/types/type_data_test.cc b/compiler/sea_ir/types/type_data_test.cc
index a66ebce38f..f7a5362fa4 100644
--- a/compiler/sea_ir/types/type_data_test.cc
+++ b/compiler/sea_ir/types/type_data_test.cc
@@ -38,4 +38,4 @@ TEST_F(TypeDataTest, Basics) {
   EXPECT_TRUE(byte_type == td.FindTypeOf(second_instruction_id));
 }
 
-}  // namespace art
+}  // namespace sea_ir
diff --git a/compiler/sea_ir/types/type_inference_visitor.cc b/compiler/sea_ir/types/type_inference_visitor.cc
index 3da2fc1e2c..81a8f4d615 100644
--- a/compiler/sea_ir/types/type_inference_visitor.cc
+++ b/compiler/sea_ir/types/type_inference_visitor.cc
@@ -78,9 +78,9 @@ std::vector<const Type*> TypeInferenceVisitor::GetOperandTypes(
 
 const Type* TypeInferenceVisitor::MergeTypes(std::vector<const Type*>& types) const {
   const Type* type = NULL;
-  if (types.size()>0) {
+  if (types.size() > 0) {
     type = *(types.begin());
-    if (types.size()>1) {
+    if (types.size() > 1) {
       for (std::vector<const Type*>::const_iterator cit = types.begin();
           cit != types.end(); cit++) {
         if (!type->Equals(**cit)) {
diff --git a/compiler/sea_ir/types/type_inference_visitor.h b/compiler/sea_ir/types/type_inference_visitor.h
index 200b9f0253..4bdac38404 100644
--- a/compiler/sea_ir/types/type_inference_visitor.h
+++ b/compiler/sea_ir/types/type_inference_visitor.h
@@ -61,7 +61,7 @@ class TypeInferenceVisitor: public IRVisitor {
   std::vector<const Type*> GetOperandTypes(InstructionNode* instruction) const;
   const Type* GetType() {
     // TODO: Currently multiple defined types are not supported.
-    if (crt_type_.size()>0) {
+    if (!crt_type_.empty()) {
       const Type* single_type = crt_type_.at(0);
       crt_type_.clear();
       return single_type;
diff --git a/compiler/sea_ir/types/type_inference_visitor_test.cc b/compiler/sea_ir/types/type_inference_visitor_test.cc
index 8a249ebceb..77acb3d277 100644
--- a/compiler/sea_ir/types/type_inference_visitor_test.cc
+++ b/compiler/sea_ir/types/type_inference_visitor_test.cc
@@ -130,4 +130,4 @@ TEST_F(TypeInferenceVisitorTest, GetOperandTypes) {
 }
 
 
-}  // namespace art
+}  // namespace sea_ir
diff --git a/compiler/utils/assembler.h b/compiler/utils/assembler.h
index 9d79002625..c9be4edbf8 100644
--- a/compiler/utils/assembler.h
+++ b/compiler/utils/assembler.h
@@ -137,6 +137,7 @@ class SlowPath {
   // Next in linked list of slow paths
   SlowPath *next_;
 
+ private:
   friend class AssemblerBuffer;
   DISALLOW_COPY_AND_ASSIGN(SlowPath);
 };
diff --git a/oatdump/oatdump.cc b/oatdump/oatdump.cc
index fbfdfd9e8d..8bc787745b 100644
--- a/oatdump/oatdump.cc
+++ b/oatdump/oatdump.cc
@@ -736,13 +736,10 @@ class ImageDumper {
 
     oat_dumper_.reset(new OatDumper(host_prefix_, *oat_file));
 
-    std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file->GetOatDexFiles();
-    for (size_t i = 0; i < oat_dex_files.size(); i++) {
-      const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
+    for (const OatFile::OatDexFile* oat_dex_file : oat_file->GetOatDexFiles()) {
       CHECK(oat_dex_file != NULL);
-      std::pair<std::string, size_t> entry(oat_dex_file->GetDexFileLocation(),
-                                           oat_dex_file->FileSize());
-      stats_.oat_dex_file_sizes.push_back(entry);
+      stats_.oat_dex_file_sizes.push_back(std::make_pair(oat_dex_file->GetDexFileLocation(),
+                                                         oat_dex_file->FileSize()));
     }
 
     os << "OBJECTS:\n" << std::flush;
@@ -761,10 +758,7 @@ class ImageDumper {
       std::ostream indent_os(&indent_filter);
       os_ = &indent_os;
       ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
-      // TODO: C++0x auto
-      typedef std::vector<gc::space::ContinuousSpace*>::const_iterator It;
-      for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-        gc::space::Space* space = *it;
+      for (const auto& space : spaces) {
         if (space->IsImageSpace()) {
           gc::space::ImageSpace* image_space = space->AsImageSpace();
           image_space->GetLiveBitmap()->Walk(ImageDumper::Callback, this);
@@ -1263,16 +1257,16 @@ class ImageDumper {
 
       os << "object_bytes breakdown:\n";
       size_t object_bytes_total = 0;
-      typedef SizeAndCountTable::const_iterator It;  // TODO: C++0x auto
-      for (It it = sizes_and_counts.begin(), end = sizes_and_counts.end(); it != end; ++it) {
-        const std::string& descriptor(it->first);
-        double average = static_cast<double>(it->second.bytes) / static_cast<double>(it->second.count);
-        double percent = PercentOfObjectBytes(it->second.bytes);
+      for (const auto& sizes_and_count : sizes_and_counts) {
+        const std::string& descriptor(sizes_and_count.first);
+        double average = static_cast<double>(sizes_and_count.second.bytes) /
+            static_cast<double>(sizes_and_count.second.count);
+        double percent = PercentOfObjectBytes(sizes_and_count.second.bytes);
         os << StringPrintf("%32s %8zd bytes %6zd instances "
                            "(%4.0f bytes/instance) %2.0f%% of object_bytes\n",
-                           descriptor.c_str(), it->second.bytes, it->second.count,
-                           average, percent);
-        object_bytes_total += it->second.bytes;
+                           descriptor.c_str(), sizes_and_count.second.bytes,
+                           sizes_and_count.second.count, average, percent);
+        object_bytes_total += sizes_and_count.second.bytes;
       }
       os << "\n" << std::flush;
       CHECK_EQ(object_bytes, object_bytes_total);
@@ -1292,11 +1286,10 @@ class ImageDumper {
                          large_initializer_code_bytes, PercentOfOatBytes(large_initializer_code_bytes),
                          large_method_code_bytes, PercentOfOatBytes(large_method_code_bytes))
             << "DexFile sizes:\n";
-      typedef std::vector<std::pair<std::string, size_t> >::const_iterator It2;
-      for (It2 it = oat_dex_file_sizes.begin(); it != oat_dex_file_sizes.end();
-          ++it) {
+      for (const std::pair<std::string, size_t>& oat_dex_file_size : oat_dex_file_sizes) {
         os << StringPrintf("%s = %zd (%2.0f%% of oat file bytes)\n",
-                           it->first.c_str(), it->second, PercentOfOatBytes(it->second));
+                           oat_dex_file_size.first.c_str(), oat_dex_file_size.second,
+                           PercentOfOatBytes(oat_dex_file_size.second));
       }
 
       os << "\n" << StringPrintf("gc_map_bytes           = %7zd (%2.0f%% of oat file bytes)\n"
diff --git a/runtime/base/histogram.h b/runtime/base/histogram.h
index f508af993e..2a02cf4245 100644
--- a/runtime/base/histogram.h
+++ b/runtime/base/histogram.h
@@ -112,6 +112,6 @@ template <class Value> class Histogram {
 
   DISALLOW_COPY_AND_ASSIGN(Histogram);
 };
-}
+}  // namespace art
 
 #endif  // ART_RUNTIME_BASE_HISTOGRAM_H_
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 039e7bc0a7..ef27321f0e 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -1111,16 +1111,15 @@ void ClassLinker::VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty)
   Thread* self = Thread::Current();
   {
     ReaderMutexLock mu(self, dex_lock_);
-    for (size_t i = 0; i < dex_caches_.size(); i++) {
-      visitor(dex_caches_[i], arg);
+    for (mirror::DexCache* dex_cache : dex_caches_) {
+      visitor(dex_cache, arg);
     }
   }
 
   {
     ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
-    typedef Table::const_iterator It;  // TODO: C++0x auto
-    for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
-      visitor(it->second, arg);
+    for (const std::pair<size_t, mirror::Class*>& it : classes_) {
+      visitor(it.second, arg);
     }
 
     // We deliberately ignore the class roots in the image since we
@@ -1135,14 +1134,13 @@ void ClassLinker::VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty)
 
 void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) const {
   ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
-  typedef Table::const_iterator It;  // TODO: C++0x auto
-  for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
-    if (!visitor(it->second, arg)) {
+  for (const std::pair<size_t, mirror::Class*>& it : classes_) {
+    if (!visitor(it.second, arg)) {
       return;
     }
   }
-  for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
-    if (!visitor(it->second, arg)) {
+  for (const std::pair<size_t, mirror::Class*>& it : image_classes_) {
+    if (!visitor(it.second, arg)) {
       return;
     }
   }
@@ -1157,9 +1155,8 @@ static bool GetClassesVisitor(mirror::Class* c, void* arg) {
 void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const {
   std::set<mirror::Class*> classes;
   VisitClasses(GetClassesVisitor, &classes);
-  typedef std::set<mirror::Class*>::const_iterator It;  // TODO: C++0x auto
-  for (It it = classes.begin(), end = classes.end(); it != end; ++it) {
-    if (!visitor(*it, arg)) {
+  for (mirror::Class* klass : classes) {
+    if (!visitor(klass, arg)) {
       return;
     }
   }
@@ -2160,10 +2157,9 @@ mirror::Class* ClassLinker::InsertClass(const StringPiece& descriptor, mirror::C
 bool ClassLinker::RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader) {
   size_t hash = Hash(descriptor);
   WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
-  typedef Table::iterator It;  // TODO: C++0x auto
   // TODO: determine if its better to search classes_ or image_classes_ first
   ClassHelper kh;
-  for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash;
+  for (auto it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash;
        ++it) {
     mirror::Class* klass = it->second;
     kh.ChangeClass(klass);
@@ -2172,7 +2168,7 @@ bool ClassLinker::RemoveClass(const char* descriptor, const mirror::ClassLoader*
       return true;
     }
   }
-  for (It it = image_classes_.lower_bound(hash), end = classes_.end();
+  for (auto it = image_classes_.lower_bound(hash), end = classes_.end();
       it != end && it->first == hash; ++it) {
     mirror::Class* klass = it->second;
     kh.ChangeClass(klass);
@@ -2204,8 +2200,9 @@ mirror::Class* ClassLinker::LookupClassLocked(const char* descriptor,
                                               const mirror::ClassLoader* class_loader,
                                               size_t hash, const Table& classes) {
   ClassHelper kh(NULL, this);
-  typedef Table::const_iterator It;  // TODO: C++0x auto
-  for (It it = classes.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
+  auto end = classes_.end();
+  for (auto it = classes.lower_bound(hash); it != end && it->first == hash;
+      ++it) {
     mirror::Class* klass = it->second;
     kh.ChangeClass(klass);
     if (strcmp(descriptor, kh.GetDescriptor()) == 0 && klass->GetClassLoader() == class_loader) {
@@ -2228,17 +2225,18 @@ void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Clas
   classes.clear();
   size_t hash = Hash(descriptor);
   ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
-  typedef Table::const_iterator It;  // TODO: C++0x auto
   // TODO: determine if its better to search classes_ or image_classes_ first
   ClassHelper kh(NULL, this);
-  for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
+  for (auto it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash;
+      ++it) {
     mirror::Class* klass = it->second;
     kh.ChangeClass(klass);
     if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
       classes.push_back(klass);
     }
   }
-  for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
+  for (auto it = image_classes_.lower_bound(hash), end = classes_.end();
+      it != end && it->first == hash; ++it) {
     mirror::Class* klass = it->second;
     kh.ChangeClass(klass);
     if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
@@ -3967,12 +3965,11 @@ void ClassLinker::DumpAllClasses(int flags) const {
   std::vector<mirror::Class*> all_classes;
   {
     ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
-    typedef Table::const_iterator It;  // TODO: C++0x auto
-    for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
-      all_classes.push_back(it->second);
+    for (const std::pair<size_t, mirror::Class*>& it : classes_) {
+      all_classes.push_back(it.second);
     }
-    for (It it = image_classes_.begin(), end = image_classes_.end(); it != end; ++it) {
-      all_classes.push_back(it->second);
+    for (const std::pair<size_t, mirror::Class*>& it : image_classes_) {
+      all_classes.push_back(it.second);
     }
   }
 
diff --git a/runtime/debugger.cc b/runtime/debugger.cc
index 569a370b3f..a72ae22d71 100644
--- a/runtime/debugger.cc
+++ b/runtime/debugger.cc
@@ -3033,9 +3033,8 @@ void Dbg::DdmSetThreadNotification(bool enable) {
     }
     {
       ScopedObjectAccess soa(self);
-      typedef std::list<Thread*>::const_iterator It;  // TODO: C++0x auto
-      for (It it = threads.begin(), end = threads.end(); it != end; ++it) {
-        Dbg::DdmSendThreadNotification(*it, CHUNK_TYPE("THCR"));
+      for (Thread* thread : threads) {
+        Dbg::DdmSendThreadNotification(thread, CHUNK_TYPE("THCR"));
       }
     }
     ResumeVM();
@@ -3600,8 +3599,7 @@ class StringTable {
   }
 
   size_t IndexOf(const char* s) const {
-    typedef std::set<std::string>::const_iterator It;  // TODO: C++0x auto
-    It it = table_.find(s);
+    auto it = table_.find(s);
     if (it == table_.end()) {
       LOG(FATAL) << "IndexOf(\"" << s << "\") failed";
     }
@@ -3613,9 +3611,8 @@ class StringTable {
   }
 
   void WriteTo(std::vector<uint8_t>& bytes) const {
-    typedef std::set<std::string>::const_iterator It;  // TODO: C++0x auto
-    for (It it = table_.begin(); it != table_.end(); ++it) {
-      const char* s = (*it).c_str();
+    for (const std::string& str : table_) {
+      const char* s = str.c_str();
       size_t s_len = CountModifiedUtf8Chars(s);
       UniquePtr<uint16_t> s_utf16(new uint16_t[s_len]);
       ConvertModifiedUtf8ToUtf16(s_utf16.get(), s);
diff --git a/runtime/dex_file_verifier.cc b/runtime/dex_file_verifier.cc
index 09e929c2d0..5b076e07b7 100644
--- a/runtime/dex_file_verifier.cc
+++ b/runtime/dex_file_verifier.cc
@@ -1299,8 +1299,7 @@ bool DexFileVerifier::CheckIntraSection() {
 }
 
 bool DexFileVerifier::CheckOffsetToTypeMap(uint32_t offset, uint16_t type) {
-  typedef SafeMap<uint32_t, uint16_t>::iterator It;  // TODO: C++0x auto
-  It it = offset_to_type_map_.find(offset);
+  auto it = offset_to_type_map_.find(offset);
   if (it == offset_to_type_map_.end()) {
     LOG(ERROR) << StringPrintf("No data map entry found @ %x; expected %x", offset, type);
     return false;
diff --git a/runtime/gc/accounting/gc_allocator.cc b/runtime/gc/accounting/gc_allocator.cc
index 0b0d3edc1d..11d0e679b1 100644
--- a/runtime/gc/accounting/gc_allocator.cc
+++ b/runtime/gc/accounting/gc_allocator.cc
@@ -31,6 +31,6 @@ namespace accounting {
     Runtime::Current()->GetHeap()->RegisterGCDeAllocation(bytes);
     free(p);
   }
-}
-}
-}
+}  // namespace accounting
+}  // namespace gc
+}  // namespace art
diff --git a/runtime/gc/accounting/gc_allocator.h b/runtime/gc/accounting/gc_allocator.h
index d1356a745c..1fba858882 100644
--- a/runtime/gc/accounting/gc_allocator.h
+++ b/runtime/gc/accounting/gc_allocator.h
@@ -75,8 +75,8 @@ namespace accounting {
                                           GCAllocatorImpl<T>,
                                           std::allocator<T> >::value {
   };
-}
-}
-}
+}  // namespace accounting
+}  // namespace gc
+}  // namespace art
 
 #endif  // ART_RUNTIME_GC_ACCOUNTING_GC_ALLOCATOR_H_
diff --git a/runtime/gc/accounting/heap_bitmap-inl.h b/runtime/gc/accounting/heap_bitmap-inl.h
index 0524ccb69c..18b93d43d6 100644
--- a/runtime/gc/accounting/heap_bitmap-inl.h
+++ b/runtime/gc/accounting/heap_bitmap-inl.h
@@ -25,20 +25,12 @@ namespace accounting {
 
 template <typename Visitor>
 inline void HeapBitmap::Visit(const Visitor& visitor) {
-  // TODO: C++0x auto
-  typedef SpaceBitmapVector::iterator It;
-  for (It it = continuous_space_bitmaps_.begin(), end = continuous_space_bitmaps_.end();
-      it != end; ++it) {
-    SpaceBitmap* bitmap = *it;
+  for (const auto& bitmap : continuous_space_bitmaps_) {
     bitmap->VisitMarkedRange(bitmap->HeapBegin(), bitmap->HeapLimit(), visitor);
   }
-  // TODO: C++0x auto
-  typedef SpaceSetMapVector::iterator It2;
-  DCHECK(discontinuous_space_sets_.begin() !=  discontinuous_space_sets_.end());
-  for (It2 it = discontinuous_space_sets_.begin(), end = discontinuous_space_sets_.end();
-      it != end; ++it) {
-    SpaceSetMap* set = *it;
-    set->Visit(visitor);
+  DCHECK(!discontinuous_space_sets_.empty());
+  for (const auto& space_set : discontinuous_space_sets_) {
+    space_set->Visit(visitor);
   }
 }
 
diff --git a/runtime/gc/accounting/heap_bitmap.cc b/runtime/gc/accounting/heap_bitmap.cc
index 046290513d..55894616b9 100644
--- a/runtime/gc/accounting/heap_bitmap.cc
+++ b/runtime/gc/accounting/heap_bitmap.cc
@@ -23,12 +23,9 @@ namespace gc {
 namespace accounting {
 
 void HeapBitmap::ReplaceBitmap(SpaceBitmap* old_bitmap, SpaceBitmap* new_bitmap) {
-  // TODO: C++0x auto
-  typedef SpaceBitmapVector::iterator It;
-  for (It it = continuous_space_bitmaps_.begin(), end = continuous_space_bitmaps_.end();
-      it != end; ++it) {
-    if (*it == old_bitmap) {
-      *it = new_bitmap;
+  for (auto& bitmap : continuous_space_bitmaps_) {
+    if (bitmap == old_bitmap) {
+      bitmap = new_bitmap;
       return;
     }
   }
@@ -36,12 +33,9 @@ void HeapBitmap::ReplaceBitmap(SpaceBitmap* old_bitmap, SpaceBitmap* new_bitmap)
 }
 
 void HeapBitmap::ReplaceObjectSet(SpaceSetMap* old_set, SpaceSetMap* new_set) {
-  // TODO: C++0x auto
-  typedef SpaceSetMapVector::iterator It;
-  for (It it = discontinuous_space_sets_.begin(), end = discontinuous_space_sets_.end();
-      it != end; ++it) {
-    if (*it == old_set) {
-      *it = new_set;
+  for (auto& space_set : discontinuous_space_sets_) {
+    if (space_set == old_set) {
+      space_set = new_set;
       return;
     }
   }
@@ -52,13 +46,10 @@ void HeapBitmap::AddContinuousSpaceBitmap(accounting::SpaceBitmap* bitmap) {
   DCHECK(bitmap != NULL);
 
   // Check for interval overlap.
-  typedef SpaceBitmapVector::iterator It;
-  for (It it = continuous_space_bitmaps_.begin(), end = continuous_space_bitmaps_.end();
-      it != end; ++it) {
-    SpaceBitmap* bitmap = *it;
-    SpaceBitmap* cur_bitmap = *it;
-    CHECK(bitmap->HeapBegin() < cur_bitmap->HeapLimit() &&
-          bitmap->HeapLimit() > cur_bitmap->HeapBegin())
+  for (const auto& cur_bitmap : continuous_space_bitmaps_) {
+    CHECK(!(
+        bitmap->HeapBegin() < cur_bitmap->HeapLimit() &&
+        bitmap->HeapLimit() > cur_bitmap->HeapBegin()))
         << "Bitmap " << bitmap->Dump() << " overlaps with existing bitmap " << cur_bitmap->Dump();
   }
   continuous_space_bitmaps_.push_back(bitmap);
@@ -70,20 +61,13 @@ void HeapBitmap::AddDiscontinuousObjectSet(SpaceSetMap* set) {
 }
 
 void HeapBitmap::Walk(SpaceBitmap::Callback* callback, void* arg) {
-  // TODO: C++0x auto
-  typedef SpaceBitmapVector::iterator It;
-  for (It it = continuous_space_bitmaps_.begin(), end = continuous_space_bitmaps_.end();
-      it != end; ++it) {
-    SpaceBitmap* bitmap = *it;
+  for (const auto& bitmap : continuous_space_bitmaps_) {
     bitmap->Walk(callback, arg);
   }
-  // TODO: C++0x auto
-  typedef SpaceSetMapVector::iterator It2;
-  DCHECK(discontinuous_space_sets_.begin() !=  discontinuous_space_sets_.end());
-  for (It2 it = discontinuous_space_sets_.begin(), end = discontinuous_space_sets_.end();
-      it != end; ++it) {
-    SpaceSetMap* set = *it;
-    set->Walk(callback, arg);
+
+  DCHECK(!discontinuous_space_sets_.empty());
+  for (const auto& space_set : discontinuous_space_sets_) {
+    space_set->Walk(callback, arg);
   }
 }
 
diff --git a/runtime/gc/accounting/heap_bitmap.h b/runtime/gc/accounting/heap_bitmap.h
index ada976fff6..2ca8c4a82e 100644
--- a/runtime/gc/accounting/heap_bitmap.h
+++ b/runtime/gc/accounting/heap_bitmap.h
@@ -66,11 +66,7 @@ class HeapBitmap {
   }
 
   SpaceBitmap* GetContinuousSpaceBitmap(const mirror::Object* obj) {
-    // TODO: C++0x auto
-    typedef SpaceBitmapVector::iterator It;
-    for (It it = continuous_space_bitmaps_.begin(), end = continuous_space_bitmaps_.end();
-        it != end; ++it) {
-      SpaceBitmap* bitmap = *it;
+    for (const auto& bitmap : continuous_space_bitmaps_) {
       if (bitmap->HasAddress(obj)) {
         return bitmap;
       }
@@ -79,13 +75,9 @@ class HeapBitmap {
   }
 
   SpaceSetMap* GetDiscontinuousSpaceObjectSet(const mirror::Object* obj) {
-    // TODO: C++0x auto
-    typedef SpaceSetMapVector::iterator It;
-    for (It it = discontinuous_space_sets_.begin(), end = discontinuous_space_sets_.end();
-        it != end; ++it) {
-      SpaceSetMap* set = *it;
-      if (set->Test(obj)) {
-        return set;
+    for (const auto& space_set : discontinuous_space_sets_) {
+      if (space_set->Test(obj)) {
+        return space_set;
       }
     }
     return NULL;
diff --git a/runtime/gc/accounting/mod_union_table.cc b/runtime/gc/accounting/mod_union_table.cc
index 3bbc3810a0..486521951a 100644
--- a/runtime/gc/accounting/mod_union_table.cc
+++ b/runtime/gc/accounting/mod_union_table.cc
@@ -36,54 +36,6 @@ namespace art {
 namespace gc {
 namespace accounting {
 
-class MarkIfReachesAllocspaceVisitor {
- public:
-  explicit MarkIfReachesAllocspaceVisitor(Heap* const heap, accounting::SpaceBitmap* bitmap)
-    : heap_(heap),
-      bitmap_(bitmap) {
-  }
-
-  // Extra parameters are required since we use this same visitor signature for checking objects.
-  void operator()(const Object* obj, const Object* ref, const MemberOffset& /* offset */,
-                  bool /* is_static */) const {
-    // TODO: Optimize?
-    // TODO: C++0x auto
-    const std::vector<space::ContinuousSpace*>& spaces = heap_->GetContinuousSpaces();
-    typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-    for (It cur = spaces.begin(); cur != spaces.end(); ++cur) {
-      if ((*cur)->IsDlMallocSpace() && (*cur)->Contains(ref)) {
-        bitmap_->Set(obj);
-        break;
-      }
-    }
-  }
-
- private:
-  Heap* const heap_;
-  accounting::SpaceBitmap* const bitmap_;
-};
-
-class ModUnionVisitor {
- public:
-  explicit ModUnionVisitor(Heap* const heap, accounting::SpaceBitmap* bitmap)
-    : heap_(heap),
-      bitmap_(bitmap) {
-  }
-
-  void operator()(const Object* obj) const
-      SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_,
-                            Locks::mutator_lock_) {
-    DCHECK(obj != NULL);
-    // We don't have an early exit since we use the visitor pattern, an early exit should
-    // significantly speed this up.
-    MarkIfReachesAllocspaceVisitor visitor(heap_, bitmap_);
-    collector::MarkSweep::VisitObjectReferences(obj, visitor);
-  }
- private:
-  Heap* const heap_;
-  accounting::SpaceBitmap* const bitmap_;
-};
-
 class ModUnionClearCardSetVisitor {
  public:
   explicit ModUnionClearCardSetVisitor(ModUnionTable::CardSet* const cleared_cards)
@@ -237,29 +189,23 @@ class ModUnionCheckReferences {
 void ModUnionTableReferenceCache::Verify() {
   // Start by checking that everything in the mod union table is marked.
   Heap* heap = GetHeap();
-  typedef SafeMap<const byte*, std::vector<const Object*> >::const_iterator It;
-  typedef std::vector<const Object*>::const_iterator It2;
-  for (It it = references_.begin(), end = references_.end(); it != end; ++it) {
-    for (It2 it_ref = it->second.begin(), end_ref = it->second.end(); it_ref != end_ref;
-        ++it_ref ) {
-      CHECK(heap->IsLiveObjectLocked(*it_ref));
+  for (const std::pair<const byte*, std::vector<const Object*> >& it : references_) {
+    for (const Object* ref : it.second) {
+      CHECK(heap->IsLiveObjectLocked(ref));
     }
   }
 
   // Check the references of each clean card which is also in the mod union table.
   CardTable* card_table = heap->GetCardTable();
-  for (It it = references_.begin(); it != references_.end(); ++it) {
-    const byte* card = &*it->first;
+  for (const std::pair<const byte*, std::vector<const Object*> > & it : references_) {
+    const byte* card = it.first;
     if (*card == CardTable::kCardClean) {
-      std::set<const Object*> reference_set;
-      for (It2 itr = it->second.begin(); itr != it->second.end(); ++itr) {
-        reference_set.insert(*itr);
-      }
+      std::set<const Object*> reference_set(it.second.begin(), it.second.end());
       ModUnionCheckReferences visitor(this, reference_set);
       uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card));
       uintptr_t end = start + CardTable::kCardSize;
-      space::ContinuousSpace* space =
-          heap->FindContinuousSpaceFromObject(reinterpret_cast<Object*>(start), false);
+      auto* space = heap->FindContinuousSpaceFromObject(reinterpret_cast<Object*>(start), false);
+      DCHECK(space != nullptr);
       SpaceBitmap* live_bitmap = space->GetLiveBitmap();
       live_bitmap->VisitMarkedRange(start, end, visitor);
     }
@@ -268,24 +214,20 @@ void ModUnionTableReferenceCache::Verify() {
 
 void ModUnionTableReferenceCache::Dump(std::ostream& os) {
   CardTable* card_table = heap_->GetCardTable();
-  typedef std::set<byte*>::const_iterator It;
   os << "ModUnionTable cleared cards: [";
-  for (It it = cleared_cards_.begin(); it != cleared_cards_.end(); ++it) {
-    byte* card = *it;
-    uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card));
+  for (byte* card_addr : cleared_cards_) {
+    uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card_addr));
     uintptr_t end = start + CardTable::kCardSize;
     os << reinterpret_cast<void*>(start) << "-" << reinterpret_cast<void*>(end) << ",";
   }
   os << "]\nModUnionTable references: [";
-  typedef SafeMap<const byte*, std::vector<const Object*> >::const_iterator It2;
-  for (It2 it = references_.begin(); it != references_.end(); ++it) {
-    const byte* card = &*it->first;
-    uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card));
+  for (const std::pair<const byte*, std::vector<const Object*> >& it : references_) {
+    const byte* card_addr = it.first;
+    uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card_addr));
     uintptr_t end = start + CardTable::kCardSize;
     os << reinterpret_cast<void*>(start) << "-" << reinterpret_cast<void*>(end) << "->{";
-    typedef std::vector<const Object*>::const_iterator It3;
-    for (It3 itr = it->second.begin(); itr != it->second.end(); ++itr) {
-      os << reinterpret_cast<const void*>(*itr) << ",";
+    for (const mirror::Object* ref : it.second) {
+      os << reinterpret_cast<const void*>(ref) << ",";
     }
     os << "},";
   }
@@ -298,20 +240,18 @@ void ModUnionTableReferenceCache::Update() {
   std::vector<const Object*> cards_references;
   ModUnionReferenceVisitor visitor(this, &cards_references);
 
-  typedef std::set<byte*>::iterator It;
-  for (It it = cleared_cards_.begin(), cc_end = cleared_cards_.end(); it != cc_end; ++it) {
-    byte* card = *it;
+  for (const auto& card : cleared_cards_) {
     // Clear and re-compute alloc space references associated with this card.
     cards_references.clear();
     uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card));
     uintptr_t end = start + CardTable::kCardSize;
-    SpaceBitmap* live_bitmap =
-        heap->FindContinuousSpaceFromObject(reinterpret_cast<Object*>(start), false)->GetLiveBitmap();
+    auto* space = heap->FindContinuousSpaceFromObject(reinterpret_cast<Object*>(start), false);
+    DCHECK(space != nullptr);
+    SpaceBitmap* live_bitmap = space->GetLiveBitmap();
     live_bitmap->VisitMarkedRange(start, end, visitor);
 
     // Update the corresponding references for the card.
-    // TODO: C++0x auto
-    SafeMap<const byte*, std::vector<const Object*> >::iterator found = references_.find(card);
+    auto found = references_.find(card);
     if (found == references_.end()) {
       if (cards_references.empty()) {
         // No reason to add empty array.
@@ -326,14 +266,11 @@ void ModUnionTableReferenceCache::Update() {
 }
 
 void ModUnionTableReferenceCache::MarkReferences(collector::MarkSweep* mark_sweep) {
-  // TODO: C++0x auto
   size_t count = 0;
 
-  typedef SafeMap<const byte*, std::vector<const Object*> >::const_iterator It;
-  for (It it = references_.begin(); it != references_.end(); ++it) {
-    typedef std::vector<const Object*>::const_iterator It2;
-    for (It2 it_ref = it->second.begin(); it_ref != it->second.end(); ++it_ref) {
-      mark_sweep->MarkRoot(*it_ref);
+  for (const auto& ref : references_) {
+    for (const auto& obj : ref.second) {
+      mark_sweep->MarkRoot(obj);
       ++count;
     }
   }
@@ -353,38 +290,28 @@ void ModUnionTableCardCache::ClearCards(space::ContinuousSpace* space) {
 void ModUnionTableCardCache::MarkReferences(collector::MarkSweep* mark_sweep) {
   CardTable* card_table = heap_->GetCardTable();
   ModUnionScanImageRootVisitor visitor(mark_sweep);
-  typedef std::set<byte*>::const_iterator It;
-  It it = cleared_cards_.begin();
-  It cc_end = cleared_cards_.end();
-  if (it != cc_end) {
-    byte* card = *it;
-    uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card));
-    uintptr_t end = start + CardTable::kCardSize;
-    space::ContinuousSpace* cur_space =
-        heap_->FindContinuousSpaceFromObject(reinterpret_cast<Object*>(start), false);
-    accounting::SpaceBitmap* cur_live_bitmap = cur_space->GetLiveBitmap();
-    cur_live_bitmap->VisitMarkedRange(start, end, visitor);
-    for (++it; it != cc_end; ++it) {
-      card = *it;
-      start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card));
-      end = start + CardTable::kCardSize;
-      if (UNLIKELY(!cur_space->Contains(reinterpret_cast<Object*>(start)))) {
-        cur_space = heap_->FindContinuousSpaceFromObject(reinterpret_cast<Object*>(start), false);
-        cur_live_bitmap = cur_space->GetLiveBitmap();
-      }
-      cur_live_bitmap->VisitMarkedRange(start, end, visitor);
+  space::ContinuousSpace* space = nullptr;
+  SpaceBitmap* bitmap = nullptr;
+  for (const byte* card_addr : cleared_cards_) {
+    auto start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card_addr));
+    auto end = start + CardTable::kCardSize;
+    auto obj_start = reinterpret_cast<Object*>(start);
+    if (UNLIKELY(space == nullptr || !space->Contains(obj_start))) {
+      space = heap_->FindContinuousSpaceFromObject(obj_start, false);
+      DCHECK(space != nullptr);
+      bitmap = space->GetLiveBitmap();
+      DCHECK(bitmap != nullptr);
     }
+    bitmap->VisitMarkedRange(start, end, visitor);
   }
 }
 
 void ModUnionTableCardCache::Dump(std::ostream& os) {
   CardTable* card_table = heap_->GetCardTable();
-  typedef std::set<byte*>::const_iterator It;
   os << "ModUnionTable dirty cards: [";
-  for (It it = cleared_cards_.begin(); it != cleared_cards_.end(); ++it) {
-    byte* card = *it;
-    uintptr_t start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card));
-    uintptr_t end = start + CardTable::kCardSize;
+  for (const byte* card_addr : cleared_cards_) {
+    auto start = reinterpret_cast<uintptr_t>(card_table->AddrFromCard(card_addr));
+    auto end = start + CardTable::kCardSize;
     os << reinterpret_cast<void*>(start) << "-" << reinterpret_cast<void*>(end) << ",";
   }
   os << "]";
diff --git a/runtime/gc/collector/garbage_collector.cc b/runtime/gc/collector/garbage_collector.cc
index 378a971250..926013753d 100644
--- a/runtime/gc/collector/garbage_collector.cc
+++ b/runtime/gc/collector/garbage_collector.cc
@@ -114,11 +114,7 @@ void GarbageCollector::SwapBitmaps() {
   // these bitmaps. The bitmap swapping is an optimization so that we do not need to clear the live
   // bits of dead objects in the live bitmap.
   const GcType gc_type = GetGcType();
-  const std::vector<space::ContinuousSpace*>& cont_spaces = GetHeap()->GetContinuousSpaces();
-  // TODO: C++0x
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = cont_spaces.begin(), end = cont_spaces.end(); it != end; ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : GetHeap()->GetContinuousSpaces()) {
     // We never allocate into zygote spaces.
     if (space->GetGcRetentionPolicy() == space::kGcRetentionPolicyAlwaysCollect ||
         (gc_type == kGcTypeFull &&
@@ -132,11 +128,8 @@ void GarbageCollector::SwapBitmaps() {
       }
     }
   }
-  const std::vector<space::DiscontinuousSpace*>& disc_spaces = GetHeap()->GetDiscontinuousSpaces();
-  // TODO: C++0x
-  typedef std::vector<space::DiscontinuousSpace*>::const_iterator It2;
-  for (It2 it = disc_spaces.begin(), end = disc_spaces.end(); it != end; ++it) {
-    space::LargeObjectSpace* space = down_cast<space::LargeObjectSpace*>(*it);
+  for (const auto& disc_space : GetHeap()->GetDiscontinuousSpaces()) {
+    space::LargeObjectSpace* space = down_cast<space::LargeObjectSpace*>(disc_space);
     accounting::SpaceSetMap* live_set = space->GetLiveObjects();
     accounting::SpaceSetMap* mark_set = space->GetMarkObjects();
     heap_->GetLiveBitmap()->ReplaceObjectSet(live_set, mark_set);
diff --git a/runtime/gc/collector/mark_sweep.cc b/runtime/gc/collector/mark_sweep.cc
index 61570ae393..e93bcd1a05 100644
--- a/runtime/gc/collector/mark_sweep.cc
+++ b/runtime/gc/collector/mark_sweep.cc
@@ -84,16 +84,13 @@ void MarkSweep::ImmuneSpace(space::ContinuousSpace* space) {
     SetImmuneRange(reinterpret_cast<Object*>(space->Begin()),
                    reinterpret_cast<Object*>(space->End()));
   } else {
-    const std::vector<space::ContinuousSpace*>& spaces = GetHeap()->GetContinuousSpaces();
-    const space::ContinuousSpace* prev_space = NULL;
+    const space::ContinuousSpace* prev_space = nullptr;
     // Find out if the previous space is immune.
-    // TODO: C++0x
-    typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-    for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-      if (*it == space) {
+    for (space::ContinuousSpace* cur_space : GetHeap()->GetContinuousSpaces()) {
+      if (cur_space == space) {
         break;
       }
-      prev_space = *it;
+      prev_space = cur_space;
     }
 
     // If previous space was immune, then extend the immune region. Relies on continuous spaces
@@ -322,13 +319,9 @@ void MarkSweep::SetImmuneRange(Object* begin, Object* end) {
 
 void MarkSweep::FindDefaultMarkBitmap() {
   base::TimingLogger::ScopedSplit split("FindDefaultMarkBitmap", &timings_);
-  const std::vector<space::ContinuousSpace*>& spaces = GetHeap()->GetContinuousSpaces();
-  // TODO: C++0x
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : GetHeap()->GetContinuousSpaces()) {
     if (space->GetGcRetentionPolicy() == space::kGcRetentionPolicyAlwaysCollect) {
-      current_mark_bitmap_ = (*it)->GetMarkBitmap();
+      current_mark_bitmap_ = space->GetMarkBitmap();
       CHECK(current_mark_bitmap_ != NULL);
       return;
     }
@@ -344,11 +337,10 @@ void MarkSweep::ExpandMarkStack() {
     // Someone else acquired the lock and expanded the mark stack before us.
     return;
   }
-  std::vector<Object*> temp;
-  temp.insert(temp.begin(), mark_stack_->Begin(), mark_stack_->End());
+  std::vector<Object*> temp(mark_stack_->Begin(), mark_stack_->End());
   mark_stack_->Resize(mark_stack_->Capacity() * 2);
-  for (size_t i = 0; i < temp.size(); ++i) {
-    mark_stack_->PushBack(temp[i]);
+  for (const auto& obj : temp) {
+    mark_stack_->PushBack(obj);
   }
 }
 
@@ -608,12 +600,8 @@ class ScanObjectVisitor {
 
 void MarkSweep::ScanGrayObjects(byte minimum_age) {
   accounting::CardTable* card_table = GetHeap()->GetCardTable();
-  const std::vector<space::ContinuousSpace*>& spaces = GetHeap()->GetContinuousSpaces();
   ScanObjectVisitor visitor(this);
-  // TODO: C++0x
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = spaces.begin(), space_end = spaces.end(); it != space_end; ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : GetHeap()->GetContinuousSpaces()) {
     switch (space->GetGcRetentionPolicy()) {
       case space::kGcRetentionPolicyNeverCollect:
         timings_.StartSplit("ScanGrayImageSpaceObjects");
@@ -656,15 +644,12 @@ void MarkSweep::VerifyImageRoots() {
   // space
   timings_.StartSplit("VerifyImageRoots");
   CheckBitmapVisitor visitor(this);
-  const std::vector<space::ContinuousSpace*>& spaces = GetHeap()->GetContinuousSpaces();
-  // TODO: C++0x
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-    if ((*it)->IsImageSpace()) {
-      space::ImageSpace* space = (*it)->AsImageSpace();
-      uintptr_t begin = reinterpret_cast<uintptr_t>(space->Begin());
-      uintptr_t end = reinterpret_cast<uintptr_t>(space->End());
-      accounting::SpaceBitmap* live_bitmap = space->GetLiveBitmap();
+  for (const auto& space : GetHeap()->GetContinuousSpaces()) {
+    if (space->IsImageSpace()) {
+      space::ImageSpace* image_space = space->AsImageSpace();
+      uintptr_t begin = reinterpret_cast<uintptr_t>(image_space->Begin());
+      uintptr_t end = reinterpret_cast<uintptr_t>(image_space->End());
+      accounting::SpaceBitmap* live_bitmap = image_space->GetLiveBitmap();
       DCHECK(live_bitmap != NULL);
       live_bitmap->VisitMarkedRange(begin, end, visitor);
     }
@@ -687,11 +672,7 @@ void MarkSweep::RecursiveMark() {
   const bool partial = GetGcType() == kGcTypePartial;
   ScanObjectVisitor scan_visitor(this);
   if (!kDisableFinger) {
-    const std::vector<space::ContinuousSpace*>& spaces = GetHeap()->GetContinuousSpaces();
-    // TODO: C++0x
-    typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-    for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-      space::ContinuousSpace* space = *it;
+    for (const auto& space : GetHeap()->GetContinuousSpaces()) {
       if ((space->GetGcRetentionPolicy() == space::kGcRetentionPolicyAlwaysCollect) ||
           (!partial && space->GetGcRetentionPolicy() == space::kGcRetentionPolicyFullCollect)) {
         current_mark_bitmap_ = space->GetMarkBitmap();
@@ -729,10 +710,7 @@ void MarkSweep::ReMarkRoots() {
 void MarkSweep::SweepJniWeakGlobals(IsMarkedTester is_marked, void* arg) {
   JavaVMExt* vm = Runtime::Current()->GetJavaVM();
   MutexLock mu(Thread::Current(), vm->weak_globals_lock);
-  IndirectReferenceTable* table = &vm->weak_globals;
-  typedef IndirectReferenceTable::iterator It;  // TODO: C++0x auto
-  for (It it = table->begin(), end = table->end(); it != end; ++it) {
-    const Object** entry = *it;
+  for (const Object** entry : vm->weak_globals) {
     if (!is_marked(*entry, arg)) {
       *entry = kClearedJniWeakGlobal;
     }
@@ -815,10 +793,7 @@ void MarkSweep::VerifySystemWeaks() {
 
   JavaVMExt* vm = runtime->GetJavaVM();
   MutexLock mu(Thread::Current(), vm->weak_globals_lock);
-  IndirectReferenceTable* table = &vm->weak_globals;
-  typedef IndirectReferenceTable::iterator It;  // TODO: C++0x auto
-  for (It it = table->begin(), end = table->end(); it != end; ++it) {
-    const Object** entry = *it;
+  for (const Object** entry : vm->weak_globals) {
     VerifyIsLive(*entry);
   }
 }
@@ -988,11 +963,7 @@ void MarkSweep::Sweep(bool swap_bitmaps) {
   SweepCallbackContext scc;
   scc.mark_sweep = this;
   scc.self = Thread::Current();
-  const std::vector<space::ContinuousSpace*>& spaces = GetHeap()->GetContinuousSpaces();
-  // TODO: C++0x
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : GetHeap()->GetContinuousSpaces()) {
     // We always sweep always collect spaces.
     bool sweep_space = (space->GetGcRetentionPolicy() == space::kGcRetentionPolicyAlwaysCollect);
     if (!partial && !sweep_space) {
@@ -1040,11 +1011,9 @@ void MarkSweep::SweepLargeObjects(bool swap_bitmaps) {
   size_t freed_objects = 0;
   size_t freed_bytes = 0;
   Thread* self = Thread::Current();
-  // TODO: C++0x
-  typedef accounting::SpaceSetMap::Objects::iterator It;
-  for (It it = live_objects.begin(), end = live_objects.end(); it != end; ++it) {
-    if (!large_mark_objects->Test(*it)) {
-      freed_bytes += large_object_space->Free(self, const_cast<Object*>(*it));
+  for (const Object* obj : live_objects) {
+    if (!large_mark_objects->Test(obj)) {
+      freed_bytes += large_object_space->Free(self, const_cast<Object*>(obj));
       ++freed_objects;
     }
   }
@@ -1054,11 +1023,7 @@ void MarkSweep::SweepLargeObjects(bool swap_bitmaps) {
 }
 
 void MarkSweep::CheckReference(const Object* obj, const Object* ref, MemberOffset offset, bool is_static) {
-  const std::vector<space::ContinuousSpace*>& spaces = GetHeap()->GetContinuousSpaces();
-  // TODO: C++0x
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : GetHeap()->GetContinuousSpaces()) {
     if (space->IsDlMallocSpace() && space->Contains(ref)) {
       DCHECK(IsMarked(obj));
 
@@ -1508,11 +1473,7 @@ void MarkSweep::ProcessReferences(Object** soft_references, bool clear_soft,
 
 void MarkSweep::UnBindBitmaps() {
   base::TimingLogger::ScopedSplit split("UnBindBitmaps", &timings_);
-  const std::vector<space::ContinuousSpace*>& spaces = GetHeap()->GetContinuousSpaces();
-  // TODO: C++0x
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : GetHeap()->GetContinuousSpaces()) {
     if (space->IsDlMallocSpace()) {
       space::DlMallocSpace* alloc_space = space->AsDlMallocSpace();
       if (alloc_space->temp_bitmap_.get() != NULL) {
@@ -1585,11 +1546,7 @@ void MarkSweep::FinishPhase() {
   cumulative_timings_.End();
 
   // Clear all of the spaces' mark bitmaps.
-  const std::vector<space::ContinuousSpace*>& spaces = GetHeap()->GetContinuousSpaces();
-  // TODO: C++0x
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : GetHeap()->GetContinuousSpaces()) {
     if (space->GetGcRetentionPolicy() != space::kGcRetentionPolicyNeverCollect) {
       space->GetMarkBitmap()->Clear();
     }
diff --git a/runtime/gc/collector/mark_sweep.h b/runtime/gc/collector/mark_sweep.h
index e39e2f7e8f..8db03d3fb0 100644
--- a/runtime/gc/collector/mark_sweep.h
+++ b/runtime/gc/collector/mark_sweep.h
@@ -428,6 +428,7 @@ class MarkSweep : public GarbageCollector {
 
   bool clear_soft_references_;
 
+ private:
   friend class AddIfReachesAllocSpaceVisitor;  // Used by mod-union table.
   friend class CheckBitmapVisitor;
   friend class CheckObjectVisitor;
diff --git a/runtime/gc/collector/partial_mark_sweep.cc b/runtime/gc/collector/partial_mark_sweep.cc
index ef893c50b0..cc3cfe544d 100644
--- a/runtime/gc/collector/partial_mark_sweep.cc
+++ b/runtime/gc/collector/partial_mark_sweep.cc
@@ -33,14 +33,10 @@ PartialMarkSweep::PartialMarkSweep(Heap* heap, bool is_concurrent, const std::st
 void PartialMarkSweep::BindBitmaps() {
   MarkSweep::BindBitmaps();
 
-  const std::vector<space::ContinuousSpace*>& spaces = GetHeap()->GetContinuousSpaces();
   WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
   // For partial GCs we need to bind the bitmap of the zygote space so that all objects in the
   // zygote space are viewed as marked.
-  // TODO: C++0x
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : GetHeap()->GetContinuousSpaces()) {
     if (space->GetGcRetentionPolicy() == space::kGcRetentionPolicyFullCollect) {
       CHECK(space->IsZygoteSpace());
       ImmuneSpace(space);
diff --git a/runtime/gc/collector/partial_mark_sweep.h b/runtime/gc/collector/partial_mark_sweep.h
index 25304b999a..3b788f4683 100644
--- a/runtime/gc/collector/partial_mark_sweep.h
+++ b/runtime/gc/collector/partial_mark_sweep.h
@@ -38,6 +38,7 @@ class PartialMarkSweep : public MarkSweep {
   // collections, ie the Zygote space. Also mark this space is immune.
   virtual void BindBitmaps() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(PartialMarkSweep);
 };
 
diff --git a/runtime/gc/collector/sticky_mark_sweep.cc b/runtime/gc/collector/sticky_mark_sweep.cc
index aad7c2973f..008d3e00b5 100644
--- a/runtime/gc/collector/sticky_mark_sweep.cc
+++ b/runtime/gc/collector/sticky_mark_sweep.cc
@@ -33,15 +33,11 @@ StickyMarkSweep::StickyMarkSweep(Heap* heap, bool is_concurrent, const std::stri
 void StickyMarkSweep::BindBitmaps() {
   PartialMarkSweep::BindBitmaps();
 
-  const std::vector<space::ContinuousSpace*>& spaces = GetHeap()->GetContinuousSpaces();
   WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
   // For sticky GC, we want to bind the bitmaps of all spaces as the allocation stack lets us
   // know what was allocated since the last GC. A side-effect of binding the allocation space mark
   // and live bitmap is that marking the objects will place them in the live bitmap.
-  // TODO: C++0x
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : GetHeap()->GetContinuousSpaces()) {
     if (space->GetGcRetentionPolicy() == space::kGcRetentionPolicyAlwaysCollect) {
       BindLiveToMarkBitmap(space);
     }
diff --git a/runtime/gc/collector/sticky_mark_sweep.h b/runtime/gc/collector/sticky_mark_sweep.h
index e009b62c4b..2099c7929b 100644
--- a/runtime/gc/collector/sticky_mark_sweep.h
+++ b/runtime/gc/collector/sticky_mark_sweep.h
@@ -45,6 +45,7 @@ class StickyMarkSweep : public PartialMarkSweep {
 
   void Sweep(bool swap_bitmaps) EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(StickyMarkSweep);
 };
 
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index a2453b8405..d5a8d75b87 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -183,11 +183,8 @@ Heap::Heap(size_t initial_size, size_t growth_limit, size_t min_free, size_t max
     heap_capacity += continuous_spaces_.back()->AsDlMallocSpace()->NonGrowthLimitCapacity();
   }
 
-  // Mark image objects in the live bitmap
-  // TODO: C++0x
-  typedef std::vector<space::ContinuousSpace*>::iterator It;
-  for (It it = continuous_spaces_.begin(); it != continuous_spaces_.end(); ++it) {
-    space::ContinuousSpace* space = *it;
+  // Mark image objects in the live bitmap.
+  for (const auto& space : continuous_spaces_) {
     if (space->IsImageSpace()) {
       space::ImageSpace* image_space = space->AsImageSpace();
       image_space->RecordImageAllocations(image_space->GetLiveBitmap());
@@ -393,9 +390,7 @@ void Heap::AddContinuousSpace(space::ContinuousSpace* space) {
   // Ensure that ImageSpaces < ZygoteSpaces < AllocSpaces so that we can do address based checks to
   // avoid redundant marking.
   bool seen_zygote = false, seen_alloc = false;
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = continuous_spaces_.begin(); it != continuous_spaces_.end(); ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : continuous_spaces_) {
     if (space->IsImageSpace()) {
       DCHECK(!seen_zygote);
       DCHECK(!seen_alloc);
@@ -436,17 +431,13 @@ void Heap::DumpGcPerformanceInfo(std::ostream& os) {
   uint64_t total_duration = 0;
 
   // Dump cumulative loggers for each GC type.
-  // TODO: C++0x
   uint64_t total_paused_time = 0;
-  typedef std::vector<collector::MarkSweep*>::const_iterator It;
-  for (It it = mark_sweep_collectors_.begin();
-       it != mark_sweep_collectors_.end(); ++it) {
-    collector::MarkSweep* collector = *it;
+  for (const auto& collector : mark_sweep_collectors_) {
     CumulativeLogger& logger = collector->GetCumulativeTimings();
     if (logger.GetTotalNs() != 0) {
       os << Dumpable<CumulativeLogger>(logger);
       const uint64_t total_ns = logger.GetTotalNs();
-      const uint64_t total_pause_ns = (*it)->GetTotalPausedTimeNs();
+      const uint64_t total_pause_ns = collector->GetTotalPausedTimeNs();
       double seconds = NsToMs(logger.GetTotalNs()) / 1000.0;
       const uint64_t freed_bytes = collector->GetTotalFreedBytes();
       const uint64_t freed_objects = collector->GetTotalFreedObjects();
@@ -507,11 +498,9 @@ Heap::~Heap() {
 
 space::ContinuousSpace* Heap::FindContinuousSpaceFromObject(const mirror::Object* obj,
                                                             bool fail_ok) const {
-  // TODO: C++0x auto
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = continuous_spaces_.begin(), end = continuous_spaces_.end(); it != end; ++it) {
-    if ((*it)->Contains(obj)) {
-      return *it;
+  for (const auto& space : continuous_spaces_) {
+    if (space->Contains(obj)) {
+      return space;
     }
   }
   if (!fail_ok) {
@@ -522,11 +511,9 @@ space::ContinuousSpace* Heap::FindContinuousSpaceFromObject(const mirror::Object
 
 space::DiscontinuousSpace* Heap::FindDiscontinuousSpaceFromObject(const mirror::Object* obj,
                                                                   bool fail_ok) const {
-  // TODO: C++0x auto
-  typedef std::vector<space::DiscontinuousSpace*>::const_iterator It;
-  for (It it = discontinuous_spaces_.begin(), end = discontinuous_spaces_.end(); it != end; ++it) {
-    if ((*it)->Contains(obj)) {
-      return *it;
+  for (const auto& space : discontinuous_spaces_) {
+    if (space->Contains(obj)) {
+      return space;
     }
   }
   if (!fail_ok) {
@@ -544,11 +531,9 @@ space::Space* Heap::FindSpaceFromObject(const mirror::Object* obj, bool fail_ok)
 }
 
 space::ImageSpace* Heap::GetImageSpace() const {
-  // TODO: C++0x auto
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = continuous_spaces_.begin(), end = continuous_spaces_.end(); it != end; ++it) {
-    if ((*it)->IsImageSpace()) {
-      return (*it)->AsImageSpace();
+  for (const auto& space : continuous_spaces_) {
+    if (space->IsImageSpace()) {
+      return space->AsImageSpace();
     }
   }
   return NULL;
@@ -627,10 +612,7 @@ mirror::Object* Heap::AllocObject(Thread* self, mirror::Class* c, size_t byte_co
     // If the allocation failed due to fragmentation, print out the largest continuous allocation.
     if (!large_object_allocation && total_bytes_free >= byte_count) {
       size_t max_contiguous_allocation = 0;
-      // TODO: C++0x auto
-      typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-      for (It it = continuous_spaces_.begin(), end = continuous_spaces_.end(); it != end; ++it) {
-        space::ContinuousSpace* space = *it;
+      for (const auto& space : continuous_spaces_) {
         if (space->IsDlMallocSpace()) {
           space->AsDlMallocSpace()->Walk(MSpaceChunkCallback, &max_contiguous_allocation);
         }
@@ -706,19 +688,14 @@ void Heap::VerifyObjectImpl(const mirror::Object* obj) {
 }
 
 void Heap::DumpSpaces() {
-  // TODO: C++0x auto
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = continuous_spaces_.begin(), end = continuous_spaces_.end(); it != end; ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : continuous_spaces_) {
     accounting::SpaceBitmap* live_bitmap = space->GetLiveBitmap();
     accounting::SpaceBitmap* mark_bitmap = space->GetMarkBitmap();
     LOG(INFO) << space << " " << *space << "\n"
               << live_bitmap << " " << *live_bitmap << "\n"
               << mark_bitmap << " " << *mark_bitmap;
   }
-  typedef std::vector<space::DiscontinuousSpace*>::const_iterator It2;
-  for (It2 it = discontinuous_spaces_.begin(), end = discontinuous_spaces_.end(); it != end; ++it) {
-    space::DiscontinuousSpace* space = *it;
+  for (const auto& space : discontinuous_spaces_) {
     LOG(INFO) << space << " " << *space << "\n";
   }
 }
@@ -1143,11 +1120,8 @@ void Heap::PreZygoteFork() {
   have_zygote_space_ = true;
 
   // Reset the cumulative loggers since we now have a few additional timing phases.
-  // TODO: C++0x
-  typedef std::vector<collector::MarkSweep*>::const_iterator It;
-  for (It it = mark_sweep_collectors_.begin(), end = mark_sweep_collectors_.end();
-      it != end; ++it) {
-    (*it)->ResetCumulativeStatistics();
+  for (const auto& collector : mark_sweep_collectors_) {
+    collector->ResetCumulativeStatistics();
   }
 }
 
@@ -1238,10 +1212,7 @@ collector::GcType Heap::CollectGarbageInternal(collector::GcType gc_type, GcCaus
   ATRACE_BEGIN(gc_cause_and_type_strings[gc_cause][gc_type]);
 
   collector::MarkSweep* collector = NULL;
-  typedef std::vector<collector::MarkSweep*>::iterator It;
-  for (It it = mark_sweep_collectors_.begin(), end = mark_sweep_collectors_.end();
-      it != end; ++it) {
-    collector::MarkSweep* cur_collector = *it;
+  for (const auto& cur_collector : mark_sweep_collectors_) {
     if (cur_collector->IsConcurrent() == concurrent_gc_ && cur_collector->GetGcType() == gc_type) {
       collector = cur_collector;
       break;
@@ -1596,9 +1567,7 @@ void Heap::SwapStacks() {
 
 void Heap::ProcessCards(base::TimingLogger& timings) {
   // Clear cards and keep track of cards cleared in the mod-union table.
-  typedef std::vector<space::ContinuousSpace*>::iterator It;
-  for (It it = continuous_spaces_.begin(), end = continuous_spaces_.end(); it != end; ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : continuous_spaces_) {
     if (space->IsImageSpace()) {
       base::TimingLogger::ScopedSplit split("ImageModUnionClearCards", &timings);
       image_mod_union_table_->ClearCards(space);
@@ -2085,9 +2054,7 @@ void Heap::RegisterNativeFree(int bytes) {
 
 int64_t Heap::GetTotalMemory() const {
   int64_t ret = 0;
-  typedef std::vector<space::ContinuousSpace*>::const_iterator It;
-  for (It it = continuous_spaces_.begin(), end = continuous_spaces_.end(); it != end; ++it) {
-    space::ContinuousSpace* space = *it;
+  for (const auto& space : continuous_spaces_) {
     if (space->IsImageSpace()) {
       // Currently don't include the image space.
     } else if (space->IsDlMallocSpace()) {
@@ -2095,9 +2062,7 @@ int64_t Heap::GetTotalMemory() const {
       ret += space->AsDlMallocSpace()->GetFootprint();
     }
   }
-  typedef std::vector<space::DiscontinuousSpace*>::const_iterator It2;
-  for (It2 it = discontinuous_spaces_.begin(), end = discontinuous_spaces_.end(); it != end; ++it) {
-    space::DiscontinuousSpace* space = *it;
+  for (const auto& space : discontinuous_spaces_) {
     if (space->IsLargeObjectSpace()) {
       ret += space->AsLargeObjectSpace()->GetBytesAllocated();
     }
diff --git a/runtime/indirect_reference_table.cc b/runtime/indirect_reference_table.cc
index 3e75716ce8..8af4d7eaab 100644
--- a/runtime/indirect_reference_table.cc
+++ b/runtime/indirect_reference_table.cc
@@ -309,9 +309,8 @@ bool IndirectReferenceTable::Remove(uint32_t cookie, IndirectRef iref) {
 }
 
 void IndirectReferenceTable::VisitRoots(RootVisitor* visitor, void* arg) {
-  typedef IndirectReferenceTable::iterator It;  // TODO: C++0x auto
-  for (It it = begin(), end = this->end(); it != end; ++it) {
-    visitor(**it, arg);
+  for (auto ref : *this) {
+    visitor(*ref, arg);
   }
 }
 
diff --git a/runtime/indirect_reference_table.h b/runtime/indirect_reference_table.h
index 97706b82bb..26f53db4ad 100644
--- a/runtime/indirect_reference_table.h
+++ b/runtime/indirect_reference_table.h
@@ -248,8 +248,6 @@ bool inline operator!=(const IrtIterator& lhs, const IrtIterator& rhs) {
 
 class IndirectReferenceTable {
  public:
-  typedef IrtIterator iterator;
-
   IndirectReferenceTable(size_t initialCount, size_t maxCount, IndirectRefKind kind);
 
   ~IndirectReferenceTable();
@@ -301,12 +299,12 @@ class IndirectReferenceTable {
     return segment_state_.parts.topIndex;
   }
 
-  iterator begin() {
-    return iterator(table_, 0, Capacity());
+  IrtIterator begin() {
+    return IrtIterator(table_, 0, Capacity());
   }
 
-  iterator end() {
-    return iterator(table_, Capacity(), Capacity());
+  IrtIterator end() {
+    return IrtIterator(table_, Capacity(), Capacity());
   }
 
   void VisitRoots(RootVisitor* visitor, void* arg);
diff --git a/runtime/instrumentation.cc b/runtime/instrumentation.cc
index ae3a165a70..6caad0110d 100644
--- a/runtime/instrumentation.cc
+++ b/runtime/instrumentation.cc
@@ -206,12 +206,9 @@ static void InstrumentationRestoreStack(Thread* thread, void* arg)
         }
         return true;  // Ignore upcalls.
       }
-      typedef std::deque<instrumentation::InstrumentationStackFrame>::const_iterator It;  // TODO: C++0x auto
       bool removed_stub = false;
       // TODO: make this search more efficient?
-      for (It it = instrumentation_stack_->begin(), end = instrumentation_stack_->end(); it != end;
-          ++it) {
-        InstrumentationStackFrame instrumentation_frame =  *it;
+      for (InstrumentationStackFrame instrumentation_frame : *instrumentation_stack_) {
         if (instrumentation_frame.frame_id_ == GetFrameId()) {
           if (kVerboseInstrumentation) {
             LOG(INFO) << "  Removing exit stub in " << DescribeLocation();
@@ -407,8 +404,7 @@ const void* Instrumentation::GetQuickCodeFor(const mirror::ArtMethod* method) co
 void Instrumentation::MethodEnterEventImpl(Thread* thread, mirror::Object* this_object,
                                            const mirror::ArtMethod* method,
                                            uint32_t dex_pc) const {
-  typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
-  It it = method_entry_listeners_.begin();
+  auto it = method_entry_listeners_.begin();
   bool is_end = (it == method_entry_listeners_.end());
   // Implemented this way to prevent problems caused by modification of the list while iterating.
   while (!is_end) {
@@ -422,8 +418,7 @@ void Instrumentation::MethodEnterEventImpl(Thread* thread, mirror::Object* this_
 void Instrumentation::MethodExitEventImpl(Thread* thread, mirror::Object* this_object,
                                           const mirror::ArtMethod* method,
                                           uint32_t dex_pc, const JValue& return_value) const {
-  typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
-  It it = method_exit_listeners_.begin();
+  auto it = method_exit_listeners_.begin();
   bool is_end = (it == method_exit_listeners_.end());
   // Implemented this way to prevent problems caused by modification of the list while iterating.
   while (!is_end) {
@@ -438,10 +433,8 @@ void Instrumentation::MethodUnwindEvent(Thread* thread, mirror::Object* this_obj
                                         const mirror::ArtMethod* method,
                                         uint32_t dex_pc) const {
   if (have_method_unwind_listeners_) {
-    typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
-    for (It it = method_unwind_listeners_.begin(), end = method_unwind_listeners_.end(); it != end;
-        ++it) {
-      (*it)->MethodUnwind(thread, method, dex_pc);
+    for (InstrumentationListener* listener : method_unwind_listeners_) {
+      listener->MethodUnwind(thread, method, dex_pc);
     }
   }
 }
@@ -454,9 +447,8 @@ void Instrumentation::DexPcMovedEventImpl(Thread* thread, mirror::Object* this_o
   // around the problem and in general we may have to move to something like reference counting to
   // ensure listeners are deleted correctly.
   std::list<InstrumentationListener*> copy(dex_pc_listeners_);
-  typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
-  for (It it = copy.begin(), end = copy.end(); it != end; ++it) {
-    (*it)->DexPcMoved(thread, this_object, method, dex_pc);
+  for (InstrumentationListener* listener : copy) {
+    listener->DexPcMoved(thread, this_object, method, dex_pc);
   }
 }
 
@@ -467,10 +459,8 @@ void Instrumentation::ExceptionCaughtEvent(Thread* thread, const ThrowLocation&
   if (have_exception_caught_listeners_) {
     DCHECK_EQ(thread->GetException(NULL), exception_object);
     thread->ClearException();
-    typedef std::list<InstrumentationListener*>::const_iterator It;  // TODO: C++0x auto
-    for (It it = exception_caught_listeners_.begin(), end = exception_caught_listeners_.end();
-        it != end; ++it) {
-      (*it)->ExceptionCaught(thread, throw_location, catch_method, catch_dex_pc, exception_object);
+    for (InstrumentationListener* listener : exception_caught_listeners_) {
+      listener->ExceptionCaught(thread, throw_location, catch_method, catch_dex_pc, exception_object);
     }
     thread->SetException(throw_location, exception_object);
   }
diff --git a/runtime/intern_table.cc b/runtime/intern_table.cc
index e2c1a64dec..d7398caa57 100644
--- a/runtime/intern_table.cc
+++ b/runtime/intern_table.cc
@@ -40,9 +40,8 @@ void InternTable::DumpForSigQuit(std::ostream& os) const {
 
 void InternTable::VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty) {
   MutexLock mu(Thread::Current(), intern_table_lock_);
-  typedef Table::const_iterator It;  // TODO: C++0x auto
-  for (It it = strong_interns_.begin(), end = strong_interns_.end(); it != end; ++it) {
-    visitor(it->second, arg);
+  for (const auto& strong_intern : strong_interns_) {
+    visitor(strong_intern.second, arg);
   }
   if (clean_dirty) {
     is_dirty_ = false;
@@ -52,8 +51,7 @@ void InternTable::VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty)
 
 mirror::String* InternTable::Lookup(Table& table, mirror::String* s, uint32_t hash_code) {
   intern_table_lock_.AssertHeld(Thread::Current());
-  typedef Table::const_iterator It;  // TODO: C++0x auto
-  for (It it = table.find(hash_code), end = table.end(); it != end; ++it) {
+  for (auto it = table.find(hash_code), end = table.end(); it != end; ++it) {
     mirror::String* existing_string = it->second;
     if (existing_string->Equals(s)) {
       return existing_string;
@@ -75,8 +73,7 @@ void InternTable::RegisterStrong(mirror::String* s) {
 
 void InternTable::Remove(Table& table, const mirror::String* s, uint32_t hash_code) {
   intern_table_lock_.AssertHeld(Thread::Current());
-  typedef Table::iterator It;  // TODO: C++0x auto
-  for (It it = table.find(hash_code), end = table.end(); it != end; ++it) {
+  for (auto it = table.find(hash_code), end = table.end(); it != end; ++it) {
     if (it->second == s) {
       table.erase(it);
       return;
@@ -166,8 +163,8 @@ bool InternTable::ContainsWeak(mirror::String* s) {
 
 void InternTable::SweepInternTableWeaks(IsMarkedTester is_marked, void* arg) {
   MutexLock mu(Thread::Current(), intern_table_lock_);
-  typedef Table::iterator It;  // TODO: C++0x auto
-  for (It it = weak_interns_.begin(), end = weak_interns_.end(); it != end;) {
+  // TODO: std::remove_if + lambda.
+  for (auto it = weak_interns_.begin(), end = weak_interns_.end(); it != end;) {
     mirror::Object* object = it->second;
     if (!is_marked(object, arg)) {
       weak_interns_.erase(it++);
diff --git a/runtime/intern_table_test.cc b/runtime/intern_table_test.cc
index ffb93eb672..d79d2c4b31 100644
--- a/runtime/intern_table_test.cc
+++ b/runtime/intern_table_test.cc
@@ -58,8 +58,7 @@ class TestPredicate {
  public:
   bool IsMarked(const mirror::Object* s) const {
     bool erased = false;
-    typedef std::vector<const mirror::String*>::iterator It;  // TODO: C++0x auto
-    for (It it = expected_.begin(), end = expected_.end(); it != end; ++it) {
+    for (auto it = expected_.begin(), end = expected_.end(); it != end; ++it) {
       if (*it == s) {
         expected_.erase(it);
         erased = true;
diff --git a/runtime/jni_internal.cc b/runtime/jni_internal.cc
index 852dd00a77..460e3b0f30 100644
--- a/runtime/jni_internal.cc
+++ b/runtime/jni_internal.cc
@@ -538,12 +538,12 @@ class Libraries {
 
   void Dump(std::ostream& os) const {
     bool first = true;
-    for (It it = libraries_.begin(); it != libraries_.end(); ++it) {
+    for (const auto& library : libraries_) {
       if (!first) {
         os << ' ';
       }
       first = false;
-      os << it->first;
+      os << library.first;
     }
   }
 
@@ -552,7 +552,7 @@ class Libraries {
   }
 
   SharedLibrary* Get(const std::string& path) {
-    It it = libraries_.find(path);
+    auto it = libraries_.find(path);
     return (it == libraries_.end()) ? NULL : it->second;
   }
 
@@ -566,8 +566,8 @@ class Libraries {
     std::string jni_short_name(JniShortName(m));
     std::string jni_long_name(JniLongName(m));
     const ClassLoader* declaring_class_loader = m->GetDeclaringClass()->GetClassLoader();
-    for (It it = libraries_.begin(); it != libraries_.end(); ++it) {
-      SharedLibrary* library = it->second;
+    for (const auto& lib : libraries_) {
+      SharedLibrary* library = lib.second;
       if (library->GetClassLoader() != declaring_class_loader) {
         // We only search libraries loaded by the appropriate ClassLoader.
         continue;
@@ -591,8 +591,6 @@ class Libraries {
   }
 
  private:
-  typedef SafeMap<std::string, SharedLibrary*>::const_iterator It;  // TODO: C++0x auto
-
   SafeMap<std::string, SharedLibrary*> libraries_;
 };
 
diff --git a/runtime/mirror/art_method.h b/runtime/mirror/art_method.h
index 7301f23747..5d4a6ea0d5 100644
--- a/runtime/mirror/art_method.h
+++ b/runtime/mirror/art_method.h
@@ -442,6 +442,7 @@ class MANAGED ArtMethod : public Object {
 
   static Class* java_lang_reflect_ArtMethod_;
 
+ private:
   friend struct art::ArtMethodOffsets;  // for verifying offset information
   DISALLOW_IMPLICIT_CONSTRUCTORS(ArtMethod);
 };
diff --git a/runtime/monitor.cc b/runtime/monitor.cc
index 48c05692b4..ff193c9534 100644
--- a/runtime/monitor.cc
+++ b/runtime/monitor.cc
@@ -979,9 +979,7 @@ void MonitorList::Add(Monitor* m) {
 
 void MonitorList::SweepMonitorList(IsMarkedTester is_marked, void* arg) {
   MutexLock mu(Thread::Current(), monitor_list_lock_);
-  typedef std::list<Monitor*>::iterator It;  // TODO: C++0x auto
-  It it = list_.begin();
-  while (it != list_.end()) {
+  for (auto it = list_.begin(); it != list_.end(); ) {
     Monitor* m = *it;
     if (!is_marked(m->GetObject(), arg)) {
       VLOG(monitor) << "freeing monitor " << m << " belonging to unmarked object " << m->GetObject();
diff --git a/runtime/native/dalvik_system_DexFile.cc b/runtime/native/dalvik_system_DexFile.cc
index 061dfb84db..4ee353359b 100644
--- a/runtime/native/dalvik_system_DexFile.cc
+++ b/runtime/native/dalvik_system_DexFile.cc
@@ -253,14 +253,10 @@ static jboolean DexFile_isDexOptNeeded(JNIEnv* env, jclass, jstring javaFilename
     return JNI_TRUE;
   }
 
-  gc::Heap* heap = runtime->GetHeap();
-  const std::vector<gc::space::ContinuousSpace*>& spaces = heap->GetContinuousSpaces();
-  // TODO: C++0x auto
-  typedef std::vector<gc::space::ContinuousSpace*>::const_iterator It;
-  for (It it = spaces.begin(), end = spaces.end(); it != end; ++it) {
-    if ((*it)->IsImageSpace()) {
+  for (const auto& space : runtime->GetHeap()->GetContinuousSpaces()) {
+    if (space->IsImageSpace()) {
       // TODO: Ensure this works with multiple image spaces.
-      const ImageHeader& image_header = (*it)->AsImageSpace()->GetImageHeader();
+      const ImageHeader& image_header = space->AsImageSpace()->GetImageHeader();
       if (oat_file->GetOatHeader().GetImageFileLocationOatChecksum() != image_header.GetOatChecksum()) {
         ScopedObjectAccess soa(env);
         LOG(INFO) << "DexFile_isDexOptNeeded cache file " << cache_location
diff --git a/runtime/output_stream_test.cc b/runtime/output_stream_test.cc
index 8da2ac91fe..d5e97558c0 100644
--- a/runtime/output_stream_test.cc
+++ b/runtime/output_stream_test.cc
@@ -78,4 +78,4 @@ TEST_F(OutputStreamTest, Vector) {
   CheckTestOutput(output);
 }
 
-}  // namespace std
+}  // namespace art
diff --git a/runtime/reference_table.cc b/runtime/reference_table.cc
index de64c26155..8e23cbb153 100644
--- a/runtime/reference_table.cc
+++ b/runtime/reference_table.cc
@@ -232,9 +232,8 @@ void ReferenceTable::Dump(std::ostream& os, const Table& entries) {
 }
 
 void ReferenceTable::VisitRoots(RootVisitor* visitor, void* arg) {
-  typedef Table::const_iterator It;  // TODO: C++0x auto
-  for (It it = entries_.begin(), end = entries_.end(); it != end; ++it) {
-    visitor(*it, arg);
+  for (const auto& ref : entries_) {
+    visitor(ref, arg);
   }
 }
 
diff --git a/runtime/thread_list.cc b/runtime/thread_list.cc
index 9c28c87b84..671924a620 100644
--- a/runtime/thread_list.cc
+++ b/runtime/thread_list.cc
@@ -53,8 +53,8 @@ bool ThreadList::Contains(Thread* thread) {
 }
 
 bool ThreadList::Contains(pid_t tid) {
-  for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-    if ((*it)->tid_ == tid) {
+  for (const auto& thread : list_) {
+    if (thread->tid_ == tid) {
       return true;
     }
   }
@@ -113,8 +113,8 @@ void ThreadList::DumpUnattachedThreads(std::ostream& os) {
 
 void ThreadList::DumpLocked(std::ostream& os) {
   os << "DALVIK THREADS (" << list_.size() << "):\n";
-  for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-    (*it)->Dump(os);
+  for (const auto& thread : list_) {
+    thread->Dump(os);
     os << "\n";
   }
 }
@@ -122,8 +122,7 @@ void ThreadList::DumpLocked(std::ostream& os) {
 void ThreadList::AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2) {
   MutexLock mu(self, *Locks::thread_list_lock_);
   MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
-  for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-    Thread* thread = *it;
+  for (const auto& thread : list_) {
     if (thread != ignore1 && thread != ignore2) {
       CHECK(thread->IsSuspended())
             << "\nUnsuspended thread: <<" << *thread << "\n"
@@ -160,9 +159,7 @@ size_t ThreadList::RunCheckpoint(Closure* checkpoint_function) {
     // Call a checkpoint function for each thread, threads which are suspend get their checkpoint
     // manually called.
     MutexLock mu(self, *Locks::thread_list_lock_);
-    // TODO: C++0x auto.
-    for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-      Thread* thread = *it;
+    for (const auto& thread : list_) {
       if (thread != self) {
         for (;;) {
           if (thread->RequestCheckpoint(checkpoint_function)) {
@@ -189,8 +186,7 @@ size_t ThreadList::RunCheckpoint(Closure* checkpoint_function) {
   checkpoint_function->Run(self);
 
   // Run the checkpoint on the suspended threads.
-  for (size_t i = 0; i < suspended_count_modified_threads.size(); ++i) {
-    Thread* thread = suspended_count_modified_threads[i];
+  for (const auto& thread : suspended_count_modified_threads) {
     if (!thread->IsSuspended()) {
       // Wait until the thread is suspended.
       uint64_t start = NanoTime();
@@ -243,8 +239,7 @@ void ThreadList::SuspendAll() {
       // Update global suspend all state for attaching threads.
       ++suspend_all_count_;
       // Increment everybody's suspend count (except our own).
-      for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-        Thread* thread = *it;
+      for (const auto& thread : list_) {
         if (thread == self) {
           continue;
         }
@@ -285,8 +280,7 @@ void ThreadList::ResumeAll() {
     // Update global suspend all state for attaching threads.
     --suspend_all_count_;
     // Decrement the suspend counts for all threads.
-    for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-      Thread* thread = *it;
+    for (const auto& thread : list_) {
       if (thread == self) {
         continue;
       }
@@ -341,8 +335,7 @@ void ThreadList::SuspendAllForDebugger() {
       ++suspend_all_count_;
       ++debug_suspend_all_count_;
       // Increment everybody's suspend count (except our own).
-      for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-        Thread* thread = *it;
+      for (const auto& thread : list_) {
         if (thread == self || thread == debug_thread) {
           continue;
         }
@@ -427,8 +420,7 @@ void ThreadList::UndoDebuggerSuspensions() {
     suspend_all_count_ -= debug_suspend_all_count_;
     debug_suspend_all_count_ = 0;
     // Update running threads.
-    for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-      Thread* thread = *it;
+    for (const auto& thread : list_) {
       if (thread == self || thread->debug_suspend_count_ == 0) {
         continue;
       }
@@ -457,8 +449,7 @@ void ThreadList::WaitForOtherNonDaemonThreadsToExit() {
     }
     all_threads_are_daemons = true;
     MutexLock mu(self, *Locks::thread_list_lock_);
-    for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-      Thread* thread = *it;
+    for (const auto& thread : list_) {
       if (thread != self && !thread->IsDaemon()) {
         all_threads_are_daemons = false;
         break;
@@ -476,8 +467,7 @@ void ThreadList::SuspendAllDaemonThreads() {
   MutexLock mu(self, *Locks::thread_list_lock_);
   {  // Tell all the daemons it's time to suspend.
     MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
-    for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-      Thread* thread = *it;
+    for (const auto& thread : list_) {
       // This is only run after all non-daemon threads have exited, so the remainder should all be
       // daemons.
       CHECK(thread->IsDaemon()) << *thread;
@@ -491,8 +481,7 @@ void ThreadList::SuspendAllDaemonThreads() {
   for (int i = 0; i < 10; ++i) {
     usleep(200 * 1000);
     bool all_suspended = true;
-    for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-      Thread* thread = *it;
+    for (const auto& thread : list_) {
       if (thread != self && thread->GetState() == kRunnable) {
         if (!have_complained) {
           LOG(WARNING) << "daemon thread not yet suspended: " << *thread;
@@ -567,22 +556,22 @@ void ThreadList::Unregister(Thread* self) {
 }
 
 void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) {
-  for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-    callback(*it, context);
+  for (const auto& thread : list_) {
+    callback(thread, context);
   }
 }
 
 void ThreadList::VisitRoots(RootVisitor* visitor, void* arg) const {
   MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
-  for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-    (*it)->VisitRoots(visitor, arg);
+  for (const auto& thread : list_) {
+    thread->VisitRoots(visitor, arg);
   }
 }
 
 void ThreadList::VerifyRoots(VerifyRootVisitor* visitor, void* arg) const {
   MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
-  for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-    (*it)->VerifyRoots(visitor, arg);
+  for (const auto& thread : list_) {
+    thread->VerifyRoots(visitor, arg);
   }
 }
 
@@ -607,9 +596,9 @@ void ThreadList::ReleaseThreadId(Thread* self, uint32_t id) {
 
 Thread* ThreadList::FindThreadByThinLockId(uint32_t thin_lock_id) {
   MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
-  for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-    if ((*it)->GetThinLockId() == thin_lock_id) {
-      return *it;
+  for (const auto& thread : list_) {
+    if (thread->GetThinLockId() == thin_lock_id) {
+      return thread;
     }
   }
   return NULL;
diff --git a/runtime/thread_list.h b/runtime/thread_list.h
index d95f191553..3df3e2c841 100644
--- a/runtime/thread_list.h
+++ b/runtime/thread_list.h
@@ -102,8 +102,6 @@ class ThreadList {
   Thread* FindThreadByThinLockId(uint32_t thin_lock_id);
 
  private:
-  typedef std::list<Thread*>::const_iterator It;  // TODO: C++0x auto
-
   uint32_t AllocThreadId(Thread* self);
   void ReleaseThreadId(Thread* self, uint32_t id) LOCKS_EXCLUDED(allocated_ids_lock_);
 
diff --git a/runtime/thread_pool.h b/runtime/thread_pool.h
index c26926cf74..9c6d47b0a9 100644
--- a/runtime/thread_pool.h
+++ b/runtime/thread_pool.h
@@ -55,6 +55,7 @@ class ThreadPoolWorker {
   const size_t stack_size_;
   pthread_t pthread_;
 
+ private:
   friend class ThreadPool;
   DISALLOW_COPY_AND_ASSIGN(ThreadPoolWorker);
 };
@@ -117,6 +118,7 @@ class ThreadPool {
   uint64_t total_wait_time_;
   Barrier creation_barier_;
 
+ private:
   friend class ThreadPoolWorker;
   friend class WorkStealingWorker;
   DISALLOW_COPY_AND_ASSIGN(ThreadPool);
@@ -153,6 +155,7 @@ class WorkStealingWorker : public ThreadPoolWorker {
   WorkStealingWorker(ThreadPool* thread_pool, const std::string& name, size_t stack_size);
   virtual void Run();
 
+ private:
   friend class WorkStealingThreadPool;
   DISALLOW_COPY_AND_ASSIGN(WorkStealingWorker);
 };
diff --git a/runtime/trace.cc b/runtime/trace.cc
index 13e2bf6deb..5d6943c959 100644
--- a/runtime/trace.cc
+++ b/runtime/trace.cc
@@ -610,12 +610,9 @@ void Trace::GetVisitedMethods(size_t buf_size,
   }
 }
 
-void Trace::DumpMethodList(std::ostream& os,
-                           const std::set<mirror::ArtMethod*>& visited_methods) {
-  typedef std::set<mirror::ArtMethod*>::const_iterator It;  // TODO: C++0x auto
+void Trace::DumpMethodList(std::ostream& os, const std::set<mirror::ArtMethod*>& visited_methods) {
   MethodHelper mh;
-  for (It it = visited_methods.begin(); it != visited_methods.end(); ++it) {
-    mirror::ArtMethod* method = *it;
+  for (const auto& method : visited_methods) {
     mh.ChangeMethod(method);
     os << StringPrintf("%p\t%s\t%s\t%s\t%s\n", method,
         PrettyDescriptor(mh.GetDeclaringClassDescriptor()).c_str(), mh.GetName(),
diff --git a/runtime/verifier/method_verifier.h b/runtime/verifier/method_verifier.h
index 6171943a6c..ff4386e104 100644
--- a/runtime/verifier/method_verifier.h
+++ b/runtime/verifier/method_verifier.h
@@ -122,7 +122,7 @@ class PcToRegisterLineTable {
             uint16_t registers_size, MethodVerifier* verifier);
 
   RegisterLine* GetLine(size_t idx) {
-    Table::iterator result = pc_to_register_line_.find(idx);  // TODO: C++0x auto
+    auto result = pc_to_register_line_.find(idx);
     if (result == pc_to_register_line_.end()) {
       return NULL;
     } else {
diff --git a/runtime/verifier/reg_type.cc b/runtime/verifier/reg_type.cc
index 8418928a83..25f840cc56 100644
--- a/runtime/verifier/reg_type.cc
+++ b/runtime/verifier/reg_type.cc
@@ -395,8 +395,7 @@ std::string UnresolvedMergedType::Dump() const {
   std::stringstream result;
   std::set<uint16_t> types = GetMergedTypes();
   result << "UnresolvedMergedReferences(";
-  typedef std::set<uint16_t>::const_iterator It;  // TODO: C++0x auto
-  It it = types.begin();
+  auto it = types.begin();
   result << reg_type_cache_->GetFromId(*it).Dump();
   for (++it; it != types.end(); ++it) {
     result << ", ";
@@ -609,9 +608,8 @@ std::set<uint16_t> UnresolvedMergedType::GetMergedTypes() const {
     types.insert(refs.second);
   }
   if (kIsDebugBuild) {
-    typedef std::set<uint16_t>::const_iterator It;  // TODO: C++0x auto
-    for (It it = types.begin(); it != types.end(); ++it) {
-      CHECK(!reg_type_cache_->GetFromId(*it).IsUnresolvedMergedReference());
+    for (const auto& type : types) {
+      CHECK(!reg_type_cache_->GetFromId(type).IsUnresolvedMergedReference());
     }
   }
   return types;
diff --git a/runtime/verifier/reg_type.h b/runtime/verifier/reg_type.h
index 33f4195885..865ba20d44 100644
--- a/runtime/verifier/reg_type.h
+++ b/runtime/verifier/reg_type.h
@@ -287,6 +287,7 @@ class RegType {
 
   friend class RegTypeCache;
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(RegType);
 };
 
diff --git a/runtime/verifier/register_line.cc b/runtime/verifier/register_line.cc
index 24a626b277..5affe4759a 100644
--- a/runtime/verifier/register_line.cc
+++ b/runtime/verifier/register_line.cc
@@ -208,9 +208,8 @@ std::string RegisterLine::Dump() const {
     result += GetRegisterType(i).Dump();
     result += "],";
   }
-  typedef std::deque<uint32_t>::const_iterator It;  // TODO: C++0x auto
-  for (It it = monitors_.begin(), end = monitors_.end(); it != end; ++it) {
-    result += StringPrintf("{%d},", *it);
+  for (const auto& monitor : monitors_) {
+    result += StringPrintf("{%d},", monitor);
   }
   return result;
 }
diff --git a/tools/cpplint.py b/tools/cpplint.py
index 0b5fb93536..30b5216b12 100755
--- a/tools/cpplint.py
+++ b/tools/cpplint.py
@@ -53,12 +53,8 @@
 #  - Check for 0 in char context (should be '\0')
 #  - Check for camel-case method name conventions for methods
 #    that are not simple inline getters and setters
-#  - Check that base classes have virtual destructors
-#    put "  // namespace" after } that closes a namespace, with
-#    namespace's name after 'namespace' if it is named.
 #  - Do not indent namespace contents
 #  - Avoid inlining non-trivial constructors in header files
-#    include base/basictypes.h if DISALLOW_EVIL_CONSTRUCTORS is used
 #  - Check for old-school (void) cast for call-sites of functions
 #    ignored return value
 #  - Check gUnit usage of anonymous namespace
@@ -80,6 +76,7 @@ same line, but it is far from perfect (in either direction).
 """
 
 import codecs
+import copy
 import getopt
 import math  # for log
 import os
@@ -139,6 +136,22 @@ Syntax: cpplint.py [--verbose=#] [--output=vs7] [--filter=-x,+y,...]
       the top-level categories like 'build' and 'whitespace' will
       also be printed. If 'detailed' is provided, then a count
       is provided for each category like 'build/class'.
+
+    root=subdir
+      The root directory used for deriving header guard CPP variable.
+      By default, the header guard CPP variable is calculated as the relative
+      path to the directory that contains .git, .hg, or .svn.  When this flag
+      is specified, the relative path is calculated from the specified
+      directory. If the specified directory does not exist, this flag is
+      ignored.
+
+      Examples:
+        Assuing that src/.git exists, the header guard CPP variables for
+        src/chrome/browser/ui/browser.h are:
+
+        No flag => CHROME_BROWSER_UI_BROWSER_H_
+        --root=chrome => BROWSER_UI_BROWSER_H_
+        --root=chrome/browser => UI_BROWSER_H_
 """
 
 # We categorize each error message we print.  Here are the categories.
@@ -161,6 +174,7 @@ _ERROR_CATEGORIES = [
   'build/printf_format',
   'build/storage_class',
   'legal/copyright',
+  'readability/alt_tokens',
   'readability/braces',
   'readability/casting',
   'readability/check',
@@ -169,6 +183,7 @@ _ERROR_CATEGORIES = [
   'readability/function',
   'readability/multiline_comment',
   'readability/multiline_string',
+  'readability/namespace',
   'readability/nolint',
   'readability/streams',
   'readability/todo',
@@ -189,13 +204,14 @@ _ERROR_CATEGORIES = [
   'runtime/sizeof',
   'runtime/string',
   'runtime/threadsafe_fn',
-  'runtime/virtual',
   'whitespace/blank_line',
   'whitespace/braces',
   'whitespace/comma',
   'whitespace/comments',
+  'whitespace/empty_loop_body',
   'whitespace/end_of_line',
   'whitespace/ending_newline',
+  'whitespace/forcolon',
   'whitespace/indent',
   'whitespace/labels',
   'whitespace/line_length',
@@ -241,8 +257,9 @@ _CPP_HEADERS = frozenset([
     'numeric', 'ostream', 'ostream.h', 'parsestream.h', 'pfstream.h',
     'PlotFile.h', 'procbuf.h', 'pthread_alloc.h', 'rope', 'rope.h',
     'ropeimpl.h', 'SFile.h', 'slist', 'slist.h', 'stack.h', 'stdexcept',
-    'stdiostream.h', 'streambuf.h', 'stream.h', 'strfile.h', 'string',
-    'strstream', 'strstream.h', 'tempbuf.h', 'tree.h', 'typeinfo', 'valarray',
+    'stdiostream.h', 'streambuf', 'streambuf.h', 'stream.h', 'strfile.h',
+    'string', 'strstream', 'strstream.h', 'tempbuf.h', 'tree.h', 'typeinfo',
+    'valarray',
     ])
 
 
@@ -278,6 +295,34 @@ for op, inv_replacement in [('==', 'NE'), ('!=', 'EQ'),
   _CHECK_REPLACEMENT['EXPECT_FALSE_M'][op] = 'EXPECT_%s_M' % inv_replacement
   _CHECK_REPLACEMENT['ASSERT_FALSE_M'][op] = 'ASSERT_%s_M' % inv_replacement
 
+# Alternative tokens and their replacements.  For full list, see section 2.5
+# Alternative tokens [lex.digraph] in the C++ standard.
+#
+# Digraphs (such as '%:') are not included here since it's a mess to
+# match those on a word boundary.
+_ALT_TOKEN_REPLACEMENT = {
+    'and': '&&',
+    'bitor': '|',
+    'or': '||',
+    'xor': '^',
+    'compl': '~',
+    'bitand': '&',
+    'and_eq': '&=',
+    'or_eq': '|=',
+    'xor_eq': '^=',
+    'not': '!',
+    'not_eq': '!='
+    }
+
+# Compile regular expression that matches all the above keywords.  The "[ =()]"
+# bit is meant to avoid matching these keywords outside of boolean expressions.
+#
+# False positives include C-style multi-line comments (http://go/nsiut )
+# and multi-line strings (http://go/beujw ), but those have always been
+# troublesome for cpplint.
+_ALT_TOKEN_REPLACEMENT_PATTERN = re.compile(
+    r'[ =()](' + ('|'.join(_ALT_TOKEN_REPLACEMENT.keys())) + r')(?=[ (]|$)')
+
 
 # These constants define types of headers for use with
 # _IncludeState.CheckNextIncludeOrder().
@@ -287,6 +332,17 @@ _LIKELY_MY_HEADER = 3
 _POSSIBLE_MY_HEADER = 4
 _OTHER_HEADER = 5
 
+# These constants define the current inline assembly state
+_NO_ASM = 0       # Outside of inline assembly block
+_INSIDE_ASM = 1   # Inside inline assembly block
+_END_ASM = 2      # Last line of inline assembly block
+_BLOCK_ASM = 3    # The whole block is an inline assembly block
+
+# Match start of assembly blocks
+_MATCH_ASM = re.compile(r'^\s*(?:asm|_asm|__asm|__asm__)'
+                        r'(?:\s+(volatile|__volatile__))?'
+                        r'\s*[{(]')
+
 
 _regexp_compile_cache = {}
 
@@ -297,6 +353,10 @@ _RE_SUPPRESSION = re.compile(r'\bNOLINT\b(\([^)]*\))?')
 # on which those errors are expected and should be suppressed.
 _error_suppressions = {}
 
+# The root directory used for deriving header guard CPP variable.
+# This is set by --root flag.
+_root = None
+
 def ParseNolintSuppressions(filename, raw_line, linenum, error):
   """Updates the global list of error-suppressions.
 
@@ -649,7 +709,6 @@ class _FunctionState(object):
     if not self.in_a_function:
       return
     # END android-added
-
     if Match(r'T(EST|est)', self.current_function):
       base_trigger = self._TEST_TRIGGER
     else:
@@ -736,7 +795,6 @@ class FileInfo:
         return "art/" + fullname[len(prefix) + 1:]
         # END android-changed
 
-
     # Don't know what to do; header guard warnings may be wrong...
     return fullname
 
@@ -825,6 +883,9 @@ def Error(filename, linenum, category, confidence, message):
     if _cpplint_state.output_format == 'vs7':
       sys.stderr.write('%s(%s):  %s  [%s] [%d]\n' % (
           filename, linenum, message, category, confidence))
+    elif _cpplint_state.output_format == 'eclipse':
+      sys.stderr.write('%s:%s: warning: %s  [%s] [%d]\n' % (
+          filename, linenum, message, category, confidence))
     else:
       sys.stderr.write('%s:%s:  %s  [%s] [%d]\n' % (
           filename, linenum, message, category, confidence))
@@ -934,7 +995,7 @@ class CleansedLines(object):
 
   1) elided member contains lines without strings and comments,
   2) lines member contains lines without comments, and
-  3) raw member contains all the lines without processing.
+  3) raw_lines member contains all the lines without processing.
   All these three members are of <type 'list'>, and of the same length.
   """
 
@@ -974,6 +1035,29 @@ class CleansedLines(object):
     return elided
 
 
+def FindEndOfExpressionInLine(line, startpos, depth, startchar, endchar):
+  """Find the position just after the matching endchar.
+
+  Args:
+    line: a CleansedLines line.
+    startpos: start searching at this position.
+    depth: nesting level at startpos.
+    startchar: expression opening character.
+    endchar: expression closing character.
+
+  Returns:
+    Index just after endchar.
+  """
+  for i in xrange(startpos, len(line)):
+    if line[i] == startchar:
+      depth += 1
+    elif line[i] == endchar:
+      depth -= 1
+      if depth == 0:
+        return i + 1
+  return -1
+
+
 def CloseExpression(clean_lines, linenum, pos):
   """If input points to ( or { or [, finds the position that closes it.
 
@@ -1000,18 +1084,23 @@ def CloseExpression(clean_lines, linenum, pos):
   if startchar == '[': endchar = ']'
   if startchar == '{': endchar = '}'
 
-  num_open = line.count(startchar) - line.count(endchar)
-  while linenum < clean_lines.NumLines() and num_open > 0:
+  # Check first line
+  end_pos = FindEndOfExpressionInLine(line, pos, 0, startchar, endchar)
+  if end_pos > -1:
+    return (line, linenum, end_pos)
+  tail = line[pos:]
+  num_open = tail.count(startchar) - tail.count(endchar)
+  while linenum < clean_lines.NumLines() - 1:
     linenum += 1
     line = clean_lines.elided[linenum]
-    num_open += line.count(startchar) - line.count(endchar)
-  # OK, now find the endchar that actually got us back to even
-  endpos = len(line)
-  while num_open >= 0:
-    endpos = line.rfind(')', 0, endpos)
-    num_open -= 1                 # chopped off another )
-  return (line, linenum, endpos + 1)
+    delta = line.count(startchar) - line.count(endchar)
+    if num_open + delta <= 0:
+      return (line, linenum,
+              FindEndOfExpressionInLine(line, 0, num_open, startchar, endchar))
+    num_open += delta
 
+  # Did not find endchar before end of file, give up
+  return (line, clean_lines.NumLines(), -1)
 
 def CheckForCopyright(filename, lines, error):
   """Logs an error if no Copyright message appears at the top of the file."""
@@ -1041,8 +1130,13 @@ def GetHeaderGuardCPPVariable(filename):
   # Restores original filename in case that cpplint is invoked from Emacs's
   # flymake.
   filename = re.sub(r'_flymake\.h$', '.h', filename)
+  filename = re.sub(r'/\.flymake/([^/]*)$', r'/\1', filename)
+
   fileinfo = FileInfo(filename)
-  return re.sub(r'[-./\s]', '_', fileinfo.RepositoryName()).upper() + '_'
+  file_path_from_root = fileinfo.RepositoryName()
+  if _root:
+    file_path_from_root = re.sub('^' + _root + os.sep, '', file_path_from_root)
+  return re.sub(r'[-./\s]', '_', file_path_from_root).upper() + '_'
 
 
 def CheckForHeaderGuard(filename, lines, error):
@@ -1206,6 +1300,7 @@ threading_list = (
     ('gmtime(', 'gmtime_r('),
     ('localtime(', 'localtime_r('),
     ('rand(', 'rand_r('),
+    ('readdir(', 'readdir_r('),
     ('strtok(', 'strtok_r('),
     ('ttyname(', 'ttyname_r('),
     )
@@ -1266,17 +1361,55 @@ def CheckInvalidIncrement(filename, clean_lines, linenum, error):
           'Changing pointer instead of value (or unused value of operator*).')
 
 
-class _ClassInfo(object):
+class _BlockInfo(object):
+  """Stores information about a generic block of code."""
+
+  def __init__(self, seen_open_brace):
+    self.seen_open_brace = seen_open_brace
+    self.open_parentheses = 0
+    self.inline_asm = _NO_ASM
+
+  def CheckBegin(self, filename, clean_lines, linenum, error):
+    """Run checks that applies to text up to the opening brace.
+
+    This is mostly for checking the text after the class identifier
+    and the "{", usually where the base class is specified.  For other
+    blocks, there isn't much to check, so we always pass.
+
+    Args:
+      filename: The name of the current file.
+      clean_lines: A CleansedLines instance containing the file.
+      linenum: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+    pass
+
+  def CheckEnd(self, filename, clean_lines, linenum, error):
+    """Run checks that applies to text after the closing brace.
+
+    This is mostly used for checking end of namespace comments.
+
+    Args:
+      filename: The name of the current file.
+      clean_lines: A CleansedLines instance containing the file.
+      linenum: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+    pass
+
+
+class _ClassInfo(_BlockInfo):
   """Stores information about a class."""
 
-  def __init__(self, name, clean_lines, linenum):
+  def __init__(self, name, class_or_struct, clean_lines, linenum):
+    _BlockInfo.__init__(self, False)
     self.name = name
-    self.linenum = linenum
-    self.seen_open_brace = False
+    self.starting_linenum = linenum
     self.is_derived = False
-    self.virtual_method_linenumber = None
-    self.has_virtual_destructor = False
-    self.brace_depth = 0
+    if class_or_struct == 'struct':
+      self.access = 'public'
+    else:
+      self.access = 'private'
 
     # Try to find the end of the class.  This will be confused by things like:
     #   class A {
@@ -1286,26 +1419,324 @@ class _ClassInfo(object):
     self.last_line = 0
     depth = 0
     for i in range(linenum, clean_lines.NumLines()):
-      line = clean_lines.lines[i]
+      line = clean_lines.elided[i]
       depth += line.count('{') - line.count('}')
       if not depth:
         self.last_line = i
         break
 
+  def CheckBegin(self, filename, clean_lines, linenum, error):
+    # Look for a bare ':'
+    if Search('(^|[^:]):($|[^:])', clean_lines.elided[linenum]):
+      self.is_derived = True
 
-class _ClassState(object):
-  """Holds the current state of the parse relating to class declarations.
 
-  It maintains a stack of _ClassInfos representing the parser's guess
-  as to the current nesting of class declarations. The innermost class
-  is at the top (back) of the stack. Typically, the stack will either
-  be empty or have exactly one entry.
-  """
+class _NamespaceInfo(_BlockInfo):
+  """Stores information about a namespace."""
+
+  def __init__(self, name, linenum):
+    _BlockInfo.__init__(self, False)
+    self.name = name or ''
+    self.starting_linenum = linenum
+
+  def CheckEnd(self, filename, clean_lines, linenum, error):
+    """Check end of namespace comments."""
+    line = clean_lines.raw_lines[linenum]
+
+    # Check how many lines is enclosed in this namespace.  Don't issue
+    # warning for missing namespace comments if there aren't enough
+    # lines.  However, do apply checks if there is already an end of
+    # namespace comment and it's incorrect.
+    #
+    # TODO(unknown): We always want to check end of namespace comments
+    # if a namespace is large, but sometimes we also want to apply the
+    # check if a short namespace contained nontrivial things (something
+    # other than forward declarations).  There is currently no logic on
+    # deciding what these nontrivial things are, so this check is
+    # triggered by namespace size only, which works most of the time.
+    if (linenum - self.starting_linenum < 10
+        and not Match(r'};*\s*(//|/\*).*\bnamespace\b', line)):
+      return
+
+    # Look for matching comment at end of namespace.
+    #
+    # Note that we accept C style "/* */" comments for terminating
+    # namespaces, so that code that terminate namespaces inside
+    # preprocessor macros can be cpplint clean.  Example: http://go/nxpiz
+    #
+    # We also accept stuff like "// end of namespace <name>." with the
+    # period at the end.
+    #
+    # Besides these, we don't accept anything else, otherwise we might
+    # get false negatives when existing comment is a substring of the
+    # expected namespace.  Example: http://go/ldkdc, http://cl/23548205
+    if self.name:
+      # Named namespace
+      if not Match((r'};*\s*(//|/\*).*\bnamespace\s+' + re.escape(self.name) +
+                    r'[\*/\.\\\s]*$'),
+                   line):
+        error(filename, linenum, 'readability/namespace', 5,
+              'Namespace should be terminated with "// namespace %s"' %
+              self.name)
+    else:
+      # Anonymous namespace
+      if not Match(r'};*\s*(//|/\*).*\bnamespace[\*/\.\\\s]*$', line):
+        error(filename, linenum, 'readability/namespace', 5,
+              'Namespace should be terminated with "// namespace"')
+
+
+class _PreprocessorInfo(object):
+  """Stores checkpoints of nesting stacks when #if/#else is seen."""
+
+  def __init__(self, stack_before_if):
+    # The entire nesting stack before #if
+    self.stack_before_if = stack_before_if
+
+    # The entire nesting stack up to #else
+    self.stack_before_else = []
+
+    # Whether we have already seen #else or #elif
+    self.seen_else = False
+
+
+class _NestingState(object):
+  """Holds states related to parsing braces."""
 
   def __init__(self):
-    self.classinfo_stack = []
+    # Stack for tracking all braces.  An object is pushed whenever we
+    # see a "{", and popped when we see a "}".  Only 3 types of
+    # objects are possible:
+    # - _ClassInfo: a class or struct.
+    # - _NamespaceInfo: a namespace.
+    # - _BlockInfo: some other type of block.
+    self.stack = []
+
+    # Stack of _PreprocessorInfo objects.
+    self.pp_stack = []
+
+  def SeenOpenBrace(self):
+    """Check if we have seen the opening brace for the innermost block.
+
+    Returns:
+      True if we have seen the opening brace, False if the innermost
+      block is still expecting an opening brace.
+    """
+    return (not self.stack) or self.stack[-1].seen_open_brace
+
+  def InNamespaceBody(self):
+    """Check if we are currently one level inside a namespace body.
+
+    Returns:
+      True if top of the stack is a namespace block, False otherwise.
+    """
+    return self.stack and isinstance(self.stack[-1], _NamespaceInfo)
+
+  def UpdatePreprocessor(self, line):
+    """Update preprocessor stack.
+
+    We need to handle preprocessors due to classes like this:
+      #ifdef SWIG
+      struct ResultDetailsPageElementExtensionPoint {
+      #else
+      struct ResultDetailsPageElementExtensionPoint : public Extension {
+      #endif
+    (see http://go/qwddn for original example)
+
+    We make the following assumptions (good enough for most files):
+    - Preprocessor condition evaluates to true from #if up to first
+      #else/#elif/#endif.
+
+    - Preprocessor condition evaluates to false from #else/#elif up
+      to #endif.  We still perform lint checks on these lines, but
+      these do not affect nesting stack.
+
+    Args:
+      line: current line to check.
+    """
+    if Match(r'^\s*#\s*(if|ifdef|ifndef)\b', line):
+      # Beginning of #if block, save the nesting stack here.  The saved
+      # stack will allow us to restore the parsing state in the #else case.
+      self.pp_stack.append(_PreprocessorInfo(copy.deepcopy(self.stack)))
+    elif Match(r'^\s*#\s*(else|elif)\b', line):
+      # Beginning of #else block
+      if self.pp_stack:
+        if not self.pp_stack[-1].seen_else:
+          # This is the first #else or #elif block.  Remember the
+          # whole nesting stack up to this point.  This is what we
+          # keep after the #endif.
+          self.pp_stack[-1].seen_else = True
+          self.pp_stack[-1].stack_before_else = copy.deepcopy(self.stack)
+
+        # Restore the stack to how it was before the #if
+        self.stack = copy.deepcopy(self.pp_stack[-1].stack_before_if)
+      else:
+        # TODO(unknown): unexpected #else, issue warning?
+        pass
+    elif Match(r'^\s*#\s*endif\b', line):
+      # End of #if or #else blocks.
+      if self.pp_stack:
+        # If we saw an #else, we will need to restore the nesting
+        # stack to its former state before the #else, otherwise we
+        # will just continue from where we left off.
+        if self.pp_stack[-1].seen_else:
+          # Here we can just use a shallow copy since we are the last
+          # reference to it.
+          self.stack = self.pp_stack[-1].stack_before_else
+        # Drop the corresponding #if
+        self.pp_stack.pop()
+      else:
+        # TODO(unknown): unexpected #endif, issue warning?
+        pass
 
-  def CheckFinished(self, filename, error):
+  def Update(self, filename, clean_lines, linenum, error):
+    """Update nesting state with current line.
+
+    Args:
+      filename: The name of the current file.
+      clean_lines: A CleansedLines instance containing the file.
+      linenum: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+    line = clean_lines.elided[linenum]
+
+    # Update pp_stack first
+    self.UpdatePreprocessor(line)
+
+    # Count parentheses.  This is to avoid adding struct arguments to
+    # the nesting stack.
+    if self.stack:
+      inner_block = self.stack[-1]
+      depth_change = line.count('(') - line.count(')')
+      inner_block.open_parentheses += depth_change
+
+      # Also check if we are starting or ending an inline assembly block.
+      if inner_block.inline_asm in (_NO_ASM, _END_ASM):
+        if (depth_change != 0 and
+            inner_block.open_parentheses == 1 and
+            _MATCH_ASM.match(line)):
+          # Enter assembly block
+          inner_block.inline_asm = _INSIDE_ASM
+        else:
+          # Not entering assembly block.  If previous line was _END_ASM,
+          # we will now shift to _NO_ASM state.
+          inner_block.inline_asm = _NO_ASM
+      elif (inner_block.inline_asm == _INSIDE_ASM and
+            inner_block.open_parentheses == 0):
+        # Exit assembly block
+        inner_block.inline_asm = _END_ASM
+
+    # Consume namespace declaration at the beginning of the line.  Do
+    # this in a loop so that we catch same line declarations like this:
+    #   namespace proto2 { namespace bridge { class MessageSet; } }
+    while True:
+      # Match start of namespace.  The "\b\s*" below catches namespace
+      # declarations even if it weren't followed by a whitespace, this
+      # is so that we don't confuse our namespace checker.  The
+      # missing spaces will be flagged by CheckSpacing.
+      namespace_decl_match = Match(r'^\s*namespace\b\s*([:\w]+)?(.*)$', line)
+      if not namespace_decl_match:
+        break
+
+      new_namespace = _NamespaceInfo(namespace_decl_match.group(1), linenum)
+      self.stack.append(new_namespace)
+
+      line = namespace_decl_match.group(2)
+      if line.find('{') != -1:
+        new_namespace.seen_open_brace = True
+        line = line[line.find('{') + 1:]
+
+    # Look for a class declaration in whatever is left of the line
+    # after parsing namespaces.  The regexp accounts for decorated classes
+    # such as in:
+    #   class LOCKABLE API Object {
+    #   };
+    #
+    # Templates with class arguments may confuse the parser, for example:
+    #   template <class T
+    #             class Comparator = less<T>,
+    #             class Vector = vector<T> >
+    #   class HeapQueue {
+    #
+    # Because this parser has no nesting state about templates, by the
+    # time it saw "class Comparator", it may think that it's a new class.
+    # Nested templates have a similar problem:
+    #   template <
+    #       typename ExportedType,
+    #       typename TupleType,
+    #       template <typename, typename> class ImplTemplate>
+    #
+    # To avoid these cases, we ignore classes that are followed by '=' or '>'
+    class_decl_match = Match(
+        r'\s*(template\s*<[\w\s<>,:]*>\s*)?'
+        '(class|struct)\s+([A-Z_]+\s+)*(\w+(?:::\w+)*)'
+        '(([^=>]|<[^<>]*>)*)$', line)
+    if (class_decl_match and
+        (not self.stack or self.stack[-1].open_parentheses == 0)):
+      self.stack.append(_ClassInfo(
+          class_decl_match.group(4), class_decl_match.group(2),
+          clean_lines, linenum))
+      line = class_decl_match.group(5)
+
+    # If we have not yet seen the opening brace for the innermost block,
+    # run checks here.
+    if not self.SeenOpenBrace():
+      self.stack[-1].CheckBegin(filename, clean_lines, linenum, error)
+
+    # Update access control if we are inside a class/struct
+    if self.stack and isinstance(self.stack[-1], _ClassInfo):
+      access_match = Match(r'\s*(public|private|protected)\s*:', line)
+      if access_match:
+        self.stack[-1].access = access_match.group(1)
+
+    # Consume braces or semicolons from what's left of the line
+    while True:
+      # Match first brace, semicolon, or closed parenthesis.
+      matched = Match(r'^[^{;)}]*([{;)}])(.*)$', line)
+      if not matched:
+        break
+
+      token = matched.group(1)
+      if token == '{':
+        # If namespace or class hasn't seen a opening brace yet, mark
+        # namespace/class head as complete.  Push a new block onto the
+        # stack otherwise.
+        if not self.SeenOpenBrace():
+          self.stack[-1].seen_open_brace = True
+        else:
+          self.stack.append(_BlockInfo(True))
+          if _MATCH_ASM.match(line):
+            self.stack[-1].inline_asm = _BLOCK_ASM
+      elif token == ';' or token == ')':
+        # If we haven't seen an opening brace yet, but we already saw
+        # a semicolon, this is probably a forward declaration.  Pop
+        # the stack for these.
+        #
+        # Similarly, if we haven't seen an opening brace yet, but we
+        # already saw a closing parenthesis, then these are probably
+        # function arguments with extra "class" or "struct" keywords.
+        # Also pop these stack for these.
+        if not self.SeenOpenBrace():
+          self.stack.pop()
+      else:  # token == '}'
+        # Perform end of block checks and pop the stack.
+        if self.stack:
+          self.stack[-1].CheckEnd(filename, clean_lines, linenum, error)
+          self.stack.pop()
+      line = matched.group(2)
+
+  def InnermostClass(self):
+    """Get class info on the top of the stack.
+
+    Returns:
+      A _ClassInfo object if we are inside a class, or None otherwise.
+    """
+    for i in range(len(self.stack), 0, -1):
+      classinfo = self.stack[i - 1]
+      if isinstance(classinfo, _ClassInfo):
+        return classinfo
+    return None
+
+  def CheckClassFinished(self, filename, error):
     """Checks that all classes have been completely parsed.
 
     Call this when all lines in a file have been processed.
@@ -1313,17 +1744,18 @@ class _ClassState(object):
       filename: The name of the current file.
       error: The function to call with any errors found.
     """
-    if self.classinfo_stack:
-      # Note: This test can result in false positives if #ifdef constructs
-      # get in the way of brace matching. See the testBuildClass test in
-      # cpplint_unittest.py for an example of this.
-      error(filename, self.classinfo_stack[0].linenum, 'build/class', 5,
-            'Failed to find complete declaration of class %s' %
-            self.classinfo_stack[0].name)
+    # Note: This test can result in false positives if #ifdef constructs
+    # get in the way of brace matching. See the testBuildClass test in
+    # cpplint_unittest.py for an example of this.
+    for obj in self.stack:
+      if isinstance(obj, _ClassInfo):
+        error(filename, obj.starting_linenum, 'build/class', 5,
+              'Failed to find complete declaration of class %s' %
+              obj.name)
 
 
 def CheckForNonStandardConstructs(filename, clean_lines, linenum,
-                                  class_state, error):
+                                  nesting_state, error):
   """Logs an error if we see certain non-ANSI constructs ignored by gcc-2.
 
   Complain about several constructs which gcc-2 accepts, but which are
@@ -1336,8 +1768,6 @@ def CheckForNonStandardConstructs(filename, clean_lines, linenum,
   - text after #endif is not allowed.
   - invalid inner-style forward declaration.
   - >? and <? operators, and their >?= and <?= cousins.
-  - classes with virtual methods need virtual destructors (compiler warning
-    available, but not turned on yet.)
 
   Additionally, check for constructor/destructor style violations and reference
   members, as it is very convenient to do so while checking for
@@ -1347,8 +1777,8 @@ def CheckForNonStandardConstructs(filename, clean_lines, linenum,
     filename: The name of the current file.
     clean_lines: A CleansedLines instance containing the file.
     linenum: The number of the line to check.
-    class_state: A _ClassState instance which maintains information about
-                 the current stack of nested class declarations being parsed.
+    nesting_state: A _NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
     error: A callable to which errors are reported, which takes 4 arguments:
            filename, line number, error level, and message
   """
@@ -1377,7 +1807,7 @@ def CheckForNonStandardConstructs(filename, clean_lines, linenum,
   if Search(r'\b(const|volatile|void|char|short|int|long'
             r'|float|double|signed|unsigned'
             r'|schar|u?int8|u?int16|u?int32|u?int64)'
-            r'\s+(auto|register|static|extern|typedef)\b',
+            r'\s+(register|static|extern|typedef)\b',
             line):
     error(filename, linenum, 'build/storage_class', 5,
           'Storage class (static, extern, typedef, etc) should be first.')
@@ -1407,45 +1837,13 @@ def CheckForNonStandardConstructs(filename, clean_lines, linenum,
           'const string& members are dangerous. It is much better to use '
           'alternatives, such as pointers or simple constants.')
 
-  # Track class entry and exit, and attempt to find cases within the
-  # class declaration that don't meet the C++ style
-  # guidelines. Tracking is very dependent on the code matching Google
-  # style guidelines, but it seems to perform well enough in testing
-  # to be a worthwhile addition to the checks.
-  classinfo_stack = class_state.classinfo_stack
-  # Look for a class declaration. The regexp accounts for decorated classes
-  # such as in:
-  # class LOCKABLE API Object {
-  # };
-  class_decl_match = Match(
-      r'\s*(template\s*<[\w\s<>,:]*>\s*)?'
-      '(class|struct)\s+([A-Z_]+\s+)*(\w+(::\w+)*)', line)
-  if class_decl_match:
-    classinfo_stack.append(_ClassInfo(
-        class_decl_match.group(4), clean_lines, linenum))
-
-  # Everything else in this function uses the top of the stack if it's
-  # not empty.
-  if not classinfo_stack:
+  # Everything else in this function operates on class declarations.
+  # Return early if the top of the nesting stack is not a class, or if
+  # the class head is not completed yet.
+  classinfo = nesting_state.InnermostClass()
+  if not classinfo or not classinfo.seen_open_brace:
     return
 
-  classinfo = classinfo_stack[-1]
-
-  # If the opening brace hasn't been seen look for it and also
-  # parent class declarations.
-  if not classinfo.seen_open_brace:
-    # If the line has a ';' in it, assume it's a forward declaration or
-    # a single-line class declaration, which we won't process.
-    if line.find(';') != -1:
-      classinfo_stack.pop()
-      return
-    classinfo.seen_open_brace = (line.find('{') != -1)
-    # Look for a bare ':'
-    if Search('(^|[^:]):($|[^:])', line):
-      classinfo.is_derived = True
-    if not classinfo.seen_open_brace:
-      return  # Everything else in this function is for after open brace
-
   # The class may have been declared with namespace or classname qualifiers.
   # The constructor and destructor will not have those qualifiers.
   base_classname = classinfo.name.split('::')[-1]
@@ -1462,35 +1860,6 @@ def CheckForNonStandardConstructs(filename, clean_lines, linenum,
     error(filename, linenum, 'runtime/explicit', 5,
           'Single-argument constructors should be marked explicit.')
 
-  # Look for methods declared virtual.
-  if Search(r'\bvirtual\b', line):
-    classinfo.virtual_method_linenumber = linenum
-    # Only look for a destructor declaration on the same line. It would
-    # be extremely unlikely for the destructor declaration to occupy
-    # more than one line.
-    if Search(r'~%s\s*\(' % base_classname, line):
-      classinfo.has_virtual_destructor = True
-
-  # Look for class end.
-  brace_depth = classinfo.brace_depth
-  brace_depth = brace_depth + line.count('{') - line.count('}')
-  if brace_depth <= 0:
-    classinfo = classinfo_stack.pop()
-    # Try to detect missing virtual destructor declarations.
-    # For now, only warn if a non-derived class with virtual methods lacks
-    # a virtual destructor. This is to make it less likely that people will
-    # declare derived virtual destructors without declaring the base
-    # destructor virtual.
-    if ((classinfo.virtual_method_linenumber is not None) and
-        (not classinfo.has_virtual_destructor) and
-        (not classinfo.is_derived)):  # Only warn for base classes
-      error(filename, classinfo.linenum, 'runtime/virtual', 4,
-            'The class %s probably needs a virtual destructor due to '
-            'having virtual method(s), one declared at line %d.'
-            % (classinfo.name, classinfo.virtual_method_linenumber))
-  else:
-    classinfo.brace_depth = brace_depth
-
 
 def CheckSpacingForFunctionCall(filename, line, linenum, error):
   """Checks for the correctness of various spacing around function calls.
@@ -1545,7 +1914,8 @@ def CheckSpacingForFunctionCall(filename, line, linenum, error):
       error(filename, linenum, 'whitespace/parens', 2,
             'Extra space after (')
     if (Search(r'\w\s+\(', fncall) and
-        not Search(r'#\s*define|typedef', fncall)):
+        not Search(r'#\s*define|typedef', fncall) and
+        not Search(r'\w\s+\((\w+::)?\*\w+\)\(', fncall)):
       error(filename, linenum, 'whitespace/parens', 4,
             'Extra space before ( in function call')
     # If the ) is followed only by a newline or a { + newline, assume it's
@@ -1678,8 +2048,165 @@ def CheckComment(comment, filename, linenum, error):
       error(filename, linenum, 'whitespace/todo', 2,
             'TODO(my_username) should be followed by a space')
 
+def CheckAccess(filename, clean_lines, linenum, nesting_state, error):
+  """Checks for improper use of DISALLOW* macros.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    nesting_state: A _NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]  # get rid of comments and strings
+
+  matched = Match((r'\s*(DISALLOW_COPY_AND_ASSIGN|'
+                   r'DISALLOW_EVIL_CONSTRUCTORS|'
+                   r'DISALLOW_IMPLICIT_CONSTRUCTORS)'), line)
+  if not matched:
+    return
+  if nesting_state.stack and isinstance(nesting_state.stack[-1], _ClassInfo):
+    if nesting_state.stack[-1].access != 'private':
+      error(filename, linenum, 'readability/constructors', 3,
+            '%s must be in the private: section' % matched.group(1))
+
+  else:
+    # Found DISALLOW* macro outside a class declaration, or perhaps it
+    # was used inside a function when it should have been part of the
+    # class declaration.  We could issue a warning here, but it
+    # probably resulted in a compiler error already.
+    pass
+
+
+def FindNextMatchingAngleBracket(clean_lines, linenum, init_suffix):
+  """Find the corresponding > to close a template.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: Current line number.
+    init_suffix: Remainder of the current line after the initial <.
+
+  Returns:
+    True if a matching bracket exists.
+  """
+  line = init_suffix
+  nesting_stack = ['<']
+  while True:
+    # Find the next operator that can tell us whether < is used as an
+    # opening bracket or as a less-than operator.  We only want to
+    # warn on the latter case.
+    #
+    # We could also check all other operators and terminate the search
+    # early, e.g. if we got something like this "a<b+c", the "<" is
+    # most likely a less-than operator, but then we will get false
+    # positives for default arguments (e.g. http://go/prccd) and
+    # other template expressions (e.g. http://go/oxcjq).
+    match = Search(r'^[^<>(),;\[\]]*([<>(),;\[\]])(.*)$', line)
+    if match:
+      # Found an operator, update nesting stack
+      operator = match.group(1)
+      line = match.group(2)
+
+      if nesting_stack[-1] == '<':
+        # Expecting closing angle bracket
+        if operator in ('<', '(', '['):
+          nesting_stack.append(operator)
+        elif operator == '>':
+          nesting_stack.pop()
+          if not nesting_stack:
+            # Found matching angle bracket
+            return True
+        elif operator == ',':
+          # Got a comma after a bracket, this is most likely a template
+          # argument.  We have not seen a closing angle bracket yet, but
+          # it's probably a few lines later if we look for it, so just
+          # return early here.
+          return True
+        else:
+          # Got some other operator.
+          return False
+
+      else:
+        # Expecting closing parenthesis or closing bracket
+        if operator in ('<', '(', '['):
+          nesting_stack.append(operator)
+        elif operator in (')', ']'):
+          # We don't bother checking for matching () or [].  If we got
+          # something like (] or [), it would have been a syntax error.
+          nesting_stack.pop()
+
+    else:
+      # Scan the next line
+      linenum += 1
+      if linenum >= len(clean_lines.elided):
+        break
+      line = clean_lines.elided[linenum]
+
+  # Exhausted all remaining lines and still no matching angle bracket.
+  # Most likely the input was incomplete, otherwise we should have
+  # seen a semicolon and returned early.
+  return True
+
+
+def FindPreviousMatchingAngleBracket(clean_lines, linenum, init_prefix):
+  """Find the corresponding < that started a template.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: Current line number.
+    init_prefix: Part of the current line before the initial >.
+
+  Returns:
+    True if a matching bracket exists.
+  """
+  line = init_prefix
+  nesting_stack = ['>']
+  while True:
+    # Find the previous operator
+    match = Search(r'^(.*)([<>(),;\[\]])[^<>(),;\[\]]*$', line)
+    if match:
+      # Found an operator, update nesting stack
+      operator = match.group(2)
+      line = match.group(1)
+
+      if nesting_stack[-1] == '>':
+        # Expecting opening angle bracket
+        if operator in ('>', ')', ']'):
+          nesting_stack.append(operator)
+        elif operator == '<':
+          nesting_stack.pop()
+          if not nesting_stack:
+            # Found matching angle bracket
+            return True
+        elif operator == ',':
+          # Got a comma before a bracket, this is most likely a
+          # template argument.  The opening angle bracket is probably
+          # there if we look for it, so just return early here.
+          return True
+        else:
+          # Got some other operator.
+          return False
+
+      else:
+        # Expecting opening parenthesis or opening bracket
+        if operator in ('>', ')', ']'):
+          nesting_stack.append(operator)
+        elif operator in ('(', '['):
+          nesting_stack.pop()
 
-def CheckSpacing(filename, clean_lines, linenum, error):
+    else:
+      # Scan the previous line
+      linenum -= 1
+      if linenum < 0:
+        break
+      line = clean_lines.elided[linenum]
+
+  # Exhausted all earlier lines and still no matching angle bracket.
+  return False
+
+
+def CheckSpacing(filename, clean_lines, linenum, nesting_state, error):
   """Checks for the correctness of various spacing issues in the code.
 
   Things we check for: spaces around operators, spaces after
@@ -1692,6 +2219,8 @@ def CheckSpacing(filename, clean_lines, linenum, error):
     filename: The name of the current file.
     clean_lines: A CleansedLines instance containing the file.
     linenum: The number of the line to check.
+    nesting_state: A _NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
     error: The function to call with any errors found.
   """
 
@@ -1701,7 +2230,16 @@ def CheckSpacing(filename, clean_lines, linenum, error):
   # Before nixing comments, check if the line is blank for no good
   # reason.  This includes the first line after a block is opened, and
   # blank lines at the end of a function (ie, right before a line like '}'
-  if IsBlankLine(line):
+  #
+  # Skip all the blank line checks if we are immediately inside a
+  # namespace body.  In other words, don't issue blank line warnings
+  # for this block:
+  #   namespace {
+  #
+  #   }
+  #
+  # A warning about missing end of namespace comments will be issued instead.
+  if IsBlankLine(line) and not nesting_state.InNamespaceBody():
     elided = clean_lines.elided
     prev_line = elided[linenum - 1]
     prevbrace = prev_line.rfind('{')
@@ -1709,8 +2247,7 @@ def CheckSpacing(filename, clean_lines, linenum, error):
     #                both start with alnums and are indented the same amount.
     #                This ignores whitespace at the start of a namespace block
     #                because those are not usually indented.
-    if (prevbrace != -1 and prev_line[prevbrace:].find('}') == -1
-        and prev_line[:prevbrace].find('namespace') == -1):
+    if prevbrace != -1 and prev_line[prevbrace:].find('}') == -1:
       # OK, we have a blank line at the start of a code block.  Before we
       # complain, we check if it is an exception to the rule: The previous
       # non-empty line has the parameters of a function header that are indented
@@ -1742,12 +2279,7 @@ def CheckSpacing(filename, clean_lines, linenum, error):
       if not exception:
         error(filename, linenum, 'whitespace/blank_line', 2,
               'Blank line at the start of a code block.  Is this needed?')
-    # This doesn't ignore whitespace at the end of a namespace block
-    # because that is too hard without pairing open/close braces;
-    # however, a special exception is made for namespace closing
-    # brackets which have a comment containing "namespace".
-    #
-    # Also, ignore blank lines at the end of a block in a long if-else
+    # Ignore blank lines at the end of a block in a long if-else
     # chain, like this:
     #   if (condition1) {
     #     // Something followed by a blank line
@@ -1759,7 +2291,6 @@ def CheckSpacing(filename, clean_lines, linenum, error):
       next_line = raw[linenum + 1]
       if (next_line
           and Match(r'\s*}', next_line)
-          and next_line.find('namespace') == -1
           and next_line.find('} else ') == -1):
         error(filename, linenum, 'whitespace/blank_line', 3,
               'Blank line at the end of a code block.  Is this needed?')
@@ -1820,26 +2351,59 @@ def CheckSpacing(filename, clean_lines, linenum, error):
   # though, so we punt on this one for now.  TODO.
 
   # You should always have whitespace around binary operators.
-  # Alas, we can't test < or > because they're legitimately used sans spaces
-  # (a->b, vector<int> a).  The only time we can tell is a < with no >, and
-  # only if it's not template params list spilling into the next line.
+  #
+  # Check <= and >= first to avoid false positives with < and >, then
+  # check non-include lines for spacing around < and >.
   match = Search(r'[^<>=!\s](==|!=|<=|>=)[^<>=!\s]', line)
-  if not match:
-    # Note that while it seems that the '<[^<]*' term in the following
-    # regexp could be simplified to '<.*', which would indeed match
-    # the same class of strings, the [^<] means that searching for the
-    # regexp takes linear rather than quadratic time.
-    if not Search(r'<[^<]*,\s*$', line):  # template params spill
-      match = Search(r'[^<>=!\s](<)[^<>=!\s]([^>]|->)*$', line)
   if match:
     error(filename, linenum, 'whitespace/operators', 3,
           'Missing spaces around %s' % match.group(1))
-  # We allow no-spaces around << and >> when used like this: 10<<20, but
+  # We allow no-spaces around << when used like this: 10<<20, but
   # not otherwise (particularly, not when used as streams)
-  match = Search(r'[^0-9\s](<<|>>)[^0-9\s]', line)
+  match = Search(r'(\S)(?:L|UL|ULL|l|ul|ull)?<<(\S)', line)
+  if match and not (match.group(1).isdigit() and match.group(2).isdigit()):
+    error(filename, linenum, 'whitespace/operators', 3,
+          'Missing spaces around <<')
+  elif not Match(r'#.*include', line):
+    # Avoid false positives on ->
+    reduced_line = line.replace('->', '')
+
+    # Look for < that is not surrounded by spaces.  This is only
+    # triggered if both sides are missing spaces, even though
+    # technically should should flag if at least one side is missing a
+    # space.  This is done to avoid some false positives with shifts.
+    match = Search(r'[^\s<]<([^\s=<].*)', reduced_line)
+    if (match and
+        not FindNextMatchingAngleBracket(clean_lines, linenum, match.group(1))):
+      error(filename, linenum, 'whitespace/operators', 3,
+            'Missing spaces around <')
+
+    # Look for > that is not surrounded by spaces.  Similar to the
+    # above, we only trigger if both sides are missing spaces to avoid
+    # false positives with shifts.
+    match = Search(r'^(.*[^\s>])>[^\s=>]', reduced_line)
+    if (match and
+        not FindPreviousMatchingAngleBracket(clean_lines, linenum,
+                                             match.group(1))):
+      error(filename, linenum, 'whitespace/operators', 3,
+            'Missing spaces around >')
+
+  # We allow no-spaces around >> for almost anything.  This is because
+  # C++11 allows ">>" to close nested templates, which accounts for
+  # most cases when ">>" is not followed by a space.
+  #
+  # We still warn on ">>" followed by alpha character, because that is
+  # likely due to ">>" being used for right shifts, e.g.:
+  #   value >> alpha
+  #
+  # When ">>" is used to close templates, the alphanumeric letter that
+  # follows would be part of an identifier, and there should still be
+  # a space separating the template type and the identifier.
+  #   type<type<type>> alpha
+  match = Search(r'>>[a-zA-Z_]', line)
   if match:
     error(filename, linenum, 'whitespace/operators', 3,
-          'Missing spaces around %s' % match.group(1))
+          'Missing spaces around >>')
 
   # There shouldn't be space around unary operators
   match = Search(r'(!\s|~\s|[\s]--[\s;]|[\s]\+\+[\s;])', line)
@@ -1913,16 +2477,23 @@ def CheckSpacing(filename, clean_lines, linenum, error):
   # the semicolon there.
   if Search(r':\s*;\s*$', line):
     error(filename, linenum, 'whitespace/semicolon', 5,
-          'Semicolon defining empty statement. Use { } instead.')
+          'Semicolon defining empty statement. Use {} instead.')
   elif Search(r'^\s*;\s*$', line):
     error(filename, linenum, 'whitespace/semicolon', 5,
           'Line contains only semicolon. If this should be an empty statement, '
-          'use { } instead.')
+          'use {} instead.')
   elif (Search(r'\s+;\s*$', line) and
         not Search(r'\bfor\b', line)):
     error(filename, linenum, 'whitespace/semicolon', 5,
           'Extra space before last semicolon. If this should be an empty '
-          'statement, use { } instead.')
+          'statement, use {} instead.')
+
+  # In range-based for, we wanted spaces before and after the colon, but
+  # not around "::" tokens that might appear.
+  if (Search('for *\(.*[^:]:[^: ]', line) or
+      Search('for *\(.*[^: ]:[^:]', line)):
+    error(filename, linenum, 'whitespace/forcolon', 2,
+          'Missing space around colon in range-based for loop')
 
 
 def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error):
@@ -1948,8 +2519,8 @@ def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error):
   #
   # If we didn't find the end of the class, last_line would be zero,
   # and the check will be skipped by the first condition.
-  if (class_info.last_line - class_info.linenum <= 24 or
-      linenum <= class_info.linenum):
+  if (class_info.last_line - class_info.starting_linenum <= 24 or
+      linenum <= class_info.starting_linenum):
     return
 
   matched = Match(r'\s*(public|protected|private):', clean_lines.lines[linenum])
@@ -1960,15 +2531,18 @@ def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error):
     #  - We are at the beginning of the class.
     #  - We are forward-declaring an inner class that is semantically
     #    private, but needed to be public for implementation reasons.
+    # Also ignores cases where the previous line ends with a backslash as can be
+    # common when defining classes in C macros.
     prev_line = clean_lines.lines[linenum - 1]
     if (not IsBlankLine(prev_line) and
-        not Search(r'\b(class|struct)\b', prev_line)):
+        not Search(r'\b(class|struct)\b', prev_line) and
+        not Search(r'\\$', prev_line)):
       # Try a bit harder to find the beginning of the class.  This is to
       # account for multi-line base-specifier lists, e.g.:
       #   class Derived
       #       : public Base {
-      end_class_head = class_info.linenum
-      for i in range(class_info.linenum, linenum):
+      end_class_head = class_info.starting_linenum
+      for i in range(class_info.starting_linenum, linenum):
         if Search(r'\{\s*$', clean_lines.lines[i]):
           end_class_head = i
           break
@@ -2018,9 +2592,11 @@ def CheckBraces(filename, clean_lines, linenum, error):
     # which is commonly used to control the lifetime of
     # stack-allocated variables.  We don't detect this perfectly: we
     # just don't complain if the last non-whitespace character on the
-    # previous non-blank line is ';', ':', '{', or '}'.
+    # previous non-blank line is ';', ':', '{', or '}', or if the previous
+    # line starts a preprocessor block.
     prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
-    if not Search(r'[;:}{]\s*$', prevline):
+    if (not Search(r'[;:}{]\s*$', prevline) and
+        not Match(r'\s*#', prevline)):
       error(filename, linenum, 'whitespace/braces', 4,
             '{ should almost always be at the end of the previous line')
 
@@ -2074,6 +2650,33 @@ def CheckBraces(filename, clean_lines, linenum, error):
           "You don't need a ; after a }")
 
 
+def CheckEmptyLoopBody(filename, clean_lines, linenum, error):
+  """Loop for empty loop body with only a single semicolon.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+
+  # Search for loop keywords at the beginning of the line.  Because only
+  # whitespaces are allowed before the keywords, this will also ignore most
+  # do-while-loops, since those lines should start with closing brace.
+  line = clean_lines.elided[linenum]
+  if Match(r'\s*(for|while)\s*\(', line):
+    # Find the end of the conditional expression
+    (end_line, end_linenum, end_pos) = CloseExpression(
+        clean_lines, linenum, line.find('('))
+
+    # Output warning if what follows the condition expression is a semicolon.
+    # No warning for all other cases, including whitespace or newline, since we
+    # have a separate check for semicolons preceded by whitespace.
+    if end_pos >= 0 and Match(r';', end_line[end_pos:]):
+      error(filename, end_linenum, 'whitespace/empty_loop_body', 5,
+            'Empty loop bodies should use {} or continue')
+
+
 def ReplaceableCheck(operator, macro, line):
   """Determine whether a basic CHECK can be replaced with a more specific one.
 
@@ -2142,6 +2745,38 @@ def CheckCheck(filename, clean_lines, linenum, error):
       break
 
 
+def CheckAltTokens(filename, clean_lines, linenum, error):
+  """Check alternative keywords being used in boolean expressions.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # Avoid preprocessor lines
+  if Match(r'^\s*#', line):
+    return
+
+  # Last ditch effort to avoid multi-line comments.  This will not help
+  # if the comment started before the current line or ended after the
+  # current line, but it catches most of the false positives.  At least,
+  # it provides a way to workaround this warning for people who use
+  # multi-line comments in preprocessor macros.
+  #
+  # TODO(unknown): remove this once cpplint has better support for
+  # multi-line comments.
+  if line.find('/*') >= 0 or line.find('*/') >= 0:
+    return
+
+  for match in _ALT_TOKEN_REPLACEMENT_PATTERN.finditer(line):
+    error(filename, linenum, 'readability/alt_tokens', 2,
+          'Use operator %s instead of %s' % (
+              _ALT_TOKEN_REPLACEMENT[match.group(1)], match.group(1)))
+
+
 def GetLineWidth(line):
   """Determines the width of the line in column positions.
 
@@ -2164,7 +2799,7 @@ def GetLineWidth(line):
     return len(line)
 
 
-def CheckStyle(filename, clean_lines, linenum, file_extension, class_state,
+def CheckStyle(filename, clean_lines, linenum, file_extension, nesting_state,
                error):
   """Checks rules from the 'C++ style rules' section of cppguide.html.
 
@@ -2177,6 +2812,8 @@ def CheckStyle(filename, clean_lines, linenum, file_extension, class_state,
     clean_lines: A CleansedLines instance containing the file.
     linenum: The number of the line to check.
     file_extension: The extension (without the dot) of the filename.
+    nesting_state: A _NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
     error: The function to call with any errors found.
   """
 
@@ -2258,16 +2895,19 @@ def CheckStyle(filename, clean_lines, linenum, file_extension, class_state,
       not ((cleansed_line.find('case ') != -1 or
             cleansed_line.find('default:') != -1) and
            cleansed_line.find('break;') != -1)):
-    error(filename, linenum, 'whitespace/newline', 4,
+    error(filename, linenum, 'whitespace/newline', 0,
           'More than one command on the same line')
 
   # Some more style checks
   CheckBraces(filename, clean_lines, linenum, error)
-  CheckSpacing(filename, clean_lines, linenum, error)
+  CheckEmptyLoopBody(filename, clean_lines, linenum, error)
+  CheckAccess(filename, clean_lines, linenum, nesting_state, error)
+  CheckSpacing(filename, clean_lines, linenum, nesting_state, error)
   CheckCheck(filename, clean_lines, linenum, error)
-  if class_state and class_state.classinfo_stack:
-    CheckSectionSpacing(filename, clean_lines,
-                        class_state.classinfo_stack[-1], linenum, error)
+  CheckAltTokens(filename, clean_lines, linenum, error)
+  classinfo = nesting_state.InnermostClass()
+  if classinfo:
+    CheckSectionSpacing(filename, clean_lines, classinfo, linenum, error)
 
 
 _RE_PATTERN_INCLUDE_NEW_STYLE = re.compile(r'#include +"[^/]+\.h"')
@@ -2564,9 +3204,11 @@ def CheckLanguage(filename, clean_lines, linenum, file_extension, include_state,
                      fnline))):
 
     # We allow non-const references in a few standard places, like functions
-    # called "swap()" or iostream operators like "<<" or ">>".
+    # called "swap()" or iostream operators like "<<" or ">>". We also filter
+    # out for loops, which lint otherwise mistakenly thinks are functions.
     if not Search(
-        r'(swap|Swap|operator[<>][<>])\s*\(\s*(?:[\w:]|<.*>)+\s*&',
+        r'(for|swap|Swap|operator[<>][<>])\s*\(\s*'
+        r'(?:(?:typename\s*)?[\w:]|<.*>)+\s*&',
         fnline):
       error(filename, linenum, 'runtime/references', 2,
             'Is this a non-const reference? '
@@ -2578,7 +3220,7 @@ def CheckLanguage(filename, clean_lines, linenum, file_extension, include_state,
   # probably a member operator declaration or default constructor.
   match = Search(
       r'(\bnew\s+)?\b'  # Grab 'new' operator, if it's there
-      r'(int|float|double|bool|char|u?int(8|16|32|64)_t)\([^)]', line) # TODO(enh): upstream change to handle all stdint types.
+      r'(int|float|double|bool|char|int32|uint32|int64|uint64)\([^)]', line)
   if match:
     # gMock methods are defined using some variant of MOCK_METHODx(name, type)
     # where type may be float(), int(string), etc.  Without context they are
@@ -2588,14 +3230,23 @@ def CheckLanguage(filename, clean_lines, linenum, file_extension, include_state,
     if (match.group(1) is None and  # If new operator, then this isn't a cast
         not (Match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(', line) or
              Match(r'^\s*MockCallback<.*>', line))):
-      error(filename, linenum, 'readability/casting', 4,
-            'Using deprecated casting style.  '
-            'Use static_cast<%s>(...) instead' %
-            match.group(2))
+      # Try a bit harder to catch gmock lines: the only place where
+      # something looks like an old-style cast is where we declare the
+      # return type of the mocked method, and the only time when we
+      # are missing context is if MOCK_METHOD was split across
+      # multiple lines (for example http://go/hrfhr ), so we only need
+      # to check the previous line for MOCK_METHOD.
+      if (linenum == 0 or
+          not Match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(\S+,\s*$',
+                    clean_lines.elided[linenum - 1])):
+        error(filename, linenum, 'readability/casting', 4,
+              'Using deprecated casting style.  '
+              'Use static_cast<%s>(...) instead' %
+              match.group(2))
 
   CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum],
                   'static_cast',
-                  r'\((int|float|double|bool|char|u?int(8|16|32|64))\)', error) # TODO(enh): upstream change to handle all stdint types.
+                  r'\((int|float|double|bool|char|u?int(16|32|64))\)', error)
 
   # This doesn't catch all cases. Consider (const char * const)"hello".
   #
@@ -2713,7 +3364,7 @@ def CheckLanguage(filename, clean_lines, linenum, file_extension, include_state,
   printf_args = _GetTextInside(line, r'(?i)\b(string)?printf\s*\(')
   if printf_args:
     match = Match(r'([\w.\->()]+)$', printf_args)
-    if match:
+    if match and match.group(1) != '__VA_ARGS__':
       function_name = re.search(r'\b((?:string)?printf)\s*\(',
                                 line, re.I).group(1)
       error(filename, linenum, 'runtime/printf', 4,
@@ -2834,6 +3485,11 @@ def CheckCStyleCast(filename, linenum, line, raw_line, cast_type, pattern,
           'Using sizeof(type).  Use sizeof(varname) instead if possible')
     return True
 
+  # operator++(int) and operator--(int)
+  if (line[0:match.start(1) - 1].endswith(' operator++') or
+      line[0:match.start(1) - 1].endswith(' operator--')):
+    return False
+
   remainder = line[match.end(0):]
 
   # The close paren is for function pointers as arguments to a function.
@@ -3122,13 +3778,13 @@ def CheckMakePairUsesDeduction(filename, clean_lines, linenum, error):
   if match:
     error(filename, linenum, 'build/explicit_make_pair',
           4,  # 4 = high confidence
-          'Omit template arguments from make_pair OR use pair directly OR'
-          ' if appropriate, construct a pair directly')
+          'For C++11-compatibility, omit template arguments from make_pair'
+          ' OR use pair directly OR if appropriate, construct a pair directly')
 
 
-def ProcessLine(filename, file_extension,
-                clean_lines, line, include_state, function_state,
-                class_state, error, extra_check_functions=[]):
+def ProcessLine(filename, file_extension, clean_lines, line,
+                include_state, function_state, nesting_state, error,
+                extra_check_functions=[]):
   """Processes a single line in the file.
 
   Args:
@@ -3139,8 +3795,8 @@ def ProcessLine(filename, file_extension,
     line: Number of line being processed.
     include_state: An _IncludeState instance in which the headers are inserted.
     function_state: A _FunctionState instance which counts function lines, etc.
-    class_state: A _ClassState instance which maintains information about
-                 the current stack of nested class declarations being parsed.
+    nesting_state: A _NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
     error: A callable to which errors are reported, which takes 4 arguments:
            filename, line number, error level, and message
     extra_check_functions: An array of additional check functions that will be
@@ -3149,13 +3805,16 @@ def ProcessLine(filename, file_extension,
   """
   raw_lines = clean_lines.raw_lines
   ParseNolintSuppressions(filename, raw_lines[line], line, error)
+  nesting_state.Update(filename, clean_lines, line, error)
+  if nesting_state.stack and nesting_state.stack[-1].inline_asm != _NO_ASM:
+    return
   CheckForFunctionLengths(filename, clean_lines, line, function_state, error)
   CheckForMultilineCommentsAndStrings(filename, clean_lines, line, error)
-  CheckStyle(filename, clean_lines, line, file_extension, class_state, error)
+  CheckStyle(filename, clean_lines, line, file_extension, nesting_state, error)
   CheckLanguage(filename, clean_lines, line, file_extension, include_state,
                 error)
   CheckForNonStandardConstructs(filename, clean_lines, line,
-                                class_state, error)
+                                nesting_state, error)
   CheckPosixThreading(filename, clean_lines, line, error)
   CheckInvalidIncrement(filename, clean_lines, line, error)
   CheckMakePairUsesDeduction(filename, clean_lines, line, error)
@@ -3182,7 +3841,7 @@ def ProcessFileData(filename, file_extension, lines, error,
 
   include_state = _IncludeState()
   function_state = _FunctionState()
-  class_state = _ClassState()
+  nesting_state = _NestingState()
 
   ResetNolintSuppressions()
 
@@ -3195,9 +3854,9 @@ def ProcessFileData(filename, file_extension, lines, error,
   clean_lines = CleansedLines(lines)
   for line in xrange(clean_lines.NumLines()):
     ProcessLine(filename, file_extension, clean_lines, line,
-                include_state, function_state, class_state, error,
+                include_state, function_state, nesting_state, error,
                 extra_check_functions)
-  class_state.CheckFinished(filename, error)
+  nesting_state.CheckClassFinished(filename, error)
 
   CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error)
 
@@ -3312,7 +3971,8 @@ def ParseArguments(args):
     (opts, filenames) = getopt.getopt(args, '', ['help', 'output=', 'verbose=',
                                                  'stdout', # TODO(enh): added --stdout
                                                  'counting=',
-                                                 'filter='])
+                                                 'filter=',
+                                                 'root='])
   except getopt.GetoptError:
     PrintUsage('Invalid arguments.')
 
@@ -3328,8 +3988,8 @@ def ParseArguments(args):
     elif opt == '--stdout': # TODO(enh): added --stdout
       output_stream = sys.stdout # TODO(enh): added --stdout
     elif opt == '--output':
-      if not val in ('emacs', 'vs7'):
-        PrintUsage('The only allowed output formats are emacs and vs7.')
+      if not val in ('emacs', 'vs7', 'eclipse'):
+        PrintUsage('The only allowed output formats are emacs, vs7 and eclipse.')
       output_format = val
     elif opt == '--verbose':
       verbosity = int(val)
@@ -3341,6 +4001,9 @@ def ParseArguments(args):
       if val not in ('total', 'toplevel', 'detailed'):
         PrintUsage('Valid counting options are total, toplevel, and detailed')
       counting_style = val
+    elif opt == '--root':
+      global _root
+      _root = val
 
   if not filenames:
     PrintUsage('No files were specified.')
@@ -3349,7 +4012,6 @@ def ParseArguments(args):
   _SetVerboseLevel(verbosity)
   _SetFilters(filters)
   _SetCountingStyle(counting_style)
-
   sys.stderr = output_stream # TODO(enh): added --stdout
 
   return filenames
-- 
cgit v1.2.3-59-g8ed1b


From 90af14d2743614e3e1453984b14258a6f145501d Mon Sep 17 00:00:00 2001
From: Dragos Sbirlea <dragoss@google.com>
Date: Thu, 15 Aug 2013 17:50:16 -0700
Subject: Get SEA fibonacci running in interpreter mode.

Android.mk: Added new file to build.
compile_driver.cc: Moved SE_IR usage test in the block
         protected by bool compile, which is enabled by
         adding a sepatate test in IsCnadidateForCompilation.
class_linker.cc: Added check in NeedsInterpreter to enable SEA_IR.
art_method-inl.h: DIsabled check in SEA_IR mode.
method_verifier.cc: Added check for SEA_IR mode.
method_verifier.h: Chenged IsCandidateForCompilation signature to
         allow testing the function name (for SEA_IR selective
         compilation).
dot_gen.h: Updated ART file API usage to altest version.
sea_ir/frontend.cc: Passing function symbol name to CompileMethod.
instruction_Nodes.h: Added  accessor for method index for
         InvokeStatic IR node.
sea.cc: Added additional IR SignatureNode for function calls (extra
         Method parameter). Fixed UnnamedConstant constant value.
sea.h: Passing function_name to GenerateLLVM.
type_inference_visitor.cc: Aded type for first (placeholder) method
         parameter.

Change-Id: I295858ea0761a3dffb36f35748d8b93d4919d6a9
---
 compiler/Android.mk                             |   1 +
 compiler/driver/compiler_driver.cc              |  15 ++--
 compiler/sea_ir/code_gen/code_gen.cc            |  58 +++++++------
 compiler/sea_ir/code_gen/code_gen.h             |  16 +++-
 compiler/sea_ir/code_gen/code_gen_data.cc       | 104 ++++++++++++++++++++++++
 compiler/sea_ir/debug/dot_gen.h                 |   4 +-
 compiler/sea_ir/frontend.cc                     |  25 ++----
 compiler/sea_ir/ir/instruction_nodes.h          |  12 ++-
 compiler/sea_ir/ir/sea.cc                       |  42 ++++++----
 compiler/sea_ir/ir/sea.h                        |  17 ++--
 compiler/sea_ir/types/type_inference.cc         |  15 +++-
 compiler/sea_ir/types/type_inference.h          |   9 +-
 compiler/sea_ir/types/type_inference_visitor.cc |   6 ++
 compiler/sea_ir/types/type_inference_visitor.h  |   2 +-
 runtime/class_linker.cc                         |   7 ++
 runtime/mirror/art_method-inl.h                 |   5 ++
 runtime/verifier/method_verifier.cc             |  10 ++-
 runtime/verifier/method_verifier.h              |   2 +-
 18 files changed, 254 insertions(+), 96 deletions(-)
 create mode 100644 compiler/sea_ir/code_gen/code_gen_data.cc

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/Android.mk b/compiler/Android.mk
index 5caf688d29..c18462abe5 100644
--- a/compiler/Android.mk
+++ b/compiler/Android.mk
@@ -97,6 +97,7 @@ LIBART_COMPILER_SRC_FILES += \
 	sea_ir/ir/instruction_tools.cc \
 	sea_ir/ir/sea.cc \
 	sea_ir/code_gen/code_gen.cc \
+	sea_ir/code_gen/code_gen_data.cc \
 	sea_ir/types/type_inference.cc \
 	sea_ir/types/type_inference_visitor.cc \
 	sea_ir/debug/dot_gen.cc
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 4659f7b7eb..9d583fd132 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -314,7 +314,7 @@ extern "C" art::CompiledMethod* ArtCompileDEX(art::CompilerDriver& compiler,
                                               uint32_t method_idx,
                                               jobject class_loader,
                                               const art::DexFile& dex_file);
-
+#ifdef ART_SEA_IR_MODE
 extern "C" art::CompiledMethod* SeaIrCompileMethod(art::CompilerDriver& compiler,
                                                    const art::DexFile::CodeItem* code_item,
                                                    uint32_t access_flags,
@@ -323,7 +323,7 @@ extern "C" art::CompiledMethod* SeaIrCompileMethod(art::CompilerDriver& compiler
                                                    uint32_t method_idx,
                                                    jobject class_loader,
                                                    const art::DexFile& dex_file);
-
+#endif
 extern "C" art::CompiledMethod* ArtLLVMJniCompileMethod(art::CompilerDriver& driver,
                                                         uint32_t access_flags, uint32_t method_idx,
                                                         const art::DexFile& dex_file);
@@ -2230,16 +2230,15 @@ void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t
     CHECK(compiled_method != NULL);
   } else if ((access_flags & kAccAbstract) != 0) {
   } else {
-    bool compile = verifier::MethodVerifier::IsCandidateForCompilation(code_item, access_flags);
-#ifdef ART_SEA_IR_MODE
-    bool use_sea = Runtime::Current()->IsSeaIRMode();
-    use_sea = use_sea && (std::string::npos != PrettyMethod(method_idx, dex_file).find("fibonacci"));
-    if (use_sea) compile = true;
-#endif
+    MethodReference method_ref(&dex_file, method_idx);
+    bool compile = verifier::MethodVerifier::IsCandidateForCompilation(method_ref, access_flags);
 
     if (compile) {
       CompilerFn compiler = compiler_;
 #ifdef ART_SEA_IR_MODE
+      bool use_sea = Runtime::Current()->IsSeaIRMode();
+      use_sea = use_sea &&
+          (std::string::npos != PrettyMethod(method_idx, dex_file).find("fibonacci"));
       if (use_sea) {
         compiler = sea_ir_compiler_;
         LOG(INFO) << "Using SEA IR to compile..." << std::endl;
diff --git a/compiler/sea_ir/code_gen/code_gen.cc b/compiler/sea_ir/code_gen/code_gen.cc
index cb150e58fa..8d79c41545 100644
--- a/compiler/sea_ir/code_gen/code_gen.cc
+++ b/compiler/sea_ir/code_gen/code_gen.cc
@@ -15,8 +15,14 @@
  */
 
 #include <llvm/Support/raw_ostream.h>
+
+#include "base/logging.h"
+#include "utils.h"
+
 #include "sea_ir/ir/sea.h"
 #include "sea_ir/code_gen/code_gen.h"
+#include "sea_ir/types/type_inference.h"
+#include "sea_ir/types/types.h"
 
 namespace sea_ir {
 
@@ -50,34 +56,36 @@ void CodeGenPassVisitor::Initialize(SeaGraph* graph) {
   }
 }
 
-void CodeGenPostpassVisitor::Visit(SeaGraph* graph) {
-  std::vector<SignatureNode*>* parameters = graph->GetParameterNodes();
-  std::cout << "=== SeaGraph ===" << parameters->size() << std::endl;
-}
-void CodeGenVisitor::Visit(SeaGraph* graph) {
-  std::vector<SignatureNode*>* parameters = graph->GetParameterNodes();
-  std::cout << "=== SeaGraph ===" << parameters->size() << std::endl;
-}
+void CodeGenPostpassVisitor::Visit(SeaGraph* graph) { }
+void CodeGenVisitor::Visit(SeaGraph* graph) { }
 void CodeGenPrepassVisitor::Visit(SeaGraph* graph) {
   std::vector<SignatureNode*>* parameters = graph->GetParameterNodes();
-  std::cout << "=== SeaGraph ===" << parameters->size() << std::endl;
-  // TODO: Extract correct types from dex for params and return value.
+  // TODO: It may be better to extract correct types from dex
+  //       instead than from type inference.
   DCHECK(parameters != NULL);
-  std::vector<llvm::Type*> parameter_types(parameters->size(),
-      llvm::Type::getInt32Ty(*llvm_data_->context_));
-  // Build llvm function name.
-  std::string function_name = art::StringPrintf(
-      "class=%d_method=%d", graph->class_def_idx_, graph->method_idx_);
+  std::vector<llvm::Type*> parameter_types;
+  for (std::vector<SignatureNode*>::const_iterator param_iterator = parameters->begin();
+      param_iterator!= parameters->end(); param_iterator++) {
+    const Type* param_type = graph->ti_->type_data_.FindTypeOf((*param_iterator)->Id());
+    DCHECK(param_type->Equals(graph->ti_->type_cache_->Integer()))
+      << "Code generation for types other than integer not implemented.";
+    parameter_types.push_back(llvm::Type::getInt32Ty(*llvm_data_->context_));
+  }
 
-  // Build llvm function type and parameters.
+  // TODO: Get correct function return type.
+  const Type* return_type = graph->ti_->type_data_.FindTypeOf(-1);
+  DCHECK(return_type->Equals(graph->ti_->type_cache_->Integer()))
+    << "Code generation for types other than integer not implemented.";
   llvm::FunctionType *function_type = llvm::FunctionType::get(
       llvm::Type::getInt32Ty(*llvm_data_->context_),
       parameter_types, false);
+
   llvm_data_->function_ = llvm::Function::Create(function_type,
-      llvm::Function::ExternalLinkage, function_name, &llvm_data_->module_);
+      llvm::Function::ExternalLinkage, function_name_, &llvm_data_->module_);
   unsigned param_id = 0;
   for (llvm::Function::arg_iterator arg_it = llvm_data_->function_->arg_begin();
       param_id != llvm_data_->function_->arg_size(); ++arg_it, ++param_id) {
+    // TODO: The "+1" is because of the Method parameter on position 0.
     DCHECK(parameters->size() > param_id) << "Insufficient parameters for function signature";
     // Build parameter register name for LLVM IR clarity.
     std::string arg_name = art::StringPrintf("r%d", parameters->at(param_id)->GetResultRegister());
@@ -97,15 +105,12 @@ void CodeGenPrepassVisitor::Visit(SeaGraph* graph) {
 }
 
 void CodeGenPrepassVisitor::Visit(Region* region) {
-  std::cout << " == Region " << region->StringId() << " ==" << std::endl;
   llvm_data_->builder_.SetInsertPoint(llvm_data_->GetBlock(region));
 }
 void CodeGenPostpassVisitor::Visit(Region* region) {
-  std::cout << " == Region " << region->StringId() << " ==" << std::endl;
   llvm_data_->builder_.SetInsertPoint(llvm_data_->GetBlock(region));
 }
 void CodeGenVisitor::Visit(Region* region) {
-  std::cout << " == Region " << region->StringId() << " ==" << std::endl;
   llvm_data_->builder_.SetInsertPoint(llvm_data_->GetBlock(region));
 }
 
@@ -189,13 +194,17 @@ void CodeGenVisitor::Visit(MoveResultInstructionNode* instruction) {
 void CodeGenVisitor::Visit(InvokeStaticInstructionNode* invoke) {
   std::string instr = invoke->GetInstruction()->DumpString(NULL);
   std::cout << "6.Instruction: " << instr << std::endl;
-  // TODO: Build callee llvm function name.
-  std::string function_name = art::StringPrintf("class=%d_method=%d", 0, 1);
+  // TODO: Build callee LLVM function name.
+  std::string symbol = "dex_";
+  symbol += art::MangleForJni(PrettyMethod(invoke->GetCalledMethodIndex(), dex_file_));
+  std::string function_name = "dex_int_00020Main_fibonacci_00028int_00029";
   llvm::Function *callee = llvm_data_->module_.getFunction(function_name);
   // TODO: Add proper checking of the matching between formal and actual signature.
   DCHECK(NULL != callee);
   std::vector<llvm::Value*> parameter_values;
   std::vector<InstructionNode*> parameter_sources = invoke->GetSSAProducers();
+  // TODO: Replace first parameter with Method argument instead of 0.
+  parameter_values.push_back(llvm::ConstantInt::get(*llvm_data_->context_, llvm::APInt(32, 0)));
   for (std::vector<InstructionNode*>::const_iterator cit = parameter_sources.begin();
       cit != parameter_sources.end(); ++cit) {
     llvm::Value* parameter_value = llvm_data_->GetValue((*cit));
@@ -245,7 +254,7 @@ void CodeGenVisitor::Visit(IfEqzInstructionNode* instruction) {
 }
 
 void CodeGenPostpassVisitor::Visit(PhiInstructionNode* phi) {
-  std::cout << "Phi node for: " << phi->GetRegisterNumber() << std::endl;
+  std::cout << "10. Instruction: Phi(" << phi->GetRegisterNumber() << ")" << std::endl;
   Region* r = phi->GetRegion();
   const std::vector<Region*>* predecessors = r->GetPredecessors();
   DCHECK(NULL != predecessors);
@@ -267,17 +276,14 @@ void CodeGenPostpassVisitor::Visit(PhiInstructionNode* phi) {
 }
 
 void CodeGenVisitor::Visit(SignatureNode* signature) {
-  std::cout << "Signature: ;" << "Id:" << signature->StringId() << std::endl;
   DCHECK_EQ(signature->GetDefinitions().size(), 1u) <<
       "Signature nodes must correspond to a single parameter register.";
 }
 void CodeGenPrepassVisitor::Visit(SignatureNode* signature) {
-  std::cout << "Signature: ;" << "Id:" << signature->StringId() << std::endl;
   DCHECK_EQ(signature->GetDefinitions().size(), 1u) <<
       "Signature nodes must correspond to a single parameter register.";
 }
 void CodeGenPostpassVisitor::Visit(SignatureNode* signature) {
-  std::cout << "Signature: ;" << "Id:" << signature->StringId() << std::endl;
   DCHECK_EQ(signature->GetDefinitions().size(), 1u) <<
       "Signature nodes must correspond to a single parameter register.";
 }
diff --git a/compiler/sea_ir/code_gen/code_gen.h b/compiler/sea_ir/code_gen/code_gen.h
index b1bc4dc2da..544e9f0650 100644
--- a/compiler/sea_ir/code_gen/code_gen.h
+++ b/compiler/sea_ir/code_gen/code_gen.h
@@ -17,6 +17,7 @@
 #ifndef ART_COMPILER_SEA_IR_CODE_GEN_CODE_GEN_H_
 #define ART_COMPILER_SEA_IR_CODE_GEN_CODE_GEN_H_
 
+#include "instruction_set.h"
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
@@ -66,6 +67,9 @@ class CodeGenData {
   void AddValue(InstructionNode* instruction, llvm::Value* value) {
       AddValue(instruction->Id(), value);
   }
+  // Generates and returns in @elf the executable code corresponding to the llvm module
+  //
+  std::string GetElf(art::InstructionSet instruction_set);
 
   llvm::LLVMContext* const context_;
   llvm::Module module_;
@@ -97,6 +101,8 @@ class CodeGenPassVisitor: public IRVisitor {
 
 class CodeGenPrepassVisitor: public CodeGenPassVisitor {
  public:
+  explicit CodeGenPrepassVisitor(const std::string& function_name):
+    function_name_(function_name) { }
   void Visit(SeaGraph* graph);
   void Visit(SignatureNode* region);
   void Visit(Region* region);
@@ -113,6 +119,9 @@ class CodeGenPrepassVisitor: public CodeGenPassVisitor {
   void Visit(GotoInstructionNode* instruction) { }
   void Visit(IfEqzInstructionNode* instruction) { }
   void Visit(PhiInstructionNode* region);
+
+ private:
+  std::string function_name_;
 };
 
 class CodeGenPostpassVisitor: public CodeGenPassVisitor {
@@ -137,7 +146,8 @@ class CodeGenPostpassVisitor: public CodeGenPassVisitor {
 
 class CodeGenVisitor: public CodeGenPassVisitor {
  public:
-  explicit CodeGenVisitor(CodeGenData* code_gen_data): CodeGenPassVisitor(code_gen_data) { }
+  explicit CodeGenVisitor(CodeGenData* code_gen_data,
+      const art::DexFile& dex_file): CodeGenPassVisitor(code_gen_data), dex_file_(dex_file) { }
   void Visit(SeaGraph* graph);
   void Visit(SignatureNode* region);
   void Visit(Region* region);
@@ -152,6 +162,10 @@ class CodeGenVisitor: public CodeGenPassVisitor {
   void Visit(GotoInstructionNode* instruction);
   void Visit(IfEqzInstructionNode* instruction);
   void Visit(PhiInstructionNode* region) { }
+
+ private:
+  std::string function_name_;
+  const art::DexFile& dex_file_;
 };
 }  // namespace sea_ir
 #endif  // ART_COMPILER_SEA_IR_CODE_GEN_CODE_GEN_H_
diff --git a/compiler/sea_ir/code_gen/code_gen_data.cc b/compiler/sea_ir/code_gen/code_gen_data.cc
new file mode 100644
index 0000000000..3baaa99f0d
--- /dev/null
+++ b/compiler/sea_ir/code_gen/code_gen_data.cc
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+
+#include <string>
+#include <llvm/PassManager.h>
+#include <llvm/Support/TargetRegistry.h>
+#include <llvm/Support/FormattedStream.h>
+#include <llvm/Target/TargetMachine.h>
+#include <llvm/Transforms/IPO.h>
+#include <llvm/Transforms/IPO/PassManagerBuilder.h>
+
+#include "base/logging.h"
+#include "driver/compiler_driver.h"
+#include "sea_ir/ir/sea.h"
+#include "sea_ir/code_gen/code_gen.h"
+
+
+namespace sea_ir {
+std::string CodeGenData::GetElf(art::InstructionSet instruction_set) {
+  std::string elf;
+  ::llvm::raw_string_ostream out_stream(elf);
+  // Lookup the LLVM target
+  std::string target_triple;
+  std::string target_cpu;
+  std::string target_attr;
+  art::CompilerDriver::InstructionSetToLLVMTarget(instruction_set,
+      target_triple, target_cpu, target_attr);
+
+  std::string errmsg;
+  const ::llvm::Target* target =
+    ::llvm::TargetRegistry::lookupTarget(target_triple, errmsg);
+
+  CHECK(target != NULL) << errmsg;
+
+  // Target options
+  ::llvm::TargetOptions target_options;
+  target_options.FloatABIType = ::llvm::FloatABI::Soft;
+  target_options.NoFramePointerElim = true;
+  target_options.NoFramePointerElimNonLeaf = true;
+  target_options.UseSoftFloat = false;
+  target_options.EnableFastISel = false;
+
+  // Create the ::llvm::TargetMachine
+  ::llvm::OwningPtr< ::llvm::TargetMachine> target_machine(
+    target->createTargetMachine(target_triple, target_cpu, target_attr, target_options,
+                                ::llvm::Reloc::Static, ::llvm::CodeModel::Small,
+                                ::llvm::CodeGenOpt::Aggressive));
+
+  CHECK(target_machine.get() != NULL) << "Failed to create target machine";
+
+  // Add target data
+  const ::llvm::DataLayout* data_layout = target_machine->getDataLayout();
+
+  // PassManager for code generation passes
+  ::llvm::PassManager pm;
+  pm.add(new ::llvm::DataLayout(*data_layout));
+
+  // FunctionPassManager for optimization pass
+  ::llvm::FunctionPassManager fpm(&module_);
+  fpm.add(new ::llvm::DataLayout(*data_layout));
+
+  // Add optimization pass
+  ::llvm::PassManagerBuilder pm_builder;
+  // TODO: Use inliner after we can do IPO.
+  pm_builder.Inliner = NULL;
+  // pm_builder.Inliner = ::llvm::createFunctionInliningPass();
+  // pm_builder.Inliner = ::llvm::createAlwaysInlinerPass();
+  // pm_builder.Inliner = ::llvm::createPartialInliningPass();
+  pm_builder.OptLevel = 3;
+  pm_builder.DisableSimplifyLibCalls = 1;
+  pm_builder.DisableUnitAtATime = 1;
+  pm_builder.populateFunctionPassManager(fpm);
+  pm_builder.populateModulePassManager(pm);
+  pm.add(::llvm::createStripDeadPrototypesPass());
+  // Add passes to emit ELF image
+  {
+    ::llvm::formatted_raw_ostream formatted_os(out_stream, false);
+    // Ask the target to add backend passes as necessary.
+    if (target_machine->addPassesToEmitFile(pm,
+                                            formatted_os,
+                                            ::llvm::TargetMachine::CGFT_ObjectFile,
+                                            true)) {
+      LOG(FATAL) << "Unable to generate ELF for this target";
+    }
+
+    // Run the code generation passes
+    pm.run(module_);
+  }
+  return elf;
+}
+}
diff --git a/compiler/sea_ir/debug/dot_gen.h b/compiler/sea_ir/debug/dot_gen.h
index 05d97fa319..f2ab8c4384 100644
--- a/compiler/sea_ir/debug/dot_gen.h
+++ b/compiler/sea_ir/debug/dot_gen.h
@@ -101,10 +101,10 @@ class DotConversion {
   // Saves to @filename the .dot representation of @graph with the options @options.
   void DumpSea(SeaGraph* graph, std::string filename,
       art::SafeMap<int, const Type*>* types) const {
-    LOG(INFO) << "Starting to write SEA string to file.";
+    LOG(INFO) << "Starting to write SEA string to file " << filename << std::endl;
     DotGenerationVisitor dgv = DotGenerationVisitor(&options_, types);
     graph->Accept(&dgv);
-    art::File* file = art::OS::OpenFileReadWrite(filename.c_str());
+    art::File* file = art::OS::CreateEmptyFile(filename.c_str());
     art::FileOutputStream fos(file);
     std::string graph_as_string = dgv.GetResult();
     graph_as_string += "}";
diff --git a/compiler/sea_ir/frontend.cc b/compiler/sea_ir/frontend.cc
index 421c3a44f1..6efc103f40 100644
--- a/compiler/sea_ir/frontend.cc
+++ b/compiler/sea_ir/frontend.cc
@@ -35,7 +35,6 @@
 #include "sea_ir/types/types.h"
 #include "sea_ir/code_gen/code_gen.h"
 
-
 namespace art {
 
 static CompiledMethod* CompileMethodWithSeaIr(CompilerDriver& compiler,
@@ -48,34 +47,22 @@ static CompiledMethod* CompileMethodWithSeaIr(CompilerDriver& compiler,
                                      , llvm::LlvmCompilationUnit* llvm_compilation_unit
 #endif
 ) {
-  // NOTE: Instead of keeping the convention from the Dalvik frontend.cc
-  //       and silencing the cpplint.py warning, I just corrected the formatting.
-  VLOG(compiler) << "Compiling " << PrettyMethod(method_idx, dex_file) << "...";
+  LOG(INFO) << "Compiling " << PrettyMethod(method_idx, dex_file) << ".";
   sea_ir::SeaGraph* ir_graph = sea_ir::SeaGraph::GetGraph(dex_file);
-  sea_ir::CodeGenData* llvm_data =
-      ir_graph->CompileMethod(code_item, class_def_idx, method_idx, method_access_flags, dex_file);
+  std::string symbol = "dex_" + MangleForJni(PrettyMethod(method_idx, dex_file));
+  sea_ir::CodeGenData* llvm_data = ir_graph->CompileMethod(symbol,
+          code_item, class_def_idx, method_idx, method_access_flags, dex_file);
   sea_ir::DotConversion dc;
   SafeMap<int, const sea_ir::Type*>*  types = ir_graph->ti_->GetTypeMap();
   dc.DumpSea(ir_graph, "/tmp/temp.dot", types);
-  CHECK(0 && "No SEA compiled function exists yet.");
-
   MethodReference mref(&dex_file, method_idx);
-
-  // TODO: Passing the LLVM code as string is ugly and inefficient,
-  //       but it is the way portable did it. I kept it for compatibility,
-  //       but actually it should not happen.
-  std::string llvm_code;
-  ::llvm::raw_string_ostream str_os(llvm_code);
-  ::llvm::WriteBitcodeToFile(&llvm_data->module_, str_os);
-
-  std::string symbol = "dex_";
-  symbol += MangleForJni(PrettyMethod(method_idx, dex_file));
-
+  std::string llvm_code = llvm_data->GetElf(compiler.GetInstructionSet());
   CompiledMethod* compiled_method =  new CompiledMethod(
                               compiler.GetInstructionSet(),
                               llvm_code,
                               *verifier::MethodVerifier::GetDexGcMap(mref),
                               symbol);
+  LOG(INFO) << "Compiled SEA IR method " << PrettyMethod(method_idx, dex_file) << ".";
   return compiled_method;
 }
 
diff --git a/compiler/sea_ir/ir/instruction_nodes.h b/compiler/sea_ir/ir/instruction_nodes.h
index 906a10fe27..63e89e7763 100644
--- a/compiler/sea_ir/ir/instruction_nodes.h
+++ b/compiler/sea_ir/ir/instruction_nodes.h
@@ -56,6 +56,8 @@ class InstructionNode: public SeaNode {
   // essentially creating SSA form.
   void RenameToSSA(int reg_no, InstructionNode* definition) {
     definition_edges_.insert(std::pair<int, InstructionNode*>(reg_no, definition));
+    DCHECK(NULL != definition) << "SSA definition for register " << reg_no
+        << " used in instruction " << Id() << " not found.";
     definition->AddSSAUse(this);
   }
   // Returns the ordered set of Instructions that define the input operands of this instruction.
@@ -179,14 +181,22 @@ class MoveResultInstructionNode: public InstructionNode {
 
 class InvokeStaticInstructionNode: public InstructionNode {
  public:
-  explicit InvokeStaticInstructionNode(const art::Instruction* inst): InstructionNode(inst) { }
+  explicit InvokeStaticInstructionNode(const art::Instruction* inst): InstructionNode(inst),
+    method_index_(inst->VRegB_35c()) { }
   int GetResultRegister() const {
     return RETURN_REGISTER;
   }
+
+  int GetCalledMethodIndex() const {
+    return method_index_;
+  }
   void Accept(IRVisitor* v) {
     v->Visit(this);
     v->Traverse(this);
   }
+
+ private:
+  const uint32_t method_index_;
 };
 
 class AddIntInstructionNode: public InstructionNode {
diff --git a/compiler/sea_ir/ir/sea.cc b/compiler/sea_ir/ir/sea.cc
index 902839dd70..5ccaba6ad9 100644
--- a/compiler/sea_ir/ir/sea.cc
+++ b/compiler/sea_ir/ir/sea.cc
@@ -174,6 +174,21 @@ void SeaGraph::ComputeReachingDefs() {
   DCHECK(!changed) << "Reaching definitions computation did not reach a fixed point.";
 }
 
+void SeaGraph::InsertSignatureNodes(const art::DexFile::CodeItem* code_item, Region* r) {
+  // Insert a fake SignatureNode for the first parameter.
+  // TODO: Provide a register enum value for the fake parameter.
+  SignatureNode* parameter_def_node = new sea_ir::SignatureNode(0, 0);
+  AddParameterNode(parameter_def_node);
+  r->AddChild(parameter_def_node);
+  // Insert SignatureNodes for each Dalvik register parameter.
+  for (unsigned int crt_offset = 0; crt_offset < code_item->ins_size_; crt_offset++) {
+    int register_no = code_item->registers_size_ - crt_offset - 1;
+    int position = crt_offset + 1;
+    SignatureNode* parameter_def_node = new sea_ir::SignatureNode(register_no, position);
+    AddParameterNode(parameter_def_node);
+    r->AddChild(parameter_def_node);
+  }
+}
 
 void SeaGraph::BuildMethodSeaGraph(const art::DexFile::CodeItem* code_item,
     const art::DexFile& dex_file, uint32_t class_def_idx,
@@ -209,15 +224,8 @@ void SeaGraph::BuildMethodSeaGraph(const art::DexFile::CodeItem* code_item,
 
 
   Region* r = GetNewRegion();
-  // Insert one SignatureNode per function argument,
-  // to serve as placeholder definitions in dataflow analysis.
-  for (unsigned int crt_offset = 0; crt_offset < code_item->ins_size_; crt_offset++) {
-    int position = crt_offset;  // TODO: Is this the correct offset in the signature?
-    SignatureNode* parameter_def_node =
-        new sea_ir::SignatureNode(code_item->registers_size_ - 1 - crt_offset, position);
-    AddParameterNode(parameter_def_node);
-    r->AddChild(parameter_def_node);
-  }
+
+  InsertSignatureNodes(code_item, r);
   // Pass: Assign instructions to region nodes and
   //         assign branches their control flow successors.
   i = 0;
@@ -386,23 +394,21 @@ void SeaGraph::RenameAsSSA(Region* crt_region,
   scoped_table->CloseScope();
 }
 
-CodeGenData* SeaGraph::GenerateLLVM() {
+CodeGenData* SeaGraph::GenerateLLVM(const std::string& function_name,
+    const art::DexFile& dex_file) {
   // Pass: Generate LLVM IR.
-  CodeGenPrepassVisitor code_gen_prepass_visitor;
+  CodeGenPrepassVisitor code_gen_prepass_visitor(function_name);
   std::cout << "Generating code..." << std::endl;
-  std::cout << "=== PRE VISITING ===" << std::endl;
   Accept(&code_gen_prepass_visitor);
-  CodeGenVisitor code_gen_visitor(code_gen_prepass_visitor.GetData());
-  std::cout << "=== VISITING ===" << std::endl;
+  CodeGenVisitor code_gen_visitor(code_gen_prepass_visitor.GetData(),  dex_file);
   Accept(&code_gen_visitor);
-  std::cout << "=== POST VISITING ===" << std::endl;
   CodeGenPostpassVisitor code_gen_postpass_visitor(code_gen_visitor.GetData());
   Accept(&code_gen_postpass_visitor);
-  code_gen_postpass_visitor.Write(std::string("my_file.llvm"));
   return code_gen_postpass_visitor.GetData();
 }
 
 CodeGenData* SeaGraph::CompileMethod(
+    const std::string& function_name,
     const art::DexFile::CodeItem* code_item, uint32_t class_def_idx,
     uint32_t method_idx, uint32_t method_access_flags, const art::DexFile& dex_file) {
   // Two passes: Builds the intermediate structure (non-SSA) of the sea-ir for the function.
@@ -422,7 +428,7 @@ CodeGenData* SeaGraph::CompileMethod(
   // Pass: type inference
   ti_->ComputeTypes(this);
   // Pass: Generate LLVM IR.
-  CodeGenData* cgd = GenerateLLVM();
+  CodeGenData* cgd = GenerateLLVM(function_name, dex_file);
   return cgd;
 }
 
@@ -607,7 +613,7 @@ std::vector<InstructionNode*> InstructionNode::Create(const art::Instruction* in
       sea_instructions.push_back(new IfNeInstructionNode(in));
       break;
     case art::Instruction::ADD_INT_LIT8:
-      sea_instructions.push_back(new UnnamedConstInstructionNode(in, in->VRegB_22b()));
+      sea_instructions.push_back(new UnnamedConstInstructionNode(in, in->VRegC_22b()));
       sea_instructions.push_back(new AddIntLitInstructionNode(in));
       break;
     case art::Instruction::MOVE_RESULT:
diff --git a/compiler/sea_ir/ir/sea.h b/compiler/sea_ir/ir/sea.h
index df420ed9c8..92c2043dbd 100644
--- a/compiler/sea_ir/ir/sea.h
+++ b/compiler/sea_ir/ir/sea.h
@@ -50,12 +50,12 @@ class SignatureNode;
 class SignatureNode: public InstructionNode {
  public:
   // Creates a new signature node representing the initial definition of the
-  // register @parameter_register which is the @position-th argument to the method.
-  explicit SignatureNode(unsigned int parameter_register, unsigned int position):
-    InstructionNode(NULL), parameter_register_(parameter_register), position_(position) { }
+  // register @register_no which is the @signature_position-th argument to the method.
+  explicit SignatureNode(unsigned int register_no, unsigned int signature_position):
+    InstructionNode(NULL), register_no_(register_no), position_(signature_position) { }
 
   int GetResultRegister() const {
-    return parameter_register_;
+    return register_no_;
   }
 
   unsigned int GetPositionInSignature() const {
@@ -72,7 +72,7 @@ class SignatureNode: public InstructionNode {
   }
 
  private:
-  const unsigned int parameter_register_;
+  const unsigned int register_no_;
   const unsigned int position_;     // The position of this parameter node is
                                     // in the function parameter list.
 };
@@ -261,7 +261,8 @@ class SeaGraph: IVisitable {
  public:
   static SeaGraph* GetGraph(const art::DexFile&);
 
-  CodeGenData* CompileMethod(const art::DexFile::CodeItem* code_item, uint32_t class_def_idx,
+  CodeGenData* CompileMethod(const std::string& function_name,
+      const art::DexFile::CodeItem* code_item, uint32_t class_def_idx,
       uint32_t method_idx, uint32_t method_access_flags, const art::DexFile& dex_file);
   // Returns all regions corresponding to this SeaGraph.
   std::vector<Region*>* GetRegions() {
@@ -338,7 +339,9 @@ class SeaGraph: IVisitable {
   void RenameAsSSA(Region* node, utils::ScopedHashtable<int, InstructionNode*>* scoped_table);
   // Generate LLVM IR for the method.
   // Precondition: ConvertToSSA().
-  CodeGenData* GenerateLLVM();
+  CodeGenData* GenerateLLVM(const std::string& function_name, const art::DexFile& dex_file);
+  // Inserts one SignatureNode for each argument of the function in
+  void InsertSignatureNodes(const art::DexFile::CodeItem* code_item, Region* r);
 
   static SeaGraph graph_;
   std::vector<Region*> regions_;
diff --git a/compiler/sea_ir/types/type_inference.cc b/compiler/sea_ir/types/type_inference.cc
index 31d7f0f8b6..173198782e 100644
--- a/compiler/sea_ir/types/type_inference.cc
+++ b/compiler/sea_ir/types/type_inference.cc
@@ -68,6 +68,9 @@ const Type* FunctionTypeInfo::GetReturnValueType() {
 std::vector<const Type*> FunctionTypeInfo::GetDeclaredArgumentTypes() {
   art::ScopedObjectAccess soa(art::Thread::Current());
   std::vector<const Type*> argument_types;
+  // TODO: The additional (fake) Method parameter is added on the first position,
+  //       but is represented as integer because we don't support  pointers yet.
+  argument_types.push_back(&(type_cache_->Integer()));
   // Include the "this" pointer.
   size_t cur_arg = 0;
   if (!IsStatic()) {
@@ -82,7 +85,7 @@ std::vector<const Type*> FunctionTypeInfo::GetDeclaredArgumentTypes() {
     }
     cur_arg++;
   }
-
+  // Include the types of the parameters in the Java method signature.
   const art::DexFile::ProtoId& proto_id =
       dex_file_->GetMethodPrototype(dex_file_->GetMethodId(dex_method_idx_));
   art::DexFileParameterIterator iterator(*dex_file_, proto_id);
@@ -149,6 +152,13 @@ void TypeInference::ComputeTypes(SeaGraph* graph) SHARED_LOCKS_REQUIRED(Locks::m
     std::copy(instructions->begin(), instructions->end(), std::back_inserter(worklist));
   }
   TypeInferenceVisitor tiv(graph, &type_data_, type_cache_);
+  // Record return type of the function.
+  graph->Accept(&tiv);
+  const Type* new_type = tiv.GetType();
+  type_data_.SetTypeOf(-1, new_type);   // TODO: Record this info in a way that
+                                        //      does not need magic constants.
+                                        //      Make SeaGraph a SeaNode?
+
   // Sparse (SSA) fixed-point algorithm that processes each instruction in the work-list,
   // adding consumers of instructions whose result changed type back into the work-list.
   // Note: According to [1] list iterators should not be invalidated on insertion,
@@ -159,14 +169,11 @@ void TypeInference::ComputeTypes(SeaGraph* graph) SHARED_LOCKS_REQUIRED(Locks::m
   // TODO: Remove elements as I go.
   for (std::list<InstructionNode*>::const_iterator instruction_it = worklist.begin();
         instruction_it != worklist.end(); instruction_it++) {
-    std::cout << "[TI] Instruction: " << (*instruction_it)->Id() << std::endl;
     (*instruction_it)->Accept(&tiv);
     const Type* old_type = type_data_.FindTypeOf((*instruction_it)->Id());
     const Type* new_type = tiv.GetType();
     bool type_changed = (old_type != new_type);
     if (type_changed) {
-      std::cout << " New type:" << new_type->IsIntegralTypes() << std::endl;
-      std::cout << " Descrip:" << new_type->Dump()<< " on " << (*instruction_it)->Id() << std::endl;
       type_data_.SetTypeOf((*instruction_it)->Id(), new_type);
       // Add SSA consumers of the current instruction to the work-list.
       std::vector<InstructionNode*>* consumers = (*instruction_it)->GetSSAConsumers();
diff --git a/compiler/sea_ir/types/type_inference.h b/compiler/sea_ir/types/type_inference.h
index d951d82071..7a178b29b8 100644
--- a/compiler/sea_ir/types/type_inference.h
+++ b/compiler/sea_ir/types/type_inference.h
@@ -31,8 +31,7 @@ class InstructionNode;
 // precise verification (which is the job of the verifier).
 class TypeInference {
  public:
-  TypeInference() {
-    type_cache_ = new art::verifier::RegTypeCache(false);
+  TypeInference() : type_cache_(new art::verifier::RegTypeCache(false)) {
   }
 
   // Computes the types for the method with SEA IR representation provided by @graph.
@@ -43,10 +42,8 @@ class TypeInference {
   }
   // Returns true if @descriptor corresponds to a primitive type.
   static bool IsPrimitiveDescriptor(char descriptor);
-
- protected:
-  art::verifier::RegTypeCache* type_cache_;
-  TypeData type_data_;
+  TypeData type_data_;    // TODO: Make private, add accessor and not publish a SafeMap above.
+  art::verifier::RegTypeCache* const type_cache_;    // TODO: Make private.
 };
 
 // Stores information about the exact type of  a function.
diff --git a/compiler/sea_ir/types/type_inference_visitor.cc b/compiler/sea_ir/types/type_inference_visitor.cc
index 3da2fc1e2c..139c89b84c 100644
--- a/compiler/sea_ir/types/type_inference_visitor.cc
+++ b/compiler/sea_ir/types/type_inference_visitor.cc
@@ -21,6 +21,12 @@
 
 namespace sea_ir {
 
+void TypeInferenceVisitor::Visit(SeaGraph* graph) {
+  FunctionTypeInfo fti(graph_, type_cache_);
+  const Type* return_type = fti.GetReturnValueType();
+  crt_type_.push_back(return_type);
+}
+
 void TypeInferenceVisitor::Visit(SignatureNode* parameter) {
   FunctionTypeInfo fti(graph_, type_cache_);
   std::vector<const Type*> arguments = fti.GetDeclaredArgumentTypes();
diff --git a/compiler/sea_ir/types/type_inference_visitor.h b/compiler/sea_ir/types/type_inference_visitor.h
index 200b9f0253..469448f015 100644
--- a/compiler/sea_ir/types/type_inference_visitor.h
+++ b/compiler/sea_ir/types/type_inference_visitor.h
@@ -40,7 +40,7 @@ class TypeInferenceVisitor: public IRVisitor {
   }
   // There are no type related actions to be performed on these classes.
   void Initialize(SeaGraph* graph) { }
-  void Visit(SeaGraph* graph) { }
+  void Visit(SeaGraph* graph);
   void Visit(Region* region) { }
 
   void Visit(PhiInstructionNode* instruction);
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 039e7bc0a7..d79066fa2d 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -1614,6 +1614,13 @@ static bool NeedsInterpreter(const mirror::ArtMethod* method, const void* code)
     // No code: need interpreter.
     return true;
   }
+#ifdef ART_SEA_IR_MODE
+  ScopedObjectAccess soa(Thread::Current());
+  if (std::string::npos != PrettyMethod(method).find("fibonacci")) {
+    LOG(INFO) << "Found " << PrettyMethod(method);
+    return false;
+  }
+#endif
   // If interpreter mode is enabled, every method (except native and proxy) must
   // be run with interpreter.
   return Runtime::Current()->GetInstrumentation()->InterpretOnly() &&
diff --git a/runtime/mirror/art_method-inl.h b/runtime/mirror/art_method-inl.h
index 4d8aa6f741..224b2ba0d4 100644
--- a/runtime/mirror/art_method-inl.h
+++ b/runtime/mirror/art_method-inl.h
@@ -49,7 +49,12 @@ inline uint16_t ArtMethod::GetMethodIndex() const {
 }
 
 inline uint32_t ArtMethod::GetDexMethodIndex() const {
+#ifdef ART_SEA_IR_MODE
+  // TODO: Re-add this check for (PORTABLE + SMALL + ) SEA IR when PORTABLE IS fixed!
+  // DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
+#else
   DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
+#endif
   return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_dex_index_), false);
 }
 
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index dcc9f90e86..4d2f36f265 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -1048,7 +1048,7 @@ bool MethodVerifier::VerifyCodeFlow() {
   // Compute information for compiler.
   if (Runtime::Current()->IsCompiler()) {
     MethodReference ref(dex_file_, dex_method_idx_);
-    bool compile = IsCandidateForCompilation(code_item_, method_access_flags_);
+    bool compile = IsCandidateForCompilation(ref, method_access_flags_);
     if (compile) {
       /* Generate a register map and add it to the method. */
       UniquePtr<const std::vector<uint8_t> > map(GenerateGcMap());
@@ -4178,8 +4178,14 @@ std::vector<int32_t> MethodVerifier::DescribeVRegs(uint32_t dex_pc) {
   return result;
 }
 
-bool MethodVerifier::IsCandidateForCompilation(const DexFile::CodeItem* code_item,
+bool MethodVerifier::IsCandidateForCompilation(MethodReference& method_ref,
                                                const uint32_t access_flags) {
+#ifdef ART_SEA_IR_MODE
+    bool use_sea = Runtime::Current()->IsSeaIRMode();
+    use_sea = use_sea && (std::string::npos != PrettyMethod(
+                          method_ref.dex_method_index, *(method_ref.dex_file)).find("fibonacci"));
+    if (use_sea) return true;
+#endif
   // Don't compile class initializers, ever.
   if (((access_flags & kAccConstructor) != 0) && ((access_flags & kAccStatic) != 0)) {
     return false;
diff --git a/runtime/verifier/method_verifier.h b/runtime/verifier/method_verifier.h
index 6171943a6c..241e1d468b 100644
--- a/runtime/verifier/method_verifier.h
+++ b/runtime/verifier/method_verifier.h
@@ -239,7 +239,7 @@ class MethodVerifier {
   // Describe VRegs at the given dex pc.
   std::vector<int32_t> DescribeVRegs(uint32_t dex_pc);
 
-  static bool IsCandidateForCompilation(const DexFile::CodeItem* code_item,
+  static bool IsCandidateForCompilation(MethodReference& method_ref,
                                         const uint32_t access_flags);
 
  private:
-- 
cgit v1.2.3-59-g8ed1b


From 65530499a0169b3b0b153008e2d187c9f4939541 Mon Sep 17 00:00:00 2001
From: Ian Rogers <irogers@google.com>
Date: Mon, 19 Aug 2013 08:54:22 -0700
Subject: Build fix.

A static field was moved from an inner to an outer class in ConcurrentHashMap
leading to a disallowed call.
Also, tidy comments on other java.util.concurrent black listed classes.

Change-Id: Iccd808766dcd5406a5bb49a4b98f570606730250
---
 compiler/driver/compiler_driver.cc | 14 +++++++-------
 runtime/thread.cc                  |  3 ++-
 2 files changed, 9 insertions(+), 8 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index a0a5c0160d..120f232d7a 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -1946,14 +1946,14 @@ static const char* class_initializer_black_list[] = {
   "Ljava/util/Scanner;",  // regex.Pattern.compileImpl.
   "Ljava/util/SimpleTimeZone;",  // Sub-class of TimeZone.
   "Ljava/util/TimeZone;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-  "Ljava/util/concurrent/ConcurrentHashMap$Segment;",  // Calls Runtime.getRuntime().availableProcessors().
-  "Ljava/util/concurrent/ConcurrentSkipListMap;",  // Calls OsConstants.initConstants.
-  "Ljava/util/concurrent/Exchanger;",  // Calls OsConstants.initConstants.
-  "Ljava/util/concurrent/ForkJoinPool;",  // Calls OsConstants.initConstants.
-  "Ljava/util/concurrent/LinkedTransferQueue;",  // Calls OsConstants.initConstants.
-  "Ljava/util/concurrent/Phaser;",  // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/ConcurrentHashMap;",  // Calls Runtime.getRuntime().availableProcessors().
+  "Ljava/util/concurrent/ConcurrentSkipListMap;",  // Calls Random() -> OsConstants.initConstants.
+  "Ljava/util/concurrent/Exchanger;",  // Calls Runtime.getRuntime().availableProcessors().
+  "Ljava/util/concurrent/ForkJoinPool;",  // Makes a thread pool ..-> calls OsConstants.initConstants.
+  "Ljava/util/concurrent/LinkedTransferQueue;",  // Calls Runtime.getRuntime().availableProcessors().
+  "Ljava/util/concurrent/Phaser;",  // Calls Runtime.getRuntime().availableProcessors().
   "Ljava/util/concurrent/ScheduledThreadPoolExecutor;",  // Calls AtomicLong.VMSupportsCS8()
-  "Ljava/util/concurrent/SynchronousQueue;",  // Calls OsConstants.initConstants.
+  "Ljava/util/concurrent/SynchronousQueue;",  // Calls Runtime.getRuntime().availableProcessors().
   "Ljava/util/concurrent/atomic/AtomicLong;",  // Calls AtomicLong.VMSupportsCS8()
   "Ljava/util/logging/LogManager;",  // Calls System.getProperty -> OsConstants.initConstants.
   "Ljava/util/prefs/AbstractPreferences;",  // Calls OsConstants.initConstants.
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 8fc744d263..505e368ec0 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -876,7 +876,8 @@ void Thread::DumpStack(std::ostream& os) const {
   // TODO: we call this code when dying but may not have suspended the thread ourself. The
   //       IsSuspended check is therefore racy with the use for dumping (normally we inhibit
   //       the race with the thread_suspend_count_lock_).
-  bool dump_for_abort = (gAborting > 0);
+  // No point dumping for an abort in debug builds where we'll hit the not suspended check in stack.
+  bool dump_for_abort = (gAborting > 0) && !kIsDebugBuild;
   if (this == Thread::Current() || IsSuspended() || dump_for_abort) {
     // If we're currently in native code, dump that stack before dumping the managed stack.
     if (dump_for_abort || ShouldShowNativeStack(this)) {
-- 
cgit v1.2.3-59-g8ed1b


From f96b21728e8b10e2060ad2d0de46fcacf5974260 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Mon, 19 Aug 2013 18:09:55 -0700
Subject: Tolerate both old and new java.util.concurrent.ConcurrentHashMap

Change-Id: I87397bbb662d7dd8cb0683fc08bd35b401034357
---
 compiler/driver/compiler_driver.cc | 1 +
 1 file changed, 1 insertion(+)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 120f232d7a..7b83e40fb6 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -1947,6 +1947,7 @@ static const char* class_initializer_black_list[] = {
   "Ljava/util/SimpleTimeZone;",  // Sub-class of TimeZone.
   "Ljava/util/TimeZone;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
   "Ljava/util/concurrent/ConcurrentHashMap;",  // Calls Runtime.getRuntime().availableProcessors().
+  "Ljava/util/concurrent/ConcurrentHashMap$Segment;",  // Calls Runtime.getRuntime().availableProcessors().
   "Ljava/util/concurrent/ConcurrentSkipListMap;",  // Calls Random() -> OsConstants.initConstants.
   "Ljava/util/concurrent/Exchanger;",  // Calls Runtime.getRuntime().availableProcessors().
   "Ljava/util/concurrent/ForkJoinPool;",  // Makes a thread pool ..-> calls OsConstants.initConstants.
-- 
cgit v1.2.3-59-g8ed1b


From e6bb3b2ce5a69c31c2adfc7eb2705633b7f966eb Mon Sep 17 00:00:00 2001
From: Ian Rogers <irogers@google.com>
Date: Mon, 19 Aug 2013 21:51:45 -0700
Subject: Reduce AOT initialization.

When compiling apps there is no need to resolve all types in the dex file, just
those declared in the dex file. There's also no need to initialize static
fields if we can only leave the class in a verified state.

Increase use of CompilerDriver::IsImage.
Move timing of dex2oat setup to before Runtime::Create.

On run-test 056 the performance improvement is an order of magnitude, for
ThinkFree dex2oat time is dominated by compilation and this change has no
effect.

Bug 10316099.

Change-Id: Ibdd7caa43284e7448e6a56d810967100ae4a7898
---
 compiler/driver/compiler_driver.cc | 253 +++++++++++++++++++++----------------
 compiler/driver/compiler_driver.h  |   1 +
 dex2oat/dex2oat.cc                 |   2 +-
 runtime/class_linker.cc            |  57 ++++-----
 runtime/class_linker.h             |   2 +-
 5 files changed, 173 insertions(+), 142 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 120f232d7a..38ffa10e45 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -582,10 +582,11 @@ void CompilerDriver::PreCompile(jobject class_loader, const std::vector<const De
 
 bool CompilerDriver::IsImageClass(const char* descriptor) const {
   DCHECK(descriptor != NULL);
-  if (image_classes_.get() == NULL) {
+  if (!IsImage()) {
     return true;
+  } else {
+    return image_classes_->find(descriptor) != image_classes_->end();
   }
-  return image_classes_->find(descriptor) != image_classes_->end();
 }
 
 static void ResolveExceptionsForMethod(MethodHelper* mh,
@@ -655,7 +656,7 @@ static bool RecordImageClassesVisitor(mirror::Class* klass, void* arg)
 // Make a list of descriptors for classes to include in the image
 void CompilerDriver::LoadImageClasses(base::TimingLogger& timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_) {
-  if (image_classes_.get() == NULL) {
+  if (!IsImage()) {
     return;
   }
 
@@ -669,7 +670,7 @@ void CompilerDriver::LoadImageClasses(base::TimingLogger& timings)
     SirtRef<mirror::Class> klass(self, class_linker->FindSystemClass(descriptor.c_str()));
     if (klass.get() == NULL) {
       image_classes_->erase(it++);
-      LOG(WARNING) << "Failed to find class " << descriptor;
+      VLOG(compiler) << "Failed to find class " << descriptor;
       Thread::Current()->ClearException();
     } else {
       ++it;
@@ -742,21 +743,19 @@ void CompilerDriver::FindClinitImageClassesCallback(mirror::Object* object, void
 }
 
 void CompilerDriver::UpdateImageClasses(base::TimingLogger& timings) {
-  if (image_classes_.get() == NULL) {
-    return;
-  }
-
-  timings.NewSplit("UpdateImageClasses");
+  if (IsImage()) {
+    timings.NewSplit("UpdateImageClasses");
 
-  // Update image_classes_ with classes for objects created by <clinit> methods.
-  Thread* self = Thread::Current();
-  const char* old_cause = self->StartAssertNoThreadSuspension("ImageWriter");
-  gc::Heap* heap = Runtime::Current()->GetHeap();
-  // TODO: Image spaces only?
-  WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
-  heap->FlushAllocStack();
-  heap->GetLiveBitmap()->Walk(FindClinitImageClassesCallback, this);
-  self->EndAssertNoThreadSuspension(old_cause);
+    // Update image_classes_ with classes for objects created by <clinit> methods.
+    Thread* self = Thread::Current();
+    const char* old_cause = self->StartAssertNoThreadSuspension("ImageWriter");
+    gc::Heap* heap = Runtime::Current()->GetHeap();
+    // TODO: Image spaces only?
+    WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
+    heap->FlushAllocStack();
+    heap->GetLiveBitmap()->Walk(FindClinitImageClassesCallback, this);
+    self->EndAssertNoThreadSuspension(old_cause);
+  }
 }
 
 void CompilerDriver::RecordClassStatus(ClassReference ref, CompiledClass* compiled_class) {
@@ -1436,12 +1435,18 @@ static bool SkipClass(mirror::ClassLoader* class_loader,
   return true;
 }
 
-static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manager, size_t class_def_index)
+static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manager,
+                                         size_t class_def_index)
     LOCKS_EXCLUDED(Locks::mutator_lock_) {
   ScopedObjectAccess soa(Thread::Current());
   mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader());
   const DexFile& dex_file = *manager->GetDexFile();
 
+  // If an instance field is final then we need to have a barrier on the return, static final
+  // fields are assigned within the lock held for class initialization. Conservatively assume
+  // constructor barriers are always required.
+  bool requires_constructor_barrier = true;
+
   // Method and Field are the worst. We can't resolve without either
   // context from the code use (to disambiguate virtual vs direct
   // method and instance vs static field) or from class
@@ -1450,72 +1455,89 @@ static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manag
   // definitions, since many of them many never be referenced by
   // generated code.
   const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
-  if (SkipClass(class_loader, dex_file, class_def)) {
-    return;
-  }
-
-  // Note the class_data pointer advances through the headers,
-  // static fields, instance fields, direct methods, and virtual
-  // methods.
-  const byte* class_data = dex_file.GetClassData(class_def);
-  if (class_data == NULL) {
-    // empty class such as a marker interface
-    return;
-  }
-  Thread* self = Thread::Current();
-  ClassLinker* class_linker = manager->GetClassLinker();
-  mirror::DexCache* dex_cache = class_linker->FindDexCache(dex_file);
-  ClassDataItemIterator it(dex_file, class_data);
-  while (it.HasNextStaticField()) {
-    mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
-                                                      class_loader, true);
-    if (field == NULL) {
-      CHECK(self->IsExceptionPending());
-      self->ClearException();
-    }
-    it.Next();
-  }
-  // If an instance field is final then we need to have a barrier on the return, static final
-  // fields are assigned within the lock held for class initialization.
-  bool requires_constructor_barrier = false;
-  while (it.HasNextInstanceField()) {
-    if ((it.GetMemberAccessFlags() & kAccFinal) != 0) {
-      requires_constructor_barrier = true;
-    }
-
-    mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
-                                                      class_loader, false);
-    if (field == NULL) {
-      CHECK(self->IsExceptionPending());
-      self->ClearException();
+  if (!SkipClass(class_loader, dex_file, class_def)) {
+    // Note the class_data pointer advances through the headers,
+    // static fields, instance fields, direct methods, and virtual
+    // methods.
+    const byte* class_data = dex_file.GetClassData(class_def);
+    if (class_data == NULL) {
+      // Empty class such as a marker interface.
+      requires_constructor_barrier = false;
+    } else {
+      ClassLinker* class_linker = manager->GetClassLinker();
+      mirror::DexCache* dex_cache = class_linker->FindDexCache(dex_file);
+
+      // Resolve the class.
+      mirror::Class* klass = class_linker->ResolveType(dex_file, class_def.class_idx_, dex_cache,
+                                                       class_loader);
+
+      bool resolve_fields_and_methods;
+      if (klass == NULL) {
+        // Class couldn't be resolved, for example, super-class is in a different dex file. Don't
+        // attempt to resolve methods and fields when there is no declaring class.
+        CHECK(soa.Self()->IsExceptionPending());
+        Thread::Current()->ClearException();
+        resolve_fields_and_methods = false;
+      } else {
+        resolve_fields_and_methods = manager->GetCompiler()->IsImage();
+      }
+      ClassDataItemIterator it(dex_file, class_data);
+      while (it.HasNextStaticField()) {
+        if (resolve_fields_and_methods) {
+          mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(),
+                                                               dex_cache, class_loader, true);
+          if (field == NULL) {
+            CHECK(soa.Self()->IsExceptionPending());
+            soa.Self()->ClearException();
+          }
+        }
+        it.Next();
+      }
+      // We require a constructor barrier if there are final instance fields.
+      requires_constructor_barrier = false;
+      while (it.HasNextInstanceField()) {
+        if ((it.GetMemberAccessFlags() & kAccFinal) != 0) {
+          requires_constructor_barrier = true;
+        }
+        if (resolve_fields_and_methods) {
+          mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(),
+                                                               dex_cache, class_loader, false);
+          if (field == NULL) {
+            CHECK(soa.Self()->IsExceptionPending());
+            soa.Self()->ClearException();
+          }
+        }
+        it.Next();
+      }
+      if (resolve_fields_and_methods) {
+        while (it.HasNextDirectMethod()) {
+          mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
+                                                                  dex_cache, class_loader, NULL,
+                                                                  it.GetMethodInvokeType(class_def));
+          if (method == NULL) {
+            CHECK(soa.Self()->IsExceptionPending());
+            soa.Self()->ClearException();
+          }
+          it.Next();
+        }
+        while (it.HasNextVirtualMethod()) {
+          mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
+                                                                  dex_cache, class_loader, NULL,
+                                                                  it.GetMethodInvokeType(class_def));
+          if (method == NULL) {
+            CHECK(soa.Self()->IsExceptionPending());
+            soa.Self()->ClearException();
+          }
+          it.Next();
+        }
+        DCHECK(!it.HasNext());
+      }
     }
-    it.Next();
   }
   if (requires_constructor_barrier) {
     manager->GetCompiler()->AddRequiresConstructorBarrier(soa.Self(), manager->GetDexFile(),
                                                           class_def_index);
   }
-  while (it.HasNextDirectMethod()) {
-    mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
-                                                                 dex_cache, class_loader, NULL,
-                                                                 it.GetMethodInvokeType(class_def));
-    if (method == NULL) {
-      CHECK(self->IsExceptionPending());
-      self->ClearException();
-    }
-    it.Next();
-  }
-  while (it.HasNextVirtualMethod()) {
-    mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
-                                                                 dex_cache, class_loader, NULL,
-                                                                 it.GetMethodInvokeType(class_def));
-    if (method == NULL) {
-      CHECK(self->IsExceptionPending());
-      self->ClearException();
-    }
-    it.Next();
-  }
-  DCHECK(!it.HasNext());
 }
 
 static void ResolveType(const ParallelCompilationManager* manager, size_t type_idx)
@@ -1541,10 +1563,16 @@ void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_fil
   // TODO: we could resolve strings here, although the string table is largely filled with class
   //       and method names.
 
-  timings.NewSplit(strdup(("Resolve " + dex_file.GetLocation() + " Types").c_str()));
   ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
-  context.ForAll(0, dex_file.NumTypeIds(), ResolveType, thread_count_);
+  if (IsImage()) {
+    // For images we resolve all types, such as array, whereas for applications just those with
+    // classdefs are resolved by ResolveClassFieldsAndMethods.
+    // TODO: strdup memory leak.
+    timings.NewSplit(strdup(("Resolve " + dex_file.GetLocation() + " Types").c_str()));
+    context.ForAll(0, dex_file.NumTypeIds(), ResolveType, thread_count_);
+  }
 
+  // TODO: strdup memory leak.
   timings.NewSplit(strdup(("Resolve " + dex_file.GetLocation() + " MethodsAndFields").c_str()));
   context.ForAll(0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_);
 }
@@ -1567,7 +1595,8 @@ static void VerifyClass(const ParallelCompilationManager* manager, size_t class_
   mirror::Class* klass =
       manager->GetClassLinker()->FindClass(descriptor,
                                            soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader()));
-  if (klass == NULL) {    CHECK(soa.Self()->IsExceptionPending());
+  if (klass == NULL) {
+    CHECK(soa.Self()->IsExceptionPending());
     soa.Self()->ClearException();
 
     /*
@@ -1587,25 +1616,25 @@ static void VerifyClass(const ParallelCompilationManager* manager, size_t class_
                  << PrettyDescriptor(manager->GetDexFile()->GetClassDescriptor(class_def))
                  << " because: " << error_msg;
     }
-    return;
-  }
-  CHECK(klass->IsResolved()) << PrettyClass(klass);
-  manager->GetClassLinker()->VerifyClass(klass);
-
-  if (klass->IsErroneous()) {
-    // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
-    CHECK(soa.Self()->IsExceptionPending());
-    soa.Self()->ClearException();
-  }
+  } else {
+    CHECK(klass->IsResolved()) << PrettyClass(klass);
+    manager->GetClassLinker()->VerifyClass(klass);
 
+    if (klass->IsErroneous()) {
+      // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
+      CHECK(soa.Self()->IsExceptionPending());
+      soa.Self()->ClearException();
+    }
 
-  CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous())
-      << PrettyDescriptor(klass) << ": state=" << klass->GetStatus();
+    CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous())
+        << PrettyDescriptor(klass) << ": state=" << klass->GetStatus();
+  }
   soa.Self()->AssertNoPendingException();
 }
 
 void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file,
                                    ThreadPool& thread_pool, base::TimingLogger& timings) {
+  // TODO: strdup memory leak.
   timings.NewSplit(strdup(("Verify " + dex_file.GetLocation()).c_str()));
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
@@ -2032,23 +2061,20 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
   mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader());
   const char* descriptor = manager->GetDexFile()->GetClassDescriptor(class_def);
   mirror::Class* klass = manager->GetClassLinker()->FindClass(descriptor, class_loader);
-  bool compiling_boot = Runtime::Current()->GetHeap()->GetContinuousSpaces().size() == 1;
-  bool can_init_static_fields = compiling_boot &&
-      manager->GetCompiler()->IsImageClass(descriptor);
   if (klass != NULL) {
-    // We don't want class initialization occurring on multiple threads due to deadlock problems.
-    // For example, a parent class is initialized (holding its lock) that refers to a sub-class
-    // in its static/class initializer causing it to try to acquire the sub-class' lock. While
-    // on a second thread the sub-class is initialized (holding its lock) after first initializing
-    // its parents, whose locks are acquired. This leads to a parent-to-child and a child-to-parent
-    // lock ordering and consequent potential deadlock.
-    // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather
-    // than use a special Object for the purpose we use the Class of java.lang.Class.
-    ObjectLock lock1(soa.Self(), klass->GetClass());
-    // The lock required to initialize the class.
-    ObjectLock lock2(soa.Self(), klass);
     // Only try to initialize classes that were successfully verified.
     if (klass->IsVerified()) {
+      // We don't want class initialization occurring on multiple threads due to deadlock problems.
+      // For example, a parent class is initialized (holding its lock) that refers to a sub-class
+      // in its static/class initializer causing it to try to acquire the sub-class' lock. While
+      // on a second thread the sub-class is initialized (holding its lock) after first initializing
+      // its parents, whose locks are acquired. This leads to a parent-to-child and a child-to-parent
+      // lock ordering and consequent potential deadlock.
+      // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather
+      // than use a special Object for the purpose we use the Class of java.lang.Class.
+      ObjectLock lock(soa.Self(), klass->GetClass());
+      bool can_init_static_fields = manager->GetCompiler()->IsImage() &&
+          manager->GetCompiler()->IsImageClass(descriptor);
       manager->GetClassLinker()->EnsureInitialized(klass, false, can_init_static_fields);
       if (soa.Self()->IsExceptionPending()) {
         soa.Self()->GetException(NULL)->Dump();
@@ -2069,6 +2095,7 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
             VLOG(compiler) << "Initializing: " << descriptor;
             if (StringPiece(descriptor) == "Ljava/lang/Void;") {
               // Hand initialize j.l.Void to avoid Dex file operations in un-started runtime.
+              ObjectLock lock(soa.Self(), klass);
               mirror::ObjectArray<mirror::ArtField>* fields = klass->GetSFields();
               CHECK_EQ(fields->GetLength(), 1);
               fields->Get(0)->SetObj(klass, manager->GetClassLinker()->FindPrimitiveClass('V'));
@@ -2102,11 +2129,15 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
 
 void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile& dex_file,
                                        ThreadPool& thread_pool, base::TimingLogger& timings) {
+  // TODO: strdup memory leak.
   timings.NewSplit(strdup(("InitializeNoClinit " + dex_file.GetLocation()).c_str()));
 #ifndef NDEBUG
-  for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) {
-    const char* descriptor = class_initializer_black_list[i];
-    CHECK(IsValidDescriptor(descriptor)) << descriptor;
+  // Sanity check blacklist descriptors.
+  if (IsImage()) {
+    for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) {
+      const char* descriptor = class_initializer_black_list[i];
+      CHECK(IsValidDescriptor(descriptor)) << descriptor;
+    }
   }
 #endif
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index 21a44eaf12..bcde178b76 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -110,6 +110,7 @@ class CompilerDriver {
     return compiler_backend_;
   }
 
+  // Are we compiling and creating an image file?
   bool IsImage() const {
     return image_;
   }
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index ceb6bf6d80..89552a375e 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -825,6 +825,7 @@ static int dex2oat(int argc, char** argv) {
     return EXIT_FAILURE;
   }
 
+  timings.StartSplit("dex2oat Setup");
   LOG(INFO) << "dex2oat: " << oat_location;
 
   Runtime::Options options;
@@ -926,7 +927,6 @@ static int dex2oat(int argc, char** argv) {
     }
   }
 
-  timings.StartSplit("dex2oat Setup");
   UniquePtr<const CompilerDriver> compiler(dex2oat->CreateOatFile(boot_image_option,
                                                                   host_prefix.get(),
                                                                   android_root,
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index d0b8bbdbe6..b4c767dd0a 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -2311,8 +2311,9 @@ void ClassLinker::VerifyClass(mirror::Class* klass) {
   mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady);
   bool preverified = VerifyClassUsingOatFile(dex_file, klass, oat_file_class_status);
   if (oat_file_class_status == mirror::Class::kStatusError) {
-    LOG(WARNING) << "Skipping runtime verification of erroneous class " << PrettyDescriptor(klass)
-                 << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
+    VLOG(class_linker) << "Skipping runtime verification of erroneous class "
+        << PrettyDescriptor(klass) << " in "
+        << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
     ThrowVerifyError(klass, "Rejecting class %s because it failed compile-time verification",
                      PrettyDescriptor(klass).c_str());
     klass->SetStatus(mirror::Class::kStatusError);
@@ -2326,7 +2327,7 @@ void ClassLinker::VerifyClass(mirror::Class* klass) {
   }
   if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
     if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
-      LOG(WARNING) << "Soft verification failure in class " << PrettyDescriptor(klass)
+      VLOG(class_linker) << "Soft verification failure in class " << PrettyDescriptor(klass)
           << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
           << " because: " << error_msg;
     }
@@ -2722,14 +2723,6 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, boo
     }
 
     clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
-    if (clinit != NULL && !can_run_clinit) {
-      // if the class has a <clinit> but we can't run it during compilation,
-      // don't bother going to kStatusInitializing. We return false so that
-      // sub-classes don't believe this class is initialized.
-      // Opportunistically link non-static methods, TODO: don't initialize and dirty pages
-      // in second pass.
-      return false;
-    }
 
     // If the class is kStatusInitializing, either this thread is
     // initializing higher up the stack or another thread has beat us
@@ -2775,9 +2768,9 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, boo
     return false;
   }
 
-  bool has_static_field_initializers = InitializeStaticFields(klass);
+  bool has_static_field_initializers = InitializeStaticFields(klass, can_init_statics);
 
-  if (clinit != NULL) {
+  if (clinit != NULL && can_run_clinit) {
     if (Runtime::Current()->IsStarted()) {
       JValue result;
       clinit->Invoke(self, NULL, 0, &result, 'V');
@@ -2786,7 +2779,11 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, boo
     }
   }
 
-  FixupStaticTrampolines(klass);
+  // Opportunistically set static method trampolines to their destiniation. Unless initialization
+  // is being hindered at compile time.
+  if (can_init_statics || can_run_clinit || (!has_static_field_initializers && clinit == NULL)) {
+    FixupStaticTrampolines(klass);
+  }
 
   uint64_t t1 = NanoTime();
 
@@ -2805,15 +2802,15 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, boo
       ++thread_stats->class_init_count;
       global_stats->class_init_time_ns += (t1 - t0);
       thread_stats->class_init_time_ns += (t1 - t0);
-      // Set the class as initialized except if we can't initialize static fields and static field
-      // initialization is necessary.
-      if (!can_init_statics && has_static_field_initializers) {
-        klass->SetStatus(mirror::Class::kStatusVerified);  // Don't leave class in initializing state.
+      // Set the class as initialized except if failed to initialize static fields.
+      if ((!can_init_statics && has_static_field_initializers) ||
+          (!can_run_clinit && clinit != NULL)) {
+        klass->SetStatus(mirror::Class::kStatusVerified);
         success = false;
       } else {
         klass->SetStatus(mirror::Class::kStatusInitialized);
       }
-      if (VLOG_IS_ON(class_linker)) {
+      if (success && VLOG_IS_ON(class_linker)) {
         ClassHelper kh(klass);
         LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
       }
@@ -2986,10 +2983,9 @@ bool ClassLinker::EnsureInitialized(mirror::Class* c, bool can_run_clinit, bool
     return true;
   }
 
-  Thread* self = Thread::Current();
-  ScopedThreadStateChange tsc(self, kRunnable);
   bool success = InitializeClass(c, can_run_clinit, can_init_fields);
   if (!success) {
+    Thread* self = Thread::Current();
     CHECK(self->IsExceptionPending() || !can_run_clinit) << PrettyClass(c);
   }
   return success;
@@ -3005,7 +3001,7 @@ void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::Clas
   }
 }
 
-bool ClassLinker::InitializeStaticFields(mirror::Class* klass) {
+bool ClassLinker::InitializeStaticFields(mirror::Class* klass, bool can_init_statics) {
   size_t num_static_fields = klass->NumStaticFields();
   if (num_static_fields == 0) {
     return false;
@@ -3022,16 +3018,19 @@ bool ClassLinker::InitializeStaticFields(mirror::Class* klass) {
   EncodedStaticFieldValueIterator it(dex_file, dex_cache, klass->GetClassLoader(),
                                      this, *dex_class_def);
 
-  if (it.HasNext()) {
-    // We reordered the fields, so we need to be able to map the field indexes to the right fields.
-    SafeMap<uint32_t, mirror::ArtField*> field_map;
-    ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
-    for (size_t i = 0; it.HasNext(); i++, it.Next()) {
-      it.ReadValueToField(field_map.Get(i));
+  if (!it.HasNext()) {
+    return false;
+  } else {
+    if (can_init_statics) {
+      // We reordered the fields, so we need to be able to map the field indexes to the right fields.
+      SafeMap<uint32_t, mirror::ArtField*> field_map;
+      ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
+      for (size_t i = 0; it.HasNext(); i++, it.Next()) {
+        it.ReadValueToField(field_map.Get(i));
+      }
     }
     return true;
   }
-  return false;
 }
 
 bool ClassLinker::LinkClass(SirtRef<mirror::Class>& klass,
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index d0cc562ca5..fdf17a25ee 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -443,7 +443,7 @@ class ClassLinker {
   bool InitializeSuperClass(mirror::Class* klass, bool can_run_clinit, bool can_init_fields)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   // Initialize static fields, returns true if fields were initialized.
-  bool InitializeStaticFields(mirror::Class* klass)
+  bool InitializeStaticFields(mirror::Class* klass, bool can_init_statics)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   bool IsSameDescriptorInDifferentClassContexts(const char* descriptor,
-- 
cgit v1.2.3-59-g8ed1b


From be7149fc2e7cc607937209f2819e3c1d672e2668 Mon Sep 17 00:00:00 2001
From: Ian Rogers <irogers@google.com>
Date: Tue, 20 Aug 2013 09:29:39 -0700
Subject: Avoid throwing NoClassDefFoundError at compile time.

Change-Id: I8ba56a8750e1718babcb1f94e0408d89f58ea9b5
---
 compiler/driver/compiler_driver.cc | 55 ++++++++++++++++----------------------
 runtime/class_linker.cc            | 26 +++++++++---------
 runtime/class_linker.h             |  2 ++
 3 files changed, 39 insertions(+), 44 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 9dd880facf..bf541c6e04 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -1416,31 +1416,22 @@ class ParallelCompilationManager {
 // classes found in the boot classpath. Since at runtime we will
 // select the class from the boot classpath, do not attempt to resolve
 // or compile it now.
-static bool SkipClass(mirror::ClassLoader* class_loader,
-                      const DexFile& dex_file,
-                      const DexFile::ClassDef& class_def)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+static bool SkipClass(ClassLinker* class_linker, jobject class_loader, const DexFile& dex_file,
+                      const DexFile::ClassDef& class_def) {
   if (class_loader == NULL) {
     return false;
   }
   const char* descriptor = dex_file.GetClassDescriptor(class_def);
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  mirror::Class* klass = class_linker->FindClass(descriptor, NULL);
-  if (klass == NULL) {
-    Thread* self = Thread::Current();
-    CHECK(self->IsExceptionPending());
-    self->ClearException();
-    return false;
-  }
-  return true;
+  return class_linker->IsInBootClassPath(descriptor);
 }
 
 static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manager,
                                          size_t class_def_index)
     LOCKS_EXCLUDED(Locks::mutator_lock_) {
-  ScopedObjectAccess soa(Thread::Current());
-  mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader());
+  Thread* self = Thread::Current();
+  jobject jclass_loader = manager->GetClassLoader();
   const DexFile& dex_file = *manager->GetDexFile();
+  ClassLinker* class_linker = manager->GetClassLinker();
 
   // If an instance field is final then we need to have a barrier on the return, static final
   // fields are assigned within the lock held for class initialization. Conservatively assume
@@ -1455,7 +1446,7 @@ static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manag
   // definitions, since many of them many never be referenced by
   // generated code.
   const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
-  if (!SkipClass(class_loader, dex_file, class_def)) {
+  if (!SkipClass(class_linker, jclass_loader, dex_file, class_def)) {
     // Note the class_data pointer advances through the headers,
     // static fields, instance fields, direct methods, and virtual
     // methods.
@@ -1464,7 +1455,8 @@ static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manag
       // Empty class such as a marker interface.
       requires_constructor_barrier = false;
     } else {
-      ClassLinker* class_linker = manager->GetClassLinker();
+      ScopedObjectAccess soa(self);
+      mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(jclass_loader);
       mirror::DexCache* dex_cache = class_linker->FindDexCache(dex_file);
 
       // Resolve the class.
@@ -1535,8 +1527,7 @@ static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manag
     }
   }
   if (requires_constructor_barrier) {
-    manager->GetCompiler()->AddRequiresConstructorBarrier(soa.Self(), manager->GetDexFile(),
-                                                          class_def_index);
+    manager->GetCompiler()->AddRequiresConstructorBarrier(self, &dex_file, class_def_index);
   }
 }
 
@@ -2170,12 +2161,9 @@ void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, siz
   jobject jclass_loader = manager->GetClassLoader();
   const DexFile& dex_file = *manager->GetDexFile();
   const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
-  {
-    ScopedObjectAccess soa(Thread::Current());
-    mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(jclass_loader);
-    if (SkipClass(class_loader, dex_file, class_def)) {
-      return;
-    }
+  ClassLinker* class_linker = manager->GetClassLinker();
+  if (SkipClass(class_linker, jclass_loader, dex_file, class_def)) {
+    return;
   }
   ClassReference ref(&dex_file, class_def_index);
   // Skip compiling classes with generic verifier failures since they will still fail at runtime
@@ -2203,6 +2191,7 @@ void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, siz
   while (it.HasNextInstanceField()) {
     it.Next();
   }
+  CompilerDriver* driver = manager->GetCompiler();
   // Compile direct methods
   int64_t previous_direct_method_idx = -1;
   while (it.HasNextDirectMethod()) {
@@ -2214,9 +2203,9 @@ void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, siz
       continue;
     }
     previous_direct_method_idx = method_idx;
-    manager->GetCompiler()->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
-                                          it.GetMethodInvokeType(class_def), class_def_index,
-                                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
+    driver->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
+                          it.GetMethodInvokeType(class_def), class_def_index,
+                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
     it.Next();
   }
   // Compile virtual methods
@@ -2230,9 +2219,9 @@ void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, siz
       continue;
     }
     previous_virtual_method_idx = method_idx;
-    manager->GetCompiler()->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
-                                          it.GetMethodInvokeType(class_def), class_def_index,
-                                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
+    driver->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
+                          it.GetMethodInvokeType(class_def), class_def_index,
+                          method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level);
     it.Next();
   }
   DCHECK(!it.HasNext());
@@ -2240,8 +2229,10 @@ void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, siz
 
 void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_file,
                                     ThreadPool& thread_pool, base::TimingLogger& timings) {
+  // TODO: strdup memory leak.
   timings.NewSplit(strdup(("Compile " + dex_file.GetLocation()).c_str()));
-  ParallelCompilationManager context(NULL, class_loader, this, &dex_file, thread_pool);
+  ParallelCompilationManager context(Runtime::Current()->GetClassLinker(), class_loader, this,
+                                     &dex_file, thread_pool);
   context.ForAll(0, dex_file.NumClassDefs(), CompilerDriver::CompileClass, thread_count_);
 }
 
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index b4c767dd0a..0110b366d6 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -1290,6 +1290,11 @@ static mirror::Class* EnsureResolved(Thread* self, mirror::Class* klass)
   return klass;
 }
 
+bool ClassLinker::IsInBootClassPath(const char* descriptor) {
+  DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
+  return pair.second != NULL;
+}
+
 mirror::Class* ClassLinker::FindSystemClass(const char* descriptor) {
   return FindClass(descriptor, NULL);
 }
@@ -1320,18 +1325,17 @@ mirror::Class* ClassLinker::FindClass(const char* descriptor, mirror::ClassLoade
     }
 
   } else if (Runtime::Current()->UseCompileTimeClassPath()) {
-    // first try the boot class path
-    mirror::Class* system_class = FindSystemClass(descriptor);
-    if (system_class != NULL) {
+    // First try the boot class path, we check the descriptor first to avoid an unnecessary
+    // throw of a NoClassDefFoundError.
+    if (IsInBootClassPath(descriptor)) {
+      mirror::Class* system_class = FindSystemClass(descriptor);
+      CHECK(system_class != NULL);
       return system_class;
     }
-    CHECK(self->IsExceptionPending());
-    self->ClearException();
-
-    // next try the compile time class path
+    // Next try the compile time class path.
     const std::vector<const DexFile*>* class_path;
     {
-      ScopedObjectAccessUnchecked soa(Thread::Current());
+      ScopedObjectAccessUnchecked soa(self);
       ScopedLocalRef<jobject> jclass_loader(soa.Env(), soa.AddLocalReference<jobject>(class_loader));
       class_path = &Runtime::Current()->GetCompileTimeClassPath(jclass_loader.get());
     }
@@ -2697,7 +2701,6 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, boo
 
   Thread* self = Thread::Current();
 
-  mirror::ArtMethod* clinit = NULL;
   {
     // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
     ObjectLock lock(self, klass);
@@ -2722,8 +2725,6 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, boo
       }
     }
 
-    clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
-
     // If the class is kStatusInitializing, either this thread is
     // initializing higher up the stack or another thread has beat us
     // to initializing and we need to wait. Either way, this
@@ -2770,6 +2771,7 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, boo
 
   bool has_static_field_initializers = InitializeStaticFields(klass, can_init_statics);
 
+  mirror::ArtMethod* clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
   if (clinit != NULL && can_run_clinit) {
     if (Runtime::Current()->IsStarted()) {
       JValue result;
@@ -2779,7 +2781,7 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, boo
     }
   }
 
-  // Opportunistically set static method trampolines to their destiniation. Unless initialization
+  // Opportunistically set static method trampolines to their destination. Unless initialization
   // is being hindered at compile time.
   if (can_init_statics || can_run_clinit || (!has_static_field_initializers && clinit == NULL)) {
     FixupStaticTrampolines(klass);
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index fdf17a25ee..624b7cecec 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -62,6 +62,8 @@ class ClassLinker {
 
   ~ClassLinker();
 
+  bool IsInBootClassPath(const char* descriptor);
+
   // Finds a class by its descriptor, loading it if necessary.
   // If class_loader is null, searches boot_class_path_.
   mirror::Class* FindClass(const char* descriptor, mirror::ClassLoader* class_loader)
-- 
cgit v1.2.3-59-g8ed1b


From 8f3c9ae38df2460940a26dff889a84430b6c38d3 Mon Sep 17 00:00:00 2001
From: Ian Rogers <irogers@google.com>
Date: Tue, 20 Aug 2013 17:26:41 -0700
Subject: Don't allow class status to go backward except for error.

Allow greater parallelism of initialization.
Bug 10393546.

Change-Id: Ic194ed490bb0a986250c09fcf335eb1be9714657
---
 compiler/driver/compiler_driver.cc | 126 +++++++++++--------
 compiler/driver/compiler_driver.h  |   5 +-
 runtime/class_linker.cc            | 247 ++++++++++++++++++++-----------------
 runtime/class_linker.h             |   7 +-
 runtime/exception_test.cc          |   2 +-
 runtime/mirror/class.cc            |  17 ++-
 6 files changed, 226 insertions(+), 178 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index bf541c6e04..d265ed1c0d 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -758,11 +758,6 @@ void CompilerDriver::UpdateImageClasses(base::TimingLogger& timings) {
   }
 }
 
-void CompilerDriver::RecordClassStatus(ClassReference ref, CompiledClass* compiled_class) {
-  MutexLock mu(Thread::Current(), CompilerDriver::compiled_classes_lock_);
-  compiled_classes_.Put(ref, compiled_class);
-}
-
 bool CompilerDriver::CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file,
                                                       uint32_t type_idx) {
   if (IsImage() && IsImageClass(dex_file.GetTypeDescriptor(dex_file.GetTypeId(type_idx)))) {
@@ -1428,6 +1423,7 @@ static bool SkipClass(ClassLinker* class_linker, jobject class_loader, const Dex
 static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manager,
                                          size_t class_def_index)
     LOCKS_EXCLUDED(Locks::mutator_lock_) {
+  ATRACE_CALL();
   Thread* self = Thread::Current();
   jobject jclass_loader = manager->GetClassLoader();
   const DexFile& dex_file = *manager->GetDexFile();
@@ -2048,6 +2044,7 @@ static const char* class_initializer_black_list[] = {
 
 static void InitializeClass(const ParallelCompilationManager* manager, size_t class_def_index)
     LOCKS_EXCLUDED(Locks::mutator_lock_) {
+  ATRACE_CALL();
   const DexFile::ClassDef& class_def = manager->GetDexFile()->GetClassDef(class_def_index);
   ScopedObjectAccess soa(Thread::Current());
   mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader());
@@ -2056,48 +2053,54 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
   if (klass != NULL) {
     // Only try to initialize classes that were successfully verified.
     if (klass->IsVerified()) {
-      // We don't want class initialization occurring on multiple threads due to deadlock problems.
-      // For example, a parent class is initialized (holding its lock) that refers to a sub-class
-      // in its static/class initializer causing it to try to acquire the sub-class' lock. While
-      // on a second thread the sub-class is initialized (holding its lock) after first initializing
-      // its parents, whose locks are acquired. This leads to a parent-to-child and a child-to-parent
-      // lock ordering and consequent potential deadlock.
-      // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather
-      // than use a special Object for the purpose we use the Class of java.lang.Class.
-      ObjectLock lock(soa.Self(), klass->GetClass());
-      bool can_init_static_fields = manager->GetCompiler()->IsImage() &&
-          manager->GetCompiler()->IsImageClass(descriptor);
-      manager->GetClassLinker()->EnsureInitialized(klass, false, can_init_static_fields);
-      if (soa.Self()->IsExceptionPending()) {
-        soa.Self()->GetException(NULL)->Dump();
-      }
+      // Attempt to initialize the class but bail if we either need to initialize the super-class
+      // or static fields.
+      manager->GetClassLinker()->EnsureInitialized(klass, false, false);
       if (!klass->IsInitialized()) {
-        if (can_init_static_fields) {
-          // NoPreloadHolder inner class implies this should not be initialized early.
-          bool is_black_listed = StringPiece(descriptor).ends_with("$NoPreloadHolder;");
-          if (!is_black_listed) {
-            for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) {
-              if (StringPiece(descriptor) == class_initializer_black_list[i]) {
-                is_black_listed = true;
-                break;
+        // We don't want non-trivial class initialization occurring on multiple threads due to
+        // deadlock problems. For example, a parent class is initialized (holding its lock) that
+        // refers to a sub-class in its static/class initializer causing it to try to acquire the
+        // sub-class' lock. While on a second thread the sub-class is initialized (holding its lock)
+        // after first initializing its parents, whose locks are acquired. This leads to a
+        // parent-to-child and a child-to-parent lock ordering and consequent potential deadlock.
+        // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather
+        // than use a special Object for the purpose we use the Class of java.lang.Class.
+        ObjectLock lock(soa.Self(), klass->GetClass());
+        // Attempt to initialize allowing initialization of parent classes but still not static
+        // fields.
+        manager->GetClassLinker()->EnsureInitialized(klass, false, true);
+        if (!klass->IsInitialized()) {
+          // We need to initialize static fields, we only do this for image classes that aren't
+          // black listed or marked with the $NoPreloadHolder.
+          bool can_init_static_fields = manager->GetCompiler()->IsImage() &&
+              manager->GetCompiler()->IsImageClass(descriptor);
+          if (can_init_static_fields) {
+            // NoPreloadHolder inner class implies this should not be initialized early.
+            bool is_black_listed = StringPiece(descriptor).ends_with("$NoPreloadHolder;");
+            if (!is_black_listed) {
+              for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) {
+                if (StringPiece(descriptor) == class_initializer_black_list[i]) {
+                  is_black_listed = true;
+                  break;
+                }
               }
             }
-          }
-          if (!is_black_listed) {
-            VLOG(compiler) << "Initializing: " << descriptor;
-            if (StringPiece(descriptor) == "Ljava/lang/Void;") {
-              // Hand initialize j.l.Void to avoid Dex file operations in un-started runtime.
-              ObjectLock lock(soa.Self(), klass);
-              mirror::ObjectArray<mirror::ArtField>* fields = klass->GetSFields();
-              CHECK_EQ(fields->GetLength(), 1);
-              fields->Get(0)->SetObj(klass, manager->GetClassLinker()->FindPrimitiveClass('V'));
-              klass->SetStatus(mirror::Class::kStatusInitialized);
-            } else {
-              manager->GetClassLinker()->EnsureInitialized(klass, true, can_init_static_fields);
+            if (!is_black_listed) {
+              VLOG(compiler) << "Initializing: " << descriptor;
+              if (StringPiece(descriptor) == "Ljava/lang/Void;") {
+                // Hand initialize j.l.Void to avoid Dex file operations in un-started runtime.
+                ObjectLock lock(soa.Self(), klass);
+                mirror::ObjectArray<mirror::ArtField>* fields = klass->GetSFields();
+                CHECK_EQ(fields->GetLength(), 1);
+                fields->Get(0)->SetObj(klass, manager->GetClassLinker()->FindPrimitiveClass('V'));
+                klass->SetStatus(mirror::Class::kStatusInitialized);
+              } else {
+                manager->GetClassLinker()->EnsureInitialized(klass, true, true);
+              }
             }
-            soa.Self()->AssertNoPendingException();
           }
         }
+        soa.Self()->AssertNoPendingException();
       }
       // If successfully initialized place in SSB array.
       if (klass->IsInitialized()) {
@@ -2105,15 +2108,8 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
       }
     }
     // Record the final class status if necessary.
-    mirror::Class::Status status = klass->GetStatus();
     ClassReference ref(manager->GetDexFile(), class_def_index);
-    CompiledClass* compiled_class = manager->GetCompiler()->GetCompiledClass(ref);
-    if (compiled_class == NULL) {
-      compiled_class = new CompiledClass(status);
-      manager->GetCompiler()->RecordClassStatus(ref, compiled_class);
-    } else {
-      DCHECK_GE(status, compiled_class->GetStatus()) << descriptor;
-    }
+    manager->GetCompiler()->RecordClassStatus(ref, klass->GetStatus());
   }
   // Clear any class not found or verification exceptions.
   soa.Self()->ClearException();
@@ -2288,7 +2284,7 @@ void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t
   Thread* self = Thread::Current();
   if (compiled_method != NULL) {
     MethodReference ref(&dex_file, method_idx);
-    CHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
+    DCHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
     {
       MutexLock mu(self, compiled_methods_lock_);
       compiled_methods_.Put(ref, compiled_method);
@@ -2313,6 +2309,32 @@ CompiledClass* CompilerDriver::GetCompiledClass(ClassReference ref) const {
   return it->second;
 }
 
+void CompilerDriver::RecordClassStatus(ClassReference ref, mirror::Class::Status status) {
+  MutexLock mu(Thread::Current(), compiled_classes_lock_);
+  auto it = compiled_classes_.find(ref);
+  if (it == compiled_classes_.end() || it->second->GetStatus() != status) {
+    // An entry doesn't exist or the status is lower than the new status.
+    if (it != compiled_classes_.end()) {
+      CHECK_GT(status, it->second->GetStatus());
+      delete it->second;
+    }
+    switch (status) {
+      case mirror::Class::kStatusNotReady:
+      case mirror::Class::kStatusError:
+      case mirror::Class::kStatusRetryVerificationAtRuntime:
+      case mirror::Class::kStatusVerified:
+      case mirror::Class::kStatusInitialized:
+        break;  // Expected states.
+      default:
+        LOG(FATAL) << "Unexpected class status for class "
+            << PrettyDescriptor(ref.first->GetClassDescriptor(ref.first->GetClassDef(ref.second)))
+            << " of " << status;
+    }
+    CompiledClass* compiled_class = new CompiledClass(status);
+    compiled_classes_.Overwrite(ref, compiled_class);
+  }
+}
+
 CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const {
   MutexLock mu(Thread::Current(), compiled_methods_lock_);
   MethodTable::const_iterator it = compiled_methods_.find(ref);
@@ -2335,13 +2357,13 @@ void CompilerDriver::SetBitcodeFileName(std::string const& filename) {
 
 void CompilerDriver::AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
                                              size_t class_def_index) {
-  MutexLock mu(self, freezing_constructor_lock_);
+  WriterMutexLock mu(self, freezing_constructor_lock_);
   freezing_constructor_classes_.insert(ClassReference(dex_file, class_def_index));
 }
 
 bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
                                           size_t class_def_index) {
-  MutexLock mu(self, freezing_constructor_lock_);
+  ReaderMutexLock mu(self, freezing_constructor_lock_);
   return freezing_constructor_classes_.count(ClassReference(dex_file, class_def_index)) != 0;
 }
 
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index bcde178b76..22a510b86b 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -296,7 +296,8 @@ class CompilerDriver {
   // Checks if class specified by type_idx is one of the image_classes_
   bool IsImageClass(const char* descriptor) const;
 
-  void RecordClassStatus(ClassReference ref, CompiledClass* compiled_class);
+  void RecordClassStatus(ClassReference ref, mirror::Class::Status status)
+      LOCKS_EXCLUDED(compiled_classes_lock_);
 
  private:
   // Compute constant code and method pointers when possible
@@ -362,7 +363,7 @@ class CompilerDriver {
   InstructionSet instruction_set_;
 
   // All class references that require
-  mutable Mutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+  mutable ReaderWriterMutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_);
 
   typedef SafeMap<const ClassReference, CompiledClass*> ClassTable;
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 0110b366d6..96c74203e6 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -782,8 +782,10 @@ class ScopedFlock {
   }
 
   ~ScopedFlock() {
-    int flock_result = TEMP_FAILURE_RETRY(flock(file_->Fd(), LOCK_UN));
-    CHECK_EQ(0, flock_result);
+    if (file_.get() != NULL) {
+      int flock_result = TEMP_FAILURE_RETRY(flock(file_->Fd(), LOCK_UN));
+      CHECK_EQ(0, flock_result);
+    }
   }
 
  private:
@@ -2284,18 +2286,18 @@ void ClassLinker::VerifyClass(mirror::Class* klass) {
   }
 
   // Verify super class.
-  mirror::Class* super = klass->GetSuperClass();
-  if (super != NULL) {
+  SirtRef<mirror::Class> super(self, klass->GetSuperClass());
+  if (super.get() != NULL) {
     // Acquire lock to prevent races on verifying the super class.
-    ObjectLock lock(self, super);
+    ObjectLock lock(self, super.get());
 
     if (!super->IsVerified() && !super->IsErroneous()) {
-      Runtime::Current()->GetClassLinker()->VerifyClass(super);
+      VerifyClass(super.get());
     }
     if (!super->IsCompileTimeVerified()) {
       std::string error_msg(StringPrintf("Rejecting class %s that attempts to sub-class erroneous class %s",
                                          PrettyDescriptor(klass).c_str(),
-                                         PrettyDescriptor(super).c_str()));
+                                         PrettyDescriptor(super.get()).c_str()));
       LOG(ERROR) << error_msg  << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
       SirtRef<mirror::Throwable> cause(self, self->GetException(NULL));
       if (cause.get() != NULL) {
@@ -2339,7 +2341,14 @@ void ClassLinker::VerifyClass(mirror::Class* klass) {
     // Make sure all classes referenced by catch blocks are resolved.
     ResolveClassExceptionHandlerTypes(dex_file, klass);
     if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
-      klass->SetStatus(mirror::Class::kStatusVerified);
+      // Even though there were no verifier failures we need to respect whether the super-class
+      // was verified or requiring runtime reverification.
+      if (super.get() == NULL || super->IsVerified()) {
+        klass->SetStatus(mirror::Class::kStatusVerified);
+      } else {
+        CHECK_EQ(super->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
+        klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime);
+      }
     } else {
       CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
       // Soft failures at compile time should be retried at runtime. Soft
@@ -2695,31 +2704,85 @@ static void CheckProxyMethod(mirror::ArtMethod* method,
   CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
 }
 
-bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, bool can_init_statics) {
-  CHECK(klass->IsResolved() || klass->IsErroneous())
-      << PrettyClass(klass) << ": state=" << klass->GetStatus();
+static bool CanWeInitializeClass(mirror::Class* klass, bool can_init_statics,
+                                 bool can_init_parents)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  if (can_init_statics && can_init_statics) {
+    return true;
+  }
+  if (!can_init_statics) {
+    // Check if there's a class initializer.
+    mirror::ArtMethod* clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
+    if (clinit != NULL) {
+      return false;
+    }
+    // Check if there are encoded static values needing initialization.
+    if (klass->NumStaticFields() != 0) {
+      ClassHelper kh(klass);
+      const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
+      DCHECK(dex_class_def != NULL);
+      if (dex_class_def->static_values_off_ != 0) {
+        return false;
+      }
+    }
+  }
+  if (!klass->IsInterface() && klass->HasSuperClass()) {
+    mirror::Class* super_class = klass->GetSuperClass();
+    if (!can_init_parents && !super_class->IsInitialized()) {
+      return false;
+    } else {
+      if (!CanWeInitializeClass(super_class, can_init_statics, true)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_init_statics,
+                                  bool can_init_parents) {
+  // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
 
-  Thread* self = Thread::Current();
+  // Are we already initialized and therefore done?
+  // Note: we differ from the JLS here as we don't do this under the lock, this is benign as
+  // an initialized class will never change its state.
+  if (klass->IsInitialized()) {
+    return true;
+  }
+
+  // Fast fail if initialization requires a full runtime. Not part of the JLS.
+  if (!CanWeInitializeClass(klass, can_init_statics, can_init_parents)) {
+    return false;
+  }
 
+  Thread* self = Thread::Current();
+  uint64_t t0;
   {
-    // see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
     ObjectLock lock(self, klass);
 
-    if (klass->GetStatus() == mirror::Class::kStatusInitialized) {
+    // Re-check under the lock in case another thread initialized ahead of us.
+    if (klass->IsInitialized()) {
       return true;
     }
 
+    // Was the class already found to be erroneous? Done under the lock to match the JLS.
     if (klass->IsErroneous()) {
       ThrowEarlierClassFailure(klass);
       return false;
     }
 
-    if (klass->GetStatus() == mirror::Class::kStatusResolved ||
-        klass->GetStatus() == mirror::Class::kStatusRetryVerificationAtRuntime) {
+    CHECK(klass->IsResolved()) << PrettyClass(klass) << ": state=" << klass->GetStatus();
+
+    if (!klass->IsVerified()) {
       VerifyClass(klass);
-      if (klass->GetStatus() != mirror::Class::kStatusVerified) {
-        if (klass->GetStatus() == mirror::Class::kStatusError) {
+      if (!klass->IsVerified()) {
+        // We failed to verify, expect either the klass to be erroneous or verification failed at
+        // compile time.
+        if (klass->IsErroneous()) {
           CHECK(self->IsExceptionPending());
+        } else {
+          CHECK(Runtime::Current()->IsCompiler());
+          CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
         }
         return false;
       }
@@ -2742,38 +2805,65 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, boo
 
     if (!ValidateSuperClassDescriptors(klass)) {
       klass->SetStatus(mirror::Class::kStatusError);
-      lock.NotifyAll();
       return false;
     }
 
-    DCHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << PrettyClass(klass);
+    CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << PrettyClass(klass);
 
+    // From here out other threads may observe that we're initializing and so changes of state
+    // require the a notification.
     klass->SetClinitThreadId(self->GetTid());
     klass->SetStatus(mirror::Class::kStatusInitializing);
-  }
 
-  uint64_t t0 = NanoTime();
+    t0 = NanoTime();
+  }
 
-  if (!InitializeSuperClass(klass, can_run_clinit, can_init_statics)) {
-    // Super class initialization failed, this can be because we can't run
-    // super-class class initializers in which case we'll be verified.
-    // Otherwise this class is erroneous.
-    if (!can_run_clinit) {
-      CHECK(klass->IsVerified());
-    } else {
-      CHECK(klass->IsErroneous());
+  // Initialize super classes, must be done will initializing for the JLS.
+  if (!klass->IsInterface() && klass->HasSuperClass()) {
+    mirror::Class* super_class = klass->GetSuperClass();
+    if (!super_class->IsInitialized()) {
+      CHECK(!super_class->IsInterface());
+      CHECK(can_init_parents);
+      bool super_initialized = InitializeClass(super_class, can_init_statics, true);
+      if (!super_initialized) {
+        // The super class was verified ahead of entering initializing, we should only be here if
+        // the super class became erroneous due to initialization.
+        CHECK(super_class->IsErroneous() && self->IsExceptionPending())
+            << "Super class initialization failed for " << PrettyDescriptor(super_class)
+            << " that has unexpected status " << super_class->GetStatus()
+            << "\nPending exception:\n"
+            << (self->GetException(NULL) != NULL ? self->GetException(NULL)->Dump() : "");
+        ObjectLock lock(self, klass);
+        // Initialization failed because the super-class is erroneous.
+        klass->SetStatus(mirror::Class::kStatusError);
+        lock.NotifyAll();
+        return false;
+      }
     }
-    // Signal to any waiting threads that saw this class as initializing.
-    ObjectLock lock(self, klass);
-    lock.NotifyAll();
-    return false;
   }
 
-  bool has_static_field_initializers = InitializeStaticFields(klass, can_init_statics);
+  if (klass->NumStaticFields() > 0) {
+    ClassHelper kh(klass);
+    const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
+    CHECK(dex_class_def != NULL);
+    const DexFile& dex_file = kh.GetDexFile();
+    EncodedStaticFieldValueIterator it(dex_file, kh.GetDexCache(), klass->GetClassLoader(),
+                                       this, *dex_class_def);
+    if (it.HasNext()) {
+      CHECK(can_init_statics);
+      // We reordered the fields, so we need to be able to map the field indexes to the right fields.
+      SafeMap<uint32_t, mirror::ArtField*> field_map;
+      ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
+      for (size_t i = 0; it.HasNext(); i++, it.Next()) {
+        it.ReadValueToField(field_map.Get(i));
+      }
+    }
+  }
 
   mirror::ArtMethod* clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
-  if (clinit != NULL && can_run_clinit) {
-    if (Runtime::Current()->IsStarted()) {
+  if (clinit != NULL) {
+    CHECK(can_init_statics);
+    if (LIKELY(Runtime::Current()->IsStarted())) {
       JValue result;
       clinit->Invoke(self, NULL, 0, &result, 'V');
     } else {
@@ -2781,11 +2871,8 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, boo
     }
   }
 
-  // Opportunistically set static method trampolines to their destination. Unless initialization
-  // is being hindered at compile time.
-  if (can_init_statics || can_run_clinit || (!has_static_field_initializers && clinit == NULL)) {
-    FixupStaticTrampolines(klass);
-  }
+  // Opportunistically set static method trampolines to their destination.
+  FixupStaticTrampolines(klass);
 
   uint64_t t1 = NanoTime();
 
@@ -2805,14 +2892,8 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, boo
       global_stats->class_init_time_ns += (t1 - t0);
       thread_stats->class_init_time_ns += (t1 - t0);
       // Set the class as initialized except if failed to initialize static fields.
-      if ((!can_init_statics && has_static_field_initializers) ||
-          (!can_run_clinit && clinit != NULL)) {
-        klass->SetStatus(mirror::Class::kStatusVerified);
-        success = false;
-      } else {
-        klass->SetStatus(mirror::Class::kStatusInitialized);
-      }
-      if (success && VLOG_IS_ON(class_linker)) {
+      klass->SetStatus(mirror::Class::kStatusInitialized);
+      if (VLOG_IS_ON(class_linker)) {
         ClassHelper kh(klass);
         LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
       }
@@ -2826,6 +2907,7 @@ bool ClassLinker::WaitForInitializeClass(mirror::Class* klass, Thread* self, Obj
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   while (true) {
     self->AssertNoPendingException();
+    CHECK(!klass->IsInitialized());
     lock.WaitIgnoringInterrupts();
 
     // When we wake up, repeat the test for init-in-progress.  If
@@ -2952,43 +3034,16 @@ bool ClassLinker::IsSameDescriptorInDifferentClassContexts(const char* descripto
   return found1 == found2;
 }
 
-bool ClassLinker::InitializeSuperClass(mirror::Class* klass, bool can_run_clinit, bool can_init_fields) {
-  CHECK(klass != NULL);
-  if (!klass->IsInterface() && klass->HasSuperClass()) {
-    mirror::Class* super_class = klass->GetSuperClass();
-    if (!super_class->IsInitialized()) {
-      CHECK(!super_class->IsInterface());
-      // Must hold lock on object when initializing and setting status.
-      Thread* self = Thread::Current();
-      ObjectLock lock(self, klass);
-      bool super_initialized = InitializeClass(super_class, can_run_clinit, can_init_fields);
-      // TODO: check for a pending exception
-      if (!super_initialized) {
-        if (!can_run_clinit) {
-          // Don't set status to error when we can't run <clinit>.
-          CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusInitializing) << PrettyClass(klass);
-          klass->SetStatus(mirror::Class::kStatusVerified);
-          return false;
-        }
-        klass->SetStatus(mirror::Class::kStatusError);
-        klass->NotifyAll(self);
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-bool ClassLinker::EnsureInitialized(mirror::Class* c, bool can_run_clinit, bool can_init_fields) {
+bool ClassLinker::EnsureInitialized(mirror::Class* c, bool can_init_fields, bool can_init_parents) {
   DCHECK(c != NULL);
   if (c->IsInitialized()) {
     return true;
   }
 
-  bool success = InitializeClass(c, can_run_clinit, can_init_fields);
+  bool success = InitializeClass(c, can_init_fields, can_init_parents);
   if (!success) {
     Thread* self = Thread::Current();
-    CHECK(self->IsExceptionPending() || !can_run_clinit) << PrettyClass(c);
+    CHECK(self->IsExceptionPending() || !can_init_fields || !can_init_parents) << PrettyClass(c);
   }
   return success;
 }
@@ -3003,38 +3058,6 @@ void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::Clas
   }
 }
 
-bool ClassLinker::InitializeStaticFields(mirror::Class* klass, bool can_init_statics) {
-  size_t num_static_fields = klass->NumStaticFields();
-  if (num_static_fields == 0) {
-    return false;
-  }
-  mirror::DexCache* dex_cache = klass->GetDexCache();
-  // TODO: this seems like the wrong check. do we really want !IsPrimitive && !IsArray?
-  if (dex_cache == NULL) {
-    return false;
-  }
-  ClassHelper kh(klass);
-  const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
-  CHECK(dex_class_def != NULL);
-  const DexFile& dex_file = kh.GetDexFile();
-  EncodedStaticFieldValueIterator it(dex_file, dex_cache, klass->GetClassLoader(),
-                                     this, *dex_class_def);
-
-  if (!it.HasNext()) {
-    return false;
-  } else {
-    if (can_init_statics) {
-      // We reordered the fields, so we need to be able to map the field indexes to the right fields.
-      SafeMap<uint32_t, mirror::ArtField*> field_map;
-      ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
-      for (size_t i = 0; it.HasNext(); i++, it.Next()) {
-        it.ReadValueToField(field_map.Get(i));
-      }
-    }
-    return true;
-  }
-}
-
 bool ClassLinker::LinkClass(SirtRef<mirror::Class>& klass,
                             mirror::ObjectArray<mirror::Class>* interfaces) {
   CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index 624b7cecec..5ef6d8f006 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -437,16 +437,11 @@ class ClassLinker {
   void RegisterOatFileLocked(const OatFile& oat_file) EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
       EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
 
-  bool InitializeClass(mirror::Class* klass, bool can_run_clinit, bool can_init_statics)
+  bool InitializeClass(mirror::Class* klass, bool can_run_clinit, bool can_init_parents)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   bool WaitForInitializeClass(mirror::Class* klass, Thread* self, ObjectLock& lock);
   bool ValidateSuperClassDescriptors(const mirror::Class* klass)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  bool InitializeSuperClass(mirror::Class* klass, bool can_run_clinit, bool can_init_fields)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  // Initialize static fields, returns true if fields were initialized.
-  bool InitializeStaticFields(mirror::Class* klass, bool can_init_statics)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   bool IsSameDescriptorInDifferentClassContexts(const char* descriptor,
                                                 const mirror::Class* klass1,
diff --git a/runtime/exception_test.cc b/runtime/exception_test.cc
index e48208d771..2e6b0a8f56 100644
--- a/runtime/exception_test.cc
+++ b/runtime/exception_test.cc
@@ -41,7 +41,7 @@ class ExceptionTest : public CommonTest {
                                       soa.Decode<mirror::ClassLoader*>(LoadDex("ExceptionHandle")));
     my_klass_ = class_linker_->FindClass("LExceptionHandle;", class_loader.get());
     ASSERT_TRUE(my_klass_ != NULL);
-    class_linker_->EnsureInitialized(my_klass_, false, true);
+    class_linker_->EnsureInitialized(my_klass_, true, true);
 
     dex_ = my_klass_->GetDexCache()->GetDexFile();
 
diff --git a/runtime/mirror/class.cc b/runtime/mirror/class.cc
index 29025f26c8..19e134fdfe 100644
--- a/runtime/mirror/class.cc
+++ b/runtime/mirror/class.cc
@@ -51,14 +51,20 @@ void Class::ResetClass() {
 }
 
 void Class::SetStatus(Status new_status) {
-  CHECK(new_status > GetStatus() || new_status == kStatusError || !Runtime::Current()->IsStarted())
-      << PrettyClass(this) << " " << GetStatus() << " -> " << new_status;
-  CHECK(sizeof(Status) == sizeof(uint32_t)) << PrettyClass(this);
+  if (UNLIKELY(new_status <= GetStatus() && new_status != kStatusError)) {
+    bool class_linker_initialized = Runtime::Current()->GetClassLinker() != nullptr;
+    if (class_linker_initialized) {
+      LOG(FATAL) << "Unexpected change back of class status for " << PrettyClass(this) << " "
+          << GetStatus() << " -> " << new_status;
+    }
+  }
   if (new_status > kStatusResolved) {
-    CHECK_EQ(GetThinLockId(), Thread::Current()->GetThinLockId()) << PrettyClass(this);
+    CHECK_EQ(GetThinLockId(), Thread::Current()->GetThinLockId())
+        << "Attempt to change status of class while not holding its lock " << PrettyClass(this);
   }
   if (new_status == kStatusError) {
-    CHECK_NE(GetStatus(), kStatusError) << PrettyClass(this);
+    CHECK_NE(GetStatus(), kStatusError)
+        << "Attempt to set as erroneous an already erroneous class " << PrettyClass(this);
 
     // Stash current exception.
     Thread* self = Thread::Current();
@@ -96,6 +102,7 @@ void Class::SetStatus(Status new_status) {
 
     self->SetException(gc_safe_throw_location, old_exception.get());
   }
+  CHECK(sizeof(Status) == sizeof(uint32_t)) << PrettyClass(this);
   return SetField32(OFFSET_OF_OBJECT_MEMBER(Class, status_), new_status, false);
 }
 
-- 
cgit v1.2.3-59-g8ed1b


From 42b32404abdd9f66b4b168ad8b17bccebfeb99f3 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Thu, 22 Aug 2013 00:13:53 -0700
Subject: Update black list with Landroid/webkit/WebViewFactory;

Change-Id: I6689d116930e862826527adad9a4000ebe9a5d28
---
 compiler/driver/compiler_driver.cc | 1 +
 1 file changed, 1 insertion(+)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 7b83e40fb6..b1a5816d63 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -1734,6 +1734,7 @@ static const char* class_initializer_black_list[] = {
   "Landroid/webkit/JniUtil;",  // Calls System.loadLibrary.
   "Landroid/webkit/PluginManager;",  // // Calls OsConstants.initConstants.
   "Landroid/webkit/WebViewCore;",  // Calls System.loadLibrary.
+  "Landroid/webkit/WebViewFactory;",  // Calls -..-> android.os.SystemProperties.native_get.
   "Landroid/webkit/WebViewFactory$Preloader;",  // Calls to Class.forName.
   "Landroid/webkit/WebViewInputDispatcher;",  // Calls Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
   "Landroid/webkit/URLUtil;",  // Calls Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
-- 
cgit v1.2.3-59-g8ed1b


From 7dfb28c066159e6cde8181720f0c451a700ef966 Mon Sep 17 00:00:00 2001
From: Ian Rogers <irogers@google.com>
Date: Thu, 22 Aug 2013 08:18:36 -0700
Subject: Don't scan image space when starting runtime.

Bug 10432288.
Find Classes and Strings from dex caches lazily rather than when the image is
loaded.
Make class status changes do notifies when there can be waiters.
For Class lookup there's a pathology if we always search dex caches and
so after 1000 failures move all classes into the class table.
Be consistent in using "const char*" for class linker descriptors as this
most easily agrees with the type in the dex file.
Improve the intern run-test so that it has a case of a literal contained in the
image.
Modify image_test to allow any valid lock word rather than expecting 0, ideally
we wouldn't see inflated monitors but we do due to NotifyAll (see bug 6961405).

Change-Id: Ia9bfa748eeccb9b4498784b97c6823141b1f6db8
---
 compiler/driver/compiler_driver.cc      |   2 +-
 compiler/image_test.cc                  |   2 +-
 runtime/base/stringpiece.h              |  13 -
 runtime/class_linker.cc                 | 456 ++++++++++++++++++--------------
 runtime/class_linker.h                  |  51 ++--
 runtime/dex_instruction.cc              |  15 +-
 runtime/intern_table.cc                 |  85 ++++--
 runtime/intern_table.h                  |   5 -
 runtime/mirror/class.cc                 |  30 ++-
 runtime/mirror/class.h                  |   4 +-
 runtime/monitor.cc                      |  25 ++
 runtime/monitor.h                       |   3 +
 runtime/native/dalvik_system_DexFile.cc |   3 +-
 runtime/native/dalvik_system_VMDebug.cc |   3 +-
 test/016-intern/expected.txt            |   2 +
 test/016-intern/src/Main.java           |  24 +-
 16 files changed, 446 insertions(+), 277 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index c079e5209c..99f8fb7281 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -2094,7 +2094,7 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
                 mirror::ObjectArray<mirror::ArtField>* fields = klass->GetSFields();
                 CHECK_EQ(fields->GetLength(), 1);
                 fields->Get(0)->SetObj(klass, manager->GetClassLinker()->FindPrimitiveClass('V'));
-                klass->SetStatus(mirror::Class::kStatusInitialized);
+                klass->SetStatus(mirror::Class::kStatusInitialized, soa.Self());
               } else {
                 manager->GetClassLinker()->EnsureInitialized(klass, true, true);
               }
diff --git a/compiler/image_test.cc b/compiler/image_test.cc
index dcafc193dd..106ef9ac86 100644
--- a/compiler/image_test.cc
+++ b/compiler/image_test.cc
@@ -152,7 +152,7 @@ TEST_F(ImageTest, WriteRead) {
       // non image classes should be in a space after the image.
       EXPECT_GT(reinterpret_cast<byte*>(klass), image_end) << descriptor;
     }
-    EXPECT_EQ(*klass->GetRawLockWordAddress(), 0);  // address should have been removed from monitor
+    EXPECT_TRUE(Monitor::IsValidLockWord(*klass->GetRawLockWordAddress()));
   }
 }
 
diff --git a/runtime/base/stringpiece.h b/runtime/base/stringpiece.h
index 62088cc183..91b83f61dc 100644
--- a/runtime/base/stringpiece.h
+++ b/runtime/base/stringpiece.h
@@ -208,19 +208,6 @@ inline bool operator>=(const StringPiece& x, const StringPiece& y) {
 
 extern std::ostream& operator<<(std::ostream& o, const StringPiece& piece);
 
-struct StringPieceHash {
-  size_t operator()(const StringPiece& string_piece) const {
-    size_t string_size = string_piece.size();
-    const char* string_data = string_piece.data();
-    // This is the java.lang.String hashcode for convenience, not interoperability.
-    size_t hash = 0;
-    while (string_size--) {
-      hash = hash * 31 + *string_data++;
-    }
-    return hash;
-  }
-};
-
 }  // namespace art
 
 #endif  // ART_RUNTIME_BASE_STRINGPIECE_H_
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 3387a70915..cd4a720e24 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -187,6 +187,8 @@ ClassLinker* ClassLinker::CreateFromImage(InternTable* intern_table) {
 ClassLinker::ClassLinker(InternTable* intern_table)
     // dex_lock_ is recursive as it may be used in stack dumping.
     : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel),
+      dex_cache_image_class_lookup_required_(false),
+      failed_dex_cache_class_lookups_(0),
       class_roots_(NULL),
       array_iftable_(NULL),
       init_done_(false),
@@ -225,7 +227,7 @@ void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class
   CHECK(java_lang_Object.get() != NULL);
   // backfill Object as the super class of Class.
   java_lang_Class->SetSuperClass(java_lang_Object.get());
-  java_lang_Object->SetStatus(mirror::Class::kStatusLoaded);
+  java_lang_Object->SetStatus(mirror::Class::kStatusLoaded, self);
 
   // Object[] next to hold class roots.
   SirtRef<mirror::Class> object_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
@@ -243,7 +245,7 @@ void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class
   SirtRef<mirror::Class> java_lang_String(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::StringClass)));
   mirror::String::SetClass(java_lang_String.get());
   java_lang_String->SetObjectSize(sizeof(mirror::String));
-  java_lang_String->SetStatus(mirror::Class::kStatusResolved);
+  java_lang_String->SetStatus(mirror::Class::kStatusResolved, self);
 
   // Create storage for root classes, save away our work so far (requires descriptors).
   class_roots_ = mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.get(), kClassRootsMax);
@@ -281,7 +283,7 @@ void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class
       java_lang_DexCache(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::DexCacheClass)));
   SetClassRoot(kJavaLangDexCache, java_lang_DexCache.get());
   java_lang_DexCache->SetObjectSize(sizeof(mirror::DexCacheClass));
-  java_lang_DexCache->SetStatus(mirror::Class::kStatusResolved);
+  java_lang_DexCache->SetStatus(mirror::Class::kStatusResolved, self);
 
   // Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
   SirtRef<mirror::Class> java_lang_reflect_ArtField(self, AllocClass(self, java_lang_Class.get(),
@@ -289,7 +291,7 @@ void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class
   CHECK(java_lang_reflect_ArtField.get() != NULL);
   java_lang_reflect_ArtField->SetObjectSize(sizeof(mirror::ArtField));
   SetClassRoot(kJavaLangReflectArtField, java_lang_reflect_ArtField.get());
-  java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusResolved);
+  java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusResolved, self);
   mirror::ArtField::SetClass(java_lang_reflect_ArtField.get());
 
   SirtRef<mirror::Class> java_lang_reflect_ArtMethod(self, AllocClass(self, java_lang_Class.get(),
@@ -297,7 +299,7 @@ void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class
   CHECK(java_lang_reflect_ArtMethod.get() != NULL);
   java_lang_reflect_ArtMethod->SetObjectSize(sizeof(mirror::ArtMethod));
   SetClassRoot(kJavaLangReflectArtMethod, java_lang_reflect_ArtMethod.get());
-  java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusResolved);
+  java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusResolved, self);
 
   mirror::ArtMethod::SetClass(java_lang_reflect_ArtMethod.get());
 
@@ -334,15 +336,15 @@ void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class
   SetClassRoot(kPrimitiveChar, char_class.get());  // needs descriptor
 
   // Object, String and DexCache need to be rerun through FindSystemClass to finish init
-  java_lang_Object->SetStatus(mirror::Class::kStatusNotReady);
+  java_lang_Object->SetStatus(mirror::Class::kStatusNotReady, self);
   mirror::Class* Object_class = FindSystemClass("Ljava/lang/Object;");
   CHECK_EQ(java_lang_Object.get(), Object_class);
   CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(mirror::Object));
-  java_lang_String->SetStatus(mirror::Class::kStatusNotReady);
+  java_lang_String->SetStatus(mirror::Class::kStatusNotReady, self);
   mirror::Class* String_class = FindSystemClass("Ljava/lang/String;");
   CHECK_EQ(java_lang_String.get(), String_class);
   CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(mirror::String));
-  java_lang_DexCache->SetStatus(mirror::Class::kStatusNotReady);
+  java_lang_DexCache->SetStatus(mirror::Class::kStatusNotReady, self);
   mirror::Class* DexCache_class = FindSystemClass("Ljava/lang/DexCache;");
   CHECK_EQ(java_lang_String.get(), String_class);
   CHECK_EQ(java_lang_DexCache.get(), DexCache_class);
@@ -397,15 +399,15 @@ void ClassLinker::InitFromCompiler(const std::vector<const DexFile*>& boot_class
   CHECK_EQ(java_lang_Cloneable, kh.GetDirectInterface(0));
   CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
   // Run Class, ArtField, and ArtMethod through FindSystemClass. This initializes their
-  // dex_cache_ fields and register them in classes_.
+  // dex_cache_ fields and register them in class_table_.
   mirror::Class* Class_class = FindSystemClass("Ljava/lang/Class;");
   CHECK_EQ(java_lang_Class.get(), Class_class);
 
-  java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusNotReady);
+  java_lang_reflect_ArtMethod->SetStatus(mirror::Class::kStatusNotReady, self);
   mirror::Class* Art_method_class = FindSystemClass("Ljava/lang/reflect/ArtMethod;");
   CHECK_EQ(java_lang_reflect_ArtMethod.get(), Art_method_class);
 
-  java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusNotReady);
+  java_lang_reflect_ArtField->SetStatus(mirror::Class::kStatusNotReady, self);
   mirror::Class* Art_field_class = FindSystemClass("Ljava/lang/reflect/ArtField;");
   CHECK_EQ(java_lang_reflect_ArtField.get(), Art_field_class);
 
@@ -984,21 +986,14 @@ const OatFile* ClassLinker::FindOatFileFromOatLocationLocked(const std::string&
   return oat_file;
 }
 
-static void InitFromImageCallbackCommon(mirror::Object* obj, ClassLinker* class_linker,
-                                        bool interpret_only_mode)
+static void InitFromImageInterpretOnlyCallback(mirror::Object* obj, void* arg)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
+
   DCHECK(obj != NULL);
   DCHECK(class_linker != NULL);
 
-  if (obj->GetClass()->IsStringClass()) {
-    class_linker->GetInternTable()->RegisterStrong(obj->AsString());
-  } else if (obj->IsClass()) {
-    // Restore class to ClassLinker::classes_ table.
-    mirror::Class* klass = obj->AsClass();
-    ClassHelper kh(klass, class_linker);
-    mirror::Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
-    DCHECK(existing == NULL) << kh.GetDescriptor();
-  } else if (interpret_only_mode && obj->IsArtMethod()) {
+  if (obj->IsArtMethod()) {
     mirror::ArtMethod* method = obj->AsArtMethod();
     if (!method->IsNative()) {
       method->SetEntryPointFromInterpreter(interpreter::artInterpreterToInterpreterBridge);
@@ -1009,24 +1004,13 @@ static void InitFromImageCallbackCommon(mirror::Object* obj, ClassLinker* class_
   }
 }
 
-static void InitFromImageCallback(mirror::Object* obj, void* arg)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
-  InitFromImageCallbackCommon(obj, class_linker, false);
-}
-
-static void InitFromImageInterpretOnlyCallback(mirror::Object* obj, void* arg)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
-  InitFromImageCallbackCommon(obj, class_linker, true);
-}
-
 void ClassLinker::InitFromImage() {
   VLOG(startup) << "ClassLinker::InitFromImage entering";
   CHECK(!init_done_);
 
   gc::Heap* heap = Runtime::Current()->GetHeap();
   gc::space::ImageSpace* space = heap->GetImageSpace();
+  dex_cache_image_class_lookup_required_ = true;
   CHECK(space != NULL);
   OatFile& oat_file = GetImageOatFile(space);
   CHECK_EQ(oat_file.GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
@@ -1049,7 +1033,7 @@ void ClassLinker::InitFromImage() {
   CHECK_EQ(oat_file.GetOatHeader().GetDexFileCount(),
            static_cast<uint32_t>(dex_caches->GetLength()));
   Thread* self = Thread::Current();
-  for (int i = 0; i < dex_caches->GetLength(); i++) {
+  for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
     SirtRef<mirror::DexCache> dex_cache(self, dex_caches->Get(i));
     const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
     const OatFile::OatDexFile* oat_dex_file = oat_file.GetOatDexFile(dex_file_location);
@@ -1069,15 +1053,11 @@ void ClassLinker::InitFromImage() {
   // bitmap walk.
   mirror::ArtMethod::SetClass(GetClassRoot(kJavaLangReflectArtMethod));
 
-  // reinit clases_ table
-  {
+  // Set entry point to interpreter if in InterpretOnly mode.
+  if (Runtime::Current()->GetInstrumentation()->InterpretOnly()) {
     ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
     heap->FlushAllocStack();
-    if (Runtime::Current()->GetInstrumentation()->InterpretOnly()) {
-      heap->GetLiveBitmap()->Walk(InitFromImageInterpretOnlyCallback, this);
-    } else {
-      heap->GetLiveBitmap()->Walk(InitFromImageCallback, this);
-    }
+    heap->GetLiveBitmap()->Walk(InitFromImageInterpretOnlyCallback, this);
   }
 
   // reinit class_roots_
@@ -1120,7 +1100,7 @@ void ClassLinker::VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty)
 
   {
     ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
-    for (const std::pair<size_t, mirror::Class*>& it : classes_) {
+    for (const std::pair<size_t, mirror::Class*>& it : class_table_) {
       visitor(it.second, arg);
     }
 
@@ -1134,14 +1114,12 @@ void ClassLinker::VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty)
   }
 }
 
-void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) const {
-  ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
-  for (const std::pair<size_t, mirror::Class*>& it : classes_) {
-    if (!visitor(it.second, arg)) {
-      return;
-    }
+void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) {
+  if (dex_cache_image_class_lookup_required_) {
+    MoveImageClassesToClassTable();
   }
-  for (const std::pair<size_t, mirror::Class*>& it : image_classes_) {
+  ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
+  for (const std::pair<size_t, mirror::Class*>& it : class_table_) {
     if (!visitor(it.second, arg)) {
       return;
     }
@@ -1154,7 +1132,7 @@ static bool GetClassesVisitor(mirror::Class* c, void* arg) {
   return true;
 }
 
-void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const {
+void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) {
   std::set<mirror::Class*> classes;
   VisitClasses(GetClassesVisitor, &classes);
   for (mirror::Class* klass : classes) {
@@ -1274,7 +1252,7 @@ static mirror::Class* EnsureResolved(Thread* self, mirror::Class* klass)
     // Check for circular dependencies between classes.
     if (!klass->IsResolved() && klass->GetClinitThreadId() == self->GetTid()) {
       ThrowClassCircularityError(klass);
-      klass->SetStatus(mirror::Class::kStatusError);
+      klass->SetStatus(mirror::Class::kStatusError, self);
       return NULL;
     }
     // Wait for the pending initialization to complete.
@@ -1383,26 +1361,26 @@ mirror::Class* ClassLinker::FindClass(const char* descriptor, mirror::ClassLoade
   return NULL;
 }
 
-mirror::Class* ClassLinker::DefineClass(const StringPiece& descriptor,
+mirror::Class* ClassLinker::DefineClass(const char* descriptor,
                                         mirror::ClassLoader* class_loader,
                                         const DexFile& dex_file,
                                         const DexFile::ClassDef& dex_class_def) {
   Thread* self = Thread::Current();
   SirtRef<mirror::Class> klass(self, NULL);
   // Load the class from the dex file.
-  if (!init_done_) {
+  if (UNLIKELY(!init_done_)) {
     // finish up init of hand crafted class_roots_
-    if (descriptor == "Ljava/lang/Object;") {
+    if (strcmp(descriptor, "Ljava/lang/Object;") == 0) {
       klass.reset(GetClassRoot(kJavaLangObject));
-    } else if (descriptor == "Ljava/lang/Class;") {
+    } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) {
       klass.reset(GetClassRoot(kJavaLangClass));
-    } else if (descriptor == "Ljava/lang/String;") {
+    } else if (strcmp(descriptor, "Ljava/lang/String;") == 0) {
       klass.reset(GetClassRoot(kJavaLangString));
-    } else if (descriptor == "Ljava/lang/DexCache;") {
+    } else if (strcmp(descriptor, "Ljava/lang/DexCache;") == 0) {
       klass.reset(GetClassRoot(kJavaLangDexCache));
-    } else if (descriptor == "Ljava/lang/reflect/ArtField;") {
+    } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtField;") == 0) {
       klass.reset(GetClassRoot(kJavaLangReflectArtField));
-    } else if (descriptor == "Ljava/lang/reflect/ArtMethod;") {
+    } else if (strcmp(descriptor, "Ljava/lang/reflect/ArtMethod;") == 0) {
       klass.reset(GetClassRoot(kJavaLangReflectArtMethod));
     } else {
       klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
@@ -1414,32 +1392,33 @@ mirror::Class* ClassLinker::DefineClass(const StringPiece& descriptor,
   LoadClass(dex_file, dex_class_def, klass, class_loader);
   // Check for a pending exception during load
   if (self->IsExceptionPending()) {
-    klass->SetStatus(mirror::Class::kStatusError);
+    klass->SetStatus(mirror::Class::kStatusError, self);
     return NULL;
   }
   ObjectLock lock(self, klass.get());
   klass->SetClinitThreadId(self->GetTid());
-  // Add the newly loaded class to the loaded classes table.
-  SirtRef<mirror::Class> existing(self, InsertClass(descriptor, klass.get(), false));
-  if (existing.get() != NULL) {
-    // We failed to insert because we raced with another thread.
-    return EnsureResolved(self, existing.get());
+  {
+    // Add the newly loaded class to the loaded classes table.
+    mirror::Class* existing = InsertClass(descriptor, klass.get(), Hash(descriptor));
+    if (existing != NULL) {
+      // We failed to insert because we raced with another thread. Calling EnsureResolved may cause
+      // this thread to block.
+      return EnsureResolved(self, existing);
+    }
   }
   // Finish loading (if necessary) by finding parents
   CHECK(!klass->IsLoaded());
   if (!LoadSuperAndInterfaces(klass, dex_file)) {
     // Loading failed.
-    klass->SetStatus(mirror::Class::kStatusError);
-    lock.NotifyAll();
+    klass->SetStatus(mirror::Class::kStatusError, self);
     return NULL;
   }
   CHECK(klass->IsLoaded());
   // Link the class (if necessary)
   CHECK(!klass->IsResolved());
-  if (!LinkClass(klass, NULL)) {
+  if (!LinkClass(klass, NULL, self)) {
     // Linking failed.
-    klass->SetStatus(mirror::Class::kStatusError);
-    lock.NotifyAll();
+    klass->SetStatus(mirror::Class::kStatusError, self);
     return NULL;
   }
   CHECK(klass->IsResolved());
@@ -1734,7 +1713,7 @@ void ClassLinker::LoadClass(const DexFile& dex_file,
   klass->SetAccessFlags(access_flags);
   klass->SetClassLoader(class_loader);
   DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
-  klass->SetStatus(mirror::Class::kStatusIdx);
+  klass->SetStatus(mirror::Class::kStatusIdx, NULL);
 
   klass->SetDexTypeIndex(dex_class_def.class_idx_);
 
@@ -1966,11 +1945,13 @@ mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type t
 mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type) {
   CHECK(primitive_class != NULL);
   // Must hold lock on object when initializing.
-  ObjectLock lock(Thread::Current(), primitive_class);
+  Thread* self = Thread::Current();
+  ObjectLock lock(self, primitive_class);
   primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
   primitive_class->SetPrimitiveType(type);
-  primitive_class->SetStatus(mirror::Class::kStatusInitialized);
-  mirror::Class* existing = InsertClass(Primitive::Descriptor(type), primitive_class, false);
+  primitive_class->SetStatus(mirror::Class::kStatusInitialized, self);
+  const char* descriptor = Primitive::Descriptor(type);
+  mirror::Class* existing = InsertClass(descriptor, primitive_class, Hash(descriptor));
   CHECK(existing == NULL) << "InitPrimitiveClass(" << type << ") failed";
   return primitive_class;
 }
@@ -1988,12 +1969,11 @@ mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_cl
 // array class; that always comes from the base element class.
 //
 // Returns NULL with an exception raised on failure.
-mirror::Class* ClassLinker::CreateArrayClass(const std::string& descriptor,
+mirror::Class* ClassLinker::CreateArrayClass(const char* descriptor,
                                              mirror::ClassLoader* class_loader) {
-  CHECK_EQ('[', descriptor[0]);
-
   // Identify the underlying component type
-  mirror::Class* component_type = FindClass(descriptor.substr(1).c_str(), class_loader);
+  CHECK_EQ('[', descriptor[0]);
+  mirror::Class* component_type = FindClass(descriptor + 1, class_loader);
   if (component_type == NULL) {
     DCHECK(Thread::Current()->IsExceptionPending());
     return NULL;
@@ -2017,7 +1997,7 @@ mirror::Class* ClassLinker::CreateArrayClass(const std::string& descriptor,
   // class to the hash table --- necessary because of possible races with
   // other threads.)
   if (class_loader != component_type->GetClassLoader()) {
-    mirror::Class* new_class = LookupClass(descriptor.c_str(), component_type->GetClassLoader());
+    mirror::Class* new_class = LookupClass(descriptor, component_type->GetClassLoader());
     if (new_class != NULL) {
       return new_class;
     }
@@ -2033,21 +2013,23 @@ mirror::Class* ClassLinker::CreateArrayClass(const std::string& descriptor,
   // link step.
   Thread* self = Thread::Current();
   SirtRef<mirror::Class> new_class(self, NULL);
-  if (!init_done_) {
+  if (UNLIKELY(!init_done_)) {
     // Classes that were hand created, ie not by FindSystemClass
-    if (descriptor == "[Ljava/lang/Class;") {
+    if (strcmp(descriptor, "[Ljava/lang/Class;") == 0) {
       new_class.reset(GetClassRoot(kClassArrayClass));
-    } else if (descriptor == "[Ljava/lang/Object;") {
+    } else if (strcmp(descriptor, "[Ljava/lang/Object;") == 0) {
       new_class.reset(GetClassRoot(kObjectArrayClass));
-    } else if (descriptor == class_roots_descriptors_[kJavaLangStringArrayClass]) {
+    } else if (strcmp(descriptor, class_roots_descriptors_[kJavaLangStringArrayClass]) == 0) {
       new_class.reset(GetClassRoot(kJavaLangStringArrayClass));
-    } else if (descriptor == class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]) {
+    } else if (strcmp(descriptor,
+                      class_roots_descriptors_[kJavaLangReflectArtMethodArrayClass]) == 0) {
       new_class.reset(GetClassRoot(kJavaLangReflectArtMethodArrayClass));
-    } else if (descriptor == class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]) {
+    } else if (strcmp(descriptor,
+                      class_roots_descriptors_[kJavaLangReflectArtFieldArrayClass]) == 0) {
       new_class.reset(GetClassRoot(kJavaLangReflectArtFieldArrayClass));
-    } else if (descriptor == "[C") {
+    } else if (strcmp(descriptor, "[C") == 0) {
       new_class.reset(GetClassRoot(kCharArrayClass));
-    } else if (descriptor == "[I") {
+    } else if (strcmp(descriptor, "[I") == 0) {
       new_class.reset(GetClassRoot(kIntArrayClass));
     }
   }
@@ -2065,7 +2047,7 @@ mirror::Class* ClassLinker::CreateArrayClass(const std::string& descriptor,
   new_class->SetVTable(java_lang_Object->GetVTable());
   new_class->SetPrimitiveType(Primitive::kPrimNot);
   new_class->SetClassLoader(component_type->GetClassLoader());
-  new_class->SetStatus(mirror::Class::kStatusInitialized);
+  new_class->SetStatus(mirror::Class::kStatusInitialized, self);
   // don't need to set new_class->SetObjectSize(..)
   // because Object::SizeOf delegates to Array::SizeOf
 
@@ -2096,7 +2078,7 @@ mirror::Class* ClassLinker::CreateArrayClass(const std::string& descriptor,
 
   new_class->SetAccessFlags(access_flags);
 
-  mirror::Class* existing = InsertClass(descriptor, new_class.get(), false);
+  mirror::Class* existing = InsertClass(descriptor, new_class.get(), Hash(descriptor));
   if (existing == NULL) {
     return new_class.get();
   }
@@ -2137,8 +2119,8 @@ mirror::Class* ClassLinker::FindPrimitiveClass(char type) {
   return NULL;
 }
 
-mirror::Class* ClassLinker::InsertClass(const StringPiece& descriptor, mirror::Class* klass,
-                                        bool image_class) {
+mirror::Class* ClassLinker::InsertClass(const char* descriptor, mirror::Class* klass,
+                                        size_t hash) {
   if (VLOG_IS_ON(class_linker)) {
     mirror::DexCache* dex_cache = klass->GetDexCache();
     std::string source;
@@ -2148,21 +2130,22 @@ mirror::Class* ClassLinker::InsertClass(const StringPiece& descriptor, mirror::C
     }
     LOG(INFO) << "Loaded class " << descriptor << source;
   }
-  size_t hash = StringPieceHash()(descriptor);
   WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
-  Table& classes = image_class ? image_classes_ : classes_;
   mirror::Class* existing =
-      LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, classes);
-#ifndef NDEBUG
-  // Check we don't have the class in the other table in error
-  Table& other_classes = image_class ? classes_ : image_classes_;
-  CHECK(LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, other_classes) == NULL);
-#endif
+      LookupClassFromTableLocked(descriptor, klass->GetClassLoader(), hash);
   if (existing != NULL) {
     return existing;
   }
+  if (kIsDebugBuild && klass->GetClassLoader() == NULL && dex_cache_image_class_lookup_required_) {
+    // Check a class loaded with the system class loader matches one in the image if the class
+    // is in the image.
+    existing = LookupClassFromImage(descriptor);
+    if (existing != NULL) {
+      CHECK(klass == existing);
+    }
+  }
   Runtime::Current()->GetHeap()->VerifyObject(klass);
-  classes.insert(std::make_pair(hash, klass));
+  class_table_.insert(std::make_pair(hash, klass));
   Dirty();
   return NULL;
 }
@@ -2170,23 +2153,13 @@ mirror::Class* ClassLinker::InsertClass(const StringPiece& descriptor, mirror::C
 bool ClassLinker::RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader) {
   size_t hash = Hash(descriptor);
   WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
-  // TODO: determine if its better to search classes_ or image_classes_ first
   ClassHelper kh;
-  for (auto it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash;
+  for (auto it = class_table_.lower_bound(hash), end = class_table_.end(); it != end && it->first == hash;
        ++it) {
     mirror::Class* klass = it->second;
     kh.ChangeClass(klass);
     if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
-      classes_.erase(it);
-      return true;
-    }
-  }
-  for (auto it = image_classes_.lower_bound(hash), end = classes_.end();
-      it != end && it->first == hash; ++it) {
-    mirror::Class* klass = it->second;
-    kh.ChangeClass(klass);
-    if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
-      image_classes_.erase(it);
+      class_table_.erase(it);
       return true;
     }
   }
@@ -2196,64 +2169,153 @@ bool ClassLinker::RemoveClass(const char* descriptor, const mirror::ClassLoader*
 mirror::Class* ClassLinker::LookupClass(const char* descriptor,
                                         const mirror::ClassLoader* class_loader) {
   size_t hash = Hash(descriptor);
-  ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
-  // TODO: determine if its better to search classes_ or image_classes_ first
-  mirror::Class* klass = NULL;
-  // Use image class only if the class_loader is null.
-  if (class_loader == NULL) {
-    klass = LookupClassLocked(descriptor, class_loader, hash, image_classes_);
+  {
+    ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
+    mirror::Class* result = LookupClassFromTableLocked(descriptor, class_loader, hash);
+    if (result != NULL) {
+      return result;
+    }
   }
-  if (klass != NULL) {
-    return klass;
+  if (class_loader != NULL || !dex_cache_image_class_lookup_required_) {
+    return NULL;
+  } else {
+    // Lookup failed but need to search dex_caches_.
+    mirror::Class* result = LookupClassFromImage(descriptor);
+    if (result != NULL) {
+      InsertClass(descriptor, result, hash);
+    } else {
+      // Searching the image dex files/caches failed, we don't want to get into this situation
+      // often as map searches are faster, so after kMaxFailedDexCacheLookups move all image
+      // classes into the class table.
+      const int32_t kMaxFailedDexCacheLookups = 1000;
+      if (++failed_dex_cache_class_lookups_ > kMaxFailedDexCacheLookups) {
+        MoveImageClassesToClassTable();
+      }
+    }
+    return result;
   }
-  return LookupClassLocked(descriptor, class_loader, hash, classes_);
 }
 
-mirror::Class* ClassLinker::LookupClassLocked(const char* descriptor,
-                                              const mirror::ClassLoader* class_loader,
-                                              size_t hash, const Table& classes) {
+mirror::Class* ClassLinker::LookupClassFromTableLocked(const char* descriptor,
+                                                       const mirror::ClassLoader* class_loader,
+                                                       size_t hash) {
   ClassHelper kh(NULL, this);
-  auto end = classes_.end();
-  for (auto it = classes.lower_bound(hash); it != end && it->first == hash;
-      ++it) {
+  auto end = class_table_.end();
+  for (auto it = class_table_.lower_bound(hash); it != end && it->first == hash; ++it) {
     mirror::Class* klass = it->second;
     kh.ChangeClass(klass);
-    if (strcmp(descriptor, kh.GetDescriptor()) == 0 && klass->GetClassLoader() == class_loader) {
-#ifndef NDEBUG
-      for (++it; it != end && it->first == hash; ++it) {
-        mirror::Class* klass2 = it->second;
-        kh.ChangeClass(klass2);
-        CHECK(!(strcmp(descriptor, kh.GetDescriptor()) == 0 && klass2->GetClassLoader() == class_loader))
-                << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
-                << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
+    if (klass->GetClassLoader() == class_loader && strcmp(descriptor, kh.GetDescriptor()) == 0) {
+      if (kIsDebugBuild) {
+        // Check for duplicates in the table.
+        for (++it; it != end && it->first == hash; ++it) {
+          mirror::Class* klass2 = it->second;
+          kh.ChangeClass(klass2);
+          CHECK(!(strcmp(descriptor, kh.GetDescriptor()) == 0 && klass2->GetClassLoader() == class_loader))
+          << PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
+          << PrettyClass(klass2) << " " << klass2 << " " << klass2->GetClassLoader();
+        }
       }
-#endif
       return klass;
     }
   }
   return NULL;
 }
 
-void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Class*>& classes) {
-  classes.clear();
-  size_t hash = Hash(descriptor);
-  ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
-  // TODO: determine if its better to search classes_ or image_classes_ first
+static mirror::ObjectArray<mirror::DexCache>* GetImageDexCaches()
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  gc::space::ImageSpace* image = Runtime::Current()->GetHeap()->GetImageSpace();
+  CHECK(image != NULL);
+  mirror::Object* root = image->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
+  return root->AsObjectArray<mirror::DexCache>();
+}
+
+void ClassLinker::MoveImageClassesToClassTable() {
+  Thread* self = Thread::Current();
+  WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
+  if (!dex_cache_image_class_lookup_required_) {
+    return;  // All dex cache classes are already in the class table.
+  }
+  const char* old_no_suspend_cause =
+      self->StartAssertNoThreadSuspension("Moving image classes to class table");
+  mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
   ClassHelper kh(NULL, this);
-  for (auto it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash;
-      ++it) {
-    mirror::Class* klass = it->second;
-    kh.ChangeClass(klass);
-    if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
-      classes.push_back(klass);
+  for (int32_t i = 0; i < dex_caches->GetLength(); i++) {
+    mirror::DexCache* dex_cache = dex_caches->Get(i);
+    mirror::ObjectArray<mirror::Class>* types = dex_cache->GetResolvedTypes();
+    for (int32_t j = 0; j < types->GetLength(); j++) {
+      mirror::Class* klass = types->Get(j);
+      if (klass != NULL) {
+        kh.ChangeClass(klass);
+        DCHECK(klass->GetClassLoader() == NULL);
+        const char* descriptor = kh.GetDescriptor();
+        size_t hash = Hash(descriptor);
+        mirror::Class* existing = LookupClassFromTableLocked(descriptor, NULL, hash);
+        if (existing != NULL) {
+          CHECK(existing == klass) << PrettyClassAndClassLoader(existing) << " != "
+              << PrettyClassAndClassLoader(klass);
+        } else {
+          class_table_.insert(std::make_pair(hash, klass));
+        }
+      }
     }
   }
-  for (auto it = image_classes_.lower_bound(hash), end = classes_.end();
+  Dirty();
+  dex_cache_image_class_lookup_required_ = false;
+  self->EndAssertNoThreadSuspension(old_no_suspend_cause);
+}
+
+mirror::Class* ClassLinker::LookupClassFromImage(const char* descriptor) {
+  Thread* self = Thread::Current();
+  const char* old_no_suspend_cause =
+      self->StartAssertNoThreadSuspension("Image class lookup");
+  mirror::ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
+  for (int32_t i = 0; i < dex_caches->GetLength(); ++i) {
+    mirror::DexCache* dex_cache = dex_caches->Get(i);
+    const DexFile* dex_file = dex_cache->GetDexFile();
+    // First search using the class def map, but don't bother for non-class types.
+    if (descriptor[0] == 'L') {
+      const DexFile::ClassDef* class_def = dex_file->FindClassDef(descriptor);
+      if (class_def != NULL) {
+        mirror::Class* klass = dex_cache->GetResolvedType(class_def->class_idx_);
+        if (klass != NULL) {
+          self->EndAssertNoThreadSuspension(old_no_suspend_cause);
+          return klass;
+        }
+      }
+    }
+    // Now try binary searching the string/type index.
+    const DexFile::StringId* string_id = dex_file->FindStringId(descriptor);
+    if (string_id != NULL) {
+      const DexFile::TypeId* type_id =
+          dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id));
+      if (type_id != NULL) {
+        uint16_t type_idx = dex_file->GetIndexForTypeId(*type_id);
+        mirror::Class* klass = dex_cache->GetResolvedType(type_idx);
+        if (klass != NULL) {
+          self->EndAssertNoThreadSuspension(old_no_suspend_cause);
+          return klass;
+        }
+      }
+    }
+  }
+  self->EndAssertNoThreadSuspension(old_no_suspend_cause);
+  return NULL;
+}
+
+void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Class*>& result) {
+  result.clear();
+  if (dex_cache_image_class_lookup_required_) {
+    MoveImageClassesToClassTable();
+  }
+  size_t hash = Hash(descriptor);
+  ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
+  ClassHelper kh(NULL, this);
+  for (auto it = class_table_.lower_bound(hash), end = class_table_.end();
       it != end && it->first == hash; ++it) {
     mirror::Class* klass = it->second;
     kh.ChangeClass(klass);
     if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
-      classes.push_back(klass);
+      result.push_back(klass);
     }
   }
 }
@@ -2277,12 +2339,12 @@ void ClassLinker::VerifyClass(mirror::Class* klass) {
   }
 
   if (klass->GetStatus() == mirror::Class::kStatusResolved) {
-    klass->SetStatus(mirror::Class::kStatusVerifying);
+    klass->SetStatus(mirror::Class::kStatusVerifying, self);
   } else {
     CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime)
         << PrettyClass(klass);
     CHECK(!Runtime::Current()->IsCompiler());
-    klass->SetStatus(mirror::Class::kStatusVerifyingAtRuntime);
+    klass->SetStatus(mirror::Class::kStatusVerifyingAtRuntime, self);
   }
 
   // Verify super class.
@@ -2307,7 +2369,7 @@ void ClassLinker::VerifyClass(mirror::Class* klass) {
       if (cause.get() != NULL) {
         self->GetException(NULL)->SetCause(cause.get());
       }
-      klass->SetStatus(mirror::Class::kStatusError);
+      klass->SetStatus(mirror::Class::kStatusError, self);
       return;
     }
   }
@@ -2322,7 +2384,7 @@ void ClassLinker::VerifyClass(mirror::Class* klass) {
         << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
     ThrowVerifyError(klass, "Rejecting class %s because it failed compile-time verification",
                      PrettyDescriptor(klass).c_str());
-    klass->SetStatus(mirror::Class::kStatusError);
+    klass->SetStatus(mirror::Class::kStatusError, self);
     return;
   }
   verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
@@ -2344,10 +2406,10 @@ void ClassLinker::VerifyClass(mirror::Class* klass) {
       // Even though there were no verifier failures we need to respect whether the super-class
       // was verified or requiring runtime reverification.
       if (super.get() == NULL || super->IsVerified()) {
-        klass->SetStatus(mirror::Class::kStatusVerified);
+        klass->SetStatus(mirror::Class::kStatusVerified, self);
       } else {
         CHECK_EQ(super->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime);
-        klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime);
+        klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime, self);
         // Pretend a soft failure occured so that we don't consider the class verified below.
         verifier_failure = verifier::MethodVerifier::kSoftFailure;
       }
@@ -2357,9 +2419,9 @@ void ClassLinker::VerifyClass(mirror::Class* klass) {
       // failures at runtime will be handled by slow paths in the generated
       // code. Set status accordingly.
       if (Runtime::Current()->IsCompiler()) {
-        klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime);
+        klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime, self);
       } else {
-        klass->SetStatus(mirror::Class::kStatusVerified);
+        klass->SetStatus(mirror::Class::kStatusVerified, self);
       }
     }
   } else {
@@ -2368,7 +2430,7 @@ void ClassLinker::VerifyClass(mirror::Class* klass) {
         << " because: " << error_msg;
     self->AssertNoPendingException();
     ThrowVerifyError(klass, "%s", error_msg.c_str());
-    klass->SetStatus(mirror::Class::kStatusError);
+    klass->SetStatus(mirror::Class::kStatusError, self);
   }
   if (preverified || verifier_failure == verifier::MethodVerifier::kNoFailure) {
     // Class is verified so we don't need to do any access check on its methods.
@@ -2522,7 +2584,7 @@ mirror::Class* ClassLinker::CreateProxyClass(mirror::String* name,
   mirror::Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
   klass->SetDexCache(proxy_class->GetDexCache());
 
-  klass->SetStatus(mirror::Class::kStatusIdx);
+  klass->SetStatus(mirror::Class::kStatusIdx, self);
 
   klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
 
@@ -2555,19 +2617,20 @@ mirror::Class* ClassLinker::CreateProxyClass(mirror::String* name,
   }
 
   klass->SetSuperClass(proxy_class);  // The super class is java.lang.reflect.Proxy
-  klass->SetStatus(mirror::Class::kStatusLoaded);  // Class is now effectively in the loaded state
+  klass->SetStatus(mirror::Class::kStatusLoaded, self);  // Class is now effectively in the loaded state
   self->AssertNoPendingException();
 
-  // Link the fields and virtual methods, creating vtable and iftables
-  if (!LinkClass(klass, interfaces)) {
-    klass->SetStatus(mirror::Class::kStatusError);
-    return NULL;
-  }
   {
-    ObjectLock lock(self, klass.get());  // Must hold lock on object when initializing.
+    ObjectLock lock(self, klass.get());  // Must hold lock on object when resolved.
+    // Link the fields and virtual methods, creating vtable and iftables
+    if (!LinkClass(klass, interfaces, self)) {
+      klass->SetStatus(mirror::Class::kStatusError, self);
+      return NULL;
+    }
+
     interfaces_sfield->SetObject(klass.get(), interfaces);
     throws_sfield->SetObject(klass.get(), throws);
-    klass->SetStatus(mirror::Class::kStatusInitialized);
+    klass->SetStatus(mirror::Class::kStatusInitialized, self);
   }
 
   // sanity checks
@@ -2806,7 +2869,7 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_init_statics,
     }
 
     if (!ValidateSuperClassDescriptors(klass)) {
-      klass->SetStatus(mirror::Class::kStatusError);
+      klass->SetStatus(mirror::Class::kStatusError, self);
       return false;
     }
 
@@ -2815,7 +2878,7 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_init_statics,
     // From here out other threads may observe that we're initializing and so changes of state
     // require the a notification.
     klass->SetClinitThreadId(self->GetTid());
-    klass->SetStatus(mirror::Class::kStatusInitializing);
+    klass->SetStatus(mirror::Class::kStatusInitializing, self);
 
     t0 = NanoTime();
   }
@@ -2837,8 +2900,7 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_init_statics,
             << (self->GetException(NULL) != NULL ? self->GetException(NULL)->Dump() : "");
         ObjectLock lock(self, klass);
         // Initialization failed because the super-class is erroneous.
-        klass->SetStatus(mirror::Class::kStatusError);
-        lock.NotifyAll();
+        klass->SetStatus(mirror::Class::kStatusError, self);
         return false;
       }
     }
@@ -2884,7 +2946,7 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_init_statics,
 
     if (self->IsExceptionPending()) {
       WrapExceptionInInitializer();
-      klass->SetStatus(mirror::Class::kStatusError);
+      klass->SetStatus(mirror::Class::kStatusError, self);
       success = false;
     } else {
       RuntimeStats* global_stats = Runtime::Current()->GetStats();
@@ -2894,13 +2956,12 @@ bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_init_statics,
       global_stats->class_init_time_ns += (t1 - t0);
       thread_stats->class_init_time_ns += (t1 - t0);
       // Set the class as initialized except if failed to initialize static fields.
-      klass->SetStatus(mirror::Class::kStatusInitialized);
+      klass->SetStatus(mirror::Class::kStatusInitialized, self);
       if (VLOG_IS_ON(class_linker)) {
         ClassHelper kh(klass);
         LOG(INFO) << "Initialized class " << kh.GetDescriptor() << " from " << kh.GetLocation();
       }
     }
-    lock.NotifyAll();
   }
   return success;
 }
@@ -2917,7 +2978,7 @@ bool ClassLinker::WaitForInitializeClass(mirror::Class* klass, Thread* self, Obj
     // "interruptShouldThrow" was set), bail out.
     if (self->IsExceptionPending()) {
       WrapExceptionInInitializer();
-      klass->SetStatus(mirror::Class::kStatusError);
+      klass->SetStatus(mirror::Class::kStatusError, self);
       return false;
     }
     // Spurious wakeup? Go back to waiting.
@@ -3061,7 +3122,7 @@ void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::Clas
 }
 
 bool ClassLinker::LinkClass(SirtRef<mirror::Class>& klass,
-                            mirror::ObjectArray<mirror::Class>* interfaces) {
+                            mirror::ObjectArray<mirror::Class>* interfaces, Thread* self) {
   CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
   if (!LinkSuperClass(klass)) {
     return false;
@@ -3078,7 +3139,7 @@ bool ClassLinker::LinkClass(SirtRef<mirror::Class>& klass,
   CreateReferenceInstanceOffsets(klass);
   CreateReferenceStaticOffsets(klass);
   CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
-  klass->SetStatus(mirror::Class::kStatusResolved);
+  klass->SetStatus(mirror::Class::kStatusResolved, self);
   return true;
 }
 
@@ -3123,7 +3184,7 @@ bool ClassLinker::LoadSuperAndInterfaces(SirtRef<mirror::Class>& klass, const De
     }
   }
   // Mark the class as loaded.
-  klass->SetStatus(mirror::Class::kStatusLoaded);
+  klass->SetStatus(mirror::Class::kStatusLoaded, NULL);
   return true;
 }
 
@@ -3175,13 +3236,13 @@ bool ClassLinker::LinkSuperClass(SirtRef<mirror::Class>& klass) {
     return false;
   }
 
-#ifndef NDEBUG
-  // Ensure super classes are fully resolved prior to resolving fields..
-  while (super != NULL) {
-    CHECK(super->IsResolved());
-    super = super->GetSuperClass();
+  if (kIsDebugBuild) {
+    // Ensure super classes are fully resolved prior to resolving fields..
+    while (super != NULL) {
+      CHECK(super->IsResolved());
+      super = super->GetSuperClass();
+    }
   }
-#endif
   return true;
 }
 
@@ -3992,16 +4053,16 @@ const char* ClassLinker::MethodShorty(uint32_t method_idx, mirror::ArtMethod* re
   return dex_file.GetMethodShorty(method_id, length);
 }
 
-void ClassLinker::DumpAllClasses(int flags) const {
+void ClassLinker::DumpAllClasses(int flags) {
+  if (dex_cache_image_class_lookup_required_) {
+    MoveImageClassesToClassTable();
+  }
   // TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
   // lock held, because it might need to resolve a field's type, which would try to take the lock.
   std::vector<mirror::Class*> all_classes;
   {
     ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
-    for (const std::pair<size_t, mirror::Class*>& it : classes_) {
-      all_classes.push_back(it.second);
-    }
-    for (const std::pair<size_t, mirror::Class*>& it : image_classes_) {
+    for (const std::pair<size_t, mirror::Class*>& it : class_table_) {
       all_classes.push_back(it.second);
     }
   }
@@ -4011,15 +4072,20 @@ void ClassLinker::DumpAllClasses(int flags) const {
   }
 }
 
-void ClassLinker::DumpForSigQuit(std::ostream& os) const {
+void ClassLinker::DumpForSigQuit(std::ostream& os) {
+  if (dex_cache_image_class_lookup_required_) {
+    MoveImageClassesToClassTable();
+  }
   ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
-  os << "Loaded classes: " << image_classes_.size() << " image classes; "
-     << classes_.size() << " allocated classes\n";
+  os << "Loaded classes: " << class_table_.size() << " allocated classes\n";
 }
 
-size_t ClassLinker::NumLoadedClasses() const {
+size_t ClassLinker::NumLoadedClasses() {
+  if (dex_cache_image_class_lookup_required_) {
+    MoveImageClassesToClassTable();
+  }
   ReaderMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
-  return classes_.size() + image_classes_.size();
+  return class_table_.size();
 }
 
 pid_t ClassLinker::GetClassesLockOwner() {
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index 5ef6d8f006..c5fb72c020 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -73,7 +73,7 @@ class ClassLinker {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Define a new a class based on a ClassDef from a DexFile
-  mirror::Class* DefineClass(const StringPiece& descriptor, mirror::ClassLoader* class_loader,
+  mirror::Class* DefineClass(const char* descriptor, mirror::ClassLoader* class_loader,
                              const DexFile& dex_file, const DexFile::ClassDef& dex_class_def)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -96,14 +96,17 @@ class ClassLinker {
       LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void DumpAllClasses(int flags) const
+  void DumpAllClasses(int flags)
       LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void DumpForSigQuit(std::ostream& os) const
-      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
+  void DumpForSigQuit(std::ostream& os)
+      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  size_t NumLoadedClasses() const LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
+  size_t NumLoadedClasses()
+      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Resolve a String with the given index from the DexFile, storing the
   // result in the DexCache. The referrer is used to identify the
@@ -219,12 +222,14 @@ class ClassLinker {
     return boot_class_path_;
   }
 
-  void VisitClasses(ClassVisitor* visitor, void* arg) const
-      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
+  void VisitClasses(ClassVisitor* visitor, void* arg)
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   // Less efficient variant of VisitClasses that doesn't hold the classlinker_classes_lock_
   // when calling the visitor.
-  void VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const
-      LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
+  void VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg)
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty)
       LOCKS_EXCLUDED(Locks::classlinker_classes_lock_, dex_lock_);
@@ -353,7 +358,7 @@ class ClassLinker {
   // Attempts to insert a class into a class table.  Returns NULL if
   // the class was inserted, otherwise returns an existing class with
   // the same descriptor and ClassLoader.
-  mirror::Class* InsertClass(const StringPiece& descriptor, mirror::Class* klass, bool image_class)
+  mirror::Class* InsertClass(const char* descriptor, mirror::Class* klass, size_t hash)
       LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -394,7 +399,7 @@ class ClassLinker {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 
-  mirror::Class* CreateArrayClass(const std::string& descriptor, mirror::ClassLoader* class_loader)
+  mirror::Class* CreateArrayClass(const char* descriptor, mirror::ClassLoader* class_loader)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void AppendToBootClassPath(const DexFile& dex_file)
@@ -453,7 +458,8 @@ class ClassLinker {
                                                      const mirror::Class* klass2)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  bool LinkClass(SirtRef<mirror::Class>& klass, mirror::ObjectArray<mirror::Class>* interfaces)
+  bool LinkClass(SirtRef<mirror::Class>& klass, mirror::ObjectArray<mirror::Class>* interfaces,
+                 Thread* self)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   bool LinkSuperClass(SirtRef<mirror::Class>& klass)
@@ -530,12 +536,23 @@ class ClassLinker {
   // mirror::Class* instances. Results should be compared for a matching
   // Class::descriptor_ and Class::class_loader_.
   typedef std::multimap<size_t, mirror::Class*> Table;
-  Table image_classes_ GUARDED_BY(Locks::classlinker_classes_lock_);
-  Table classes_ GUARDED_BY(Locks::classlinker_classes_lock_);
+  Table class_table_ GUARDED_BY(Locks::classlinker_classes_lock_);
+
+  // Do we need to search dex caches to find image classes?
+  bool dex_cache_image_class_lookup_required_;
+  // Number of times we've searched dex caches for a class. After a certain number of misses we move
+  // the classes into the class_table_ to avoid dex cache based searches.
+  AtomicInteger failed_dex_cache_class_lookups_;
 
-  mirror::Class* LookupClassLocked(const char* descriptor, const mirror::ClassLoader* class_loader,
-                                   size_t hash, const Table& classes)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::classlinker_classes_lock_);
+  mirror::Class* LookupClassFromTableLocked(const char* descriptor,
+                                            const mirror::ClassLoader* class_loader,
+                                            size_t hash)
+      SHARED_LOCKS_REQUIRED(Locks::classlinker_classes_lock_, Locks::mutator_lock_);
+
+  void MoveImageClassesToClassTable() LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  mirror::Class* LookupClassFromImage(const char* descriptor)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // indexes into class_roots_.
   // needs to be kept in sync with class_roots_descriptors_.
diff --git a/runtime/dex_instruction.cc b/runtime/dex_instruction.cc
index 09fa19e4d5..6e8736ade0 100644
--- a/runtime/dex_instruction.cc
+++ b/runtime/dex_instruction.cc
@@ -529,7 +529,20 @@ std::string Instruction::DumpString(const DexFile* file) const {
     case k30t:  os << StringPrintf("%s %+d", opcode, VRegA_30t()); break;
     case k31t:  os << StringPrintf("%s v%d, %+d", opcode, VRegA_31t(), VRegB_31t()); break;
     case k31i:  os << StringPrintf("%s v%d, #%+d", opcode, VRegA_31i(), VRegB_31i()); break;
-    case k31c:  os << StringPrintf("%s v%d, thing@%d", opcode, VRegA_31c(), VRegB_31c()); break;
+    case k31c:
+      if (Opcode() == CONST_STRING_JUMBO) {
+        uint32_t string_idx = VRegB_31c();
+        if (file != NULL) {
+          os << StringPrintf("%s v%d, %s // string@%d", opcode, VRegA_31c(),
+                             PrintableString(file->StringDataByIdx(string_idx)).c_str(),
+                             string_idx);
+        } else {
+          os << StringPrintf("%s v%d, string@%d", opcode, VRegA_31c(), string_idx);
+        }
+      } else {
+        os << StringPrintf("%s v%d, thing@%d", opcode, VRegA_31c(), VRegB_31c()); break;
+      }
+      break;
     case k35c: {
       uint32_t arg[5];
       GetArgs(arg);
diff --git a/runtime/intern_table.cc b/runtime/intern_table.cc
index d7398caa57..e3a75cf3f9 100644
--- a/runtime/intern_table.cc
+++ b/runtime/intern_table.cc
@@ -16,6 +16,10 @@
 
 #include "intern_table.h"
 
+#include "gc/space/image_space.h"
+#include "mirror/dex_cache.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/object-inl.h"
 #include "mirror/string.h"
 #include "thread.h"
 #include "UniquePtr.h"
@@ -23,8 +27,8 @@
 
 namespace art {
 
-InternTable::InternTable() : intern_table_lock_("InternTable lock"), is_dirty_(false) {
-}
+InternTable::InternTable()
+    : intern_table_lock_("InternTable lock"), is_dirty_(false) {}
 
 size_t InternTable::Size() const {
   MutexLock mu(Thread::Current(), intern_table_lock_);
@@ -34,11 +38,11 @@ size_t InternTable::Size() const {
 void InternTable::DumpForSigQuit(std::ostream& os) const {
   MutexLock mu(Thread::Current(), intern_table_lock_);
   os << "Intern table: " << strong_interns_.size() << " strong; "
-     << weak_interns_.size() << " weak; "
-     << image_strong_interns_.size() << " image strong\n";
+     << weak_interns_.size() << " weak\n";
 }
 
-void InternTable::VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty) {
+void InternTable::VisitRoots(RootVisitor* visitor, void* arg,
+                             bool clean_dirty) {
   MutexLock mu(Thread::Current(), intern_table_lock_);
   for (const auto& strong_intern : strong_interns_) {
     visitor(strong_intern.second, arg);
@@ -46,10 +50,12 @@ void InternTable::VisitRoots(RootVisitor* visitor, void* arg, bool clean_dirty)
   if (clean_dirty) {
     is_dirty_ = false;
   }
-  // Note: we deliberately don't visit the weak_interns_ table and the immutable image roots.
+  // Note: we deliberately don't visit the weak_interns_ table and the immutable
+  // image roots.
 }
 
-mirror::String* InternTable::Lookup(Table& table, mirror::String* s, uint32_t hash_code) {
+mirror::String* InternTable::Lookup(Table& table, mirror::String* s,
+                                    uint32_t hash_code) {
   intern_table_lock_.AssertHeld(Thread::Current());
   for (auto it = table.find(hash_code), end = table.end(); it != end; ++it) {
     mirror::String* existing_string = it->second;
@@ -60,18 +66,15 @@ mirror::String* InternTable::Lookup(Table& table, mirror::String* s, uint32_t ha
   return NULL;
 }
 
-mirror::String* InternTable::Insert(Table& table, mirror::String* s, uint32_t hash_code) {
+mirror::String* InternTable::Insert(Table& table, mirror::String* s,
+                                    uint32_t hash_code) {
   intern_table_lock_.AssertHeld(Thread::Current());
   table.insert(std::make_pair(hash_code, s));
   return s;
 }
 
-void InternTable::RegisterStrong(mirror::String* s) {
-  MutexLock mu(Thread::Current(), intern_table_lock_);
-  Insert(image_strong_interns_, s, s->GetHashCode());
-}
-
-void InternTable::Remove(Table& table, const mirror::String* s, uint32_t hash_code) {
+void InternTable::Remove(Table& table, const mirror::String* s,
+                         uint32_t hash_code) {
   intern_table_lock_.AssertHeld(Thread::Current());
   for (auto it = table.find(hash_code), end = table.end(); it != end; ++it) {
     if (it->second == s) {
@@ -81,6 +84,31 @@ void InternTable::Remove(Table& table, const mirror::String* s, uint32_t hash_co
   }
 }
 
+static mirror::String* LookupStringFromImage(mirror::String* s)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  gc::space::ImageSpace* image = Runtime::Current()->GetHeap()->GetImageSpace();
+  if (image == NULL) {
+    return NULL;  // No image present.
+  }
+  mirror::Object* root = image->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
+  mirror::ObjectArray<mirror::DexCache>* dex_caches = root->AsObjectArray<mirror::DexCache>();
+  const std::string utf8 = s->ToModifiedUtf8();
+  for (int32_t i = 0; i < dex_caches->GetLength(); ++i) {
+    mirror::DexCache* dex_cache = dex_caches->Get(i);
+    const DexFile* dex_file = dex_cache->GetDexFile();
+    // Binary search the dex file for the string index.
+    const DexFile::StringId* string_id = dex_file->FindStringId(utf8.c_str());
+    if (string_id != NULL) {
+      uint32_t string_idx = dex_file->GetIndexForStringId(*string_id);
+      mirror::String* image = dex_cache->GetResolvedString(string_idx);
+      if (image != NULL) {
+        return image;
+      }
+    }
+  }
+  return NULL;
+}
+
 mirror::String* InternTable::Insert(mirror::String* s, bool is_strong) {
   MutexLock mu(Thread::Current(), intern_table_lock_);
 
@@ -93,15 +121,16 @@ mirror::String* InternTable::Insert(mirror::String* s, bool is_strong) {
     if (strong != NULL) {
       return strong;
     }
-    // Check the image table for a match.
-    mirror::String* image = Lookup(image_strong_interns_, s, hash_code);
-    if (image != NULL) {
-      return image;
-    }
 
     // Mark as dirty so that we rescan the roots.
     Dirty();
 
+    // Check the image for a match.
+    mirror::String* image = LookupStringFromImage(s);
+    if (image != NULL) {
+      return Insert(strong_interns_, image, hash_code);
+    }
+
     // There is no match in the strong table, check the weak table.
     mirror::String* weak = Lookup(weak_interns_, s, hash_code);
     if (weak != NULL) {
@@ -110,7 +139,8 @@ mirror::String* InternTable::Insert(mirror::String* s, bool is_strong) {
       return Insert(strong_interns_, weak, hash_code);
     }
 
-    // No match in the strong table or the weak table. Insert into the strong table.
+    // No match in the strong table or the weak table. Insert into the strong
+    // table.
     return Insert(strong_interns_, s, hash_code);
   }
 
@@ -119,10 +149,10 @@ mirror::String* InternTable::Insert(mirror::String* s, bool is_strong) {
   if (strong != NULL) {
     return strong;
   }
-  // Check the image table for a match.
-  mirror::String* image = Lookup(image_strong_interns_, s, hash_code);
+  // Check the image for a match.
+  mirror::String* image = LookupStringFromImage(s);
   if (image != NULL) {
-    return image;
+    return Insert(weak_interns_, image, hash_code);
   }
   // Check the weak table for a match.
   mirror::String* weak = Lookup(weak_interns_, s, hash_code);
@@ -133,12 +163,15 @@ mirror::String* InternTable::Insert(mirror::String* s, bool is_strong) {
   return Insert(weak_interns_, s, hash_code);
 }
 
-mirror::String* InternTable::InternStrong(int32_t utf16_length, const char* utf8_data) {
-  return InternStrong(mirror::String::AllocFromModifiedUtf8(Thread::Current(), utf16_length, utf8_data));
+mirror::String* InternTable::InternStrong(int32_t utf16_length,
+                                          const char* utf8_data) {
+  return InternStrong(mirror::String::AllocFromModifiedUtf8(
+      Thread::Current(), utf16_length, utf8_data));
 }
 
 mirror::String* InternTable::InternStrong(const char* utf8_data) {
-  return InternStrong(mirror::String::AllocFromModifiedUtf8(Thread::Current(), utf8_data));
+  return InternStrong(
+      mirror::String::AllocFromModifiedUtf8(Thread::Current(), utf8_data));
 }
 
 mirror::String* InternTable::InternStrong(mirror::String* s) {
diff --git a/runtime/intern_table.h b/runtime/intern_table.h
index 5031ce3c5a..a804d1f30e 100644
--- a/runtime/intern_table.h
+++ b/runtime/intern_table.h
@@ -55,10 +55,6 @@ class InternTable {
   // Interns a potentially new string in the 'weak' table. (See above.)
   mirror::String* InternWeak(mirror::String* s) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  // Register a String trusting that it is safe to intern.
-  // Used when reinitializing InternTable from an image.
-  void RegisterStrong(mirror::String* s) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
   void SweepInternTableWeaks(IsMarkedTester is_marked, void* arg)
       SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
 
@@ -88,7 +84,6 @@ class InternTable {
 
   mutable Mutex intern_table_lock_;
   bool is_dirty_;
-  Table image_strong_interns_ GUARDED_BY(intern_table_lock_);
   Table strong_interns_ GUARDED_BY(intern_table_lock_);
   Table weak_interns_ GUARDED_BY(intern_table_lock_);
 };
diff --git a/runtime/mirror/class.cc b/runtime/mirror/class.cc
index 19e134fdfe..5e8b82793a 100644
--- a/runtime/mirror/class.cc
+++ b/runtime/mirror/class.cc
@@ -50,24 +50,26 @@ void Class::ResetClass() {
   java_lang_Class_ = NULL;
 }
 
-void Class::SetStatus(Status new_status) {
-  if (UNLIKELY(new_status <= GetStatus() && new_status != kStatusError)) {
-    bool class_linker_initialized = Runtime::Current()->GetClassLinker() != nullptr;
-    if (class_linker_initialized) {
+void Class::SetStatus(Status new_status, Thread* self) {
+  Status old_status = GetStatus();
+  bool class_linker_initialized = Runtime::Current()->GetClassLinker() != nullptr;
+  if (LIKELY(class_linker_initialized)) {
+    if (UNLIKELY(new_status <= old_status && new_status != kStatusError)) {
       LOG(FATAL) << "Unexpected change back of class status for " << PrettyClass(this) << " "
-          << GetStatus() << " -> " << new_status;
+          << old_status << " -> " << new_status;
+    }
+    if (new_status >= kStatusResolved || old_status >= kStatusResolved) {
+      // When classes are being resolved the resolution code should hold the lock.
+      CHECK_EQ(GetThinLockId(), self->GetThinLockId())
+            << "Attempt to change status of class while not holding its lock: "
+            << PrettyClass(this) << " " << old_status << " -> " << new_status;
     }
-  }
-  if (new_status > kStatusResolved) {
-    CHECK_EQ(GetThinLockId(), Thread::Current()->GetThinLockId())
-        << "Attempt to change status of class while not holding its lock " << PrettyClass(this);
   }
   if (new_status == kStatusError) {
     CHECK_NE(GetStatus(), kStatusError)
         << "Attempt to set as erroneous an already erroneous class " << PrettyClass(this);
 
     // Stash current exception.
-    Thread* self = Thread::Current();
     SirtRef<mirror::Object> old_throw_this_object(self, NULL);
     SirtRef<mirror::ArtMethod> old_throw_method(self, NULL);
     SirtRef<mirror::Throwable> old_exception(self, NULL);
@@ -103,7 +105,13 @@ void Class::SetStatus(Status new_status) {
     self->SetException(gc_safe_throw_location, old_exception.get());
   }
   CHECK(sizeof(Status) == sizeof(uint32_t)) << PrettyClass(this);
-  return SetField32(OFFSET_OF_OBJECT_MEMBER(Class, status_), new_status, false);
+  SetField32(OFFSET_OF_OBJECT_MEMBER(Class, status_), new_status, false);
+  // Classes that are being resolved or initialized need to notify waiters that the class status
+  // changed. See ClassLinker::EnsureResolved and ClassLinker::WaitForInitializeClass.
+  if ((old_status >= kStatusResolved || new_status >= kStatusResolved) &&
+      class_linker_initialized) {
+    NotifyAll(self);
+  }
 }
 
 void Class::SetDexCache(DexCache* new_dex_cache) {
diff --git a/runtime/mirror/class.h b/runtime/mirror/class.h
index 638b67f485..99f3850b9b 100644
--- a/runtime/mirror/class.h
+++ b/runtime/mirror/class.h
@@ -125,10 +125,10 @@ class MANAGED Class : public StaticStorageBase {
 
   Status GetStatus() const {
     DCHECK_EQ(sizeof(Status), sizeof(uint32_t));
-    return static_cast<Status>(GetField32(OFFSET_OF_OBJECT_MEMBER(Class, status_), false));
+    return static_cast<Status>(GetField32(OFFSET_OF_OBJECT_MEMBER(Class, status_), true));
   }
 
-  void SetStatus(Status new_status) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void SetStatus(Status new_status, Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Returns true if the class has failed to link.
   bool IsErroneous() const {
diff --git a/runtime/monitor.cc b/runtime/monitor.cc
index ff193c9534..66c51e6eb6 100644
--- a/runtime/monitor.cc
+++ b/runtime/monitor.cc
@@ -792,6 +792,8 @@ void Monitor::Notify(Thread* self, mirror::Object *obj) {
       return;
     }
     // no-op;  there are no waiters to notify.
+    // We inflate here in case the Notify is in a tight loop. Without inflation here the waiter
+    // will struggle to get in. Bug 6961405.
     Inflate(self, obj);
   } else {
     // It's a fat lock.
@@ -811,6 +813,8 @@ void Monitor::NotifyAll(Thread* self, mirror::Object *obj) {
       return;
     }
     // no-op;  there are no waiters to notify.
+    // We inflate here in case the NotifyAll is in a tight loop. Without inflation here the waiter
+    // will struggle to get in. Bug 6961405.
     Inflate(self, obj);
   } else {
     // It's a fat lock.
@@ -948,6 +952,27 @@ void Monitor::VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::O
   }
 }
 
+bool Monitor::IsValidLockWord(int32_t lock_word) {
+  if (lock_word == 0) {
+    return true;
+  } else if (LW_SHAPE(lock_word) == LW_SHAPE_FAT) {
+    Monitor* mon = LW_MONITOR(lock_word);
+    MonitorList* list = Runtime::Current()->GetMonitorList();
+    MutexLock mu(Thread::Current(), list->monitor_list_lock_);
+    bool found = false;
+    for (Monitor* list_mon : list->list_) {
+      if (mon == list_mon) {
+        found = true;
+        break;
+      }
+    }
+    return found;
+  } else {
+    // TODO: thin lock validity checking.
+    return LW_SHAPE(lock_word) == LW_SHAPE_THIN;
+  }
+}
+
 void Monitor::TranslateLocation(const mirror::ArtMethod* method, uint32_t dex_pc,
                                 const char*& source_file, uint32_t& line_number) const {
   // If method is null, location is unknown
diff --git a/runtime/monitor.h b/runtime/monitor.h
index 02c10a7a10..66517683c2 100644
--- a/runtime/monitor.h
+++ b/runtime/monitor.h
@@ -100,6 +100,8 @@ class Monitor {
                          void* callback_context)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
+  static bool IsValidLockWord(int32_t lock_word);
+
   mirror::Object* GetObject();
 
  private:
@@ -188,6 +190,7 @@ class MonitorList {
   Mutex monitor_list_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   std::list<Monitor*> list_ GUARDED_BY(monitor_list_lock_);
 
+  friend class Monitor;
   DISALLOW_COPY_AND_ASSIGN(MonitorList);
 };
 
diff --git a/runtime/native/dalvik_system_DexFile.cc b/runtime/native/dalvik_system_DexFile.cc
index 4ee353359b..2f4e427bb6 100644
--- a/runtime/native/dalvik_system_DexFile.cc
+++ b/runtime/native/dalvik_system_DexFile.cc
@@ -158,7 +158,8 @@ static jclass DexFile_defineClassNative(JNIEnv* env, jclass, jstring javaName, j
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   class_linker->RegisterDexFile(*dex_file);
   mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(javaLoader);
-  mirror::Class* result = class_linker->DefineClass(descriptor, class_loader, *dex_file, *dex_class_def);
+  mirror::Class* result = class_linker->DefineClass(descriptor.c_str(), class_loader, *dex_file,
+                                                    *dex_class_def);
   VLOG(class_linker) << "DexFile_defineClassNative returning " << result;
   return soa.AddLocalReference<jclass>(result);
 }
diff --git a/runtime/native/dalvik_system_VMDebug.cc b/runtime/native/dalvik_system_VMDebug.cc
index e3ec3bcbb0..2956c2c90a 100644
--- a/runtime/native/dalvik_system_VMDebug.cc
+++ b/runtime/native/dalvik_system_VMDebug.cc
@@ -151,7 +151,8 @@ static void VMDebug_printLoadedClasses(JNIEnv* env, jclass, jint flags) {
   return Runtime::Current()->GetClassLinker()->DumpAllClasses(flags);
 }
 
-static jint VMDebug_getLoadedClassCount(JNIEnv*, jclass) {
+static jint VMDebug_getLoadedClassCount(JNIEnv* env, jclass) {
+  ScopedObjectAccess soa(env);
   return Runtime::Current()->GetClassLinker()->NumLoadedClasses();
 }
 
diff --git a/test/016-intern/expected.txt b/test/016-intern/expected.txt
index 7d919635fc..0b7ac3d3ce 100644
--- a/test/016-intern/expected.txt
+++ b/test/016-intern/expected.txt
@@ -1 +1,3 @@
 good! foobar
+good! foo
+good! null
diff --git a/test/016-intern/src/Main.java b/test/016-intern/src/Main.java
index 430686302a..01cbf18c6d 100644
--- a/test/016-intern/src/Main.java
+++ b/test/016-intern/src/Main.java
@@ -20,15 +20,33 @@
 public class Main {
     public static void main(String args[]) {
         String a, b;
-        String foo = "foo";
-        String bar = "bar";
+        final String foo = "foo";
+        final String bar = "bar";
 
+        // Two interned strings should match.
         a = foo.concat(bar).intern();
         b = foo.concat(bar).intern();
         if (a == b && foo != bar) {
             System.out.println("good! " + a);
         } else {
-            System.out.println("bad!");
+            System.out.println("bad! " + a + " != " + b);
+        }
+
+        // An interned string should match a string literal.
+        a = ("f" + foo.substring(1,3)).intern();
+        if (a == foo) {
+            System.out.println("good! " + a);
+        } else {
+            System.out.println("bad! " + a + " != " + b);
+        }
+
+        // Check that a string literal in libcore equals one in the app.
+        a = (new java.nio.charset.IllegalCharsetNameException(null)).getMessage();
+        b = "null";
+        if (a == b) {
+            System.out.println("good! " + a);
+        } else {
+            System.out.println("bad! " + a + " != " + b);
         }
     }
 }
-- 
cgit v1.2.3-59-g8ed1b


From 0b3eb39f8bc92f955f875ef50929c439aafe35fb Mon Sep 17 00:00:00 2001
From: Mathieu Chartier <mathieuc@google.com>
Date: Fri, 23 Aug 2013 14:56:59 -0700
Subject: Use atomic integer for compiler driver work balancing.

Before, we divided the work by dividing the total work by the number
of threads. This did not balance work well since some threads could
finish much earlier than others. The new method uses a shared atomic
integer to balance work. This makes it that a thread can process at
most one item after the other worker threads are finished.

Changed the number of threads to take into account the main thread
also doing work. This means that we subtract one from the number of
threads when we make the thread pool.

Change-Id: I0147b0403c6214800ed6bfcdac4f1e5486330996
---
 compiler/driver/compiler_driver.cc | 36 ++++++++++++++++++++++--------------
 1 file changed, 22 insertions(+), 14 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 99f8fb7281..634d3bc9c0 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -473,7 +473,7 @@ void CompilerDriver::CompileAll(jobject class_loader,
                                 const std::vector<const DexFile*>& dex_files,
                                 base::TimingLogger& timings) {
   DCHECK(!Runtime::Current()->IsStarted());
-  UniquePtr<ThreadPool> thread_pool(new ThreadPool(thread_count_));
+  UniquePtr<ThreadPool> thread_pool(new ThreadPool(thread_count_ - 1));
   PreCompile(class_loader, dex_files, *thread_pool.get(), timings);
   Compile(class_loader, dex_files, *thread_pool.get(), timings);
   if (dump_stats_) {
@@ -537,7 +537,7 @@ void CompilerDriver::CompileOne(const mirror::ArtMethod* method, base::TimingLog
   std::vector<const DexFile*> dex_files;
   dex_files.push_back(dex_file);
 
-  UniquePtr<ThreadPool> thread_pool(new ThreadPool(1U));
+  UniquePtr<ThreadPool> thread_pool(new ThreadPool(0U));
   PreCompile(jclass_loader, dex_files, *thread_pool.get(), timings);
 
   uint32_t method_idx = method->GetDexMethodIndex();
@@ -1322,7 +1322,8 @@ class ParallelCompilationManager {
                              CompilerDriver* compiler,
                              const DexFile* dex_file,
                              ThreadPool& thread_pool)
-    : class_linker_(class_linker),
+    : index_(0),
+      class_linker_(class_linker),
       class_loader_(class_loader),
       compiler_(compiler),
       dex_file_(dex_file),
@@ -1353,8 +1354,9 @@ class ParallelCompilationManager {
     CHECK_GT(work_units, 0U);
 
     std::vector<ForAllClosure*> closures(work_units);
+    index_ = begin;
     for (size_t i = 0; i < work_units; ++i) {
-      closures[i] = new ForAllClosure(this, begin + i, end, callback, work_units);
+      closures[i] = new ForAllClosure(this, end, callback);
       thread_pool_->AddTask(self, closures[i]);
     }
     thread_pool_->StartWorkers(self);
@@ -1367,20 +1369,25 @@ class ParallelCompilationManager {
     thread_pool_->Wait(self, true, false);
   }
 
+  size_t NextIndex() {
+    return index_.fetch_add(1);
+  }
+
  private:
   class ForAllClosure : public Task {
    public:
-    ForAllClosure(ParallelCompilationManager* manager, size_t begin, size_t end, Callback* callback,
-                  size_t stripe)
+    ForAllClosure(ParallelCompilationManager* manager, size_t end, Callback* callback)
         : manager_(manager),
-          begin_(begin),
           end_(end),
-          callback_(callback),
-          stripe_(stripe) {}
+          callback_(callback) {}
 
     virtual void Run(Thread* self) {
-      for (size_t i = begin_; i < end_; i += stripe_) {
-        callback_(manager_, i);
+      while (true) {
+        const size_t index = manager_->NextIndex();
+        if (UNLIKELY(index >= end_)) {
+          break;
+        }
+        callback_(manager_, index);
         self->AssertNoPendingException();
       }
     }
@@ -1390,18 +1397,19 @@ class ParallelCompilationManager {
     }
 
    private:
-    const ParallelCompilationManager* const manager_;
-    const size_t begin_;
+    ParallelCompilationManager* const manager_;
     const size_t end_;
     const Callback* const callback_;
-    const size_t stripe_;
   };
 
+  AtomicInteger index_;
   ClassLinker* const class_linker_;
   const jobject class_loader_;
   CompilerDriver* const compiler_;
   const DexFile* const dex_file_;
   ThreadPool* const thread_pool_;
+
+  DISALLOW_COPY_AND_ASSIGN(ParallelCompilationManager);
 };
 
 // Return true if the class should be skipped during compilation. We
-- 
cgit v1.2.3-59-g8ed1b


From a436fde2762664a3ecdda5eefcadd20b2e104f59 Mon Sep 17 00:00:00 2001
From: Ian Rogers <irogers@google.com>
Date: Tue, 27 Aug 2013 23:34:06 -0700
Subject: Handle OOMEs in class linker with grace.

Check for OOMEs and then fail due to them in class loading.
Make the compiler driver spot OOMEs during resolution and abort compilation to
avoid needless GC thrash then eventual death.
Allocate the pre-allocated OOME during Runtime::Init as Runtime::Start isn't
called in the context of the compiler/tools.

Change-Id: Id72199d0fe82001b5bf22758b3cdc9cc4b8efbb9
---
 compiler/driver/compiler_driver.cc        |  13 +-
 runtime/class_linker.cc                   | 193 ++++++++++++++++++++++++++----
 runtime/mirror/object.h                   |   6 +-
 runtime/mirror/object_array-inl.h         |   4 +-
 runtime/mirror/stack_trace_element.cc     |  18 +--
 runtime/mirror/string.cc                  |   2 +-
 runtime/native/dalvik_system_VMRuntime.cc |   3 -
 runtime/runtime.cc                        |  23 ++--
 runtime/runtime.h                         |   5 +-
 9 files changed, 217 insertions(+), 50 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 634d3bc9c0..3368e96139 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -671,7 +671,7 @@ void CompilerDriver::LoadImageClasses(base::TimingLogger& timings)
     if (klass.get() == NULL) {
       image_classes_->erase(it++);
       VLOG(compiler) << "Failed to find class " << descriptor;
-      Thread::Current()->ClearException();
+      self->ClearException();
     } else {
       ++it;
     }
@@ -1472,7 +1472,7 @@ static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manag
         // Class couldn't be resolved, for example, super-class is in a different dex file. Don't
         // attempt to resolve methods and fields when there is no declaring class.
         CHECK(soa.Self()->IsExceptionPending());
-        Thread::Current()->ClearException();
+        soa.Self()->ClearException();
         resolve_fields_and_methods = false;
       } else {
         resolve_fields_and_methods = manager->GetCompiler()->IsImage();
@@ -1547,7 +1547,14 @@ static void ResolveType(const ParallelCompilationManager* manager, size_t type_i
 
   if (klass == NULL) {
     CHECK(soa.Self()->IsExceptionPending());
-    Thread::Current()->ClearException();
+    mirror::Throwable* exception = soa.Self()->GetException(NULL);
+    VLOG(compiler) << "Exception during type resolution: " << exception->Dump();
+    if (strcmp(ClassHelper(exception->GetClass()).GetDescriptor(),
+               "Ljava/lang/OutOfMemoryError;") == 0) {
+      // There's little point continuing compilation if the heap is exhausted.
+      LOG(FATAL) << "Out of memory during type resolution for compilation";
+    }
+    soa.Self()->ClearException();
   }
 }
 
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index cd4a720e24..37b62ad7c6 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -1217,11 +1217,15 @@ mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Cl
                                        size_t class_size) {
   DCHECK_GE(class_size, sizeof(mirror::Class));
   gc::Heap* heap = Runtime::Current()->GetHeap();
-  SirtRef<mirror::Class> klass(self,
-                       heap->AllocObject(self, java_lang_Class, class_size)->AsClass());
+  mirror::Object* k = heap->AllocObject(self, java_lang_Class, class_size);
+  if (UNLIKELY(k == NULL)) {
+    CHECK(self->IsExceptionPending());  // OOME.
+    return NULL;
+  }
+  mirror::Class* klass = k->AsClass();
   klass->SetPrimitiveType(Primitive::kPrimNot);  // default to not being primitive
   klass->SetClassSize(class_size);
-  return klass.get();
+  return klass;
 }
 
 mirror::Class* ClassLinker::AllocClass(Thread* self, size_t class_size) {
@@ -1388,6 +1392,10 @@ mirror::Class* ClassLinker::DefineClass(const char* descriptor,
   } else {
     klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
   }
+  if (UNLIKELY(klass.get() == NULL)) {
+    CHECK(self->IsExceptionPending());  // Expect an OOME.
+    return NULL;
+  }
   klass->SetDexCache(FindDexCache(dex_file));
   LoadClass(dex_file, dex_class_def, klass, class_loader);
   // Check for a pending exception during load
@@ -1725,18 +1733,37 @@ void ClassLinker::LoadClass(const DexFile& dex_file,
   ClassDataItemIterator it(dex_file, class_data);
   Thread* self = Thread::Current();
   if (it.NumStaticFields() != 0) {
-    klass->SetSFields(AllocArtFieldArray(self, it.NumStaticFields()));
+    mirror::ObjectArray<mirror::ArtField>* statics = AllocArtFieldArray(self, it.NumStaticFields());
+    if (UNLIKELY(statics == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return;
+    }
+    klass->SetSFields(statics);
   }
   if (it.NumInstanceFields() != 0) {
-    klass->SetIFields(AllocArtFieldArray(self, it.NumInstanceFields()));
+    mirror::ObjectArray<mirror::ArtField>* fields =
+        AllocArtFieldArray(self, it.NumInstanceFields());
+    if (UNLIKELY(fields == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return;
+    }
+    klass->SetIFields(fields);
   }
   for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
     SirtRef<mirror::ArtField> sfield(self, AllocArtField(self));
+    if (UNLIKELY(sfield.get() == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return;
+    }
     klass->SetStaticField(i, sfield.get());
     LoadField(dex_file, it, klass, sfield);
   }
   for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
     SirtRef<mirror::ArtField> ifield(self, AllocArtField(self));
+    if (UNLIKELY(ifield.get() == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return;
+    }
     klass->SetInstanceField(i, ifield.get());
     LoadField(dex_file, it, klass, ifield);
   }
@@ -1749,15 +1776,31 @@ void ClassLinker::LoadClass(const DexFile& dex_file,
   // Load methods.
   if (it.NumDirectMethods() != 0) {
     // TODO: append direct methods to class object
-    klass->SetDirectMethods(AllocArtMethodArray(self, it.NumDirectMethods()));
+    mirror::ObjectArray<mirror::ArtMethod>* directs =
+         AllocArtMethodArray(self, it.NumDirectMethods());
+    if (UNLIKELY(directs == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return;
+    }
+    klass->SetDirectMethods(directs);
   }
   if (it.NumVirtualMethods() != 0) {
     // TODO: append direct methods to class object
-    klass->SetVirtualMethods(AllocArtMethodArray(self, it.NumVirtualMethods()));
+    mirror::ObjectArray<mirror::ArtMethod>* virtuals =
+        AllocArtMethodArray(self, it.NumVirtualMethods());
+    if (UNLIKELY(virtuals == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return;
+    }
+    klass->SetVirtualMethods(virtuals);
   }
   size_t class_def_method_index = 0;
   for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
     SirtRef<mirror::ArtMethod> method(self, LoadMethod(self, dex_file, it, klass));
+    if (UNLIKELY(method.get() == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return;
+    }
     klass->SetDirectMethod(i, method.get());
     if (oat_class.get() != NULL) {
       LinkCode(method, oat_class.get(), class_def_method_index);
@@ -1767,6 +1810,10 @@ void ClassLinker::LoadClass(const DexFile& dex_file,
   }
   for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
     SirtRef<mirror::ArtMethod> method(self, LoadMethod(self, dex_file, it, klass));
+    if (UNLIKELY(method.get() == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return;
+    }
     klass->SetVirtualMethod(i, method.get());
     DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
     if (oat_class.get() != NULL) {
@@ -1786,13 +1833,17 @@ void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIter
 }
 
 mirror::ArtMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
-                                                const ClassDataItemIterator& it,
-                                                SirtRef<mirror::Class>& klass) {
+                                           const ClassDataItemIterator& it,
+                                           SirtRef<mirror::Class>& klass) {
   uint32_t dex_method_idx = it.GetMemberIndex();
   const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
   StringPiece method_name(dex_file.GetMethodName(method_id));
 
   mirror::ArtMethod* dst = AllocArtMethod(self);
+  if (UNLIKELY(dst == NULL)) {
+    CHECK(self->IsExceptionPending());  // OOME.
+    return NULL;
+  }
   DCHECK(dst->IsArtMethod()) << PrettyDescriptor(dst->GetClass());
 
   const char* old_cause = self->StartAssertNoThreadSuspension("LoadMethod");
@@ -1846,6 +1897,7 @@ mirror::ArtMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file
 void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
   Thread* self = Thread::Current();
   SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
+  CHECK(dex_cache.get() != NULL) << "Failed to allocate dex cache for " << dex_file.GetLocation();
   AppendToBootClassPath(dex_file, dex_cache);
 }
 
@@ -1891,6 +1943,7 @@ void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
   // suspend all threads and another thread may need the dex_lock_ to
   // get to a suspend point.
   SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
+  CHECK(dex_cache.get() != NULL) << "Failed to allocate dex cache for " << dex_file.GetLocation();
   {
     WriterMutexLock mu(self, dex_lock_);
     if (IsDexFileRegisteredLocked(dex_file)) {
@@ -1939,7 +1992,11 @@ void ClassLinker::FixupDexCaches(mirror::ArtMethod* resolution_method) const {
 }
 
 mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
-  return InitializePrimitiveClass(AllocClass(self, sizeof(mirror::Class)), type);
+  mirror::Class* klass = AllocClass(self, sizeof(mirror::Class));
+  if (UNLIKELY(klass == NULL)) {
+    return NULL;
+  }
+  return InitializePrimitiveClass(klass, type);
 }
 
 mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type) {
@@ -2574,7 +2631,10 @@ mirror::Class* ClassLinker::CreateProxyClass(mirror::String* name,
   Thread* self = Thread::Current();
   SirtRef<mirror::Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
                                                 sizeof(mirror::SynthesizedProxyClass)));
-  CHECK(klass.get() != NULL);
+  if (klass.get() == NULL) {
+    CHECK(self->IsExceptionPending());  // OOME.
+    return NULL;
+  }
   DCHECK(klass->GetClass() != NULL);
   klass->SetObjectSize(sizeof(mirror::Proxy));
   klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
@@ -2589,31 +2649,72 @@ mirror::Class* ClassLinker::CreateProxyClass(mirror::String* name,
   klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
 
   // Instance fields are inherited, but we add a couple of static fields...
-  klass->SetSFields(AllocArtFieldArray(self, 2));
+  {
+    mirror::ObjectArray<mirror::ArtField>* sfields = AllocArtFieldArray(self, 2);
+    if (UNLIKELY(sfields == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return NULL;
+    }
+    klass->SetSFields(sfields);
+  }
   // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
   // our proxy, so Class.getInterfaces doesn't return the flattened set.
   SirtRef<mirror::ArtField> interfaces_sfield(self, AllocArtField(self));
+  if (UNLIKELY(interfaces_sfield.get() == NULL)) {
+    CHECK(self->IsExceptionPending());  // OOME.
+    return NULL;
+  }
   klass->SetStaticField(0, interfaces_sfield.get());
   interfaces_sfield->SetDexFieldIndex(0);
   interfaces_sfield->SetDeclaringClass(klass.get());
   interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
   // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
   SirtRef<mirror::ArtField> throws_sfield(self, AllocArtField(self));
+  if (UNLIKELY(throws_sfield.get() == NULL)) {
+    CHECK(self->IsExceptionPending());  // OOME.
+    return NULL;
+  }
   klass->SetStaticField(1, throws_sfield.get());
   throws_sfield->SetDexFieldIndex(1);
   throws_sfield->SetDeclaringClass(klass.get());
   throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
 
   // Proxies have 1 direct method, the constructor
-  klass->SetDirectMethods(AllocArtMethodArray(self, 1));
-  klass->SetDirectMethod(0, CreateProxyConstructor(self, klass, proxy_class));
+  {
+    mirror::ObjectArray<mirror::ArtMethod>* directs =
+      AllocArtMethodArray(self, 1);
+    if (UNLIKELY(directs == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return NULL;
+    }
+    klass->SetDirectMethods(directs);
+    mirror::ArtMethod* constructor = CreateProxyConstructor(self, klass, proxy_class);
+    if (UNLIKELY(constructor == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return NULL;
+    }
+    klass->SetDirectMethod(0, constructor);
+  }
 
   // Create virtual method using specified prototypes
   size_t num_virtual_methods = methods->GetLength();
-  klass->SetVirtualMethods(AllocArtMethodArray(self, num_virtual_methods));
+  {
+    mirror::ObjectArray<mirror::ArtMethod>* virtuals =
+        AllocArtMethodArray(self, num_virtual_methods);
+    if (UNLIKELY(virtuals == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return NULL;
+    }
+    klass->SetVirtualMethods(virtuals);
+  }
   for (size_t i = 0; i < num_virtual_methods; ++i) {
     SirtRef<mirror::ArtMethod> prototype(self, methods->Get(i));
-    klass->SetVirtualMethod(i, CreateProxyMethod(self, klass, prototype));
+    mirror::ArtMethod* clone = CreateProxyMethod(self, klass, prototype);
+    if (UNLIKELY(clone == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return NULL;
+    }
+    klass->SetVirtualMethod(i, clone);
   }
 
   klass->SetSuperClass(proxy_class);  // The super class is java.lang.reflect.Proxy
@@ -2701,6 +2802,10 @@ mirror::ArtMethod* ClassLinker::CreateProxyConstructor(Thread* self,
   // code_ too)
   mirror::ArtMethod* constructor =
       down_cast<mirror::ArtMethod*>(proxy_constructor->Clone(self));
+  if (constructor == NULL) {
+    CHECK(self->IsExceptionPending());  // OOME.
+    return NULL;
+  }
   // Make this constructor public and fix the class to be our Proxy version
   constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
   constructor->SetDeclaringClass(klass.get());
@@ -2725,6 +2830,10 @@ mirror::ArtMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<mirror::
   // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
   // as necessary
   mirror::ArtMethod* method = down_cast<mirror::ArtMethod*>(prototype->Clone(self));
+  if (UNLIKELY(method == NULL)) {
+    CHECK(self->IsExceptionPending());  // OOME.
+    return NULL;
+  }
 
   // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
   // the intersection of throw exceptions as defined in Proxy
@@ -3277,6 +3386,10 @@ bool ClassLinker::LinkVirtualMethods(SirtRef<mirror::Class>& klass) {
     // TODO: do not assign to the vtable field until it is fully constructed.
     SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
       vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(self, max_count));
+    if (UNLIKELY(vtable.get() == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return false;
+    }
     // See if any of our virtual methods override the superclass.
     MethodHelper local_mh(NULL, this);
     MethodHelper super_mh(NULL, this);
@@ -3320,6 +3433,10 @@ bool ClassLinker::LinkVirtualMethods(SirtRef<mirror::Class>& klass) {
     CHECK_LE(actual_count, max_count);
     if (actual_count < max_count) {
       vtable.reset(vtable->CopyOf(self, actual_count));
+      if (UNLIKELY(vtable.get() == NULL)) {
+        CHECK(self->IsExceptionPending());  // OOME.
+        return false;
+      }
     }
     klass->SetVTable(vtable.get());
   } else {
@@ -3331,6 +3448,10 @@ bool ClassLinker::LinkVirtualMethods(SirtRef<mirror::Class>& klass) {
     }
     SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
         vtable(self, AllocArtMethodArray(self, num_virtual_methods));
+    if (UNLIKELY(vtable.get() == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return false;
+    }
     for (size_t i = 0; i < num_virtual_methods; ++i) {
       mirror::ArtMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
       vtable->Set(i, virtual_method);
@@ -3381,6 +3502,10 @@ bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
   }
   Thread* self = Thread::Current();
   SirtRef<mirror::IfTable> iftable(self, AllocIfTable(self, ifcount));
+  if (UNLIKELY(iftable.get() == NULL)) {
+    CHECK(self->IsExceptionPending());  // OOME.
+    return false;
+  }
   if (super_ifcount != 0) {
     mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
     for (size_t i = 0; i < super_ifcount; i++) {
@@ -3432,6 +3557,10 @@ bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
   // Shrink iftable in case duplicates were found
   if (idx < ifcount) {
     iftable.reset(down_cast<mirror::IfTable*>(iftable->CopyOf(self, idx * mirror::IfTable::kMax)));
+    if (UNLIKELY(iftable.get() == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return false;
+    }
     ifcount = idx;
   } else {
     CHECK_EQ(idx, ifcount);
@@ -3451,6 +3580,10 @@ bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
     if (num_methods > 0) {
       mirror::ObjectArray<mirror::ArtMethod>* method_array =
           AllocArtMethodArray(self, num_methods);
+      if (UNLIKELY(method_array == NULL)) {
+        CHECK(self->IsExceptionPending());  // OOME.
+        return false;
+      }
       iftable->SetMethodArray(i, method_array);
       mirror::ObjectArray<mirror::ArtMethod>* vtable = klass->GetVTableDuringLinking();
       for (size_t j = 0; j < num_methods; ++j) {
@@ -3491,8 +3624,16 @@ bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
             }
           }
           if (miranda_method.get() == NULL) {
-            // point the interface table at a phantom slot
+            // Point the interface table at a phantom slot.
             miranda_method.reset(down_cast<mirror::ArtMethod*>(interface_method->Clone(self)));
+            if (UNLIKELY(miranda_method.get() == NULL)) {
+              CHECK(self->IsExceptionPending());  // OOME.
+              return false;
+            }
+#ifdef MOVING_GARBAGE_COLLECTOR
+            // TODO: If a methods move then the miranda_list may hold stale references.
+            UNIMPLEMENTED(FATAL);
+#endif
             miranda_list.push_back(miranda_method.get());
           }
           method_array->Set(j, miranda_method.get());
@@ -3503,9 +3644,17 @@ bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
   if (!miranda_list.empty()) {
     int old_method_count = klass->NumVirtualMethods();
     int new_method_count = old_method_count + miranda_list.size();
-    klass->SetVirtualMethods((old_method_count == 0)
-                             ? AllocArtMethodArray(self, new_method_count)
-                             : klass->GetVirtualMethods()->CopyOf(self, new_method_count));
+    mirror::ObjectArray<mirror::ArtMethod>* virtuals;
+    if (old_method_count == 0) {
+      virtuals = AllocArtMethodArray(self, new_method_count);
+    } else {
+      virtuals = klass->GetVirtualMethods()->CopyOf(self, new_method_count);
+    }
+    if (UNLIKELY(virtuals == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return false;
+    }
+    klass->SetVirtualMethods(virtuals);
 
     SirtRef<mirror::ObjectArray<mirror::ArtMethod> >
         vtable(self, klass->GetVTableDuringLinking());
@@ -3513,6 +3662,10 @@ bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
     int old_vtable_count = vtable->GetLength();
     int new_vtable_count = old_vtable_count + miranda_list.size();
     vtable.reset(vtable->CopyOf(self, new_vtable_count));
+    if (UNLIKELY(vtable.get() == NULL)) {
+      CHECK(self->IsExceptionPending());  // OOME.
+      return false;
+    }
     for (size_t i = 0; i < miranda_list.size(); ++i) {
       mirror::ArtMethod* method = miranda_list[i];
       // Leave the declaring class alone as type indices are relative to it
diff --git a/runtime/mirror/object.h b/runtime/mirror/object.h
index 28a91dd8e5..efaa183498 100644
--- a/runtime/mirror/object.h
+++ b/runtime/mirror/object.h
@@ -79,10 +79,10 @@ class MANAGED Object {
   Object* Clone(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   int32_t IdentityHashCode() const {
-  #ifdef MOVING_GARBAGE_COLLECTOR
+#ifdef MOVING_GARBAGE_COLLECTOR
     // TODO: we'll need to use the Object's internal concept of identity
-      UNIMPLEMENTED(FATAL);
-  #endif
+    UNIMPLEMENTED(FATAL);
+#endif
     return reinterpret_cast<int32_t>(this);
   }
 
diff --git a/runtime/mirror/object_array-inl.h b/runtime/mirror/object_array-inl.h
index 6f22618340..abc88a3bf8 100644
--- a/runtime/mirror/object_array-inl.h
+++ b/runtime/mirror/object_array-inl.h
@@ -135,7 +135,9 @@ inline void ObjectArray<T>::Copy(const ObjectArray<T>* src, int src_pos,
 template<class T>
 inline ObjectArray<T>* ObjectArray<T>::CopyOf(Thread* self, int32_t new_length) {
   ObjectArray<T>* new_array = Alloc(self, GetClass(), new_length);
-  Copy(this, 0, new_array, 0, std::min(GetLength(), new_length));
+  if (LIKELY(new_array != NULL)) {
+    Copy(this, 0, new_array, 0, std::min(GetLength(), new_length));
+  }
   return new_array;
 }
 
diff --git a/runtime/mirror/stack_trace_element.cc b/runtime/mirror/stack_trace_element.cc
index 1ad01823b2..a505ed00a3 100644
--- a/runtime/mirror/stack_trace_element.cc
+++ b/runtime/mirror/stack_trace_element.cc
@@ -44,14 +44,16 @@ StackTraceElement* StackTraceElement::Alloc(Thread* self,
                                             int32_t line_number) {
   StackTraceElement* trace =
       down_cast<StackTraceElement*>(GetStackTraceElement()->AllocObject(self));
-  trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, declaring_class_),
-                        const_cast<String*>(declaring_class), false);
-  trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, method_name_),
-                        const_cast<String*>(method_name), false);
-  trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, file_name_),
-                        const_cast<String*>(file_name), false);
-  trace->SetField32(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, line_number_),
-                    line_number, false);
+  if (LIKELY(trace != NULL)) {
+    trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, declaring_class_),
+                          const_cast<String*>(declaring_class), false);
+    trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, method_name_),
+                          const_cast<String*>(method_name), false);
+    trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, file_name_),
+                          const_cast<String*>(file_name), false);
+    trace->SetField32(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, line_number_),
+                      line_number, false);
+  }
   return trace;
 }
 
diff --git a/runtime/mirror/string.cc b/runtime/mirror/string.cc
index c64caa82a6..54ba3b01c6 100644
--- a/runtime/mirror/string.cc
+++ b/runtime/mirror/string.cc
@@ -137,7 +137,7 @@ String* String::AllocFromUtf16(Thread* self,
   return string;
 }
 
-  String* String::AllocFromModifiedUtf8(Thread* self, const char* utf) {
+String* String::AllocFromModifiedUtf8(Thread* self, const char* utf) {
   if (utf == NULL) {
     return NULL;
   }
diff --git a/runtime/native/dalvik_system_VMRuntime.cc b/runtime/native/dalvik_system_VMRuntime.cc
index b0f67c4c2e..5fc8bd5a48 100644
--- a/runtime/native/dalvik_system_VMRuntime.cc
+++ b/runtime/native/dalvik_system_VMRuntime.cc
@@ -74,9 +74,6 @@ static jobject VMRuntime_newNonMovableArray(JNIEnv* env, jobject, jclass javaEle
   descriptor += ClassHelper(element_class).GetDescriptor();
   mirror::Class* array_class = class_linker->FindClass(descriptor.c_str(), NULL);
   mirror::Array* result = mirror::Array::Alloc(soa.Self(), array_class, length);
-  if (result == NULL) {
-    return NULL;
-  }
   return soa.AddLocalReference<jobject>(result);
 }
 
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index 5679d4ea83..09cbd0bf6c 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -704,14 +704,8 @@ bool Runtime::Start() {
 
   CHECK(host_prefix_.empty()) << host_prefix_;
 
-  // Pre-allocate an OutOfMemoryError for the double-OOME case.
-  Thread* self = Thread::Current();
-  self->ThrowNewException(ThrowLocation(), "Ljava/lang/OutOfMemoryError;",
-                          "OutOfMemoryError thrown while trying to throw OutOfMemoryError; no stack available");
-  pre_allocated_OutOfMemoryError_ = self->GetException(NULL);
-  self->ClearException();
-
   // Restore main thread state to kNative as expected by native code.
+  Thread* self = Thread::Current();
   self->TransitionFromRunnableToSuspended(kNative);
 
   started_ = true;
@@ -906,7 +900,7 @@ bool Runtime::Init(const Options& raw_options, bool ignore_unrecognized) {
   // Set us to runnable so tools using a runtime can allocate and GC by default
   self->TransitionFromSuspendedToRunnable();
 
-  // Now we're attached, we can take the heap lock and validate the heap.
+  // Now we're attached, we can take the heap locks and validate the heap.
   GetHeap()->EnableObjectValidation();
 
   CHECK_GE(GetHeap()->GetContinuousSpaces().size(), 1U);
@@ -929,6 +923,12 @@ bool Runtime::Init(const Options& raw_options, bool ignore_unrecognized) {
                  false, false, 0);
   }
 
+  // Pre-allocate an OutOfMemoryError for the double-OOME case.
+  self->ThrowNewException(ThrowLocation(), "Ljava/lang/OutOfMemoryError;",
+                          "OutOfMemoryError thrown while trying to throw OutOfMemoryError; no stack available");
+  pre_allocated_OutOfMemoryError_ = self->GetException(NULL);
+  self->ClearException();
+
   VLOG(startup) << "Runtime::Init exiting";
   return true;
 }
@@ -1123,6 +1123,13 @@ void Runtime::DetachCurrentThread() {
   thread_list_->Unregister(self);
 }
 
+  mirror::Throwable* Runtime::GetPreAllocatedOutOfMemoryError() const {
+  if (pre_allocated_OutOfMemoryError_ == NULL) {
+    LOG(ERROR) << "Failed to return pre-allocated OOME";
+  }
+  return pre_allocated_OutOfMemoryError_;
+}
+
 void Runtime::VisitConcurrentRoots(RootVisitor* visitor, void* arg, bool only_dirty,
                                    bool clean_dirty) {
   if (!only_dirty || intern_table_->IsDirty()) {
diff --git a/runtime/runtime.h b/runtime/runtime.h
index 50108ac4e2..21161a03b4 100644
--- a/runtime/runtime.h
+++ b/runtime/runtime.h
@@ -287,9 +287,8 @@ class Runtime {
     return monitor_list_;
   }
 
-  mirror::Throwable* GetPreAllocatedOutOfMemoryError() {
-    return pre_allocated_OutOfMemoryError_;
-  }
+  mirror::Throwable* GetPreAllocatedOutOfMemoryError() const
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   const std::vector<std::string>& GetProperties() const {
     return properties_;
-- 
cgit v1.2.3-59-g8ed1b


From 4bf1c8d4f2127caf769573d7c762a5d460a2781f Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Wed, 28 Aug 2013 22:31:13 -0700
Subject: Update blacklist for klp-dev

Change-Id: I5308f71b4c2ccdd7f6ac422ccb2a2d78141d1ce3
---
 compiler/driver/compiler_driver.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 3368e96139..b17df4e443 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -1707,12 +1707,13 @@ static const char* class_initializer_black_list[] = {
   "Landroid/net/NetworkInfo;",  // Calls java.util.EnumMap.<init> -> java.lang.Enum.getSharedConstants -> System.identityHashCode.
   "Landroid/net/Proxy;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
   "Landroid/net/SSLCertificateSocketFactory;",  // Requires javax.net.ssl.HttpsURLConnection.
-  "Landroid/net/Uri;",  // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
   "Landroid/net/Uri$AbstractHierarchicalUri;",  // Requires Uri.
   "Landroid/net/Uri$HierarchicalUri;",  // Requires Uri.
   "Landroid/net/Uri$OpaqueUri;",  // Requires Uri.
   "Landroid/net/Uri$StringUri;",  // Requires Uri.
+  "Landroid/net/Uri;",  // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex.
   "Landroid/net/WebAddress;",  // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl.
+  "Landroid/net/wifi/WifiNative;",  // Calls new LocalLog -> new Time -> TimeZone -> Pattern.compile.
   "Landroid/nfc/NdefRecord;",  // Calls String.getBytes -> java.nio.charset.Charset.
   "Landroid/opengl/EGL14;",  // Calls android.opengl.EGL14._nativeClassInit.
   "Landroid/opengl/GLES10;",  // Calls android.opengl.GLES10._nativeClassInit.
-- 
cgit v1.2.3-59-g8ed1b


From 193bad9b9cfd10642043fa2ebbfc68bd5f9ede4b Mon Sep 17 00:00:00 2001
From: Mathieu Chartier <mathieuc@google.com>
Date: Thu, 29 Aug 2013 18:46:00 -0700
Subject: Multi threaded hashed deduplication during compilation.

Moved deduplication to be in the compiler driver instead of oat
writer. This enables deduplication to be performed on multiple
threads. Also added a hash function to avoid excessive comparison
of byte arrays.

Improvements:
Before (alloats host):
real	1m6.967s
user	4m22.940s
sys	1m22.610s

Thinkfree.apk (target mako):
0m23.74s real     0m50.95s user     0m9.50s system
0m24.62s real     0m50.61s user     0m10.07s system
0m24.22s real     0m51.44s user     0m10.09s system
0m23.70s real     0m51.05s user     0m9.97s system
0m23.50s real     0m50.74s user     0m10.63s system

After (alloats host):
real	1m5.705s
user	4m44.030s
sys	1m29.990s

Thinkfree.apk (target mako):
0m23.32s real     0m51.38s user     0m10.00s system
0m23.49s real     0m51.20s user     0m9.80s system
0m23.18s real     0m50.80s user     0m9.77s system
0m23.52s real     0m51.22s user     0m10.02s system
0m23.50s real     0m51.55s user     0m9.46s system

Bug: 10552630

Change-Id: Ia6d06a747b86b0bfc4473b3cd68f8ce1a1c7eb22
---
 build/Android.gtest.mk                |   1 +
 compiler/Android.mk                   |   1 +
 compiler/compiled_method.cc           | 170 +++++++++++++++++++++++++++++++
 compiler/compiled_method.h            | 176 +++++++++++++++++++++++++++++++++
 compiler/dex/quick/codegen_util.cc    |  13 ++-
 compiler/driver/compiler_driver.cc    |  16 +++
 compiler/driver/compiler_driver.h     |  32 ++++++
 compiler/jni/portable/jni_compiler.cc |   5 +-
 compiler/jni/portable/jni_compiler.h  |   4 +-
 compiler/jni/quick/jni_compiler.cc    |   3 +-
 compiler/llvm/compiler_llvm.cc        |   5 +-
 compiler/oat_writer.h                 |  18 ++--
 compiler/sea_ir/frontend.cc           |   8 +-
 compiler/utils/dedupe_set.h           |  82 +++++++++++++++
 compiler/utils/dedupe_set_test.cc     |  78 +++++++++++++++
 runtime/Android.mk                    |   1 -
 runtime/compiled_method.cc            | 133 -------------------------
 runtime/compiled_method.h             | 181 ----------------------------------
 18 files changed, 579 insertions(+), 348 deletions(-)
 create mode 100644 compiler/compiled_method.cc
 create mode 100644 compiler/compiled_method.h
 create mode 100644 compiler/utils/dedupe_set.h
 create mode 100644 compiler/utils/dedupe_set_test.cc
 delete mode 100644 runtime/compiled_method.cc
 delete mode 100644 runtime/compiled_method.h

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/build/Android.gtest.mk b/build/Android.gtest.mk
index a150f0653c..4c658a2bb7 100644
--- a/build/Android.gtest.mk
+++ b/build/Android.gtest.mk
@@ -23,6 +23,7 @@ TEST_COMMON_SRC_FILES := \
 	compiler/jni/jni_compiler_test.cc \
 	compiler/oat_test.cc \
 	compiler/output_stream_test.cc \
+	compiler/utils/dedupe_set_test.cc \
 	compiler/utils/arm/managed_register_arm_test.cc \
 	compiler/utils/x86/managed_register_x86_test.cc \
 	runtime/barrier_test.cc \
diff --git a/compiler/Android.mk b/compiler/Android.mk
index 8eb8db7140..66ff46163b 100644
--- a/compiler/Android.mk
+++ b/compiler/Android.mk
@@ -19,6 +19,7 @@ LOCAL_PATH := $(call my-dir)
 include art/build/Android.common.mk
 
 LIBART_COMPILER_SRC_FILES := \
+	compiled_method.cc \
 	dex/local_value_numbering.cc \
 	dex/arena_allocator.cc \
 	dex/arena_bit_vector.cc \
diff --git a/compiler/compiled_method.cc b/compiler/compiled_method.cc
new file mode 100644
index 0000000000..29ff390678
--- /dev/null
+++ b/compiler/compiled_method.cc
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "compiled_method.h"
+#include "driver/compiler_driver.h"
+
+namespace art {
+
+CompiledCode::CompiledCode(CompilerDriver* compiler_driver, InstructionSet instruction_set,
+                           const std::vector<uint8_t>& code)
+    : compiler_driver_(compiler_driver), instruction_set_(instruction_set), code_(nullptr) {
+  SetCode(code);
+}
+
+CompiledCode::CompiledCode(CompilerDriver* compiler_driver, InstructionSet instruction_set,
+                           const std::string& elf_object, const std::string& symbol)
+    : compiler_driver_(compiler_driver), instruction_set_(instruction_set), symbol_(symbol) {
+  CHECK_NE(elf_object.size(), 0U);
+  CHECK_NE(symbol.size(), 0U);
+  std::vector<uint8_t> temp_code(elf_object.size());
+  for (size_t i = 0; i < elf_object.size(); ++i) {
+    temp_code[i] = elf_object[i];
+  }
+  // TODO: we shouldn't just shove ELF objects in as "code" but
+  // change to have different kinds of compiled methods.  This is
+  // being deferred until we work on hybrid execution or at least
+  // until we work on batch compilation.
+  SetCode(temp_code);
+}
+
+void CompiledCode::SetCode(const std::vector<uint8_t>& code) {
+  CHECK(!code.empty());
+  code_ = compiler_driver_->DeduplicateCode(code);
+}
+
+uint32_t CompiledCode::AlignCode(uint32_t offset) const {
+  return AlignCode(offset, instruction_set_);
+}
+
+uint32_t CompiledCode::AlignCode(uint32_t offset, InstructionSet instruction_set) {
+  switch (instruction_set) {
+    case kArm:
+    case kThumb2:
+      return RoundUp(offset, kArmAlignment);
+    case kMips:
+      return RoundUp(offset, kMipsAlignment);
+    case kX86:
+      return RoundUp(offset, kX86Alignment);
+    default:
+      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set;
+      return 0;
+  }
+}
+
+size_t CompiledCode::CodeDelta() const {
+  switch (instruction_set_) {
+    case kArm:
+    case kMips:
+    case kX86:
+      return 0;
+    case kThumb2: {
+      // +1 to set the low-order bit so a BLX will switch to Thumb mode
+      return 1;
+    }
+    default:
+      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
+      return 0;
+  }
+}
+
+const void* CompiledCode::CodePointer(const void* code_pointer,
+                                      InstructionSet instruction_set) {
+  switch (instruction_set) {
+    case kArm:
+    case kMips:
+    case kX86:
+      return code_pointer;
+    case kThumb2: {
+      uintptr_t address = reinterpret_cast<uintptr_t>(code_pointer);
+      // Set the low-order bit so a BLX will switch to Thumb mode
+      address |= 0x1;
+      return reinterpret_cast<const void*>(address);
+    }
+    default:
+      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set;
+      return NULL;
+  }
+}
+
+#if defined(ART_USE_PORTABLE_COMPILER)
+const std::string& CompiledCode::GetSymbol() const {
+  CHECK_NE(0U, symbol_.size());
+  return symbol_;
+}
+
+const std::vector<uint32_t>& CompiledCode::GetOatdataOffsetsToCompliledCodeOffset() const {
+  CHECK_NE(0U, oatdata_offsets_to_compiled_code_offset_.size()) << symbol_;
+  return oatdata_offsets_to_compiled_code_offset_;
+}
+
+void CompiledCode::AddOatdataOffsetToCompliledCodeOffset(uint32_t offset) {
+  oatdata_offsets_to_compiled_code_offset_.push_back(offset);
+}
+#endif
+
+CompiledMethod::CompiledMethod(CompilerDriver& driver,
+                               InstructionSet instruction_set,
+                               const std::vector<uint8_t>& code,
+                               const size_t frame_size_in_bytes,
+                               const uint32_t core_spill_mask,
+                               const uint32_t fp_spill_mask,
+                               const std::vector<uint8_t>& mapping_table,
+                               const std::vector<uint8_t>& vmap_table,
+                               const std::vector<uint8_t>& native_gc_map)
+    : CompiledCode(&driver, instruction_set, code), frame_size_in_bytes_(frame_size_in_bytes),
+      core_spill_mask_(core_spill_mask), fp_spill_mask_(fp_spill_mask),
+  mapping_table_(driver.DeduplicateMappingTable(mapping_table)),
+  vmap_table_(driver.DeduplicateVMapTable(vmap_table)),
+  gc_map_(driver.DeduplicateGCMap(native_gc_map)) {
+}
+
+CompiledMethod::CompiledMethod(CompilerDriver& driver,
+                               InstructionSet instruction_set,
+                               const std::vector<uint8_t>& code,
+                               const size_t frame_size_in_bytes,
+                               const uint32_t core_spill_mask,
+                               const uint32_t fp_spill_mask)
+    : CompiledCode(&driver, instruction_set, code),
+      frame_size_in_bytes_(frame_size_in_bytes),
+      core_spill_mask_(core_spill_mask), fp_spill_mask_(fp_spill_mask) {
+  mapping_table_ = driver.DeduplicateMappingTable(std::vector<uint8_t>());
+  vmap_table_ = driver.DeduplicateVMapTable(std::vector<uint8_t>());
+  gc_map_ = driver.DeduplicateGCMap(std::vector<uint8_t>());
+}
+
+// Constructs a CompiledMethod for the Portable compiler.
+CompiledMethod::CompiledMethod(CompilerDriver& driver, InstructionSet instruction_set,
+                               const std::string& code, const std::vector<uint8_t>& gc_map,
+                               const std::string& symbol)
+    : CompiledCode(&driver, instruction_set, code, symbol),
+      frame_size_in_bytes_(kStackAlignment), core_spill_mask_(0),
+      fp_spill_mask_(0), gc_map_(driver.DeduplicateGCMap(gc_map)) {
+  mapping_table_ = driver.DeduplicateMappingTable(std::vector<uint8_t>());
+  vmap_table_ = driver.DeduplicateVMapTable(std::vector<uint8_t>());
+}
+
+CompiledMethod::CompiledMethod(CompilerDriver& driver, InstructionSet instruction_set,
+                               const std::string& code, const std::string& symbol)
+    : CompiledCode(&driver, instruction_set, code, symbol),
+      frame_size_in_bytes_(kStackAlignment), core_spill_mask_(0),
+      fp_spill_mask_(0) {
+  mapping_table_ = driver.DeduplicateMappingTable(std::vector<uint8_t>());
+  vmap_table_ = driver.DeduplicateVMapTable(std::vector<uint8_t>());
+  gc_map_ = driver.DeduplicateGCMap(std::vector<uint8_t>());
+}
+
+}  // namespace art
diff --git a/compiler/compiled_method.h b/compiler/compiled_method.h
new file mode 100644
index 0000000000..e4fedf1ab4
--- /dev/null
+++ b/compiler/compiled_method.h
@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2011 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_COMPILED_METHOD_H_
+#define ART_COMPILER_COMPILED_METHOD_H_
+
+#include <string>
+#include <vector>
+
+#include "instruction_set.h"
+#include "utils.h"
+#include "UniquePtr.h"
+
+namespace llvm {
+  class Function;
+}  // namespace llvm
+
+namespace art {
+
+class CompilerDriver;
+
+class CompiledCode {
+ public:
+  // For Quick to supply an code blob
+  CompiledCode(CompilerDriver* compiler_driver, InstructionSet instruction_set,
+               const std::vector<uint8_t>& code);
+
+  // For Portable to supply an ELF object
+  CompiledCode(CompilerDriver* compiler_driver, InstructionSet instruction_set,
+               const std::string& elf_object, const std::string &symbol);
+
+  InstructionSet GetInstructionSet() const {
+    return instruction_set_;
+  }
+
+  const std::vector<uint8_t>& GetCode() const {
+    return *code_;
+  }
+
+  void SetCode(const std::vector<uint8_t>& code);
+
+  bool operator==(const CompiledCode& rhs) const {
+    return (code_ == rhs.code_);
+  }
+
+  // To align an offset from a page-aligned value to make it suitable
+  // for code storage. For example on ARM, to ensure that PC relative
+  // valu computations work out as expected.
+  uint32_t AlignCode(uint32_t offset) const;
+  static uint32_t AlignCode(uint32_t offset, InstructionSet instruction_set);
+
+  // returns the difference between the code address and a usable PC.
+  // mainly to cope with kThumb2 where the lower bit must be set.
+  size_t CodeDelta() const;
+
+  // Returns a pointer suitable for invoking the code at the argument
+  // code_pointer address.  Mainly to cope with kThumb2 where the
+  // lower bit must be set to indicate Thumb mode.
+  static const void* CodePointer(const void* code_pointer,
+                                 InstructionSet instruction_set);
+
+#if defined(ART_USE_PORTABLE_COMPILER)
+  const std::string& GetSymbol() const;
+  const std::vector<uint32_t>& GetOatdataOffsetsToCompliledCodeOffset() const;
+  void AddOatdataOffsetToCompliledCodeOffset(uint32_t offset);
+#endif
+
+ private:
+  CompilerDriver* compiler_driver_;
+
+  const InstructionSet instruction_set_;
+
+  // Used to store the PIC code for Quick and an ELF image for portable.
+  std::vector<uint8_t>* code_;
+
+  // Used for the Portable ELF symbol name.
+  const std::string symbol_;
+
+  // There are offsets from the oatdata symbol to where the offset to
+  // the compiled method will be found. These are computed by the
+  // OatWriter and then used by the ElfWriter to add relocations so
+  // that MCLinker can update the values to the location in the linked .so.
+  std::vector<uint32_t> oatdata_offsets_to_compiled_code_offset_;
+};
+
+class CompiledMethod : public CompiledCode {
+ public:
+  // Constructs a CompiledMethod for the non-LLVM compilers.
+  CompiledMethod(CompilerDriver& driver,
+                 InstructionSet instruction_set,
+                 const std::vector<uint8_t>& code,
+                 const size_t frame_size_in_bytes,
+                 const uint32_t core_spill_mask,
+                 const uint32_t fp_spill_mask,
+                 const std::vector<uint8_t>& mapping_table,
+                 const std::vector<uint8_t>& vmap_table,
+                 const std::vector<uint8_t>& native_gc_map);
+
+  // Constructs a CompiledMethod for the JniCompiler.
+  CompiledMethod(CompilerDriver& driver,
+                 InstructionSet instruction_set,
+                 const std::vector<uint8_t>& code,
+                 const size_t frame_size_in_bytes,
+                 const uint32_t core_spill_mask,
+                 const uint32_t fp_spill_mask);
+
+  // Constructs a CompiledMethod for the Portable compiler.
+  CompiledMethod(CompilerDriver& driver, InstructionSet instruction_set, const std::string& code,
+                 const std::vector<uint8_t>& gc_map, const std::string& symbol);
+
+  // Constructs a CompiledMethod for the Portable JniCompiler.
+  CompiledMethod(CompilerDriver& driver, InstructionSet instruction_set, const std::string& code,
+                 const std::string& symbol);
+
+  ~CompiledMethod() {}
+
+  size_t GetFrameSizeInBytes() const {
+    return frame_size_in_bytes_;
+  }
+
+  uint32_t GetCoreSpillMask() const {
+    return core_spill_mask_;
+  }
+
+  uint32_t GetFpSpillMask() const {
+    return fp_spill_mask_;
+  }
+
+  const std::vector<uint8_t>& GetMappingTable() const {
+    DCHECK(mapping_table_ != nullptr);
+    return *mapping_table_;
+  }
+
+  const std::vector<uint8_t>& GetVmapTable() const {
+    DCHECK(vmap_table_ != nullptr);
+    return *vmap_table_;
+  }
+
+  const std::vector<uint8_t>& GetGcMap() const {
+    DCHECK(gc_map_ != nullptr);
+    return *gc_map_;
+  }
+
+ private:
+  // For quick code, the size of the activation used by the code.
+  const size_t frame_size_in_bytes_;
+  // For quick code, a bit mask describing spilled GPR callee-save registers.
+  const uint32_t core_spill_mask_;
+  // For quick code, a bit mask describing spilled FPR callee-save registers.
+  const uint32_t fp_spill_mask_;
+  // For quick code, a uleb128 encoded map from native PC offset to dex PC aswell as dex PC to
+  // native PC offset. Size prefixed.
+  std::vector<uint8_t>* mapping_table_;
+  // For quick code, a uleb128 encoded map from GPR/FPR register to dex register. Size prefixed.
+  std::vector<uint8_t>* vmap_table_;
+  // For quick code, a map keyed by native PC indices to bitmaps describing what dalvik registers
+  // are live. For portable code, the key is a dalvik PC.
+  std::vector<uint8_t>* gc_map_;
+};
+
+}  // namespace art
+
+#endif  // ART_COMPILER_COMPILED_METHOD_H_
diff --git a/compiler/dex/quick/codegen_util.cc b/compiler/dex/quick/codegen_util.cc
index d89f1ed227..e081c16bb5 100644
--- a/compiler/dex/quick/codegen_util.cc
+++ b/compiler/dex/quick/codegen_util.cc
@@ -1004,7 +1004,7 @@ CompiledMethod* Mir2Lir::GetCompiledMethod() {
   std::vector<uint16_t> raw_vmap_table;
   // Core regs may have been inserted out of order - sort first
   std::sort(core_vmap_table_.begin(), core_vmap_table_.end());
-  for (size_t i = 0 ; i < core_vmap_table_.size(); i++) {
+  for (size_t i = 0 ; i < core_vmap_table_.size(); ++i) {
     // Copy, stripping out the phys register sort key
     raw_vmap_table.push_back(~(-1 << VREG_NUM_WIDTH) & core_vmap_table_[i]);
   }
@@ -1022,14 +1022,13 @@ CompiledMethod* Mir2Lir::GetCompiledMethod() {
   UnsignedLeb128EncodingVector vmap_encoder;
   // Prefix the encoded data with its size.
   vmap_encoder.PushBack(raw_vmap_table.size());
-  typedef std::vector<uint16_t>::const_iterator It;
-  for (It cur = raw_vmap_table.begin(), end = raw_vmap_table.end(); cur != end; ++cur) {
-    vmap_encoder.PushBack(*cur);
+  for (uint16_t cur : raw_vmap_table) {
+    vmap_encoder.PushBack(cur);
   }
   CompiledMethod* result =
-      new CompiledMethod(cu_->instruction_set, code_buffer_,
-                         frame_size_, core_spill_mask_, fp_spill_mask_,
-                         encoded_mapping_table_.GetData(), vmap_encoder.GetData(), native_gc_map_);
+      new CompiledMethod(*cu_->compiler_driver, cu_->instruction_set, code_buffer_, frame_size_,
+                         core_spill_mask_, fp_spill_mask_, encoded_mapping_table_.GetData(),
+                         vmap_encoder.GetData(), native_gc_map_);
   return result;
 }
 
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index b17df4e443..cbd9020df4 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -394,6 +394,22 @@ CompilerDriver::CompilerDriver(CompilerBackend compiler_backend, InstructionSet
   }
 }
 
+std::vector<uint8_t>* CompilerDriver::DeduplicateCode(const std::vector<uint8_t>& code) {
+  return dedupe_code_.Add(Thread::Current(), code);
+}
+
+std::vector<uint8_t>* CompilerDriver::DeduplicateMappingTable(const std::vector<uint8_t>& code) {
+  return dedupe_mapping_table_.Add(Thread::Current(), code);
+}
+
+std::vector<uint8_t>* CompilerDriver::DeduplicateVMapTable(const std::vector<uint8_t>& code) {
+  return dedupe_vmap_table_.Add(Thread::Current(), code);
+}
+
+std::vector<uint8_t>* CompilerDriver::DeduplicateGCMap(const std::vector<uint8_t>& code) {
+  return dedupe_gc_map_.Add(Thread::Current(), code);
+}
+
 CompilerDriver::~CompilerDriver() {
   Thread* self = Thread::Current();
   {
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index fa1b8f9854..cd6b5fab02 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -34,6 +34,7 @@
 #include "runtime.h"
 #include "safe_map.h"
 #include "thread_pool.h"
+#include "utils/dedupe_set.h"
 
 namespace art {
 
@@ -303,6 +304,11 @@ class CompilerDriver {
   void RecordClassStatus(ClassReference ref, mirror::Class::Status status)
       LOCKS_EXCLUDED(compiled_classes_lock_);
 
+  std::vector<uint8_t>* DeduplicateCode(const std::vector<uint8_t>& code);
+  std::vector<uint8_t>* DeduplicateMappingTable(const std::vector<uint8_t>& code);
+  std::vector<uint8_t>* DeduplicateVMapTable(const std::vector<uint8_t>& code);
+  std::vector<uint8_t>* DeduplicateGCMap(const std::vector<uint8_t>& code);
+
  private:
   // Compute constant code and method pointers when possible
   void GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type,
@@ -439,6 +445,32 @@ class CompilerDriver {
 
   bool support_boot_image_fixup_;
 
+  // DeDuplication data structures, these own the corresponding byte arrays.
+  class DedupeHashFunc {
+   public:
+    size_t operator()(const std::vector<uint8_t>& array) const {
+      // Take a random sample of bytes.
+      static const size_t kSmallArrayThreshold = 16;
+      static const size_t kRandomHashCount = 16;
+      size_t hash = 0;
+      if (array.size() < kSmallArrayThreshold) {
+        for (auto c : array) {
+          hash = hash * 54 + c;
+        }
+      } else {
+        for (size_t i = 0; i < kRandomHashCount; ++i) {
+          size_t r = i * 1103515245 + 12345;
+          hash = hash * 54 + array[r % array.size()];
+        }
+      }
+      return hash;
+    }
+  };
+  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc> dedupe_code_;
+  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc> dedupe_mapping_table_;
+  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc> dedupe_vmap_table_;
+  DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc> dedupe_gc_map_;
+
   DISALLOW_COPY_AND_ASSIGN(CompilerDriver);
 };
 
diff --git a/compiler/jni/portable/jni_compiler.cc b/compiler/jni/portable/jni_compiler.cc
index fc2e4e2b2e..43408a7d64 100644
--- a/compiler/jni/portable/jni_compiler.cc
+++ b/compiler/jni/portable/jni_compiler.cc
@@ -50,7 +50,7 @@ using ::art::llvm::runtime_support::JniMethodStartSynchronized;
 using ::art::llvm::runtime_support::RuntimeId;
 
 JniCompiler::JniCompiler(LlvmCompilationUnit* cunit,
-                         const CompilerDriver& driver,
+                         CompilerDriver& driver,
                          const DexCompilationUnit* dex_compilation_unit)
     : cunit_(cunit), driver_(&driver), module_(cunit_->GetModule()),
       context_(cunit_->GetLLVMContext()), irb_(*cunit_->GetIRBuilder()),
@@ -251,8 +251,7 @@ CompiledMethod* JniCompiler::Compile() {
 
   cunit_->Materialize();
 
-  return new CompiledMethod(cunit_->GetInstructionSet(),
-                            cunit_->GetElfObject(),
+  return new CompiledMethod(*driver_, cunit_->GetInstructionSet(), cunit_->GetElfObject(),
                             func_name);
 }
 
diff --git a/compiler/jni/portable/jni_compiler.h b/compiler/jni/portable/jni_compiler.h
index 49cc9f4abf..d20c63bc1e 100644
--- a/compiler/jni/portable/jni_compiler.h
+++ b/compiler/jni/portable/jni_compiler.h
@@ -54,7 +54,7 @@ class IRBuilder;
 class JniCompiler {
  public:
   JniCompiler(LlvmCompilationUnit* cunit,
-              const CompilerDriver& driver,
+              CompilerDriver& driver,
               const DexCompilationUnit* dex_compilation_unit);
 
   CompiledMethod* Compile();
@@ -67,7 +67,7 @@ class JniCompiler {
 
  private:
   LlvmCompilationUnit* cunit_;
-  const CompilerDriver* const driver_;
+  CompilerDriver* driver_;
 
   ::llvm::Module* module_;
   ::llvm::LLVMContext* context_;
diff --git a/compiler/jni/quick/jni_compiler.cc b/compiler/jni/quick/jni_compiler.cc
index 069def60f9..1417fb9e40 100644
--- a/compiler/jni/quick/jni_compiler.cc
+++ b/compiler/jni/quick/jni_compiler.cc
@@ -370,7 +370,8 @@ CompiledMethod* ArtJniCompileMethodInternal(CompilerDriver& compiler,
     UniquePtr<Disassembler> disassembler(Disassembler::Create(instruction_set));
     disassembler->Dump(LOG(INFO), &managed_code[0], &managed_code[managed_code.size()]);
   }
-  return new CompiledMethod(instruction_set,
+  return new CompiledMethod(compiler,
+                            instruction_set,
                             managed_code,
                             frame_size,
                             main_jni_conv->CoreSpillMask(),
diff --git a/compiler/llvm/compiler_llvm.cc b/compiler/llvm/compiler_llvm.cc
index 6b19a37b6f..fd440d5bf0 100644
--- a/compiler/llvm/compiler_llvm.cc
+++ b/compiler/llvm/compiler_llvm.cc
@@ -153,9 +153,8 @@ CompileDexMethod(DexCompilationUnit* dex_compilation_unit, InvokeType invoke_typ
 
   MethodReference mref(dex_compilation_unit->GetDexFile(),
                        dex_compilation_unit->GetDexMethodIndex());
-  return new CompiledMethod(compiler_driver_->GetInstructionSet(),
-                            cunit->GetElfObject(),
-                            *verifier::MethodVerifier::GetDexGcMap(mref),
+  return new CompiledMethod(*compiler_driver_, compiler_driver_->GetInstructionSet(),
+                            cunit->GetElfObject(), *verifier::MethodVerifier::GetDexGcMap(mref),
                             cunit->GetDexCompilationUnit()->GetSymbol());
 }
 
diff --git a/compiler/oat_writer.h b/compiler/oat_writer.h
index 8111c9f7a0..d5f7e21a1a 100644
--- a/compiler/oat_writer.h
+++ b/compiler/oat_writer.h
@@ -217,18 +217,12 @@ class OatWriter {
   uint32_t size_oat_class_status_;
   uint32_t size_oat_class_method_offsets_;
 
-  template <class T> struct MapCompare {
-   public:
-    bool operator() (const T* const &a, const T* const &b) const {
-      return *a < *b;
-    }
-  };
-
-  // code mappings for deduplication
-  SafeMap<const std::vector<uint8_t>*, uint32_t, MapCompare<std::vector<uint8_t> > > code_offsets_;
-  SafeMap<const std::vector<uint8_t>*, uint32_t, MapCompare<std::vector<uint8_t> > > vmap_table_offsets_;
-  SafeMap<const std::vector<uint8_t>*, uint32_t, MapCompare<std::vector<uint8_t> > > mapping_table_offsets_;
-  SafeMap<const std::vector<uint8_t>*, uint32_t, MapCompare<std::vector<uint8_t> > > gc_map_offsets_;
+  // Code mappings for deduplication. Deduplication is already done on a pointer basis by the
+  // compiler driver, so we can simply compare the pointers to find out if things are duplicated.
+  SafeMap<const std::vector<uint8_t>*, uint32_t> code_offsets_;
+  SafeMap<const std::vector<uint8_t>*, uint32_t> vmap_table_offsets_;
+  SafeMap<const std::vector<uint8_t>*, uint32_t> mapping_table_offsets_;
+  SafeMap<const std::vector<uint8_t>*, uint32_t> gc_map_offsets_;
 
   DISALLOW_COPY_AND_ASSIGN(OatWriter);
 };
diff --git a/compiler/sea_ir/frontend.cc b/compiler/sea_ir/frontend.cc
index 6efc103f40..93f6f25461 100644
--- a/compiler/sea_ir/frontend.cc
+++ b/compiler/sea_ir/frontend.cc
@@ -57,11 +57,9 @@ static CompiledMethod* CompileMethodWithSeaIr(CompilerDriver& compiler,
   dc.DumpSea(ir_graph, "/tmp/temp.dot", types);
   MethodReference mref(&dex_file, method_idx);
   std::string llvm_code = llvm_data->GetElf(compiler.GetInstructionSet());
-  CompiledMethod* compiled_method =  new CompiledMethod(
-                              compiler.GetInstructionSet(),
-                              llvm_code,
-                              *verifier::MethodVerifier::GetDexGcMap(mref),
-                              symbol);
+  CompiledMethod* compiled_method =
+      new CompiledMethod(compiler, compiler.GetInstructionSet(), llvm_code,
+                         *verifier::MethodVerifier::GetDexGcMap(mref), symbol);
   LOG(INFO) << "Compiled SEA IR method " << PrettyMethod(method_idx, dex_file) << ".";
   return compiled_method;
 }
diff --git a/compiler/utils/dedupe_set.h b/compiler/utils/dedupe_set.h
new file mode 100644
index 0000000000..f3d35d728c
--- /dev/null
+++ b/compiler/utils/dedupe_set.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2013 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_UTILS_DEDUPE_SET_H_
+#define ART_COMPILER_UTILS_DEDUPE_SET_H_
+
+#include <set>
+
+#include "base/mutex.h"
+#include "base/stl_util.h"
+
+namespace art {
+
+// A simple data structure to handle hashed deduplication. Add is thread safe.
+template <typename Key, typename HashType, typename HashFunc>
+class DedupeSet {
+  typedef std::pair<HashType, Key*> HashedKey;
+
+  class Comparator {
+   public:
+    bool operator()(const HashedKey& a, const HashedKey& b) const {
+      if (a.first < b.first) return true;
+      if (a.first > b.first) return true;
+      return *a.second < *b.second;
+    }
+  };
+
+  typedef std::set<HashedKey, Comparator> Keys;
+
+ public:
+  typedef typename Keys::iterator iterator;
+  typedef typename Keys::const_iterator const_iterator;
+  typedef typename Keys::size_type size_type;
+  typedef typename Keys::value_type value_type;
+
+  iterator begin() { return keys_.begin(); }
+  const_iterator begin() const { return keys_.begin(); }
+  iterator end() { return keys_.end(); }
+  const_iterator end() const { return keys_.end(); }
+
+  Key* Add(Thread* self, const Key& key) {
+    HashType hash = HashFunc()(key);
+    HashedKey hashed_key(hash, const_cast<Key*>(&key));
+    MutexLock lock(self, lock_);
+    auto it = keys_.find(hashed_key);
+    if (it != keys_.end()) {
+      return it->second;
+    }
+    hashed_key.second = new Key(key);
+    keys_.insert(hashed_key);
+    return hashed_key.second;
+  }
+
+  DedupeSet() : lock_("dedupe lock") {
+  }
+
+  ~DedupeSet() {
+    STLDeleteValues(&keys_);
+  }
+
+ private:
+  Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+  Keys keys_;
+  DISALLOW_COPY_AND_ASSIGN(DedupeSet);
+};
+
+}  // namespace art
+
+#endif  // ART_COMPILER_UTILS_DEDUPE_SET_H_
diff --git a/compiler/utils/dedupe_set_test.cc b/compiler/utils/dedupe_set_test.cc
new file mode 100644
index 0000000000..9f5e292f53
--- /dev/null
+++ b/compiler/utils/dedupe_set_test.cc
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+
+#include "common_test.h"
+#include "dedupe_set.h"
+
+namespace art {
+
+class DedupeSetTest : public testing::Test {
+ public:
+};
+
+class DedupeHashFunc {
+ public:
+  size_t operator()(const std::vector<uint8_t>& array) const {
+    size_t hash = 0;
+    for (uint8_t c : array) {
+      hash += c;
+      hash += hash << 10;
+      hash += hash >> 6;
+    }
+    return hash;
+  }
+};
+TEST_F(DedupeSetTest, Test) {
+  Thread* self = Thread::Current();
+  typedef std::vector<uint8_t> ByteArray;
+  DedupeSet<ByteArray, size_t, DedupeHashFunc> deduplicator;
+  ByteArray* array1;
+  {
+    ByteArray test1;
+    test1.push_back(10);
+    test1.push_back(20);
+    test1.push_back(30);
+    test1.push_back(45);
+    array1 = deduplicator.Add(self, test1);
+    ASSERT_EQ(test1, *array1);
+  }
+
+  ByteArray* array2;
+  {
+    ByteArray test1;
+    test1.push_back(10);
+    test1.push_back(20);
+    test1.push_back(30);
+    test1.push_back(45);
+    array2 = deduplicator.Add(self, test1);
+    ASSERT_EQ(array2, array1);
+    ASSERT_EQ(test1, *array2);
+  }
+
+  ByteArray* array3;
+  {
+    ByteArray test1;
+    test1.push_back(10);
+    test1.push_back(22);
+    test1.push_back(30);
+    test1.push_back(47);
+    array3 = deduplicator.Add(self, test1);
+    ASSERT_NE(array3, &test1);
+    ASSERT_EQ(test1, *array3);
+  }
+}
+
+}  // namespace art
diff --git a/runtime/Android.mk b/runtime/Android.mk
index 1ce7a3055d..a8d505e1f5 100644
--- a/runtime/Android.mk
+++ b/runtime/Android.mk
@@ -34,7 +34,6 @@ LIBART_COMMON_SRC_FILES := \
 	check_jni.cc \
 	class_linker.cc \
 	common_throws.cc \
-	compiled_method.cc \
 	debugger.cc \
 	dex_file.cc \
 	dex_file_verifier.cc \
diff --git a/runtime/compiled_method.cc b/runtime/compiled_method.cc
deleted file mode 100644
index 4631cb5db4..0000000000
--- a/runtime/compiled_method.cc
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright (C) 2011 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.
- */
-
-#include "compiled_method.h"
-
-namespace art {
-
-CompiledCode::CompiledCode(InstructionSet instruction_set, const std::vector<uint8_t>& code)
-    : instruction_set_(instruction_set), code_(code) {
-  CHECK_NE(code.size(), 0U);
-}
-
-CompiledCode::CompiledCode(InstructionSet instruction_set,
-                           const std::string& elf_object,
-                           const std::string& symbol)
-    : instruction_set_(instruction_set), symbol_(symbol) {
-  CHECK_NE(elf_object.size(), 0U);
-  CHECK_NE(symbol.size(), 0U);
-  // TODO: we shouldn't just shove ELF objects in as "code" but
-  // change to have different kinds of compiled methods.  This is
-  // being deferred until we work on hybrid execution or at least
-  // until we work on batch compilation.
-  code_.resize(elf_object.size());
-  memcpy(&code_[0], &elf_object[0], elf_object.size());
-}
-
-uint32_t CompiledCode::AlignCode(uint32_t offset) const {
-  return AlignCode(offset, instruction_set_);
-}
-
-uint32_t CompiledCode::AlignCode(uint32_t offset, InstructionSet instruction_set) {
-  switch (instruction_set) {
-    case kArm:
-    case kThumb2:
-      return RoundUp(offset, kArmAlignment);
-    case kMips:
-      return RoundUp(offset, kMipsAlignment);
-    case kX86:
-      return RoundUp(offset, kX86Alignment);
-    default:
-      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set;
-      return 0;
-  }
-}
-
-size_t CompiledCode::CodeDelta() const {
-  switch (instruction_set_) {
-    case kArm:
-    case kMips:
-    case kX86:
-      return 0;
-    case kThumb2: {
-      // +1 to set the low-order bit so a BLX will switch to Thumb mode
-      return 1;
-    }
-    default:
-      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set_;
-      return 0;
-  }
-}
-
-const void* CompiledCode::CodePointer(const void* code_pointer,
-                                      InstructionSet instruction_set) {
-  switch (instruction_set) {
-    case kArm:
-    case kMips:
-    case kX86:
-      return code_pointer;
-    case kThumb2: {
-      uintptr_t address = reinterpret_cast<uintptr_t>(code_pointer);
-      // Set the low-order bit so a BLX will switch to Thumb mode
-      address |= 0x1;
-      return reinterpret_cast<const void*>(address);
-    }
-    default:
-      LOG(FATAL) << "Unknown InstructionSet: " << instruction_set;
-      return NULL;
-  }
-}
-
-#if defined(ART_USE_PORTABLE_COMPILER)
-const std::string& CompiledCode::GetSymbol() const {
-  CHECK_NE(0U, symbol_.size());
-  return symbol_;
-}
-
-const std::vector<uint32_t>& CompiledCode::GetOatdataOffsetsToCompliledCodeOffset() const {
-  CHECK_NE(0U, oatdata_offsets_to_compiled_code_offset_.size()) << symbol_;
-  return oatdata_offsets_to_compiled_code_offset_;
-}
-
-void CompiledCode::AddOatdataOffsetToCompliledCodeOffset(uint32_t offset) {
-  oatdata_offsets_to_compiled_code_offset_.push_back(offset);
-}
-#endif
-
-CompiledMethod::CompiledMethod(InstructionSet instruction_set,
-                               const std::vector<uint8_t>& code,
-                               const size_t frame_size_in_bytes,
-                               const uint32_t core_spill_mask,
-                               const uint32_t fp_spill_mask,
-                               const std::vector<uint8_t>& mapping_table,
-                               const std::vector<uint8_t>& vmap_table,
-                               const std::vector<uint8_t>& native_gc_map)
-    : CompiledCode(instruction_set, code), frame_size_in_bytes_(frame_size_in_bytes),
-      core_spill_mask_(core_spill_mask), fp_spill_mask_(fp_spill_mask),
-      mapping_table_(mapping_table), vmap_table_(vmap_table),
-      gc_map_(native_gc_map) {
-}
-
-CompiledMethod::CompiledMethod(InstructionSet instruction_set,
-                               const std::vector<uint8_t>& code,
-                               const size_t frame_size_in_bytes,
-                               const uint32_t core_spill_mask,
-                               const uint32_t fp_spill_mask)
-    : CompiledCode(instruction_set, code),
-      frame_size_in_bytes_(frame_size_in_bytes),
-      core_spill_mask_(core_spill_mask), fp_spill_mask_(fp_spill_mask) {}
-
-}  // namespace art
diff --git a/runtime/compiled_method.h b/runtime/compiled_method.h
deleted file mode 100644
index b3bb20fac4..0000000000
--- a/runtime/compiled_method.h
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- * Copyright (C) 2011 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_RUNTIME_COMPILED_METHOD_H_
-#define ART_RUNTIME_COMPILED_METHOD_H_
-
-#include <string>
-#include <vector>
-
-#include "instruction_set.h"
-#include "utils.h"
-#include "UniquePtr.h"
-
-namespace llvm {
-  class Function;
-}  // namespace llvm
-
-namespace art {
-
-class CompiledCode {
- public:
-  // For Quick to supply an code blob
-  CompiledCode(InstructionSet instruction_set, const std::vector<uint8_t>& code);
-
-  // For Portable to supply an ELF object
-  CompiledCode(InstructionSet instruction_set,
-               const std::string& elf_object,
-               const std::string &symbol);
-
-  InstructionSet GetInstructionSet() const {
-    return instruction_set_;
-  }
-
-  const std::vector<uint8_t>& GetCode() const {
-    return code_;
-  }
-
-  void SetCode(const std::vector<uint8_t>& code) {
-    CHECK_NE(code.size(), 0U);
-    code_ = code;
-  }
-
-  bool operator==(const CompiledCode& rhs) const {
-    return (code_ == rhs.code_);
-  }
-
-  // To align an offset from a page-aligned value to make it suitable
-  // for code storage. For example on ARM, to ensure that PC relative
-  // valu computations work out as expected.
-  uint32_t AlignCode(uint32_t offset) const;
-  static uint32_t AlignCode(uint32_t offset, InstructionSet instruction_set);
-
-  // returns the difference between the code address and a usable PC.
-  // mainly to cope with kThumb2 where the lower bit must be set.
-  size_t CodeDelta() const;
-
-  // Returns a pointer suitable for invoking the code at the argument
-  // code_pointer address.  Mainly to cope with kThumb2 where the
-  // lower bit must be set to indicate Thumb mode.
-  static const void* CodePointer(const void* code_pointer,
-                                 InstructionSet instruction_set);
-
-#if defined(ART_USE_PORTABLE_COMPILER)
-  const std::string& GetSymbol() const;
-  const std::vector<uint32_t>& GetOatdataOffsetsToCompliledCodeOffset() const;
-  void AddOatdataOffsetToCompliledCodeOffset(uint32_t offset);
-#endif
-
- private:
-  const InstructionSet instruction_set_;
-
-  // Used to store the PIC code for Quick and an ELF image for portable.
-  std::vector<uint8_t> code_;
-
-  // Used for the Portable ELF symbol name.
-  const std::string symbol_;
-
-  // There are offsets from the oatdata symbol to where the offset to
-  // the compiled method will be found. These are computed by the
-  // OatWriter and then used by the ElfWriter to add relocations so
-  // that MCLinker can update the values to the location in the linked .so.
-  std::vector<uint32_t> oatdata_offsets_to_compiled_code_offset_;
-};
-
-class CompiledMethod : public CompiledCode {
- public:
-  // Constructs a CompiledMethod for the non-LLVM compilers.
-  CompiledMethod(InstructionSet instruction_set,
-                 const std::vector<uint8_t>& code,
-                 const size_t frame_size_in_bytes,
-                 const uint32_t core_spill_mask,
-                 const uint32_t fp_spill_mask,
-                 const std::vector<uint8_t>& mapping_table,
-                 const std::vector<uint8_t>& vmap_table,
-                 const std::vector<uint8_t>& native_gc_map);
-
-  // Constructs a CompiledMethod for the JniCompiler.
-  CompiledMethod(InstructionSet instruction_set,
-                 const std::vector<uint8_t>& code,
-                 const size_t frame_size_in_bytes,
-                 const uint32_t core_spill_mask,
-                 const uint32_t fp_spill_mask);
-
-  // Constructs a CompiledMethod for the Portable compiler.
-  CompiledMethod(InstructionSet instruction_set,
-                 const std::string& code,
-                 const std::vector<uint8_t>& gc_map,
-                 const std::string& symbol)
-      : CompiledCode(instruction_set, code, symbol),
-        frame_size_in_bytes_(kStackAlignment), core_spill_mask_(0),
-        fp_spill_mask_(0), gc_map_(gc_map) {
-  }
-
-  // Constructs a CompiledMethod for the Portable JniCompiler.
-  CompiledMethod(InstructionSet instruction_set,
-                 const std::string& code,
-                 const std::string& symbol)
-      : CompiledCode(instruction_set, code, symbol),
-        frame_size_in_bytes_(kStackAlignment), core_spill_mask_(0),
-        fp_spill_mask_(0) {
-  }
-
-  ~CompiledMethod() {}
-
-  size_t GetFrameSizeInBytes() const {
-    return frame_size_in_bytes_;
-  }
-
-  uint32_t GetCoreSpillMask() const {
-    return core_spill_mask_;
-  }
-
-  uint32_t GetFpSpillMask() const {
-    return fp_spill_mask_;
-  }
-
-  const std::vector<uint8_t>& GetMappingTable() const {
-    return mapping_table_;
-  }
-
-  const std::vector<uint8_t>& GetVmapTable() const {
-    return vmap_table_;
-  }
-
-  const std::vector<uint8_t>& GetGcMap() const {
-    return gc_map_;
-  }
-
- private:
-  // For quick code, the size of the activation used by the code.
-  const size_t frame_size_in_bytes_;
-  // For quick code, a bit mask describing spilled GPR callee-save registers.
-  const uint32_t core_spill_mask_;
-  // For quick code, a bit mask describing spilled FPR callee-save registers.
-  const uint32_t fp_spill_mask_;
-  // For quick code, a uleb128 encoded map from native PC offset to dex PC aswell as dex PC to
-  // native PC offset. Size prefixed.
-  std::vector<uint8_t> mapping_table_;
-  // For quick code, a uleb128 encoded map from GPR/FPR register to dex register. Size prefixed.
-  std::vector<uint8_t> vmap_table_;
-  // For quick code, a map keyed by native PC indices to bitmaps describing what dalvik registers
-  // are live. For portable code, the key is a dalvik PC.
-  std::vector<uint8_t> gc_map_;
-};
-
-}  // namespace art
-
-#endif  // ART_RUNTIME_COMPILED_METHOD_H_
-- 
cgit v1.2.3-59-g8ed1b


From ee39a10e45a6a0880e8b829525c40d6055818560 Mon Sep 17 00:00:00 2001
From: Ian Rogers <irogers@google.com>
Date: Thu, 19 Sep 2013 02:56:49 -0700
Subject: Use class def index from java.lang.Class.

Bug: 10244719
This removes the computation of the dex file index, when necessary this is
computed by searching the dex file. Its only necessary in
dalvik.system.DexFile.defineClassNative and DexFile::FindInClassPath, the
latter not showing up significantly in profiling with this change.

(cherry-picked from 8b2c0b9abc3f520495f4387ea040132ba85cae69)
Change-Id: I20c73a3b17d86286428ab0fd21bc13f51f36c85c
---
 compiler/dex/compiler_ir.h                         |   2 +-
 compiler/dex/dex_to_dex_compiler.cc                |   2 +-
 compiler/dex/frontend.cc                           |   6 +-
 compiler/dex/frontend.h                            |   2 +-
 compiler/dex/mir_graph.cc                          |   2 +-
 compiler/dex/mir_graph.h                           |   2 +-
 compiler/dex/quick/codegen_util.cc                 |  22 ++--
 compiler/driver/compiler_driver.cc                 |  49 +++++----
 compiler/driver/compiler_driver.h                  |  27 +++--
 compiler/driver/dex_compilation_unit.cc            |   2 +-
 compiler/driver/dex_compilation_unit.h             |   6 +-
 compiler/image_writer.cc                           |   1 +
 compiler/llvm/compiler_llvm.cc                     |   4 +-
 compiler/sea_ir/frontend.cc                        |   6 +-
 compiler/sea_ir/ir/sea.cc                          |   4 +-
 compiler/sea_ir/ir/sea.h                           |   6 +-
 oatdump/oatdump.cc                                 |  32 +++---
 runtime/Android.mk                                 |   1 +
 runtime/class_linker.cc                            | 111 ++++++++++-----------
 runtime/class_linker.h                             |   4 +-
 runtime/class_linker_test.cc                       |  12 +--
 runtime/dex_file.cc                                |  91 +++++------------
 runtime/dex_file.h                                 |  44 +++-----
 .../entrypoints/quick/quick_invoke_entrypoints.cc  |   2 +-
 runtime/mirror/art_method-inl.h                    |   2 +-
 runtime/mirror/class.cc                            |  23 ++---
 runtime/mirror/class.h                             |  31 ++++--
 runtime/mirror/dex_cache.h                         |   1 +
 runtime/mirror/proxy.h                             |   3 +
 runtime/mirror/string.h                            |   2 +-
 runtime/native/dalvik_system_DexFile.cc            |   2 +-
 runtime/native/java_lang_Class.cc                  |  31 ------
 runtime/native/java_lang_DexCache.cc               |  56 +++++++++++
 runtime/oat_file.cc                                |   2 +-
 runtime/oat_file.h                                 |   2 +-
 runtime/object_utils.h                             |  87 +++++++---------
 runtime/runtime.cc                                 |   5 +-
 runtime/thread.cc                                  |   2 +-
 runtime/verifier/method_verifier.cc                |  96 +++++++++---------
 runtime/verifier/method_verifier.h                 |  19 ++--
 runtime/verifier/method_verifier_test.cc           |   3 +-
 test/100-reflect2/expected.txt                     |   2 +-
 42 files changed, 397 insertions(+), 412 deletions(-)
 create mode 100644 runtime/native/java_lang_DexCache.cc

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/dex/compiler_ir.h b/compiler/dex/compiler_ir.h
index 26d0923baa..6607562b13 100644
--- a/compiler/dex/compiler_ir.h
+++ b/compiler/dex/compiler_ir.h
@@ -77,7 +77,7 @@ struct CompilationUnit {
   ClassLinker* class_linker;           // Linker to resolve fields and methods.
   const DexFile* dex_file;             // DexFile containing the method being compiled.
   jobject class_loader;                // compiling method's class loader.
-  uint32_t class_def_idx;              // compiling method's defining class definition index.
+  uint16_t class_def_idx;              // compiling method's defining class definition index.
   uint32_t method_idx;                 // compiling method's index into method_ids of DexFile.
   const DexFile::CodeItem* code_item;  // compiling method's DexFile code_item.
   uint32_t access_flags;               // compiling method's access flags.
diff --git a/compiler/dex/dex_to_dex_compiler.cc b/compiler/dex/dex_to_dex_compiler.cc
index a392f829f6..63d8aa04f8 100644
--- a/compiler/dex/dex_to_dex_compiler.cc
+++ b/compiler/dex/dex_to_dex_compiler.cc
@@ -277,7 +277,7 @@ void DexCompiler::CompileInvokeVirtual(Instruction* inst,
 
 extern "C" void ArtCompileDEX(art::CompilerDriver& compiler, const art::DexFile::CodeItem* code_item,
                   uint32_t access_flags, art::InvokeType invoke_type,
-                  uint32_t class_def_idx, uint32_t method_idx, jobject class_loader,
+                  uint16_t class_def_idx, uint32_t method_idx, jobject class_loader,
                   const art::DexFile& dex_file,
                   art::DexToDexCompilationLevel dex_to_dex_compilation_level) {
   if (dex_to_dex_compilation_level != art::kDontDexToDexCompile) {
diff --git a/compiler/dex/frontend.cc b/compiler/dex/frontend.cc
index 23036495ce..fefcab9e87 100644
--- a/compiler/dex/frontend.cc
+++ b/compiler/dex/frontend.cc
@@ -110,7 +110,7 @@ static CompiledMethod* CompileMethod(CompilerDriver& compiler,
                                      const CompilerBackend compiler_backend,
                                      const DexFile::CodeItem* code_item,
                                      uint32_t access_flags, InvokeType invoke_type,
-                                     uint32_t class_def_idx, uint32_t method_idx,
+                                     uint16_t class_def_idx, uint32_t method_idx,
                                      jobject class_loader, const DexFile& dex_file
 #if defined(ART_USE_PORTABLE_COMPILER)
                                      , llvm::LlvmCompilationUnit* llvm_compilation_unit
@@ -273,7 +273,7 @@ CompiledMethod* CompileOneMethod(CompilerDriver& compiler,
                                  const DexFile::CodeItem* code_item,
                                  uint32_t access_flags,
                                  InvokeType invoke_type,
-                                 uint32_t class_def_idx,
+                                 uint16_t class_def_idx,
                                  uint32_t method_idx,
                                  jobject class_loader,
                                  const DexFile& dex_file,
@@ -292,7 +292,7 @@ extern "C" art::CompiledMethod*
     ArtQuickCompileMethod(art::CompilerDriver& compiler,
                           const art::DexFile::CodeItem* code_item,
                           uint32_t access_flags, art::InvokeType invoke_type,
-                          uint32_t class_def_idx, uint32_t method_idx, jobject class_loader,
+                          uint16_t class_def_idx, uint32_t method_idx, jobject class_loader,
                           const art::DexFile& dex_file) {
   // TODO: check method fingerprint here to determine appropriate backend type.  Until then, use build default
   art::CompilerBackend backend = compiler.GetCompilerBackend();
diff --git a/compiler/dex/frontend.h b/compiler/dex/frontend.h
index bafa46892c..6c33d109e3 100644
--- a/compiler/dex/frontend.h
+++ b/compiler/dex/frontend.h
@@ -117,7 +117,7 @@ extern "C" art::CompiledMethod* ArtCompileMethod(art::CompilerDriver& driver,
                                                  const art::DexFile::CodeItem* code_item,
                                                  uint32_t access_flags,
                                                  art::InvokeType invoke_type,
-                                                 uint32_t class_dex_idx,
+                                                 uint16_t class_def_idx,
                                                  uint32_t method_idx,
                                                  jobject class_loader,
                                                  const art::DexFile& dex_file);
diff --git a/compiler/dex/mir_graph.cc b/compiler/dex/mir_graph.cc
index 81702e3842..a12bf39e64 100644
--- a/compiler/dex/mir_graph.cc
+++ b/compiler/dex/mir_graph.cc
@@ -503,7 +503,7 @@ BasicBlock* MIRGraph::ProcessCanThrow(BasicBlock* cur_block, MIR* insn, int cur_
 
 /* Parse a Dex method and insert it into the MIRGraph at the current insert point. */
 void MIRGraph::InlineMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
-                           InvokeType invoke_type, uint32_t class_def_idx,
+                           InvokeType invoke_type, uint16_t class_def_idx,
                            uint32_t method_idx, jobject class_loader, const DexFile& dex_file) {
   current_code_item_ = code_item;
   method_stack_.push_back(std::make_pair(current_method_, current_offset_));
diff --git a/compiler/dex/mir_graph.h b/compiler/dex/mir_graph.h
index 28ab2834e1..6f8bd85630 100644
--- a/compiler/dex/mir_graph.h
+++ b/compiler/dex/mir_graph.h
@@ -357,7 +357,7 @@ class MIRGraph {
    * actually the index of the method in the m_units_ array).
    */
   void InlineMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
-                    InvokeType invoke_type, uint32_t class_def_idx,
+                    InvokeType invoke_type, uint16_t class_def_idx,
                     uint32_t method_idx, jobject class_loader, const DexFile& dex_file);
 
   /* Find existing block */
diff --git a/compiler/dex/quick/codegen_util.cc b/compiler/dex/quick/codegen_util.cc
index e081c16bb5..a49fa7b44d 100644
--- a/compiler/dex/quick/codegen_util.cc
+++ b/compiler/dex/quick/codegen_util.cc
@@ -362,11 +362,12 @@ void Mir2Lir::InstallLiteralPools() {
   while (data_lir != NULL) {
     uint32_t target = data_lir->operands[0];
     cu_->compiler_driver->AddCodePatch(cu_->dex_file,
-                                      cu_->method_idx,
-                                      cu_->invoke_type,
-                                      target,
-                                      static_cast<InvokeType>(data_lir->operands[1]),
-                                      code_buffer_.size());
+                                       cu_->class_def_idx,
+                                       cu_->method_idx,
+                                       cu_->invoke_type,
+                                       target,
+                                       static_cast<InvokeType>(data_lir->operands[1]),
+                                       code_buffer_.size());
     const DexFile::MethodId& id = cu_->dex_file->GetMethodId(target);
     // unique based on target to ensure code deduplication works
     uint32_t unique_patch_value = reinterpret_cast<uint32_t>(&id);
@@ -377,11 +378,12 @@ void Mir2Lir::InstallLiteralPools() {
   while (data_lir != NULL) {
     uint32_t target = data_lir->operands[0];
     cu_->compiler_driver->AddMethodPatch(cu_->dex_file,
-                                        cu_->method_idx,
-                                        cu_->invoke_type,
-                                        target,
-                                        static_cast<InvokeType>(data_lir->operands[1]),
-                                        code_buffer_.size());
+                                         cu_->class_def_idx,
+                                         cu_->method_idx,
+                                         cu_->invoke_type,
+                                         target,
+                                         static_cast<InvokeType>(data_lir->operands[1]),
+                                         code_buffer_.size());
     const DexFile::MethodId& id = cu_->dex_file->GetMethodId(target);
     // unique based on target to ensure code deduplication works
     uint32_t unique_patch_value = reinterpret_cast<uint32_t>(&id);
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index cbd9020df4..1c831cf3f6 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -293,7 +293,7 @@ extern "C" art::CompiledMethod* ArtCompileMethod(art::CompilerDriver& driver,
                                                  const art::DexFile::CodeItem* code_item,
                                                  uint32_t access_flags,
                                                  art::InvokeType invoke_type,
-                                                 uint32_t class_def_idx,
+                                                 uint16_t class_def_idx,
                                                  uint32_t method_idx,
                                                  jobject class_loader,
                                                  const art::DexFile& dex_file);
@@ -301,7 +301,7 @@ extern "C" art::CompiledMethod* ArtQuickCompileMethod(art::CompilerDriver& compi
                                                       const art::DexFile::CodeItem* code_item,
                                                       uint32_t access_flags,
                                                       art::InvokeType invoke_type,
-                                                      uint32_t class_def_idx,
+                                                      uint16_t class_def_idx,
                                                       uint32_t method_idx,
                                                       jobject class_loader,
                                                       const art::DexFile& dex_file);
@@ -310,7 +310,7 @@ extern "C" art::CompiledMethod* ArtCompileDEX(art::CompilerDriver& compiler,
                                               const art::DexFile::CodeItem* code_item,
                                               uint32_t access_flags,
                                               art::InvokeType invoke_type,
-                                              uint32_t class_def_idx,
+                                              uint16_t class_def_idx,
                                               uint32_t method_idx,
                                               jobject class_loader,
                                               const art::DexFile& dex_file);
@@ -319,7 +319,7 @@ extern "C" art::CompiledMethod* SeaIrCompileMethod(art::CompilerDriver& compiler
                                                    const art::DexFile::CodeItem* code_item,
                                                    uint32_t access_flags,
                                                    art::InvokeType invoke_type,
-                                                   uint32_t class_def_idx,
+                                                   uint16_t class_def_idx,
                                                    uint32_t method_idx,
                                                    jobject class_loader,
                                                    const art::DexFile& dex_file);
@@ -536,7 +536,7 @@ void CompilerDriver::CompileOne(const mirror::ArtMethod* method, base::TimingLog
   Thread* self = Thread::Current();
   jobject jclass_loader;
   const DexFile* dex_file;
-  uint32_t class_def_idx;
+  uint16_t class_def_idx;
   {
     ScopedObjectAccessUnchecked soa(self);
     ScopedLocalRef<jobject>
@@ -1301,13 +1301,15 @@ bool CompilerDriver::IsSafeCast(const MethodReference& mr, uint32_t dex_pc) {
 
 
 void CompilerDriver::AddCodePatch(const DexFile* dex_file,
-                            uint32_t referrer_method_idx,
-                            InvokeType referrer_invoke_type,
-                            uint32_t target_method_idx,
-                            InvokeType target_invoke_type,
-                            size_t literal_offset) {
+                                  uint16_t referrer_class_def_idx,
+                                  uint32_t referrer_method_idx,
+                                  InvokeType referrer_invoke_type,
+                                  uint32_t target_method_idx,
+                                  InvokeType target_invoke_type,
+                                  size_t literal_offset) {
   MutexLock mu(Thread::Current(), compiled_methods_lock_);
   code_to_patch_.push_back(new PatchInformation(dex_file,
+                                                referrer_class_def_idx,
                                                 referrer_method_idx,
                                                 referrer_invoke_type,
                                                 target_method_idx,
@@ -1315,13 +1317,15 @@ void CompilerDriver::AddCodePatch(const DexFile* dex_file,
                                                 literal_offset));
 }
 void CompilerDriver::AddMethodPatch(const DexFile* dex_file,
-                              uint32_t referrer_method_idx,
-                              InvokeType referrer_invoke_type,
-                              uint32_t target_method_idx,
-                              InvokeType target_invoke_type,
-                              size_t literal_offset) {
+                                    uint16_t referrer_class_def_idx,
+                                    uint32_t referrer_method_idx,
+                                    InvokeType referrer_invoke_type,
+                                    uint32_t target_method_idx,
+                                    InvokeType target_invoke_type,
+                                    size_t literal_offset) {
   MutexLock mu(Thread::Current(), compiled_methods_lock_);
   methods_to_patch_.push_back(new PatchInformation(dex_file,
+                                                   referrer_class_def_idx,
                                                    referrer_method_idx,
                                                    referrer_invoke_type,
                                                    target_method_idx,
@@ -1624,10 +1628,12 @@ static void VerifyClass(const ParallelCompilationManager* manager, size_t class_
      */
     mirror::DexCache* dex_cache =  manager->GetClassLinker()->FindDexCache(*manager->GetDexFile());
     std::string error_msg;
-    if (verifier::MethodVerifier::VerifyClass(manager->GetDexFile(),
+    const DexFile* dex_file = manager->GetDexFile();
+    const DexFile::ClassDef* class_def = &dex_file->GetClassDef(class_def_index);
+    if (verifier::MethodVerifier::VerifyClass(dex_file,
                                               dex_cache,
                                               soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader()),
-                                              class_def_index, error_msg, true) ==
+                                              class_def, true, &error_msg) ==
                                                   verifier::MethodVerifier::kHardFailure) {
       const DexFile::ClassDef& class_def = manager->GetDexFile()->GetClassDef(class_def_index);
       LOG(ERROR) << "Verification failed on class "
@@ -2137,7 +2143,8 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
       }
       // If successfully initialized place in SSB array.
       if (klass->IsInitialized()) {
-        klass->GetDexCache()->GetInitializedStaticStorage()->Set(klass->GetDexTypeIndex(), klass);
+        int32_t ssb_index = klass->GetDexTypeIndex();
+        klass->GetDexCache()->GetInitializedStaticStorage()->Set(ssb_index, klass);
       }
     }
     // Record the final class status if necessary.
@@ -2266,7 +2273,7 @@ void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_fil
 }
 
 void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
-                                   InvokeType invoke_type, uint32_t class_def_idx,
+                                   InvokeType invoke_type, uint16_t class_def_idx,
                                    uint32_t method_idx, jobject class_loader,
                                    const DexFile& dex_file,
                                    DexToDexCompilationLevel dex_to_dex_compilation_level) {
@@ -2389,13 +2396,13 @@ void CompilerDriver::SetBitcodeFileName(std::string const& filename) {
 
 
 void CompilerDriver::AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
-                                             size_t class_def_index) {
+                                                   uint16_t class_def_index) {
   WriterMutexLock mu(self, freezing_constructor_lock_);
   freezing_constructor_classes_.insert(ClassReference(dex_file, class_def_index));
 }
 
 bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
-                                          size_t class_def_index) {
+                                                uint16_t class_def_index) {
   ReaderMutexLock mu(self, freezing_constructor_lock_);
   return freezing_constructor_classes_.count(ClassReference(dex_file, class_def_index)) != 0;
 }
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index cd6b5fab02..3852acfd3b 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -145,8 +145,9 @@ class CompilerDriver {
   CompiledMethod* GetCompiledMethod(MethodReference ref) const
       LOCKS_EXCLUDED(compiled_methods_lock_);
 
-  void AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file, size_t class_def_index);
-  bool RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, size_t class_def_index);
+  void AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file,
+                                     uint16_t class_def_index);
+  bool RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, uint16_t class_def_index);
 
   // Callbacks from compiler to see what runtime checks must be generated.
 
@@ -191,6 +192,7 @@ class CompilerDriver {
 
   // Record patch information for later fix up.
   void AddCodePatch(const DexFile* dex_file,
+                    uint16_t referrer_class_def_idx,
                     uint32_t referrer_method_idx,
                     InvokeType referrer_invoke_type,
                     uint32_t target_method_idx,
@@ -198,6 +200,7 @@ class CompilerDriver {
                     size_t literal_offset)
       LOCKS_EXCLUDED(compiled_methods_lock_);
   void AddMethodPatch(const DexFile* dex_file,
+                      uint16_t referrer_class_def_idx,
                       uint32_t referrer_method_idx,
                       InvokeType referrer_invoke_type,
                       uint32_t target_method_idx,
@@ -248,6 +251,9 @@ class CompilerDriver {
     const DexFile& GetDexFile() const {
       return *dex_file_;
     }
+    uint16_t GetReferrerClassDefIdx() const {
+      return referrer_class_def_idx_;
+    }
     uint32_t GetReferrerMethodIdx() const {
       return referrer_method_idx_;
     }
@@ -266,12 +272,14 @@ class CompilerDriver {
 
    private:
     PatchInformation(const DexFile* dex_file,
+                     uint16_t referrer_class_def_idx,
                      uint32_t referrer_method_idx,
                      InvokeType referrer_invoke_type,
                      uint32_t target_method_idx,
                      InvokeType target_invoke_type,
                      size_t literal_offset)
       : dex_file_(dex_file),
+        referrer_class_def_idx_(referrer_class_def_idx),
         referrer_method_idx_(referrer_method_idx),
         referrer_invoke_type_(referrer_invoke_type),
         target_method_idx_(target_method_idx),
@@ -280,12 +288,13 @@ class CompilerDriver {
       CHECK(dex_file_ != NULL);
     }
 
-    const DexFile* dex_file_;
-    uint32_t referrer_method_idx_;
-    InvokeType referrer_invoke_type_;
-    uint32_t target_method_idx_;
-    InvokeType target_invoke_type_;
-    size_t literal_offset_;
+    const DexFile* const dex_file_;
+    const uint16_t referrer_class_def_idx_;
+    const uint32_t referrer_method_idx_;
+    const InvokeType referrer_invoke_type_;
+    const uint32_t target_method_idx_;
+    const InvokeType target_invoke_type_;
+    const size_t literal_offset_;
 
     friend class CompilerDriver;
     DISALLOW_COPY_AND_ASSIGN(PatchInformation);
@@ -357,7 +366,7 @@ class CompilerDriver {
                       ThreadPool& thread_pool, base::TimingLogger& timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
   void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
-                     InvokeType invoke_type, uint32_t class_def_idx, uint32_t method_idx,
+                     InvokeType invoke_type, uint16_t class_def_idx, uint32_t method_idx,
                      jobject class_loader, const DexFile& dex_file,
                      DexToDexCompilationLevel dex_to_dex_compilation_level)
       LOCKS_EXCLUDED(compiled_methods_lock_);
diff --git a/compiler/driver/dex_compilation_unit.cc b/compiler/driver/dex_compilation_unit.cc
index eb8941b15f..c441d09ab2 100644
--- a/compiler/driver/dex_compilation_unit.cc
+++ b/compiler/driver/dex_compilation_unit.cc
@@ -39,7 +39,7 @@ DexCompilationUnit::DexCompilationUnit(CompilationUnit* cu,
                                        ClassLinker* class_linker,
                                        const DexFile& dex_file,
                                        const DexFile::CodeItem* code_item,
-                                       uint32_t class_def_idx,
+                                       uint16_t class_def_idx,
                                        uint32_t method_idx,
                                        uint32_t access_flags)
     : cu_(cu),
diff --git a/compiler/driver/dex_compilation_unit.h b/compiler/driver/dex_compilation_unit.h
index 465139b34f..3df50ffec6 100644
--- a/compiler/driver/dex_compilation_unit.h
+++ b/compiler/driver/dex_compilation_unit.h
@@ -36,7 +36,7 @@ class DexCompilationUnit {
 
   DexCompilationUnit(CompilationUnit* cu, jobject class_loader, ClassLinker* class_linker,
                      const DexFile& dex_file, const DexFile::CodeItem* code_item,
-                     uint32_t class_def_idx, uint32_t method_idx, uint32_t access_flags);
+                     uint16_t class_def_idx, uint32_t method_idx, uint32_t access_flags);
 
   CompilationUnit* GetCompilationUnit() const {
     return cu_;
@@ -54,7 +54,7 @@ class DexCompilationUnit {
     return dex_file_;
   }
 
-  uint32_t GetClassDefIndex() const {
+  uint16_t GetClassDefIndex() const {
     return class_def_idx_;
   }
 
@@ -108,7 +108,7 @@ class DexCompilationUnit {
   const DexFile* const dex_file_;
 
   const DexFile::CodeItem* const code_item_;
-  const uint32_t class_def_idx_;
+  const uint16_t class_def_idx_;
   const uint32_t dex_method_idx_;
   const uint32_t access_flags_;
 
diff --git a/compiler/image_writer.cc b/compiler/image_writer.cc
index d1859e6f98..f82c6fb40f 100644
--- a/compiler/image_writer.cc
+++ b/compiler/image_writer.cc
@@ -699,6 +699,7 @@ void ImageWriter::PatchOatCodeAndMethods() {
 void ImageWriter::SetPatchLocation(const CompilerDriver::PatchInformation* patch, uint32_t value) {
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   const void* oat_code = class_linker->GetOatCodeFor(patch->GetDexFile(),
+                                                     patch->GetReferrerClassDefIdx(),
                                                      patch->GetReferrerMethodIdx());
   OatHeader& oat_header = const_cast<OatHeader&>(oat_file_->GetOatHeader());
   // TODO: make this Thumb2 specific
diff --git a/compiler/llvm/compiler_llvm.cc b/compiler/llvm/compiler_llvm.cc
index fd440d5bf0..a917cdc6de 100644
--- a/compiler/llvm/compiler_llvm.cc
+++ b/compiler/llvm/compiler_llvm.cc
@@ -39,7 +39,7 @@ void CompileOneMethod(CompilerDriver& driver,
                       const CompilerBackend compilerBackend,
                       const DexFile::CodeItem* code_item,
                       uint32_t access_flags, InvokeType invoke_type,
-                      uint32_t class_def_idx, uint32_t method_idx, jobject class_loader,
+                      uint16_t class_def_idx, uint32_t method_idx, jobject class_loader,
                       const DexFile& dex_file,
                       llvm::LlvmCompilationUnit* llvm_info);
 }
@@ -202,7 +202,7 @@ extern "C" art::CompiledMethod* ArtCompileMethod(art::CompilerDriver& driver,
                                                  const art::DexFile::CodeItem* code_item,
                                                  uint32_t access_flags,
                                                  art::InvokeType invoke_type,
-                                                 uint32_t class_def_idx,
+                                                 uint16_t class_def_idx,
                                                  uint32_t method_idx,
                                                  jobject class_loader,
                                                  const art::DexFile& dex_file) {
diff --git a/compiler/sea_ir/frontend.cc b/compiler/sea_ir/frontend.cc
index 93f6f25461..3512911f43 100644
--- a/compiler/sea_ir/frontend.cc
+++ b/compiler/sea_ir/frontend.cc
@@ -41,7 +41,7 @@ static CompiledMethod* CompileMethodWithSeaIr(CompilerDriver& compiler,
                                      const CompilerBackend compiler_backend,
                                      const DexFile::CodeItem* code_item,
                                      uint32_t method_access_flags, InvokeType invoke_type,
-                                     uint32_t class_def_idx, uint32_t method_idx,
+                                     uint16_t class_def_idx, uint32_t method_idx,
                                      jobject class_loader, const DexFile& dex_file
 #if defined(ART_USE_PORTABLE_COMPILER)
                                      , llvm::LlvmCompilationUnit* llvm_compilation_unit
@@ -69,7 +69,7 @@ CompiledMethod* SeaIrCompileOneMethod(CompilerDriver& compiler,
                                  const DexFile::CodeItem* code_item,
                                  uint32_t method_access_flags,
                                  InvokeType invoke_type,
-                                 uint32_t class_def_idx,
+                                 uint16_t class_def_idx,
                                  uint32_t method_idx,
                                  jobject class_loader,
                                  const DexFile& dex_file,
@@ -86,7 +86,7 @@ extern "C" art::CompiledMethod*
     SeaIrCompileMethod(art::CompilerDriver& compiler,
                           const art::DexFile::CodeItem* code_item,
                           uint32_t method_access_flags, art::InvokeType invoke_type,
-                          uint32_t class_def_idx, uint32_t method_idx, jobject class_loader,
+                          uint16_t class_def_idx, uint32_t method_idx, jobject class_loader,
                           const art::DexFile& dex_file) {
   // TODO: Check method fingerprint here to determine appropriate backend type.
   //       Until then, use build default
diff --git a/compiler/sea_ir/ir/sea.cc b/compiler/sea_ir/ir/sea.cc
index 5ccaba6ad9..0734b21f12 100644
--- a/compiler/sea_ir/ir/sea.cc
+++ b/compiler/sea_ir/ir/sea.cc
@@ -191,7 +191,7 @@ void SeaGraph::InsertSignatureNodes(const art::DexFile::CodeItem* code_item, Reg
 }
 
 void SeaGraph::BuildMethodSeaGraph(const art::DexFile::CodeItem* code_item,
-    const art::DexFile& dex_file, uint32_t class_def_idx,
+    const art::DexFile& dex_file, uint16_t class_def_idx,
     uint32_t method_idx, uint32_t method_access_flags) {
   code_item_ = code_item;
   class_def_idx_ = class_def_idx;
@@ -409,7 +409,7 @@ CodeGenData* SeaGraph::GenerateLLVM(const std::string& function_name,
 
 CodeGenData* SeaGraph::CompileMethod(
     const std::string& function_name,
-    const art::DexFile::CodeItem* code_item, uint32_t class_def_idx,
+    const art::DexFile::CodeItem* code_item, uint16_t class_def_idx,
     uint32_t method_idx, uint32_t method_access_flags, const art::DexFile& dex_file) {
   // Two passes: Builds the intermediate structure (non-SSA) of the sea-ir for the function.
   BuildMethodSeaGraph(code_item, dex_file, class_def_idx, method_idx, method_access_flags);
diff --git a/compiler/sea_ir/ir/sea.h b/compiler/sea_ir/ir/sea.h
index 92c2043dbd..26b16be019 100644
--- a/compiler/sea_ir/ir/sea.h
+++ b/compiler/sea_ir/ir/sea.h
@@ -262,7 +262,7 @@ class SeaGraph: IVisitable {
   static SeaGraph* GetGraph(const art::DexFile&);
 
   CodeGenData* CompileMethod(const std::string& function_name,
-      const art::DexFile::CodeItem* code_item, uint32_t class_def_idx,
+      const art::DexFile::CodeItem* code_item, uint16_t class_def_idx,
       uint32_t method_idx, uint32_t method_access_flags, const art::DexFile& dex_file);
   // Returns all regions corresponding to this SeaGraph.
   std::vector<Region*>* GetRegions() {
@@ -288,7 +288,7 @@ class SeaGraph: IVisitable {
   }
 
   TypeInference* ti_;
-  uint32_t class_def_idx_;
+  uint16_t class_def_idx_;
   uint32_t method_idx_;
   uint32_t method_access_flags_;
 
@@ -311,7 +311,7 @@ class SeaGraph: IVisitable {
   // Builds the non-SSA sea-ir representation of the function @code_item from @dex_file
   // with class id @class_def_idx and method id @method_idx.
   void BuildMethodSeaGraph(const art::DexFile::CodeItem* code_item,
-      const art::DexFile& dex_file, uint32_t class_def_idx,
+      const art::DexFile& dex_file, uint16_t class_def_idx,
       uint32_t method_idx, uint32_t method_access_flags);
   // Computes immediate dominators for each region.
   // Precondition: ComputeMethodSeaGraph()
diff --git a/oatdump/oatdump.cc b/oatdump/oatdump.cc
index cf1b6af809..fc9e00c2cb 100644
--- a/oatdump/oatdump.cc
+++ b/oatdump/oatdump.cc
@@ -176,9 +176,10 @@ class OatDumper {
       CHECK(oat_dex_file != NULL);
       UniquePtr<const DexFile> dex_file(oat_dex_file->OpenDexFile());
       if (dex_file.get() != NULL) {
-        uint32_t class_def_index;
-        bool found = dex_file->FindClassDefIndex(mh.GetDeclaringClassDescriptor(), class_def_index);
-        if (found) {
+        const DexFile::ClassDef* class_def =
+            dex_file->FindClassDef(mh.GetDeclaringClassDescriptor());
+        if (class_def != NULL) {
+          uint16_t class_def_index = dex_file->GetIndexForClassDef(*class_def);
           const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_index);
           CHECK(oat_class != NULL);
           size_t method_index = m->GetMethodIndex();
@@ -284,18 +285,17 @@ class OatDumper {
     }
     ClassDataItemIterator it(dex_file, class_data);
     SkipAllFields(it);
-    uint32_t class_def_idx = dex_file.GetIndexForClassDef(class_def);
     uint32_t class_method_idx = 0;
     while (it.HasNextDirectMethod()) {
       const OatFile::OatMethod oat_method = oat_class.GetOatMethod(class_method_idx);
-      DumpOatMethod(os, class_def_idx, class_method_idx, oat_method, dex_file,
+      DumpOatMethod(os, class_def, class_method_idx, oat_method, dex_file,
                     it.GetMemberIndex(), it.GetMethodCodeItem(), it.GetMemberAccessFlags());
       class_method_idx++;
       it.Next();
     }
     while (it.HasNextVirtualMethod()) {
       const OatFile::OatMethod oat_method = oat_class.GetOatMethod(class_method_idx);
-      DumpOatMethod(os, class_def_idx, class_method_idx, oat_method, dex_file,
+      DumpOatMethod(os, class_def, class_method_idx, oat_method, dex_file,
                     it.GetMemberIndex(), it.GetMethodCodeItem(), it.GetMemberAccessFlags());
       class_method_idx++;
       it.Next();
@@ -304,7 +304,8 @@ class OatDumper {
     os << std::flush;
   }
 
-  void DumpOatMethod(std::ostream& os, uint32_t class_def_idx, uint32_t class_method_index,
+  void DumpOatMethod(std::ostream& os, const DexFile::ClassDef& class_def,
+                     uint32_t class_method_index,
                      const OatFile::OatMethod& oat_method, const DexFile& dex_file,
                      uint32_t dex_method_idx, const DexFile::CodeItem* code_item,
                      uint32_t method_access_flags) {
@@ -323,7 +324,8 @@ class OatDumper {
       indent1_os << "VERIFIER TYPE ANALYSIS:\n";
       Indenter indent2_filter(indent1_os.rdbuf(), kIndentChar, kIndentBy1Count);
       std::ostream indent2_os(&indent2_filter);
-      DumpVerifier(indent2_os, dex_method_idx, &dex_file, class_def_idx, code_item, method_access_flags);
+      DumpVerifier(indent2_os, dex_method_idx, &dex_file, class_def, code_item,
+                   method_access_flags);
     }
     {
       indent1_os << "OAT DATA:\n";
@@ -363,7 +365,7 @@ class OatDumper {
                                  oat_method.GetCode() != NULL ? "..." : "");
       Indenter indent2_filter(indent1_os.rdbuf(), kIndentChar, kIndentBy1Count);
       std::ostream indent2_os(&indent2_filter);
-      DumpCode(indent2_os, oat_method, dex_method_idx, &dex_file, class_def_idx, code_item,
+      DumpCode(indent2_os, oat_method, dex_method_idx, &dex_file, class_def, code_item,
                method_access_flags);
     }
   }
@@ -554,7 +556,7 @@ class OatDumper {
 
   void DumpVRegsAtDexPc(std::ostream& os,  const OatFile::OatMethod& oat_method,
                         uint32_t dex_method_idx, const DexFile* dex_file,
-                        uint32_t class_def_idx, const DexFile::CodeItem* code_item,
+                        const DexFile::ClassDef& class_def, const DexFile::CodeItem* code_item,
                         uint32_t method_access_flags, uint32_t dex_pc) {
     static UniquePtr<verifier::MethodVerifier> verifier;
     static const DexFile* verified_dex_file = NULL;
@@ -563,7 +565,7 @@ class OatDumper {
       ScopedObjectAccess soa(Thread::Current());
       mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(*dex_file);
       mirror::ClassLoader* class_loader = NULL;
-      verifier.reset(new verifier::MethodVerifier(dex_file, dex_cache, class_loader, class_def_idx,
+      verifier.reset(new verifier::MethodVerifier(dex_file, dex_cache, class_loader, &class_def,
                                                   code_item, dex_method_idx, NULL,
                                                   method_access_flags, true, true));
       verifier->Verify();
@@ -615,21 +617,21 @@ class OatDumper {
   }
 
   void DumpVerifier(std::ostream& os, uint32_t dex_method_idx, const DexFile* dex_file,
-                    uint32_t class_def_idx, const DexFile::CodeItem* code_item,
+                    const DexFile::ClassDef& class_def, const DexFile::CodeItem* code_item,
                     uint32_t method_access_flags) {
     if ((method_access_flags & kAccNative) == 0) {
       ScopedObjectAccess soa(Thread::Current());
       mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(*dex_file);
       mirror::ClassLoader* class_loader = NULL;
       verifier::MethodVerifier::VerifyMethodAndDump(os, dex_method_idx, dex_file, dex_cache,
-                                                    class_loader, class_def_idx, code_item, NULL,
+                                                    class_loader, &class_def, code_item, NULL,
                                                     method_access_flags);
     }
   }
 
   void DumpCode(std::ostream& os,  const OatFile::OatMethod& oat_method,
                 uint32_t dex_method_idx, const DexFile* dex_file,
-                uint32_t class_def_idx, const DexFile::CodeItem* code_item,
+                const DexFile::ClassDef& class_def, const DexFile::CodeItem* code_item,
                 uint32_t method_access_flags) {
     const void* code = oat_method.GetCode();
     size_t code_size = oat_method.GetCodeSize();
@@ -647,7 +649,7 @@ class OatDumper {
       if (dex_pc != DexFile::kDexNoIndex) {
         DumpGcMapAtNativePcOffset(os, oat_method, code_item, offset);
         if (kDumpVRegs) {
-          DumpVRegsAtDexPc(os, oat_method, dex_method_idx, dex_file, class_def_idx, code_item,
+          DumpVRegsAtDexPc(os, oat_method, dex_method_idx, dex_file, class_def, code_item,
                            method_access_flags, dex_pc);
         }
       }
diff --git a/runtime/Android.mk b/runtime/Android.mk
index a8d505e1f5..a0ae4bffbc 100644
--- a/runtime/Android.mk
+++ b/runtime/Android.mk
@@ -92,6 +92,7 @@ LIBART_COMMON_SRC_FILES := \
 	native/dalvik_system_VMStack.cc \
 	native/dalvik_system_Zygote.cc \
 	native/java_lang_Class.cc \
+	native/java_lang_DexCache.cc \
 	native/java_lang_Object.cc \
 	native/java_lang_Runtime.cc \
 	native/java_lang_String.cc \
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 0773a8d659..4043f8be5a 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -475,40 +475,33 @@ void ClassLinker::FinishInit() {
   // as the types of the field can't be resolved prior to the runtime being
   // fully initialized
   mirror::Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
-  mirror::Class* java_lang_ref_ReferenceQueue = FindSystemClass("Ljava/lang/ref/ReferenceQueue;");
-  mirror::Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
-
-  const DexFile& java_lang_dex = *java_lang_ref_Reference->GetDexCache()->GetDexFile();
+  mirror::Class* java_lang_ref_FinalizerReference =
+      FindSystemClass("Ljava/lang/ref/FinalizerReference;");
 
   mirror::ArtField* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
   FieldHelper fh(pendingNext, this);
   CHECK_STREQ(fh.GetName(), "pendingNext");
-  CHECK_EQ(java_lang_dex.GetFieldId(pendingNext->GetDexFieldIndex()).type_idx_,
-           java_lang_ref_Reference->GetDexTypeIndex());
+  CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
 
   mirror::ArtField* queue = java_lang_ref_Reference->GetInstanceField(1);
   fh.ChangeField(queue);
   CHECK_STREQ(fh.GetName(), "queue");
-  CHECK_EQ(java_lang_dex.GetFieldId(queue->GetDexFieldIndex()).type_idx_,
-           java_lang_ref_ReferenceQueue->GetDexTypeIndex());
+  CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/ReferenceQueue;");
 
   mirror::ArtField* queueNext = java_lang_ref_Reference->GetInstanceField(2);
   fh.ChangeField(queueNext);
   CHECK_STREQ(fh.GetName(), "queueNext");
-  CHECK_EQ(java_lang_dex.GetFieldId(queueNext->GetDexFieldIndex()).type_idx_,
-           java_lang_ref_Reference->GetDexTypeIndex());
+  CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/ref/Reference;");
 
   mirror::ArtField* referent = java_lang_ref_Reference->GetInstanceField(3);
   fh.ChangeField(referent);
   CHECK_STREQ(fh.GetName(), "referent");
-  CHECK_EQ(java_lang_dex.GetFieldId(referent->GetDexFieldIndex()).type_idx_,
-           GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
+  CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/Object;");
 
   mirror::ArtField* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
   fh.ChangeField(zombie);
   CHECK_STREQ(fh.GetName(), "zombie");
-  CHECK_EQ(java_lang_dex.GetFieldId(zombie->GetDexFieldIndex()).type_idx_,
-           GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
+  CHECK_STREQ(fh.GetTypeDescriptor(), "Ljava/lang/Object;");
 
   gc::Heap* heap = Runtime::Current()->GetHeap();
   heap->SetReferenceOffsets(referent->GetOffset(),
@@ -1231,8 +1224,10 @@ mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Cl
     return NULL;
   }
   mirror::Class* klass = k->AsClass();
-  klass->SetPrimitiveType(Primitive::kPrimNot);  // default to not being primitive
+  klass->SetPrimitiveType(Primitive::kPrimNot);  // Default to not being primitive.
   klass->SetClassSize(class_size);
+  klass->SetDexClassDefIndex(DexFile::kDexNoIndex16);  // Default to no valid class def index.
+  klass->SetDexTypeIndex(DexFile::kDexNoIndex16);  // Default to no valid type index.
   return klass;
 }
 
@@ -1496,26 +1491,21 @@ size_t ClassLinker::SizeOfClass(const DexFile& dex_file,
   return size;
 }
 
-const OatFile::OatClass* ClassLinker::GetOatClass(const DexFile& dex_file, const char* descriptor) {
-  DCHECK(descriptor != NULL);
+const OatFile::OatClass* ClassLinker::GetOatClass(const DexFile& dex_file, uint16_t class_def_idx) {
+  DCHECK_NE(class_def_idx, DexFile::kDexNoIndex16);
   const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
-  CHECK(oat_file != NULL) << dex_file.GetLocation() << " " << descriptor;
+  CHECK(oat_file != NULL) << dex_file.GetLocation();
   const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
-  CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << descriptor;
-  uint32_t class_def_index;
-  bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
-  CHECK(found) << dex_file.GetLocation() << " " << descriptor;
-  const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_index);
-  CHECK(oat_class != NULL) << dex_file.GetLocation() << " " << descriptor;
+  CHECK(oat_dex_file != NULL) << dex_file.GetLocation();
+  const OatFile::OatClass* oat_class = oat_dex_file->GetOatClass(class_def_idx);
+  CHECK(oat_class != NULL) << dex_file.GetLocation() << " " << class_def_idx;
   return oat_class;
 }
 
-static uint32_t GetOatMethodIndexFromMethodIndex(const DexFile& dex_file, uint32_t method_idx) {
-  const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
-  const DexFile::TypeId& type_id = dex_file.GetTypeId(method_id.class_idx_);
-  const DexFile::ClassDef* class_def = dex_file.FindClassDef(dex_file.GetTypeDescriptor(type_id));
-  CHECK(class_def != NULL);
-  const byte* class_data = dex_file.GetClassData(*class_def);
+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 byte* class_data = dex_file.GetClassData(class_def);
   CHECK(class_data != NULL);
   ClassDataItemIterator it(dex_file, class_data);
   // Skip fields
@@ -1569,11 +1559,13 @@ const OatFile::OatMethod ClassLinker::GetOatMethodFor(const mirror::ArtMethod* m
     }
     CHECK(found) << "Didn't find oat method index for virtual method: " << PrettyMethod(method);
   }
-  ClassHelper kh(declaring_class);
-  UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(kh.GetDexFile(), kh.GetDescriptor()));
+  UniquePtr<const OatFile::OatClass>
+      oat_class(GetOatClass(*declaring_class->GetDexCache()->GetDexFile(),
+                            declaring_class->GetDexClassDefIndex()));
   CHECK(oat_class.get() != NULL);
   DCHECK_EQ(oat_method_index,
             GetOatMethodIndexFromMethodIndex(*declaring_class->GetDexCache()->GetDexFile(),
+                                             method->GetDeclaringClass()->GetDexClassDefIndex(),
                                              method->GetDexMethodIndex()));
 
   return oat_class->GetOatMethod(oat_method_index);
@@ -1597,12 +1589,11 @@ const void* ClassLinker::GetOatCodeFor(const mirror::ArtMethod* method) {
   return result;
 }
 
-const void* ClassLinker::GetOatCodeFor(const DexFile& dex_file, uint32_t method_idx) {
-  const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
-  const char* descriptor = dex_file.GetTypeDescriptor(dex_file.GetTypeId(method_id.class_idx_));
-  uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, method_idx);
-  UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, descriptor));
-  CHECK(oat_class.get() != NULL);
+const void* ClassLinker::GetOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx,
+                                       uint32_t method_idx) {
+  UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, class_def_idx));
+  CHECK(oat_class.get() != nullptr);
+  uint32_t oat_method_idx = GetOatMethodIndexFromMethodIndex(dex_file, class_def_idx, method_idx);
   return oat_class->GetOatMethod(oat_method_idx).GetCode();
 }
 
@@ -1639,7 +1630,7 @@ void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) {
     // OAT file unavailable
     return;
   }
-  UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, kh.GetDescriptor()));
+  UniquePtr<const OatFile::OatClass> oat_class(GetOatClass(dex_file, klass->GetDexClassDefIndex()));
   CHECK(oat_class.get() != NULL);
   ClassDataItemIterator it(dex_file, class_data);
   // Skip fields
@@ -1731,6 +1722,7 @@ void ClassLinker::LoadClass(const DexFile& dex_file,
   DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
   klass->SetStatus(mirror::Class::kStatusIdx, NULL);
 
+  klass->SetDexClassDefIndex(dex_file.GetIndexForClassDef(dex_class_def));
   klass->SetDexTypeIndex(dex_class_def.class_idx_);
 
   // Load fields fields.
@@ -1778,7 +1770,7 @@ void ClassLinker::LoadClass(const DexFile& dex_file,
 
   UniquePtr<const OatFile::OatClass> oat_class;
   if (Runtime::Current()->IsStarted() && !Runtime::Current()->UseCompileTimeClassPath()) {
-    oat_class.reset(GetOatClass(dex_file, descriptor));
+    oat_class.reset(GetOatClass(dex_file, klass->GetDexClassDefIndex()));
   }
 
   // Load methods.
@@ -1873,7 +1865,8 @@ mirror::ArtMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file
           if (klass->GetClassLoader() != NULL) {  // All non-boot finalizer methods are flagged
             klass->SetFinalizable();
           } else {
-            StringPiece klass_descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
+            ClassHelper kh(klass.get());
+            StringPiece klass_descriptor(kh.GetDescriptor());
             // The Enum class declares a "final" finalize() method to prevent subclasses from
             // introducing a finalizer. We don't want to set the finalizable flag for Enum or its
             // subclasses, so we exclude it here.
@@ -2339,12 +2332,16 @@ mirror::Class* ClassLinker::LookupClassFromImage(const char* descriptor) {
     const DexFile* dex_file = dex_cache->GetDexFile();
     // First search using the class def map, but don't bother for non-class types.
     if (descriptor[0] == 'L') {
-      const DexFile::ClassDef* class_def = dex_file->FindClassDef(descriptor);
-      if (class_def != NULL) {
-        mirror::Class* klass = dex_cache->GetResolvedType(class_def->class_idx_);
-        if (klass != NULL) {
-          self->EndAssertNoThreadSuspension(old_no_suspend_cause);
-          return klass;
+      const DexFile::StringId* descriptor_string_id = dex_file->FindStringId(descriptor);
+      if (descriptor_string_id != NULL) {
+        const DexFile::TypeId* type_id =
+            dex_file->FindTypeId(dex_file->GetIndexForStringId(*descriptor_string_id));
+        if (type_id != NULL) {
+          mirror::Class* klass = dex_cache->GetResolvedType(dex_file->GetIndexForTypeId(*type_id));
+          if (klass != NULL) {
+            self->EndAssertNoThreadSuspension(old_no_suspend_cause);
+            return klass;
+          }
         }
       }
     }
@@ -2455,8 +2452,9 @@ void ClassLinker::VerifyClass(mirror::Class* klass) {
   verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
   std::string error_msg;
   if (!preverified) {
-    verifier_failure = verifier::MethodVerifier::VerifyClass(klass, error_msg,
-                                                             Runtime::Current()->IsCompiler());
+    verifier_failure = verifier::MethodVerifier::VerifyClass(klass,
+                                                             Runtime::Current()->IsCompiler(),
+                                                             &error_msg);
   }
   if (preverified || verifier_failure != verifier::MethodVerifier::kHardFailure) {
     if (!preverified && verifier_failure != verifier::MethodVerifier::kNoFailure) {
@@ -2527,7 +2525,6 @@ bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class
     }
   }
 
-
   const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
   // Make this work with gtests, which do not set up the image properly.
   // TODO: we should clean up gtests to set up the image path properly.
@@ -2539,9 +2536,7 @@ bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class
   const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
   CHECK(oat_dex_file != NULL) << dex_file.GetLocation() << " " << PrettyClass(klass);
   const char* descriptor = ClassHelper(klass).GetDescriptor();
-  uint32_t class_def_index;
-  bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
-  CHECK(found) << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
+  uint16_t class_def_index = klass->GetDexClassDefIndex();
   UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(class_def_index));
   CHECK(oat_class.get() != NULL)
           << dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
@@ -2654,8 +2649,6 @@ mirror::Class* ClassLinker::CreateProxyClass(mirror::String* name,
 
   klass->SetStatus(mirror::Class::kStatusIdx, self);
 
-  klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
-
   // Instance fields are inherited, but we add a couple of static fields...
   {
     mirror::ObjectArray<mirror::ArtField>* sfields = AllocArtFieldArray(self, 2);
@@ -3262,10 +3255,8 @@ bool ClassLinker::LinkClass(SirtRef<mirror::Class>& klass,
 
 bool ClassLinker::LoadSuperAndInterfaces(SirtRef<mirror::Class>& klass, const DexFile& dex_file) {
   CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus());
-  StringPiece descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
-  const DexFile::ClassDef* class_def = dex_file.FindClassDef(descriptor);
-  CHECK(class_def != NULL);
-  uint16_t super_class_idx = class_def->superclass_idx_;
+  const DexFile::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex());
+  uint16_t super_class_idx = class_def.superclass_idx_;
   if (super_class_idx != DexFile::kDexNoIndex16) {
     mirror::Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
     if (super_class == NULL) {
@@ -3281,7 +3272,7 @@ bool ClassLinker::LoadSuperAndInterfaces(SirtRef<mirror::Class>& klass, const De
     }
     klass->SetSuperClass(super_class);
   }
-  const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(*class_def);
+  const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(class_def);
   if (interfaces != NULL) {
     for (size_t i = 0; i < interfaces->Size(); i++) {
       uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index 20efbb43a9..3ffcf14447 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -329,7 +329,7 @@ class ClassLinker {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Get the oat code for a method from a method index.
-  const void* GetOatCodeFor(const DexFile& dex_file, uint32_t method_idx)
+  const void* GetOatCodeFor(const DexFile& dex_file, uint16_t class_def_idx, uint32_t method_idx)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   pid_t GetClassesLockOwner();  // For SignalCatcher.
@@ -424,7 +424,7 @@ class ClassLinker {
   void FixupStaticTrampolines(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Finds the associated oat class for a dex_file and descriptor
-  const OatFile::OatClass* GetOatClass(const DexFile& dex_file, const char* descriptor)
+  const OatFile::OatClass* GetOatClass(const DexFile& dex_file, uint16_t class_def_idx)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void RegisterDexFileLocked(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
diff --git a/runtime/class_linker_test.cc b/runtime/class_linker_test.cc
index 995434c1f7..bbc2877b73 100644
--- a/runtime/class_linker_test.cc
+++ b/runtime/class_linker_test.cc
@@ -507,6 +507,7 @@ struct ClassOffsets : public CheckOffsets<mirror::Class> {
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, access_flags_),                  "accessFlags"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, class_size_),                    "classSize"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, clinit_thread_id_),              "clinitThreadId"));
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, dex_class_def_idx_),             "dexClassDefIndex"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, dex_type_idx_),                  "dexTypeIndex"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, num_reference_instance_fields_), "numReferenceInstanceFields"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::Class, num_reference_static_fields_),   "numReferenceStaticFields"));
@@ -569,10 +570,6 @@ struct ProxyOffsets : public CheckOffsets<mirror::Proxy> {
 
 struct ClassClassOffsets : public CheckOffsets<mirror::ClassClass> {
   ClassClassOffsets() : CheckOffsets<mirror::ClassClass>(true, "Ljava/lang/Class;") {
-    // padding 32-bit
-    CHECK_EQ(OFFSETOF_MEMBER(mirror::ClassClass, padding_) + 4,
-             OFFSETOF_MEMBER(mirror::ClassClass, serialVersionUID_));
-
     // alphabetical 64-bit
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::ClassClass, serialVersionUID_), "serialVersionUID"));
   };
@@ -584,11 +581,11 @@ struct StringClassOffsets : public CheckOffsets<mirror::StringClass> {
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StringClass, ASCII_),                  "ASCII"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StringClass, CASE_INSENSITIVE_ORDER_), "CASE_INSENSITIVE_ORDER"));
 
-    // padding 32-bit
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StringClass, REPLACEMENT_CHAR_),       "REPLACEMENT_CHAR"));
-
     // alphabetical 64-bit
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StringClass, serialVersionUID_),       "serialVersionUID"));
+
+    // alphabetical 32-bit
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::StringClass, REPLACEMENT_CHAR_),       "REPLACEMENT_CHAR"));
   };
 };
 
@@ -605,6 +602,7 @@ struct ArtMethodClassOffsets : public CheckOffsets<mirror::ArtMethodClass> {
 struct DexCacheOffsets : public CheckOffsets<mirror::DexCache> {
   DexCacheOffsets() : CheckOffsets<mirror::DexCache>(false, "Ljava/lang/DexCache;") {
     // alphabetical references
+    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::DexCache, dex_),                        "dex"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::DexCache, initialized_static_storage_), "initializedStaticStorage"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::DexCache, location_),                   "location"));
     offsets.push_back(CheckOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_fields_),            "resolvedFields"));
diff --git a/runtime/dex_file.cc b/runtime/dex_file.cc
index 4fd9a608c1..e81c456ccf 100644
--- a/runtime/dex_file.cc
+++ b/runtime/dex_file.cc
@@ -48,7 +48,7 @@ namespace art {
 const byte DexFile::kDexMagic[] = { 'd', 'e', 'x', '\n' };
 const byte DexFile::kDexMagicVersion[] = { '0', '3', '5', '\0' };
 
-DexFile::ClassPathEntry DexFile::FindInClassPath(const StringPiece& descriptor,
+DexFile::ClassPathEntry DexFile::FindInClassPath(const char* descriptor,
                                                  const ClassPath& class_path) {
   for (size_t i = 0; i != class_path.size(); ++i) {
     const DexFile* dex_file = class_path[i];
@@ -251,56 +251,11 @@ DexFile::~DexFile() {
   // the global reference table is otherwise empty!
 }
 
-class ScopedJniMonitorLock {
- public:
-  ScopedJniMonitorLock(JNIEnv* env, jobject locked) : env_(env), locked_(locked) {
-    env->MonitorEnter(locked_);
-  }
-  ~ScopedJniMonitorLock() {
-    env_->MonitorExit(locked_);
-  }
- private:
-  JNIEnv* const env_;
-  const jobject locked_;
-};
-
-jobject DexFile::GetDexObject(JNIEnv* env) const {
-  {
-    ScopedJniMonitorLock lock(env, WellKnownClasses::com_android_dex_Dex);
-    if (dex_object_ != NULL) {
-      return dex_object_;
-    }
-  }
-  void* address = const_cast<void*>(reinterpret_cast<const void*>(begin_));
-  jobject byte_buffer = env->NewDirectByteBuffer(address, size_);
-  if (byte_buffer == NULL) {
-    return NULL;
-  }
-
-  ScopedJniMonitorLock lock(env, WellKnownClasses::com_android_dex_Dex);
-  // Re-test to see if someone beat us to the creation when we had the lock released.
-  if (dex_object_ != NULL) {
-    return dex_object_;
-  }
-  jvalue args[1];
-  args[0].l = byte_buffer;
-  jobject local = env->CallStaticObjectMethodA(WellKnownClasses::com_android_dex_Dex,
-                                               WellKnownClasses::com_android_dex_Dex_create,
-                                               args);
-  if (local == NULL) {
-    return NULL;
-  }
-
-  dex_object_ = env->NewGlobalRef(local);
-  return dex_object_;
-}
-
 bool DexFile::Init() {
   InitMembers();
   if (!CheckMagicAndVersion()) {
     return false;
   }
-  InitIndex();
   return true;
 }
 
@@ -351,28 +306,36 @@ uint32_t DexFile::GetVersion() const {
   return atoi(version);
 }
 
-void DexFile::InitIndex() {
-  CHECK_EQ(index_.size(), 0U) << GetLocation();
-  for (size_t i = 0; i < NumClassDefs(); ++i) {
-    const ClassDef& class_def = GetClassDef(i);
-    const char* descriptor = GetClassDescriptor(class_def);
-    index_.Put(descriptor, i);
+const DexFile::ClassDef* DexFile::FindClassDef(const char* descriptor) const {
+  size_t num_class_defs = NumClassDefs();
+  if (num_class_defs == 0) {
+    return NULL;
   }
-}
-
-bool DexFile::FindClassDefIndex(const StringPiece& descriptor, uint32_t& idx) const {
-  Index::const_iterator it = index_.find(descriptor);
-  if (it == index_.end()) {
-    return false;
+  const StringId* string_id = FindStringId(descriptor);
+  if (string_id == NULL) {
+    return NULL;
   }
-  idx = it->second;
-  return true;
+  const TypeId* type_id = FindTypeId(GetIndexForStringId(*string_id));
+  if (type_id == NULL) {
+    return NULL;
+  }
+  uint16_t type_idx = GetIndexForTypeId(*type_id);
+  for (size_t i = 0; i < num_class_defs; ++i) {
+    const ClassDef& class_def = GetClassDef(i);
+    if (class_def.class_idx_ == type_idx) {
+      return &class_def;
+    }
+  }
+  return NULL;
 }
 
-const DexFile::ClassDef* DexFile::FindClassDef(const StringPiece& descriptor) const {
-  uint32_t idx;
-  if (FindClassDefIndex(descriptor, idx)) {
-    return &GetClassDef(idx);
+const DexFile::ClassDef* DexFile::FindClassDef(uint16_t type_idx) const {
+  size_t num_class_defs = NumClassDefs();
+  for (size_t i = 0; i < num_class_defs; ++i) {
+    const ClassDef& class_def = GetClassDef(i);
+    if (class_def.class_idx_ == type_idx) {
+      return &class_def;
+    }
   }
   return NULL;
 }
diff --git a/runtime/dex_file.h b/runtime/dex_file.h
index 26635ae255..7be5cb848f 100644
--- a/runtime/dex_file.h
+++ b/runtime/dex_file.h
@@ -339,7 +339,7 @@ class DexFile {
   typedef std::vector<const DexFile*> ClassPath;
 
   // Search a collection of DexFiles for a descriptor
-  static ClassPathEntry FindInClassPath(const StringPiece& descriptor,
+  static ClassPathEntry FindInClassPath(const char* descriptor,
                                         const ClassPath& class_path);
 
   // Returns the checksum of a file for comparison with GetLocationChecksum().
@@ -376,10 +376,6 @@ class DexFile {
     return location_checksum_;
   }
 
-  // Returns a com.android.dex.Dex object corresponding to the mapped-in dex file.
-  // Used by managed code to implement annotations.
-  jobject GetDexObject(JNIEnv* env) const;
-
   const Header& GetHeader() const {
     DCHECK(header_ != NULL) << GetLocation();
     return *header_;
@@ -584,12 +580,12 @@ class DexFile {
   }
 
   // Returns the ClassDef at the specified index.
-  const ClassDef& GetClassDef(uint32_t idx) const {
+  const ClassDef& GetClassDef(uint16_t idx) const {
     DCHECK_LT(idx, NumClassDefs()) << GetLocation();
     return class_defs_[idx];
   }
 
-  uint32_t GetIndexForClassDef(const ClassDef& class_def) const {
+  uint16_t GetIndexForClassDef(const ClassDef& class_def) const {
     CHECK_GE(&class_def, class_defs_) << GetLocation();
     CHECK_LT(&class_def, class_defs_ + header_->class_defs_size_) << GetLocation();
     return &class_def - class_defs_;
@@ -601,10 +597,10 @@ class DexFile {
   }
 
   // Looks up a class definition by its class descriptor.
-  const ClassDef* FindClassDef(const StringPiece& descriptor) const;
+  const ClassDef* FindClassDef(const char* descriptor) const;
 
-  // Looks up a class definition index by its class descriptor.
-  bool FindClassDefIndex(const StringPiece& descriptor, uint32_t& idx) const;
+  // Looks up a class definition by its type index.
+  const ClassDef* FindClassDef(uint16_t type_idx) const;
 
   const TypeList* GetInterfacesList(const ClassDef& class_def) const {
     if (class_def.interfaces_off_ == 0) {
@@ -809,6 +805,14 @@ class DexFile {
 
   bool DisableWrite() const;
 
+  const byte* Begin() const {
+    return begin_;
+  }
+
+  size_t Size() const {
+    return size_;
+  }
+
  private:
   // Opens a .dex file
   static const DexFile* OpenFile(const std::string& filename,
@@ -840,7 +844,6 @@ class DexFile {
         location_(location),
         location_checksum_(location_checksum),
         mem_map_(mem_map),
-        dex_object_(NULL),
         modification_lock("DEX modification lock"),
         header_(0),
         string_ids_(0),
@@ -853,23 +856,12 @@ class DexFile {
     CHECK_GT(size_, 0U) << GetLocation();
   }
 
-  const byte* Begin() const {
-    return begin_;
-  }
-
-  size_t Size() const {
-    return size_;
-  }
-
   // Top-level initializer that calls other Init methods.
   bool Init();
 
   // Caches pointers into to the various file sections.
   void InitMembers();
 
-  // Builds the index of descriptors to class definitions.
-  void InitIndex();
-
   // Returns true if the header magic and version numbers are of the expected values.
   bool CheckMagicAndVersion() const;
 
@@ -877,10 +869,6 @@ class DexFile {
       DexDebugNewPositionCb position_cb, DexDebugNewLocalCb local_cb,
       void* context, const byte* stream, LocalInfo* local_in_reg) const;
 
-  // The index of descriptors to class definition indexes (as opposed to type id indexes)
-  typedef SafeMap<const StringPiece, uint32_t> Index;
-  Index index_;
-
   // The base address of the memory mapping.
   const byte* const begin_;
 
@@ -898,10 +886,6 @@ class DexFile {
   // Manages the underlying memory allocation.
   UniquePtr<MemMap> mem_map_;
 
-  // A cached com.android.dex.Dex instance, possibly NULL. Use GetDexObject.
-  // TODO: this is mutable as it shouldn't be here. We should move it to the dex cache or similar.
-  mutable jobject dex_object_;
-
   // The DEX-to-DEX compiler uses this lock to ensure thread safety when
   // enabling write access to a read-only DEX file.
   // TODO: move to Locks::dex_file_modification_lock.
diff --git a/runtime/entrypoints/quick/quick_invoke_entrypoints.cc b/runtime/entrypoints/quick/quick_invoke_entrypoints.cc
index 1d8022f803..07c1c015aa 100644
--- a/runtime/entrypoints/quick/quick_invoke_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_invoke_entrypoints.cc
@@ -32,7 +32,7 @@ extern "C" uint64_t artInvokeInterfaceTrampoline(mirror::ArtMethod* interface_me
                                                  Thread* self, mirror::ArtMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::ArtMethod* method;
-  if (LIKELY(interface_method->GetDexMethodIndex() != DexFile::kDexNoIndex16)) {
+  if (LIKELY(interface_method->GetDexMethodIndex() != DexFile::kDexNoIndex)) {
     method = this_object->GetClass()->FindVirtualMethodForInterface(interface_method);
     if (UNLIKELY(method == NULL)) {
       FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
diff --git a/runtime/mirror/art_method-inl.h b/runtime/mirror/art_method-inl.h
index 224b2ba0d4..ccf3e59f18 100644
--- a/runtime/mirror/art_method-inl.h
+++ b/runtime/mirror/art_method-inl.h
@@ -178,7 +178,7 @@ inline uint32_t ArtMethod::GetOatNativeGcMapOffset() const {
 }
 
 inline bool ArtMethod::IsRuntimeMethod() const {
-  return GetDexMethodIndex() == DexFile::kDexNoIndex16;
+  return GetDexMethodIndex() == DexFile::kDexNoIndex;
 }
 
 inline bool ArtMethod::IsCalleeSaveMethod() const {
diff --git a/runtime/mirror/class.cc b/runtime/mirror/class.cc
index 5e8b82793a..add7e1b2af 100644
--- a/runtime/mirror/class.cc
+++ b/runtime/mirror/class.cc
@@ -128,7 +128,10 @@ Object* Class::AllocObject(Thread* self) {
 }
 
 void Class::SetClassSize(size_t new_class_size) {
-  DCHECK_GE(new_class_size, GetClassSize()) << " class=" << PrettyTypeOf(this);
+  if (kIsDebugBuild && (new_class_size < GetClassSize())) {
+    DumpClass(LOG(ERROR), kDumpClassFullDetail);
+    CHECK_GE(new_class_size, GetClassSize()) << " class=" << PrettyTypeOf(this);
+  }
   SetField32(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), new_class_size, false);
 }
 
@@ -300,22 +303,8 @@ bool Class::IsInSamePackage(const Class* that) const {
     return true;
   }
   // Compare the package part of the descriptor string.
-  if (LIKELY(!klass1->IsProxyClass() && !klass2->IsProxyClass())) {
-    ClassHelper kh(klass1);
-    const DexFile* dex_file1 = &kh.GetDexFile();
-    const DexFile::TypeId* type_id1 = &dex_file1->GetTypeId(klass1->GetDexTypeIndex());
-    const char* descriptor1 = dex_file1->GetTypeDescriptor(*type_id1);
-    kh.ChangeClass(klass2);
-    const DexFile* dex_file2 = &kh.GetDexFile();
-    const DexFile::TypeId* type_id2 = &dex_file2->GetTypeId(klass2->GetDexTypeIndex());
-    const char* descriptor2 = dex_file2->GetTypeDescriptor(*type_id2);
-    return IsInSamePackage(descriptor1, descriptor2);
-  }
-  ClassHelper kh(klass1);
-  std::string descriptor1(kh.GetDescriptor());
-  kh.ChangeClass(klass2);
-  std::string descriptor2(kh.GetDescriptor());
-  return IsInSamePackage(descriptor1, descriptor2);
+  return IsInSamePackage(ClassHelper(klass1).GetDescriptor(),
+                         ClassHelper(klass2).GetDescriptor());
 }
 
 bool Class::IsClassClass() const {
diff --git a/runtime/mirror/class.h b/runtime/mirror/class.h
index 99f3850b9b..d97b603ad8 100644
--- a/runtime/mirror/class.h
+++ b/runtime/mirror/class.h
@@ -726,6 +726,14 @@ class MANAGED Class : public StaticStorageBase {
     return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, verify_error_class_), false);
   }
 
+  uint16_t GetDexClassDefIndex() const {
+    return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_class_def_idx_), false);
+  }
+
+  void SetDexClassDefIndex(uint16_t class_def_idx) {
+    SetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_class_def_idx_), class_def_idx, false);
+  }
+
   uint16_t GetDexTypeIndex() const {
     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_type_idx_), false);
   }
@@ -807,7 +815,7 @@ class MANAGED Class : public StaticStorageBase {
   // If class verify fails, we must return same error on subsequent tries.
   Class* verify_error_class_;
 
-  // virtual methods defined in this class; invoked through vtable
+  // Virtual methods defined in this class; invoked through vtable.
   ObjectArray<ArtMethod>* virtual_methods_;
 
   // Virtual method table (vtable), for use by "invoke-virtual".  The vtable from the superclass is
@@ -816,24 +824,28 @@ class MANAGED Class : public StaticStorageBase {
   // virtual_ methods_ for miranda methods.
   ObjectArray<ArtMethod>* vtable_;
 
-  // access flags; low 16 bits are defined by VM spec
+  // Access flags; low 16 bits are defined by VM spec.
   uint32_t access_flags_;
 
   // Total size of the Class instance; used when allocating storage on gc heap.
   // See also object_size_.
   size_t class_size_;
 
-  // tid used to check for recursive <clinit> invocation
+  // Tid used to check for recursive <clinit> invocation.
   pid_t clinit_thread_id_;
 
-  // type index from dex file
+  // ClassDef index in dex file, -1 if no class definition such as an array.
+  // TODO: really 16bits
+  int32_t dex_class_def_idx_;
+
+  // Type index in dex file.
   // TODO: really 16bits
-  uint32_t dex_type_idx_;
+  int32_t dex_type_idx_;
 
-  // number of instance fields that are object refs
+  // Number of instance fields that are object refs.
   size_t num_reference_instance_fields_;
 
-  // number of static fields that are object refs
+  // Number of static fields that are object refs,
   size_t num_reference_static_fields_;
 
   // Total object size; used when allocating storage on gc heap.
@@ -841,7 +853,7 @@ class MANAGED Class : public StaticStorageBase {
   // See also class_size_.
   size_t object_size_;
 
-  // primitive type value, or Primitive::kPrimNot (0); set for generated prim classes
+  // Primitive type value, or Primitive::kPrimNot (0); set for generated primitive classes.
   Primitive::Type primitive_type_;
 
   // Bitmap of offsets of ifields.
@@ -850,7 +862,7 @@ class MANAGED Class : public StaticStorageBase {
   // Bitmap of offsets of sfields.
   uint32_t reference_static_offsets_;
 
-  // state of class initialization
+  // State of class initialization.
   Status status_;
 
   // TODO: ?
@@ -873,7 +885,6 @@ std::ostream& operator<<(std::ostream& os, const Class::Status& rhs);
 
 class MANAGED ClassClass : public Class {
  private:
-  int32_t padding_;
   int64_t serialVersionUID_;
   friend struct art::ClassClassOffsets;  // for verifying offset information
   DISALLOW_IMPLICIT_CONSTRUCTORS(ClassClass);
diff --git a/runtime/mirror/dex_cache.h b/runtime/mirror/dex_cache.h
index 6cfab9e425..0522f134af 100644
--- a/runtime/mirror/dex_cache.h
+++ b/runtime/mirror/dex_cache.h
@@ -164,6 +164,7 @@ class MANAGED DexCache : public Object {
   }
 
  private:
+  Object* dex_;
   ObjectArray<StaticStorageBase>* initialized_static_storage_;
   String* location_;
   ObjectArray<ArtField>* resolved_fields_;
diff --git a/runtime/mirror/proxy.h b/runtime/mirror/proxy.h
index 7c5bc39429..18a84dcbdb 100644
--- a/runtime/mirror/proxy.h
+++ b/runtime/mirror/proxy.h
@@ -25,6 +25,8 @@ struct ProxyOffsets;
 
 namespace mirror {
 
+// All proxy objects have a class which is a synthesized proxy class. The synthesized proxy class
+// has the static fields used to implement reflection on proxy objects.
 class MANAGED SynthesizedProxyClass : public Class {
  public:
   ObjectArray<Class>* GetInterfaces() {
@@ -41,6 +43,7 @@ class MANAGED SynthesizedProxyClass : public Class {
   DISALLOW_IMPLICIT_CONSTRUCTORS(SynthesizedProxyClass);
 };
 
+// C++ mirror of java.lang.reflect.Proxy.
 class MANAGED Proxy : public Object {
  private:
   Object* h_;
diff --git a/runtime/mirror/string.h b/runtime/mirror/string.h
index bf545eaefb..81fe42f2a6 100644
--- a/runtime/mirror/string.h
+++ b/runtime/mirror/string.h
@@ -155,8 +155,8 @@ class MANAGED StringClass : public Class {
  private:
   CharArray* ASCII_;
   Object* CASE_INSENSITIVE_ORDER_;
-  uint32_t REPLACEMENT_CHAR_;
   int64_t serialVersionUID_;
+  uint32_t REPLACEMENT_CHAR_;
   friend struct art::StringClassOffsets;  // for verifying offset information
   DISALLOW_IMPLICIT_CONSTRUCTORS(StringClass);
 };
diff --git a/runtime/native/dalvik_system_DexFile.cc b/runtime/native/dalvik_system_DexFile.cc
index 2f4e427bb6..d2a6c0edb4 100644
--- a/runtime/native/dalvik_system_DexFile.cc
+++ b/runtime/native/dalvik_system_DexFile.cc
@@ -150,7 +150,7 @@ static jclass DexFile_defineClassNative(JNIEnv* env, jclass, jstring javaName, j
     return NULL;
   }
   const std::string descriptor(DotToDescriptor(class_name.c_str()));
-  const DexFile::ClassDef* dex_class_def = dex_file->FindClassDef(descriptor);
+  const DexFile::ClassDef* dex_class_def = dex_file->FindClassDef(descriptor.c_str());
   if (dex_class_def == NULL) {
     VLOG(class_linker) << "Failed to find dex_class_def";
     return NULL;
diff --git a/runtime/native/java_lang_Class.cc b/runtime/native/java_lang_Class.cc
index a7296996da..d3011cb013 100644
--- a/runtime/native/java_lang_Class.cc
+++ b/runtime/native/java_lang_Class.cc
@@ -78,35 +78,6 @@ static jclass Class_classForName(JNIEnv* env, jclass, jstring javaName, jboolean
   return soa.AddLocalReference<jclass>(c);
 }
 
-static jint Class_getAnnotationDirectoryOffset(JNIEnv* env, jclass javaClass) {
-  ScopedObjectAccess soa(env);
-  mirror::Class* c = DecodeClass(soa, javaClass);
-  if (c->IsPrimitive() || c->IsArrayClass() || c->IsProxyClass()) {
-    return 0;  // primitive, array and proxy classes don't have class definitions
-  }
-  const DexFile::ClassDef* class_def = ClassHelper(c).GetClassDef();
-  if (class_def == NULL) {
-    return 0;  // not found
-  } else {
-    return class_def->annotations_off_;
-  }
-}
-
-static jobject Class_getDex(JNIEnv* env, jobject javaClass) {
-  ScopedObjectAccess soa(env);
-  mirror::Class* c = DecodeClass(soa, javaClass);
-
-  mirror::DexCache* dex_cache = c->GetDexCache();
-  if (dex_cache == NULL) {
-    return NULL;
-  }
-  const DexFile* dex_file = dex_cache->GetDexFile();
-  if (dex_file == NULL) {
-    return NULL;
-  }
-  return dex_file->GetDexObject(env);
-}
-
 static jstring Class_getNameNative(JNIEnv* env, jobject javaThis) {
   ScopedObjectAccess soa(env);
   mirror::Class* c = DecodeClass(soa, javaThis);
@@ -122,8 +93,6 @@ static jobjectArray Class_getProxyInterfaces(JNIEnv* env, jobject javaThis) {
 
 static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(Class, classForName, "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;"),
-  NATIVE_METHOD(Class, getAnnotationDirectoryOffset, "()I"),
-  NATIVE_METHOD(Class, getDex, "()Lcom/android/dex/Dex;"),
   NATIVE_METHOD(Class, getNameNative, "()Ljava/lang/String;"),
   NATIVE_METHOD(Class, getProxyInterfaces, "()[Ljava/lang/Class;"),
 };
diff --git a/runtime/native/java_lang_DexCache.cc b/runtime/native/java_lang_DexCache.cc
new file mode 100644
index 0000000000..f8eeb2906e
--- /dev/null
+++ b/runtime/native/java_lang_DexCache.cc
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2008 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.
+ */
+
+#include "dex_file.h"
+#include "mirror/dex_cache.h"
+#include "mirror/object-inl.h"
+#include "scoped_thread_state_change.h"
+#include "well_known_classes.h"
+
+namespace art {
+
+static jobject DexCache_getDexNative(JNIEnv* env, jobject javaDexCache) {
+  ScopedObjectAccess soa(env);
+  mirror::DexCache* dex_cache = soa.Decode<mirror::DexCache*>(javaDexCache);
+  // Should only be called while holding the lock on the dex cache.
+  DCHECK_EQ(dex_cache->GetThinLockId(), soa.Self()->GetThinLockId());
+  const DexFile* dex_file = dex_cache->GetDexFile();
+  if (dex_file == NULL) {
+    return NULL;
+  }
+  void* address = const_cast<void*>(reinterpret_cast<const void*>(dex_file->Begin()));
+  jobject byte_buffer = env->NewDirectByteBuffer(address, dex_file->Size());
+  if (byte_buffer == NULL) {
+    DCHECK(soa.Self()->IsExceptionPending());
+    return NULL;
+  }
+
+  jvalue args[1];
+  args[0].l = byte_buffer;
+  return env->CallStaticObjectMethodA(WellKnownClasses::com_android_dex_Dex,
+                                      WellKnownClasses::com_android_dex_Dex_create,
+                                      args);
+}
+
+static JNINativeMethod gMethods[] = {
+  NATIVE_METHOD(DexCache, getDexNative, "()Lcom/android/dex/Dex;"),
+};
+
+void register_java_lang_DexCache(JNIEnv* env) {
+  REGISTER_NATIVE_METHODS("java/lang/DexCache");
+}
+
+}  // namespace art
diff --git a/runtime/oat_file.cc b/runtime/oat_file.cc
index afa823dbd9..4c970172b4 100644
--- a/runtime/oat_file.cc
+++ b/runtime/oat_file.cc
@@ -365,7 +365,7 @@ const DexFile* OatFile::OatDexFile::OpenDexFile() const {
                        dex_file_location_checksum_);
 }
 
-const OatFile::OatClass* OatFile::OatDexFile::GetOatClass(uint32_t class_def_index) const {
+const OatFile::OatClass* OatFile::OatDexFile::GetOatClass(uint16_t class_def_index) const {
   uint32_t oat_class_offset = oat_class_offsets_pointer_[class_def_index];
 
   const byte* oat_class_pointer = oat_file_->Begin() + oat_class_offset;
diff --git a/runtime/oat_file.h b/runtime/oat_file.h
index 325ebb2914..bbd2615b66 100644
--- a/runtime/oat_file.h
+++ b/runtime/oat_file.h
@@ -183,7 +183,7 @@ class OatFile {
     }
 
     // Returns the OatClass for the class specified by the given DexFile class_def_index.
-    const OatClass* GetOatClass(uint32_t class_def_index) const;
+    const OatClass* GetOatClass(uint16_t class_def_index) const;
 
     ~OatDexFile();
 
diff --git a/runtime/object_utils.h b/runtime/object_utils.h
index 29102437a2..6ee3016179 100644
--- a/runtime/object_utils.h
+++ b/runtime/object_utils.h
@@ -68,8 +68,7 @@ class ClassHelper {
  public:
   ClassHelper(const mirror::Class* c = NULL, ClassLinker* l = NULL)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-      : class_def_(NULL),
-        class_linker_(l),
+      : class_linker_(l),
         dex_cache_(NULL),
         dex_file_(NULL),
         interface_type_list_(NULL),
@@ -92,7 +91,6 @@ class ClassHelper {
     }
     klass_ = new_c;
     interface_type_list_ = NULL;
-    class_def_ = NULL;
   }
 
   // The returned const char* is only guaranteed to be valid for the lifetime of the ClassHelper.
@@ -108,7 +106,7 @@ class ClassHelper {
       return descriptor_.c_str();
     } else {
       const DexFile& dex_file = GetDexFile();
-      const DexFile::TypeId& type_id = dex_file.GetTypeId(klass_->GetDexTypeIndex());
+      const DexFile::TypeId& type_id = dex_file.GetTypeId(GetClassDef()->class_idx_);
       return dex_file.GetTypeDescriptor(type_id);
     }
   }
@@ -124,14 +122,13 @@ class ClassHelper {
     return descriptor_.c_str();
   }
 
-  const DexFile::ClassDef* GetClassDef()
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    const DexFile::ClassDef* result = class_def_;
-    if (result == NULL) {
-      result = GetDexFile().FindClassDef(GetDescriptor());
-      class_def_ = result;
+  const DexFile::ClassDef* GetClassDef() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    DCHECK(klass_ != nullptr);
+    uint16_t class_def_idx = klass_->GetDexClassDefIndex();
+    if (class_def_idx == DexFile::kDexNoIndex16) {
+      return nullptr;
     }
-    return result;
+    return &GetDexFile().GetClassDef(class_def_idx);
   }
 
   uint32_t NumDirectInterfaces() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -187,7 +184,7 @@ class ClassHelper {
   const char* GetSourceFile() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     std::string descriptor(GetDescriptor());
     const DexFile& dex_file = GetDexFile();
-    const DexFile::ClassDef* dex_class_def = dex_file.FindClassDef(descriptor);
+    const DexFile::ClassDef* dex_class_def = GetClassDef();
     CHECK(dex_class_def != NULL);
     return dex_file.GetSourceFile(*dex_class_def);
   }
@@ -242,7 +239,6 @@ class ClassHelper {
     return result;
   }
 
-  const DexFile::ClassDef* class_def_;
   ClassLinker* class_linker_;
   mirror::DexCache* dex_cache_;
   const DexFile* dex_file_;
@@ -327,12 +323,15 @@ class FieldHelper {
   // If you need it longer, copy it into a std::string.
   const char* GetDeclaringClassDescriptor()
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    uint16_t type_idx = field_->GetDeclaringClass()->GetDexTypeIndex();
-    if (type_idx != DexFile::kDexNoIndex16) {
+    uint32_t field_index = field_->GetDexFieldIndex();
+    if (!field_->GetDeclaringClass()->IsProxyClass()) {
       const DexFile& dex_file = GetDexFile();
-      return dex_file.GetTypeDescriptor(dex_file.GetTypeId(type_idx));
+      const DexFile::FieldId& field_id = dex_file.GetFieldId(field_index);
+      return dex_file.GetFieldDeclaringClassDescriptor(field_id);
     } else {
-      // Most likely a proxy class.
+      DCHECK(field_->IsStatic());
+      DCHECK_LT(field_index, 2U);
+      // 0 == Class[] interfaces; 1 == Class[][] throws;
       ClassHelper kh(field_->GetDeclaringClass());
       declaring_class_descriptor_ = kh.GetDescriptor();
       return declaring_class_descriptor_.c_str();
@@ -418,7 +417,7 @@ class MethodHelper {
   const char* GetName() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
     uint32_t dex_method_idx = method_->GetDexMethodIndex();
-    if (dex_method_idx != DexFile::kDexNoIndex16) {
+    if (dex_method_idx != DexFile::kDexNoIndex) {
       return dex_file.GetMethodName(dex_file.GetMethodId(dex_method_idx));
     } else {
       Runtime* runtime = Runtime::Current();
@@ -464,21 +463,19 @@ class MethodHelper {
   const std::string GetSignature() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
     uint32_t dex_method_idx = method_->GetDexMethodIndex();
-    if (dex_method_idx != DexFile::kDexNoIndex16) {
+    if (dex_method_idx != DexFile::kDexNoIndex) {
       return dex_file.GetMethodSignature(dex_file.GetMethodId(dex_method_idx));
     } else {
       return "<no signature>";
     }
   }
 
-  const DexFile::ProtoId& GetPrototype()
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  const DexFile::ProtoId& GetPrototype() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
     return dex_file.GetMethodPrototype(dex_file.GetMethodId(method_->GetDexMethodIndex()));
   }
 
-  const DexFile::TypeList* GetParameterTypeList()
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  const DexFile::TypeList* GetParameterTypeList() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     const DexFile::ProtoId& proto = GetPrototype();
     return GetDexFile().GetProtoParameters(proto);
   }
@@ -491,8 +488,7 @@ class MethodHelper {
     return GetClassFromTypeIdx(return_type_idx);
   }
 
-  const char* GetReturnTypeDescriptor()
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  const char* GetReturnTypeDescriptor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
     const DexFile::MethodId& method_id = dex_file.GetMethodId(method_->GetDexMethodIndex());
     const DexFile::ProtoId& proto_id = dex_file.GetMethodPrototype(method_id);
@@ -500,8 +496,7 @@ class MethodHelper {
     return dex_file.GetTypeDescriptor(dex_file.GetTypeId(return_type_idx));
   }
 
-  int32_t GetLineNumFromDexPC(uint32_t dex_pc)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  int32_t GetLineNumFromDexPC(uint32_t dex_pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     if (dex_pc == DexFile::kDexNoIndex) {
       return method_->IsNative() ? -2 : -1;
     } else {
@@ -510,35 +505,29 @@ class MethodHelper {
     }
   }
 
-  const char* GetDeclaringClassDescriptor()
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    mirror::Class* klass = method_->GetDeclaringClass();
-    DCHECK(!klass->IsProxyClass());
-    uint16_t type_idx = klass->GetDexTypeIndex();
+  const char* GetDeclaringClassDescriptor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
-    return dex_file.GetTypeDescriptor(dex_file.GetTypeId(type_idx));
+    uint32_t dex_method_idx = method_->GetDexMethodIndex();
+    if (dex_method_idx != DexFile::kDexNoIndex) {
+      return dex_file.GetMethodDeclaringClassDescriptor(dex_file.GetMethodId(dex_method_idx));
+    } else {
+      return "<runtime method>";
+    }
   }
 
-  const char* GetDeclaringClassSourceFile()
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    const char* descriptor = GetDeclaringClassDescriptor();
-    const DexFile& dex_file = GetDexFile();
-    const DexFile::ClassDef* dex_class_def = dex_file.FindClassDef(descriptor);
-    CHECK(dex_class_def != NULL);
-    return dex_file.GetSourceFile(*dex_class_def);
+  const char* GetDeclaringClassSourceFile() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    return ClassHelper(method_->GetDeclaringClass()).GetSourceFile();
   }
 
-  uint32_t GetClassDefIndex()
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    const char* descriptor = GetDeclaringClassDescriptor();
-    const DexFile& dex_file = GetDexFile();
-    uint32_t index;
-    CHECK(dex_file.FindClassDefIndex(descriptor, index));
-    return index;
+  uint16_t GetClassDefIndex() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    return method_->GetDeclaringClass()->GetDexClassDefIndex();
   }
 
-  mirror::ClassLoader* GetClassLoader()
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  const DexFile::ClassDef& GetClassDef() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+    return GetDexFile().GetClassDef(GetClassDefIndex());
+  }
+
+  mirror::ClassLoader* GetClassLoader() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     return method_->GetDeclaringClass()->GetClassLoader();
   }
 
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index 657735a06b..09d1447d7b 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -1001,6 +1001,7 @@ void Runtime::RegisterRuntimeNativeMethods(JNIEnv* env) {
   REGISTER(register_dalvik_system_VMStack);
   REGISTER(register_dalvik_system_Zygote);
   REGISTER(register_java_lang_Class);
+  REGISTER(register_java_lang_DexCache);
   REGISTER(register_java_lang_Object);
   REGISTER(register_java_lang_Runtime);
   REGISTER(register_java_lang_String);
@@ -1164,7 +1165,7 @@ mirror::ArtMethod* Runtime::CreateResolutionMethod() {
       method(self, down_cast<mirror::ArtMethod*>(method_class->AllocObject(self)));
   method->SetDeclaringClass(method_class);
   // TODO: use a special method for resolution method saves
-  method->SetDexMethodIndex(DexFile::kDexNoIndex16);
+  method->SetDexMethodIndex(DexFile::kDexNoIndex);
   // When compiling, the code pointer will get set later when the image is loaded.
   Runtime* r = Runtime::Current();
   ClassLinker* cl = r->GetClassLinker();
@@ -1180,7 +1181,7 @@ mirror::ArtMethod* Runtime::CreateCalleeSaveMethod(InstructionSet instruction_se
       method(self, down_cast<mirror::ArtMethod*>(method_class->AllocObject(self)));
   method->SetDeclaringClass(method_class);
   // TODO: use a special method for callee saves
-  method->SetDexMethodIndex(DexFile::kDexNoIndex16);
+  method->SetDexMethodIndex(DexFile::kDexNoIndex);
   method->SetEntryPointFromCompiledCode(NULL);
   if ((instruction_set == kThumb2) || (instruction_set == kArm)) {
     uint32_t ref_spills = (1 << art::arm::R5) | (1 << art::arm::R6)  | (1 << art::arm::R7) |
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 558ceb47f9..23cafe8707 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -1807,7 +1807,7 @@ class CatchBlockStackVisitor : public StackVisitor {
     uint32_t new_dex_pc = dex_pc + inst->SizeInCodeUnits();
     ShadowFrame* new_frame = ShadowFrame::Create(num_regs, NULL, m, new_dex_pc);
     verifier::MethodVerifier verifier(&mh.GetDexFile(), mh.GetDexCache(), mh.GetClassLoader(),
-                                      mh.GetClassDefIndex(), code_item,
+                                      &mh.GetClassDef(), code_item,
                                       m->GetDexMethodIndex(), m, m->GetAccessFlags(), false, true);
     verifier.Verify();
     std::vector<int32_t> kinds = verifier.DescribeVRegs(dex_pc);
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index fa00c61017..9811926b16 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -74,50 +74,51 @@ void PcToRegisterLineTable::Init(RegisterTrackingMode mode, InstructionFlags* fl
 }
 
 MethodVerifier::FailureKind MethodVerifier::VerifyClass(const mirror::Class* klass,
-                                                        std::string& error,
-                                                        bool allow_soft_failures) {
+                                                        bool allow_soft_failures,
+                                                        std::string* error) {
   if (klass->IsVerified()) {
     return kNoFailure;
   }
   mirror::Class* super = klass->GetSuperClass();
   if (super == NULL && StringPiece(ClassHelper(klass).GetDescriptor()) != "Ljava/lang/Object;") {
-    error = "Verifier rejected class ";
-    error += PrettyDescriptor(klass);
-    error += " that has no super class";
+    *error = "Verifier rejected class ";
+    *error += PrettyDescriptor(klass);
+    *error += " that has no super class";
     return kHardFailure;
   }
   if (super != NULL && super->IsFinal()) {
-    error = "Verifier rejected class ";
-    error += PrettyDescriptor(klass);
-    error += " that attempts to sub-class final class ";
-    error += PrettyDescriptor(super);
+    *error = "Verifier rejected class ";
+    *error += PrettyDescriptor(klass);
+    *error += " that attempts to sub-class final class ";
+    *error += PrettyDescriptor(super);
     return kHardFailure;
   }
   ClassHelper kh(klass);
   const DexFile& dex_file = kh.GetDexFile();
-  uint32_t class_def_idx;
-  if (!dex_file.FindClassDefIndex(kh.GetDescriptor(), class_def_idx)) {
-    error = "Verifier rejected class ";
-    error += PrettyDescriptor(klass);
-    error += " that isn't present in dex file ";
-    error += dex_file.GetLocation();
+  const DexFile::ClassDef* class_def = kh.GetClassDef();
+  if (class_def == NULL) {
+    *error = "Verifier rejected class ";
+    *error += PrettyDescriptor(klass);
+    *error += " that isn't present in dex file ";
+    *error += dex_file.GetLocation();
     return kHardFailure;
   }
   return VerifyClass(&dex_file,
                      kh.GetDexCache(),
                      klass->GetClassLoader(),
-                     class_def_idx, error,
-                     allow_soft_failures);
+                     class_def,
+                     allow_soft_failures,
+                     error);
 }
 
 MethodVerifier::FailureKind MethodVerifier::VerifyClass(const DexFile* dex_file,
                                                         mirror::DexCache* dex_cache,
                                                         mirror::ClassLoader* class_loader,
-                                                        uint32_t class_def_idx,
-                                                        std::string& error,
-                                                        bool allow_soft_failures) {
-  const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_idx);
-  const byte* class_data = dex_file->GetClassData(class_def);
+                                                        const DexFile::ClassDef* class_def,
+                                                        bool allow_soft_failures,
+                                                        std::string* error) {
+  DCHECK(class_def != nullptr);
+  const byte* class_data = dex_file->GetClassData(*class_def);
   if (class_data == NULL) {
     // empty class, probably a marker interface
     return kNoFailure;
@@ -139,7 +140,7 @@ MethodVerifier::FailureKind MethodVerifier::VerifyClass(const DexFile* dex_file,
       continue;
     }
     previous_direct_method_idx = method_idx;
-    InvokeType type = it.GetMethodInvokeType(class_def);
+    InvokeType type = it.GetMethodInvokeType(*class_def);
     mirror::ArtMethod* method =
         linker->ResolveMethod(*dex_file, method_idx, dex_cache, class_loader, NULL, type);
     if (method == NULL) {
@@ -151,7 +152,7 @@ MethodVerifier::FailureKind MethodVerifier::VerifyClass(const DexFile* dex_file,
                                                       dex_file,
                                                       dex_cache,
                                                       class_loader,
-                                                      class_def_idx,
+                                                      class_def,
                                                       it.GetMethodCodeItem(),
                                                       method,
                                                       it.GetMemberAccessFlags(),
@@ -160,12 +161,12 @@ MethodVerifier::FailureKind MethodVerifier::VerifyClass(const DexFile* dex_file,
       if (result == kHardFailure) {
         hard_fail = true;
         if (error_count > 0) {
-          error += "\n";
+          *error += "\n";
         }
-        error = "Verifier rejected class ";
-        error += PrettyDescriptor(dex_file->GetClassDescriptor(class_def));
-        error += " due to bad method ";
-        error += PrettyMethod(method_idx, *dex_file);
+        *error = "Verifier rejected class ";
+        *error += PrettyDescriptor(dex_file->GetClassDescriptor(*class_def));
+        *error += " due to bad method ";
+        *error += PrettyMethod(method_idx, *dex_file);
       }
       ++error_count;
     }
@@ -181,7 +182,7 @@ MethodVerifier::FailureKind MethodVerifier::VerifyClass(const DexFile* dex_file,
       continue;
     }
     previous_virtual_method_idx = method_idx;
-    InvokeType type = it.GetMethodInvokeType(class_def);
+    InvokeType type = it.GetMethodInvokeType(*class_def);
     mirror::ArtMethod* method =
         linker->ResolveMethod(*dex_file, method_idx, dex_cache, class_loader, NULL, type);
     if (method == NULL) {
@@ -193,7 +194,7 @@ MethodVerifier::FailureKind MethodVerifier::VerifyClass(const DexFile* dex_file,
                                                       dex_file,
                                                       dex_cache,
                                                       class_loader,
-                                                      class_def_idx,
+                                                      class_def,
                                                       it.GetMethodCodeItem(),
                                                       method,
                                                       it.GetMemberAccessFlags(),
@@ -202,12 +203,12 @@ MethodVerifier::FailureKind MethodVerifier::VerifyClass(const DexFile* dex_file,
       if (result == kHardFailure) {
         hard_fail = true;
         if (error_count > 0) {
-          error += "\n";
+          *error += "\n";
         }
-        error = "Verifier rejected class ";
-        error += PrettyDescriptor(dex_file->GetClassDescriptor(class_def));
-        error += " due to bad method ";
-        error += PrettyMethod(method_idx, *dex_file);
+        *error = "Verifier rejected class ";
+        *error += PrettyDescriptor(dex_file->GetClassDescriptor(*class_def));
+        *error += " due to bad method ";
+        *error += PrettyMethod(method_idx, *dex_file);
       }
       ++error_count;
     }
@@ -224,7 +225,7 @@ MethodVerifier::FailureKind MethodVerifier::VerifyMethod(uint32_t method_idx,
                                                          const DexFile* dex_file,
                                                          mirror::DexCache* dex_cache,
                                                          mirror::ClassLoader* class_loader,
-                                                         uint32_t class_def_idx,
+                                                         const DexFile::ClassDef* class_def,
                                                          const DexFile::CodeItem* code_item,
                                                          mirror::ArtMethod* method,
                                                          uint32_t method_access_flags,
@@ -232,7 +233,7 @@ MethodVerifier::FailureKind MethodVerifier::VerifyMethod(uint32_t method_idx,
   MethodVerifier::FailureKind result = kNoFailure;
   uint64_t start_ns = NanoTime();
 
-  MethodVerifier verifier_(dex_file, dex_cache, class_loader, class_def_idx, code_item, method_idx,
+  MethodVerifier verifier_(dex_file, dex_cache, class_loader, class_def, code_item, method_idx,
                            method, method_access_flags, true, allow_soft_failures);
   if (verifier_.Verify()) {
     // Verification completed, however failures may be pending that didn't cause the verification
@@ -267,11 +268,12 @@ MethodVerifier::FailureKind MethodVerifier::VerifyMethod(uint32_t method_idx,
 
 void MethodVerifier::VerifyMethodAndDump(std::ostream& os, uint32_t dex_method_idx,
                                          const DexFile* dex_file, mirror::DexCache* dex_cache,
-                                         mirror::ClassLoader* class_loader, uint32_t class_def_idx,
+                                         mirror::ClassLoader* class_loader,
+                                         const DexFile::ClassDef* class_def,
                                          const DexFile::CodeItem* code_item,
                                          mirror::ArtMethod* method,
                                          uint32_t method_access_flags) {
-  MethodVerifier verifier(dex_file, dex_cache, class_loader, class_def_idx, code_item,
+  MethodVerifier verifier(dex_file, dex_cache, class_loader, class_def, code_item,
                           dex_method_idx, method, method_access_flags, true, true);
   verifier.Verify();
   verifier.DumpFailures(os);
@@ -280,7 +282,8 @@ void MethodVerifier::VerifyMethodAndDump(std::ostream& os, uint32_t dex_method_i
 }
 
 MethodVerifier::MethodVerifier(const DexFile* dex_file, mirror::DexCache* dex_cache,
-                               mirror::ClassLoader* class_loader, uint32_t class_def_idx,
+                               mirror::ClassLoader* class_loader,
+                               const DexFile::ClassDef* class_def,
                                const DexFile::CodeItem* code_item,
                                uint32_t dex_method_idx, mirror::ArtMethod* method,
                                uint32_t method_access_flags, bool can_load_classes,
@@ -293,7 +296,7 @@ MethodVerifier::MethodVerifier(const DexFile* dex_file, mirror::DexCache* dex_ca
       dex_file_(dex_file),
       dex_cache_(dex_cache),
       class_loader_(class_loader),
-      class_def_idx_(class_def_idx),
+      class_def_(class_def),
       code_item_(code_item),
       declaring_class_(NULL),
       interesting_dex_pc_(-1),
@@ -306,13 +309,14 @@ MethodVerifier::MethodVerifier(const DexFile* dex_file, mirror::DexCache* dex_ca
       allow_soft_failures_(allow_soft_failures),
       has_check_casts_(false),
       has_virtual_or_interface_invokes_(false) {
+  DCHECK(class_def != NULL);
 }
 
 void MethodVerifier::FindLocksAtDexPc(mirror::ArtMethod* m, uint32_t dex_pc,
                                       std::vector<uint32_t>& monitor_enter_dex_pcs) {
   MethodHelper mh(m);
   MethodVerifier verifier(&mh.GetDexFile(), mh.GetDexCache(), mh.GetClassLoader(),
-                          mh.GetClassDefIndex(), mh.GetCodeItem(), m->GetDexMethodIndex(),
+                          &mh.GetClassDef(), mh.GetCodeItem(), m->GetDexMethodIndex(),
                           m, m->GetAccessFlags(), false, true);
   verifier.interesting_dex_pc_ = dex_pc;
   verifier.monitor_enter_dex_pcs_ = &monitor_enter_dex_pcs;
@@ -334,7 +338,7 @@ mirror::ArtField* MethodVerifier::FindAccessedFieldAtDexPc(mirror::ArtMethod* m,
                                                         uint32_t dex_pc) {
   MethodHelper mh(m);
   MethodVerifier verifier(&mh.GetDexFile(), mh.GetDexCache(), mh.GetClassLoader(),
-                          mh.GetClassDefIndex(), mh.GetCodeItem(), m->GetDexMethodIndex(),
+                          &mh.GetClassDef(), mh.GetCodeItem(), m->GetDexMethodIndex(),
                           m, m->GetAccessFlags(), false, true);
   return verifier.FindAccessedFieldAtDexPc(dex_pc);
 }
@@ -362,7 +366,7 @@ mirror::ArtMethod* MethodVerifier::FindInvokedMethodAtDexPc(mirror::ArtMethod* m
                                                                  uint32_t dex_pc) {
   MethodHelper mh(m);
   MethodVerifier verifier(&mh.GetDexFile(), mh.GetDexCache(), mh.GetClassLoader(),
-                          mh.GetClassDefIndex(), mh.GetCodeItem(), m->GetDexMethodIndex(),
+                          &mh.GetClassDef(), mh.GetCodeItem(), m->GetDexMethodIndex(),
                           m, m->GetAccessFlags(), false, true);
   return verifier.FindInvokedMethodAtDexPc(dex_pc);
 }
@@ -448,7 +452,7 @@ std::ostream& MethodVerifier::Fail(VerifyError error) {
       // marked as rejected to prevent it from being compiled.
     case VERIFY_ERROR_BAD_CLASS_HARD: {
       if (Runtime::Current()->IsCompiler()) {
-        ClassReference ref(dex_file_, class_def_idx_);
+        ClassReference ref(dex_file_, dex_file_->GetIndexForClassDef(*class_def_));
         AddRejectedClass(ref);
       }
       have_pending_hard_failure_ = true;
diff --git a/runtime/verifier/method_verifier.h b/runtime/verifier/method_verifier.h
index 70442fbc04..073a2f76be 100644
--- a/runtime/verifier/method_verifier.h
+++ b/runtime/verifier/method_verifier.h
@@ -145,17 +145,19 @@ class MethodVerifier {
   };
 
   /* Verify a class. Returns "kNoFailure" on success. */
-  static FailureKind VerifyClass(const mirror::Class* klass, std::string& error,
-                                 bool allow_soft_failures)
+  static FailureKind VerifyClass(const mirror::Class* klass, bool allow_soft_failures,
+                                 std::string* error)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   static FailureKind VerifyClass(const DexFile* dex_file, mirror::DexCache* dex_cache,
-                                 mirror::ClassLoader* class_loader, uint32_t class_def_idx,
-                                 std::string& error, bool allow_soft_failures)
+                                 mirror::ClassLoader* class_loader,
+                                 const DexFile::ClassDef* class_def,
+                                 bool allow_soft_failures, std::string* error)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   static void VerifyMethodAndDump(std::ostream& os, uint32_t method_idx, const DexFile* dex_file,
                                   mirror::DexCache* dex_cache, mirror::ClassLoader* class_loader,
-                                  uint32_t class_def_idx, const DexFile::CodeItem* code_item,
+                                  const DexFile::ClassDef* class_def,
+                                  const DexFile::CodeItem* code_item,
                                   mirror::ArtMethod* method, uint32_t method_access_flags)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -222,7 +224,7 @@ class MethodVerifier {
   }
 
   MethodVerifier(const DexFile* dex_file, mirror::DexCache* dex_cache,
-                 mirror::ClassLoader* class_loader, uint32_t class_def_idx,
+                 mirror::ClassLoader* class_loader, const DexFile::ClassDef* class_def,
                  const DexFile::CodeItem* code_item,
                  uint32_t method_idx, mirror::ArtMethod* method,
                  uint32_t access_flags, bool can_load_classes, bool allow_soft_failures)
@@ -262,7 +264,8 @@ class MethodVerifier {
    */
   static FailureKind VerifyMethod(uint32_t method_idx, const DexFile* dex_file,
                                   mirror::DexCache* dex_cache,
-                                  mirror::ClassLoader* class_loader, uint32_t class_def_idx,
+                                  mirror::ClassLoader* class_loader,
+                                  const DexFile::ClassDef* class_def_idx,
                                   const DexFile::CodeItem* code_item,
                                   mirror::ArtMethod* method, uint32_t method_access_flags,
                                   bool allow_soft_failures)
@@ -690,7 +693,7 @@ class MethodVerifier {
   mirror::DexCache* dex_cache_ GUARDED_BY(Locks::mutator_lock_);
   // The class loader for the declaring class of the method.
   mirror::ClassLoader* class_loader_ GUARDED_BY(Locks::mutator_lock_);
-  const uint32_t class_def_idx_;  // The class def index of the declaring class of the method.
+  const DexFile::ClassDef* const class_def_;  // The class def of the declaring class of the method.
   const DexFile::CodeItem* const code_item_;  // The code item containing the code for the method.
   const RegType* declaring_class_;  // Lazily computed reg type of the method's declaring class.
   // Instruction widths and flags, one entry per code unit.
diff --git a/runtime/verifier/method_verifier_test.cc b/runtime/verifier/method_verifier_test.cc
index 611b7c06eb..a56abba3cf 100644
--- a/runtime/verifier/method_verifier_test.cc
+++ b/runtime/verifier/method_verifier_test.cc
@@ -34,7 +34,8 @@ class MethodVerifierTest : public CommonTest {
 
     // Verify the class
     std::string error_msg;
-    ASSERT_TRUE(MethodVerifier::VerifyClass(klass, error_msg, true) == MethodVerifier::kNoFailure) << error_msg;
+    ASSERT_TRUE(MethodVerifier::VerifyClass(klass, true, &error_msg) == MethodVerifier::kNoFailure)
+        << error_msg;
   }
 
   void VerifyDexFile(const DexFile* dex)
diff --git a/test/100-reflect2/expected.txt b/test/100-reflect2/expected.txt
index 3d87ebc559..967f167f37 100644
--- a/test/100-reflect2/expected.txt
+++ b/test/100-reflect2/expected.txt
@@ -35,7 +35,7 @@ z (class java.lang.Character)
 62 (class java.lang.Long)
 14 (class java.lang.Short)
 [public java.lang.String(), java.lang.String(int,int,char[]), public java.lang.String(java.lang.String), public java.lang.String(java.lang.StringBuffer), public java.lang.String(java.lang.StringBuilder), public java.lang.String(byte[]), public java.lang.String(byte[],int), public java.lang.String(byte[],int,int), public java.lang.String(byte[],int,int,int), public java.lang.String(byte[],int,int,java.lang.String) throws java.io.UnsupportedEncodingException, public java.lang.String(byte[],int,int,java.nio.charset.Charset), public java.lang.String(byte[],java.lang.String) throws java.io.UnsupportedEncodingException, public java.lang.String(byte[],java.nio.charset.Charset), public java.lang.String(char[]), public java.lang.String(char[],int,int), public java.lang.String(int[],int,int)]
-[private final char[] java.lang.String.value, private final int java.lang.String.count, private int java.lang.String.hashCode, private final int java.lang.String.offset, private static final char[] java.lang.String.ASCII, public static final java.util.Comparator java.lang.String.CASE_INSENSITIVE_ORDER, private static final char java.lang.String.REPLACEMENT_CHAR, private static final long java.lang.String.serialVersionUID]
+[private final char[] java.lang.String.value, private final int java.lang.String.count, private int java.lang.String.hashCode, private final int java.lang.String.offset, private static final char[] java.lang.String.ASCII, public static final java.util.Comparator java.lang.String.CASE_INSENSITIVE_ORDER, private static final long java.lang.String.serialVersionUID, private static final char java.lang.String.REPLACEMENT_CHAR]
 [void java.lang.String._getChars(int,int,char[],int), public char java.lang.String.charAt(int), public int java.lang.String.codePointAt(int), public int java.lang.String.codePointBefore(int), public int java.lang.String.codePointCount(int,int), public volatile int java.lang.String.compareTo(java.lang.Object), public native int java.lang.String.compareTo(java.lang.String), public int java.lang.String.compareToIgnoreCase(java.lang.String), public java.lang.String java.lang.String.concat(java.lang.String), public boolean java.lang.String.contains(java.lang.CharSequence), public boolean java.lang.String.contentEquals(java.lang.CharSequence), public boolean java.lang.String.contentEquals(java.lang.StringBuffer), public boolean java.lang.String.endsWith(java.lang.String), public boolean java.lang.String.equals(java.lang.Object), public boolean java.lang.String.equalsIgnoreCase(java.lang.String), public void java.lang.String.getBytes(int,int,byte[],int), public [B java.lang.String.getBytes(), public [B java.lang.String.getBytes(java.lang.String) throws java.io.UnsupportedEncodingException, public [B java.lang.String.getBytes(java.nio.charset.Charset), public void java.lang.String.getChars(int,int,char[],int), public int java.lang.String.hashCode(), public int java.lang.String.indexOf(int), public int java.lang.String.indexOf(int,int), public int java.lang.String.indexOf(java.lang.String), public int java.lang.String.indexOf(java.lang.String,int), public native java.lang.String java.lang.String.intern(), public boolean java.lang.String.isEmpty(), public int java.lang.String.lastIndexOf(int), public int java.lang.String.lastIndexOf(int,int), public int java.lang.String.lastIndexOf(java.lang.String), public int java.lang.String.lastIndexOf(java.lang.String,int), public int java.lang.String.length(), public boolean java.lang.String.matches(java.lang.String), public int java.lang.String.offsetByCodePoints(int,int), public boolean java.lang.String.regionMatches(int,java.lang.String,int,int), public boolean java.lang.String.regionMatches(boolean,int,java.lang.String,int,int), public java.lang.String java.lang.String.replace(char,char), public java.lang.String java.lang.String.replace(java.lang.CharSequence,java.lang.CharSequence), public java.lang.String java.lang.String.replaceAll(java.lang.String,java.lang.String), public java.lang.String java.lang.String.replaceFirst(java.lang.String,java.lang.String), public [Ljava.lang.String; java.lang.String.split(java.lang.String), public [Ljava.lang.String; java.lang.String.split(java.lang.String,int), public boolean java.lang.String.startsWith(java.lang.String), public boolean java.lang.String.startsWith(java.lang.String,int), public java.lang.CharSequence java.lang.String.subSequence(int,int), public java.lang.String java.lang.String.substring(int), public java.lang.String java.lang.String.substring(int,int), public [C java.lang.String.toCharArray(), public java.lang.String java.lang.String.toLowerCase(), public java.lang.String java.lang.String.toLowerCase(java.util.Locale), public java.lang.String java.lang.String.toString(), public java.lang.String java.lang.String.toUpperCase(), public java.lang.String java.lang.String.toUpperCase(java.util.Locale), public java.lang.String java.lang.String.trim(), public static java.lang.String java.lang.String.copyValueOf(char[]), public static java.lang.String java.lang.String.copyValueOf(char[],int,int), private java.lang.StringIndexOutOfBoundsException java.lang.String.failedBoundsCheck(int,int,int), private native int java.lang.String.fastIndexOf(int,int), private char java.lang.String.foldCase(char), public static transient java.lang.String java.lang.String.format(java.lang.String,java.lang.Object[]), public static transient java.lang.String java.lang.String.format(java.util.Locale,java.lang.String,java.lang.Object[]), private java.lang.StringIndexOutOfBoundsException java.lang.String.indexAndLength(int), private static int java.lang.String.indexOf(java.lang.String,java.lang.String,int,int,char), private int java.lang.String.indexOfSupplementary(int,int), private int java.lang.String.lastIndexOfSupplementary(int,int), private java.lang.StringIndexOutOfBoundsException java.lang.String.startEndAndLength(int,int), public static java.lang.String java.lang.String.valueOf(char), public static java.lang.String java.lang.String.valueOf(double), public static java.lang.String java.lang.String.valueOf(float), public static java.lang.String java.lang.String.valueOf(int), public static java.lang.String java.lang.String.valueOf(long), public static java.lang.String java.lang.String.valueOf(java.lang.Object), public static java.lang.String java.lang.String.valueOf(boolean), public static java.lang.String java.lang.String.valueOf(char[]), public static java.lang.String java.lang.String.valueOf(char[],int,int)]
 []
 [interface java.io.Serializable, interface java.lang.Comparable, interface java.lang.CharSequence]
-- 
cgit v1.2.3-59-g8ed1b


From cb5f5e53b580023fa2c1d8235c2e9aa1ff67d1dc Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Mon, 23 Sep 2013 17:48:16 -0700
Subject: Make sure CompilerDriver actually resolves types

Bug: 10750824
Change-Id: Ie61881f24196e851d87822798a7e9abdf9678aa3
---
 compiler/driver/compiler_driver.cc | 36 ++++++++++++++++++------------------
 runtime/class_linker.cc            |  1 +
 2 files changed, 19 insertions(+), 18 deletions(-)

(limited to 'compiler/driver/compiler_driver.cc')

diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 1c831cf3f6..6eabeed34b 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -1471,6 +1471,24 @@ static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manag
   // generated code.
   const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
   if (!SkipClass(class_linker, jclass_loader, dex_file, class_def)) {
+    ScopedObjectAccess soa(self);
+    mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(jclass_loader);
+    mirror::DexCache* dex_cache = class_linker->FindDexCache(dex_file);
+
+    // Resolve the class.
+    mirror::Class* klass = class_linker->ResolveType(dex_file, class_def.class_idx_, dex_cache,
+                                                     class_loader);
+
+    bool resolve_fields_and_methods;
+    if (klass == NULL) {
+      // Class couldn't be resolved, for example, super-class is in a different dex file. Don't
+      // attempt to resolve methods and fields when there is no declaring class.
+      CHECK(soa.Self()->IsExceptionPending());
+      soa.Self()->ClearException();
+      resolve_fields_and_methods = false;
+    } else {
+      resolve_fields_and_methods = manager->GetCompiler()->IsImage();
+    }
     // Note the class_data pointer advances through the headers,
     // static fields, instance fields, direct methods, and virtual
     // methods.
@@ -1479,24 +1497,6 @@ static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manag
       // Empty class such as a marker interface.
       requires_constructor_barrier = false;
     } else {
-      ScopedObjectAccess soa(self);
-      mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(jclass_loader);
-      mirror::DexCache* dex_cache = class_linker->FindDexCache(dex_file);
-
-      // Resolve the class.
-      mirror::Class* klass = class_linker->ResolveType(dex_file, class_def.class_idx_, dex_cache,
-                                                       class_loader);
-
-      bool resolve_fields_and_methods;
-      if (klass == NULL) {
-        // Class couldn't be resolved, for example, super-class is in a different dex file. Don't
-        // attempt to resolve methods and fields when there is no declaring class.
-        CHECK(soa.Self()->IsExceptionPending());
-        soa.Self()->ClearException();
-        resolve_fields_and_methods = false;
-      } else {
-        resolve_fields_and_methods = manager->GetCompiler()->IsImage();
-      }
       ClassDataItemIterator it(dex_file, class_data);
       while (it.HasNextStaticField()) {
         if (resolve_fields_and_methods) {
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 4043f8be5a..4a3ae1b8c9 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -3979,6 +3979,7 @@ mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file,
       }
     }
   }
+  DCHECK((resolved == NULL) || resolved->IsResolved()) << PrettyDescriptor(resolved);
   return resolved;
 }
 
-- 
cgit v1.2.3-59-g8ed1b