375 lines
14 KiB
C++
375 lines
14 KiB
C++
/*
|
|
* Copyright (C) 2011 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "dex_to_dex_compiler.h"
|
|
|
|
#include "art_field-inl.h"
|
|
#include "art_method-inl.h"
|
|
#include "base/logging.h"
|
|
#include "base/mutex.h"
|
|
#include "compiled_method.h"
|
|
#include "dex_file-inl.h"
|
|
#include "dex_instruction-inl.h"
|
|
#include "driver/compiler_driver.h"
|
|
#include "driver/dex_compilation_unit.h"
|
|
#include "mirror/class-inl.h"
|
|
#include "mirror/dex_cache.h"
|
|
#include "thread-inl.h"
|
|
|
|
namespace art {
|
|
namespace optimizer {
|
|
|
|
// Controls quickening activation.
|
|
const bool kEnableQuickening = true;
|
|
// Control check-cast elision.
|
|
const bool kEnableCheckCastEllision = true;
|
|
|
|
struct QuickenedInfo {
|
|
QuickenedInfo(uint32_t pc, uint16_t index) : dex_pc(pc), dex_member_index(index) {}
|
|
|
|
uint32_t dex_pc;
|
|
uint16_t dex_member_index;
|
|
};
|
|
|
|
class DexCompiler {
|
|
public:
|
|
DexCompiler(art::CompilerDriver& compiler,
|
|
const DexCompilationUnit& unit,
|
|
DexToDexCompilationLevel dex_to_dex_compilation_level)
|
|
: driver_(compiler),
|
|
unit_(unit),
|
|
dex_to_dex_compilation_level_(dex_to_dex_compilation_level) {}
|
|
|
|
~DexCompiler() {}
|
|
|
|
void Compile();
|
|
|
|
const std::vector<QuickenedInfo>& GetQuickenedInfo() const {
|
|
return quickened_info_;
|
|
}
|
|
|
|
private:
|
|
const DexFile& GetDexFile() const {
|
|
return *unit_.GetDexFile();
|
|
}
|
|
|
|
bool PerformOptimizations() const {
|
|
return dex_to_dex_compilation_level_ >= DexToDexCompilationLevel::kOptimize;
|
|
}
|
|
|
|
// Compiles a RETURN-VOID into a RETURN-VOID-BARRIER within a constructor where
|
|
// a barrier is required.
|
|
void CompileReturnVoid(Instruction* inst, uint32_t dex_pc);
|
|
|
|
// Compiles a CHECK-CAST into 2 NOP instructions if it is known to be safe. In
|
|
// this case, returns the second NOP instruction pointer. Otherwise, returns
|
|
// the given "inst".
|
|
Instruction* CompileCheckCast(Instruction* inst, uint32_t dex_pc);
|
|
|
|
// Compiles a field access into a quick field access.
|
|
// The field index is replaced by an offset within an Object where we can read
|
|
// from / write to this field. Therefore, this does not involve any resolution
|
|
// at runtime.
|
|
// Since the field index is encoded with 16 bits, we can replace it only if the
|
|
// field offset can be encoded with 16 bits too.
|
|
void CompileInstanceFieldAccess(Instruction* inst, uint32_t dex_pc,
|
|
Instruction::Code new_opcode, bool is_put);
|
|
|
|
// Compiles a virtual method invocation into a quick virtual method invocation.
|
|
// The method index is replaced by the vtable index where the corresponding
|
|
// AbstractMethod can be found. Therefore, this does not involve any resolution
|
|
// at runtime.
|
|
// Since the method index is encoded with 16 bits, we can replace it only if the
|
|
// vtable index can be encoded with 16 bits too.
|
|
void CompileInvokeVirtual(Instruction* inst, uint32_t dex_pc,
|
|
Instruction::Code new_opcode, bool is_range);
|
|
|
|
CompilerDriver& driver_;
|
|
const DexCompilationUnit& unit_;
|
|
const DexToDexCompilationLevel dex_to_dex_compilation_level_;
|
|
|
|
// Filled by the compiler when quickening, in order to encode that information
|
|
// in the .oat file. The runtime will use that information to get to the original
|
|
// opcodes.
|
|
std::vector<QuickenedInfo> quickened_info_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(DexCompiler);
|
|
};
|
|
|
|
void DexCompiler::Compile() {
|
|
DCHECK_GE(dex_to_dex_compilation_level_, DexToDexCompilationLevel::kRequired);
|
|
const DexFile::CodeItem* code_item = unit_.GetCodeItem();
|
|
const uint16_t* insns = code_item->insns_;
|
|
const uint32_t insns_size = code_item->insns_size_in_code_units_;
|
|
Instruction* inst = const_cast<Instruction*>(Instruction::At(insns));
|
|
|
|
for (uint32_t dex_pc = 0; dex_pc < insns_size;
|
|
inst = const_cast<Instruction*>(inst->Next()), dex_pc = inst->GetDexPc(insns)) {
|
|
switch (inst->Opcode()) {
|
|
case Instruction::RETURN_VOID:
|
|
CompileReturnVoid(inst, dex_pc);
|
|
break;
|
|
|
|
case Instruction::CHECK_CAST:
|
|
inst = CompileCheckCast(inst, dex_pc);
|
|
break;
|
|
|
|
case Instruction::IGET:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_QUICK, false);
|
|
break;
|
|
|
|
case Instruction::IGET_WIDE:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_WIDE_QUICK, false);
|
|
break;
|
|
|
|
case Instruction::IGET_OBJECT:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_OBJECT_QUICK, false);
|
|
break;
|
|
|
|
case Instruction::IGET_BOOLEAN:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_BOOLEAN_QUICK, false);
|
|
break;
|
|
|
|
case Instruction::IGET_BYTE:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_BYTE_QUICK, false);
|
|
break;
|
|
|
|
case Instruction::IGET_CHAR:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_CHAR_QUICK, false);
|
|
break;
|
|
|
|
case Instruction::IGET_SHORT:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IGET_SHORT_QUICK, false);
|
|
break;
|
|
|
|
case Instruction::IPUT:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_QUICK, true);
|
|
break;
|
|
|
|
case Instruction::IPUT_BOOLEAN:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_BOOLEAN_QUICK, true);
|
|
break;
|
|
|
|
case Instruction::IPUT_BYTE:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_BYTE_QUICK, true);
|
|
break;
|
|
|
|
case Instruction::IPUT_CHAR:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_CHAR_QUICK, true);
|
|
break;
|
|
|
|
case Instruction::IPUT_SHORT:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_SHORT_QUICK, true);
|
|
break;
|
|
|
|
case Instruction::IPUT_WIDE:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_WIDE_QUICK, true);
|
|
break;
|
|
|
|
case Instruction::IPUT_OBJECT:
|
|
CompileInstanceFieldAccess(inst, dex_pc, Instruction::IPUT_OBJECT_QUICK, true);
|
|
break;
|
|
|
|
case Instruction::INVOKE_VIRTUAL:
|
|
CompileInvokeVirtual(inst, dex_pc, Instruction::INVOKE_VIRTUAL_QUICK, false);
|
|
break;
|
|
|
|
case Instruction::INVOKE_VIRTUAL_RANGE:
|
|
CompileInvokeVirtual(inst, dex_pc, Instruction::INVOKE_VIRTUAL_RANGE_QUICK, true);
|
|
break;
|
|
|
|
default:
|
|
// Nothing to do.
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void DexCompiler::CompileReturnVoid(Instruction* inst, uint32_t dex_pc) {
|
|
DCHECK_EQ(inst->Opcode(), Instruction::RETURN_VOID);
|
|
if (unit_.IsConstructor()) {
|
|
// Are we compiling a non clinit constructor which needs a barrier ?
|
|
if (!unit_.IsStatic() &&
|
|
driver_.RequiresConstructorBarrier(Thread::Current(), unit_.GetDexFile(),
|
|
unit_.GetClassDefIndex())) {
|
|
return;
|
|
}
|
|
}
|
|
// Replace RETURN_VOID by RETURN_VOID_NO_BARRIER.
|
|
VLOG(compiler) << "Replacing " << Instruction::Name(inst->Opcode())
|
|
<< " by " << Instruction::Name(Instruction::RETURN_VOID_NO_BARRIER)
|
|
<< " at dex pc " << StringPrintf("0x%x", dex_pc) << " in method "
|
|
<< PrettyMethod(unit_.GetDexMethodIndex(), GetDexFile(), true);
|
|
inst->SetOpcode(Instruction::RETURN_VOID_NO_BARRIER);
|
|
}
|
|
|
|
Instruction* DexCompiler::CompileCheckCast(Instruction* inst, uint32_t dex_pc) {
|
|
if (!kEnableCheckCastEllision || !PerformOptimizations()) {
|
|
return inst;
|
|
}
|
|
if (!driver_.IsSafeCast(&unit_, dex_pc)) {
|
|
return inst;
|
|
}
|
|
// Ok, this is a safe cast. Since the "check-cast" instruction size is 2 code
|
|
// units and a "nop" instruction size is 1 code unit, we need to replace it by
|
|
// 2 consecutive NOP instructions.
|
|
// Because the caller loops over instructions by calling Instruction::Next onto
|
|
// the current instruction, we need to return the 2nd NOP instruction. Indeed,
|
|
// its next instruction is the former check-cast's next instruction.
|
|
VLOG(compiler) << "Removing " << Instruction::Name(inst->Opcode())
|
|
<< " by replacing it with 2 NOPs at dex pc "
|
|
<< StringPrintf("0x%x", dex_pc) << " in method "
|
|
<< PrettyMethod(unit_.GetDexMethodIndex(), GetDexFile(), true);
|
|
// We are modifying 4 consecutive bytes.
|
|
inst->SetOpcode(Instruction::NOP);
|
|
inst->SetVRegA_10x(0u); // keep compliant with verifier.
|
|
// Get to next instruction which is the second half of check-cast and replace
|
|
// it by a NOP.
|
|
inst = const_cast<Instruction*>(inst->Next());
|
|
inst->SetOpcode(Instruction::NOP);
|
|
inst->SetVRegA_10x(0u); // keep compliant with verifier.
|
|
return inst;
|
|
}
|
|
|
|
void DexCompiler::CompileInstanceFieldAccess(Instruction* inst,
|
|
uint32_t dex_pc,
|
|
Instruction::Code new_opcode,
|
|
bool is_put) {
|
|
if (!kEnableQuickening || !PerformOptimizations()) {
|
|
return;
|
|
}
|
|
uint32_t field_idx = inst->VRegC_22c();
|
|
MemberOffset field_offset(0u);
|
|
bool is_volatile;
|
|
bool fast_path = driver_.ComputeInstanceFieldInfo(field_idx, &unit_, is_put,
|
|
&field_offset, &is_volatile);
|
|
if (fast_path && !is_volatile && IsUint<16>(field_offset.Int32Value())) {
|
|
VLOG(compiler) << "Quickening " << Instruction::Name(inst->Opcode())
|
|
<< " to " << Instruction::Name(new_opcode)
|
|
<< " by replacing field index " << field_idx
|
|
<< " by field offset " << field_offset.Int32Value()
|
|
<< " at dex pc " << StringPrintf("0x%x", dex_pc) << " in method "
|
|
<< PrettyMethod(unit_.GetDexMethodIndex(), GetDexFile(), true);
|
|
// We are modifying 4 consecutive bytes.
|
|
inst->SetOpcode(new_opcode);
|
|
// Replace field index by field offset.
|
|
inst->SetVRegC_22c(static_cast<uint16_t>(field_offset.Int32Value()));
|
|
quickened_info_.push_back(QuickenedInfo(dex_pc, field_idx));
|
|
}
|
|
}
|
|
|
|
void DexCompiler::CompileInvokeVirtual(Instruction* inst, uint32_t dex_pc,
|
|
Instruction::Code new_opcode, bool is_range) {
|
|
if (!kEnableQuickening || !PerformOptimizations()) {
|
|
return;
|
|
}
|
|
uint32_t method_idx = is_range ? inst->VRegB_3rc() : inst->VRegB_35c();
|
|
MethodReference target_method(&GetDexFile(), method_idx);
|
|
InvokeType invoke_type = kVirtual;
|
|
InvokeType original_invoke_type = invoke_type;
|
|
int vtable_idx;
|
|
uintptr_t direct_code;
|
|
uintptr_t direct_method;
|
|
// TODO: support devirtualization.
|
|
const bool kEnableDevirtualization = false;
|
|
bool fast_path = driver_.ComputeInvokeInfo(&unit_, dex_pc,
|
|
false, kEnableDevirtualization,
|
|
&invoke_type,
|
|
&target_method, &vtable_idx,
|
|
&direct_code, &direct_method);
|
|
if (fast_path && original_invoke_type == invoke_type) {
|
|
if (vtable_idx >= 0 && IsUint<16>(vtable_idx)) {
|
|
VLOG(compiler) << "Quickening " << Instruction::Name(inst->Opcode())
|
|
<< "(" << PrettyMethod(method_idx, GetDexFile(), true) << ")"
|
|
<< " to " << Instruction::Name(new_opcode)
|
|
<< " by replacing method index " << method_idx
|
|
<< " by vtable index " << vtable_idx
|
|
<< " at dex pc " << StringPrintf("0x%x", dex_pc) << " in method "
|
|
<< PrettyMethod(unit_.GetDexMethodIndex(), GetDexFile(), true);
|
|
// We are modifying 4 consecutive bytes.
|
|
inst->SetOpcode(new_opcode);
|
|
// Replace method index by vtable index.
|
|
if (is_range) {
|
|
inst->SetVRegB_3rc(static_cast<uint16_t>(vtable_idx));
|
|
} else {
|
|
inst->SetVRegB_35c(static_cast<uint16_t>(vtable_idx));
|
|
}
|
|
quickened_info_.push_back(QuickenedInfo(dex_pc, method_idx));
|
|
}
|
|
}
|
|
}
|
|
|
|
CompiledMethod* 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) {
|
|
DCHECK(driver != nullptr);
|
|
if (dex_to_dex_compilation_level != DexToDexCompilationLevel::kDontDexToDexCompile) {
|
|
ScopedObjectAccess soa(Thread::Current());
|
|
StackHandleScope<1> hs(soa.Self());
|
|
ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
|
|
art::DexCompilationUnit unit(
|
|
class_loader,
|
|
class_linker,
|
|
dex_file,
|
|
code_item,
|
|
class_def_idx,
|
|
method_idx,
|
|
access_flags,
|
|
driver->GetVerifiedMethod(&dex_file, method_idx),
|
|
hs.NewHandle(class_linker->FindDexCache(soa.Self(), dex_file)));
|
|
art::optimizer::DexCompiler dex_compiler(*driver, unit, dex_to_dex_compilation_level);
|
|
dex_compiler.Compile();
|
|
if (dex_compiler.GetQuickenedInfo().empty()) {
|
|
// No need to create a CompiledMethod if there are no quickened opcodes.
|
|
return nullptr;
|
|
}
|
|
|
|
// Create a `CompiledMethod`, with the quickened information in the vmap table.
|
|
Leb128EncodingVector<> builder;
|
|
for (QuickenedInfo info : dex_compiler.GetQuickenedInfo()) {
|
|
builder.PushBackUnsigned(info.dex_pc);
|
|
builder.PushBackUnsigned(info.dex_member_index);
|
|
}
|
|
InstructionSet instruction_set = driver->GetInstructionSet();
|
|
if (instruction_set == kThumb2) {
|
|
// Don't use the thumb2 instruction set to avoid the one off code delta.
|
|
instruction_set = kArm;
|
|
}
|
|
return CompiledMethod::SwapAllocCompiledMethod(
|
|
driver,
|
|
instruction_set,
|
|
ArrayRef<const uint8_t>(), // no code
|
|
0,
|
|
0,
|
|
0,
|
|
ArrayRef<const SrcMapElem>(), // src_mapping_table
|
|
ArrayRef<const uint8_t>(builder.GetData()), // vmap_table
|
|
ArrayRef<const uint8_t>(), // cfi data
|
|
ArrayRef<const LinkerPatch>());
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
} // namespace optimizer
|
|
|
|
} // namespace art
|