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 "sharpening.h"
18
19 #include "art_method-inl.h"
20 #include "base/casts.h"
21 #include "base/enums.h"
22 #include "class_linker.h"
23 #include "code_generator.h"
24 #include "driver/compiler_options.h"
25 #include "driver/dex_compilation_unit.h"
26 #include "utils/dex_cache_arrays_layout-inl.h"
27 #include "driver/compiler_driver.h"
28 #include "gc/heap.h"
29 #include "gc/space/image_space.h"
30 #include "handle_scope-inl.h"
31 #include "mirror/dex_cache.h"
32 #include "mirror/string.h"
33 #include "nodes.h"
34 #include "runtime.h"
35 #include "scoped_thread_state_change-inl.h"
36
37 namespace art {
38
Run()39 void HSharpening::Run() {
40 // We don't care about the order of the blocks here.
41 for (HBasicBlock* block : graph_->GetReversePostOrder()) {
42 for (HInstructionIterator it(block->GetInstructions()); !it.Done(); it.Advance()) {
43 HInstruction* instruction = it.Current();
44 if (instruction->IsInvokeStaticOrDirect()) {
45 SharpenInvokeStaticOrDirect(instruction->AsInvokeStaticOrDirect(),
46 codegen_,
47 compiler_driver_);
48 } else if (instruction->IsLoadString()) {
49 ProcessLoadString(instruction->AsLoadString());
50 }
51 // TODO: Move the sharpening of invoke-virtual/-interface/-super from HGraphBuilder
52 // here. Rewrite it to avoid the CompilerDriver's reliance on verifier data
53 // because we know the type better when inlining.
54 }
55 }
56 }
57
IsInBootImage(ArtMethod * method)58 static bool IsInBootImage(ArtMethod* method) {
59 const std::vector<gc::space::ImageSpace*>& image_spaces =
60 Runtime::Current()->GetHeap()->GetBootImageSpaces();
61 for (gc::space::ImageSpace* image_space : image_spaces) {
62 const ImageSection& method_section = image_space->GetImageHeader().GetMethodsSection();
63 if (method_section.Contains(reinterpret_cast<uint8_t*>(method) - image_space->Begin())) {
64 return true;
65 }
66 }
67 return false;
68 }
69
AOTCanEmbedMethod(ArtMethod * method,const CompilerOptions & options)70 static bool AOTCanEmbedMethod(ArtMethod* method, const CompilerOptions& options) {
71 return IsInBootImage(method) && !options.GetCompilePic();
72 }
73
BootImageAOTCanEmbedMethod(ArtMethod * method,CompilerDriver * compiler_driver)74 static bool BootImageAOTCanEmbedMethod(ArtMethod* method, CompilerDriver* compiler_driver) {
75 DCHECK(compiler_driver->GetCompilerOptions().IsBootImage());
76 if (!compiler_driver->GetSupportBootImageFixup()) {
77 return false;
78 }
79 ScopedObjectAccess soa(Thread::Current());
80 ObjPtr<mirror::Class> klass = method->GetDeclaringClass();
81 DCHECK(klass != nullptr);
82 const DexFile& dex_file = klass->GetDexFile();
83 return compiler_driver->IsImageClass(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
84 }
85
SharpenInvokeStaticOrDirect(HInvokeStaticOrDirect * invoke,CodeGenerator * codegen,CompilerDriver * compiler_driver)86 void HSharpening::SharpenInvokeStaticOrDirect(HInvokeStaticOrDirect* invoke,
87 CodeGenerator* codegen,
88 CompilerDriver* compiler_driver) {
89 if (invoke->IsStringInit()) {
90 // Not using the dex cache arrays. But we could still try to use a better dispatch...
91 // TODO: Use direct_method and direct_code for the appropriate StringFactory method.
92 return;
93 }
94
95 ArtMethod* callee = invoke->GetResolvedMethod();
96 DCHECK(callee != nullptr);
97
98 HInvokeStaticOrDirect::MethodLoadKind method_load_kind;
99 HInvokeStaticOrDirect::CodePtrLocation code_ptr_location;
100 uint64_t method_load_data = 0u;
101
102 // Note: we never call an ArtMethod through a known code pointer, as
103 // we do not want to keep on invoking it if it gets deoptimized. This
104 // applies to both AOT and JIT.
105 // This also avoids having to find out if the code pointer of an ArtMethod
106 // is the resolution trampoline (for ensuring the class is initialized), or
107 // the interpreter entrypoint. Such code pointers we do not want to call
108 // directly.
109 // Only in the case of a recursive call can we call directly, as we know the
110 // class is initialized already or being initialized, and the call will not
111 // be invoked once the method is deoptimized.
112
113 // We don't optimize for debuggable as it would prevent us from obsoleting the method in some
114 // situations.
115 if (callee == codegen->GetGraph()->GetArtMethod() && !codegen->GetGraph()->IsDebuggable()) {
116 // Recursive call.
117 method_load_kind = HInvokeStaticOrDirect::MethodLoadKind::kRecursive;
118 code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallSelf;
119 } else if (Runtime::Current()->UseJitCompilation() ||
120 AOTCanEmbedMethod(callee, codegen->GetCompilerOptions())) {
121 // JIT or on-device AOT compilation referencing a boot image method.
122 // Use the method address directly.
123 method_load_kind = HInvokeStaticOrDirect::MethodLoadKind::kDirectAddress;
124 method_load_data = reinterpret_cast<uintptr_t>(callee);
125 code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallArtMethod;
126 } else if (codegen->GetCompilerOptions().IsBootImage() &&
127 BootImageAOTCanEmbedMethod(callee, compiler_driver)) {
128 method_load_kind = HInvokeStaticOrDirect::MethodLoadKind::kBootImageLinkTimePcRelative;
129 code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallArtMethod;
130 } else {
131 // Use PC-relative access to the .bss methods arrays.
132 method_load_kind = HInvokeStaticOrDirect::MethodLoadKind::kBssEntry;
133 code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallArtMethod;
134 }
135
136 if (codegen->GetGraph()->IsDebuggable()) {
137 // For debuggable apps always use the code pointer from ArtMethod
138 // so that we don't circumvent instrumentation stubs if installed.
139 code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallArtMethod;
140 }
141
142 HInvokeStaticOrDirect::DispatchInfo desired_dispatch_info = {
143 method_load_kind, code_ptr_location, method_load_data
144 };
145 HInvokeStaticOrDirect::DispatchInfo dispatch_info =
146 codegen->GetSupportedInvokeStaticOrDirectDispatch(desired_dispatch_info, invoke);
147 invoke->SetDispatchInfo(dispatch_info);
148 }
149
ComputeLoadClassKind(HLoadClass * load_class,CodeGenerator * codegen,CompilerDriver * compiler_driver,const DexCompilationUnit & dex_compilation_unit)150 HLoadClass::LoadKind HSharpening::ComputeLoadClassKind(HLoadClass* load_class,
151 CodeGenerator* codegen,
152 CompilerDriver* compiler_driver,
153 const DexCompilationUnit& dex_compilation_unit) {
154 Handle<mirror::Class> klass = load_class->GetClass();
155 DCHECK(load_class->GetLoadKind() == HLoadClass::LoadKind::kRuntimeCall ||
156 load_class->GetLoadKind() == HLoadClass::LoadKind::kReferrersClass)
157 << load_class->GetLoadKind();
158 DCHECK(!load_class->IsInBootImage()) << "HLoadClass should not be optimized before sharpening.";
159
160 HLoadClass::LoadKind load_kind = load_class->GetLoadKind();
161
162 if (load_class->NeedsAccessCheck()) {
163 // We need to call the runtime anyway, so we simply get the class as that call's return value.
164 } else if (load_kind == HLoadClass::LoadKind::kReferrersClass) {
165 // Loading from the ArtMethod* is the most efficient retrieval in code size.
166 // TODO: This may not actually be true for all architectures and
167 // locations of target classes. The additional register pressure
168 // for using the ArtMethod* should be considered.
169 } else {
170 const DexFile& dex_file = load_class->GetDexFile();
171 dex::TypeIndex type_index = load_class->GetTypeIndex();
172
173 bool is_in_boot_image = false;
174 HLoadClass::LoadKind desired_load_kind = HLoadClass::LoadKind::kInvalid;
175 Runtime* runtime = Runtime::Current();
176 if (codegen->GetCompilerOptions().IsBootImage()) {
177 // Compiling boot image. Check if the class is a boot image class.
178 DCHECK(!runtime->UseJitCompilation());
179 if (!compiler_driver->GetSupportBootImageFixup()) {
180 // compiler_driver_test. Do not sharpen.
181 desired_load_kind = HLoadClass::LoadKind::kRuntimeCall;
182 } else if ((klass != nullptr) &&
183 compiler_driver->IsImageClass(dex_file.StringByTypeIdx(type_index))) {
184 is_in_boot_image = true;
185 desired_load_kind = HLoadClass::LoadKind::kBootImageLinkTimePcRelative;
186 } else {
187 // Not a boot image class.
188 DCHECK(ContainsElement(compiler_driver->GetDexFilesForOatFile(), &dex_file));
189 desired_load_kind = HLoadClass::LoadKind::kBssEntry;
190 }
191 } else {
192 is_in_boot_image = (klass != nullptr) &&
193 runtime->GetHeap()->ObjectIsInBootImageSpace(klass.Get());
194 if (runtime->UseJitCompilation()) {
195 DCHECK(!codegen->GetCompilerOptions().GetCompilePic());
196 if (is_in_boot_image) {
197 // TODO: Use direct pointers for all non-moving spaces, not just boot image. Bug: 29530787
198 desired_load_kind = HLoadClass::LoadKind::kBootImageAddress;
199 } else if (klass != nullptr) {
200 desired_load_kind = HLoadClass::LoadKind::kJitTableAddress;
201 } else {
202 // Class not loaded yet. This happens when the dex code requesting
203 // this `HLoadClass` hasn't been executed in the interpreter.
204 // Fallback to the dex cache.
205 // TODO(ngeoffray): Generate HDeoptimize instead.
206 desired_load_kind = HLoadClass::LoadKind::kRuntimeCall;
207 }
208 } else if (is_in_boot_image && !codegen->GetCompilerOptions().GetCompilePic()) {
209 // AOT app compilation. Check if the class is in the boot image.
210 desired_load_kind = HLoadClass::LoadKind::kBootImageAddress;
211 } else {
212 // Not JIT and either the klass is not in boot image or we are compiling in PIC mode.
213 desired_load_kind = HLoadClass::LoadKind::kBssEntry;
214 }
215 }
216 DCHECK_NE(desired_load_kind, HLoadClass::LoadKind::kInvalid);
217
218 if (is_in_boot_image) {
219 load_class->MarkInBootImage();
220 }
221 load_kind = codegen->GetSupportedLoadClassKind(desired_load_kind);
222 }
223
224 if (!IsSameDexFile(load_class->GetDexFile(), *dex_compilation_unit.GetDexFile())) {
225 if ((load_kind == HLoadClass::LoadKind::kRuntimeCall) ||
226 (load_kind == HLoadClass::LoadKind::kBssEntry)) {
227 // We actually cannot reference this class, we're forced to bail.
228 // We cannot reference this class with Bss, as the entrypoint will lookup the class
229 // in the caller's dex file, but that dex file does not reference the class.
230 return HLoadClass::LoadKind::kInvalid;
231 }
232 }
233 return load_kind;
234 }
235
ProcessLoadString(HLoadString * load_string)236 void HSharpening::ProcessLoadString(HLoadString* load_string) {
237 DCHECK_EQ(load_string->GetLoadKind(), HLoadString::LoadKind::kRuntimeCall);
238
239 const DexFile& dex_file = load_string->GetDexFile();
240 dex::StringIndex string_index = load_string->GetStringIndex();
241
242 HLoadString::LoadKind desired_load_kind = static_cast<HLoadString::LoadKind>(-1);
243 {
244 Runtime* runtime = Runtime::Current();
245 ClassLinker* class_linker = runtime->GetClassLinker();
246 ScopedObjectAccess soa(Thread::Current());
247 StackHandleScope<1> hs(soa.Self());
248 Handle<mirror::DexCache> dex_cache = IsSameDexFile(dex_file, *compilation_unit_.GetDexFile())
249 ? compilation_unit_.GetDexCache()
250 : hs.NewHandle(class_linker->FindDexCache(soa.Self(), dex_file));
251 mirror::String* string = nullptr;
252
253 if (codegen_->GetCompilerOptions().IsBootImage()) {
254 // Compiling boot image. Resolve the string and allocate it if needed, to ensure
255 // the string will be added to the boot image.
256 DCHECK(!runtime->UseJitCompilation());
257 string = class_linker->ResolveString(dex_file, string_index, dex_cache);
258 CHECK(string != nullptr);
259 if (compiler_driver_->GetSupportBootImageFixup()) {
260 DCHECK(ContainsElement(compiler_driver_->GetDexFilesForOatFile(), &dex_file));
261 desired_load_kind = HLoadString::LoadKind::kBootImageLinkTimePcRelative;
262 } else {
263 // compiler_driver_test. Do not sharpen.
264 desired_load_kind = HLoadString::LoadKind::kRuntimeCall;
265 }
266 } else if (runtime->UseJitCompilation()) {
267 DCHECK(!codegen_->GetCompilerOptions().GetCompilePic());
268 string = class_linker->LookupString(dex_file, string_index, dex_cache.Get());
269 if (string != nullptr) {
270 if (runtime->GetHeap()->ObjectIsInBootImageSpace(string)) {
271 desired_load_kind = HLoadString::LoadKind::kBootImageAddress;
272 } else {
273 desired_load_kind = HLoadString::LoadKind::kJitTableAddress;
274 }
275 } else {
276 desired_load_kind = HLoadString::LoadKind::kRuntimeCall;
277 }
278 } else {
279 // AOT app compilation. Try to lookup the string without allocating if not found.
280 string = class_linker->LookupString(dex_file, string_index, dex_cache.Get());
281 if (string != nullptr &&
282 runtime->GetHeap()->ObjectIsInBootImageSpace(string) &&
283 !codegen_->GetCompilerOptions().GetCompilePic()) {
284 desired_load_kind = HLoadString::LoadKind::kBootImageAddress;
285 } else {
286 desired_load_kind = HLoadString::LoadKind::kBssEntry;
287 }
288 }
289 if (string != nullptr) {
290 load_string->SetString(handles_->NewHandle(string));
291 }
292 }
293 DCHECK_NE(desired_load_kind, static_cast<HLoadString::LoadKind>(-1));
294
295 HLoadString::LoadKind load_kind = codegen_->GetSupportedLoadStringKind(desired_load_kind);
296 load_string->SetLoadKind(load_kind);
297 }
298
299 } // namespace art
300