ART: Reduce dependencies on CompilerDriver.

Preparation for moving CompilerDriver and other stuff
from libart-compiler.so to dex2oat.

Test: m test-art-host-gtest
Test: testrunner.py --host --optimizing
Change-Id: Ic221ebca4b8c79dd1549316921ace655f2e3f0fe

19 files changed, 99 insertions, 130 deletions

diff --git a/compiler/compiler.cc b/compiler/compiler.cc
index 54da446e6d..d044c2fe4f 100644
--- a/compiler/compiler.cc
+++ b/compiler/compiler.cc
@@ -22,17 +22,18 @@
 #include "base/utils.h"
 #include "dex/code_item_accessors-inl.h"
 #include "dex/dex_file.h"
-#include "driver/compiler_driver.h"
 #include "optimizing/optimizing_compiler.h"
 
 namespace art {
 
-Compiler* Compiler::Create(CompilerDriver* driver, Compiler::Kind kind) {
+Compiler* Compiler::Create(const CompilerOptions& compiler_options,
+                           CompiledMethodStorage* storage,
+                           Compiler::Kind kind) {
   switch (kind) {
     case kQuick:
       // TODO: Remove Quick in options.
     case kOptimizing:
-      return CreateOptimizingCompiler(driver);
+      return CreateOptimizingCompiler(compiler_options, storage);
 
     default:
       LOG(FATAL) << "UNREACHABLE";
diff --git a/compiler/compiler.h b/compiler/compiler.h
index 8a67724de0..a496c6ced5 100644
--- a/compiler/compiler.h
+++ b/compiler/compiler.h
@@ -36,8 +36,9 @@ class DexCache;
 }  // namespace mirror
 
 class ArtMethod;
-class CompilerDriver;
 class CompiledMethod;
+class CompiledMethodStorage;
+class CompilerOptions;
 class DexFile;
 template<class T> class Handle;
 class OatWriter;
@@ -50,11 +51,9 @@ class Compiler {
     kOptimizing
   };
 
-  static Compiler* Create(CompilerDriver* driver, Kind kind);
-
-  virtual void Init() = 0;
-
-  virtual void UnInit() const = 0;
+  static Compiler* Create(const CompilerOptions& compiler_options,
+                          CompiledMethodStorage* storage,
+                          Kind kind);
 
   virtual bool CanCompileMethod(uint32_t method_idx, const DexFile& dex_file) const = 0;
 
@@ -91,19 +90,6 @@ class Compiler {
 
   virtual ~Compiler() {}
 
-  /*
-   * @brief Generate and return Dwarf CFI initialization, if supported by the
-   * backend.
-   * @param driver CompilerDriver for this compile.
-   * @returns nullptr if not supported by backend or a vector of bytes for CFI DWARF
-   * information.
-   * @note This is used for backtrace information in generated code.
-   */
-  virtual std::vector<uint8_t>* GetCallFrameInformationInitialization(
-      const CompilerDriver& driver ATTRIBUTE_UNUSED) const {
-    return nullptr;
-  }
-
   // Returns whether the method to compile is such a pathological case that
   // it's not worth compiling.
   static bool IsPathologicalCase(const dex::CodeItem& code_item,
@@ -111,16 +97,25 @@ class Compiler {
                                  const DexFile& dex_file);
 
  protected:
-  Compiler(CompilerDriver* driver, uint64_t warning) :
-      driver_(driver), maximum_compilation_time_before_warning_(warning) {
+  Compiler(const CompilerOptions& compiler_options,
+           CompiledMethodStorage* storage,
+           uint64_t warning) :
+      compiler_options_(compiler_options),
+      storage_(storage),
+      maximum_compilation_time_before_warning_(warning) {
+  }
+
+  const CompilerOptions& GetCompilerOptions() const {
+    return compiler_options_;
   }
 
-  CompilerDriver* GetCompilerDriver() const {
-    return driver_;
+  CompiledMethodStorage* GetCompiledMethodStorage() const {
+    return storage_;
   }
 
  private:
-  CompilerDriver* const driver_;
+  const CompilerOptions& compiler_options_;
+  CompiledMethodStorage* const storage_;
   const uint64_t maximum_compilation_time_before_warning_;
 
   DISALLOW_COPY_AND_ASSIGN(Compiler);
diff --git a/compiler/dex/verification_results.cc b/compiler/dex/verification_results.cc
index 6bd5fe8bd8..e7a3817c56 100644
--- a/compiler/dex/verification_results.cc
+++ b/compiler/dex/verification_results.cc
@@ -20,7 +20,6 @@
 
 #include "base/mutex-inl.h"
 #include "base/stl_util.h"
-#include "driver/compiler_driver.h"
 #include "driver/compiler_options.h"
 #include "runtime.h"
 #include "thread-current-inl.h"
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index f39d8fc896..e9a3d550d9 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -258,7 +258,7 @@ CompilerDriver::CompilerDriver(
     size_t thread_count,
     int swap_fd)
     : compiler_options_(compiler_options),
-      compiler_(Compiler::Create(this, compiler_kind)),
+      compiler_(),
       compiler_kind_(compiler_kind),
       number_of_soft_verifier_failures_(0),
       had_hard_verifier_failure_(false),
@@ -269,9 +269,8 @@ CompilerDriver::CompilerDriver(
       dex_to_dex_compiler_(this) {
   DCHECK(compiler_options_ != nullptr);
 
-  compiler_->Init();
-
   compiled_method_storage_.SetDedupeEnabled(compiler_options_->DeduplicateCode());
+  compiler_.reset(Compiler::Create(*compiler_options, &compiled_method_storage_, compiler_kind));
 }
 
 CompilerDriver::~CompilerDriver() {
@@ -281,7 +280,6 @@ CompilerDriver::~CompilerDriver() {
       CompiledMethod::ReleaseSwapAllocatedCompiledMethod(GetCompiledMethodStorage(), method);
     }
   });
-  compiler_->UnInit();
 }
 
 
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index 6f8ec125bc..199835c6d2 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -22,8 +22,6 @@
 #include <string>
 #include <vector>
 
-#include "android-base/strings.h"
-
 #include "arch/instruction_set.h"
 #include "base/array_ref.h"
 #include "base/bit_utils.h"
@@ -246,23 +244,6 @@ class CompilerDriver {
     return &compiled_method_storage_;
   }
 
-  // Is `boot_image_filename` the name of a core image (small boot
-  // image used for ART testing only)?
-  static bool IsCoreImageFilename(const std::string& boot_image_filename) {
-    // Look for "core.art" or "core-*.art".
-    if (android::base::EndsWith(boot_image_filename, "core.art")) {
-      return true;
-    }
-    if (!android::base::EndsWith(boot_image_filename, ".art")) {
-      return false;
-    }
-    size_t slash_pos = boot_image_filename.rfind('/');
-    if (slash_pos == std::string::npos) {
-      return android::base::StartsWith(boot_image_filename, "core-");
-    }
-    return boot_image_filename.compare(slash_pos + 1, 5u, "core-") == 0;
-  }
-
   optimizer::DexToDexCompiler& GetDexToDexCompiler() {
     return dex_to_dex_compiler_;
   }
diff --git a/compiler/driver/compiler_options.cc b/compiler/driver/compiler_options.cc
index 7dd743f533..6f39488cc7 100644
--- a/compiler/driver/compiler_options.cc
+++ b/compiler/driver/compiler_options.cc
@@ -20,6 +20,7 @@
 #include <string_view>
 
 #include "android-base/stringprintf.h"
+#include "android-base/strings.h"
 
 #include "arch/instruction_set.h"
 #include "arch/instruction_set_features.h"
@@ -184,4 +185,19 @@ bool CompilerOptions::IsMethodVerifiedWithoutFailures(uint32_t method_idx,
   return is_system_class;
 }
 
+bool CompilerOptions::IsCoreImageFilename(const std::string& boot_image_filename) {
+  // Look for "core.art" or "core-*.art".
+  if (android::base::EndsWith(boot_image_filename, "core.art")) {
+    return true;
+  }
+  if (!android::base::EndsWith(boot_image_filename, ".art")) {
+    return false;
+  }
+  size_t slash_pos = boot_image_filename.rfind('/');
+  if (slash_pos == std::string::npos) {
+    return android::base::StartsWith(boot_image_filename, "core-");
+  }
+  return boot_image_filename.compare(slash_pos + 1, 5u, "core-") == 0;
+}
+
 }  // namespace art
diff --git a/compiler/driver/compiler_options.h b/compiler/driver/compiler_options.h
index fccd9ca26e..25d7b36571 100644
--- a/compiler/driver/compiler_options.h
+++ b/compiler/driver/compiler_options.h
@@ -359,6 +359,10 @@ class CompilerOptions final {
     max_image_block_size_ = size;
   }
 
+  // Is `boot_image_filename` the name of a core image (small boot
+  // image used for ART testing only)?
+  static bool IsCoreImageFilename(const std::string& boot_image_filename);
+
  private:
   bool ParseDumpInitFailures(const std::string& option, std::string* error_msg);
   bool ParseRegisterAllocationStrategy(const std::string& option, std::string* error_msg);
diff --git a/compiler/jit/jit_compiler.cc b/compiler/jit/jit_compiler.cc
index 2c20b3224e..bbf34585eb 100644
--- a/compiler/jit/jit_compiler.cc
+++ b/compiler/jit/jit_compiler.cc
@@ -26,8 +26,8 @@
 #include "base/systrace.h"
 #include "base/time_utils.h"
 #include "base/timing_logger.h"
+#include "compiler.h"
 #include "debug/elf_debug_writer.h"
-#include "driver/compiler_driver.h"
 #include "driver/compiler_options.h"
 #include "jit/debugger_interface.h"
 #include "jit/jit.h"
@@ -107,7 +107,7 @@ void JitCompiler::ParseCompilerOptions() {
   }
   compiler_options_->instruction_set_features_ = std::move(instruction_set_features);
   compiler_options_->compiling_with_core_image_ =
-      CompilerDriver::IsCoreImageFilename(runtime->GetImageLocation());
+      CompilerOptions::IsCoreImageFilename(runtime->GetImageLocation());
 
   if (compiler_options_->GetGenerateDebugInfo()) {
     jit_logger_.reset(new JitLogger());
@@ -171,14 +171,8 @@ extern "C" bool jit_generate_debug_info(void* handle) {
 JitCompiler::JitCompiler() {
   compiler_options_.reset(new CompilerOptions());
   ParseCompilerOptions();
-
-  compiler_driver_.reset(new CompilerDriver(
-      compiler_options_.get(),
-      Compiler::kOptimizing,
-      /* thread_count= */ 1,
-      /* swap_fd= */ -1));
-  // Disable dedupe so we can remove compiled methods.
-  compiler_driver_->SetDedupeEnabled(false);
+  compiler_.reset(
+      Compiler::Create(*compiler_options_, /*storage=*/ nullptr, Compiler::kOptimizing));
 }
 
 JitCompiler::~JitCompiler() {
@@ -203,8 +197,7 @@ bool JitCompiler::CompileMethod(Thread* self, ArtMethod* method, bool baseline,
   {
     TimingLogger::ScopedTiming t2("Compiling", &logger);
     JitCodeCache* const code_cache = runtime->GetJit()->GetCodeCache();
-    success = compiler_driver_->GetCompiler()->JitCompile(
-        self, code_cache, method, baseline, osr, jit_logger_.get());
+    success = compiler_->JitCompile(self, code_cache, method, baseline, osr, jit_logger_.get());
   }
 
   // Trim maps to reduce memory usage.
diff --git a/compiler/jit/jit_compiler.h b/compiler/jit/jit_compiler.h
index 29d2761348..d008de404a 100644
--- a/compiler/jit/jit_compiler.h
+++ b/compiler/jit/jit_compiler.h
@@ -23,7 +23,7 @@ namespace art {
 
 class ArtMethod;
 class CompiledMethod;
-class CompilerDriver;
+class Compiler;
 class CompilerOptions;
 class Thread;
 
@@ -44,15 +44,11 @@ class JitCompiler {
     return *compiler_options_.get();
   }
 
-  CompilerDriver* GetCompilerDriver() const {
-    return compiler_driver_.get();
-  }
-
   void ParseCompilerOptions();
 
  private:
   std::unique_ptr<CompilerOptions> compiler_options_;
-  std::unique_ptr<CompilerDriver> compiler_driver_;
+  std::unique_ptr<Compiler> compiler_;
   std::unique_ptr<JitLogger> jit_logger_;
 
   JitCompiler();
diff --git a/compiler/jit/jit_logger.cc b/compiler/jit/jit_logger.cc
index 2199b64139..6b9453f525 100644
--- a/compiler/jit/jit_logger.cc
+++ b/compiler/jit/jit_logger.cc
@@ -20,7 +20,6 @@
 #include "art_method-inl.h"
 #include "base/time_utils.h"
 #include "base/unix_file/fd_file.h"
-#include "driver/compiler_driver.h"
 #include "jit/jit.h"
 #include "jit/jit_code_cache.h"
 #include "oat_file-inl.h"
diff --git a/compiler/jit/jit_logger.h b/compiler/jit/jit_logger.h
index 8b39888315..f4ef75a5fe 100644
--- a/compiler/jit/jit_logger.h
+++ b/compiler/jit/jit_logger.h
@@ -17,10 +17,11 @@
 #ifndef ART_COMPILER_JIT_JIT_LOGGER_H_
 #define ART_COMPILER_JIT_JIT_LOGGER_H_
 
+#include <memory>
+
 #include "base/mutex.h"
+#include "base/os.h"
 #include "compiled_method.h"
-#include "driver/compiler_driver.h"
-#include "driver/compiler_options.h"
 
 namespace art {
 
diff --git a/compiler/optimizing/code_generator.cc b/compiler/optimizing/code_generator.cc
index 122f27b0e0..cc2ff1696c 100644
--- a/compiler/optimizing/code_generator.cc
+++ b/compiler/optimizing/code_generator.cc
@@ -49,7 +49,6 @@
 #include "dex/bytecode_utils.h"
 #include "dex/code_item_accessors-inl.h"
 #include "dex/verified_method.h"
-#include "driver/compiler_driver.h"
 #include "graph_visualizer.h"
 #include "image.h"
 #include "gc/space/image_space.h"
diff --git a/compiler/optimizing/inliner.h b/compiler/optimizing/inliner.h
index efd4c74079..15d7349694 100644
--- a/compiler/optimizing/inliner.h
+++ b/compiler/optimizing/inliner.h
@@ -25,7 +25,6 @@
 namespace art {
 
 class CodeGenerator;
-class CompilerDriver;
 class DexCompilationUnit;
 class HGraph;
 class HInvoke;
diff --git a/compiler/optimizing/optimization.h b/compiler/optimizing/optimization.h
index ce44b5f81a..b84e03894c 100644
--- a/compiler/optimizing/optimization.h
+++ b/compiler/optimizing/optimization.h
@@ -24,7 +24,6 @@
 namespace art {
 
 class CodeGenerator;
-class CompilerDriver;
 class DexCompilationUnit;
 
 /**
diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index 4f43b71fde..dd5d4a5891 100644
--- a/compiler/optimizing/optimizing_compiler.cc
+++ b/compiler/optimizing/optimizing_compiler.cc
@@ -41,7 +41,7 @@
 #include "dex/dex_file_types.h"
 #include "dex/verification_results.h"
 #include "dex/verified_method.h"
-#include "driver/compiler_driver-inl.h"
+#include "driver/compiled_method_storage.h"
 #include "driver/compiler_options.h"
 #include "driver/dex_compilation_unit.h"
 #include "graph_checker.h"
@@ -107,22 +107,22 @@ class PassObserver : public ValueObject {
   PassObserver(HGraph* graph,
                CodeGenerator* codegen,
                std::ostream* visualizer_output,
-               CompilerDriver* compiler_driver,
+               const CompilerOptions& compiler_options,
                Mutex& dump_mutex)
       : graph_(graph),
         last_seen_graph_size_(0),
         cached_method_name_(),
-        timing_logger_enabled_(compiler_driver->GetCompilerOptions().GetDumpPassTimings()),
+        timing_logger_enabled_(compiler_options.GetDumpPassTimings()),
         timing_logger_(timing_logger_enabled_ ? GetMethodName() : "", true, true),
         disasm_info_(graph->GetAllocator()),
         visualizer_oss_(),
         visualizer_output_(visualizer_output),
-        visualizer_enabled_(!compiler_driver->GetCompilerOptions().GetDumpCfgFileName().empty()),
+        visualizer_enabled_(!compiler_options.GetDumpCfgFileName().empty()),
         visualizer_(&visualizer_oss_, graph, *codegen),
         visualizer_dump_mutex_(dump_mutex),
         graph_in_bad_state_(false) {
     if (timing_logger_enabled_ || visualizer_enabled_) {
-      if (!IsVerboseMethod(compiler_driver, GetMethodName())) {
+      if (!IsVerboseMethod(compiler_options, GetMethodName())) {
         timing_logger_enabled_ = visualizer_enabled_ = false;
       }
       if (visualizer_enabled_) {
@@ -200,11 +200,11 @@ class PassObserver : public ValueObject {
     }
   }
 
-  static bool IsVerboseMethod(CompilerDriver* compiler_driver, const char* method_name) {
+  static bool IsVerboseMethod(const CompilerOptions& compiler_options, const char* method_name) {
     // Test an exact match to --verbose-methods. If verbose-methods is set, this overrides an
     // empty kStringFilter matching all methods.
-    if (compiler_driver->GetCompilerOptions().HasVerboseMethods()) {
-      return compiler_driver->GetCompilerOptions().IsVerboseMethod(method_name);
+    if (compiler_options.HasVerboseMethods()) {
+      return compiler_options.IsVerboseMethod(method_name);
     }
 
     // Test the kStringFilter sub-string. constexpr helper variable to silence unreachable-code
@@ -267,7 +267,8 @@ class PassScope : public ValueObject {
 
 class OptimizingCompiler final : public Compiler {
  public:
-  explicit OptimizingCompiler(CompilerDriver* driver);
+  explicit OptimizingCompiler(const CompilerOptions& compiler_options,
+                              CompiledMethodStorage* storage);
   ~OptimizingCompiler() override;
 
   bool CanCompileMethod(uint32_t method_idx, const DexFile& dex_file) const override;
@@ -289,13 +290,9 @@ class OptimizingCompiler final : public Compiler {
   uintptr_t GetEntryPointOf(ArtMethod* method) const override
       REQUIRES_SHARED(Locks::mutator_lock_) {
     return reinterpret_cast<uintptr_t>(method->GetEntryPointFromQuickCompiledCodePtrSize(
-        InstructionSetPointerSize(GetCompilerDriver()->GetCompilerOptions().GetInstructionSet())));
+        InstructionSetPointerSize(GetCompilerOptions().GetInstructionSet())));
   }
 
-  void Init() override;
-
-  void UnInit() const override;
-
   bool JitCompile(Thread* self,
                   jit::JitCodeCache* code_cache,
                   ArtMethod* method,
@@ -422,28 +419,22 @@ class OptimizingCompiler final : public Compiler {
 
 static const int kMaximumCompilationTimeBeforeWarning = 100; /* ms */
 
-OptimizingCompiler::OptimizingCompiler(CompilerDriver* driver)
-    : Compiler(driver, kMaximumCompilationTimeBeforeWarning),
-      dump_mutex_("Visualizer dump lock") {}
-
-void OptimizingCompiler::Init() {
-  // Enable C1visualizer output. Must be done in Init() because the compiler
-  // driver is not fully initialized when passed to the compiler's constructor.
-  CompilerDriver* driver = GetCompilerDriver();
-  const std::string cfg_file_name = driver->GetCompilerOptions().GetDumpCfgFileName();
+OptimizingCompiler::OptimizingCompiler(const CompilerOptions& compiler_options,
+                                       CompiledMethodStorage* storage)
+    : Compiler(compiler_options, storage, kMaximumCompilationTimeBeforeWarning),
+      dump_mutex_("Visualizer dump lock") {
+  // Enable C1visualizer output.
+  const std::string& cfg_file_name = compiler_options.GetDumpCfgFileName();
   if (!cfg_file_name.empty()) {
     std::ios_base::openmode cfg_file_mode =
-        driver->GetCompilerOptions().GetDumpCfgAppend() ? std::ofstream::app : std::ofstream::out;
+        compiler_options.GetDumpCfgAppend() ? std::ofstream::app : std::ofstream::out;
     visualizer_output_.reset(new std::ofstream(cfg_file_name, cfg_file_mode));
   }
-  if (driver->GetCompilerOptions().GetDumpStats()) {
+  if (compiler_options.GetDumpStats()) {
     compilation_stats_.reset(new OptimizingCompilerStats());
   }
 }
 
-void OptimizingCompiler::UnInit() const {
-}
-
 OptimizingCompiler::~OptimizingCompiler() {
   if (compilation_stats_.get() != nullptr) {
     compilation_stats_->Log();
@@ -652,8 +643,7 @@ void OptimizingCompiler::RunOptimizations(HGraph* graph,
                                           const DexCompilationUnit& dex_compilation_unit,
                                           PassObserver* pass_observer,
                                           VariableSizedHandleScope* handles) const {
-  const std::vector<std::string>* pass_names =
-      GetCompilerDriver()->GetCompilerOptions().GetPassesToRun();
+  const std::vector<std::string>* pass_names = GetCompilerOptions().GetPassesToRun();
   if (pass_names != nullptr) {
     // If passes were defined on command-line, build the optimization
     // passes and run these instead of the built-in optimizations.
@@ -764,15 +754,15 @@ CompiledMethod* OptimizingCompiler::Emit(ArenaAllocator* allocator,
   ArenaVector<linker::LinkerPatch> linker_patches = EmitAndSortLinkerPatches(codegen);
   ScopedArenaVector<uint8_t> stack_map = codegen->BuildStackMaps(code_item_for_osr_check);
 
+  CompiledMethodStorage* storage = GetCompiledMethodStorage();
   CompiledMethod* compiled_method = CompiledMethod::SwapAllocCompiledMethod(
-      GetCompilerDriver()->GetCompiledMethodStorage(),
+      storage,
       codegen->GetInstructionSet(),
       code_allocator->GetMemory(),
       ArrayRef<const uint8_t>(stack_map),
       ArrayRef<const uint8_t>(*codegen->GetAssembler()->cfi().data()),
       ArrayRef<const linker::LinkerPatch>(linker_patches));
 
-  CompiledMethodStorage* storage = GetCompilerDriver()->GetCompiledMethodStorage();
   for (const linker::LinkerPatch& patch : linker_patches) {
     if (codegen->NeedsThunkCode(patch) && storage->GetThunkCode(patch).empty()) {
       ArenaVector<uint8_t> code(allocator->Adapter());
@@ -794,8 +784,7 @@ CodeGenerator* OptimizingCompiler::TryCompile(ArenaAllocator* allocator,
                                               bool osr,
                                               VariableSizedHandleScope* handles) const {
   MaybeRecordStat(compilation_stats_.get(), MethodCompilationStat::kAttemptBytecodeCompilation);
-  CompilerDriver* compiler_driver = GetCompilerDriver();
-  const CompilerOptions& compiler_options = compiler_driver->GetCompilerOptions();
+  const CompilerOptions& compiler_options = GetCompilerOptions();
   InstructionSet instruction_set = compiler_options.GetInstructionSet();
   const DexFile& dex_file = *dex_compilation_unit.GetDexFile();
   uint32_t method_idx = dex_compilation_unit.GetDexMethodIndex();
@@ -859,7 +848,7 @@ CodeGenerator* OptimizingCompiler::TryCompile(ArenaAllocator* allocator,
       compiler_options.GetInstructionSet(),
       kInvalidInvokeType,
       dead_reference_safe,
-      compiler_driver->GetCompilerOptions().GetDebuggable(),
+      compiler_options.GetDebuggable(),
       /* osr= */ osr);
 
   if (method != nullptr) {
@@ -874,13 +863,12 @@ CodeGenerator* OptimizingCompiler::TryCompile(ArenaAllocator* allocator,
     MaybeRecordStat(compilation_stats_.get(), MethodCompilationStat::kNotCompiledNoCodegen);
     return nullptr;
   }
-  codegen->GetAssembler()->cfi().SetEnabled(
-      compiler_driver->GetCompilerOptions().GenerateAnyDebugInfo());
+  codegen->GetAssembler()->cfi().SetEnabled(compiler_options.GenerateAnyDebugInfo());
 
   PassObserver pass_observer(graph,
                              codegen.get(),
                              visualizer_output_.get(),
-                             compiler_driver,
+                             compiler_options,
                              dump_mutex_);
 
   {
@@ -959,8 +947,7 @@ CodeGenerator* OptimizingCompiler::TryCompileIntrinsic(
     ArtMethod* method,
     VariableSizedHandleScope* handles) const {
   MaybeRecordStat(compilation_stats_.get(), MethodCompilationStat::kAttemptIntrinsicCompilation);
-  CompilerDriver* compiler_driver = GetCompilerDriver();
-  const CompilerOptions& compiler_options = compiler_driver->GetCompilerOptions();
+  const CompilerOptions& compiler_options = GetCompilerOptions();
   InstructionSet instruction_set = compiler_options.GetInstructionSet();
   const DexFile& dex_file = *dex_compilation_unit.GetDexFile();
   uint32_t method_idx = dex_compilation_unit.GetDexMethodIndex();
@@ -1001,7 +988,7 @@ CodeGenerator* OptimizingCompiler::TryCompileIntrinsic(
   PassObserver pass_observer(graph,
                              codegen.get(),
                              visualizer_output_.get(),
-                             compiler_driver,
+                             compiler_options,
                              dump_mutex_);
 
   {
@@ -1035,7 +1022,7 @@ CodeGenerator* OptimizingCompiler::TryCompileIntrinsic(
   AllocateRegisters(graph,
                     codegen.get(),
                     &pass_observer,
-                    compiler_driver->GetCompilerOptions().GetRegisterAllocationStrategy(),
+                    compiler_options.GetRegisterAllocationStrategy(),
                     compilation_stats_.get());
   if (!codegen->IsLeafMethod()) {
     VLOG(compiler) << "Intrinsic method is not leaf: " << method->GetIntrinsic()
@@ -1060,8 +1047,7 @@ CompiledMethod* OptimizingCompiler::Compile(const dex::CodeItem* code_item,
                                             Handle<mirror::ClassLoader> jclass_loader,
                                             const DexFile& dex_file,
                                             Handle<mirror::DexCache> dex_cache) const {
-  CompilerDriver* compiler_driver = GetCompilerDriver();
-  const CompilerOptions& compiler_options = compiler_driver->GetCompilerOptions();
+  const CompilerOptions& compiler_options = GetCompilerOptions();
   CompiledMethod* compiled_method = nullptr;
   Runtime* runtime = Runtime::Current();
   DCHECK(runtime->IsAotCompiler());
@@ -1194,7 +1180,7 @@ CompiledMethod* OptimizingCompiler::JniCompile(uint32_t access_flags,
   ArenaAllocator allocator(runtime->GetArenaPool());
   ArenaStack arena_stack(runtime->GetArenaPool());
 
-  const CompilerOptions& compiler_options = GetCompilerDriver()->GetCompilerOptions();
+  const CompilerOptions& compiler_options = GetCompilerOptions();
   if (compiler_options.IsBootImage()) {
     ScopedObjectAccess soa(Thread::Current());
     ArtMethod* method = runtime->GetClassLinker()->LookupResolvedMethod(
@@ -1243,7 +1229,7 @@ CompiledMethod* OptimizingCompiler::JniCompile(uint32_t access_flags,
   ScopedArenaVector<uint8_t> stack_map = CreateJniStackMap(
       &stack_map_allocator, jni_compiled_method, jni_compiled_method.GetCode().size());
   return CompiledMethod::SwapAllocCompiledMethod(
-      GetCompilerDriver()->GetCompiledMethodStorage(),
+      GetCompiledMethodStorage(),
       jni_compiled_method.GetInstructionSet(),
       jni_compiled_method.GetCode(),
       ArrayRef<const uint8_t>(stack_map),
@@ -1251,8 +1237,9 @@ CompiledMethod* OptimizingCompiler::JniCompile(uint32_t access_flags,
       /* patches= */ ArrayRef<const linker::LinkerPatch>());
 }
 
-Compiler* CreateOptimizingCompiler(CompilerDriver* driver) {
-  return new OptimizingCompiler(driver);
+Compiler* CreateOptimizingCompiler(const CompilerOptions& compiler_options,
+                                   CompiledMethodStorage* storage) {
+  return new OptimizingCompiler(compiler_options, storage);
 }
 
 bool EncodeArtMethodInInlineInfo(ArtMethod* method ATTRIBUTE_UNUSED) {
@@ -1282,7 +1269,7 @@ bool OptimizingCompiler::JitCompile(Thread* self,
   ArenaAllocator allocator(runtime->GetJitArenaPool());
 
   if (UNLIKELY(method->IsNative())) {
-    const CompilerOptions& compiler_options = GetCompilerDriver()->GetCompilerOptions();
+    const CompilerOptions& compiler_options = GetCompilerOptions();
     JniCompiledMethod jni_compiled_method = ArtQuickJniCompileMethod(
         compiler_options, access_flags, method_idx, *dex_file);
     std::vector<Handle<mirror::Object>> roots;
@@ -1431,7 +1418,7 @@ bool OptimizingCompiler::JitCompile(Thread* self,
     return false;
   }
 
-  const CompilerOptions& compiler_options = GetCompilerDriver()->GetCompilerOptions();
+  const CompilerOptions& compiler_options = GetCompilerOptions();
   if (compiler_options.GenerateAnyDebugInfo()) {
     const auto* method_header = reinterpret_cast<const OatQuickMethodHeader*>(code);
     const uintptr_t code_address = reinterpret_cast<uintptr_t>(method_header->GetCode());
@@ -1478,7 +1465,7 @@ bool OptimizingCompiler::JitCompile(Thread* self,
 
 void OptimizingCompiler::GenerateJitDebugInfo(ArtMethod* method ATTRIBUTE_UNUSED,
                                               const debug::MethodDebugInfo& info) {
-  const CompilerOptions& compiler_options = GetCompilerDriver()->GetCompilerOptions();
+  const CompilerOptions& compiler_options = GetCompilerOptions();
   DCHECK(compiler_options.GenerateAnyDebugInfo());
   TimingLogger logger("Generate JIT debug info logger", true, VLOG_IS_ON(jit));
   {
diff --git a/compiler/optimizing/optimizing_compiler.h b/compiler/optimizing/optimizing_compiler.h
index f5279e83eb..cd6d684590 100644
--- a/compiler/optimizing/optimizing_compiler.h
+++ b/compiler/optimizing/optimizing_compiler.h
@@ -24,10 +24,12 @@ namespace art {
 
 class ArtMethod;
 class Compiler;
-class CompilerDriver;
+class CompiledMethodStorage;
+class CompilerOptions;
 class DexFile;
 
-Compiler* CreateOptimizingCompiler(CompilerDriver* driver);
+Compiler* CreateOptimizingCompiler(const CompilerOptions& compiler_options,
+                                   CompiledMethodStorage* storage);
 
 bool EncodeArtMethodInInlineInfo(ArtMethod* method);
 
diff --git a/compiler/optimizing/scheduler.h b/compiler/optimizing/scheduler.h
index 48e80f5f8b..d2dbeca924 100644
--- a/compiler/optimizing/scheduler.h
+++ b/compiler/optimizing/scheduler.h
@@ -23,7 +23,6 @@
 #include "base/scoped_arena_containers.h"
 #include "base/time_utils.h"
 #include "code_generator.h"
-#include "driver/compiler_driver.h"
 #include "load_store_analysis.h"
 #include "nodes.h"
 #include "optimization.h"
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index 1f18172e94..edefd0a80f 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -958,7 +958,7 @@ class Dex2Oat final {
     compiler_options_->passes_to_run_ = passes_to_run_.get();
     compiler_options_->compiling_with_core_image_ =
         !boot_image_filename_.empty() &&
-        CompilerDriver::IsCoreImageFilename(boot_image_filename_);
+        CompilerOptions::IsCoreImageFilename(boot_image_filename_);
   }
 
   static bool SupportsDeterministicCompilation() {
diff --git a/dex2oat/linker/image_test.h b/dex2oat/linker/image_test.h
index 431ab90f39..6b56517868 100644
--- a/dex2oat/linker/image_test.h
+++ b/dex2oat/linker/image_test.h
@@ -25,6 +25,7 @@
 #include <vector>
 
 #include "android-base/stringprintf.h"
+#include "android-base/strings.h"
 
 #include "art_method-inl.h"
 #include "base/file_utils.h"