1 /*
2 * Copyright (C) 2011 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 "dex_to_dex_compiler.h"
18
19 #include "art_field-inl.h"
20 #include "art_method-inl.h"
21 #include "base/logging.h"
22 #include "base/mutex.h"
23 #include "compiled_method.h"
24 #include "dex_file-inl.h"
25 #include "dex_instruction-inl.h"
26 #include "driver/compiler_driver.h"
27 #include "driver/dex_compilation_unit.h"
28 #include "mirror/class-inl.h"
29 #include "mirror/dex_cache.h"
30 #include "thread-inl.h"
31
32 namespace art {
33 namespace optimizer {
34
35 // Controls quickening activation.
36 const bool kEnableQuickening = true;
37 // Control check-cast elision.
38 const bool kEnableCheckCastEllision = true;
39
40 struct QuickenedInfo {
QuickenedInfoart::optimizer::QuickenedInfo41 QuickenedInfo(uint32_t pc, uint16_t index) : dex_pc(pc), dex_member_index(index) {}
42
43 uint32_t dex_pc;
44 uint16_t dex_member_index;
45 };
46
47 class DexCompiler {
48 public:
DexCompiler(art::CompilerDriver & compiler,const DexCompilationUnit & unit,DexToDexCompilationLevel dex_to_dex_compilation_level)49 DexCompiler(art::CompilerDriver& compiler,
50 const DexCompilationUnit& unit,
51 DexToDexCompilationLevel dex_to_dex_compilation_level)
52 : driver_(compiler),
53 unit_(unit),
54 dex_to_dex_compilation_level_(dex_to_dex_compilation_level) {}
55
~DexCompiler()56 ~DexCompiler() {}
57
58 void Compile();
59
GetQuickenedInfo() const60 const std::vector<QuickenedInfo>& GetQuickenedInfo() const {
61 return quickened_info_;
62 }
63
64 private:
GetDexFile() const65 const DexFile& GetDexFile() const {
66 return *unit_.GetDexFile();
67 }
68
PerformOptimizations() const69 bool PerformOptimizations() const {
70 return dex_to_dex_compilation_level_ >= DexToDexCompilationLevel::kOptimize;
71 }
72
73 // Compiles a RETURN-VOID into a RETURN-VOID-BARRIER within a constructor where
74 // a barrier is required.
75 void CompileReturnVoid(Instruction* inst, uint32_t dex_pc);
76
77 // Compiles a CHECK-CAST into 2 NOP instructions if it is known to be safe. In
78 // this case, returns the second NOP instruction pointer. Otherwise, returns
79 // the given "inst".
80 Instruction* CompileCheckCast(Instruction* inst, uint32_t dex_pc);
81
82 // Compiles a field access into a quick field access.
83 // The field index is replaced by an offset within an Object where we can read
84 // from / write to this field. Therefore, this does not involve any resolution
85 // at runtime.
86 // Since the field index is encoded with 16 bits, we can replace it only if the
87 // field offset can be encoded with 16 bits too.
88 void CompileInstanceFieldAccess(Instruction* inst, uint32_t dex_pc,
89 Instruction::Code new_opcode, bool is_put);
90
91 // Compiles a virtual method invocation into a quick virtual method invocation.
92 // The method index is replaced by the vtable index where the corresponding
93 // AbstractMethod can be found. Therefore, this does not involve any resolution
94 // at runtime.
95 // Since the method index is encoded with 16 bits, we can replace it only if the
96 // vtable index can be encoded with 16 bits too.
97 void CompileInvokeVirtual(Instruction* inst, uint32_t dex_pc,
98 Instruction::Code new_opcode, bool is_range);
99
100 CompilerDriver& driver_;
101 const DexCompilationUnit& unit_;
102 const DexToDexCompilationLevel dex_to_dex_compilation_level_;
103
104 // Filled by the compiler when quickening, in order to encode that information
105 // in the .oat file. The runtime will use that information to get to the original
106 // opcodes.
107 std::vector<QuickenedInfo> quickened_info_;
108
109 DISALLOW_COPY_AND_ASSIGN(DexCompiler);
110 };
111
Compile()112 void DexCompiler::Compile() {
113 DCHECK_GE(dex_to_dex_compilation_level_, DexToDexCompilationLevel::kRequired);
114 const DexFile::CodeItem* code_item = unit_.GetCodeItem();
115 const uint16_t* insns = code_item->insns_;
116 const uint32_t insns_size = code_item->insns_size_in_code_units_;
117 Instruction* inst = const_cast<Instruction*>(Instruction::At(insns));
118
119 for (uint32_t dex_pc = 0; dex_pc < insns_size;
120 inst = const_cast<Instruction*>(inst->Next()), dex_pc = inst->GetDexPc(insns)) {
121 switch (inst->Opcode()) {
122 case Instruction::RETURN_VOID:
123 CompileReturnVoid(inst, dex_pc);
124 break;
125
126 case Instruction::CHECK_CAST:
127 inst = CompileCheckCast(inst, dex_pc);
128 break;
129
130 case Instruction::IGET:
131 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_QUICK, false);
132 break;
133
134 case Instruction::IGET_WIDE:
135 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_WIDE_QUICK, false);
136 break;
137
138 case Instruction::IGET_OBJECT:
139 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_OBJECT_QUICK, false);
140 break;
141
142 case Instruction::IGET_BOOLEAN:
143 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_BOOLEAN_QUICK, false);
144 break;
145
146 case Instruction::IGET_BYTE:
147 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_BYTE_QUICK, false);
148 break;
149
150 case Instruction::IGET_CHAR:
151 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_CHAR_QUICK, false);
152 break;
153
154 case Instruction::IGET_SHORT:
155 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_SHORT_QUICK, false);
156 break;
157
158 case Instruction::IPUT:
159 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_QUICK, true);
160 break;
161
162 case Instruction::IPUT_BOOLEAN:
163 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_BOOLEAN_QUICK, true);
164 break;
165
166 case Instruction::IPUT_BYTE:
167 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_BYTE_QUICK, true);
168 break;
169
170 case Instruction::IPUT_CHAR:
171 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_CHAR_QUICK, true);
172 break;
173
174 case Instruction::IPUT_SHORT:
175 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_SHORT_QUICK, true);
176 break;
177
178 case Instruction::IPUT_WIDE:
179 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_WIDE_QUICK, true);
180 break;
181
182 case Instruction::IPUT_OBJECT:
183 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_OBJECT_QUICK, true);
184 break;
185
186 case Instruction::INVOKE_VIRTUAL:
187 CompileInvokeVirtual(inst, dex_pc, Instruction::INVOKE_VIRTUAL_QUICK, false);
188 break;
189
190 case Instruction::INVOKE_VIRTUAL_RANGE:
191 CompileInvokeVirtual(inst, dex_pc, Instruction::INVOKE_VIRTUAL_RANGE_QUICK, true);
192 break;
193
194 default:
195 // Nothing to do.
196 break;
197 }
198 }
199 }
200
CompileReturnVoid(Instruction * inst,uint32_t dex_pc)201 void DexCompiler::CompileReturnVoid(Instruction* inst, uint32_t dex_pc) {
202 DCHECK_EQ(inst->Opcode(), Instruction::RETURN_VOID);
203 if (unit_.IsConstructor()) {
204 // Are we compiling a non clinit constructor which needs a barrier ?
205 if (!unit_.IsStatic() &&
206 driver_.RequiresConstructorBarrier(Thread::Current(), unit_.GetDexFile(),
207 unit_.GetClassDefIndex())) {
208 return;
209 }
210 }
211 // Replace RETURN_VOID by RETURN_VOID_NO_BARRIER.
212 VLOG(compiler) << "Replacing " << Instruction::Name(inst->Opcode())
213 << " by " << Instruction::Name(Instruction::RETURN_VOID_NO_BARRIER)
214 << " at dex pc " << StringPrintf("0x%x", dex_pc) << " in method "
215 << PrettyMethod(unit_.GetDexMethodIndex(), GetDexFile(), true);
216 inst->SetOpcode(Instruction::RETURN_VOID_NO_BARRIER);
217 }
218
CompileCheckCast(Instruction * inst,uint32_t dex_pc)219 Instruction* DexCompiler::CompileCheckCast(Instruction* inst, uint32_t dex_pc) {
220 if (!kEnableCheckCastEllision || !PerformOptimizations()) {
221 return inst;
222 }
223 if (!driver_.IsSafeCast(&unit_, dex_pc)) {
224 return inst;
225 }
226 // Ok, this is a safe cast. Since the "check-cast" instruction size is 2 code
227 // units and a "nop" instruction size is 1 code unit, we need to replace it by
228 // 2 consecutive NOP instructions.
229 // Because the caller loops over instructions by calling Instruction::Next onto
230 // the current instruction, we need to return the 2nd NOP instruction. Indeed,
231 // its next instruction is the former check-cast's next instruction.
232 VLOG(compiler) << "Removing " << Instruction::Name(inst->Opcode())
233 << " by replacing it with 2 NOPs at dex pc "
234 << StringPrintf("0x%x", dex_pc) << " in method "
235 << PrettyMethod(unit_.GetDexMethodIndex(), GetDexFile(), true);
236 // We are modifying 4 consecutive bytes.
237 inst->SetOpcode(Instruction::NOP);
238 inst->SetVRegA_10x(0u); // keep compliant with verifier.
239 // Get to next instruction which is the second half of check-cast and replace
240 // it by a NOP.
241 inst = const_cast<Instruction*>(inst->Next());
242 inst->SetOpcode(Instruction::NOP);
243 inst->SetVRegA_10x(0u); // keep compliant with verifier.
244 return inst;
245 }
246
CompileInstanceFieldAccess(Instruction * inst,uint32_t dex_pc,Instruction::Code new_opcode,bool is_put)247 void DexCompiler::CompileInstanceFieldAccess(Instruction* inst,
248 uint32_t dex_pc,
249 Instruction::Code new_opcode,
250 bool is_put) {
251 if (!kEnableQuickening || !PerformOptimizations()) {
252 return;
253 }
254 uint32_t field_idx = inst->VRegC_22c();
255 MemberOffset field_offset(0u);
256 bool is_volatile;
257 bool fast_path = driver_.ComputeInstanceFieldInfo(field_idx, &unit_, is_put,
258 &field_offset, &is_volatile);
259 if (fast_path && !is_volatile && IsUint<16>(field_offset.Int32Value())) {
260 VLOG(compiler) << "Quickening " << Instruction::Name(inst->Opcode())
261 << " to " << Instruction::Name(new_opcode)
262 << " by replacing field index " << field_idx
263 << " by field offset " << field_offset.Int32Value()
264 << " at dex pc " << StringPrintf("0x%x", dex_pc) << " in method "
265 << PrettyMethod(unit_.GetDexMethodIndex(), GetDexFile(), true);
266 // We are modifying 4 consecutive bytes.
267 inst->SetOpcode(new_opcode);
268 // Replace field index by field offset.
269 inst->SetVRegC_22c(static_cast<uint16_t>(field_offset.Int32Value()));
270 quickened_info_.push_back(QuickenedInfo(dex_pc, field_idx));
271 }
272 }
273
CompileInvokeVirtual(Instruction * inst,uint32_t dex_pc,Instruction::Code new_opcode,bool is_range)274 void DexCompiler::CompileInvokeVirtual(Instruction* inst, uint32_t dex_pc,
275 Instruction::Code new_opcode, bool is_range) {
276 if (!kEnableQuickening || !PerformOptimizations()) {
277 return;
278 }
279 uint32_t method_idx = is_range ? inst->VRegB_3rc() : inst->VRegB_35c();
280 MethodReference target_method(&GetDexFile(), method_idx);
281 InvokeType invoke_type = kVirtual;
282 InvokeType original_invoke_type = invoke_type;
283 int vtable_idx;
284 uintptr_t direct_code;
285 uintptr_t direct_method;
286 // TODO: support devirtualization.
287 const bool kEnableDevirtualization = false;
288 bool fast_path = driver_.ComputeInvokeInfo(&unit_, dex_pc,
289 false, kEnableDevirtualization,
290 &invoke_type,
291 &target_method, &vtable_idx,
292 &direct_code, &direct_method);
293 if (fast_path && original_invoke_type == invoke_type) {
294 if (vtable_idx >= 0 && IsUint<16>(vtable_idx)) {
295 VLOG(compiler) << "Quickening " << Instruction::Name(inst->Opcode())
296 << "(" << PrettyMethod(method_idx, GetDexFile(), true) << ")"
297 << " to " << Instruction::Name(new_opcode)
298 << " by replacing method index " << method_idx
299 << " by vtable index " << vtable_idx
300 << " at dex pc " << StringPrintf("0x%x", dex_pc) << " in method "
301 << PrettyMethod(unit_.GetDexMethodIndex(), GetDexFile(), true);
302 // We are modifying 4 consecutive bytes.
303 inst->SetOpcode(new_opcode);
304 // Replace method index by vtable index.
305 if (is_range) {
306 inst->SetVRegB_3rc(static_cast<uint16_t>(vtable_idx));
307 } else {
308 inst->SetVRegB_35c(static_cast<uint16_t>(vtable_idx));
309 }
310 quickened_info_.push_back(QuickenedInfo(dex_pc, method_idx));
311 }
312 }
313 }
314
ArtCompileDEX(CompilerDriver * driver,const DexFile::CodeItem * code_item,uint32_t access_flags,InvokeType invoke_type ATTRIBUTE_UNUSED,uint16_t class_def_idx,uint32_t method_idx,jobject class_loader,const DexFile & dex_file,DexToDexCompilationLevel dex_to_dex_compilation_level)315 CompiledMethod* ArtCompileDEX(
316 CompilerDriver* driver,
317 const DexFile::CodeItem* code_item,
318 uint32_t access_flags,
319 InvokeType invoke_type ATTRIBUTE_UNUSED,
320 uint16_t class_def_idx,
321 uint32_t method_idx,
322 jobject class_loader,
323 const DexFile& dex_file,
324 DexToDexCompilationLevel dex_to_dex_compilation_level) {
325 DCHECK(driver != nullptr);
326 if (dex_to_dex_compilation_level != DexToDexCompilationLevel::kDontDexToDexCompile) {
327 ScopedObjectAccess soa(Thread::Current());
328 StackHandleScope<1> hs(soa.Self());
329 ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
330 art::DexCompilationUnit unit(
331 class_loader,
332 class_linker,
333 dex_file,
334 code_item,
335 class_def_idx,
336 method_idx,
337 access_flags,
338 driver->GetVerifiedMethod(&dex_file, method_idx),
339 hs.NewHandle(class_linker->FindDexCache(soa.Self(), dex_file)));
340 art::optimizer::DexCompiler dex_compiler(*driver, unit, dex_to_dex_compilation_level);
341 dex_compiler.Compile();
342 if (dex_compiler.GetQuickenedInfo().empty()) {
343 // No need to create a CompiledMethod if there are no quickened opcodes.
344 return nullptr;
345 }
346
347 // Create a `CompiledMethod`, with the quickened information in the vmap table.
348 Leb128EncodingVector<> builder;
349 for (QuickenedInfo info : dex_compiler.GetQuickenedInfo()) {
350 builder.PushBackUnsigned(info.dex_pc);
351 builder.PushBackUnsigned(info.dex_member_index);
352 }
353 InstructionSet instruction_set = driver->GetInstructionSet();
354 if (instruction_set == kThumb2) {
355 // Don't use the thumb2 instruction set to avoid the one off code delta.
356 instruction_set = kArm;
357 }
358 return CompiledMethod::SwapAllocCompiledMethod(
359 driver,
360 instruction_set,
361 ArrayRef<const uint8_t>(), // no code
362 0,
363 0,
364 0,
365 ArrayRef<const SrcMapElem>(), // src_mapping_table
366 ArrayRef<const uint8_t>(builder.GetData()), // vmap_table
367 ArrayRef<const uint8_t>(), // cfi data
368 ArrayRef<const LinkerPatch>());
369 }
370 return nullptr;
371 }
372
373 } // namespace optimizer
374
375 } // namespace art
376