Make out arguments non-reference types.

Also, tidy some portable related code.

Change-Id: I67c8aa52eef8b556ca117ecda1b1e75465ba06a5

22 files changed, 266 insertions, 268 deletions

diff --git a/compiler/common_compiler_test.h b/compiler/common_compiler_test.h
index 9bcc040..d034b79 100644
--- a/compiler/common_compiler_test.h
+++ b/compiler/common_compiler_test.h
@@ -353,7 +353,7 @@ class CommonCompilerTest : public CommonRuntimeTest {
     CHECK(method != nullptr);
     TimingLogger timings("CommonTest::CompileMethod", false, false);
     timings.StartSplit("CompileOne");
-    compiler_driver_->CompileOne(method, timings);
+    compiler_driver_->CompileOne(method, &timings);
     MakeExecutable(method);
     timings.EndSplit();
   }
diff --git a/compiler/compiler_backend.cc b/compiler/compiler_backend.cc
index eaa39f8..f37ee37 100644
--- a/compiler/compiler_backend.cc
+++ b/compiler/compiler_backend.cc
@@ -135,10 +135,11 @@ class QuickBackend : public CompilerBackend {
   }
 
   bool WriteElf(art::File* file,
-                OatWriter& oat_writer,
+                OatWriter* oat_writer,
                 const std::vector<const art::DexFile*>& dex_files,
                 const std::string& android_root,
                 bool is_host, const CompilerDriver& driver) const
+    OVERRIDE
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     return art::ElfWriterQuick::Create(file, oat_writer, dex_files, android_root, is_host, driver);
   }
@@ -249,11 +250,12 @@ class LLVMBackend : public CompilerBackend {
   }
 
   bool WriteElf(art::File* file,
-                OatWriter& oat_writer,
+                OatWriter* oat_writer,
                 const std::vector<const art::DexFile*>& dex_files,
                 const std::string& android_root,
                 bool is_host, const CompilerDriver& driver) const
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+      OVERRIDE
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     return art::ElfWriterMclinker::Create(
         file, oat_writer, dex_files, android_root, is_host, driver);
   }
@@ -271,15 +273,17 @@ class LLVMBackend : public CompilerBackend {
         (1 << kSuppressExceptionEdges);
   }
 
-  bool isPortable() const { return true; }
+  bool IsPortable() const OVERRIDE {
+    return true;
+  }
 
-  void SetBitcodeFileName(std::string const& filename) {
-    typedef void (*SetBitcodeFileNameFn)(CompilerDriver&, std::string const&);
+  void SetBitcodeFileName(const CompilerDriver& driver, const std::string& filename) {
+    typedef void (*SetBitcodeFileNameFn)(const CompilerDriver&, const std::string&);
 
     SetBitcodeFileNameFn set_bitcode_file_name =
       reinterpret_cast<SetBitcodeFileNameFn>(compilerLLVMSetBitcodeFileName);
 
-    set_bitcode_file_name(*this, filename);
+    set_bitcode_file_name(driver, filename);
   }
 
  private:
diff --git a/compiler/compiler_backend.h b/compiler/compiler_backend.h
index 2d68b21..51fb29a 100644
--- a/compiler/compiler_backend.h
+++ b/compiler/compiler_backend.h
@@ -40,8 +40,9 @@ class CompilerBackend {
     kPortable
   };
 
-  explicit CompilerBackend(int warning)
-      : maximum_compilation_time_before_warning_(warning) {}
+  explicit CompilerBackend(uint64_t warning)
+      : maximum_compilation_time_before_warning_(warning) {
+  }
 
   static CompilerBackend* Create(Kind kind);
 
@@ -49,7 +50,7 @@ class CompilerBackend {
 
   virtual void UnInit(CompilerDriver& driver) const = 0;
 
-  virtual CompiledMethod* Compile(CompilerDriver& compiler,
+  virtual CompiledMethod* Compile(CompilerDriver& driver,
                                   const DexFile::CodeItem* code_item,
                                   uint32_t access_flags,
                                   InvokeType invoke_type,
@@ -66,7 +67,7 @@ class CompilerBackend {
   virtual uintptr_t GetEntryPointOf(mirror::ArtMethod* method) const = 0;
 
   virtual bool WriteElf(art::File* file,
-                        OatWriter& oat_writer,
+                        OatWriter* oat_writer,
                         const std::vector<const art::DexFile*>& dex_files,
                         const std::string& android_root,
                         bool is_host, const CompilerDriver& driver) const
@@ -79,8 +80,12 @@ class CompilerBackend {
     return maximum_compilation_time_before_warning_;
   }
 
-  virtual bool IsPortable() const { return false; }
-  void SetBitcodeFileName(std::string const& filename) {
+  virtual bool IsPortable() const {
+    return false;
+  }
+
+  void SetBitcodeFileName(const CompilerDriver& driver, const std::string& filename) {
+    UNUSED(driver);
     UNUSED(filename);
   }
 
@@ -89,7 +94,7 @@ class CompilerBackend {
   virtual ~CompilerBackend() {}
 
  private:
-  uint64_t maximum_compilation_time_before_warning_;
+  const uint64_t maximum_compilation_time_before_warning_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilerBackend);
 };
diff --git a/compiler/dex/compiler_ir.h b/compiler/dex/compiler_ir.h
index 8447d23..b9a26d6 100644
--- a/compiler/dex/compiler_ir.h
+++ b/compiler/dex/compiler_ir.h
@@ -64,7 +64,7 @@ struct CompilationUnit {
   const CompilerBackend* compiler_backend;
   InstructionSet instruction_set;
 
-  const InstructionSetFeatures& GetInstructionSetFeatures() {
+  InstructionSetFeatures GetInstructionSetFeatures() {
     return compiler_driver->GetInstructionSetFeatures();
   }
   // TODO: much of this info available elsewhere.  Go to the original source?
diff --git a/compiler/dex/frontend.cc b/compiler/dex/frontend.cc
index 6800f7b..2619258 100644
--- a/compiler/dex/frontend.cc
+++ b/compiler/dex/frontend.cc
@@ -128,7 +128,7 @@ void CompilationUnit::EndTiming() {
   }
 }
 
-static CompiledMethod* CompileMethod(CompilerDriver& compiler,
+static CompiledMethod* CompileMethod(CompilerDriver& driver,
                                      CompilerBackend* compiler_backend,
                                      const DexFile::CodeItem* code_item,
                                      uint32_t access_flags, InvokeType invoke_type,
@@ -143,11 +143,11 @@ static CompiledMethod* CompileMethod(CompilerDriver& compiler,
   }
 
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  CompilationUnit cu(&compiler.GetArenaPool());
+  CompilationUnit cu(driver.GetArenaPool());
 
-  cu.compiler_driver = &compiler;
+  cu.compiler_driver = &driver;
   cu.class_linker = class_linker;
-  cu.instruction_set = compiler.GetInstructionSet();
+  cu.instruction_set = driver.GetInstructionSet();
   cu.compiler_backend = compiler_backend;
   DCHECK((cu.instruction_set == kThumb2) ||
          (cu.instruction_set == kX86) ||
@@ -216,8 +216,8 @@ static CompiledMethod* CompileMethod(CompilerDriver& compiler,
   }
 
   /* Create the pass driver and launch it */
-  PassDriver driver(&cu);
-  driver.Launch();
+  PassDriver pass_driver(&cu);
+  pass_driver.Launch();
 
   if (cu.enable_debug & (1 << kDebugDumpCheckStats)) {
     cu.mir_graph->DumpCheckStats();
@@ -257,9 +257,9 @@ static CompiledMethod* CompileMethod(CompilerDriver& compiler,
   }
 
   cu.EndTiming();
-  compiler.GetTimingsLogger().Start();
-  compiler.GetTimingsLogger().AddLogger(cu.timings);
-  compiler.GetTimingsLogger().End();
+  driver.GetTimingsLogger()->Start();
+  driver.GetTimingsLogger()->AddLogger(cu.timings);
+  driver.GetTimingsLogger()->End();
   return result;
 }
 
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index 1b284de..931055b 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -441,11 +441,11 @@ const std::vector<uint8_t>* CompilerDriver::CreateQuickToInterpreterBridge() con
 
 void CompilerDriver::CompileAll(jobject class_loader,
                                 const std::vector<const DexFile*>& dex_files,
-                                TimingLogger& timings) {
+                                TimingLogger* timings) {
   DCHECK(!Runtime::Current()->IsStarted());
   UniquePtr<ThreadPool> thread_pool(new ThreadPool("Compiler driver thread pool", thread_count_ - 1));
-  PreCompile(class_loader, dex_files, *thread_pool.get(), timings);
-  Compile(class_loader, dex_files, *thread_pool.get(), timings);
+  PreCompile(class_loader, dex_files, thread_pool.get(), timings);
+  Compile(class_loader, dex_files, thread_pool.get(), timings);
   if (dump_stats_) {
     stats_->Dump();
   }
@@ -483,7 +483,7 @@ static DexToDexCompilationLevel GetDexToDexCompilationlevel(
   }
 }
 
-void CompilerDriver::CompileOne(mirror::ArtMethod* method, TimingLogger& timings) {
+void CompilerDriver::CompileOne(mirror::ArtMethod* method, TimingLogger* timings) {
   DCHECK(!Runtime::Current()->IsStarted());
   Thread* self = Thread::Current();
   jobject jclass_loader;
@@ -510,7 +510,7 @@ void CompilerDriver::CompileOne(mirror::ArtMethod* method, TimingLogger& timings
   dex_files.push_back(dex_file);
 
   UniquePtr<ThreadPool> thread_pool(new ThreadPool("Compiler driver thread pool", 0U));
-  PreCompile(jclass_loader, dex_files, *thread_pool.get(), timings);
+  PreCompile(jclass_loader, dex_files, thread_pool.get(), timings);
 
   // Can we run DEX-to-DEX compiler on this class ?
   DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile;
@@ -531,7 +531,7 @@ void CompilerDriver::CompileOne(mirror::ArtMethod* method, TimingLogger& timings
 }
 
 void CompilerDriver::Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                             ThreadPool& thread_pool, TimingLogger& timings) {
+                             ThreadPool* thread_pool, TimingLogger* timings) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
@@ -540,7 +540,7 @@ void CompilerDriver::Resolve(jobject class_loader, const std::vector<const DexFi
 }
 
 void CompilerDriver::PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                                ThreadPool& thread_pool, TimingLogger& timings) {
+                                ThreadPool* thread_pool, TimingLogger* timings) {
   LoadImageClasses(timings);
 
   Resolve(class_loader, dex_files, thread_pool, timings);
@@ -625,13 +625,13 @@ static bool RecordImageClassesVisitor(mirror::Class* klass, void* arg)
 }
 
 // Make a list of descriptors for classes to include in the image
-void CompilerDriver::LoadImageClasses(TimingLogger& timings)
+void CompilerDriver::LoadImageClasses(TimingLogger* timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_) {
   if (!IsImage()) {
     return;
   }
 
-  timings.NewSplit("LoadImageClasses");
+  timings->NewSplit("LoadImageClasses");
   // Make a first class to load all classes explicitly listed in the file
   Thread* self = Thread::Current();
   ScopedObjectAccess soa(self);
@@ -713,9 +713,9 @@ void CompilerDriver::FindClinitImageClassesCallback(mirror::Object* object, void
   MaybeAddToImageClasses(object->GetClass(), compiler_driver->image_classes_.get());
 }
 
-void CompilerDriver::UpdateImageClasses(TimingLogger& timings) {
+void CompilerDriver::UpdateImageClasses(TimingLogger* timings) {
   if (IsImage()) {
-    timings.NewSplit("UpdateImageClasses");
+    timings->NewSplit("UpdateImageClasses");
 
     // Update image_classes_ with classes for objects created by <clinit> methods.
     Thread* self = Thread::Current();
@@ -1368,13 +1368,13 @@ class ParallelCompilationManager {
                              jobject class_loader,
                              CompilerDriver* compiler,
                              const DexFile* dex_file,
-                             ThreadPool& thread_pool)
+                             ThreadPool* thread_pool)
     : index_(0),
       class_linker_(class_linker),
       class_loader_(class_loader),
       compiler_(compiler),
       dex_file_(dex_file),
-      thread_pool_(&thread_pool) {}
+      thread_pool_(thread_pool) {}
 
   ClassLinker* GetClassLinker() const {
     CHECK(class_linker_ != NULL);
@@ -1628,7 +1628,7 @@ static void ResolveType(const ParallelCompilationManager* manager, size_t type_i
 }
 
 void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_file,
-                                    ThreadPool& thread_pool, TimingLogger& timings) {
+                                    ThreadPool* thread_pool, TimingLogger* timings) {
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
 
   // TODO: we could resolve strings here, although the string table is largely filled with class
@@ -1638,16 +1638,16 @@ void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_fil
   if (IsImage()) {
     // For images we resolve all types, such as array, whereas for applications just those with
     // classdefs are resolved by ResolveClassFieldsAndMethods.
-    timings.NewSplit("Resolve Types");
+    timings->NewSplit("Resolve Types");
     context.ForAll(0, dex_file.NumTypeIds(), ResolveType, thread_count_);
   }
 
-  timings.NewSplit("Resolve MethodsAndFields");
+  timings->NewSplit("Resolve MethodsAndFields");
   context.ForAll(0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_);
 }
 
 void CompilerDriver::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                            ThreadPool& thread_pool, TimingLogger& timings) {
+                            ThreadPool* thread_pool, TimingLogger* timings) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
@@ -1702,8 +1702,8 @@ static void VerifyClass(const ParallelCompilationManager* manager, size_t class_
 }
 
 void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file,
-                                   ThreadPool& thread_pool, TimingLogger& timings) {
-  timings.NewSplit("Verify Dex File");
+                                   ThreadPool* thread_pool, TimingLogger* timings) {
+  timings->NewSplit("Verify Dex File");
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool);
   context.ForAll(0, dex_file.NumClassDefs(), VerifyClass, thread_count_);
@@ -1805,8 +1805,8 @@ static void InitializeClass(const ParallelCompilationManager* manager, size_t cl
 }
 
 void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile& dex_file,
-                                       ThreadPool& thread_pool, TimingLogger& timings) {
-  timings.NewSplit("InitializeNoClinit");
+                                       ThreadPool* thread_pool, TimingLogger* timings) {
+  timings->NewSplit("InitializeNoClinit");
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, thread_pool);
   size_t thread_count;
@@ -1825,7 +1825,7 @@ void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile&
 
 void CompilerDriver::InitializeClasses(jobject class_loader,
                                        const std::vector<const DexFile*>& dex_files,
-                                       ThreadPool& thread_pool, TimingLogger& timings) {
+                                       ThreadPool* thread_pool, TimingLogger* timings) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
@@ -1834,7 +1834,7 @@ void CompilerDriver::InitializeClasses(jobject class_loader,
 }
 
 void CompilerDriver::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                       ThreadPool& thread_pool, TimingLogger& timings) {
+                             ThreadPool* thread_pool, TimingLogger* timings) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
@@ -1916,8 +1916,8 @@ void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, siz
 }
 
 void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_file,
-                                    ThreadPool& thread_pool, TimingLogger& timings) {
-  timings.NewSplit("Compile Dex File");
+                                    ThreadPool* thread_pool, TimingLogger* timings) {
+  timings->NewSplit("Compile Dex File");
   ParallelCompilationManager context(Runtime::Current()->GetClassLinker(), class_loader, this,
                                      &dex_file, thread_pool);
   context.ForAll(0, dex_file.NumClassDefs(), CompilerDriver::CompileClass, thread_count_);
@@ -2037,38 +2037,38 @@ bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex
 bool CompilerDriver::WriteElf(const std::string& android_root,
                               bool is_host,
                               const std::vector<const art::DexFile*>& dex_files,
-                              OatWriter& oat_writer,
+                              OatWriter* oat_writer,
                               art::File* file)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return compiler_backend_->WriteElf(file, oat_writer, dex_files, android_root, is_host, *this);
 }
 void CompilerDriver::InstructionSetToLLVMTarget(InstructionSet instruction_set,
-                                                std::string& target_triple,
-                                                std::string& target_cpu,
-                                                std::string& target_attr) {
+                                                std::string* target_triple,
+                                                std::string* target_cpu,
+                                                std::string* target_attr) {
   switch (instruction_set) {
     case kThumb2:
-      target_triple = "thumb-none-linux-gnueabi";
-      target_cpu = "cortex-a9";
-      target_attr = "+thumb2,+neon,+neonfp,+vfp3,+db";
+      *target_triple = "thumb-none-linux-gnueabi";
+      *target_cpu = "cortex-a9";
+      *target_attr = "+thumb2,+neon,+neonfp,+vfp3,+db";
       break;
 
     case kArm:
-      target_triple = "armv7-none-linux-gnueabi";
+      *target_triple = "armv7-none-linux-gnueabi";
       // TODO: Fix for Nexus S.
-      target_cpu = "cortex-a9";
+      *target_cpu = "cortex-a9";
       // TODO: Fix for Xoom.
-      target_attr = "+v7,+neon,+neonfp,+vfp3,+db";
+      *target_attr = "+v7,+neon,+neonfp,+vfp3,+db";
       break;
 
     case kX86:
-      target_triple = "i386-pc-linux-gnu";
-      target_attr = "";
+      *target_triple = "i386-pc-linux-gnu";
+      *target_attr = "";
       break;
 
     case kMips:
-      target_triple = "mipsel-unknown-linux";
-      target_attr = "mips32r2";
+      *target_triple = "mipsel-unknown-linux";
+      *target_attr = "mips32r2";
       break;
 
     default:
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index 1bd2c1b..5a5fc36 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -108,11 +108,11 @@ class CompilerDriver {
   ~CompilerDriver();
 
   void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                  TimingLogger& timings)
+                  TimingLogger* timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
 
   // Compile a single Method.
-  void CompileOne(mirror::ArtMethod* method, TimingLogger& timings)
+  void CompileOne(mirror::ArtMethod* method, TimingLogger* timings)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   VerificationResults* GetVerificationResults() const {
@@ -123,16 +123,15 @@ class CompilerDriver {
     return method_inliner_map_;
   }
 
-  const InstructionSet& GetInstructionSet() const {
+  InstructionSet GetInstructionSet() const {
     return instruction_set_;
   }
 
-  const InstructionSetFeatures& GetInstructionSetFeatures() const {
+  InstructionSetFeatures GetInstructionSetFeatures() const {
     return instruction_set_features_;
   }
 
   const CompilerOptions& GetCompilerOptions() const {
-    DCHECK(compiler_options_ != nullptr);
     return *compiler_options_;
   }
 
@@ -275,21 +274,21 @@ class CompilerDriver {
     support_boot_image_fixup_ = support_boot_image_fixup;
   }
 
-  ArenaPool& GetArenaPool() {
-    return arena_pool_;
+  ArenaPool* GetArenaPool() {
+    return &arena_pool_;
   }
 
   bool WriteElf(const std::string& android_root,
                 bool is_host,
                 const std::vector<const DexFile*>& dex_files,
-                OatWriter& oat_writer,
+                OatWriter* oat_writer,
                 File* file);
 
-  // TODO: move to a common home for llvm helpers once quick/portable are merged
+  // TODO: move to a common home for llvm helpers once quick/portable are merged.
   static void InstructionSetToLLVMTarget(InstructionSet instruction_set,
-                                         std::string& target_triple,
-                                         std::string& target_cpu,
-                                         std::string& target_attr);
+                                         std::string* target_triple,
+                                         std::string* target_cpu,
+                                         std::string* target_attr);
 
   void SetCompilerContext(void* compiler_context) {
     compiler_context_ = compiler_context;
@@ -310,8 +309,8 @@ class CompilerDriver {
     return dump_passes_;
   }
 
-  CumulativeLogger& GetTimingsLogger() const {
-    return *timings_logger_;
+  CumulativeLogger* GetTimingsLogger() const {
+    return timings_logger_;
   }
 
   class PatchInformation {
@@ -507,43 +506,42 @@ class CompilerDriver {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                  ThreadPool& thread_pool, TimingLogger& timings)
+                  ThreadPool* thread_pool, TimingLogger* timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
 
-  void LoadImageClasses(TimingLogger& timings);
+  void LoadImageClasses(TimingLogger* timings);
 
   // Attempt to resolve all type, methods, fields, and strings
   // referenced from code in the dex file following PathClassLoader
   // ordering semantics.
   void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-               ThreadPool& thread_pool, TimingLogger& timings)
+               ThreadPool* thread_pool, TimingLogger* timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
   void ResolveDexFile(jobject class_loader, const DexFile& dex_file,
-                      ThreadPool& thread_pool, TimingLogger& timings)
+                      ThreadPool* thread_pool, TimingLogger* timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
 
   void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-              ThreadPool& thread_pool, TimingLogger& timings);
+              ThreadPool* thread_pool, TimingLogger* timings);
   void VerifyDexFile(jobject class_loader, const DexFile& dex_file,
-                     ThreadPool& thread_pool, TimingLogger& timings)
+                     ThreadPool* thread_pool, TimingLogger* timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
 
   void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-                         ThreadPool& thread_pool, TimingLogger& timings)
+                         ThreadPool* thread_pool, TimingLogger* timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
   void InitializeClasses(jobject class_loader, const DexFile& dex_file,
-                         ThreadPool& thread_pool, TimingLogger& timings)
+                         ThreadPool* thread_pool, TimingLogger* timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_);
 
-  void UpdateImageClasses(TimingLogger& timings)
-      LOCKS_EXCLUDED(Locks::mutator_lock_);
+  void UpdateImageClasses(TimingLogger* timings) LOCKS_EXCLUDED(Locks::mutator_lock_);
   static void FindClinitImageClassesCallback(mirror::Object* object, void* arg)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
-               ThreadPool& thread_pool, TimingLogger& timings);
+               ThreadPool* thread_pool, TimingLogger* timings);
   void CompileDexFile(jobject class_loader, const DexFile& dex_file,
-                      ThreadPool& thread_pool, TimingLogger& timings)
+                      ThreadPool* thread_pool, TimingLogger* timings)
       LOCKS_EXCLUDED(Locks::mutator_lock_);
   void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
                      InvokeType invoke_type, uint16_t class_def_idx, uint32_t method_idx,
diff --git a/compiler/driver/compiler_driver_test.cc b/compiler/driver/compiler_driver_test.cc
index 34806ce..2b3af62 100644
--- a/compiler/driver/compiler_driver_test.cc
+++ b/compiler/driver/compiler_driver_test.cc
@@ -40,7 +40,7 @@ class CompilerDriverTest : public CommonCompilerTest {
     timings.StartSplit("CompileAll");
     compiler_driver_->CompileAll(class_loader,
                                  Runtime::Current()->GetCompileTimeClassPath(class_loader),
-                                 timings);
+                                 &timings);
     MakeAllExecutable(class_loader);
     timings.EndSplit();
   }
diff --git a/compiler/elf_writer.cc b/compiler/elf_writer.cc
index 6db3fa1..ccc26a1 100644
--- a/compiler/elf_writer.cc
+++ b/compiler/elf_writer.cc
@@ -30,12 +30,7 @@
 
 namespace art {
 
-ElfWriter::ElfWriter(const CompilerDriver& driver, File* elf_file)
-  : compiler_driver_(&driver), elf_file_(elf_file) {}
-
-ElfWriter::~ElfWriter() {}
-
-Elf32_Addr ElfWriter::GetOatDataAddress(ElfFile* elf_file) {
+uint32_t ElfWriter::GetOatDataAddress(ElfFile* elf_file) {
   Elf32_Addr oatdata_address = elf_file->FindSymbolAddress(SHT_DYNSYM,
                                                            "oatdata",
                                                            false);
diff --git a/compiler/elf_writer.h b/compiler/elf_writer.h
index 99dfc56..3610d1a 100644
--- a/compiler/elf_writer.h
+++ b/compiler/elf_writer.h
@@ -23,7 +23,6 @@
 #include <vector>
 
 #include "base/macros.h"
-#include "elf_utils.h"
 #include "os.h"
 
 namespace art {
@@ -42,21 +41,23 @@ class ElfWriter {
                                    size_t& oat_data_offset);
 
   // Returns runtime oat_data runtime address for an opened ElfFile.
-  static Elf32_Addr GetOatDataAddress(ElfFile* elf_file);
+  static uint32_t GetOatDataAddress(ElfFile* elf_file);
 
  protected:
-  ElfWriter(const CompilerDriver& driver, File* elf_file);
-  virtual ~ElfWriter();
+  ElfWriter(const CompilerDriver& driver, File* elf_file)
+    : compiler_driver_(&driver), elf_file_(elf_file) {
+  }
 
-  virtual bool Write(OatWriter& oat_writer,
+  virtual ~ElfWriter() {}
+
+  virtual bool Write(OatWriter* oat_writer,
                      const std::vector<const DexFile*>& dex_files,
                      const std::string& android_root,
                      bool is_host)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) = 0;
 
-  // Setup by constructor
-  const CompilerDriver* compiler_driver_;
-  File* elf_file_;
+  const CompilerDriver* const compiler_driver_;
+  File* const elf_file_;
 };
 
 }  // namespace art
diff --git a/compiler/elf_writer_mclinker.cc b/compiler/elf_writer_mclinker.cc
index c7baf4f..b2d3a69 100644
--- a/compiler/elf_writer_mclinker.cc
+++ b/compiler/elf_writer_mclinker.cc
@@ -16,6 +16,7 @@
 
 #include "elf_writer_mclinker.h"
 
+#include <llvm/Support/ELF.h>
 #include <llvm/Support/TargetSelect.h>
 
 #include <mcld/Environment.h>
@@ -32,7 +33,6 @@
 #include "class_linker.h"
 #include "dex_method_iterator.h"
 #include "driver/compiler_driver.h"
-#include "elf_file.h"
 #include "globals.h"
 #include "mirror/art_method.h"
 #include "mirror/art_method-inl.h"
@@ -44,12 +44,14 @@
 namespace art {
 
 ElfWriterMclinker::ElfWriterMclinker(const CompilerDriver& driver, File* elf_file)
-  : ElfWriter(driver, elf_file), oat_input_(NULL) {}
+  : ElfWriter(driver, elf_file), oat_input_(nullptr) {
+}
 
-ElfWriterMclinker::~ElfWriterMclinker() {}
+ElfWriterMclinker::~ElfWriterMclinker() {
+}
 
 bool ElfWriterMclinker::Create(File* elf_file,
-                               OatWriter& oat_writer,
+                               OatWriter* oat_writer,
                                const std::vector<const DexFile*>& dex_files,
                                const std::string& android_root,
                                bool is_host,
@@ -58,29 +60,29 @@ bool ElfWriterMclinker::Create(File* elf_file,
   return elf_writer.Write(oat_writer, dex_files, android_root, is_host);
 }
 
-bool ElfWriterMclinker::Write(OatWriter& oat_writer,
+bool ElfWriterMclinker::Write(OatWriter* oat_writer,
                               const std::vector<const DexFile*>& dex_files,
                               const std::string& android_root,
                               bool is_host) {
   std::vector<uint8_t> oat_contents;
-  oat_contents.reserve(oat_writer.GetSize());
+  oat_contents.reserve(oat_writer->GetSize());
   VectorOutputStream output_stream("oat contents", oat_contents);
-  CHECK(oat_writer.Write(output_stream));
-  CHECK_EQ(oat_writer.GetSize(), oat_contents.size());
+  CHECK(oat_writer->Write(&output_stream));
+  CHECK_EQ(oat_writer->GetSize(), oat_contents.size());
 
   Init();
   AddOatInput(oat_contents);
-#if defined(ART_USE_PORTABLE_COMPILER)
-  AddMethodInputs(dex_files);
-  AddRuntimeInputs(android_root, is_host);
-#endif
+  if (kUsePortableCompiler) {
+    AddMethodInputs(dex_files);
+    AddRuntimeInputs(android_root, is_host);
+  }
   if (!Link()) {
     return false;
   }
   oat_contents.clear();
-#if defined(ART_USE_PORTABLE_COMPILER)
-  FixupOatMethodOffsets(dex_files);
-#endif
+  if (kUsePortableCompiler) {
+    FixupOatMethodOffsets(dex_files);
+  }
   return true;
 }
 
@@ -100,9 +102,9 @@ void ElfWriterMclinker::Init() {
   std::string target_cpu;
   std::string target_attr;
   CompilerDriver::InstructionSetToLLVMTarget(compiler_driver_->GetInstructionSet(),
-                                             target_triple,
-                                             target_cpu,
-                                             target_attr);
+                                             &target_triple,
+                                             &target_cpu,
+                                             &target_attr);
 
   // Based on mclinker's llvm-mcld.cpp main() and LinkerTest
   //
@@ -236,7 +238,6 @@ void ElfWriterMclinker::AddOatInput(std::vector<uint8_t>& oat_contents) {
                          text_section);
 }
 
-#if defined(ART_USE_PORTABLE_COMPILER)
 void ElfWriterMclinker::AddMethodInputs(const std::vector<const DexFile*>& dex_files) {
   DCHECK(oat_input_ != NULL);
 
@@ -320,7 +321,6 @@ void ElfWriterMclinker::AddRuntimeInputs(const std::string& android_root, bool i
   mcld::Input* libm_lib_input_input = ir_builder_->ReadInput(libm_lib, libm_lib);
   CHECK(libm_lib_input_input != NULL);
 }
-#endif
 
 bool ElfWriterMclinker::Link() {
   // link inputs
@@ -345,7 +345,6 @@ bool ElfWriterMclinker::Link() {
   return true;
 }
 
-#if defined(ART_USE_PORTABLE_COMPILER)
 void ElfWriterMclinker::FixupOatMethodOffsets(const std::vector<const DexFile*>& dex_files) {
   std::string error_msg;
   UniquePtr<ElfFile> elf_file(ElfFile::Open(elf_file_, true, false, &error_msg));
@@ -409,6 +408,5 @@ uint32_t ElfWriterMclinker::FixupCompiledCodeOffset(ElfFile& elf_file,
   }
   return compiled_code_offset;
 }
-#endif
 
 }  // namespace art
diff --git a/compiler/elf_writer_mclinker.h b/compiler/elf_writer_mclinker.h
index 8ee7231..13757ed 100644
--- a/compiler/elf_writer_mclinker.h
+++ b/compiler/elf_writer_mclinker.h
@@ -37,11 +37,11 @@ namespace art {
 
 class CompiledCode;
 
-class ElfWriterMclinker : public ElfWriter {
+class ElfWriterMclinker FINAL : public ElfWriter {
  public:
   // Write an ELF file. Returns true on success, false on failure.
   static bool Create(File* file,
-                     OatWriter& oat_writer,
+                     OatWriter* oat_writer,
                      const std::vector<const DexFile*>& dex_files,
                      const std::string& android_root,
                      bool is_host,
@@ -49,10 +49,11 @@ class ElfWriterMclinker : public ElfWriter {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
  protected:
-  virtual bool Write(OatWriter& oat_writer,
-                     const std::vector<const DexFile*>& dex_files,
-                     const std::string& android_root,
-                     bool is_host)
+  bool Write(OatWriter* oat_writer,
+             const std::vector<const DexFile*>& dex_files,
+             const std::string& android_root,
+             bool is_host)
+      OVERRIDE
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
  private:
@@ -65,13 +66,11 @@ class ElfWriterMclinker : public ElfWriter {
   void AddCompiledCodeInput(const CompiledCode& compiled_code);
   void AddRuntimeInputs(const std::string& android_root, bool is_host);
   bool Link();
-#if defined(ART_USE_PORTABLE_COMPILER)
   void FixupOatMethodOffsets(const std::vector<const DexFile*>& dex_files)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   uint32_t FixupCompiledCodeOffset(ElfFile& elf_file,
-                                   ::llvm::ELF::Elf32_Addr oatdata_address,
+                                   uint32_t oatdata_address,
                                    const CompiledCode& compiled_code);
-#endif
 
   // Setup by Init()
   UniquePtr<mcld::LinkerConfig> linker_config_;
diff --git a/compiler/elf_writer_quick.cc b/compiler/elf_writer_quick.cc
index 3191374..4b416a0 100644
--- a/compiler/elf_writer_quick.cc
+++ b/compiler/elf_writer_quick.cc
@@ -29,13 +29,8 @@
 
 namespace art {
 
-ElfWriterQuick::ElfWriterQuick(const CompilerDriver& driver, File* elf_file)
-  : ElfWriter(driver, elf_file) {}
-
-ElfWriterQuick::~ElfWriterQuick() {}
-
 bool ElfWriterQuick::Create(File* elf_file,
-                            OatWriter& oat_writer,
+                            OatWriter* oat_writer,
                             const std::vector<const DexFile*>& dex_files,
                             const std::string& android_root,
                             bool is_host,
@@ -44,7 +39,7 @@ bool ElfWriterQuick::Create(File* elf_file,
   return elf_writer.Write(oat_writer, dex_files, android_root, is_host);
 }
 
-bool ElfWriterQuick::Write(OatWriter& oat_writer,
+bool ElfWriterQuick::Write(OatWriter* oat_writer,
                            const std::vector<const DexFile*>& dex_files_unused,
                            const std::string& android_root_unused,
                            bool is_host_unused) {
@@ -197,7 +192,7 @@ bool ElfWriterQuick::Write(OatWriter& oat_writer,
   // .rodata
   uint32_t oat_data_alignment = kPageSize;
   uint32_t oat_data_offset = expected_offset = RoundUp(expected_offset, oat_data_alignment);
-  const OatHeader& oat_header = oat_writer.GetOatHeader();
+  const OatHeader& oat_header = oat_writer->GetOatHeader();
   CHECK(oat_header.IsValid());
   uint32_t oat_data_size = oat_header.GetExecutableOffset();
   expected_offset += oat_data_size;
@@ -210,9 +205,9 @@ bool ElfWriterQuick::Write(OatWriter& oat_writer,
   uint32_t oat_exec_alignment = kPageSize;
   CHECK_ALIGNED(expected_offset, kPageSize);
   uint32_t oat_exec_offset = expected_offset = RoundUp(expected_offset, oat_exec_alignment);
-  uint32_t oat_exec_size = oat_writer.GetSize() - oat_data_size;
+  uint32_t oat_exec_size = oat_writer->GetSize() - oat_data_size;
   expected_offset += oat_exec_size;
-  CHECK_EQ(oat_data_offset + oat_writer.GetSize(), expected_offset);
+  CHECK_EQ(oat_data_offset + oat_writer->GetSize(), expected_offset);
   if (debug) {
     LOG(INFO) << "oat_exec_offset=" << oat_exec_offset << std::hex << " " << oat_exec_offset;
     LOG(INFO) << "oat_exec_size=" << oat_exec_size << std::hex << " " << oat_exec_size;
@@ -622,13 +617,13 @@ bool ElfWriterQuick::Write(OatWriter& oat_writer,
     return false;
   }
   BufferedOutputStream output_stream(new FileOutputStream(elf_file_));
-  if (!oat_writer.Write(output_stream)) {
+  if (!oat_writer->Write(&output_stream)) {
     PLOG(ERROR) << "Failed to write .rodata and .text for " << elf_file_->GetPath();
     return false;
   }
 
   // .dynamic
-  DCHECK_LE(oat_data_offset + oat_writer.GetSize(), dynamic_offset);
+  DCHECK_LE(oat_data_offset + oat_writer->GetSize(), dynamic_offset);
   if (static_cast<off_t>(dynamic_offset) != lseek(elf_file_->Fd(), dynamic_offset, SEEK_SET)) {
     PLOG(ERROR) << "Failed to seek to .dynamic offset " << dynamic_offset
                 << " for " << elf_file_->GetPath();
diff --git a/compiler/elf_writer_quick.h b/compiler/elf_writer_quick.h
index f36d06f..25b0495 100644
--- a/compiler/elf_writer_quick.h
+++ b/compiler/elf_writer_quick.h
@@ -21,11 +21,11 @@
 
 namespace art {
 
-class ElfWriterQuick : public ElfWriter {
+class ElfWriterQuick FINAL : public ElfWriter {
  public:
   // Write an ELF file. Returns true on success, false on failure.
   static bool Create(File* file,
-                     OatWriter& oat_writer,
+                     OatWriter* oat_writer,
                      const std::vector<const DexFile*>& dex_files,
                      const std::string& android_root,
                      bool is_host,
@@ -33,15 +33,17 @@ class ElfWriterQuick : public ElfWriter {
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
  protected:
-  virtual bool Write(OatWriter& oat_writer,
-                     const std::vector<const DexFile*>& dex_files,
-                     const std::string& android_root,
-                     bool is_host)
+  bool Write(OatWriter* oat_writer,
+             const std::vector<const DexFile*>& dex_files,
+             const std::string& android_root,
+             bool is_host)
+      OVERRIDE
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
  private:
-  ElfWriterQuick(const CompilerDriver& driver, File* elf_file);
-  ~ElfWriterQuick();
+  ElfWriterQuick(const CompilerDriver& driver, File* elf_file)
+    : ElfWriter(driver, elf_file) {}
+  ~ElfWriterQuick() {}
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ElfWriterQuick);
 };
diff --git a/compiler/image_test.cc b/compiler/image_test.cc
index 16e2aa2..619b056 100644
--- a/compiler/image_test.cc
+++ b/compiler/image_test.cc
@@ -49,15 +49,15 @@ TEST_F(ImageTest, WriteRead) {
       ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
       TimingLogger timings("ImageTest::WriteRead", false, false);
       timings.StartSplit("CompileAll");
-#if defined(ART_USE_PORTABLE_COMPILER)
-      // TODO: we disable this for portable so the test executes in a reasonable amount of time.
-      //       We shouldn't need to do this.
-      runtime_->SetCompilerFilter(Runtime::kInterpretOnly);
-#endif
+      if (kUsePortableCompiler) {
+        // TODO: we disable this for portable so the test executes in a reasonable amount of time.
+        //       We shouldn't need to do this.
+        compiler_options_->SetCompilerFilter(CompilerOptions::kInterpretOnly);
+      }
       for (const DexFile* dex_file : class_linker->GetBootClassPath()) {
         dex_file->EnableWrite();
       }
-      compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), timings);
+      compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), &timings);
 
       ScopedObjectAccess soa(Thread::Current());
       OatWriter oat_writer(class_linker->GetBootClassPath(),
@@ -65,7 +65,7 @@ TEST_F(ImageTest, WriteRead) {
       bool success = compiler_driver_->WriteElf(GetTestAndroidRoot(),
                                                 !kIsTargetBuild,
                                                 class_linker->GetBootClassPath(),
-                                                oat_writer,
+                                                &oat_writer,
                                                 tmp_elf.GetFile());
       ASSERT_TRUE(success);
       timings.EndSplit();
diff --git a/compiler/llvm/compiler_llvm.cc b/compiler/llvm/compiler_llvm.cc
index a5acd2a..4ce714a 100644
--- a/compiler/llvm/compiler_llvm.cc
+++ b/compiler/llvm/compiler_llvm.cc
@@ -175,16 +175,16 @@ CompileNativeMethod(DexCompilationUnit* dex_compilation_unit) {
 }  // namespace llvm
 }  // namespace art
 
-inline static art::llvm::CompilerLLVM* ContextOf(art::CompilerDriver& driver) {
+static art::llvm::CompilerLLVM* ContextOf(art::CompilerDriver& driver) {
   void *compiler_context = driver.GetCompilerContext();
   CHECK(compiler_context != NULL);
   return reinterpret_cast<art::llvm::CompilerLLVM*>(compiler_context);
 }
 
-inline static const art::llvm::CompilerLLVM* ContextOf(const art::CompilerDriver& driver) {
+static art::llvm::CompilerLLVM* ContextOf(const art::CompilerDriver& driver) {
   void *compiler_context = driver.GetCompilerContext();
   CHECK(compiler_context != NULL);
-  return reinterpret_cast<const art::llvm::CompilerLLVM*>(compiler_context);
+  return reinterpret_cast<art::llvm::CompilerLLVM*>(compiler_context);
 }
 
 extern "C" void ArtInitCompilerContext(art::CompilerDriver& driver) {
@@ -233,7 +233,7 @@ extern "C" art::CompiledMethod* ArtLLVMJniCompileMethod(art::CompilerDriver& dri
   return result;
 }
 
-extern "C" void compilerLLVMSetBitcodeFileName(art::CompilerDriver& driver,
-                                               std::string const& filename) {
+extern "C" void compilerLLVMSetBitcodeFileName(const art::CompilerDriver& driver,
+                                               const std::string& filename) {
   ContextOf(driver)->SetBitcodeFileName(filename);
 }
diff --git a/compiler/llvm/compiler_llvm.h b/compiler/llvm/compiler_llvm.h
index 65bc16b..c2211fb 100644
--- a/compiler/llvm/compiler_llvm.h
+++ b/compiler/llvm/compiler_llvm.h
@@ -70,7 +70,7 @@ class CompilerLLVM {
     return insn_set_;
   }
 
-  void SetBitcodeFileName(std::string const& filename) {
+  void SetBitcodeFileName(const std::string& filename) {
     bitcode_filename_ = filename;
   }
 
diff --git a/compiler/llvm/llvm_compilation_unit.cc b/compiler/llvm/llvm_compilation_unit.cc
index d23706d..1d027f9 100644
--- a/compiler/llvm/llvm_compilation_unit.cc
+++ b/compiler/llvm/llvm_compilation_unit.cc
@@ -199,7 +199,8 @@ bool LlvmCompilationUnit::MaterializeToRawOStream(::llvm::raw_ostream& out_strea
   std::string target_triple;
   std::string target_cpu;
   std::string target_attr;
-  CompilerDriver::InstructionSetToLLVMTarget(GetInstructionSet(), target_triple, target_cpu, target_attr);
+  CompilerDriver::InstructionSetToLLVMTarget(GetInstructionSet(), &target_triple, &target_cpu,
+                                             &target_attr);
 
   std::string errmsg;
   const ::llvm::Target* target =
diff --git a/compiler/oat_test.cc b/compiler/oat_test.cc
index 55a962f..6dbba9f 100644
--- a/compiler/oat_test.cc
+++ b/compiler/oat_test.cc
@@ -105,7 +105,7 @@ TEST_F(OatTest, WriteRead) {
   jobject class_loader = NULL;
   if (kCompile) {
     TimingLogger timings("OatTest::WriteRead", false, false);
-    compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), timings);
+    compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), &timings);
   }
 
   ScopedObjectAccess soa(Thread::Current());
@@ -119,12 +119,12 @@ TEST_F(OatTest, WriteRead) {
   bool success = compiler_driver_->WriteElf(GetTestAndroidRoot(),
                                             !kIsTargetBuild,
                                             class_linker->GetBootClassPath(),
-                                            oat_writer,
+                                            &oat_writer,
                                             tmp.GetFile());
   ASSERT_TRUE(success);
 
   if (kCompile) {  // OatWriter strips the code, regenerate to compare
-    compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), timings);
+    compiler_driver_->CompileAll(class_loader, class_linker->GetBootClassPath(), &timings);
   }
   std::string error_msg;
   UniquePtr<OatFile> oat_file(OatFile::Open(tmp.GetFilename(), tmp.GetFilename(), NULL, false,
diff --git a/compiler/oat_writer.cc b/compiler/oat_writer.cc
index 7c5669a..970d2e3 100644
--- a/compiler/oat_writer.cc
+++ b/compiler/oat_writer.cc
@@ -229,7 +229,7 @@ size_t OatWriter::InitOatClasses(size_t offset) {
       oat_classes_.push_back(oat_class);
       offset += oat_class->SizeOf();
     }
-    oat_dex_files_[i]->UpdateChecksum(*oat_header_);
+    oat_dex_files_[i]->UpdateChecksum(oat_header_);
   }
   return offset;
 }
@@ -293,7 +293,7 @@ size_t OatWriter::InitOatCodeDexFile(size_t offset,
        class_def_index++, (*oat_class_index)++) {
     const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
     offset = InitOatCodeClassDef(offset, *oat_class_index, class_def_index, dex_file, class_def);
-    oat_classes_[*oat_class_index]->UpdateChecksum(*oat_header_);
+    oat_classes_[*oat_class_index]->UpdateChecksum(oat_header_);
   }
   return offset;
 }
@@ -499,42 +499,42 @@ size_t OatWriter::InitOatCodeMethod(size_t offset, size_t oat_class_index,
 }
 
 #define DCHECK_OFFSET() \
-  DCHECK_EQ(static_cast<off_t>(file_offset + relative_offset), out.Seek(0, kSeekCurrent)) \
+  DCHECK_EQ(static_cast<off_t>(file_offset + relative_offset), out->Seek(0, kSeekCurrent)) \
     << "file_offset=" << file_offset << " relative_offset=" << relative_offset
 
 #define DCHECK_OFFSET_() \
-  DCHECK_EQ(static_cast<off_t>(file_offset + offset_), out.Seek(0, kSeekCurrent)) \
+  DCHECK_EQ(static_cast<off_t>(file_offset + offset_), out->Seek(0, kSeekCurrent)) \
     << "file_offset=" << file_offset << " offset_=" << offset_
 
-bool OatWriter::Write(OutputStream& out) {
-  const size_t file_offset = out.Seek(0, kSeekCurrent);
+bool OatWriter::Write(OutputStream* out) {
+  const size_t file_offset = out->Seek(0, kSeekCurrent);
 
-  if (!out.WriteFully(oat_header_, sizeof(*oat_header_))) {
-    PLOG(ERROR) << "Failed to write oat header to " << out.GetLocation();
+  if (!out->WriteFully(oat_header_, sizeof(*oat_header_))) {
+    PLOG(ERROR) << "Failed to write oat header to " << out->GetLocation();
     return false;
   }
   size_oat_header_ += sizeof(*oat_header_);
 
-  if (!out.WriteFully(image_file_location_.data(), image_file_location_.size())) {
-    PLOG(ERROR) << "Failed to write oat header image file location to " << out.GetLocation();
+  if (!out->WriteFully(image_file_location_.data(), image_file_location_.size())) {
+    PLOG(ERROR) << "Failed to write oat header image file location to " << out->GetLocation();
     return false;
   }
   size_oat_header_image_file_location_ += image_file_location_.size();
 
   if (!WriteTables(out, file_offset)) {
-    LOG(ERROR) << "Failed to write oat tables to " << out.GetLocation();
+    LOG(ERROR) << "Failed to write oat tables to " << out->GetLocation();
     return false;
   }
 
   size_t relative_offset = WriteCode(out, file_offset);
   if (relative_offset == 0) {
-    LOG(ERROR) << "Failed to write oat code to " << out.GetLocation();
+    LOG(ERROR) << "Failed to write oat code to " << out->GetLocation();
     return false;
   }
 
   relative_offset = WriteCodeDexFiles(out, file_offset, relative_offset);
   if (relative_offset == 0) {
-    LOG(ERROR) << "Failed to write oat code for dex files to " << out.GetLocation();
+    LOG(ERROR) << "Failed to write oat code for dex files to " << out->GetLocation();
     return false;
   }
 
@@ -577,26 +577,26 @@ bool OatWriter::Write(OutputStream& out) {
     #undef DO_STAT
 
     VLOG(compiler) << "size_total=" << PrettySize(size_total) << " (" << size_total << "B)"; \
-    CHECK_EQ(file_offset + size_total, static_cast<uint32_t>(out.Seek(0, kSeekCurrent)));
+    CHECK_EQ(file_offset + size_total, static_cast<uint32_t>(out->Seek(0, kSeekCurrent)));
     CHECK_EQ(size_, size_total);
   }
 
-  CHECK_EQ(file_offset + size_, static_cast<uint32_t>(out.Seek(0, kSeekCurrent)));
+  CHECK_EQ(file_offset + size_, static_cast<uint32_t>(out->Seek(0, kSeekCurrent)));
   CHECK_EQ(size_, relative_offset);
 
   return true;
 }
 
-bool OatWriter::WriteTables(OutputStream& out, const size_t file_offset) {
+bool OatWriter::WriteTables(OutputStream* out, const size_t file_offset) {
   for (size_t i = 0; i != oat_dex_files_.size(); ++i) {
     if (!oat_dex_files_[i]->Write(this, out, file_offset)) {
-      PLOG(ERROR) << "Failed to write oat dex information to " << out.GetLocation();
+      PLOG(ERROR) << "Failed to write oat dex information to " << out->GetLocation();
       return false;
     }
   }
   for (size_t i = 0; i != oat_dex_files_.size(); ++i) {
     uint32_t expected_offset = file_offset + oat_dex_files_[i]->dex_file_offset_;
-    off_t actual_offset = out.Seek(expected_offset, kSeekSet);
+    off_t actual_offset = out->Seek(expected_offset, kSeekSet);
     if (static_cast<uint32_t>(actual_offset) != expected_offset) {
       const DexFile* dex_file = (*dex_files_)[i];
       PLOG(ERROR) << "Failed to seek to dex file section. Actual: " << actual_offset
@@ -604,29 +604,29 @@ bool OatWriter::WriteTables(OutputStream& out, const size_t file_offset) {
       return false;
     }
     const DexFile* dex_file = (*dex_files_)[i];
-    if (!out.WriteFully(&dex_file->GetHeader(), dex_file->GetHeader().file_size_)) {
+    if (!out->WriteFully(&dex_file->GetHeader(), dex_file->GetHeader().file_size_)) {
       PLOG(ERROR) << "Failed to write dex file " << dex_file->GetLocation()
-                  << " to " << out.GetLocation();
+                  << " to " << out->GetLocation();
       return false;
     }
     size_dex_file_ += dex_file->GetHeader().file_size_;
   }
   for (size_t i = 0; i != oat_classes_.size(); ++i) {
     if (!oat_classes_[i]->Write(this, out, file_offset)) {
-      PLOG(ERROR) << "Failed to write oat methods information to " << out.GetLocation();
+      PLOG(ERROR) << "Failed to write oat methods information to " << out->GetLocation();
       return false;
     }
   }
   return true;
 }
 
-size_t OatWriter::WriteCode(OutputStream& out, const size_t file_offset) {
+size_t OatWriter::WriteCode(OutputStream* out, const size_t file_offset) {
   size_t relative_offset = oat_header_->GetExecutableOffset();
-  off_t new_offset = out.Seek(size_executable_offset_alignment_, kSeekCurrent);
+  off_t new_offset = out->Seek(size_executable_offset_alignment_, kSeekCurrent);
   size_t expected_file_offset = file_offset + relative_offset;
   if (static_cast<uint32_t>(new_offset) != expected_file_offset) {
     PLOG(ERROR) << "Failed to seek to oat code section. Actual: " << new_offset
-                << " Expected: " << expected_file_offset << " File: " << out.GetLocation();
+                << " Expected: " << expected_file_offset << " File: " << out->GetLocation();
     return 0;
   }
   DCHECK_OFFSET();
@@ -637,10 +637,10 @@ size_t OatWriter::WriteCode(OutputStream& out, const size_t file_offset) {
       do { \
         uint32_t aligned_offset = CompiledCode::AlignCode(relative_offset, instruction_set); \
         uint32_t alignment_padding = aligned_offset - relative_offset; \
-        out.Seek(alignment_padding, kSeekCurrent); \
+        out->Seek(alignment_padding, kSeekCurrent); \
         size_trampoline_alignment_ += alignment_padding; \
-        if (!out.WriteFully(&(*field)[0], field->size())) { \
-          PLOG(ERROR) << "Failed to write " # field " to " << out.GetLocation(); \
+        if (!out->WriteFully(&(*field)[0], field->size())) { \
+          PLOG(ERROR) << "Failed to write " # field " to " << out->GetLocation(); \
           return false; \
         } \
         size_ ## field += field->size(); \
@@ -662,7 +662,7 @@ size_t OatWriter::WriteCode(OutputStream& out, const size_t file_offset) {
   return relative_offset;
 }
 
-size_t OatWriter::WriteCodeDexFiles(OutputStream& out,
+size_t OatWriter::WriteCodeDexFiles(OutputStream* out,
                                     const size_t file_offset,
                                     size_t relative_offset) {
   size_t oat_class_index = 0;
@@ -678,7 +678,7 @@ size_t OatWriter::WriteCodeDexFiles(OutputStream& out,
   return relative_offset;
 }
 
-size_t OatWriter::WriteCodeDexFile(OutputStream& out, const size_t file_offset,
+size_t OatWriter::WriteCodeDexFile(OutputStream* out, const size_t file_offset,
                                    size_t relative_offset, size_t* oat_class_index,
                                    const DexFile& dex_file) {
   for (size_t class_def_index = 0; class_def_index < dex_file.NumClassDefs();
@@ -694,12 +694,12 @@ size_t OatWriter::WriteCodeDexFile(OutputStream& out, const size_t file_offset,
 }
 
 void OatWriter::ReportWriteFailure(const char* what, uint32_t method_idx,
-                                   const DexFile& dex_file, OutputStream& out) const {
+                                   const DexFile& dex_file, const OutputStream& out) const {
   PLOG(ERROR) << "Failed to write " << what << " for " << PrettyMethod(method_idx, dex_file)
       << " to " << out.GetLocation();
 }
 
-size_t OatWriter::WriteCodeClassDef(OutputStream& out,
+size_t OatWriter::WriteCodeClassDef(OutputStream* out,
                                     const size_t file_offset,
                                     size_t relative_offset,
                                     size_t oat_class_index,
@@ -747,7 +747,7 @@ size_t OatWriter::WriteCodeClassDef(OutputStream& out,
   return relative_offset;
 }
 
-size_t OatWriter::WriteCodeMethod(OutputStream& out, const size_t file_offset,
+size_t OatWriter::WriteCodeMethod(OutputStream* out, const size_t file_offset,
                                   size_t relative_offset, size_t oat_class_index,
                                   size_t class_def_method_index, size_t* method_offsets_index,
                                   bool is_static, uint32_t method_idx, const DexFile& dex_file) {
@@ -763,12 +763,12 @@ size_t OatWriter::WriteCodeMethod(OutputStream& out, const size_t file_offset,
       uint32_t aligned_offset = compiled_method->AlignCode(relative_offset);
       uint32_t aligned_code_delta = aligned_offset - relative_offset;
       if (aligned_code_delta != 0) {
-        off_t new_offset = out.Seek(aligned_code_delta, kSeekCurrent);
+        off_t new_offset = out->Seek(aligned_code_delta, kSeekCurrent);
         size_code_alignment_ += aligned_code_delta;
         uint32_t expected_offset = file_offset + aligned_offset;
         if (static_cast<uint32_t>(new_offset) != expected_offset) {
           PLOG(ERROR) << "Failed to seek to align oat code. Actual: " << new_offset
-              << " Expected: " << expected_offset << " File: " << out.GetLocation();
+              << " Expected: " << expected_offset << " File: " << out->GetLocation();
           return 0;
         }
         relative_offset += aligned_code_delta;
@@ -787,15 +787,15 @@ size_t OatWriter::WriteCodeMethod(OutputStream& out, const size_t file_offset,
               << PrettyMethod(method_idx, dex_file);
       } else {
         DCHECK(code_offset == method_offsets.code_offset_) << PrettyMethod(method_idx, dex_file);
-        if (!out.WriteFully(&code_size, sizeof(code_size))) {
-          ReportWriteFailure("method code size", method_idx, dex_file, out);
+        if (!out->WriteFully(&code_size, sizeof(code_size))) {
+          ReportWriteFailure("method code size", method_idx, dex_file, *out);
           return 0;
         }
         size_code_size_ += sizeof(code_size);
         relative_offset += sizeof(code_size);
         DCHECK_OFFSET();
-        if (!out.WriteFully(&(*quick_code)[0], code_size)) {
-          ReportWriteFailure("method code", method_idx, dex_file, out);
+        if (!out->WriteFully(&(*quick_code)[0], code_size)) {
+          ReportWriteFailure("method code", method_idx, dex_file, *out);
           return 0;
         }
         size_code_ += code_size;
@@ -818,8 +818,8 @@ size_t OatWriter::WriteCodeMethod(OutputStream& out, const size_t file_offset,
       DCHECK((mapping_table_size == 0 && method_offsets.mapping_table_offset_ == 0)
           || relative_offset == method_offsets.mapping_table_offset_)
           << PrettyMethod(method_idx, dex_file);
-      if (!out.WriteFully(&mapping_table[0], mapping_table_size)) {
-        ReportWriteFailure("mapping table", method_idx, dex_file, out);
+      if (!out->WriteFully(&mapping_table[0], mapping_table_size)) {
+        ReportWriteFailure("mapping table", method_idx, dex_file, *out);
         return 0;
       }
       size_mapping_table_ += mapping_table_size;
@@ -842,8 +842,8 @@ size_t OatWriter::WriteCodeMethod(OutputStream& out, const size_t file_offset,
       DCHECK((vmap_table_size == 0 && method_offsets.vmap_table_offset_ == 0)
           || relative_offset == method_offsets.vmap_table_offset_)
           << PrettyMethod(method_idx, dex_file);
-      if (!out.WriteFully(&vmap_table[0], vmap_table_size)) {
-        ReportWriteFailure("vmap table", method_idx, dex_file, out);
+      if (!out->WriteFully(&vmap_table[0], vmap_table_size)) {
+        ReportWriteFailure("vmap table", method_idx, dex_file, *out);
         return 0;
       }
       size_vmap_table_ += vmap_table_size;
@@ -866,8 +866,8 @@ size_t OatWriter::WriteCodeMethod(OutputStream& out, const size_t file_offset,
       DCHECK((gc_map_size == 0 && method_offsets.gc_map_offset_ == 0)
           || relative_offset == method_offsets.gc_map_offset_)
           << PrettyMethod(method_idx, dex_file);
-      if (!out.WriteFully(&gc_map[0], gc_map_size)) {
-        ReportWriteFailure("GC map", method_idx, dex_file, out);
+      if (!out->WriteFully(&gc_map[0], gc_map_size)) {
+        ReportWriteFailure("GC map", method_idx, dex_file, *out);
         return 0;
       }
       size_gc_map_ += gc_map_size;
@@ -897,42 +897,42 @@ size_t OatWriter::OatDexFile::SizeOf() const {
           + (sizeof(methods_offsets_[0]) * methods_offsets_.size());
 }
 
-void OatWriter::OatDexFile::UpdateChecksum(OatHeader& oat_header) const {
-  oat_header.UpdateChecksum(&dex_file_location_size_, sizeof(dex_file_location_size_));
-  oat_header.UpdateChecksum(dex_file_location_data_, dex_file_location_size_);
-  oat_header.UpdateChecksum(&dex_file_location_checksum_, sizeof(dex_file_location_checksum_));
-  oat_header.UpdateChecksum(&dex_file_offset_, sizeof(dex_file_offset_));
-  oat_header.UpdateChecksum(&methods_offsets_[0],
+void OatWriter::OatDexFile::UpdateChecksum(OatHeader* oat_header) const {
+  oat_header->UpdateChecksum(&dex_file_location_size_, sizeof(dex_file_location_size_));
+  oat_header->UpdateChecksum(dex_file_location_data_, dex_file_location_size_);
+  oat_header->UpdateChecksum(&dex_file_location_checksum_, sizeof(dex_file_location_checksum_));
+  oat_header->UpdateChecksum(&dex_file_offset_, sizeof(dex_file_offset_));
+  oat_header->UpdateChecksum(&methods_offsets_[0],
                             sizeof(methods_offsets_[0]) * methods_offsets_.size());
 }
 
 bool OatWriter::OatDexFile::Write(OatWriter* oat_writer,
-                                  OutputStream& out,
+                                  OutputStream* out,
                                   const size_t file_offset) const {
   DCHECK_OFFSET_();
-  if (!out.WriteFully(&dex_file_location_size_, sizeof(dex_file_location_size_))) {
-    PLOG(ERROR) << "Failed to write dex file location length to " << out.GetLocation();
+  if (!out->WriteFully(&dex_file_location_size_, sizeof(dex_file_location_size_))) {
+    PLOG(ERROR) << "Failed to write dex file location length to " << out->GetLocation();
     return false;
   }
   oat_writer->size_oat_dex_file_location_size_ += sizeof(dex_file_location_size_);
-  if (!out.WriteFully(dex_file_location_data_, dex_file_location_size_)) {
-    PLOG(ERROR) << "Failed to write dex file location data to " << out.GetLocation();
+  if (!out->WriteFully(dex_file_location_data_, dex_file_location_size_)) {
+    PLOG(ERROR) << "Failed to write dex file location data to " << out->GetLocation();
     return false;
   }
   oat_writer->size_oat_dex_file_location_data_ += dex_file_location_size_;
-  if (!out.WriteFully(&dex_file_location_checksum_, sizeof(dex_file_location_checksum_))) {
-    PLOG(ERROR) << "Failed to write dex file location checksum to " << out.GetLocation();
+  if (!out->WriteFully(&dex_file_location_checksum_, sizeof(dex_file_location_checksum_))) {
+    PLOG(ERROR) << "Failed to write dex file location checksum to " << out->GetLocation();
     return false;
   }
   oat_writer->size_oat_dex_file_location_checksum_ += sizeof(dex_file_location_checksum_);
-  if (!out.WriteFully(&dex_file_offset_, sizeof(dex_file_offset_))) {
-    PLOG(ERROR) << "Failed to write dex file offset to " << out.GetLocation();
+  if (!out->WriteFully(&dex_file_offset_, sizeof(dex_file_offset_))) {
+    PLOG(ERROR) << "Failed to write dex file offset to " << out->GetLocation();
     return false;
   }
   oat_writer->size_oat_dex_file_offset_ += sizeof(dex_file_offset_);
-  if (!out.WriteFully(&methods_offsets_[0],
+  if (!out->WriteFully(&methods_offsets_[0],
                       sizeof(methods_offsets_[0]) * methods_offsets_.size())) {
-    PLOG(ERROR) << "Failed to write methods offsets to " << out.GetLocation();
+    PLOG(ERROR) << "Failed to write methods offsets to " << out->GetLocation();
     return false;
   }
   oat_writer->size_oat_dex_file_methods_offsets_ +=
@@ -1020,48 +1020,48 @@ size_t OatWriter::OatClass::SizeOf() const {
           + (sizeof(method_offsets_[0]) * method_offsets_.size());
 }
 
-void OatWriter::OatClass::UpdateChecksum(OatHeader& oat_header) const {
-  oat_header.UpdateChecksum(&status_, sizeof(status_));
-  oat_header.UpdateChecksum(&type_, sizeof(type_));
+void OatWriter::OatClass::UpdateChecksum(OatHeader* oat_header) const {
+  oat_header->UpdateChecksum(&status_, sizeof(status_));
+  oat_header->UpdateChecksum(&type_, sizeof(type_));
   if (method_bitmap_size_ != 0) {
     CHECK_EQ(kOatClassSomeCompiled, type_);
-    oat_header.UpdateChecksum(&method_bitmap_size_, sizeof(method_bitmap_size_));
-    oat_header.UpdateChecksum(method_bitmap_->GetRawStorage(), method_bitmap_size_);
+    oat_header->UpdateChecksum(&method_bitmap_size_, sizeof(method_bitmap_size_));
+    oat_header->UpdateChecksum(method_bitmap_->GetRawStorage(), method_bitmap_size_);
   }
-  oat_header.UpdateChecksum(&method_offsets_[0],
-                            sizeof(method_offsets_[0]) * method_offsets_.size());
+  oat_header->UpdateChecksum(&method_offsets_[0],
+                             sizeof(method_offsets_[0]) * method_offsets_.size());
 }
 
 bool OatWriter::OatClass::Write(OatWriter* oat_writer,
-                                OutputStream& out,
+                                OutputStream* out,
                                 const size_t file_offset) const {
   DCHECK_OFFSET_();
-  if (!out.WriteFully(&status_, sizeof(status_))) {
-    PLOG(ERROR) << "Failed to write class status to " << out.GetLocation();
+  if (!out->WriteFully(&status_, sizeof(status_))) {
+    PLOG(ERROR) << "Failed to write class status to " << out->GetLocation();
     return false;
   }
   oat_writer->size_oat_class_status_ += sizeof(status_);
-  if (!out.WriteFully(&type_, sizeof(type_))) {
-    PLOG(ERROR) << "Failed to write oat class type to " << out.GetLocation();
+  if (!out->WriteFully(&type_, sizeof(type_))) {
+    PLOG(ERROR) << "Failed to write oat class type to " << out->GetLocation();
     return false;
   }
   oat_writer->size_oat_class_type_ += sizeof(type_);
   if (method_bitmap_size_ != 0) {
     CHECK_EQ(kOatClassSomeCompiled, type_);
-    if (!out.WriteFully(&method_bitmap_size_, sizeof(method_bitmap_size_))) {
-      PLOG(ERROR) << "Failed to write method bitmap size to " << out.GetLocation();
+    if (!out->WriteFully(&method_bitmap_size_, sizeof(method_bitmap_size_))) {
+      PLOG(ERROR) << "Failed to write method bitmap size to " << out->GetLocation();
       return false;
     }
     oat_writer->size_oat_class_method_bitmaps_ += sizeof(method_bitmap_size_);
-    if (!out.WriteFully(method_bitmap_->GetRawStorage(), method_bitmap_size_)) {
-      PLOG(ERROR) << "Failed to write method bitmap to " << out.GetLocation();
+    if (!out->WriteFully(method_bitmap_->GetRawStorage(), method_bitmap_size_)) {
+      PLOG(ERROR) << "Failed to write method bitmap to " << out->GetLocation();
       return false;
     }
     oat_writer->size_oat_class_method_bitmaps_ += method_bitmap_size_;
   }
-  if (!out.WriteFully(&method_offsets_[0],
+  if (!out->WriteFully(&method_offsets_[0],
                       sizeof(method_offsets_[0]) * method_offsets_.size())) {
-    PLOG(ERROR) << "Failed to write method offsets to " << out.GetLocation();
+    PLOG(ERROR) << "Failed to write method offsets to " << out->GetLocation();
     return false;
   }
   oat_writer->size_oat_class_method_offsets_ += sizeof(method_offsets_[0]) * method_offsets_.size();
diff --git a/compiler/oat_writer.h b/compiler/oat_writer.h
index 067c789..f12c84d 100644
--- a/compiler/oat_writer.h
+++ b/compiler/oat_writer.h
@@ -78,7 +78,7 @@ class OatWriter {
     return size_;
   }
 
-  bool Write(OutputStream& out);
+  bool Write(OutputStream* out);
 
   ~OatWriter();
 
@@ -105,28 +105,28 @@ class OatWriter {
                            bool is_native, InvokeType type, uint32_t method_idx, const DexFile&)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  bool WriteTables(OutputStream& out, const size_t file_offset);
-  size_t WriteCode(OutputStream& out, const size_t file_offset);
-  size_t WriteCodeDexFiles(OutputStream& out, const size_t file_offset, size_t relative_offset);
-  size_t WriteCodeDexFile(OutputStream& out, const size_t file_offset, size_t relative_offset,
+  bool WriteTables(OutputStream* out, const size_t file_offset);
+  size_t WriteCode(OutputStream* out, const size_t file_offset);
+  size_t WriteCodeDexFiles(OutputStream* out, const size_t file_offset, size_t relative_offset);
+  size_t WriteCodeDexFile(OutputStream* out, const size_t file_offset, size_t relative_offset,
                           size_t* oat_class_index, const DexFile& dex_file);
-  size_t WriteCodeClassDef(OutputStream& out, const size_t file_offset, size_t relative_offset,
+  size_t WriteCodeClassDef(OutputStream* out, const size_t file_offset, size_t relative_offset,
                            size_t oat_class_index, const DexFile& dex_file,
                            const DexFile::ClassDef& class_def);
-  size_t WriteCodeMethod(OutputStream& out, const size_t file_offset, size_t relative_offset,
+  size_t WriteCodeMethod(OutputStream* out, const size_t file_offset, size_t relative_offset,
                          size_t oat_class_index, size_t class_def_method_index,
                          size_t* method_offsets_index, bool is_static, uint32_t method_idx,
                          const DexFile& dex_file);
 
   void ReportWriteFailure(const char* what, uint32_t method_idx, const DexFile& dex_file,
-                          OutputStream& out) const;
+                          const OutputStream& out) const;
 
   class OatDexFile {
    public:
     explicit OatDexFile(size_t offset, const DexFile& dex_file);
     size_t SizeOf() const;
-    void UpdateChecksum(OatHeader& oat_header) const;
-    bool Write(OatWriter* oat_writer, OutputStream& out, const size_t file_offset) const;
+    void UpdateChecksum(OatHeader* oat_header) const;
+    bool Write(OatWriter* oat_writer, OutputStream* out, const size_t file_offset) const;
 
     // Offset of start of OatDexFile from beginning of OatHeader. It is
     // used to validate file position when writing.
@@ -153,8 +153,8 @@ class OatWriter {
     size_t GetOatMethodOffsetsOffsetFromOatHeader(size_t class_def_method_index_) const;
     size_t GetOatMethodOffsetsOffsetFromOatClass(size_t class_def_method_index_) const;
     size_t SizeOf() const;
-    void UpdateChecksum(OatHeader& oat_header) const;
-    bool Write(OatWriter* oat_writer, OutputStream& out, const size_t file_offset) const;
+    void UpdateChecksum(OatHeader* oat_header) const;
+    bool Write(OatWriter* oat_writer, OutputStream* out, const size_t file_offset) const;
 
     CompiledMethod* GetCompiledMethod(size_t class_def_method_index) const {
       DCHECK(compiled_methods_ != NULL);
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index a082e36..0e54021 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -349,9 +349,9 @@ class Dex2Oat {
                                                         dump_passes,
                                                         &compiler_phases_timings));
 
-    driver->GetCompilerBackend()->SetBitcodeFileName(bitcode_filename);
+    driver->GetCompilerBackend()->SetBitcodeFileName(*driver.get(), bitcode_filename);
 
-    driver->CompileAll(class_loader, dex_files, timings);
+    driver->CompileAll(class_loader, dex_files, &timings);
 
     timings.NewSplit("dex2oat OatWriter");
     std::string image_file_location;
@@ -377,7 +377,7 @@ class Dex2Oat {
                          &timings);
 
     TimingLogger::ScopedSplit split("Writing ELF", &timings);
-    if (!driver->WriteElf(android_root, is_host, dex_files, oat_writer, oat_file)) {
+    if (!driver->WriteElf(android_root, is_host, dex_files, &oat_writer, oat_file)) {
       LOG(ERROR) << "Failed to write ELF file " << oat_file->GetPath();
       return NULL;
     }
@@ -1302,7 +1302,7 @@ static int dex2oat(int argc, char** argv) {
       LOG(INFO) << Dumpable<TimingLogger>(timings);
     }
     if (dump_passes) {
-      LOG(INFO) << Dumpable<CumulativeLogger>(compiler.get()->GetTimingsLogger());
+      LOG(INFO) << Dumpable<CumulativeLogger>(*compiler.get()->GetTimingsLogger());
     }
     return EXIT_SUCCESS;
   }