compiler_options.h revision 8363c772581bf00ebcdc2e38391b4bfae51beb75
1/* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef ART_COMPILER_DRIVER_COMPILER_OPTIONS_H_ 18#define ART_COMPILER_DRIVER_COMPILER_OPTIONS_H_ 19 20#include <ostream> 21#include <string> 22#include <vector> 23 24#include "base/macros.h" 25#include "globals.h" 26 27namespace art { 28 29class PassManagerOptions; 30 31class CompilerOptions FINAL { 32 public: 33 enum CompilerFilter { 34 kVerifyNone, // Skip verification and compile nothing except JNI stubs. 35 kInterpretOnly, // Verify, and compile only JNI stubs. 36 kVerifyAtRuntime, // Only compile JNI stubs and verify at runtime. 37 kSpace, // Maximize space savings. 38 kBalanced, // Try to get the best performance return on compilation investment. 39 kSpeed, // Maximize runtime performance. 40 kEverything, // Force compilation (Note: excludes compilation of class initializers). 41 kTime, // Compile methods, but minimize compilation time. 42 }; 43 44 // Guide heuristics to determine whether to compile method if profile data not available. 45 static const CompilerFilter kDefaultCompilerFilter = kSpeed; 46 static const size_t kDefaultHugeMethodThreshold = 10000; 47 static const size_t kDefaultLargeMethodThreshold = 600; 48 static const size_t kDefaultSmallMethodThreshold = 60; 49 static const size_t kDefaultTinyMethodThreshold = 20; 50 static const size_t kDefaultNumDexMethodsThreshold = 900; 51 static constexpr double kDefaultTopKProfileThreshold = 90.0; 52 static const bool kDefaultGenerateDebugInfo = kIsDebugBuild; 53 static const bool kDefaultIncludePatchInformation = false; 54 55 CompilerOptions(); 56 ~CompilerOptions(); 57 58 CompilerOptions(CompilerFilter compiler_filter, 59 size_t huge_method_threshold, 60 size_t large_method_threshold, 61 size_t small_method_threshold, 62 size_t tiny_method_threshold, 63 size_t num_dex_methods_threshold, 64 bool include_patch_information, 65 double top_k_profile_threshold, 66 bool debuggable, 67 bool generate_debug_info, 68 bool implicit_null_checks, 69 bool implicit_so_checks, 70 bool implicit_suspend_checks, 71 bool compile_pic, 72 const std::vector<std::string>* verbose_methods, 73 PassManagerOptions* pass_manager_options, 74 std::ostream* init_failure_output, 75 bool abort_on_hard_verifier_failure); 76 77 CompilerFilter GetCompilerFilter() const { 78 return compiler_filter_; 79 } 80 81 void SetCompilerFilter(CompilerFilter compiler_filter) { 82 compiler_filter_ = compiler_filter; 83 } 84 85 bool VerifyAtRuntime() const { 86 return compiler_filter_ == CompilerOptions::kVerifyAtRuntime; 87 } 88 89 bool IsCompilationEnabled() const { 90 return compiler_filter_ != CompilerOptions::kVerifyNone && 91 compiler_filter_ != CompilerOptions::kInterpretOnly && 92 compiler_filter_ != CompilerOptions::kVerifyAtRuntime; 93 } 94 95 bool IsVerificationEnabled() const { 96 return compiler_filter_ != CompilerOptions::kVerifyNone && 97 compiler_filter_ != CompilerOptions::kVerifyAtRuntime; 98 } 99 100 bool NeverVerify() const { 101 return compiler_filter_ == CompilerOptions::kVerifyNone; 102 } 103 104 size_t GetHugeMethodThreshold() const { 105 return huge_method_threshold_; 106 } 107 108 size_t GetLargeMethodThreshold() const { 109 return large_method_threshold_; 110 } 111 112 size_t GetSmallMethodThreshold() const { 113 return small_method_threshold_; 114 } 115 116 size_t GetTinyMethodThreshold() const { 117 return tiny_method_threshold_; 118 } 119 120 bool IsHugeMethod(size_t num_dalvik_instructions) const { 121 return num_dalvik_instructions > huge_method_threshold_; 122 } 123 124 bool IsLargeMethod(size_t num_dalvik_instructions) const { 125 return num_dalvik_instructions > large_method_threshold_; 126 } 127 128 bool IsSmallMethod(size_t num_dalvik_instructions) const { 129 return num_dalvik_instructions > small_method_threshold_; 130 } 131 132 bool IsTinyMethod(size_t num_dalvik_instructions) const { 133 return num_dalvik_instructions > tiny_method_threshold_; 134 } 135 136 size_t GetNumDexMethodsThreshold() const { 137 return num_dex_methods_threshold_; 138 } 139 140 double GetTopKProfileThreshold() const { 141 return top_k_profile_threshold_; 142 } 143 144 bool GetDebuggable() const { 145 return debuggable_; 146 } 147 148 bool GetGenerateDebugInfo() const { 149 return generate_debug_info_; 150 } 151 152 bool GetImplicitNullChecks() const { 153 return implicit_null_checks_; 154 } 155 156 bool GetImplicitStackOverflowChecks() const { 157 return implicit_so_checks_; 158 } 159 160 bool GetImplicitSuspendChecks() const { 161 return implicit_suspend_checks_; 162 } 163 164 bool GetIncludePatchInformation() const { 165 return include_patch_information_; 166 } 167 168 // Should the code be compiled as position independent? 169 bool GetCompilePic() const { 170 return compile_pic_; 171 } 172 173 bool HasVerboseMethods() const { 174 return verbose_methods_ != nullptr && !verbose_methods_->empty(); 175 } 176 177 bool IsVerboseMethod(const std::string& pretty_method) const { 178 for (const std::string& cur_method : *verbose_methods_) { 179 if (pretty_method.find(cur_method) != std::string::npos) { 180 return true; 181 } 182 } 183 return false; 184 } 185 186 std::ostream* GetInitFailureOutput() const { 187 return init_failure_output_; 188 } 189 190 const PassManagerOptions* GetPassManagerOptions() const { 191 return pass_manager_options_.get(); 192 } 193 194 bool AbortOnHardVerifierFailure() const { 195 return abort_on_hard_verifier_failure_; 196 } 197 198 private: 199 CompilerFilter compiler_filter_; 200 const size_t huge_method_threshold_; 201 const size_t large_method_threshold_; 202 const size_t small_method_threshold_; 203 const size_t tiny_method_threshold_; 204 const size_t num_dex_methods_threshold_; 205 const bool include_patch_information_; 206 // When using a profile file only the top K% of the profiled samples will be compiled. 207 const double top_k_profile_threshold_; 208 const bool debuggable_; 209 const bool generate_debug_info_; 210 const bool implicit_null_checks_; 211 const bool implicit_so_checks_; 212 const bool implicit_suspend_checks_; 213 const bool compile_pic_; 214 215 // Vector of methods to have verbose output enabled for. 216 const std::vector<std::string>* const verbose_methods_; 217 218 std::unique_ptr<PassManagerOptions> pass_manager_options_; 219 220 // Abort compilation with an error if we find a class that fails verification with a hard 221 // failure. 222 const bool abort_on_hard_verifier_failure_; 223 224 // Log initialization of initialization failures to this stream if not null. 225 std::ostream* const init_failure_output_; 226 227 DISALLOW_COPY_AND_ASSIGN(CompilerOptions); 228}; 229std::ostream& operator<<(std::ostream& os, const CompilerOptions::CompilerFilter& rhs); 230 231} // namespace art 232 233#endif // ART_COMPILER_DRIVER_COMPILER_OPTIONS_H_ 234