blob: b2dc1f21b5cd97134278ecfbed2d5915a193fc2d [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 "compiler.h"
#include "ir_builder.h"
#include "logging.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>
namespace art {
namespace compiler_llvm {
using namespace runtime_support;
MethodCompiler::MethodCompiler(InstructionSet insn_set,
Compiler* compiler,
ClassLinker* class_linker,
ClassLoader const* class_loader,
DexFile const* dex_file,
DexCache* dex_cache,
DexFile::CodeItem const* code_item,
uint32_t method_idx,
uint32_t access_flags)
: insn_set_(insn_set),
compiler_(compiler), compiler_llvm_(compiler->GetCompilerLLVM()),
class_linker_(class_linker), class_loader_(class_loader),
dex_file_(dex_file), dex_cache_(dex_cache), code_item_(code_item),
method_(dex_cache->GetResolvedMethod(method_idx)),
method_helper_(method_), method_idx_(method_idx),
access_flags_(access_flags), module_(compiler_llvm_->GetModule()),
context_(compiler_llvm_->GetLLVMContext()),
irb_(*compiler_llvm_->GetIRBuilder()), func_(NULL), retval_reg_(NULL),
basic_block_reg_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) {
}
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);
int32_t shorty_size;
char const* shorty = dex_file_->GetMethodShorty(method_id, &shorty_size);
CHECK_GE(shorty_size, 1);
// 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 (int32_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_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));
// 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_reg_zero_init_);
irb_.SetInsertPoint(basic_block_reg_zero_init_);
irb_.CreateBr(basic_block_reg_arg_init_);
}
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_InvokeDirect(ARGS, false);
break;
case Instruction::INVOKE_STATIC:
EmitInsn_InvokeStatic(ARGS, 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_InvokeDirect(ARGS, true);
break;
case Instruction::INVOKE_STATIC_RANGE:
EmitInsn_InvokeStatic(ARGS, 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) {
// UNIMPLEMENTED(WARNING);
irb_.CreateUnreachable();
}
void MethodCompiler::EmitInsn_Move(uint32_t dex_pc,
Instruction const* insn,
JType jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_MoveResult(uint32_t dex_pc,
Instruction const* insn,
JType jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_MoveException(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_ThrowException(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateUnreachable();
}
void MethodCompiler::EmitInsn_ReturnVoid(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateUnreachable();
}
void MethodCompiler::EmitInsn_Return(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateUnreachable();
}
void MethodCompiler::EmitInsn_LoadConstant(uint32_t dex_pc,
Instruction const* insn,
JType imm_jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_LoadConstantString(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_LoadConstantClass(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_MonitorEnter(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_MonitorExit(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_CheckCast(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_InstanceOf(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_ArrayLength(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_NewInstance(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_NewArray(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_FilledNewArray(uint32_t dex_pc,
Instruction const* insn,
bool is_range) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_FillArrayData(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_UnconditionalBranch(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateUnreachable();
}
void MethodCompiler::EmitInsn_PackedSwitch(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateUnreachable();
}
void MethodCompiler::EmitInsn_SparseSwitch(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateUnreachable();
}
void MethodCompiler::EmitInsn_FPCompare(uint32_t dex_pc,
Instruction const* insn,
JType fp_jty,
bool gt_bias) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_LongCompare(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_BinaryConditionalBranch(uint32_t dex_pc,
Instruction const* insn,
CondBranchKind cond) {
// UNIMPLEMENTED(WARNING);
irb_.CreateUnreachable();
}
void MethodCompiler::EmitInsn_UnaryConditionalBranch(uint32_t dex_pc,
Instruction const* insn,
CondBranchKind cond) {
// UNIMPLEMENTED(WARNING);
irb_.CreateUnreachable();
}
void MethodCompiler::EmitInsn_AGet(uint32_t dex_pc,
Instruction const* insn,
JType elem_jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_APut(uint32_t dex_pc,
Instruction const* insn,
JType elem_jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_IGet(uint32_t dex_pc,
Instruction const* insn,
JType field_jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_IPut(uint32_t dex_pc,
Instruction const* insn,
JType field_jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_SGet(uint32_t dex_pc,
Instruction const* insn,
JType field_jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_SPut(uint32_t dex_pc,
Instruction const* insn,
JType field_jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_InvokeVirtual(uint32_t dex_pc,
Instruction const* insn,
bool is_range) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_InvokeSuper(uint32_t dex_pc,
Instruction const* insn,
bool is_range) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_InvokeDirect(uint32_t dex_pc,
Instruction const* insn,
bool is_range) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_InvokeStatic(uint32_t dex_pc,
Instruction const* insn,
bool is_range) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_InvokeInterface(uint32_t dex_pc,
Instruction const* insn,
bool is_range) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_Neg(uint32_t dex_pc,
Instruction const* insn,
JType op_jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_Not(uint32_t dex_pc,
Instruction const* insn,
JType op_jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_SExt(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_Trunc(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_TruncAndSExt(uint32_t dex_pc,
Instruction const* insn,
unsigned N) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_TruncAndZExt(uint32_t dex_pc,
Instruction const* insn,
unsigned N) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_FNeg(uint32_t dex_pc,
Instruction const* insn,
JType op_jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_IntToFP(uint32_t dex_pc,
Instruction const* insn,
JType src_jty,
JType dest_jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_FPToInt(uint32_t dex_pc,
Instruction const* insn,
JType src_jty,
JType dest_jty) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_FExt(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_FTrunc(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_IntArithm(uint32_t dex_pc,
Instruction const* insn,
IntArithmKind arithm,
JType op_jty,
bool is_2addr) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_IntArithmImmediate(uint32_t dex_pc,
Instruction const* insn,
IntArithmKind arithm) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_RSubImmediate(uint32_t dex_pc,
Instruction const* insn) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
void MethodCompiler::EmitInsn_FPArithm(uint32_t dex_pc,
Instruction const* insn,
FPArithmKind arithm,
JType op_jty,
bool is_2addr) {
// UNIMPLEMENTED(WARNING);
irb_.CreateBr(GetNextBasicBlock(dex_pc));
}
CompiledMethod *MethodCompiler::Compile() {
// Code generation
CreateFunction();
EmitPrologue();
EmitInstructions();
EmitPrologueLastBranch();
// Verify the generated bitcode
llvm::verifyFunction(*func_, llvm::PrintMessageAction);
// Delete the inferred register category map (won't be used anymore)
method_->ResetInferredRegCategoryMap();
return new CompiledMethod(insn_set_, func_);
}
llvm::Value* MethodCompiler::EmitLoadMethodObjectAddr() {
return func_->arg_begin();
}
void MethodCompiler::EmitBranchExceptionLandingPad(uint32_t dex_pc) {
if (llvm::BasicBlock* lpad = GetLandingPadBasicBlock(dex_pc)) {
irb_.CreateBr(lpad);
} else {
irb_.CreateBr(GetUnwindBasicBlock());
}
}
void MethodCompiler::EmitGuard_ExceptionLandingPad(uint32_t dex_pc) {
llvm::Value* exception_pending =
irb_.CreateCall(irb_.GetRuntime(IsExceptionPending));
llvm::BasicBlock* block_cont = CreateBasicBlockWithDexPC(dex_pc, "cont");
if (llvm::BasicBlock* lpad = GetLandingPadBasicBlock(dex_pc)) {
irb_.CreateCondBr(exception_pending, lpad, block_cont);
} else {
irb_.CreateCondBr(exception_pending, GetUnwindBasicBlock(), block_cont);
}
irb_.SetInsertPoint(block_cont);
}
void MethodCompiler::EmitGuard_GarbageCollectionSuspend(uint32_t dex_pc) {
llvm::Value* runtime_func = irb_.GetRuntime(TestSuspend);
irb_.CreateCall(runtime_func);
EmitGuard_ExceptionLandingPad(dex_pc);
}
llvm::BasicBlock* MethodCompiler::
CreateBasicBlockWithDexPC(uint32_t dex_pc, char const* postfix) {
std::string name;
if (postfix) {
StringAppendF(&name, "B%u.%s", dex_pc, postfix);
} else {
StringAppendF(&name, "B%u", dex_pc);
}
return llvm::BasicBlock::Create(*context_, name, func_);
}
llvm::BasicBlock* MethodCompiler::GetBasicBlock(uint32_t dex_pc) {
DCHECK(dex_pc < code_item_->insns_size_in_code_units_);
llvm::BasicBlock* basic_block = basic_blocks_[dex_pc];
if (!basic_block) {
basic_block = CreateBasicBlockWithDexPC(dex_pc);
basic_blocks_[dex_pc] = basic_block;
}
return basic_block;
}
llvm::BasicBlock*
MethodCompiler::GetNextBasicBlock(uint32_t dex_pc) {
Instruction const* insn = Instruction::At(code_item_->insns_ + dex_pc);
return GetBasicBlock(dex_pc + insn->SizeInCodeUnits());
}
int32_t MethodCompiler::GetTryItemOffset(uint32_t dex_pc) {
// TODO: Since we are emitting the dex instructions in ascending order
// w.r.t. address, we can cache the lastest try item offset so that we
// don't have to do binary search for every query.
int32_t min = 0;
int32_t max = code_item_->tries_size_ - 1;
while (min <= max) {
int32_t mid = min + (max - min) / 2;
DexFile::TryItem const* ti = DexFile::GetTryItems(*code_item_, mid);
uint32_t start = ti->start_addr_;
uint32_t end = start + ti->insn_count_;
if (dex_pc < start) {
max = mid - 1;
} else if (dex_pc >= end) {
min = mid + 1;
} else {
return mid; // found
}
}
return -1; // not found
}
llvm::BasicBlock* MethodCompiler::GetLandingPadBasicBlock(uint32_t dex_pc) {
// Find the try item for this address in this method
int32_t ti_offset = GetTryItemOffset(dex_pc);
if (ti_offset == -1) {
return NULL; // No landing pad is available for this address.
}
// Check for the existing landing pad basic block
DCHECK_GT(basic_block_landing_pads_.size(), static_cast<size_t>(ti_offset));
llvm::BasicBlock* block_lpad = basic_block_landing_pads_[ti_offset];
if (block_lpad) {
// We have generated landing pad for this try item already. Return the
// same basic block.
return block_lpad;
}
// Get try item from code item
DexFile::TryItem const* ti = DexFile::GetTryItems(*code_item_, ti_offset);
// Create landing pad basic block
block_lpad = llvm::BasicBlock::Create(*context_,
StringPrintf("lpad%d", ti_offset),
func_);
// Change IRBuilder insert point
llvm::IRBuilderBase::InsertPoint irb_ip_original = irb_.saveIP();
irb_.SetInsertPoint(block_lpad);
// Find catch block with matching type
llvm::Value* method_object_addr = EmitLoadMethodObjectAddr();
// TODO: Maybe passing try item offset will be a better idea? For now,
// we are passing dex_pc, so that we can use existing runtime support
// function directly. However, in the runtime supporting function we
// have to search for try item with binary search which can be
// eliminated.
llvm::Value* dex_pc_value = irb_.getInt32(ti->start_addr_);
llvm::Value* catch_handler_index_value =
irb_.CreateCall2(irb_.GetRuntime(FindCatchBlock),
method_object_addr, dex_pc_value);
// Switch instruction (Go to unwind basic block by default)
llvm::SwitchInst* sw =
irb_.CreateSwitch(catch_handler_index_value, GetUnwindBasicBlock());
// Cases with matched catch block
CatchHandlerIterator iter(*code_item_, ti->start_addr_);
for (uint32_t c = 0; iter.HasNext(); iter.Next(), ++c) {
sw->addCase(irb_.getInt32(c), GetBasicBlock(iter.GetHandlerAddress()));
}
// Restore the orignal insert point for IRBuilder
irb_.restoreIP(irb_ip_original);
// Cache this landing pad
DCHECK_GT(basic_block_landing_pads_.size(), static_cast<size_t>(ti_offset));
basic_block_landing_pads_[ti_offset] = block_lpad;
return block_lpad;
}
llvm::BasicBlock* MethodCompiler::GetUnwindBasicBlock() {
// Check the existing unwinding baisc block block
if (basic_block_unwind_ != NULL) {
return basic_block_unwind_;
}
// Create new basic block for unwinding
basic_block_unwind_ =
llvm::BasicBlock::Create(*context_, "exception_unwind", func_);
// Change IRBuilder insert point
llvm::IRBuilderBase::InsertPoint irb_ip_original = irb_.saveIP();
irb_.SetInsertPoint(basic_block_unwind_);
// Emit the code to return default value (zero) for the given return type.
char ret_shorty = method_helper_.GetShorty()[0];
if (ret_shorty == 'V') {
irb_.CreateRetVoid();
} else {
irb_.CreateRet(irb_.getJZero(ret_shorty));
}
// Restore the orignal insert point for IRBuilder
irb_.restoreIP(irb_ip_original);
return basic_block_unwind_;
}
llvm::Value* MethodCompiler::AllocDalvikLocalVarReg(RegCategory cat,
uint32_t reg_idx) {
// Save current IR builder insert point
llvm::IRBuilderBase::InsertPoint irb_ip_original = irb_.saveIP();
// Alloca
llvm::Value* reg_addr = NULL;
switch (cat) {
case kRegCat1nr:
irb_.SetInsertPoint(basic_block_reg_alloca_);
reg_addr = irb_.CreateAlloca(irb_.getJIntTy(), 0,
StringPrintf("r%u", reg_idx));
irb_.SetInsertPoint(basic_block_reg_zero_init_);
irb_.CreateStore(irb_.getJInt(0), reg_addr);
break;
case kRegCat2:
irb_.SetInsertPoint(basic_block_reg_alloca_);
reg_addr = irb_.CreateAlloca(irb_.getJLongTy(), 0,
StringPrintf("w%u", reg_idx));
irb_.SetInsertPoint(basic_block_reg_zero_init_);
irb_.CreateStore(irb_.getJLong(0), reg_addr);
break;
case kRegObject:
irb_.SetInsertPoint(basic_block_reg_alloca_);
reg_addr = irb_.CreateAlloca(irb_.getJObjectTy(), 0,
StringPrintf("p%u", reg_idx));
irb_.SetInsertPoint(basic_block_reg_zero_init_);
irb_.CreateStore(irb_.getJNull(), reg_addr);
break;
default:
LOG(FATAL) << "Unknown register category for allocation: " << cat;
}
// Restore IRBuilder insert point
irb_.restoreIP(irb_ip_original);
DCHECK_NE(reg_addr, static_cast<llvm::Value*>(NULL));
return reg_addr;
}
llvm::Value* MethodCompiler::AllocDalvikRetValReg(RegCategory cat) {
// Save current IR builder insert point
llvm::IRBuilderBase::InsertPoint irb_ip_original = irb_.saveIP();
// Alloca
llvm::Value* reg_addr = NULL;
switch (cat) {
case kRegCat1nr:
irb_.SetInsertPoint(basic_block_reg_alloca_);
reg_addr = irb_.CreateAlloca(irb_.getJIntTy(), 0, "r_res");
break;
case kRegCat2:
irb_.SetInsertPoint(basic_block_reg_alloca_);
reg_addr = irb_.CreateAlloca(irb_.getJLongTy(), 0, "w_res");
break;
case kRegObject:
irb_.SetInsertPoint(basic_block_reg_alloca_);
reg_addr = irb_.CreateAlloca(irb_.getJObjectTy(), 0, "p_res");
break;
default:
LOG(FATAL) << "Unknown register category for allocation: " << cat;
}
// Restore IRBuilder insert point
irb_.restoreIP(irb_ip_original);
DCHECK_NE(reg_addr, static_cast<llvm::Value*>(NULL));
return reg_addr;
}
} // namespace compiler_llvm
} // namespace art