Use compiler filter to determine oat file status.

Record the compiler filter in the oat header. Use that to determine
when the oat file is up-to-date with respect to a target compiler
filter level.

New xxx-profile filter levels are added to specify if a profile should
be used instead of testing for the presence of a profile file.

This change should allow for different compiler-filters to be set for
different package manager use cases.

Bug: 27689078
Change-Id: Id6706d0ed91b45f307142692ea4316aa9713b023

5 files changed, 17 insertions, 55 deletions

diff --git a/compiler/dex/verification_results.cc b/compiler/dex/verification_results.cc
index dd24220e0e..7c9ce1ee60 100644
--- a/compiler/dex/verification_results.cc
+++ b/compiler/dex/verification_results.cc
@@ -109,7 +109,7 @@ bool VerificationResults::IsCandidateForCompilation(MethodReference&,
     return false;
   }
   // Don't compile class initializers unless kEverything.
-  if ((compiler_options_->GetCompilerFilter() != CompilerOptions::kEverything) &&
+  if ((compiler_options_->GetCompilerFilter() != CompilerFilter::kEverything) &&
      ((access_flags & kAccConstructor) != 0) && ((access_flags & kAccStatic) != 0)) {
     return false;
   }
diff --git a/compiler/driver/compiler_options.cc b/compiler/driver/compiler_options.cc
index f5969aa825..1bd4c3ad80 100644
--- a/compiler/driver/compiler_options.cc
+++ b/compiler/driver/compiler_options.cc
@@ -52,7 +52,7 @@ CompilerOptions::~CompilerOptions() {
   // because we don't want to include the PassManagerOptions definition from the header file.
 }
 
-CompilerOptions::CompilerOptions(CompilerFilter compiler_filter,
+CompilerOptions::CompilerOptions(CompilerFilter::Filter compiler_filter,
                                  size_t huge_method_threshold,
                                  size_t large_method_threshold,
                                  size_t small_method_threshold,
@@ -147,25 +147,7 @@ void CompilerOptions::ParseDumpInitFailures(const StringPiece& option,
 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 if (strcmp(compiler_filter_string, "verify-profile") == 0) {
-      compiler_filter_ = CompilerOptions::kVerifyProfile;
-    } else {
+    if (!CompilerFilter::ParseCompilerFilter(compiler_filter_string, &compiler_filter_)) {
       Usage("Unknown --compiler-filter value %s", compiler_filter_string);
     }
   } else if (option == "--compile-pic") {
diff --git a/compiler/driver/compiler_options.h b/compiler/driver/compiler_options.h
index 11a4e06313..c67ab6ef14 100644
--- a/compiler/driver/compiler_options.h
+++ b/compiler/driver/compiler_options.h
@@ -22,6 +22,7 @@
 #include <vector>
 
 #include "base/macros.h"
+#include "compiler_filter.h"
 #include "globals.h"
 #include "utils.h"
 
@@ -29,20 +30,8 @@ namespace art {
 
 class CompilerOptions FINAL {
  public:
-  enum CompilerFilter {
-    kVerifyNone,          // Skip verification and compile nothing except JNI stubs.
-    kInterpretOnly,       // Verify, and compile only JNI stubs.
-    kVerifyAtRuntime,     // Only compile JNI stubs and verify at runtime.
-    kSpace,               // Maximize space savings.
-    kBalanced,            // Try to get the best performance return on compilation investment.
-    kSpeed,               // Maximize runtime performance.
-    kEverything,          // Force compilation of everything capable of being compiled.
-    kTime,                // Compile methods, but minimize compilation time.
-    kVerifyProfile,       // Verify only the classes in the profile.
-  };
-
   // Guide heuristics to determine whether to compile method if profile data not available.
-  static const CompilerFilter kDefaultCompilerFilter = kSpeed;
+  static const CompilerFilter::Filter kDefaultCompilerFilter = CompilerFilter::kSpeed;
   static const size_t kDefaultHugeMethodThreshold = 10000;
   static const size_t kDefaultLargeMethodThreshold = 600;
   static const size_t kDefaultSmallMethodThreshold = 60;
@@ -64,7 +53,7 @@ class CompilerOptions FINAL {
   CompilerOptions();
   ~CompilerOptions();
 
-  CompilerOptions(CompilerFilter compiler_filter,
+  CompilerOptions(CompilerFilter::Filter compiler_filter,
                   size_t huge_method_threshold,
                   size_t large_method_threshold,
                   size_t small_method_threshold,
@@ -88,40 +77,32 @@ class CompilerOptions FINAL {
                   bool dump_cfg_append,
                   bool force_determinism);
 
-  CompilerFilter GetCompilerFilter() const {
+  CompilerFilter::Filter GetCompilerFilter() const {
     return compiler_filter_;
   }
 
-  void SetCompilerFilter(CompilerFilter compiler_filter) {
+  void SetCompilerFilter(CompilerFilter::Filter compiler_filter) {
     compiler_filter_ = compiler_filter;
   }
 
   bool VerifyAtRuntime() const {
-    return compiler_filter_ == CompilerOptions::kVerifyAtRuntime;
+    return compiler_filter_ == CompilerFilter::kVerifyAtRuntime;
   }
 
   bool IsCompilationEnabled() const {
-    return compiler_filter_ != CompilerOptions::kVerifyNone &&
-           compiler_filter_ != CompilerOptions::kInterpretOnly &&
-           compiler_filter_ != CompilerOptions::kVerifyAtRuntime &&
-           compiler_filter_ != CompilerOptions::kVerifyProfile;
+    return CompilerFilter::IsCompilationEnabled(compiler_filter_);
   }
 
   bool IsVerificationEnabled() const {
-    return compiler_filter_ != CompilerOptions::kVerifyNone &&
-           compiler_filter_ != CompilerOptions::kVerifyAtRuntime;
+    return CompilerFilter::IsVerificationEnabled(compiler_filter_);
   }
 
   bool NeverVerify() const {
-    return compiler_filter_ == CompilerOptions::kVerifyNone;
-  }
-
-  bool IsExtractOnly() const {
-    return compiler_filter_ == CompilerOptions::kVerifyAtRuntime;
+    return compiler_filter_ == CompilerFilter::kVerifyNone;
   }
 
   bool VerifyOnlyProfile() const {
-    return compiler_filter_ == CompilerOptions::kVerifyProfile;
+    return compiler_filter_ == CompilerFilter::kVerifyProfile;
   }
 
   size_t GetHugeMethodThreshold() const {
@@ -271,7 +252,7 @@ class CompilerOptions FINAL {
   void ParseLargeMethodMax(const StringPiece& option, UsageFn Usage);
   void ParseHugeMethodMax(const StringPiece& option, UsageFn Usage);
 
-  CompilerFilter compiler_filter_;
+  CompilerFilter::Filter compiler_filter_;
   size_t huge_method_threshold_;
   size_t large_method_threshold_;
   size_t small_method_threshold_;
@@ -317,7 +298,6 @@ class CompilerOptions FINAL {
 
   DISALLOW_COPY_AND_ASSIGN(CompilerOptions);
 };
-std::ostream& operator<<(std::ostream& os, const CompilerOptions::CompilerFilter& rhs);
 
 }  // namespace art
 
diff --git a/compiler/optimizing/builder.cc b/compiler/optimizing/builder.cc
index 124afbc73b..082d15961a 100644
--- a/compiler/optimizing/builder.cc
+++ b/compiler/optimizing/builder.cc
@@ -145,8 +145,8 @@ void HGraphBuilder::MaybeRecordStat(MethodCompilationStat compilation_stat) {
 bool HGraphBuilder::SkipCompilation(const DexFile::CodeItem& code_item,
                                     size_t number_of_branches) {
   const CompilerOptions& compiler_options = compiler_driver_->GetCompilerOptions();
-  CompilerOptions::CompilerFilter compiler_filter = compiler_options.GetCompilerFilter();
-  if (compiler_filter == CompilerOptions::kEverything) {
+  CompilerFilter::Filter compiler_filter = compiler_options.GetCompilerFilter();
+  if (compiler_filter == CompilerFilter::kEverything) {
     return false;
   }
 
diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index f1c5581c5b..125c00d275 100644
--- a/compiler/optimizing/optimizing_compiler.cc
+++ b/compiler/optimizing/optimizing_compiler.cc
@@ -655,7 +655,7 @@ CodeGenerator* OptimizingCompiler::TryCompile(ArenaAllocator* arena,
   // code units is bigger than 128.
   static constexpr size_t kSpaceFilterOptimizingThreshold = 128;
   const CompilerOptions& compiler_options = compiler_driver->GetCompilerOptions();
-  if ((compiler_options.GetCompilerFilter() == CompilerOptions::kSpace)
+  if ((compiler_options.GetCompilerFilter() == CompilerFilter::kSpace)
       && (code_item->insns_size_in_code_units_ > kSpaceFilterOptimizingThreshold)) {
     MaybeRecordStat(MethodCompilationStat::kNotCompiledSpaceFilter);
     return nullptr;