1 /*
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
19 #include <fstream>
20 #include <string_view>
21
22 #include "android-base/stringprintf.h"
23
24 #include "arch/instruction_set.h"
25 #include "arch/instruction_set_features.h"
26 #include "base/runtime_debug.h"
27 #include "base/string_view_cpp20.h"
28 #include "base/variant_map.h"
29 #include "class_linker.h"
30 #include "cmdline_parser.h"
31 #include "compiler_options_map-inl.h"
32 #include "dex/dex_file-inl.h"
33 #include "dex/verification_results.h"
34 #include "dex/verified_method.h"
35 #include "runtime.h"
36 #include "scoped_thread_state_change-inl.h"
37 #include "simple_compiler_options_map.h"
38
39 namespace art {
40
CompilerOptions()41 CompilerOptions::CompilerOptions()
42 : compiler_filter_(CompilerFilter::kDefaultCompilerFilter),
43 huge_method_threshold_(kDefaultHugeMethodThreshold),
44 large_method_threshold_(kDefaultLargeMethodThreshold),
45 num_dex_methods_threshold_(kDefaultNumDexMethodsThreshold),
46 inline_max_code_units_(kUnsetInlineMaxCodeUnits),
47 instruction_set_(kRuntimeISA == InstructionSet::kArm ? InstructionSet::kThumb2 : kRuntimeISA),
48 instruction_set_features_(nullptr),
49 no_inline_from_(),
50 dex_files_for_oat_file_(),
51 image_classes_(),
52 verification_results_(nullptr),
53 compiler_type_(CompilerType::kAotCompiler),
54 image_type_(ImageType::kNone),
55 compile_art_test_(false),
56 baseline_(false),
57 debuggable_(false),
58 generate_debug_info_(kDefaultGenerateDebugInfo),
59 generate_mini_debug_info_(kDefaultGenerateMiniDebugInfo),
60 generate_build_id_(false),
61 implicit_null_checks_(true),
62 implicit_so_checks_(true),
63 implicit_suspend_checks_(false),
64 compile_pic_(false),
65 dump_timings_(false),
66 dump_pass_timings_(false),
67 dump_stats_(false),
68 top_k_profile_threshold_(kDefaultTopKProfileThreshold),
69 profile_compilation_info_(nullptr),
70 verbose_methods_(),
71 abort_on_hard_verifier_failure_(false),
72 abort_on_soft_verifier_failure_(false),
73 init_failure_output_(nullptr),
74 dump_cfg_file_name_(""),
75 dump_cfg_append_(false),
76 force_determinism_(false),
77 check_linkage_conditions_(false),
78 crash_on_linkage_violation_(false),
79 deduplicate_code_(true),
80 count_hotness_in_compiled_code_(false),
81 resolve_startup_const_strings_(false),
82 initialize_app_image_classes_(false),
83 check_profiled_methods_(ProfileMethodsCheck::kNone),
84 max_image_block_size_(std::numeric_limits<uint32_t>::max()),
85 register_allocation_strategy_(RegisterAllocator::kRegisterAllocatorDefault),
86 passes_to_run_(nullptr) {
87 }
88
~CompilerOptions()89 CompilerOptions::~CompilerOptions() {
90 // Everything done by member destructors.
91 // The definitions of classes forward-declared in the header have now been #included.
92 }
93
94 namespace {
95
96 bool kEmitRuntimeReadBarrierChecks = kIsDebugBuild &&
97 RegisterRuntimeDebugFlag(&kEmitRuntimeReadBarrierChecks);
98
99 } // namespace
100
EmitRunTimeChecksInDebugMode() const101 bool CompilerOptions::EmitRunTimeChecksInDebugMode() const {
102 // Run-time checks (e.g. Marking Register checks) are only emitted in slow-debug mode.
103 return kEmitRuntimeReadBarrierChecks;
104 }
105
ParseDumpInitFailures(const std::string & option,std::string * error_msg)106 bool CompilerOptions::ParseDumpInitFailures(const std::string& option, std::string* error_msg) {
107 init_failure_output_.reset(new std::ofstream(option));
108 if (init_failure_output_.get() == nullptr) {
109 *error_msg = "Failed to construct std::ofstream";
110 return false;
111 } else if (init_failure_output_->fail()) {
112 *error_msg = android::base::StringPrintf(
113 "Failed to open %s for writing the initialization failures.", option.c_str());
114 init_failure_output_.reset();
115 return false;
116 }
117 return true;
118 }
119
ParseRegisterAllocationStrategy(const std::string & option,std::string * error_msg)120 bool CompilerOptions::ParseRegisterAllocationStrategy(const std::string& option,
121 std::string* error_msg) {
122 if (option == "linear-scan") {
123 register_allocation_strategy_ = RegisterAllocator::Strategy::kRegisterAllocatorLinearScan;
124 } else if (option == "graph-color") {
125 register_allocation_strategy_ = RegisterAllocator::Strategy::kRegisterAllocatorGraphColor;
126 } else {
127 *error_msg = "Unrecognized register allocation strategy. Try linear-scan, or graph-color.";
128 return false;
129 }
130 return true;
131 }
132
ParseCompilerOptions(const std::vector<std::string> & options,bool ignore_unrecognized,std::string * error_msg)133 bool CompilerOptions::ParseCompilerOptions(const std::vector<std::string>& options,
134 bool ignore_unrecognized,
135 std::string* error_msg) {
136 auto parser = CreateSimpleParser(ignore_unrecognized);
137 CmdlineResult parse_result = parser.Parse(options);
138 if (!parse_result.IsSuccess()) {
139 *error_msg = parse_result.GetMessage();
140 return false;
141 }
142
143 SimpleParseArgumentMap args = parser.ReleaseArgumentsMap();
144 return ReadCompilerOptions(args, this, error_msg);
145 }
146
IsImageClass(const char * descriptor) const147 bool CompilerOptions::IsImageClass(const char* descriptor) const {
148 // Historical note: We used to hold the set indirectly and there was a distinction between an
149 // empty set and a null, null meaning to include all classes. However, the distiction has been
150 // removed; if we don't have a profile, we treat it as an empty set of classes. b/77340429
151 return image_classes_.find(std::string_view(descriptor)) != image_classes_.end();
152 }
153
GetVerificationResults() const154 const VerificationResults* CompilerOptions::GetVerificationResults() const {
155 DCHECK(Runtime::Current()->IsAotCompiler());
156 return verification_results_;
157 }
158
GetVerifiedMethod(const DexFile * dex_file,uint32_t method_idx) const159 const VerifiedMethod* CompilerOptions::GetVerifiedMethod(const DexFile* dex_file,
160 uint32_t method_idx) const {
161 MethodReference ref(dex_file, method_idx);
162 return verification_results_->GetVerifiedMethod(ref);
163 }
164
IsMethodVerifiedWithoutFailures(uint32_t method_idx,uint16_t class_def_idx,const DexFile & dex_file) const165 bool CompilerOptions::IsMethodVerifiedWithoutFailures(uint32_t method_idx,
166 uint16_t class_def_idx,
167 const DexFile& dex_file) const {
168 const VerifiedMethod* verified_method = GetVerifiedMethod(&dex_file, method_idx);
169 if (verified_method != nullptr) {
170 return !verified_method->HasVerificationFailures();
171 }
172
173 // If we can't find verification metadata, check if this is a system class (we trust that system
174 // classes have their methods verified). If it's not, be conservative and assume the method
175 // has not been verified successfully.
176
177 // TODO: When compiling the boot image it should be safe to assume that everything is verified,
178 // even if methods are not found in the verification cache.
179 const char* descriptor = dex_file.GetClassDescriptor(dex_file.GetClassDef(class_def_idx));
180 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
181 Thread* self = Thread::Current();
182 ScopedObjectAccess soa(self);
183 bool is_system_class = class_linker->FindSystemClass(self, descriptor) != nullptr;
184 if (!is_system_class) {
185 self->ClearException();
186 }
187 return is_system_class;
188 }
189
190 } // namespace art
191