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