Home | History | Annotate | Download | only in dex 
      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:
     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 
     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 
    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 
    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 
    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 
    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 
    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