blob: 4694777b0dd9f7d93e773bc3b561a07857ba14ea [file] [log] [blame]
/*
* Copyright (C) 2012 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 "method_compiler.h"
#include "backend_types.h"
#include "compilation_unit.h"
#include "compiler.h"
#include "inferred_reg_category_map.h"
#include "ir_builder.h"
#include "logging.h"
#include "oat_compilation_unit.h"
#include "object.h"
#include "object_utils.h"
#include "runtime_support_func.h"
#include "stl_util.h"
#include "stringprintf.h"
#include "utils_llvm.h"
#include <iomanip>
#include <llvm/Analysis/Verifier.h>
#include <llvm/BasicBlock.h>
#include <llvm/Function.h>
#include <llvm/GlobalVariable.h>
#include <llvm/Intrinsics.h>
namespace art {
namespace compiler_llvm {
using namespace runtime_support;
MethodCompiler::MethodCompiler(CompilationUnit* cunit,
Compiler* compiler,
OatCompilationUnit* oat_compilation_unit)
: cunit_(cunit), compiler_(compiler),
class_linker_(oat_compilation_unit->class_linker_),
class_loader_(oat_compilation_unit->class_loader_),
dex_file_(oat_compilation_unit->dex_file_),
dex_cache_(oat_compilation_unit->dex_cache_),
code_item_(oat_compilation_unit->code_item_),
oat_compilation_unit_(oat_compilation_unit),
method_(dex_cache_->GetResolvedMethod(oat_compilation_unit->method_idx_)),
method_helper_(method_),
method_idx_(oat_compilation_unit->method_idx_),
access_flags_(oat_compilation_unit->access_flags_),
module_(cunit->GetModule()),
context_(cunit->GetLLVMContext()),
irb_(*cunit->GetIRBuilder()), func_(NULL), retval_reg_(NULL),
basic_block_reg_alloca_(NULL), basic_block_shadow_frame_alloca_(NULL),
basic_block_reg_zero_init_(NULL), basic_block_reg_arg_init_(NULL),
basic_blocks_(code_item_->insns_size_in_code_units_),
basic_block_landing_pads_(code_item_->tries_size_, NULL),
basic_block_unwind_(NULL), basic_block_unreachable_(NULL),
shadow_frame_(NULL) {
}
MethodCompiler::~MethodCompiler() {
STLDeleteElements(&regs_);
}
void MethodCompiler::CreateFunction() {
// LLVM function name
std::string func_name(LLVMLongName(method_));
// Get function type
llvm::FunctionType* func_type =
GetFunctionType(method_idx_, method_->IsStatic());
// Create function
func_ = llvm::Function::Create(func_type, llvm::Function::ExternalLinkage,
func_name, module_);
// Set argument name
llvm::Function::arg_iterator arg_iter(func_->arg_begin());
llvm::Function::arg_iterator arg_end(func_->arg_end());
DCHECK_NE(arg_iter, arg_end);
arg_iter->setName("method");
++arg_iter;
if (!method_->IsStatic()) {
DCHECK_NE(arg_iter, arg_end);
arg_iter->setName("this");
++arg_iter;
}
for (unsigned i = 0; arg_iter != arg_end; ++i, ++arg_iter) {
arg_iter->setName(StringPrintf("a%u", i));
}
}
llvm::FunctionType* MethodCompiler::GetFunctionType(uint32_t method_idx,
bool is_static) {
// Get method signature
DexFile::MethodId const& method_id = dex_file_->GetMethodId(method_idx);
uint32_t shorty_size;
char const* shorty = dex_file_->GetMethodShorty(method_id, &shorty_size);
CHECK_GE(shorty_size, 1u);
// Get return type
llvm::Type* ret_type = irb_.getJType(shorty[0], kAccurate);
// Get argument type
std::vector<llvm::Type*> args_type;
args_type.push_back(irb_.getJObjectTy()); // method object pointer
if (!is_static) {
args_type.push_back(irb_.getJType('L', kAccurate)); // "this" object pointer
}
for (uint32_t i = 1; i < shorty_size; ++i) {
args_type.push_back(irb_.getJType(shorty[i], kAccurate));
}
return llvm::FunctionType::get(ret_type, args_type, false);
}
void MethodCompiler::EmitPrologue() {
// Create basic blocks for prologue
basic_block_reg_alloca_ =
llvm::BasicBlock::Create(*context_, "prologue.alloca", func_);
basic_block_shadow_frame_alloca_ =
llvm::BasicBlock::Create(*context_, "prologue.shadowframe", func_);
basic_block_reg_zero_init_ =
llvm::BasicBlock::Create(*context_, "prologue.zeroinit", func_);
basic_block_reg_arg_init_ =
llvm::BasicBlock::Create(*context_, "prologue.arginit", func_);
// Create register array
for (uint16_t r = 0; r < code_item_->registers_size_; ++r) {
regs_.push_back(DalvikReg::CreateLocalVarReg(*this, r));
}
retval_reg_.reset(DalvikReg::CreateRetValReg(*this));
// Create Shadow Frame
EmitPrologueAllocShadowFrame();
// Store argument to dalvik register
irb_.SetInsertPoint(basic_block_reg_arg_init_);
EmitPrologueAssignArgRegister();
// Branch to start address
irb_.CreateBr(GetBasicBlock(0));
}
void MethodCompiler::EmitPrologueLastBranch() {
irb_.SetInsertPoint(basic_block_reg_alloca_);
irb_.CreateBr(basic_block_shadow_frame_alloca_);
irb_.SetInsertPoint(basic_block_shadow_frame_alloca_);
irb_.CreateBr(basic_block_reg_zero_init_);
irb_.SetInsertPoint(basic_block_reg_zero_init_);
irb_.CreateBr(basic_block_reg_arg_init_);
}
void MethodCompiler::EmitPrologueAllocShadowFrame() {
irb_.SetInsertPoint(basic_block_shadow_frame_alloca_);
// Allocate the shadow frame now!
uint32_t sirt_size = code_item_->registers_size_;
// TODO: registers_size_ is a bad approximation. Compute a
// tighter approximation at Dex verifier while performing data-flow
// analysis.
llvm::StructType* shadow_frame_type = irb_.getShadowFrameTy(sirt_size);
shadow_frame_ = irb_.CreateAlloca(shadow_frame_type);
// Zero-initialization of the shadow frame
llvm::ConstantAggregateZero* zero_initializer =
llvm::ConstantAggregateZero::get(shadow_frame_type);
irb_.CreateStore(zero_initializer, shadow_frame_);
// Variables for GetElementPtr
llvm::Constant* zero = irb_.getInt32(0);
llvm::Value* gep_index[] = {
zero, // No displacement for shadow frame pointer
zero, // Get the %ArtFrame data structure
NULL,
};
// Store the method pointer
gep_index[2] = irb_.getInt32(1);
llvm::Value* method_field_addr = irb_.CreateGEP(shadow_frame_, gep_index);
llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
irb_.CreateStore(method_object_addr, method_field_addr);
// Store the number of the pointer slots
gep_index[2] = irb_.getInt32(3);
llvm::Value* size_field_addr = irb_.CreateGEP(shadow_frame_, gep_index);
llvm::ConstantInt* sirt_size_value = irb_.getInt32(sirt_size);
irb_.CreateStore(sirt_size_value, size_field_addr);
// Push the shadow frame
llvm::Value* shadow_frame_upcast =
irb_.CreateConstGEP2_32(shadow_frame_, 0, 0);
irb_.CreateCall(irb_.GetRuntime(PushShadowFrame), shadow_frame_upcast);
}
void MethodCompiler::EmitPrologueAssignArgRegister() {
uint16_t arg_reg = code_item_->registers_size_ - code_item_->ins_size_;
llvm::Function::arg_iterator arg_iter(func_->arg_begin());
llvm::Function::arg_iterator arg_end(func_->arg_end());
char const* shorty = method_helper_.GetShorty();
int32_t shorty_size = method_helper_.GetShortyLength();
CHECK_LE(1, shorty_size);
++arg_iter; // skip method object
if (!method_->IsStatic()) {
EmitStoreDalvikReg(arg_reg, kObject, kAccurate, arg_iter);
++arg_iter;
++arg_reg;
}
for (int32_t i = 1; i < shorty_size; ++i, ++arg_iter) {
EmitStoreDalvikReg(arg_reg, shorty[i], kAccurate, arg_iter);
++arg_reg;
if (shorty[i] == 'J' || shorty[i] == 'D') {
// Wide types, such as long and double, are using a pair of registers
// to store the value, so we have to increase arg_reg again.
++arg_reg;
}
}
DCHECK_EQ(arg_end, arg_iter);
}
void MethodCompiler::EmitInstructions() {
uint32_t dex_pc = 0;
while (dex_pc < code_item_->insns_size_in_code_units_) {
Instruction const* insn = Instruction::At(code_item_->insns_ + dex_pc);
EmitInstruction(dex_pc, insn);
dex_pc += insn->SizeInCodeUnits();
}
}
void MethodCompiler::EmitInstruction(uint32_t dex_pc,
Instruction const* insn) {
// Set the IRBuilder insertion point
irb_.SetInsertPoint(GetBasicBlock(dex_pc));
#define ARGS dex_pc, insn
// Dispatch the instruction
switch (insn->Opcode()) {
case Instruction::NOP:
EmitInsn_Nop(ARGS);
break;
case Instruction::MOVE:
case Instruction::MOVE_FROM16:
case Instruction::MOVE_16:
EmitInsn_Move(ARGS, kInt);
break;
case Instruction::MOVE_WIDE:
case Instruction::MOVE_WIDE_FROM16:
case Instruction::MOVE_WIDE_16:
EmitInsn_Move(ARGS, kLong);
break;
case Instruction::MOVE_OBJECT:
case Instruction::MOVE_OBJECT_FROM16:
case Instruction::MOVE_OBJECT_16:
EmitInsn_Move(ARGS, kObject);
break;
case Instruction::MOVE_RESULT:
EmitInsn_MoveResult(ARGS, kInt);
break;
case Instruction::MOVE_RESULT_WIDE:
EmitInsn_MoveResult(ARGS, kLong);
break;
case Instruction::MOVE_RESULT_OBJECT:
EmitInsn_MoveResult(ARGS, kObject);
break;
case Instruction::MOVE_EXCEPTION:
EmitInsn_MoveException(ARGS);
break;
case Instruction::RETURN_VOID:
EmitInsn_ReturnVoid(ARGS);
break;
case Instruction::RETURN:
case Instruction::RETURN_WIDE:
case Instruction::RETURN_OBJECT:
EmitInsn_Return(ARGS);
break;
case Instruction::CONST_4:
case Instruction::CONST_16:
case Instruction::CONST:
case Instruction::CONST_HIGH16:
EmitInsn_LoadConstant(ARGS, kInt);
break;
case Instruction::CONST_WIDE_16:
case Instruction::CONST_WIDE_32:
case Instruction::CONST_WIDE:
case Instruction::CONST_WIDE_HIGH16:
EmitInsn_LoadConstant(ARGS, kLong);
break;
case Instruction::CONST_STRING:
case Instruction::CONST_STRING_JUMBO:
EmitInsn_LoadConstantString(ARGS);
break;
case Instruction::CONST_CLASS:
EmitInsn_LoadConstantClass(ARGS);
break;
case Instruction::MONITOR_ENTER:
EmitInsn_MonitorEnter(ARGS);
break;
case Instruction::MONITOR_EXIT:
EmitInsn_MonitorExit(ARGS);
break;
case Instruction::CHECK_CAST:
EmitInsn_CheckCast(ARGS);
break;
case Instruction::INSTANCE_OF:
EmitInsn_InstanceOf(ARGS);
break;
case Instruction::ARRAY_LENGTH:
EmitInsn_ArrayLength(ARGS);
break;
case Instruction::NEW_INSTANCE:
EmitInsn_NewInstance(ARGS);
break;
case Instruction::NEW_ARRAY:
EmitInsn_NewArray(ARGS);
break;
case Instruction::FILLED_NEW_ARRAY:
EmitInsn_FilledNewArray(ARGS, false);
break;
case Instruction::FILLED_NEW_ARRAY_RANGE:
EmitInsn_FilledNewArray(ARGS, true);
break;
case Instruction::FILL_ARRAY_DATA:
EmitInsn_FillArrayData(ARGS);
break;
case Instruction::THROW:
EmitInsn_ThrowException(ARGS);
break;
case Instruction::GOTO:
case Instruction::GOTO_16:
case Instruction::GOTO_32:
EmitInsn_UnconditionalBranch(ARGS);
break;
case Instruction::PACKED_SWITCH:
EmitInsn_PackedSwitch(ARGS);
break;
case Instruction::SPARSE_SWITCH:
EmitInsn_SparseSwitch(ARGS);
break;
case Instruction::CMPL_FLOAT:
EmitInsn_FPCompare(ARGS, kFloat, false);
break;
case Instruction::CMPG_FLOAT:
EmitInsn_FPCompare(ARGS, kFloat, true);
break;
case Instruction::CMPL_DOUBLE:
EmitInsn_FPCompare(ARGS, kDouble, false);
break;
case Instruction::CMPG_DOUBLE:
EmitInsn_FPCompare(ARGS, kDouble, true);
break;
case Instruction::CMP_LONG:
EmitInsn_LongCompare(ARGS);
break;
case Instruction::IF_EQ:
EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_EQ);
break;
case Instruction::IF_NE:
EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_NE);
break;
case Instruction::IF_LT:
EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_LT);
break;
case Instruction::IF_GE:
EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_GE);
break;
case Instruction::IF_GT:
EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_GT);
break;
case Instruction::IF_LE:
EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_LE);
break;
case Instruction::IF_EQZ:
EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_EQ);
break;
case Instruction::IF_NEZ:
EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_NE);
break;
case Instruction::IF_LTZ:
EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_LT);
break;
case Instruction::IF_GEZ:
EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_GE);
break;
case Instruction::IF_GTZ:
EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_GT);
break;
case Instruction::IF_LEZ:
EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_LE);
break;
case Instruction::AGET:
EmitInsn_AGet(ARGS, kInt);
break;
case Instruction::AGET_WIDE:
EmitInsn_AGet(ARGS, kLong);
break;
case Instruction::AGET_OBJECT:
EmitInsn_AGet(ARGS, kObject);
break;
case Instruction::AGET_BOOLEAN:
EmitInsn_AGet(ARGS, kBoolean);
break;
case Instruction::AGET_BYTE:
EmitInsn_AGet(ARGS, kByte);
break;
case Instruction::AGET_CHAR:
EmitInsn_AGet(ARGS, kChar);
break;
case Instruction::AGET_SHORT:
EmitInsn_AGet(ARGS, kShort);
break;
case Instruction::APUT:
EmitInsn_APut(ARGS, kInt);
break;
case Instruction::APUT_WIDE:
EmitInsn_APut(ARGS, kLong);
break;
case Instruction::APUT_OBJECT:
EmitInsn_APut(ARGS, kObject);
break;
case Instruction::APUT_BOOLEAN:
EmitInsn_APut(ARGS, kBoolean);
break;
case Instruction::APUT_BYTE:
EmitInsn_APut(ARGS, kByte);
break;
case Instruction::APUT_CHAR:
EmitInsn_APut(ARGS, kChar);
break;
case Instruction::APUT_SHORT:
EmitInsn_APut(ARGS, kShort);
break;
case Instruction::IGET:
EmitInsn_IGet(ARGS, kInt);
break;
case Instruction::IGET_WIDE:
EmitInsn_IGet(ARGS, kLong);
break;
case Instruction::IGET_OBJECT:
EmitInsn_IGet(ARGS, kObject);
break;
case Instruction::IGET_BOOLEAN:
EmitInsn_IGet(ARGS, kBoolean);
break;
case Instruction::IGET_BYTE:
EmitInsn_IGet(ARGS, kByte);
break;
case Instruction::IGET_CHAR:
EmitInsn_IGet(ARGS, kChar);
break;
case Instruction::IGET_SHORT:
EmitInsn_IGet(ARGS, kShort);
break;
case Instruction::IPUT:
EmitInsn_IPut(ARGS, kInt);
break;
case Instruction::IPUT_WIDE:
EmitInsn_IPut(ARGS, kLong);
break;
case Instruction::IPUT_OBJECT:
EmitInsn_IPut(ARGS, kObject);
break;
case Instruction::IPUT_BOOLEAN:
EmitInsn_IPut(ARGS, kBoolean);
break;
case Instruction::IPUT_BYTE:
EmitInsn_IPut(ARGS, kByte);
break;
case Instruction::IPUT_CHAR:
EmitInsn_IPut(ARGS, kChar);
break;
case Instruction::IPUT_SHORT:
EmitInsn_IPut(ARGS, kShort);
break;
case Instruction::SGET:
EmitInsn_SGet(ARGS, kInt);
break;
case Instruction::SGET_WIDE:
EmitInsn_SGet(ARGS, kLong);
break;
case Instruction::SGET_OBJECT:
EmitInsn_SGet(ARGS, kObject);
break;
case Instruction::SGET_BOOLEAN:
EmitInsn_SGet(ARGS, kBoolean);
break;
case Instruction::SGET_BYTE:
EmitInsn_SGet(ARGS, kByte);
break;
case Instruction::SGET_CHAR:
EmitInsn_SGet(ARGS, kChar);
break;
case Instruction::SGET_SHORT:
EmitInsn_SGet(ARGS, kShort);
break;
case Instruction::SPUT:
EmitInsn_SPut(ARGS, kInt);
break;
case Instruction::SPUT_WIDE:
EmitInsn_SPut(ARGS, kLong);
break;
case Instruction::SPUT_OBJECT:
EmitInsn_SPut(ARGS, kObject);
break;
case Instruction::SPUT_BOOLEAN:
EmitInsn_SPut(ARGS, kBoolean);
break;
case Instruction::SPUT_BYTE:
EmitInsn_SPut(ARGS, kByte);
break;
case Instruction::SPUT_CHAR:
EmitInsn_SPut(ARGS, kChar);
break;
case Instruction::SPUT_SHORT:
EmitInsn_SPut(ARGS, kShort);
break;
case Instruction::INVOKE_VIRTUAL:
EmitInsn_InvokeVirtual(ARGS, false);
break;
case Instruction::INVOKE_SUPER:
EmitInsn_InvokeSuper(ARGS, false);
break;
case Instruction::INVOKE_DIRECT:
EmitInsn_InvokeStaticDirect(ARGS, kDirect, /* is_range */ false);
break;
case Instruction::INVOKE_STATIC:
EmitInsn_InvokeStaticDirect(ARGS, kStatic, /* is_range */ false);
break;
case Instruction::INVOKE_INTERFACE:
EmitInsn_InvokeInterface(ARGS, false);
break;
case Instruction::INVOKE_VIRTUAL_RANGE:
EmitInsn_InvokeVirtual(ARGS, true);
break;
case Instruction::INVOKE_SUPER_RANGE:
EmitInsn_InvokeSuper(ARGS, true);
break;
case Instruction::INVOKE_DIRECT_RANGE:
EmitInsn_InvokeStaticDirect(ARGS, kDirect, true);
break;
case Instruction::INVOKE_STATIC_RANGE:
EmitInsn_InvokeStaticDirect(ARGS, kStatic, true);
break;
case Instruction::INVOKE_INTERFACE_RANGE:
EmitInsn_InvokeInterface(ARGS, true);
break;
case Instruction::NEG_INT:
EmitInsn_Neg(ARGS, kInt);
break;
case Instruction::NOT_INT:
EmitInsn_Not(ARGS, kInt);
break;
case Instruction::NEG_LONG:
EmitInsn_Neg(ARGS, kLong);
break;
case Instruction::NOT_LONG:
EmitInsn_Not(ARGS, kLong);
break;
case Instruction::NEG_FLOAT:
EmitInsn_FNeg(ARGS, kFloat);
break;
case Instruction::NEG_DOUBLE:
EmitInsn_FNeg(ARGS, kDouble);
break;
case Instruction::INT_TO_LONG:
EmitInsn_SExt(ARGS);
break;
case Instruction::INT_TO_FLOAT:
EmitInsn_IntToFP(ARGS, kInt, kFloat);
break;
case Instruction::INT_TO_DOUBLE:
EmitInsn_IntToFP(ARGS, kInt, kDouble);
break;
case Instruction::LONG_TO_INT:
EmitInsn_Trunc(ARGS);
break;
case Instruction::LONG_TO_FLOAT:
EmitInsn_IntToFP(ARGS, kLong, kFloat);
break;
case Instruction::LONG_TO_DOUBLE:
EmitInsn_IntToFP(ARGS, kLong, kDouble);
break;
case Instruction::FLOAT_TO_INT:
EmitInsn_FPToInt(ARGS, kFloat, kInt);
break;
case Instruction::FLOAT_TO_LONG:
EmitInsn_FPToInt(ARGS, kFloat, kLong);
break;
case Instruction::FLOAT_TO_DOUBLE:
EmitInsn_FExt(ARGS);
break;
case Instruction::DOUBLE_TO_INT:
EmitInsn_FPToInt(ARGS, kDouble, kInt);
break;
case Instruction::DOUBLE_TO_LONG:
EmitInsn_FPToInt(ARGS, kDouble, kLong);
break;
case Instruction::DOUBLE_TO_FLOAT:
EmitInsn_FTrunc(ARGS);
break;
case Instruction::INT_TO_BYTE:
EmitInsn_TruncAndSExt(ARGS, 8);
break;
case Instruction::INT_TO_CHAR:
EmitInsn_TruncAndZExt(ARGS, 16);
break;
case Instruction::INT_TO_SHORT:
EmitInsn_TruncAndSExt(ARGS, 16);
break;
case Instruction::ADD_INT:
EmitInsn_IntArithm(ARGS, kIntArithm_Add, kInt, false);
break;
case Instruction::SUB_INT:
EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kInt, false);
break;
case Instruction::MUL_INT:
EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kInt, false);
break;
case Instruction::DIV_INT:
EmitInsn_IntArithm(ARGS, kIntArithm_Div, kInt, false);
break;
case Instruction::REM_INT:
EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kInt, false);
break;
case Instruction::AND_INT:
EmitInsn_IntArithm(ARGS, kIntArithm_And, kInt, false);
break;
case Instruction::OR_INT:
EmitInsn_IntArithm(ARGS, kIntArithm_Or, kInt, false);
break;
case Instruction::XOR_INT:
EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kInt, false);
break;
case Instruction::SHL_INT:
EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kInt, false);
break;
case Instruction::SHR_INT:
EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kInt, false);
break;
case Instruction::USHR_INT:
EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kInt, false);
break;
case Instruction::ADD_LONG:
EmitInsn_IntArithm(ARGS, kIntArithm_Add, kLong, false);
break;
case Instruction::SUB_LONG:
EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kLong, false);
break;
case Instruction::MUL_LONG:
EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kLong, false);
break;
case Instruction::DIV_LONG:
EmitInsn_IntArithm(ARGS, kIntArithm_Div, kLong, false);
break;
case Instruction::REM_LONG:
EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kLong, false);
break;
case Instruction::AND_LONG:
EmitInsn_IntArithm(ARGS, kIntArithm_And, kLong, false);
break;
case Instruction::OR_LONG:
EmitInsn_IntArithm(ARGS, kIntArithm_Or, kLong, false);
break;
case Instruction::XOR_LONG:
EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kLong, false);
break;
case Instruction::SHL_LONG:
EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kLong, false);
break;
case Instruction::SHR_LONG:
EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kLong, false);
break;
case Instruction::USHR_LONG:
EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kLong, false);
break;
case Instruction::ADD_FLOAT:
EmitInsn_FPArithm(ARGS, kFPArithm_Add, kFloat, false);
break;
case Instruction::SUB_FLOAT:
EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kFloat, false);
break;
case Instruction::MUL_FLOAT:
EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kFloat, false);
break;
case Instruction::DIV_FLOAT:
EmitInsn_FPArithm(ARGS, kFPArithm_Div, kFloat, false);
break;
case Instruction::REM_FLOAT:
EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kFloat, false);
break;
case Instruction::ADD_DOUBLE:
EmitInsn_FPArithm(ARGS, kFPArithm_Add, kDouble, false);
break;
case Instruction::SUB_DOUBLE:
EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kDouble, false);
break;
case Instruction::MUL_DOUBLE:
EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kDouble, false);
break;
case Instruction::DIV_DOUBLE:
EmitInsn_FPArithm(ARGS, kFPArithm_Div, kDouble, false);
break;
case Instruction::REM_DOUBLE:
EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kDouble, false);
break;
case Instruction::ADD_INT_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Add, kInt, true);
break;
case Instruction::SUB_INT_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kInt, true);
break;
case Instruction::MUL_INT_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kInt, true);
break;
case Instruction::DIV_INT_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Div, kInt, true);
break;
case Instruction::REM_INT_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kInt, true);
break;
case Instruction::AND_INT_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_And, kInt, true);
break;
case Instruction::OR_INT_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Or, kInt, true);
break;
case Instruction::XOR_INT_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kInt, true);
break;
case Instruction::SHL_INT_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kInt, true);
break;
case Instruction::SHR_INT_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kInt, true);
break;
case Instruction::USHR_INT_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kInt, true);
break;
case Instruction::ADD_LONG_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Add, kLong, true);
break;
case Instruction::SUB_LONG_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kLong, true);
break;
case Instruction::MUL_LONG_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kLong, true);
break;
case Instruction::DIV_LONG_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Div, kLong, true);
break;
case Instruction::REM_LONG_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kLong, true);
break;
case Instruction::AND_LONG_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_And, kLong, true);
break;
case Instruction::OR_LONG_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Or, kLong, true);
break;
case Instruction::XOR_LONG_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kLong, true);
break;
case Instruction::SHL_LONG_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kLong, true);
break;
case Instruction::SHR_LONG_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kLong, true);
break;
case Instruction::USHR_LONG_2ADDR:
EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kLong, true);
break;
case Instruction::ADD_FLOAT_2ADDR:
EmitInsn_FPArithm(ARGS, kFPArithm_Add, kFloat, true);
break;
case Instruction::SUB_FLOAT_2ADDR:
EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kFloat, true);
break;
case Instruction::MUL_FLOAT_2ADDR:
EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kFloat, true);
break;
case Instruction::DIV_FLOAT_2ADDR:
EmitInsn_FPArithm(ARGS, kFPArithm_Div, kFloat, true);
break;
case Instruction::REM_FLOAT_2ADDR:
EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kFloat, true);
break;
case Instruction::ADD_DOUBLE_2ADDR:
EmitInsn_FPArithm(ARGS, kFPArithm_Add, kDouble, true);
break;
case Instruction::SUB_DOUBLE_2ADDR:
EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kDouble, true);
break;
case Instruction::MUL_DOUBLE_2ADDR:
EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kDouble, true);
break;
case Instruction::DIV_DOUBLE_2ADDR:
EmitInsn_FPArithm(ARGS, kFPArithm_Div, kDouble, true);
break;
case Instruction::REM_DOUBLE_2ADDR:
EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kDouble, true);
break;
case Instruction::ADD_INT_LIT16:
case Instruction::ADD_INT_LIT8:
EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Add);
break;
case Instruction::RSUB_INT:
case Instruction::RSUB_INT_LIT8:
EmitInsn_RSubImmediate(ARGS);
break;
case Instruction::MUL_INT_LIT16:
case Instruction::MUL_INT_LIT8:
EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Mul);
break;
case Instruction::DIV_INT_LIT16:
case Instruction::DIV_INT_LIT8:
EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Div);
break;
case Instruction::REM_INT_LIT16:
case Instruction::REM_INT_LIT8:
EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Rem);
break;
case Instruction::AND_INT_LIT16:
case Instruction::AND_INT_LIT8:
EmitInsn_IntArithmImmediate(ARGS, kIntArithm_And);
break;
case Instruction::OR_INT_LIT16:
case Instruction::OR_INT_LIT8:
EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Or);
break;
case Instruction::XOR_INT_LIT16:
case Instruction::XOR_INT_LIT8:
EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Xor);
break;
case Instruction::SHL_INT_LIT8:
EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Shl);
break;
case Instruction::SHR_INT_LIT8:
EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Shr);
break;
case Instruction::USHR_INT_LIT8:
EmitInsn_IntArithmImmediate(ARGS, kIntArithm_UShr);
break;
case Instruction::UNUSED_3E:
case Instruction::UNUSED_3F:
case Instruction::UNUSED_40:
case Instruction::UNUSED_41:
case Instruction::UNUSED_42:
case Instruction::UNUSED_43:
case Instruction::UNUSED_73:
case Instruction::UNUSED_79:
case Instruction::UNUSED_7A:
case Instruction::UNUSED_E3:
case Instruction::UNUSED_E4:
case Instruction::UNUSED_E5:
case Instruction::UNUSED_E6:
case Instruction::UNUSED_E7:
case Instruction::UNUSED_E8:
case Instruction::UNUSED_E9:
case Instruction::UNUSED_EA:
case Instruction::UNUSED_EB:
case Instruction::UNUSED_EC:
case Instruction::THROW_VERIFICATION_ERROR:
case Instruction::UNUSED_EE:
case Instruction::UNUSED_EF:
case Instruction::UNUSED_F0:
case Instruction::UNUSED_F1:
case Instruction::UNUSED_F2:
case Instruction::UNUSED_F3:
case Instruction::UNUSED_F4:
case Instruction::UNUSED_F5:
case Instruction::UNUSED_F6:
case Instruction::UNUSED_F7:
case Instruction::UNUSED_F8:
case Instruction::UNUSED_F9:
case Instruction::UNUSED_FA:
case Instruction::UNUSED_FB:
case Instruction::UNUSED_FC:
case Instruction::UNUSED_FD:
case Instruction::UNUSED_FE:
case Instruction::UNUSED_FF:
LOG(FATAL) << "Dex file contains UNUSED bytecode: " << insn->Opcode();
break;
}
#undef ARGS
}
void MethodCompiler::EmitInsn_Nop(uint32_t dex_pc,
Instruction const* insn) {
uint16_t insn_signature = code_item_->insns_[dex_pc];
if (insn_signature == Instruction::kPackedSwitchSignature ||
insn_signature == Instruction::kSparseSwitchSignature ||
insn_signature == Instruction::kArrayDataSignature) {
irb_.CreateUnreachable();
} else{
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
}
void MethodCompiler::EmitInsn_Move(uint32_t dex_pc,
Instruction const* insn,
JType jty) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Value* src_value = EmitLoadDalvikReg(dec_insn.vB_, jty, kReg);
EmitStoreDalvikReg(dec_insn.vA_, jty, kReg, src_value);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_MoveResult(uint32_t dex_pc,
Instruction const* insn,
JType jty) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Value* src_value = EmitLoadDalvikRetValReg(jty, kReg);
EmitStoreDalvikReg(dec_insn.vA_, jty, kReg, src_value);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_MoveException(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
// Get thread-local exception field address
llvm::Constant* exception_field_offset =
irb_.getPtrEquivInt(Thread::ExceptionOffset().Int32Value());
llvm::Value* thread_object_addr =
irb_.CreateCall(irb_.GetRuntime(GetCurrentThread));
llvm::Value* exception_field_addr =
irb_.CreatePtrDisp(thread_object_addr, exception_field_offset,
irb_.getJObjectTy()->getPointerTo());
// Get exception object address
llvm::Value* exception_object_addr = irb_.CreateLoad(exception_field_addr);
// Set thread-local exception field address to NULL
irb_.CreateStore(irb_.getJNull(), exception_field_addr);
// Keep the exception object in the Dalvik register
EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, exception_object_addr);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_ThrowException(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Value* exception_addr =
EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
EmitUpdateLineNumFromDexPC(dex_pc);
irb_.CreateCall(irb_.GetRuntime(ThrowException), exception_addr);
EmitBranchExceptionLandingPad(dex_pc);
}
void MethodCompiler::EmitInsn_ReturnVoid(uint32_t dex_pc,
Instruction const* insn) {
// Garbage collection safe-point
EmitGuard_GarbageCollectionSuspend(dex_pc);
// Pop the shadow frame
EmitPopShadowFrame();
// Return!
irb_.CreateRetVoid();
}
void MethodCompiler::EmitInsn_Return(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
// Garbage collection safe-point
EmitGuard_GarbageCollectionSuspend(dex_pc);
// Pop the shadow frame
EmitPopShadowFrame();
// NOTE: It is important to keep this AFTER the GC safe-point. Otherwise,
// the return value might be collected since the shadow stack is popped.
// Return!
char ret_shorty = method_helper_.GetShorty()[0];
llvm::Value* retval = EmitLoadDalvikReg(dec_insn.vA_, ret_shorty, kAccurate);
irb_.CreateRet(retval);
}
void MethodCompiler::EmitInsn_LoadConstant(uint32_t dex_pc,
Instruction const* insn,
JType imm_jty) {
Instruction::DecodedInstruction dec_insn(insn);
DCHECK(imm_jty == kInt || imm_jty == kLong) << imm_jty;
int64_t imm = 0;
switch (insn->Opcode()) {
// 32-bit Immediate
case Instruction::CONST_4:
case Instruction::CONST_16:
case Instruction::CONST:
case Instruction::CONST_WIDE_16:
case Instruction::CONST_WIDE_32:
imm = static_cast<int64_t>(static_cast<int32_t>(dec_insn.vB_));
break;
case Instruction::CONST_HIGH16:
imm = static_cast<int64_t>(static_cast<int32_t>(
static_cast<uint32_t>(static_cast<uint16_t>(dec_insn.vB_)) << 16));
break;
// 64-bit Immediate
case Instruction::CONST_WIDE:
imm = static_cast<int64_t>(dec_insn.vB_wide_);
break;
case Instruction::CONST_WIDE_HIGH16:
imm = static_cast<int64_t>(
static_cast<uint64_t>(static_cast<uint16_t>(dec_insn.vB_)) << 48);
break;
// Unknown opcode for load constant (unreachable)
default:
LOG(FATAL) << "Unknown opcode for load constant: " << insn->Opcode();
break;
}
// Store the non-object register
llvm::Type* imm_type = irb_.getJType(imm_jty, kAccurate);
llvm::Constant* imm_value = llvm::ConstantInt::getSigned(imm_type, imm);
EmitStoreDalvikReg(dec_insn.vA_, imm_jty, kAccurate, imm_value);
// Store the object register if it is possible to be null.
if (imm_jty == kInt && imm == 0) {
EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, irb_.getJNull());
}
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_LoadConstantString(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
uint32_t string_idx = dec_insn.vB_;
llvm::Value* string_field_addr = EmitLoadDexCacheStringFieldAddr(string_idx);
llvm::Value* string_addr = irb_.CreateLoad(string_field_addr);
if (!compiler_->CanAssumeStringIsPresentInDexCache(dex_cache_, string_idx)) {
llvm::BasicBlock* block_str_exist =
CreateBasicBlockWithDexPC(dex_pc, "str_exist");
llvm::BasicBlock* block_str_resolve =
CreateBasicBlockWithDexPC(dex_pc, "str_resolve");
// Test: Is the string resolved and in the dex cache?
llvm::Value* equal_null = irb_.CreateICmpEQ(string_addr, irb_.getJNull());
irb_.CreateCondBr(equal_null, block_str_exist, block_str_resolve);
// String is resolved, go to next basic block.
irb_.SetInsertPoint(block_str_exist);
EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, string_addr);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
// String is not resolved yet, resolve it now.
irb_.SetInsertPoint(block_str_resolve);
llvm::Function* runtime_func = irb_.GetRuntime(ResolveString);
llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
llvm::Value* string_idx_value = irb_.getInt32(string_idx);
EmitUpdateLineNumFromDexPC(dex_pc);
string_addr = irb_.CreateCall2(runtime_func, method_object_addr,
string_idx_value);
EmitGuard_ExceptionLandingPad(dex_pc);
}
// Store the string object to the Dalvik register
EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, string_addr);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
llvm::Value* MethodCompiler::EmitLoadConstantClass(uint32_t dex_pc,
uint32_t type_idx) {
if (!compiler_->CanAccessTypeWithoutChecks(method_idx_, dex_cache_,
*dex_file_, type_idx)) {
llvm::Value* type_idx_value = irb_.getInt32(type_idx);
llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
llvm::Function* runtime_func =
irb_.GetRuntime(InitializeTypeAndVerifyAccess);
EmitUpdateLineNumFromDexPC(dex_pc);
llvm::Value* type_object_addr =
irb_.CreateCall2(runtime_func, type_idx_value, method_object_addr);
EmitGuard_ExceptionLandingPad(dex_pc);
return type_object_addr;
} else {
// Try to load the class (type) object from the test cache.
llvm::Value* type_field_addr =
EmitLoadDexCacheResolvedTypeFieldAddr(type_idx);
llvm::Value* type_object_addr = irb_.CreateLoad(type_field_addr);
if (compiler_->CanAssumeTypeIsPresentInDexCache(dex_cache_, type_idx)) {
return type_object_addr;
}
llvm::BasicBlock* block_original = irb_.GetInsertBlock();
// Test whether class (type) object is in the dex cache or not
llvm::Value* equal_null =
irb_.CreateICmpEQ(type_object_addr, irb_.getJNull());
llvm::BasicBlock* block_cont =
CreateBasicBlockWithDexPC(dex_pc, "cont");
llvm::BasicBlock* block_load_class =
CreateBasicBlockWithDexPC(dex_pc, "load_class");
irb_.CreateCondBr(equal_null, block_load_class, block_cont);
// Failback routine to load the class object
irb_.SetInsertPoint(block_load_class);
llvm::Function* runtime_func = irb_.GetRuntime(InitializeType);
llvm::Constant* type_idx_value = irb_.getInt32(type_idx);
llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
EmitUpdateLineNumFromDexPC(dex_pc);
llvm::Value* loaded_type_object_addr =
irb_.CreateCall2(runtime_func, type_idx_value, method_object_addr);
EmitGuard_ExceptionLandingPad(dex_pc);
llvm::BasicBlock* block_after_load_class = irb_.GetInsertBlock();
irb_.CreateBr(block_cont);
// Now the class object must be loaded
irb_.SetInsertPoint(block_cont);
llvm::PHINode* phi = irb_.CreatePHI(irb_.getJObjectTy(), 2);
phi->addIncoming(type_object_addr, block_original);
phi->addIncoming(loaded_type_object_addr, block_after_load_class);
return phi;
}
}
void MethodCompiler::EmitInsn_LoadConstantClass(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vB_);
EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, type_object_addr);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_MonitorEnter(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Value* object_addr =
EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
// TODO: Slow path always. May not need NullPointerException check.
EmitGuard_NullPointerException(dex_pc, object_addr);
EmitUpdateLineNumFromDexPC(dex_pc);
irb_.CreateCall(irb_.GetRuntime(LockObject), object_addr);
EmitGuard_ExceptionLandingPad(dex_pc);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_MonitorExit(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Value* object_addr =
EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
EmitGuard_NullPointerException(dex_pc, object_addr);
EmitUpdateLineNumFromDexPC(dex_pc);
irb_.CreateCall(irb_.GetRuntime(UnlockObject), object_addr);
EmitGuard_ExceptionLandingPad(dex_pc);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_CheckCast(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::BasicBlock* block_test_class =
CreateBasicBlockWithDexPC(dex_pc, "test_class");
llvm::BasicBlock* block_test_sub_class =
CreateBasicBlockWithDexPC(dex_pc, "test_sub_class");
llvm::Value* object_addr =
EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
// Test: Is the reference equal to null? Act as no-op when it is null.
llvm::Value* equal_null = irb_.CreateICmpEQ(object_addr, irb_.getJNull());
irb_.CreateCondBr(equal_null,
GetNextBasicBlock(dex_pc),
block_test_class);
// Test: Is the object instantiated from the given class?
irb_.SetInsertPoint(block_test_class);
llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vB_);
DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
llvm::PointerType* jobject_ptr_ty = irb_.getJObjectTy();
llvm::Value* object_type_field_addr =
irb_.CreateBitCast(object_addr, jobject_ptr_ty->getPointerTo());
llvm::Value* object_type_object_addr =
irb_.CreateLoad(object_type_field_addr);
llvm::Value* equal_class =
irb_.CreateICmpEQ(type_object_addr, object_type_object_addr);
irb_.CreateCondBr(equal_class,
GetNextBasicBlock(dex_pc),
block_test_sub_class);
// Test: Is the object instantiated from the subclass of the given class?
irb_.SetInsertPoint(block_test_sub_class);
EmitUpdateLineNumFromDexPC(dex_pc);
irb_.CreateCall2(irb_.GetRuntime(CheckCast),
type_object_addr, object_type_object_addr);
EmitGuard_ExceptionLandingPad(dex_pc);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_InstanceOf(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Constant* zero = irb_.getJInt(0);
llvm::Constant* one = irb_.getJInt(1);
llvm::BasicBlock* block_nullp = CreateBasicBlockWithDexPC(dex_pc, "nullp");
llvm::BasicBlock* block_test_class =
CreateBasicBlockWithDexPC(dex_pc, "test_class");
llvm::BasicBlock* block_class_equals =
CreateBasicBlockWithDexPC(dex_pc, "class_eq");
llvm::BasicBlock* block_test_sub_class =
CreateBasicBlockWithDexPC(dex_pc, "test_sub_class");
llvm::Value* object_addr =
EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
// Overview of the following code :
// We check for null, if so, then false, otherwise check for class == . If so
// then true, otherwise do callout slowpath.
//
// Test: Is the reference equal to null? Set 0 when it is null.
llvm::Value* equal_null = irb_.CreateICmpEQ(object_addr, irb_.getJNull());
irb_.CreateCondBr(equal_null, block_nullp, block_test_class);
irb_.SetInsertPoint(block_nullp);
EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, zero);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
// Test: Is the object instantiated from the given class?
irb_.SetInsertPoint(block_test_class);
llvm::Value* type_object_addr = EmitLoadConstantClass(dex_pc, dec_insn.vC_);
DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
llvm::PointerType* jobject_ptr_ty = irb_.getJObjectTy();
llvm::Value* object_type_field_addr =
irb_.CreateBitCast(object_addr, jobject_ptr_ty->getPointerTo());
llvm::Value* object_type_object_addr =
irb_.CreateLoad(object_type_field_addr);
llvm::Value* equal_class =
irb_.CreateICmpEQ(type_object_addr, object_type_object_addr);
irb_.CreateCondBr(equal_class, block_class_equals, block_test_sub_class);
irb_.SetInsertPoint(block_class_equals);
EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, one);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
// Test: Is the object instantiated from the subclass of the given class?
irb_.SetInsertPoint(block_test_sub_class);
llvm::Value* result =
irb_.CreateCall2(irb_.GetRuntime(IsAssignable),
type_object_addr, object_type_object_addr);
EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
llvm::Value* MethodCompiler::EmitLoadArrayLength(llvm::Value* array) {
// Load array length field address
llvm::Constant* array_len_field_offset =
irb_.getPtrEquivInt(Array::LengthOffset().Int32Value());
llvm::Value* array_len_field_addr =
irb_.CreatePtrDisp(array, array_len_field_offset,
irb_.getJIntTy()->getPointerTo());
// Load array length
return irb_.CreateLoad(array_len_field_addr);
}
void MethodCompiler::EmitInsn_ArrayLength(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
// Get the array object address
llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
EmitGuard_NullPointerException(dex_pc, array_addr);
// Get the array length and store it to the register
llvm::Value* array_len = EmitLoadArrayLength(array_addr);
EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, array_len);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_NewInstance(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Function* runtime_func;
if (compiler_->CanAccessTypeWithoutChecks(method_idx_, dex_cache_,
*dex_file_, dec_insn.vB_)) {
runtime_func = irb_.GetRuntime(AllocObject);
} else {
runtime_func = irb_.GetRuntime(AllocObjectWithAccessCheck);
}
llvm::Constant* type_index_value = irb_.getInt32(dec_insn.vB_);
llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
EmitUpdateLineNumFromDexPC(dex_pc);
llvm::Value* object_addr =
irb_.CreateCall2(runtime_func, type_index_value, method_object_addr);
EmitGuard_ExceptionLandingPad(dex_pc);
EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, object_addr);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
llvm::Value* MethodCompiler::EmitAllocNewArray(uint32_t dex_pc,
int32_t length,
uint32_t type_idx,
bool is_filled_new_array) {
llvm::Function* runtime_func;
bool skip_access_check =
compiler_->CanAccessTypeWithoutChecks(method_idx_, dex_cache_,
*dex_file_, type_idx);
if (is_filled_new_array) {
runtime_func = skip_access_check ?
irb_.GetRuntime(CheckAndAllocArray) :
irb_.GetRuntime(CheckAndAllocArrayWithAccessCheck);
} else {
runtime_func = skip_access_check ?
irb_.GetRuntime(AllocArray) :
irb_.GetRuntime(AllocArrayWithAccessCheck);
}
llvm::Constant* type_index_value = irb_.getInt32(type_idx);
llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
llvm::Value* array_length_value = irb_.getInt32(length);
EmitUpdateLineNumFromDexPC(dex_pc);
llvm::Value* object_addr =
irb_.CreateCall3(runtime_func, type_index_value, method_object_addr,
array_length_value);
EmitGuard_ExceptionLandingPad(dex_pc);
return object_addr;
}
void MethodCompiler::EmitInsn_NewArray(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Value* object_addr =
EmitAllocNewArray(dex_pc, dec_insn.vB_, dec_insn.vC_, false);
EmitStoreDalvikReg(dec_insn.vA_, kObject, kAccurate, object_addr);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_FilledNewArray(uint32_t dex_pc,
Instruction const* insn,
bool is_range) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Value* object_addr =
EmitAllocNewArray(dex_pc, dec_insn.vA_, dec_insn.vB_, true);
if (dec_insn.vA_ > 0) {
llvm::Value* object_addr_int =
irb_.CreatePtrToInt(object_addr, irb_.getPtrEquivIntTy());
// TODO: currently FilledNewArray doesn't support I, J, D and L, [ so computing the component
// size using int alignment is safe. This code should determine the width of the FilledNewArray
// component.
llvm::Value* data_field_offset =
irb_.getPtrEquivInt(Array::DataOffset(sizeof(int32_t)).Int32Value());
llvm::Value* data_field_addr_int =
irb_.CreateAdd(object_addr_int, data_field_offset);
Class* klass = method_->GetDexCacheResolvedTypes()->Get(dec_insn.vB_);
CHECK_NE(klass, static_cast<Class*>(NULL));
// Moved this below already: CHECK(!klass->IsPrimitive() || klass->IsPrimitiveInt());
llvm::Constant* word_size = irb_.getSizeOfPtrEquivIntValue();
llvm::Type* field_type;
if (klass->IsPrimitiveInt()) {
field_type = irb_.getJIntTy()->getPointerTo();
} else {
CHECK(!klass->IsPrimitive());
field_type = irb_.getJObjectTy()->getPointerTo();
}
// TODO: Tune this code. Currently we are generating one instruction for
// one element which may be very space consuming. Maybe changing to use
// memcpy may help; however, since we can't guarantee that the alloca of
// dalvik register are continuous, we can't perform such optimization yet.
for (uint32_t i = 0; i < dec_insn.vA_; ++i) {
llvm::Value* data_field_addr =
irb_.CreateIntToPtr(data_field_addr_int, field_type);
int reg_index;
if (is_range) {
reg_index = dec_insn.vC_ + i;
} else {
reg_index = dec_insn.arg_[i];
}
llvm::Value* reg_value;
if (klass->IsPrimitiveInt()) {
reg_value = EmitLoadDalvikReg(reg_index, kInt, kAccurate);
} else {
reg_value = EmitLoadDalvikReg(reg_index, kObject, kAccurate);
}
irb_.CreateStore(reg_value, data_field_addr);
data_field_addr_int = irb_.CreateAdd(data_field_addr_int, word_size);
}
}
EmitStoreDalvikRetValReg(kObject, kAccurate, object_addr);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_FillArrayData(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
// Read the payload
struct PACKED Payload {
uint16_t ident_;
uint16_t elem_width_;
uint32_t num_elems_;
uint8_t data_[];
};
int32_t payload_offset = static_cast<int32_t>(dex_pc) +
static_cast<int32_t>(dec_insn.vB_);
Payload const* payload =
reinterpret_cast<Payload const*>(code_item_->insns_ + payload_offset);
uint32_t size_in_bytes = payload->elem_width_ * payload->num_elems_;
// Load and check the array
llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
EmitGuard_NullPointerException(dex_pc, array_addr);
if (payload->num_elems_ > 0) {
// Test: Is array length big enough?
llvm::Constant* last_index = irb_.getJInt(payload->num_elems_ - 1);
EmitGuard_ArrayIndexOutOfBoundsException(dex_pc, array_addr, last_index);
// TODO: currently FillArray doesn't support I, J, D and L, [ so computing the component
// size using int alignment is safe. This code should determine the width of the FillArray
// component.
// Get array data field
llvm::Value* data_field_offset_value =
irb_.getPtrEquivInt(Array::DataOffset(sizeof(int32_t)).Int32Value());
llvm::Value* data_field_addr =
irb_.CreatePtrDisp(array_addr, data_field_offset_value,
irb_.getInt8Ty()->getPointerTo());
// Emit payload to bitcode constant pool
std::vector<llvm::Constant*> const_pool_data;
for (uint32_t i = 0; i < size_in_bytes; ++i) {
const_pool_data.push_back(irb_.getInt8(payload->data_[i]));
}
llvm::Constant* const_pool_data_array_value = llvm::ConstantArray::get(
llvm::ArrayType::get(irb_.getInt8Ty(), size_in_bytes), const_pool_data);
llvm::Value* const_pool_data_array_addr =
new llvm::GlobalVariable(*module_,
const_pool_data_array_value->getType(),
false, llvm::GlobalVariable::InternalLinkage,
const_pool_data_array_value,
"array_data_payload");
// Find the memcpy intrinsic
llvm::Type* memcpy_arg_types[] = {
llvm::Type::getInt8Ty(*context_)->getPointerTo(),
llvm::Type::getInt8Ty(*context_)->getPointerTo(),
llvm::Type::getInt32Ty(*context_)
};
llvm::Function* memcpy_intrinsic =
llvm::Intrinsic::getDeclaration(module_,
llvm::Intrinsic::memcpy,
memcpy_arg_types);
// Copy now!
llvm::Value *args[] = {
data_field_addr,
irb_.CreateConstGEP2_32(const_pool_data_array_addr, 0, 0),
irb_.getInt32(size_in_bytes),
irb_.getInt32(0), // alignment: no guarantee
irb_.getFalse() // is_volatile: false
};
irb_.CreateCall(memcpy_intrinsic, args);
}
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_UnconditionalBranch(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
int32_t branch_offset = dec_insn.vA_;
if (branch_offset <= 0) {
// Garbage collection safe-point on backward branch
EmitGuard_GarbageCollectionSuspend(dex_pc);
}
irb_.CreateBr(GetBasicBlock(dex_pc + branch_offset));
}
void MethodCompiler::EmitInsn_PackedSwitch(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
struct PACKED Payload {
uint16_t ident_;
uint16_t num_cases_;
int32_t first_key_;
int32_t targets_[];
};
int32_t payload_offset = static_cast<int32_t>(dex_pc) +
static_cast<int32_t>(dec_insn.vB_);
Payload const* payload =
reinterpret_cast<Payload const*>(code_item_->insns_ + payload_offset);
llvm::Value* value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
llvm::SwitchInst* sw =
irb_.CreateSwitch(value, GetNextBasicBlock(dex_pc), payload->num_cases_);
for (uint16_t i = 0; i < payload->num_cases_; ++i) {
sw->addCase(irb_.getInt32(payload->first_key_ + i),
GetBasicBlock(dex_pc + payload->targets_[i]));
}
}
void MethodCompiler::EmitInsn_SparseSwitch(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
struct PACKED Payload {
uint16_t ident_;
uint16_t num_cases_;
int32_t keys_and_targets_[];
};
int32_t payload_offset = static_cast<int32_t>(dex_pc) +
static_cast<int32_t>(dec_insn.vB_);
Payload const* payload =
reinterpret_cast<Payload const*>(code_item_->insns_ + payload_offset);
int32_t const* keys = payload->keys_and_targets_;
int32_t const* targets = payload->keys_and_targets_ + payload->num_cases_;
llvm::Value* value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
llvm::SwitchInst* sw =
irb_.CreateSwitch(value, GetNextBasicBlock(dex_pc), payload->num_cases_);
for (size_t i = 0; i < payload->num_cases_; ++i) {
sw->addCase(irb_.getInt32(keys[i]), GetBasicBlock(dex_pc + targets[i]));
}
}
void MethodCompiler::EmitInsn_FPCompare(uint32_t dex_pc,
Instruction const* insn,
JType fp_jty,
bool gt_bias) {
Instruction::DecodedInstruction dec_insn(insn);
DCHECK(fp_jty == kFloat || fp_jty == kDouble) << "JType: " << fp_jty;
llvm::Value* src1_value = EmitLoadDalvikReg(dec_insn.vB_, fp_jty, kAccurate);
llvm::Value* src2_value = EmitLoadDalvikReg(dec_insn.vC_, fp_jty, kAccurate);
llvm::Value* cmp_eq = irb_.CreateFCmpOEQ(src1_value, src2_value);
llvm::Value* cmp_lt;
if (gt_bias) {
cmp_lt = irb_.CreateFCmpOLT(src1_value, src2_value);
} else {
cmp_lt = irb_.CreateFCmpULT(src1_value, src2_value);
}
llvm::Value* result = EmitCompareResultSelection(cmp_eq, cmp_lt);
EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_LongCompare(uint32_t dex_pc,
Instruction const* insn) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Value* src1_value = EmitLoadDalvikReg(dec_insn.vB_, kLong, kAccurate);
llvm::Value* src2_value = EmitLoadDalvikReg(dec_insn.vC_, kLong, kAccurate);
llvm::Value* cmp_eq = irb_.CreateICmpEQ(src1_value, src2_value);
llvm::Value* cmp_lt = irb_.CreateICmpSLT(src1_value, src2_value);
llvm::Value* result = EmitCompareResultSelection(cmp_eq, cmp_lt);
EmitStoreDalvikReg(dec_insn.vA_, kInt, kAccurate, result);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
llvm::Value* MethodCompiler::EmitCompareResultSelection(llvm::Value* cmp_eq,
llvm::Value* cmp_lt) {
llvm::Constant* zero = irb_.getJInt(0);
llvm::Constant* pos1 = irb_.getJInt(1);
llvm::Constant* neg1 = irb_.getJInt(-1);
llvm::Value* result_lt = irb_.CreateSelect(cmp_lt, neg1, pos1);
llvm::Value* result_eq = irb_.CreateSelect(cmp_eq, zero, result_lt);
return result_eq;
}
void MethodCompiler::EmitInsn_BinaryConditionalBranch(uint32_t dex_pc,
Instruction const* insn,
CondBranchKind cond) {
Instruction::DecodedInstruction dec_insn(insn);
int8_t src1_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA_);
int8_t src2_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vB_);
DCHECK_NE(kRegUnknown, src1_reg_cat);
DCHECK_NE(kRegUnknown, src2_reg_cat);
DCHECK_NE(kRegCat2, src1_reg_cat);
DCHECK_NE(kRegCat2, src2_reg_cat);
int32_t branch_offset = dec_insn.vC_;
if (branch_offset <= 0) {
// Garbage collection safe-point on backward branch
EmitGuard_GarbageCollectionSuspend(dex_pc);
}
if (src1_reg_cat == kRegZero && src2_reg_cat == kRegZero) {
irb_.CreateBr(GetBasicBlock(dex_pc + branch_offset));
return;
}
llvm::Value* src1_value;
llvm::Value* src2_value;
if (src1_reg_cat != kRegZero && src2_reg_cat != kRegZero) {
CHECK_EQ(src1_reg_cat, src2_reg_cat);
if (src1_reg_cat == kRegCat1nr) {
src1_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
src2_value = EmitLoadDalvikReg(dec_insn.vB_, kInt, kAccurate);
} else {
src1_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
src2_value = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
}
} else {
DCHECK(src1_reg_cat == kRegZero ||
src2_reg_cat == kRegZero);
if (src1_reg_cat == kRegZero) {
if (src2_reg_cat == kRegCat1nr) {
src1_value = irb_.getJInt(0);
src2_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
} else {
src1_value = irb_.getJNull();
src2_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
}
} else { // src2_reg_cat == kRegZero
if (src2_reg_cat == kRegCat1nr) {
src1_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
src2_value = irb_.getJInt(0);
} else {
src1_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
src2_value = irb_.getJNull();
}
}
}
llvm::Value* cond_value =
EmitConditionResult(src1_value, src2_value, cond);
irb_.CreateCondBr(cond_value,
GetBasicBlock(dex_pc + branch_offset),
GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_UnaryConditionalBranch(uint32_t dex_pc,
Instruction const* insn,
CondBranchKind cond) {
Instruction::DecodedInstruction dec_insn(insn);
int8_t src_reg_cat = GetInferredRegCategory(dex_pc, dec_insn.vA_);
DCHECK_NE(kRegUnknown, src_reg_cat);
DCHECK_NE(kRegCat2, src_reg_cat);
int32_t branch_offset = dec_insn.vB_;
if (branch_offset <= 0) {
// Garbage collection safe-point on backward branch
EmitGuard_GarbageCollectionSuspend(dex_pc);
}
if (src_reg_cat == kRegZero) {
irb_.CreateBr(GetBasicBlock(dex_pc + branch_offset));
return;
}
llvm::Value* src1_value;
llvm::Value* src2_value;
if (src_reg_cat == kRegCat1nr) {
src1_value = EmitLoadDalvikReg(dec_insn.vA_, kInt, kAccurate);
src2_value = irb_.getInt32(0);
} else {
src1_value = EmitLoadDalvikReg(dec_insn.vA_, kObject, kAccurate);
src2_value = irb_.getJNull();
}
llvm::Value* cond_value =
EmitConditionResult(src1_value, src2_value, cond);
irb_.CreateCondBr(cond_value,
GetBasicBlock(dex_pc + branch_offset),
GetNextBasicBlock(dex_pc));
}
RegCategory MethodCompiler::GetInferredRegCategory(uint32_t dex_pc,
uint16_t reg_idx) {
InferredRegCategoryMap const* map = method_->GetInferredRegCategoryMap();
CHECK_NE(map, static_cast<InferredRegCategoryMap*>(NULL));
return map->GetRegCategory(dex_pc, reg_idx);
}
llvm::Value* MethodCompiler::EmitConditionResult(llvm::Value* lhs,
llvm::Value* rhs,
CondBranchKind cond) {
switch (cond) {
case kCondBranch_EQ:
return irb_.CreateICmpEQ(lhs, rhs);
case kCondBranch_NE:
return irb_.CreateICmpNE(lhs, rhs);
case kCondBranch_LT:
return irb_.CreateICmpSLT(lhs, rhs);
case kCondBranch_GE:
return irb_.CreateICmpSGE(lhs, rhs);
case kCondBranch_GT:
return irb_.CreateICmpSGT(lhs, rhs);
case kCondBranch_LE:
return irb_.CreateICmpSLE(lhs, rhs);
default: // Unreachable
LOG(FATAL) << "Unknown conditional branch kind: " << cond;
return NULL;
}
}
void
MethodCompiler::EmitGuard_ArrayIndexOutOfBoundsException(uint32_t dex_pc,
llvm::Value* array,
llvm::Value* index) {
llvm::Value* array_len = EmitLoadArrayLength(array);
llvm::Value* cmp = irb_.CreateICmpUGE(index, array_len);
llvm::BasicBlock* block_exception =
CreateBasicBlockWithDexPC(dex_pc, "overflow");
llvm::BasicBlock* block_continue =
CreateBasicBlockWithDexPC(dex_pc, "cont");
irb_.CreateCondBr(cmp, block_exception, block_continue);
irb_.SetInsertPoint(block_exception);
EmitUpdateLineNumFromDexPC(dex_pc);
irb_.CreateCall2(irb_.GetRuntime(ThrowIndexOutOfBounds), index, array_len);
EmitBranchExceptionLandingPad(dex_pc);
irb_.SetInsertPoint(block_continue);
}
void MethodCompiler::EmitGuard_ArrayException(uint32_t dex_pc,
llvm::Value* array,
llvm::Value* index) {
EmitGuard_NullPointerException(dex_pc, array);
EmitGuard_ArrayIndexOutOfBoundsException(dex_pc, array, index);
}
// Emit Array GetElementPtr
llvm::Value* MethodCompiler::EmitArrayGEP(llvm::Value* array_addr,
llvm::Value* index_value,
llvm::Type* elem_type,
JType elem_jty) {
int data_offset;
if (elem_jty == kLong || elem_jty == kDouble ||
(elem_jty == kObject && sizeof(uint64_t) == sizeof(Object*))) {
data_offset = Array::DataOffset(sizeof(int64_t)).Int32Value();
} else {
data_offset = Array::DataOffset(sizeof(int32_t)).Int32Value();
}
llvm::Constant* data_offset_value =
irb_.getPtrEquivInt(data_offset);
llvm::Value* array_data_addr =
irb_.CreatePtrDisp(array_addr, data_offset_value,
elem_type->getPointerTo());
return irb_.CreateGEP(array_data_addr, index_value);
}
void MethodCompiler::EmitInsn_AGet(uint32_t dex_pc,
Instruction const* insn,
JType elem_jty) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
llvm::Value* index_value = EmitLoadDalvikReg(dec_insn.vC_, kInt, kAccurate);
EmitGuard_ArrayException(dex_pc, array_addr, index_value);
llvm::Type* elem_type = irb_.getJType(elem_jty, kArray);
llvm::Value* array_elem_addr =
EmitArrayGEP(array_addr, index_value, elem_type, elem_jty);
llvm::Value* array_elem_value = irb_.CreateLoad(array_elem_addr);
EmitStoreDalvikReg(dec_insn.vA_, elem_jty, kArray, array_elem_value);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_APut(uint32_t dex_pc,
Instruction const* insn,
JType elem_jty) {
Instruction::DecodedInstruction dec_insn(insn);
llvm::Value* array_addr = EmitLoadDalvikReg(dec_insn.vB_, kObject, kAccurate);
llvm::Value* index_value = EmitLoadDalvikReg(dec_insn.vC_, kInt, kAccurate);
EmitGuard_ArrayException(dex_pc, array_addr, index_value);
llvm::Type* elem_type = irb_.getJType(elem_jty, kArray);
llvm::Value* array_elem_addr =
EmitArrayGEP(array_addr, index_value, elem_type, elem_jty);
llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA_, elem_jty, kArray);
irb_.CreateStore(new_value, array_elem_addr);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::PrintUnresolvedFieldWarning(int32_t field_idx) {
DexFile const& dex_file = method_helper_.GetDexFile();
DexFile::FieldId const& field_id = dex_file.GetFieldId(field_idx);
LOG(WARNING) << "unable to resolve static field " << field_idx << " ("
<< dex_file.GetFieldName(field_id) << ") in "
<< dex_file.GetFieldDeclaringClassDescriptor(field_id);
}
void MethodCompiler::EmitInsn_IGet(uint32_t dex_pc,
Instruction const* insn,
JType field_jty) {
Instruction::DecodedInstruction dec_insn(insn);
uint32_t reg_idx = dec_insn.vB_;
uint32_t field_idx = dec_insn.vC_;
Field* field = dex_cache_->GetResolvedField(field_idx);
llvm::Value* object_addr = EmitLoadDalvikReg(reg_idx, kObject, kAccurate);
EmitGuard_NullPointerException(dex_pc, object_addr);
llvm::Value* field_value;
if (field == NULL) {
PrintUnresolvedFieldWarning(field_idx);
llvm::Function* runtime_func;
if (field_jty == kObject) {
runtime_func = irb_.GetRuntime(GetObjectInstance);
} else if (field_jty == kLong || field_jty == kDouble) {
runtime_func = irb_.GetRuntime(Get64Instance);
} else {
runtime_func = irb_.GetRuntime(Get32Instance);
}
llvm::ConstantInt* field_idx_value = irb_.getInt32(field_idx);
llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
EmitUpdateLineNumFromDexPC(dex_pc);
field_value = irb_.CreateCall3(runtime_func, field_idx_value,
method_object_addr, object_addr);
EmitGuard_ExceptionLandingPad(dex_pc);
} else {
llvm::PointerType* field_type =
irb_.getJType(field_jty, kField)->getPointerTo();
llvm::ConstantInt* field_offset =
irb_.getPtrEquivInt(field->GetOffset().Int32Value());
llvm::Value* field_addr =
irb_.CreatePtrDisp(object_addr, field_offset, field_type);
field_value = irb_.CreateLoad(field_addr);
}
EmitStoreDalvikReg(dec_insn.vA_, field_jty, kField, field_value);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_IPut(uint32_t dex_pc,
Instruction const* insn,
JType field_jty) {
Instruction::DecodedInstruction dec_insn(insn);
uint32_t reg_idx = dec_insn.vB_;
uint32_t field_idx = dec_insn.vC_;
Field* field = dex_cache_->GetResolvedField(field_idx);
llvm::Value* object_addr = EmitLoadDalvikReg(reg_idx, kObject, kAccurate);
EmitGuard_NullPointerException(dex_pc, object_addr);
llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA_, field_jty, kField);
if (field == NULL) {
PrintUnresolvedFieldWarning(field_idx);
llvm::Function* runtime_func;
if (field_jty == kObject) {
runtime_func = irb_.GetRuntime(SetObjectInstance);
} else if (field_jty == kLong || field_jty == kDouble) {
runtime_func = irb_.GetRuntime(Set64Instance);
} else {
runtime_func = irb_.GetRuntime(Set32Instance);
}
llvm::Value* field_idx_value = irb_.getInt32(field_idx);
llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
EmitUpdateLineNumFromDexPC(dex_pc);
irb_.CreateCall4(runtime_func, field_idx_value,
method_object_addr, object_addr, new_value);
EmitGuard_ExceptionLandingPad(dex_pc);
} else {
llvm::PointerType* field_type =
irb_.getJType(field_jty, kField)->getPointerTo();
llvm::Value* field_offset =
irb_.getPtrEquivInt(field->GetOffset().Int32Value());
llvm::Value* field_addr =
irb_.CreatePtrDisp(object_addr, field_offset, field_type);
irb_.CreateStore(new_value, field_addr);
}
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
Method* MethodCompiler::ResolveMethod(uint32_t method_idx) {
Thread* thread = Thread::Current();
// Save the exception state
Throwable* old_exception = NULL;
if (thread->IsExceptionPending()) {
old_exception = thread->GetException();
thread->ClearException();
}
// Resolve the method through the class linker
Method* method = class_linker_->ResolveMethod(*dex_file_, method_idx,
dex_cache_, class_loader_,
/* is_direct= */ false);
if (method == NULL) {
// Ignore the exception raised during the method resolution
thread->ClearException();
}
// Restore the exception state
if (old_exception != NULL) {
thread->SetException(old_exception);
}
return method;
}
Field* MethodCompiler::ResolveField(uint32_t field_idx) {
Thread* thread = Thread::Current();
// Save the exception state
Throwable* old_exception = NULL;
if (thread->IsExceptionPending()) {
old_exception = thread->GetException();
thread->ClearException();
}
// Resolve the fields through the class linker
Field* field = class_linker_->ResolveField(*dex_file_, field_idx,
dex_cache_, class_loader_,
/* is_static= */ true);
if (field == NULL) {
// Ignore the exception raised during the field resolution
thread->ClearException();
}
// Restore the exception state
if (old_exception != NULL) {
thread->SetException(old_exception);
}
return field;
}
Field* MethodCompiler::
FindFieldAndDeclaringTypeIdx(uint32_t field_idx,
uint32_t &resolved_type_idx) {
// Resolve the field through the class linker
Field* field = ResolveField(field_idx);
if (field == NULL) {
return NULL;
}
DexFile::FieldId const& field_id = dex_file_->GetFieldId(field_idx);
// Search for the type_idx of the declaring class
uint16_t type_idx = field_id.class_idx_;
Class* klass = dex_cache_->GetResolvedTypes()->Get(type_idx);
// Test: Is referring_class equal to declaring_class?
// If true, then return the type_idx; otherwise, this field must be declared
// in super class or interfaces, we have to search for declaring class.
if (field->GetDeclaringClass() == klass) {
resolved_type_idx = type_idx;
return field;
}
// Search for the type_idx of the super class or interfaces
std::string desc(FieldHelper(field).GetDeclaringClassDescriptor());
DexFile::StringId const* string_id = dex_file_->FindStringId(desc);
if (string_id == NULL) {
return NULL;
}
DexFile::TypeId const* type_id =
dex_file_->FindTypeId(dex_file_->GetIndexForStringId(*string_id));
if (type_id == NULL) {
return NULL;
}
resolved_type_idx = dex_file_->GetIndexForTypeId(*type_id);
return field;
}
llvm::Value* MethodCompiler::EmitLoadStaticStorage(uint32_t dex_pc,
uint32_t type_idx) {
llvm::BasicBlock* block_load_static =
CreateBasicBlockWithDexPC(dex_pc, "load_static");
llvm::BasicBlock* block_cont = CreateBasicBlockWithDexPC(dex_pc, "cont");
// Load static storage from dex cache
llvm::Value* storage_field_addr =
EmitLoadDexCacheStaticStorageFieldAddr(type_idx);
llvm::Value* storage_object_addr = irb_.CreateLoad(storage_field_addr);
llvm::BasicBlock* block_original = irb_.GetInsertBlock();
// Test: Is the static storage of this class initialized?
llvm::Value* equal_null =
irb_.CreateICmpEQ(storage_object_addr, irb_.getJNull());
irb_.CreateCondBr(equal_null, block_load_static, block_cont);
// Failback routine to load the class object
irb_.SetInsertPoint(block_load_static);
llvm::Function* runtime_func =
irb_.GetRuntime(InitializeStaticStorage);
llvm::Constant* type_idx_value = irb_.getInt32(type_idx);
llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
EmitUpdateLineNumFromDexPC(dex_pc);
llvm::Value* loaded_storage_object_addr =
irb_.CreateCall2(runtime_func, type_idx_value, method_object_addr);
EmitGuard_ExceptionLandingPad(dex_pc);
llvm::BasicBlock* block_after_load_static = irb_.GetInsertBlock();
irb_.CreateBr(block_cont);
// Now the class object must be loaded
irb_.SetInsertPoint(block_cont);
llvm::PHINode* phi = irb_.CreatePHI(irb_.getJObjectTy(), 2);
phi->addIncoming(storage_object_addr, block_original);
phi->addIncoming(loaded_storage_object_addr, block_after_load_static);
return phi;
}
void MethodCompiler::EmitInsn_SGet(uint32_t dex_pc,
Instruction const* insn,
JType field_jty) {
Instruction::DecodedInstruction dec_insn(insn);
uint32_t declaring_type_idx = DexFile::kDexNoIndex;
Field* field = FindFieldAndDeclaringTypeIdx(dec_insn.vB_, declaring_type_idx);
llvm::Value* static_field_value;
if (field == NULL) {
llvm::Function* runtime_func;
if (field_jty == kObject) {
runtime_func = irb_.GetRuntime(GetObjectStatic);
} else if (field_jty == kLong || field_jty == kDouble) {
runtime_func = irb_.GetRuntime(Get64Static);
} else {
runtime_func = irb_.GetRuntime(Get32Static);
}
llvm::Constant* field_idx_value = irb_.getInt32(dec_insn.vB_);
llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
EmitUpdateLineNumFromDexPC(dex_pc);
static_field_value =
irb_.CreateCall2(runtime_func, field_idx_value, method_object_addr);
EmitGuard_ExceptionLandingPad(dex_pc);
} else {
llvm::Value* static_storage_addr =
EmitLoadStaticStorage(dex_pc, declaring_type_idx);
llvm::Value* static_field_offset_value =
irb_.getPtrEquivInt(field->GetOffset().Int32Value());
llvm::Value* static_field_addr =
irb_.CreatePtrDisp(static_storage_addr, static_field_offset_value,
irb_.getJType(field_jty, kField)->getPointerTo());
static_field_value = irb_.CreateLoad(static_field_addr);
}
EmitStoreDalvikReg(dec_insn.vA_, field_jty, kField, static_field_value);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_SPut(uint32_t dex_pc,
Instruction const* insn,
JType field_jty) {
Instruction::DecodedInstruction dec_insn(insn);
uint32_t declaring_type_idx = DexFile::kDexNoIndex;
Field* field = FindFieldAndDeclaringTypeIdx(dec_insn.vB_, declaring_type_idx);
llvm::Value* new_value = EmitLoadDalvikReg(dec_insn.vA_, field_jty, kField);
if (field == NULL) {
llvm::Function* runtime_func;
if (field_jty == kObject) {
runtime_func = irb_.GetRuntime(SetObjectStatic);
} else if (field_jty == kLong || field_jty == kDouble) {
runtime_func = irb_.GetRuntime(Set64Static);
} else {
runtime_func = irb_.GetRuntime(Set32Static);
}
llvm::Constant* field_idx_value = irb_.getInt32(dec_insn.vB_);
llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
EmitUpdateLineNumFromDexPC(dex_pc);
irb_.CreateCall3(runtime_func, field_idx_value,
method_object_addr, new_value);
EmitGuard_ExceptionLandingPad(dex_pc);
} else {
llvm::Value* static_storage_addr =
EmitLoadStaticStorage(dex_pc, declaring_type_idx);
llvm::Value* static_field_offset_value =
irb_.getPtrEquivInt(field->GetOffset().Int32Value());
llvm::Value* static_field_addr =
irb_.CreatePtrDisp(static_storage_addr, static_field_offset_value,
irb_.getJType(field_jty, kField)->getPointerTo());
irb_.CreateStore(new_value, static_field_addr);
}
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
llvm::Value* MethodCompiler::
EmitLoadCalleeThis(Instruction::DecodedInstruction const& dec_insn,
bool is_range) {
if (is_range) {
return EmitLoadDalvikReg(dec_insn.vC_, kObject, kAccurate);
} else {
return EmitLoadDalvikReg(dec_insn.arg_[0], kObject, kAccurate);
}
}
void MethodCompiler::
EmitLoadActualParameters(std::vector<llvm::Value*>& args,
uint32_t callee_method_idx,
Instruction::DecodedInstruction const& dec_insn,
bool is_range,
bool is_static) {
// Get method signature
DexFile::MethodId const& method_id =
dex_file_->GetMethodId(callee_method_idx);
uint32_t shorty_size;
char const* shorty = dex_file_->GetMethodShorty(method_id, &shorty_size);
CHECK_GE(shorty_size, 1u);
// Load argument values according to the shorty (without "this")
uint16_t reg_count = 0;
if (!is_static) {
++reg_count; // skip the "this" pointer
}
for (uint32_t i = 1; i < shorty_size; ++i) {
uint32_t reg_idx = (is_range) ? (dec_insn.vC_ + reg_count)
: (dec_insn.arg_[reg_count]);
args.push_back(EmitLoadDalvikReg(reg_idx, shorty[i], kAccurate));
++reg_count;
if (shorty[i] == 'J' || shorty[i] == 'D') {
// Wide types, such as long and double, are using a pair of registers
// to store the value, so we have to increase arg_reg again.
++reg_count;
}
}
DCHECK_EQ(reg_count, dec_insn.vA_)
<< "Actual argument mismatch for callee: "
<< PrettyMethod(callee_method_idx, *dex_file_);
}
void MethodCompiler::EmitInsn_InvokeVirtual(uint32_t dex_pc,
Instruction const* insn,
bool is_range) {
Instruction::DecodedInstruction dec_insn(insn);
uint32_t callee_method_idx = dec_insn.vB_;
// Find the method object at compile time
Method* callee_method = ResolveMethod(callee_method_idx);
if (callee_method == NULL) {
// Callee method can't be resolved at compile time. Emit the runtime
// method resolution code.
UNIMPLEMENTED(FATAL) << "Method index " << callee_method_idx
<< " can't be resolved";
} else {
// Test: Is *this* parameter equal to null?
llvm::Value* this_addr = EmitLoadCalleeThis(dec_insn, is_range);
EmitGuard_NullPointerException(dex_pc, this_addr);
// Load class object of *this* pointer
llvm::Value* class_object_addr = EmitLoadClassObjectAddr(this_addr);
// Load callee method code address (branch destination)
llvm::Value* vtable_addr = EmitLoadVTableAddr(class_object_addr);
llvm::Value* method_object_addr =
EmitLoadMethodObjectAddrFromVTable(vtable_addr,
callee_method->GetMethodIndex());
llvm::Value* code_addr =
EmitLoadCodeAddr(method_object_addr, callee_method_idx, false);
// Load actual parameters
std::vector<llvm::Value*> args;
args.push_back(method_object_addr);
args.push_back(this_addr);
EmitLoadActualParameters(args, callee_method_idx, dec_insn,
is_range, false);