dex_to_dex_compiler.cc revision 1ebe2173d9c6144da16fd6c8790d14bcc9b38fa0
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 "base/logging.h" 18#include "base/mutex.h" 19#include "dex_file-inl.h" 20#include "dex_instruction-inl.h" 21#include "driver/compiler_driver.h" 22#include "driver/dex_compilation_unit.h" 23#include "mirror/art_field-inl.h" 24#include "mirror/art_method-inl.h" 25#include "mirror/class-inl.h" 26#include "mirror/dex_cache.h" 27#include "thread-inl.h" 28 29namespace art { 30namespace optimizer { 31 32// Controls quickening activation. 33const bool kEnableQuickening = true; 34// Control check-cast elision. 35const bool kEnableCheckCastEllision = true; 36 37class DexCompiler { 38 public: 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 46 ~DexCompiler() {} 47 48 void Compile(); 49 50 private: 51 const DexFile& GetDexFile() const { 52 return *unit_.GetDexFile(); 53 } 54 55 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 93void 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::IPUT: 124 case Instruction::IPUT_BOOLEAN: 125 case Instruction::IPUT_BYTE: 126 case Instruction::IPUT_CHAR: 127 case Instruction::IPUT_SHORT: 128 // These opcodes have the same implementation in interpreter so group 129 // them under IPUT_QUICK. 130 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_QUICK, true); 131 break; 132 133 case Instruction::IPUT_WIDE: 134 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_WIDE_QUICK, true); 135 break; 136 137 case Instruction::IPUT_OBJECT: 138 CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_OBJECT_QUICK, true); 139 break; 140 141 case Instruction::INVOKE_VIRTUAL: 142 CompileInvokeVirtual(inst, dex_pc, Instruction::INVOKE_VIRTUAL_QUICK, false); 143 break; 144 145 case Instruction::INVOKE_VIRTUAL_RANGE: 146 CompileInvokeVirtual(inst, dex_pc, Instruction::INVOKE_VIRTUAL_RANGE_QUICK, true); 147 break; 148 149 default: 150 // Nothing to do. 151 break; 152 } 153 } 154} 155 156void DexCompiler::CompileReturnVoid(Instruction* inst, uint32_t dex_pc) { 157 DCHECK(inst->Opcode() == Instruction::RETURN_VOID); 158 // Are we compiling a non-clinit constructor? 159 if (!unit_.IsConstructor() || unit_.IsStatic()) { 160 return; 161 } 162 // Do we need a constructor barrier ? 163 if (!driver_.RequiresConstructorBarrier(Thread::Current(), unit_.GetDexFile(), 164 unit_.GetClassDefIndex())) { 165 return; 166 } 167 // Replace RETURN_VOID by RETURN_VOID_BARRIER. 168 VLOG(compiler) << "Replacing " << Instruction::Name(inst->Opcode()) 169 << " by " << Instruction::Name(Instruction::RETURN_VOID_BARRIER) 170 << " at dex pc " << StringPrintf("0x%x", dex_pc) << " in method " 171 << PrettyMethod(unit_.GetDexMethodIndex(), GetDexFile(), true); 172 inst->SetOpcode(Instruction::RETURN_VOID_BARRIER); 173} 174 175Instruction* DexCompiler::CompileCheckCast(Instruction* inst, uint32_t dex_pc) { 176 if (!kEnableCheckCastEllision || !PerformOptimizations()) { 177 return inst; 178 } 179 MethodReference referrer(&GetDexFile(), unit_.GetDexMethodIndex()); 180 if (!driver_.IsSafeCast(referrer, dex_pc)) { 181 return inst; 182 } 183 // Ok, this is a safe cast. Since the "check-cast" instruction size is 2 code 184 // units and a "nop" instruction size is 1 code unit, we need to replace it by 185 // 2 consecutive NOP instructions. 186 // Because the caller loops over instructions by calling Instruction::Next onto 187 // the current instruction, we need to return the 2nd NOP instruction. Indeed, 188 // its next instruction is the former check-cast's next instruction. 189 VLOG(compiler) << "Removing " << Instruction::Name(inst->Opcode()) 190 << " by replacing it with 2 NOPs at dex pc " 191 << StringPrintf("0x%x", dex_pc) << " in method " 192 << PrettyMethod(unit_.GetDexMethodIndex(), GetDexFile(), true); 193 // We are modifying 4 consecutive bytes. 194 inst->SetOpcode(Instruction::NOP); 195 inst->SetVRegA_10x(0u); // keep compliant with verifier. 196 // Get to next instruction which is the second half of check-cast and replace 197 // it by a NOP. 198 inst = const_cast<Instruction*>(inst->Next()); 199 inst->SetOpcode(Instruction::NOP); 200 inst->SetVRegA_10x(0u); // keep compliant with verifier. 201 return inst; 202} 203 204void DexCompiler::CompileInstanceFieldAccess(Instruction* inst, 205 uint32_t dex_pc, 206 Instruction::Code new_opcode, 207 bool is_put) { 208 if (!kEnableQuickening || !PerformOptimizations()) { 209 return; 210 } 211 uint32_t field_idx = inst->VRegC_22c(); 212 int field_offset; 213 bool is_volatile; 214 bool fast_path = driver_.ComputeInstanceFieldInfo(field_idx, &unit_, is_put, 215 &field_offset, &is_volatile); 216 if (fast_path && !is_volatile && IsUint(16, field_offset)) { 217 VLOG(compiler) << "Quickening " << Instruction::Name(inst->Opcode()) 218 << " to " << Instruction::Name(new_opcode) 219 << " by replacing field index " << field_idx 220 << " by field offset " << field_offset 221 << " at dex pc " << StringPrintf("0x%x", dex_pc) << " in method " 222 << PrettyMethod(unit_.GetDexMethodIndex(), GetDexFile(), true); 223 // We are modifying 4 consecutive bytes. 224 inst->SetOpcode(new_opcode); 225 // Replace field index by field offset. 226 inst->SetVRegC_22c(static_cast<uint16_t>(field_offset)); 227 } 228} 229 230void DexCompiler::CompileInvokeVirtual(Instruction* inst, 231 uint32_t dex_pc, 232 Instruction::Code new_opcode, 233 bool is_range) { 234 if (!kEnableQuickening || !PerformOptimizations()) { 235 return; 236 } 237 uint32_t method_idx = is_range ? inst->VRegB_3rc() : inst->VRegB_35c(); 238 MethodReference target_method(&GetDexFile(), method_idx); 239 InvokeType invoke_type = kVirtual; 240 InvokeType original_invoke_type = invoke_type; 241 int vtable_idx; 242 uintptr_t direct_code; 243 uintptr_t direct_method; 244 // TODO: support devirtualization. 245 const bool kEnableDevirtualization = false; 246 bool fast_path = driver_.ComputeInvokeInfo(&unit_, dex_pc, 247 false, kEnableDevirtualization, 248 &invoke_type, 249 &target_method, &vtable_idx, 250 &direct_code, &direct_method); 251 if (fast_path && original_invoke_type == invoke_type) { 252 if (vtable_idx >= 0 && IsUint(16, vtable_idx)) { 253 VLOG(compiler) << "Quickening " << Instruction::Name(inst->Opcode()) 254 << "(" << PrettyMethod(method_idx, GetDexFile(), true) << ")" 255 << " to " << Instruction::Name(new_opcode) 256 << " by replacing method index " << method_idx 257 << " by vtable index " << vtable_idx 258 << " at dex pc " << StringPrintf("0x%x", dex_pc) << " in method " 259 << PrettyMethod(unit_.GetDexMethodIndex(), GetDexFile(), true); 260 // We are modifying 4 consecutive bytes. 261 inst->SetOpcode(new_opcode); 262 // Replace method index by vtable index. 263 if (is_range) { 264 inst->SetVRegB_3rc(static_cast<uint16_t>(vtable_idx)); 265 } else { 266 inst->SetVRegB_35c(static_cast<uint16_t>(vtable_idx)); 267 } 268 } 269 } 270} 271 272} // namespace optimizer 273} // namespace art 274 275extern "C" void ArtCompileDEX(art::CompilerDriver& compiler, const art::DexFile::CodeItem* code_item, 276 uint32_t access_flags, art::InvokeType invoke_type, 277 uint16_t class_def_idx, uint32_t method_idx, jobject class_loader, 278 const art::DexFile& dex_file, 279 art::DexToDexCompilationLevel dex_to_dex_compilation_level) { 280 if (dex_to_dex_compilation_level != art::kDontDexToDexCompile) { 281 art::DexCompilationUnit unit(NULL, class_loader, art::Runtime::Current()->GetClassLinker(), 282 dex_file, code_item, class_def_idx, method_idx, access_flags); 283 art::optimizer::DexCompiler dex_compiler(compiler, unit, dex_to_dex_compilation_level); 284 dex_compiler.Compile(); 285 } 286} 287