diff --git a/build/Android.common.mk b/build/Android.common.mk
index c4f04be..74bc4a9 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -233,7 +233,6 @@
 
 ifeq ($(ART_USE_LLVM_COMPILER),true)
 LIBART_COMMON_SRC_FILES += \
-	src/compiler_llvm/elf_loader.cc \
 	src/compiler_llvm/inferred_reg_category_map.cc \
 	src/compiler_llvm/procedure_linkage_table.cc \
 	src/compiler_llvm/runtime_support_llvm.cc
diff --git a/build/Android.gtest.mk b/build/Android.gtest.mk
index 9f75115..d090395 100644
--- a/build/Android.gtest.mk
+++ b/build/Android.gtest.mk
@@ -63,11 +63,6 @@
     LOCAL_SHARED_LIBRARIES += libdynamic_annotations-host
   endif
 
-  ifeq ($(ART_USE_LLVM_COMPILER),true)
-    LOCAL_C_INCLUDES += frameworks/compile/linkloader
-    LOCAL_STATIC_LIBRARIES += librsloader
-  endif
-
   # Mac OS linker doesn't understand --export-dynamic.
   ifneq ($(HOST_OS)-$$(art_target_or_host),darwin-host)
     # Allow jni_compiler_test to find Java_MyClassNatives_bar within itself using dlopen(NULL, ...).
diff --git a/build/Android.libart-compiler-llvm.mk b/build/Android.libart-compiler-llvm.mk
index e2c66e4..9ec356a 100644
--- a/build/Android.libart-compiler-llvm.mk
+++ b/build/Android.libart-compiler-llvm.mk
@@ -74,7 +74,7 @@
   endif
 
   LOCAL_C_INCLUDES += $(ART_C_INCLUDES)
-  LOCAL_C_INCLUDES += frameworks/compile/linkloader
+
   libart_compiler_llvm_arm_STATIC_LIBRARIES := \
     libLLVMARMInfo \
     libLLVMARMDisassembler \
@@ -111,6 +111,7 @@
   endif
 
   LOCAL_STATIC_LIBRARIES += \
+    libLLVMObject \
     libLLVMLinker \
     libLLVMipo \
     libLLVMBitWriter \
@@ -129,8 +130,8 @@
     libLLVMMC \
     libLLVMMCParser \
     libLLVMCore \
-    libLLVMSupport \
-    librsloader
+    libLLVMSupport
+
   LOCAL_SHARED_LIBRARIES := liblog libnativehelper
   LOCAL_SHARED_LIBRARIES += libcorkscrew # native stack trace support
   ifeq ($$(art_target_or_host),target)
diff --git a/build/Android.libart.mk b/build/Android.libart.mk
index 01fa42b..9ccbe3f 100644
--- a/build/Android.libart.mk
+++ b/build/Android.libart.mk
@@ -98,13 +98,6 @@
     endif
   endif
   LOCAL_C_INCLUDES += $(ART_C_INCLUDES)
-  ifeq ($(ART_USE_LLVM_COMPILER),true)
-    LOCAL_C_INCLUDES += frameworks/compile/linkloader
-    LOCAL_STATIC_LIBRARIES += librsloader
-  endif
-  ifeq ($(ART_REQUIRE_LLVM),true)
-    LOCAL_STATIC_LIBRARIES += libLLVMSupport
-  endif
   LOCAL_SHARED_LIBRARIES := liblog libnativehelper
   LOCAL_SHARED_LIBRARIES += libcorkscrew # native stack trace support
   ifeq ($$(art_target_or_host),target)
diff --git a/src/common_test.h b/src/common_test.h
index cdcac24..58d0219 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -177,14 +177,10 @@
     MakeExecutable(code_array->GetData(), code_array->GetLength());
   }
 
-#if !defined(ART_USE_LLVM_COMPILER)  // LLVM compilation uses ELF instead
   static void MakeExecutable(const std::vector<uint8_t>& code) {
     CHECK_NE(code.size(), 0U);
     MakeExecutable(&code[0], code.size());
   }
-#else
-  static void MakeExecutable(const std::vector<uint8_t>&) {}
-#endif
 
   // Create an OatMethod based on pointers (for unit tests)
   OatFile::OatMethod CreateOatMethod(const void* code,
@@ -205,13 +201,7 @@
                                 reinterpret_cast<uint32_t>(gc_map),
                                 reinterpret_cast<uint32_t>(invoke_stub)
 #if defined(ART_USE_LLVM_COMPILER)
-                              , NULL,
-                                static_cast<uint16_t>(-1u),
-                                static_cast<uint16_t>(-1u),
-                                static_cast<uint16_t>(-1u),
-                                static_cast<uint16_t>(-1u),
-                                static_cast<uint16_t>(-1u),
-                                static_cast<uint16_t>(-1u)
+                              , 0
 #endif
                                 );
   }
@@ -224,17 +214,12 @@
         compiler_->FindInvokeStub(mh.IsStatic(), mh.GetShorty());
     CHECK(compiled_invoke_stub != NULL) << PrettyMethod(method);
 
-    const Method::InvokeStub* method_invoke_stub = NULL;
-    if (compiled_invoke_stub->IsExecutableInElf()) {
-      method_invoke_stub =
-          compiler_->GetMethodInvokeStubAddr(compiled_invoke_stub, method);
-    } else {
-      const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
-      MakeExecutable(invoke_stub);
-      method_invoke_stub = reinterpret_cast<const Method::InvokeStub*>(
+    const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
+    MakeExecutable(invoke_stub);
+    const Method::InvokeStub* method_invoke_stub =
+        reinterpret_cast<const Method::InvokeStub*>(
           CompiledCode::CodePointer(&invoke_stub[0],
                                     compiled_invoke_stub->GetInstructionSet()));
-    }
 
     LOG(INFO) << "MakeExecutable " << PrettyMethod(method)
               << " invoke_stub=" << reinterpret_cast<void*>(method_invoke_stub);
@@ -247,14 +232,10 @@
                                                                  method->GetDexMethodIndex()));
       CHECK(compiled_method != NULL) << PrettyMethod(method);
 
-      const void* method_code = NULL;
-      if (compiled_method->IsExecutableInElf()) {
-        method_code = compiler_->GetMethodCodeAddr(compiled_method, method);
-      } else {
-        const std::vector<uint8_t>& code = compiled_method->GetCode();
-        MakeExecutable(code);
-        method_code = CompiledMethod::CodePointer(&code[0], compiled_method->GetInstructionSet());
-      }
+      const std::vector<uint8_t>& code = compiled_method->GetCode();
+      MakeExecutable(code);
+      const void* method_code = CompiledMethod::CodePointer(&code[0],
+                                                            compiled_method->GetInstructionSet());
 
       LOG(INFO) << "MakeExecutable " << PrettyMethod(method) << " code=" << method_code;
 
@@ -380,9 +361,6 @@
     image_classes_.reset(new std::set<std::string>);
     compiler_.reset(new Compiler(instruction_set, true, 2, false, image_classes_.get(),
                                  true, true));
-#if defined(ART_USE_LLVM_COMPILER)
-    compiler_->EnableAutoElfLoading();
-#endif
 
     Runtime::Current()->GetHeap()->VerifyHeap();  // Check for heap corruption before the test
   }
diff --git a/src/compiled_method.h b/src/compiled_method.h
index 7ddde0c..ca3a597 100644
--- a/src/compiled_method.h
+++ b/src/compiled_method.h
@@ -32,22 +32,14 @@
 class CompiledCode {
  public:
   CompiledCode(InstructionSet instruction_set)
-      : instruction_set_(instruction_set), elf_idx_(-1), elf_func_idx_(-1) {
+      : instruction_set_(instruction_set) {
   }
 
   CompiledCode(InstructionSet instruction_set, const std::vector<uint8_t>& code)
-      : instruction_set_(instruction_set), code_(code), elf_idx_(-1),
-        elf_func_idx_(-1) {
+      : instruction_set_(instruction_set), code_(code) {
     CHECK_NE(code.size(), 0U);
   }
 
-  CompiledCode(InstructionSet instruction_set,
-               uint16_t elf_idx,
-               uint16_t elf_func_idx)
-      : instruction_set_(instruction_set), elf_idx_(elf_idx),
-        elf_func_idx_(elf_func_idx) {
-  }
-
   InstructionSet GetInstructionSet() const {
     return instruction_set_;
   }
@@ -57,6 +49,7 @@
   }
 
   void SetCode(const std::vector<uint8_t>& code) {
+    CHECK_NE(code.size(), 0U);
     code_ = code;
   }
 
@@ -64,18 +57,6 @@
     return (code_ == rhs.code_);
   }
 
-  bool IsExecutableInElf() const {
-    return (elf_idx_ != static_cast<uint16_t>(-1u));
-  }
-
-  uint16_t GetElfIndex() const {
-    return elf_idx_;
-  }
-
-  uint16_t GetElfFuncIndex() const {
-    return elf_func_idx_;
-  }
-
   // 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.
@@ -95,10 +76,6 @@
  private:
   const InstructionSet instruction_set_;
   std::vector<uint8_t> code_;
-
-  // LLVM-specific fields
-  uint16_t elf_idx_;
-  uint16_t elf_func_idx_;
 };
 
 class CompiledMethod : public CompiledCode {
@@ -124,9 +101,8 @@
 
   // Constructs a CompiledMethod for the LLVM compiler.
   CompiledMethod(InstructionSet instruction_set,
-                 uint16_t elf_idx,
-                 uint16_t elf_func_idx)
-      : CompiledCode(instruction_set, elf_idx, elf_func_idx),
+                 const std::vector<uint8_t>& code)
+      : CompiledCode(instruction_set, code),
         frame_size_in_bytes_(kStackAlignment), core_spill_mask_(0),
         fp_spill_mask_(0) {
   }
@@ -162,12 +138,6 @@
   explicit CompiledInvokeStub(InstructionSet instruction_set,
                               const std::vector<uint8_t>& code);
 
-  explicit CompiledInvokeStub(InstructionSet instruction_set,
-                              uint16_t elf_idx,
-                              uint16_t elf_func_idx)
-      : CompiledCode(instruction_set, elf_idx, elf_func_idx) {
-  }
-
   ~CompiledInvokeStub();
 };
 
diff --git a/src/compiler.cc b/src/compiler.cc
index a726606..272ba9e 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -319,14 +319,8 @@
       compiler_(NULL),
       compiler_context_(NULL),
       jni_compiler_(NULL),
-#if !defined(ART_USE_LLVM_COMPILER)
-      create_invoke_stub_(NULL) {
-#else
-      create_invoke_stub_(NULL),
-      compiler_enable_auto_elf_loading_(NULL),
-      compiler_get_method_code_addr_(NULL),
-      compiler_get_method_invoke_stub_addr_(NULL) {
-#endif
+      create_invoke_stub_(NULL)
+{
   std::string compiler_so_name(MakeCompilerSoName(instruction_set_));
   compiler_library_ = dlopen(compiler_so_name.c_str(), RTLD_LAZY);
   if (compiler_library_ == NULL) {
@@ -353,12 +347,6 @@
 #if defined(ART_USE_LLVM_COMPILER)
   create_proxy_stub_ = FindFunction<CreateProxyStubFn>(
       compiler_so_name, compiler_library_, "ArtCreateProxyStub");
-  compiler_enable_auto_elf_loading_ = FindFunction<CompilerEnableAutoElfLoadingFn>(
-      compiler_so_name, compiler_library_, "compilerLLVMEnableAutoElfLoading");
-  compiler_get_method_code_addr_ = FindFunction<CompilerGetMethodCodeAddrFn>(
-      compiler_so_name, compiler_library_, "compilerLLVMGetMethodCodeAddr");
-  compiler_get_method_invoke_stub_addr_ = FindFunction<CompilerGetMethodInvokeStubAddrFn>(
-      compiler_so_name, compiler_library_, "compilerLLVMGetMethodInvokeStubAddr");
 #endif
 
   CHECK(!Runtime::Current()->IsStarted());
@@ -395,10 +383,17 @@
     STLDeleteElements(&methods_to_patch_);
   }
 #if defined(ART_USE_LLVM_COMPILER)
-  CompilerCallbackFn f = FindFunction<CompilerCallbackFn>(MakeCompilerSoName(instruction_set_),
-                                                          compiler_library_,
-                                                          "compilerLLVMDispose");
-  (*f)(*this);
+  // Uninitialize compiler_context_
+  typedef void (*UninitCompilerContextFn)(Compiler&);
+
+  std::string compiler_so_name(MakeCompilerSoName(instruction_set_));
+
+  UninitCompilerContextFn uninit_compiler_context =
+    FindFunction<void (*)(Compiler&)>(compiler_so_name,
+                                      compiler_library_,
+                                      "ArtUnInitCompilerContext");
+
+  uninit_compiler_context(*this);
 #endif
   if (compiler_library_ != NULL) {
     VLOG(compiler) << "dlclose(" << compiler_library_ << ")";
@@ -511,12 +506,6 @@
 void Compiler::PostCompile(ClassLoader* class_loader,
                            const std::vector<const DexFile*>& dex_files) {
   SetGcMaps(class_loader, dex_files);
-#if defined(ART_USE_LLVM_COMPILER)
-  CompilerCallbackFn f = FindFunction<CompilerCallbackFn>(MakeCompilerSoName(instruction_set_),
-                                                          compiler_library_,
-                                                          "compilerLLVMMaterializeRemainder");
-  (*f)(*this);
-#endif
 }
 
 bool Compiler::IsImageClass(const std::string& descriptor) const {
@@ -1683,31 +1672,4 @@
 }
 #endif
 
-#if defined(ART_USE_LLVM_COMPILER)
-void Compiler::EnableAutoElfLoading() {
-  compiler_enable_auto_elf_loading_(*this);
-}
-
-const void* Compiler::GetMethodCodeAddr(const CompiledMethod* cm,
-                                        const Method* method) const {
-  return compiler_get_method_code_addr_(*this, cm, method);
-}
-
-const Method::InvokeStub* Compiler::GetMethodInvokeStubAddr(const CompiledInvokeStub* cm,
-                                                            const Method* method) const {
-  return compiler_get_method_invoke_stub_addr_(*this, cm, method);
-}
-
-std::vector<ElfImage> Compiler::GetElfImages() const {
-  typedef std::vector<ElfImage> (*GetElfImagesFn)(const Compiler&);
-
-  GetElfImagesFn get_elf_images =
-    FindFunction<GetElfImagesFn>(MakeCompilerSoName(instruction_set_),
-                                 compiler_library_,
-                                 "compilerLLVMGetElfImages");
-
-  return get_elf_images(*this);
-}
-#endif
-
 }  // namespace art
diff --git a/src/compiler.h b/src/compiler.h
index 5202967..46d3647 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -25,7 +25,6 @@
 #include "compiled_method.h"
 #include "dex_cache.h"
 #include "dex_file.h"
-#include "elf_image.h"
 #include "instruction_set.h"
 #include "invoke_type.h"
 #include "oat_file.h"
@@ -146,34 +145,6 @@
   void SetBitcodeFileName(std::string const& filename);
 #endif
 
-#if defined(ART_USE_LLVM_COMPILER)
-  void EnableAutoElfLoading();
-
-  const void* GetMethodCodeAddr(const CompiledMethod* cm,
-                                const Method* method) const;
-
-  const Method::InvokeStub* GetMethodInvokeStubAddr(const CompiledInvokeStub* cm,
-                                                    const Method* method) const;
-
-  std::vector<ElfImage> GetElfImages() const;
-#else
-  void EnableAutoElfLoader() { }
-
-  const void* GetMethodCodeAddr(const CompiledMethod*,
-                                const Method*) const {
-    return NULL;
-  }
-
-  const Method::InvokeStub* GetMethodInvokeStubAddr(const CompiledInvokeStub*,
-                                                    const Method*) const {
-    return NULL;
-  }
-
-  std::vector<ElfImage> GetElfImages() const {
-    return std::vector<ElfImage>();
-  }
-#endif
-
   void SetCompilerContext(void* compiler_context) {
     compiler_context_ = compiler_context;
   }
diff --git a/src/compiler_llvm/compilation_unit.cc b/src/compiler_llvm/compilation_unit.cc
index 38faf61..fdbf575 100644
--- a/src/compiler_llvm/compilation_unit.cc
+++ b/src/compiler_llvm/compilation_unit.cc
@@ -17,6 +17,7 @@
 #include "compilation_unit.h"
 
 #include "compiled_method.h"
+#include "compiler_llvm.h"
 #include "file.h"
 #include "instruction_set.h"
 #include "ir_builder.h"
@@ -47,8 +48,10 @@
 #include <llvm/DerivedTypes.h>
 #include <llvm/LLVMContext.h>
 #include <llvm/Module.h>
+#include <llvm/Object/ObjectFile.h>
 #include <llvm/PassManager.h>
 #include <llvm/Support/Debug.h>
+#include <llvm/Support/ELF.h>
 #include <llvm/Support/FormattedStream.h>
 #include <llvm/Support/ManagedStatic.h>
 #include <llvm/Support/MemoryBuffer.h>
@@ -77,37 +80,6 @@
 
 namespace {
 
-class UpdateFrameSizePass : public llvm::MachineFunctionPass {
- public:
-  static char ID;
-
-  UpdateFrameSizePass() : llvm::MachineFunctionPass(ID), cunit_(NULL) {
-    LOG(FATAL) << "Unexpected instantiation of UpdateFrameSizePass";
-    // NOTE: We have to declare this constructor for llvm::RegisterPass, but
-    // this constructor won't work because we have no information on
-    // CompilationUnit.  Thus, we should place a LOG(FATAL) here.
-  }
-
-  UpdateFrameSizePass(art::compiler_llvm::CompilationUnit* cunit)
-    : llvm::MachineFunctionPass(ID), cunit_(cunit) {
-  }
-
-  virtual bool runOnMachineFunction(llvm::MachineFunction &MF) {
-    cunit_->UpdateFrameSizeInBytes(MF.getFunction(),
-                                   MF.getFrameInfo()->getStackSize());
-    return false;
-  }
-
- private:
-  art::compiler_llvm::CompilationUnit* cunit_;
-};
-
-char UpdateFrameSizePass::ID = 0;
-
-llvm::RegisterPass<UpdateFrameSizePass> reg_update_frame_size_pass_(
-  "update-frame-size", "Update frame size pass", false, false);
-
-
 // TODO: We may need something to manage these passes.
 // TODO: We need high-level IR to analysis and do this at the IRBuilder level.
 class AddSuspendCheckToLoopLatchPass : public llvm::LoopPass {
@@ -167,10 +139,10 @@
 llvm::Module* makeLLVMModuleContents(llvm::Module* module);
 
 
-CompilationUnit::CompilationUnit(InstructionSet insn_set, size_t elf_idx)
-: cunit_lock_("compilation_unit_lock"), insn_set_(insn_set), elf_idx_(elf_idx),
-  context_(new llvm::LLVMContext()), compiled_methods_map_(new CompiledMethodMap()),
-  mem_usage_(0), num_elf_funcs_(0) {
+CompilationUnit::CompilationUnit(const CompilerLLVM* compiler_llvm,
+                                 size_t cunit_idx)
+: compiler_llvm_(compiler_llvm), cunit_idx_(cunit_idx),
+  context_(new llvm::LLVMContext()) {
 
   // Create the module and include the runtime function declaration
   module_ = new llvm::Module("art", *context_);
@@ -180,7 +152,7 @@
   irb_.reset(new IRBuilder(*context_, *module_));
 
   // We always need a switch case, so just use a normal function.
-  switch(insn_set_) {
+  switch(GetInstructionSet()) {
   default:
     runtime_support_.reset(new RuntimeSupportBuilder(*context_, *module_, *irb_));
     break;
@@ -205,57 +177,56 @@
 }
 
 
-bool CompilationUnit::Materialize(size_t thread_count) {
-  MutexLock GUARD(cunit_lock_);
-
-  // Materialize the bitcode to elf_image_
-  llvm::raw_string_ostream str_os(elf_image_);
-  bool success = MaterializeToFile(str_os);
-  LOG(INFO) << "Compilation Unit: " << elf_idx_ << (success ? " (done)" : " (failed)");
-
-  // Free the resources
-  context_.reset(NULL);
-  irb_.reset(NULL);
-  module_ = NULL;
-  runtime_support_.reset(NULL);
-  compiled_methods_map_.reset(NULL);
-
-  return success;
+InstructionSet CompilationUnit::GetInstructionSet() const {
+  return compiler_llvm_->GetInstructionSet();
 }
 
 
-void CompilationUnit::RegisterCompiledMethod(const llvm::Function* func,
-                                             CompiledMethod* compiled_method) {
-  MutexLock GUARD(cunit_lock_);
-  compiled_methods_map_->Put(func, compiled_method);
-}
+bool CompilationUnit::Materialize() {
+  std::string elf_image;
 
-
-void CompilationUnit::UpdateFrameSizeInBytes(const llvm::Function* func,
-                                             size_t frame_size_in_bytes) {
-  MutexLock GUARD(cunit_lock_);
-  SafeMap<const llvm::Function*, CompiledMethod*>::iterator iter =
-    compiled_methods_map_->find(func);
-
-  if (iter != compiled_methods_map_->end()) {
-    CompiledMethod* compiled_method = iter->second;
-    compiled_method->SetFrameSizeInBytes(frame_size_in_bytes);
-
-    if (frame_size_in_bytes > 1728u) {
-      LOG(WARNING) << "Huge frame size: " << frame_size_in_bytes
-                   << " elf_idx=" << compiled_method->GetElfIndex()
-                   << " elf_func_idx=" << compiled_method->GetElfFuncIndex();
-    }
+  // Compile and prelink llvm::Module
+  if (!MaterializeToString(elf_image)) {
+    LOG(ERROR) << "Failed to materialize compilation unit " << cunit_idx_;
+    DeleteResources();
+    return false;
   }
+
+#if 0
+  // Dump the ELF image for debugging
+  std::string filename(StringPrintf("%s/Art%zu.elf",
+                                    GetArtCacheOrDie(GetAndroidData()).c_str(),
+                                    cunit_idx_));
+  UniquePtr<File> output(OS::OpenFile(filename.c_str(), true));
+  output->WriteFully(elf_image.data(), elf_image.size());
+#endif
+
+  // Extract the .text section and prelink the code
+  if (!ExtractCodeAndPrelink(elf_image)) {
+    LOG(ERROR) << "Failed to extract code from compilation unit " << cunit_idx_;
+    DeleteResources();
+    return false;
+  }
+
+  DeleteResources();
+  return true;
 }
 
-bool CompilationUnit::MaterializeToFile(llvm::raw_ostream& out_stream) {
+
+bool CompilationUnit::MaterializeToString(std::string& str_buffer) {
+  llvm::raw_string_ostream str_os(str_buffer);
+  return MaterializeToRawOStream(str_os);
+}
+
+
+bool CompilationUnit::MaterializeToRawOStream(llvm::raw_ostream& out_stream) {
   // Lookup the LLVM target
   char const* target_triple = NULL;
   char const* target_cpu = "";
   char const* target_attr = NULL;
 
-  switch (insn_set_) {
+  InstructionSet insn_set = GetInstructionSet();
+  switch (insn_set) {
   case kThumb2:
     target_triple = "thumb-none-linux-gnueabi";
     target_cpu = "cortex-a9";
@@ -281,7 +252,7 @@
     break;
 
   default:
-    LOG(FATAL) << "Unknown instruction set: " << insn_set_;
+    LOG(FATAL) << "Unknown instruction set: " << insn_set;
   }
 
   std::string errmsg;
@@ -375,11 +346,6 @@
       return false;
     }
 
-    // FIXME: Unable to run the UpdateFrameSizePass pass since it tries to
-    //        update the value reside in the different address space.
-    // Add pass to update the frame_size_in_bytes_
-    //pm.add(new ::UpdateFrameSizePass(this));
-
     // Run the per-function optimization
     fpm.doInitialization();
     for (llvm::Module::iterator F = module_->begin(), E = module_->end();
@@ -395,5 +361,130 @@
   return true;
 }
 
+
+bool CompilationUnit::ExtractCodeAndPrelink(const std::string& elf_image) {
+  llvm::OwningPtr<llvm::MemoryBuffer> elf_image_buff(
+    llvm::MemoryBuffer::getMemBuffer(llvm::StringRef(elf_image.data(),
+                                                     elf_image.size())));
+
+  llvm::OwningPtr<llvm::object::ObjectFile> elf_file(
+    llvm::object::ObjectFile::createELFObjectFile(elf_image_buff.take()));
+
+  llvm::error_code ec;
+
+  const ProcedureLinkageTable& plt = compiler_llvm_->GetProcedureLinkageTable();
+
+  for (llvm::object::section_iterator
+       sec_iter = elf_file->begin_sections(),
+       sec_end = elf_file->end_sections();
+       sec_iter != sec_end; sec_iter.increment(ec)) {
+
+    CHECK(ec == 0) << "Failed to read section because " << ec.message();
+
+    // Read the section information
+    llvm::StringRef name;
+    uint64_t alignment = 0u;
+    uint64_t size = 0u;
+
+    CHECK(sec_iter->getName(name) == 0);
+    CHECK(sec_iter->getSize(size) == 0);
+    CHECK(sec_iter->getAlignment(alignment) == 0);
+
+    if (name == ".data" || name == ".bss" || name == ".rodata") {
+      if (size > 0) {
+        LOG(FATAL) << "Compilation unit " << cunit_idx_ << " has non-empty "
+                   << name.str() << " section";
+      }
+
+    } else if (name == "" || name == ".rel.text" ||
+               name == ".ARM.attributes" || name == ".symtab" ||
+               name == ".strtab" || name == ".shstrtab") {
+      // We can ignore these sections.  We don't have to copy them into
+      // the result Oat file.
+
+    } else if (name == ".text") {
+      // Ensure the alignment requirement is less than or equal to
+      // kArchAlignment
+      CheckCodeAlign(alignment);
+
+      // Copy the compiled code
+      llvm::StringRef contents;
+      CHECK(sec_iter->getContents(contents) == 0);
+
+      copy(contents.data(),
+           contents.data() + contents.size(),
+           back_inserter(compiled_code_));
+
+      // Prelink the compiled code
+      for (llvm::object::relocation_iterator
+           rel_iter = sec_iter->begin_relocations(),
+           rel_end = sec_iter->end_relocations(); rel_iter != rel_end;
+           rel_iter.increment(ec)) {
+
+        CHECK(ec == 0) << "Failed to read relocation because " << ec.message();
+
+        // Read the relocation information
+        llvm::object::SymbolRef sym_ref;
+        uint64_t rel_offset = 0;
+        uint64_t rel_type = 0;
+        int64_t rel_addend = 0;
+
+        CHECK(rel_iter->getSymbol(sym_ref) == 0);
+        CHECK(rel_iter->getOffset(rel_offset) == 0);
+        CHECK(rel_iter->getType(rel_type) == 0);
+        CHECK(rel_iter->getAdditionalInfo(rel_addend) == 0);
+
+        // Read the symbol related to this relocation fixup
+        llvm::StringRef sym_name;
+        CHECK(sym_ref.getName(sym_name) == 0);
+
+        // Relocate the fixup.
+        // TODO: Support more relocation type.
+        CHECK(rel_type == llvm::ELF::R_ARM_ABS32);
+        CHECK_LE(rel_offset + 4, compiled_code_.size());
+
+        uintptr_t dest_addr = plt.GetEntryAddress(sym_name.str().c_str());
+        uintptr_t final_addr = dest_addr + rel_addend;
+        compiled_code_[rel_offset] = final_addr & 0xff;
+        compiled_code_[rel_offset + 1] = (final_addr >> 8) & 0xff;
+        compiled_code_[rel_offset + 2] = (final_addr >> 16) & 0xff;
+        compiled_code_[rel_offset + 3] = (final_addr >> 24) & 0xff;
+      }
+
+    } else {
+      LOG(WARNING) << "Unexpected section: " << name.str();
+    }
+  }
+
+  return true;
+}
+
+
+// Check whether the align is less than or equal to the code alignment of
+// that architecture.  Since the Oat writer only guarantee that the compiled
+// method being aligned to kArchAlignment, we have no way to align the ELf
+// section if the section alignment is greater than kArchAlignment.
+void CompilationUnit::CheckCodeAlign(uint32_t align) const {
+  InstructionSet insn_set = GetInstructionSet();
+  switch (insn_set) {
+  case kThumb2:
+  case kArm:
+    CHECK_LE(align, static_cast<uint32_t>(kArmAlignment));
+    break;
+
+  case kX86:
+    CHECK_LE(align, static_cast<uint32_t>(kX86Alignment));
+    break;
+
+  case kMips:
+    CHECK_LE(align, static_cast<uint32_t>(kMipsAlignment));
+    break;
+
+  default:
+    LOG(FATAL) << "Unknown instruction set: " << insn_set;
+  }
+}
+
+
 } // namespace compiler_llvm
 } // namespace art
diff --git a/src/compiler_llvm/compilation_unit.h b/src/compiler_llvm/compilation_unit.h
index d391620..576b65f 100644
--- a/src/compiler_llvm/compilation_unit.h
+++ b/src/compiler_llvm/compilation_unit.h
@@ -18,7 +18,6 @@
 #define ART_SRC_COMPILER_LLVM_COMPILATION_UNIT_H_
 
 #include "../mutex.h"
-#include "elf_image.h"
 #include "globals.h"
 #include "instruction_set.h"
 #include "logging.h"
@@ -44,81 +43,52 @@
 namespace art {
 namespace compiler_llvm {
 
+class CompilerLLVM;
 class IRBuilder;
 
 class CompilationUnit {
  public:
-  CompilationUnit(InstructionSet insn_set, size_t elf_idx);
+  CompilationUnit(const CompilerLLVM* compiler_llvm,
+                  size_t cunit_idx);
 
   ~CompilationUnit();
 
-  size_t GetElfIndex() const {
-    return elf_idx_;
+  size_t GetIndex() const {
+    return cunit_idx_;
   }
 
-  InstructionSet GetInstructionSet() const {
-    cunit_lock_.AssertHeld();
-    return insn_set_;
-  }
+  InstructionSet GetInstructionSet() const;
 
   llvm::LLVMContext* GetLLVMContext() const {
-    cunit_lock_.AssertHeld();
     return context_.get();
   }
 
   llvm::Module* GetModule() const {
-    cunit_lock_.AssertHeld();
     return module_;
   }
 
   IRBuilder* GetIRBuilder() const {
-    cunit_lock_.AssertHeld();
     return irb_.get();
   }
 
-  ElfImage GetElfImage() const {
-    MutexLock GUARD(cunit_lock_);
-    CHECK_GT(elf_image_.size(), 0u);
-    return ElfImage(elf_image_);
-  }
-
-  uint16_t AcquireUniqueElfFuncIndex() {
-    cunit_lock_.AssertHeld();
-    CHECK(num_elf_funcs_ < UINT16_MAX);
-    return num_elf_funcs_++;
-  }
-
   void SetBitcodeFileName(const std::string& bitcode_filename) {
-    MutexLock GUARD(cunit_lock_);
     bitcode_filename_ = bitcode_filename;
   }
 
-  bool Materialize(size_t thread_count);
+  bool Materialize();
 
   bool IsMaterialized() const {
-    MutexLock GUARD(cunit_lock_);
     return (context_.get() == NULL);
   }
 
-  bool IsMaterializeThresholdReached() const {
-    MutexLock GUARD(cunit_lock_);
-    return (mem_usage_ > 1000000u); // (threshold: 1 MB)
+  const std::vector<uint8_t>& GetCompiledCode() const {
+    DCHECK(IsMaterialized());
+    return compiled_code_;
   }
 
-  void AddMemUsageApproximation(size_t usage) {
-    MutexLock GUARD(cunit_lock_);
-    mem_usage_ += usage;
-  }
-
-  void RegisterCompiledMethod(const llvm::Function* func, CompiledMethod* cm);
-
-  void UpdateFrameSizeInBytes(const llvm::Function* func, size_t frame_size_in_bytes);
-
-  mutable Mutex cunit_lock_;
-
  private:
-  InstructionSet insn_set_;
-  const size_t elf_idx_;
+  const CompilerLLVM* compiler_llvm_;
+  const size_t cunit_idx_;
 
   UniquePtr<llvm::LLVMContext> context_;
   UniquePtr<IRBuilder> irb_;
@@ -126,15 +96,24 @@
   llvm::Module* module_;
 
   std::string bitcode_filename_;
-  std::string elf_image_;
 
-  typedef SafeMap<const llvm::Function*, CompiledMethod*> CompiledMethodMap;
-  UniquePtr<CompiledMethodMap> compiled_methods_map_;
+  std::vector<uint8_t> compiled_code_;
 
-  size_t mem_usage_;
-  uint16_t num_elf_funcs_;
+  SafeMap<const llvm::Function*, CompiledMethod*> compiled_methods_map_;
 
-  bool MaterializeToFile(llvm::raw_ostream& out_stream);
+  void CheckCodeAlign(uint32_t offset) const;
+
+  void DeleteResources() {
+    module_ = NULL; // Managed by context_
+    context_.reset(NULL);
+    irb_.reset(NULL);
+    runtime_support_.reset(NULL);
+  }
+
+  bool MaterializeToString(std::string& str_buffer);
+  bool MaterializeToRawOStream(llvm::raw_ostream& out_stream);
+
+  bool ExtractCodeAndPrelink(const std::string& elf_image);
 };
 
 } // namespace compiler_llvm
diff --git a/src/compiler_llvm/compiler_llvm.cc b/src/compiler_llvm/compiler_llvm.cc
index 6c8188e..b793fbd 100644
--- a/src/compiler_llvm/compiler_llvm.cc
+++ b/src/compiler_llvm/compiler_llvm.cc
@@ -22,8 +22,6 @@
 #include "compiled_method.h"
 #include "compiler.h"
 #include "dex_cache.h"
-#include "elf_image.h"
-#include "elf_loader.h"
 #include "ir_builder.h"
 #include "jni_compiler.h"
 #include "method_compiler.h"
@@ -95,9 +93,9 @@
 
 
 CompilerLLVM::CompilerLLVM(Compiler* compiler, InstructionSet insn_set)
-    : compiler_(compiler), compiler_lock_("llvm_compiler_lock"),
-      insn_set_(insn_set), curr_cunit_(NULL) {
-
+    : compiler_(compiler), insn_set_(insn_set),
+      num_cunits_lock_("compilation unit counter lock"), num_cunits_(0),
+      plt_(insn_set) {
 
   // Initialize LLVM libraries
   pthread_once(&llvm_initialized, InitializeLLVM);
@@ -105,152 +103,21 @@
 
 
 CompilerLLVM::~CompilerLLVM() {
-  STLDeleteElements(&cunits_);
 }
 
 
-void CompilerLLVM::EnsureCompilationUnit() {
-  compiler_lock_.AssertHeld();
-
-  if (curr_cunit_ != NULL) {
-    return;
-  }
-
-  // Allocate compilation unit
-  size_t cunit_idx = cunits_.size();
-  curr_cunit_ = new CompilationUnit(insn_set_, cunit_idx);
-
-  // Register compilation unit
-  cunits_.push_back(curr_cunit_);
-}
-
-
-void CompilerLLVM::MaterializeRemainder() {
-  compiler_lock_.Lock();
-  // Localize
-  CompilationUnit* cunit = curr_cunit_;
-  // Reset the curr_cuit_
-  curr_cunit_ = NULL;
-  compiler_lock_.Unlock();
-
-  if (cunit != NULL) {
-    Materialize(cunit);
-  }
-}
-
-
-void CompilerLLVM::MaterializeIfThresholdReached() {
-  compiler_lock_.Lock();
-  // Localize
-  CompilationUnit* cunit = curr_cunit_;
-
-  if (curr_cunit_ != NULL && curr_cunit_->IsMaterializeThresholdReached()) {
-    // Delete the compilation unit
-    curr_cunit_ = NULL;
-  } else {
-    // Reset cunit such that Materialize() won't be invoked
-    cunit = NULL;
-  }
-
-  compiler_lock_.Unlock();
-
-  if (cunit != NULL) {
-    Materialize(cunit);
-  }
-}
-
-
-void CompilerLLVM::Materialize(CompilationUnit* cunit) {
-  DCHECK(cunit != NULL);
-  DCHECK(!cunit->IsMaterialized());
-
-  // Write bitcode to file when filename is set
-  if (IsBitcodeFileNameAvailable()) {
-    const size_t cunit_idx = cunits_.size();
-    cunit->SetBitcodeFileName(
-      StringPrintf("%s-%zu", bitcode_filename_.c_str(), cunit_idx));
-  }
-
-  // Materialize the llvm::Module into ELF object file
-  cunit->Materialize(compiler_->GetThreadCount());
-
-  // Load ELF image when automatic ELF loading is enabled
-  if (IsAutoElfLoadingEnabled()) {
-    LoadElfFromCompilationUnit(cunit);
-  }
-}
-
-
-void CompilerLLVM::EnableAutoElfLoading() {
-  MutexLock GUARD(compiler_lock_);
-
-  if (IsAutoElfLoadingEnabled()) {
-    // If there is an existing ELF loader, then do nothing.
-    // Because the existing ELF loader may have returned some code address
-    // already.  If we replace the existing ELF loader with
-    // elf_loader_.reset(...), then it is possible to have some dangling
-    // pointer.
-    return;
-  }
-
-  // Create ELF loader and load the materialized CompilationUnit
-  elf_loader_.reset(new ElfLoader());
-
-  for (size_t i = 0; i < cunits_.size(); ++i) {
-    if (cunits_[i]->IsMaterialized()) {
-      LoadElfFromCompilationUnit(cunits_[i]);
-    }
-  }
-}
-
-
-void CompilerLLVM::LoadElfFromCompilationUnit(const CompilationUnit* cunit) {
-  MutexLock GUARD(compiler_lock_);
-  DCHECK(cunit->IsMaterialized()) << cunit->GetElfIndex();
-
-  if (!elf_loader_->LoadElfAt(cunit->GetElfIndex(),
-                              cunit->GetElfImage(),
-                              OatFile::kRelocAll)) {
-    LOG(ERROR) << "Failed to load ELF from compilation unit "
-               << cunit->GetElfIndex();
-  }
-}
-
-
-const void* CompilerLLVM::GetMethodCodeAddr(const CompiledMethod* cm) const {
-  return elf_loader_->GetMethodCodeAddr(cm->GetElfIndex(),
-                                        cm->GetElfFuncIndex());
-}
-
-
-const Method::InvokeStub* CompilerLLVM::
-GetMethodInvokeStubAddr(const CompiledInvokeStub* cm) const {
-  return elf_loader_->GetMethodInvokeStubAddr(cm->GetElfIndex(),
-                                              cm->GetElfFuncIndex());
-}
-
-
-std::vector<ElfImage> CompilerLLVM::GetElfImages() const {
-  std::vector<ElfImage> result;
-
-  for (size_t i = 0; i < cunits_.size(); ++i) {
-    result.push_back(cunits_[i]->GetElfImage());
-  }
-
-  return result;
+CompilationUnit* CompilerLLVM::AllocateCompilationUnit() {
+  MutexLock GUARD(num_cunits_lock_);
+  return new CompilationUnit(this, num_cunits_++);
 }
 
 
 CompiledMethod* CompilerLLVM::
 CompileDexMethod(OatCompilationUnit* oat_compilation_unit) {
-  MutexLock GUARD(compiler_lock_);
-
-  EnsureCompilationUnit();
-
-  MutexLock GUARD_CUNIT(curr_cunit_->cunit_lock_);
+  UniquePtr<CompilationUnit> cunit(AllocateCompilationUnit());
 
   UniquePtr<MethodCompiler> method_compiler(
-      new MethodCompiler(curr_cunit_, compiler_, oat_compilation_unit));
+      new MethodCompiler(cunit.get(), compiler_, oat_compilation_unit));
 
   return method_compiler->Compile();
 }
@@ -258,14 +125,10 @@
 
 CompiledMethod* CompilerLLVM::
 CompileNativeMethod(OatCompilationUnit* oat_compilation_unit) {
-  MutexLock GUARD(compiler_lock_);
-
-  EnsureCompilationUnit();
-
-  MutexLock GUARD_CUNIT(curr_cunit_->cunit_lock_);
+  UniquePtr<CompilationUnit> cunit(AllocateCompilationUnit());
 
   UniquePtr<JniCompiler> jni_compiler(
-      new JniCompiler(curr_cunit_, *compiler_, oat_compilation_unit));
+      new JniCompiler(cunit.get(), *compiler_, oat_compilation_unit));
 
   return jni_compiler->Compile();
 }
@@ -273,28 +136,20 @@
 
 CompiledInvokeStub* CompilerLLVM::CreateInvokeStub(bool is_static,
                                                    char const *shorty) {
-  MutexLock GUARD(compiler_lock_);
-
-  EnsureCompilationUnit();
-
-  MutexLock GUARD_CUNIT(curr_cunit_->cunit_lock_);
+  UniquePtr<CompilationUnit> cunit(AllocateCompilationUnit());
 
   UniquePtr<StubCompiler> stub_compiler(
-    new StubCompiler(curr_cunit_, *compiler_));
+    new StubCompiler(cunit.get(), *compiler_));
 
   return stub_compiler->CreateInvokeStub(is_static, shorty);
 }
 
 
 CompiledInvokeStub* CompilerLLVM::CreateProxyStub(char const *shorty) {
-  MutexLock GUARD(compiler_lock_);
-
-  EnsureCompilationUnit();
-
-  MutexLock GUARD_CUNIT(curr_cunit_->cunit_lock_);
+  UniquePtr<CompilationUnit> cunit(AllocateCompilationUnit());
 
   UniquePtr<StubCompiler> stub_compiler(
-    new StubCompiler(curr_cunit_, *compiler_));
+    new StubCompiler(cunit.get(), *compiler_));
 
   return stub_compiler->CreateProxyStub(shorty);
 }
@@ -324,6 +179,11 @@
   compiler.SetCompilerContext(compiler_llvm);
 }
 
+extern "C" void ArtUnInitCompilerContext(art::Compiler& compiler) {
+  delete ContextOf(compiler);
+  compiler.SetCompilerContext(NULL);
+}
+
 extern "C" art::CompiledMethod* ArtCompileMethod(art::Compiler& compiler,
                                                  const art::DexFile::CodeItem* code_item,
                                                  uint32_t access_flags, uint32_t method_idx,
@@ -338,7 +198,6 @@
     method_idx, access_flags);
   art::compiler_llvm::CompilerLLVM* compiler_llvm = ContextOf(compiler);
   art::CompiledMethod* result = compiler_llvm->CompileDexMethod(&oat_compilation_unit);
-  compiler_llvm->MaterializeIfThresholdReached();
   return result;
 }
 
@@ -354,7 +213,6 @@
 
   art::compiler_llvm::CompilerLLVM* compiler_llvm = ContextOf(compiler);
   art::CompiledMethod* result = compiler_llvm->CompileNativeMethod(&oat_compilation_unit);
-  compiler_llvm->MaterializeIfThresholdReached();
   return result;
 }
 
@@ -364,7 +222,6 @@
                                                         uint32_t shorty_len) {
   art::compiler_llvm::CompilerLLVM* compiler_llvm = ContextOf(compiler);
   art::CompiledInvokeStub* result = compiler_llvm->CreateInvokeStub(is_static, shorty);
-  compiler_llvm->MaterializeIfThresholdReached();
   return result;
 }
 
@@ -373,7 +230,6 @@
                                                        uint32_t shorty_len) {
   art::compiler_llvm::CompilerLLVM* compiler_llvm = ContextOf(compiler);
   art::CompiledInvokeStub* result = compiler_llvm->CreateProxyStub(shorty);
-  compiler_llvm->MaterializeIfThresholdReached();
   return result;
 }
 
@@ -381,37 +237,3 @@
                                                std::string const& filename) {
   ContextOf(compiler)->SetBitcodeFileName(filename);
 }
-
-extern "C" void compilerLLVMMaterializeRemainder(art::Compiler& compiler) {
-  ContextOf(compiler)->MaterializeRemainder();
-}
-
-extern "C" void compilerLLVMEnableAutoElfLoading(art::Compiler& compiler) {
-  art::compiler_llvm::CompilerLLVM* compiler_llvm =
-      reinterpret_cast<art::compiler_llvm::CompilerLLVM*>(compiler.GetCompilerContext());
-  return compiler_llvm->EnableAutoElfLoading();
-}
-
-extern "C" const void* compilerLLVMGetMethodCodeAddr(const art::Compiler& compiler,
-                                                     const art::CompiledMethod* cm,
-                                                     const art::Method*) {
-  const art::compiler_llvm::CompilerLLVM* compiler_llvm =
-      reinterpret_cast<const art::compiler_llvm::CompilerLLVM*>(compiler.GetCompilerContext());
-  return compiler_llvm->GetMethodCodeAddr(cm);
-}
-
-extern "C" const art::Method::InvokeStub* compilerLLVMGetMethodInvokeStubAddr(const art::Compiler& compiler,
-                                                                              const art::CompiledInvokeStub* cm,
-                                                                              const art::Method*) {
-  const art::compiler_llvm::CompilerLLVM* compiler_llvm =
-      reinterpret_cast<const art::compiler_llvm::CompilerLLVM*>(compiler.GetCompilerContext());
-  return compiler_llvm->GetMethodInvokeStubAddr(cm);
-}
-
-extern "C" std::vector<art::ElfImage> compilerLLVMGetElfImages(const art::Compiler& compiler) {
-  return ContextOf(compiler)->GetElfImages();
-}
-
-extern "C" void compilerLLVMDispose(art::Compiler& compiler) {
-  delete ContextOf(compiler);
-}
diff --git a/src/compiler_llvm/compiler_llvm.h b/src/compiler_llvm/compiler_llvm.h
index 7cc4a0e..24a766e 100644
--- a/src/compiler_llvm/compiler_llvm.h
+++ b/src/compiler_llvm/compiler_llvm.h
@@ -19,10 +19,10 @@
 
 #include "compiler.h"
 #include "dex_file.h"
-#include "elf_image.h"
 #include "instruction_set.h"
 #include "macros.h"
 #include "object.h"
+#include "procedure_linkage_table.h"
 
 #include <UniquePtr.h>
 
@@ -54,7 +54,6 @@
 namespace compiler_llvm {
 
 class CompilationUnit;
-class ElfLoader;
 class IRBuilder;
 
 class CompilerLLVM {
@@ -63,10 +62,6 @@
 
   ~CompilerLLVM();
 
-  void MaterializeIfThresholdReached();
-
-  void MaterializeRemainder();
-
   Compiler* GetCompiler() const {
     return compiler_;
   }
@@ -75,31 +70,10 @@
     return insn_set_;
   }
 
-  size_t GetNumCompilationUnits() const {
-    return cunits_.size();
-  }
-
-  const CompilationUnit* GetCompilationUnit(size_t i) const {
-    return cunits_[i];
-  }
-
   void SetBitcodeFileName(std::string const& filename) {
     bitcode_filename_ = filename;
   }
 
-  void EnableAutoElfLoading();
-
-  bool IsAutoElfLoadingEnabled() const {
-    return (elf_loader_.get() != NULL);
-  }
-
-  const void* GetMethodCodeAddr(const CompiledMethod* cm) const;
-
-  const Method::InvokeStub* GetMethodInvokeStubAddr(
-                                const CompiledInvokeStub* cm) const;
-
-  std::vector<ElfImage> GetElfImages() const;
-
   CompiledMethod* CompileDexMethod(OatCompilationUnit* oat_compilation_unit);
 
   CompiledMethod* CompileNativeMethod(OatCompilationUnit* oat_compilation_unit);
@@ -108,32 +82,29 @@
 
   CompiledInvokeStub* CreateProxyStub(const char *shorty);
 
+  const ProcedureLinkageTable& GetProcedureLinkageTable() const {
+    return plt_;
+  }
+
  private:
-  void EnsureCompilationUnit();
+  CompilationUnit* AllocateCompilationUnit();
 
   void Materialize(CompilationUnit* cunit);
 
-  void LoadElfFromCompilationUnit(const CompilationUnit* cunit);
-
   bool IsBitcodeFileNameAvailable() const {
     return !bitcode_filename_.empty();
   }
 
   Compiler* compiler_;
 
- public:
-  Mutex compiler_lock_;
-
- private:
   InstructionSet insn_set_;
 
-  CompilationUnit* curr_cunit_;
-
-  std::vector<CompilationUnit*> cunits_;
+  Mutex num_cunits_lock_;
+  size_t num_cunits_;
 
   std::string bitcode_filename_;
 
-  UniquePtr<ElfLoader> elf_loader_;
+  ProcedureLinkageTable plt_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilerLLVM);
 };
diff --git a/src/compiler_llvm/elf_loader.cc b/src/compiler_llvm/elf_loader.cc
deleted file mode 100644
index 8432a07..0000000
--- a/src/compiler_llvm/elf_loader.cc
+++ /dev/null
@@ -1,134 +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 "elf_loader.h"
-
-#include "compiled_method.h"
-#include "elf_image.h"
-#include "logging.h"
-#include "oat_file.h"
-#include "object.h"
-#include "runtime_support_llvm.h"
-#include "utils_llvm.h"
-
-#include <android/librsloader.h>
-
-namespace art {
-namespace compiler_llvm {
-
-
-ElfLoader::~ElfLoader() {
-  // Release every ELF object
-  for (size_t i = 0; i < executables_.size(); ++i) {
-    rsloaderDisposeExec(executables_[i]);
-  }
-}
-
-
-bool ElfLoader::LoadElfAt(size_t elf_idx,
-                          const ElfImage& elf_image,
-                          OatFile::RelocationBehavior reloc) {
-  if (elf_idx < executables_.size() && executables_[elf_idx] != NULL) {
-    return false;
-  }
-
-  if (elf_idx >= executables_.size()) {
-    executables_.resize(elf_idx + 1);
-    elf_images_.resize(elf_idx + 1);
-  }
-
-  RSExecRef executable = rsloaderLoadExecutable(elf_image.begin(),
-                                                elf_image.size(),
-                                                reloc == OatFile::kRelocNone ? 1 : 0);
-
-  if (executable == NULL) {
-    LOG(WARNING) << "Failed to load ELF"
-                 << " image: " << static_cast<const void*>(elf_image.begin())
-                 << " size: " << elf_image.size();
-    return false;
-  }
-
-  if (reloc == OatFile::kRelocAll) {
-    if (!rsloaderRelocateExecutable(executable,
-                                    art_find_runtime_support_func, NULL)) {
-      LOG(ERROR) << "Failed to relocate the ELF image";
-      rsloaderDisposeExec(executable);
-      return false;
-    }
-    relocated = true;
-  }
-
-  executables_[elf_idx] = executable;
-  elf_images_[elf_idx] = elf_image;
-  return true;
-}
-
-
-void ElfLoader::RelocateExecutable() {
-  if (relocated) {
-    return;
-  }
-  LOG(INFO) << "Reload ELF for relocate.";
-  for (size_t i = 0; i < executables_.size(); ++i) {
-    if (executables_[i] != NULL) {
-      // TODO: After implement in-place linking, we will no longer need to dispose and reload.
-      rsloaderDisposeExec(executables_[i]);
-      executables_[i] = rsloaderLoadExecutable(elf_images_[i].begin(), elf_images_[i].size(), 0);
-      if (executables_[i] == NULL) {
-        LOG(FATAL) << "Failed to reload ELF image " << i;
-      }
-      if (!rsloaderRelocateExecutable(executables_[i],
-                                      art_find_runtime_support_func, NULL)) {
-        LOG(FATAL) << "Failed to relocate ELF image " << i;
-      }
-    }
-  }
-  relocated = true;
-}
-
-
-const void* ElfLoader::GetMethodCodeAddr(uint16_t elf_idx,
-                                         uint16_t elf_func_idx) const {
-  CHECK_LT(elf_idx, executables_.size());
-  return GetAddr(elf_idx, ElfFuncName(elf_func_idx).c_str());
-}
-
-
-const Method::InvokeStub* ElfLoader::
-GetMethodInvokeStubAddr(uint16_t elf_idx, uint16_t elf_func_idx) const {
-  CHECK_LT(elf_idx, executables_.size());
-  return reinterpret_cast<const Method::InvokeStub*>(
-      GetAddr(elf_idx, ElfFuncName(elf_func_idx).c_str()));
-}
-
-
-size_t ElfLoader::GetCodeSize(uint16_t elf_idx, uint16_t elf_func_idx) const {
-  CHECK_LT(elf_idx, executables_.size());
-  CHECK(executables_[elf_idx] != NULL);
-  return rsloaderGetSymbolSize(executables_[elf_idx],
-                               ElfFuncName(elf_func_idx).c_str());
-}
-
-
-const void* ElfLoader::GetAddr(size_t elf_idx, const char* sym_name) const {
-  CHECK_LT(elf_idx, executables_.size());
-  CHECK(executables_[elf_idx] != NULL);
-  return rsloaderGetSymbolAddress(executables_[elf_idx], sym_name);
-}
-
-
-} // namespace compiler_llvm
-} // namespace art
diff --git a/src/compiler_llvm/elf_loader.h b/src/compiler_llvm/elf_loader.h
deleted file mode 100644
index 9e8611c..0000000
--- a/src/compiler_llvm/elf_loader.h
+++ /dev/null
@@ -1,61 +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_SRC_COMPILER_LLVM_ELF_LOADER_H_
-#define ART_SRC_COMPILER_LLVM_ELF_LOADER_H_
-
-#include "elf_image.h"
-#include "globals.h"
-#include "oat_file.h"
-#include "object.h"
-
-#include <android/librsloader.h>
-#include <vector>
-
-namespace art {
-namespace compiler_llvm {
-
-class ElfLoader {
- public:
-  ElfLoader() : relocated(false) {}
-  ~ElfLoader();
-
-  bool LoadElfAt(size_t elf_idx, const ElfImage& elf_image,
-                 OatFile::RelocationBehavior reloc);
-
-  void RelocateExecutable();
-
-  const void* GetMethodCodeAddr(uint16_t elf_idx,
-                                uint16_t elf_func_idx) const;
-
-  const Method::InvokeStub* GetMethodInvokeStubAddr(uint16_t elf_idx,
-                                                    uint16_t elf_func_idx) const;
-
-  size_t GetCodeSize(uint16_t elf_idx, uint16_t elf_func_idx) const;
-
- private:
-  const void* GetAddr(size_t elf_idx, const char* sym_name) const;
-
-  bool relocated;
-  std::vector<ElfImage> elf_images_;
-  std::vector<RSExecRef> executables_;
-};
-
-
-} // namespace compiler_llvm
-} // namespace art
-
-#endif // ART_SRC_COMPILER_LLVM_ELF_LOADER_H_
diff --git a/src/compiler_llvm/jni_compiler.cc b/src/compiler_llvm/jni_compiler.cc
index 37ca82f..f4f5be5 100644
--- a/src/compiler_llvm/jni_compiler.cc
+++ b/src/compiler_llvm/jni_compiler.cc
@@ -51,8 +51,7 @@
   class_loader_(oat_compilation_unit->class_loader_),
   dex_cache_(oat_compilation_unit->dex_cache_),
   dex_file_(oat_compilation_unit->dex_file_),
-  method_(dex_cache_->GetResolvedMethod(method_idx_)),
-  elf_func_idx_(cunit_->AcquireUniqueElfFuncIndex()) {
+  method_(dex_cache_->GetResolvedMethod(method_idx_)) {
 
   // Check: Ensure that the method is resolved
   CHECK_NE(method_, static_cast<art::Method*>(NULL));
@@ -262,26 +261,16 @@
   // Verify the generated bitcode
   VERIFY_LLVM_FUNCTION(*func_);
 
-  // Add the memory usage approximation of the compilation unit
-  cunit_->AddMemUsageApproximation((sirt_size * 4 + 50) * 50);
-  // NOTE: We will emit 4 LLVM instructions per object argument,
-  // And about 50 instructions for other operations. (Some runtime support will be inlined.)
-  // Beside, we guess that we have to use 50 bytes to represent one LLVM instruction.
+  cunit_->Materialize();
 
-  CompiledMethod* compiled_method =
-      new CompiledMethod(cunit_->GetInstructionSet(),
-                         cunit_->GetElfIndex(),
-                         elf_func_idx_);
-
-  cunit_->RegisterCompiledMethod(func_, compiled_method);
-
-  return compiled_method;
+  return new CompiledMethod(cunit_->GetInstructionSet(),
+                            cunit_->GetCompiledCode());
 }
 
 
 void JniCompiler::CreateFunction() {
   // LLVM function name
-  std::string func_name(ElfFuncName(elf_func_idx_));
+  std::string func_name(ElfFuncName(cunit_->GetIndex()));
 
   // Get function type
   llvm::FunctionType* func_type =
diff --git a/src/compiler_llvm/method_compiler.cc b/src/compiler_llvm/method_compiler.cc
index eef71db..da8f91a 100644
--- a/src/compiler_llvm/method_compiler.cc
+++ b/src/compiler_llvm/method_compiler.cc
@@ -72,8 +72,7 @@
     basic_block_landing_pads_(code_item_->tries_size_, NULL),
     basic_block_unwind_(NULL), basic_block_unreachable_(NULL),
     shadow_frame_(NULL), old_shadow_frame_(NULL),
-    already_pushed_shadow_frame_(NULL), shadow_frame_size_(0),
-    elf_func_idx_(cunit_->AcquireUniqueElfFuncIndex()) {
+    already_pushed_shadow_frame_(NULL), shadow_frame_size_(0) {
 }
 
 
@@ -84,7 +83,7 @@
 
 void MethodCompiler::CreateFunction() {
   // LLVM function name
-  std::string func_name(ElfFuncName(elf_func_idx_));
+  std::string func_name(ElfFuncName(cunit_->GetIndex()));
 
   // Get function type
   llvm::FunctionType* func_type =
@@ -3616,20 +3615,10 @@
   // Verify the generated bitcode
   VERIFY_LLVM_FUNCTION(*func_);
 
-  // Add the memory usage approximation of the compilation unit
-  cunit_->AddMemUsageApproximation(code_item_->insns_size_in_code_units_ * 900);
-  // NOTE: From statistics, the bitcode size is 4.5 times bigger than the
-  // Dex file.  Besides, we have to convert the code unit into bytes.
-  // Thus, we got our magic number 9.
+  cunit_->Materialize();
 
-  CompiledMethod* compiled_method =
-    new CompiledMethod(cunit_->GetInstructionSet(),
-                       cunit_->GetElfIndex(),
-                       elf_func_idx_);
-
-  cunit_->RegisterCompiledMethod(func_, compiled_method);
-
-  return compiled_method;
+  return new CompiledMethod(cunit_->GetInstructionSet(),
+                            cunit_->GetCompiledCode());
 }
 
 
diff --git a/src/compiler_llvm/stub_compiler.cc b/src/compiler_llvm/stub_compiler.cc
index 0d64f0d..af05e52 100644
--- a/src/compiler_llvm/stub_compiler.cc
+++ b/src/compiler_llvm/stub_compiler.cc
@@ -48,13 +48,11 @@
 
 CompiledInvokeStub* StubCompiler::CreateInvokeStub(bool is_static,
                                                    char const* shorty) {
-  uint16_t elf_func_idx = cunit_->AcquireUniqueElfFuncIndex();
-
   CHECK(shorty != NULL);
   size_t shorty_size = strlen(shorty);
 
   // Function name
-  std::string func_name(ElfFuncName(elf_func_idx));
+  std::string func_name(ElfFuncName(cunit_->GetIndex()));
 
   // Get argument types
   llvm::Type* arg_types[] = {
@@ -186,15 +184,10 @@
   // Verify the generated function
   VERIFY_LLVM_FUNCTION(*func);
 
-  // Add the memory usage approximation of the compilation unit
-  cunit_->AddMemUsageApproximation((shorty_size * 3 + 8) * 50);
-  // NOTE: We will emit 3 LLVM instructions per shorty for the argument,
-  // plus 3 for pointer arithmetic, and 5 for code_addr, retval, ret_addr,
-  // store ret_addr, and ret_void.  Beside, we guess that we have to use
-  // 50 bytes to represent one LLVM instruction.
+  cunit_->Materialize();
 
   return new CompiledInvokeStub(cunit_->GetInstructionSet(),
-                                cunit_->GetElfIndex(), elf_func_idx);
+                                cunit_->GetCompiledCode());
 }
 
 
@@ -202,10 +195,8 @@
   CHECK(shorty != NULL);
   size_t shorty_size = strlen(shorty);
 
-  uint16_t elf_func_idx = cunit_->AcquireUniqueElfFuncIndex();
-
   // Function name
-  std::string func_name(ElfFuncName(elf_func_idx));
+  std::string func_name(ElfFuncName(cunit_->GetIndex()));
 
   // Accurate function type
   llvm::Type* accurate_ret_type = irb_.getJType(shorty[0], kAccurate);
@@ -266,11 +257,10 @@
   // Verify the generated function
   VERIFY_LLVM_FUNCTION(*func);
 
-  // Add the memory usage approximation of the compilation unit
-  cunit_->AddMemUsageApproximation((shorty_size + 2) * 50);
+  cunit_->Materialize();
 
   return new CompiledInvokeStub(cunit_->GetInstructionSet(),
-                                cunit_->GetElfIndex(), elf_func_idx);
+                                cunit_->GetCompiledCode());
 }
 
 
diff --git a/src/compiler_llvm/utils_llvm.h b/src/compiler_llvm/utils_llvm.h
index dd35f0a..eb5fd53 100644
--- a/src/compiler_llvm/utils_llvm.h
+++ b/src/compiler_llvm/utils_llvm.h
@@ -32,8 +32,8 @@
 #define VERIFY_LLVM_FUNCTION(func)
 #endif
 
-inline static std::string ElfFuncName(uint16_t elf_func_idx) {
-  return StringPrintf("Art%u", static_cast<unsigned int>(elf_func_idx));
+inline static std::string ElfFuncName(uint16_t idx) {
+  return StringPrintf("Art%u", static_cast<unsigned int>(idx));
 }
 
 class CStringLessThanComparator {
diff --git a/src/elf_image.h b/src/elf_image.h
deleted file mode 100644
index 094467a..0000000
--- a/src/elf_image.h
+++ /dev/null
@@ -1,63 +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_SRC_ELF_IMAGE_H_
-#define ART_SRC_ELF_IMAGE_H_
-
-#include "globals.h"
-#include <string>
-#include <vector>
-
-namespace art {
-
-class ElfImage {
- public:
-  explicit ElfImage(const std::vector<uint8_t>& v)
-      : begin_(&*v.begin()), size_(v.size()) {
-  }
-
-  explicit ElfImage(const std::string& s)
-      : begin_(reinterpret_cast<const uint8_t*>(s.data())), size_(s.size()) {
-  }
-
-  explicit ElfImage(const byte* begin, size_t size)
-      : begin_(begin), size_(size) {
-  }
-
-  // TODO: Remove this after implement in-place linking.
-  ElfImage() : begin_(NULL), size_(0) {
-  }
-
-  const byte* begin() const {
-    return begin_;
-  }
-
-  const byte* end() const {
-    return (begin_ + size_);
-  }
-
-  size_t size() const {
-    return size_;
-  }
-
- private:
-  const byte* begin_;
-  size_t size_;
-};
-
-} // namespace art
-
-#endif // ART_SRC_ELF_IMAGE_H_
diff --git a/src/oat.cc b/src/oat.cc
index ce7c133..cd9e0a3 100644
--- a/src/oat.cc
+++ b/src/oat.cc
@@ -29,7 +29,6 @@
 
 OatHeader::OatHeader(InstructionSet instruction_set,
                      const std::vector<const DexFile*>* dex_files,
-                     uint32_t elf_image_count,
                      uint32_t image_file_location_checksum,
                      const std::string& image_file_location) {
   memcpy(magic_, kOatMagic, sizeof(kOatMagic));
@@ -43,9 +42,6 @@
   dex_file_count_ = dex_files->size();
   UpdateChecksum(&dex_file_count_, sizeof(dex_file_count_));
 
-  elf_image_count_ = elf_image_count;
-  UpdateChecksum(&elf_image_count_, sizeof(elf_image_count_));
-
   image_file_location_checksum_ = image_file_location_checksum;
   UpdateChecksum(&image_file_location_checksum_, sizeof(image_file_location_checksum_));
 
@@ -53,7 +49,6 @@
   UpdateChecksum(&image_file_location_size_, sizeof(image_file_location_size_));
   UpdateChecksum(image_file_location.data(), image_file_location_size_);
 
-  elf_image_table_offset_ = 0;
   executable_offset_ = 0;
 }
 
@@ -77,16 +72,6 @@
   return dex_file_count_;
 }
 
-uint32_t OatHeader::GetElfImageCount() const {
-  DCHECK(IsValid());
-  return elf_image_count_;
-}
-
-uint32_t OatHeader::GetElfImageTableOffset() const {
-  DCHECK(IsValid());
-  return elf_image_table_offset_;
-}
-
 uint32_t OatHeader::GetChecksum() const {
   CHECK(IsValid());
   return adler32_checksum_;
@@ -131,12 +116,6 @@
                      GetImageFileLocationSize());
 }
 
-void OatHeader::SetElfImageTableOffset(uint32_t elf_image_table_offset) {
-  DCHECK(IsValid());
-  elf_image_table_offset_ = elf_image_table_offset;
-  UpdateChecksum(&elf_image_table_offset_, sizeof(elf_image_table_offset_));
-}
-
 void OatHeader::SetExecutableOffset(uint32_t executable_offset) {
   DCHECK_ALIGNED(executable_offset, kPageSize);
   CHECK_GT(executable_offset, sizeof(OatHeader));
@@ -156,12 +135,6 @@
     vmap_table_offset_(0),
     gc_map_offset_(0),
     invoke_stub_offset_(0)
-#if defined(ART_USE_LLVM_COMPILER)
-  , code_elf_idx_(static_cast<uint16_t>(-1u)),
-    code_elf_func_idx_(static_cast<uint16_t>(-1u)),
-    invoke_stub_elf_idx_(static_cast<uint16_t>(-1u)),
-    invoke_stub_elf_func_idx_(static_cast<uint16_t>(-1u))
-#endif
 {}
 
 OatMethodOffsets::OatMethodOffsets(uint32_t code_offset,
@@ -173,12 +146,7 @@
                                    uint32_t gc_map_offset,
                                    uint32_t invoke_stub_offset
 #if defined(ART_USE_LLVM_COMPILER)
-                                 , uint16_t code_elf_idx,
-                                   uint16_t code_elf_func_idx,
-                                   uint16_t invoke_stub_elf_idx,
-                                   uint16_t invoke_stub_elf_func_idx,
-                                   uint16_t proxy_stub_elf_idx,
-                                   uint16_t proxy_stub_elf_func_idx
+                                 , uint32_t proxy_stub_offset
 #endif
                                    )
   : code_offset_(code_offset),
@@ -190,12 +158,7 @@
     gc_map_offset_(gc_map_offset),
     invoke_stub_offset_(invoke_stub_offset)
 #if defined(ART_USE_LLVM_COMPILER)
-  , code_elf_idx_(code_elf_idx),
-    code_elf_func_idx_(code_elf_func_idx),
-    invoke_stub_elf_idx_(invoke_stub_elf_idx),
-    invoke_stub_elf_func_idx_(invoke_stub_elf_func_idx),
-    proxy_stub_elf_idx_(proxy_stub_elf_idx),
-    proxy_stub_elf_func_idx_(proxy_stub_elf_func_idx)
+  , proxy_stub_offset_(proxy_stub_offset)
 #endif
 {}
 
diff --git a/src/oat.h b/src/oat.h
index d1e177f..cd3330b 100644
--- a/src/oat.h
+++ b/src/oat.h
@@ -30,7 +30,6 @@
   OatHeader();
   OatHeader(InstructionSet instruction_set,
             const std::vector<const DexFile*>* dex_files,
-            uint32_t elf_image_count,
             uint32_t image_file_location_checksum,
             const std::string& image_file_location);
 
@@ -39,11 +38,8 @@
   uint32_t GetChecksum() const;
   void UpdateChecksum(const void* data, size_t length);
   uint32_t GetDexFileCount() const;
-  uint32_t GetElfImageCount() const;
-  uint32_t GetElfImageTableOffset() const;
   uint32_t GetExecutableOffset() const;
   InstructionSet GetInstructionSet() const;
-  void SetElfImageTableOffset(uint32_t elf_image_offset);
   void SetExecutableOffset(uint32_t executable_offset);
   uint32_t GetImageFileLocationChecksum() const;
   uint32_t GetImageFileLocationSize() const;
@@ -60,8 +56,6 @@
 
   InstructionSet instruction_set_;
   uint32_t dex_file_count_;
-  uint32_t elf_image_count_;
-  uint32_t elf_image_table_offset_;
   uint32_t executable_offset_;
 
   uint32_t image_file_location_checksum_;
@@ -74,6 +68,7 @@
 class PACKED OatMethodOffsets {
  public:
   OatMethodOffsets();
+
   OatMethodOffsets(uint32_t code_offset,
                    uint32_t frame_size_in_bytes,
                    uint32_t core_spill_mask,
@@ -83,14 +78,10 @@
                    uint32_t gc_map_offset,
                    uint32_t invoke_stub_offset
 #if defined(ART_USE_LLVM_COMPILER)
-                 , uint16_t code_elf_idx,
-                   uint16_t code_elf_func_idx,
-                   uint16_t invoke_stub_elf_idx,
-                   uint16_t invoke_stub_elf_func_idx,
-                   uint16_t proxy_stub_elf_idx,
-                   uint16_t proxy_stub_elf_func_idx
+                 , uint32_t proxy_stub_offset
 #endif
                    );
+
   ~OatMethodOffsets();
 
   uint32_t code_offset_;
@@ -103,12 +94,7 @@
   uint32_t invoke_stub_offset_;
 
 #if defined(ART_USE_LLVM_COMPILER)
-  uint16_t code_elf_idx_;
-  uint16_t code_elf_func_idx_;
-  uint16_t invoke_stub_elf_idx_;
-  uint16_t invoke_stub_elf_func_idx_;
-  uint16_t proxy_stub_elf_idx_;
-  uint16_t proxy_stub_elf_func_idx_;
+  uint32_t proxy_stub_offset_;
 #endif
 };
 
diff --git a/src/oat_file.cc b/src/oat_file.cc
index 239239b..f64f512 100644
--- a/src/oat_file.cc
+++ b/src/oat_file.cc
@@ -20,10 +20,6 @@
 #include "os.h"
 #include "stl_util.h"
 
-#if defined(ART_USE_LLVM_COMPILER)
-#include "compiler_llvm/elf_loader.h"
-#endif
-
 namespace art {
 
 std::string OatFile::DexFilenameToOatFilename(const std::string& location) {
@@ -64,19 +60,12 @@
 }
 
 OatFile::OatFile(const std::string& location)
-    : location_(location)
-#if defined(ART_USE_LLVM_COMPILER)
-    , elf_loader_(new compiler_llvm::ElfLoader())
-#endif
-{
+    : location_(location) {
   CHECK(!location_.empty());
 }
 
 OatFile::~OatFile() {
   STLDeleteValues(&oat_dex_files_);
-#if defined(ART_USE_LLVM_COMPILER)
-  STLDeleteElements(&oat_elf_images_);
-#endif
 }
 
 bool OatFile::Map(File& file,
@@ -182,31 +171,6 @@
                                                          methods_offsets_pointer));
   }
 
-#if !defined(ART_USE_LLVM_COMPILER)
-  CHECK_EQ(oat_header.GetElfImageTableOffset(), 0u);
-  CHECK_EQ(oat_header.GetElfImageCount(), 0u);
-
-#else
-  oat = map->Begin() + oat_header.GetElfImageTableOffset();
-  CHECK_EQ((reinterpret_cast<uintptr_t>(oat) & 0x3), 0u);
-
-  for (uint32_t i = 0, end = oat_header.GetElfImageCount(); i < end; ++i) {
-    uint32_t elf_offset = *reinterpret_cast<const uint32_t*>(oat);
-    oat += sizeof(uint32_t);
-
-    uint32_t elf_size = *reinterpret_cast<const uint32_t*>(oat);
-    oat += sizeof(uint32_t);
-
-    const byte* elf_begin = map->Begin() + elf_offset;
-
-    oat_elf_images_.push_back(new OatElfImage(this, elf_begin, elf_size));
-
-    if (!elf_loader_->LoadElfAt(i, ElfImage(elf_begin, elf_size), reloc)) {
-      LOG(ERROR) << "Failed to load ELF image.  index: " << i;
-    }
-  }
-#endif
-
   mem_map_.reset(map.release());
   return true;
 }
@@ -246,9 +210,7 @@
 }
 
 void OatFile::RelocateExecutable() {
-#if defined(ART_USE_LLVM_COMPILER)
-  elf_loader_->RelocateExecutable();
-#endif
+  UNIMPLEMENTED(WARNING) << "Relocate the executable";
 }
 
 OatFile::OatDexFile::OatDexFile(const OatFile* oat_file,
@@ -308,13 +270,7 @@
       oat_method_offsets.gc_map_offset_,
       oat_method_offsets.invoke_stub_offset_
 #if defined(ART_USE_LLVM_COMPILER)
-    , oat_file_->elf_loader_.get(),
-      oat_method_offsets.code_elf_idx_,
-      oat_method_offsets.code_elf_func_idx_,
-      oat_method_offsets.invoke_stub_elf_idx_,
-      oat_method_offsets.invoke_stub_elf_func_idx_,
-      oat_method_offsets.proxy_stub_elf_idx_,
-      oat_method_offsets.proxy_stub_elf_func_idx_
+    , oat_method_offsets.proxy_stub_offset_
 #endif
       );
 }
@@ -329,13 +285,7 @@
                               const uint32_t gc_map_offset,
                               const uint32_t invoke_stub_offset
 #if defined(ART_USE_LLVM_COMPILER)
-                            , const compiler_llvm::ElfLoader* elf_loader,
-                              const uint16_t code_elf_idx,
-                              const uint16_t code_elf_func_idx,
-                              const uint16_t invoke_stub_elf_idx,
-                              const uint16_t invoke_stub_elf_func_idx,
-                              const uint16_t proxy_stub_elf_idx,
-                              const uint16_t proxy_stub_elf_func_idx
+                            , const uint32_t proxy_stub_offset
 #endif
                               )
   : begin_(base),
@@ -348,13 +298,7 @@
     gc_map_offset_(gc_map_offset),
     invoke_stub_offset_(invoke_stub_offset)
 #if defined(ART_USE_LLVM_COMPILER)
-  , elf_loader_(elf_loader),
-    code_elf_idx_(code_elf_idx),
-    code_elf_func_idx_(code_elf_func_idx),
-    invoke_stub_elf_idx_(invoke_stub_elf_idx),
-    invoke_stub_elf_func_idx_(invoke_stub_elf_func_idx),
-    proxy_stub_elf_idx_(proxy_stub_elf_idx),
-    proxy_stub_elf_func_idx_(proxy_stub_elf_func_idx)
+  , proxy_stub_offset_(proxy_stub_offset)
 #endif
 {
 #ifndef NDEBUG
@@ -374,92 +318,37 @@
 OatFile::OatMethod::~OatMethod() {}
 
 const void* OatFile::OatMethod::GetCode() const {
-  if (!IsCodeInElf()) {
-    return GetOatPointer<const void*>(code_offset_);
-  } else {
-#if !defined(ART_USE_LLVM_COMPILER)
-    UNIMPLEMENTED(FATAL);
-    return NULL;
-#else
-    CHECK(elf_loader_ != NULL);
-    const void* code =
-        elf_loader_->GetMethodCodeAddr(code_elf_idx_, code_elf_func_idx_);
-    CHECK(code != NULL);
-    return code;
-#endif
-  }
+  return GetOatPointer<const void*>(code_offset_);
 }
 
 uint32_t OatFile::OatMethod::GetCodeSize() const {
-  if (!IsCodeInElf()) {
-    uintptr_t code = reinterpret_cast<uint32_t>(GetCode());
+  uintptr_t code = reinterpret_cast<uint32_t>(GetCode());
 
-    if (code == 0) {
-      return 0;
-    }
-    // TODO: make this Thumb2 specific
-    code &= ~0x1;
-    return reinterpret_cast<uint32_t*>(code)[-1];
-  } else {
-#if !defined(ART_USE_LLVM_COMPILER)
-    UNIMPLEMENTED(ERROR);
+  if (code == 0) {
     return 0;
-#else
-    CHECK(elf_loader_ != NULL);
-    return elf_loader_->GetCodeSize(code_elf_idx_, code_elf_func_idx_);
-#endif
   }
+  // TODO: make this Thumb2 specific
+  code &= ~0x1;
+  return reinterpret_cast<uint32_t*>(code)[-1];
 }
 
 const Method::InvokeStub* OatFile::OatMethod::GetInvokeStub() const {
-  if (!IsInvokeStubInElf()) {
-    return GetOatPointer<const Method::InvokeStub*>(invoke_stub_offset_);
-  } else {
-#if !defined(ART_USE_LLVM_COMPILER)
-    UNIMPLEMENTED(FATAL);
-    return NULL;
-#else
-    CHECK(elf_loader_ != NULL);
-    const Method::InvokeStub* stub =
-        elf_loader_->GetMethodInvokeStubAddr(invoke_stub_elf_idx_,
-                                             invoke_stub_elf_func_idx_);
-    CHECK(stub != NULL);
-    return stub;
-#endif
-  }
+  return GetOatPointer<const Method::InvokeStub*>(invoke_stub_offset_);
 }
 
 uint32_t OatFile::OatMethod::GetInvokeStubSize() const {
-  if (!IsInvokeStubInElf()) {
-    uintptr_t code = reinterpret_cast<uint32_t>(GetInvokeStub());
-    if (code == 0) {
-      return 0;
-    }
-    // TODO: make this Thumb2 specific
-    code &= ~0x1;
-    return reinterpret_cast<uint32_t*>(code)[-1];
-  } else {
-#if !defined(ART_USE_LLVM_COMPILER)
-    UNIMPLEMENTED(WARNING);
+  uintptr_t code = reinterpret_cast<uint32_t>(GetInvokeStub());
+  if (code == 0) {
     return 0;
-#else
-    CHECK(elf_loader_ != NULL);
-    return elf_loader_->GetCodeSize(invoke_stub_elf_idx_,
-                                    invoke_stub_elf_func_idx_);
-#endif
   }
+  // TODO: make this Thumb2 specific
+  code &= ~0x1;
+  return reinterpret_cast<uint32_t*>(code)[-1];
 }
 
 #if defined(ART_USE_LLVM_COMPILER)
 const void* OatFile::OatMethod::GetProxyStub() const {
-  CHECK(elf_loader_ != NULL);
-  const void* stub = NULL;
-  if (proxy_stub_elf_func_idx_ != static_cast<uint16_t>(-1)) {
-    stub = elf_loader_->GetMethodCodeAddr(proxy_stub_elf_idx_,
-                                          proxy_stub_elf_func_idx_);
-    CHECK(stub != NULL);
-  }
-  return stub;
+  return GetOatPointer<const void*>(proxy_stub_offset_);
 }
 #endif
 
@@ -487,12 +376,4 @@
   method->SetOatInvokeStubOffset(GetInvokeStubOffset());
 }
 
-#if defined(ART_USE_LLVM_COMPILER)
-OatFile::OatElfImage::OatElfImage(const OatFile* oat_file,
-                                  const byte* addr,
-                                  uint32_t size)
-    : oat_file_(oat_file), elf_addr_(addr), elf_size_(size) {
-}
-#endif
-
 }  // namespace art
diff --git a/src/oat_file.h b/src/oat_file.h
index a4ca2de..856a033 100644
--- a/src/oat_file.h
+++ b/src/oat_file.h
@@ -25,14 +25,6 @@
 #include "oat.h"
 #include "object.h"
 
-#if defined(ART_USE_LLVM_COMPILER)
-namespace art {
-  namespace compiler_llvm {
-    class ElfLoader;
-  }
-}
-#endif
-
 namespace art {
 
 class OatFile {
@@ -103,37 +95,6 @@
       return invoke_stub_offset_;
     }
 
-#if defined(ART_USE_LLVM_COMPILER)
-    uint16_t GetCodeElfIndex() const {
-      return code_elf_idx_;
-    }
-    uint16_t GetCodeElfFuncIndex() const {
-      return code_elf_func_idx_;
-    }
-    uint16_t GetInvokeStubElfIndex() const {
-      return invoke_stub_elf_idx_;
-    }
-    uint16_t GetInvokeStubElfFuncIndex() const {
-      return invoke_stub_elf_func_idx_;
-    }
-#endif
-
-    bool IsCodeInElf() const {
-#if defined(ART_USE_LLVM_COMPILER)
-      return (code_elf_idx_ != static_cast<uint16_t>(-1));
-#else
-      return false;
-#endif
-    }
-
-    bool IsInvokeStubInElf() const {
-#if defined(ART_USE_LLVM_COMPILER)
-      return (invoke_stub_elf_idx_ != static_cast<uint16_t>(-1));
-#else
-      return false;
-#endif
-    }
-
     const void* GetCode() const;
     uint32_t GetCodeSize() const;
 
@@ -167,13 +128,7 @@
               const uint32_t gc_map_offset,
               const uint32_t invoke_stub_offset
 #if defined(ART_USE_LLVM_COMPILER)
-            , const compiler_llvm::ElfLoader* elf_loader,
-              const uint16_t code_elf_idx,
-              const uint16_t code_elf_func_idx,
-              const uint16_t invoke_stub_elf_idx,
-              const uint16_t invoke_stub_elf_func_idx,
-              const uint16_t proxy_stub_elf_idx,
-              const uint16_t proxy_stub_elf_func_idx
+            , const uint32_t proxy_stub_offset
 #endif
               );
 
@@ -198,14 +153,7 @@
     uint32_t invoke_stub_offset_;
 
 #if defined(ART_USE_LLVM_COMPILER)
-    const compiler_llvm::ElfLoader* elf_loader_;
-
-    uint16_t code_elf_idx_;
-    uint16_t code_elf_func_idx_;
-    uint16_t invoke_stub_elf_idx_;
-    uint16_t invoke_stub_elf_func_idx_;
-    uint16_t proxy_stub_elf_idx_;
-    uint16_t proxy_stub_elf_func_idx_;
+    uint32_t proxy_stub_offset_;
 #endif
 
     friend class OatClass;
@@ -266,43 +214,10 @@
     DISALLOW_COPY_AND_ASSIGN(OatDexFile);
   };
 
-#if defined(ART_USE_LLVM_COMPILER)
-  class OatElfImage {
-   public:
-    const byte* begin() const {
-      return elf_addr_;
-    }
-
-    const byte* end() const {
-      return (elf_addr_ + elf_size_);
-    }
-
-    size_t size() const {
-      return elf_size_;
-    }
-
-   private:
-    OatElfImage(const OatFile* oat_file, const byte* addr, uint32_t size);
-
-    const OatFile* oat_file_;
-    const byte* elf_addr_;
-    uint32_t elf_size_;
-
-    friend class OatFile;
-    DISALLOW_COPY_AND_ASSIGN(OatElfImage);
-  };
-#endif
-
   const OatDexFile* GetOatDexFile(const std::string& dex_file_location,
                                   bool warn_if_not_found = true) const;
   std::vector<const OatDexFile*> GetOatDexFiles() const;
 
-#if defined(ART_USE_LLVM_COMPILER)
-  const OatElfImage* GetOatElfImage(size_t i) const {
-    return oat_elf_images_[i];
-  }
-#endif
-
   size_t Size() const {
     return End() - Begin();
   }
@@ -327,11 +242,6 @@
   typedef SafeMap<std::string, const OatDexFile*> Table;
   Table oat_dex_files_;
 
-#if defined(ART_USE_LLVM_COMPILER)
-  std::vector<OatElfImage*> oat_elf_images_;
-  UniquePtr<compiler_llvm::ElfLoader> elf_loader_;
-#endif
-
   friend class OatClass;
   friend class OatDexFile;
   friend class OatDumper;  // For GetBase and GetLimit
diff --git a/src/oat_writer.cc b/src/oat_writer.cc
index 2558eba..013a561 100644
--- a/src/oat_writer.cc
+++ b/src/oat_writer.cc
@@ -20,7 +20,6 @@
 
 #include "class_linker.h"
 #include "class_loader.h"
-#include "elf_image.h"
 #include "file.h"
 #include "os.h"
 #include "safe_map.h"
@@ -53,15 +52,12 @@
   image_file_location_checksum_ = image_file_location_checksum;
   image_file_location_ = image_file_location;
   dex_files_ = &dex_files;
-  elf_images_ = compiler_->GetElfImages();
   oat_header_ = NULL;
   executable_offset_padding_length_ = 0;
 
   size_t offset = InitOatHeader();
   offset = InitOatDexFiles(offset);
   offset = InitDexFiles(offset);
-  offset = InitOatElfImages(offset);
-  offset = InitElfImages(offset);
   offset = InitOatClasses(offset);
   offset = InitOatCode(offset);
   offset = InitOatCodeDexFiles(offset);
@@ -72,7 +68,6 @@
 OatWriter::~OatWriter() {
   delete oat_header_;
   STLDeleteElements(&oat_dex_files_);
-  STLDeleteElements(&oat_elf_images_);
   STLDeleteElements(&oat_classes_);
 }
 
@@ -80,7 +75,6 @@
   // create the OatHeader
   oat_header_ = new OatHeader(compiler_->GetInstructionSet(),
                               dex_files_,
-                              elf_images_.size(),
                               image_file_location_checksum_,
                               image_file_location_);
   size_t offset = sizeof(*oat_header_);
@@ -115,34 +109,6 @@
   return offset;
 }
 
-size_t OatWriter::InitOatElfImages(size_t offset) {
-  size_t n = elf_images_.size();
-  if (n != 0) {
-    // Offset to ELF image table should be rounded up to 4-byte aligned, so that
-    // we can read the uint32_t directly.
-    offset = RoundUp(offset, 4);
-    oat_header_->SetElfImageTableOffset(offset);
-  } else {
-    oat_header_->SetElfImageTableOffset(0);
-  }
-
-  for (size_t i = 0; i < n; ++i) {
-    OatElfImage* oat_elf_image = new OatElfImage(elf_images_[i]);
-    oat_elf_images_.push_back(oat_elf_image);
-    offset += oat_elf_image->SizeOf();
-  }
-  return offset;
-}
-
-size_t OatWriter::InitElfImages(size_t offset) {
-  for (size_t i = 0; i < oat_elf_images_.size(); ++i) {
-    offset = RoundUp(offset, 4);
-    oat_elf_images_[i]->SetElfOffset(offset);
-    offset += oat_elf_images_[i]->GetElfSize();
-  }
-  return offset;
-}
-
 size_t OatWriter::InitOatClasses(size_t offset) {
   // create the OatClasses
   // calculate the offsets within OatDexFiles to OatClasses
@@ -258,10 +224,6 @@
                                     uint32_t method_idx, const DexFile* dex_file) {
   // derived from CompiledMethod if available
   uint32_t code_offset = 0;
-#if defined(ART_USE_LLVM_COMPILER)
-  uint16_t code_elf_idx = static_cast<uint16_t>(-1u);
-  uint16_t code_elf_func_idx = static_cast<uint16_t>(-1u);
-#endif
   uint32_t frame_size_in_bytes = kStackAlignment;
   uint32_t core_spill_mask = 0;
   uint32_t fp_spill_mask = 0;
@@ -271,125 +233,107 @@
   // derived from CompiledInvokeStub if available
   uint32_t invoke_stub_offset = 0;
 #if defined(ART_USE_LLVM_COMPILER)
-  uint16_t invoke_stub_elf_idx = static_cast<uint16_t>(-1u);
-  uint16_t invoke_stub_elf_func_idx = static_cast<uint16_t>(-1u);
-  uint16_t proxy_stub_elf_idx = static_cast<uint16_t>(-1u);
-  uint16_t proxy_stub_elf_func_idx = static_cast<uint16_t>(-1u);
+  uint32_t proxy_stub_offset = 0;
 #endif
 
   CompiledMethod* compiled_method =
       compiler_->GetCompiledMethod(Compiler::MethodReference(dex_file, method_idx));
   if (compiled_method != NULL) {
-    if (compiled_method->IsExecutableInElf()) {
-#if defined(ART_USE_LLVM_COMPILER)
-      code_elf_idx = compiled_method->GetElfIndex();
-      code_elf_func_idx = compiled_method->GetElfFuncIndex();
-#endif
-      frame_size_in_bytes = compiled_method->GetFrameSizeInBytes();
+    offset = compiled_method->AlignCode(offset);
+    DCHECK_ALIGNED(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);
+    uint32_t thumb_offset = compiled_method->CodeDelta();
+    code_offset = offset + sizeof(code_size) + thumb_offset;
+
+    // Deduplicate code arrays
+    SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator code_iter = code_offsets_.find(&code);
+    if (code_iter != code_offsets_.end()) {
+      code_offset = code_iter->second;
     } else {
-      offset = compiled_method->AlignCode(offset);
-      DCHECK_ALIGNED(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);
-      uint32_t thumb_offset = compiled_method->CodeDelta();
-      code_offset = offset + sizeof(code_size) + thumb_offset;
+      code_offsets_.Put(&code, code_offset);
+      offset += sizeof(code_size);  // code size is prepended before code
+      offset += code_size;
+      oat_header_->UpdateChecksum(&code[0], code_size);
+    }
+    frame_size_in_bytes = compiled_method->GetFrameSizeInBytes();
+    core_spill_mask = compiled_method->GetCoreSpillMask();
+    fp_spill_mask = compiled_method->GetFpSpillMask();
 
-      // Deduplicate code arrays
-      SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator code_iter = code_offsets_.find(&code);
-      if (code_iter != code_offsets_.end()) {
-        code_offset = code_iter->second;
-      } else {
-        code_offsets_.Put(&code, code_offset);
-        offset += sizeof(code_size);  // code size is prepended before code
-        offset += code_size;
-        oat_header_->UpdateChecksum(&code[0], code_size);
-      }
-      frame_size_in_bytes = compiled_method->GetFrameSizeInBytes();
-      core_spill_mask = compiled_method->GetCoreSpillMask();
-      fp_spill_mask = compiled_method->GetFpSpillMask();
+    const std::vector<uint32_t>& mapping_table = compiled_method->GetMappingTable();
+    size_t mapping_table_size = mapping_table.size() * sizeof(mapping_table[0]);
+    mapping_table_offset = (mapping_table_size == 0) ? 0 : offset;
 
-      const std::vector<uint32_t>& mapping_table = compiled_method->GetMappingTable();
-      size_t mapping_table_size = mapping_table.size() * sizeof(mapping_table[0]);
-      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);
+    if (mapping_iter != mapping_table_offsets_.end()) {
+      mapping_table_offset = mapping_iter->second;
+    } else {
+      mapping_table_offsets_.Put(&mapping_table, mapping_table_offset);
+      offset += mapping_table_size;
+      oat_header_->UpdateChecksum(&mapping_table[0], mapping_table_size);
+    }
 
-      // Deduplicate mapping tables
-      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 {
-        mapping_table_offsets_.Put(&mapping_table, mapping_table_offset);
-        offset += mapping_table_size;
-        oat_header_->UpdateChecksum(&mapping_table[0], mapping_table_size);
-      }
+    const std::vector<uint16_t>& vmap_table = compiled_method->GetVmapTable();
+    size_t vmap_table_size = vmap_table.size() * sizeof(vmap_table[0]);
+    vmap_table_offset = (vmap_table_size == 0) ? 0 : offset;
 
-      const std::vector<uint16_t>& vmap_table = compiled_method->GetVmapTable();
-      size_t vmap_table_size = vmap_table.size() * sizeof(vmap_table[0]);
-      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);
+    if (vmap_iter != vmap_table_offsets_.end()) {
+      vmap_table_offset = vmap_iter->second;
+    } else {
+      vmap_table_offsets_.Put(&vmap_table, vmap_table_offset);
+      offset += vmap_table_size;
+      oat_header_->UpdateChecksum(&vmap_table[0], vmap_table_size);
+    }
 
-      // Deduplicate vmap tables
-      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 {
-        vmap_table_offsets_.Put(&vmap_table, vmap_table_offset);
-        offset += vmap_table_size;
-        oat_header_->UpdateChecksum(&vmap_table[0], vmap_table_size);
-      }
+    const std::vector<uint8_t>& gc_map = compiled_method->GetGcMap();
+    size_t gc_map_size = gc_map.size() * sizeof(gc_map[0]);
+    gc_map_offset = (gc_map_size == 0) ? 0 : offset;
 
-      const std::vector<uint8_t>& gc_map = compiled_method->GetGcMap();
-      size_t gc_map_size = gc_map.size() * sizeof(gc_map[0]);
-      gc_map_offset = (gc_map_size == 0) ? 0 : offset;
-
-#ifndef NDEBUG
-      // We expect GC maps except when the class hasn't been verified or the method is native
-      CompiledClass* compiled_class =
-          compiler_->GetCompiledClass(Compiler::MethodReference(dex_file, class_def_index));
-      Class::Status status =
-          (compiled_class != NULL) ? compiled_class->GetStatus() : Class::kStatusNotReady;
-      CHECK(gc_map_size != 0 || is_native || status < Class::kStatusVerified)
-          << &gc_map << " " << gc_map_size << " " << (is_native ? "true" : "false") << " " << (status < Class::kStatusVerified) << " " << status << " " << PrettyMethod(method_idx, *dex_file);
+#if !defined(NDEBUG) && !defined(ART_USE_LLVM_COMPILER)
+    // We expect GC maps except when the class hasn't been verified or the method is native
+    CompiledClass* compiled_class =
+        compiler_->GetCompiledClass(Compiler::MethodReference(dex_file, class_def_index));
+    Class::Status status =
+        (compiled_class != NULL) ? compiled_class->GetStatus() : Class::kStatusNotReady;
+    CHECK(gc_map_size != 0 || is_native || status < Class::kStatusVerified)
+        << &gc_map << " " << gc_map_size << " " << (is_native ? "true" : "false") << " " << (status < Class::kStatusVerified) << " " << status << " " << PrettyMethod(method_idx, *dex_file);
 #endif
 
-      // Deduplicate GC maps
-      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 {
-        gc_map_offsets_.Put(&gc_map, gc_map_offset);
-        offset += gc_map_size;
-        oat_header_->UpdateChecksum(&gc_map[0], gc_map_size);
-      }
+    // Deduplicate GC maps
+    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 {
+      gc_map_offsets_.Put(&gc_map, gc_map_offset);
+      offset += gc_map_size;
+      oat_header_->UpdateChecksum(&gc_map[0], gc_map_size);
     }
   }
 
   const char* shorty = dex_file->GetMethodShorty(dex_file->GetMethodId(method_idx));
   const CompiledInvokeStub* compiled_invoke_stub = compiler_->FindInvokeStub(is_static, shorty);
   if (compiled_invoke_stub != NULL) {
-    if (compiled_invoke_stub->IsExecutableInElf()) {
-#if defined(ART_USE_LLVM_COMPILER)
-      invoke_stub_elf_idx = compiled_invoke_stub->GetElfIndex();
-      invoke_stub_elf_func_idx = compiled_invoke_stub->GetElfFuncIndex();
-#endif
-    } else {
-      offset = CompiledMethod::AlignCode(offset, compiler_->GetInstructionSet());
-      DCHECK_ALIGNED(offset, kArmAlignment);
-      const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
-      uint32_t invoke_stub_size = invoke_stub.size() * sizeof(invoke_stub[0]);
-      CHECK_NE(invoke_stub_size, 0U);
-      uint32_t thumb_offset = compiled_invoke_stub->CodeDelta();
-      invoke_stub_offset = offset + sizeof(invoke_stub_size) + thumb_offset;
+    offset = CompiledMethod::AlignCode(offset, compiler_->GetInstructionSet());
+    DCHECK_ALIGNED(offset, kArmAlignment);
+    const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
+    uint32_t invoke_stub_size = invoke_stub.size() * sizeof(invoke_stub[0]);
+    CHECK_NE(invoke_stub_size, 0U);
+    uint32_t thumb_offset = compiled_invoke_stub->CodeDelta();
+    invoke_stub_offset = offset + sizeof(invoke_stub_size) + thumb_offset;
 
-      // Deduplicate invoke stubs
-      SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator stub_iter = code_offsets_.find(&invoke_stub);
-      if (stub_iter != code_offsets_.end()) {
-        invoke_stub_offset = stub_iter->second;
-      } else {
-        code_offsets_.Put(&invoke_stub, invoke_stub_offset);
-        offset += sizeof(invoke_stub_size);  // invoke stub size is prepended before code
-        offset += invoke_stub_size;
-        oat_header_->UpdateChecksum(&invoke_stub[0], invoke_stub_size);
-      }
+    // Deduplicate invoke stubs
+    SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator stub_iter = code_offsets_.find(&invoke_stub);
+    if (stub_iter != code_offsets_.end()) {
+      invoke_stub_offset = stub_iter->second;
+    } else {
+      code_offsets_.Put(&invoke_stub, invoke_stub_offset);
+      offset += sizeof(invoke_stub_size);  // invoke stub size is prepended before code
+      offset += invoke_stub_size;
+      oat_header_->UpdateChecksum(&invoke_stub[0], invoke_stub_size);
     }
   }
 
@@ -397,9 +341,24 @@
   if (!is_static) {
     const CompiledInvokeStub* compiled_proxy_stub = compiler_->FindProxyStub(shorty);
     if (compiled_proxy_stub != NULL) {
-      DCHECK(compiled_proxy_stub->IsExecutableInElf());
-      proxy_stub_elf_idx = compiled_proxy_stub->GetElfIndex();
-      proxy_stub_elf_func_idx = compiled_proxy_stub->GetElfFuncIndex();
+      offset = CompiledMethod::AlignCode(offset, compiler_->GetInstructionSet());
+      DCHECK_ALIGNED(offset, kArmAlignment);
+      const std::vector<uint8_t>& proxy_stub = compiled_proxy_stub->GetCode();
+      uint32_t proxy_stub_size = proxy_stub.size() * sizeof(proxy_stub[0]);
+      CHECK_NE(proxy_stub_size, 0U);
+      uint32_t thumb_offset = compiled_proxy_stub->CodeDelta();
+      proxy_stub_offset = offset + sizeof(proxy_stub_size) + thumb_offset;
+
+      // Deduplicate proxy stubs
+      SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator stub_iter = code_offsets_.find(&proxy_stub);
+      if (stub_iter != code_offsets_.end()) {
+        proxy_stub_offset = stub_iter->second;
+      } else {
+        code_offsets_.Put(&proxy_stub, proxy_stub_offset);
+        offset += sizeof(proxy_stub_size);  // proxy stub size is prepended before code
+        offset += proxy_stub_size;
+        oat_header_->UpdateChecksum(&proxy_stub[0], proxy_stub_size);
+      }
     }
   }
 #endif
@@ -414,12 +373,7 @@
                          gc_map_offset,
                          invoke_stub_offset
 #if defined(ART_USE_LLVM_COMPILER)
-                       , code_elf_idx,
-                         code_elf_func_idx,
-                         invoke_stub_elf_idx,
-                         invoke_stub_elf_func_idx,
-                         proxy_stub_elf_idx,
-                         proxy_stub_elf_func_idx
+                       , proxy_stub_offset
 #endif
                          );
 
@@ -505,25 +459,6 @@
       return false;
     }
   }
-  for (size_t i = 0; i != oat_elf_images_.size(); ++i) {
-    if (!oat_elf_images_[i]->Write(file)) {
-      PLOG(ERROR) << "Failed to write oat elf information to " << file->name();
-      return false;
-    }
-  }
-  for (size_t i = 0; i != oat_elf_images_.size(); ++i) {
-    uint32_t expected_offset = oat_elf_images_[i]->GetElfOffset();
-    off_t actual_offset = lseek(file->Fd(), expected_offset, SEEK_SET);
-    if (static_cast<uint32_t>(actual_offset) != expected_offset) {
-      PLOG(ERROR) << "Failed to seek to dex file section."
-                  << " Actual: " << actual_offset
-                  << " Expected: " << expected_offset;
-      return false;
-    }
-    if (!oat_elf_images_[i]->WriteElfImage(file)) {
-      return false;
-    }
-  }
   for (size_t i = 0; i != oat_classes_.size(); ++i) {
     if (!oat_classes_[i]->Write(file)) {
       PLOG(ERROR) << "Failed to write oat methods information to " << file->name();
@@ -629,126 +564,169 @@
 
 
   if (compiled_method != NULL) {  // ie. not an abstract method
-    if (!compiled_method->IsExecutableInElf()) {
-      uint32_t aligned_code_offset = compiled_method->AlignCode(code_offset);
-      uint32_t aligned_code_delta = aligned_code_offset - code_offset;
-      if (aligned_code_delta != 0) {
-        off_t new_offset = lseek(file->Fd(), aligned_code_delta, SEEK_CUR);
-        if (static_cast<uint32_t>(new_offset) != aligned_code_offset) {
-          PLOG(ERROR) << "Failed to seek to align oat code. Actual: " << new_offset
-                      << " Expected: " << aligned_code_offset << " File: " << file->name();
-          return 0;
-        }
-        code_offset += aligned_code_delta;
-        DCHECK_CODE_OFFSET();
+    uint32_t aligned_code_offset = compiled_method->AlignCode(code_offset);
+    uint32_t aligned_code_delta = aligned_code_offset - code_offset;
+    if (aligned_code_delta != 0) {
+      off_t new_offset = lseek(file->Fd(), aligned_code_delta, SEEK_CUR);
+      if (static_cast<uint32_t>(new_offset) != aligned_code_offset) {
+        PLOG(ERROR) << "Failed to seek to align oat code. Actual: " << new_offset
+                    << " Expected: " << aligned_code_offset << " File: " << file->name();
+        return 0;
       }
-      DCHECK_ALIGNED(code_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 offset = code_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() && offset != method_offsets.code_offset_) {
-        DCHECK(code_iter->second == method_offsets.code_offset_) << PrettyMethod(method_idx, dex_file);
-      } else {
-        DCHECK(offset == method_offsets.code_offset_) << PrettyMethod(method_idx, dex_file);
-        if (!file->WriteFully(&code_size, sizeof(code_size))) {
-          ReportWriteFailure("method code size", method_idx, dex_file, file);
-          return 0;
-        }
-        code_offset += sizeof(code_size);
-        DCHECK_CODE_OFFSET();
-        if (!file->WriteFully(&code[0], code_size)) {
-          ReportWriteFailure("method code", method_idx, dex_file, file);
-          return 0;
-        }
-        code_offset += code_size;
-      }
-      DCHECK_CODE_OFFSET();
-
-      const std::vector<uint32_t>& mapping_table = compiled_method->GetMappingTable();
-      size_t mapping_table_size = mapping_table.size() * sizeof(mapping_table[0]);
-
-      // Deduplicate mapping tables
-      SafeMap<const std::vector<uint32_t>*, uint32_t>::iterator mapping_iter =
-          mapping_table_offsets_.find(&mapping_table);
-      if (mapping_iter != mapping_table_offsets_.end() &&
-          code_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)
-            || code_offset == method_offsets.mapping_table_offset_)
-            << PrettyMethod(method_idx, dex_file);
-        if (!file->WriteFully(&mapping_table[0], mapping_table_size)) {
-          ReportWriteFailure("mapping table", method_idx, dex_file, file);
-          return 0;
-        }
-        code_offset += mapping_table_size;
-      }
-      DCHECK_CODE_OFFSET();
-
-      const std::vector<uint16_t>& vmap_table = compiled_method->GetVmapTable();
-      size_t vmap_table_size = vmap_table.size() * sizeof(vmap_table[0]);
-
-      // Deduplicate vmap tables
-      SafeMap<const std::vector<uint16_t>*, uint32_t>::iterator vmap_iter =
-          vmap_table_offsets_.find(&vmap_table);
-      if (vmap_iter != vmap_table_offsets_.end() &&
-          code_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)
-            || code_offset == method_offsets.vmap_table_offset_)
-            << PrettyMethod(method_idx, dex_file);
-        if (!file->WriteFully(&vmap_table[0], vmap_table_size)) {
-          ReportWriteFailure("vmap table", method_idx, dex_file, file);
-          return 0;
-        }
-        code_offset += vmap_table_size;
-      }
-      DCHECK_CODE_OFFSET();
-
-      const std::vector<uint8_t>& gc_map = compiled_method->GetGcMap();
-      size_t gc_map_size = gc_map.size() * sizeof(gc_map[0]);
-
-      // Deduplicate GC maps
-      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() &&
-          code_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)
-            || code_offset == method_offsets.gc_map_offset_)
-            << PrettyMethod(method_idx, dex_file);
-        if (!file->WriteFully(&gc_map[0], gc_map_size)) {
-          ReportWriteFailure("GC map", method_idx, dex_file, file);
-          return 0;
-        }
-        code_offset += gc_map_size;
-      }
+      code_offset += aligned_code_delta;
       DCHECK_CODE_OFFSET();
     }
+    DCHECK_ALIGNED(code_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 offset = code_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() && offset != method_offsets.code_offset_) {
+      DCHECK(code_iter->second == method_offsets.code_offset_) << PrettyMethod(method_idx, dex_file);
+    } else {
+      DCHECK(offset == method_offsets.code_offset_) << PrettyMethod(method_idx, dex_file);
+      if (!file->WriteFully(&code_size, sizeof(code_size))) {
+        ReportWriteFailure("method code size", method_idx, dex_file, file);
+        return 0;
+      }
+      code_offset += sizeof(code_size);
+      DCHECK_CODE_OFFSET();
+      if (!file->WriteFully(&code[0], code_size)) {
+        ReportWriteFailure("method code", method_idx, dex_file, file);
+        return 0;
+      }
+      code_offset += code_size;
+    }
+    DCHECK_CODE_OFFSET();
+
+    const std::vector<uint32_t>& mapping_table = compiled_method->GetMappingTable();
+    size_t mapping_table_size = mapping_table.size() * sizeof(mapping_table[0]);
+
+    // Deduplicate mapping tables
+    SafeMap<const std::vector<uint32_t>*, uint32_t>::iterator mapping_iter =
+        mapping_table_offsets_.find(&mapping_table);
+    if (mapping_iter != mapping_table_offsets_.end() &&
+        code_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)
+          || code_offset == method_offsets.mapping_table_offset_)
+          << PrettyMethod(method_idx, dex_file);
+      if (!file->WriteFully(&mapping_table[0], mapping_table_size)) {
+        ReportWriteFailure("mapping table", method_idx, dex_file, file);
+        return 0;
+      }
+      code_offset += mapping_table_size;
+    }
+    DCHECK_CODE_OFFSET();
+
+    const std::vector<uint16_t>& vmap_table = compiled_method->GetVmapTable();
+    size_t vmap_table_size = vmap_table.size() * sizeof(vmap_table[0]);
+
+    // Deduplicate vmap tables
+    SafeMap<const std::vector<uint16_t>*, uint32_t>::iterator vmap_iter =
+        vmap_table_offsets_.find(&vmap_table);
+    if (vmap_iter != vmap_table_offsets_.end() &&
+        code_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)
+          || code_offset == method_offsets.vmap_table_offset_)
+          << PrettyMethod(method_idx, dex_file);
+      if (!file->WriteFully(&vmap_table[0], vmap_table_size)) {
+        ReportWriteFailure("vmap table", method_idx, dex_file, file);
+        return 0;
+      }
+      code_offset += vmap_table_size;
+    }
+    DCHECK_CODE_OFFSET();
+
+    const std::vector<uint8_t>& gc_map = compiled_method->GetGcMap();
+    size_t gc_map_size = gc_map.size() * sizeof(gc_map[0]);
+
+    // Deduplicate GC maps
+    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() &&
+        code_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)
+          || code_offset == method_offsets.gc_map_offset_)
+          << PrettyMethod(method_idx, dex_file);
+      if (!file->WriteFully(&gc_map[0], gc_map_size)) {
+        ReportWriteFailure("GC map", method_idx, dex_file, file);
+        return 0;
+      }
+      code_offset += gc_map_size;
+    }
+    DCHECK_CODE_OFFSET();
   }
   const char* shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx));
   const CompiledInvokeStub* compiled_invoke_stub = compiler_->FindInvokeStub(is_static, shorty);
   if (compiled_invoke_stub != NULL) {
-    if (!compiled_invoke_stub->IsExecutableInElf()) {
+    uint32_t aligned_code_offset = CompiledMethod::AlignCode(code_offset,
+                                                             compiler_->GetInstructionSet());
+    uint32_t aligned_code_delta = aligned_code_offset - code_offset;
+    if (aligned_code_delta != 0) {
+      off_t new_offset = lseek(file->Fd(), aligned_code_delta, SEEK_CUR);
+      if (static_cast<uint32_t>(new_offset) != aligned_code_offset) {
+        PLOG(ERROR) << "Failed to seek to align invoke stub code. Actual: " << new_offset
+                    << " Expected: " << aligned_code_offset;
+        return 0;
+      }
+      code_offset += aligned_code_delta;
+      DCHECK_CODE_OFFSET();
+    }
+    DCHECK_ALIGNED(code_offset, kArmAlignment);
+    const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
+    uint32_t invoke_stub_size = invoke_stub.size() * sizeof(invoke_stub[0]);
+    CHECK_NE(invoke_stub_size, 0U);
+
+    // Deduplicate invoke stubs
+    size_t offset = code_offset + sizeof(invoke_stub_size) + compiled_invoke_stub->CodeDelta();
+    SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator stub_iter =
+        code_offsets_.find(&invoke_stub);
+    if (stub_iter != code_offsets_.end() && offset != method_offsets.invoke_stub_offset_) {
+      DCHECK(stub_iter->second == method_offsets.invoke_stub_offset_) << PrettyMethod(method_idx, dex_file);
+    } else {
+      DCHECK(offset == method_offsets.invoke_stub_offset_) << PrettyMethod(method_idx, dex_file);
+      if (!file->WriteFully(&invoke_stub_size, sizeof(invoke_stub_size))) {
+        ReportWriteFailure("invoke stub code size", method_idx, dex_file, file);
+        return 0;
+      }
+      code_offset += sizeof(invoke_stub_size);
+      DCHECK_CODE_OFFSET();
+      if (!file->WriteFully(&invoke_stub[0], invoke_stub_size)) {
+        ReportWriteFailure("invoke stub code", method_idx, dex_file, file);
+        return 0;
+      }
+      code_offset += invoke_stub_size;
+      DCHECK_CODE_OFFSET();
+    }
+  }
+
+#if defined(ART_USE_LLVM_COMPILER)
+  if (!is_static) {
+    const CompiledInvokeStub* compiled_proxy_stub = compiler_->FindProxyStub(shorty);
+    if (compiled_proxy_stub != NULL) {
       uint32_t aligned_code_offset = CompiledMethod::AlignCode(code_offset,
                                                                compiler_->GetInstructionSet());
       uint32_t aligned_code_delta = aligned_code_offset - code_offset;
+      CHECK(aligned_code_delta < 48u);
       if (aligned_code_delta != 0) {
         off_t new_offset = lseek(file->Fd(), aligned_code_delta, SEEK_CUR);
         if (static_cast<uint32_t>(new_offset) != aligned_code_offset) {
-          PLOG(ERROR) << "Failed to seek to align invoke stub code. Actual: " << new_offset
+          PLOG(ERROR) << "Failed to seek to align proxy stub code. Actual: " << new_offset
                       << " Expected: " << aligned_code_offset;
           return 0;
         }
@@ -756,33 +734,35 @@
         DCHECK_CODE_OFFSET();
       }
       DCHECK_ALIGNED(code_offset, kArmAlignment);
-      const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
-      uint32_t invoke_stub_size = invoke_stub.size() * sizeof(invoke_stub[0]);
-      CHECK_NE(invoke_stub_size, 0U);
+      const std::vector<uint8_t>& proxy_stub = compiled_proxy_stub->GetCode();
+      uint32_t proxy_stub_size = proxy_stub.size() * sizeof(proxy_stub[0]);
+      CHECK_NE(proxy_stub_size, 0U);
 
-      // Deduplicate invoke stubs
-      size_t offset = code_offset + sizeof(invoke_stub_size) + compiled_invoke_stub->CodeDelta();
+      // Deduplicate proxy stubs
+      size_t offset = code_offset + sizeof(proxy_stub_size) + compiled_proxy_stub->CodeDelta();
       SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator stub_iter =
-          code_offsets_.find(&invoke_stub);
-      if (stub_iter != code_offsets_.end() && offset != method_offsets.invoke_stub_offset_) {
-        DCHECK(stub_iter->second == method_offsets.invoke_stub_offset_) << PrettyMethod(method_idx, dex_file);
+          code_offsets_.find(&proxy_stub);
+      if (stub_iter != code_offsets_.end() && offset != method_offsets.proxy_stub_offset_) {
+        DCHECK(stub_iter->second == method_offsets.proxy_stub_offset_) << PrettyMethod(method_idx, dex_file);
       } else {
-        DCHECK(offset == method_offsets.invoke_stub_offset_) << PrettyMethod(method_idx, dex_file);
-        if (!file->WriteFully(&invoke_stub_size, sizeof(invoke_stub_size))) {
-          ReportWriteFailure("invoke stub code size", method_idx, dex_file, file);
+        DCHECK(offset == method_offsets.proxy_stub_offset_) << PrettyMethod(method_idx, dex_file);
+        if (!file->WriteFully(&proxy_stub_size, sizeof(proxy_stub_size))) {
+          ReportWriteFailure("proxy stub code size", method_idx, dex_file, file);
           return 0;
         }
-        code_offset += sizeof(invoke_stub_size);
+        code_offset += sizeof(proxy_stub_size);
         DCHECK_CODE_OFFSET();
-        if (!file->WriteFully(&invoke_stub[0], invoke_stub_size)) {
-          ReportWriteFailure("invoke stub code", method_idx, dex_file, file);
+        if (!file->WriteFully(&proxy_stub[0], proxy_stub_size)) {
+          ReportWriteFailure("proxy stub code", method_idx, dex_file, file);
           return 0;
         }
-        code_offset += invoke_stub_size;
+        code_offset += proxy_stub_size;
+        DCHECK_CODE_OFFSET();
       }
       DCHECK_CODE_OFFSET();
     }
   }
+#endif
 
   return code_offset;
 }
@@ -867,48 +847,4 @@
   return true;
 }
 
-OatWriter::OatElfImage::OatElfImage(const ElfImage& image)
-    : elf_offset_(0), elf_size_(image.size()), elf_addr_(image.begin()) {
-}
-
-size_t OatWriter::OatElfImage::SizeOf() const {
-  return (sizeof(elf_offset_) + sizeof(elf_size_));
-}
-
-uint32_t OatWriter::OatElfImage::GetElfSize() const {
-  return elf_size_;
-}
-
-uint32_t OatWriter::OatElfImage::GetElfOffset() const {
-  DCHECK_NE(elf_offset_, 0U);
-  return elf_offset_;
-}
-
-void OatWriter::OatElfImage::SetElfOffset(uint32_t offset) {
-  DCHECK_NE(offset, 0U);
-  DCHECK_EQ((offset & 0x3LU), 0U);
-  elf_offset_ = offset;
-}
-
-bool OatWriter::OatElfImage::Write(File* file) const {
-  DCHECK_NE(elf_offset_, 0U);
-  if (!file->WriteFully(&elf_offset_, sizeof(elf_offset_))) {
-    PLOG(ERROR) << "Failed to write ELF offset to " << file->name();
-    return false;
-  }
-  if (!file->WriteFully(&elf_size_, sizeof(elf_size_))) {
-    PLOG(ERROR) << "Failed to write ELF size to " << file->name();
-    return false;
-  }
-  return true;
-}
-
-bool OatWriter::OatElfImage::WriteElfImage(File* file) const {
-  if (!file->WriteFully(elf_addr_, elf_size_)) {
-    PLOG(ERROR) << "Failed to write ELF image to " << file->name();
-    return false;
-  }
-  return true;
-}
-
 }  // namespace art
diff --git a/src/oat_writer.h b/src/oat_writer.h
index 29072ab..b748dbc 100644
--- a/src/oat_writer.h
+++ b/src/oat_writer.h
@@ -49,16 +49,6 @@
 // ...
 // OatClass[C]
 //
-// OatElfImage[0]    one OatElfImage for each ELF image
-// OatElfImage[1]    contains the size, checksum, and offset to the ELF image.
-// ...
-// OatElfImage[E]
-//
-// ELF[0]
-// ELF[1]
-// ...
-// ELF[E]
-//
 // padding           if necessary so that the following code will be page aligned
 //
 // CompiledMethod    one variable sized blob with the contents of each CompiledMethod
@@ -92,8 +82,6 @@
   size_t InitOatDexFiles(size_t offset);
   size_t InitDexFiles(size_t offset);
   size_t InitOatClasses(size_t offset);
-  size_t InitOatElfImages(size_t offset);
-  size_t InitElfImages(size_t offset);
   size_t InitOatCode(size_t offset);
   size_t InitOatCodeDexFiles(size_t offset);
   size_t InitOatCodeDexFile(size_t offset,
@@ -155,25 +143,6 @@
     DISALLOW_COPY_AND_ASSIGN(OatClass);
   };
 
-  class OatElfImage {
-   public:
-    explicit OatElfImage(const ElfImage& elf_image);
-    size_t SizeOf() const;
-    uint32_t GetElfSize() const;
-    uint32_t GetElfOffset() const;
-    void SetElfOffset(uint32_t offset);
-    bool Write(File* file) const;
-    bool WriteElfImage(File* file) const;
-
-   private:
-    // data to write
-    uint32_t elf_offset_;
-    const uint32_t elf_size_;
-
-    const byte* const elf_addr_;
-    DISALLOW_COPY_AND_ASSIGN(OatElfImage);
-  };
-
   const Compiler* compiler_;
 
   // TODO: remove the ClassLoader when the code storage moves out of Method
@@ -182,8 +151,6 @@
   // note OatFile does not take ownership of the DexFiles
   const std::vector<const DexFile*>* dex_files_;
 
-  std::vector<ElfImage> elf_images_;
-
   // dependency on the image
   uint32_t image_file_location_checksum_;
   std::string image_file_location_;
@@ -192,7 +159,6 @@
   OatHeader* oat_header_;
   std::vector<OatDexFile*> oat_dex_files_;
   std::vector<OatClass*> oat_classes_;
-  std::vector<OatElfImage*> oat_elf_images_;
   uint32_t executable_offset_padding_length_;
 
   template <class T> struct MapCompare {
diff --git a/src/oatdump.cc b/src/oatdump.cc
index b599eaa..a33cd09 100644
--- a/src/oatdump.cc
+++ b/src/oatdump.cc
@@ -57,11 +57,6 @@
           "      Example: --boot-image=/system/framework/boot.art\n"
           "\n");
   fprintf(stderr,
-          "  --extract-elf-to=<file.elf>: provide the prefix of the filename for\n"
-          "      the output ELF files.\n"
-          "      Example: --extract-elf-to=output.elf\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"
@@ -113,9 +108,6 @@
     os << "DEX FILE COUNT:\n";
     os << oat_header.GetDexFileCount() << "\n\n";
 
-    os << "ELF IMAGE COUNT:\n";
-    os << oat_header.GetElfImageCount() << "\n\n";
-
     os << "EXECUTABLE OFFSET:\n";
     os << StringPrintf("0x%08x\n\n", oat_header.GetExecutableOffset());
 
@@ -318,35 +310,17 @@
     os << StringPrintf("\t\tgc_map: %p (offset=0x%08x)\n",
                        oat_method.GetGcMap(), oat_method.GetGcMapOffset());
     DumpGcMap(os, oat_method.GetGcMap());
-    os << StringPrintf(
-#if defined(ART_USE_LLVM_COMPILER)
-                       "\t\tCODE: %p (offset=0x%08x size=%d elf_idx=%d elf_func_idx=%d)%s\n",
-#else
-                       "\t\tCODE: %p (offset=0x%08x size=%d)%s\n",
-#endif
+    os << StringPrintf("\t\tCODE: %p (offset=0x%08x size=%d)%s\n",
                        oat_method.GetCode(),
                        oat_method.GetCodeOffset(),
                        oat_method.GetCodeSize(),
-#if defined(ART_USE_LLVM_COMPILER)
-                       static_cast<int>(oat_method.GetCodeElfIndex()),
-                       static_cast<int>(oat_method.GetCodeElfFuncIndex()),
-#endif
                        oat_method.GetCode() != NULL ? "..." : "");
     DumpCode(os, oat_method.GetCode(), oat_method.GetCodeSize(), oat_method.GetMappingTable(),
              dex_file, code_item);
-    os << StringPrintf(
-#if defined(ART_USE_LLVM_COMPILER)
-                       "\t\tINVOKE STUB: %p (offset=0x%08x size=%d elf_idx=%d elf_func_idx=%d)%s\n",
-#else
-                       "\t\tINVOKE STUB: %p (offset=0x%08x size=%d)%s\n",
-#endif
+    os << StringPrintf("\t\tINVOKE STUB: %p (offset=0x%08x size=%d)%s\n",
                        oat_method.GetInvokeStub(),
                        oat_method.GetInvokeStubOffset(),
                        oat_method.GetInvokeStubSize(),
-#if defined(ART_USE_LLVM_COMPILER)
-                       static_cast<int>(oat_method.GetInvokeStubElfIndex()),
-                       static_cast<int>(oat_method.GetInvokeStubElfFuncIndex()),
-#endif
                        oat_method.GetInvokeStub() != NULL ? "..." : "");
     DumpCode(os, reinterpret_cast<const void*>(oat_method.GetInvokeStub()),
              oat_method.GetInvokeStubSize(), NULL, dex_file, NULL);
@@ -1158,8 +1132,6 @@
       image_filename = option.substr(strlen("--image=")).data();
     } else if (option.starts_with("--boot-image=")) {
       boot_image_filename = option.substr(strlen("--boot-image=")).data();
-    } else if (option.starts_with("--extract-elf-to=")) {
-      elf_filename_prefix = option.substr(strlen("--extract-elf-to=")).data();
     } else if (option.starts_with("--host-prefix=")) {
       host_prefix.reset(new std::string(option.substr(strlen("--host-prefix=")).data()));
     } else if (option.starts_with("--output=")) {
@@ -1204,25 +1176,6 @@
     }
     OatDumper oat_dumper(*host_prefix.get(), *oat_file);
     oat_dumper.Dump(*os);
-
-#if defined(ART_USE_LLVM_COMPILER)
-    if (!elf_filename_prefix.empty()) {
-      uint32_t elf_image_count = oat_file->GetOatHeader().GetElfImageCount();
-      for (uint32_t i = 0; i < elf_image_count; ++i) {
-        const OatFile::OatElfImage* elf_image = oat_file->GetOatElfImage(i);
-
-        std::string elf_filename(
-            StringPrintf("%s-%u", elf_filename_prefix.c_str(), i));
-
-        UniquePtr<File> elf_file(OS::OpenFile(elf_filename.c_str(), true));
-
-        if (!elf_file->WriteFully(elf_image->begin(), elf_image->size())) {
-          fprintf(stderr, "Failed to write ELF image to: %s\n",
-                  elf_filename.c_str());
-        }
-      }
-    }
-#endif
     return EXIT_SUCCESS;
   }
 
diff --git a/src/runtime.cc b/src/runtime.cc
index 5f20a4b..b5928b2 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -48,6 +48,10 @@
 #include "verifier/method_verifier.h"
 #include "well_known_classes.h"
 
+#if defined(ART_USE_LLVM_COMPILER)
+#include "compiler_llvm/procedure_linkage_table.h"
+#endif
+
 #include "JniConstants.h" // Last to avoid LOG redefinition in ics-mr1-plus-art.
 
 namespace art {
@@ -83,13 +87,27 @@
       tracer_(NULL),
       use_compile_time_class_path_(false),
       main_thread_group_(NULL),
-      system_thread_group_(NULL) {
+      system_thread_group_(NULL)
+#if defined(ART_USE_LLVM_COMPILER)
+#if defined(__arm__)
+    , plt_(kArm)
+#elif defined(__mips__)
+    , plt_(kMips)
+#elif defined(__i386__)
+    , plt_(kX86)
+#endif
+#endif
+      {
   for (int i = 0; i < Runtime::kLastTrampolineMethodType; i++) {
     resolution_stub_array_[i] = NULL;
   }
   for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
     callee_save_methods_[i] = NULL;
   }
+
+#if defined(ART_USE_LLVM_COMPILER)
+  CHECK(plt_.AllocateTable()) << "Failed to allocate PLT";
+#endif
 }
 
 Runtime::~Runtime() {
diff --git a/src/runtime.h b/src/runtime.h
index a6cebe7..ba579ea 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -33,6 +33,10 @@
 #include "safe_map.h"
 #include "stringpiece.h"
 
+#if defined(ART_USE_LLVM_COMPILER)
+#include "compiler_llvm/procedure_linkage_table.h"
+#endif
+
 namespace art {
 
 template<class T> class PrimitiveArray;
@@ -422,6 +426,9 @@
 
   jobject main_thread_group_;
   jobject system_thread_group_;
+#if defined(ART_USE_LLVM_COMPILER)
+  compiler_llvm::ProcedureLinkageTable plt_;
+#endif
 
   DISALLOW_COPY_AND_ASSIGN(Runtime);
 };