Quick Compiler function renaming
Move the Quick compiler's function naming to Art coding conventions. Will
be done is pieces: names first, then arguments and locals. Also removed
some dead code and marked statics for the top level source files
No logic changes aside from eliminating a few useless exported "oat"
routines.
Change-Id: Iadaddc560942a0fc1199ba5b1c261cd6ac5cfd9a
diff --git a/src/compiler/codegen/gen_common.cc b/src/compiler/codegen/gen_common.cc
index 649ae82..af7d4e0 100644
--- a/src/compiler/codegen/gen_common.cc
+++ b/src/compiler/codegen/gen_common.cc
@@ -22,7 +22,7 @@
namespace art {
//TODO: remove decl.
-void genInvoke(CompilationUnit* cUnit, CallInfo* info);
+void GenInvoke(CompilationUnit* cUnit, CallInfo* info);
/*
* This source files contains "gen" codegen routines that should
@@ -30,10 +30,10 @@
* and "op" calls may be used here.
*/
-void markSafepointPC(CompilationUnit* cUnit, LIR* inst)
+void MarkSafepointPC(CompilationUnit* cUnit, LIR* inst)
{
inst->defMask = ENCODE_ALL;
- LIR* safepointPC = newLIR0(cUnit, kPseudoSafepointPC);
+ LIR* safepointPC = NewLIR0(cUnit, kPseudoSafepointPC);
DCHECK_EQ(safepointPC->defMask, ENCODE_ALL);
}
@@ -43,275 +43,275 @@
* 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)
+int CallHelperSetup(CompilationUnit* cUnit, int helperOffset)
{
- return (cUnit->instructionSet == kX86) ? 0 : loadHelper(cUnit, 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* CallHelper(CompilationUnit* cUnit, int rTgt, int helperOffset, bool safepointPC)
{
LIR* callInst;
if (cUnit->instructionSet == kX86) {
- callInst = opThreadMem(cUnit, kOpBlx, helperOffset);
+ callInst = OpThreadMem(cUnit, kOpBlx, helperOffset);
} else {
- callInst = opReg(cUnit, kOpBlx, rTgt);
- oatFreeTemp(cUnit, rTgt);
+ callInst = OpReg(cUnit, kOpBlx, rTgt);
+ FreeTemp(cUnit, rTgt);
}
if (safepointPC) {
- markSafepointPC(cUnit, callInst);
+ 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);
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, safepointPC);
+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);
- oatClobberCalleeSave(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,
+void CallRuntimeHelperRegLocation(CompilationUnit* cUnit, int helperOffset, RegLocation arg0,
bool safepointPC) {
- int rTgt = callHelperSetup(cUnit, helperOffset);
+ int rTgt = CallHelperSetup(cUnit, helperOffset);
if (arg0.wide == 0) {
- loadValueDirectFixed(cUnit, arg0, targetReg(kArg0));
+ LoadValueDirectFixed(cUnit, arg0, TargetReg(kArg0));
} else {
- loadValueDirectWideFixed(cUnit, arg0, targetReg(kArg0), targetReg(kArg1));
+ LoadValueDirectWideFixed(cUnit, arg0, TargetReg(kArg0), TargetReg(kArg1));
}
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, safepointPC);
+ ClobberCalleeSave(cUnit);
+ CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
-void callRuntimeHelperImmImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1,
+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);
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, 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,
+void CallRuntimeHelperImmRegLocation(CompilationUnit* cUnit, int helperOffset, int arg0,
RegLocation arg1, bool safepointPC) {
- int rTgt = callHelperSetup(cUnit, helperOffset);
+ int rTgt = CallHelperSetup(cUnit, helperOffset);
if (arg1.wide == 0) {
- loadValueDirectFixed(cUnit, arg1, targetReg(kArg1));
+ LoadValueDirectFixed(cUnit, arg1, TargetReg(kArg1));
} else {
- loadValueDirectWideFixed(cUnit, arg1, targetReg(kArg1), targetReg(kArg2));
+ LoadValueDirectWideFixed(cUnit, arg1, TargetReg(kArg1), TargetReg(kArg2));
}
- loadConstant(cUnit, targetReg(kArg0), arg0);
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, safepointPC);
+ LoadConstant(cUnit, TargetReg(kArg0), arg0);
+ ClobberCalleeSave(cUnit);
+ CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
-void callRuntimeHelperRegLocationImm(CompilationUnit* cUnit, int helperOffset, RegLocation arg0,
+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);
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, 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,
+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);
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, 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,
+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);
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, 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);
- oatClobberCalleeSave(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,
+void CallRuntimeHelperRegLocationRegLocation(CompilationUnit* cUnit, int helperOffset,
RegLocation arg0, RegLocation arg1, bool safepointPC) {
- int rTgt = callHelperSetup(cUnit, helperOffset);
+ int rTgt = CallHelperSetup(cUnit, helperOffset);
if (arg0.wide == 0) {
- loadValueDirectFixed(cUnit, arg0, arg0.fp ? targetReg(kFArg0) : targetReg(kArg0));
+ 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));
+ LoadValueDirectFixed(cUnit, arg1, arg1.fp ? TargetReg(kFArg2) : TargetReg(kArg1));
} else {
- loadValueDirectFixed(cUnit, arg1, targetReg(kArg1));
+ 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));
+ LoadValueDirectWideFixed(cUnit, arg1, arg1.fp ? TargetReg(kFArg2) : TargetReg(kArg1), arg1.fp ? TargetReg(kFArg3) : TargetReg(kArg2));
} else {
- loadValueDirectWideFixed(cUnit, arg1, targetReg(kArg1), targetReg(kArg2));
+ LoadValueDirectWideFixed(cUnit, arg1, TargetReg(kArg1), TargetReg(kArg2));
}
}
} else {
- loadValueDirectWideFixed(cUnit, arg0, arg0.fp ? targetReg(kFArg0) : targetReg(kArg0), arg0.fp ? targetReg(kFArg1) : targetReg(kArg1));
+ 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));
+ 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));
+ LoadValueDirectWideFixed(cUnit, arg1, arg1.fp ? TargetReg(kFArg2) : TargetReg(kArg2), arg1.fp ? TargetReg(kFArg3) : TargetReg(kArg3));
}
}
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, safepointPC);
+ ClobberCalleeSave(cUnit);
+ CallHelper(cUnit, rTgt, helperOffset, safepointPC);
}
-void callRuntimeHelperRegReg(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1,
+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);
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, 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,
+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);
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, 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,
+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);
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, 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,
+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);
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, 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,
+void CallRuntimeHelperImmRegLocationRegLocation(CompilationUnit* cUnit, int helperOffset,
int arg0, RegLocation arg1, RegLocation arg2,
bool safepointPC) {
- int rTgt = callHelperSetup(cUnit, helperOffset);
- loadValueDirectFixed(cUnit, arg1, targetReg(kArg1));
+ int rTgt = CallHelperSetup(cUnit, helperOffset);
+ LoadValueDirectFixed(cUnit, arg1, TargetReg(kArg1));
if (arg2.wide == 0) {
- loadValueDirectFixed(cUnit, arg2, targetReg(kArg2));
+ LoadValueDirectFixed(cUnit, arg2, TargetReg(kArg2));
} else {
- loadValueDirectWideFixed(cUnit, arg2, targetReg(kArg2), targetReg(kArg3));
+ LoadValueDirectWideFixed(cUnit, arg2, TargetReg(kArg2), TargetReg(kArg3));
}
- loadConstant(cUnit, targetReg(kArg0), arg0);
- oatClobberCalleeSave(cUnit);
- callHelper(cUnit, rTgt, helperOffset, safepointPC);
+ 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)
+void GenBarrier(CompilationUnit* cUnit)
{
- LIR* barrier = newLIR0(cUnit, kPseudoBarrier);
+ 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* OpUnconditionalBranch(CompilationUnit* cUnit, LIR* target)
{
- LIR* branch = opBranchUnconditional(cUnit, kOpUncondBr);
+ 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,
+LIR* GenCheck(CompilationUnit* cUnit, ConditionCode cCode,
ThrowKind kind)
{
DCHECK_NE(cUnit->instructionSet, kMips);
- LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind,
+ LIR* tgt = RawLIR(cUnit, 0, kPseudoThrowTarget, kind,
cUnit->currentDalvikOffset);
- LIR* branch = opCondBranch(cUnit, cCode, tgt);
+ LIR* branch = OpCondBranch(cUnit, cCode, tgt);
// Remember branch target - will process later
- oatInsertGrowableList(cUnit, &cUnit->throwLaunchpads, reinterpret_cast<uintptr_t>(tgt));
+ InsertGrowableList(cUnit, &cUnit->throwLaunchpads, reinterpret_cast<uintptr_t>(tgt));
return branch;
}
-LIR* genImmedCheck(CompilationUnit* cUnit, ConditionCode cCode,
+LIR* GenImmedCheck(CompilationUnit* cUnit, ConditionCode cCode,
int reg, int immVal, ThrowKind kind)
{
- LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind,
+ LIR* tgt = RawLIR(cUnit, 0, kPseudoThrowTarget, kind,
cUnit->currentDalvikOffset);
LIR* branch;
if (cCode == kCondAl) {
- branch = opUnconditionalBranch(cUnit, tgt);
+ branch = OpUnconditionalBranch(cUnit, tgt);
} else {
- branch = opCmpImmBranch(cUnit, cCode, reg, immVal, tgt);
+ branch = OpCmpImmBranch(cUnit, cCode, reg, immVal, tgt);
}
// Remember branch target - will process later
- oatInsertGrowableList(cUnit, &cUnit->throwLaunchpads, reinterpret_cast<uintptr_t>(tgt));
+ 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)
+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);
+ return GenImmedCheck(cUnit, kCondEq, mReg, 0, kThrowNullPointer);
}
/* Perform check on two registers */
-LIR* genRegRegCheck(CompilationUnit* cUnit, ConditionCode cCode,
+LIR* GenRegRegCheck(CompilationUnit* cUnit, ConditionCode cCode,
int reg1, int reg2, ThrowKind kind)
{
- LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind,
+ LIR* tgt = RawLIR(cUnit, 0, kPseudoThrowTarget, kind,
cUnit->currentDalvikOffset, reg1, reg2);
- LIR* branch = opCmpBranch(cUnit, cCode, reg1, reg2, tgt);
+ LIR* branch = OpCmpBranch(cUnit, cCode, reg1, reg2, tgt);
// Remember branch target - will process later
- oatInsertGrowableList(cUnit, &cUnit->throwLaunchpads, reinterpret_cast<uintptr_t>(tgt));
+ InsertGrowableList(cUnit, &cUnit->throwLaunchpads, reinterpret_cast<uintptr_t>(tgt));
return branch;
}
-void genCompareAndBranch(CompilationUnit* cUnit, Instruction::Code opcode,
+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);
+ rlSrc1 = LoadValue(cUnit, rlSrc1, kCoreReg);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kCoreReg);
switch (opcode) {
case Instruction::IF_EQ:
cond = kCondEq;
@@ -335,15 +335,15 @@
cond = static_cast<ConditionCode>(0);
LOG(FATAL) << "Unexpected opcode " << opcode;
}
- opCmpBranch(cUnit, cond, rlSrc1.lowReg, rlSrc2.lowReg, taken);
- opUnconditionalBranch(cUnit, fallThrough);
+ OpCmpBranch(cUnit, cond, rlSrc1.lowReg, rlSrc2.lowReg, taken);
+ OpUnconditionalBranch(cUnit, fallThrough);
}
-void genCompareZeroAndBranch(CompilationUnit* cUnit, Instruction::Code opcode,
+void GenCompareZeroAndBranch(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlSrc, LIR* taken, LIR* fallThrough)
{
ConditionCode cond;
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
switch (opcode) {
case Instruction::IF_EQZ:
cond = kCondEq;
@@ -368,32 +368,32 @@
LOG(FATAL) << "Unexpected opcode " << opcode;
}
if (cUnit->instructionSet == kThumb2) {
- opRegImm(cUnit, kOpCmp, rlSrc.lowReg, 0);
- opCondBranch(cUnit, cond, taken);
+ OpRegImm(cUnit, kOpCmp, rlSrc.lowReg, 0);
+ OpCondBranch(cUnit, cond, taken);
} else {
- opCmpImmBranch(cUnit, cond, rlSrc.lowReg, 0, taken);
+ OpCmpImmBranch(cUnit, cond, rlSrc.lowReg, 0, taken);
}
- opUnconditionalBranch(cUnit, fallThrough);
+ OpUnconditionalBranch(cUnit, fallThrough);
}
-void genIntToLong(CompilationUnit* cUnit, RegLocation rlDest,
+void GenIntToLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
if (rlSrc.location == kLocPhysReg) {
- opRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
+ OpRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
} else {
- loadValueDirect(cUnit, rlSrc, rlResult.lowReg);
+ LoadValueDirect(cUnit, rlSrc, rlResult.lowReg);
}
- opRegRegImm(cUnit, kOpAsr, rlResult.highReg, rlResult.lowReg, 31);
- storeValueWide(cUnit, rlDest, rlResult);
+ OpRegRegImm(cUnit, kOpAsr, rlResult.highReg, rlResult.lowReg, 31);
+ StoreValueWide(cUnit, rlDest, rlResult);
}
-void genIntNarrowing(CompilationUnit* cUnit, Instruction::Code opcode,
+void GenIntNarrowing(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc)
{
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
OpKind op = kOpInvalid;
switch (opcode) {
case Instruction::INT_TO_BYTE:
@@ -408,8 +408,8 @@
default:
LOG(ERROR) << "Bad int conversion type";
}
- opRegReg(cUnit, op, rlResult.lowReg, rlSrc.lowReg);
- storeValue(cUnit, rlDest, rlResult);
+ OpRegReg(cUnit, op, rlResult.lowReg, rlSrc.lowReg);
+ StoreValue(cUnit, rlDest, rlResult);
}
/*
@@ -417,10 +417,10 @@
* Array::AllocFromCode(type_idx, method, count);
* Note: AllocFromCode will handle checks for errNegativeArraySize.
*/
-void genNewArray(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest,
+void GenNewArray(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest,
RegLocation rlSrc)
{
- oatFlushAllRegs(cUnit); /* Everything to home location */
+ FlushAllRegs(cUnit); /* Everything to home location */
int funcOffset;
if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
*cUnit->dex_file,
@@ -429,22 +429,22 @@
} else {
funcOffset= ENTRYPOINT_OFFSET(pAllocArrayFromCodeWithAccessCheck);
}
- callRuntimeHelperImmMethodRegLocation(cUnit, funcOffset, type_idx, rlSrc, true);
- RegLocation rlResult = oatGetReturn(cUnit, false);
- storeValue(cUnit, rlDest, rlResult);
+ CallRuntimeHelperImmMethodRegLocation(cUnit, funcOffset, type_idx, rlSrc, true);
+ RegLocation rlResult = GetReturn(cUnit, false);
+ StoreValue(cUnit, rlDest, rlResult);
}
/*
- * Similar to genNewArray, but with post-allocation initialization.
+ * 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)
+void GenFilledNewArray(CompilationUnit* cUnit, CallInfo* info)
{
int elems = info->numArgWords;
int typeIdx = info->index;
- oatFlushAllRegs(cUnit); /* Everything to home location */
+ FlushAllRegs(cUnit); /* Everything to home location */
int funcOffset;
if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
*cUnit->dex_file,
@@ -453,9 +453,9 @@
} else {
funcOffset = ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCodeWithAccessCheck);
}
- callRuntimeHelperImmMethodImm(cUnit, funcOffset, typeIdx, elems, true);
- oatFreeTemp(cUnit, targetReg(kArg2));
- oatFreeTemp(cUnit, targetReg(kArg1));
+ 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
@@ -463,7 +463,7 @@
* added, it may be necessary to additionally copy all return
* values to a home location in thread-local storage
*/
- oatLockTemp(cUnit, targetReg(kRet0));
+ 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)
@@ -480,9 +480,9 @@
* home location.
*/
for (int i = 0; i < elems; i++) {
- RegLocation loc = oatUpdateLoc(cUnit, info->args[i]);
+ RegLocation loc = UpdateLoc(cUnit, info->args[i]);
if (loc.location == kLocPhysReg) {
- storeBaseDisp(cUnit, targetReg(kSp), oatSRegOffset(cUnit, loc.sRegLow),
+ StoreBaseDisp(cUnit, TargetReg(kSp), SRegOffset(cUnit, loc.sRegLow),
loc.lowReg, kWord);
}
}
@@ -491,62 +491,62 @@
* this is an uncommon operation and isn't especially performance
* critical.
*/
- int rSrc = oatAllocTemp(cUnit);
- int rDst = oatAllocTemp(cUnit);
- int rIdx = oatAllocTemp(cUnit);
+ int rSrc = AllocTemp(cUnit);
+ int rDst = AllocTemp(cUnit);
+ int rIdx = AllocTemp(cUnit);
int rVal = INVALID_REG;
switch(cUnit->instructionSet) {
case kThumb2:
- rVal = targetReg(kLr);
+ rVal = TargetReg(kLr);
break;
case kX86:
- oatFreeTemp(cUnit, targetReg(kRet0));
- rVal = oatAllocTemp(cUnit);
+ FreeTemp(cUnit, TargetReg(kRet0));
+ rVal = AllocTemp(cUnit);
break;
case kMips:
- rVal = oatAllocTemp(cUnit);
+ 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),
- oatSRegOffset(cUnit, rlFirst.sRegLow));
+ OpRegRegImm(cUnit, kOpAdd, rSrc, TargetReg(kSp),
+ SRegOffset(cUnit, rlFirst.sRegLow));
// Set up the target pointer
- opRegRegImm(cUnit, kOpAdd, rDst, targetReg(kRet0),
+ 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);
+ LoadConstant(cUnit, rIdx, elems - 1);
// Generate the copy loop. Going backwards for convenience
- LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
// Copy next element
- loadBaseIndexed(cUnit, rSrc, rIdx, rVal, 2, kWord);
- storeBaseIndexed(cUnit, rDst, rIdx, rVal, 2, kWord);
- oatFreeTemp(cUnit, rVal);
- opDecAndBranch(cUnit, kCondGe, rIdx, target);
+ 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());
+ 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),
+ 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 (oatIsTemp(cUnit, rlArg.lowReg)) {
- oatFreeTemp(cUnit, rlArg.lowReg);
+ // 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, oatGetReturn(cUnit, false /* not fp */));
+ StoreValue(cUnit, info->result, GetReturn(cUnit, false /* not fp */));
}
}
-void genSput(CompilationUnit* cUnit, uint32_t fieldIdx, RegLocation rlSrc,
+void GenSput(CompilationUnit* cUnit, uint32_t fieldIdx, RegLocation rlSrc,
bool isLongOrDouble, bool isObject)
{
int fieldOffset;
@@ -567,78 +567,78 @@
int rBase;
if (isReferrersClass) {
// Fast path, static storage base is this method's class
- RegLocation rlMethod = loadCurrMethod(cUnit);
- rBase = oatAllocTemp(cUnit);
- loadWordDisp(cUnit, rlMethod.lowReg,
+ RegLocation rlMethod = LoadCurrMethod(cUnit);
+ rBase = AllocTemp(cUnit);
+ LoadWordDisp(cUnit, rlMethod.lowReg,
AbstractMethod::DeclaringClassOffset().Int32Value(), rBase);
- if (oatIsTemp(cUnit, rlMethod.lowReg)) {
- oatFreeTemp(cUnit, rlMethod.lowReg);
+ 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.
- oatFlushAllRegs(cUnit);
+ FlushAllRegs(cUnit);
// Using fixed register to sync with possible call to runtime
// support.
- int rMethod = targetReg(kArg1);
- oatLockTemp(cUnit, rMethod);
- loadCurrMethodDirect(cUnit, rMethod);
- rBase = targetReg(kArg0);
- oatLockTemp(cUnit, rBase);
- loadWordDisp(cUnit, rMethod,
+ 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,
+ 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);
+ 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));
+ OpRegCopy(cUnit, rBase, TargetReg(kRet0));
}
- LIR* skipTarget = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* skipTarget = NewLIR0(cUnit, kPseudoTargetLabel);
branchOver->target = skipTarget;
- oatFreeTemp(cUnit, rMethod);
+ FreeTemp(cUnit, rMethod);
}
// rBase now holds static storage base
if (isLongOrDouble) {
- rlSrc = loadValueWide(cUnit, rlSrc, kAnyReg);
+ rlSrc = LoadValueWide(cUnit, rlSrc, kAnyReg);
} else {
- rlSrc = loadValue(cUnit, rlSrc, kAnyReg);
+ rlSrc = LoadValue(cUnit, rlSrc, kAnyReg);
}
if (isVolatile) {
- oatGenMemBarrier(cUnit, kStoreStore);
+ GenMemBarrier(cUnit, kStoreStore);
}
if (isLongOrDouble) {
- storeBaseDispWide(cUnit, rBase, fieldOffset, rlSrc.lowReg,
+ StoreBaseDispWide(cUnit, rBase, fieldOffset, rlSrc.lowReg,
rlSrc.highReg);
} else {
- storeWordDisp(cUnit, rBase, fieldOffset, rlSrc.lowReg);
+ StoreWordDisp(cUnit, rBase, fieldOffset, rlSrc.lowReg);
}
if (isVolatile) {
- oatGenMemBarrier(cUnit, kStoreLoad);
+ GenMemBarrier(cUnit, kStoreLoad);
}
if (isObject) {
- markGCCard(cUnit, rlSrc.lowReg, rBase);
+ MarkGCCard(cUnit, rlSrc.lowReg, rBase);
}
- oatFreeTemp(cUnit, rBase);
+ FreeTemp(cUnit, rBase);
} else {
- oatFlushAllRegs(cUnit); // Everything to home locations
+ 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);
+ CallRuntimeHelperImmRegLocation(cUnit, setterOffset, fieldIdx, rlSrc, true);
}
}
-void genSget(CompilationUnit* cUnit, uint32_t fieldIdx, RegLocation rlDest,
+void GenSget(CompilationUnit* cUnit, uint32_t fieldIdx, RegLocation rlDest,
bool isLongOrDouble, bool isObject)
{
int fieldOffset;
@@ -661,134 +661,134 @@
int rBase;
if (isReferrersClass) {
// Fast path, static storage base is this method's class
- RegLocation rlMethod = loadCurrMethod(cUnit);
- rBase = oatAllocTemp(cUnit);
- loadWordDisp(cUnit, rlMethod.lowReg,
+ 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.
- oatFlushAllRegs(cUnit);
+ FlushAllRegs(cUnit);
// Using fixed register to sync with possible call to runtime
// support
- int rMethod = targetReg(kArg1);
- oatLockTemp(cUnit, rMethod);
- loadCurrMethodDirect(cUnit, rMethod);
- rBase = targetReg(kArg0);
- oatLockTemp(cUnit, rBase);
- loadWordDisp(cUnit, rMethod,
+ 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,
+ 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);
+ 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));
+ OpRegCopy(cUnit, rBase, TargetReg(kRet0));
}
- LIR* skipTarget = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* skipTarget = NewLIR0(cUnit, kPseudoTargetLabel);
branchOver->target = skipTarget;
- oatFreeTemp(cUnit, rMethod);
+ FreeTemp(cUnit, rMethod);
}
// rBase now holds static storage base
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
if (isVolatile) {
- oatGenMemBarrier(cUnit, kLoadLoad);
+ GenMemBarrier(cUnit, kLoadLoad);
}
if (isLongOrDouble) {
- loadBaseDispWide(cUnit, rBase, fieldOffset, rlResult.lowReg,
+ LoadBaseDispWide(cUnit, rBase, fieldOffset, rlResult.lowReg,
rlResult.highReg, INVALID_SREG);
} else {
- loadWordDisp(cUnit, rBase, fieldOffset, rlResult.lowReg);
+ LoadWordDisp(cUnit, rBase, fieldOffset, rlResult.lowReg);
}
- oatFreeTemp(cUnit, rBase);
+ FreeTemp(cUnit, rBase);
if (isLongOrDouble) {
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
} else {
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
}
} else {
- oatFlushAllRegs(cUnit); // Everything to home locations
+ FlushAllRegs(cUnit); // Everything to home locations
int getterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pGet64Static) :
(isObject ? ENTRYPOINT_OFFSET(pGetObjStatic)
: ENTRYPOINT_OFFSET(pGet32Static));
- callRuntimeHelperImm(cUnit, getterOffset, fieldIdx, true);
+ CallRuntimeHelperImm(cUnit, getterOffset, fieldIdx, true);
if (isLongOrDouble) {
- RegLocation rlResult = oatGetReturnWide(cUnit, rlDest.fp);
- storeValueWide(cUnit, rlDest, rlResult);
+ RegLocation rlResult = GetReturnWide(cUnit, rlDest.fp);
+ StoreValueWide(cUnit, rlDest, rlResult);
} else {
- RegLocation rlResult = oatGetReturn(cUnit, rlDest.fp);
- storeValue(cUnit, rlDest, rlResult);
+ RegLocation rlResult = GetReturn(cUnit, rlDest.fp);
+ StoreValue(cUnit, rlDest, rlResult);
}
}
}
// Debugging routine - if null target, branch to DebugMe
-void genShowTarget(CompilationUnit* cUnit)
+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);
+ 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)
+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++) {
- oatResetRegPool(cUnit);
- oatResetDefTracking(cUnit);
+ ResetRegPool(cUnit);
+ ResetDefTracking(cUnit);
LIR* lab = suspendLabel[i];
LIR* resumeLab = reinterpret_cast<LIR*>(lab->operands[0]);
cUnit->currentDalvikOffset = lab->operands[1];
- oatAppendLIR(cUnit, lab);
- int rTgt = callHelperSetup(cUnit, helperOffset);
- callHelper(cUnit, rTgt, helperOffset, true /* markSafepointPC */);
- opUnconditionalBranch(cUnit, resumeLab);
+ AppendLIR(cUnit, lab);
+ int rTgt = CallHelperSetup(cUnit, helperOffset);
+ CallHelper(cUnit, rTgt, helperOffset, true /* MarkSafepointPC */);
+ OpUnconditionalBranch(cUnit, resumeLab);
}
}
-void handleIntrinsicLaunchpads(CompilationUnit *cUnit)
+void HandleIntrinsicLaunchPads(CompilationUnit *cUnit)
{
LIR** intrinsicLabel = reinterpret_cast<LIR**>(cUnit->intrinsicLaunchpads.elemList);
int numElems = cUnit->intrinsicLaunchpads.numUsed;
for (int i = 0; i < numElems; i++) {
- oatResetRegPool(cUnit);
- oatResetDefTracking(cUnit);
+ ResetRegPool(cUnit);
+ ResetDefTracking(cUnit);
LIR* lab = intrinsicLabel[i];
CallInfo* info = reinterpret_cast<CallInfo*>(lab->operands[0]);
cUnit->currentDalvikOffset = info->offset;
- oatAppendLIR(cUnit, lab);
- // NOTE: genInvoke handles markSafepointPC
- genInvoke(cUnit, info);
+ AppendLIR(cUnit, lab);
+ // NOTE: GenInvoke handles MarkSafepointPC
+ GenInvoke(cUnit, info);
LIR* resumeLab = reinterpret_cast<LIR*>(lab->operands[2]);
if (resumeLab != NULL) {
- opUnconditionalBranch(cUnit, resumeLab);
+ OpUnconditionalBranch(cUnit, resumeLab);
}
}
}
-void handleThrowLaunchpads(CompilationUnit *cUnit)
+void HandleThrowLaunchPads(CompilationUnit *cUnit)
{
LIR** throwLabel = reinterpret_cast<LIR**>(cUnit->throwLaunchpads.elemList);
int numElems = cUnit->throwLaunchpads.numUsed;
for (int i = 0; i < numElems; i++) {
- oatResetRegPool(cUnit);
- oatResetDefTracking(cUnit);
+ ResetRegPool(cUnit);
+ ResetDefTracking(cUnit);
LIR* lab = throwLabel[i];
cUnit->currentDalvikOffset = lab->operands[1];
- oatAppendLIR(cUnit, lab);
+ AppendLIR(cUnit, lab);
int funcOffset = 0;
int v1 = lab->operands[2];
int v2 = lab->operands[3];
@@ -799,33 +799,33 @@
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 (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());
+ OpRegMem(cUnit, kOpMov, TargetReg(kArg1), v2, Array::LengthOffset().Int32Value());
} else {
- opRegCopy(cUnit, targetReg(kArg1), v2);
+ OpRegCopy(cUnit, TargetReg(kArg1), v2);
}
} else {
- if (v1 == targetReg(kArg1)) {
+ if (v1 == TargetReg(kArg1)) {
// Swap v1 and v2, using kArg2 as a temp
- opRegCopy(cUnit, targetReg(kArg2), v1);
+ 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());
+ OpRegMem(cUnit, kOpMov, TargetReg(kArg1), v2, Array::LengthOffset().Int32Value());
} else {
- opRegCopy(cUnit, targetReg(kArg1), v2);
+ OpRegCopy(cUnit, TargetReg(kArg1), v2);
}
- opRegCopy(cUnit, targetReg(kArg0), targetReg(kArg2));
+ 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());
+ OpRegMem(cUnit, kOpMov, TargetReg(kArg1), v2, Array::LengthOffset().Int32Value());
} else {
- opRegCopy(cUnit, targetReg(kArg1), v2);
+ OpRegCopy(cUnit, TargetReg(kArg1), v2);
}
- opRegCopy(cUnit, targetReg(kArg0), v1);
+ OpRegCopy(cUnit, TargetReg(kArg0), v1);
}
}
funcOffset = ENTRYPOINT_OFFSET(pThrowArrayBoundsFromCode);
@@ -834,7 +834,7 @@
funcOffset = ENTRYPOINT_OFFSET(pThrowDivZeroFromCode);
break;
case kThrowNoSuchMethod:
- opRegCopy(cUnit, targetReg(kArg0), v1);
+ OpRegCopy(cUnit, TargetReg(kArg0), v1);
funcOffset =
ENTRYPOINT_OFFSET(pThrowNoSuchMethodFromCode);
break;
@@ -842,27 +842,21 @@
funcOffset = ENTRYPOINT_OFFSET(pThrowStackOverflowFromCode);
// Restore stack alignment
if (targetX86) {
- opRegImm(cUnit, kOpAdd, targetReg(kSp), cUnit->frameSize);
+ OpRegImm(cUnit, kOpAdd, TargetReg(kSp), cUnit->frameSize);
} else {
- opRegImm(cUnit, kOpAdd, targetReg(kSp), (cUnit->numCoreSpills + cUnit->numFPSpills) * 4);
+ OpRegImm(cUnit, kOpAdd, TargetReg(kSp), (cUnit->numCoreSpills + cUnit->numFPSpills) * 4);
}
break;
default:
LOG(FATAL) << "Unexpected throw kind: " << lab->operands[0];
}
- oatClobberCalleeSave(cUnit);
- int rTgt = callHelperSetup(cUnit, funcOffset);
- callHelper(cUnit, rTgt, funcOffset, true /* markSafepointPC */);
+ ClobberCalleeSave(cUnit);
+ int rTgt = CallHelperSetup(cUnit, funcOffset);
+ CallHelper(cUnit, rTgt, funcOffset, true /* MarkSafepointPC */);
}
}
-/* Needed by the Assembler */
-void oatSetupResourceMasks(CompilationUnit* cUnit, LIR* lir)
-{
- setupResourceMasks(cUnit, lir);
-}
-
-bool fastInstance(CompilationUnit* cUnit, uint32_t fieldIdx,
+bool FastInstance(CompilationUnit* cUnit, uint32_t fieldIdx,
int& fieldOffset, bool& isVolatile, bool isPut)
{
OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
@@ -873,176 +867,176 @@
fieldOffset, isVolatile, isPut);
}
-void genIGet(CompilationUnit* cUnit, uint32_t fieldIdx, int optFlags, OpSize size,
+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);
+ 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);
+ rlObj = LoadValue(cUnit, rlObj, kCoreReg);
if (isLongOrDouble) {
DCHECK(rlDest.wide);
- genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
+ GenNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
if (cUnit->instructionSet == kX86) {
- rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
- genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
- loadBaseDispWide(cUnit, rlObj.lowReg, fieldOffset, rlResult.lowReg,
+ 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) {
- oatGenMemBarrier(cUnit, kLoadLoad);
+ GenMemBarrier(cUnit, kLoadLoad);
}
} else {
- int regPtr = oatAllocTemp(cUnit);
- opRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
- rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
- loadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
+ 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) {
- oatGenMemBarrier(cUnit, kLoadLoad);
+ GenMemBarrier(cUnit, kLoadLoad);
}
- oatFreeTemp(cUnit, regPtr);
+ FreeTemp(cUnit, regPtr);
}
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
} else {
- rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
- genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
- loadBaseDisp(cUnit, rlObj.lowReg, fieldOffset, rlResult.lowReg,
+ 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) {
- oatGenMemBarrier(cUnit, kLoadLoad);
+ GenMemBarrier(cUnit, kLoadLoad);
}
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
}
} else {
int getterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pGet64Instance) :
(isObject ? ENTRYPOINT_OFFSET(pGetObjInstance)
: ENTRYPOINT_OFFSET(pGet32Instance));
- callRuntimeHelperImmRegLocation(cUnit, getterOffset, fieldIdx, rlObj, true);
+ CallRuntimeHelperImmRegLocation(cUnit, getterOffset, fieldIdx, rlObj, true);
if (isLongOrDouble) {
- RegLocation rlResult = oatGetReturnWide(cUnit, rlDest.fp);
- storeValueWide(cUnit, rlDest, rlResult);
+ RegLocation rlResult = GetReturnWide(cUnit, rlDest.fp);
+ StoreValueWide(cUnit, rlDest, rlResult);
} else {
- RegLocation rlResult = oatGetReturn(cUnit, rlDest.fp);
- storeValue(cUnit, rlDest, rlResult);
+ RegLocation rlResult = GetReturn(cUnit, rlDest.fp);
+ StoreValue(cUnit, rlDest, rlResult);
}
}
}
-void genIPut(CompilationUnit* cUnit, uint32_t fieldIdx, int optFlags, OpSize size,
+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,
+ 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);
+ rlObj = LoadValue(cUnit, rlObj, kCoreReg);
if (isLongOrDouble) {
int regPtr;
- rlSrc = loadValueWide(cUnit, rlSrc, kAnyReg);
- genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
- regPtr = oatAllocTemp(cUnit);
- opRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
+ rlSrc = LoadValueWide(cUnit, rlSrc, kAnyReg);
+ GenNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
+ regPtr = AllocTemp(cUnit);
+ OpRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
if (isVolatile) {
- oatGenMemBarrier(cUnit, kStoreStore);
+ GenMemBarrier(cUnit, kStoreStore);
}
- storeBaseDispWide(cUnit, regPtr, 0, rlSrc.lowReg, rlSrc.highReg);
+ StoreBaseDispWide(cUnit, regPtr, 0, rlSrc.lowReg, rlSrc.highReg);
if (isVolatile) {
- oatGenMemBarrier(cUnit, kLoadLoad);
+ GenMemBarrier(cUnit, kLoadLoad);
}
- oatFreeTemp(cUnit, regPtr);
+ FreeTemp(cUnit, regPtr);
} else {
- rlSrc = loadValue(cUnit, rlSrc, regClass);
- genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
+ rlSrc = LoadValue(cUnit, rlSrc, regClass);
+ GenNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, optFlags);
if (isVolatile) {
- oatGenMemBarrier(cUnit, kStoreStore);
+ GenMemBarrier(cUnit, kStoreStore);
}
- storeBaseDisp(cUnit, rlObj.lowReg, fieldOffset, rlSrc.lowReg, kWord);
+ StoreBaseDisp(cUnit, rlObj.lowReg, fieldOffset, rlSrc.lowReg, kWord);
if (isVolatile) {
- oatGenMemBarrier(cUnit, kLoadLoad);
+ GenMemBarrier(cUnit, kLoadLoad);
}
if (isObject) {
- markGCCard(cUnit, rlSrc.lowReg, rlObj.lowReg);
+ 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);
+ CallRuntimeHelperImmRegLocationRegLocation(cUnit, setterOffset, fieldIdx, rlObj, rlSrc, true);
}
}
-void genConstClass(CompilationUnit* cUnit, uint32_t type_idx,
+void GenConstClass(CompilationUnit* cUnit, uint32_t type_idx,
RegLocation rlDest)
{
- RegLocation rlMethod = loadCurrMethod(cUnit);
- int resReg = oatAllocTemp(cUnit);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ 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),
+ CallRuntimeHelperImmReg(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
type_idx, rlMethod.lowReg, true);
- RegLocation rlResult = oatGetReturn(cUnit, false);
- storeValue(cUnit, rlDest, rlResult);
+ 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);
+ 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);
+ 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
- oatFlushAllRegs(cUnit);
- LIR* branch1 = opCmpImmBranch(cUnit, kCondEq, rlResult.lowReg, 0, NULL);
+ FlushAllRegs(cUnit);
+ LIR* branch1 = OpCmpImmBranch(cUnit, kCondEq, rlResult.lowReg, 0, NULL);
// Resolved, store and hop over following code
- storeValue(cUnit, rlDest, rlResult);
+ 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
*/
- oatClobberSReg(cUnit, rlDest.sRegLow);
- LIR* branch2 = opUnconditionalBranch(cUnit,0);
+ ClobberSReg(cUnit, rlDest.sRegLow);
+ LIR* branch2 = OpUnconditionalBranch(cUnit,0);
// TUNING: move slow path to end & remove unconditional branch
- LIR* target1 = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* target1 = NewLIR0(cUnit, kPseudoTargetLabel);
// Call out to helper, which will return resolved type in kArg0
- callRuntimeHelperImmReg(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeFromCode), type_idx,
+ CallRuntimeHelperImmReg(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeFromCode), type_idx,
rlMethod.lowReg, true);
- RegLocation rlResult = oatGetReturn(cUnit, false);
- storeValue(cUnit, rlDest, rlResult);
+ 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
*/
- oatClobberSReg(cUnit, rlDest.sRegLow);
+ ClobberSReg(cUnit, rlDest.sRegLow);
// Rejoin code paths
- LIR* target2 = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* target2 = NewLIR0(cUnit, kPseudoTargetLabel);
branch1->target = target1;
branch2->target = target2;
} else {
// Fast path, we're done - just store result
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
}
}
}
-void genConstString(CompilationUnit* cUnit, uint32_t string_idx,
+void GenConstString(CompilationUnit* cUnit, uint32_t string_idx,
RegLocation rlDest)
{
/* NOTE: Most strings should be available at compile time */
@@ -1051,48 +1045,48 @@
if (!cUnit->compiler->CanAssumeStringIsPresentInDexCache(
*cUnit->dex_file, string_idx) || SLOW_STRING_PATH) {
// slow path, resolve string if not in dex cache
- oatFlushAllRegs(cUnit);
- oatLockCallTemps(cUnit); // Using explicit registers
- loadCurrMethodDirect(cUnit, targetReg(kArg2));
- loadWordDisp(cUnit, targetReg(kArg2),
- AbstractMethod::DexCacheStringsOffset().Int32Value(), targetReg(kArg0));
+ 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);
+ 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);
+ 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");
+ 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);
- oatFreeTemp(cUnit, rTgt);
+ 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);
- oatFreeTemp(cUnit, rTgt);
- LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
+ 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);
+ CallRuntimeHelperRegReg(cUnit, ENTRYPOINT_OFFSET(pResolveStringFromCode), TargetReg(kArg2), TargetReg(kArg1), true);
}
- genBarrier(cUnit);
- storeValue(cUnit, rlDest, oatGetReturn(cUnit, false));
+ GenBarrier(cUnit);
+ StoreValue(cUnit, rlDest, GetReturn(cUnit, false));
} else {
- RegLocation rlMethod = loadCurrMethod(cUnit);
- int resReg = oatAllocTemp(cUnit);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- loadWordDisp(cUnit, rlMethod.lowReg,
+ 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);
+ LoadWordDisp(cUnit, resReg, offset_of_string, rlResult.lowReg);
+ StoreValue(cUnit, rlDest, rlResult);
}
}
@@ -1100,9 +1094,9 @@
* Let helper function take care of everything. Will
* call Class::NewInstanceFromCode(type_idx, method);
*/
-void genNewInstance(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest)
+void GenNewInstance(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest)
{
- oatFlushAllRegs(cUnit); /* Everything to home location */
+ 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;
@@ -1112,181 +1106,181 @@
} else {
funcOffset = ENTRYPOINT_OFFSET(pAllocObjectFromCodeWithAccessCheck);
}
- callRuntimeHelperImmMethod(cUnit, funcOffset, type_idx, true);
- RegLocation rlResult = oatGetReturn(cUnit, false);
- storeValue(cUnit, rlDest, rlResult);
+ CallRuntimeHelperImmMethod(cUnit, funcOffset, type_idx, true);
+ RegLocation rlResult = GetReturn(cUnit, false);
+ StoreValue(cUnit, rlDest, rlResult);
}
-void genMoveException(CompilationUnit* cUnit, RegLocation rlDest)
+void GenMoveException(CompilationUnit* cUnit, RegLocation rlDest)
{
- oatFlushAllRegs(cUnit); /* Everything to home location */
+ 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);
+ CallRuntimeHelperReg(cUnit, funcOffset, TargetReg(kArg0), false);
} else {
- callRuntimeHelperReg(cUnit, funcOffset, targetReg(kSelf), false);
+ CallRuntimeHelperReg(cUnit, funcOffset, TargetReg(kSelf), false);
}
- RegLocation rlResult = oatGetReturn(cUnit, false);
- storeValue(cUnit, rlDest, rlResult);
+ RegLocation rlResult = GetReturn(cUnit, false);
+ StoreValue(cUnit, rlDest, rlResult);
}
-void genThrow(CompilationUnit* cUnit, RegLocation rlSrc)
+void GenThrow(CompilationUnit* cUnit, RegLocation rlSrc)
{
- oatFlushAllRegs(cUnit);
- callRuntimeHelperRegLocation(cUnit, ENTRYPOINT_OFFSET(pDeliverException), rlSrc, true);
+ FlushAllRegs(cUnit);
+ CallRuntimeHelperRegLocation(cUnit, ENTRYPOINT_OFFSET(pDeliverException), rlSrc, true);
}
-void genInstanceof(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest,
+void GenInstanceof(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest,
RegLocation rlSrc)
{
- oatFlushAllRegs(cUnit);
+ FlushAllRegs(cUnit);
// May generate a call - use explicit registers
- oatLockCallTemps(cUnit);
- loadCurrMethodDirect(cUnit, targetReg(kArg1)); // kArg1 <= current Method*
- int classReg = targetReg(kArg2); // kArg2 will hold the Class*
+ 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),
+ 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
+ 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),
+ 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);
+ 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);
+ 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 */
+ 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);
+ LIR* hopTarget = NewLIR0(cUnit, kPseudoTargetLabel);
hopBranch->target = hopTarget;
}
}
/* kArg0 is ref, kArg2 is class. If ref==null, use directly as bool result */
- RegLocation rlResult = oatGetReturn(cUnit, false);
+ RegLocation rlResult = GetReturn(cUnit, false);
if (cUnit->instructionSet == kMips) {
- loadConstant(cUnit, rlResult.lowReg, 0); // store false result for if branch is taken
+ LoadConstant(cUnit, rlResult.lowReg, 0); // store false result for if branch is taken
}
- LIR* branch1 = opCmpImmBranch(cUnit, kCondEq, targetReg(kArg0), 0, NULL);
+ 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));
+ 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)
- oatFreeTemp(cUnit, rTgt);
+ 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);
+ 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)
- oatFreeTemp(cUnit, rTgt);
+ 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));
+ OpRegCopy(cUnit, TargetReg(kArg0), TargetReg(kArg2));
+ callInst = OpThreadMem(cUnit, kOpBlx, ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
}
}
- markSafepointPC(cUnit, callInst);
- oatClobberCalleeSave(cUnit);
+ MarkSafepointPC(cUnit, callInst);
+ ClobberCalleeSave(cUnit);
/* branch targets here */
- LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
- storeValue(cUnit, rlDest, rlResult);
+ 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)
+void GenCheckCast(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlSrc)
{
- oatFlushAllRegs(cUnit);
+ FlushAllRegs(cUnit);
// May generate a call - use explicit registers
- oatLockCallTemps(cUnit);
- loadCurrMethodDirect(cUnit, targetReg(kArg1)); // kArg1 <= current Method*
- int classReg = targetReg(kArg2); // kArg2 will hold the Class*
+ 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
+ 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),
+ 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);
+ 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);
+ 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),
+ CallRuntimeHelperImmReg(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeFromCode), type_idx, TargetReg(kArg1),
true);
- opRegCopy(cUnit, classReg, targetReg(kRet0)); // Align usage with fast path
+ OpRegCopy(cUnit, classReg, TargetReg(kRet0)); // Align usage with fast path
// Rejoin code paths
- LIR* hopTarget = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* hopTarget = NewLIR0(cUnit, kPseudoTargetLabel);
hopBranch->target = hopTarget;
}
}
// At this point, classReg (kArg2) has class
- loadValueDirectFixed(cUnit, rlSrc, targetReg(kArg0)); // kArg0 <= ref
+ LoadValueDirectFixed(cUnit, rlSrc, TargetReg(kArg0)); // kArg0 <= ref
/* Null is OK - continue */
- LIR* branch1 = opCmpImmBranch(cUnit, kCondEq, targetReg(kArg0), 0, NULL);
+ 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));
+ 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));
- oatClobberCalleeSave(cUnit);
- LIR* callInst = opReg(cUnit, kOpBlx, rTgt);
- markSafepointPC(cUnit, callInst);
- oatFreeTemp(cUnit, rTgt);
+ 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);
+ 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);
+ LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
branch1->target = target;
branch2->target = target;
}
@@ -1295,76 +1289,76 @@
* Generate array store
*
*/
-void genArrayObjPut(CompilationUnit* cUnit, int optFlags, RegLocation rlArray,
+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();
- oatFlushAllRegs(cUnit); // Use explicit registers
- oatLockCallTemps(cUnit);
+ 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
+ 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
+ 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?
+ GenNullCheck(cUnit, rlArray.sRegLow, rArray, optFlags); // NPE?
// Store of null?
- LIR* null_value_check = opCmpImmBranch(cUnit, kCondEq, rValue, 0, 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,
+ 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
+ // 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);
+ LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
null_value_check->target = target;
if (cUnit->instructionSet == kX86) {
// make an extra temp available for card mark below
- oatFreeTemp(cUnit, targetReg(kArg1));
+ FreeTemp(cUnit, TargetReg(kArg1));
if (!(optFlags & MIR_IGNORE_RANGE_CHECK)) {
/* if (rlIndex >= [rlArray + lenOffset]) goto kThrowArrayBounds */
- genRegMemCheck(cUnit, kCondUge, rIndex, rArray, lenOffset, kThrowArrayBounds);
+ GenRegMemCheck(cUnit, kCondUge, rIndex, rArray, lenOffset, kThrowArrayBounds);
}
- storeBaseIndexedDisp(cUnit, rArray, rIndex, scale,
+ 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
+ regLen = TargetReg(kArg1);
+ LoadWordDisp(cUnit, rArray, lenOffset, regLen); // Get len
}
/* rPtr -> array data */
- int rPtr = oatAllocTemp(cUnit);
- opRegRegImm(cUnit, kOpAdd, rPtr, rArray, dataOffset);
+ int rPtr = AllocTemp(cUnit);
+ OpRegRegImm(cUnit, kOpAdd, rPtr, rArray, dataOffset);
if (needsRangeCheck) {
- genRegRegCheck(cUnit, kCondCs, rIndex, regLen, kThrowArrayBounds);
+ GenRegRegCheck(cUnit, kCondCs, rIndex, regLen, kThrowArrayBounds);
}
- storeBaseIndexed(cUnit, rPtr, rIndex, rValue, scale, kWord);
- oatFreeTemp(cUnit, rPtr);
+ StoreBaseIndexed(cUnit, rPtr, rIndex, rValue, scale, kWord);
+ FreeTemp(cUnit, rPtr);
}
- oatFreeTemp(cUnit, rIndex);
- markGCCard(cUnit, rValue, rArray);
+ FreeTemp(cUnit, rIndex);
+ MarkGCCard(cUnit, rValue, rArray);
}
/*
* Generate array load
*/
-void genArrayGet(CompilationUnit* cUnit, int optFlags, OpSize size,
+void GenArrayGet(CompilationUnit* cUnit, int optFlags, OpSize size,
RegLocation rlArray, RegLocation rlIndex,
RegLocation rlDest, int scale)
{
@@ -1372,8 +1366,8 @@
int lenOffset = Array::LengthOffset().Int32Value();
int dataOffset;
RegLocation rlResult;
- rlArray = loadValue(cUnit, rlArray, kCoreReg);
- rlIndex = loadValue(cUnit, rlIndex, kCoreReg);
+ rlArray = LoadValue(cUnit, rlArray, kCoreReg);
+ rlIndex = LoadValue(cUnit, rlIndex, kCoreReg);
if (size == kLong || size == kDouble) {
dataOffset = Array::DataOffset(sizeof(int64_t)).Int32Value();
@@ -1382,79 +1376,79 @@
}
/* null object? */
- genNullCheck(cUnit, rlArray.sRegLow, rlArray.lowReg, optFlags);
+ 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,
+ GenRegMemCheck(cUnit, kCondUge, rlIndex.lowReg, rlArray.lowReg,
lenOffset, kThrowArrayBounds);
}
if ((size == kLong) || (size == kDouble)) {
- int regAddr = oatAllocTemp(cUnit);
- opLea(cUnit, regAddr, rlArray.lowReg, rlIndex.lowReg, scale, dataOffset);
- oatFreeTemp(cUnit, rlArray.lowReg);
- oatFreeTemp(cUnit, rlIndex.lowReg);
- rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
- loadBaseIndexedDisp(cUnit, regAddr, INVALID_REG, 0, 0, rlResult.lowReg,
+ 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);
+ StoreValueWide(cUnit, rlDest, rlResult);
} else {
- rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
+ rlResult = EvalLoc(cUnit, rlDest, regClass, true);
- loadBaseIndexedDisp(cUnit, rlArray.lowReg, rlIndex.lowReg, scale,
+ LoadBaseIndexedDisp(cUnit, rlArray.lowReg, rlIndex.lowReg, scale,
dataOffset, rlResult.lowReg, INVALID_REG, size,
INVALID_SREG);
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
}
} else {
- int regPtr = oatAllocTemp(cUnit);
+ int regPtr = AllocTemp(cUnit);
bool needsRangeCheck = (!(optFlags & MIR_IGNORE_RANGE_CHECK));
int regLen = INVALID_REG;
if (needsRangeCheck) {
- regLen = oatAllocTemp(cUnit);
+ regLen = AllocTemp(cUnit);
/* Get len */
- loadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
+ LoadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
}
/* regPtr -> array data */
- opRegRegImm(cUnit, kOpAdd, regPtr, rlArray.lowReg, dataOffset);
- oatFreeTemp(cUnit, rlArray.lowReg);
+ OpRegRegImm(cUnit, kOpAdd, regPtr, rlArray.lowReg, dataOffset);
+ FreeTemp(cUnit, rlArray.lowReg);
if ((size == kLong) || (size == kDouble)) {
if (scale) {
- int rNewIndex = oatAllocTemp(cUnit);
- opRegRegImm(cUnit, kOpLsl, rNewIndex, rlIndex.lowReg, scale);
- opRegReg(cUnit, kOpAdd, regPtr, rNewIndex);
- oatFreeTemp(cUnit, rNewIndex);
+ 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);
+ OpRegReg(cUnit, kOpAdd, regPtr, rlIndex.lowReg);
}
- oatFreeTemp(cUnit, rlIndex.lowReg);
- rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
+ 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);
- oatFreeTemp(cUnit, regLen);
+ GenRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, kThrowArrayBounds);
+ FreeTemp(cUnit, regLen);
}
- loadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
+ LoadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
- oatFreeTemp(cUnit, regPtr);
- storeValueWide(cUnit, rlDest, rlResult);
+ FreeTemp(cUnit, regPtr);
+ StoreValueWide(cUnit, rlDest, rlResult);
} else {
- rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
+ 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);
- oatFreeTemp(cUnit, regLen);
+ GenRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, kThrowArrayBounds);
+ FreeTemp(cUnit, regLen);
}
- loadBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlResult.lowReg, scale, size);
+ LoadBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlResult.lowReg, scale, size);
- oatFreeTemp(cUnit, regPtr);
- storeValue(cUnit, rlDest, rlResult);
+ FreeTemp(cUnit, regPtr);
+ StoreValue(cUnit, rlDest, rlResult);
}
}
}
@@ -1463,7 +1457,7 @@
* Generate array store
*
*/
-void genArrayPut(CompilationUnit* cUnit, int optFlags, OpSize size,
+void GenArrayPut(CompilationUnit* cUnit, int optFlags, OpSize size,
RegLocation rlArray, RegLocation rlIndex,
RegLocation rlSrc, int scale)
{
@@ -1477,87 +1471,87 @@
dataOffset = Array::DataOffset(sizeof(int32_t)).Int32Value();
}
- rlArray = loadValue(cUnit, rlArray, kCoreReg);
- rlIndex = loadValue(cUnit, rlIndex, kCoreReg);
+ rlArray = LoadValue(cUnit, rlArray, kCoreReg);
+ rlIndex = LoadValue(cUnit, rlIndex, kCoreReg);
int regPtr = INVALID_REG;
if (cUnit->instructionSet != kX86) {
- if (oatIsTemp(cUnit, rlArray.lowReg)) {
- oatClobber(cUnit, rlArray.lowReg);
+ if (IsTemp(cUnit, rlArray.lowReg)) {
+ Clobber(cUnit, rlArray.lowReg);
regPtr = rlArray.lowReg;
} else {
- regPtr = oatAllocTemp(cUnit);
- opRegCopy(cUnit, regPtr, rlArray.lowReg);
+ regPtr = AllocTemp(cUnit);
+ OpRegCopy(cUnit, regPtr, rlArray.lowReg);
}
}
/* null object? */
- genNullCheck(cUnit, rlArray.sRegLow, rlArray.lowReg, optFlags);
+ 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);
+ GenRegMemCheck(cUnit, kCondUge, rlIndex.lowReg, rlArray.lowReg, lenOffset, kThrowArrayBounds);
}
if ((size == kLong) || (size == kDouble)) {
- rlSrc = loadValueWide(cUnit, rlSrc, regClass);
+ rlSrc = LoadValueWide(cUnit, rlSrc, regClass);
} else {
- rlSrc = loadValue(cUnit, rlSrc, regClass);
+ 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 = oatAllocTemp(cUnit);
- opRegCopy(cUnit, temp, rlSrc.lowReg);
- storeBaseIndexedDisp(cUnit, rlArray.lowReg, rlIndex.lowReg, scale, dataOffset, temp,
+ 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,
+ 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 = oatAllocTemp(cUnit);
+ regLen = AllocTemp(cUnit);
//NOTE: max live temps(4) here.
/* Get len */
- loadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
+ LoadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
}
/* regPtr -> array data */
- opRegImm(cUnit, kOpAdd, regPtr, dataOffset);
+ 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 = oatAllocTemp(cUnit);
- opRegRegImm(cUnit, kOpLsl, rNewIndex, rlIndex.lowReg, scale);
- opRegReg(cUnit, kOpAdd, regPtr, rNewIndex);
- oatFreeTemp(cUnit, rNewIndex);
+ 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);
+ OpRegReg(cUnit, kOpAdd, regPtr, rlIndex.lowReg);
}
- rlSrc = loadValueWide(cUnit, rlSrc, regClass);
+ rlSrc = LoadValueWide(cUnit, rlSrc, regClass);
if (needsRangeCheck) {
- genRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, kThrowArrayBounds);
- oatFreeTemp(cUnit, regLen);
+ GenRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, kThrowArrayBounds);
+ FreeTemp(cUnit, regLen);
}
- storeBaseDispWide(cUnit, regPtr, 0, rlSrc.lowReg, rlSrc.highReg);
+ StoreBaseDispWide(cUnit, regPtr, 0, rlSrc.lowReg, rlSrc.highReg);
- oatFreeTemp(cUnit, regPtr);
+ FreeTemp(cUnit, regPtr);
} else {
- rlSrc = loadValue(cUnit, rlSrc, regClass);
+ rlSrc = LoadValue(cUnit, rlSrc, regClass);
if (needsRangeCheck) {
- genRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, kThrowArrayBounds);
- oatFreeTemp(cUnit, regLen);
+ GenRegRegCheck(cUnit, kCondCs, rlIndex.lowReg, regLen, kThrowArrayBounds);
+ FreeTemp(cUnit, regLen);
}
- storeBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlSrc.lowReg,
+ StoreBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlSrc.lowReg,
scale, size);
}
}
}
-void genLong3Addr(CompilationUnit* cUnit, OpKind firstOp,
+void GenLong3Addr(CompilationUnit* cUnit, OpKind firstOp,
OpKind secondOp, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
@@ -1571,42 +1565,42 @@
* lr is used explicitly elsewhere in the code generator and cannot
* normally be used as a general temp register.
*/
- oatMarkTemp(cUnit, targetReg(kLr)); // Add lr to the temp pool
- oatFreeTemp(cUnit, targetReg(kLr)); // and make it available
+ 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 = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ 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 = oatAllocTemp(cUnit);
- opRegRegReg(cUnit, firstOp, tReg, rlSrc1.lowReg, rlSrc2.lowReg);
- opRegRegReg(cUnit, secondOp, rlResult.highReg, rlSrc1.highReg, rlSrc2.highReg);
- opRegCopy(cUnit, rlResult.lowReg, tReg);
- oatFreeTemp(cUnit, tReg);
+ 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,
+ 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.
+ * 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);
+ FreeRegLocTemps(cUnit, rlResult, rlSrc1);
+ FreeRegLocTemps(cUnit, rlResult, rlSrc2);
+ StoreValueWide(cUnit, rlDest, rlResult);
if (cUnit->instructionSet == kThumb2) {
- oatClobber(cUnit, targetReg(kLr));
- oatUnmarkTemp(cUnit, targetReg(kLr)); // Remove lr from the temp pool
+ Clobber(cUnit, TargetReg(kLr));
+ UnmarkTemp(cUnit, TargetReg(kLr)); // Remove lr from the temp pool
}
}
-bool genShiftOpLong(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest,
+bool GenShiftOpLong(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlShift)
{
int funcOffset;
@@ -1628,15 +1622,15 @@
LOG(FATAL) << "Unexpected case";
return true;
}
- oatFlushAllRegs(cUnit); /* Send everything to home location */
- callRuntimeHelperRegLocationRegLocation(cUnit, funcOffset, rlSrc1, rlShift, false);
- RegLocation rlResult = oatGetReturnWide(cUnit, false);
- storeValueWide(cUnit, rlDest, rlResult);
+ 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,
+bool GenArithOpInt(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
OpKind op = kOpBkpt;
@@ -1711,58 +1705,58 @@
}
if (!isDivRem) {
if (unary) {
- rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- opRegReg(cUnit, op, rlResult.lowReg, rlSrc1.lowReg);
+ 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);
+ tReg = TargetReg(kCount); // rCX
+ LoadValueDirectFixed(cUnit, rlSrc2, tReg);
} else {
- rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
- tReg = oatAllocTemp(cUnit);
- opRegRegImm(cUnit, kOpAnd, tReg, rlSrc2.lowReg, 31);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kCoreReg);
+ tReg = AllocTemp(cUnit);
+ OpRegRegImm(cUnit, kOpAnd, tReg, rlSrc2.lowReg, 31);
}
- rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- opRegRegReg(cUnit, op, rlResult.lowReg, rlSrc1.lowReg, tReg);
- oatFreeTemp(cUnit, tReg);
+ 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 = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- opRegRegReg(cUnit, op, rlResult.lowReg, rlSrc1.lowReg, rlSrc2.lowReg);
+ 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);
+ StoreValue(cUnit, rlDest, rlResult);
} else {
if (cUnit->instructionSet == kMips) {
- rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
- rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
+ rlSrc1 = LoadValue(cUnit, rlSrc1, kCoreReg);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kCoreReg);
if (checkZero) {
- genImmedCheck(cUnit, kCondEq, rlSrc2.lowReg, 0, kThrowDivZero);
+ GenImmedCheck(cUnit, kCondEq, rlSrc2.lowReg, 0, kThrowDivZero);
}
- rlResult = genDivRem(cUnit, rlDest, rlSrc1.lowReg, rlSrc2.lowReg, op == kOpDiv);
+ rlResult = GenDivRem(cUnit, rlDest, rlSrc1.lowReg, rlSrc2.lowReg, op == kOpDiv);
} else {
int funcOffset = ENTRYPOINT_OFFSET(pIdivmod);
- oatFlushAllRegs(cUnit); /* Send everything to home location */
- loadValueDirectFixed(cUnit, rlSrc2, targetReg(kArg1));
- int rTgt = callHelperSetup(cUnit, funcOffset);
- loadValueDirectFixed(cUnit, rlSrc1, targetReg(kArg0));
+ 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);
+ GenImmedCheck(cUnit, kCondEq, TargetReg(kArg1), 0, kThrowDivZero);
}
// NOTE: callout here is not a safepoint
- callHelper(cUnit, rTgt, funcOffset, false /* not a safepoint */ );
+ CallHelper(cUnit, rTgt, funcOffset, false /* not a safepoint */ );
if (op == kOpDiv)
- rlResult = oatGetReturn(cUnit, false);
+ rlResult = GetReturn(cUnit, false);
else
- rlResult = oatGetReturnAlt(cUnit);
+ rlResult = GetReturnAlt(cUnit);
}
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
}
return false;
}
@@ -1773,20 +1767,20 @@
* or produce corresponding Thumb instructions directly.
*/
-bool isPowerOfTwo(int x)
+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)
+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 LowestSetBit(unsigned int x) {
int bit_posn = 0;
while ((x & 0xf) == 0) {
bit_posn += 4;
@@ -1801,61 +1795,61 @@
// 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,
+bool HandleEasyDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode,
RegLocation rlSrc, RegLocation rlDest, int lit)
{
- if ((lit < 2) || ((cUnit->instructionSet != kThumb2) && !isPowerOfTwo(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);
+ if ((cUnit->instructionSet == kThumb2) && !IsPowerOfTwo(lit)) {
+ return SmallLiteralDivide(cUnit, dalvikOpcode, rlSrc, rlDest, lit);
}
- int k = lowestSetBit(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 = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
if (div) {
- int tReg = oatAllocTemp(cUnit);
+ 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);
+ 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);
+ 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 = oatAllocTemp(cUnit);
- int tReg2 = oatAllocTemp(cUnit);
+ 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);
+ 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);
+ 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);
+ 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,
+bool HandleEasyMultiply(CompilationUnit* cUnit, RegLocation rlSrc,
RegLocation rlDest, int lit)
{
// Can we simplify this multiplication?
@@ -1865,40 +1859,40 @@
if (lit < 2) {
// Avoid special cases.
return false;
- } else if (isPowerOfTwo(lit)) {
+ } else if (IsPowerOfTwo(lit)) {
powerOfTwo = true;
- } else if (isPopCountLE2(lit)) {
+ } else if (IsPopCountLE2(lit)) {
popCountLE2 = true;
- } else if (isPowerOfTwo(lit + 1)) {
+ } else if (IsPowerOfTwo(lit + 1)) {
powerOfTwoMinusOne = true;
} else {
return false;
}
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
if (powerOfTwo) {
// Shift.
- opRegRegImm(cUnit, kOpLsl, rlResult.lowReg, rlSrc.lowReg,
- lowestSetBit(lit));
+ 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,
+ 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 = oatAllocTemp(cUnit);
- opRegRegImm(cUnit, kOpLsl, tReg, rlSrc.lowReg, lowestSetBit(lit + 1));
- opRegRegReg(cUnit, kOpSub, rlResult.lowReg, tReg, rlSrc.lowReg);
+ // 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);
+ StoreValue(cUnit, rlDest, rlResult);
return true;
}
-bool genArithOpIntLit(CompilationUnit* cUnit, Instruction::Code opcode,
+bool GenArithOpIntLit(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc, int lit)
{
RegLocation rlResult;
@@ -1911,12 +1905,12 @@
case Instruction::RSUB_INT: {
int tReg;
//TUNING: add support for use of Arm rsub op
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- tReg = oatAllocTemp(cUnit);
- loadConstant(cUnit, tReg, lit);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- opRegRegReg(cUnit, kOpSub, rlResult.lowReg, tReg, rlSrc.lowReg);
- storeValue(cUnit, rlDest, rlResult);
+ 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;
}
@@ -1927,7 +1921,7 @@
break;
case Instruction::MUL_INT_LIT8:
case Instruction::MUL_INT_LIT16: {
- if (handleEasyMultiply(cUnit, rlSrc, rlDest, lit)) {
+ if (HandleEasyMultiply(cUnit, rlSrc, rlDest, lit)) {
return false;
}
op = kOpMul;
@@ -1969,10 +1963,10 @@
case Instruction::REM_INT_LIT8:
case Instruction::REM_INT_LIT16: {
if (lit == 0) {
- genImmedCheck(cUnit, kCondAl, 0, 0, kThrowDivZero);
+ GenImmedCheck(cUnit, kCondAl, 0, 0, kThrowDivZero);
return false;
}
- if (handleEasyDivide(cUnit, opcode, rlSrc, rlDest, lit)) {
+ if (HandleEasyDivide(cUnit, opcode, rlSrc, rlDest, lit)) {
return false;
}
if ((opcode == Instruction::DIV_INT_LIT8) ||
@@ -1982,39 +1976,39 @@
isDiv = false;
}
if (cUnit->instructionSet == kMips) {
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- rlResult = genDivRemLit(cUnit, rlDest, rlSrc.lowReg, lit, isDiv);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
+ rlResult = GenDivRemLit(cUnit, rlDest, rlSrc.lowReg, lit, isDiv);
} else {
- oatFlushAllRegs(cUnit); /* Everything to home location */
- loadValueDirectFixed(cUnit, rlSrc, targetReg(kArg0));
- oatClobber(cUnit, targetReg(kArg0));
+ 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);
+ CallRuntimeHelperRegImm(cUnit, funcOffset, TargetReg(kArg0), lit, false);
if (isDiv)
- rlResult = oatGetReturn(cUnit, false);
+ rlResult = GetReturn(cUnit, false);
else
- rlResult = oatGetReturnAlt(cUnit);
+ rlResult = GetReturnAlt(cUnit);
}
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
return false;
break;
}
default:
return true;
}
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, 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);
+ OpRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
} else {
- opRegRegImm(cUnit, op, rlResult.lowReg, rlSrc.lowReg, lit);
+ OpRegRegImm(cUnit, op, rlResult.lowReg, rlSrc.lowReg, lit);
}
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
return false;
}
-bool genArithOpLong(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest,
+bool GenArithOpLong(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
RegLocation rlResult;
@@ -2023,30 +2017,30 @@
bool callOut = false;
bool checkZero = false;
int funcOffset;
- int retReg = targetReg(kRet0);
+ int retReg = TargetReg(kRet0);
switch (opcode) {
case Instruction::NOT_LONG:
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kCoreReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kCoreReg);
+ rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
// Check for destructive overlap
if (rlResult.lowReg == rlSrc2.highReg) {
- int tReg = oatAllocTemp(cUnit);
- opRegCopy(cUnit, tReg, rlSrc2.highReg);
- opRegReg(cUnit, kOpMvn, rlResult.lowReg, rlSrc2.lowReg);
- opRegReg(cUnit, kOpMvn, rlResult.highReg, tReg);
- oatFreeTemp(cUnit, tReg);
+ 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);
+ OpRegReg(cUnit, kOpMvn, rlResult.lowReg, rlSrc2.lowReg);
+ OpRegReg(cUnit, kOpMvn, rlResult.highReg, rlSrc2.highReg);
}
- storeValueWide(cUnit, rlDest, rlResult);
+ 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);
+ return GenAddLong(cUnit, rlDest, rlSrc1, rlSrc2);
}
firstOp = kOpAdd;
secondOp = kOpAdc;
@@ -2054,7 +2048,7 @@
case Instruction::SUB_LONG:
case Instruction::SUB_LONG_2ADDR:
if (cUnit->instructionSet != kThumb2) {
- return genSubLong(cUnit, rlDest, rlSrc1, rlSrc2);
+ return GenSubLong(cUnit, rlDest, rlSrc1, rlSrc2);
}
firstOp = kOpSub;
secondOp = kOpSbc;
@@ -2062,14 +2056,14 @@
case Instruction::MUL_LONG:
case Instruction::MUL_LONG_2ADDR:
callOut = true;
- retReg = targetReg(kRet0);
+ retReg = TargetReg(kRet0);
funcOffset = ENTRYPOINT_OFFSET(pLmul);
break;
case Instruction::DIV_LONG:
case Instruction::DIV_LONG_2ADDR:
callOut = true;
checkZero = true;
- retReg = targetReg(kRet0);
+ retReg = TargetReg(kRet0);
funcOffset = ENTRYPOINT_OFFSET(pLdiv);
break;
case Instruction::REM_LONG:
@@ -2078,12 +2072,12 @@
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);
+ 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);
+ return GenAndLong(cUnit, rlDest, rlSrc1, rlSrc2);
}
firstOp = kOpAnd;
secondOp = kOpAnd;
@@ -2091,7 +2085,7 @@
case Instruction::OR_LONG:
case Instruction::OR_LONG_2ADDR:
if (cUnit->instructionSet == kX86) {
- return genOrLong(cUnit, rlDest, rlSrc1, rlSrc2);
+ return GenOrLong(cUnit, rlDest, rlSrc1, rlSrc2);
}
firstOp = kOpOr;
secondOp = kOpOr;
@@ -2099,70 +2093,70 @@
case Instruction::XOR_LONG:
case Instruction::XOR_LONG_2ADDR:
if (cUnit->instructionSet == kX86) {
- return genXorLong(cUnit, rlDest, rlSrc1, rlSrc2);
+ return GenXorLong(cUnit, rlDest, rlSrc1, rlSrc2);
}
firstOp = kOpXor;
secondOp = kOpXor;
break;
case Instruction::NEG_LONG: {
- return genNegLong(cUnit, rlDest, rlSrc2);
+ return GenNegLong(cUnit, rlDest, rlSrc2);
}
default:
LOG(FATAL) << "Invalid long arith op";
}
if (!callOut) {
- genLong3Addr(cUnit, firstOp, secondOp, rlDest, rlSrc1, rlSrc2);
+ GenLong3Addr(cUnit, firstOp, secondOp, rlDest, rlSrc1, rlSrc2);
} else {
- oatFlushAllRegs(cUnit); /* Send everything to home location */
+ 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));
+ 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 */);
+ CallHelper(cUnit, rTgt, funcOffset, false /* not safepoint */);
} else {
- callRuntimeHelperRegLocationRegLocation(cUnit, funcOffset,
+ CallRuntimeHelperRegLocationRegLocation(cUnit, funcOffset,
rlSrc1, rlSrc2, false);
}
// Adjust return regs in to handle case of rem returning kArg2/kArg3
- if (retReg == targetReg(kRet0))
- rlResult = oatGetReturnWide(cUnit, false);
+ if (retReg == TargetReg(kRet0))
+ rlResult = GetReturnWide(cUnit, false);
else
- rlResult = oatGetReturnWideAlt(cUnit);
- storeValueWide(cUnit, rlDest, rlResult);
+ rlResult = GetReturnWideAlt(cUnit);
+ StoreValueWide(cUnit, rlDest, rlResult);
}
return false;
}
-bool genConversionCall(CompilationUnit* cUnit, int funcOffset,
+bool GenConversionCall(CompilationUnit* cUnit, int funcOffset,
RegLocation rlDest, RegLocation rlSrc)
{
/*
* Don't optimize the register usage since it calls out to support
* functions
*/
- oatFlushAllRegs(cUnit); /* Send everything to home location */
+ 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));
+ 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));
+ LoadValueDirectFixed(cUnit, rlSrc, rlSrc.fp ? TargetReg(kFArg0) : TargetReg(kArg0));
}
- callRuntimeHelperRegLocation(cUnit, funcOffset, rlSrc, false);
+ CallRuntimeHelperRegLocation(cUnit, funcOffset, rlSrc, false);
if (rlDest.wide) {
RegLocation rlResult;
- rlResult = oatGetReturnWide(cUnit, rlDest.fp);
- storeValueWide(cUnit, rlDest, rlResult);
+ rlResult = GetReturnWide(cUnit, rlDest.fp);
+ StoreValueWide(cUnit, rlDest, rlResult);
} else {
RegLocation rlResult;
- rlResult = oatGetReturn(cUnit, rlDest.fp);
- storeValue(cUnit, rlDest, rlResult);
+ rlResult = GetReturn(cUnit, rlDest.fp);
+ StoreValue(cUnit, rlDest, rlResult);
}
return false;
}
-bool genArithOpFloatPortable(CompilationUnit* cUnit, Instruction::Code opcode,
+bool GenArithOpFloatPortable(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc1,
RegLocation rlSrc2)
{
@@ -2191,20 +2185,20 @@
funcOffset = ENTRYPOINT_OFFSET(pFmodf);
break;
case Instruction::NEG_FLOAT: {
- genNegFloat(cUnit, rlDest, rlSrc1);
+ GenNegFloat(cUnit, rlDest, rlSrc1);
return false;
}
default:
return true;
}
- oatFlushAllRegs(cUnit); /* Send everything to home location */
- callRuntimeHelperRegLocationRegLocation(cUnit, funcOffset, rlSrc1, rlSrc2, false);
- rlResult = oatGetReturn(cUnit, true);
- storeValue(cUnit, rlDest, rlResult);
+ 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,
+bool GenArithOpDoublePortable(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc1,
RegLocation rlSrc2)
{
@@ -2233,53 +2227,53 @@
funcOffset = ENTRYPOINT_OFFSET(pFmod);
break;
case Instruction::NEG_DOUBLE: {
- genNegDouble(cUnit, rlDest, rlSrc1);
+ GenNegDouble(cUnit, rlDest, rlSrc1);
return false;
}
default:
return true;
}
- oatFlushAllRegs(cUnit); /* Send everything to home location */
- callRuntimeHelperRegLocationRegLocation(cUnit, funcOffset, rlSrc1, rlSrc2, false);
- rlResult = oatGetReturnWide(cUnit, true);
- storeValueWide(cUnit, rlDest, rlResult);
+ 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,
+bool GenConversionPortable(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc)
{
switch (opcode) {
case Instruction::INT_TO_FLOAT:
- return genConversionCall(cUnit, ENTRYPOINT_OFFSET(pI2f),
+ return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pI2f),
rlDest, rlSrc);
case Instruction::FLOAT_TO_INT:
- return genConversionCall(cUnit, ENTRYPOINT_OFFSET(pF2iz),
+ return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pF2iz),
rlDest, rlSrc);
case Instruction::DOUBLE_TO_FLOAT:
- return genConversionCall(cUnit, ENTRYPOINT_OFFSET(pD2f),
+ return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pD2f),
rlDest, rlSrc);
case Instruction::FLOAT_TO_DOUBLE:
- return genConversionCall(cUnit, ENTRYPOINT_OFFSET(pF2d),
+ return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pF2d),
rlDest, rlSrc);
case Instruction::INT_TO_DOUBLE:
- return genConversionCall(cUnit, ENTRYPOINT_OFFSET(pI2d),
+ return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pI2d),
rlDest, rlSrc);
case Instruction::DOUBLE_TO_INT:
- return genConversionCall(cUnit, ENTRYPOINT_OFFSET(pD2iz),
+ return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pD2iz),
rlDest, rlSrc);
case Instruction::FLOAT_TO_LONG:
- return genConversionCall(cUnit, ENTRYPOINT_OFFSET(pF2l),
+ return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pF2l),
rlDest, rlSrc);
case Instruction::LONG_TO_FLOAT:
- return genConversionCall(cUnit, ENTRYPOINT_OFFSET(pL2f),
+ return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pL2f),
rlDest, rlSrc);
case Instruction::DOUBLE_TO_LONG:
- return genConversionCall(cUnit, ENTRYPOINT_OFFSET(pD2l),
+ return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pD2l),
rlDest, rlSrc);
case Instruction::LONG_TO_DOUBLE:
- return genConversionCall(cUnit, ENTRYPOINT_OFFSET(pL2d),
+ return GenConversionCall(cUnit, ENTRYPOINT_OFFSET(pL2d),
rlDest, rlSrc);
default:
return true;
@@ -2288,34 +2282,34 @@
}
/* Check if we need to check for pending suspend request */
-void genSuspendTest(CompilationUnit* cUnit, int optFlags)
+void GenSuspendTest(CompilationUnit* cUnit, int optFlags)
{
if (NO_SUSPEND || (optFlags & MIR_IGNORE_SUSPEND_CHECK)) {
return;
}
- oatFlushAllRegs(cUnit);
- LIR* branch = opTestSuspend(cUnit, NULL);
- LIR* retLab = newLIR0(cUnit, kPseudoTargetLabel);
- LIR* target = rawLIR(cUnit, cUnit->currentDalvikOffset, kPseudoSuspendTarget,
+ 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;
- oatInsertGrowableList(cUnit, &cUnit->suspendLaunchpads, reinterpret_cast<uintptr_t>(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)
+void GenSuspendTestAndBranch(CompilationUnit* cUnit, int optFlags, LIR* target)
{
if (NO_SUSPEND || (optFlags & MIR_IGNORE_SUSPEND_CHECK)) {
- opUnconditionalBranch(cUnit, target);
+ OpUnconditionalBranch(cUnit, target);
return;
}
- opTestSuspend(cUnit, target);
+ OpTestSuspend(cUnit, target);
LIR* launchPad =
- rawLIR(cUnit, cUnit->currentDalvikOffset, kPseudoSuspendTarget,
+ RawLIR(cUnit, cUnit->currentDalvikOffset, kPseudoSuspendTarget,
reinterpret_cast<uintptr_t>(target), cUnit->currentDalvikOffset);
- oatFlushAllRegs(cUnit);
- opUnconditionalBranch(cUnit, launchPad);
- oatInsertGrowableList(cUnit, &cUnit->suspendLaunchpads, reinterpret_cast<uintptr_t>(launchPad));
+ FlushAllRegs(cUnit);
+ OpUnconditionalBranch(cUnit, launchPad);
+ InsertGrowableList(cUnit, &cUnit->suspendLaunchpads, reinterpret_cast<uintptr_t>(launchPad));
}
} // namespace art