compiler_options.h revision b17d1ccff0ac26fc22df671907ba2b4f4c656ce4 
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 "dex/pass_manager.h"
26#include "globals.h"
27#include "utils.h"
28
29namespace art {
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 of everything capable of being compiled.
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  static const size_t kDefaultInlineDepthLimit = 3;
55  static const size_t kDefaultInlineMaxCodeUnits = 20;
56  static constexpr size_t kUnsetInlineDepthLimit = -1;
57  static constexpr size_t kUnsetInlineMaxCodeUnits = -1;
58
59  // Default inlining settings when the space filter is used.
60  static constexpr size_t kSpaceFilterInlineDepthLimit = 3;
61  static constexpr size_t kSpaceFilterInlineMaxCodeUnits = 10;
62
63  CompilerOptions();
64  ~CompilerOptions();
65
66  CompilerOptions(CompilerFilter compiler_filter,
67                  size_t huge_method_threshold,
68                  size_t large_method_threshold,
69                  size_t small_method_threshold,
70                  size_t tiny_method_threshold,
71                  size_t num_dex_methods_threshold,
72                  size_t inline_depth_limit,
73                  size_t inline_max_code_units,
74                  bool include_patch_information,
75                  double top_k_profile_threshold,
76                  bool debuggable,
77                  bool generate_debug_info,
78                  bool implicit_null_checks,
79                  bool implicit_so_checks,
80                  bool implicit_suspend_checks,
81                  bool compile_pic,
82                  const std::vector<std::string>* verbose_methods,
83                  std::ostream* init_failure_output,
84                  bool abort_on_hard_verifier_failure);
85
86  CompilerFilter GetCompilerFilter() const {
87    return compiler_filter_;
88  }
89
90  void SetCompilerFilter(CompilerFilter compiler_filter) {
91    compiler_filter_ = compiler_filter;
92  }
93
94  bool VerifyAtRuntime() const {
95    return compiler_filter_ == CompilerOptions::kVerifyAtRuntime;
96  }
97
98  bool IsCompilationEnabled() const {
99    return compiler_filter_ != CompilerOptions::kVerifyNone &&
100        compiler_filter_ != CompilerOptions::kInterpretOnly &&
101        compiler_filter_ != CompilerOptions::kVerifyAtRuntime;
102  }
103
104  bool IsVerificationEnabled() const {
105    return compiler_filter_ != CompilerOptions::kVerifyNone &&
106        compiler_filter_ != CompilerOptions::kVerifyAtRuntime;
107  }
108
109  bool NeverVerify() const {
110    return compiler_filter_ == CompilerOptions::kVerifyNone;
111  }
112
113  size_t GetHugeMethodThreshold() const {
114    return huge_method_threshold_;
115  }
116
117  size_t GetLargeMethodThreshold() const {
118    return large_method_threshold_;
119  }
120
121  size_t GetSmallMethodThreshold() const {
122    return small_method_threshold_;
123  }
124
125  size_t GetTinyMethodThreshold() const {
126    return tiny_method_threshold_;
127  }
128
129  bool IsHugeMethod(size_t num_dalvik_instructions) const {
130    return num_dalvik_instructions > huge_method_threshold_;
131  }
132
133  bool IsLargeMethod(size_t num_dalvik_instructions) const {
134    return num_dalvik_instructions > large_method_threshold_;
135  }
136
137  bool IsSmallMethod(size_t num_dalvik_instructions) const {
138    return num_dalvik_instructions > small_method_threshold_;
139  }
140
141  bool IsTinyMethod(size_t num_dalvik_instructions) const {
142    return num_dalvik_instructions > tiny_method_threshold_;
143  }
144
145  size_t GetNumDexMethodsThreshold() const {
146    return num_dex_methods_threshold_;
147  }
148
149  size_t GetInlineDepthLimit() const {
150    return inline_depth_limit_;
151  }
152
153  size_t GetInlineMaxCodeUnits() const {
154    return inline_max_code_units_;
155  }
156
157  double GetTopKProfileThreshold() const {
158    return top_k_profile_threshold_;
159  }
160
161  bool GetDebuggable() const {
162    return debuggable_;
163  }
164
165  bool GetGenerateDebugInfo() const {
166    return generate_debug_info_;
167  }
168
169  bool GetImplicitNullChecks() const {
170    return implicit_null_checks_;
171  }
172
173  bool GetImplicitStackOverflowChecks() const {
174    return implicit_so_checks_;
175  }
176
177  bool GetImplicitSuspendChecks() const {
178    return implicit_suspend_checks_;
179  }
180
181  bool GetIncludePatchInformation() const {
182    return include_patch_information_;
183  }
184
185  // Should the code be compiled as position independent?
186  bool GetCompilePic() const {
187    return compile_pic_;
188  }
189
190  bool HasVerboseMethods() const {
191    return verbose_methods_ != nullptr && !verbose_methods_->empty();
192  }
193
194  bool IsVerboseMethod(const std::string& pretty_method) const {
195    for (const std::string& cur_method : *verbose_methods_) {
196      if (pretty_method.find(cur_method) != std::string::npos) {
197        return true;
198      }
199    }
200    return false;
201  }
202
203  std::ostream* GetInitFailureOutput() const {
204    return init_failure_output_.get();
205  }
206
207  const PassManagerOptions* GetPassManagerOptions() const {
208    return &pass_manager_options_;
209  }
210
211  bool AbortOnHardVerifierFailure() const {
212    return abort_on_hard_verifier_failure_;
213  }
214
215  bool ParseCompilerOption(const StringPiece& option, UsageFn Usage);
216
217 private:
218  void ParseDumpInitFailures(const StringPiece& option, UsageFn Usage);
219  void ParsePassOptions(const StringPiece& option, UsageFn Usage);
220  void ParseDumpCfgPasses(const StringPiece& option, UsageFn Usage);
221  void ParsePrintPasses(const StringPiece& option, UsageFn Usage);
222  void ParseDisablePasses(const StringPiece& option, UsageFn Usage);
223  void ParseInlineMaxCodeUnits(const StringPiece& option, UsageFn Usage);
224  void ParseInlineDepthLimit(const StringPiece& option, UsageFn Usage);
225  void ParseNumDexMethods(const StringPiece& option, UsageFn Usage);
226  void ParseTinyMethodMax(const StringPiece& option, UsageFn Usage);
227  void ParseSmallMethodMax(const StringPiece& option, UsageFn Usage);
228  void ParseLargeMethodMax(const StringPiece& option, UsageFn Usage);
229  void ParseHugeMethodMax(const StringPiece& option, UsageFn Usage);
230
231  CompilerFilter compiler_filter_;
232  size_t huge_method_threshold_;
233  size_t large_method_threshold_;
234  size_t small_method_threshold_;
235  size_t tiny_method_threshold_;
236  size_t num_dex_methods_threshold_;
237  size_t inline_depth_limit_;
238  size_t inline_max_code_units_;
239  bool include_patch_information_;
240  // When using a profile file only the top K% of the profiled samples will be compiled.
241  double top_k_profile_threshold_;
242  bool debuggable_;
243  bool generate_debug_info_;
244  bool implicit_null_checks_;
245  bool implicit_so_checks_;
246  bool implicit_suspend_checks_;
247  bool compile_pic_;
248
249  // Vector of methods to have verbose output enabled for.
250  const std::vector<std::string>* verbose_methods_;
251
252  PassManagerOptions pass_manager_options_;
253
254  // Abort compilation with an error if we find a class that fails verification with a hard
255  // failure.
256  bool abort_on_hard_verifier_failure_;
257
258  // Log initialization of initialization failures to this stream if not null.
259  std::unique_ptr<std::ostream> init_failure_output_;
260
261  friend class Dex2Oat;
262
263  DISALLOW_COPY_AND_ASSIGN(CompilerOptions);
264};
265std::ostream& operator<<(std::ostream& os, const CompilerOptions::CompilerFilter& rhs);
266
267}  // namespace art
268
269#endif  // ART_COMPILER_DRIVER_COMPILER_OPTIONS_H_
270