Google Git
Sign in
android / platform / art / 52a77fc / . / src / compiler / codegen / gen_common.cc
blob: af7d4e004ea3c118bd76bdd9df85dfc3010a88c5 [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 "oat/runtime/oat_support_entrypoints.h"
#include "../compiler_ir.h"
#include "ralloc_util.h"
#include "codegen_util.h"
namespace art {
//TODO: remove decl.
void GenInvoke(CompilationUnit* cUnit, CallInfo* info);
/*
* This source files contains "gen" codegen routines that should
* be applicable to most targets. Only mid-level support utilities
* and "op" calls may be used here.
*/
void MarkSafepointPC(CompilationUnit* cUnit, LIR* inst)
{
inst->defMask = ENCODE_ALL;
LIR* safepointPC = NewLIR0(cUnit, kPseudoSafepointPC);
DCHECK_EQ(safepointPC->defMask, ENCODE_ALL);
}
/*
* To save scheduling time, helper calls are broken into two parts: generation of
* the helper target address, and the actuall call to the helper. Because x86
* has a memory call operation, part 1 is a NOP for x86. For other targets,
* load arguments between the two parts.
*/
int CallHelperSetup(CompilationUnit* cUnit, int helperOffset)
{
return (cUnit->instructionSet == kX86) ? 0 : LoadHelper(cUnit, helperOffset);
}
/* NOTE: if rTgt is a temp, it will be freed following use */
LIR* CallHelper(CompilationUnit* cUnit, int rTgt, int helperOffset, bool safepointPC)
{
LIR* callInst;
if (cUnit->instructionSet == kX86) {
callInst = OpThreadMem(cUnit, kOpBlx, helperOffset);
} else {
callInst = OpReg(cUnit, kOpBlx, rTgt);
FreeTemp(cUnit, rTgt);
}
if (safepointPC) {
MarkSafepointPC(cUnit, callInst);
}
return callInst;
}
void CallRuntimeHelperImm(CompilationUnit* cUnit, int helperOffset, int arg0, bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
LoadConstant(cUnit, TargetReg(kArg0), arg0);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperReg(CompilationUnit* cUnit, int helperOffset, int arg0, bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
OpRegCopy(cUnit, TargetReg(kArg0), arg0);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperRegLocation(CompilationUnit* cUnit, int helperOffset, RegLocation arg0,
bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
if (arg0.wide == 0) {
LoadValueDirectFixed(cUnit, arg0, TargetReg(kArg0));
} else {
LoadValueDirectWideFixed(cUnit, arg0, TargetReg(kArg0), TargetReg(kArg1));
}
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperImmImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1,
bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
LoadConstant(cUnit, TargetReg(kArg0), arg0);
LoadConstant(cUnit, TargetReg(kArg1), arg1);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperImmRegLocation(CompilationUnit* cUnit, int helperOffset, int arg0,
RegLocation arg1, bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
if (arg1.wide == 0) {
LoadValueDirectFixed(cUnit, arg1, TargetReg(kArg1));
} else {
LoadValueDirectWideFixed(cUnit, arg1, TargetReg(kArg1), TargetReg(kArg2));
}
LoadConstant(cUnit, TargetReg(kArg0), arg0);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperRegLocationImm(CompilationUnit* cUnit, int helperOffset, RegLocation arg0,
int arg1, bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
LoadValueDirectFixed(cUnit, arg0, TargetReg(kArg0));
LoadConstant(cUnit, TargetReg(kArg1), arg1);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperImmReg(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1,
bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
OpRegCopy(cUnit, TargetReg(kArg1), arg1);
LoadConstant(cUnit, TargetReg(kArg0), arg0);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperRegImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1,
bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
OpRegCopy(cUnit, TargetReg(kArg0), arg0);
LoadConstant(cUnit, TargetReg(kArg1), arg1);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperImmMethod(CompilationUnit* cUnit, int helperOffset, int arg0, bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
LoadCurrMethodDirect(cUnit, TargetReg(kArg1));
LoadConstant(cUnit, TargetReg(kArg0), arg0);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperRegLocationRegLocation(CompilationUnit* cUnit, int helperOffset,
RegLocation arg0, RegLocation arg1, bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
if (arg0.wide == 0) {
LoadValueDirectFixed(cUnit, arg0, arg0.fp ? TargetReg(kFArg0) : TargetReg(kArg0));
if (arg1.wide == 0) {
if (cUnit->instructionSet == kMips) {
LoadValueDirectFixed(cUnit, arg1, arg1.fp ? TargetReg(kFArg2) : TargetReg(kArg1));
} else {
LoadValueDirectFixed(cUnit, arg1, TargetReg(kArg1));
}
} else {
if (cUnit->instructionSet == kMips) {
LoadValueDirectWideFixed(cUnit, arg1, arg1.fp ? TargetReg(kFArg2) : TargetReg(kArg1), arg1.fp ? TargetReg(kFArg3) : TargetReg(kArg2));
} else {
LoadValueDirectWideFixed(cUnit, arg1, TargetReg(kArg1), TargetReg(kArg2));
}
}
} else {
LoadValueDirectWideFixed(cUnit, arg0, arg0.fp ? TargetReg(kFArg0) : TargetReg(kArg0), arg0.fp ? TargetReg(kFArg1) : TargetReg(kArg1));
if (arg1.wide == 0) {
LoadValueDirectFixed(cUnit, arg1, arg1.fp ? TargetReg(kFArg2) : TargetReg(kArg2));
} else {
LoadValueDirectWideFixed(cUnit, arg1, arg1.fp ? TargetReg(kFArg2) : TargetReg(kArg2), arg1.fp ? TargetReg(kFArg3) : TargetReg(kArg3));
}
}
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperRegReg(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1,
bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
DCHECK_NE(TargetReg(kArg0), arg1); // check copy into arg0 won't clobber arg1
OpRegCopy(cUnit, TargetReg(kArg0), arg0);
OpRegCopy(cUnit, TargetReg(kArg1), arg1);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperRegRegImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1,
int arg2, bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
DCHECK_NE(TargetReg(kArg0), arg1); // check copy into arg0 won't clobber arg1
OpRegCopy(cUnit, TargetReg(kArg0), arg0);
OpRegCopy(cUnit, TargetReg(kArg1), arg1);
LoadConstant(cUnit, TargetReg(kArg2), arg2);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperImmMethodRegLocation(CompilationUnit* cUnit, int helperOffset, int arg0,
RegLocation arg2, bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
LoadValueDirectFixed(cUnit, arg2, TargetReg(kArg2));
LoadCurrMethodDirect(cUnit, TargetReg(kArg1));
LoadConstant(cUnit, TargetReg(kArg0), arg0);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperImmMethodImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg2,
bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
LoadCurrMethodDirect(cUnit, TargetReg(kArg1));
LoadConstant(cUnit, TargetReg(kArg2), arg2);
LoadConstant(cUnit, TargetReg(kArg0), arg0);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
void CallRuntimeHelperImmRegLocationRegLocation(CompilationUnit* cUnit, int helperOffset,
int arg0, RegLocation arg1, RegLocation arg2,
bool safepointPC) {
int rTgt = CallHelperSetup(cUnit, helperOffset);
LoadValueDirectFixed(cUnit, arg1, TargetReg(kArg1));
if (arg2.wide == 0) {
LoadValueDirectFixed(cUnit, arg2, TargetReg(kArg2));
} else {
LoadValueDirectWideFixed(cUnit, arg2, TargetReg(kArg2), TargetReg(kArg3));
}
LoadConstant(cUnit, TargetReg(kArg0), arg0);
ClobberCalleeSave(cUnit);
CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
/*
* Generate an kPseudoBarrier marker to indicate the boundary of special
* blocks.
*/
void GenBarrier(CompilationUnit* cUnit)
{
LIR* barrier = NewLIR0(cUnit, kPseudoBarrier);
/* Mark all resources as being clobbered */
barrier->defMask = -1;
}
/* Generate unconditional branch instructions */
LIR* OpUnconditionalBranch(CompilationUnit* cUnit, LIR* target)
{
LIR* branch = OpBranchUnconditional(cUnit, kOpUncondBr);
branch->target = target;
return branch;
}
// FIXME: need to do some work to split out targets with
// condition codes and those without
LIR* GenCheck(CompilationUnit* cUnit, ConditionCode cCode,
ThrowKind kind)
{
DCHECK_NE(cUnit->instructionSet, kMips);
LIR* tgt = RawLIR(cUnit, 0, kPseudoThrowTarget, kind,
cUnit->currentDalvikOffset);
LIR* branch = OpCondBranch(cUnit, cCode, tgt);
// Remember branch target - will process later
InsertGrowableList(cUnit, &cUnit->throwLaunchpads, reinterpret_cast<uintptr_t>(tgt));
return branch;
}
LIR* GenImmedCheck(CompilationUnit* cUnit, ConditionCode cCode,
int reg, int immVal, ThrowKind kind)
{
LIR* tgt = RawLIR(cUnit, 0, kPseudoThrowTarget, kind,
cUnit->currentDalvikOffset);
LIR* branch;
if (cCode == kCondAl) {
branch = OpUnconditionalBranch(cUnit, tgt);
} else {
branch = OpCmpImmBranch(cUnit, cCode, reg, immVal, tgt);
}
// Remember branch target - will process later
InsertGrowableList(cUnit, &cUnit->throwLaunchpads, reinterpret_cast<uintptr_t>(tgt));
return branch;
}
/* Perform null-check on a register. */
LIR* GenNullCheck(CompilationUnit* cUnit, int sReg, int mReg, int optFlags)
{
if (!(cUnit->disableOpt & (1 << kNullCheckElimination)) &&
optFlags & MIR_IGNORE_NULL_CHECK) {
return NULL;
}
return GenImmedCheck(cUnit, kCondEq, mReg, 0, kThrowNullPointer);
}
/* Perform check on two registers */
LIR* GenRegRegCheck(CompilationUnit* cUnit, ConditionCode cCode,
int reg1, int reg2, ThrowKind kind)
{
LIR* tgt = RawLIR(cUnit, 0, kPseudoThrowTarget, kind,
cUnit->currentDalvikOffset, reg1, reg2);
LIR* branch = OpCmpBranch(cUnit, cCode, reg1, reg2, tgt);
// Remember branch target - will process later
InsertGrowableList(cUnit, &cUnit->throwLaunchpads, reinterpret_cast<uintptr_t>(tgt));
return branch;
}
void GenCompareAndBranch(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlSrc1, RegLocation rlSrc2, LIR* taken,
LIR* fallThrough)
{
ConditionCode cond;
rlSrc1 = LoadValue(cUnit, rlSrc1, kCoreReg);
rlSrc2 = LoadValue(cUnit, rlSrc2, kCoreReg);
switch (opcode) {
case Instruction::IF_EQ:
cond = kCondEq;
break;
case Instruction::IF_NE:
cond = kCondNe;
break;
case Instruction::IF_LT:
cond = kCondLt;
break;
case Instruction::IF_GE:
cond = kCondGe;
break;
case Instruction::IF_GT:
cond = kCondGt;
break;
case Instruction::IF_LE:
cond = kCondLe;
break;
default:
cond = static_cast<ConditionCode>(0);
LOG(FATAL) << "Unexpected opcode " << opcode;
}
OpCmpBranch(cUnit, cond, rlSrc1.lowReg, rlSrc2.lowReg, taken);
OpUnconditionalBranch(cUnit, fallThrough);
}
void GenCompareZeroAndBranch(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlSrc, LIR* taken, LIR* fallThrough)
{
ConditionCode cond;
rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
switch (opcode) {
case Instruction::IF_EQZ:
cond = kCondEq;
break;
case Instruction::IF_NEZ:
cond = kCondNe;
break;
case Instruction::IF_LTZ:
cond = kCondLt;
break;
case Instruction::IF_GEZ:
cond = kCondGe;
break;
case Instruction::IF_GTZ:
cond = kCondGt;
break;
case Instruction::IF_LEZ:
cond = kCondLe;
break;
default:
cond = static_cast<ConditionCode>(0);
LOG(FATAL) << "Unexpected opcode " << opcode;
}
if (cUnit->instructionSet == kThumb2) {
OpRegImm(cUnit, kOpCmp, rlSrc.lowReg, 0);
OpCondBranch(cUnit, cond, taken);
} else {
OpCmpImmBranch(cUnit, cond, rlSrc.lowReg, 0, taken);
}
OpUnconditionalBranch(cUnit, fallThrough);
}
void GenIntToLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
if (rlSrc.location == kLocPhysReg) {
OpRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
} else {
LoadValueDirect(cUnit, rlSrc, rlResult.lowReg);
}
OpRegRegImm(cUnit, kOpAsr, rlResult.highReg, rlResult.lowReg, 31);
StoreValueWide(cUnit, rlDest, rlResult);
}
void GenIntNarrowing(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc)
{
rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
OpKind op = kOpInvalid;
switch (opcode) {
case Instruction::INT_TO_BYTE:
op = kOp2Byte;
break;
case Instruction::INT_TO_SHORT:
op = kOp2Short;
break;
case Instruction::INT_TO_CHAR:
op = kOp2Char;
break;
default:
LOG(ERROR) << "Bad int conversion type";
}
OpRegReg(cUnit, op, rlResult.lowReg, rlSrc.lowReg);
StoreValue(cUnit, rlDest, rlResult);
}
/*
* Let helper function take care of everything. Will call
* Array::AllocFromCode(type_idx, method, count);
* Note: AllocFromCode will handle checks for errNegativeArraySize.
*/
void GenNewArray(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest,
RegLocation rlSrc)
{
FlushAllRegs(cUnit); /* Everything to home location */
int funcOffset;
if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
*cUnit->dex_file,
type_idx)) {
funcOffset = ENTRYPOINT_OFFSET(pAllocArrayFromCode);
} else {
funcOffset= ENTRYPOINT_OFFSET(pAllocArrayFromCodeWithAccessCheck);
}
CallRuntimeHelperImmMethodRegLocation(cUnit, funcOffset, type_idx, rlSrc, true);
RegLocation rlResult = GetReturn(cUnit, false);
StoreValue(cUnit, rlDest, rlResult);
}
/*
* Similar to GenNewArray, but with post-allocation initialization.
* Verifier guarantees we're dealing with an array class. Current
* code throws runtime exception "bad Filled array req" for 'D' and 'J'.
* Current code also throws internal unimp if not 'L', '[' or 'I'.
*/
void GenFilledNewArray(CompilationUnit* cUnit, CallInfo* info)
{
int elems = info->numArgWords;
int typeIdx = info->index;
FlushAllRegs(cUnit); /* Everything to home location */
int funcOffset;
if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
*cUnit->dex_file,
typeIdx)) {
funcOffset = ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCode);
} else {
funcOffset = ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCodeWithAccessCheck);
}
CallRuntimeHelperImmMethodImm(cUnit, funcOffset, typeIdx, elems, true);
FreeTemp(cUnit, TargetReg(kArg2));
FreeTemp(cUnit, TargetReg(kArg1));
/*
* NOTE: the implicit target for Instruction::FILLED_NEW_ARRAY is the
* return region. Because AllocFromCode placed the new array
* in kRet0, we'll just lock it into place. When debugger support is
* added, it may be necessary to additionally copy all return
* values to a home location in thread-local storage
*/
LockTemp(cUnit, TargetReg(kRet0));
// TODO: use the correct component size, currently all supported types
// share array alignment with ints (see comment at head of function)
size_t component_size = sizeof(int32_t);
// Having a range of 0 is legal
if (info->isRange && (elems > 0)) {
/*
* Bit of ugliness here. We're going generate a mem copy loop
* on the register range, but it is possible that some regs
* in the range have been promoted. This is unlikely, but
* before generating the copy, we'll just force a flush
* of any regs in the source range that have been promoted to
* home location.
*/
for (int i = 0; i < elems; i++) {
RegLocation loc = UpdateLoc(cUnit, info->args[i]);
if (loc.location == kLocPhysReg) {
StoreBaseDisp(cUnit, TargetReg(kSp), SRegOffset(cUnit, loc.sRegLow),
loc.lowReg, kWord);
}
}
/*
* TUNING note: generated code here could be much improved, but
* this is an uncommon operation and isn't especially performance
* critical.
*/
int rSrc = AllocTemp(cUnit);
int rDst = AllocTemp(cUnit);
int rIdx = AllocTemp(cUnit);
int rVal = INVALID_REG;
switch(cUnit->instructionSet) {
case kThumb2:
rVal = TargetReg(kLr);
break;
case kX86:
FreeTemp(cUnit, TargetReg(kRet0));
rVal = AllocTemp(cUnit);
break;
case kMips:
rVal = AllocTemp(cUnit);
break;
default: LOG(FATAL) << "Unexpected instruction set: " << cUnit->instructionSet;
}
// Set up source pointer
RegLocation rlFirst = info->args[0];
OpRegRegImm(cUnit, kOpAdd, rSrc, TargetReg(kSp),
SRegOffset(cUnit, rlFirst.sRegLow));
// Set up the target pointer
OpRegRegImm(cUnit, kOpAdd, rDst, TargetReg(kRet0),
Array::DataOffset(component_size).Int32Value());
// Set up the loop counter (known to be > 0)
LoadConstant(cUnit, rIdx, elems - 1);
// Generate the copy loop. Going backwards for convenience
LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
// Copy next element
LoadBaseIndexed(cUnit, rSrc, rIdx, rVal, 2, kWord);
StoreBaseIndexed(cUnit, rDst, rIdx, rVal, 2, kWord);
FreeTemp(cUnit, rVal);
OpDecAndBranch(cUnit, kCondGe, rIdx, target);
if (cUnit->instructionSet == kX86) {
// Restore the target pointer
OpRegRegImm(cUnit, kOpAdd, TargetReg(kRet0), rDst, -Array::DataOffset(component_size).Int32Value());
}
} else if (!info->isRange) {
// TUNING: interleave
for (int i = 0; i < elems; i++) {
RegLocation rlArg = LoadValue(cUnit, info->args[i], kCoreReg);
StoreBaseDisp(cUnit, TargetReg(kRet0),
Array::DataOffset(component_size).Int32Value() +
i * 4, rlArg.lowReg, kWord);
// If the LoadValue caused a temp to be allocated, free it
if (IsTemp(cUnit, rlArg.lowReg)) {
FreeTemp(cUnit, rlArg.lowReg);
}
}
}
if (info->result.location != kLocInvalid) {
StoreValue(cUnit, info->result, GetReturn(cUnit, false /* not fp */));
}
}
void GenSput(CompilationUnit* cUnit, uint32_t fieldIdx, RegLocation rlSrc,
bool isLongOrDouble, bool isObject)
{
int fieldOffset;
int ssbIndex;
bool isVolatile;
bool isReferrersClass;
OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker, *cUnit->dex_file,
cUnit->code_item, cUnit->method_idx, cUnit->access_flags);
bool fastPath =
cUnit->compiler->ComputeStaticFieldInfo(fieldIdx, &mUnit,
fieldOffset, ssbIndex,
isReferrersClass, isVolatile,
true);
if (fastPath && !SLOW_FIELD_PATH) {
DCHECK_GE(fieldOffset, 0);
int rBase;
if (isReferrersClass) {
// Fast path, static storage base is this method's class
RegLocation rlMethod = LoadCurrMethod(cUnit);
rBase = AllocTemp(cUnit);
LoadWordDisp(cUnit, rlMethod.lowReg,
AbstractMethod::DeclaringClassOffset().Int32Value(), rBase);
if (IsTemp(cUnit, rlMethod.lowReg)) {
FreeTemp(cUnit, rlMethod.lowReg);
}
} else {
// Medium path, static storage base in a different class which
// requires checks that the other class is initialized.
DCHECK_GE(ssbIndex, 0);
// May do runtime call so everything to home locations.
FlushAllRegs(cUnit);
// Using fixed register to sync with possible call to runtime
// support.
int rMethod = TargetReg(kArg1);
LockTemp(cUnit, rMethod);
LoadCurrMethodDirect(cUnit, rMethod);
rBase = TargetReg(kArg0);
LockTemp(cUnit, rBase);
LoadWordDisp(cUnit, rMethod,
AbstractMethod::DexCacheInitializedStaticStorageOffset().Int32Value(),
rBase);
LoadWordDisp(cUnit, rBase,
Array::DataOffset(sizeof(Object*)).Int32Value() +
sizeof(int32_t*) * ssbIndex, rBase);
// rBase now points at appropriate static storage base (Class*)
// or NULL if not initialized. Check for NULL and call helper if NULL.
// TUNING: fast path should fall through
LIR* branchOver = OpCmpImmBranch(cUnit, kCondNe, rBase, 0, NULL);
LoadConstant(cUnit, TargetReg(kArg0), ssbIndex);
CallRuntimeHelperImm(cUnit, ENTRYPOINT_OFFSET(pInitializeStaticStorage), ssbIndex, true);
if (cUnit->instructionSet == kMips) {
// For Arm, kRet0 = kArg0 = rBase, for Mips, we need to copy
OpRegCopy(cUnit, rBase, TargetReg(kRet0));
}
LIR* skipTarget = NewLIR0(cUnit, kPseudoTargetLabel);
branchOver->target = skipTarget;
FreeTemp(cUnit, rMethod);
}
// rBase now holds static storage base
if (isLongOrDouble) {
rlSrc = LoadValueWide(cUnit, rlSrc, kAnyReg);
} else {
rlSrc = LoadValue(cUnit, rlSrc, kAnyReg);
}
if (isVolatile) {
GenMemBarrier(cUnit, kStoreStore);
}
if (isLongOrDouble) {
StoreBaseDispWide(cUnit, rBase, fieldOffset, rlSrc.lowReg,
rlSrc.highReg);
} else {
StoreWordDisp(cUnit, rBase, fieldOffset, rlSrc.lowReg);
}
if (isVolatile) {
GenMemBarrier(cUnit, kStoreLoad);
}
if (isObject) {
MarkGCCard(cUnit, rlSrc.lowReg, rBase);
}
FreeTemp(cUnit, rBase);
} else {
FlushAllRegs(cUnit); // Everything to home locations
int setterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pSet64Static) :
(isObject ? ENTRYPOINT_OFFSET(pSetObjStatic)
: ENTRYPOINT_OFFSET(pSet32Static));
CallRuntimeHelperImmRegLocation(cUnit, setterOffset, fieldIdx, rlSrc, true);
}
}
void GenSget(CompilationUnit* cUnit, uint32_t fieldIdx, RegLocation rlDest,
bool isLongOrDouble, bool isObject)
{
int fieldOffset;
int ssbIndex;
bool isVolatile;
bool isReferrersClass;
OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
*cUnit->dex_file,
cUnit->code_item, cUnit->method_idx,
cUnit->access_flags);
bool fastPath =
cUnit->compiler->ComputeStaticFieldInfo(fieldIdx, &mUnit,
fieldOffset, ssbIndex,
isReferrersClass, isVolatile,
false);
if (fastPath && !SLOW_FIELD_PATH) {
DCHECK_GE(fieldOffset, 0);
int rBase;
if (isReferrersClass) {
// Fast path, static storage base is this method's class
RegLocation rlMethod = LoadCurrMethod(cUnit);
rBase = AllocTemp(cUnit);
LoadWordDisp(cUnit, rlMethod.lowReg,
AbstractMethod::DeclaringClassOffset().Int32Value(), rBase);
} else {
// Medium path, static storage base in a different class which
// requires checks that the other class is initialized
DCHECK_GE(ssbIndex, 0);
// May do runtime call so everything to home locations.
FlushAllRegs(cUnit);
// Using fixed register to sync with possible call to runtime
// support
int rMethod = TargetReg(kArg1);
LockTemp(cUnit, rMethod);
LoadCurrMethodDirect(cUnit, rMethod);
rBase = TargetReg(kArg0);
LockTemp(cUnit, rBase);
LoadWordDisp(cUnit, rMethod,
AbstractMethod::DexCacheInitializedStaticStorageOffset().Int32Value(),
rBase);
LoadWordDisp(cUnit, rBase,
Array::DataOffset(sizeof(Object*)).Int32Value() +
sizeof(int32_t*) * ssbIndex, rBase);
// rBase now points at appropriate static storage base (Class*)
// or NULL if not initialized. Check for NULL and call helper if NULL.
// TUNING: fast path should fall through
LIR* branchOver = OpCmpImmBranch(cUnit, kCondNe, rBase, 0, NULL);
CallRuntimeHelperImm(cUnit, ENTRYPOINT_OFFSET(pInitializeStaticStorage), ssbIndex, true);
if (cUnit->instructionSet == kMips) {
// For Arm, kRet0 = kArg0 = rBase, for Mips, we need to copy
OpRegCopy(cUnit, rBase, TargetReg(kRet0));
}
LIR* skipTarget = NewLIR0(cUnit, kPseudoTargetLabel);
branchOver->target = skipTarget;
FreeTemp(cUnit, rMethod);
}
// rBase now holds static storage base
RegLocation rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
if (isVolatile) {
GenMemBarrier(cUnit, kLoadLoad);
}
if (isLongOrDouble) {
LoadBaseDispWide(cUnit, rBase, fieldOffset, rlResult.lowReg,
rlResult.highReg, INVALID_SREG);
} else {
LoadWordDisp(cUnit, rBase, fieldOffset, rlResult.lowReg);
}
FreeTemp(cUnit, rBase);
if (isLongOrDouble) {
StoreValueWide(cUnit, rlDest, rlResult);
} else {
StoreValue(cUnit, rlDest, rlResult);
}
} else {
FlushAllRegs(cUnit); // Everything to home locations
int getterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pGet64Static) :
(isObject ? ENTRYPOINT_OFFSET(pGetObjStatic)
: ENTRYPOINT_OFFSET(pGet32Static));
CallRuntimeHelperImm(cUnit, getterOffset, fieldIdx, true);
if (isLongOrDouble) {
RegLocation rlResult = GetReturnWide(cUnit, rlDest.fp);
StoreValueWide(cUnit, rlDest, rlResult);
} else {
RegLocation rlResult = GetReturn(cUnit, rlDest.fp);
StoreValue(cUnit, rlDest, rlResult);
}
}
}
// Debugging routine - if null target, branch to DebugMe
void GenShowTarget(CompilationUnit* cUnit)
{
DCHECK_NE(cUnit->instructionSet, kX86) << "unimplemented GenShowTarget";
LIR* branchOver = OpCmpImmBranch(cUnit, kCondNe, TargetReg(kInvokeTgt), 0, NULL);
LoadWordDisp(cUnit, TargetReg(kSelf), ENTRYPOINT_OFFSET(pDebugMe), TargetReg(kInvokeTgt));
LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
branchOver->target = target;
}
void HandleSuspendLaunchPads(CompilationUnit *cUnit)
{
LIR** suspendLabel = reinterpret_cast<LIR**>(cUnit->suspendLaunchpads.elemList);
int numElems = cUnit->suspendLaunchpads.numUsed;
int helperOffset = ENTRYPOINT_OFFSET(pTestSuspendFromCode);
for (int i = 0; i < numElems; i++) {
ResetRegPool(cUnit);
ResetDefTracking(cUnit);
LIR* lab = suspendLabel[i];
LIR* resumeLab = reinterpret_cast<LIR*>(lab->operands[0]);
cUnit->currentDalvikOffset = lab->operands[1];
AppendLIR(cUnit, lab);
int rTgt = CallHelperSetup(cUnit, helperOffset);
CallHelper(cUnit, rTgt, helperOffset, true /* MarkSafepointPC */);
OpUnconditionalBranch(cUnit, resumeLab);
}
}
void HandleIntrinsicLaunchPads(CompilationUnit *cUnit)
{
LIR** intrinsicLabel = reinterpret_cast<LIR**>(cUnit->intrinsicLaunchpads.elemList);
int numElems = cUnit->intrinsicLaunchpads.numUsed;
for (int i = 0; i < numElems; i++) {
ResetRegPool(cUnit);
ResetDefTracking(cUnit);
LIR* lab = intrinsicLabel[i];
CallInfo* info = reinterpret_cast<CallInfo*>(lab->operands[0]);
cUnit->currentDalvikOffset = info->offset;
AppendLIR(cUnit, lab);
// NOTE: GenInvoke handles MarkSafepointPC
GenInvoke(cUnit, info);
LIR* resumeLab = reinterpret_cast<LIR*>(lab->operands[2]);
if (resumeLab != NULL) {
OpUnconditionalBranch(cUnit, resumeLab);
}
}
}
void HandleThrowLaunchPads(CompilationUnit *cUnit)
{
LIR** throwLabel = reinterpret_cast<LIR**>(cUnit->throwLaunchpads.elemList);
int numElems = cUnit->throwLaunchpads.numUsed;
for (int i = 0; i < numElems; i++) {
ResetRegPool(cUnit);
ResetDefTracking(cUnit);
LIR* lab = throwLabel[i];
cUnit->currentDalvikOffset = lab->operands[1];
AppendLIR(cUnit, lab);
int funcOffset = 0;
int v1 = lab->operands[2];
int v2 = lab->operands[3];
bool targetX86 = (cUnit->instructionSet == kX86);
switch (lab->operands[0]) {
case kThrowNullPointer:
funcOffset = ENTRYPOINT_OFFSET(pThrowNullPointerFromCode);
break;
case kThrowArrayBounds:
// Move v1 (array index) to kArg0 and v2 (array length) to kArg1
if (v2 != TargetReg(kArg0)) {
OpRegCopy(cUnit, TargetReg(kArg0), v1);
if (targetX86) {
// x86 leaves the array pointer in v2, so load the array length that the handler expects
OpRegMem(cUnit, kOpMov, TargetReg(kArg1), v2, Array::LengthOffset().Int32Value());
} else {
OpRegCopy(cUnit, TargetReg(kArg1), v2);
}
} else {
if (v1 == TargetReg(kArg1)) {
// Swap v1 and v2, using kArg2 as a temp
OpRegCopy(cUnit, TargetReg(kArg2), v1);
if (targetX86) {
// x86 leaves the array pointer in v2; load the array length that the handler expects
OpRegMem(cUnit, kOpMov, TargetReg(kArg1), v2, Array::LengthOffset().Int32Value());
} else {
OpRegCopy(cUnit, TargetReg(kArg1), v2);
}
OpRegCopy(cUnit, TargetReg(kArg0), TargetReg(kArg2));
} else {
if (targetX86) {
// x86 leaves the array pointer in v2; load the array length that the handler expects
OpRegMem(cUnit, kOpMov, TargetReg(kArg1), v2, Array::LengthOffset().Int32Value());
} else {
OpRegCopy(cUnit, TargetReg(kArg1), v2);
}
OpRegCopy(cUnit, TargetReg(kArg0), v1);
}
}
funcOffset = ENTRYPOINT_OFFSET(pThrowArrayBoundsFromCode);
break;
case kThrowDivZero:
funcOffset = ENTRYPOINT_OFFSET(pThrowDivZeroFromCode);
break;
case kThrowNoSuchMethod:
OpRegCopy(cUnit, TargetReg(kArg0), v1);
funcOffset =
ENTRYPOINT_OFFSET(pThrowNoSuchMethodFromCode);
break;
case kThrowStackOverflow:
funcOffset = ENTRYPOINT_OFFSET(pThrowStackOverflowFromCode);
// Restore stack alignment
if (targetX86) {
OpRegImm(cUnit, kOpAdd, TargetReg(kSp), cUnit->frameSize);
} else {
OpRegImm(cUnit, kOpAdd, TargetReg(kSp), (cUnit->numCoreSpills + cUnit->numFPSpills) * 4);
}
break;
default:
LOG(FATAL) << "Unexpected throw kind: " << lab->operands[0];
}
ClobberCalleeSave(cUnit);
int rTgt = CallHelperSetup(cUnit, funcOffset);
CallHelper(cUnit, rTgt, funcOffset, true /* MarkSafepointPC */);
}
}
bool FastInstance(CompilationUnit* cUnit, uint32_t fieldIdx,
int& fieldOffset, bool& isVolatile, bool isPut)
{
OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
*cUnit->dex_file,
cUnit->code_item, cUnit->method_idx,
cUnit->access_flags);
return cUnit->compiler->ComputeInstanceFieldInfo(fieldIdx, &mUnit,
fieldOffset, isVolatile, isPut);
}
void GenIGet(CompilationUnit* cUnit, uint32_t fieldIdx, int optFlags, OpSize size,
RegLocation rlDest, RegLocation rlObj,
bool isLongOrDouble, bool isObject)
{
int fieldOffset;
bool isVolatile;
bool fastPath = FastInstance(cUnit, fieldIdx, fieldOffset, isVolatile, false);
if (fastPath && !SLOW_FIELD_PATH) {
RegLocation rlResult;
RegisterClass regClass = oatRegClassBySize(size);
DCHECK_GE(fieldOffset, 0);
rlObj = LoadValue(cUnit, rlObj, kCoreReg);
if (isLongOrDouble) {
DCHECK(rlDest.wide);
GenNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
if (cUnit->instructionSet == kX86) {
rlResult = EvalLoc(cUnit, rlDest, regClass, true);
GenNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
LoadBaseDispWide(cUnit, rlObj.lowReg, fieldOffset, rlResult.lowReg,
rlResult.highReg, rlObj.sRegLow);
if (isVolatile) {
GenMemBarrier(cUnit, kLoadLoad);
}
} else {
int regPtr = AllocTemp(cUnit);
OpRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
rlResult = EvalLoc(cUnit, rlDest, regClass, true);
LoadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
if (isVolatile) {
GenMemBarrier(cUnit, kLoadLoad);
}
FreeTemp(cUnit, regPtr);
}
StoreValueWide(cUnit, rlDest, rlResult);
} else {
rlResult = EvalLoc(cUnit, rlDest, regClass, true);
GenNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
LoadBaseDisp(cUnit, rlObj.lowReg, fieldOffset, rlResult.lowReg,
kWord, rlObj.sRegLow);
if (isVolatile) {
GenMemBarrier(cUnit, kLoadLoad);
}
StoreValue(cUnit, rlDest, rlResult);
}
} else {
int getterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pGet64Instance) :
(isObject ? ENTRYPOINT_OFFSET(pGetObjInstance)
: ENTRYPOINT_OFFSET(pGet32Instance));
CallRuntimeHelperImmRegLocation(cUnit, getterOffset, fieldIdx, rlObj, true);
if (isLongOrDouble) {
RegLocation rlResult = GetReturnWide(cUnit, rlDest.fp);
StoreValueWide(cUnit, rlDest, rlResult);
} else {
RegLocation rlResult = GetReturn(cUnit, rlDest.fp);
StoreValue(cUnit, rlDest, rlResult);
}
}
}
void GenIPut(CompilationUnit* cUnit, uint32_t fieldIdx, int optFlags, OpSize size,
RegLocation rlSrc, RegLocation rlObj, bool isLongOrDouble, bool isObject)
{
int fieldOffset;
bool isVolatile;
bool fastPath = FastInstance(cUnit, fieldIdx, fieldOffset, isVolatile,
true);
if (fastPath && !SLOW_FIELD_PATH) {
RegisterClass regClass = oatRegClassBySize(size);
DCHECK_GE(fieldOffset, 0);
rlObj = LoadValue(cUnit, rlObj, kCoreReg);
if (isLongOrDouble) {
int regPtr;
rlSrc = LoadValueWide(cUnit, rlSrc, kAnyReg);
GenNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
regPtr = AllocTemp(cUnit);
OpRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
if (isVolatile) {
GenMemBarrier(cUnit, kStoreStore);
}
StoreBaseDispWide(cUnit, regPtr, 0, rlSrc.lowReg, rlSrc.highReg);
if (isVolatile) {
GenMemBarrier(cUnit, kLoadLoad);
}
FreeTemp(cUnit, regPtr);
} else {
rlSrc = LoadValue(cUnit, rlSrc, regClass);
GenNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
if (isVolatile) {
GenMemBarrier(cUnit, kStoreStore);
}
StoreBaseDisp(cUnit, rlObj.lowReg, fieldOffset, rlSrc.lowReg, kWord);
if (isVolatile) {
GenMemBarrier(cUnit, kLoadLoad);
}
if (isObject) {
MarkGCCard(cUnit, rlSrc.lowReg, rlObj.lowReg);
}
}
} else {
int setterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pSet64Instance) :
(isObject ? ENTRYPOINT_OFFSET(pSetObjInstance)
: ENTRYPOINT_OFFSET(pSet32Instance));
CallRuntimeHelperImmRegLocationRegLocation(cUnit, setterOffset, fieldIdx, rlObj, rlSrc, true);
}
}
void GenConstClass(CompilationUnit* cUnit, uint32_t type_idx,
RegLocation rlDest)
{
RegLocation rlMethod = LoadCurrMethod(cUnit);
int resReg = AllocTemp(cUnit);
RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
*cUnit->dex_file,
type_idx)) {
// Call out to helper which resolves type and verifies access.
// Resolved type returned in kRet0.
CallRuntimeHelperImmReg(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
type_idx, rlMethod.lowReg, true);
RegLocation rlResult = GetReturn(cUnit, false);
StoreValue(cUnit, rlDest, rlResult);
} else {
// We're don't need access checks, load type from dex cache
int32_t dex_cache_offset =
AbstractMethod::DexCacheResolvedTypesOffset().Int32Value();
LoadWordDisp(cUnit, rlMethod.lowReg, dex_cache_offset, resReg);
int32_t offset_of_type =
Array::DataOffset(sizeof(Class*)).Int32Value() + (sizeof(Class*)
* type_idx);
LoadWordDisp(cUnit, resReg, offset_of_type, rlResult.lowReg);
if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(*cUnit->dex_file,
type_idx) || SLOW_TYPE_PATH) {
// Slow path, at runtime test if type is null and if so initialize
FlushAllRegs(cUnit);
LIR* branch1 = OpCmpImmBranch(cUnit, kCondEq, rlResult.lowReg, 0, NULL);
// Resolved, store and hop over following code
StoreValue(cUnit, rlDest, rlResult);
/*
* Because we have stores of the target value on two paths,
* clobber temp tracking for the destination using the ssa name
*/
ClobberSReg(cUnit, rlDest.sRegLow);
LIR* branch2 = OpUnconditionalBranch(cUnit,0);
// TUNING: move slow path to end & remove unconditional branch
LIR* target1 = NewLIR0(cUnit, kPseudoTargetLabel);
// Call out to helper, which will return resolved type in kArg0
CallRuntimeHelperImmReg(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeFromCode), type_idx,
rlMethod.lowReg, true);
RegLocation rlResult = GetReturn(cUnit, false);
StoreValue(cUnit, rlDest, rlResult);
/*
* Because we have stores of the target value on two paths,
* clobber temp tracking for the destination using the ssa name
*/
ClobberSReg(cUnit, rlDest.sRegLow);
// Rejoin code paths
LIR* target2 = NewLIR0(cUnit, kPseudoTargetLabel);
branch1->target = target1;
branch2->target = target2;
} else {
// Fast path, we're done - just store result
StoreValue(cUnit, rlDest, rlResult);
}
}
}
void GenConstString(CompilationUnit* cUnit, uint32_t string_idx,
RegLocation rlDest)
{
/* NOTE: Most strings should be available at compile time */
int32_t offset_of_string = Array::DataOffset(sizeof(String*)).Int32Value() +
(sizeof(String*) * string_idx);
if (!cUnit->compiler->CanAssumeStringIsPresentInDexCache(
*cUnit->dex_file, string_idx) || SLOW_STRING_PATH) {
// slow path, resolve string if not in dex cache
FlushAllRegs(cUnit);
LockCallTemps(cUnit); // Using explicit registers
LoadCurrMethodDirect(cUnit, TargetReg(kArg2));
LoadWordDisp(cUnit, TargetReg(kArg2),
AbstractMethod::DexCacheStringsOffset().Int32Value(), TargetReg(kArg0));
// Might call out to helper, which will return resolved string in kRet0
int rTgt = CallHelperSetup(cUnit, ENTRYPOINT_OFFSET(pResolveStringFromCode));
LoadWordDisp(cUnit, TargetReg(kArg0), offset_of_string, TargetReg(kRet0));
LoadConstant(cUnit, TargetReg(kArg1), string_idx);
if (cUnit->instructionSet == kThumb2) {
OpRegImm(cUnit, kOpCmp, TargetReg(kRet0), 0); // Is resolved?
GenBarrier(cUnit);
// For testing, always force through helper
if (!EXERCISE_SLOWEST_STRING_PATH) {
OpIT(cUnit, kArmCondEq, "T");
}
OpRegCopy(cUnit, TargetReg(kArg0), TargetReg(kArg2)); // .eq
LIR* callInst = OpReg(cUnit, kOpBlx, rTgt); // .eq, helper(Method*, string_idx)
MarkSafepointPC(cUnit, callInst);
FreeTemp(cUnit, rTgt);
} else if (cUnit->instructionSet == kMips) {
LIR* branch = OpCmpImmBranch(cUnit, kCondNe, TargetReg(kRet0), 0, NULL);
OpRegCopy(cUnit, TargetReg(kArg0), TargetReg(kArg2)); // .eq
LIR* callInst = OpReg(cUnit, kOpBlx, rTgt);
MarkSafepointPC(cUnit, callInst);
FreeTemp(cUnit, rTgt);
LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
branch->target = target;
} else {
DCHECK_EQ(cUnit->instructionSet, kX86);
CallRuntimeHelperRegReg(cUnit, ENTRYPOINT_OFFSET(pResolveStringFromCode), TargetReg(kArg2), TargetReg(kArg1), true);
}
GenBarrier(cUnit);
StoreValue(cUnit, rlDest, GetReturn(cUnit, false));
} else {
RegLocation rlMethod = LoadCurrMethod(cUnit);
int resReg = AllocTemp(cUnit);
RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
LoadWordDisp(cUnit, rlMethod.lowReg,
AbstractMethod::DexCacheStringsOffset().Int32Value(), resReg);
LoadWordDisp(cUnit, resReg, offset_of_string, rlResult.lowReg);
StoreValue(cUnit, rlDest, rlResult);
}
}
/*
* Let helper function take care of everything. Will
* call Class::NewInstanceFromCode(type_idx, method);
*/
void GenNewInstance(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest)
{
FlushAllRegs(cUnit); /* Everything to home location */
// alloc will always check for resolution, do we also need to verify
// access because the verifier was unable to?
int funcOffset;
if (cUnit->compiler->CanAccessInstantiableTypeWithoutChecks(
cUnit->method_idx, *cUnit->dex_file, type_idx)) {
funcOffset = ENTRYPOINT_OFFSET(pAllocObjectFromCode);
} else {
funcOffset = ENTRYPOINT_OFFSET(pAllocObjectFromCodeWithAccessCheck);
}
CallRuntimeHelperImmMethod(cUnit, funcOffset, type_idx, true);
RegLocation rlResult = GetReturn(cUnit, false);
StoreValue(cUnit, rlDest, rlResult);
}
void GenMoveException(CompilationUnit* cUnit, RegLocation rlDest)
{
FlushAllRegs(cUnit); /* Everything to home location */
int funcOffset = ENTRYPOINT_OFFSET(pGetAndClearException);
if (cUnit->instructionSet == kX86) {
// Runtime helper will load argument for x86.
CallRuntimeHelperReg(cUnit, funcOffset, TargetReg(kArg0), false);
} else {
CallRuntimeHelperReg(cUnit, funcOffset, TargetReg(kSelf), false);
}
RegLocation rlResult = GetReturn(cUnit, false);
StoreValue(cUnit, rlDest, rlResult);
}
void GenThrow(CompilationUnit* cUnit, RegLocation rlSrc)
{
FlushAllRegs(cUnit);
CallRuntimeHelperRegLocation(cUnit, ENTRYPOINT_OFFSET(pDeliverException), rlSrc, true);
}
void GenInstanceof(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest,
RegLocation rlSrc)
{
FlushAllRegs(cUnit);
// May generate a call - use explicit registers
LockCallTemps(cUnit);
LoadCurrMethodDirect(cUnit, TargetReg(kArg1)); // kArg1 <= current Method*
int classReg = TargetReg(kArg2); // kArg2 will hold the Class*
if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
*cUnit->dex_file,
type_idx)) {
// Check we have access to type_idx and if not throw IllegalAccessError,
// returns Class* in kArg0
CallRuntimeHelperImm(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
type_idx, true);
OpRegCopy(cUnit, classReg, TargetReg(kRet0)); // Align usage with fast path
LoadValueDirectFixed(cUnit, rlSrc, TargetReg(kArg0)); // kArg0 <= ref
} else {
// Load dex cache entry into classReg (kArg2)
LoadValueDirectFixed(cUnit, rlSrc, TargetReg(kArg0)); // kArg0 <= ref
LoadWordDisp(cUnit, TargetReg(kArg1),
AbstractMethod::DexCacheResolvedTypesOffset().Int32Value(), classReg);
int32_t offset_of_type =
Array::DataOffset(sizeof(Class*)).Int32Value() + (sizeof(Class*)
* type_idx);
LoadWordDisp(cUnit, classReg, offset_of_type, classReg);
if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(
*cUnit->dex_file, type_idx)) {
// Need to test presence of type in dex cache at runtime
LIR* hopBranch = OpCmpImmBranch(cUnit, kCondNe, classReg, 0, NULL);
// Not resolved
// Call out to helper, which will return resolved type in kRet0
CallRuntimeHelperImm(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeFromCode), type_idx, true);
OpRegCopy(cUnit, TargetReg(kArg2), TargetReg(kRet0)); // Align usage with fast path
LoadValueDirectFixed(cUnit, rlSrc, TargetReg(kArg0)); /* reload Ref */
// Rejoin code paths
LIR* hopTarget = NewLIR0(cUnit, kPseudoTargetLabel);
hopBranch->target = hopTarget;
}
}
/* kArg0 is ref, kArg2 is class. If ref==null, use directly as bool result */
RegLocation rlResult = GetReturn(cUnit, false);
if (cUnit->instructionSet == kMips) {
LoadConstant(cUnit, rlResult.lowReg, 0); // store false result for if branch is taken
}
LIR* branch1 = OpCmpImmBranch(cUnit, kCondEq, TargetReg(kArg0), 0, NULL);
/* load object->klass_ */
DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
LoadWordDisp(cUnit, TargetReg(kArg0), Object::ClassOffset().Int32Value(), TargetReg(kArg1));
/* kArg0 is ref, kArg1 is ref->klass_, kArg2 is class */
LIR* callInst;
LIR* branchover = NULL;
if (cUnit->instructionSet == kThumb2) {
/* Uses conditional nullification */
int rTgt = LoadHelper(cUnit, ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
OpRegReg(cUnit, kOpCmp, TargetReg(kArg1), TargetReg(kArg2)); // Same?
OpIT(cUnit, kArmCondEq, "EE"); // if-convert the test
LoadConstant(cUnit, TargetReg(kArg0), 1); // .eq case - load true
OpRegCopy(cUnit, TargetReg(kArg0), TargetReg(kArg2)); // .ne case - arg0 <= class
callInst = OpReg(cUnit, kOpBlx, rTgt); // .ne case: helper(class, ref->class)
FreeTemp(cUnit, rTgt);
} else {
/* Uses branchovers */
LoadConstant(cUnit, rlResult.lowReg, 1); // assume true
branchover = OpCmpBranch(cUnit, kCondEq, TargetReg(kArg1), TargetReg(kArg2), NULL);
if (cUnit->instructionSet != kX86) {
int rTgt = LoadHelper(cUnit, ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
OpRegCopy(cUnit, TargetReg(kArg0), TargetReg(kArg2)); // .ne case - arg0 <= class
callInst = OpReg(cUnit, kOpBlx, rTgt); // .ne case: helper(class, ref->class)
FreeTemp(cUnit, rTgt);
} else {
OpRegCopy(cUnit, TargetReg(kArg0), TargetReg(kArg2));
callInst = OpThreadMem(cUnit, kOpBlx, ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
}
}
MarkSafepointPC(cUnit, callInst);
ClobberCalleeSave(cUnit);
/* branch targets here */
LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
StoreValue(cUnit, rlDest, rlResult);
branch1->target = target;
if (cUnit->instructionSet != kThumb2) {
branchover->target = target;
}
}
void GenCheckCast(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlSrc)
{
FlushAllRegs(cUnit);
// May generate a call - use explicit registers
LockCallTemps(cUnit);
LoadCurrMethodDirect(cUnit, TargetReg(kArg1)); // kArg1 <= current Method*
int classReg = TargetReg(kArg2); // kArg2 will hold the Class*
if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
*cUnit->dex_file,
type_idx)) {
// Check we have access to type_idx and if not throw IllegalAccessError,
// returns Class* in kRet0
// InitializeTypeAndVerifyAccess(idx, method)
CallRuntimeHelperImmReg(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
type_idx, TargetReg(kArg1), true);
OpRegCopy(cUnit, classReg, TargetReg(kRet0)); // Align usage with fast path
} else {
// Load dex cache entry into classReg (kArg2)
LoadWordDisp(cUnit, TargetReg(kArg1),
AbstractMethod::DexCacheResolvedTypesOffset().Int32Value(), classReg);
int32_t offset_of_type =
Array::DataOffset(sizeof(Class*)).Int32Value() +
(sizeof(Class*) * type_idx);
LoadWordDisp(cUnit, classReg, offset_of_type, classReg);
if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(
*cUnit->dex_file, type_idx)) {
// Need to test presence of type in dex cache at runtime
LIR* hopBranch = OpCmpImmBranch(cUnit, kCondNe, classReg, 0, NULL);
// Not resolved
// Call out to helper, which will return resolved type in kArg0
// InitializeTypeFromCode(idx, method)
CallRuntimeHelperImmReg(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeFromCode), type_idx, TargetReg(kArg1),
true);
OpRegCopy(cUnit, classReg, TargetReg(kRet0)); // Align usage with fast path
// Rejoin code paths
LIR* hopTarget = NewLIR0(cUnit, kPseudoTargetLabel);
hopBranch->target = hopTarget;
}
}
// At this point, classReg (kArg2) has class
LoadValueDirectFixed(cUnit, rlSrc, TargetReg(kArg0)); // kArg0 <= ref
/* Null is OK - continue */
LIR* branch1 = OpCmpImmBranch(cUnit, kCondEq, TargetReg(kArg0), 0, NULL);
/* load object->klass_ */
DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
LoadWordDisp(cUnit, TargetReg(kArg0), Object::ClassOffset().Int32Value(), TargetReg(kArg1));
/* kArg1 now contains object->klass_ */
LIR* branch2;
if (cUnit->instructionSet == kThumb2) {
int rTgt = LoadHelper(cUnit, ENTRYPOINT_OFFSET(pCheckCastFromCode));
OpRegReg(cUnit, kOpCmp, TargetReg(kArg1), classReg);
branch2 = OpCondBranch(cUnit, kCondEq, NULL); /* If eq, trivial yes */
OpRegCopy(cUnit, TargetReg(kArg0), TargetReg(kArg1));
OpRegCopy(cUnit, TargetReg(kArg1), TargetReg(kArg2));
ClobberCalleeSave(cUnit);
LIR* callInst = OpReg(cUnit, kOpBlx, rTgt);
MarkSafepointPC(cUnit, callInst);
FreeTemp(cUnit, rTgt);
} else {
branch2 = OpCmpBranch(cUnit, kCondEq, TargetReg(kArg1), classReg, NULL);
CallRuntimeHelperRegReg(cUnit, ENTRYPOINT_OFFSET(pCheckCastFromCode), TargetReg(kArg1), TargetReg(kArg2), true);
}
/* branch target here */
LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
branch1->target = target;
branch2->target = target;
}
/*
* Generate array store
*
*/
void GenArrayObjPut(CompilationUnit* cUnit, int optFlags, RegLocation rlArray,
RegLocation rlIndex, RegLocation rlSrc, int scale)
{
int lenOffset = Array::LengthOffset().Int32Value();
int dataOffset = Array::DataOffset(sizeof(Object*)).Int32Value();
FlushAllRegs(cUnit); // Use explicit registers
LockCallTemps(cUnit);
int rValue = TargetReg(kArg0); // Register holding value
int rArrayClass = TargetReg(kArg1); // Register holding array's Class
int rArray = TargetReg(kArg2); // Register holding array
int rIndex = TargetReg(kArg3); // Register holding index into array
LoadValueDirectFixed(cUnit, rlArray, rArray); // Grab array
LoadValueDirectFixed(cUnit, rlSrc, rValue); // Grab value
LoadValueDirectFixed(cUnit, rlIndex, rIndex); // Grab index
GenNullCheck(cUnit, rlArray.sRegLow, rArray, optFlags); // NPE?
// Store of null?
LIR* null_value_check = OpCmpImmBranch(cUnit, kCondEq, rValue, 0, NULL);
// Get the array's class.
LoadWordDisp(cUnit, rArray, Object::ClassOffset().Int32Value(), rArrayClass);
CallRuntimeHelperRegReg(cUnit, ENTRYPOINT_OFFSET(pCanPutArrayElementFromCode), rValue,
rArrayClass, true);
// Redo LoadValues in case they didn't survive the call.
LoadValueDirectFixed(cUnit, rlArray, rArray); // Reload array
LoadValueDirectFixed(cUnit, rlIndex, rIndex); // Reload index
LoadValueDirectFixed(cUnit, rlSrc, rValue); // Reload value
rArrayClass = INVALID_REG;
// Branch here if value to be stored == null
LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
null_value_check->target = target;
if (cUnit->instructionSet == kX86) {
// make an extra temp available for card mark below
FreeTemp(cUnit, TargetReg(kArg1));
if (!(optFlags & MIR_IGNORE_RANGE_CHECK)) {
/* if (rlIndex >= [rlArray + lenOffset]) goto kThrowArrayBounds */
GenRegMemCheck(cUnit, kCondUge, rIndex, rArray, lenOffset, kThrowArrayBounds);
}
StoreBaseIndexedDisp(cUnit, rArray, rIndex, scale,
dataOffset, rValue, INVALID_REG, kWord, INVALID_SREG);
} else {
bool needsRangeCheck = (!(optFlags & MIR_IGNORE_RANGE_CHECK));
int regLen = INVALID_REG;
if (needsRangeCheck) {
regLen = TargetReg(kArg1);
LoadWordDisp(cUnit, rArray, lenOffset, regLen); // Get len
}
/* rPtr -> array data */
int rPtr = AllocTemp(cUnit);
OpRegRegImm(cUnit, kOpAdd, rPtr, rArray, dataOffset);
if (needsRangeCheck) {
GenRegRegCheck(cUnit, kCondCs, rIndex, regLen, kThrowArrayBounds);
}
StoreBaseIndexed(cUnit, rPtr, rIndex, rValue, scale, kWord);
FreeTemp(cUnit, rPtr);
}
FreeTemp(cUnit, rIndex);
MarkGCCard(cUnit, rValue, rArray);
}
/*
* Generate array load
*/
void GenArrayGet(CompilationUnit* cUnit, int optFlags, OpSize size,
RegLocation rlArray, RegLocation rlIndex,
RegLocation rlDest, int scale)
{
RegisterClass regClass = oatRegClassBySize(size);
int lenOffset = Array::LengthOffset().Int32Value();
int dataOffset;
RegLocation rlResult;
rlArray = LoadValue(cUnit, rlArray, kCoreReg);
rlIndex = LoadValue(cUnit, rlIndex, kCoreReg);
if (size == kLong || size == kDouble) {
dataOffset = Array::DataOffset(sizeof(int64_t)).Int32Value();
} else {
dataOffset = Array::DataOffset(sizeof(int32_t)).Int32Value();
}
/* null object? */
GenNullCheck(cUnit, rlArray.sRegLow, rlArray.lowReg, optFlags);
if (cUnit->instructionSet == kX86) {
if (!(optFlags & MIR_IGNORE_RANGE_CHECK)) {
/* if (rlIndex >= [rlArray + lenOffset]) goto kThrowArrayBounds */
GenRegMemCheck(cUnit, kCondUge, rlIndex.lowReg, rlArray.lowReg,
lenOffset, kThrowArrayBounds);
}
if ((size == kLong) || (size == kDouble)) {
int regAddr = AllocTemp(cUnit);
OpLea(cUnit, regAddr, rlArray.lowReg, rlIndex.lowReg, scale, dataOffset);
FreeTemp(cUnit, rlArray.lowReg);
FreeTemp(cUnit, rlIndex.lowReg);
rlResult = EvalLoc(cUnit, rlDest, regClass, true);
LoadBaseIndexedDisp(cUnit, regAddr, INVALID_REG, 0, 0, rlResult.lowReg,
rlResult.highReg, size, INVALID_SREG);
StoreValueWide(cUnit, rlDest, rlResult);
} else {
rlResult = EvalLoc(cUnit, rlDest, regClass, true);
LoadBaseIndexedDisp(cUnit, rlArray.lowReg, rlIndex.lowReg, scale,
dataOffset, rlResult.lowReg, INVALID_REG, size,
INVALID_SREG);
StoreValue(cUnit, rlDest, rlResult);
}
} else {
int regPtr = AllocTemp(cUnit);
bool needsRangeCheck = (!(optFlags & MIR_IGNORE_RANGE_CHECK));
int regLen = INVALID_REG;
if (needsRangeCheck) {
regLen = AllocTemp(cUnit);
/* Get len */
LoadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
}
/* regPtr -> array data */
OpRegRegImm(cUnit, kOpAdd, regPtr, rlArray.lowReg, dataOffset);
FreeTemp(cUnit, rlArray.lowReg);
if ((size == kLong) || (size == kDouble)) {
if (scale) {
int rNewIndex = AllocTemp(cUnit);
OpRegRegImm(cUnit, kOpLsl, rNewIndex, rlIndex.lowReg, scale);
OpRegReg(cUnit, kOpAdd, regPtr, rNewIndex);
FreeTemp(cUnit, rNewIndex);
} else {
OpRegReg(cUnit, kOpAdd, regPtr, rlIndex.lowReg);
}
FreeTemp(cUnit, rlIndex.lowReg);
rlResult = EvalLoc(cUnit, rlDest, regClass, true);
if (needsRangeCheck) {
// TODO: change kCondCS to a more meaningful name, is the sense of
// carry-set/clear flipped?
GenRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, kThrowArrayBounds);
FreeTemp(cUnit, regLen);
}
LoadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
FreeTemp(cUnit, regPtr);
StoreValueWide(cUnit, rlDest, rlResult);
} else {
rlResult = EvalLoc(cUnit, rlDest, regClass, true);
if (needsRangeCheck) {
// TODO: change kCondCS to a more meaningful name, is the sense of
// carry-set/clear flipped?
GenRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, kThrowArrayBounds);
FreeTemp(cUnit, regLen);
}
LoadBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlResult.lowReg, scale, size);
FreeTemp(cUnit, regPtr);
StoreValue(cUnit, rlDest, rlResult);
}
}
}
/*
* Generate array store
*
*/
void GenArrayPut(CompilationUnit* cUnit, int optFlags, OpSize size,
RegLocation rlArray, RegLocation rlIndex,
RegLocation rlSrc, int scale)
{
RegisterClass regClass = oatRegClassBySize(size);
int lenOffset = Array::LengthOffset().Int32Value();
int dataOffset;
if (size == kLong || size == kDouble) {
dataOffset = Array::DataOffset(sizeof(int64_t)).Int32Value();
} else {
dataOffset = Array::DataOffset(sizeof(int32_t)).Int32Value();
}
rlArray = LoadValue(cUnit, rlArray, kCoreReg);
rlIndex = LoadValue(cUnit, rlIndex, kCoreReg);
int regPtr = INVALID_REG;
if (cUnit->instructionSet != kX86) {
if (IsTemp(cUnit, rlArray.lowReg)) {
Clobber(cUnit, rlArray.lowReg);
regPtr = rlArray.lowReg;
} else {
regPtr = AllocTemp(cUnit);
OpRegCopy(cUnit, regPtr, rlArray.lowReg);
}
}
/* null object? */
GenNullCheck(cUnit, rlArray.sRegLow, rlArray.lowReg, optFlags);
if (cUnit->instructionSet == kX86) {
if (!(optFlags & MIR_IGNORE_RANGE_CHECK)) {
/* if (rlIndex >= [rlArray + lenOffset]) goto kThrowArrayBounds */
GenRegMemCheck(cUnit, kCondUge, rlIndex.lowReg, rlArray.lowReg, lenOffset, kThrowArrayBounds);
}
if ((size == kLong) || (size == kDouble)) {
rlSrc = LoadValueWide(cUnit, rlSrc, regClass);
} else {
rlSrc = LoadValue(cUnit, rlSrc, regClass);
}
// If the src reg can't be byte accessed, move it to a temp first.
if ((size == kSignedByte || size == kUnsignedByte) && rlSrc.lowReg >= 4) {
int temp = AllocTemp(cUnit);
OpRegCopy(cUnit, temp, rlSrc.lowReg);
StoreBaseIndexedDisp(cUnit, rlArray.lowReg, rlIndex.lowReg, scale, dataOffset, temp,
INVALID_REG, size, INVALID_SREG);
} else {
StoreBaseIndexedDisp(cUnit, rlArray.lowReg, rlIndex.lowReg, scale, dataOffset, rlSrc.lowReg,
rlSrc.highReg, size, INVALID_SREG);
}
} else {
bool needsRangeCheck = (!(optFlags & MIR_IGNORE_RANGE_CHECK));
int regLen = INVALID_REG;
if (needsRangeCheck) {
regLen = AllocTemp(cUnit);
//NOTE: max live temps(4) here.
/* Get len */
LoadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
}
/* regPtr -> array data */
OpRegImm(cUnit, kOpAdd, regPtr, dataOffset);
/* at this point, regPtr points to array, 2 live temps */
if ((size == kLong) || (size == kDouble)) {
//TUNING: specific wide routine that can handle fp regs
if (scale) {
int rNewIndex = AllocTemp(cUnit);
OpRegRegImm(cUnit, kOpLsl, rNewIndex, rlIndex.lowReg, scale);
OpRegReg(cUnit, kOpAdd, regPtr, rNewIndex);
FreeTemp(cUnit, rNewIndex);
} else {
OpRegReg(cUnit, kOpAdd, regPtr, rlIndex.lowReg);
}
rlSrc = LoadValueWide(cUnit, rlSrc, regClass);
if (needsRangeCheck) {
GenRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, kThrowArrayBounds);
FreeTemp(cUnit, regLen);
}
StoreBaseDispWide(cUnit, regPtr, 0, rlSrc.lowReg, rlSrc.highReg);
FreeTemp(cUnit, regPtr);
} else {
rlSrc = LoadValue(cUnit, rlSrc, regClass);
if (needsRangeCheck) {
GenRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, kThrowArrayBounds);
FreeTemp(cUnit, regLen);
}
StoreBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlSrc.lowReg,
scale, size);
}
}
}
void GenLong3Addr(CompilationUnit* cUnit, OpKind firstOp,
OpKind secondOp, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
RegLocation rlResult;
if (cUnit->instructionSet == kThumb2) {
/*
* NOTE: This is the one place in the code in which we might have
* as many as six live temporary registers. There are 5 in the normal
* set for Arm. Until we have spill capabilities, temporarily add
* lr to the temp set. It is safe to do this locally, but note that
* lr is used explicitly elsewhere in the code generator and cannot
* normally be used as a general temp register.
*/
MarkTemp(cUnit, TargetReg(kLr)); // Add lr to the temp pool
FreeTemp(cUnit, TargetReg(kLr)); // and make it available
}
rlSrc1 = LoadValueWide(cUnit, rlSrc1, kCoreReg);
rlSrc2 = LoadValueWide(cUnit, rlSrc2, kCoreReg);
rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
// The longs may overlap - use intermediate temp if so
if ((rlResult.lowReg == rlSrc1.highReg) || (rlResult.lowReg == rlSrc2.highReg)){
int tReg = AllocTemp(cUnit);
OpRegRegReg(cUnit, firstOp, tReg, rlSrc1.lowReg, rlSrc2.lowReg);
OpRegRegReg(cUnit, secondOp, rlResult.highReg, rlSrc1.highReg, rlSrc2.highReg);
OpRegCopy(cUnit, rlResult.lowReg, tReg);
FreeTemp(cUnit, tReg);
} else {
OpRegRegReg(cUnit, firstOp, rlResult.lowReg, rlSrc1.lowReg, rlSrc2.lowReg);
OpRegRegReg(cUnit, secondOp, rlResult.highReg, rlSrc1.highReg,
rlSrc2.highReg);
}
/*
* NOTE: If rlDest refers to a frame variable in a large frame, the
* following StoreValueWide might need to allocate a temp register.
* To further work around the lack of a spill capability, explicitly
* free any temps from rlSrc1 & rlSrc2 that aren't still live in rlResult.
* Remove when spill is functional.
*/
FreeRegLocTemps(cUnit, rlResult, rlSrc1);
FreeRegLocTemps(cUnit, rlResult, rlSrc2);
StoreValueWide(cUnit, rlDest, rlResult);
if (cUnit->instructionSet == kThumb2) {
Clobber(cUnit, TargetReg(kLr));
UnmarkTemp(cUnit, TargetReg(kLr)); // Remove lr from the temp pool
}
}
bool GenShiftOpLong(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlShift)
{
int funcOffset;
switch (opcode) {
case Instruction::SHL_LONG:
case Instruction::SHL_LONG_2ADDR:
funcOffset = ENTRYPOINT_OFFSET(pShlLong);
break;
case Instruction::SHR_LONG:
case Instruction::SHR_LONG_2ADDR:
funcOffset = ENTRYPOINT_OFFSET(pShrLong);
break;
case Instruction::USHR_LONG:
case Instruction::USHR_LONG_2ADDR:
funcOffset = ENTRYPOINT_OFFSET(pUshrLong);
break;
default:
LOG(FATAL) << "Unexpected case";
return true;
}
FlushAllRegs(cUnit); /* Send everything to home location */
CallRuntimeHelperRegLocationRegLocation(cUnit, funcOffset, rlSrc1, rlShift, false);
RegLocation rlResult = GetReturnWide(cUnit, false);
StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
bool GenArithOpInt(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
OpKind op = kOpBkpt;
bool isDivRem = false;
bool checkZero = false;
bool unary = false;
RegLocation rlResult;
bool shiftOp = false;
switch (opcode) {
case Instruction::NEG_INT:
op = kOpNeg;
unary = true;
break;
case Instruction::NOT_INT:
op = kOpMvn;
unary = true;
break;
case Instruction::ADD_INT:
case Instruction::ADD_INT_2ADDR:
op = kOpAdd;
break;
case Instruction::SUB_INT:
case Instruction::SUB_INT_2ADDR:
op = kOpSub;
break;
case Instruction::MUL_INT:
case Instruction::MUL_INT_2ADDR:
op = kOpMul;
break;
case Instruction::DIV_INT:
case Instruction::DIV_INT_2ADDR:
checkZero = true;
op = kOpDiv;
isDivRem = true;
break;
/* NOTE: returns in kArg1 */
case Instruction::REM_INT:
case Instruction::REM_INT_2ADDR:
checkZero = true;
op = kOpRem;
isDivRem = true;
break;
case Instruction::AND_INT:
case Instruction::AND_INT_2ADDR:
op = kOpAnd;
break;
case Instruction::OR_INT:
case Instruction::OR_INT_2ADDR:
op = kOpOr;
break;
case Instruction::XOR_INT:
case Instruction::XOR_INT_2ADDR:
op = kOpXor;
break;
case Instruction::SHL_INT:
case Instruction::SHL_INT_2ADDR:
shiftOp = true;
op = kOpLsl;
break;
case Instruction::SHR_INT:
case Instruction::SHR_INT_2ADDR:
shiftOp = true;
op = kOpAsr;
break;
case Instruction::USHR_INT:
case Instruction::USHR_INT_2ADDR:
shiftOp = true;
op = kOpLsr;
break;
default:
LOG(FATAL) << "Invalid word arith op: " << opcode;
}
if (!isDivRem) {
if (unary) {
rlSrc1 = LoadValue(cUnit, rlSrc1, kCoreReg);
rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
OpRegReg(cUnit, op, rlResult.lowReg, rlSrc1.lowReg);
} else {
if (shiftOp) {
int tReg = INVALID_REG;
if (cUnit->instructionSet == kX86) {
// X86 doesn't require masking and must use ECX
tReg = TargetReg(kCount); // rCX
LoadValueDirectFixed(cUnit, rlSrc2, tReg);
} else {
rlSrc2 = LoadValue(cUnit, rlSrc2, kCoreReg);
tReg = AllocTemp(cUnit);
OpRegRegImm(cUnit, kOpAnd, tReg, rlSrc2.lowReg, 31);
}
rlSrc1 = LoadValue(cUnit, rlSrc1, kCoreReg);
rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
OpRegRegReg(cUnit, op, rlResult.lowReg, rlSrc1.lowReg, tReg);
FreeTemp(cUnit, tReg);
} else {
rlSrc1 = LoadValue(cUnit, rlSrc1, kCoreReg);
rlSrc2 = LoadValue(cUnit, rlSrc2, kCoreReg);
rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
OpRegRegReg(cUnit, op, rlResult.lowReg, rlSrc1.lowReg, rlSrc2.lowReg);
}
}
StoreValue(cUnit, rlDest, rlResult);
} else {
if (cUnit->instructionSet == kMips) {
rlSrc1 = LoadValue(cUnit, rlSrc1, kCoreReg);
rlSrc2 = LoadValue(cUnit, rlSrc2, kCoreReg);
if (checkZero) {
GenImmedCheck(cUnit, kCondEq, rlSrc2.lowReg, 0, kThrowDivZero);
}
rlResult = GenDivRem(cUnit, rlDest, rlSrc1.lowReg, rlSrc2.lowReg, op == kOpDiv);
} else {
int funcOffset = ENTRYPOINT_OFFSET(pIdivmod);
FlushAllRegs(cUnit); /* Send everything to home location */
LoadValueDirectFixed(cUnit, rlSrc2, TargetReg(kArg1));
int rTgt = CallHelperSetup(cUnit, funcOffset);
LoadValueDirectFixed(cUnit, rlSrc1, TargetReg(kArg0));
if (checkZero) {
GenImmedCheck(cUnit, kCondEq, TargetReg(kArg1), 0, kThrowDivZero);
}
// NOTE: callout here is not a safepoint
CallHelper(cUnit, rTgt, funcOffset, false /* not a safepoint */ );
if (op == kOpDiv)
rlResult = GetReturn(cUnit, false);
else
rlResult = GetReturnAlt(cUnit);
}
StoreValue(cUnit, rlDest, rlResult);
}
return false;
}
/*
* The following are the first-level codegen routines that analyze the format
* of each bytecode then either dispatch special purpose codegen routines
* or produce corresponding Thumb instructions directly.
*/
bool IsPowerOfTwo(int x)
{
return (x & (x - 1)) == 0;
}
// Returns true if no more than two bits are set in 'x'.
bool IsPopCountLE2(unsigned int x)
{
x &= x - 1;
return (x & (x - 1)) == 0;
}
// Returns the index of the lowest set bit in 'x'.
int LowestSetBit(unsigned int x) {
int bit_posn = 0;
while ((x & 0xf) == 0) {
bit_posn += 4;
x >>= 4;
}
while ((x & 1) == 0) {
bit_posn++;
x >>= 1;
}
return bit_posn;
}
// Returns true if it added instructions to 'cUnit' to divide 'rlSrc' by 'lit'
// and store the result in 'rlDest'.
bool HandleEasyDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode,
RegLocation rlSrc, RegLocation rlDest, int lit)
{
if ((lit < 2) || ((cUnit->instructionSet != kThumb2) && !IsPowerOfTwo(lit))) {
return false;
}
// No divide instruction for Arm, so check for more special cases
if ((cUnit->instructionSet == kThumb2) && !IsPowerOfTwo(lit)) {
return SmallLiteralDivide(cUnit, dalvikOpcode, rlSrc, rlDest, lit);
}
int k = LowestSetBit(lit);
if (k >= 30) {
// Avoid special cases.
return false;
}
bool div = (dalvikOpcode == Instruction::DIV_INT_LIT8 ||
dalvikOpcode == Instruction::DIV_INT_LIT16);
rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
if (div) {
int tReg = AllocTemp(cUnit);
if (lit == 2) {
// Division by 2 is by far the most common division by constant.
OpRegRegImm(cUnit, kOpLsr, tReg, rlSrc.lowReg, 32 - k);
OpRegRegReg(cUnit, kOpAdd, tReg, tReg, rlSrc.lowReg);
OpRegRegImm(cUnit, kOpAsr, rlResult.lowReg, tReg, k);
} else {
OpRegRegImm(cUnit, kOpAsr, tReg, rlSrc.lowReg, 31);
OpRegRegImm(cUnit, kOpLsr, tReg, tReg, 32 - k);
OpRegRegReg(cUnit, kOpAdd, tReg, tReg, rlSrc.lowReg);
OpRegRegImm(cUnit, kOpAsr, rlResult.lowReg, tReg, k);
}
} else {
int tReg1 = AllocTemp(cUnit);
int tReg2 = AllocTemp(cUnit);
if (lit == 2) {
OpRegRegImm(cUnit, kOpLsr, tReg1, rlSrc.lowReg, 32 - k);
OpRegRegReg(cUnit, kOpAdd, tReg2, tReg1, rlSrc.lowReg);
OpRegRegImm(cUnit, kOpAnd, tReg2, tReg2, lit -1);
OpRegRegReg(cUnit, kOpSub, rlResult.lowReg, tReg2, tReg1);
} else {
OpRegRegImm(cUnit, kOpAsr, tReg1, rlSrc.lowReg, 31);
OpRegRegImm(cUnit, kOpLsr, tReg1, tReg1, 32 - k);
OpRegRegReg(cUnit, kOpAdd, tReg2, tReg1, rlSrc.lowReg);
OpRegRegImm(cUnit, kOpAnd, tReg2, tReg2, lit - 1);
OpRegRegReg(cUnit, kOpSub, rlResult.lowReg, tReg2, tReg1);
}
}
StoreValue(cUnit, rlDest, rlResult);
return true;
}
// Returns true if it added instructions to 'cUnit' to multiply 'rlSrc' by 'lit'
// and store the result in 'rlDest'.
bool HandleEasyMultiply(CompilationUnit* cUnit, RegLocation rlSrc,
RegLocation rlDest, int lit)
{
// Can we simplify this multiplication?
bool powerOfTwo = false;
bool popCountLE2 = false;
bool powerOfTwoMinusOne = false;
if (lit < 2) {
// Avoid special cases.
return false;
} else if (IsPowerOfTwo(lit)) {
powerOfTwo = true;
} else if (IsPopCountLE2(lit)) {
popCountLE2 = true;
} else if (IsPowerOfTwo(lit + 1)) {
powerOfTwoMinusOne = true;
} else {
return false;
}
rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
if (powerOfTwo) {
// Shift.
OpRegRegImm(cUnit, kOpLsl, rlResult.lowReg, rlSrc.lowReg,
LowestSetBit(lit));
} else if (popCountLE2) {
// Shift and add and shift.
int firstBit = LowestSetBit(lit);
int secondBit = LowestSetBit(lit ^ (1 << firstBit));
GenMultiplyByTwoBitMultiplier(cUnit, rlSrc, rlResult, lit,
firstBit, secondBit);
} else {
// Reverse subtract: (src << (shift + 1)) - src.
DCHECK(powerOfTwoMinusOne);
// TUNING: rsb dst, src, src lsl#LowestSetBit(lit + 1)
int tReg = AllocTemp(cUnit);
OpRegRegImm(cUnit, kOpLsl, tReg, rlSrc.lowReg, LowestSetBit(lit + 1));
OpRegRegReg(cUnit, kOpSub, rlResult.lowReg, tReg, rlSrc.lowReg);
}
StoreValue(cUnit, rlDest, rlResult);
return true;
}
bool GenArithOpIntLit(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc, int lit)
{
RegLocation rlResult;
OpKind op = static_cast<OpKind>(0); /* Make gcc happy */
int shiftOp = false;
bool isDiv = false;
switch (opcode) {
case Instruction::RSUB_INT_LIT8:
case Instruction::RSUB_INT: {
int tReg;
//TUNING: add support for use of Arm rsub op
rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
tReg = AllocTemp(cUnit);
LoadConstant(cUnit, tReg, lit);
rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
OpRegRegReg(cUnit, kOpSub, rlResult.lowReg, tReg, rlSrc.lowReg);
StoreValue(cUnit, rlDest, rlResult);
return false;
break;
}
case Instruction::ADD_INT_LIT8:
case Instruction::ADD_INT_LIT16:
op = kOpAdd;
break;
case Instruction::MUL_INT_LIT8:
case Instruction::MUL_INT_LIT16: {
if (HandleEasyMultiply(cUnit, rlSrc, rlDest, lit)) {
return false;
}
op = kOpMul;
break;
}
case Instruction::AND_INT_LIT8:
case Instruction::AND_INT_LIT16:
op = kOpAnd;
break;
case Instruction::OR_INT_LIT8:
case Instruction::OR_INT_LIT16:
op = kOpOr;
break;
case Instruction::XOR_INT_LIT8:
case Instruction::XOR_INT_LIT16:
op = kOpXor;
break;
case Instruction::SHL_INT_LIT8:
case Instruction::SHL_INT:
lit &= 31;
shiftOp = true;
op = kOpLsl;
break;
case Instruction::SHR_INT_LIT8:
case Instruction::SHR_INT:
lit &= 31;
shiftOp = true;
op = kOpAsr;
break;
case Instruction::USHR_INT_LIT8:
case Instruction::USHR_INT:
lit &= 31;
shiftOp = true;
op = kOpLsr;
break;
case Instruction::DIV_INT_LIT8:
case Instruction::DIV_INT_LIT16:
case Instruction::REM_INT_LIT8:
case Instruction::REM_INT_LIT16: {
if (lit == 0) {
GenImmedCheck(cUnit, kCondAl, 0, 0, kThrowDivZero);
return false;
}
if (HandleEasyDivide(cUnit, opcode, rlSrc, rlDest, lit)) {
return false;
}
if ((opcode == Instruction::DIV_INT_LIT8) ||
(opcode == Instruction::DIV_INT_LIT16)) {
isDiv = true;
} else {
isDiv = false;
}
if (cUnit->instructionSet == kMips) {
rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
rlResult = GenDivRemLit(cUnit, rlDest, rlSrc.lowReg, lit, isDiv);
} else {
FlushAllRegs(cUnit); /* Everything to home location */
LoadValueDirectFixed(cUnit, rlSrc, TargetReg(kArg0));
Clobber(cUnit, TargetReg(kArg0));
int funcOffset = ENTRYPOINT_OFFSET(pIdivmod);
CallRuntimeHelperRegImm(cUnit, funcOffset, TargetReg(kArg0), lit, false);
if (isDiv)
rlResult = GetReturn(cUnit, false);
else
rlResult = GetReturnAlt(cUnit);
}
StoreValue(cUnit, rlDest, rlResult);
return false;
break;
}
default:
return true;
}
rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
// Avoid shifts by literal 0 - no support in Thumb. Change to copy
if (shiftOp && (lit == 0)) {
OpRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
} else {
OpRegRegImm(cUnit, op, rlResult.lowReg, rlSrc.lowReg, lit);
}
StoreValue(cUnit, rlDest, rlResult);
return false;
}
bool GenArithOpLong(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
RegLocation rlResult;
OpKind firstOp = kOpBkpt;
OpKind secondOp = kOpBkpt;
bool callOut = false;
bool checkZero = false;
int funcOffset;
int retReg = TargetReg(kRet0);
switch (opcode) {
case Instruction::NOT_LONG:
rlSrc2 = LoadValueWide(cUnit, rlSrc2, kCoreReg);
rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
// Check for destructive overlap
if (rlResult.lowReg == rlSrc2.highReg) {
int tReg = AllocTemp(cUnit);
OpRegCopy(cUnit, tReg, rlSrc2.highReg);
OpRegReg(cUnit, kOpMvn, rlResult.lowReg, rlSrc2.lowReg);
OpRegReg(cUnit, kOpMvn, rlResult.highReg, tReg);
FreeTemp(cUnit, tReg);
} else {
OpRegReg(cUnit, kOpMvn, rlResult.lowReg, rlSrc2.lowReg);
OpRegReg(cUnit, kOpMvn, rlResult.highReg, rlSrc2.highReg);
}
StoreValueWide(cUnit, rlDest, rlResult);
return false;
break;
case Instruction::ADD_LONG:
case Instruction::ADD_LONG_2ADDR:
if (cUnit->instructionSet != kThumb2) {
return GenAddLong(cUnit, rlDest, rlSrc1, rlSrc2);
}
firstOp = kOpAdd;
secondOp = kOpAdc;
break;
case Instruction::SUB_LONG:
case Instruction::SUB_LONG_2ADDR:
if (cUnit->instructionSet != kThumb2) {
return GenSubLong(cUnit, rlDest, rlSrc1, rlSrc2);
}
firstOp = kOpSub;
secondOp = kOpSbc;
break;
case Instruction::MUL_LONG:
case Instruction::MUL_LONG_2ADDR:
callOut = true;
retReg = TargetReg(kRet0);
funcOffset = ENTRYPOINT_OFFSET(pLmul);
break;
case Instruction::DIV_LONG:
case Instruction::DIV_LONG_2ADDR:
callOut = true;
checkZero = true;
retReg = TargetReg(kRet0);
funcOffset = ENTRYPOINT_OFFSET(pLdiv);
break;
case Instruction::REM_LONG:
case Instruction::REM_LONG_2ADDR:
callOut = true;
checkZero = true;
funcOffset = ENTRYPOINT_OFFSET(pLdivmod);
/* NOTE - for Arm, result is in kArg2/kArg3 instead of kRet0/kRet1 */
retReg = (cUnit->instructionSet == kThumb2) ? TargetReg(kArg2) : TargetReg(kRet0);
break;
case Instruction::AND_LONG_2ADDR:
case Instruction::AND_LONG:
if (cUnit->instructionSet == kX86) {
return GenAndLong(cUnit, rlDest, rlSrc1, rlSrc2);
}
firstOp = kOpAnd;
secondOp = kOpAnd;
break;
case Instruction::OR_LONG:
case Instruction::OR_LONG_2ADDR:
if (cUnit->instructionSet == kX86) {
return GenOrLong(cUnit, rlDest, rlSrc1, rlSrc2);
}
firstOp = kOpOr;
secondOp = kOpOr;
break;
case Instruction::XOR_LONG:
case Instruction::XOR_LONG_2ADDR:
if (cUnit->instructionSet == kX86) {
return GenXorLong(cUnit, rlDest, rlSrc1, rlSrc2);
}
firstOp = kOpXor;
secondOp = kOpXor;
break;
case Instruction::NEG_LONG: {
return GenNegLong(cUnit, rlDest, rlSrc2);
}
default:
LOG(FATAL) << "Invalid long arith op";
}
if (!callOut) {
GenLong3Addr(cUnit, firstOp, secondOp, rlDest, rlSrc1, rlSrc2);
} else {
FlushAllRegs(cUnit); /* Send everything to home location */
if (checkZero) {
LoadValueDirectWideFixed(cUnit, rlSrc2, TargetReg(kArg2), TargetReg(kArg3));
int rTgt = CallHelperSetup(cUnit, funcOffset);
GenDivZeroCheck(cUnit, TargetReg(kArg2), TargetReg(kArg3));
LoadValueDirectWideFixed(cUnit, rlSrc1, TargetReg(kArg0), TargetReg(kArg1));
// NOTE: callout here is not a safepoint
CallHelper(cUnit, rTgt, funcOffset, false /* not safepoint */);
} else {
CallRuntimeHelperRegLocationRegLocation(cUnit, funcOffset,
rlSrc1, rlSrc2, false);
}
// Adjust return regs in to handle case of rem returning kArg2/kArg3
if (retReg == TargetReg(kRet0))
rlResult = GetReturnWide(cUnit, false);
else
rlResult = GetReturnWideAlt(cUnit);
StoreValueWide(cUnit, rlDest, rlResult);
}
return false;
}
bool GenConversionCall(CompilationUnit* cUnit, int funcOffset,
RegLocation rlDest, RegLocation rlSrc)
{
/*
* Don't optimize the register usage since it calls out to support
* functions
*/
FlushAllRegs(cUnit); /* Send everything to home location */
if (rlSrc.wide) {
LoadValueDirectWideFixed(cUnit, rlSrc, rlSrc.fp ? TargetReg(kFArg0) : TargetReg(kArg0),
rlSrc.fp ? TargetReg(kFArg1) : TargetReg(kArg1));
} else {
LoadValueDirectFixed(cUnit, rlSrc, rlSrc.fp ? TargetReg(kFArg0) : TargetReg(kArg0));
}
CallRuntimeHelperRegLocation(cUnit, funcOffset, rlSrc, false);
if (rlDest.wide) {
RegLocation rlResult;
rlResult = GetReturnWide(cUnit, rlDest.fp);
StoreValueWide(cUnit, rlDest, rlResult);
} else {
RegLocation rlResult;
rlResult = GetReturn(cUnit, rlDest.fp);
StoreValue(cUnit, rlDest, rlResult);
}
return false;
}
bool GenArithOpFloatPortable(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc1,
RegLocation rlSrc2)
{
RegLocation rlResult;
int funcOffset;
switch (opcode) {
case Instruction::ADD_FLOAT_2ADDR:
case Instruction::ADD_FLOAT:
funcOffset = ENTRYPOINT_OFFSET(pFadd);
break;
case Instruction::SUB_FLOAT_2ADDR:
case Instruction::SUB_FLOAT:
funcOffset = ENTRYPOINT_OFFSET(pFsub);
break;
case Instruction::DIV_FLOAT_2ADDR:
case Instruction::DIV_FLOAT:
funcOffset = ENTRYPOINT_OFFSET(pFdiv);
break;
case Instruction::MUL_FLOAT_2ADDR:
case Instruction::MUL_FLOAT:
funcOffset = ENTRYPOINT_OFFSET(pFmul);
break;
case Instruction::REM_FLOAT_2ADDR:
case Instruction::REM_FLOAT:
funcOffset = ENTRYPOINT_OFFSET(pFmodf);
break;
case Instruction::NEG_FLOAT: {
GenNegFloat(cUnit, rlDest, rlSrc1);
return false;
}
default:
return true;
}
FlushAllRegs(cUnit); /* Send everything to home location */
CallRuntimeHelperRegLocationRegLocation(cUnit, funcOffset, rlSrc1, rlSrc2, false);
rlResult = GetReturn(cUnit, true);
StoreValue(cUnit, rlDest, rlResult);
return false;
}
bool GenArithOpDoublePortable(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc1,
RegLocation rlSrc2)
{
RegLocation rlResult;
int funcOffset;
switch (opcode) {
case Instruction::ADD_DOUBLE_2ADDR:
case Instruction::ADD_DOUBLE:
funcOffset = ENTRYPOINT_OFFSET(pDadd);
break;
case Instruction::SUB_DOUBLE_2ADDR:
case Instruction::SUB_DOUBLE:
funcOffset = ENTRYPOINT_OFFSET(pDsub);
break;
case Instruction::DIV_DOUBLE_2ADDR:
case Instruction::DIV_DOUBLE:
funcOffset = ENTRYPOINT_OFFSET(pDdiv);
break;
case Instruction::MUL_DOUBLE_2ADDR:
case Instruction::MUL_DOUBLE:
funcOffset = ENTRYPOINT_OFFSET(pDmul);
break;
case Instruction::REM_DOUBLE_2ADDR:
case Instruction::REM_DOUBLE:
funcOffset = ENTRYPOINT_OFFSET(pFmod);
break;
case Instruction::NEG_DOUBLE: {
GenNegDouble(cUnit, rlDest, rlSrc1);
return false;
}
default:
return true;
}
FlushAllRegs(cUnit); /* Send everything to home location */
CallRuntimeHelperRegLocationRegLocation(cUnit, funcOffset, rlSrc1, rlSrc2, false);
rlResult = GetReturnWide(cUnit, true);
StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
bool GenConversionPortable(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc)
{
switch (opcode) {
case Instruction::INT_TO_FLOAT:
return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pI2f),
rlDest, rlSrc);
case Instruction::FLOAT_TO_INT:
return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pF2iz),
rlDest, rlSrc);
case Instruction::DOUBLE_TO_FLOAT:
return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pD2f),
rlDest, rlSrc);
case Instruction::FLOAT_TO_DOUBLE:
return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pF2d),
rlDest, rlSrc);
case Instruction::INT_TO_DOUBLE:
return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pI2d),
rlDest, rlSrc);
case Instruction::DOUBLE_TO_INT:
return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pD2iz),
rlDest, rlSrc);
case Instruction::FLOAT_TO_LONG:
return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pF2l),
rlDest, rlSrc);
case Instruction::LONG_TO_FLOAT:
return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pL2f),
rlDest, rlSrc);
case Instruction::DOUBLE_TO_LONG:
return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pD2l),
rlDest, rlSrc);
case Instruction::LONG_TO_DOUBLE:
return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pL2d),
rlDest, rlSrc);
default:
return true;
}
return false;
}
/* Check if we need to check for pending suspend request */
void GenSuspendTest(CompilationUnit* cUnit, int optFlags)
{
if (NO_SUSPEND || (optFlags & MIR_IGNORE_SUSPEND_CHECK)) {
return;
}
FlushAllRegs(cUnit);
LIR* branch = OpTestSuspend(cUnit, NULL);
LIR* retLab = NewLIR0(cUnit, kPseudoTargetLabel);
LIR* target = RawLIR(cUnit, cUnit->currentDalvikOffset, kPseudoSuspendTarget,
reinterpret_cast<uintptr_t>(retLab), cUnit->currentDalvikOffset);
branch->target = target;
InsertGrowableList(cUnit, &cUnit->suspendLaunchpads, reinterpret_cast<uintptr_t>(target));
}
/* Check if we need to check for pending suspend request */
void GenSuspendTestAndBranch(CompilationUnit* cUnit, int optFlags, LIR* target)
{
if (NO_SUSPEND || (optFlags & MIR_IGNORE_SUSPEND_CHECK)) {
OpUnconditionalBranch(cUnit, target);
return;
}
OpTestSuspend(cUnit, target);
LIR* launchPad =
RawLIR(cUnit, cUnit->currentDalvikOffset, kPseudoSuspendTarget,
reinterpret_cast<uintptr_t>(target), cUnit->currentDalvikOffset);
FlushAllRegs(cUnit);
OpUnconditionalBranch(cUnit, launchPad);
InsertGrowableList(cUnit, &cUnit->suspendLaunchpads, reinterpret_cast<uintptr_t>(launchPad));
}
} // namespace art