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