diff --git a/Android.mk b/Android.mk
index 3d50015..809ee85 100644
--- a/Android.mk
+++ b/Android.mk
@@ -199,7 +199,7 @@
 $(eval $(call build-art-cache-oat,system/app/MusicFX.apk))
 $(eval $(call build-art-cache-oat,system/app/NetSpeed.apk))
 $(eval $(call build-art-cache-oat,system/app/NetworkLocation.apk))
-$(eval $(call build-art-cache-oat,system/app/NfcGoogle.apk))
+$(eval $(call build-art-cache-oat,system/app/Nfc.apk))
 $(eval $(call build-art-cache-oat,system/app/OneTimeInitializer.apk))
 $(eval $(call build-art-cache-oat,system/app/PackageInstaller.apk))
 $(eval $(call build-art-cache-oat,system/app/Phone.apk))
diff --git a/build/Android.common.mk b/build/Android.common.mk
index 4b0cdfe..2001c06 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -169,6 +169,7 @@
 	src/org_apache_harmony_dalvik_ddmc_DdmServer.cc \
 	src/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc \
 	src/os_linux.cc \
+	src/primitive.cc \
 	src/reference_table.cc \
 	src/reflection.cc \
 	src/runtime.cc \
diff --git a/build/Android.oat.mk b/build/Android.oat.mk
index 6d72ded..9ea9e81 100644
--- a/build/Android.oat.mk
+++ b/build/Android.oat.mk
@@ -32,6 +32,8 @@
 IMG_HOST_BASE_ADDRESS   := 0x60000000
 IMG_TARGET_BASE_ADDRESS := 0x60000000
 
+PRELOADED_CLASSES := frameworks/base/preloaded-classes
+
 ########################################################################
 # A smaller libcore only oat file
 HOST_CORE_JARS := core-hostdex
@@ -50,13 +52,13 @@
 	@echo "host dex2oat: $@ ($?)"
 	@mkdir -p $(dir $@)
 	@rm -f $@
-	$(hide) $(DEX2OAT) --runtime-arg -Xms16m --runtime-arg -Xmx16m $(addprefix --dex-file=,$(filter-out $(DEX2OAT),$^)) --oat=$@ --image=$(HOST_CORE_IMG) --base=$(IMG_HOST_BASE_ADDRESS)
+	$(hide) $(DEX2OAT) --runtime-arg -Xms16m --runtime-arg -Xmx16m --image-classes=$(PRELOADED_CLASSES) $(addprefix --dex-file=,$(filter-out $(DEX2OAT),$^)) --oat=$@ --image=$(HOST_CORE_IMG) --base=$(IMG_HOST_BASE_ADDRESS)
 
 $(TARGET_CORE_OAT): $(TARGET_CORE_DEX) $(DEX2OAT_DEPENDENCY)
 	@echo "target dex2oat: $@ ($?)"
 	@mkdir -p $(dir $@)
 	@rm -f $@
-	$(hide) $(DEX2OAT) --runtime-arg -Xms32m --runtime-arg -Xmx32m $(addprefix --dex-file=,$(filter-out $(DEX2OAT),$^)) --oat=$@ --image=$(TARGET_CORE_IMG) --base=$(IMG_TARGET_BASE_ADDRESS) --host-prefix=$(PRODUCT_OUT)
+	$(hide) $(DEX2OAT) --runtime-arg -Xms16m --runtime-arg -Xmx16m --image-classes=$(PRELOADED_CLASSES) $(addprefix --dex-file=,$(filter-out $(DEX2OAT),$^)) --oat=$@ --image=$(TARGET_CORE_IMG) --base=$(IMG_TARGET_BASE_ADDRESS) --host-prefix=$(PRODUCT_OUT)
 
 $(HOST_CORE_IMG): $(HOST_CORE_OAT)
 
@@ -73,6 +75,6 @@
 	@echo "target dex2oat: $@ ($?)"
 	@mkdir -p $(dir $@)
 	@rm -f $@
-	$(hide) $(DEX2OAT) --runtime-arg -Xms256m --runtime-arg -Xmx256m $(addprefix --dex-file=,$(filter-out $(DEX2OAT),$^)) --oat=$@ --image=$(TARGET_BOOT_IMG) --base=$(IMG_TARGET_BASE_ADDRESS) --host-prefix=$(PRODUCT_OUT)
+	$(hide) $(DEX2OAT) --runtime-arg -Xms256m --runtime-arg -Xmx256m --image-classes=$(PRELOADED_CLASSES) $(addprefix --dex-file=,$(filter-out $(DEX2OAT),$^)) --oat=$@ --image=$(TARGET_BOOT_IMG) --base=$(IMG_TARGET_BASE_ADDRESS) --host-prefix=$(PRODUCT_OUT)
 
 $(TARGET_BOOT_IMG): $(TARGET_BOOT_OAT)
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 4598ae9..266c1f0 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -184,22 +184,24 @@
   DISALLOW_COPY_AND_ASSIGN(ObjectLock);
 };
 
-ClassLinker* ClassLinker::Create(const std::string& boot_class_path,
+ClassLinker* ClassLinker::Create(bool verbose,
+                                 const std::string& boot_class_path,
                                  InternTable* intern_table) {
   CHECK_NE(boot_class_path.size(), 0U);
-  UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
+  UniquePtr<ClassLinker> class_linker(new ClassLinker(verbose, intern_table));
   class_linker->Init(boot_class_path);
   return class_linker.release();
 }
 
-ClassLinker* ClassLinker::Create(InternTable* intern_table) {
-  UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
+ClassLinker* ClassLinker::Create(bool verbose, InternTable* intern_table) {
+  UniquePtr<ClassLinker> class_linker(new ClassLinker(verbose, intern_table));
   class_linker->InitFromImage();
   return class_linker.release();
 }
 
-ClassLinker::ClassLinker(InternTable* intern_table)
-    : dex_lock_("ClassLinker dex lock"),
+ClassLinker::ClassLinker(bool verbose, InternTable* intern_table)
+    : verbose_(verbose),
+      dex_lock_("ClassLinker dex lock"),
       classes_lock_("ClassLinker classes lock"),
       class_roots_(NULL),
       array_interfaces_(NULL),
@@ -633,9 +635,25 @@
   return oat_file;
 }
 
-const OatFile* ClassLinker::FindOatFile(const DexFile& dex_file) {
+const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
+  for (size_t i = 0; i < oat_files_.size(); i++) {
+    const OatFile* oat_file = oat_files_[i];
+    DCHECK(oat_file != NULL);
+    if (oat_file->GetOatDexFile(dex_file.GetLocation())) {
+      return oat_file;
+    }
+  }
+  return NULL;
+}
+
+const OatFile* ClassLinker::FindOatFileForDexFile(const DexFile& dex_file) {
   MutexLock mu(dex_lock_);
-  const OatFile* oat_file = FindOatFile(OatFile::DexFilenameToOatFilename(dex_file.GetLocation()));
+  const OatFile* oat_file = FindOpenedOatFileForDexFile(dex_file);
+  if (oat_file != NULL) {
+    return oat_file;
+  }
+
+  oat_file = FindOatFileFromOatLocation(OatFile::DexFilenameToOatFilename(dex_file.GetLocation()));
   if (oat_file != NULL) {
     const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
     if (dex_file.GetHeader().checksum_ == oat_dex_file->GetDexFileChecksum()) {
@@ -658,44 +676,44 @@
   return oat_file;
 }
 
-const OatFile* ClassLinker::FindOpenedOatFile(const std::string& location) {
+const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
   for (size_t i = 0; i < oat_files_.size(); i++) {
     const OatFile* oat_file = oat_files_[i];
     DCHECK(oat_file != NULL);
-    if (oat_file->GetLocation() == location) {
+    if (oat_file->GetLocation() == oat_location) {
       return oat_file;
     }
   }
   return NULL;
 }
 
-const OatFile* ClassLinker::FindOatFile(const std::string& location) {
-  const OatFile* oat_file = FindOpenedOatFile(location);
+const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location) {
+  const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
   if (oat_file != NULL) {
     return oat_file;
   }
 
-  oat_file = OatFile::Open(location, "", NULL);
+  oat_file = OatFile::Open(oat_location, "", NULL);
   if (oat_file == NULL) {
-    if (location.empty() || location[0] != '/') {
-      LOG(ERROR) << "Failed to open oat file from " << location;
+    if (oat_location.empty() || oat_location[0] != '/') {
+      LOG(ERROR) << "Failed to open oat file from " << oat_location;
       return NULL;
     }
 
     // not found in /foo/bar/baz.oat? try /data/art-cache/foo@bar@baz.oat
-    std::string cache_location = GetArtCacheFilenameOrDie(location);
-    oat_file = FindOpenedOatFile(cache_location);
+    std::string cache_location = GetArtCacheFilenameOrDie(oat_location);
+    oat_file = FindOpenedOatFileFromOatLocation(cache_location);
     if (oat_file != NULL) {
       return oat_file;
     }
     oat_file = OatFile::Open(cache_location, "", NULL);
     if (oat_file  == NULL) {
-      LOG(INFO) << "Failed to open oat file from " << location << " or " << cache_location << ".";
+      LOG(INFO) << "Failed to open oat file from " << oat_location << " or " << cache_location << ".";
       return NULL;
     }
   }
 
-  CHECK(oat_file != NULL) << location;
+  CHECK(oat_file != NULL) << oat_location;
   oat_files_.push_back(oat_file);
   return oat_file;
 }
@@ -1137,7 +1155,7 @@
   // Every kind of method should at least get an invoke stub from the oat_method.
   // non-abstract methods also get their code pointers.
   const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
-  oat_method.LinkMethod(method.get());
+  oat_method.LinkMethodPointers(method.get());
 
   if (method->IsAbstract()) {
     method->SetCode(Runtime::Current()->GetAbstractMethodErrorStubArray()->GetData());
@@ -1218,7 +1236,7 @@
 
   UniquePtr<const OatFile::OatClass> oat_class;
   if (Runtime::Current()->IsStarted() && !ClassLoader::UseCompileTimeClassPath()) {
-    const OatFile* oat_file = FindOatFile(dex_file);
+    const OatFile* oat_file = FindOatFileForDexFile(dex_file);
     if (oat_file != NULL) {
       const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
       if (oat_dex_file != NULL) {
@@ -1632,6 +1650,15 @@
 }
 
 bool ClassLinker::InsertClass(const std::string& descriptor, Class* klass, bool image_class) {
+  if (verbose_) {
+    DexCache* dex_cache = klass->GetDexCache();
+    std::string source;
+    if (dex_cache != NULL) {
+      source += " from ";
+      source += dex_cache->GetLocation()->ToModifiedUtf8();
+    }
+    LOG(INFO) << "Loaded class " << descriptor << source;
+  }
   size_t hash = StringPieceHash()(descriptor);
   MutexLock mu(classes_lock_);
   Table::iterator it;
@@ -1645,6 +1672,28 @@
   return ((*it).second == klass);
 }
 
+bool ClassLinker::RemoveClass(const std::string& descriptor, const ClassLoader* class_loader) {
+  size_t hash = StringPieceHash()(descriptor);
+  MutexLock mu(classes_lock_);
+  typedef Table::const_iterator It;  // TODO: C++0x auto
+  // TODO: determine if its better to search classes_ or image_classes_ first
+  for (It it = classes_.find(hash), end = classes_.end(); it != end; ++it) {
+    Class* klass = it->second;
+    if (klass->GetDescriptor()->Equals(descriptor) && klass->GetClassLoader() == class_loader) {
+      classes_.erase(it);
+      return true;
+    }
+  }
+  for (It it = image_classes_.find(hash), end = image_classes_.end(); it != end; ++it) {
+    Class* klass = it->second;
+    if (klass->GetDescriptor()->Equals(descriptor) && klass->GetClassLoader() == class_loader) {
+      image_classes_.erase(it);
+      return true;
+    }
+  }
+  return false;
+}
+
 Class* ClassLinker::LookupClass(const std::string& descriptor, const ClassLoader* class_loader) {
   size_t hash = StringPieceHash()(descriptor);
   MutexLock mu(classes_lock_);
@@ -1858,6 +1907,10 @@
       global_stats->class_init_time_ns += (t1 - t0);
       thread_stats->class_init_time_ns += (t1 - t0);
       klass->SetStatus(Class::kStatusInitialized);
+      if (verbose_) {
+        LOG(INFO) << "Initialized class " << klass->GetDescriptor()->ToModifiedUtf8()
+                  << " from " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
+      }
     }
     lock.NotifyAll();
   }
diff --git a/src/class_linker.h b/src/class_linker.h
index 5032d9f..d212c59 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -45,10 +45,10 @@
 class ClassLinker {
  public:
   // Creates the class linker by boot strapping from dex files.
-  static ClassLinker* Create(const std::string& boot_class_path, InternTable* intern_table);
+  static ClassLinker* Create(bool verbose, const std::string& boot_class_path, InternTable* intern_table);
 
   // Creates the class linker from one or more images.
-  static ClassLinker* Create(InternTable* intern_table);
+  static ClassLinker* Create(bool verbose, InternTable* intern_table);
 
   ~ClassLinker();
 
@@ -70,6 +70,10 @@
 
   Class* FindPrimitiveClass(char type);
 
+  // General class unloading is not supported, this is used to prune
+  // unwanted classes during image writing.
+  bool RemoveClass(const std::string& descriptor, const ClassLoader* class_loader);
+
   void DumpAllClasses(int flags) const;
 
   void DumpForSigQuit(std::ostream& os) const;
@@ -219,8 +223,8 @@
   const OatFile* GenerateOatFile(const std::string& filename);
 
   // Find, possibily opening, an OatFile corresponding to a DexFile
-  const OatFile* FindOatFile(const DexFile& dex_file);
-  const OatFile* FindOatFile(const std::string& location);
+  const OatFile* FindOatFileForDexFile(const DexFile& dex_file);
+  const OatFile* FindOatFileFromOatLocation(const std::string& location);
 
   // TODO: replace this with multiple methods that allocate the correct managed type.
   template <class T>
@@ -243,7 +247,7 @@
   pid_t GetDexLockOwner(); // For SignalCatcher.
 
  private:
-  explicit ClassLinker(InternTable*);
+  explicit ClassLinker(bool verbose, InternTable*);
 
   // Initialize class linker by bootstraping from dex files
   void Init(const std::string& boot_class_path);
@@ -354,11 +358,14 @@
     return dex_caches_;
   }
 
-  const OatFile* FindOpenedOatFile(const std::string& location);
+  const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file);
+  const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location);
 
   Method* CreateProxyConstructor(SirtRef<Class>& klass);
   Method* CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype, ObjectArray<Class>* throws);
 
+  const bool verbose_;
+
   std::vector<const DexFile*> boot_class_path_;
 
   std::vector<const DexFile*> dex_files_;
@@ -457,11 +464,11 @@
   InternTable* intern_table_;
 
   friend class CommonTest;
-  FRIEND_TEST(DexCacheTest, Open);
-  friend class ObjectTest;
-  FRIEND_TEST(ObjectTest, AllocObjectArray);
-  FRIEND_TEST(ExceptionTest, FindExceptionHandler);
   friend class ImageWriter;  // for GetClassRoots
+  friend class ObjectTest;
+  FRIEND_TEST(DexCacheTest, Open);
+  FRIEND_TEST(ExceptionTest, FindExceptionHandler);
+  FRIEND_TEST(ObjectTest, AllocObjectArray);
   DISALLOW_COPY_AND_ASSIGN(ClassLinker);
 };
 
diff --git a/src/common_test.h b/src/common_test.h
index f2a18e5..d140d40 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -97,6 +97,24 @@
     MakeExecutable(&code[0], code.size());
   }
 
+  // Create an OatMethod based on pointers (for unit tests)
+  OatFile::OatMethod CreateOatMethod(const void* code,
+                                     const size_t frame_size_in_bytes,
+                                     const uint32_t core_spill_mask,
+                                     const uint32_t fp_spill_mask,
+                                     const uint32_t* mapping_table,
+                                     const uint16_t* vmap_table,
+                                     const Method::InvokeStub* invoke_stub) {
+      return OatFile::OatMethod(NULL,
+                                reinterpret_cast<uint32_t>(code),
+                                frame_size_in_bytes,
+                                core_spill_mask,
+                                fp_spill_mask,
+                                reinterpret_cast<uint32_t>(mapping_table),
+                                reinterpret_cast<uint32_t>(vmap_table),
+                                reinterpret_cast<uint32_t>(invoke_stub));
+  }
+
   void MakeExecutable(Method* method) {
     CHECK(method != NULL);
 
@@ -123,26 +141,26 @@
       const void* method_code
           = CompiledMethod::CodePointer(&code[0], compiled_method->GetInstructionSet());
       LOG(INFO) << "MakeExecutable " << PrettyMethod(method) << " code=" << method_code;
-      OatFile::OatMethod oat_method(method_code,
-                                    compiled_method->GetFrameSizeInBytes(),
-                                    compiled_method->GetCoreSpillMask(),
-                                    compiled_method->GetFpSpillMask(),
-                                    &compiled_method->GetMappingTable()[0],
-                                    &compiled_method->GetVmapTable()[0],
-                                    method_invoke_stub);
-      oat_method.LinkMethod(method);
+      OatFile::OatMethod oat_method = CreateOatMethod(method_code,
+                                                      compiled_method->GetFrameSizeInBytes(),
+                                                      compiled_method->GetCoreSpillMask(),
+                                                      compiled_method->GetFpSpillMask(),
+                                                      &compiled_method->GetMappingTable()[0],
+                                                      &compiled_method->GetVmapTable()[0],
+                                                      method_invoke_stub);
+      oat_method.LinkMethodPointers(method);
     } else {
       MakeExecutable(runtime_->GetAbstractMethodErrorStubArray());
       const void* method_code = runtime_->GetAbstractMethodErrorStubArray()->GetData();
       LOG(INFO) << "MakeExecutable " << PrettyMethod(method) << " code=" << method_code;
-      OatFile::OatMethod oat_method(method_code,
-                                    kStackAlignment,
-                                    0,
-                                    0,
-                                    NULL,
-                                    NULL,
-                                    method_invoke_stub);
-      oat_method.LinkMethod(method);
+      OatFile::OatMethod oat_method = CreateOatMethod(method_code,
+                                                      kStackAlignment,
+                                                      0,
+                                                      0,
+                                                      NULL,
+                                                      NULL,
+                                                      method_invoke_stub);
+      oat_method.LinkMethodPointers(method);
     }
   }
 
@@ -221,7 +239,7 @@
             runtime_->CreateCalleeSaveMethod(instruction_set, type), type);
       }
     }
-    compiler_.reset(new Compiler(instruction_set, false));
+    compiler_.reset(new Compiler(instruction_set, false, NULL));
 
     Heap::VerifyHeap();  // Check for heap corruption before the test
   }
diff --git a/src/compiler.cc b/src/compiler.cc
index a3655c6..fba767d 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -35,12 +35,18 @@
   ByteArray* CreateJniDlysmLookupStub();
 }
 
-Compiler::Compiler(InstructionSet instruction_set, bool image)
+Compiler::Compiler(InstructionSet instruction_set,
+                   bool image,
+                   const std::set<std::string>* image_classes)
     : instruction_set_(instruction_set),
       jni_compiler_(instruction_set),
       image_(image),
+      image_classes_(image_classes),
       verbose_(false) {
   CHECK(!Runtime::Current()->IsStarted());
+  if (!image_) {
+    CHECK(image_classes_ == NULL);
+  }
 }
 
 Compiler::~Compiler() {
@@ -83,50 +89,62 @@
 }
 
 void Compiler::CompileAll(const ClassLoader* class_loader,
-    const std::vector<const DexFile*>& dex_files) {
+                          const std::vector<const DexFile*>& dex_files) {
   DCHECK(!Runtime::Current()->IsStarted());
-  for (size_t i = 0; i != dex_files.size(); ++i) {
-    ResolveDexFile(class_loader, *dex_files[i]);
-  }
-  for (size_t i = 0; i != dex_files.size(); ++i) {
-    VerifyDexFile(class_loader, *dex_files[i]);
-  }
-  for (size_t i = 0; i != dex_files.size(); ++i) {
-    InitializeClassesWithoutClinit(class_loader, *dex_files[i]);
-  }
-  for (size_t i = 0; i != dex_files.size(); ++i) {
-    CompileDexFile(class_loader, *dex_files[i]);
-  }
-  for (size_t i = 0; i != dex_files.size(); ++i) {
-    SetCodeAndDirectMethodsDexFile(*dex_files[i]);
-  }
+
+  PreCompile(class_loader, dex_files);
+  Compile(class_loader, dex_files);
+  PostCompile(class_loader, dex_files);
 }
 
 void Compiler::CompileOne(const Method* method) {
   DCHECK(!Runtime::Current()->IsStarted());
+
   const ClassLoader* class_loader = method->GetDeclaringClass()->GetClassLoader();
-  Resolve(class_loader);
-  Verify(class_loader);
-  InitializeClassesWithoutClinit(class_loader);
+
   // Find the dex_file
   const DexCache* dex_cache = method->GetDeclaringClass()->GetDexCache();
   const DexFile& dex_file = Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache);
+  std::vector<const DexFile*> dex_files;
+  dex_files.push_back(&dex_file);
+
+  PreCompile(class_loader, dex_files);
+
   uint32_t method_idx = method->GetDexMethodIndex();
   const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
   CompileMethod(code_item, method->GetAccessFlags(), method_idx, class_loader, dex_file);
-  SetCodeAndDirectMethods(class_loader);
+
+  PostCompile(class_loader, dex_files);
 }
 
-void Compiler::Resolve(const ClassLoader* class_loader) {
-  const std::vector<const DexFile*>& class_path
-      = ClassLoader::GetCompileTimeClassPath(class_loader);
-  for (size_t i = 0; i != class_path.size(); ++i) {
-    const DexFile* dex_file = class_path[i];
+void Compiler::Resolve(const ClassLoader* class_loader,
+                       const std::vector<const DexFile*>& dex_files) {
+  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);
   }
 }
 
+void Compiler::PreCompile(const ClassLoader* class_loader,
+                          const std::vector<const DexFile*>& dex_files) {
+  Resolve(class_loader, dex_files);
+  Verify(class_loader, dex_files);
+  InitializeClassesWithoutClinit(class_loader, dex_files);
+}
+
+void Compiler::PostCompile(const ClassLoader* class_loader,
+                           const std::vector<const DexFile*>& dex_files) {
+  SetCodeAndDirectMethods(dex_files);
+}
+
+bool Compiler::IsImageClass(const std::string& descriptor) const {
+  if (image_classes_ == NULL) {
+    return true;
+  }
+  return image_classes_->find(descriptor) != image_classes_->end();
+}
+
 // 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
@@ -157,8 +175,10 @@
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   DexCache* dex_cache = class_linker->FindDexCache(dex_file);
 
-  // Strings are easy, they always are simply resolved to literals in the same file
-  if (IsImage()) {  // Only resolve when we'll have an image, so compiler won't choose fast path
+  // Strings are easy in that they always are simply resolved to literals in the same file
+  if (image_ && image_classes_ == NULL) {
+    // TODO: Add support for loading strings referenced by image_classes_
+    // See also Compiler::CanAssumeTypeIsPresentInDexCache.
     for (size_t string_idx = 0; string_idx < dex_cache->NumStrings(); string_idx++) {
       class_linker->ResolveString(dex_file, string_idx, dex_cache);
     }
@@ -235,11 +255,10 @@
   }
 }
 
-void Compiler::Verify(const ClassLoader* class_loader) {
-  const std::vector<const DexFile*>& class_path
-      = ClassLoader::GetCompileTimeClassPath(class_loader);
-  for (size_t i = 0; i != class_path.size(); ++i) {
-    const DexFile* dex_file = class_path[i];
+void Compiler::Verify(const ClassLoader* class_loader,
+                      const std::vector<const DexFile*>& dex_files) {
+  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);
   }
@@ -275,11 +294,10 @@
   dex_file.ChangePermissions(PROT_READ);
 }
 
-void Compiler::InitializeClassesWithoutClinit(const ClassLoader* class_loader) {
-  const std::vector<const DexFile*>& class_path
-      = ClassLoader::GetCompileTimeClassPath(class_loader);
-  for (size_t i = 0; i != class_path.size(); ++i) {
-    const DexFile* dex_file = class_path[i];
+void Compiler::InitializeClassesWithoutClinit(const ClassLoader* class_loader,
+                                              const std::vector<const DexFile*>& dex_files) {
+  for (size_t i = 0; i != dex_files.size(); ++i) {
+    const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
     InitializeClassesWithoutClinit(class_loader, *dex_file);
   }
@@ -309,11 +327,10 @@
   }
 }
 
-void Compiler::Compile(const ClassLoader* class_loader) {
-  const std::vector<const DexFile*>& class_path
-      = ClassLoader::GetCompileTimeClassPath(class_loader);
-  for (size_t i = 0; i != class_path.size(); ++i) {
-    const DexFile* dex_file = class_path[i];
+void Compiler::Compile(const ClassLoader* class_loader,
+                       const std::vector<const DexFile*>& dex_files) {
+  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);
   }
@@ -410,7 +427,7 @@
 }
 
 const CompiledInvokeStub* Compiler::FindInvokeStub(bool is_static, const char* shorty) const {
-  std::string key = MakeInvokeStubKey(is_static, shorty);
+  const std::string key = MakeInvokeStubKey(is_static, shorty);
   InvokeStubTable::const_iterator it = compiled_invoke_stubs_.find(key);
   if (it == compiled_invoke_stubs_.end()) {
     return NULL;
@@ -435,11 +452,9 @@
   return it->second;
 }
 
-void Compiler::SetCodeAndDirectMethods(const ClassLoader* class_loader) {
-  const std::vector<const DexFile*>& class_path
-      = ClassLoader::GetCompileTimeClassPath(class_loader);
-  for (size_t i = 0; i != class_path.size(); ++i) {
-    const DexFile* dex_file = class_path[i];
+void Compiler::SetCodeAndDirectMethods(const std::vector<const DexFile*>& dex_files) {
+  for (size_t i = 0; i != dex_files.size(); ++i) {
+    const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
     SetCodeAndDirectMethodsDexFile(*dex_file);
   }
diff --git a/src/compiler.h b/src/compiler.h
index a8ea205..5203ffb 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -13,6 +13,7 @@
 #include "runtime.h"
 #include "unordered_map.h"
 
+#include <set>
 #include <string>
 
 namespace art {
@@ -20,13 +21,18 @@
 class Compiler {
  public:
   // Create a compiler targeting the requested "instruction_set".
-  // "image" should be true if image specific optimizations should be enabled.
-  explicit Compiler(InstructionSet instruction_set, bool image);
+  // "image" should be true if image specific optimizations should be
+  // enabled.  "image_classes" lets the compiler know what classes it
+  // can assume will be in the image, with NULL implying all available
+  // classes.
+  explicit Compiler(InstructionSet instruction_set,
+                    bool image,
+                    const std::set<std::string>* image_classes);
 
   ~Compiler();
 
   void CompileAll(const ClassLoader* class_loader,
-                  const std::vector<const DexFile*>& class_path);
+                  const std::vector<const DexFile*>& dex_files);
 
   // Compile a single Method
   void CompileOne(const Method* method);
@@ -65,20 +71,29 @@
 
   // Callbacks from OAT/ART compiler to see what runtime checks must be generated
   bool CanAssumeTypeIsPresentInDexCache(const DexCache* dex_cache, uint32_t type_idx) const {
-    return IsImage() && dex_cache->GetResolvedTypes()->Get(type_idx) != NULL;
+    if (!IsImage()) {
+      return false;
+    }
+    Class* resolved_class = dex_cache->GetResolvedTypes()->Get(type_idx);
+    if (resolved_class == NULL) {
+      return false;
+    }
+    return IsImageClass(resolved_class->GetDescriptor()->ToModifiedUtf8());
   }
   bool CanAssumeStringIsPresentInDexCache(const DexCache* dex_cache, uint32_t string_idx) const {
-    return IsImage() && dex_cache->GetStrings()->Get(string_idx) != NULL;
+    // TODO: Add support for loading strings referenced by image_classes_
+    // See also Compiler::ResolveDexFile
+    return IsImage() && image_classes_ == NULL && dex_cache->GetResolvedString(string_idx) != NULL;
   }
   bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexCache* dex_cache,
                                   const DexFile& dex_file, uint32_t type_idx) const {
-    Class* resolved_class = dex_cache->GetResolvedTypes()->Get(type_idx);
+    Class* resolved_class = dex_cache->GetResolvedType(type_idx);
     // We should never ask whether a type needs access checks to raise a verification error,
     // all other cases where this following test could fail should have been rewritten by the
     // verifier to verification errors. Also need to handle a lack of knowledge at compile time.
 #ifndef NDEBUG
-    Class* referrer_class = dex_cache->GetResolvedTypes()
-        ->Get(dex_file.GetMethodId(referrer_idx).class_idx_);
+    const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
+    Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
     DCHECK(resolved_class == NULL || referrer_class == NULL ||
            referrer_class->CanAccess(resolved_class));
 #endif
@@ -86,19 +101,27 @@
   }
 
  private:
+
+  // Checks if class specified by type_idx is one of the image_classes_
+  bool IsImageClass(const std::string& descriptor) const;
+
+  void PreCompile(const ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files);
+  void PostCompile(const ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files);
+
   // Attempt to resolve all type, methods, fields, and strings
   // referenced from code in the dex file following PathClassLoader
   // ordering semantics.
-  void Resolve(const ClassLoader* class_loader);
+  void Resolve(const ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files);
   void ResolveDexFile(const ClassLoader* class_loader, const DexFile& dex_file);
 
-  void Verify(const ClassLoader* class_loader);
+  void Verify(const ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files);
   void VerifyDexFile(const ClassLoader* class_loader, const DexFile& dex_file);
 
-  void InitializeClassesWithoutClinit(const ClassLoader* class_loader);
+  void InitializeClassesWithoutClinit(const ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files);
   void InitializeClassesWithoutClinit(const ClassLoader* class_loader, const DexFile& dex_file);
 
-  void Compile(const ClassLoader* class_loader);
+  void Compile(const ClassLoader* class_loader,
+               const std::vector<const DexFile*>& dex_files);
   void CompileDexFile(const ClassLoader* class_loader, const DexFile& dex_file);
   void CompileClass(const DexFile::ClassDef& class_def, const ClassLoader* class_loader,
                     const DexFile& dex_file);
@@ -107,7 +130,7 @@
 
   // After compiling, walk all the DexCaches and set the code and
   // method pointers of CodeAndDirectMethods entries in the DexCaches.
-  void SetCodeAndDirectMethods(const ClassLoader* class_loader);
+  void SetCodeAndDirectMethods(const std::vector<const DexFile*>& dex_files);
   void SetCodeAndDirectMethodsDexFile(const DexFile& dex_file);
 
   void InsertInvokeStub(bool is_static, const char* shorty,
@@ -139,6 +162,8 @@
 
   bool image_;
 
+  const std::set<std::string>* image_classes_;
+
   bool verbose_;
 
   DISALLOW_COPY_AND_ASSIGN(Compiler);
diff --git a/src/dalvik_system_DexFile.cc b/src/dalvik_system_DexFile.cc
index 6ad92ba..cf4443b 100644
--- a/src/dalvik_system_DexFile.cc
+++ b/src/dalvik_system_DexFile.cc
@@ -222,7 +222,7 @@
     return JNI_TRUE;
   }
 
-  const OatFile* oat_file = class_linker->FindOatFile(*dex_file.get());
+  const OatFile* oat_file = class_linker->FindOatFileForDexFile(*dex_file.get());
   if (oat_file == NULL) {
     return JNI_TRUE;
   }
diff --git a/src/dex2oat.cc b/src/dex2oat.cc
index 231ca9c..0e4c224 100644
--- a/src/dex2oat.cc
+++ b/src/dex2oat.cc
@@ -4,6 +4,8 @@
 #include <stdlib.h>
 #include <sys/file.h>
 
+#include <iostream>
+#include <fstream>
 #include <string>
 #include <vector>
 
@@ -29,13 +31,16 @@
           "      Example: --dex-file=/system/framework/core.jar\n"
           "\n");
   fprintf(stderr,
-          "  --image=<file.art>: specifies the required output image filename.\n"
+          "  --oat=<file.oat>: specifies the required oat filename.\n"
+          "      Example: --oat=/data/art-cache/boot.oat\n"
+          "\n");
+  fprintf(stderr,
+          "  --image=<file.art>: specifies the output image filename.\n"
           "      Example: --image=/data/art-cache/boot.art\n"
           "\n");
-  // TODO: remove this by inferring from --image
   fprintf(stderr,
-          "  --oat=<file.oat>: specifies the required oat filename.\n"
-          "      Example: --image=/data/art-cache/boot.oat\n"
+          "  --image-classes=<classname-file>: specifies classes to include in an image.\n"
+          "      Example: --image=frameworks/base/preloaded-classes\n"
           "\n");
   fprintf(stderr,
           "  --base=<hex-address>: specifies the base address when creating a boot image.\n"
@@ -46,10 +51,6 @@
           "      Example: --boot-image=/data/art-cache/boot.art\n"
           "\n");
   fprintf(stderr,
-          "  --method may be used to limit compilation to a subset of methods.\n"
-          "      Example: --method=Ljava/lang/Object;<init>()V\n"
-          "\n");
-  fprintf(stderr,
           "  --host-prefix may be used to translate host paths to target paths during\n"
           "      cross compilation.\n"
           "      Example: --host-prefix=out/target/product/crespo\n"
@@ -94,33 +95,190 @@
   bool do_unlink_;
 };
 
-// Returns true if dex_files has a dex with the named location.
-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) {
+class Dex2Oat {
+ public:
+
+  static Dex2Oat* Create(Runtime::Options& options) {
+    UniquePtr<Runtime> runtime(CreateRuntime(options));
+    if (runtime.get() == NULL) {
+      return NULL;
+    }
+    return new Dex2Oat(runtime.release());
+  }
+
+  ~Dex2Oat() {
+    delete runtime_;
+  }
+
+  // Make a list of descriptors for classes to include in the image
+  const std::set<std::string>* GetImageClassDescriptors(const char* image_classes_filename) {
+    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;
+    }
+
+    // Load all the classes specifed in the file
+    ClassLinker* class_linker = runtime_->GetClassLinker();
+    while (image_classes_file->good()) {
+      std::string dot;
+      std::getline(*image_classes_file.get(), dot);
+      if (StringPiece(dot).starts_with("#") || dot.empty()) {
+        continue;
+      }
+      std::string descriptor = DotToDescriptor(dot.c_str());
+      SirtRef<Class> klass(class_linker->FindSystemClass(descriptor));
+      if (klass.get() == NULL) {
+        LOG(WARNING) << "Failed to find class " << descriptor;
+        Thread::Current()->ClearException();
+      }
+    }
+    image_classes_file->close();
+
+    // 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.
+    UniquePtr<std::set<std::string> > image_classes(new std::set<std::string>());
+    class_linker->VisitClasses(ClassVisitor, image_classes.get());
+    CHECK_NE(image_classes->size(), 0U);
+    return image_classes.release();
+  }
+
+  bool CreateOatFile(const std::string& boot_image_option,
+                     const std::vector<const char*>& dex_filenames,
+                     const std::string& host_prefix,
+                     File* oat_file,
+                     bool image,
+                     const std::set<std::string>* image_classes) {
+    // SirtRef and ClassLoader creation needs to come after Runtime::Create
+    UniquePtr<SirtRef<ClassLoader> > class_loader(new SirtRef<ClassLoader>(NULL));
+    if (class_loader.get() == NULL) {
+      LOG(ERROR) << "Failed to create SirtRef for class loader";
+      return false;
+    }
+
+    std::vector<const DexFile*> dex_files;
+    if (!boot_image_option.empty()) {
+      ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+      DexFile::OpenDexFiles(dex_filenames, dex_files, host_prefix);
+      std::vector<const DexFile*> class_path_files(dex_files);
+      OpenClassPathFiles(runtime_->GetClassPath(), class_path_files);
+      for (size_t i = 0; i < class_path_files.size(); i++) {
+        class_linker->RegisterDexFile(*class_path_files[i]);
+      }
+      class_loader.get()->reset(PathClassLoader::AllocCompileTime(class_path_files));
+    } else {
+      dex_files = runtime_->GetClassLinker()->GetBootClassPath();
+    }
+
+    Compiler compiler(instruction_set_, image, image_classes);
+    compiler.CompileAll(class_loader->get(), dex_files);
+
+    if (!OatWriter::Create(oat_file, class_loader->get(), compiler)) {
+      LOG(ERROR) << "Failed to create oat file " << oat_file->name();
+      return false;
+    }
+    return true;
+  }
+
+  bool CreateImageFile(const char* image_filename,
+                       uintptr_t image_base,
+                       const std::set<std::string>* image_classes,
+                       const std::string& oat_filename,
+                       const std::string& host_prefix) {
+    // If we have an existing boot image, position new space after its oat file
+    if (Heap::GetSpaces().size() > 1) {
+      Space* last_image_space = Heap::GetSpaces()[Heap::GetSpaces().size()-2];
+      CHECK(last_image_space != NULL);
+      CHECK(last_image_space->IsImageSpace());
+      CHECK(!Heap::GetSpaces()[Heap::GetSpaces().size()-1]->IsImageSpace());
+      byte* oat_limit_addr = last_image_space->GetImageHeader().GetOatLimitAddr();
+      image_base = RoundUp(reinterpret_cast<uintptr_t>(oat_limit_addr), kPageSize);
+    }
+
+    ImageWriter image_writer(image_classes);
+    if (!image_writer.Write(image_filename, image_base, oat_filename, host_prefix)) {
+      LOG(ERROR) << "Failed to create image file " << image_filename;
+      return false;
+    }
+    return true;
+  }
+
+ private:
+
+  Dex2Oat(Runtime* runtime) : runtime_(runtime) {}
+
+  static Runtime* CreateRuntime(Runtime::Options& options) {
+    Runtime* runtime = Runtime::Create(options, false);
+    if (runtime == NULL) {
+      LOG(ERROR) << "Failed to create runtime";
+      return NULL;
+    }
+
+    // if we loaded an existing image, we will reuse values from the image roots.
+    if (!runtime->HasJniDlsymLookupStub()) {
+      runtime->SetJniDlsymLookupStub(Compiler::CreateJniDlysmLookupStub(instruction_set_));
+    }
+    if (!runtime->HasAbstractMethodErrorStubArray()) {
+      runtime->SetAbstractMethodErrorStubArray(Compiler::CreateAbstractMethodErrorStub(instruction_set_));
+    }
+    for (int i = 0; i < Runtime::kLastTrampolineMethodType; i++) {
+      Runtime::TrampolineType type = Runtime::TrampolineType(i);
+      if (!runtime->HasResolutionStubArray(type)) {
+        runtime->SetResolutionStubArray(Compiler::CreateResolutionStub(instruction_set_, type), type);
+      }
+    }
+    for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
+      Runtime::CalleeSaveType type = Runtime::CalleeSaveType(i);
+      if (!runtime->HasCalleeSaveMethod(type)) {
+        runtime->SetCalleeSaveMethod(runtime->CreateCalleeSaveMethod(instruction_set_, type), type);
+      }
+    }
+    return runtime;
+  }
+
+  static bool ClassVisitor(Class* klass, void* arg) {
+    std::set<std::string>* image_classes = reinterpret_cast<std::set<std::string>*>(arg);
+    if (klass->IsArrayClass() || klass->IsPrimitive()) {
       return true;
     }
+    image_classes->insert(klass->GetDescriptor()->ToModifiedUtf8());
+    return true;
   }
-  return false;
-}
 
-// Appends to dex_files any elements of class_path that it doesn't already
-// contain. This will open those dex files as necessary.
-void OpenClassPathFiles(const std::string& class_path, std::vector<const DexFile*>& dex_files) {
-  std::vector<std::string> parsed;
-  Split(class_path, ':', parsed);
-  for (size_t i = 0; i < parsed.size(); ++i) {
-    if (DexFilesContains(dex_files, parsed[i])) {
-      continue;
-    }
-    const DexFile* dex_file = DexFile::Open(parsed[i], Runtime::Current()->GetHostPrefix());
-    if (dex_file == NULL) {
-      LOG(WARNING) << "Failed to open dex file " << parsed[i];
-    } else {
-      dex_files.push_back(dex_file);
+  // 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) {
+    std::vector<std::string> parsed;
+    Split(class_path, ':', parsed);
+    for (size_t i = 0; i < parsed.size(); ++i) {
+      if (DexFilesContains(dex_files, parsed[i])) {
+        continue;
+      }
+      const DexFile* dex_file = DexFile::Open(parsed[i], Runtime::Current()->GetHostPrefix());
+      if (dex_file == NULL) {
+        LOG(WARNING) << "Failed to open dex file " << parsed[i];
+      } else {
+        dex_files.push_back(dex_file);
+      }
     }
   }
-}
+
+  // 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) {
+    for (size_t i = 0; i < dex_files.size(); ++i) {
+      if (dex_files[i]->GetLocation() == location) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  Runtime* runtime_;
+  static const InstructionSet instruction_set_ = kThumb2;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(Dex2Oat);
+};
 
 int dex2oat(int argc, char** argv) {
   // Skip over argv[0].
@@ -133,9 +291,9 @@
   }
 
   std::vector<const char*> dex_filenames;
-  std::vector<const char*> method_names;
   std::string oat_filename;
   const char* image_filename = NULL;
+  const char* image_classes_filename = NULL;
   std::string boot_image_option;
   uintptr_t image_base = 0;
   std::string host_prefix;
@@ -148,12 +306,12 @@
     }
     if (option.starts_with("--dex-file=")) {
       dex_filenames.push_back(option.substr(strlen("--dex-file=")).data());
-    } else if (option.starts_with("--method=")) {
-      method_names.push_back(option.substr(strlen("--method=")).data());
     } else if (option.starts_with("--oat=")) {
       oat_filename = option.substr(strlen("--oat=")).data();
     } else if (option.starts_with("--image=")) {
       image_filename = option.substr(strlen("--image=")).data();
+    } else if (option.starts_with("--image-classes=")) {
+      image_classes_filename = option.substr(strlen("--image-classes=")).data();
     } else if (option.starts_with("--base=")) {
       const char* image_base_str = option.substr(strlen("--base=")).data();
       char* end;
@@ -181,18 +339,24 @@
     }
   }
 
-  if (oat_filename == NULL) {
+  if (oat_filename.empty()) {
     fprintf(stderr, "--oat file name not specified\n");
     return EXIT_FAILURE;
   }
 
-  if (image_filename == NULL && boot_image_option.empty()) {
+  bool image = (image_filename != NULL);
+  if (!image && boot_image_option.empty()) {
     fprintf(stderr, "Either --image or --boot-image must be specified\n");
     return EXIT_FAILURE;
   }
 
-  if (dex_filenames.empty()) {
-    fprintf(stderr, "no --dex-file values specified\n");
+  if (image_classes_filename != NULL && !image) {
+    fprintf(stderr, "--image-classes should only be used with --image\n");
+    return EXIT_FAILURE;
+  }
+
+  if (image_classes_filename != NULL && !boot_image_option.empty()) {
+    fprintf(stderr, "--image-classes should not be used with --boot-image\n");
     return EXIT_FAILURE;
   }
 
@@ -220,7 +384,7 @@
   }
 
   // Handles removing the file on failure and unlocking on both failure and success.
-  FileJanitor file_janitor(oat_filename, fd);
+  FileJanitor oat_file_janitor(oat_filename, fd);
 
   // If we won the creation race, block trying to take the lock (since we're going to be doing
   // the work, we need the lock). If we lost the creation race, spin trying to take the lock
@@ -252,7 +416,7 @@
     // TODO: check the creator did a good job by checking the header.
     LOG(INFO) << "Another process finished working on " << oat_filename;
     // Job done.
-    file_janitor.KeepFile();
+    oat_file_janitor.KeepFile();
     return EXIT_SUCCESS;
   }
 
@@ -281,122 +445,47 @@
   for (size_t i = 0; i < runtime_args.size(); i++) {
     options.push_back(std::make_pair(runtime_args[i], reinterpret_cast<void*>(NULL)));
   }
-  UniquePtr<Runtime> runtime(Runtime::Create(options, false));
-  if (runtime.get() == NULL) {
-    LOG(ERROR) << "Could not create runtime";
-    return EXIT_FAILURE;
-  }
-  ClassLinker* class_linker = runtime->GetClassLinker();
 
-  // If we have an existing boot image, position new space after its oat file
-  if (Heap::GetSpaces().size() > 1) {
-    Space* last_image_space = Heap::GetSpaces()[Heap::GetSpaces().size()-2];
-    CHECK(last_image_space != NULL);
-    CHECK(last_image_space->IsImageSpace());
-    CHECK(!Heap::GetSpaces()[Heap::GetSpaces().size()-1]->IsImageSpace());
-    byte* oat_limit_addr = last_image_space->GetImageHeader().GetOatLimitAddr();
-    image_base = RoundUp(reinterpret_cast<uintptr_t>(oat_limit_addr), kPageSize);
-  }
+  UniquePtr<Dex2Oat> dex2oat(Dex2Oat::Create(options));
 
-  // ClassLoader creation needs to come after Runtime::Create
-  SirtRef<ClassLoader> class_loader(NULL);
-  std::vector<const DexFile*> dex_files;
-  if (!boot_image_option.empty()) {
-    DexFile::OpenDexFiles(dex_filenames, dex_files, host_prefix);
-    std::vector<const DexFile*> class_path_files(dex_files);
-    OpenClassPathFiles(runtime->GetClassPath(), class_path_files);
-    for (size_t i = 0; i < class_path_files.size(); i++) {
-      class_linker->RegisterDexFile(*class_path_files[i]);
-    }
-    class_loader.reset(PathClassLoader::AllocCompileTime(class_path_files));
-  } else {
-    dex_files = runtime->GetClassLinker()->GetBootClassPath();
-  }
-
-  // if we loaded an existing image, we will reuse values from the image roots.
-  if (!runtime->HasJniDlsymLookupStub()) {
-    runtime->SetJniDlsymLookupStub(Compiler::CreateJniDlysmLookupStub(kThumb2));
-  }
-  if (!runtime->HasAbstractMethodErrorStubArray()) {
-    runtime->SetAbstractMethodErrorStubArray(Compiler::CreateAbstractMethodErrorStub(kThumb2));
-  }
-  for (int i = 0; i < Runtime::kLastTrampolineMethodType; i++) {
-    Runtime::TrampolineType type = Runtime::TrampolineType(i);
-    if (!runtime->HasResolutionStubArray(type)) {
-      runtime->SetResolutionStubArray(Compiler::CreateResolutionStub(kThumb2, type), type);
-    }
-  }
-  for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
-    Runtime::CalleeSaveType type = Runtime::CalleeSaveType(i);
-    if (!runtime->HasCalleeSaveMethod(type)) {
-      runtime->SetCalleeSaveMethod(runtime->CreateCalleeSaveMethod(kThumb2, type), type);
-    }
-  }
-  Compiler compiler(kThumb2, image_filename != NULL);
-  if (method_names.empty()) {
-    compiler.CompileAll(class_loader.get(), dex_files);
-  } else {
-    for (size_t i = 0; i < method_names.size(); i++) {
-      // names are actually class_descriptor + name + signature.
-      // example: Ljava/lang/Object;<init>()V
-      StringPiece method_name = method_names[i];
-      size_t end_of_class_descriptor = method_name.find(';');
-      if (end_of_class_descriptor == method_name.npos) {
-        LOG(ERROR) << "Could not find class descriptor in method " << method_name << "'";
-        return EXIT_FAILURE;
-      }
-      end_of_class_descriptor++;  // want to include ;
-      std::string class_descriptor = method_name.substr(0, end_of_class_descriptor).ToString();
-      size_t end_of_name = method_name.find('(', end_of_class_descriptor);
-      if (end_of_name == method_name.npos) {
-        LOG(ERROR) << "Could not find start of method signature in method '" << method_name << "'";
-        return EXIT_FAILURE;
-      }
-      std::string name = method_name.substr(end_of_class_descriptor,
-                                            end_of_name - end_of_class_descriptor).ToString();
-      std::string signature = method_name.substr(end_of_name).ToString();
-
-      Class* klass = class_linker->FindClass(class_descriptor, class_loader.get());
-      if (klass == NULL) {
-        LOG(ERROR) << "Could not find class for descriptor '" << class_descriptor
-            << "' in method '" << method_name << "'";
-        return EXIT_FAILURE;
-      }
-      Method* method = klass->FindDirectMethod(name, signature);
-      if (method == NULL) {
-          method = klass->FindVirtualMethod(name, signature);
-      }
-      if (method == NULL) {
-        LOG(ERROR) << "Could not find method '" << method_name << "' with signature '"
-            << signature << "' in class '" << class_descriptor << "' for method argument '"
-            << method_name << "'";
-        return EXIT_FAILURE;
-      }
-      compiler.CompileOne(method);
+  // If --image-classes was specified, calculate the full list classes to include in the image
+  UniquePtr<const std::set<std::string> > image_classes(NULL);
+  if (image_classes_filename != NULL) {
+    image_classes.reset(dex2oat->GetImageClassDescriptors(image_classes_filename));
+    if (image_classes.get() == NULL) {
+      LOG(ERROR) << "Failed to create list of image classes from " << image_classes_filename;
+      return EXIT_FAILURE;
     }
   }
 
-  if (!OatWriter::Create(oat_file.get(), class_loader.get(), compiler)) {
-    LOG(ERROR) << "Failed to create oat file " << oat_file->name();
+  if (!dex2oat->CreateOatFile(boot_image_option,
+                              dex_filenames,
+                              host_prefix,
+                              oat_file.get(),
+                              image,
+                              image_classes.get())) {
+    LOG(ERROR) << "Failed to create oat file" << oat_filename;
     return EXIT_FAILURE;
   }
 
-  if (image_filename == NULL) {
-    file_janitor.KeepFile();
-    LOG(INFO) << "Oat file written successfully " << oat_file->name();
+  if (!image) {
+    oat_file_janitor.KeepFile();
+    LOG(INFO) << "Oat file written successfully " << oat_filename;
     return EXIT_SUCCESS;
   }
-  CHECK(compiler.IsImage());
 
-  ImageWriter image_writer;
-  if (!image_writer.Write(image_filename, image_base, oat_file->name(), host_prefix)) {
-    LOG(ERROR) << "Failed to create image file " << image_filename;
+  if (!dex2oat->CreateImageFile(image_filename,
+                                image_base,
+                                image_classes.get(),
+                                oat_filename,
+                                host_prefix)) {
     return EXIT_FAILURE;
   }
 
-  // We wrote the file successfully, and want to keep it.
+  // We wrote the oat file successfully, and want to keep it.
+  oat_file_janitor.KeepFile();
+  LOG(INFO) << "Oat file written successfully " << oat_filename;
   LOG(INFO) << "Image written successfully " << image_filename;
-  file_janitor.KeepFile();
   return EXIT_SUCCESS;
 }
 
diff --git a/src/dex_file.cc b/src/dex_file.cc
index 208479e..d7517c4 100644
--- a/src/dex_file.cc
+++ b/src/dex_file.cc
@@ -45,7 +45,7 @@
                         reinterpret_cast<const DexFile::ClassDef*>(NULL));
 }
 
-void DexFile::OpenDexFiles(std::vector<const char*>& dex_filenames,
+void DexFile::OpenDexFiles(const std::vector<const char*>& dex_filenames,
                            std::vector<const DexFile*>& dex_files,
                            const std::string& strip_location_prefix) {
   for (size_t i = 0; i < dex_filenames.size(); i++) {
diff --git a/src/dex_file.h b/src/dex_file.h
index 92aa794..a7026d6 100644
--- a/src/dex_file.h
+++ b/src/dex_file.h
@@ -176,7 +176,7 @@
                                         const ClassPath& class_path);
 
   // Opens a collection of .dex files
-  static void OpenDexFiles(std::vector<const char*>& dex_filenames,
+  static void OpenDexFiles(const std::vector<const char*>& dex_filenames,
                            std::vector<const DexFile*>& dex_files,
                            const std::string& strip_location_prefix);
 
diff --git a/src/image_test.cc b/src/image_test.cc
index 812b281..6901482 100644
--- a/src/image_test.cc
+++ b/src/image_test.cc
@@ -29,7 +29,7 @@
     EXPECT_TRUE(klass != NULL) << descriptor;
   }
 
-  ImageWriter writer;
+  ImageWriter writer(NULL);
   ScratchFile tmp_image;
   const uintptr_t requested_image_base = 0x60000000;
   bool success_image = writer.Write(tmp_image.GetFilename(), requested_image_base,
diff --git a/src/image_writer.cc b/src/image_writer.cc
index cdb7bd0..adc7b78 100644
--- a/src/image_writer.cc
+++ b/src/image_writer.cc
@@ -9,6 +9,7 @@
 #include "UniquePtr.h"
 #include "class_linker.h"
 #include "class_loader.h"
+#include "compiled_method.h"
 #include "dex_cache.h"
 #include "file.h"
 #include "globals.h"
@@ -23,8 +24,10 @@
 
 namespace art {
 
-bool ImageWriter::Write(const char* image_filename, uintptr_t image_base,
-                        const std::string& oat_filename, const std::string& strip_location_prefix) {
+bool ImageWriter::Write(const char* image_filename,
+                        uintptr_t image_base,
+                        const std::string& oat_filename,
+                        const std::string& strip_location_prefix) {
   CHECK(image_filename != NULL);
 
   CHECK_NE(image_base, 0U);
@@ -36,16 +39,29 @@
   source_space_ = spaces[spaces.size()-1];
   CHECK(!source_space_->IsImageSpace());
 
+  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];
+    if (InSourceSpace(dex_cache)) {
+      dex_caches_.insert(dex_cache);
+    }
+  }
+
   oat_file_.reset(OatFile::Open(oat_filename, strip_location_prefix, NULL));
   if (oat_file_.get() == NULL) {
     LOG(ERROR) << "Failed to open oat file " << oat_filename;
     return false;
   }
 
-  if (!Init()) {
+  if (!AllocMemory()) {
     return false;
   }
+  PruneNonImageClasses();
   Heap::CollectGarbage();
+#ifndef NDEBUG
+  CheckNonImageClassesRemoved();
+#endif
   Heap::DisableCardMarking();
   CalculateNewObjectOffsets();
   CopyAndFixupObjects();
@@ -63,7 +79,7 @@
   return true;
 }
 
-bool ImageWriter::Init() {
+bool ImageWriter::AllocMemory() {
   size_t size = source_space_->Size();
   int prot = PROT_READ | PROT_WRITE;
   size_t length = RoundUp(size, kPageSize);
@@ -75,6 +91,96 @@
   return true;
 }
 
+bool ImageWriter::IsImageClass(const Class* klass) {
+  if (image_classes_ == NULL) {
+    return true;
+  }
+  while (klass->IsArrayClass()) {
+    klass = klass->GetComponentType();
+  }
+  if (klass->IsPrimitive()) { 
+    return true;
+  }
+  const std::string descriptor = klass->GetDescriptor()->ToModifiedUtf8();
+  return image_classes_->find(descriptor) != image_classes_->end();
+}
+
+
+struct NonImageClasses {
+  ImageWriter* image_writer;
+  std::set<std::string>* non_image_classes;
+};
+
+void ImageWriter::PruneNonImageClasses() {
+  if (image_classes_ == NULL) {
+    return;
+  }
+  Runtime* runtime = Runtime::Current();
+  ClassLinker* class_linker = runtime->GetClassLinker();
+
+  std::set<std::string> non_image_classes;
+  NonImageClasses context;
+  context.image_writer = this;
+  context.non_image_classes = &non_image_classes;
+  class_linker->VisitClasses(NonImageClassesVisitor, &context);
+
+  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, NULL);
+  }
+
+  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 (size_t i = 0; i < dex_cache->NumResolvedTypes(); i++) {
+      Class* klass = dex_cache->GetResolvedType(i);
+      if (klass != NULL && !IsImageClass(klass)) {
+        dex_cache->SetResolvedType(i, NULL);
+        dex_cache->GetInitializedStaticStorage()->Set(i, NULL);
+      }
+    }
+    for (size_t i = 0; i < dex_cache->NumResolvedMethods(); i++) {
+      Method* method = dex_cache->GetResolvedMethod(i);
+      if (method != NULL && !IsImageClass(method->GetDeclaringClass())) {
+        dex_cache->SetResolvedMethod(i, NULL);
+        Runtime::TrampolineType type = Runtime::GetTrampolineType(method);
+        ByteArray* res_trampoline = runtime->GetResolutionStubArray(type);
+        dex_cache->GetCodeAndDirectMethods()->SetResolvedDirectMethodTrampoline(i, res_trampoline);
+      }
+    }
+    for (size_t i = 0; i < dex_cache->NumResolvedFields(); i++) {
+      Field* field = dex_cache->GetResolvedField(i);
+      if (field != NULL && !IsImageClass(field->GetDeclaringClass())) {
+        dex_cache->SetResolvedField(i, NULL);
+      }
+    }
+  }
+}
+
+bool ImageWriter::NonImageClassesVisitor(Class* klass, void* arg) {
+  NonImageClasses* context = reinterpret_cast<NonImageClasses*>(arg);
+  if (!context->image_writer->IsImageClass(klass)) {
+    context->non_image_classes->insert(klass->GetDescriptor()->ToModifiedUtf8());
+  }
+  return true;
+}
+
+void ImageWriter::CheckNonImageClassesRemoved() {
+  if (image_classes_ == NULL) {
+    return;
+  }
+  Heap::GetLiveBits()->Walk(CheckNonImageClassesRemovedCallback, this);
+}
+
+void ImageWriter::CheckNonImageClassesRemovedCallback(Object* obj, void* arg) {
+  ImageWriter* image_writer = reinterpret_cast<ImageWriter*>(arg);
+  if (!obj->IsClass()) {
+    return;
+  }
+  Class* klass = obj->AsClass();
+  CHECK(image_writer->IsImageClass(klass)) << klass->GetDescriptor()->ToModifiedUtf8();
+}
+
 void ImageWriter::CalculateNewObjectOffsetsCallback(Object* obj, void* arg) {
   DCHECK(obj != NULL);
   DCHECK(arg != NULL);
@@ -104,17 +210,6 @@
   }
 
   image_writer->AssignImageOffset(obj);
-
-  // sniff out the DexCaches on this pass for use on the next pass
-  if (obj->IsClass()) {
-    Class* klass = obj->AsClass();
-    DexCache* dex_cache = klass->GetDexCache();
-    if (dex_cache != NULL) {
-      image_writer->dex_caches_.insert(dex_cache);
-    } else {
-      DCHECK(klass->IsArrayClass() || klass->IsPrimitive()) << PrettyClass(klass);
-    }
-  }
 }
 
 ObjectArray<Object>* ImageWriter::CreateImageRoots() const {
@@ -123,18 +218,12 @@
   Class* object_array_class = class_linker->FindSystemClass("[Ljava/lang/Object;");
 
   // build an Object[] of all the DexCaches used in the source_space_
-  const std::vector<DexCache*>& all_dex_caches = class_linker->GetDexCaches();
-  std::vector<DexCache*> source_space_dex_caches;
-  for (size_t i = 0; i < all_dex_caches.size(); i++) {
-    DexCache* dex_cache = all_dex_caches[i];
-    if (InSourceSpace(dex_cache)) {
-      source_space_dex_caches.push_back(dex_cache);
-    }
-  }
   ObjectArray<Object>* dex_caches = ObjectArray<Object>::Alloc(object_array_class,
-                                                               source_space_dex_caches.size());
-  for (size_t i = 0; i < source_space_dex_caches.size(); i++) {
-      dex_caches->Set(i, source_space_dex_caches[i]);
+                                                               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);
   }
 
   // build an Object[] of the roots needed to restore the runtime
@@ -245,15 +334,15 @@
   FixupStaticFields(orig, copy);
 }
 
-const void* FixupCode(const ByteArray* copy_code_array, const void* orig_code) {
+static uint32_t FixupCode(const ByteArray* copy_code_array, uint32_t orig_code) {
   // TODO: change to DCHECK when all code compiling
   if (copy_code_array == NULL) {
-    return NULL;
+    return 0;
   }
-  const void* copy_code = copy_code_array->GetData();
+  uint32_t copy_code = reinterpret_cast<uint32_t>(copy_code_array->GetData());
   // TODO: remember InstructionSet with each code array so we know if we need to do thumb fixup?
-  if ((reinterpret_cast<uintptr_t>(orig_code) % 2) == 1) {
-    return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(copy_code) + 1);
+  if ((orig_code % 2) == 1) {
+    return copy_code + 1;
   }
   return copy_code;
 }
@@ -266,7 +355,7 @@
 
   // Every type of method can have an invoke stub
   uint32_t invoke_stub_offset = orig->GetOatInvokeStubOffset();
-  const byte* invoke_stub = (invoke_stub_offset != 0) ? (oat_base_ + invoke_stub_offset) : 0;
+  const byte* invoke_stub = GetOatAddress(invoke_stub_offset);
   copy->invoke_stub_ = reinterpret_cast<const Method::InvokeStub*>(invoke_stub);
 
   if (orig->IsAbstract()) {
@@ -279,7 +368,7 @@
 
   // Non-abstract methods typically have code
   uint32_t code_offset = orig->GetOatCodeOffset();
-  const byte* code = (code_offset != 0) ? (oat_base_ + code_offset) : 0;
+  const byte* code = GetOatAddress(code_offset);
   copy->code_ = code;
 
   if (orig->IsNative()) {
@@ -291,11 +380,11 @@
   } else {
     // normal (non-abstract non-native) methods have mapping tables to relocate
     uint32_t mapping_table_off = orig->GetOatMappingTableOffset();
-    const byte* mapping_table = (mapping_table_off != 0) ? (oat_base_ + mapping_table_off) : 0;
+    const byte* mapping_table = GetOatAddress(mapping_table_off);
     copy->mapping_table_ = reinterpret_cast<const uint32_t*>(mapping_table);
 
     uint32_t vmap_table_offset = orig->GetOatVmapTableOffset();
-    const byte* vmap_table = (vmap_table_offset != 0) ? (oat_base_ + vmap_table_offset) : 0;
+    const byte* vmap_table = GetOatAddress(vmap_table_offset);
     copy->vmap_table_ = reinterpret_cast<const uint16_t*>(vmap_table);
   }
 }
@@ -387,9 +476,10 @@
     if (orig_method != NULL && !InSourceSpace(orig_method)) {
       continue;
     }
-    // if it was resolved in the original, resolve it in the copy
-    if (orig_method == NULL || (orig_method->IsStatic() &&
-                                !orig_method->GetDeclaringClass()->IsInitialized())) {
+    // if it was unresolved or a resolved static method in an uninit class, use a resolution stub
+    // we need to use the stub in the static method case to ensure <clinit> is run.
+    if (orig_method == NULL 
+        || (orig_method->IsStatic() && !orig_method->GetDeclaringClass()->IsInitialized())) {
       uint32_t orig_res_stub_code = orig_cadms->Get(CodeAndDirectMethods::CodeIndex(i));
       if (orig_res_stub_code == 0) {
         continue;  // NULL maps the same in the image and the original
@@ -400,22 +490,13 @@
       if (!InSourceSpace(orig_res_stub_array)) {
         continue;
       }
-      // Compute the delta from the start of the resolution stub to its starting code.
-      // For ARM and X86 this is 0, for Thumb2 it is 1.
-      static size_t res_stub_delta = 0xFFFF;
-      if (res_stub_delta == 0xFFFF) {
-        uint32_t orig_res_stub_array_data =
-            reinterpret_cast<uint32_t>(orig_res_stub_array->GetData());
-        res_stub_delta = orig_res_stub_code - orig_res_stub_array_data;
-        DCHECK(res_stub_delta == 0 || res_stub_delta == 1);
-      }
       // Compute address in image of resolution stub and the code address
       ByteArray* image_res_stub_array = down_cast<ByteArray*>(GetImageAddress(orig_res_stub_array));
-      int32_t image_res_stub_code =
-          reinterpret_cast<int32_t>(image_res_stub_array->GetData()) + res_stub_delta;
+      uint32_t image_res_stub_code = FixupCode(image_res_stub_array, orig_res_stub_code);
       // Put the image code address in the array
       copy_cadms->Set(CodeAndDirectMethods::CodeIndex(i), image_res_stub_code);
     } else if (orig_method->IsDirect()) {
+      // if it was resolved in the original, resolve it in the copy
       Method* copy_method = down_cast<Method*>(GetLocalAddress(orig_method));
       copy_cadms->Set(CodeAndDirectMethods::CodeIndex(i),
                       reinterpret_cast<int32_t>(copy_method->code_));
diff --git a/src/image_writer.h b/src/image_writer.h
index ec17ebf..4e95ee4 100644
--- a/src/image_writer.h
+++ b/src/image_writer.h
@@ -6,6 +6,8 @@
 #include <stdint.h>
 
 #include <cstddef>
+#include <set>
+#include <string>
 
 #include "UniquePtr.h"
 #include "dex_cache.h"
@@ -20,14 +22,18 @@
 // Write a Space built during compilation for use during execution.
 class ImageWriter {
  public:
-  ImageWriter() : source_space_(NULL), image_top_(0), image_base_(NULL) {}
-  bool Write(const char* image_filename, uintptr_t image_base,
-             const std::string& oat_filename, const std::string& strip_location_prefix);
+  ImageWriter(const std::set<std::string>* image_classes)
+      : source_space_(NULL), image_top_(0), image_base_(NULL), image_classes_(image_classes) {}
+
   ~ImageWriter() {}
 
+  bool Write(const char* image_filename,
+             uintptr_t image_base,
+             const std::string& oat_filename,
+             const std::string& strip_location_prefix);
  private:
 
-  bool Init();
+  bool AllocMemory();
 
   // we use the lock word to store the offset of the object in the image
   void AssignImageOffset(Object* object) {
@@ -82,6 +88,22 @@
     return reinterpret_cast<Object*>(dst);
   }
 
+  const byte* GetOatAddress(uint32_t offset) const {
+    DCHECK_LT(offset, oat_file_->GetSize());
+    if (offset == 0) {
+      return NULL;
+    }
+    return oat_base_ + offset;
+  }
+
+  bool IsImageClass(const Class* klass);
+
+  void PruneNonImageClasses();
+  static bool NonImageClassesVisitor(Class* c, void* arg);
+
+  void CheckNonImageClassesRemoved();
+  static void CheckNonImageClassesRemovedCallback(Object* obj, void* arg);
+
   void CalculateNewObjectOffsets();
   ObjectArray<Object>* CreateImageRoots() const;
   static void CalculateNewObjectOffsetsCallback(Object* obj, void* arg);
@@ -114,6 +136,9 @@
   // Target image base address for the output image
   byte* image_base_;
 
+  // Set of classes to be include in the image, or NULL for all.
+  const std::set<std::string>* image_classes_;
+
   // Target oat base address for the pointers from the output image to its oat file
   const byte* oat_base_;
 
diff --git a/src/oat_file.cc b/src/oat_file.cc
index 383bc2a..55493e8 100644
--- a/src/oat_file.cc
+++ b/src/oat_file.cc
@@ -173,54 +173,69 @@
 const OatFile::OatMethod OatFile::OatClass::GetOatMethod(uint32_t method_index) const {
   const OatMethodOffsets& oat_method_offsets = methods_pointer_[method_index];
   return OatMethod(
-      GetOatPointer<const void*>(oat_method_offsets.code_offset_),
+      oat_file_->GetBase(),
+      oat_method_offsets.code_offset_,
       oat_method_offsets.frame_size_in_bytes_,
       oat_method_offsets.core_spill_mask_,
       oat_method_offsets.fp_spill_mask_,
-      GetOatPointer<const uint32_t*>(oat_method_offsets.mapping_table_offset_),
-      GetOatPointer<const uint16_t*>(oat_method_offsets.vmap_table_offset_),
-      GetOatPointer<const Method::InvokeStub*>(oat_method_offsets.invoke_stub_offset_));
+      oat_method_offsets.mapping_table_offset_,
+      oat_method_offsets.vmap_table_offset_,
+      oat_method_offsets.invoke_stub_offset_);
 }
 
-OatFile::OatMethod::OatMethod(const void* code,
+OatFile::OatMethod::OatMethod(const byte* base,
+                              const uint32_t code_offset,
                               const size_t frame_size_in_bytes,
                               const uint32_t core_spill_mask,
                               const uint32_t fp_spill_mask,
-                              const uint32_t* mapping_table,
-                              const uint16_t* vmap_table,
-                              const Method::InvokeStub* invoke_stub)
-  : code_(code),
+                              const uint32_t mapping_table_offset,
+                              const uint32_t vmap_table_offset,
+                              const uint32_t invoke_stub_offset)
+  : base_(base),
+    code_offset_(code_offset),
     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),
-    invoke_stub_(invoke_stub) {
+    mapping_table_offset_(mapping_table_offset),
+    vmap_table_offset_(vmap_table_offset),
+    invoke_stub_offset_(invoke_stub_offset) {
 
 #ifndef NDEBUG
-  if (mapping_table != NULL) {  // implies non-native, non-stub code
-    if (vmap_table_ == NULL) {
+  if (mapping_table_offset_ != 0) {  // implies non-native, non-stub code
+    if (vmap_table_offset_ == 0) {
       DCHECK_EQ(0U, static_cast<uint32_t>(__builtin_popcount(core_spill_mask_) + __builtin_popcount(fp_spill_mask_)));
     } else {
+      const uint16_t* vmap_table_ = reinterpret_cast<const uint16_t*>(base_ + vmap_table_offset_);
       DCHECK_EQ(vmap_table_[0], static_cast<uint32_t>(__builtin_popcount(core_spill_mask_) + __builtin_popcount(fp_spill_mask_)));
     }
   } else {
-    DCHECK(vmap_table_ == NULL);
+    DCHECK(vmap_table_offset_ == 0);
   }
 #endif
 }
 
 OatFile::OatMethod::~OatMethod() {}
 
-void OatFile::OatMethod::LinkMethod(Method* method) const {
+void OatFile::OatMethod::LinkMethodPointers(Method* method) const {
   CHECK(method != NULL);
-  method->SetCode(code_);
+  method->SetCode(GetCode());
   method->SetFrameSizeInBytes(frame_size_in_bytes_);
   method->SetCoreSpillMask(core_spill_mask_);
   method->SetFpSpillMask(fp_spill_mask_);
-  method->SetMappingTable(mapping_table_);
-  method->SetVmapTable(vmap_table_);
-  method->SetInvokeStub(invoke_stub_);
+  method->SetMappingTable(GetMappingTable());
+  method->SetVmapTable(GetVmapTable());
+  method->SetInvokeStub(GetInvokeStub());
+}
+
+void OatFile::OatMethod::LinkMethodOffsets(Method* method) const {
+  CHECK(method != NULL);
+  method->SetOatCodeOffset(GetCodeOffset());
+  method->SetFrameSizeInBytes(GetFrameSizeInBytes());
+  method->SetCoreSpillMask(GetCoreSpillMask());
+  method->SetFpSpillMask(GetFpSpillMask());
+  method->SetOatMappingTableOffset(GetMappingTableOffset());
+  method->SetOatVmapTableOffset(GetVmapTableOffset());
+  method->SetOatInvokeStubOffset(GetInvokeStubOffset());
 }
 
 }  // namespace art
diff --git a/src/oat_file.h b/src/oat_file.h
index 2c39e9d..0e22719 100644
--- a/src/oat_file.h
+++ b/src/oat_file.h
@@ -37,27 +37,79 @@
 
   class OatMethod {
    public:
-    // Create an OatMethod backed by an OatFile
-    OatMethod(const void* code,
-              const size_t frame_size_in_bytes,
-              const uint32_t core_spill_mask,
-              const uint32_t fp_spill_mask,
-              const uint32_t* mapping_table,
-              const uint16_t* vmap_table,
-              const Method::InvokeStub* invoke_stub);
+    // Link Method for execution using the contents of this OatMethod
+    void LinkMethodPointers(Method* method) const;
+
+    // Link Method for image writing using the contents of this OatMethod
+    void LinkMethodOffsets(Method* method) const;
+
+    uint32_t GetCodeOffset() const {
+      return code_offset_;
+    }
+    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_;
+    }
+    uint32_t GetMappingTableOffset() const {
+      return mapping_table_offset_;
+    }
+    uint32_t GetVmapTableOffset() const {
+      return vmap_table_offset_;
+    }
+    uint32_t GetInvokeStubOffset() const {
+      return invoke_stub_offset_;
+    }
+
+    const void* GetCode() const {
+      return GetOatPointer<const void*>(code_offset_);
+    }
+    const uint32_t* GetMappingTable() const {
+      return GetOatPointer<const uint32_t*>(mapping_table_offset_);
+    }
+    const uint16_t* GetVmapTable() const {
+      return GetOatPointer<const uint16_t*>(vmap_table_offset_);
+    }
+    const Method::InvokeStub* GetInvokeStub() const {
+      return GetOatPointer<const Method::InvokeStub*>(invoke_stub_offset_);
+    }
 
     ~OatMethod();
 
-    // Link Method using the contents of this OatMethod
-    void LinkMethod(Method* method) const;
+    // Create an OatMethod with offsets relative to the given base address
+    OatMethod(const byte* base,
+              const uint32_t code_offset,
+              const size_t frame_size_in_bytes,
+              const uint32_t core_spill_mask,
+              const uint32_t fp_spill_mask,
+              const uint32_t mapping_table_offset,
+              const uint32_t vmap_table_offset,
+              const uint32_t invoke_stub_offset);
 
-    const void* code_;
+   private:
+    template<class T>
+    T GetOatPointer(uint32_t offset) const {
+      if (offset == 0) {
+        return NULL;
+      }
+      return reinterpret_cast<T>(base_ + offset);
+    }
+
+    const byte* base_;
+
+    uint32_t code_offset_;
     size_t frame_size_in_bytes_;
     uint32_t core_spill_mask_;
     uint32_t fp_spill_mask_;
-    const uint32_t* mapping_table_;
-    const uint16_t* vmap_table_;
-    const Method::InvokeStub* invoke_stub_;
+    uint32_t mapping_table_offset_;
+    uint32_t vmap_table_offset_;
+    uint32_t invoke_stub_offset_;
+
+    friend class OatClass;
   };
 
   class OatClass {
@@ -72,16 +124,6 @@
    private:
     OatClass(const OatFile* oat_file, const OatMethodOffsets* methods_pointer);
 
-    template<class T>
-    T GetOatPointer(uint32_t offset) const {
-      if (offset == 0) {
-        return NULL;
-      }
-      T pointer = reinterpret_cast<T>(oat_file_->GetBase() + offset);
-      CHECK_LT(pointer, reinterpret_cast<T>(oat_file_->GetLimit()));
-      return pointer;
-    }
-
     const OatFile* oat_file_;
     const OatMethodOffsets* methods_pointer_;
 
diff --git a/src/oat_test.cc b/src/oat_test.cc
index 17a00e4..e4af31e 100644
--- a/src/oat_test.cc
+++ b/src/oat_test.cc
@@ -15,7 +15,7 @@
 
   SirtRef<ClassLoader> class_loader(NULL);
   if (compile) {
-    compiler_.reset(new Compiler(kThumb2, false));
+    compiler_.reset(new Compiler(kThumb2, false, NULL));
     compiler_->CompileAll(class_loader.get(), class_linker->GetBootClassPath());
   }
 
@@ -56,12 +56,12 @@
                                                                  method->GetDexMethodIndex()));
 
       if (compiled_method == NULL) {
-        EXPECT_TRUE(oat_method.code_ == NULL) << PrettyMethod(method) << " " << oat_method.code_;
-        EXPECT_EQ(oat_method.frame_size_in_bytes_, static_cast<uint32_t>(kStackAlignment));
-        EXPECT_EQ(oat_method.core_spill_mask_, 0U);
-        EXPECT_EQ(oat_method.fp_spill_mask_, 0U);
+        EXPECT_TRUE(oat_method.GetCode() == NULL) << PrettyMethod(method) << " " << oat_method.GetCode();
+        EXPECT_EQ(oat_method.GetFrameSizeInBytes(), static_cast<uint32_t>(kStackAlignment));
+        EXPECT_EQ(oat_method.GetCoreSpillMask(), 0U);
+        EXPECT_EQ(oat_method.GetFpSpillMask(), 0U);
       } else {
-        const void* oat_code = oat_method.code_;
+        const void* oat_code = oat_method.GetCode();
         uintptr_t oat_code_aligned = RoundDown(reinterpret_cast<uintptr_t>(oat_code), 2);
         oat_code = reinterpret_cast<const void*>(oat_code_aligned);
 
@@ -70,9 +70,9 @@
         EXPECT_EQ(0, memcmp(oat_code, &code[0], code_size))
             << PrettyMethod(method) << " " << code_size;
         CHECK_EQ(0, memcmp(oat_code, &code[0], code_size));
-        EXPECT_EQ(oat_method.frame_size_in_bytes_, compiled_method->GetFrameSizeInBytes());
-        EXPECT_EQ(oat_method.core_spill_mask_, compiled_method->GetCoreSpillMask());
-        EXPECT_EQ(oat_method.fp_spill_mask_, compiled_method->GetFpSpillMask());
+        EXPECT_EQ(oat_method.GetFrameSizeInBytes(), compiled_method->GetFrameSizeInBytes());
+        EXPECT_EQ(oat_method.GetCoreSpillMask(), compiled_method->GetCoreSpillMask());
+        EXPECT_EQ(oat_method.GetFpSpillMask(), compiled_method->GetFpSpillMask());
       }
     }
     for (size_t i = 0; i < num_virtual_methods; i++, method_index++) {
@@ -83,12 +83,12 @@
                                                                  method->GetDexMethodIndex()));
 
       if (compiled_method == NULL) {
-        EXPECT_TRUE(oat_method.code_ == NULL) << PrettyMethod(method) << " " << oat_method.code_;
-        EXPECT_EQ(oat_method.frame_size_in_bytes_, static_cast<uint32_t>(kStackAlignment));
-        EXPECT_EQ(oat_method.core_spill_mask_, 0U);
-        EXPECT_EQ(oat_method.fp_spill_mask_, 0U);
+        EXPECT_TRUE(oat_method.GetCode() == NULL) << PrettyMethod(method) << " " << oat_method.GetCode();
+        EXPECT_EQ(oat_method.GetFrameSizeInBytes(), static_cast<uint32_t>(kStackAlignment));
+        EXPECT_EQ(oat_method.GetCoreSpillMask(), 0U);
+        EXPECT_EQ(oat_method.GetFpSpillMask(), 0U);
       } else {
-        const void* oat_code = oat_method.code_;
+        const void* oat_code = oat_method.GetCode();
         EXPECT_TRUE(oat_code != NULL) << PrettyMethod(method);
         uintptr_t oat_code_aligned = RoundDown(reinterpret_cast<uintptr_t>(oat_code), 2);
         oat_code = reinterpret_cast<const void*>(oat_code_aligned);
@@ -98,9 +98,9 @@
         EXPECT_EQ(0, memcmp(oat_code, &code[0], code_size))
             << PrettyMethod(method) << " " << code_size;
         CHECK_EQ(0, memcmp(oat_code, &code[0], code_size));
-        EXPECT_EQ(oat_method.frame_size_in_bytes_, compiled_method->GetFrameSizeInBytes());
-        EXPECT_EQ(oat_method.core_spill_mask_, compiled_method->GetCoreSpillMask());
-        EXPECT_EQ(oat_method.fp_spill_mask_, compiled_method->GetFpSpillMask());
+        EXPECT_EQ(oat_method.GetFrameSizeInBytes(), compiled_method->GetFrameSizeInBytes());
+        EXPECT_EQ(oat_method.GetCoreSpillMask(), compiled_method->GetCoreSpillMask());
+        EXPECT_EQ(oat_method.GetFpSpillMask(), compiled_method->GetFpSpillMask());
       }
     }
   }
diff --git a/src/oatdump.cc b/src/oatdump.cc
index 2d5732f..ac9449f 100644
--- a/src/oatdump.cc
+++ b/src/oatdump.cc
@@ -177,23 +177,19 @@
     os << StringPrintf("\t%d: %s %s (method_idx=%d)\n",
                        method_index, name, signature.c_str(), method_idx);
     os << StringPrintf("\t\tcode: %p (offset=%08x)\n",
-                       oat_method.code_,
-                       reinterpret_cast<const byte*>(oat_method.code_) - oat_file.GetBase());
+                       oat_method.GetCode(), oat_method.GetCodeOffset());
     os << StringPrintf("\t\tframe_size_in_bytes: %d\n",
-                       oat_method.frame_size_in_bytes_);
+                       oat_method.GetFrameSizeInBytes());
     os << StringPrintf("\t\tcore_spill_mask: %08x\n",
-                       oat_method.core_spill_mask_);
+                       oat_method.GetCoreSpillMask());
     os << StringPrintf("\t\tfp_spill_mask: %08x\n",
-                       oat_method.fp_spill_mask_);
+                       oat_method.GetFpSpillMask());
     os << StringPrintf("\t\tmapping_table: %p (offset=%08x)\n",
-                       oat_method.mapping_table_,
-                       reinterpret_cast<const byte*>(oat_method.mapping_table_) - oat_file.GetBase());
+                       oat_method.GetMappingTable(), oat_method.GetMappingTableOffset());
     os << StringPrintf("\t\tvmap_table: %p (offset=%08x)\n",
-                       oat_method.vmap_table_,
-                       reinterpret_cast<const byte*>(oat_method.vmap_table_) - oat_file.GetBase());
+                       oat_method.GetVmapTable(), oat_method.GetVmapTableOffset());
     os << StringPrintf("\t\tinvoke_stub: %p (offset=%08x)\n",
-                       oat_method.invoke_stub_,
-                       reinterpret_cast<const byte*>(oat_method.invoke_stub_) - oat_file.GetBase());
+                       oat_method.GetInvokeStub(), oat_method.GetInvokeStubOffset());
   }
 };
 
@@ -268,7 +264,7 @@
       os << " (" << oat_location << ")";
     }
     os << "\n";
-    const OatFile* oat_file = class_linker->FindOatFile(oat_location);
+    const OatFile* oat_file = class_linker->FindOatFileFromOatLocation(oat_location);
     if (oat_file == NULL) {
       os << "NOT FOUND\n";
       os << std::flush;
@@ -353,8 +349,10 @@
         DCHECK(method->GetGcMap() == NULL) << PrettyMethod(method);
         DCHECK(method->GetMappingTable() == NULL) << PrettyMethod(method);
       } else {
-        size_t register_map_bytes = method->GetGcMap()->SizeOf();
-        state->stats_.register_map_bytes += register_map_bytes;
+        if (method->GetGcMap() != NULL) {
+          size_t register_map_bytes = method->GetGcMap()->SizeOf();
+          state->stats_.register_map_bytes += register_map_bytes;
+        }
 
         if (method->GetMappingTable() != NULL) {
           size_t pc_mapping_table_bytes = method->GetMappingTableLength();
diff --git a/src/object.cc b/src/object.cc
index 8cf79c2..abf8310 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -209,100 +209,100 @@
 }
 
 bool Field::GetBoolean(const Object* object) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimBoolean) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimBoolean) << PrettyField(this);
   return Get32(object);
 }
 
 void Field::SetBoolean(Object* object, bool z) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimBoolean) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimBoolean) << PrettyField(this);
   Set32(object, z);
 }
 
 int8_t Field::GetByte(const Object* object) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimByte) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimByte) << PrettyField(this);
   return Get32(object);
 }
 
 void Field::SetByte(Object* object, int8_t b) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimByte) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimByte) << PrettyField(this);
   Set32(object, b);
 }
 
 uint16_t Field::GetChar(const Object* object) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimChar) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimChar) << PrettyField(this);
   return Get32(object);
 }
 
 void Field::SetChar(Object* object, uint16_t c) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimChar) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimChar) << PrettyField(this);
   Set32(object, c);
 }
 
 int16_t Field::GetShort(const Object* object) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimShort) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimShort) << PrettyField(this);
   return Get32(object);
 }
 
 void Field::SetShort(Object* object, int16_t s) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimShort) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimShort) << PrettyField(this);
   Set32(object, s);
 }
 
 int32_t Field::GetInt(const Object* object) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimInt) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimInt) << PrettyField(this);
   return Get32(object);
 }
 
 void Field::SetInt(Object* object, int32_t i) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimInt) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimInt) << PrettyField(this);
   Set32(object, i);
 }
 
 int64_t Field::GetLong(const Object* object) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimLong) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimLong) << PrettyField(this);
   return Get64(object);
 }
 
 void Field::SetLong(Object* object, int64_t j) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimLong) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimLong) << PrettyField(this);
   Set64(object, j);
 }
 
 float Field::GetFloat(const Object* object) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimFloat) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimFloat) << PrettyField(this);
   JValue float_bits;
   float_bits.i = Get32(object);
   return float_bits.f;
 }
 
 void Field::SetFloat(Object* object, float f) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimFloat) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimFloat) << PrettyField(this);
   JValue float_bits;
   float_bits.f = f;
   Set32(object, float_bits.i);
 }
 
 double Field::GetDouble(const Object* object) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimDouble) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimDouble) << PrettyField(this);
   JValue double_bits;
   double_bits.j = Get64(object);
   return double_bits.d;
 }
 
 void Field::SetDouble(Object* object, double d) const {
-  DCHECK(GetPrimitiveType() == Primitive::kPrimDouble) << PrettyField(this);
+  DCHECK_EQ(GetPrimitiveType(), Primitive::kPrimDouble) << PrettyField(this);
   JValue double_bits;
   double_bits.d = d;
   Set64(object, double_bits.j);
 }
 
 Object* Field::GetObject(const Object* object) const {
-  CHECK(GetPrimitiveType() == Primitive::kPrimNot) << PrettyField(this);
+  CHECK_EQ(GetPrimitiveType(), Primitive::kPrimNot) << PrettyField(this);
   return GetObj(object);
 }
 
 void Field::SetObject(Object* object, const Object* l) const {
-  CHECK(GetPrimitiveType() == Primitive::kPrimNot) << PrettyField(this);
+  CHECK_EQ(GetPrimitiveType(), Primitive::kPrimNot) << PrettyField(this);
   SetObj(object, l);
 }
 
diff --git a/src/primitive.cc b/src/primitive.cc
new file mode 100644
index 0000000..16ca0fe
--- /dev/null
+++ b/src/primitive.cc
@@ -0,0 +1,43 @@
+/*
+ * 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 "primitive.h"
+
+namespace art {
+
+static const char* kTypeNames[] = {
+  "PrimNot",
+  "PrimBoolean",
+  "PrimByte",
+  "PrimChar",
+  "PrimShort",
+  "PrimInt",
+  "PrimLong",
+  "PrimFloat",
+  "PrimDouble",
+  "PrimVoid",
+};
+std::ostream& operator<<(std::ostream& os, const Primitive::Type& type) {
+  int32_t int_type = static_cast<int32_t>(type);
+  if (type >= Primitive::kPrimNot && type <= Primitive::kPrimVoid) {
+    os << kTypeNames[int_type];
+  } else {
+    os << "Type[" << int_type << "]";
+  }
+  return os;
+}
+
+}  // namespace art
diff --git a/src/primitive.h b/src/primitive.h
index 240892f..5d41966 100644
--- a/src/primitive.h
+++ b/src/primitive.h
@@ -116,6 +116,8 @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(Primitive);
 };
 
+std::ostream& operator<<(std::ostream& os, const Primitive::Type& state);
+
 }  // namespace art
 
 #endif  // ART_SRC_PRIMITIVE_H_
diff --git a/src/runtime.cc b/src/runtime.cc
index 656fdb8..f52bca8 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -446,10 +446,12 @@
   // Restore main thread state to kNative as expected by native code
   Thread::Current()->SetState(Thread::kNative);
 
-  InitNativeMethods();
-
   started_ = true;
 
+  // InitNativeMethods needs to be after started_ so that the classes
+  // it touches will have methods linked to the oat file if necessary.
+  InitNativeMethods();
+
   Thread::FinishStartup();
 
   if (!is_zygote_) {
@@ -564,9 +566,10 @@
   Thread::Current()->SetState(Thread::kRunnable);
 
   CHECK_GE(Heap::GetSpaces().size(), 1U);
+  bool verbose_class = options->IsVerbose("class");
   class_linker_ = ((Heap::GetSpaces()[0]->IsImageSpace())
-                   ? ClassLinker::Create(intern_table_)
-                   : ClassLinker::Create(options->boot_class_path_, intern_table_));
+                   ? ClassLinker::Create(verbose_class, intern_table_)
+                   : ClassLinker::Create(verbose_class, options->boot_class_path_, intern_table_));
 
   if (IsVerboseStartup()) {
     LOG(INFO) << "Runtime::Init exiting";
@@ -793,7 +796,7 @@
   resolution_stub_array_[type] = resolution_stub_array;
 }
 
-Method* Runtime::CreateCalleeSaveMethod(InstructionSet insns, CalleeSaveType type) {
+Method* Runtime::CreateCalleeSaveMethod(InstructionSet instruction_set, CalleeSaveType type) {
   Class* method_class = Method::GetMethodClass();
   SirtRef<Method> method(down_cast<Method*>(method_class->AllocObject()));
   method->SetDeclaringClass(method_class);
@@ -811,7 +814,7 @@
   method->SetSignature(intern_table_->InternStrong("()V"));
   CHECK(method->GetSignature() != NULL);
   method->SetCode(NULL);
-  if ((insns == kThumb2) || (insns == kArm)) {
+  if ((instruction_set == kThumb2) || (instruction_set == kArm)) {
     uint32_t ref_spills = (1 << art::arm::R5) | (1 << art::arm::R6)  | (1 << art::arm::R7) |
                           (1 << art::arm::R8) | (1 << art::arm::R10) | (1 << art::arm::R11);
     uint32_t arg_spills = (1 << art::arm::R1) | (1 << art::arm::R2) | (1 << art::arm::R3);
@@ -836,7 +839,7 @@
     method->SetFrameSizeInBytes(frame_size);
     method->SetCoreSpillMask(core_spills);
     method->SetFpSpillMask(fp_spills);
-  } else if (insns == kX86) {
+  } else if (instruction_set == kX86) {
     method->SetFrameSizeInBytes(32);
     method->SetCoreSpillMask((1 << art::x86::EBX) | (1 << art::x86::EBP) | (1 << art::x86::ESI) |
                              (1 << art::x86::EDI));
diff --git a/src/runtime.h b/src/runtime.h
index 50f9ed1..1d9a3d1 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -190,13 +190,13 @@
     kRefsAndArgs,
     kLastCalleeSaveType  // Value used for iteration
   };
-  Method* CreateCalleeSaveMethod(InstructionSet insns, CalleeSaveType type);
+  Method* CreateCalleeSaveMethod(InstructionSet instruction_set, CalleeSaveType type);
   bool HasCalleeSaveMethod(CalleeSaveType type) const;
   Method* GetCalleeSaveMethod(CalleeSaveType type) const;
   void SetCalleeSaveMethod(Method* method, CalleeSaveType type);
 
-  Method* CreateRefOnlyCalleeSaveMethod(InstructionSet insns);
-  Method* CreateRefAndArgsCalleeSaveMethod(InstructionSet insns);
+  Method* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set);
+  Method* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set);
 
   int32_t GetStat(int kind);