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