blob: 30ba8c9e7422ed8c3ad6e340b12e9c2e8c98fc07 [file] [log] [blame]
Mathieu Chartier5bdab122015-01-26 18:30:19 -08001/*
2 * Copyright (C) 2015 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#include "compiler_options.h"
18
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +000019#include <fstream>
20
Mathieu Chartier5bdab122015-01-26 18:30:19 -080021namespace art {
22
23CompilerOptions::CompilerOptions()
Richard Uhlerf4b34872016-04-13 11:03:46 -070024 : compiler_filter_(CompilerFilter::kDefaultCompilerFilter),
Mathieu Chartier5bdab122015-01-26 18:30:19 -080025 huge_method_threshold_(kDefaultHugeMethodThreshold),
26 large_method_threshold_(kDefaultLargeMethodThreshold),
27 small_method_threshold_(kDefaultSmallMethodThreshold),
28 tiny_method_threshold_(kDefaultTinyMethodThreshold),
29 num_dex_methods_threshold_(kDefaultNumDexMethodsThreshold),
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +000030 inline_depth_limit_(kUnsetInlineDepthLimit),
31 inline_max_code_units_(kUnsetInlineMaxCodeUnits),
Jeff Haodcdc85b2015-12-04 14:06:18 -080032 no_inline_from_(nullptr),
Mathieu Chartier5bdab122015-01-26 18:30:19 -080033 include_patch_information_(kDefaultIncludePatchInformation),
34 top_k_profile_threshold_(kDefaultTopKProfileThreshold),
Andreas Gampe7b2f09e2015-03-02 14:07:33 -080035 debuggable_(false),
David Srbecky8363c772015-05-28 16:12:43 +010036 generate_debug_info_(kDefaultGenerateDebugInfo),
David Srbecky5b1c2ca2016-01-25 17:32:41 +000037 generate_mini_debug_info_(kDefaultGenerateMiniDebugInfo),
Mathieu Chartier5bdab122015-01-26 18:30:19 -080038 implicit_null_checks_(true),
39 implicit_so_checks_(true),
40 implicit_suspend_checks_(false),
41 compile_pic_(false),
42 verbose_methods_(nullptr),
Andreas Gampe6cf49e52015-03-05 13:08:45 -080043 abort_on_hard_verifier_failure_(false),
Nicolas Geoffrayc903b6a2016-01-18 12:56:06 +000044 init_failure_output_(nullptr),
45 dump_cfg_file_name_(""),
Andreas Gampeace0dc12016-01-20 13:33:13 -080046 dump_cfg_append_(false),
Matthew Gharrity2cd05b72016-08-03 16:57:37 -070047 force_determinism_(false),
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -070048 register_allocation_strategy_(RegisterAllocator::kRegisterAllocatorDefault),
49 passes_to_run_(nullptr) {
Mathieu Chartier5bdab122015-01-26 18:30:19 -080050}
51
Vladimir Markob163bb72015-03-31 21:49:49 +010052CompilerOptions::~CompilerOptions() {
53 // The destructor looks empty but it destroys a PassManagerOptions object. We keep it here
54 // because we don't want to include the PassManagerOptions definition from the header file.
55}
56
Andreas Gampe29d38e72016-03-23 15:31:51 +000057CompilerOptions::CompilerOptions(CompilerFilter::Filter compiler_filter,
Mathieu Chartier5bdab122015-01-26 18:30:19 -080058 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,
Calin Juravleec748352015-07-29 13:52:12 +010063 size_t inline_depth_limit,
64 size_t inline_max_code_units,
Vladimir Marko47496c22016-01-27 16:15:08 +000065 const std::vector<const DexFile*>* no_inline_from,
Mathieu Chartier5bdab122015-01-26 18:30:19 -080066 bool include_patch_information,
67 double top_k_profile_threshold,
Andreas Gampe7b2f09e2015-03-02 14:07:33 -080068 bool debuggable,
David Srbecky8363c772015-05-28 16:12:43 +010069 bool generate_debug_info,
Mathieu Chartier5bdab122015-01-26 18:30:19 -080070 bool implicit_null_checks,
71 bool implicit_so_checks,
72 bool implicit_suspend_checks,
73 bool compile_pic,
74 const std::vector<std::string>* verbose_methods,
Andreas Gampe6cf49e52015-03-05 13:08:45 -080075 std::ostream* init_failure_output,
Nicolas Geoffrayc903b6a2016-01-18 12:56:06 +000076 bool abort_on_hard_verifier_failure,
77 const std::string& dump_cfg_file_name,
Andreas Gampeace0dc12016-01-20 13:33:13 -080078 bool dump_cfg_append,
Matthew Gharrity2cd05b72016-08-03 16:57:37 -070079 bool force_determinism,
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -070080 RegisterAllocator::Strategy regalloc_strategy,
81 const std::vector<std::string>* passes_to_run
Mathieu Chartier5bdab122015-01-26 18:30:19 -080082 ) : // NOLINT(whitespace/parens)
83 compiler_filter_(compiler_filter),
84 huge_method_threshold_(huge_method_threshold),
85 large_method_threshold_(large_method_threshold),
86 small_method_threshold_(small_method_threshold),
87 tiny_method_threshold_(tiny_method_threshold),
88 num_dex_methods_threshold_(num_dex_methods_threshold),
Calin Juravleec748352015-07-29 13:52:12 +010089 inline_depth_limit_(inline_depth_limit),
90 inline_max_code_units_(inline_max_code_units),
Jeff Haodcdc85b2015-12-04 14:06:18 -080091 no_inline_from_(no_inline_from),
Mathieu Chartier5bdab122015-01-26 18:30:19 -080092 include_patch_information_(include_patch_information),
93 top_k_profile_threshold_(top_k_profile_threshold),
Andreas Gampe7b2f09e2015-03-02 14:07:33 -080094 debuggable_(debuggable),
David Srbecky8363c772015-05-28 16:12:43 +010095 generate_debug_info_(generate_debug_info),
David Srbecky5b1c2ca2016-01-25 17:32:41 +000096 generate_mini_debug_info_(kDefaultGenerateMiniDebugInfo),
Mathieu Chartier5bdab122015-01-26 18:30:19 -080097 implicit_null_checks_(implicit_null_checks),
98 implicit_so_checks_(implicit_so_checks),
99 implicit_suspend_checks_(implicit_suspend_checks),
100 compile_pic_(compile_pic),
101 verbose_methods_(verbose_methods),
Andreas Gampe6cf49e52015-03-05 13:08:45 -0800102 abort_on_hard_verifier_failure_(abort_on_hard_verifier_failure),
Nicolas Geoffrayc903b6a2016-01-18 12:56:06 +0000103 init_failure_output_(init_failure_output),
104 dump_cfg_file_name_(dump_cfg_file_name),
Andreas Gampeace0dc12016-01-20 13:33:13 -0800105 dump_cfg_append_(dump_cfg_append),
Matthew Gharrity2cd05b72016-08-03 16:57:37 -0700106 force_determinism_(force_determinism),
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -0700107 register_allocation_strategy_(regalloc_strategy),
108 passes_to_run_(passes_to_run) {
Mathieu Chartier5bdab122015-01-26 18:30:19 -0800109}
110
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000111void CompilerOptions::ParseHugeMethodMax(const StringPiece& option, UsageFn Usage) {
112 ParseUintOption(option, "--huge-method-max", &huge_method_threshold_, Usage);
113}
114
115void CompilerOptions::ParseLargeMethodMax(const StringPiece& option, UsageFn Usage) {
116 ParseUintOption(option, "--large-method-max", &large_method_threshold_, Usage);
117}
118
119void CompilerOptions::ParseSmallMethodMax(const StringPiece& option, UsageFn Usage) {
120 ParseUintOption(option, "--small-method-max", &small_method_threshold_, Usage);
121}
122
123void CompilerOptions::ParseTinyMethodMax(const StringPiece& option, UsageFn Usage) {
124 ParseUintOption(option, "--tiny-method-max", &tiny_method_threshold_, Usage);
125}
126
127void CompilerOptions::ParseNumDexMethods(const StringPiece& option, UsageFn Usage) {
128 ParseUintOption(option, "--num-dex-methods", &num_dex_methods_threshold_, Usage);
129}
130
131void CompilerOptions::ParseInlineDepthLimit(const StringPiece& option, UsageFn Usage) {
132 ParseUintOption(option, "--inline-depth-limit", &inline_depth_limit_, Usage);
133}
134
135void CompilerOptions::ParseInlineMaxCodeUnits(const StringPiece& option, UsageFn Usage) {
Nicolas Geoffray18c12bb2015-12-15 12:09:43 +0000136 ParseUintOption(option, "--inline-max-code-units", &inline_max_code_units_, Usage);
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000137}
138
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000139void CompilerOptions::ParseDumpInitFailures(const StringPiece& option,
140 UsageFn Usage ATTRIBUTE_UNUSED) {
141 DCHECK(option.starts_with("--dump-init-failures="));
142 std::string file_name = option.substr(strlen("--dump-init-failures=")).data();
143 init_failure_output_.reset(new std::ofstream(file_name));
144 if (init_failure_output_.get() == nullptr) {
145 LOG(ERROR) << "Failed to allocate ofstream";
146 } else if (init_failure_output_->fail()) {
147 LOG(ERROR) << "Failed to open " << file_name << " for writing the initialization "
148 << "failures.";
149 init_failure_output_.reset();
150 }
151}
152
Matthew Gharrity2cd05b72016-08-03 16:57:37 -0700153void CompilerOptions::ParseRegisterAllocationStrategy(const StringPiece& option,
154 UsageFn Usage) {
155 DCHECK(option.starts_with("--register-allocation-strategy="));
156 StringPiece choice = option.substr(strlen("--register-allocation-strategy=")).data();
157 if (choice == "linear-scan") {
158 register_allocation_strategy_ = RegisterAllocator::Strategy::kRegisterAllocatorLinearScan;
159 } else if (choice == "graph-color") {
160 register_allocation_strategy_ = RegisterAllocator::Strategy::kRegisterAllocatorGraphColor;
161 } else {
162 Usage("Unrecognized register allocation strategy. Try linear-scan, or graph-color.");
163 }
164}
165
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000166bool CompilerOptions::ParseCompilerOption(const StringPiece& option, UsageFn Usage) {
167 if (option.starts_with("--compiler-filter=")) {
168 const char* compiler_filter_string = option.substr(strlen("--compiler-filter=")).data();
Andreas Gampe29d38e72016-03-23 15:31:51 +0000169 if (!CompilerFilter::ParseCompilerFilter(compiler_filter_string, &compiler_filter_)) {
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000170 Usage("Unknown --compiler-filter value %s", compiler_filter_string);
171 }
172 } else if (option == "--compile-pic") {
173 compile_pic_ = true;
174 } else if (option.starts_with("--huge-method-max=")) {
175 ParseHugeMethodMax(option, Usage);
176 } else if (option.starts_with("--large-method-max=")) {
177 ParseLargeMethodMax(option, Usage);
178 } else if (option.starts_with("--small-method-max=")) {
179 ParseSmallMethodMax(option, Usage);
180 } else if (option.starts_with("--tiny-method-max=")) {
181 ParseTinyMethodMax(option, Usage);
182 } else if (option.starts_with("--num-dex-methods=")) {
183 ParseNumDexMethods(option, Usage);
184 } else if (option.starts_with("--inline-depth-limit=")) {
185 ParseInlineDepthLimit(option, Usage);
186 } else if (option.starts_with("--inline-max-code-units=")) {
187 ParseInlineMaxCodeUnits(option, Usage);
188 } else if (option == "--generate-debug-info" || option == "-g") {
189 generate_debug_info_ = true;
190 } else if (option == "--no-generate-debug-info") {
191 generate_debug_info_ = false;
David Srbecky5b1c2ca2016-01-25 17:32:41 +0000192 } else if (option == "--generate-mini-debug-info") {
193 generate_mini_debug_info_ = true;
194 } else if (option == "--no-generate-mini-debug-info") {
195 generate_mini_debug_info_ = false;
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000196 } else if (option == "--debuggable") {
197 debuggable_ = true;
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000198 } else if (option.starts_with("--top-k-profile-threshold=")) {
199 ParseDouble(option.data(), '=', 0.0, 100.0, &top_k_profile_threshold_, Usage);
200 } else if (option == "--include-patch-information") {
201 include_patch_information_ = true;
202 } else if (option == "--no-include-patch-information") {
203 include_patch_information_ = false;
204 } else if (option == "--abort-on-hard-verifier-error") {
205 abort_on_hard_verifier_failure_ = true;
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000206 } else if (option.starts_with("--dump-init-failures=")) {
207 ParseDumpInitFailures(option, Usage);
Nicolas Geoffrayc903b6a2016-01-18 12:56:06 +0000208 } else if (option.starts_with("--dump-cfg=")) {
209 dump_cfg_file_name_ = option.substr(strlen("--dump-cfg=")).data();
210 } else if (option.starts_with("--dump-cfg-append")) {
211 dump_cfg_append_ = true;
Matthew Gharrity2cd05b72016-08-03 16:57:37 -0700212 } else if (option.starts_with("--register-allocation-strategy=")) {
213 ParseRegisterAllocationStrategy(option, Usage);
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000214 } else {
215 // Option not recognized.
216 return false;
217 }
218 return true;
219}
220
Mathieu Chartier5bdab122015-01-26 18:30:19 -0800221} // namespace art