Merge "Refactor code so that JIT can parse compiler options."

am: f31f9739e6

* commit 'f31f9739e6cb06298604f5fb723db2ab9a8f2962':
  Refactor code so that JIT can parse compiler options.

5 files changed, 208 insertions, 34 deletions

diff --git a/compiler/dex/quick/quick_cfi_test.cc b/compiler/dex/quick/quick_cfi_test.cc
index 18c2e55700..24daf2f15f 100644
--- a/compiler/dex/quick/quick_cfi_test.cc
+++ b/compiler/dex/quick/quick_cfi_test.cc
@@ -67,7 +67,6 @@ class QuickCFITest : public CFITest {
       false,
       false,
       nullptr,
-      new PassManagerOptions(),
       nullptr,
       false);
     VerificationResults verification_results(&compiler_options);
diff --git a/compiler/dex/quick/x86/quick_assemble_x86_test.cc b/compiler/dex/quick/x86/quick_assemble_x86_test.cc
index d9571c5f26..e977ebf722 100644
--- a/compiler/dex/quick/x86/quick_assemble_x86_test.cc
+++ b/compiler/dex/quick/x86/quick_assemble_x86_test.cc
@@ -50,7 +50,6 @@ class QuickAssembleX86TestBase : public testing::Test {
         false,
         false,
         nullptr,
-        new PassManagerOptions(),
         nullptr,
         false));
     verification_results_.reset(new VerificationResults(compiler_options_.get()));
diff --git a/compiler/driver/compiler_options.cc b/compiler/driver/compiler_options.cc
index 3f5a1eabb6..a24c8a3347 100644
--- a/compiler/driver/compiler_options.cc
+++ b/compiler/driver/compiler_options.cc
@@ -16,6 +16,8 @@
 
 #include "compiler_options.h"
 
+#include <fstream>
+
 #include "dex/pass_manager.h"
 
 namespace art {
@@ -27,8 +29,8 @@ CompilerOptions::CompilerOptions()
       small_method_threshold_(kDefaultSmallMethodThreshold),
       tiny_method_threshold_(kDefaultTinyMethodThreshold),
       num_dex_methods_threshold_(kDefaultNumDexMethodsThreshold),
-      inline_depth_limit_(kDefaultInlineDepthLimit),
-      inline_max_code_units_(kDefaultInlineMaxCodeUnits),
+      inline_depth_limit_(kUnsetInlineDepthLimit),
+      inline_max_code_units_(kUnsetInlineMaxCodeUnits),
       include_patch_information_(kDefaultIncludePatchInformation),
       top_k_profile_threshold_(kDefaultTopKProfileThreshold),
       debuggable_(false),
@@ -38,7 +40,7 @@ CompilerOptions::CompilerOptions()
       implicit_suspend_checks_(false),
       compile_pic_(false),
       verbose_methods_(nullptr),
-      pass_manager_options_(new PassManagerOptions),
+      pass_manager_options_(),
       abort_on_hard_verifier_failure_(false),
       init_failure_output_(nullptr) {
 }
@@ -65,7 +67,6 @@ CompilerOptions::CompilerOptions(CompilerFilter compiler_filter,
                                  bool implicit_suspend_checks,
                                  bool compile_pic,
                                  const std::vector<std::string>* verbose_methods,
-                                 PassManagerOptions* pass_manager_options,
                                  std::ostream* init_failure_output,
                                  bool abort_on_hard_verifier_failure
                                  ) :  // NOLINT(whitespace/parens)
@@ -86,9 +87,155 @@ CompilerOptions::CompilerOptions(CompilerFilter compiler_filter,
     implicit_suspend_checks_(implicit_suspend_checks),
     compile_pic_(compile_pic),
     verbose_methods_(verbose_methods),
-    pass_manager_options_(pass_manager_options),
+    pass_manager_options_(),
     abort_on_hard_verifier_failure_(abort_on_hard_verifier_failure),
     init_failure_output_(init_failure_output) {
 }
 
+void CompilerOptions::ParseHugeMethodMax(const StringPiece& option, UsageFn Usage) {
+  ParseUintOption(option, "--huge-method-max", &huge_method_threshold_, Usage);
+}
+
+void CompilerOptions::ParseLargeMethodMax(const StringPiece& option, UsageFn Usage) {
+  ParseUintOption(option, "--large-method-max", &large_method_threshold_, Usage);
+}
+
+void CompilerOptions::ParseSmallMethodMax(const StringPiece& option, UsageFn Usage) {
+  ParseUintOption(option, "--small-method-max", &small_method_threshold_, Usage);
+}
+
+void CompilerOptions::ParseTinyMethodMax(const StringPiece& option, UsageFn Usage) {
+  ParseUintOption(option, "--tiny-method-max", &tiny_method_threshold_, Usage);
+}
+
+void CompilerOptions::ParseNumDexMethods(const StringPiece& option, UsageFn Usage) {
+  ParseUintOption(option, "--num-dex-methods", &num_dex_methods_threshold_, Usage);
+}
+
+void CompilerOptions::ParseInlineDepthLimit(const StringPiece& option, UsageFn Usage) {
+  ParseUintOption(option, "--inline-depth-limit", &inline_depth_limit_, Usage);
+}
+
+void CompilerOptions::ParseInlineMaxCodeUnits(const StringPiece& option, UsageFn Usage) {
+  ParseUintOption(option, "--inline-max-code-units=", &inline_max_code_units_, Usage);
+}
+
+void CompilerOptions::ParseDisablePasses(const StringPiece& option,
+                                         UsageFn Usage ATTRIBUTE_UNUSED) {
+  DCHECK(option.starts_with("--disable-passes="));
+  const std::string disable_passes = option.substr(strlen("--disable-passes=")).data();
+  pass_manager_options_.SetDisablePassList(disable_passes);
+}
+
+void CompilerOptions::ParsePrintPasses(const StringPiece& option,
+                                       UsageFn Usage ATTRIBUTE_UNUSED) {
+  DCHECK(option.starts_with("--print-passes="));
+  const std::string print_passes = option.substr(strlen("--print-passes=")).data();
+  pass_manager_options_.SetPrintPassList(print_passes);
+}
+
+void CompilerOptions::ParseDumpCfgPasses(const StringPiece& option,
+                                         UsageFn Usage ATTRIBUTE_UNUSED) {
+  DCHECK(option.starts_with("--dump-cfg-passes="));
+  const std::string dump_passes_string = option.substr(strlen("--dump-cfg-passes=")).data();
+  pass_manager_options_.SetDumpPassList(dump_passes_string);
+}
+
+void CompilerOptions::ParsePassOptions(const StringPiece& option,
+                                       UsageFn Usage ATTRIBUTE_UNUSED) {
+  DCHECK(option.starts_with("--pass-options="));
+  const std::string pass_options = option.substr(strlen("--pass-options=")).data();
+  pass_manager_options_.SetOverriddenPassOptions(pass_options);
+}
+
+void CompilerOptions::ParseDumpInitFailures(const StringPiece& option,
+                                            UsageFn Usage ATTRIBUTE_UNUSED) {
+  DCHECK(option.starts_with("--dump-init-failures="));
+  std::string file_name = option.substr(strlen("--dump-init-failures=")).data();
+  init_failure_output_.reset(new std::ofstream(file_name));
+  if (init_failure_output_.get() == nullptr) {
+    LOG(ERROR) << "Failed to allocate ofstream";
+  } else if (init_failure_output_->fail()) {
+    LOG(ERROR) << "Failed to open " << file_name << " for writing the initialization "
+               << "failures.";
+    init_failure_output_.reset();
+  }
+}
+
+bool CompilerOptions::ParseCompilerOption(const StringPiece& option, UsageFn Usage) {
+  if (option.starts_with("--compiler-filter=")) {
+    const char* compiler_filter_string = option.substr(strlen("--compiler-filter=")).data();
+    if (strcmp(compiler_filter_string, "verify-none") == 0) {
+      compiler_filter_ = CompilerOptions::kVerifyNone;
+    } else if (strcmp(compiler_filter_string, "interpret-only") == 0) {
+      compiler_filter_ = CompilerOptions::kInterpretOnly;
+    } else if (strcmp(compiler_filter_string, "verify-at-runtime") == 0) {
+      compiler_filter_ = CompilerOptions::kVerifyAtRuntime;
+    } else if (strcmp(compiler_filter_string, "space") == 0) {
+      compiler_filter_ = CompilerOptions::kSpace;
+    } else if (strcmp(compiler_filter_string, "balanced") == 0) {
+      compiler_filter_ = CompilerOptions::kBalanced;
+    } else if (strcmp(compiler_filter_string, "speed") == 0) {
+      compiler_filter_ = CompilerOptions::kSpeed;
+    } else if (strcmp(compiler_filter_string, "everything") == 0) {
+      compiler_filter_ = CompilerOptions::kEverything;
+    } else if (strcmp(compiler_filter_string, "time") == 0) {
+      compiler_filter_ = CompilerOptions::kTime;
+    } else {
+      Usage("Unknown --compiler-filter value %s", compiler_filter_string);
+    }
+  } else if (option == "--compile-pic") {
+    compile_pic_ = true;
+  } else if (option.starts_with("--huge-method-max=")) {
+    ParseHugeMethodMax(option, Usage);
+  } else if (option.starts_with("--large-method-max=")) {
+    ParseLargeMethodMax(option, Usage);
+  } else if (option.starts_with("--small-method-max=")) {
+    ParseSmallMethodMax(option, Usage);
+  } else if (option.starts_with("--tiny-method-max=")) {
+    ParseTinyMethodMax(option, Usage);
+  } else if (option.starts_with("--num-dex-methods=")) {
+    ParseNumDexMethods(option, Usage);
+  } else if (option.starts_with("--inline-depth-limit=")) {
+    ParseInlineDepthLimit(option, Usage);
+  } else if (option.starts_with("--inline-max-code-units=")) {
+    ParseInlineMaxCodeUnits(option, Usage);
+  } else if (option == "--generate-debug-info" || option == "-g") {
+    generate_debug_info_ = true;
+  } else if (option == "--no-generate-debug-info") {
+    generate_debug_info_ = false;
+  } else if (option == "--debuggable") {
+    debuggable_ = true;
+    generate_debug_info_ = true;
+  } else if (option.starts_with("--top-k-profile-threshold=")) {
+    ParseDouble(option.data(), '=', 0.0, 100.0, &top_k_profile_threshold_, Usage);
+  } else if (option == "--include-patch-information") {
+    include_patch_information_ = true;
+  } else if (option == "--no-include-patch-information") {
+    include_patch_information_ = false;
+  } else if (option == "--abort-on-hard-verifier-error") {
+    abort_on_hard_verifier_failure_ = true;
+  } else if (option == "--print-pass-names") {
+    pass_manager_options_.SetPrintPassNames(true);
+  } else if (option.starts_with("--disable-passes=")) {
+    ParseDisablePasses(option, Usage);
+  } else if (option.starts_with("--print-passes=")) {
+    ParsePrintPasses(option, Usage);
+  } else if (option == "--print-all-passes") {
+    pass_manager_options_.SetPrintAllPasses();
+  } else if (option.starts_with("--dump-cfg-passes=")) {
+    ParseDumpCfgPasses(option, Usage);
+  } else if (option == "--print-pass-options") {
+    pass_manager_options_.SetPrintPassOptions(true);
+  } else if (option.starts_with("--pass-options=")) {
+    ParsePassOptions(option, Usage);
+  } else if (option.starts_with("--dump-init-failures=")) {
+    ParseDumpInitFailures(option, Usage);
+  } else {
+    // Option not recognized.
+    return false;
+  }
+  return true;
+}
+
 }  // namespace art
diff --git a/compiler/driver/compiler_options.h b/compiler/driver/compiler_options.h
index 18f215d165..e6acab42f2 100644
--- a/compiler/driver/compiler_options.h
+++ b/compiler/driver/compiler_options.h
@@ -22,12 +22,12 @@
 #include <vector>
 
 #include "base/macros.h"
+#include "dex/pass_manager.h"
 #include "globals.h"
+#include "utils.h"
 
 namespace art {
 
-class PassManagerOptions;
-
 class CompilerOptions FINAL {
  public:
   enum CompilerFilter {
@@ -53,6 +53,8 @@ class CompilerOptions FINAL {
   static const bool kDefaultIncludePatchInformation = false;
   static const size_t kDefaultInlineDepthLimit = 3;
   static const size_t kDefaultInlineMaxCodeUnits = 20;
+  static constexpr size_t kUnsetInlineDepthLimit = -1;
+  static constexpr size_t kUnsetInlineMaxCodeUnits = -1;
 
   // Default inlining settings when the space filter is used.
   static constexpr size_t kSpaceFilterInlineDepthLimit = 3;
@@ -78,7 +80,6 @@ class CompilerOptions FINAL {
                   bool implicit_suspend_checks,
                   bool compile_pic,
                   const std::vector<std::string>* verbose_methods,
-                  PassManagerOptions* pass_manager_options,
                   std::ostream* init_failure_output,
                   bool abort_on_hard_verifier_failure);
 
@@ -200,47 +201,64 @@ class CompilerOptions FINAL {
   }
 
   std::ostream* GetInitFailureOutput() const {
-    return init_failure_output_;
+    return init_failure_output_.get();
   }
 
   const PassManagerOptions* GetPassManagerOptions() const {
-    return pass_manager_options_.get();
+    return &pass_manager_options_;
   }
 
   bool AbortOnHardVerifierFailure() const {
     return abort_on_hard_verifier_failure_;
   }
 
+  bool ParseCompilerOption(const StringPiece& option, UsageFn Usage);
+
  private:
+  void ParseDumpInitFailures(const StringPiece& option, UsageFn Usage);
+  void ParsePassOptions(const StringPiece& option, UsageFn Usage);
+  void ParseDumpCfgPasses(const StringPiece& option, UsageFn Usage);
+  void ParsePrintPasses(const StringPiece& option, UsageFn Usage);
+  void ParseDisablePasses(const StringPiece& option, UsageFn Usage);
+  void ParseInlineMaxCodeUnits(const StringPiece& option, UsageFn Usage);
+  void ParseInlineDepthLimit(const StringPiece& option, UsageFn Usage);
+  void ParseNumDexMethods(const StringPiece& option, UsageFn Usage);
+  void ParseTinyMethodMax(const StringPiece& option, UsageFn Usage);
+  void ParseSmallMethodMax(const StringPiece& option, UsageFn Usage);
+  void ParseLargeMethodMax(const StringPiece& option, UsageFn Usage);
+  void ParseHugeMethodMax(const StringPiece& option, UsageFn Usage);
+
   CompilerFilter compiler_filter_;
-  const size_t huge_method_threshold_;
-  const size_t large_method_threshold_;
-  const size_t small_method_threshold_;
-  const size_t tiny_method_threshold_;
-  const size_t num_dex_methods_threshold_;
-  const size_t inline_depth_limit_;
-  const size_t inline_max_code_units_;
-  const bool include_patch_information_;
+  size_t huge_method_threshold_;
+  size_t large_method_threshold_;
+  size_t small_method_threshold_;
+  size_t tiny_method_threshold_;
+  size_t num_dex_methods_threshold_;
+  size_t inline_depth_limit_;
+  size_t inline_max_code_units_;
+  bool include_patch_information_;
   // When using a profile file only the top K% of the profiled samples will be compiled.
-  const double top_k_profile_threshold_;
-  const bool debuggable_;
-  const bool generate_debug_info_;
-  const bool implicit_null_checks_;
-  const bool implicit_so_checks_;
-  const bool implicit_suspend_checks_;
-  const bool compile_pic_;
+  double top_k_profile_threshold_;
+  bool debuggable_;
+  bool generate_debug_info_;
+  bool implicit_null_checks_;
+  bool implicit_so_checks_;
+  bool implicit_suspend_checks_;
+  bool compile_pic_;
 
   // Vector of methods to have verbose output enabled for.
-  const std::vector<std::string>* const verbose_methods_;
+  const std::vector<std::string>* verbose_methods_;
 
-  std::unique_ptr<PassManagerOptions> pass_manager_options_;
+  PassManagerOptions pass_manager_options_;
 
   // Abort compilation with an error if we find a class that fails verification with a hard
   // failure.
-  const bool abort_on_hard_verifier_failure_;
+  bool abort_on_hard_verifier_failure_;
 
   // Log initialization of initialization failures to this stream if not null.
-  std::ostream* const init_failure_output_;
+  std::unique_ptr<std::ostream> init_failure_output_;
+
+  friend class Dex2Oat;
 
   DISALLOW_COPY_AND_ASSIGN(CompilerOptions);
 };
diff --git a/compiler/jit/jit_compiler.cc b/compiler/jit/jit_compiler.cc
index b563c80f7d..c1b87c9cd0 100644
--- a/compiler/jit/jit_compiler.cc
+++ b/compiler/jit/jit_compiler.cc
@@ -63,9 +63,18 @@ extern "C" bool jit_compile_method(void* handle, ArtMethod* method, Thread* self
   return jit_compiler->CompileMethod(self, method);
 }
 
+// Callers of this method assume it has NO_RETURN.
+NO_RETURN static void Usage(const char* fmt, ...) {
+  va_list ap;
+  va_start(ap, fmt);
+  std::string error;
+  StringAppendV(&error, fmt, ap);
+  LOG(FATAL) << error;
+  va_end(ap);
+  exit(EXIT_FAILURE);
+}
+
 JitCompiler::JitCompiler() : total_time_(0) {
-  auto* pass_manager_options = new PassManagerOptions;
-  pass_manager_options->SetDisablePassList("GVN,DCE,GVNCleanup");
   compiler_options_.reset(new CompilerOptions(
       CompilerOptions::kDefaultCompilerFilter,
       CompilerOptions::kDefaultHugeMethodThreshold,
@@ -84,9 +93,11 @@ JitCompiler::JitCompiler() : total_time_(0) {
       /* implicit_suspend_checks */ false,
       /* pic */ true,  // TODO: Support non-PIC in optimizing.
       /* verbose_methods */ nullptr,
-      pass_manager_options,
       /* init_failure_output */ nullptr,
       /* abort_on_hard_verifier_failure */ false));
+  for (const std::string& argument : Runtime::Current()->GetCompilerOptions()) {
+    compiler_options_->ParseCompilerOption(argument, Usage);
+  }
   const InstructionSet instruction_set = kRuntimeISA;
   for (const StringPiece option : Runtime::Current()->GetCompilerOptions()) {
     VLOG(compiler) << "JIT compiler option " << option;