1 files changed, 27 insertions, 33 deletions

diff --git a/compiler/compiler.h b/compiler/compiler.h
index f2ec3a9fa3..a496c6ced5 100644
--- a/compiler/compiler.h
+++ b/compiler/compiler.h
@@ -19,10 +19,13 @@
 
 #include "base/mutex.h"
 #include "base/os.h"
-#include "dex/dex_file.h"
+#include "dex/invoke_type.h"
 
 namespace art {
 
+namespace dex {
+struct CodeItem;
+}  // namespace dex
 namespace jit {
 class JitCodeCache;
 class JitLogger;
@@ -33,18 +36,14 @@ class DexCache;
 }  // namespace mirror
 
 class ArtMethod;
-class CompilerDriver;
 class CompiledMethod;
+class CompiledMethodStorage;
+class CompilerOptions;
+class DexFile;
 template<class T> class Handle;
 class OatWriter;
 class Thread;
 
-enum class CopyOption {
-  kNever,
-  kAlways,
-  kOnlyIfCompressed
-};
-
 class Compiler {
  public:
   enum Kind {
@@ -52,15 +51,13 @@ 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;
 
-  virtual CompiledMethod* Compile(const DexFile::CodeItem* code_item,
+  virtual CompiledMethod* Compile(const dex::CodeItem* code_item,
                                   uint32_t access_flags,
                                   InvokeType invoke_type,
                                   uint16_t class_def_idx,
@@ -77,6 +74,7 @@ class Compiler {
   virtual bool JitCompile(Thread* self ATTRIBUTE_UNUSED,
                           jit::JitCodeCache* code_cache ATTRIBUTE_UNUSED,
                           ArtMethod* method ATTRIBUTE_UNUSED,
+                          bool baseline ATTRIBUTE_UNUSED,
                           bool osr ATTRIBUTE_UNUSED,
                           jit::JitLogger* jit_logger ATTRIBUTE_UNUSED)
       REQUIRES_SHARED(Locks::mutator_lock_) {
@@ -92,36 +90,32 @@ 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 DexFile::CodeItem& code_item,
+  static bool IsPathologicalCase(const dex::CodeItem& code_item,
                                  uint32_t method_idx,
                                  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);