compiler_options.h revision a10ac2ac733a9dc07962cfea2502605141e61953 
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 "compiler_filter.h"
26#include "globals.h"
27#include "optimizing/register_allocator.h"
28#include "utils.h"
29
30namespace art {
31
32namespace verifier {
33  class VerifierDepsTest;
34}
35
36class DexFile;
37
38class CompilerOptions FINAL {
39 public:
40  // Guide heuristics to determine whether to compile method if profile data not available.
41  static const size_t kDefaultHugeMethodThreshold = 10000;
42  static const size_t kDefaultLargeMethodThreshold = 600;
43  static const size_t kDefaultSmallMethodThreshold = 60;
44  static const size_t kDefaultTinyMethodThreshold = 20;
45  static const size_t kDefaultNumDexMethodsThreshold = 900;
46  static constexpr double kDefaultTopKProfileThreshold = 90.0;
47  static const bool kDefaultGenerateDebugInfo = false;
48  static const bool kDefaultGenerateMiniDebugInfo = false;
49  static const size_t kDefaultInlineMaxCodeUnits = 32;
50  static constexpr size_t kUnsetInlineMaxCodeUnits = -1;
51
52  CompilerOptions();
53  ~CompilerOptions();
54
55  CompilerOptions(CompilerFilter::Filter compiler_filter,
56                  size_t huge_method_threshold,
57                  size_t large_method_threshold,
58                  size_t small_method_threshold,
59                  size_t tiny_method_threshold,
60                  size_t num_dex_methods_threshold,
61                  size_t inline_max_code_units,
62                  const std::vector<const DexFile*>* no_inline_from,
63                  double top_k_profile_threshold,
64                  bool debuggable,
65                  bool generate_debug_info,
66                  bool implicit_null_checks,
67                  bool implicit_so_checks,
68                  bool implicit_suspend_checks,
69                  bool compile_pic,
70                  const std::vector<std::string>* verbose_methods,
71                  std::ostream* init_failure_output,
72                  bool abort_on_hard_verifier_failure,
73                  const std::string& dump_cfg_file_name,
74                  bool dump_cfg_append,
75                  bool force_determinism,
76                  RegisterAllocator::Strategy regalloc_strategy,
77                  const std::vector<std::string>* passes_to_run);
78
79  CompilerFilter::Filter GetCompilerFilter() const {
80    return compiler_filter_;
81  }
82
83  void SetCompilerFilter(CompilerFilter::Filter compiler_filter) {
84    compiler_filter_ = compiler_filter;
85  }
86
87  bool IsAotCompilationEnabled() const {
88    return CompilerFilter::IsAotCompilationEnabled(compiler_filter_);
89  }
90
91  bool IsJniCompilationEnabled() const {
92    return CompilerFilter::IsJniCompilationEnabled(compiler_filter_);
93  }
94
95  bool IsQuickeningCompilationEnabled() const {
96    return CompilerFilter::IsQuickeningCompilationEnabled(compiler_filter_);
97  }
98
99  bool IsVerificationEnabled() const {
100    return CompilerFilter::IsVerificationEnabled(compiler_filter_);
101  }
102
103  bool AssumeClassesAreVerified() const {
104    return compiler_filter_ == CompilerFilter::kAssumeVerified;
105  }
106
107  bool VerifyAtRuntime() const {
108    return compiler_filter_ == CompilerFilter::kExtract;
109  }
110
111  bool IsAnyCompilationEnabled() const {
112    return CompilerFilter::IsAnyCompilationEnabled(compiler_filter_);
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 GetInlineMaxCodeUnits() const {
152    return inline_max_code_units_;
153  }
154  void SetInlineMaxCodeUnits(size_t units) {
155    inline_max_code_units_ = units;
156  }
157
158  double GetTopKProfileThreshold() const {
159    return top_k_profile_threshold_;
160  }
161
162  bool GetDebuggable() const {
163    return debuggable_;
164  }
165
166  bool GetNativeDebuggable() const {
167    return GetDebuggable() && GetGenerateDebugInfo();
168  }
169
170  // This flag controls whether the compiler collects debugging information.
171  // The other flags control how the information is written to disk.
172  bool GenerateAnyDebugInfo() const {
173    return GetGenerateDebugInfo() || GetGenerateMiniDebugInfo();
174  }
175
176  bool GetGenerateDebugInfo() const {
177    return generate_debug_info_;
178  }
179
180  bool GetGenerateMiniDebugInfo() const {
181    return generate_mini_debug_info_;
182  }
183
184  bool GetGenerateBuildId() const {
185    return generate_build_id_;
186  }
187
188  bool GetImplicitNullChecks() const {
189    return implicit_null_checks_;
190  }
191
192  bool GetImplicitStackOverflowChecks() const {
193    return implicit_so_checks_;
194  }
195
196  bool GetImplicitSuspendChecks() const {
197    return implicit_suspend_checks_;
198  }
199
200  bool IsBootImage() const {
201    return boot_image_;
202  }
203
204  bool IsAppImage() const {
205    return app_image_;
206  }
207
208  // Should the code be compiled as position independent?
209  bool GetCompilePic() const {
210    return compile_pic_;
211  }
212
213  bool HasVerboseMethods() const {
214    return verbose_methods_ != nullptr && !verbose_methods_->empty();
215  }
216
217  bool IsVerboseMethod(const std::string& pretty_method) const {
218    for (const std::string& cur_method : *verbose_methods_) {
219      if (pretty_method.find(cur_method) != std::string::npos) {
220        return true;
221      }
222    }
223    return false;
224  }
225
226  std::ostream* GetInitFailureOutput() const {
227    return init_failure_output_.get();
228  }
229
230  bool AbortOnHardVerifierFailure() const {
231    return abort_on_hard_verifier_failure_;
232  }
233
234  const std::vector<const DexFile*>* GetNoInlineFromDexFile() const {
235    return no_inline_from_;
236  }
237
238  bool ParseCompilerOption(const StringPiece& option, UsageFn Usage);
239
240  const std::string& GetDumpCfgFileName() const {
241    return dump_cfg_file_name_;
242  }
243
244  bool GetDumpCfgAppend() const {
245    return dump_cfg_append_;
246  }
247
248  bool IsForceDeterminism() const {
249    return force_determinism_;
250  }
251
252  RegisterAllocator::Strategy GetRegisterAllocationStrategy() const {
253    return register_allocation_strategy_;
254  }
255
256  const std::vector<std::string>* GetPassesToRun() const {
257    return passes_to_run_;
258  }
259
260 private:
261  void ParseDumpInitFailures(const StringPiece& option, UsageFn Usage);
262  void ParseDumpCfgPasses(const StringPiece& option, UsageFn Usage);
263  void ParseInlineMaxCodeUnits(const StringPiece& option, UsageFn Usage);
264  void ParseNumDexMethods(const StringPiece& option, UsageFn Usage);
265  void ParseTinyMethodMax(const StringPiece& option, UsageFn Usage);
266  void ParseSmallMethodMax(const StringPiece& option, UsageFn Usage);
267  void ParseLargeMethodMax(const StringPiece& option, UsageFn Usage);
268  void ParseHugeMethodMax(const StringPiece& option, UsageFn Usage);
269  void ParseRegisterAllocationStrategy(const StringPiece& option, UsageFn Usage);
270
271  CompilerFilter::Filter compiler_filter_;
272  size_t huge_method_threshold_;
273  size_t large_method_threshold_;
274  size_t small_method_threshold_;
275  size_t tiny_method_threshold_;
276  size_t num_dex_methods_threshold_;
277  size_t inline_max_code_units_;
278
279  // Dex files from which we should not inline code.
280  // This is usually a very short list (i.e. a single dex file), so we
281  // prefer vector<> over a lookup-oriented container, such as set<>.
282  const std::vector<const DexFile*>* no_inline_from_;
283
284  bool boot_image_;
285  bool app_image_;
286  // When using a profile file only the top K% of the profiled samples will be compiled.
287  double top_k_profile_threshold_;
288  bool debuggable_;
289  bool generate_debug_info_;
290  bool generate_mini_debug_info_;
291  bool generate_build_id_;
292  bool implicit_null_checks_;
293  bool implicit_so_checks_;
294  bool implicit_suspend_checks_;
295  bool compile_pic_;
296
297  // Vector of methods to have verbose output enabled for.
298  const std::vector<std::string>* verbose_methods_;
299
300  // Abort compilation with an error if we find a class that fails verification with a hard
301  // failure.
302  bool abort_on_hard_verifier_failure_;
303
304  // Log initialization of initialization failures to this stream if not null.
305  std::unique_ptr<std::ostream> init_failure_output_;
306
307  std::string dump_cfg_file_name_;
308  bool dump_cfg_append_;
309
310  // Whether the compiler should trade performance for determinism to guarantee exactly reproducible
311  // outcomes.
312  bool force_determinism_;
313
314  RegisterAllocator::Strategy register_allocation_strategy_;
315
316  // If not null, specifies optimization passes which will be run instead of defaults.
317  // Note that passes_to_run_ is not checked for correctness and providing an incorrect
318  // list of passes can lead to unexpected compiler behaviour. This is caused by dependencies
319  // between passes. Failing to satisfy them can for example lead to compiler crashes.
320  // Passing pass names which are not recognized by the compiler will result in
321  // compiler-dependant behavior.
322  const std::vector<std::string>* passes_to_run_;
323
324  friend class Dex2Oat;
325  friend class DexToDexDecompilerTest;
326  friend class CommonCompilerTest;
327  friend class verifier::VerifierDepsTest;
328
329  DISALLOW_COPY_AND_ASSIGN(CompilerOptions);
330};
331
332}  // namespace art
333
334#endif  // ART_COMPILER_DRIVER_COMPILER_OPTIONS_H_
335