compiler_options.h revision e86deeffad79c00ed2ebede04f4adc348bda790c
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 kDefaultIncludeDebugSymbols = kIsDebugBuild; 53 static const bool kDefaultIncludePatchInformation = false; 54 55 CompilerOptions(); 56 57 CompilerOptions(CompilerFilter compiler_filter, 58 size_t huge_method_threshold, 59 size_t large_method_threshold, 60 size_t small_method_threshold, 61 size_t tiny_method_threshold, 62 size_t num_dex_methods_threshold, 63 bool generate_gdb_information, 64 bool include_patch_information, 65 double top_k_profile_threshold, 66 bool debuggable, 67 bool include_debug_symbols, 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 GetIncludeDebugSymbols() const { 149 return include_debug_symbols_; 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 GetGenerateGDBInformation() const { 165 return generate_gdb_information_; 166 } 167 168 bool GetIncludePatchInformation() const { 169 return include_patch_information_; 170 } 171 172 // Should the code be compiled as position independent? 173 bool GetCompilePic() const { 174 return compile_pic_; 175 } 176 177 bool HasVerboseMethods() const { 178 return verbose_methods_ != nullptr && !verbose_methods_->empty(); 179 } 180 181 bool IsVerboseMethod(const std::string& pretty_method) const { 182 for (const std::string& cur_method : *verbose_methods_) { 183 if (pretty_method.find(cur_method) != std::string::npos) { 184 return true; 185 } 186 } 187 return false; 188 } 189 190 std::ostream* GetInitFailureOutput() const { 191 return init_failure_output_; 192 } 193 194 const PassManagerOptions* GetPassManagerOptions() const { 195 return pass_manager_options_.get(); 196 } 197 198 bool AbortOnHardVerifierFailure() const { 199 return abort_on_hard_verifier_failure_; 200 } 201 202 private: 203 CompilerFilter compiler_filter_; 204 const size_t huge_method_threshold_; 205 const size_t large_method_threshold_; 206 const size_t small_method_threshold_; 207 const size_t tiny_method_threshold_; 208 const size_t num_dex_methods_threshold_; 209 const bool generate_gdb_information_; 210 const bool include_patch_information_; 211 // When using a profile file only the top K% of the profiled samples will be compiled. 212 const double top_k_profile_threshold_; 213 const bool debuggable_; 214 const bool include_debug_symbols_; 215 const bool implicit_null_checks_; 216 const bool implicit_so_checks_; 217 const bool implicit_suspend_checks_; 218 const bool compile_pic_; 219 220 // Vector of methods to have verbose output enabled for. 221 const std::vector<std::string>* const verbose_methods_; 222 223 std::unique_ptr<PassManagerOptions> pass_manager_options_; 224 225 // Abort compilation with an error if we find a class that fails verification with a hard 226 // failure. 227 const bool abort_on_hard_verifier_failure_; 228 229 // Log initialization of initialization failures to this stream if not null. 230 std::ostream* const init_failure_output_; 231 232 DISALLOW_COPY_AND_ASSIGN(CompilerOptions); 233}; 234std::ostream& operator<<(std::ostream& os, const CompilerOptions::CompilerFilter& rhs); 235 236} // namespace art 237 238#endif // ART_COMPILER_DRIVER_COMPILER_OPTIONS_H_ 239