1 /*
2  * Copyright (C) 2017 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_MAP_INL_H_
18 #define ART_COMPILER_DRIVER_COMPILER_OPTIONS_MAP_INL_H_
19 
20 #include "compiler_options_map.h"
21 
22 #include <memory>
23 
24 #include "android-base/logging.h"
25 #include "android-base/macros.h"
26 #include "android-base/stringprintf.h"
27 
28 #include "base/macros.h"
29 #include "cmdline_parser.h"
30 #include "compiler_options.h"
31 
32 namespace art {
33 
34 template <class Base>
ReadCompilerOptions(Base & map,CompilerOptions * options,std::string * error_msg)35 inline bool ReadCompilerOptions(Base& map, CompilerOptions* options, std::string* error_msg) {
36   if (map.Exists(Base::CompilerFilter)) {
37     CompilerFilter::Filter compiler_filter;
38     if (!CompilerFilter::ParseCompilerFilter(map.Get(Base::CompilerFilter)->c_str(),
39                                              &compiler_filter)) {
40       *error_msg = android::base::StringPrintf("Unknown --compiler-filter value %s",
41                                                map.Get(Base::CompilerFilter)->c_str());
42       return false;
43     }
44     options->SetCompilerFilter(compiler_filter);
45   }
46   map.AssignIfExists(Base::CompileArtTest, &options->compile_art_test_);
47   map.AssignIfExists(Base::HugeMethodMaxThreshold, &options->huge_method_threshold_);
48   map.AssignIfExists(Base::LargeMethodMaxThreshold, &options->large_method_threshold_);
49   map.AssignIfExists(Base::NumDexMethodsThreshold, &options->num_dex_methods_threshold_);
50   map.AssignIfExists(Base::InlineMaxCodeUnitsThreshold, &options->inline_max_code_units_);
51   map.AssignIfExists(Base::GenerateDebugInfo, &options->generate_debug_info_);
52   map.AssignIfExists(Base::GenerateMiniDebugInfo, &options->generate_mini_debug_info_);
53   map.AssignIfExists(Base::GenerateBuildID, &options->generate_build_id_);
54   if (map.Exists(Base::Debuggable)) {
55     options->debuggable_ = true;
56   }
57   if (map.Exists(Base::Baseline)) {
58     options->baseline_ = true;
59   }
60   map.AssignIfExists(Base::TopKProfileThreshold, &options->top_k_profile_threshold_);
61   map.AssignIfExists(Base::AbortOnHardVerifierFailure, &options->abort_on_hard_verifier_failure_);
62   map.AssignIfExists(Base::AbortOnSoftVerifierFailure, &options->abort_on_soft_verifier_failure_);
63   if (map.Exists(Base::DumpInitFailures)) {
64     if (!options->ParseDumpInitFailures(*map.Get(Base::DumpInitFailures), error_msg)) {
65       return false;
66     }
67   }
68   map.AssignIfExists(Base::DumpCFG, &options->dump_cfg_file_name_);
69   if (map.Exists(Base::DumpCFGAppend)) {
70     options->dump_cfg_append_ = true;
71   }
72   if (map.Exists(Base::RegisterAllocationStrategy)) {
73     if (!options->ParseRegisterAllocationStrategy(*map.Get(Base::DumpInitFailures), error_msg)) {
74       return false;
75     }
76   }
77   map.AssignIfExists(Base::VerboseMethods, &options->verbose_methods_);
78   options->deduplicate_code_ = map.GetOrDefault(Base::DeduplicateCode);
79   if (map.Exists(Base::CountHotnessInCompiledCode)) {
80     options->count_hotness_in_compiled_code_ = true;
81   }
82   map.AssignIfExists(Base::ResolveStartupConstStrings, &options->resolve_startup_const_strings_);
83   map.AssignIfExists(Base::InitializeAppImageClasses, &options->initialize_app_image_classes_);
84   if (map.Exists(Base::CheckProfiledMethods)) {
85     options->check_profiled_methods_ = *map.Get(Base::CheckProfiledMethods);
86   }
87   map.AssignIfExists(Base::MaxImageBlockSize, &options->max_image_block_size_);
88 
89   if (map.Exists(Base::DumpTimings)) {
90     options->dump_timings_ = true;
91   }
92 
93   if (map.Exists(Base::DumpPassTimings)) {
94     options->dump_pass_timings_ = true;
95   }
96 
97   if (map.Exists(Base::DumpStats)) {
98     options->dump_stats_ = true;
99   }
100 
101   return true;
102 }
103 
104 #pragma GCC diagnostic push
105 #pragma GCC diagnostic ignored "-Wframe-larger-than="
106 
107 template <typename Map, typename Builder>
AddCompilerOptionsArgumentParserOptions(Builder & b)108 inline void AddCompilerOptionsArgumentParserOptions(Builder& b) {
109   b.
110       Define("--compiler-filter=_")
111           .template WithType<std::string>()
112           .IntoKey(Map::CompilerFilter)
113 
114       .Define({"--compile-art-test", "--no-compile-art-test"})
115           .WithValues({true, false})
116           .IntoKey(Map::CompileArtTest)
117       .Define("--huge-method-max=_")
118           .template WithType<unsigned int>()
119           .IntoKey(Map::HugeMethodMaxThreshold)
120       .Define("--large-method-max=_")
121           .template WithType<unsigned int>()
122           .IntoKey(Map::LargeMethodMaxThreshold)
123       .Define("--num-dex-methods=_")
124           .template WithType<unsigned int>()
125           .IntoKey(Map::NumDexMethodsThreshold)
126       .Define("--inline-max-code-units=_")
127           .template WithType<unsigned int>()
128           .IntoKey(Map::InlineMaxCodeUnitsThreshold)
129 
130       .Define({"--generate-debug-info", "-g", "--no-generate-debug-info"})
131           .WithValues({true, true, false})
132           .IntoKey(Map::GenerateDebugInfo)
133       .Define({"--generate-mini-debug-info", "--no-generate-mini-debug-info"})
134           .WithValues({true, false})
135           .IntoKey(Map::GenerateMiniDebugInfo)
136 
137       .Define({"--generate-build-id", "--no-generate-build-id"})
138           .WithValues({true, false})
139           .IntoKey(Map::GenerateBuildID)
140 
141       .Define({"--deduplicate-code=_"})
142           .template WithType<bool>()
143           .WithValueMap({{"false", false}, {"true", true}})
144           .IntoKey(Map::DeduplicateCode)
145 
146       .Define({"--count-hotness-in-compiled-code"})
147           .IntoKey(Map::CountHotnessInCompiledCode)
148 
149       .Define({"--check-profiled-methods=_"})
150           .template WithType<ProfileMethodsCheck>()
151           .WithValueMap({{"log", ProfileMethodsCheck::kLog},
152                          {"abort", ProfileMethodsCheck::kAbort}})
153           .IntoKey(Map::CheckProfiledMethods)
154 
155       .Define({"--dump-timings"})
156           .IntoKey(Map::DumpTimings)
157 
158       .Define({"--dump-pass-timings"})
159           .IntoKey(Map::DumpPassTimings)
160 
161       .Define({"--dump-stats"})
162           .IntoKey(Map::DumpStats)
163 
164       .Define("--debuggable")
165           .IntoKey(Map::Debuggable)
166 
167       .Define("--baseline")
168           .IntoKey(Map::Baseline)
169 
170       .Define("--top-k-profile-threshold=_")
171           .template WithType<double>().WithRange(0.0, 100.0)
172           .IntoKey(Map::TopKProfileThreshold)
173 
174       .Define({"--abort-on-hard-verifier-error", "--no-abort-on-hard-verifier-error"})
175           .WithValues({true, false})
176           .IntoKey(Map::AbortOnHardVerifierFailure)
177       .Define({"--abort-on-soft-verifier-error", "--no-abort-on-soft-verifier-error"})
178           .WithValues({true, false})
179           .IntoKey(Map::AbortOnSoftVerifierFailure)
180 
181       .Define("--dump-init-failures=_")
182           .template WithType<std::string>()
183           .IntoKey(Map::DumpInitFailures)
184 
185       .Define("--dump-cfg=_")
186           .template WithType<std::string>()
187           .IntoKey(Map::DumpCFG)
188       .Define("--dump-cfg-append")
189           .IntoKey(Map::DumpCFGAppend)
190 
191       .Define("--register-allocation-strategy=_")
192           .template WithType<std::string>()
193           .IntoKey(Map::RegisterAllocationStrategy)
194 
195       .Define("--resolve-startup-const-strings=_")
196           .template WithType<bool>()
197           .WithValueMap({{"false", false}, {"true", true}})
198           .IntoKey(Map::ResolveStartupConstStrings)
199 
200       .Define("--initialize-app-image-classes=_")
201           .template WithType<bool>()
202           .WithValueMap({{"false", false}, {"true", true}})
203           .IntoKey(Map::InitializeAppImageClasses)
204 
205       .Define("--verbose-methods=_")
206           .template WithType<ParseStringList<','>>()
207           .IntoKey(Map::VerboseMethods)
208 
209       .Define("--max-image-block-size=_")
210           .template WithType<unsigned int>()
211           .IntoKey(Map::MaxImageBlockSize);
212 }
213 
214 #pragma GCC diagnostic pop
215 
216 }  // namespace art
217 
218 #endif  // ART_COMPILER_DRIVER_COMPILER_OPTIONS_MAP_INL_H_
219