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/arm/assemble_arm.cc b/src/compiler/codegen/arm/assemble_arm.cc
index d7fa05d..8e7a07b 100644
--- a/src/compiler/codegen/arm/assemble_arm.cc
+++ b/src/compiler/codegen/arm/assemble_arm.cc
@@ -987,7 +987,7 @@
* discover that pc-relative displacements may not fit the selected
* instruction.
*/
-AssemblerStatus oatAssembleInstructions(CompilationUnit* cUnit,
+AssemblerStatus AssembleInstructions(CompilationUnit* cUnit,
uintptr_t startAddr)
{
LIR* lir;
@@ -1057,9 +1057,9 @@
lir->operands[0] : rARM_LR;
// Add new Adr to generate the address
- LIR* newAdr = rawLIR(cUnit, lir->dalvikOffset, kThumb2Adr,
+ LIR* newAdr = RawLIR(cUnit, lir->dalvikOffset, kThumb2Adr,
baseReg, 0, 0, 0, 0, lir->target);
- oatInsertLIRBefore(lir, newAdr);
+ InsertLIRBefore(lir, newAdr);
// Convert to normal load
if (lir->opcode == kThumb2LdrPcRel12) {
@@ -1068,7 +1068,7 @@
// Change the load to be relative to the new Adr base
lir->operands[1] = baseReg;
lir->operands[2] = 0;
- oatSetupResourceMasks(cUnit, lir);
+ SetupResourceMasks(cUnit, lir);
res = kRetryAll;
} else {
if ((lir->opcode == kThumb2Vldrs) ||
@@ -1090,16 +1090,16 @@
* Make new branch instruction and insert after
*/
LIR* newInst =
- rawLIR(cUnit, lir->dalvikOffset, kThumbBCond, 0,
+ RawLIR(cUnit, lir->dalvikOffset, kThumbBCond, 0,
(lir->opcode == kThumb2Cbz) ? kArmCondEq : kArmCondNe,
0, 0, 0, lir->target);
- oatInsertLIRAfter(lir, newInst);
+ InsertLIRAfter(lir, newInst);
/* Convert the cb[n]z to a cmp rx, #0 ] */
lir->opcode = kThumbCmpRI8;
/* operand[0] is src1 in both cb[n]z & CmpRI8 */
lir->operands[1] = 0;
lir->target = 0;
- oatSetupResourceMasks(cUnit, lir);
+ SetupResourceMasks(cUnit, lir);
res = kRetryAll;
} else {
lir->operands[1] = delta >> 1;
@@ -1124,7 +1124,7 @@
}
}
lir->operands[0] = reg;
- oatSetupResourceMasks(cUnit, lir);
+ SetupResourceMasks(cUnit, lir);
res = kRetryAll;
}
} else if (lir->opcode == kThumbBCond || lir->opcode == kThumb2BCond) {
@@ -1136,7 +1136,7 @@
delta = target - pc;
if ((lir->opcode == kThumbBCond) && (delta > 254 || delta < -256)) {
lir->opcode = kThumb2BCond;
- oatSetupResourceMasks(cUnit, lir);
+ SetupResourceMasks(cUnit, lir);
res = kRetryAll;
}
lir->operands[0] = delta >> 1;
@@ -1160,7 +1160,7 @@
// Convert to Thumb2BCond w/ kArmCondAl
lir->opcode = kThumb2BUncond;
lir->operands[0] = 0;
- oatSetupResourceMasks(cUnit, lir);
+ SetupResourceMasks(cUnit, lir);
res = kRetryAll;
} else {
lir->operands[0] = delta >> 1;
@@ -1207,19 +1207,19 @@
} else {
// convert to ldimm16l, ldimm16h, add tgt, pc, operands[0]
LIR *newMov16L =
- rawLIR(cUnit, lir->dalvikOffset, kThumb2MovImm16LST,
+ RawLIR(cUnit, lir->dalvikOffset, kThumb2MovImm16LST,
lir->operands[0], 0, reinterpret_cast<uintptr_t>(lir),
reinterpret_cast<uintptr_t>(tabRec), 0, lir->target);
- oatInsertLIRBefore(lir, newMov16L);
+ InsertLIRBefore(lir, newMov16L);
LIR *newMov16H =
- rawLIR(cUnit, lir->dalvikOffset, kThumb2MovImm16HST,
+ RawLIR(cUnit, lir->dalvikOffset, kThumb2MovImm16HST,
lir->operands[0], 0, reinterpret_cast<uintptr_t>(lir),
reinterpret_cast<uintptr_t>(tabRec), 0, lir->target);
- oatInsertLIRBefore(lir, newMov16H);
+ InsertLIRBefore(lir, newMov16H);
lir->opcode = kThumb2AddRRR;
lir->operands[1] = rARM_PC;
lir->operands[2] = lir->operands[0];
- oatSetupResourceMasks(cUnit, lir);
+ SetupResourceMasks(cUnit, lir);
res = kRetryAll;
}
} else if (lir->opcode == kThumb2MovImm16LST) {
@@ -1361,7 +1361,7 @@
return res;
}
-int oatGetInsnSize(LIR* lir)
+int GetInsnSize(LIR* lir)
{
return EncodingMap[lir->opcode].size;
}
@@ -1369,7 +1369,7 @@
/*
* Target-dependent offset assignment.
*/
-int oatAssignInsnOffsets(CompilationUnit* cUnit)
+int AssignInsnOffsets(CompilationUnit* cUnit)
{
LIR* armLIR;
int offset = 0;
diff --git a/src/compiler/codegen/arm/call_arm.cc b/src/compiler/codegen/arm/call_arm.cc
index 0964226..3250448 100644
--- a/src/compiler/codegen/arm/call_arm.cc
+++ b/src/compiler/codegen/arm/call_arm.cc
@@ -26,7 +26,7 @@
/* Return the position of an ssa name within the argument list */
-int inPosition(CompilationUnit* cUnit, int sReg)
+int InPosition(CompilationUnit* cUnit, int sReg)
{
int vReg = SRegToVReg(cUnit, sReg);
return vReg - cUnit->numRegs;
@@ -37,9 +37,9 @@
* there. NOTE: all live arg registers must be locked prior to this call
* to avoid having them allocated as a temp by downstream utilities.
*/
-RegLocation argLoc(CompilationUnit* cUnit, RegLocation loc)
+RegLocation ArgLoc(CompilationUnit* cUnit, RegLocation loc)
{
- int argNum = inPosition(cUnit, loc.sRegLow);
+ int argNum = InPosition(cUnit, loc.sRegLow);
if (loc.wide) {
if (argNum == 2) {
// Bad case - half in register, half in frame. Just punt
@@ -64,18 +64,18 @@
/*
* Load an argument. If already in a register, just return. If in
- * the frame, we can't use the normal loadValue() because it assumed
+ * the frame, we can't use the normal LoadValue() because it assumed
* a proper frame - and we're frameless.
*/
-RegLocation loadArg(CompilationUnit* cUnit, RegLocation loc)
+RegLocation LoadArg(CompilationUnit* cUnit, RegLocation loc)
{
if (loc.location == kLocDalvikFrame) {
- int start = (inPosition(cUnit, loc.sRegLow) + 1) * sizeof(uint32_t);
- loc.lowReg = oatAllocTemp(cUnit);
- loadWordDisp(cUnit, rARM_SP, start, loc.lowReg);
+ int start = (InPosition(cUnit, loc.sRegLow) + 1) * sizeof(uint32_t);
+ loc.lowReg = AllocTemp(cUnit);
+ LoadWordDisp(cUnit, rARM_SP, start, loc.lowReg);
if (loc.wide) {
- loc.highReg = oatAllocTemp(cUnit);
- loadWordDisp(cUnit, rARM_SP, start + sizeof(uint32_t), loc.highReg);
+ loc.highReg = AllocTemp(cUnit);
+ LoadWordDisp(cUnit, rARM_SP, start + sizeof(uint32_t), loc.highReg);
}
loc.location = kLocPhysReg;
}
@@ -83,21 +83,21 @@
}
/* Lock any referenced arguments that arrive in registers */
-void lockLiveArgs(CompilationUnit* cUnit, MIR* mir)
+void LockLiveArgs(CompilationUnit* cUnit, MIR* mir)
{
int firstIn = cUnit->numRegs;
const int numArgRegs = 3; // TODO: generalize & move to RegUtil.cc
for (int i = 0; i < mir->ssaRep->numUses; i++) {
int vReg = SRegToVReg(cUnit, mir->ssaRep->uses[i]);
- int inPosition = vReg - firstIn;
- if (inPosition < numArgRegs) {
- oatLockTemp(cUnit, rARM_ARG1 + inPosition);
+ int InPosition = vReg - firstIn;
+ if (InPosition < numArgRegs) {
+ LockTemp(cUnit, rARM_ARG1 + InPosition);
}
}
}
/* Find the next MIR, which may be in a following basic block */
-MIR* getNextMir(CompilationUnit* cUnit, BasicBlock** pBb, MIR* mir)
+MIR* GetNextMir(CompilationUnit* cUnit, BasicBlock** pBb, MIR* mir)
{
BasicBlock* bb = *pBb;
MIR* origMir = mir;
@@ -122,107 +122,107 @@
}
/* Used for the "printMe" listing */
-void genPrintLabel(CompilationUnit *cUnit, MIR* mir)
+void GenPrintLabel(CompilationUnit *cUnit, MIR* mir)
{
/* Mark the beginning of a Dalvik instruction for line tracking */
char* instStr = cUnit->printMe ?
- oatGetDalvikDisassembly(cUnit, mir->dalvikInsn, "") : NULL;
- markBoundary(cUnit, mir->offset, instStr);
+ GetDalvikDisassembly(cUnit, mir->dalvikInsn, "") : NULL;
+ MarkBoundary(cUnit, mir->offset, instStr);
/* Don't generate the SSA annotation unless verbose mode is on */
if (cUnit->printMe && mir->ssaRep) {
- char* ssaString = oatGetSSAString(cUnit, mir->ssaRep);
- newLIR1(cUnit, kPseudoSSARep, reinterpret_cast<uintptr_t>(ssaString));
+ char* ssaString = GetSSAString(cUnit, mir->ssaRep);
+ NewLIR1(cUnit, kPseudoSSARep, reinterpret_cast<uintptr_t>(ssaString));
}
}
-MIR* specialIGet(CompilationUnit* cUnit, BasicBlock** bb, MIR* mir,
+MIR* SpecialIGet(CompilationUnit* cUnit, BasicBlock** bb, MIR* mir,
OpSize size, bool longOrDouble, bool isObject)
{
int fieldOffset;
bool isVolatile;
uint32_t fieldIdx = mir->dalvikInsn.vC;
- bool fastPath = fastInstance(cUnit, fieldIdx, fieldOffset, isVolatile, false);
+ bool fastPath = FastInstance(cUnit, fieldIdx, fieldOffset, isVolatile, false);
if (!fastPath || !(mir->optimizationFlags & MIR_IGNORE_NULL_CHECK)) {
return NULL;
}
- RegLocation rlObj = oatGetSrc(cUnit, mir, 0);
- lockLiveArgs(cUnit, mir);
- rlObj = argLoc(cUnit, rlObj);
+ RegLocation rlObj = GetSrc(cUnit, mir, 0);
+ LockLiveArgs(cUnit, mir);
+ rlObj = ArgLoc(cUnit, rlObj);
RegLocation rlDest;
if (longOrDouble) {
- rlDest = oatGetReturnWide(cUnit, false);
+ rlDest = GetReturnWide(cUnit, false);
} else {
- rlDest = oatGetReturn(cUnit, false);
+ rlDest = GetReturn(cUnit, false);
}
// Point of no return - no aborts after this
- genPrintLabel(cUnit, mir);
- rlObj = loadArg(cUnit, rlObj);
- genIGet(cUnit, fieldIdx, mir->optimizationFlags, size, rlDest, rlObj,
+ GenPrintLabel(cUnit, mir);
+ rlObj = LoadArg(cUnit, rlObj);
+ GenIGet(cUnit, fieldIdx, mir->optimizationFlags, size, rlDest, rlObj,
longOrDouble, isObject);
- return getNextMir(cUnit, bb, mir);
+ return GetNextMir(cUnit, bb, mir);
}
-MIR* specialIPut(CompilationUnit* cUnit, BasicBlock** bb, MIR* mir,
+MIR* SpecialIPut(CompilationUnit* cUnit, BasicBlock** bb, MIR* mir,
OpSize size, bool longOrDouble, bool isObject)
{
int fieldOffset;
bool isVolatile;
uint32_t fieldIdx = mir->dalvikInsn.vC;
- bool fastPath = fastInstance(cUnit, fieldIdx, fieldOffset, isVolatile, false);
+ bool fastPath = FastInstance(cUnit, fieldIdx, fieldOffset, isVolatile, false);
if (!fastPath || !(mir->optimizationFlags & MIR_IGNORE_NULL_CHECK)) {
return NULL;
}
RegLocation rlSrc;
RegLocation rlObj;
- lockLiveArgs(cUnit, mir);
+ LockLiveArgs(cUnit, mir);
if (longOrDouble) {
- rlSrc = oatGetSrcWide(cUnit, mir, 0);
- rlObj = oatGetSrc(cUnit, mir, 2);
+ rlSrc = GetSrcWide(cUnit, mir, 0);
+ rlObj = GetSrc(cUnit, mir, 2);
} else {
- rlSrc = oatGetSrc(cUnit, mir, 0);
- rlObj = oatGetSrc(cUnit, mir, 1);
+ rlSrc = GetSrc(cUnit, mir, 0);
+ rlObj = GetSrc(cUnit, mir, 1);
}
- rlSrc = argLoc(cUnit, rlSrc);
- rlObj = argLoc(cUnit, rlObj);
+ rlSrc = ArgLoc(cUnit, rlSrc);
+ rlObj = ArgLoc(cUnit, rlObj);
// Reject if source is split across registers & frame
if (rlObj.location == kLocInvalid) {
- oatResetRegPool(cUnit);
+ ResetRegPool(cUnit);
return NULL;
}
// Point of no return - no aborts after this
- genPrintLabel(cUnit, mir);
- rlObj = loadArg(cUnit, rlObj);
- rlSrc = loadArg(cUnit, rlSrc);
- genIPut(cUnit, fieldIdx, mir->optimizationFlags, size, rlSrc, rlObj,
+ GenPrintLabel(cUnit, mir);
+ rlObj = LoadArg(cUnit, rlObj);
+ rlSrc = LoadArg(cUnit, rlSrc);
+ GenIPut(cUnit, fieldIdx, mir->optimizationFlags, size, rlSrc, rlObj,
longOrDouble, isObject);
- return getNextMir(cUnit, bb, mir);
+ return GetNextMir(cUnit, bb, mir);
}
-MIR* specialIdentity(CompilationUnit* cUnit, MIR* mir)
+MIR* SpecialIdentity(CompilationUnit* cUnit, MIR* mir)
{
RegLocation rlSrc;
RegLocation rlDest;
bool wide = (mir->ssaRep->numUses == 2);
if (wide) {
- rlSrc = oatGetSrcWide(cUnit, mir, 0);
- rlDest = oatGetReturnWide(cUnit, false);
+ rlSrc = GetSrcWide(cUnit, mir, 0);
+ rlDest = GetReturnWide(cUnit, false);
} else {
- rlSrc = oatGetSrc(cUnit, mir, 0);
- rlDest = oatGetReturn(cUnit, false);
+ rlSrc = GetSrc(cUnit, mir, 0);
+ rlDest = GetReturn(cUnit, false);
}
- lockLiveArgs(cUnit, mir);
- rlSrc = argLoc(cUnit, rlSrc);
+ LockLiveArgs(cUnit, mir);
+ rlSrc = ArgLoc(cUnit, rlSrc);
if (rlSrc.location == kLocInvalid) {
- oatResetRegPool(cUnit);
+ ResetRegPool(cUnit);
return NULL;
}
// Point of no return - no aborts after this
- genPrintLabel(cUnit, mir);
- rlSrc = loadArg(cUnit, rlSrc);
+ GenPrintLabel(cUnit, mir);
+ rlSrc = LoadArg(cUnit, rlSrc);
if (wide) {
- storeValueWide(cUnit, rlDest, rlSrc);
+ StoreValueWide(cUnit, rlDest, rlSrc);
} else {
- storeValue(cUnit, rlDest, rlSrc);
+ StoreValue(cUnit, rlDest, rlSrc);
}
return mir;
}
@@ -230,7 +230,7 @@
/*
* Special-case code genration for simple non-throwing leaf methods.
*/
-void genSpecialCase(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+void GenSpecialCase(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
SpecialCaseHandler specialCase)
{
cUnit->currentDalvikOffset = mir->offset;
@@ -241,50 +241,50 @@
nextMir = mir;
break;
case kConstFunction:
- genPrintLabel(cUnit, mir);
- loadConstant(cUnit, rARM_RET0, mir->dalvikInsn.vB);
- nextMir = getNextMir(cUnit, &bb, mir);
+ GenPrintLabel(cUnit, mir);
+ LoadConstant(cUnit, rARM_RET0, mir->dalvikInsn.vB);
+ nextMir = GetNextMir(cUnit, &bb, mir);
break;
case kIGet:
- nextMir = specialIGet(cUnit, &bb, mir, kWord, false, false);
+ nextMir = SpecialIGet(cUnit, &bb, mir, kWord, false, false);
break;
case kIGetBoolean:
case kIGetByte:
- nextMir = specialIGet(cUnit, &bb, mir, kUnsignedByte, false, false);
+ nextMir = SpecialIGet(cUnit, &bb, mir, kUnsignedByte, false, false);
break;
case kIGetObject:
- nextMir = specialIGet(cUnit, &bb, mir, kWord, false, true);
+ nextMir = SpecialIGet(cUnit, &bb, mir, kWord, false, true);
break;
case kIGetChar:
- nextMir = specialIGet(cUnit, &bb, mir, kUnsignedHalf, false, false);
+ nextMir = SpecialIGet(cUnit, &bb, mir, kUnsignedHalf, false, false);
break;
case kIGetShort:
- nextMir = specialIGet(cUnit, &bb, mir, kSignedHalf, false, false);
+ nextMir = SpecialIGet(cUnit, &bb, mir, kSignedHalf, false, false);
break;
case kIGetWide:
- nextMir = specialIGet(cUnit, &bb, mir, kLong, true, false);
+ nextMir = SpecialIGet(cUnit, &bb, mir, kLong, true, false);
break;
case kIPut:
- nextMir = specialIPut(cUnit, &bb, mir, kWord, false, false);
+ nextMir = SpecialIPut(cUnit, &bb, mir, kWord, false, false);
break;
case kIPutBoolean:
case kIPutByte:
- nextMir = specialIPut(cUnit, &bb, mir, kUnsignedByte, false, false);
+ nextMir = SpecialIPut(cUnit, &bb, mir, kUnsignedByte, false, false);
break;
case kIPutObject:
- nextMir = specialIPut(cUnit, &bb, mir, kWord, false, true);
+ nextMir = SpecialIPut(cUnit, &bb, mir, kWord, false, true);
break;
case kIPutChar:
- nextMir = specialIPut(cUnit, &bb, mir, kUnsignedHalf, false, false);
+ nextMir = SpecialIPut(cUnit, &bb, mir, kUnsignedHalf, false, false);
break;
case kIPutShort:
- nextMir = specialIPut(cUnit, &bb, mir, kSignedHalf, false, false);
+ nextMir = SpecialIPut(cUnit, &bb, mir, kSignedHalf, false, false);
break;
case kIPutWide:
- nextMir = specialIPut(cUnit, &bb, mir, kLong, true, false);
+ nextMir = SpecialIPut(cUnit, &bb, mir, kLong, true, false);
break;
case kIdentity:
- nextMir = specialIdentity(cUnit, mir);
+ nextMir = SpecialIdentity(cUnit, mir);
break;
default:
return;
@@ -292,9 +292,9 @@
if (nextMir != NULL) {
cUnit->currentDalvikOffset = nextMir->offset;
if (specialCase != kIdentity) {
- genPrintLabel(cUnit, nextMir);
+ GenPrintLabel(cUnit, nextMir);
}
- newLIR1(cUnit, kThumbBx, rARM_LR);
+ NewLIR1(cUnit, kThumbBx, rARM_LR);
cUnit->coreSpillMask = 0;
cUnit->numCoreSpills = 0;
cUnit->fpSpillMask = 0;
@@ -324,28 +324,28 @@
* add rARM_PC, rDisp ; This is the branch from which we compute displacement
* cbnz rIdx, lp
*/
-void genSparseSwitch(CompilationUnit* cUnit, uint32_t tableOffset,
+void GenSparseSwitch(CompilationUnit* cUnit, uint32_t tableOffset,
RegLocation rlSrc)
{
const uint16_t* table = cUnit->insns + cUnit->currentDalvikOffset + tableOffset;
if (cUnit->printMe) {
- dumpSparseSwitchTable(table);
+ DumpSparseSwitchTable(table);
}
// Add the table to the list - we'll process it later
SwitchTable *tabRec =
- static_cast<SwitchTable*>(oatNew(cUnit, sizeof(SwitchTable), true, kAllocData));
+ static_cast<SwitchTable*>(NewMem(cUnit, sizeof(SwitchTable), true, kAllocData));
tabRec->table = table;
tabRec->vaddr = cUnit->currentDalvikOffset;
int size = table[1];
- tabRec->targets = static_cast<LIR**>(oatNew(cUnit, size * sizeof(LIR*), true, kAllocLIR));
- oatInsertGrowableList(cUnit, &cUnit->switchTables, reinterpret_cast<uintptr_t>(tabRec));
+ tabRec->targets = static_cast<LIR**>(NewMem(cUnit, size * sizeof(LIR*), true, kAllocLIR));
+ InsertGrowableList(cUnit, &cUnit->switchTables, reinterpret_cast<uintptr_t>(tabRec));
// Get the switch value
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- int rBase = oatAllocTemp(cUnit);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
+ int rBase = AllocTemp(cUnit);
/* Allocate key and disp temps */
- int rKey = oatAllocTemp(cUnit);
- int rDisp = oatAllocTemp(cUnit);
+ int rKey = AllocTemp(cUnit);
+ int rDisp = AllocTemp(cUnit);
// Make sure rKey's register number is less than rDisp's number for ldmia
if (rKey > rDisp) {
int tmp = rDisp;
@@ -353,69 +353,69 @@
rKey = tmp;
}
// Materialize a pointer to the switch table
- newLIR3(cUnit, kThumb2Adr, rBase, 0, reinterpret_cast<uintptr_t>(tabRec));
+ NewLIR3(cUnit, kThumb2Adr, rBase, 0, reinterpret_cast<uintptr_t>(tabRec));
// Set up rIdx
- int rIdx = oatAllocTemp(cUnit);
- loadConstant(cUnit, rIdx, size);
+ int rIdx = AllocTemp(cUnit);
+ LoadConstant(cUnit, rIdx, size);
// Establish loop branch target
- LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
// Load next key/disp
- newLIR2(cUnit, kThumb2LdmiaWB, rBase, (1 << rKey) | (1 << rDisp));
- opRegReg(cUnit, kOpCmp, rKey, rlSrc.lowReg);
+ NewLIR2(cUnit, kThumb2LdmiaWB, rBase, (1 << rKey) | (1 << rDisp));
+ OpRegReg(cUnit, kOpCmp, rKey, rlSrc.lowReg);
// Go if match. NOTE: No instruction set switch here - must stay Thumb2
- opIT(cUnit, kArmCondEq, "");
- LIR* switchBranch = newLIR1(cUnit, kThumb2AddPCR, rDisp);
+ OpIT(cUnit, kArmCondEq, "");
+ LIR* switchBranch = NewLIR1(cUnit, kThumb2AddPCR, rDisp);
tabRec->anchor = switchBranch;
// Needs to use setflags encoding here
- newLIR3(cUnit, kThumb2SubsRRI12, rIdx, rIdx, 1);
- opCondBranch(cUnit, kCondNe, target);
+ NewLIR3(cUnit, kThumb2SubsRRI12, rIdx, rIdx, 1);
+ OpCondBranch(cUnit, kCondNe, target);
}
-void genPackedSwitch(CompilationUnit* cUnit, uint32_t tableOffset,
+void GenPackedSwitch(CompilationUnit* cUnit, uint32_t tableOffset,
RegLocation rlSrc)
{
const uint16_t* table = cUnit->insns + cUnit->currentDalvikOffset + tableOffset;
if (cUnit->printMe) {
- dumpPackedSwitchTable(table);
+ DumpPackedSwitchTable(table);
}
// Add the table to the list - we'll process it later
SwitchTable *tabRec =
- static_cast<SwitchTable*>(oatNew(cUnit, sizeof(SwitchTable), true, kAllocData));
+ static_cast<SwitchTable*>(NewMem(cUnit, sizeof(SwitchTable), true, kAllocData));
tabRec->table = table;
tabRec->vaddr = cUnit->currentDalvikOffset;
int size = table[1];
- tabRec->targets = static_cast<LIR**>(oatNew(cUnit, size * sizeof(LIR*), true, kAllocLIR));
- oatInsertGrowableList(cUnit, &cUnit->switchTables, reinterpret_cast<uintptr_t>(tabRec));
+ tabRec->targets = static_cast<LIR**>(NewMem(cUnit, size * sizeof(LIR*), true, kAllocLIR));
+ InsertGrowableList(cUnit, &cUnit->switchTables, reinterpret_cast<uintptr_t>(tabRec));
// Get the switch value
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- int tableBase = oatAllocTemp(cUnit);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
+ int tableBase = AllocTemp(cUnit);
// Materialize a pointer to the switch table
- newLIR3(cUnit, kThumb2Adr, tableBase, 0, reinterpret_cast<uintptr_t>(tabRec));
+ NewLIR3(cUnit, kThumb2Adr, tableBase, 0, reinterpret_cast<uintptr_t>(tabRec));
int lowKey = s4FromSwitchData(&table[2]);
int keyReg;
// Remove the bias, if necessary
if (lowKey == 0) {
keyReg = rlSrc.lowReg;
} else {
- keyReg = oatAllocTemp(cUnit);
- opRegRegImm(cUnit, kOpSub, keyReg, rlSrc.lowReg, lowKey);
+ keyReg = AllocTemp(cUnit);
+ OpRegRegImm(cUnit, kOpSub, keyReg, rlSrc.lowReg, lowKey);
}
// Bounds check - if < 0 or >= size continue following switch
- opRegImm(cUnit, kOpCmp, keyReg, size-1);
- LIR* branchOver = opCondBranch(cUnit, kCondHi, NULL);
+ OpRegImm(cUnit, kOpCmp, keyReg, size-1);
+ LIR* branchOver = OpCondBranch(cUnit, kCondHi, NULL);
// Load the displacement from the switch table
- int dispReg = oatAllocTemp(cUnit);
- loadBaseIndexed(cUnit, tableBase, keyReg, dispReg, 2, kWord);
+ int dispReg = AllocTemp(cUnit);
+ LoadBaseIndexed(cUnit, tableBase, keyReg, dispReg, 2, kWord);
// ..and go! NOTE: No instruction set switch here - must stay Thumb2
- LIR* switchBranch = newLIR1(cUnit, kThumb2AddPCR, dispReg);
+ LIR* switchBranch = NewLIR1(cUnit, kThumb2AddPCR, dispReg);
tabRec->anchor = switchBranch;
/* branchOver target here */
- LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
branchOver->target = target;
}
@@ -429,30 +429,30 @@
*
* Total size is 4+(width * size + 1)/2 16-bit code units.
*/
-void genFillArrayData(CompilationUnit* cUnit, uint32_t tableOffset, RegLocation rlSrc)
+void GenFillArrayData(CompilationUnit* cUnit, uint32_t tableOffset, RegLocation rlSrc)
{
const uint16_t* table = cUnit->insns + cUnit->currentDalvikOffset + tableOffset;
// Add the table to the list - we'll process it later
FillArrayData *tabRec =
- static_cast<FillArrayData*>(oatNew(cUnit, sizeof(FillArrayData), true, kAllocData));
+ static_cast<FillArrayData*>(NewMem(cUnit, sizeof(FillArrayData), true, kAllocData));
tabRec->table = table;
tabRec->vaddr = cUnit->currentDalvikOffset;
uint16_t width = tabRec->table[1];
uint32_t size = tabRec->table[2] | ((static_cast<uint32_t>(tabRec->table[3])) << 16);
tabRec->size = (size * width) + 8;
- oatInsertGrowableList(cUnit, &cUnit->fillArrayData, reinterpret_cast<uintptr_t>(tabRec));
+ InsertGrowableList(cUnit, &cUnit->fillArrayData, reinterpret_cast<uintptr_t>(tabRec));
// Making a call - use explicit registers
- oatFlushAllRegs(cUnit); /* Everything to home location */
- loadValueDirectFixed(cUnit, rlSrc, r0);
- loadWordDisp(cUnit, rARM_SELF, ENTRYPOINT_OFFSET(pHandleFillArrayDataFromCode),
+ FlushAllRegs(cUnit); /* Everything to home location */
+ LoadValueDirectFixed(cUnit, rlSrc, r0);
+ LoadWordDisp(cUnit, rARM_SELF, ENTRYPOINT_OFFSET(pHandleFillArrayDataFromCode),
rARM_LR);
// Materialize a pointer to the fill data image
- newLIR3(cUnit, kThumb2Adr, r1, 0, reinterpret_cast<uintptr_t>(tabRec));
- oatClobberCalleeSave(cUnit);
- LIR* callInst = opReg(cUnit, kOpBlx, rARM_LR);
- markSafepointPC(cUnit, callInst);
+ NewLIR3(cUnit, kThumb2Adr, r1, 0, reinterpret_cast<uintptr_t>(tabRec));
+ ClobberCalleeSave(cUnit);
+ LIR* callInst = OpReg(cUnit, kOpBlx, rARM_LR);
+ MarkSafepointPC(cUnit, callInst);
}
/*
@@ -481,33 +481,33 @@
* preserved.
*
*/
-void genMonitorEnter(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc)
+void GenMonitorEnter(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc)
{
- oatFlushAllRegs(cUnit);
+ FlushAllRegs(cUnit);
DCHECK_EQ(LW_SHAPE_THIN, 0);
- loadValueDirectFixed(cUnit, rlSrc, r0); // Get obj
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- genNullCheck(cUnit, rlSrc.sRegLow, r0, optFlags);
- loadWordDisp(cUnit, rARM_SELF, Thread::ThinLockIdOffset().Int32Value(), r2);
- newLIR3(cUnit, kThumb2Ldrex, r1, r0,
+ LoadValueDirectFixed(cUnit, rlSrc, r0); // Get obj
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ GenNullCheck(cUnit, rlSrc.sRegLow, r0, optFlags);
+ LoadWordDisp(cUnit, rARM_SELF, Thread::ThinLockIdOffset().Int32Value(), r2);
+ NewLIR3(cUnit, kThumb2Ldrex, r1, r0,
Object::MonitorOffset().Int32Value() >> 2); // Get object->lock
// Align owner
- opRegImm(cUnit, kOpLsl, r2, LW_LOCK_OWNER_SHIFT);
+ OpRegImm(cUnit, kOpLsl, r2, LW_LOCK_OWNER_SHIFT);
// Is lock unheld on lock or held by us (==threadId) on unlock?
- newLIR4(cUnit, kThumb2Bfi, r2, r1, 0, LW_LOCK_OWNER_SHIFT - 1);
- newLIR3(cUnit, kThumb2Bfc, r1, LW_HASH_STATE_SHIFT, LW_LOCK_OWNER_SHIFT - 1);
- opRegImm(cUnit, kOpCmp, r1, 0);
- opIT(cUnit, kArmCondEq, "");
- newLIR4(cUnit, kThumb2Strex, r1, r2, r0,
+ NewLIR4(cUnit, kThumb2Bfi, r2, r1, 0, LW_LOCK_OWNER_SHIFT - 1);
+ NewLIR3(cUnit, kThumb2Bfc, r1, LW_HASH_STATE_SHIFT, LW_LOCK_OWNER_SHIFT - 1);
+ OpRegImm(cUnit, kOpCmp, r1, 0);
+ OpIT(cUnit, kArmCondEq, "");
+ NewLIR4(cUnit, kThumb2Strex, r1, r2, r0,
Object::MonitorOffset().Int32Value() >> 2);
- opRegImm(cUnit, kOpCmp, r1, 0);
- opIT(cUnit, kArmCondNe, "T");
+ OpRegImm(cUnit, kOpCmp, r1, 0);
+ OpIT(cUnit, kArmCondNe, "T");
// Go expensive route - artLockObjectFromCode(self, obj);
- loadWordDisp(cUnit, rARM_SELF, ENTRYPOINT_OFFSET(pLockObjectFromCode), rARM_LR);
- oatClobberCalleeSave(cUnit);
- LIR* callInst = opReg(cUnit, kOpBlx, rARM_LR);
- markSafepointPC(cUnit, callInst);
- oatGenMemBarrier(cUnit, kLoadLoad);
+ LoadWordDisp(cUnit, rARM_SELF, ENTRYPOINT_OFFSET(pLockObjectFromCode), rARM_LR);
+ ClobberCalleeSave(cUnit);
+ LIR* callInst = OpReg(cUnit, kOpBlx, rARM_LR);
+ MarkSafepointPC(cUnit, callInst);
+ GenMemBarrier(cUnit, kLoadLoad);
}
/*
@@ -516,51 +516,51 @@
* a zero recursion count, it's safe to punch it back to the
* initial, unlock thin state with a store word.
*/
-void genMonitorExit(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc)
+void GenMonitorExit(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc)
{
DCHECK_EQ(LW_SHAPE_THIN, 0);
- oatFlushAllRegs(cUnit);
- loadValueDirectFixed(cUnit, rlSrc, r0); // Get obj
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- genNullCheck(cUnit, rlSrc.sRegLow, r0, optFlags);
- loadWordDisp(cUnit, r0, Object::MonitorOffset().Int32Value(), r1); // Get lock
- loadWordDisp(cUnit, rARM_SELF, Thread::ThinLockIdOffset().Int32Value(), r2);
+ FlushAllRegs(cUnit);
+ LoadValueDirectFixed(cUnit, rlSrc, r0); // Get obj
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ GenNullCheck(cUnit, rlSrc.sRegLow, r0, optFlags);
+ LoadWordDisp(cUnit, r0, Object::MonitorOffset().Int32Value(), r1); // Get lock
+ LoadWordDisp(cUnit, rARM_SELF, Thread::ThinLockIdOffset().Int32Value(), r2);
// Is lock unheld on lock or held by us (==threadId) on unlock?
- opRegRegImm(cUnit, kOpAnd, r3, r1,
+ OpRegRegImm(cUnit, kOpAnd, r3, r1,
(LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT));
// Align owner
- opRegImm(cUnit, kOpLsl, r2, LW_LOCK_OWNER_SHIFT);
- newLIR3(cUnit, kThumb2Bfc, r1, LW_HASH_STATE_SHIFT, LW_LOCK_OWNER_SHIFT - 1);
- opRegReg(cUnit, kOpSub, r1, r2);
- opIT(cUnit, kArmCondEq, "EE");
- storeWordDisp(cUnit, r0, Object::MonitorOffset().Int32Value(), r3);
+ OpRegImm(cUnit, kOpLsl, r2, LW_LOCK_OWNER_SHIFT);
+ NewLIR3(cUnit, kThumb2Bfc, r1, LW_HASH_STATE_SHIFT, LW_LOCK_OWNER_SHIFT - 1);
+ OpRegReg(cUnit, kOpSub, r1, r2);
+ OpIT(cUnit, kArmCondEq, "EE");
+ StoreWordDisp(cUnit, r0, Object::MonitorOffset().Int32Value(), r3);
// Go expensive route - UnlockObjectFromCode(obj);
- loadWordDisp(cUnit, rARM_SELF, ENTRYPOINT_OFFSET(pUnlockObjectFromCode), rARM_LR);
- oatClobberCalleeSave(cUnit);
- LIR* callInst = opReg(cUnit, kOpBlx, rARM_LR);
- markSafepointPC(cUnit, callInst);
- oatGenMemBarrier(cUnit, kStoreLoad);
+ LoadWordDisp(cUnit, rARM_SELF, ENTRYPOINT_OFFSET(pUnlockObjectFromCode), rARM_LR);
+ ClobberCalleeSave(cUnit);
+ LIR* callInst = OpReg(cUnit, kOpBlx, rARM_LR);
+ MarkSafepointPC(cUnit, callInst);
+ GenMemBarrier(cUnit, kStoreLoad);
}
/*
* Mark garbage collection card. Skip if the value we're storing is null.
*/
-void markGCCard(CompilationUnit* cUnit, int valReg, int tgtAddrReg)
+void MarkGCCard(CompilationUnit* cUnit, int valReg, int tgtAddrReg)
{
- int regCardBase = oatAllocTemp(cUnit);
- int regCardNo = oatAllocTemp(cUnit);
- LIR* branchOver = opCmpImmBranch(cUnit, kCondEq, valReg, 0, NULL);
- loadWordDisp(cUnit, rARM_SELF, Thread::CardTableOffset().Int32Value(), regCardBase);
- opRegRegImm(cUnit, kOpLsr, regCardNo, tgtAddrReg, CardTable::kCardShift);
- storeBaseIndexed(cUnit, regCardBase, regCardNo, regCardBase, 0,
+ int regCardBase = AllocTemp(cUnit);
+ int regCardNo = AllocTemp(cUnit);
+ LIR* branchOver = OpCmpImmBranch(cUnit, kCondEq, valReg, 0, NULL);
+ LoadWordDisp(cUnit, rARM_SELF, Thread::CardTableOffset().Int32Value(), regCardBase);
+ OpRegRegImm(cUnit, kOpLsr, regCardNo, tgtAddrReg, CardTable::kCardShift);
+ StoreBaseIndexed(cUnit, regCardBase, regCardNo, regCardBase, 0,
kUnsignedByte);
- LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
branchOver->target = target;
- oatFreeTemp(cUnit, regCardBase);
- oatFreeTemp(cUnit, regCardNo);
+ FreeTemp(cUnit, regCardBase);
+ FreeTemp(cUnit, regCardNo);
}
-void genEntrySequence(CompilationUnit* cUnit, RegLocation* argLocs,
+void GenEntrySequence(CompilationUnit* cUnit, RegLocation* ArgLocs,
RegLocation rlMethod)
{
int spillCount = cUnit->numCoreSpills + cUnit->numFPSpills;
@@ -570,10 +570,10 @@
* expanding the frame or flushing. This leaves the utility
* code with a single temp: r12. This should be enough.
*/
- oatLockTemp(cUnit, r0);
- oatLockTemp(cUnit, r1);
- oatLockTemp(cUnit, r2);
- oatLockTemp(cUnit, r3);
+ LockTemp(cUnit, r0);
+ LockTemp(cUnit, r1);
+ LockTemp(cUnit, r2);
+ LockTemp(cUnit, r3);
/*
* We can safely skip the stack overflow check if we're
@@ -582,13 +582,13 @@
bool skipOverflowCheck = ((cUnit->attrs & METHOD_IS_LEAF) &&
(static_cast<size_t>(cUnit->frameSize) <
Thread::kStackOverflowReservedBytes));
- newLIR0(cUnit, kPseudoMethodEntry);
+ NewLIR0(cUnit, kPseudoMethodEntry);
if (!skipOverflowCheck) {
/* Load stack limit */
- loadWordDisp(cUnit, rARM_SELF, Thread::StackEndOffset().Int32Value(), r12);
+ LoadWordDisp(cUnit, rARM_SELF, Thread::StackEndOffset().Int32Value(), r12);
}
/* Spill core callee saves */
- newLIR1(cUnit, kThumb2Push, cUnit->coreSpillMask);
+ NewLIR1(cUnit, kThumb2Push, cUnit->coreSpillMask);
/* Need to spill any FP regs? */
if (cUnit->numFPSpills) {
/*
@@ -596,49 +596,49 @@
* they are pushed as a contiguous block. When promoting from
* the fp set, we must allocate all singles from s16..highest-promoted
*/
- newLIR1(cUnit, kThumb2VPushCS, cUnit->numFPSpills);
+ NewLIR1(cUnit, kThumb2VPushCS, cUnit->numFPSpills);
}
if (!skipOverflowCheck) {
- opRegRegImm(cUnit, kOpSub, rARM_LR, rARM_SP, cUnit->frameSize - (spillCount * 4));
- genRegRegCheck(cUnit, kCondCc, rARM_LR, r12, kThrowStackOverflow);
- opRegCopy(cUnit, rARM_SP, rARM_LR); // Establish stack
+ OpRegRegImm(cUnit, kOpSub, rARM_LR, rARM_SP, cUnit->frameSize - (spillCount * 4));
+ GenRegRegCheck(cUnit, kCondCc, rARM_LR, r12, kThrowStackOverflow);
+ OpRegCopy(cUnit, rARM_SP, rARM_LR); // Establish stack
} else {
- opRegImm(cUnit, kOpSub, rARM_SP, cUnit->frameSize - (spillCount * 4));
+ OpRegImm(cUnit, kOpSub, rARM_SP, cUnit->frameSize - (spillCount * 4));
}
- flushIns(cUnit, argLocs, rlMethod);
+ FlushIns(cUnit, ArgLocs, rlMethod);
- oatFreeTemp(cUnit, r0);
- oatFreeTemp(cUnit, r1);
- oatFreeTemp(cUnit, r2);
- oatFreeTemp(cUnit, r3);
+ FreeTemp(cUnit, r0);
+ FreeTemp(cUnit, r1);
+ FreeTemp(cUnit, r2);
+ FreeTemp(cUnit, r3);
}
-void genExitSequence(CompilationUnit* cUnit)
+void GenExitSequence(CompilationUnit* cUnit)
{
int spillCount = cUnit->numCoreSpills + cUnit->numFPSpills;
/*
* In the exit path, r0/r1 are live - make sure they aren't
* allocated by the register utilities as temps.
*/
- oatLockTemp(cUnit, r0);
- oatLockTemp(cUnit, r1);
+ LockTemp(cUnit, r0);
+ LockTemp(cUnit, r1);
- newLIR0(cUnit, kPseudoMethodExit);
- opRegImm(cUnit, kOpAdd, rARM_SP, cUnit->frameSize - (spillCount * 4));
+ NewLIR0(cUnit, kPseudoMethodExit);
+ OpRegImm(cUnit, kOpAdd, rARM_SP, cUnit->frameSize - (spillCount * 4));
/* Need to restore any FP callee saves? */
if (cUnit->numFPSpills) {
- newLIR1(cUnit, kThumb2VPopCS, cUnit->numFPSpills);
+ NewLIR1(cUnit, kThumb2VPopCS, cUnit->numFPSpills);
}
if (cUnit->coreSpillMask & (1 << rARM_LR)) {
/* Unspill rARM_LR to rARM_PC */
cUnit->coreSpillMask &= ~(1 << rARM_LR);
cUnit->coreSpillMask |= (1 << rARM_PC);
}
- newLIR1(cUnit, kThumb2Pop, cUnit->coreSpillMask);
+ NewLIR1(cUnit, kThumb2Pop, cUnit->coreSpillMask);
if (!(cUnit->coreSpillMask & (1 << rARM_PC))) {
/* We didn't pop to rARM_PC, so must do a bv rARM_LR */
- newLIR1(cUnit, kThumbBx, rARM_LR);
+ NewLIR1(cUnit, kThumbBx, rARM_LR);
}
}
diff --git a/src/compiler/codegen/arm/fp_arm.cc b/src/compiler/codegen/arm/fp_arm.cc
index 3b0d540..3584971 100644
--- a/src/compiler/codegen/arm/fp_arm.cc
+++ b/src/compiler/codegen/arm/fp_arm.cc
@@ -20,7 +20,7 @@
namespace art {
-bool genArithOpFloat(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest,
+bool GenArithOpFloat(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
int op = kThumbBkpt;
@@ -50,20 +50,20 @@
case Instruction::REM_FLOAT_2ADDR:
case Instruction::REM_FLOAT:
case Instruction::NEG_FLOAT: {
- return genArithOpFloatPortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
+ return GenArithOpFloatPortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
}
default:
return true;
}
- rlSrc1 = loadValue(cUnit, rlSrc1, kFPReg);
- rlSrc2 = loadValue(cUnit, rlSrc2, kFPReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
- newLIR3(cUnit, op, rlResult.lowReg, rlSrc1.lowReg, rlSrc2.lowReg);
- storeValue(cUnit, rlDest, rlResult);
+ rlSrc1 = LoadValue(cUnit, rlSrc1, kFPReg);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kFPReg);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
+ NewLIR3(cUnit, op, rlResult.lowReg, rlSrc1.lowReg, rlSrc2.lowReg);
+ StoreValue(cUnit, rlDest, rlResult);
return false;
}
-bool genArithOpDouble(CompilationUnit* cUnit, Instruction::Code opcode,
+bool GenArithOpDouble(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2)
{
int op = kThumbBkpt;
@@ -89,26 +89,26 @@
case Instruction::REM_DOUBLE_2ADDR:
case Instruction::REM_DOUBLE:
case Instruction::NEG_DOUBLE: {
- return genArithOpDoublePortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
+ return GenArithOpDoublePortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
}
default:
return true;
}
- rlSrc1 = loadValueWide(cUnit, rlSrc1, kFPReg);
+ rlSrc1 = LoadValueWide(cUnit, rlSrc1, kFPReg);
DCHECK(rlSrc1.wide);
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kFPReg);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kFPReg);
DCHECK(rlSrc2.wide);
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
DCHECK(rlDest.wide);
DCHECK(rlResult.wide);
- newLIR3(cUnit, op, s2d(rlResult.lowReg, rlResult.highReg), s2d(rlSrc1.lowReg, rlSrc1.highReg),
- s2d(rlSrc2.lowReg, rlSrc2.highReg));
- storeValueWide(cUnit, rlDest, rlResult);
+ NewLIR3(cUnit, op, S2d(rlResult.lowReg, rlResult.highReg), S2d(rlSrc1.lowReg, rlSrc1.highReg),
+ S2d(rlSrc2.lowReg, rlSrc2.highReg));
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
-bool genConversion(CompilationUnit* cUnit, Instruction::Code opcode,
+bool GenConversion(CompilationUnit* cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc)
{
int op = kThumbBkpt;
@@ -138,30 +138,30 @@
case Instruction::FLOAT_TO_LONG:
case Instruction::LONG_TO_FLOAT:
case Instruction::DOUBLE_TO_LONG:
- return genConversionPortable(cUnit, opcode, rlDest, rlSrc);
+ return GenConversionPortable(cUnit, opcode, rlDest, rlSrc);
default:
return true;
}
if (rlSrc.wide) {
- rlSrc = loadValueWide(cUnit, rlSrc, kFPReg);
- srcReg = s2d(rlSrc.lowReg, rlSrc.highReg);
+ rlSrc = LoadValueWide(cUnit, rlSrc, kFPReg);
+ srcReg = S2d(rlSrc.lowReg, rlSrc.highReg);
} else {
- rlSrc = loadValue(cUnit, rlSrc, kFPReg);
+ rlSrc = LoadValue(cUnit, rlSrc, kFPReg);
srcReg = rlSrc.lowReg;
}
if (rlDest.wide) {
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
- newLIR2(cUnit, op, s2d(rlResult.lowReg, rlResult.highReg), srcReg);
- storeValueWide(cUnit, rlDest, rlResult);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
+ NewLIR2(cUnit, op, S2d(rlResult.lowReg, rlResult.highReg), srcReg);
+ StoreValueWide(cUnit, rlDest, rlResult);
} else {
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
- newLIR2(cUnit, op, rlResult.lowReg, srcReg);
- storeValue(cUnit, rlDest, rlResult);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
+ NewLIR2(cUnit, op, rlResult.lowReg, srcReg);
+ StoreValue(cUnit, rlDest, rlResult);
}
return false;
}
-void genFusedFPCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+void GenFusedFPCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
bool gtBias, bool isDouble)
{
LIR* labelList = cUnit->blockLabelList;
@@ -169,20 +169,20 @@
RegLocation rlSrc1;
RegLocation rlSrc2;
if (isDouble) {
- rlSrc1 = oatGetSrcWide(cUnit, mir, 0);
- rlSrc2 = oatGetSrcWide(cUnit, mir, 2);
- rlSrc1 = loadValueWide(cUnit, rlSrc1, kFPReg);
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kFPReg);
- newLIR2(cUnit, kThumb2Vcmpd, s2d(rlSrc1.lowReg, rlSrc2.highReg),
- s2d(rlSrc2.lowReg, rlSrc2.highReg));
+ rlSrc1 = GetSrcWide(cUnit, mir, 0);
+ rlSrc2 = GetSrcWide(cUnit, mir, 2);
+ rlSrc1 = LoadValueWide(cUnit, rlSrc1, kFPReg);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kFPReg);
+ NewLIR2(cUnit, kThumb2Vcmpd, S2d(rlSrc1.lowReg, rlSrc2.highReg),
+ S2d(rlSrc2.lowReg, rlSrc2.highReg));
} else {
- rlSrc1 = oatGetSrc(cUnit, mir, 0);
- rlSrc2 = oatGetSrc(cUnit, mir, 1);
- rlSrc1 = loadValue(cUnit, rlSrc1, kFPReg);
- rlSrc2 = loadValue(cUnit, rlSrc2, kFPReg);
- newLIR2(cUnit, kThumb2Vcmps, rlSrc1.lowReg, rlSrc2.lowReg);
+ rlSrc1 = GetSrc(cUnit, mir, 0);
+ rlSrc2 = GetSrc(cUnit, mir, 1);
+ rlSrc1 = LoadValue(cUnit, rlSrc1, kFPReg);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kFPReg);
+ NewLIR2(cUnit, kThumb2Vcmps, rlSrc1.lowReg, rlSrc2.lowReg);
}
- newLIR0(cUnit, kThumb2Fmstat);
+ NewLIR0(cUnit, kThumb2Fmstat);
ConditionCode ccode = static_cast<ConditionCode>(mir->dalvikInsn.arg[0]);
switch(ccode) {
case kCondEq:
@@ -211,11 +211,11 @@
default:
LOG(FATAL) << "Unexpected ccode: " << ccode;
}
- opCondBranch(cUnit, ccode, target);
+ OpCondBranch(cUnit, ccode, target);
}
-bool genCmpFP(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest,
+bool GenCmpFP(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
bool isDouble;
@@ -243,77 +243,77 @@
return true;
}
if (isDouble) {
- rlSrc1 = loadValueWide(cUnit, rlSrc1, kFPReg);
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kFPReg);
- oatClobberSReg(cUnit, rlDest.sRegLow);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- loadConstant(cUnit, rlResult.lowReg, defaultResult);
- newLIR2(cUnit, kThumb2Vcmpd, s2d(rlSrc1.lowReg, rlSrc2.highReg),
- s2d(rlSrc2.lowReg, rlSrc2.highReg));
+ rlSrc1 = LoadValueWide(cUnit, rlSrc1, kFPReg);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kFPReg);
+ ClobberSReg(cUnit, rlDest.sRegLow);
+ rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ LoadConstant(cUnit, rlResult.lowReg, defaultResult);
+ NewLIR2(cUnit, kThumb2Vcmpd, S2d(rlSrc1.lowReg, rlSrc2.highReg),
+ S2d(rlSrc2.lowReg, rlSrc2.highReg));
} else {
- rlSrc1 = loadValue(cUnit, rlSrc1, kFPReg);
- rlSrc2 = loadValue(cUnit, rlSrc2, kFPReg);
- oatClobberSReg(cUnit, rlDest.sRegLow);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- loadConstant(cUnit, rlResult.lowReg, defaultResult);
- newLIR2(cUnit, kThumb2Vcmps, rlSrc1.lowReg, rlSrc2.lowReg);
+ rlSrc1 = LoadValue(cUnit, rlSrc1, kFPReg);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kFPReg);
+ ClobberSReg(cUnit, rlDest.sRegLow);
+ rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ LoadConstant(cUnit, rlResult.lowReg, defaultResult);
+ NewLIR2(cUnit, kThumb2Vcmps, rlSrc1.lowReg, rlSrc2.lowReg);
}
DCHECK(!ARM_FPREG(rlResult.lowReg));
- newLIR0(cUnit, kThumb2Fmstat);
+ NewLIR0(cUnit, kThumb2Fmstat);
- opIT(cUnit, (defaultResult == -1) ? kArmCondGt : kArmCondMi, "");
- newLIR2(cUnit, kThumb2MovImmShift, rlResult.lowReg,
- modifiedImmediate(-defaultResult)); // Must not alter ccodes
- genBarrier(cUnit);
+ OpIT(cUnit, (defaultResult == -1) ? kArmCondGt : kArmCondMi, "");
+ NewLIR2(cUnit, kThumb2MovImmShift, rlResult.lowReg,
+ ModifiedImmediate(-defaultResult)); // Must not alter ccodes
+ GenBarrier(cUnit);
- opIT(cUnit, kArmCondEq, "");
- loadConstant(cUnit, rlResult.lowReg, 0);
- genBarrier(cUnit);
+ OpIT(cUnit, kArmCondEq, "");
+ LoadConstant(cUnit, rlResult.lowReg, 0);
+ GenBarrier(cUnit);
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
return false;
}
-void genNegFloat(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc)
+void GenNegFloat(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc)
{
RegLocation rlResult;
- rlSrc = loadValue(cUnit, rlSrc, kFPReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
- newLIR2(cUnit, kThumb2Vnegs, rlResult.lowReg, rlSrc.lowReg);
- storeValue(cUnit, rlDest, rlResult);
+ rlSrc = LoadValue(cUnit, rlSrc, kFPReg);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
+ NewLIR2(cUnit, kThumb2Vnegs, rlResult.lowReg, rlSrc.lowReg);
+ StoreValue(cUnit, rlDest, rlResult);
}
-void genNegDouble(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc)
+void GenNegDouble(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc)
{
RegLocation rlResult;
- rlSrc = loadValueWide(cUnit, rlSrc, kFPReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
- newLIR2(cUnit, kThumb2Vnegd, s2d(rlResult.lowReg, rlResult.highReg),
- s2d(rlSrc.lowReg, rlSrc.highReg));
- storeValueWide(cUnit, rlDest, rlResult);
+ rlSrc = LoadValueWide(cUnit, rlSrc, kFPReg);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
+ NewLIR2(cUnit, kThumb2Vnegd, S2d(rlResult.lowReg, rlResult.highReg),
+ S2d(rlSrc.lowReg, rlSrc.highReg));
+ StoreValueWide(cUnit, rlDest, rlResult);
}
-bool genInlinedSqrt(CompilationUnit* cUnit, CallInfo* info) {
+bool GenInlinedSqrt(CompilationUnit* cUnit, CallInfo* info) {
DCHECK_EQ(cUnit->instructionSet, kThumb2);
LIR *branch;
RegLocation rlSrc = info->args[0];
- RegLocation rlDest = inlineTargetWide(cUnit, info); // double place for result
- rlSrc = loadValueWide(cUnit, rlSrc, kFPReg);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
- newLIR2(cUnit, kThumb2Vsqrtd, s2d(rlResult.lowReg, rlResult.highReg),
- s2d(rlSrc.lowReg, rlSrc.highReg));
- newLIR2(cUnit, kThumb2Vcmpd, s2d(rlResult.lowReg, rlResult.highReg),
- s2d(rlResult.lowReg, rlResult.highReg));
- newLIR0(cUnit, kThumb2Fmstat);
- branch = newLIR2(cUnit, kThumbBCond, 0, kArmCondEq);
- oatClobberCalleeSave(cUnit);
- oatLockCallTemps(cUnit); // Using fixed registers
- int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pSqrt));
- newLIR3(cUnit, kThumb2Fmrrd, r0, r1, s2d(rlSrc.lowReg, rlSrc.highReg));
- newLIR1(cUnit, kThumbBlxR, rTgt);
- newLIR3(cUnit, kThumb2Fmdrr, s2d(rlResult.lowReg, rlResult.highReg), r0, r1);
- branch->target = newLIR0(cUnit, kPseudoTargetLabel);
- storeValueWide(cUnit, rlDest, rlResult);
+ RegLocation rlDest = InlineTargetWide(cUnit, info); // double place for result
+ rlSrc = LoadValueWide(cUnit, rlSrc, kFPReg);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
+ NewLIR2(cUnit, kThumb2Vsqrtd, S2d(rlResult.lowReg, rlResult.highReg),
+ S2d(rlSrc.lowReg, rlSrc.highReg));
+ NewLIR2(cUnit, kThumb2Vcmpd, S2d(rlResult.lowReg, rlResult.highReg),
+ S2d(rlResult.lowReg, rlResult.highReg));
+ NewLIR0(cUnit, kThumb2Fmstat);
+ branch = NewLIR2(cUnit, kThumbBCond, 0, kArmCondEq);
+ ClobberCalleeSave(cUnit);
+ LockCallTemps(cUnit); // Using fixed registers
+ int rTgt = LoadHelper(cUnit, ENTRYPOINT_OFFSET(pSqrt));
+ NewLIR3(cUnit, kThumb2Fmrrd, r0, r1, S2d(rlSrc.lowReg, rlSrc.highReg));
+ NewLIR1(cUnit, kThumbBlxR, rTgt);
+ NewLIR3(cUnit, kThumb2Fmdrr, S2d(rlResult.lowReg, rlResult.highReg), r0, r1);
+ branch->target = NewLIR0(cUnit, kPseudoTargetLabel);
+ StoreValueWide(cUnit, rlDest, rlResult);
return true;
}
diff --git a/src/compiler/codegen/arm/int_arm.cc b/src/compiler/codegen/arm/int_arm.cc
index f54c58c..bdb3bea 100644
--- a/src/compiler/codegen/arm/int_arm.cc
+++ b/src/compiler/codegen/arm/int_arm.cc
@@ -24,11 +24,11 @@
namespace art {
-LIR* opCmpBranch(CompilationUnit* cUnit, ConditionCode cond, int src1,
+LIR* OpCmpBranch(CompilationUnit* cUnit, ConditionCode cond, int src1,
int src2, LIR* target)
{
- opRegReg(cUnit, kOpCmp, src1, src2);
- return opCondBranch(cUnit, cond, target);
+ OpRegReg(cUnit, kOpCmp, src1, src2);
+ return OpCondBranch(cUnit, cond, target);
}
/*
@@ -41,7 +41,7 @@
* met, and an "E" means the instruction is executed if the condition
* is not met.
*/
-LIR* opIT(CompilationUnit* cUnit, ArmConditionCode code, const char* guide)
+LIR* OpIT(CompilationUnit* cUnit, ArmConditionCode code, const char* guide)
{
int mask;
int condBit = code & 1;
@@ -62,11 +62,11 @@
case 0:
break;
default:
- LOG(FATAL) << "OAT: bad case in opIT";
+ LOG(FATAL) << "OAT: bad case in OpIT";
}
mask = (mask3 << 3) | (mask2 << 2) | (mask1 << 1) |
(1 << (3 - strlen(guide)));
- return newLIR2(cUnit, kThumb2It, code, mask);
+ return NewLIR2(cUnit, kThumb2It, code, mask);
}
/*
@@ -84,122 +84,122 @@
* neg rX
* done:
*/
-void genCmpLong(CompilationUnit* cUnit, RegLocation rlDest,
+void GenCmpLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
LIR* target1;
LIR* target2;
- rlSrc1 = loadValueWide(cUnit, rlSrc1, kCoreReg);
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kCoreReg);
- int tReg = oatAllocTemp(cUnit);
- loadConstant(cUnit, tReg, -1);
- opRegReg(cUnit, kOpCmp, rlSrc1.highReg, rlSrc2.highReg);
- LIR* branch1 = opCondBranch(cUnit, kCondLt, NULL);
- LIR* branch2 = opCondBranch(cUnit, kCondGt, NULL);
- opRegRegReg(cUnit, kOpSub, tReg, rlSrc1.lowReg, rlSrc2.lowReg);
- LIR* branch3 = opCondBranch(cUnit, kCondEq, NULL);
+ rlSrc1 = LoadValueWide(cUnit, rlSrc1, kCoreReg);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kCoreReg);
+ int tReg = AllocTemp(cUnit);
+ LoadConstant(cUnit, tReg, -1);
+ OpRegReg(cUnit, kOpCmp, rlSrc1.highReg, rlSrc2.highReg);
+ LIR* branch1 = OpCondBranch(cUnit, kCondLt, NULL);
+ LIR* branch2 = OpCondBranch(cUnit, kCondGt, NULL);
+ OpRegRegReg(cUnit, kOpSub, tReg, rlSrc1.lowReg, rlSrc2.lowReg);
+ LIR* branch3 = OpCondBranch(cUnit, kCondEq, NULL);
- opIT(cUnit, kArmCondHi, "E");
- newLIR2(cUnit, kThumb2MovImmShift, tReg, modifiedImmediate(-1));
- loadConstant(cUnit, tReg, 1);
- genBarrier(cUnit);
+ OpIT(cUnit, kArmCondHi, "E");
+ NewLIR2(cUnit, kThumb2MovImmShift, tReg, ModifiedImmediate(-1));
+ LoadConstant(cUnit, tReg, 1);
+ GenBarrier(cUnit);
- target2 = newLIR0(cUnit, kPseudoTargetLabel);
- opRegReg(cUnit, kOpNeg, tReg, tReg);
+ target2 = NewLIR0(cUnit, kPseudoTargetLabel);
+ OpRegReg(cUnit, kOpNeg, tReg, tReg);
- target1 = newLIR0(cUnit, kPseudoTargetLabel);
+ target1 = NewLIR0(cUnit, kPseudoTargetLabel);
- RegLocation rlTemp = locCReturn(); // Just using as template, will change
+ RegLocation rlTemp = LocCReturn(); // Just using as template, will change
rlTemp.lowReg = tReg;
- storeValue(cUnit, rlDest, rlTemp);
- oatFreeTemp(cUnit, tReg);
+ StoreValue(cUnit, rlDest, rlTemp);
+ FreeTemp(cUnit, tReg);
branch1->target = target1;
branch2->target = target2;
branch3->target = branch1->target;
}
-void genFusedLongCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir)
+void GenFusedLongCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir)
{
LIR* labelList = cUnit->blockLabelList;
LIR* taken = &labelList[bb->taken->id];
LIR* notTaken = &labelList[bb->fallThrough->id];
- RegLocation rlSrc1 = oatGetSrcWide(cUnit, mir, 0);
- RegLocation rlSrc2 = oatGetSrcWide(cUnit, mir, 2);
- rlSrc1 = loadValueWide(cUnit, rlSrc1, kCoreReg);
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kCoreReg);
+ RegLocation rlSrc1 = GetSrcWide(cUnit, mir, 0);
+ RegLocation rlSrc2 = GetSrcWide(cUnit, mir, 2);
+ rlSrc1 = LoadValueWide(cUnit, rlSrc1, kCoreReg);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kCoreReg);
ConditionCode ccode = static_cast<ConditionCode>(mir->dalvikInsn.arg[0]);
- opRegReg(cUnit, kOpCmp, rlSrc1.highReg, rlSrc2.highReg);
+ OpRegReg(cUnit, kOpCmp, rlSrc1.highReg, rlSrc2.highReg);
switch(ccode) {
case kCondEq:
- opCondBranch(cUnit, kCondNe, notTaken);
+ OpCondBranch(cUnit, kCondNe, notTaken);
break;
case kCondNe:
- opCondBranch(cUnit, kCondNe, taken);
+ OpCondBranch(cUnit, kCondNe, taken);
break;
case kCondLt:
- opCondBranch(cUnit, kCondLt, taken);
- opCondBranch(cUnit, kCondGt, notTaken);
+ OpCondBranch(cUnit, kCondLt, taken);
+ OpCondBranch(cUnit, kCondGt, notTaken);
ccode = kCondCc;
break;
case kCondLe:
- opCondBranch(cUnit, kCondLt, taken);
- opCondBranch(cUnit, kCondGt, notTaken);
+ OpCondBranch(cUnit, kCondLt, taken);
+ OpCondBranch(cUnit, kCondGt, notTaken);
ccode = kCondLs;
break;
case kCondGt:
- opCondBranch(cUnit, kCondGt, taken);
- opCondBranch(cUnit, kCondLt, notTaken);
+ OpCondBranch(cUnit, kCondGt, taken);
+ OpCondBranch(cUnit, kCondLt, notTaken);
ccode = kCondHi;
break;
case kCondGe:
- opCondBranch(cUnit, kCondGt, taken);
- opCondBranch(cUnit, kCondLt, notTaken);
+ OpCondBranch(cUnit, kCondGt, taken);
+ OpCondBranch(cUnit, kCondLt, notTaken);
ccode = kCondCs;
break;
default:
LOG(FATAL) << "Unexpected ccode: " << ccode;
}
- opRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
- opCondBranch(cUnit, ccode, taken);
+ OpRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
+ OpCondBranch(cUnit, ccode, taken);
}
/*
* Generate a register comparison to an immediate and branch. Caller
* is responsible for setting branch target field.
*/
-LIR* opCmpImmBranch(CompilationUnit* cUnit, ConditionCode cond, int reg,
+LIR* OpCmpImmBranch(CompilationUnit* cUnit, ConditionCode cond, int reg,
int checkValue, LIR* target)
{
LIR* branch;
int modImm;
- ArmConditionCode armCond = oatArmConditionEncoding(cond);
+ ArmConditionCode armCond = ArmConditionEncoding(cond);
if ((ARM_LOWREG(reg)) && (checkValue == 0) &&
((armCond == kArmCondEq) || (armCond == kArmCondNe))) {
- branch = newLIR2(cUnit, (armCond == kArmCondEq) ? kThumb2Cbz : kThumb2Cbnz,
+ branch = NewLIR2(cUnit, (armCond == kArmCondEq) ? kThumb2Cbz : kThumb2Cbnz,
reg, 0);
} else {
- modImm = modifiedImmediate(checkValue);
+ modImm = ModifiedImmediate(checkValue);
if (ARM_LOWREG(reg) && ((checkValue & 0xff) == checkValue)) {
- newLIR2(cUnit, kThumbCmpRI8, reg, checkValue);
+ NewLIR2(cUnit, kThumbCmpRI8, reg, checkValue);
} else if (modImm >= 0) {
- newLIR2(cUnit, kThumb2CmpRI8, reg, modImm);
+ NewLIR2(cUnit, kThumb2CmpRI8, reg, modImm);
} else {
- int tReg = oatAllocTemp(cUnit);
- loadConstant(cUnit, tReg, checkValue);
- opRegReg(cUnit, kOpCmp, reg, tReg);
+ int tReg = AllocTemp(cUnit);
+ LoadConstant(cUnit, tReg, checkValue);
+ OpRegReg(cUnit, kOpCmp, reg, tReg);
}
- branch = newLIR2(cUnit, kThumbBCond, 0, armCond);
+ branch = NewLIR2(cUnit, kThumbBCond, 0, armCond);
}
branch->target = target;
return branch;
}
-LIR* opRegCopyNoInsert(CompilationUnit* cUnit, int rDest, int rSrc)
+LIR* OpRegCopyNoInsert(CompilationUnit* cUnit, int rDest, int rSrc)
{
LIR* res;
int opcode;
if (ARM_FPREG(rDest) || ARM_FPREG(rSrc))
- return fpRegCopy(cUnit, rDest, rSrc);
+ return FpRegCopy(cUnit, rDest, rSrc);
if (ARM_LOWREG(rDest) && ARM_LOWREG(rSrc))
opcode = kThumbMovRR;
else if (!ARM_LOWREG(rDest) && !ARM_LOWREG(rSrc))
@@ -208,21 +208,21 @@
opcode = kThumbMovRR_H2L;
else
opcode = kThumbMovRR_L2H;
- res = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, rDest, rSrc);
+ res = RawLIR(cUnit, cUnit->currentDalvikOffset, opcode, rDest, rSrc);
if (!(cUnit->disableOpt & (1 << kSafeOptimizations)) && rDest == rSrc) {
res->flags.isNop = true;
}
return res;
}
-LIR* opRegCopy(CompilationUnit* cUnit, int rDest, int rSrc)
+LIR* OpRegCopy(CompilationUnit* cUnit, int rDest, int rSrc)
{
- LIR* res = opRegCopyNoInsert(cUnit, rDest, rSrc);
- oatAppendLIR(cUnit, res);
+ LIR* res = OpRegCopyNoInsert(cUnit, rDest, rSrc);
+ AppendLIR(cUnit, res);
return res;
}
-void opRegCopyWide(CompilationUnit* cUnit, int destLo, int destHi,
+void OpRegCopyWide(CompilationUnit* cUnit, int destLo, int destHi,
int srcLo, int srcHi)
{
bool destFP = ARM_FPREG(destLo) && ARM_FPREG(destHi);
@@ -231,21 +231,21 @@
DCHECK_EQ(ARM_FPREG(destLo), ARM_FPREG(destHi));
if (destFP) {
if (srcFP) {
- opRegCopy(cUnit, s2d(destLo, destHi), s2d(srcLo, srcHi));
+ OpRegCopy(cUnit, S2d(destLo, destHi), S2d(srcLo, srcHi));
} else {
- newLIR3(cUnit, kThumb2Fmdrr, s2d(destLo, destHi), srcLo, srcHi);
+ NewLIR3(cUnit, kThumb2Fmdrr, S2d(destLo, destHi), srcLo, srcHi);
}
} else {
if (srcFP) {
- newLIR3(cUnit, kThumb2Fmrrd, destLo, destHi, s2d(srcLo, srcHi));
+ NewLIR3(cUnit, kThumb2Fmrrd, destLo, destHi, S2d(srcLo, srcHi));
} else {
// Handle overlap
if (srcHi == destLo) {
- opRegCopy(cUnit, destHi, srcHi);
- opRegCopy(cUnit, destLo, srcLo);
+ OpRegCopy(cUnit, destHi, srcHi);
+ OpRegCopy(cUnit, destLo, srcLo);
} else {
- opRegCopy(cUnit, destLo, srcLo);
- opRegCopy(cUnit, destHi, srcHi);
+ OpRegCopy(cUnit, destLo, srcLo);
+ OpRegCopy(cUnit, destHi, srcHi);
}
}
}
@@ -278,7 +278,7 @@
};
// Integer division by constant via reciprocal multiply (Hacker's Delight, 10-4)
-bool smallLiteralDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode,
+bool SmallLiteralDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode,
RegLocation rlSrc, RegLocation rlDest, int lit)
{
if ((lit < 0) || (lit >= static_cast<int>(sizeof(magicTable)/sizeof(magicTable[0])))) {
@@ -293,84 +293,84 @@
return false;
}
- int rMagic = oatAllocTemp(cUnit);
- loadConstant(cUnit, rMagic, magicTable[lit].magic);
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- int rHi = oatAllocTemp(cUnit);
- int rLo = oatAllocTemp(cUnit);
- newLIR4(cUnit, kThumb2Smull, rLo, rHi, rMagic, rlSrc.lowReg);
+ int rMagic = AllocTemp(cUnit);
+ LoadConstant(cUnit, rMagic, magicTable[lit].magic);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ int rHi = AllocTemp(cUnit);
+ int rLo = AllocTemp(cUnit);
+ NewLIR4(cUnit, kThumb2Smull, rLo, rHi, rMagic, rlSrc.lowReg);
switch(pattern) {
case Divide3:
- opRegRegRegShift(cUnit, kOpSub, rlResult.lowReg, rHi,
- rlSrc.lowReg, encodeShift(kArmAsr, 31));
+ OpRegRegRegShift(cUnit, kOpSub, rlResult.lowReg, rHi,
+ rlSrc.lowReg, EncodeShift(kArmAsr, 31));
break;
case Divide5:
- opRegRegImm(cUnit, kOpAsr, rLo, rlSrc.lowReg, 31);
- opRegRegRegShift(cUnit, kOpRsub, rlResult.lowReg, rLo, rHi,
- encodeShift(kArmAsr, magicTable[lit].shift));
+ OpRegRegImm(cUnit, kOpAsr, rLo, rlSrc.lowReg, 31);
+ OpRegRegRegShift(cUnit, kOpRsub, rlResult.lowReg, rLo, rHi,
+ EncodeShift(kArmAsr, magicTable[lit].shift));
break;
case Divide7:
- opRegReg(cUnit, kOpAdd, rHi, rlSrc.lowReg);
- opRegRegImm(cUnit, kOpAsr, rLo, rlSrc.lowReg, 31);
- opRegRegRegShift(cUnit, kOpRsub, rlResult.lowReg, rLo, rHi,
- encodeShift(kArmAsr, magicTable[lit].shift));
+ OpRegReg(cUnit, kOpAdd, rHi, rlSrc.lowReg);
+ OpRegRegImm(cUnit, kOpAsr, rLo, rlSrc.lowReg, 31);
+ OpRegRegRegShift(cUnit, kOpRsub, rlResult.lowReg, rLo, rHi,
+ EncodeShift(kArmAsr, magicTable[lit].shift));
break;
default:
LOG(FATAL) << "Unexpected pattern: " << pattern;
}
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
return true;
}
-LIR* genRegMemCheck(CompilationUnit* cUnit, ConditionCode cCode,
+LIR* GenRegMemCheck(CompilationUnit* cUnit, ConditionCode cCode,
int reg1, int base, int offset, ThrowKind kind)
{
- LOG(FATAL) << "Unexpected use of genRegMemCheck for Arm";
+ LOG(FATAL) << "Unexpected use of GenRegMemCheck for Arm";
return NULL;
}
-RegLocation genDivRemLit(CompilationUnit* cUnit, RegLocation rlDest, int reg1, int lit, bool isDiv)
+RegLocation GenDivRemLit(CompilationUnit* cUnit, RegLocation rlDest, int reg1, int lit, bool isDiv)
{
- LOG(FATAL) << "Unexpected use of genDivRemLit for Arm";
+ LOG(FATAL) << "Unexpected use of GenDivRemLit for Arm";
return rlDest;
}
-RegLocation genDivRem(CompilationUnit* cUnit, RegLocation rlDest, int reg1, int reg2, bool isDiv)
+RegLocation GenDivRem(CompilationUnit* cUnit, RegLocation rlDest, int reg1, int reg2, bool isDiv)
{
- LOG(FATAL) << "Unexpected use of genDivRem for Arm";
+ LOG(FATAL) << "Unexpected use of GenDivRem for Arm";
return rlDest;
}
-bool genInlinedMinMaxInt(CompilationUnit *cUnit, CallInfo* info, bool isMin)
+bool GenInlinedMinMaxInt(CompilationUnit *cUnit, CallInfo* info, bool isMin)
{
DCHECK_EQ(cUnit->instructionSet, kThumb2);
RegLocation rlSrc1 = info->args[0];
RegLocation rlSrc2 = info->args[1];
- rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
- rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
- RegLocation rlDest = inlineTarget(cUnit, info);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- opRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
- opIT(cUnit, (isMin) ? kArmCondGt : kArmCondLt, "E");
- opRegReg(cUnit, kOpMov, rlResult.lowReg, rlSrc2.lowReg);
- opRegReg(cUnit, kOpMov, rlResult.lowReg, rlSrc1.lowReg);
- genBarrier(cUnit);
- storeValue(cUnit, rlDest, rlResult);
+ rlSrc1 = LoadValue(cUnit, rlSrc1, kCoreReg);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kCoreReg);
+ RegLocation rlDest = InlineTarget(cUnit, info);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ OpRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
+ OpIT(cUnit, (isMin) ? kArmCondGt : kArmCondLt, "E");
+ OpRegReg(cUnit, kOpMov, rlResult.lowReg, rlSrc2.lowReg);
+ OpRegReg(cUnit, kOpMov, rlResult.lowReg, rlSrc1.lowReg);
+ GenBarrier(cUnit);
+ StoreValue(cUnit, rlDest, rlResult);
return true;
}
-void opLea(CompilationUnit* cUnit, int rBase, int reg1, int reg2, int scale, int offset)
+void OpLea(CompilationUnit* cUnit, int rBase, int reg1, int reg2, int scale, int offset)
{
- LOG(FATAL) << "Unexpected use of opLea for Arm";
+ LOG(FATAL) << "Unexpected use of OpLea for Arm";
}
-void opTlsCmp(CompilationUnit* cUnit, int offset, int val)
+void OpTlsCmp(CompilationUnit* cUnit, int offset, int val)
{
- LOG(FATAL) << "Unexpected use of opTlsCmp for Arm";
+ LOG(FATAL) << "Unexpected use of OpTlsCmp for Arm";
}
-bool genInlinedCas32(CompilationUnit* cUnit, CallInfo* info, bool need_write_barrier) {
+bool GenInlinedCas32(CompilationUnit* cUnit, CallInfo* info, bool need_write_barrier) {
DCHECK_EQ(cUnit->instructionSet, kThumb2);
// Unused - RegLocation rlSrcUnsafe = info->args[0];
RegLocation rlSrcObj= info->args[1]; // Object - known non-null
@@ -378,35 +378,35 @@
rlSrcOffset.wide = 0; // ignore high half in info->args[3]
RegLocation rlSrcExpected= info->args[4]; // int or Object
RegLocation rlSrcNewValue= info->args[5]; // int or Object
- RegLocation rlDest = inlineTarget(cUnit, info); // boolean place for result
+ RegLocation rlDest = InlineTarget(cUnit, info); // boolean place for result
// Release store semantics, get the barrier out of the way. TODO: revisit
- oatGenMemBarrier(cUnit, kStoreLoad);
+ GenMemBarrier(cUnit, kStoreLoad);
- RegLocation rlObject = loadValue(cUnit, rlSrcObj, kCoreReg);
- RegLocation rlNewValue = loadValue(cUnit, rlSrcNewValue, kCoreReg);
+ RegLocation rlObject = LoadValue(cUnit, rlSrcObj, kCoreReg);
+ RegLocation rlNewValue = LoadValue(cUnit, rlSrcNewValue, kCoreReg);
if (need_write_barrier) {
// Mark card for object assuming new value is stored.
- markGCCard(cUnit, rlNewValue.lowReg, rlObject.lowReg);
+ MarkGCCard(cUnit, rlNewValue.lowReg, rlObject.lowReg);
}
- RegLocation rlOffset = loadValue(cUnit, rlSrcOffset, kCoreReg);
+ RegLocation rlOffset = LoadValue(cUnit, rlSrcOffset, kCoreReg);
- int rPtr = oatAllocTemp(cUnit);
- opRegRegReg(cUnit, kOpAdd, rPtr, rlObject.lowReg, rlOffset.lowReg);
+ int rPtr = AllocTemp(cUnit);
+ OpRegRegReg(cUnit, kOpAdd, rPtr, rlObject.lowReg, rlOffset.lowReg);
// Free now unneeded rlObject and rlOffset to give more temps.
- oatClobberSReg(cUnit, rlObject.sRegLow);
- oatFreeTemp(cUnit, rlObject.lowReg);
- oatClobberSReg(cUnit, rlOffset.sRegLow);
- oatFreeTemp(cUnit, rlOffset.lowReg);
+ ClobberSReg(cUnit, rlObject.sRegLow);
+ FreeTemp(cUnit, rlObject.lowReg);
+ ClobberSReg(cUnit, rlOffset.sRegLow);
+ FreeTemp(cUnit, rlOffset.lowReg);
- int rOldValue = oatAllocTemp(cUnit);
- newLIR3(cUnit, kThumb2Ldrex, rOldValue, rPtr, 0); // rOldValue := [rPtr]
+ int rOldValue = AllocTemp(cUnit);
+ NewLIR3(cUnit, kThumb2Ldrex, rOldValue, rPtr, 0); // rOldValue := [rPtr]
- RegLocation rlExpected = loadValue(cUnit, rlSrcExpected, kCoreReg);
+ RegLocation rlExpected = LoadValue(cUnit, rlSrcExpected, kCoreReg);
// if (rOldValue == rExpected) {
// [rPtr] <- rNewValue && rResult := success ? 0 : 1
@@ -414,70 +414,70 @@
// } else {
// rResult := 0
// }
- opRegReg(cUnit, kOpCmp, rOldValue, rlExpected.lowReg);
- oatFreeTemp(cUnit, rOldValue); // Now unneeded.
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- opIT(cUnit, kArmCondEq, "TE");
- newLIR4(cUnit, kThumb2Strex, rlResult.lowReg, rlNewValue.lowReg, rPtr, 0);
- oatFreeTemp(cUnit, rPtr); // Now unneeded.
- opRegImm(cUnit, kOpXor, rlResult.lowReg, 1);
- opRegReg(cUnit, kOpXor, rlResult.lowReg, rlResult.lowReg);
+ OpRegReg(cUnit, kOpCmp, rOldValue, rlExpected.lowReg);
+ FreeTemp(cUnit, rOldValue); // Now unneeded.
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ OpIT(cUnit, kArmCondEq, "TE");
+ NewLIR4(cUnit, kThumb2Strex, rlResult.lowReg, rlNewValue.lowReg, rPtr, 0);
+ FreeTemp(cUnit, rPtr); // Now unneeded.
+ OpRegImm(cUnit, kOpXor, rlResult.lowReg, 1);
+ OpRegReg(cUnit, kOpXor, rlResult.lowReg, rlResult.lowReg);
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
return true;
}
-LIR* opPcRelLoad(CompilationUnit* cUnit, int reg, LIR* target)
+LIR* OpPcRelLoad(CompilationUnit* cUnit, int reg, LIR* target)
{
- return rawLIR(cUnit, cUnit->currentDalvikOffset, kThumb2LdrPcRel12, reg, 0, 0, 0, 0, target);
+ return RawLIR(cUnit, cUnit->currentDalvikOffset, kThumb2LdrPcRel12, reg, 0, 0, 0, 0, target);
}
-LIR* opVldm(CompilationUnit* cUnit, int rBase, int count)
+LIR* OpVldm(CompilationUnit* cUnit, int rBase, int count)
{
- return newLIR3(cUnit, kThumb2Vldms, rBase, fr0, count);
+ return NewLIR3(cUnit, kThumb2Vldms, rBase, fr0, count);
}
-LIR* opVstm(CompilationUnit* cUnit, int rBase, int count)
+LIR* OpVstm(CompilationUnit* cUnit, int rBase, int count)
{
- return newLIR3(cUnit, kThumb2Vstms, rBase, fr0, count);
+ return NewLIR3(cUnit, kThumb2Vstms, rBase, fr0, count);
}
-void genMultiplyByTwoBitMultiplier(CompilationUnit* cUnit, RegLocation rlSrc,
+void GenMultiplyByTwoBitMultiplier(CompilationUnit* cUnit, RegLocation rlSrc,
RegLocation rlResult, int lit,
int firstBit, int secondBit)
{
- opRegRegRegShift(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, rlSrc.lowReg,
- encodeShift(kArmLsl, secondBit - firstBit));
+ OpRegRegRegShift(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, rlSrc.lowReg,
+ EncodeShift(kArmLsl, secondBit - firstBit));
if (firstBit != 0) {
- opRegRegImm(cUnit, kOpLsl, rlResult.lowReg, rlResult.lowReg, firstBit);
+ OpRegRegImm(cUnit, kOpLsl, rlResult.lowReg, rlResult.lowReg, firstBit);
}
}
-void genDivZeroCheck(CompilationUnit* cUnit, int regLo, int regHi)
+void GenDivZeroCheck(CompilationUnit* cUnit, int regLo, int regHi)
{
- int tReg = oatAllocTemp(cUnit);
- newLIR4(cUnit, kThumb2OrrRRRs, tReg, regLo, regHi, 0);
- oatFreeTemp(cUnit, tReg);
- genCheck(cUnit, kCondEq, kThrowDivZero);
+ int tReg = AllocTemp(cUnit);
+ NewLIR4(cUnit, kThumb2OrrRRRs, tReg, regLo, regHi, 0);
+ FreeTemp(cUnit, tReg);
+ GenCheck(cUnit, kCondEq, kThrowDivZero);
}
// Test suspend flag, return target of taken suspend branch
-LIR* opTestSuspend(CompilationUnit* cUnit, LIR* target)
+LIR* OpTestSuspend(CompilationUnit* cUnit, LIR* target)
{
- newLIR2(cUnit, kThumbSubRI8, rARM_SUSPEND, 1);
- return opCondBranch(cUnit, (target == NULL) ? kCondEq : kCondNe, target);
+ NewLIR2(cUnit, kThumbSubRI8, rARM_SUSPEND, 1);
+ return OpCondBranch(cUnit, (target == NULL) ? kCondEq : kCondNe, target);
}
// Decrement register and branch on condition
-LIR* opDecAndBranch(CompilationUnit* cUnit, ConditionCode cCode, int reg, LIR* target)
+LIR* OpDecAndBranch(CompilationUnit* cUnit, ConditionCode cCode, int reg, LIR* target)
{
// Combine sub & test using sub setflags encoding here
- newLIR3(cUnit, kThumb2SubsRRI12, reg, reg, 1);
- return opCondBranch(cUnit, cCode, target);
+ NewLIR3(cUnit, kThumb2SubsRRI12, reg, reg, 1);
+ return OpCondBranch(cUnit, cCode, target);
}
-void oatGenMemBarrier(CompilationUnit* cUnit, MemBarrierKind barrierKind)
+void GenMemBarrier(CompilationUnit* cUnit, MemBarrierKind barrierKind)
{
#if ANDROID_SMP != 0
int dmbFlavor;
@@ -492,62 +492,62 @@
dmbFlavor = kSY; // quiet gcc.
break;
}
- LIR* dmb = newLIR1(cUnit, kThumb2Dmb, dmbFlavor);
+ LIR* dmb = NewLIR1(cUnit, kThumb2Dmb, dmbFlavor);
dmb->defMask = ENCODE_ALL;
#endif
}
-bool genNegLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenNegLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
- rlSrc = loadValueWide(cUnit, rlSrc, kCoreReg);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- int zReg = oatAllocTemp(cUnit);
- loadConstantNoClobber(cUnit, zReg, 0);
+ rlSrc = LoadValueWide(cUnit, rlSrc, kCoreReg);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ int zReg = AllocTemp(cUnit);
+ LoadConstantNoClobber(cUnit, zReg, 0);
// Check for destructive overlap
if (rlResult.lowReg == rlSrc.highReg) {
- int tReg = oatAllocTemp(cUnit);
- opRegRegReg(cUnit, kOpSub, rlResult.lowReg, zReg, rlSrc.lowReg);
- opRegRegReg(cUnit, kOpSbc, rlResult.highReg, zReg, tReg);
- oatFreeTemp(cUnit, tReg);
+ int tReg = AllocTemp(cUnit);
+ OpRegRegReg(cUnit, kOpSub, rlResult.lowReg, zReg, rlSrc.lowReg);
+ OpRegRegReg(cUnit, kOpSbc, rlResult.highReg, zReg, tReg);
+ FreeTemp(cUnit, tReg);
} else {
- opRegRegReg(cUnit, kOpSub, rlResult.lowReg, zReg, rlSrc.lowReg);
- opRegRegReg(cUnit, kOpSbc, rlResult.highReg, zReg, rlSrc.highReg);
+ OpRegRegReg(cUnit, kOpSub, rlResult.lowReg, zReg, rlSrc.lowReg);
+ OpRegRegReg(cUnit, kOpSbc, rlResult.highReg, zReg, rlSrc.highReg);
}
- oatFreeTemp(cUnit, zReg);
- storeValueWide(cUnit, rlDest, rlResult);
+ FreeTemp(cUnit, zReg);
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
-bool genAddLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenAddLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- LOG(FATAL) << "Unexpected use of genAddLong for Arm";
+ LOG(FATAL) << "Unexpected use of GenAddLong for Arm";
return false;
}
-bool genSubLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenSubLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- LOG(FATAL) << "Unexpected use of genSubLong for Arm";
+ LOG(FATAL) << "Unexpected use of GenSubLong for Arm";
return false;
}
-bool genAndLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenAndLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- LOG(FATAL) << "Unexpected use of genAndLong for Arm";
+ LOG(FATAL) << "Unexpected use of GenAndLong for Arm";
return false;
}
-bool genOrLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenOrLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- LOG(FATAL) << "Unexpected use of genOrLong for Arm";
+ LOG(FATAL) << "Unexpected use of GenOrLong for Arm";
return false;
}
-bool genXorLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenXorLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
LOG(FATAL) << "Unexpected use of genXoLong for Arm";
diff --git a/src/compiler/codegen/arm/target_arm.cc b/src/compiler/codegen/arm/target_arm.cc
index aa67be1..744800d 100644
--- a/src/compiler/codegen/arm/target_arm.cc
+++ b/src/compiler/codegen/arm/target_arm.cc
@@ -25,8 +25,8 @@
static int coreRegs[] = {r0, r1, r2, r3, rARM_SUSPEND, r5, r6, r7, r8, rARM_SELF, r10,
r11, r12, rARM_SP, rARM_LR, rARM_PC};
-static int reservedRegs[] = {rARM_SUSPEND, rARM_SELF, rARM_SP, rARM_LR, rARM_PC};
-static int fpRegs[] = {fr0, fr1, fr2, fr3, fr4, fr5, fr6, fr7,
+static int ReservedRegs[] = {rARM_SUSPEND, rARM_SELF, rARM_SP, rARM_LR, rARM_PC};
+static int FpRegs[] = {fr0, fr1, fr2, fr3, fr4, fr5, fr6, fr7,
fr8, fr9, fr10, fr11, fr12, fr13, fr14, fr15,
fr16, fr17, fr18, fr19, fr20, fr21, fr22, fr23,
fr24, fr25, fr26, fr27, fr28, fr29, fr30, fr31};
@@ -34,32 +34,32 @@
static int fpTemps[] = {fr0, fr1, fr2, fr3, fr4, fr5, fr6, fr7,
fr8, fr9, fr10, fr11, fr12, fr13, fr14, fr15};
-RegLocation locCReturn()
+RegLocation LocCReturn()
{
RegLocation res = ARM_LOC_C_RETURN;
return res;
}
-RegLocation locCReturnWide()
+RegLocation LocCReturnWide()
{
RegLocation res = ARM_LOC_C_RETURN_WIDE;
return res;
}
-RegLocation locCReturnFloat()
+RegLocation LocCReturnFloat()
{
RegLocation res = ARM_LOC_C_RETURN_FLOAT;
return res;
}
-RegLocation locCReturnDouble()
+RegLocation LocCReturnDouble()
{
RegLocation res = ARM_LOC_C_RETURN_DOUBLE;
return res;
}
// Return a target-dependent special register.
-int targetReg(SpecialTargetRegister reg) {
+int TargetReg(SpecialTargetRegister reg) {
int res = INVALID_REG;
switch (reg) {
case kSelf: res = rARM_SELF; break;
@@ -85,37 +85,37 @@
// Create a double from a pair of singles.
-int s2d(int lowReg, int highReg)
+int S2d(int lowReg, int highReg)
{
return ARM_S2D(lowReg, highReg);
}
// Is reg a single or double?
-bool fpReg(int reg)
+bool FpReg(int reg)
{
return ARM_FPREG(reg);
}
// Is reg a single?
-bool singleReg(int reg)
+bool SingleReg(int reg)
{
return ARM_SINGLEREG(reg);
}
// Is reg a double?
-bool doubleReg(int reg)
+bool DoubleReg(int reg)
{
return ARM_DOUBLEREG(reg);
}
// Return mask to strip off fp reg flags and bias.
-uint32_t fpRegMask()
+uint32_t FpRegMask()
{
return ARM_FP_REG_MASK;
}
// True if both regs single, both core or both double.
-bool sameRegType(int reg1, int reg2)
+bool SameRegType(int reg1, int reg2)
{
return (ARM_REGTYPE(reg1) == ARM_REGTYPE(reg2));
}
@@ -123,7 +123,7 @@
/*
* Decode the register id.
*/
-uint64_t getRegMaskCommon(CompilationUnit* cUnit, int reg)
+uint64_t GetRegMaskCommon(CompilationUnit* cUnit, int reg)
{
uint64_t seed;
int shift;
@@ -140,12 +140,12 @@
return (seed << shift);
}
-uint64_t getPCUseDefEncoding()
+uint64_t GetPCUseDefEncoding()
{
return ENCODE_ARM_REG_PC;
}
-void setupTargetResourceMasks(CompilationUnit* cUnit, LIR* lir)
+void SetupTargetResourceMasks(CompilationUnit* cUnit, LIR* lir)
{
DCHECK_EQ(cUnit->instructionSet, kThumb2);
@@ -175,7 +175,7 @@
if (flags & REG_DEF_FPCS_LIST2) {
for (int i = 0; i < lir->operands[2]; i++) {
- oatSetupRegMask(cUnit, &lir->defMask, lir->operands[1] + i);
+ SetupRegMask(cUnit, &lir->defMask, lir->operands[1] + i);
}
}
@@ -202,12 +202,12 @@
if (flags & REG_USE_FPCS_LIST2) {
for (int i = 0; i < lir->operands[2]; i++) {
- oatSetupRegMask(cUnit, &lir->useMask, lir->operands[1] + i);
+ SetupRegMask(cUnit, &lir->useMask, lir->operands[1] + i);
}
}
/* Fixup for kThumbPush/lr and kThumbPop/pc */
if (opcode == kThumbPush || opcode == kThumbPop) {
- uint64_t r8Mask = oatGetRegMaskCommon(cUnit, r8);
+ uint64_t r8Mask = GetRegMaskCommon(cUnit, r8);
if ((opcode == kThumbPush) && (lir->useMask & r8Mask)) {
lir->useMask &= ~r8Mask;
lir->useMask |= ENCODE_ARM_REG_LR;
@@ -221,7 +221,7 @@
}
}
-ArmConditionCode oatArmConditionEncoding(ConditionCode ccode)
+ArmConditionCode ArmConditionEncoding(ConditionCode ccode)
{
ArmConditionCode res;
switch (ccode) {
@@ -275,7 +275,7 @@
"ror"};
/* Decode and print a ARM register name */
-char* decodeRegList(int opcode, int vector, char* buf)
+char* DecodeRegList(int opcode, int vector, char* buf)
{
int i;
bool printed = false;
@@ -299,7 +299,7 @@
return buf;
}
-char* decodeFPCSRegList(int count, int base, char* buf)
+char* DecodeFPCSRegList(int count, int base, char* buf)
{
sprintf(buf, "s%d", base);
for (int i = 1; i < count; i++) {
@@ -308,7 +308,7 @@
return buf;
}
-int expandImmediate(int value)
+int ExpandImmediate(int value)
{
int mode = (value & 0xf00) >> 8;
uint32_t bits = value & 0xff;
@@ -334,7 +334,7 @@
* Interpret a format string and build a string no longer than size
* See format key in Assemble.c.
*/
-std::string buildInsnString(const char* fmt, LIR* lir, unsigned char* baseAddr)
+std::string BuildInsnString(const char* fmt, LIR* lir, unsigned char* baseAddr)
{
std::string buf;
int i;
@@ -396,11 +396,11 @@
}
break;
case 'n':
- operand = ~expandImmediate(operand);
+ operand = ~ExpandImmediate(operand);
sprintf(tbuf,"%d [%#x]", operand, operand);
break;
case 'm':
- operand = expandImmediate(operand);
+ operand = ExpandImmediate(operand);
sprintf(tbuf,"%d [%#x]", operand, operand);
break;
case 's':
@@ -452,13 +452,13 @@
strcpy(tbuf, "see above");
break;
case 'R':
- decodeRegList(lir->opcode, operand, tbuf);
+ DecodeRegList(lir->opcode, operand, tbuf);
break;
case 'P':
- decodeFPCSRegList(operand, 16, tbuf);
+ DecodeFPCSRegList(operand, 16, tbuf);
break;
case 'Q':
- decodeFPCSRegList(operand, 0, tbuf);
+ DecodeFPCSRegList(operand, 0, tbuf);
break;
default:
strcpy(tbuf,"DecodeError1");
@@ -473,7 +473,7 @@
return buf;
}
-void oatDumpResourceMask(LIR* armLIR, uint64_t mask, const char* prefix)
+void DumpResourceMask(LIR* armLIR, uint64_t mask, const char* prefix)
{
char buf[256];
buf[0] = 0;
@@ -519,13 +519,13 @@
}
}
-bool branchUnconditional(LIR* lir)
+bool BranchUnconditional(LIR* lir)
{
return ((lir->opcode == kThumbBUncond) || (lir->opcode == kThumb2BUncond));
}
/* Common initialization routine for an architecture family */
-bool oatArchInit()
+bool ArchInit()
{
int i;
@@ -537,19 +537,11 @@
}
}
- return oatArchVariantInit();
-}
-/*
- * Determine the initial instruction set to be used for this trace.
- * Later components may decide to change this.
- */
-InstructionSet oatInstructionSet()
-{
- return kThumb2;
+ return ArchVariantInit();
}
/* Architecture-specific initializations and checks go here */
-bool oatArchVariantInit(void)
+bool ArchVariantInit(void)
{
return true;
}
@@ -558,62 +550,62 @@
* Alloc a pair of core registers, or a double. Low reg in low byte,
* high reg in next byte.
*/
-int oatAllocTypedTempPair(CompilationUnit* cUnit, bool fpHint, int regClass)
+int AllocTypedTempPair(CompilationUnit* cUnit, bool fpHint, int regClass)
{
int highReg;
int lowReg;
int res = 0;
if (((regClass == kAnyReg) && fpHint) || (regClass == kFPReg)) {
- lowReg = oatAllocTempDouble(cUnit);
+ lowReg = AllocTempDouble(cUnit);
highReg = lowReg + 1;
} else {
- lowReg = oatAllocTemp(cUnit);
- highReg = oatAllocTemp(cUnit);
+ lowReg = AllocTemp(cUnit);
+ highReg = AllocTemp(cUnit);
}
res = (lowReg & 0xff) | ((highReg & 0xff) << 8);
return res;
}
-int oatAllocTypedTemp(CompilationUnit* cUnit, bool fpHint, int regClass)
+int AllocTypedTemp(CompilationUnit* cUnit, bool fpHint, int regClass)
{
if (((regClass == kAnyReg) && fpHint) || (regClass == kFPReg))
- return oatAllocTempFloat(cUnit);
- return oatAllocTemp(cUnit);
+ return AllocTempFloat(cUnit);
+ return AllocTemp(cUnit);
}
-void oatInitializeRegAlloc(CompilationUnit* cUnit)
+void CompilerInitializeRegAlloc(CompilationUnit* cUnit)
{
int numRegs = sizeof(coreRegs)/sizeof(*coreRegs);
- int numReserved = sizeof(reservedRegs)/sizeof(*reservedRegs);
+ int numReserved = sizeof(ReservedRegs)/sizeof(*ReservedRegs);
int numTemps = sizeof(coreTemps)/sizeof(*coreTemps);
- int numFPRegs = sizeof(fpRegs)/sizeof(*fpRegs);
+ int numFPRegs = sizeof(FpRegs)/sizeof(*FpRegs);
int numFPTemps = sizeof(fpTemps)/sizeof(*fpTemps);
RegisterPool *pool =
- static_cast<RegisterPool*>(oatNew(cUnit, sizeof(*pool), true, kAllocRegAlloc));
+ static_cast<RegisterPool*>(NewMem(cUnit, sizeof(*pool), true, kAllocRegAlloc));
cUnit->regPool = pool;
pool->numCoreRegs = numRegs;
pool->coreRegs = reinterpret_cast<RegisterInfo*>
- (oatNew(cUnit, numRegs * sizeof(*cUnit->regPool->coreRegs), true, kAllocRegAlloc));
+ (NewMem(cUnit, numRegs * sizeof(*cUnit->regPool->coreRegs), true, kAllocRegAlloc));
pool->numFPRegs = numFPRegs;
pool->FPRegs = static_cast<RegisterInfo*>
- (oatNew(cUnit, numFPRegs * sizeof(*cUnit->regPool->FPRegs), true, kAllocRegAlloc));
- oatInitPool(pool->coreRegs, coreRegs, pool->numCoreRegs);
- oatInitPool(pool->FPRegs, fpRegs, pool->numFPRegs);
+ (NewMem(cUnit, numFPRegs * sizeof(*cUnit->regPool->FPRegs), true, kAllocRegAlloc));
+ CompilerInitPool(pool->coreRegs, coreRegs, pool->numCoreRegs);
+ CompilerInitPool(pool->FPRegs, FpRegs, pool->numFPRegs);
// Keep special registers from being allocated
for (int i = 0; i < numReserved; i++) {
- if (NO_SUSPEND && (reservedRegs[i] == rARM_SUSPEND)) {
+ if (NO_SUSPEND && (ReservedRegs[i] == rARM_SUSPEND)) {
//To measure cost of suspend check
continue;
}
- oatMarkInUse(cUnit, reservedRegs[i]);
+ MarkInUse(cUnit, ReservedRegs[i]);
}
// Mark temp regs - all others not in use can be used for promotion
for (int i = 0; i < numTemps; i++) {
- oatMarkTemp(cUnit, coreTemps[i]);
+ MarkTemp(cUnit, coreTemps[i]);
}
for (int i = 0; i < numFPTemps; i++) {
- oatMarkTemp(cUnit, fpTemps[i]);
+ MarkTemp(cUnit, fpTemps[i]);
}
// Start allocation at r2 in an attempt to avoid clobbering return values
@@ -621,7 +613,7 @@
// Construct the alias map.
cUnit->phiAliasMap = static_cast<int*>
- (oatNew(cUnit, cUnit->numSSARegs * sizeof(cUnit->phiAliasMap[0]), false, kAllocDFInfo));
+ (NewMem(cUnit, cUnit->numSSARegs * sizeof(cUnit->phiAliasMap[0]), false, kAllocDFInfo));
for (int i = 0; i < cUnit->numSSARegs; i++) {
cUnit->phiAliasMap[i] = i;
}
@@ -637,14 +629,14 @@
}
}
-void freeRegLocTemps(CompilationUnit* cUnit, RegLocation rlKeep,
+void FreeRegLocTemps(CompilationUnit* cUnit, RegLocation rlKeep,
RegLocation rlFree)
{
if ((rlFree.lowReg != rlKeep.lowReg) && (rlFree.lowReg != rlKeep.highReg) &&
(rlFree.highReg != rlKeep.lowReg) && (rlFree.highReg != rlKeep.highReg)) {
// No overlap, free both
- oatFreeTemp(cUnit, rlFree.lowReg);
- oatFreeTemp(cUnit, rlFree.highReg);
+ FreeTemp(cUnit, rlFree.lowReg);
+ FreeTemp(cUnit, rlFree.highReg);
}
}
/*
@@ -653,7 +645,7 @@
* machinery is in place, always spill lr.
*/
-void oatAdjustSpillMask(CompilationUnit* cUnit)
+void AdjustSpillMask(CompilationUnit* cUnit)
{
cUnit->coreSpillMask |= (1 << rARM_LR);
cUnit->numCoreSpills++;
@@ -665,7 +657,7 @@
* include any holes in the mask. Associate holes with
* Dalvik register INVALID_VREG (0xFFFFU).
*/
-void oatMarkPreservedSingle(CompilationUnit* cUnit, int vReg, int reg)
+void MarkPreservedSingle(CompilationUnit* cUnit, int vReg, int reg)
{
DCHECK_GE(reg, ARM_FP_REG_MASK + ARM_FP_CALLEE_SAVE_BASE);
reg = (reg & ARM_FP_REG_MASK) - ARM_FP_CALLEE_SAVE_BASE;
@@ -681,10 +673,10 @@
cUnit->fpSpillMask = ((1 << cUnit->numFPSpills) - 1) << ARM_FP_CALLEE_SAVE_BASE;
}
-void oatFlushRegWide(CompilationUnit* cUnit, int reg1, int reg2)
+void FlushRegWide(CompilationUnit* cUnit, int reg1, int reg2)
{
- RegisterInfo* info1 = oatGetRegInfo(cUnit, reg1);
- RegisterInfo* info2 = oatGetRegInfo(cUnit, reg2);
+ RegisterInfo* info1 = GetRegInfo(cUnit, reg1);
+ RegisterInfo* info2 = GetRegInfo(cUnit, reg2);
DCHECK(info1 && info2 && info1->pair && info2->pair &&
(info1->partner == info2->reg) &&
(info2->partner == info1->reg));
@@ -700,119 +692,115 @@
SRegToVReg(cUnit, info1->sReg))
info1 = info2;
int vReg = SRegToVReg(cUnit, info1->sReg);
- storeBaseDispWide(cUnit, rARM_SP, oatVRegOffset(cUnit, vReg), info1->reg, info1->partner);
+ StoreBaseDispWide(cUnit, rARM_SP, VRegOffset(cUnit, vReg), info1->reg, info1->partner);
}
}
-void oatFlushReg(CompilationUnit* cUnit, int reg)
+void FlushReg(CompilationUnit* cUnit, int reg)
{
- RegisterInfo* info = oatGetRegInfo(cUnit, reg);
+ RegisterInfo* info = GetRegInfo(cUnit, reg);
if (info->live && info->dirty) {
info->dirty = false;
int vReg = SRegToVReg(cUnit, info->sReg);
- storeBaseDisp(cUnit, rARM_SP, oatVRegOffset(cUnit, vReg), reg, kWord);
+ StoreBaseDisp(cUnit, rARM_SP, VRegOffset(cUnit, vReg), reg, kWord);
}
}
/* Give access to the target-dependent FP register encoding to common code */
-bool oatIsFpReg(int reg) {
+bool IsFpReg(int reg) {
return ARM_FPREG(reg);
}
-uint32_t oatFpRegMask() {
- return ARM_FP_REG_MASK;
-}
-
/* Clobber all regs that might be used by an external C call */
-void oatClobberCalleeSave(CompilationUnit *cUnit)
+void ClobberCalleeSave(CompilationUnit *cUnit)
{
- oatClobber(cUnit, r0);
- oatClobber(cUnit, r1);
- oatClobber(cUnit, r2);
- oatClobber(cUnit, r3);
- oatClobber(cUnit, r12);
- oatClobber(cUnit, r14lr);
- oatClobber(cUnit, fr0);
- oatClobber(cUnit, fr1);
- oatClobber(cUnit, fr2);
- oatClobber(cUnit, fr3);
- oatClobber(cUnit, fr4);
- oatClobber(cUnit, fr5);
- oatClobber(cUnit, fr6);
- oatClobber(cUnit, fr7);
- oatClobber(cUnit, fr8);
- oatClobber(cUnit, fr9);
- oatClobber(cUnit, fr10);
- oatClobber(cUnit, fr11);
- oatClobber(cUnit, fr12);
- oatClobber(cUnit, fr13);
- oatClobber(cUnit, fr14);
- oatClobber(cUnit, fr15);
+ Clobber(cUnit, r0);
+ Clobber(cUnit, r1);
+ Clobber(cUnit, r2);
+ Clobber(cUnit, r3);
+ Clobber(cUnit, r12);
+ Clobber(cUnit, r14lr);
+ Clobber(cUnit, fr0);
+ Clobber(cUnit, fr1);
+ Clobber(cUnit, fr2);
+ Clobber(cUnit, fr3);
+ Clobber(cUnit, fr4);
+ Clobber(cUnit, fr5);
+ Clobber(cUnit, fr6);
+ Clobber(cUnit, fr7);
+ Clobber(cUnit, fr8);
+ Clobber(cUnit, fr9);
+ Clobber(cUnit, fr10);
+ Clobber(cUnit, fr11);
+ Clobber(cUnit, fr12);
+ Clobber(cUnit, fr13);
+ Clobber(cUnit, fr14);
+ Clobber(cUnit, fr15);
}
-extern RegLocation oatGetReturnWideAlt(CompilationUnit* cUnit)
+extern RegLocation GetReturnWideAlt(CompilationUnit* cUnit)
{
- RegLocation res = locCReturnWide();
+ RegLocation res = LocCReturnWide();
res.lowReg = r2;
res.highReg = r3;
- oatClobber(cUnit, r2);
- oatClobber(cUnit, r3);
- oatMarkInUse(cUnit, r2);
- oatMarkInUse(cUnit, r3);
- oatMarkPair(cUnit, res.lowReg, res.highReg);
+ Clobber(cUnit, r2);
+ Clobber(cUnit, r3);
+ MarkInUse(cUnit, r2);
+ MarkInUse(cUnit, r3);
+ MarkPair(cUnit, res.lowReg, res.highReg);
return res;
}
-extern RegLocation oatGetReturnAlt(CompilationUnit* cUnit)
+extern RegLocation GetReturnAlt(CompilationUnit* cUnit)
{
- RegLocation res = locCReturn();
+ RegLocation res = LocCReturn();
res.lowReg = r1;
- oatClobber(cUnit, r1);
- oatMarkInUse(cUnit, r1);
+ Clobber(cUnit, r1);
+ MarkInUse(cUnit, r1);
return res;
}
-extern RegisterInfo* oatGetRegInfo(CompilationUnit* cUnit, int reg)
+extern RegisterInfo* GetRegInfo(CompilationUnit* cUnit, int reg)
{
return ARM_FPREG(reg) ? &cUnit->regPool->FPRegs[reg & ARM_FP_REG_MASK]
: &cUnit->regPool->coreRegs[reg];
}
/* To be used when explicitly managing register use */
-extern void oatLockCallTemps(CompilationUnit* cUnit)
+extern void LockCallTemps(CompilationUnit* cUnit)
{
- oatLockTemp(cUnit, r0);
- oatLockTemp(cUnit, r1);
- oatLockTemp(cUnit, r2);
- oatLockTemp(cUnit, r3);
+ LockTemp(cUnit, r0);
+ LockTemp(cUnit, r1);
+ LockTemp(cUnit, r2);
+ LockTemp(cUnit, r3);
}
/* To be used when explicitly managing register use */
-extern void oatFreeCallTemps(CompilationUnit* cUnit)
+extern void FreeCallTemps(CompilationUnit* cUnit)
{
- oatFreeTemp(cUnit, r0);
- oatFreeTemp(cUnit, r1);
- oatFreeTemp(cUnit, r2);
- oatFreeTemp(cUnit, r3);
+ FreeTemp(cUnit, r0);
+ FreeTemp(cUnit, r1);
+ FreeTemp(cUnit, r2);
+ FreeTemp(cUnit, r3);
}
-int loadHelper(CompilationUnit* cUnit, int offset)
+int LoadHelper(CompilationUnit* cUnit, int offset)
{
- loadWordDisp(cUnit, rARM_SELF, offset, rARM_LR);
+ LoadWordDisp(cUnit, rARM_SELF, offset, rARM_LR);
return rARM_LR;
}
-uint64_t getTargetInstFlags(int opcode)
+uint64_t GetTargetInstFlags(int opcode)
{
return EncodingMap[opcode].flags;
}
-const char* getTargetInstName(int opcode)
+const char* GetTargetInstName(int opcode)
{
return EncodingMap[opcode].name;
}
-const char* getTargetInstFmt(int opcode)
+const char* GetTargetInstFmt(int opcode)
{
return EncodingMap[opcode].fmt;
}
diff --git a/src/compiler/codegen/arm/utility_arm.cc b/src/compiler/codegen/arm/utility_arm.cc
index 35f4a2d..1c8ea89 100644
--- a/src/compiler/codegen/arm/utility_arm.cc
+++ b/src/compiler/codegen/arm/utility_arm.cc
@@ -22,7 +22,7 @@
/* This file contains codegen for the Thumb ISA. */
-int encodeImmSingle(int value)
+int EncodeImmSingle(int value)
{
int res;
int bitA = (value & 0x80000000) >> 31;
@@ -44,26 +44,26 @@
return res;
}
-LIR* loadFPConstantValue(CompilationUnit* cUnit, int rDest, int value)
+LIR* LoadFPConstantValue(CompilationUnit* cUnit, int rDest, int value)
{
- int encodedImm = encodeImmSingle(value);
+ int encodedImm = EncodeImmSingle(value);
DCHECK(ARM_SINGLEREG(rDest));
if (encodedImm >= 0) {
- return newLIR2(cUnit, kThumb2Vmovs_IMM8, rDest, encodedImm);
+ return NewLIR2(cUnit, kThumb2Vmovs_IMM8, rDest, encodedImm);
}
- LIR* dataTarget = scanLiteralPool(cUnit->literalList, value, 0);
+ LIR* dataTarget = ScanLiteralPool(cUnit->literalList, value, 0);
if (dataTarget == NULL) {
- dataTarget = addWordData(cUnit, &cUnit->literalList, value);
+ dataTarget = AddWordData(cUnit, &cUnit->literalList, value);
}
- LIR* loadPcRel = rawLIR(cUnit, cUnit->currentDalvikOffset, kThumb2Vldrs,
+ LIR* loadPcRel = RawLIR(cUnit, cUnit->currentDalvikOffset, kThumb2Vldrs,
rDest, r15pc, 0, 0, 0, dataTarget);
- setMemRefType(loadPcRel, true, kLiteral);
+ SetMemRefType(loadPcRel, true, kLiteral);
loadPcRel->aliasInfo = reinterpret_cast<uintptr_t>(dataTarget);
- oatAppendLIR(cUnit, loadPcRel);
+ AppendLIR(cUnit, loadPcRel);
return loadPcRel;
}
-int leadingZeros(uint32_t val)
+int LeadingZeros(uint32_t val)
{
uint32_t alt;
int n;
@@ -86,7 +86,7 @@
* Determine whether value can be encoded as a Thumb2 modified
* immediate. If not, return -1. If so, return i:imm3:a:bcdefgh form.
*/
-int modifiedImmediate(uint32_t value)
+int ModifiedImmediate(uint32_t value)
{
int zLeading;
int zTrailing;
@@ -103,8 +103,8 @@
if (value == ((b0 << 24) | (b0 << 8)))
return (0x2 << 8) | b0; /* 0:010:a:bcdefgh */
/* Can we do it with rotation? */
- zLeading = leadingZeros(value);
- zTrailing = 32 - leadingZeros(~value & (value - 1));
+ zLeading = LeadingZeros(value);
+ zTrailing = 32 - LeadingZeros(~value & (value - 1));
/* A run of eight or fewer active bits? */
if ((zLeading + zTrailing) < 24)
return -1; /* No - bail */
@@ -121,75 +121,75 @@
* grab from the per-translation literal pool.
*
* No additional register clobbering operation performed. Use this version when
- * 1) rDest is freshly returned from oatAllocTemp or
+ * 1) rDest is freshly returned from AllocTemp or
* 2) The codegen is under fixed register usage
*/
-LIR* loadConstantNoClobber(CompilationUnit* cUnit, int rDest, int value)
+LIR* LoadConstantNoClobber(CompilationUnit* cUnit, int rDest, int value)
{
LIR* res;
int modImm;
if (ARM_FPREG(rDest)) {
- return loadFPConstantValue(cUnit, rDest, value);
+ return LoadFPConstantValue(cUnit, rDest, value);
}
/* See if the value can be constructed cheaply */
if (ARM_LOWREG(rDest) && (value >= 0) && (value <= 255)) {
- return newLIR2(cUnit, kThumbMovImm, rDest, value);
+ return NewLIR2(cUnit, kThumbMovImm, rDest, value);
}
/* Check Modified immediate special cases */
- modImm = modifiedImmediate(value);
+ modImm = ModifiedImmediate(value);
if (modImm >= 0) {
- res = newLIR2(cUnit, kThumb2MovImmShift, rDest, modImm);
+ res = NewLIR2(cUnit, kThumb2MovImmShift, rDest, modImm);
return res;
}
- modImm = modifiedImmediate(~value);
+ modImm = ModifiedImmediate(~value);
if (modImm >= 0) {
- res = newLIR2(cUnit, kThumb2MvnImm12, rDest, modImm);
+ res = NewLIR2(cUnit, kThumb2MvnImm12, rDest, modImm);
return res;
}
/* 16-bit immediate? */
if ((value & 0xffff) == value) {
- res = newLIR2(cUnit, kThumb2MovImm16, rDest, value);
+ res = NewLIR2(cUnit, kThumb2MovImm16, rDest, value);
return res;
}
/* No shortcut - go ahead and use literal pool */
- LIR* dataTarget = scanLiteralPool(cUnit->literalList, value, 0);
+ LIR* dataTarget = ScanLiteralPool(cUnit->literalList, value, 0);
if (dataTarget == NULL) {
- dataTarget = addWordData(cUnit, &cUnit->literalList, value);
+ dataTarget = AddWordData(cUnit, &cUnit->literalList, value);
}
- LIR* loadPcRel = rawLIR(cUnit, cUnit->currentDalvikOffset,
+ LIR* loadPcRel = RawLIR(cUnit, cUnit->currentDalvikOffset,
kThumb2LdrPcRel12, rDest, 0, 0, 0, 0, dataTarget);
- setMemRefType(loadPcRel, true, kLiteral);
+ SetMemRefType(loadPcRel, true, kLiteral);
loadPcRel->aliasInfo = reinterpret_cast<uintptr_t>(dataTarget);
res = loadPcRel;
- oatAppendLIR(cUnit, loadPcRel);
+ AppendLIR(cUnit, loadPcRel);
/*
* To save space in the constant pool, we use the ADD_RRI8 instruction to
* add up to 255 to an existing constant value.
*/
if (dataTarget->operands[0] != value) {
- opRegImm(cUnit, kOpAdd, rDest, value - dataTarget->operands[0]);
+ OpRegImm(cUnit, kOpAdd, rDest, value - dataTarget->operands[0]);
}
return res;
}
-LIR* opBranchUnconditional(CompilationUnit* cUnit, OpKind op)
+LIR* OpBranchUnconditional(CompilationUnit* cUnit, OpKind op)
{
DCHECK_EQ(op, kOpUncondBr);
- return newLIR1(cUnit, kThumbBUncond, 0 /* offset to be patched */);
+ return NewLIR1(cUnit, kThumbBUncond, 0 /* offset to be patched */);
}
-LIR* opCondBranch(CompilationUnit* cUnit, ConditionCode cc, LIR* target)
+LIR* OpCondBranch(CompilationUnit* cUnit, ConditionCode cc, LIR* target)
{
- LIR* branch = newLIR2(cUnit, kThumb2BCond, 0 /* offset to be patched */,
- oatArmConditionEncoding(cc));
+ LIR* branch = NewLIR2(cUnit, kThumb2BCond, 0 /* offset to be patched */,
+ ArmConditionEncoding(cc));
branch->target = target;
return branch;
}
-LIR* opReg(CompilationUnit* cUnit, OpKind op, int rDestSrc)
+LIR* OpReg(CompilationUnit* cUnit, OpKind op, int rDestSrc)
{
ArmOpcode opcode = kThumbBkpt;
switch (op) {
@@ -199,10 +199,10 @@
default:
LOG(FATAL) << "Bad opcode " << op;
}
- return newLIR1(cUnit, opcode, rDestSrc);
+ return NewLIR1(cUnit, opcode, rDestSrc);
}
-LIR* opRegRegShift(CompilationUnit* cUnit, OpKind op, int rDestSrc1,
+LIR* OpRegRegShift(CompilationUnit* cUnit, OpKind op, int rDestSrc1,
int rSrc2, int shift)
{
bool thumbForm = ((shift == 0) && ARM_LOWREG(rDestSrc1) && ARM_LOWREG(rSrc2));
@@ -291,39 +291,39 @@
break;
case kOp2Byte:
DCHECK_EQ(shift, 0);
- return newLIR4(cUnit, kThumb2Sbfx, rDestSrc1, rSrc2, 0, 8);
+ return NewLIR4(cUnit, kThumb2Sbfx, rDestSrc1, rSrc2, 0, 8);
case kOp2Short:
DCHECK_EQ(shift, 0);
- return newLIR4(cUnit, kThumb2Sbfx, rDestSrc1, rSrc2, 0, 16);
+ return NewLIR4(cUnit, kThumb2Sbfx, rDestSrc1, rSrc2, 0, 16);
case kOp2Char:
DCHECK_EQ(shift, 0);
- return newLIR4(cUnit, kThumb2Ubfx, rDestSrc1, rSrc2, 0, 16);
+ return NewLIR4(cUnit, kThumb2Ubfx, rDestSrc1, rSrc2, 0, 16);
default:
LOG(FATAL) << "Bad opcode: " << op;
break;
}
DCHECK_GE(static_cast<int>(opcode), 0);
if (EncodingMap[opcode].flags & IS_BINARY_OP)
- return newLIR2(cUnit, opcode, rDestSrc1, rSrc2);
+ return NewLIR2(cUnit, opcode, rDestSrc1, rSrc2);
else if (EncodingMap[opcode].flags & IS_TERTIARY_OP) {
if (EncodingMap[opcode].fieldLoc[2].kind == kFmtShift)
- return newLIR3(cUnit, opcode, rDestSrc1, rSrc2, shift);
+ return NewLIR3(cUnit, opcode, rDestSrc1, rSrc2, shift);
else
- return newLIR3(cUnit, opcode, rDestSrc1, rDestSrc1, rSrc2);
+ return NewLIR3(cUnit, opcode, rDestSrc1, rDestSrc1, rSrc2);
} else if (EncodingMap[opcode].flags & IS_QUAD_OP)
- return newLIR4(cUnit, opcode, rDestSrc1, rDestSrc1, rSrc2, shift);
+ return NewLIR4(cUnit, opcode, rDestSrc1, rDestSrc1, rSrc2, shift);
else {
LOG(FATAL) << "Unexpected encoding operand count";
return NULL;
}
}
-LIR* opRegReg(CompilationUnit* cUnit, OpKind op, int rDestSrc1, int rSrc2)
+LIR* OpRegReg(CompilationUnit* cUnit, OpKind op, int rDestSrc1, int rSrc2)
{
- return opRegRegShift(cUnit, op, rDestSrc1, rSrc2, 0);
+ return OpRegRegShift(cUnit, op, rDestSrc1, rSrc2, 0);
}
-LIR* opRegRegRegShift(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1,
+LIR* OpRegRegRegShift(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1,
int rSrc2, int shift)
{
ArmOpcode opcode = kThumbBkpt;
@@ -383,20 +383,20 @@
}
DCHECK_GE(static_cast<int>(opcode), 0);
if (EncodingMap[opcode].flags & IS_QUAD_OP)
- return newLIR4(cUnit, opcode, rDest, rSrc1, rSrc2, shift);
+ return NewLIR4(cUnit, opcode, rDest, rSrc1, rSrc2, shift);
else {
DCHECK(EncodingMap[opcode].flags & IS_TERTIARY_OP);
- return newLIR3(cUnit, opcode, rDest, rSrc1, rSrc2);
+ return NewLIR3(cUnit, opcode, rDest, rSrc1, rSrc2);
}
}
-LIR* opRegRegReg(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1,
+LIR* OpRegRegReg(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1,
int rSrc2)
{
- return opRegRegRegShift(cUnit, op, rDest, rSrc1, rSrc2, 0);
+ return OpRegRegRegShift(cUnit, op, rDest, rSrc1, rSrc2, 0);
}
-LIR* opRegRegImm(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1,
+LIR* OpRegRegImm(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1,
int value)
{
LIR* res;
@@ -405,34 +405,34 @@
ArmOpcode opcode = kThumbBkpt;
ArmOpcode altOpcode = kThumbBkpt;
bool allLowRegs = (ARM_LOWREG(rDest) && ARM_LOWREG(rSrc1));
- int modImm = modifiedImmediate(value);
- int modImmNeg = modifiedImmediate(-value);
+ int modImm = ModifiedImmediate(value);
+ int modImmNeg = ModifiedImmediate(-value);
switch (op) {
case kOpLsl:
if (allLowRegs)
- return newLIR3(cUnit, kThumbLslRRI5, rDest, rSrc1, value);
+ return NewLIR3(cUnit, kThumbLslRRI5, rDest, rSrc1, value);
else
- return newLIR3(cUnit, kThumb2LslRRI5, rDest, rSrc1, value);
+ return NewLIR3(cUnit, kThumb2LslRRI5, rDest, rSrc1, value);
case kOpLsr:
if (allLowRegs)
- return newLIR3(cUnit, kThumbLsrRRI5, rDest, rSrc1, value);
+ return NewLIR3(cUnit, kThumbLsrRRI5, rDest, rSrc1, value);
else
- return newLIR3(cUnit, kThumb2LsrRRI5, rDest, rSrc1, value);
+ return NewLIR3(cUnit, kThumb2LsrRRI5, rDest, rSrc1, value);
case kOpAsr:
if (allLowRegs)
- return newLIR3(cUnit, kThumbAsrRRI5, rDest, rSrc1, value);
+ return NewLIR3(cUnit, kThumbAsrRRI5, rDest, rSrc1, value);
else
- return newLIR3(cUnit, kThumb2AsrRRI5, rDest, rSrc1, value);
+ return NewLIR3(cUnit, kThumb2AsrRRI5, rDest, rSrc1, value);
case kOpRor:
- return newLIR3(cUnit, kThumb2RorRRI5, rDest, rSrc1, value);
+ return NewLIR3(cUnit, kThumb2RorRRI5, rDest, rSrc1, value);
case kOpAdd:
if (ARM_LOWREG(rDest) && (rSrc1 == r13sp) &&
(value <= 1020) && ((value & 0x3)==0)) {
- return newLIR3(cUnit, kThumbAddSpRel, rDest, rSrc1, value >> 2);
+ return NewLIR3(cUnit, kThumbAddSpRel, rDest, rSrc1, value >> 2);
} else if (ARM_LOWREG(rDest) && (rSrc1 == r15pc) &&
(value <= 1020) && ((value & 0x3)==0)) {
- return newLIR3(cUnit, kThumbAddPcRel, rDest, rSrc1, value >> 2);
+ return NewLIR3(cUnit, kThumbAddPcRel, rDest, rSrc1, value >> 2);
}
// Note: intentional fallthrough
case kOpSub:
@@ -441,13 +441,13 @@
opcode = (neg) ? kThumbSubRRI3 : kThumbAddRRI3;
else
opcode = (neg) ? kThumbAddRRI3 : kThumbSubRRI3;
- return newLIR3(cUnit, opcode, rDest, rSrc1, absValue);
+ return NewLIR3(cUnit, opcode, rDest, rSrc1, absValue);
} else if ((absValue & 0xff) == absValue) {
if (op == kOpAdd)
opcode = (neg) ? kThumb2SubRRI12 : kThumb2AddRRI12;
else
opcode = (neg) ? kThumb2AddRRI12 : kThumb2SubRRI12;
- return newLIR3(cUnit, opcode, rDest, rSrc1, absValue);
+ return NewLIR3(cUnit, opcode, rDest, rSrc1, absValue);
}
if (modImmNeg >= 0) {
op = (op == kOpAdd) ? kOpSub : kOpAdd;
@@ -487,15 +487,15 @@
altOpcode = kThumb2MulRRR;
break;
case kOpCmp: {
- int modImm = modifiedImmediate(value);
+ int modImm = ModifiedImmediate(value);
LIR* res;
if (modImm >= 0) {
- res = newLIR2(cUnit, kThumb2CmpRI8, rSrc1, modImm);
+ res = NewLIR2(cUnit, kThumb2CmpRI8, rSrc1, modImm);
} else {
- int rTmp = oatAllocTemp(cUnit);
- res = loadConstant(cUnit, rTmp, value);
- opRegReg(cUnit, kOpCmp, rSrc1, rTmp);
- oatFreeTemp(cUnit, rTmp);
+ int rTmp = AllocTemp(cUnit);
+ res = LoadConstant(cUnit, rTmp, value);
+ OpRegReg(cUnit, kOpCmp, rSrc1, rTmp);
+ FreeTemp(cUnit, rTmp);
}
return res;
}
@@ -504,21 +504,21 @@
}
if (modImm >= 0) {
- return newLIR3(cUnit, opcode, rDest, rSrc1, modImm);
+ return NewLIR3(cUnit, opcode, rDest, rSrc1, modImm);
} else {
- int rScratch = oatAllocTemp(cUnit);
- loadConstant(cUnit, rScratch, value);
+ int rScratch = AllocTemp(cUnit);
+ LoadConstant(cUnit, rScratch, value);
if (EncodingMap[altOpcode].flags & IS_QUAD_OP)
- res = newLIR4(cUnit, altOpcode, rDest, rSrc1, rScratch, 0);
+ res = NewLIR4(cUnit, altOpcode, rDest, rSrc1, rScratch, 0);
else
- res = newLIR3(cUnit, altOpcode, rDest, rSrc1, rScratch);
- oatFreeTemp(cUnit, rScratch);
+ res = NewLIR3(cUnit, altOpcode, rDest, rSrc1, rScratch);
+ FreeTemp(cUnit, rScratch);
return res;
}
}
-/* Handle Thumb-only variants here - otherwise punt to opRegRegImm */
-LIR* opRegImm(CompilationUnit* cUnit, OpKind op, int rDestSrc1, int value)
+/* Handle Thumb-only variants here - otherwise punt to OpRegRegImm */
+LIR* OpRegImm(CompilationUnit* cUnit, OpKind op, int rDestSrc1, int value)
{
bool neg = (value < 0);
int absValue = (neg) ? -value : value;
@@ -528,7 +528,7 @@
case kOpAdd:
if ( !neg && (rDestSrc1 == r13sp) && (value <= 508)) { /* sp */
DCHECK_EQ((value & 0x3), 0);
- return newLIR1(cUnit, kThumbAddSpI7, value >> 2);
+ return NewLIR1(cUnit, kThumbAddSpI7, value >> 2);
} else if (shortForm) {
opcode = (neg) ? kThumbSubRI8 : kThumbAddRI8;
}
@@ -536,7 +536,7 @@
case kOpSub:
if (!neg && (rDestSrc1 == r13sp) && (value <= 508)) { /* sp */
DCHECK_EQ((value & 0x3), 0);
- return newLIR1(cUnit, kThumbSubSpI7, value >> 2);
+ return NewLIR1(cUnit, kThumbSubSpI7, value >> 2);
} else if (shortForm) {
opcode = (neg) ? kThumbAddRI8 : kThumbSubRI8;
}
@@ -552,14 +552,14 @@
}
break;
default:
- /* Punt to opRegRegImm - if bad case catch it there */
+ /* Punt to OpRegRegImm - if bad case catch it there */
shortForm = false;
break;
}
if (shortForm)
- return newLIR2(cUnit, opcode, rDestSrc1, absValue);
+ return NewLIR2(cUnit, opcode, rDestSrc1, absValue);
else {
- return opRegRegImm(cUnit, op, rDestSrc1, rDestSrc1, value);
+ return OpRegRegImm(cUnit, op, rDestSrc1, rDestSrc1, value);
}
}
@@ -567,7 +567,7 @@
* Determine whether value can be encoded as a Thumb2 floating point
* immediate. If not, return -1. If so return encoded 8-bit value.
*/
-int encodeImmDoubleHigh(int value)
+int EncodeImmDoubleHigh(int value)
{
int res;
int bitA = (value & 0x80000000) >> 31;
@@ -589,48 +589,48 @@
return res;
}
-int encodeImmDouble(int valLo, int valHi)
+int EncodeImmDouble(int valLo, int valHi)
{
int res = -1;
if (valLo == 0)
- res = encodeImmDoubleHigh(valHi);
+ res = EncodeImmDoubleHigh(valHi);
return res;
}
-LIR* loadConstantValueWide(CompilationUnit* cUnit, int rDestLo, int rDestHi,
+LIR* LoadConstantValueWide(CompilationUnit* cUnit, int rDestLo, int rDestHi,
int valLo, int valHi)
{
- int encodedImm = encodeImmDouble(valLo, valHi);
+ int encodedImm = EncodeImmDouble(valLo, valHi);
LIR* res;
if (ARM_FPREG(rDestLo)) {
if (encodedImm >= 0) {
- res = newLIR2(cUnit, kThumb2Vmovd_IMM8, s2d(rDestLo, rDestHi),
+ res = NewLIR2(cUnit, kThumb2Vmovd_IMM8, S2d(rDestLo, rDestHi),
encodedImm);
} else {
- LIR* dataTarget = scanLiteralPoolWide(cUnit->literalList, valLo, valHi);
+ LIR* dataTarget = ScanLiteralPoolWide(cUnit->literalList, valLo, valHi);
if (dataTarget == NULL) {
- dataTarget = addWideData(cUnit, &cUnit->literalList, valLo, valHi);
+ dataTarget = AddWideData(cUnit, &cUnit->literalList, valLo, valHi);
}
LIR* loadPcRel =
- rawLIR(cUnit, cUnit->currentDalvikOffset, kThumb2Vldrd,
- s2d(rDestLo, rDestHi), r15pc, 0, 0, 0, dataTarget);
- setMemRefType(loadPcRel, true, kLiteral);
+ RawLIR(cUnit, cUnit->currentDalvikOffset, kThumb2Vldrd,
+ S2d(rDestLo, rDestHi), r15pc, 0, 0, 0, dataTarget);
+ SetMemRefType(loadPcRel, true, kLiteral);
loadPcRel->aliasInfo = reinterpret_cast<uintptr_t>(dataTarget);
- oatAppendLIR(cUnit, loadPcRel);
+ AppendLIR(cUnit, loadPcRel);
res = loadPcRel;
}
} else {
- res = loadConstantNoClobber(cUnit, rDestLo, valLo);
- loadConstantNoClobber(cUnit, rDestHi, valHi);
+ res = LoadConstantNoClobber(cUnit, rDestLo, valLo);
+ LoadConstantNoClobber(cUnit, rDestHi, valHi);
}
return res;
}
-int encodeShift(int code, int amount) {
+int EncodeShift(int code, int amount) {
return ((amount & 0x1f) << 2) | code;
}
-LIR* loadBaseIndexed(CompilationUnit* cUnit, int rBase, int rIndex, int rDest,
+LIR* LoadBaseIndexed(CompilationUnit* cUnit, int rBase, int rIndex, int rDest,
int scale, OpSize size)
{
bool allLowRegs = ARM_LOWREG(rBase) && ARM_LOWREG(rIndex) && ARM_LOWREG(rDest);
@@ -659,15 +659,15 @@
switch (size) {
case kDouble: // fall-through
case kSingle:
- regPtr = oatAllocTemp(cUnit);
+ regPtr = AllocTemp(cUnit);
if (scale) {
- newLIR4(cUnit, kThumb2AddRRR, regPtr, rBase, rIndex,
- encodeShift(kArmLsl, scale));
+ NewLIR4(cUnit, kThumb2AddRRR, regPtr, rBase, rIndex,
+ EncodeShift(kArmLsl, scale));
} else {
- opRegRegReg(cUnit, kOpAdd, regPtr, rBase, rIndex);
+ OpRegRegReg(cUnit, kOpAdd, regPtr, rBase, rIndex);
}
- load = newLIR3(cUnit, opcode, rDest, regPtr, 0);
- oatFreeTemp(cUnit, regPtr);
+ load = NewLIR3(cUnit, opcode, rDest, regPtr, 0);
+ FreeTemp(cUnit, regPtr);
return load;
case kWord:
opcode = (thumbForm) ? kThumbLdrRRR : kThumb2LdrRRR;
@@ -688,14 +688,14 @@
LOG(FATAL) << "Bad size: " << size;
}
if (thumbForm)
- load = newLIR3(cUnit, opcode, rDest, rBase, rIndex);
+ load = NewLIR3(cUnit, opcode, rDest, rBase, rIndex);
else
- load = newLIR4(cUnit, opcode, rDest, rBase, rIndex, scale);
+ load = NewLIR4(cUnit, opcode, rDest, rBase, rIndex, scale);
return load;
}
-LIR* storeBaseIndexed(CompilationUnit* cUnit, int rBase, int rIndex, int rSrc,
+LIR* StoreBaseIndexed(CompilationUnit* cUnit, int rBase, int rIndex, int rSrc,
int scale, OpSize size)
{
bool allLowRegs = ARM_LOWREG(rBase) && ARM_LOWREG(rIndex) && ARM_LOWREG(rSrc);
@@ -724,15 +724,15 @@
switch (size) {
case kDouble: // fall-through
case kSingle:
- regPtr = oatAllocTemp(cUnit);
+ regPtr = AllocTemp(cUnit);
if (scale) {
- newLIR4(cUnit, kThumb2AddRRR, regPtr, rBase, rIndex,
- encodeShift(kArmLsl, scale));
+ NewLIR4(cUnit, kThumb2AddRRR, regPtr, rBase, rIndex,
+ EncodeShift(kArmLsl, scale));
} else {
- opRegRegReg(cUnit, kOpAdd, regPtr, rBase, rIndex);
+ OpRegRegReg(cUnit, kOpAdd, regPtr, rBase, rIndex);
}
- store = newLIR3(cUnit, opcode, rSrc, regPtr, 0);
- oatFreeTemp(cUnit, regPtr);
+ store = NewLIR3(cUnit, opcode, rSrc, regPtr, 0);
+ FreeTemp(cUnit, regPtr);
return store;
case kWord:
opcode = (thumbForm) ? kThumbStrRRR : kThumb2StrRRR;
@@ -749,9 +749,9 @@
LOG(FATAL) << "Bad size: " << size;
}
if (thumbForm)
- store = newLIR3(cUnit, opcode, rSrc, rBase, rIndex);
+ store = NewLIR3(cUnit, opcode, rSrc, rBase, rIndex);
else
- store = newLIR4(cUnit, opcode, rSrc, rBase, rIndex, scale);
+ store = NewLIR4(cUnit, opcode, rSrc, rBase, rIndex, scale);
return store;
}
@@ -761,7 +761,7 @@
* on base (which must have an associated sReg and MIR). If not
* performing null check, incoming MIR can be null.
*/
-LIR* loadBaseDispBody(CompilationUnit* cUnit, int rBase,
+LIR* LoadBaseDispBody(CompilationUnit* cUnit, int rBase,
int displacement, int rDest, int rDestHi, OpSize size,
int sReg)
{
@@ -780,7 +780,7 @@
if (ARM_FPREG(rDest)) {
if (ARM_SINGLEREG(rDest)) {
DCHECK(ARM_FPREG(rDestHi));
- rDest = s2d(rDest, rDestHi);
+ rDest = S2d(rDest, rDestHi);
}
opcode = kThumb2Vldrd;
if (displacement <= 1020) {
@@ -789,9 +789,9 @@
}
break;
} else {
- res = loadBaseDispBody(cUnit, rBase, displacement, rDest,
+ res = LoadBaseDispBody(cUnit, rBase, displacement, rDest,
-1, kWord, sReg);
- loadBaseDispBody(cUnit, rBase, displacement + 4, rDestHi,
+ LoadBaseDispBody(cUnit, rBase, displacement + 4, rDestHi,
-1, kWord, INVALID_SREG);
return res;
}
@@ -862,37 +862,37 @@
}
if (shortForm) {
- load = res = newLIR3(cUnit, opcode, rDest, rBase, encodedDisp);
+ load = res = NewLIR3(cUnit, opcode, rDest, rBase, encodedDisp);
} else {
- int regOffset = oatAllocTemp(cUnit);
- res = loadConstant(cUnit, regOffset, encodedDisp);
- load = loadBaseIndexed(cUnit, rBase, regOffset, rDest, 0, size);
- oatFreeTemp(cUnit, regOffset);
+ int regOffset = AllocTemp(cUnit);
+ res = LoadConstant(cUnit, regOffset, encodedDisp);
+ load = LoadBaseIndexed(cUnit, rBase, regOffset, rDest, 0, size);
+ FreeTemp(cUnit, regOffset);
}
// TODO: in future may need to differentiate Dalvik accesses w/ spills
if (rBase == rARM_SP) {
- annotateDalvikRegAccess(load, displacement >> 2, true /* isLoad */, is64bit);
+ AnnotateDalvikRegAccess(load, displacement >> 2, true /* isLoad */, is64bit);
}
return load;
}
-LIR* loadBaseDisp(CompilationUnit* cUnit, int rBase,
+LIR* LoadBaseDisp(CompilationUnit* cUnit, int rBase,
int displacement, int rDest, OpSize size, int sReg)
{
- return loadBaseDispBody(cUnit, rBase, displacement, rDest, -1, size,
+ return LoadBaseDispBody(cUnit, rBase, displacement, rDest, -1, size,
sReg);
}
- LIR* loadBaseDispWide(CompilationUnit* cUnit, int rBase,
+ LIR* LoadBaseDispWide(CompilationUnit* cUnit, int rBase,
int displacement, int rDestLo, int rDestHi, int sReg)
{
- return loadBaseDispBody(cUnit, rBase, displacement, rDestLo, rDestHi,
+ return LoadBaseDispBody(cUnit, rBase, displacement, rDestLo, rDestHi,
kLong, sReg);
}
-LIR* storeBaseDispBody(CompilationUnit* cUnit, int rBase, int displacement,
+LIR* StoreBaseDispBody(CompilationUnit* cUnit, int rBase, int displacement,
int rSrc, int rSrcHi, OpSize size)
{
LIR* res, *store;
@@ -907,13 +907,13 @@
case kDouble:
is64bit = true;
if (!ARM_FPREG(rSrc)) {
- res = storeBaseDispBody(cUnit, rBase, displacement, rSrc, -1, kWord);
- storeBaseDispBody(cUnit, rBase, displacement + 4, rSrcHi, -1, kWord);
+ res = StoreBaseDispBody(cUnit, rBase, displacement, rSrc, -1, kWord);
+ StoreBaseDispBody(cUnit, rBase, displacement + 4, rSrcHi, -1, kWord);
return res;
}
if (ARM_SINGLEREG(rSrc)) {
DCHECK(ARM_FPREG(rSrcHi));
- rSrc = s2d(rSrc, rSrcHi);
+ rSrc = S2d(rSrc, rSrcHi);
}
opcode = kThumb2Vstrd;
if (displacement <= 1020) {
@@ -968,40 +968,40 @@
LOG(FATAL) << "Bad size: " << size;
}
if (shortForm) {
- store = res = newLIR3(cUnit, opcode, rSrc, rBase, encodedDisp);
+ store = res = NewLIR3(cUnit, opcode, rSrc, rBase, encodedDisp);
} else {
- int rScratch = oatAllocTemp(cUnit);
- res = loadConstant(cUnit, rScratch, encodedDisp);
- store = storeBaseIndexed(cUnit, rBase, rScratch, rSrc, 0, size);
- oatFreeTemp(cUnit, rScratch);
+ int rScratch = AllocTemp(cUnit);
+ res = LoadConstant(cUnit, rScratch, encodedDisp);
+ store = StoreBaseIndexed(cUnit, rBase, rScratch, rSrc, 0, size);
+ FreeTemp(cUnit, rScratch);
}
// TODO: In future, may need to differentiate Dalvik & spill accesses
if (rBase == rARM_SP) {
- annotateDalvikRegAccess(store, displacement >> 2, false /* isLoad */,
+ AnnotateDalvikRegAccess(store, displacement >> 2, false /* isLoad */,
is64bit);
}
return res;
}
-LIR* storeBaseDisp(CompilationUnit* cUnit, int rBase, int displacement,
+LIR* StoreBaseDisp(CompilationUnit* cUnit, int rBase, int displacement,
int rSrc, OpSize size)
{
- return storeBaseDispBody(cUnit, rBase, displacement, rSrc, -1, size);
+ return StoreBaseDispBody(cUnit, rBase, displacement, rSrc, -1, size);
}
-LIR* storeBaseDispWide(CompilationUnit* cUnit, int rBase, int displacement,
+LIR* StoreBaseDispWide(CompilationUnit* cUnit, int rBase, int displacement,
int rSrcLo, int rSrcHi)
{
- return storeBaseDispBody(cUnit, rBase, displacement, rSrcLo, rSrcHi, kLong);
+ return StoreBaseDispBody(cUnit, rBase, displacement, rSrcLo, rSrcHi, kLong);
}
-void loadPair(CompilationUnit* cUnit, int base, int lowReg, int highReg)
+void LoadPair(CompilationUnit* cUnit, int base, int lowReg, int highReg)
{
- loadBaseDispWide(cUnit, base, 0, lowReg, highReg, INVALID_SREG);
+ LoadBaseDispWide(cUnit, base, 0, lowReg, highReg, INVALID_SREG);
}
-LIR* fpRegCopy(CompilationUnit* cUnit, int rDest, int rSrc)
+LIR* FpRegCopy(CompilationUnit* cUnit, int rDest, int rSrc)
{
int opcode;
DCHECK_EQ(ARM_DOUBLEREG(rDest), ARM_DOUBLEREG(rSrc));
@@ -1015,47 +1015,47 @@
opcode = kThumb2Fmrs;
}
}
- LIR* res = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, rDest, rSrc);
+ LIR* res = RawLIR(cUnit, cUnit->currentDalvikOffset, opcode, rDest, rSrc);
if (!(cUnit->disableOpt & (1 << kSafeOptimizations)) && rDest == rSrc) {
res->flags.isNop = true;
}
return res;
}
-LIR* opThreadMem(CompilationUnit* cUnit, OpKind op, int threadOffset)
+LIR* OpThreadMem(CompilationUnit* cUnit, OpKind op, int threadOffset)
{
- LOG(FATAL) << "Unexpected use of opThreadMem for Arm";
+ LOG(FATAL) << "Unexpected use of OpThreadMem for Arm";
return NULL;
}
-LIR* opMem(CompilationUnit* cUnit, OpKind op, int rBase, int disp)
+LIR* OpMem(CompilationUnit* cUnit, OpKind op, int rBase, int disp)
{
- LOG(FATAL) << "Unexpected use of opMem for Arm";
+ LOG(FATAL) << "Unexpected use of OpMem for Arm";
return NULL;
}
-LIR* storeBaseIndexedDisp(CompilationUnit *cUnit,
+LIR* StoreBaseIndexedDisp(CompilationUnit *cUnit,
int rBase, int rIndex, int scale, int displacement,
int rSrc, int rSrcHi,
OpSize size, int sReg)
{
- LOG(FATAL) << "Unexpected use of storeBaseIndexedDisp for Arm";
+ LOG(FATAL) << "Unexpected use of StoreBaseIndexedDisp for Arm";
return NULL;
}
-LIR* opRegMem(CompilationUnit *cUnit, OpKind op, int rDest, int rBase,
+LIR* OpRegMem(CompilationUnit *cUnit, OpKind op, int rDest, int rBase,
int offset)
{
- LOG(FATAL) << "Unexpected use of opRegMem for Arm";
+ LOG(FATAL) << "Unexpected use of OpRegMem for Arm";
return NULL;
}
-LIR* loadBaseIndexedDisp(CompilationUnit *cUnit,
+LIR* LoadBaseIndexedDisp(CompilationUnit *cUnit,
int rBase, int rIndex, int scale, int displacement,
int rDest, int rDestHi,
OpSize size, int sReg)
{
- LOG(FATAL) << "Unexpected use of loadBaseIndexedDisp for Arm";
+ LOG(FATAL) << "Unexpected use of LoadBaseIndexedDisp for Arm";
return NULL;
}
diff --git a/src/compiler/codegen/codegen_util.cc b/src/compiler/codegen/codegen_util.cc
index c6c8af1..26bf613 100644
--- a/src/compiler/codegen/codegen_util.cc
+++ b/src/compiler/codegen/codegen_util.cc
@@ -24,16 +24,16 @@
namespace art {
/* Convert an instruction to a NOP */
-void oatNopLIR( LIR* lir)
+void NopLIR( LIR* lir)
{
lir->flags.isNop = true;
}
-void setMemRefType(LIR* lir, bool isLoad, int memType)
+void SetMemRefType(LIR* lir, bool isLoad, int memType)
{
uint64_t *maskPtr;
uint64_t mask = ENCODE_MEM;;
- DCHECK(getTargetInstFlags(lir->opcode) & (IS_LOAD | IS_STORE));
+ DCHECK(GetTargetInstFlags(lir->opcode) & (IS_LOAD | IS_STORE));
if (isLoad) {
maskPtr = &lir->useMask;
} else {
@@ -55,7 +55,7 @@
break;
case kMustNotAlias:
/* Currently only loads can be marked as kMustNotAlias */
- DCHECK(!(getTargetInstFlags(lir->opcode) & IS_STORE));
+ DCHECK(!(GetTargetInstFlags(lir->opcode) & IS_STORE));
*maskPtr |= ENCODE_MUST_NOT_ALIAS;
break;
default:
@@ -66,9 +66,9 @@
/*
* Mark load/store instructions that access Dalvik registers through the stack.
*/
-void annotateDalvikRegAccess(LIR* lir, int regId, bool isLoad, bool is64bit)
+void AnnotateDalvikRegAccess(LIR* lir, int regId, bool isLoad, bool is64bit)
{
- setMemRefType(lir, isLoad, kDalvikReg);
+ SetMemRefType(lir, isLoad, kDalvikReg);
/*
* Store the Dalvik register id in aliasInfo. Mark the MSB if it is a 64-bit
@@ -77,29 +77,18 @@
lir->aliasInfo = ENCODE_ALIAS_INFO(regId, is64bit);
}
-uint64_t oatGetRegMaskCommon(CompilationUnit* cUnit, int reg)
-{
- return getRegMaskCommon(cUnit, reg);
-}
-
/*
* Mark the corresponding bit(s).
*/
-inline void setupRegMask(CompilationUnit* cUnit, uint64_t* mask, int reg)
+void SetupRegMask(CompilationUnit* cUnit, uint64_t* mask, int reg)
{
- *mask |= getRegMaskCommon(cUnit, reg);
-}
-
-/* Exported version of setupRegMask */
-void oatSetupRegMask(CompilationUnit* cUnit, uint64_t* mask, int reg)
-{
- setupRegMask(cUnit, mask, reg);
+ *mask |= GetRegMaskCommon(cUnit, reg);
}
/*
* Set up the proper fields in the resource mask
*/
-void setupResourceMasks(CompilationUnit* cUnit, LIR* lir)
+void SetupResourceMasks(CompilationUnit* cUnit, LIR* lir)
{
int opcode = lir->opcode;
@@ -108,19 +97,19 @@
return;
}
- uint64_t flags = getTargetInstFlags(opcode);
+ uint64_t flags = GetTargetInstFlags(opcode);
if (flags & NEEDS_FIXUP) {
lir->flags.pcRelFixup = true;
}
/* Get the starting size of the instruction's template */
- lir->flags.size = oatGetInsnSize(lir);
+ lir->flags.size = GetInsnSize(lir);
/* Set up the mask for resources that are updated */
if (flags & (IS_LOAD | IS_STORE)) {
/* Default to heap - will catch specialized classes later */
- setMemRefType(lir, flags & IS_LOAD, kHeapRef);
+ SetMemRefType(lir, flags & IS_LOAD, kHeapRef);
}
/*
@@ -133,11 +122,11 @@
}
if (flags & REG_DEF0) {
- setupRegMask(cUnit, &lir->defMask, lir->operands[0]);
+ SetupRegMask(cUnit, &lir->defMask, lir->operands[0]);
}
if (flags & REG_DEF1) {
- setupRegMask(cUnit, &lir->defMask, lir->operands[1]);
+ SetupRegMask(cUnit, &lir->defMask, lir->operands[1]);
}
@@ -150,7 +139,7 @@
for (i = 0; i < 4; i++) {
if (flags & (1 << (kRegUse0 + i))) {
- setupRegMask(cUnit, &lir->useMask, lir->operands[i]);
+ SetupRegMask(cUnit, &lir->useMask, lir->operands[i]);
}
}
}
@@ -160,7 +149,7 @@
}
// Handle target-specific actions
- setupTargetResourceMasks(cUnit, lir);
+ SetupTargetResourceMasks(cUnit, lir);
}
/*
@@ -170,7 +159,7 @@
#define DUMP_SSA_REP(X)
/* Pretty-print a LIR instruction */
-void oatDumpLIRInsn(CompilationUnit* cUnit, LIR* lir, unsigned char* baseAddr)
+void DumpLIRInsn(CompilationUnit* cUnit, LIR* lir, unsigned char* baseAddr)
{
int offset = lir->offset;
int dest = lir->operands[0];
@@ -239,9 +228,9 @@
if (lir->flags.isNop && !dumpNop) {
break;
} else {
- std::string op_name(buildInsnString(getTargetInstName(lir->opcode),
+ std::string op_name(BuildInsnString(GetTargetInstName(lir->opcode),
lir, baseAddr));
- std::string op_operands(buildInsnString(getTargetInstFmt(lir->opcode),
+ std::string op_operands(BuildInsnString(GetTargetInstFmt(lir->opcode),
lir, baseAddr));
LOG(INFO) << StringPrintf("%05x: %-9s%s%s",
reinterpret_cast<unsigned int>(baseAddr + offset),
@@ -252,21 +241,21 @@
}
if (lir->useMask && (!lir->flags.isNop || dumpNop)) {
- DUMP_RESOURCE_MASK(oatDumpResourceMask((LIR* ) lir, lir->useMask, "use"));
+ DUMP_RESOURCE_MASK(DumpResourceMask((LIR* ) lir, lir->useMask, "use"));
}
if (lir->defMask && (!lir->flags.isNop || dumpNop)) {
- DUMP_RESOURCE_MASK(oatDumpResourceMask((LIR* ) lir, lir->defMask, "def"));
+ DUMP_RESOURCE_MASK(DumpResourceMask((LIR* ) lir, lir->defMask, "def"));
}
}
-void oatDumpPromotionMap(CompilationUnit *cUnit)
+void DumpPromotionMap(CompilationUnit *cUnit)
{
int numRegs = cUnit->numDalvikRegisters + cUnit->numCompilerTemps + 1;
for (int i = 0; i < numRegs; i++) {
PromotionMap vRegMap = cUnit->promotionMap[i];
std::string buf;
if (vRegMap.fpLocation == kLocPhysReg) {
- StringAppendF(&buf, " : s%d", vRegMap.fpReg & fpRegMask());
+ StringAppendF(&buf, " : s%d", vRegMap.FpReg & FpRegMask());
}
std::string buf3;
@@ -281,13 +270,13 @@
LOG(INFO) << StringPrintf("V[%s] -> %s%d%s", buf3.c_str(),
vRegMap.coreLocation == kLocPhysReg ?
"r" : "SP+", vRegMap.coreLocation == kLocPhysReg ?
- vRegMap.coreReg : oatSRegOffset(cUnit, i),
+ vRegMap.coreReg : SRegOffset(cUnit, i),
buf.c_str());
}
}
/* Dump a mapping table */
-void dumpMappingTable(const char* table_name, const std::string& descriptor,
+void DumpMappingTable(const char* table_name, const std::string& descriptor,
const std::string& name, const std::string& signature,
const std::vector<uint32_t>& v) {
if (v.size() > 0) {
@@ -304,7 +293,7 @@
}
/* Dump instructions and constant pool contents */
-void oatCodegenDump(CompilationUnit* cUnit)
+void CodegenDump(CompilationUnit* cUnit)
{
LOG(INFO) << "Dumping LIR insns for "
<< PrettyMethod(cUnit->method_idx, *cUnit->dex_file);
@@ -322,9 +311,9 @@
" bytes, Dalvik size is " << insnsSize * 2;
LOG(INFO) << "expansion factor: "
<< static_cast<float>(cUnit->totalSize) / static_cast<float>(insnsSize * 2);
- oatDumpPromotionMap(cUnit);
+ DumpPromotionMap(cUnit);
for (lirInsn = cUnit->firstLIRInsn; lirInsn; lirInsn = lirInsn->next) {
- oatDumpLIRInsn(cUnit, lirInsn, 0);
+ DumpLIRInsn(cUnit, lirInsn, 0);
}
for (lirInsn = cUnit->literalList; lirInsn; lirInsn = lirInsn->next) {
LOG(INFO) << StringPrintf("%x (%04x): .word (%#x)", lirInsn->offset, lirInsn->offset,
@@ -338,15 +327,15 @@
std::string descriptor(cUnit->dex_file->GetMethodDeclaringClassDescriptor(method_id));
// Dump mapping tables
- dumpMappingTable("PC2Dex_MappingTable", descriptor, name, signature, cUnit->pc2dexMappingTable);
- dumpMappingTable("Dex2PC_MappingTable", descriptor, name, signature, cUnit->dex2pcMappingTable);
+ DumpMappingTable("PC2Dex_MappingTable", descriptor, name, signature, cUnit->pc2dexMappingTable);
+ DumpMappingTable("Dex2PC_MappingTable", descriptor, name, signature, cUnit->dex2pcMappingTable);
}
-LIR* rawLIR(CompilationUnit* cUnit, int dalvikOffset, int opcode, int op0,
+LIR* RawLIR(CompilationUnit* cUnit, int dalvikOffset, int opcode, int op0,
int op1, int op2, int op3, int op4, LIR* target)
{
- LIR* insn = static_cast<LIR*>(oatNew(cUnit, sizeof(LIR), true, kAllocLIR));
+ LIR* insn = static_cast<LIR*>(NewMem(cUnit, sizeof(LIR), true, kAllocLIR));
insn->dalvikOffset = dalvikOffset;
insn->opcode = opcode;
insn->operands[0] = op0;
@@ -355,7 +344,7 @@
insn->operands[3] = op3;
insn->operands[4] = op4;
insn->target = target;
- oatSetupResourceMasks(cUnit, insn);
+ SetupResourceMasks(cUnit, insn);
if ((opcode == kPseudoTargetLabel) || (opcode == kPseudoSafepointPC) ||
(opcode == kPseudoExportedPC)) {
// Always make labels scheduling barriers
@@ -368,74 +357,74 @@
* The following are building blocks to construct low-level IRs with 0 - 4
* operands.
*/
-LIR* newLIR0(CompilationUnit* cUnit, int opcode)
+LIR* NewLIR0(CompilationUnit* cUnit, int opcode)
{
- DCHECK(isPseudoOpcode(opcode) || (getTargetInstFlags(opcode) & NO_OPERAND))
- << getTargetInstName(opcode) << " " << opcode << " "
+ DCHECK(isPseudoOpcode(opcode) || (GetTargetInstFlags(opcode) & NO_OPERAND))
+ << GetTargetInstName(opcode) << " " << opcode << " "
<< PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
<< cUnit->currentDalvikOffset;
- LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode);
- oatAppendLIR(cUnit, insn);
+ LIR* insn = RawLIR(cUnit, cUnit->currentDalvikOffset, opcode);
+ AppendLIR(cUnit, insn);
return insn;
}
-LIR* newLIR1(CompilationUnit* cUnit, int opcode,
+LIR* NewLIR1(CompilationUnit* cUnit, int opcode,
int dest)
{
- DCHECK(isPseudoOpcode(opcode) || (getTargetInstFlags(opcode) & IS_UNARY_OP))
- << getTargetInstName(opcode) << " " << opcode << " "
+ DCHECK(isPseudoOpcode(opcode) || (GetTargetInstFlags(opcode) & IS_UNARY_OP))
+ << GetTargetInstName(opcode) << " " << opcode << " "
<< PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
<< cUnit->currentDalvikOffset;
- LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest);
- oatAppendLIR(cUnit, insn);
+ LIR* insn = RawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest);
+ AppendLIR(cUnit, insn);
return insn;
}
-LIR* newLIR2(CompilationUnit* cUnit, int opcode,
+LIR* NewLIR2(CompilationUnit* cUnit, int opcode,
int dest, int src1)
{
- DCHECK(isPseudoOpcode(opcode) || (getTargetInstFlags(opcode) & IS_BINARY_OP))
- << getTargetInstName(opcode) << " " << opcode << " "
+ DCHECK(isPseudoOpcode(opcode) || (GetTargetInstFlags(opcode) & IS_BINARY_OP))
+ << GetTargetInstName(opcode) << " " << opcode << " "
<< PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
<< cUnit->currentDalvikOffset;
- LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1);
- oatAppendLIR(cUnit, insn);
+ LIR* insn = RawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1);
+ AppendLIR(cUnit, insn);
return insn;
}
-LIR* newLIR3(CompilationUnit* cUnit, int opcode,
+LIR* NewLIR3(CompilationUnit* cUnit, int opcode,
int dest, int src1, int src2)
{
- DCHECK(isPseudoOpcode(opcode) || (getTargetInstFlags(opcode) & IS_TERTIARY_OP))
- << getTargetInstName(opcode) << " " << opcode << " "
+ DCHECK(isPseudoOpcode(opcode) || (GetTargetInstFlags(opcode) & IS_TERTIARY_OP))
+ << GetTargetInstName(opcode) << " " << opcode << " "
<< PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
<< cUnit->currentDalvikOffset;
- LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1, src2);
- oatAppendLIR(cUnit, insn);
+ LIR* insn = RawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1, src2);
+ AppendLIR(cUnit, insn);
return insn;
}
-LIR* newLIR4(CompilationUnit* cUnit, int opcode,
+LIR* NewLIR4(CompilationUnit* cUnit, int opcode,
int dest, int src1, int src2, int info)
{
- DCHECK(isPseudoOpcode(opcode) || (getTargetInstFlags(opcode) & IS_QUAD_OP))
- << getTargetInstName(opcode) << " " << opcode << " "
+ DCHECK(isPseudoOpcode(opcode) || (GetTargetInstFlags(opcode) & IS_QUAD_OP))
+ << GetTargetInstName(opcode) << " " << opcode << " "
<< PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
<< cUnit->currentDalvikOffset;
- LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1, src2, info);
- oatAppendLIR(cUnit, insn);
+ LIR* insn = RawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1, src2, info);
+ AppendLIR(cUnit, insn);
return insn;
}
-LIR* newLIR5(CompilationUnit* cUnit, int opcode,
+LIR* NewLIR5(CompilationUnit* cUnit, int opcode,
int dest, int src1, int src2, int info1, int info2)
{
- DCHECK(isPseudoOpcode(opcode) || (getTargetInstFlags(opcode) & IS_QUIN_OP))
- << getTargetInstName(opcode) << " " << opcode << " "
+ DCHECK(isPseudoOpcode(opcode) || (GetTargetInstFlags(opcode) & IS_QUIN_OP))
+ << GetTargetInstName(opcode) << " " << opcode << " "
<< PrettyMethod(cUnit->method_idx, *cUnit->dex_file) << " "
<< cUnit->currentDalvikOffset;
- LIR* insn = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1, src2, info1, info2);
- oatAppendLIR(cUnit, insn);
+ LIR* insn = RawLIR(cUnit, cUnit->currentDalvikOffset, opcode, dest, src1, src2, info1, info2);
+ AppendLIR(cUnit, insn);
return insn;
}
@@ -443,7 +432,7 @@
* Search the existing constants in the literal pool for an exact or close match
* within specified delta (greater or equal to 0).
*/
-LIR* scanLiteralPool(LIR* dataTarget, int value, unsigned int delta)
+LIR* ScanLiteralPool(LIR* dataTarget, int value, unsigned int delta)
{
while (dataTarget) {
if ((static_cast<unsigned>(value - dataTarget->operands[0])) <= delta)
@@ -454,7 +443,7 @@
}
/* Search the existing constants in the literal pool for an exact wide match */
-LIR* scanLiteralPoolWide(LIR* dataTarget, int valLo, int valHi)
+LIR* ScanLiteralPoolWide(LIR* dataTarget, int valLo, int valHi)
{
bool loMatch = false;
LIR* loTarget = NULL;
@@ -478,11 +467,11 @@
*/
/* Add a 32-bit constant either in the constant pool */
-LIR* addWordData(CompilationUnit* cUnit, LIR* *constantListP, int value)
+LIR* AddWordData(CompilationUnit* cUnit, LIR* *constantListP, int value)
{
/* Add the constant to the literal pool */
if (constantListP) {
- LIR* newValue = static_cast<LIR*>(oatNew(cUnit, sizeof(LIR), true, kAllocData));
+ LIR* newValue = static_cast<LIR*>(NewMem(cUnit, sizeof(LIR), true, kAllocData));
newValue->operands[0] = value;
newValue->next = *constantListP;
*constantListP = newValue;
@@ -492,21 +481,21 @@
}
/* Add a 64-bit constant to the constant pool or mixed with code */
-LIR* addWideData(CompilationUnit* cUnit, LIR* *constantListP,
+LIR* AddWideData(CompilationUnit* cUnit, LIR* *constantListP,
int valLo, int valHi)
{
- addWordData(cUnit, constantListP, valHi);
- return addWordData(cUnit, constantListP, valLo);
+ AddWordData(cUnit, constantListP, valHi);
+ return AddWordData(cUnit, constantListP, valLo);
}
-void pushWord(std::vector<uint8_t>&buf, int data) {
+void PushWord(std::vector<uint8_t>&buf, int data) {
buf.push_back( data & 0xff);
buf.push_back( (data >> 8) & 0xff);
buf.push_back( (data >> 16) & 0xff);
buf.push_back( (data >> 24) & 0xff);
}
-void alignBuffer(std::vector<uint8_t>&buf, size_t offset) {
+void AlignBuffer(std::vector<uint8_t>&buf, size_t offset) {
while (buf.size() < offset) {
buf.push_back(0);
}
@@ -518,12 +507,12 @@
}
/* Write the literal pool to the output stream */
-void installLiteralPools(CompilationUnit* cUnit)
+void InstallLiteralPools(CompilationUnit* cUnit)
{
- alignBuffer(cUnit->codeBuffer, cUnit->dataOffset);
+ AlignBuffer(cUnit->codeBuffer, cUnit->dataOffset);
LIR* dataLIR = cUnit->literalList;
while (dataLIR != NULL) {
- pushWord(cUnit->codeBuffer, dataLIR->operands[0]);
+ PushWord(cUnit->codeBuffer, dataLIR->operands[0]);
dataLIR = NEXT_LIR(dataLIR);
}
// Push code and method literals, record offsets for the compiler to patch.
@@ -539,7 +528,7 @@
const DexFile::MethodId& id = cUnit->dex_file->GetMethodId(target);
// unique based on target to ensure code deduplication works
uint32_t unique_patch_value = reinterpret_cast<uint32_t>(&id);
- pushWord(cUnit->codeBuffer, unique_patch_value);
+ PushWord(cUnit->codeBuffer, unique_patch_value);
dataLIR = NEXT_LIR(dataLIR);
}
dataLIR = cUnit->methodLiteralList;
@@ -554,20 +543,20 @@
const DexFile::MethodId& id = cUnit->dex_file->GetMethodId(target);
// unique based on target to ensure code deduplication works
uint32_t unique_patch_value = reinterpret_cast<uint32_t>(&id);
- pushWord(cUnit->codeBuffer, unique_patch_value);
+ PushWord(cUnit->codeBuffer, unique_patch_value);
dataLIR = NEXT_LIR(dataLIR);
}
}
/* Write the switch tables to the output stream */
-void installSwitchTables(CompilationUnit* cUnit)
+void InstallSwitchTables(CompilationUnit* cUnit)
{
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&cUnit->switchTables, &iterator);
+ GrowableListIteratorInit(&cUnit->switchTables, &iterator);
while (true) {
- SwitchTable* tabRec = reinterpret_cast<SwitchTable*>(oatGrowableListIteratorNext( &iterator));
+ SwitchTable* tabRec = reinterpret_cast<SwitchTable*>(GrowableListIteratorNext( &iterator));
if (tabRec == NULL) break;
- alignBuffer(cUnit->codeBuffer, tabRec->offset);
+ AlignBuffer(cUnit->codeBuffer, tabRec->offset);
/*
* For Arm, our reference point is the address of the bx
* instruction that does the launch, so we have to subtract
@@ -599,8 +588,8 @@
<< std::hex << keys[elems] << ", disp: 0x"
<< std::hex << disp;
}
- pushWord(cUnit->codeBuffer, keys[elems]);
- pushWord(cUnit->codeBuffer,
+ PushWord(cUnit->codeBuffer, keys[elems]);
+ PushWord(cUnit->codeBuffer,
tabRec->targets[elems]->offset - bxOffset);
}
} else {
@@ -612,22 +601,22 @@
LOG(INFO) << " Case[" << elems << "] disp: 0x"
<< std::hex << disp;
}
- pushWord(cUnit->codeBuffer, tabRec->targets[elems]->offset - bxOffset);
+ PushWord(cUnit->codeBuffer, tabRec->targets[elems]->offset - bxOffset);
}
}
}
}
/* Write the fill array dta to the output stream */
-void installFillArrayData(CompilationUnit* cUnit)
+void InstallFillArrayData(CompilationUnit* cUnit)
{
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&cUnit->fillArrayData, &iterator);
+ GrowableListIteratorInit(&cUnit->fillArrayData, &iterator);
while (true) {
FillArrayData *tabRec =
- reinterpret_cast<FillArrayData*>(oatGrowableListIteratorNext( &iterator));
+ reinterpret_cast<FillArrayData*>(GrowableListIteratorNext( &iterator));
if (tabRec == NULL) break;
- alignBuffer(cUnit->codeBuffer, tabRec->offset);
+ AlignBuffer(cUnit->codeBuffer, tabRec->offset);
for (int i = 0; i < (tabRec->size + 1) / 2; i++) {
cUnit->codeBuffer.push_back( tabRec->table[i] & 0xFF);
cUnit->codeBuffer.push_back( (tabRec->table[i] >> 8) & 0xFF);
@@ -635,7 +624,7 @@
}
}
-int assignLiteralOffsetCommon(LIR* lir, int offset)
+int AssignLiteralOffsetCommon(LIR* lir, int offset)
{
for (;lir != NULL; lir = lir->next) {
lir->offset = offset;
@@ -645,7 +634,7 @@
}
// Make sure we have a code address for every declared catch entry
-bool verifyCatchEntries(CompilationUnit* cUnit)
+bool VerifyCatchEntries(CompilationUnit* cUnit)
{
bool success = true;
for (std::set<uint32_t>::const_iterator it = cUnit->catches.begin(); it != cUnit->catches.end(); ++it) {
@@ -678,7 +667,7 @@
return success;
}
-void createMappingTables(CompilationUnit* cUnit)
+void CreateMappingTables(CompilationUnit* cUnit)
{
for (LIR* tgtLIR = cUnit->firstLIRInsn; tgtLIR != NULL; tgtLIR = NEXT_LIR(tgtLIR)) {
if (!tgtLIR->flags.isNop && (tgtLIR->opcode == kPseudoSafepointPC)) {
@@ -690,7 +679,7 @@
cUnit->dex2pcMappingTable.push_back(tgtLIR->dalvikOffset);
}
}
- DCHECK(verifyCatchEntries(cUnit));
+ DCHECK(VerifyCatchEntries(cUnit));
cUnit->combinedMappingTable.push_back(cUnit->pc2dexMappingTable.size() +
cUnit->dex2pcMappingTable.size());
cUnit->combinedMappingTable.push_back(cUnit->pc2dexMappingTable.size());
@@ -780,7 +769,7 @@
std::vector<uint8_t>* const table_;
};
-static void createNativeGcMap(CompilationUnit* cUnit) {
+static void CreateNativeGcMap(CompilationUnit* cUnit) {
const std::vector<uint32_t>& mapping_table = cUnit->pc2dexMappingTable;
uint32_t max_native_offset = 0;
for (size_t i = 0; i < mapping_table.size(); i += 2) {
@@ -807,20 +796,20 @@
}
/* Determine the offset of each literal field */
-int assignLiteralOffset(CompilationUnit* cUnit, int offset)
+int AssignLiteralOffset(CompilationUnit* cUnit, int offset)
{
- offset = assignLiteralOffsetCommon(cUnit->literalList, offset);
- offset = assignLiteralOffsetCommon(cUnit->codeLiteralList, offset);
- offset = assignLiteralOffsetCommon(cUnit->methodLiteralList, offset);
+ offset = AssignLiteralOffsetCommon(cUnit->literalList, offset);
+ offset = AssignLiteralOffsetCommon(cUnit->codeLiteralList, offset);
+ offset = AssignLiteralOffsetCommon(cUnit->methodLiteralList, offset);
return offset;
}
-int assignSwitchTablesOffset(CompilationUnit* cUnit, int offset)
+int AssignSiwtchTablesOffset(CompilationUnit* cUnit, int offset)
{
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&cUnit->switchTables, &iterator);
+ GrowableListIteratorInit(&cUnit->switchTables, &iterator);
while (true) {
- SwitchTable *tabRec = reinterpret_cast<SwitchTable*>(oatGrowableListIteratorNext(&iterator));
+ SwitchTable *tabRec = reinterpret_cast<SwitchTable*>(GrowableListIteratorNext(&iterator));
if (tabRec == NULL) break;
tabRec->offset = offset;
if (tabRec->table[0] == Instruction::kSparseSwitchSignature) {
@@ -834,13 +823,13 @@
return offset;
}
-int assignFillArrayDataOffset(CompilationUnit* cUnit, int offset)
+int AssignFillArrayDataOffset(CompilationUnit* cUnit, int offset)
{
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&cUnit->fillArrayData, &iterator);
+ GrowableListIteratorInit(&cUnit->fillArrayData, &iterator);
while (true) {
FillArrayData *tabRec =
- reinterpret_cast<FillArrayData*>(oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<FillArrayData*>(GrowableListIteratorNext(&iterator));
if (tabRec == NULL) break;
tabRec->offset = offset;
offset += tabRec->size;
@@ -854,9 +843,9 @@
* Walk the compilation unit and assign offsets to instructions
* and literals and compute the total size of the compiled unit.
*/
-void oatAssignOffsets(CompilationUnit* cUnit)
+void AssignOffsets(CompilationUnit* cUnit)
{
- int offset = oatAssignInsnOffsets(cUnit);
+ int offset = AssignInsnOffsets(cUnit);
/* Const values have to be word aligned */
offset = (offset + 3) & ~3;
@@ -864,11 +853,11 @@
/* Set up offsets for literals */
cUnit->dataOffset = offset;
- offset = assignLiteralOffset(cUnit, offset);
+ offset = AssignLiteralOffset(cUnit, offset);
- offset = assignSwitchTablesOffset(cUnit, offset);
+ offset = AssignSiwtchTablesOffset(cUnit, offset);
- offset = assignFillArrayDataOffset(cUnit, offset);
+ offset = AssignFillArrayDataOffset(cUnit, offset);
cUnit->totalSize = offset;
}
@@ -878,43 +867,43 @@
* before sending them off to the assembler. If out-of-range branch distance is
* seen rearrange the instructions a bit to correct it.
*/
-void oatAssembleLIR(CompilationUnit* cUnit)
+void AssembleLIR(CompilationUnit* cUnit)
{
- oatAssignOffsets(cUnit);
+ AssignOffsets(cUnit);
/*
* Assemble here. Note that we generate code with optimistic assumptions
* and if found now to work, we'll have to redo the sequence and retry.
*/
while (true) {
- AssemblerStatus res = oatAssembleInstructions(cUnit, 0);
+ AssemblerStatus res = AssembleInstructions(cUnit, 0);
if (res == kSuccess) {
break;
} else {
cUnit->assemblerRetries++;
if (cUnit->assemblerRetries > MAX_ASSEMBLER_RETRIES) {
- oatCodegenDump(cUnit);
+ CodegenDump(cUnit);
LOG(FATAL) << "Assembler error - too many retries";
}
// Redo offsets and try again
- oatAssignOffsets(cUnit);
+ AssignOffsets(cUnit);
cUnit->codeBuffer.clear();
}
}
// Install literals
- installLiteralPools(cUnit);
+ InstallLiteralPools(cUnit);
// Install switch tables
- installSwitchTables(cUnit);
+ InstallSwitchTables(cUnit);
// Install fill array data
- installFillArrayData(cUnit);
+ InstallFillArrayData(cUnit);
// Create the mapping table and native offset to reference map.
- createMappingTables(cUnit);
+ CreateMappingTables(cUnit);
- createNativeGcMap(cUnit);
+ CreateNativeGcMap(cUnit);
}
/*
@@ -924,22 +913,22 @@
* all resource flags on this to prevent code motion across
* target boundaries. KeyVal is just there for debugging.
*/
-LIR* insertCaseLabel(CompilationUnit* cUnit, int vaddr, int keyVal)
+LIR* InsertCaseLabel(CompilationUnit* cUnit, int vaddr, int keyVal)
{
SafeMap<unsigned int, LIR*>::iterator it;
it = cUnit->boundaryMap.find(vaddr);
if (it == cUnit->boundaryMap.end()) {
LOG(FATAL) << "Error: didn't find vaddr 0x" << std::hex << vaddr;
}
- LIR* newLabel = static_cast<LIR*>(oatNew(cUnit, sizeof(LIR), true, kAllocLIR));
+ LIR* newLabel = static_cast<LIR*>(NewMem(cUnit, sizeof(LIR), true, kAllocLIR));
newLabel->dalvikOffset = vaddr;
newLabel->opcode = kPseudoCaseLabel;
newLabel->operands[0] = keyVal;
- oatInsertLIRAfter(it->second, newLabel);
+ InsertLIRAfter(it->second, newLabel);
return newLabel;
}
-void markPackedCaseLabels(CompilationUnit* cUnit, SwitchTable *tabRec)
+void MarkPackedCaseLabels(CompilationUnit* cUnit, SwitchTable *tabRec)
{
const uint16_t* table = tabRec->table;
int baseVaddr = tabRec->vaddr;
@@ -947,11 +936,11 @@
int entries = table[1];
int lowKey = s4FromSwitchData(&table[2]);
for (int i = 0; i < entries; i++) {
- tabRec->targets[i] = insertCaseLabel(cUnit, baseVaddr + targets[i], i + lowKey);
+ tabRec->targets[i] = InsertCaseLabel(cUnit, baseVaddr + targets[i], i + lowKey);
}
}
-void markSparseCaseLabels(CompilationUnit* cUnit, SwitchTable *tabRec)
+void MarkSparseCaseLabels(CompilationUnit* cUnit, SwitchTable *tabRec)
{
const uint16_t* table = tabRec->table;
int baseVaddr = tabRec->vaddr;
@@ -959,29 +948,29 @@
const int* keys = reinterpret_cast<const int*>(&table[2]);
const int* targets = &keys[entries];
for (int i = 0; i < entries; i++) {
- tabRec->targets[i] = insertCaseLabel(cUnit, baseVaddr + targets[i], keys[i]);
+ tabRec->targets[i] = InsertCaseLabel(cUnit, baseVaddr + targets[i], keys[i]);
}
}
-void oatProcessSwitchTables(CompilationUnit* cUnit)
+void ProcessSwitchTables(CompilationUnit* cUnit)
{
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&cUnit->switchTables, &iterator);
+ GrowableListIteratorInit(&cUnit->switchTables, &iterator);
while (true) {
SwitchTable *tabRec =
- reinterpret_cast<SwitchTable*>(oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<SwitchTable*>(GrowableListIteratorNext(&iterator));
if (tabRec == NULL) break;
if (tabRec->table[0] == Instruction::kPackedSwitchSignature) {
- markPackedCaseLabels(cUnit, tabRec);
+ MarkPackedCaseLabels(cUnit, tabRec);
} else if (tabRec->table[0] == Instruction::kSparseSwitchSignature) {
- markSparseCaseLabels(cUnit, tabRec);
+ MarkSparseCaseLabels(cUnit, tabRec);
} else {
LOG(FATAL) << "Invalid switch table";
}
}
}
-void dumpSparseSwitchTable(const uint16_t* table)
+void DumpSparseSwitchTable(const uint16_t* table)
/*
* Sparse switch data format:
* ushort ident = 0x0200 magic value
@@ -1003,7 +992,7 @@
}
}
-void dumpPackedSwitchTable(const uint16_t* table)
+void DumpPackedSwitchTable(const uint16_t* table)
/*
* Packed switch data format:
* ushort ident = 0x0100 magic value
@@ -1032,9 +1021,9 @@
* which we split a single Dalvik instruction, only the first MIR op
* associated with a Dalvik PC should be entered into the map.
*/
-LIR* markBoundary(CompilationUnit* cUnit, int offset, const char* instStr)
+LIR* MarkBoundary(CompilationUnit* cUnit, int offset, const char* instStr)
{
- LIR* res = newLIR1(cUnit, kPseudoDalvikByteCodeBoundary, reinterpret_cast<uintptr_t>(instStr));
+ LIR* res = NewLIR1(cUnit, kPseudoDalvikByteCodeBoundary, reinterpret_cast<uintptr_t>(instStr));
if (cUnit->boundaryMap.find(offset) == cUnit->boundaryMap.end()) {
cUnit->boundaryMap.Put(offset, res);
}
diff --git a/src/compiler/codegen/codegen_util.h b/src/compiler/codegen/codegen_util.h
index c50c0f0..9920014 100644
--- a/src/compiler/codegen/codegen_util.h
+++ b/src/compiler/codegen/codegen_util.h
@@ -21,32 +21,32 @@
inline int32_t s4FromSwitchData(const void* switchData) { return *reinterpret_cast<const int32_t*>(switchData); }
inline RegisterClass oatRegClassBySize(OpSize size) { return (size == kUnsignedHalf || size == kSignedHalf || size == kUnsignedByte || size == kSignedByte ) ? kCoreReg : kAnyReg; }
-void oatAssembleLIR(CompilationUnit* cUnit);
-void setMemRefType(LIR* lir, bool isLoad, int memType);
-void annotateDalvikRegAccess(LIR* lir, int regId, bool isLoad, bool is64bit);
-uint64_t oatGetRegMaskCommon(CompilationUnit* cUnit, int reg);
-void oatSetupRegMask(CompilationUnit* cUnit, uint64_t* mask, int reg);
-void setupResourceMasks(CompilationUnit* cUnit, LIR* lir);
-void oatDumpLIRInsn(CompilationUnit* cUnit, LIR* arg, unsigned char* baseAddr);
-void oatDumpPromotionMap(CompilationUnit *cUnit);
-void dumpMappingTable(const char* table_name, const std::string& descriptor, const std::string& name, const std::string& signature, const std::vector<uint32_t>& v);
-void oatCodegenDump(CompilationUnit* cUnit);
+void AssembleLIR(CompilationUnit* cUnit);
+void SetMemRefType(LIR* lir, bool isLoad, int memType);
+void AnnotateDalvikRegAccess(LIR* lir, int regId, bool isLoad, bool is64bit);
+uint64_t GetRegMaskCommon(CompilationUnit* cUnit, int reg);
+void SetupRegMask(CompilationUnit* cUnit, uint64_t* mask, int reg);
+void SetupResourceMasks(CompilationUnit* cUnit, LIR* lir);
+void DumpLIRInsn(CompilationUnit* cUnit, LIR* arg, unsigned char* baseAddr);
+void DumpPromotionMap(CompilationUnit *cUnit);
+void DumpMappingTable(const char* table_name, const std::string& descriptor, const std::string& name, const std::string& signature, const std::vector<uint32_t>& v);
+void CodegenDump(CompilationUnit* cUnit);
// TODO: remove default parameters
-LIR* rawLIR(CompilationUnit* cUnit, int dalvikOffset, int opcode, int op0 = 0, int op1 = 0, int op2 = 0, int op3 = 0, int op4 = 0, LIR* target = NULL);
-LIR* newLIR0(CompilationUnit* cUnit, int opcode);
-LIR* newLIR1(CompilationUnit* cUnit, int opcode, int dest);
-LIR* newLIR2(CompilationUnit* cUnit, int opcode, int dest, int src1);
-LIR* newLIR3(CompilationUnit* cUnit, int opcode, int dest, int src1, int src2);
-LIR* newLIR4(CompilationUnit* cUnit, int opcode, int dest, int src1, int src2, int info);
-LIR* newLIR5(CompilationUnit* cUnit, int opcode, int dest, int src1, int src2, int info1, int info2);
-LIR* scanLiteralPool(LIR* dataTarget, int value, unsigned int delta);
-LIR* scanLiteralPoolWide(LIR* dataTarget, int valLo, int valHi);
-LIR* addWordData(CompilationUnit* cUnit, LIR* *constantListP, int value);
-LIR* addWideData(CompilationUnit* cUnit, LIR* *constantListP, int valLo, int valHi);
-void oatProcessSwitchTables(CompilationUnit* cUnit);
-void dumpSparseSwitchTable(const uint16_t* table);
-void dumpPackedSwitchTable(const uint16_t* table);
-LIR* markBoundary(CompilationUnit* cUnit, int offset, const char* instStr);
+LIR* RawLIR(CompilationUnit* cUnit, int dalvikOffset, int opcode, int op0 = 0, int op1 = 0, int op2 = 0, int op3 = 0, int op4 = 0, LIR* target = NULL);
+LIR* NewLIR0(CompilationUnit* cUnit, int opcode);
+LIR* NewLIR1(CompilationUnit* cUnit, int opcode, int dest);
+LIR* NewLIR2(CompilationUnit* cUnit, int opcode, int dest, int src1);
+LIR* NewLIR3(CompilationUnit* cUnit, int opcode, int dest, int src1, int src2);
+LIR* NewLIR4(CompilationUnit* cUnit, int opcode, int dest, int src1, int src2, int info);
+LIR* NewLIR5(CompilationUnit* cUnit, int opcode, int dest, int src1, int src2, int info1, int info2);
+LIR* ScanLiteralPool(LIR* dataTarget, int value, unsigned int delta);
+LIR* ScanLiteralPoolWide(LIR* dataTarget, int valLo, int valHi);
+LIR* AddWordData(CompilationUnit* cUnit, LIR* *constantListP, int value);
+LIR* AddWideData(CompilationUnit* cUnit, LIR* *constantListP, int valLo, int valHi);
+void ProcessSwitchTables(CompilationUnit* cUnit);
+void DumpSparseSwitchTable(const uint16_t* table);
+void DumpPackedSwitchTable(const uint16_t* table);
+LIR* MarkBoundary(CompilationUnit* cUnit, int offset, const char* instStr);
} // namespace art
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
diff --git a/src/compiler/codegen/gen_common.h b/src/compiler/codegen/gen_common.h
index db4b74c..04e32f2 100644
--- a/src/compiler/codegen/gen_common.h
+++ b/src/compiler/codegen/gen_common.h
@@ -17,66 +17,66 @@
#ifndef ART_SRC_COMPILER_CODEGEN_GENCOMMON_H_
#define ART_SRC_COMPILER_CODEGEN_GENCOMMON_H_
-void markSafepointPC(CompilationUnit* cUnit, LIR* inst);
-void callRuntimeHelperImm(CompilationUnit* cUnit, int helperOffset, int arg0, bool safepointPC);
-void callRuntimeHelperReg(CompilationUnit* cUnit, int helperOffset, int arg0, bool safepointPC);
-void callRuntimeHelperRegLocation(CompilationUnit* cUnit, int helperOffset, RegLocation arg0, bool safepointPC);
-void callRuntimeHelperImmImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1, bool safepointPC);
-void callRuntimeHelperImmRegLocation(CompilationUnit* cUnit, int helperOffset, int arg0, RegLocation arg1, bool safepointPC);
-void callRuntimeHelperRegLocationImm(CompilationUnit* cUnit, int helperOffset, RegLocation arg0, int arg1, bool safepointPC);
-void callRuntimeHelperImmReg(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1, bool safepointPC);
-void callRuntimeHelperRegImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1, bool safepointPC);
-void callRuntimeHelperImmMethod(CompilationUnit* cUnit, int helperOffset, int arg0, bool safepointPC);
-void callRuntimeHelperRegLocationRegLocation(CompilationUnit* cUnit, int helperOffset, RegLocation arg0, RegLocation arg1, bool safepointPC);
-void callRuntimeHelperRegReg(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1, bool safepointPC);
-void callRuntimeHelperRegRegImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1, int arg2, bool safepointPC);
-void callRuntimeHelperImmMethodRegLocation(CompilationUnit* cUnit, int helperOffset, int arg0, RegLocation arg2, bool safepointPC);
-void callRuntimeHelperImmMethodImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg2, bool safepointPC);
-void callRuntimeHelperImmRegLocationRegLocation(CompilationUnit* cUnit, int helperOffset, int arg0, RegLocation arg1, RegLocation arg2, bool safepointPC);
-void genBarrier(CompilationUnit* cUnit);
-LIR* opUnconditionalBranch(CompilationUnit* cUnit, LIR* target);
-LIR* genCheck(CompilationUnit* cUnit, ConditionCode cCode, ThrowKind kind);
-LIR* genImmedCheck(CompilationUnit* cUnit, ConditionCode cCode, int reg, int immVal, ThrowKind kind);
-LIR* genNullCheck(CompilationUnit* cUnit, int sReg, int mReg, int optFlags);
-LIR* genRegRegCheck(CompilationUnit* cUnit, ConditionCode cCode, int reg1, int reg2, ThrowKind kind);
-void genCompareAndBranch(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlSrc1, RegLocation rlSrc2, LIR* taken, LIR* fallThrough);
-void genCompareZeroAndBranch(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlSrc, LIR* taken, LIR* fallThrough);
-void genIntToLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
-void genIntNarrowing(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc);
-void genNewArray(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest, RegLocation rlSrc);
-void genFilledNewArray(CompilationUnit* cUnit, CallInfo* info);
-void genSput(CompilationUnit* cUnit, uint32_t fieldIdx, RegLocation rlSrc, bool isLongOrDouble, bool isObject);
-void genSget(CompilationUnit* cUnit, uint32_t fieldIdx, RegLocation rlDest, bool isLongOrDouble, bool isObject);
-void genShowTarget(CompilationUnit* cUnit);
-void handleSuspendLaunchpads(CompilationUnit *cUnit);
-void handleIntrinsicLaunchpads(CompilationUnit *cUnit);
-void handleThrowLaunchpads(CompilationUnit *cUnit);
-void oatSetupResourceMasks(CompilationUnit* cUnit, LIR* lir);
-bool fastInstance(CompilationUnit* cUnit, uint32_t fieldIdx, int& fieldOffset, bool& isVolatile, bool isPut);
-void genIGet(CompilationUnit* cUnit, uint32_t fieldIdx, int optFlags, OpSize size, RegLocation rlDest, RegLocation rlObj, bool isLongOrDouble, bool isObject);
-void genIPut(CompilationUnit* cUnit, uint32_t fieldIdx, int optFlags, OpSize size, RegLocation rlSrc, RegLocation rlObj, bool isLongOrDouble, bool isObject);
-void genConstClass(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest);
-void genConstString(CompilationUnit* cUnit, uint32_t string_idx, RegLocation rlDest);
-void genNewInstance(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest);
-void genMoveException(CompilationUnit* cUnit, RegLocation rlDest);
-void genThrow(CompilationUnit* cUnit, RegLocation rlSrc);
-void genInstanceof(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest, RegLocation rlSrc);
-void genCheckCast(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlSrc);
-void genArrayObjPut(CompilationUnit* cUnit, int optFlags, RegLocation rlArray, RegLocation rlIndex, RegLocation rlSrc, int scale);
-void genArrayGet(CompilationUnit* cUnit, int optFlags, OpSize size, RegLocation rlArray, RegLocation rlIndex, RegLocation rlDest, int scale);
-void genArrayPut(CompilationUnit* cUnit, int optFlags, OpSize size, RegLocation rlArray, RegLocation rlIndex, RegLocation rlSrc, int scale);
-void genLong3Addr(CompilationUnit* cUnit, OpKind firstOp, OpKind secondOp, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool genShiftOpLong(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlShift);
-bool genArithOpInt(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool handleEasyDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode, RegLocation rlSrc, RegLocation rlDest, int lit);
-bool handleEasyMultiply(CompilationUnit* cUnit, RegLocation rlSrc, RegLocation rlDest, int lit);
-bool genArithOpIntLit(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc, int lit);
-bool genArithOpLong(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool genConversionCall(CompilationUnit* cUnit, int funcOffset, RegLocation rlDest, RegLocation rlSrc);
-bool genArithOpFloatPortable(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool genArithOpDoublePortable(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool genConversionPortable(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc);
-void genSuspendTest(CompilationUnit* cUnit, int optFlags);
-void genSuspendTestAndBranch(CompilationUnit* cUnit, int optFlags, LIR* target);
+void MarkSafepointPC(CompilationUnit* cUnit, LIR* inst);
+void CallRuntimeHelperImm(CompilationUnit* cUnit, int helperOffset, int arg0, bool safepointPC);
+void CallRuntimeHelperReg(CompilationUnit* cUnit, int helperOffset, int arg0, bool safepointPC);
+void CallRuntimeHelperRegLocation(CompilationUnit* cUnit, int helperOffset, RegLocation arg0, bool safepointPC);
+void CallRuntimeHelperImmImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1, bool safepointPC);
+void CallRuntimeHelperImmRegLocation(CompilationUnit* cUnit, int helperOffset, int arg0, RegLocation arg1, bool safepointPC);
+void CallRuntimeHelperRegLocationImm(CompilationUnit* cUnit, int helperOffset, RegLocation arg0, int arg1, bool safepointPC);
+void CallRuntimeHelperImmReg(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1, bool safepointPC);
+void CallRuntimeHelperRegImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1, bool safepointPC);
+void CallRuntimeHelperImmMethod(CompilationUnit* cUnit, int helperOffset, int arg0, bool safepointPC);
+void CallRuntimeHelperRegLocationRegLocation(CompilationUnit* cUnit, int helperOffset, RegLocation arg0, RegLocation arg1, bool safepointPC);
+void CallRuntimeHelperRegReg(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1, bool safepointPC);
+void CallRuntimeHelperRegRegImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg1, int arg2, bool safepointPC);
+void CallRuntimeHelperImmMethodRegLocation(CompilationUnit* cUnit, int helperOffset, int arg0, RegLocation arg2, bool safepointPC);
+void CallRuntimeHelperImmMethodImm(CompilationUnit* cUnit, int helperOffset, int arg0, int arg2, bool safepointPC);
+void CallRuntimeHelperImmRegLocationRegLocation(CompilationUnit* cUnit, int helperOffset, int arg0, RegLocation arg1, RegLocation arg2, bool safepointPC);
+void GenBarrier(CompilationUnit* cUnit);
+LIR* OpUnconditionalBranch(CompilationUnit* cUnit, LIR* target);
+LIR* GenCheck(CompilationUnit* cUnit, ConditionCode cCode, ThrowKind kind);
+LIR* GenImmedCheck(CompilationUnit* cUnit, ConditionCode cCode, int reg, int immVal, ThrowKind kind);
+LIR* GenNullCheck(CompilationUnit* cUnit, int sReg, int mReg, int optFlags);
+LIR* GenRegRegCheck(CompilationUnit* cUnit, ConditionCode cCode, int reg1, int reg2, ThrowKind kind);
+void GenCompareAndBranch(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlSrc1, RegLocation rlSrc2, LIR* taken, LIR* fallThrough);
+void GenCompareZeroAndBranch(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlSrc, LIR* taken, LIR* fallThrough);
+void GenIntToLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
+void GenIntNarrowing(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc);
+void GenNewArray(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest, RegLocation rlSrc);
+void GenFilledNewArray(CompilationUnit* cUnit, CallInfo* info);
+void GenSput(CompilationUnit* cUnit, uint32_t fieldIdx, RegLocation rlSrc, bool isLongOrDouble, bool isObject);
+void GenSget(CompilationUnit* cUnit, uint32_t fieldIdx, RegLocation rlDest, bool isLongOrDouble, bool isObject);
+void GenShowTarget(CompilationUnit* cUnit);
+void HandleSuspendLaunchPads(CompilationUnit *cUnit);
+void HandleIntrinsicLaunchPads(CompilationUnit *cUnit);
+void HandleThrowLaunchPads(CompilationUnit *cUnit);
+void SetupResourceMasks(CompilationUnit* cUnit, LIR* lir);
+bool FastInstance(CompilationUnit* cUnit, uint32_t fieldIdx, int& fieldOffset, bool& isVolatile, bool isPut);
+void GenIGet(CompilationUnit* cUnit, uint32_t fieldIdx, int optFlags, OpSize size, RegLocation rlDest, RegLocation rlObj, bool isLongOrDouble, bool isObject);
+void GenIPut(CompilationUnit* cUnit, uint32_t fieldIdx, int optFlags, OpSize size, RegLocation rlSrc, RegLocation rlObj, bool isLongOrDouble, bool isObject);
+void GenConstClass(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest);
+void GenConstString(CompilationUnit* cUnit, uint32_t string_idx, RegLocation rlDest);
+void GenNewInstance(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest);
+void GenMoveException(CompilationUnit* cUnit, RegLocation rlDest);
+void GenThrow(CompilationUnit* cUnit, RegLocation rlSrc);
+void GenInstanceof(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlDest, RegLocation rlSrc);
+void GenCheckCast(CompilationUnit* cUnit, uint32_t type_idx, RegLocation rlSrc);
+void GenArrayObjPut(CompilationUnit* cUnit, int optFlags, RegLocation rlArray, RegLocation rlIndex, RegLocation rlSrc, int scale);
+void GenArrayGet(CompilationUnit* cUnit, int optFlags, OpSize size, RegLocation rlArray, RegLocation rlIndex, RegLocation rlDest, int scale);
+void GenArrayPut(CompilationUnit* cUnit, int optFlags, OpSize size, RegLocation rlArray, RegLocation rlIndex, RegLocation rlSrc, int scale);
+void GenLong3Addr(CompilationUnit* cUnit, OpKind firstOp, OpKind secondOp, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool GenShiftOpLong(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlShift);
+bool GenArithOpInt(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool HandleEasyDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode, RegLocation rlSrc, RegLocation rlDest, int lit);
+bool HandleEasyMultiply(CompilationUnit* cUnit, RegLocation rlSrc, RegLocation rlDest, int lit);
+bool GenArithOpIntLit(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc, int lit);
+bool GenArithOpLong(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool GenConversionCall(CompilationUnit* cUnit, int funcOffset, RegLocation rlDest, RegLocation rlSrc);
+bool GenArithOpFloatPortable(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool GenArithOpDoublePortable(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool GenConversionPortable(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc);
+void GenSuspendTest(CompilationUnit* cUnit, int optFlags);
+void GenSuspendTestAndBranch(CompilationUnit* cUnit, int optFlags, LIR* target);
#endif // ART_SRC_COMPILER_CODEGEN_GENCOMMON_H_
diff --git a/src/compiler/codegen/gen_invoke.cc b/src/compiler/codegen/gen_invoke.cc
index 90fc14b..6f8b092 100644
--- a/src/compiler/codegen/gen_invoke.cc
+++ b/src/compiler/codegen/gen_invoke.cc
@@ -32,10 +32,10 @@
* to a callee-save register, flush them to the frame. Perform intial
* assignment of promoted arguments.
*
- * argLocs is an array of location records describing the incoming arguments
+ * ArgLocs is an array of location records describing the incoming arguments
* with one location record per word of argument.
*/
-void flushIns(CompilationUnit* cUnit, RegLocation* argLocs, RegLocation rlMethod)
+void FlushIns(CompilationUnit* cUnit, RegLocation* ArgLocs, RegLocation rlMethod)
{
/*
* Dummy up a RegLocation for the incoming Method*
@@ -44,13 +44,13 @@
*/
RegLocation rlSrc = rlMethod;
rlSrc.location = kLocPhysReg;
- rlSrc.lowReg = targetReg(kArg0);
+ rlSrc.lowReg = TargetReg(kArg0);
rlSrc.home = false;
- oatMarkLive(cUnit, rlSrc.lowReg, rlSrc.sRegLow);
- storeValue(cUnit, rlMethod, rlSrc);
+ MarkLive(cUnit, rlSrc.lowReg, rlSrc.sRegLow);
+ StoreValue(cUnit, rlMethod, rlSrc);
// If Method* has been promoted, explicitly flush
if (rlMethod.location == kLocPhysReg) {
- storeWordDisp(cUnit, targetReg(kSp), 0, targetReg(kArg0));
+ StoreWordDisp(cUnit, TargetReg(kSp), 0, TargetReg(kArg0));
}
if (cUnit->numIns == 0)
@@ -75,12 +75,12 @@
if (i < numArgRegs) {
// If arriving in register
bool needFlush = true;
- RegLocation* tLoc = &argLocs[i];
+ RegLocation* tLoc = &ArgLocs[i];
if ((vMap->coreLocation == kLocPhysReg) && !tLoc->fp) {
- opRegCopy(cUnit, vMap->coreReg, targetReg(argRegs[i]));
+ OpRegCopy(cUnit, vMap->coreReg, TargetReg(argRegs[i]));
needFlush = false;
} else if ((vMap->fpLocation == kLocPhysReg) && tLoc->fp) {
- opRegCopy(cUnit, vMap->fpReg, targetReg(argRegs[i]));
+ OpRegCopy(cUnit, vMap->FpReg, TargetReg(argRegs[i]));
needFlush = false;
} else {
needFlush = true;
@@ -93,24 +93,24 @@
(pMap->fpLocation != vMap->fpLocation);
}
if (needFlush) {
- storeBaseDisp(cUnit, targetReg(kSp), oatSRegOffset(cUnit, startVReg + i),
- targetReg(argRegs[i]), kWord);
+ StoreBaseDisp(cUnit, TargetReg(kSp), SRegOffset(cUnit, startVReg + i),
+ TargetReg(argRegs[i]), kWord);
}
} else {
// If arriving in frame & promoted
if (vMap->coreLocation == kLocPhysReg) {
- loadWordDisp(cUnit, targetReg(kSp), oatSRegOffset(cUnit, startVReg + i),
+ LoadWordDisp(cUnit, TargetReg(kSp), SRegOffset(cUnit, startVReg + i),
vMap->coreReg);
}
if (vMap->fpLocation == kLocPhysReg) {
- loadWordDisp(cUnit, targetReg(kSp), oatSRegOffset(cUnit, startVReg + i),
- vMap->fpReg);
+ LoadWordDisp(cUnit, TargetReg(kSp), SRegOffset(cUnit, startVReg + i),
+ vMap->FpReg);
}
}
}
}
-void scanMethodLiteralPool(CompilationUnit* cUnit, LIR** methodTarget, LIR** codeTarget,
+void ScanMethodLiteralPool(CompilationUnit* cUnit, LIR** methodTarget, LIR** codeTarget,
const DexFile* dexFile, uint32_t dexMethodIdx)
{
LIR* curTarget = cUnit->methodLiteralList;
@@ -134,7 +134,7 @@
* Bit of a hack here - in the absence of a real scheduling pass,
* emit the next instruction in static & direct invoke sequences.
*/
-int nextSDCallInsn(CompilationUnit* cUnit, CallInfo* info,
+int NextSDCallInsn(CompilationUnit* cUnit, CallInfo* info,
int state, uint32_t dexIdx, uint32_t unused,
uintptr_t directCode, uintptr_t directMethod,
InvokeType type)
@@ -148,27 +148,27 @@
switch (state) {
case 0: // Get the current Method* [sets kArg0]
if (directCode != static_cast<unsigned int>(-1)) {
- loadConstant(cUnit, targetReg(kInvokeTgt), directCode);
+ LoadConstant(cUnit, TargetReg(kInvokeTgt), directCode);
} else {
- LIR* dataTarget = scanLiteralPool(cUnit->codeLiteralList, dexIdx, 0);
+ LIR* dataTarget = ScanLiteralPool(cUnit->codeLiteralList, dexIdx, 0);
if (dataTarget == NULL) {
- dataTarget = addWordData(cUnit, &cUnit->codeLiteralList, dexIdx);
+ dataTarget = AddWordData(cUnit, &cUnit->codeLiteralList, dexIdx);
dataTarget->operands[1] = type;
}
- LIR* loadPcRel = opPcRelLoad(cUnit, targetReg(kInvokeTgt), dataTarget);
- oatAppendLIR(cUnit, loadPcRel);
+ LIR* loadPcRel = OpPcRelLoad(cUnit, TargetReg(kInvokeTgt), dataTarget);
+ AppendLIR(cUnit, loadPcRel);
DCHECK_EQ(cUnit->instructionSet, kThumb2) << reinterpret_cast<void*>(dataTarget);
}
if (directMethod != static_cast<unsigned int>(-1)) {
- loadConstant(cUnit, targetReg(kArg0), directMethod);
+ LoadConstant(cUnit, TargetReg(kArg0), directMethod);
} else {
- LIR* dataTarget = scanLiteralPool(cUnit->methodLiteralList, dexIdx, 0);
+ LIR* dataTarget = ScanLiteralPool(cUnit->methodLiteralList, dexIdx, 0);
if (dataTarget == NULL) {
- dataTarget = addWordData(cUnit, &cUnit->methodLiteralList, dexIdx);
+ dataTarget = AddWordData(cUnit, &cUnit->methodLiteralList, dexIdx);
dataTarget->operands[1] = type;
}
- LIR* loadPcRel = opPcRelLoad(cUnit, targetReg(kArg0), dataTarget);
- oatAppendLIR(cUnit, loadPcRel);
+ LIR* loadPcRel = OpPcRelLoad(cUnit, TargetReg(kArg0), dataTarget);
+ AppendLIR(cUnit, loadPcRel);
DCHECK_EQ(cUnit->instructionSet, kThumb2) << reinterpret_cast<void*>(dataTarget);
}
break;
@@ -179,36 +179,36 @@
switch (state) {
case 0: // Get the current Method* [sets kArg0]
// TUNING: we can save a reg copy if Method* has been promoted.
- loadCurrMethodDirect(cUnit, targetReg(kArg0));
+ LoadCurrMethodDirect(cUnit, TargetReg(kArg0));
break;
case 1: // Get method->dex_cache_resolved_methods_
- loadWordDisp(cUnit, targetReg(kArg0),
- AbstractMethod::DexCacheResolvedMethodsOffset().Int32Value(), targetReg(kArg0));
+ LoadWordDisp(cUnit, TargetReg(kArg0),
+ AbstractMethod::DexCacheResolvedMethodsOffset().Int32Value(), TargetReg(kArg0));
// Set up direct code if known.
if (directCode != 0) {
if (directCode != static_cast<unsigned int>(-1)) {
- loadConstant(cUnit, targetReg(kInvokeTgt), directCode);
+ LoadConstant(cUnit, TargetReg(kInvokeTgt), directCode);
} else {
- LIR* dataTarget = scanLiteralPool(cUnit->codeLiteralList, dexIdx, 0);
+ LIR* dataTarget = ScanLiteralPool(cUnit->codeLiteralList, dexIdx, 0);
if (dataTarget == NULL) {
- dataTarget = addWordData(cUnit, &cUnit->codeLiteralList, dexIdx);
+ dataTarget = AddWordData(cUnit, &cUnit->codeLiteralList, dexIdx);
dataTarget->operands[1] = type;
}
- LIR* loadPcRel = opPcRelLoad(cUnit, targetReg(kInvokeTgt), dataTarget);
- oatAppendLIR(cUnit, loadPcRel);
+ LIR* loadPcRel = OpPcRelLoad(cUnit, TargetReg(kInvokeTgt), dataTarget);
+ AppendLIR(cUnit, loadPcRel);
DCHECK_EQ(cUnit->instructionSet, kThumb2) << reinterpret_cast<void*>(dataTarget);
}
}
break;
case 2: // Grab target method*
- loadWordDisp(cUnit, targetReg(kArg0),
- Array::DataOffset(sizeof(Object*)).Int32Value() + dexIdx * 4, targetReg(kArg0));
+ LoadWordDisp(cUnit, TargetReg(kArg0),
+ Array::DataOffset(sizeof(Object*)).Int32Value() + dexIdx * 4, TargetReg(kArg0));
break;
case 3: // Grab the code from the method*
if (cUnit->instructionSet != kX86) {
if (directCode == 0) {
- loadWordDisp(cUnit, targetReg(kArg0), AbstractMethod::GetCodeOffset().Int32Value(),
- targetReg(kInvokeTgt));
+ LoadWordDisp(cUnit, TargetReg(kArg0), AbstractMethod::GetCodeOffset().Int32Value(),
+ TargetReg(kInvokeTgt));
}
break;
}
@@ -225,9 +225,9 @@
* emit the next instruction in a virtual invoke sequence.
* We can use kLr as a temp prior to target address loading
* Note also that we'll load the first argument ("this") into
- * kArg1 here rather than the standard loadArgRegs.
+ * kArg1 here rather than the standard LoadArgRegs.
*/
-int nextVCallInsn(CompilationUnit* cUnit, CallInfo* info,
+int NextVCallInsn(CompilationUnit* cUnit, CallInfo* info,
int state, uint32_t dexIdx, uint32_t methodIdx,
uintptr_t unused, uintptr_t unused2, InvokeType unused3)
{
@@ -238,27 +238,27 @@
switch (state) {
case 0: { // Get "this" [set kArg1]
RegLocation rlArg = info->args[0];
- loadValueDirectFixed(cUnit, rlArg, targetReg(kArg1));
+ LoadValueDirectFixed(cUnit, rlArg, TargetReg(kArg1));
break;
}
case 1: // Is "this" null? [use kArg1]
- genNullCheck(cUnit, info->args[0].sRegLow, targetReg(kArg1), info->optFlags);
+ GenNullCheck(cUnit, info->args[0].sRegLow, TargetReg(kArg1), info->optFlags);
// get this->klass_ [use kArg1, set kInvokeTgt]
- loadWordDisp(cUnit, targetReg(kArg1), Object::ClassOffset().Int32Value(),
- targetReg(kInvokeTgt));
+ LoadWordDisp(cUnit, TargetReg(kArg1), Object::ClassOffset().Int32Value(),
+ TargetReg(kInvokeTgt));
break;
case 2: // Get this->klass_->vtable [usr kInvokeTgt, set kInvokeTgt]
- loadWordDisp(cUnit, targetReg(kInvokeTgt), Class::VTableOffset().Int32Value(),
- targetReg(kInvokeTgt));
+ LoadWordDisp(cUnit, TargetReg(kInvokeTgt), Class::VTableOffset().Int32Value(),
+ TargetReg(kInvokeTgt));
break;
case 3: // Get target method [use kInvokeTgt, set kArg0]
- loadWordDisp(cUnit, targetReg(kInvokeTgt), (methodIdx * 4) +
- Array::DataOffset(sizeof(Object*)).Int32Value(), targetReg(kArg0));
+ LoadWordDisp(cUnit, TargetReg(kInvokeTgt), (methodIdx * 4) +
+ Array::DataOffset(sizeof(Object*)).Int32Value(), TargetReg(kArg0));
break;
case 4: // Get the compiled code address [uses kArg0, sets kInvokeTgt]
if (cUnit->instructionSet != kX86) {
- loadWordDisp(cUnit, targetReg(kArg0), AbstractMethod::GetCodeOffset().Int32Value(),
- targetReg(kInvokeTgt));
+ LoadWordDisp(cUnit, TargetReg(kArg0), AbstractMethod::GetCodeOffset().Int32Value(),
+ TargetReg(kInvokeTgt));
break;
}
// Intentional fallthrough for X86
@@ -272,7 +272,7 @@
* All invoke-interface calls bounce off of art_invoke_interface_trampoline,
* which will locate the target and continue on via a tail call.
*/
-int nextInterfaceCallInsn(CompilationUnit* cUnit, CallInfo* info, int state,
+int NextInterfaceCallInsn(CompilationUnit* cUnit, CallInfo* info, int state,
uint32_t dexIdx, uint32_t unused, uintptr_t unused2,
uintptr_t directMethod, InvokeType unused4)
{
@@ -287,19 +287,19 @@
switch (state) {
case 0: // Load the trampoline target [sets kInvokeTgt].
if (cUnit->instructionSet != kX86) {
- loadWordDisp(cUnit, targetReg(kSelf), trampoline, targetReg(kInvokeTgt));
+ LoadWordDisp(cUnit, TargetReg(kSelf), trampoline, TargetReg(kInvokeTgt));
}
// Get the interface Method* [sets kArg0]
if (directMethod != static_cast<unsigned int>(-1)) {
- loadConstant(cUnit, targetReg(kArg0), directMethod);
+ LoadConstant(cUnit, TargetReg(kArg0), directMethod);
} else {
- LIR* dataTarget = scanLiteralPool(cUnit->methodLiteralList, dexIdx, 0);
+ LIR* dataTarget = ScanLiteralPool(cUnit->methodLiteralList, dexIdx, 0);
if (dataTarget == NULL) {
- dataTarget = addWordData(cUnit, &cUnit->methodLiteralList, dexIdx);
+ dataTarget = AddWordData(cUnit, &cUnit->methodLiteralList, dexIdx);
dataTarget->operands[1] = kInterface;
}
- LIR* loadPcRel = opPcRelLoad(cUnit, targetReg(kArg0), dataTarget);
- oatAppendLIR(cUnit, loadPcRel);
+ LIR* loadPcRel = OpPcRelLoad(cUnit, TargetReg(kArg0), dataTarget);
+ AppendLIR(cUnit, loadPcRel);
DCHECK_EQ(cUnit->instructionSet, kThumb2) << reinterpret_cast<void*>(dataTarget);
}
break;
@@ -310,21 +310,21 @@
switch (state) {
case 0:
// Get the current Method* [sets kArg0] - TUNING: remove copy of method if it is promoted.
- loadCurrMethodDirect(cUnit, targetReg(kArg0));
+ LoadCurrMethodDirect(cUnit, TargetReg(kArg0));
// Load the trampoline target [sets kInvokeTgt].
if (cUnit->instructionSet != kX86) {
- loadWordDisp(cUnit, targetReg(kSelf), trampoline, targetReg(kInvokeTgt));
+ LoadWordDisp(cUnit, TargetReg(kSelf), trampoline, TargetReg(kInvokeTgt));
}
break;
case 1: // Get method->dex_cache_resolved_methods_ [set/use kArg0]
- loadWordDisp(cUnit, targetReg(kArg0),
+ LoadWordDisp(cUnit, TargetReg(kArg0),
AbstractMethod::DexCacheResolvedMethodsOffset().Int32Value(),
- targetReg(kArg0));
+ TargetReg(kArg0));
break;
case 2: // Grab target method* [set/use kArg0]
- loadWordDisp(cUnit, targetReg(kArg0),
+ LoadWordDisp(cUnit, TargetReg(kArg0),
Array::DataOffset(sizeof(Object*)).Int32Value() + dexIdx * 4,
- targetReg(kArg0));
+ TargetReg(kArg0));
break;
default:
return -1;
@@ -333,7 +333,7 @@
return state + 1;
}
-int nextInvokeInsnSP(CompilationUnit* cUnit, CallInfo* info, int trampoline,
+int NextInvokeInsnSP(CompilationUnit* cUnit, CallInfo* info, int trampoline,
int state, uint32_t dexIdx, uint32_t methodIdx)
{
/*
@@ -343,65 +343,65 @@
if (state == 0) {
if (cUnit->instructionSet != kX86) {
// Load trampoline target
- loadWordDisp(cUnit, targetReg(kSelf), trampoline, targetReg(kInvokeTgt));
+ LoadWordDisp(cUnit, TargetReg(kSelf), trampoline, TargetReg(kInvokeTgt));
}
// Load kArg0 with method index
- loadConstant(cUnit, targetReg(kArg0), dexIdx);
+ LoadConstant(cUnit, TargetReg(kArg0), dexIdx);
return 1;
}
return -1;
}
-int nextStaticCallInsnSP(CompilationUnit* cUnit, CallInfo* info,
+int NextStaticCallInsnSP(CompilationUnit* cUnit, CallInfo* info,
int state, uint32_t dexIdx, uint32_t methodIdx,
uintptr_t unused, uintptr_t unused2,
InvokeType unused3)
{
int trampoline = ENTRYPOINT_OFFSET(pInvokeStaticTrampolineWithAccessCheck);
- return nextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
+ return NextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
}
-int nextDirectCallInsnSP(CompilationUnit* cUnit, CallInfo* info, int state,
+int NextDirectCallInsnSP(CompilationUnit* cUnit, CallInfo* info, int state,
uint32_t dexIdx, uint32_t methodIdx, uintptr_t unused,
uintptr_t unused2, InvokeType unused3)
{
int trampoline = ENTRYPOINT_OFFSET(pInvokeDirectTrampolineWithAccessCheck);
- return nextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
+ return NextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
}
-int nextSuperCallInsnSP(CompilationUnit* cUnit, CallInfo* info, int state,
+int NextSuperCallInsnSP(CompilationUnit* cUnit, CallInfo* info, int state,
uint32_t dexIdx, uint32_t methodIdx, uintptr_t unused,
uintptr_t unused2, InvokeType unused3)
{
int trampoline = ENTRYPOINT_OFFSET(pInvokeSuperTrampolineWithAccessCheck);
- return nextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
+ return NextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
}
-int nextVCallInsnSP(CompilationUnit* cUnit, CallInfo* info, int state,
+int NextVCallInsnSP(CompilationUnit* cUnit, CallInfo* info, int state,
uint32_t dexIdx, uint32_t methodIdx, uintptr_t unused,
uintptr_t unused2, InvokeType unused3)
{
int trampoline = ENTRYPOINT_OFFSET(pInvokeVirtualTrampolineWithAccessCheck);
- return nextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
+ return NextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
}
-int nextInterfaceCallInsnWithAccessCheck(CompilationUnit* cUnit,
+int NextInterfaceCallInsnWithAccessCheck(CompilationUnit* cUnit,
CallInfo* info, int state,
uint32_t dexIdx, uint32_t unused,
uintptr_t unused2, uintptr_t unused3,
InvokeType unused4)
{
int trampoline = ENTRYPOINT_OFFSET(pInvokeInterfaceTrampolineWithAccessCheck);
- return nextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
+ return NextInvokeInsnSP(cUnit, info, trampoline, state, dexIdx, 0);
}
-int loadArgRegs(CompilationUnit* cUnit, CallInfo* info, int callState,
+int LoadArgRegs(CompilationUnit* cUnit, CallInfo* info, int callState,
NextCallInsn nextCallInsn, uint32_t dexIdx,
uint32_t methodIdx, uintptr_t directCode,
uintptr_t directMethod, InvokeType type, bool skipThis)
{
- int lastArgReg = targetReg(kArg3);
- int nextReg = targetReg(kArg1);
+ int lastArgReg = TargetReg(kArg3);
+ int nextReg = TargetReg(kArg1);
int nextArg = 0;
if (skipThis) {
nextReg++;
@@ -409,14 +409,14 @@
}
for (; (nextReg <= lastArgReg) && (nextArg < info->numArgWords); nextReg++) {
RegLocation rlArg = info->args[nextArg++];
- rlArg = oatUpdateRawLoc(cUnit, rlArg);
- if (rlArg.wide && (nextReg <= targetReg(kArg2))) {
- loadValueDirectWideFixed(cUnit, rlArg, nextReg, nextReg + 1);
+ rlArg = UpdateRawLoc(cUnit, rlArg);
+ if (rlArg.wide && (nextReg <= TargetReg(kArg2))) {
+ LoadValueDirectWideFixed(cUnit, rlArg, nextReg, nextReg + 1);
nextReg++;
nextArg++;
} else {
rlArg.wide = false;
- loadValueDirectFixed(cUnit, rlArg, nextReg);
+ LoadValueDirectFixed(cUnit, rlArg, nextReg);
}
callState = nextCallInsn(cUnit, info, callState, dexIdx, methodIdx,
directCode, directMethod, type);
@@ -431,7 +431,7 @@
* the target method pointer. Note, this may also be called
* for "range" variants if the number of arguments is 5 or fewer.
*/
-int genDalvikArgsNoRange(CompilationUnit* cUnit, CallInfo* info,
+int GenDalvikArgsNoRange(CompilationUnit* cUnit, CallInfo* info,
int callState,
LIR** pcrLabel, NextCallInsn nextCallInsn,
uint32_t dexIdx, uint32_t methodIdx,
@@ -458,18 +458,18 @@
rlUse2.wide) {
int reg = -1;
// Wide spans, we need the 2nd half of uses[2].
- rlArg = oatUpdateLocWide(cUnit, rlUse2);
+ rlArg = UpdateLocWide(cUnit, rlUse2);
if (rlArg.location == kLocPhysReg) {
reg = rlArg.highReg;
} else {
// kArg2 & rArg3 can safely be used here
- reg = targetReg(kArg3);
- loadWordDisp(cUnit, targetReg(kSp), oatSRegOffset(cUnit, rlArg.sRegLow) + 4, reg);
+ reg = TargetReg(kArg3);
+ LoadWordDisp(cUnit, TargetReg(kSp), SRegOffset(cUnit, rlArg.sRegLow) + 4, reg);
callState = nextCallInsn(cUnit, info, callState, dexIdx,
methodIdx, directCode, directMethod, type);
}
- storeBaseDisp(cUnit, targetReg(kSp), (nextUse + 1) * 4, reg, kWord);
- storeBaseDisp(cUnit, targetReg(kSp), 16 /* (3+1)*4 */, reg, kWord);
+ StoreBaseDisp(cUnit, TargetReg(kSp), (nextUse + 1) * 4, reg, kWord);
+ StoreBaseDisp(cUnit, TargetReg(kSp), 16 /* (3+1)*4 */, reg, kWord);
callState = nextCallInsn(cUnit, info, callState, dexIdx, methodIdx,
directCode, directMethod, type);
nextUse++;
@@ -479,27 +479,27 @@
int lowReg;
int highReg = -1;
rlArg = info->args[nextUse];
- rlArg = oatUpdateRawLoc(cUnit, rlArg);
+ rlArg = UpdateRawLoc(cUnit, rlArg);
if (rlArg.location == kLocPhysReg) {
lowReg = rlArg.lowReg;
highReg = rlArg.highReg;
} else {
- lowReg = targetReg(kArg2);
+ lowReg = TargetReg(kArg2);
if (rlArg.wide) {
- highReg = targetReg(kArg3);
- loadValueDirectWideFixed(cUnit, rlArg, lowReg, highReg);
+ highReg = TargetReg(kArg3);
+ LoadValueDirectWideFixed(cUnit, rlArg, lowReg, highReg);
} else {
- loadValueDirectFixed(cUnit, rlArg, lowReg);
+ LoadValueDirectFixed(cUnit, rlArg, lowReg);
}
callState = nextCallInsn(cUnit, info, callState, dexIdx,
methodIdx, directCode, directMethod, type);
}
int outsOffset = (nextUse + 1) * 4;
if (rlArg.wide) {
- storeBaseDispWide(cUnit, targetReg(kSp), outsOffset, lowReg, highReg);
+ StoreBaseDispWide(cUnit, TargetReg(kSp), outsOffset, lowReg, highReg);
nextUse += 2;
} else {
- storeWordDisp(cUnit, targetReg(kSp), outsOffset, lowReg);
+ StoreWordDisp(cUnit, TargetReg(kSp), outsOffset, lowReg);
nextUse++;
}
callState = nextCallInsn(cUnit, info, callState, dexIdx, methodIdx,
@@ -507,12 +507,12 @@
}
}
- callState = loadArgRegs(cUnit, info, callState, nextCallInsn,
+ callState = LoadArgRegs(cUnit, info, callState, nextCallInsn,
dexIdx, methodIdx, directCode, directMethod,
type, skipThis);
if (pcrLabel) {
- *pcrLabel = genNullCheck(cUnit, info->args[0].sRegLow, targetReg(kArg1), info->optFlags);
+ *pcrLabel = GenNullCheck(cUnit, info->args[0].sRegLow, TargetReg(kArg1), info->optFlags);
}
return callState;
}
@@ -532,7 +532,7 @@
* Pass arg0, arg1 & arg2 in kArg1-kArg3
*
*/
-int genDalvikArgsRange(CompilationUnit* cUnit, CallInfo* info, int callState,
+int GenDalvikArgsRange(CompilationUnit* cUnit, CallInfo* info, int callState,
LIR** pcrLabel, NextCallInsn nextCallInsn,
uint32_t dexIdx, uint32_t methodIdx,
uintptr_t directCode, uintptr_t directMethod,
@@ -541,7 +541,7 @@
// If we can treat it as non-range (Jumbo ops will use range form)
if (info->numArgWords <= 5)
- return genDalvikArgsNoRange(cUnit, info, callState, pcrLabel,
+ return GenDalvikArgsNoRange(cUnit, info, callState, pcrLabel,
nextCallInsn, dexIdx, methodIdx,
directCode, directMethod, type, skipThis);
/*
@@ -554,96 +554,96 @@
for (int nextArg = 0; nextArg < info->numArgWords;) {
RegLocation loc = info->args[nextArg];
if (loc.wide) {
- loc = oatUpdateLocWide(cUnit, loc);
+ loc = UpdateLocWide(cUnit, loc);
if ((nextArg >= 2) && (loc.location == kLocPhysReg)) {
- storeBaseDispWide(cUnit, targetReg(kSp), oatSRegOffset(cUnit, loc.sRegLow),
+ StoreBaseDispWide(cUnit, TargetReg(kSp), SRegOffset(cUnit, loc.sRegLow),
loc.lowReg, loc.highReg);
}
nextArg += 2;
} else {
- loc = oatUpdateLoc(cUnit, loc);
+ loc = UpdateLoc(cUnit, loc);
if ((nextArg >= 3) && (loc.location == kLocPhysReg)) {
- storeBaseDisp(cUnit, targetReg(kSp), oatSRegOffset(cUnit, loc.sRegLow),
+ StoreBaseDisp(cUnit, TargetReg(kSp), SRegOffset(cUnit, loc.sRegLow),
loc.lowReg, kWord);
}
nextArg++;
}
}
- int startOffset = oatSRegOffset(cUnit, info->args[3].sRegLow);
+ int startOffset = SRegOffset(cUnit, info->args[3].sRegLow);
int outsOffset = 4 /* Method* */ + (3 * 4);
if (cUnit->instructionSet != kThumb2) {
// Generate memcpy
- opRegRegImm(cUnit, kOpAdd, targetReg(kArg0), targetReg(kSp), outsOffset);
- opRegRegImm(cUnit, kOpAdd, targetReg(kArg1), targetReg(kSp), startOffset);
- callRuntimeHelperRegRegImm(cUnit, ENTRYPOINT_OFFSET(pMemcpy), targetReg(kArg0),
- targetReg(kArg1), (info->numArgWords - 3) * 4, false);
+ OpRegRegImm(cUnit, kOpAdd, TargetReg(kArg0), TargetReg(kSp), outsOffset);
+ OpRegRegImm(cUnit, kOpAdd, TargetReg(kArg1), TargetReg(kSp), startOffset);
+ CallRuntimeHelperRegRegImm(cUnit, ENTRYPOINT_OFFSET(pMemcpy), TargetReg(kArg0),
+ TargetReg(kArg1), (info->numArgWords - 3) * 4, false);
} else {
if (info->numArgWords >= 20) {
// Generate memcpy
- opRegRegImm(cUnit, kOpAdd, targetReg(kArg0), targetReg(kSp), outsOffset);
- opRegRegImm(cUnit, kOpAdd, targetReg(kArg1), targetReg(kSp), startOffset);
- callRuntimeHelperRegRegImm(cUnit, ENTRYPOINT_OFFSET(pMemcpy), targetReg(kArg0),
- targetReg(kArg1), (info->numArgWords - 3) * 4, false);
+ OpRegRegImm(cUnit, kOpAdd, TargetReg(kArg0), TargetReg(kSp), outsOffset);
+ OpRegRegImm(cUnit, kOpAdd, TargetReg(kArg1), TargetReg(kSp), startOffset);
+ CallRuntimeHelperRegRegImm(cUnit, ENTRYPOINT_OFFSET(pMemcpy), TargetReg(kArg0),
+ TargetReg(kArg1), (info->numArgWords - 3) * 4, false);
} else {
// Use vldm/vstm pair using kArg3 as a temp
int regsLeft = std::min(info->numArgWords - 3, 16);
callState = nextCallInsn(cUnit, info, callState, dexIdx, methodIdx,
directCode, directMethod, type);
- opRegRegImm(cUnit, kOpAdd, targetReg(kArg3), targetReg(kSp), startOffset);
- LIR* ld = opVldm(cUnit, targetReg(kArg3), regsLeft);
+ OpRegRegImm(cUnit, kOpAdd, TargetReg(kArg3), TargetReg(kSp), startOffset);
+ LIR* ld = OpVldm(cUnit, TargetReg(kArg3), regsLeft);
//TUNING: loosen barrier
ld->defMask = ENCODE_ALL;
- setMemRefType(ld, true /* isLoad */, kDalvikReg);
+ SetMemRefType(ld, true /* isLoad */, kDalvikReg);
callState = nextCallInsn(cUnit, info, callState, dexIdx, methodIdx,
directCode, directMethod, type);
- opRegRegImm(cUnit, kOpAdd, targetReg(kArg3), targetReg(kSp), 4 /* Method* */ + (3 * 4));
+ OpRegRegImm(cUnit, kOpAdd, TargetReg(kArg3), TargetReg(kSp), 4 /* Method* */ + (3 * 4));
callState = nextCallInsn(cUnit, info, callState, dexIdx, methodIdx,
directCode, directMethod, type);
- LIR* st = opVstm(cUnit, targetReg(kArg3), regsLeft);
- setMemRefType(st, false /* isLoad */, kDalvikReg);
+ LIR* st = OpVstm(cUnit, TargetReg(kArg3), regsLeft);
+ SetMemRefType(st, false /* isLoad */, kDalvikReg);
st->defMask = ENCODE_ALL;
callState = nextCallInsn(cUnit, info, callState, dexIdx, methodIdx,
directCode, directMethod, type);
}
}
- callState = loadArgRegs(cUnit, info, callState, nextCallInsn,
+ callState = LoadArgRegs(cUnit, info, callState, nextCallInsn,
dexIdx, methodIdx, directCode, directMethod,
type, skipThis);
callState = nextCallInsn(cUnit, info, callState, dexIdx, methodIdx,
directCode, directMethod, type);
if (pcrLabel) {
- *pcrLabel = genNullCheck(cUnit, info->args[0].sRegLow, targetReg(kArg1),
+ *pcrLabel = GenNullCheck(cUnit, info->args[0].sRegLow, TargetReg(kArg1),
info->optFlags);
}
return callState;
}
-RegLocation inlineTarget(CompilationUnit* cUnit, CallInfo* info)
+RegLocation InlineTarget(CompilationUnit* cUnit, CallInfo* info)
{
RegLocation res;
if (info->result.location == kLocInvalid) {
- res = oatGetReturn(cUnit, false);
+ res = GetReturn(cUnit, false);
} else {
res = info->result;
}
return res;
}
-RegLocation inlineTargetWide(CompilationUnit* cUnit, CallInfo* info)
+RegLocation InlineTargetWide(CompilationUnit* cUnit, CallInfo* info)
{
RegLocation res;
if (info->result.location == kLocInvalid) {
- res = oatGetReturnWide(cUnit, false);
+ res = GetReturnWide(cUnit, false);
} else {
res = info->result;
}
return res;
}
-bool genInlinedCharAt(CompilationUnit* cUnit, CallInfo* info)
+bool GenInlinedCharAt(CompilationUnit* cUnit, CallInfo* info)
{
if (cUnit->instructionSet == kMips) {
// TODO - add Mips implementation
@@ -660,59 +660,59 @@
RegLocation rlObj = info->args[0];
RegLocation rlIdx = info->args[1];
- rlObj = loadValue(cUnit, rlObj, kCoreReg);
- rlIdx = loadValue(cUnit, rlIdx, kCoreReg);
+ rlObj = LoadValue(cUnit, rlObj, kCoreReg);
+ rlIdx = LoadValue(cUnit, rlIdx, kCoreReg);
int regMax;
- genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, info->optFlags);
+ GenNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, info->optFlags);
bool rangeCheck = (!(info->optFlags & MIR_IGNORE_RANGE_CHECK));
LIR* launchPad = NULL;
int regOff = INVALID_REG;
int regPtr = INVALID_REG;
if (cUnit->instructionSet != kX86) {
- regOff = oatAllocTemp(cUnit);
- regPtr = oatAllocTemp(cUnit);
+ regOff = AllocTemp(cUnit);
+ regPtr = AllocTemp(cUnit);
if (rangeCheck) {
- regMax = oatAllocTemp(cUnit);
- loadWordDisp(cUnit, rlObj.lowReg, countOffset, regMax);
+ regMax = AllocTemp(cUnit);
+ LoadWordDisp(cUnit, rlObj.lowReg, countOffset, regMax);
}
- loadWordDisp(cUnit, rlObj.lowReg, offsetOffset, regOff);
- loadWordDisp(cUnit, rlObj.lowReg, valueOffset, regPtr);
+ LoadWordDisp(cUnit, rlObj.lowReg, offsetOffset, regOff);
+ LoadWordDisp(cUnit, rlObj.lowReg, valueOffset, regPtr);
if (rangeCheck) {
// Set up a launch pad to allow retry in case of bounds violation */
- launchPad = rawLIR(cUnit, 0, kPseudoIntrinsicRetry, reinterpret_cast<uintptr_t>(info));
- oatInsertGrowableList(cUnit, &cUnit->intrinsicLaunchpads,
+ launchPad = RawLIR(cUnit, 0, kPseudoIntrinsicRetry, reinterpret_cast<uintptr_t>(info));
+ InsertGrowableList(cUnit, &cUnit->intrinsicLaunchpads,
reinterpret_cast<uintptr_t>(launchPad));
- opRegReg(cUnit, kOpCmp, rlIdx.lowReg, regMax);
- oatFreeTemp(cUnit, regMax);
- opCondBranch(cUnit, kCondCs, launchPad);
+ OpRegReg(cUnit, kOpCmp, rlIdx.lowReg, regMax);
+ FreeTemp(cUnit, regMax);
+ OpCondBranch(cUnit, kCondCs, launchPad);
}
} else {
if (rangeCheck) {
- regMax = oatAllocTemp(cUnit);
- loadWordDisp(cUnit, rlObj.lowReg, countOffset, regMax);
+ regMax = AllocTemp(cUnit);
+ LoadWordDisp(cUnit, rlObj.lowReg, countOffset, regMax);
// Set up a launch pad to allow retry in case of bounds violation */
- launchPad = rawLIR(cUnit, 0, kPseudoIntrinsicRetry, reinterpret_cast<uintptr_t>(info));
- oatInsertGrowableList(cUnit, &cUnit->intrinsicLaunchpads,
+ launchPad = RawLIR(cUnit, 0, kPseudoIntrinsicRetry, reinterpret_cast<uintptr_t>(info));
+ InsertGrowableList(cUnit, &cUnit->intrinsicLaunchpads,
reinterpret_cast<uintptr_t>(launchPad));
- opRegReg(cUnit, kOpCmp, rlIdx.lowReg, regMax);
- oatFreeTemp(cUnit, regMax);
- opCondBranch(cUnit, kCondCc, launchPad);
+ OpRegReg(cUnit, kOpCmp, rlIdx.lowReg, regMax);
+ FreeTemp(cUnit, regMax);
+ OpCondBranch(cUnit, kCondCc, launchPad);
}
- regOff = oatAllocTemp(cUnit);
- regPtr = oatAllocTemp(cUnit);
- loadWordDisp(cUnit, rlObj.lowReg, offsetOffset, regOff);
- loadWordDisp(cUnit, rlObj.lowReg, valueOffset, regPtr);
+ regOff = AllocTemp(cUnit);
+ regPtr = AllocTemp(cUnit);
+ LoadWordDisp(cUnit, rlObj.lowReg, offsetOffset, regOff);
+ LoadWordDisp(cUnit, rlObj.lowReg, valueOffset, regPtr);
}
- opRegImm(cUnit, kOpAdd, regPtr, dataOffset);
- opRegReg(cUnit, kOpAdd, regOff, rlIdx.lowReg);
- oatFreeTemp(cUnit, rlObj.lowReg);
- oatFreeTemp(cUnit, rlIdx.lowReg);
- RegLocation rlDest = inlineTarget(cUnit, info);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- loadBaseIndexed(cUnit, regPtr, regOff, rlResult.lowReg, 1, kUnsignedHalf);
- oatFreeTemp(cUnit, regOff);
- oatFreeTemp(cUnit, regPtr);
- storeValue(cUnit, rlDest, rlResult);
+ OpRegImm(cUnit, kOpAdd, regPtr, dataOffset);
+ OpRegReg(cUnit, kOpAdd, regOff, rlIdx.lowReg);
+ FreeTemp(cUnit, rlObj.lowReg);
+ FreeTemp(cUnit, rlIdx.lowReg);
+ RegLocation rlDest = InlineTarget(cUnit, info);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ LoadBaseIndexed(cUnit, regPtr, regOff, rlResult.lowReg, 1, kUnsignedHalf);
+ FreeTemp(cUnit, regOff);
+ FreeTemp(cUnit, regPtr);
+ StoreValue(cUnit, rlDest, rlResult);
if (rangeCheck) {
launchPad->operands[2] = 0; // no resumption
}
@@ -722,7 +722,7 @@
}
// Generates an inlined String.isEmpty or String.length.
-bool genInlinedStringIsEmptyOrLength(CompilationUnit* cUnit, CallInfo* info,
+bool GenInlinedStringIsEmptyOrLength(CompilationUnit* cUnit, CallInfo* info,
bool isEmpty)
{
if (cUnit->instructionSet == kMips) {
@@ -731,48 +731,48 @@
}
// dst = src.length();
RegLocation rlObj = info->args[0];
- rlObj = loadValue(cUnit, rlObj, kCoreReg);
- RegLocation rlDest = inlineTarget(cUnit, info);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, info->optFlags);
- loadWordDisp(cUnit, rlObj.lowReg, String::CountOffset().Int32Value(),
+ rlObj = LoadValue(cUnit, rlObj, kCoreReg);
+ RegLocation rlDest = InlineTarget(cUnit, info);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ GenNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, info->optFlags);
+ LoadWordDisp(cUnit, rlObj.lowReg, String::CountOffset().Int32Value(),
rlResult.lowReg);
if (isEmpty) {
// dst = (dst == 0);
if (cUnit->instructionSet == kThumb2) {
- int tReg = oatAllocTemp(cUnit);
- opRegReg(cUnit, kOpNeg, tReg, rlResult.lowReg);
- opRegRegReg(cUnit, kOpAdc, rlResult.lowReg, rlResult.lowReg, tReg);
+ int tReg = AllocTemp(cUnit);
+ OpRegReg(cUnit, kOpNeg, tReg, rlResult.lowReg);
+ OpRegRegReg(cUnit, kOpAdc, rlResult.lowReg, rlResult.lowReg, tReg);
} else {
DCHECK_EQ(cUnit->instructionSet, kX86);
- opRegImm(cUnit, kOpSub, rlResult.lowReg, 1);
- opRegImm(cUnit, kOpLsr, rlResult.lowReg, 31);
+ OpRegImm(cUnit, kOpSub, rlResult.lowReg, 1);
+ OpRegImm(cUnit, kOpLsr, rlResult.lowReg, 31);
}
}
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
return true;
}
-bool genInlinedAbsInt(CompilationUnit *cUnit, CallInfo* info)
+bool GenInlinedAbsInt(CompilationUnit *cUnit, CallInfo* info)
{
if (cUnit->instructionSet == kMips) {
// TODO - add Mips implementation
return false;
}
RegLocation rlSrc = info->args[0];
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- RegLocation rlDest = inlineTarget(cUnit, info);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- int signReg = oatAllocTemp(cUnit);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
+ RegLocation rlDest = InlineTarget(cUnit, info);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ int signReg = AllocTemp(cUnit);
// abs(x) = y<=x>>31, (x+y)^y.
- opRegRegImm(cUnit, kOpAsr, signReg, rlSrc.lowReg, 31);
- opRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, signReg);
- opRegReg(cUnit, kOpXor, rlResult.lowReg, signReg);
- storeValue(cUnit, rlDest, rlResult);
+ OpRegRegImm(cUnit, kOpAsr, signReg, rlSrc.lowReg, 31);
+ OpRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, signReg);
+ OpRegReg(cUnit, kOpXor, rlResult.lowReg, signReg);
+ StoreValue(cUnit, rlDest, rlResult);
return true;
}
-bool genInlinedAbsLong(CompilationUnit *cUnit, CallInfo* info)
+bool GenInlinedAbsLong(CompilationUnit *cUnit, CallInfo* info)
{
if (cUnit->instructionSet == kMips) {
// TODO - add Mips implementation
@@ -780,61 +780,61 @@
}
if (cUnit->instructionSet == kThumb2) {
RegLocation rlSrc = info->args[0];
- rlSrc = loadValueWide(cUnit, rlSrc, kCoreReg);
- RegLocation rlDest = inlineTargetWide(cUnit, info);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- int signReg = oatAllocTemp(cUnit);
+ rlSrc = LoadValueWide(cUnit, rlSrc, kCoreReg);
+ RegLocation rlDest = InlineTargetWide(cUnit, info);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ int signReg = AllocTemp(cUnit);
// abs(x) = y<=x>>31, (x+y)^y.
- opRegRegImm(cUnit, kOpAsr, signReg, rlSrc.highReg, 31);
- opRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, signReg);
- opRegRegReg(cUnit, kOpAdc, rlResult.highReg, rlSrc.highReg, signReg);
- opRegReg(cUnit, kOpXor, rlResult.lowReg, signReg);
- opRegReg(cUnit, kOpXor, rlResult.highReg, signReg);
- storeValueWide(cUnit, rlDest, rlResult);
+ OpRegRegImm(cUnit, kOpAsr, signReg, rlSrc.highReg, 31);
+ OpRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, signReg);
+ OpRegRegReg(cUnit, kOpAdc, rlResult.highReg, rlSrc.highReg, signReg);
+ OpRegReg(cUnit, kOpXor, rlResult.lowReg, signReg);
+ OpRegReg(cUnit, kOpXor, rlResult.highReg, signReg);
+ StoreValueWide(cUnit, rlDest, rlResult);
return true;
} else {
DCHECK_EQ(cUnit->instructionSet, kX86);
// Reuse source registers to avoid running out of temps
RegLocation rlSrc = info->args[0];
- rlSrc = loadValueWide(cUnit, rlSrc, kCoreReg);
- RegLocation rlDest = inlineTargetWide(cUnit, info);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- opRegCopyWide(cUnit, rlResult.lowReg, rlResult.highReg, rlSrc.lowReg, rlSrc.highReg);
- oatFreeTemp(cUnit, rlSrc.lowReg);
- oatFreeTemp(cUnit, rlSrc.highReg);
- int signReg = oatAllocTemp(cUnit);
+ rlSrc = LoadValueWide(cUnit, rlSrc, kCoreReg);
+ RegLocation rlDest = InlineTargetWide(cUnit, info);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ OpRegCopyWide(cUnit, rlResult.lowReg, rlResult.highReg, rlSrc.lowReg, rlSrc.highReg);
+ FreeTemp(cUnit, rlSrc.lowReg);
+ FreeTemp(cUnit, rlSrc.highReg);
+ int signReg = AllocTemp(cUnit);
// abs(x) = y<=x>>31, (x+y)^y.
- opRegRegImm(cUnit, kOpAsr, signReg, rlResult.highReg, 31);
- opRegReg(cUnit, kOpAdd, rlResult.lowReg, signReg);
- opRegReg(cUnit, kOpAdc, rlResult.highReg, signReg);
- opRegReg(cUnit, kOpXor, rlResult.lowReg, signReg);
- opRegReg(cUnit, kOpXor, rlResult.highReg, signReg);
- storeValueWide(cUnit, rlDest, rlResult);
+ OpRegRegImm(cUnit, kOpAsr, signReg, rlResult.highReg, 31);
+ OpRegReg(cUnit, kOpAdd, rlResult.lowReg, signReg);
+ OpRegReg(cUnit, kOpAdc, rlResult.highReg, signReg);
+ OpRegReg(cUnit, kOpXor, rlResult.lowReg, signReg);
+ OpRegReg(cUnit, kOpXor, rlResult.highReg, signReg);
+ StoreValueWide(cUnit, rlDest, rlResult);
return true;
}
}
-bool genInlinedFloatCvt(CompilationUnit *cUnit, CallInfo* info)
+bool GenInlinedFloatCvt(CompilationUnit *cUnit, CallInfo* info)
{
if (cUnit->instructionSet == kMips) {
// TODO - add Mips implementation
return false;
}
RegLocation rlSrc = info->args[0];
- RegLocation rlDest = inlineTarget(cUnit, info);
- storeValue(cUnit, rlDest, rlSrc);
+ RegLocation rlDest = InlineTarget(cUnit, info);
+ StoreValue(cUnit, rlDest, rlSrc);
return true;
}
-bool genInlinedDoubleCvt(CompilationUnit *cUnit, CallInfo* info)
+bool GenInlinedDoubleCvt(CompilationUnit *cUnit, CallInfo* info)
{
if (cUnit->instructionSet == kMips) {
// TODO - add Mips implementation
return false;
}
RegLocation rlSrc = info->args[0];
- RegLocation rlDest = inlineTargetWide(cUnit, info);
- storeValueWide(cUnit, rlDest, rlSrc);
+ RegLocation rlDest = InlineTargetWide(cUnit, info);
+ StoreValueWide(cUnit, rlDest, rlSrc);
return true;
}
@@ -842,89 +842,89 @@
* Fast string.indexOf(I) & (II). Tests for simple case of char <= 0xffff,
* otherwise bails to standard library code.
*/
-bool genInlinedIndexOf(CompilationUnit* cUnit, CallInfo* info,
+bool GenInlinedIndexOf(CompilationUnit* cUnit, CallInfo* info,
bool zeroBased)
{
if (cUnit->instructionSet == kMips) {
// TODO - add Mips implementation
return false;
}
- oatClobberCalleeSave(cUnit);
- oatLockCallTemps(cUnit); // Using fixed registers
- int regPtr = targetReg(kArg0);
- int regChar = targetReg(kArg1);
- int regStart = targetReg(kArg2);
+ ClobberCalleeSave(cUnit);
+ LockCallTemps(cUnit); // Using fixed registers
+ int regPtr = TargetReg(kArg0);
+ int regChar = TargetReg(kArg1);
+ int regStart = TargetReg(kArg2);
RegLocation rlObj = info->args[0];
RegLocation rlChar = info->args[1];
RegLocation rlStart = info->args[2];
- loadValueDirectFixed(cUnit, rlObj, regPtr);
- loadValueDirectFixed(cUnit, rlChar, regChar);
+ LoadValueDirectFixed(cUnit, rlObj, regPtr);
+ LoadValueDirectFixed(cUnit, rlChar, regChar);
if (zeroBased) {
- loadConstant(cUnit, regStart, 0);
+ LoadConstant(cUnit, regStart, 0);
} else {
- loadValueDirectFixed(cUnit, rlStart, regStart);
+ LoadValueDirectFixed(cUnit, rlStart, regStart);
}
- int rTgt = (cUnit->instructionSet != kX86) ? loadHelper(cUnit, ENTRYPOINT_OFFSET(pIndexOf)) : 0;
- genNullCheck(cUnit, rlObj.sRegLow, regPtr, info->optFlags);
- LIR* launchPad = rawLIR(cUnit, 0, kPseudoIntrinsicRetry, reinterpret_cast<uintptr_t>(info));
- oatInsertGrowableList(cUnit, &cUnit->intrinsicLaunchpads, reinterpret_cast<uintptr_t>(launchPad));
- opCmpImmBranch(cUnit, kCondGt, regChar, 0xFFFF, launchPad);
+ int rTgt = (cUnit->instructionSet != kX86) ? LoadHelper(cUnit, ENTRYPOINT_OFFSET(pIndexOf)) : 0;
+ GenNullCheck(cUnit, rlObj.sRegLow, regPtr, info->optFlags);
+ LIR* launchPad = RawLIR(cUnit, 0, kPseudoIntrinsicRetry, reinterpret_cast<uintptr_t>(info));
+ InsertGrowableList(cUnit, &cUnit->intrinsicLaunchpads, reinterpret_cast<uintptr_t>(launchPad));
+ OpCmpImmBranch(cUnit, kCondGt, regChar, 0xFFFF, launchPad);
// NOTE: not a safepoint
if (cUnit->instructionSet != kX86) {
- opReg(cUnit, kOpBlx, rTgt);
+ OpReg(cUnit, kOpBlx, rTgt);
} else {
- opThreadMem(cUnit, kOpBlx, ENTRYPOINT_OFFSET(pIndexOf));
+ OpThreadMem(cUnit, kOpBlx, ENTRYPOINT_OFFSET(pIndexOf));
}
- LIR* resumeTgt = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* resumeTgt = NewLIR0(cUnit, kPseudoTargetLabel);
launchPad->operands[2] = reinterpret_cast<uintptr_t>(resumeTgt);
// Record that we've already inlined & null checked
info->optFlags |= (MIR_INLINED | MIR_IGNORE_NULL_CHECK);
- RegLocation rlReturn = oatGetReturn(cUnit, false);
- RegLocation rlDest = inlineTarget(cUnit, info);
- storeValue(cUnit, rlDest, rlReturn);
+ RegLocation rlReturn = GetReturn(cUnit, false);
+ RegLocation rlDest = InlineTarget(cUnit, info);
+ StoreValue(cUnit, rlDest, rlReturn);
return true;
}
/* Fast string.compareTo(Ljava/lang/string;)I. */
-bool genInlinedStringCompareTo(CompilationUnit* cUnit, CallInfo* info)
+bool GenInlinedStringCompareTo(CompilationUnit* cUnit, CallInfo* info)
{
if (cUnit->instructionSet == kMips) {
// TODO - add Mips implementation
return false;
}
- oatClobberCalleeSave(cUnit);
- oatLockCallTemps(cUnit); // Using fixed registers
- int regThis = targetReg(kArg0);
- int regCmp = targetReg(kArg1);
+ ClobberCalleeSave(cUnit);
+ LockCallTemps(cUnit); // Using fixed registers
+ int regThis = TargetReg(kArg0);
+ int regCmp = TargetReg(kArg1);
RegLocation rlThis = info->args[0];
RegLocation rlCmp = info->args[1];
- loadValueDirectFixed(cUnit, rlThis, regThis);
- loadValueDirectFixed(cUnit, rlCmp, regCmp);
+ LoadValueDirectFixed(cUnit, rlThis, regThis);
+ LoadValueDirectFixed(cUnit, rlCmp, regCmp);
int rTgt = (cUnit->instructionSet != kX86) ?
- loadHelper(cUnit, ENTRYPOINT_OFFSET(pStringCompareTo)) : 0;
- genNullCheck(cUnit, rlThis.sRegLow, regThis, info->optFlags);
+ LoadHelper(cUnit, ENTRYPOINT_OFFSET(pStringCompareTo)) : 0;
+ GenNullCheck(cUnit, rlThis.sRegLow, regThis, info->optFlags);
//TUNING: check if rlCmp.sRegLow is already null checked
- LIR* launchPad = rawLIR(cUnit, 0, kPseudoIntrinsicRetry, reinterpret_cast<uintptr_t>(info));
- oatInsertGrowableList(cUnit, &cUnit->intrinsicLaunchpads, reinterpret_cast<uintptr_t>(launchPad));
- opCmpImmBranch(cUnit, kCondEq, regCmp, 0, launchPad);
+ LIR* launchPad = RawLIR(cUnit, 0, kPseudoIntrinsicRetry, reinterpret_cast<uintptr_t>(info));
+ InsertGrowableList(cUnit, &cUnit->intrinsicLaunchpads, reinterpret_cast<uintptr_t>(launchPad));
+ OpCmpImmBranch(cUnit, kCondEq, regCmp, 0, launchPad);
// NOTE: not a safepoint
if (cUnit->instructionSet != kX86) {
- opReg(cUnit, kOpBlx, rTgt);
+ OpReg(cUnit, kOpBlx, rTgt);
} else {
- opThreadMem(cUnit, kOpBlx, ENTRYPOINT_OFFSET(pStringCompareTo));
+ OpThreadMem(cUnit, kOpBlx, ENTRYPOINT_OFFSET(pStringCompareTo));
}
launchPad->operands[2] = 0; // No return possible
// Record that we've already inlined & null checked
info->optFlags |= (MIR_INLINED | MIR_IGNORE_NULL_CHECK);
- RegLocation rlReturn = oatGetReturn(cUnit, false);
- RegLocation rlDest = inlineTarget(cUnit, info);
- storeValue(cUnit, rlDest, rlReturn);
+ RegLocation rlReturn = GetReturn(cUnit, false);
+ RegLocation rlDest = InlineTarget(cUnit, info);
+ StoreValue(cUnit, rlDest, rlReturn);
return true;
}
-bool genIntrinsic(CompilationUnit* cUnit, CallInfo* info)
+bool GenIntrinsic(CompilationUnit* cUnit, CallInfo* info)
{
if (info->optFlags & MIR_INLINED) {
return false;
@@ -942,69 +942,69 @@
std::string tgtMethod(PrettyMethod(info->index, *cUnit->dex_file));
if (tgtMethod.find(" java.lang") != std::string::npos) {
if (tgtMethod == "long java.lang.Double.doubleToRawLongBits(double)") {
- return genInlinedDoubleCvt(cUnit, info);
+ return GenInlinedDoubleCvt(cUnit, info);
}
if (tgtMethod == "double java.lang.Double.longBitsToDouble(long)") {
- return genInlinedDoubleCvt(cUnit, info);
+ return GenInlinedDoubleCvt(cUnit, info);
}
if (tgtMethod == "int java.lang.Float.floatToRawIntBits(float)") {
- return genInlinedFloatCvt(cUnit, info);
+ return GenInlinedFloatCvt(cUnit, info);
}
if (tgtMethod == "float java.lang.Float.intBitsToFloat(int)") {
- return genInlinedFloatCvt(cUnit, info);
+ return GenInlinedFloatCvt(cUnit, info);
}
if (tgtMethod == "int java.lang.Math.abs(int)" ||
tgtMethod == "int java.lang.StrictMath.abs(int)") {
- return genInlinedAbsInt(cUnit, info);
+ return GenInlinedAbsInt(cUnit, info);
}
if (tgtMethod == "long java.lang.Math.abs(long)" ||
tgtMethod == "long java.lang.StrictMath.abs(long)") {
- return genInlinedAbsLong(cUnit, info);
+ return GenInlinedAbsLong(cUnit, info);
}
if (tgtMethod == "int java.lang.Math.max(int, int)" ||
tgtMethod == "int java.lang.StrictMath.max(int, int)") {
- return genInlinedMinMaxInt(cUnit, info, false /* isMin */);
+ return GenInlinedMinMaxInt(cUnit, info, false /* isMin */);
}
if (tgtMethod == "int java.lang.Math.min(int, int)" ||
tgtMethod == "int java.lang.StrictMath.min(int, int)") {
- return genInlinedMinMaxInt(cUnit, info, true /* isMin */);
+ return GenInlinedMinMaxInt(cUnit, info, true /* isMin */);
}
if (tgtMethod == "double java.lang.Math.sqrt(double)" ||
tgtMethod == "double java.lang.StrictMath.sqrt(double)") {
- return genInlinedSqrt(cUnit, info);
+ return GenInlinedSqrt(cUnit, info);
}
if (tgtMethod == "char java.lang.String.charAt(int)") {
- return genInlinedCharAt(cUnit, info);
+ return GenInlinedCharAt(cUnit, info);
}
if (tgtMethod == "int java.lang.String.compareTo(java.lang.String)") {
- return genInlinedStringCompareTo(cUnit, info);
+ return GenInlinedStringCompareTo(cUnit, info);
}
if (tgtMethod == "boolean java.lang.String.isEmpty()") {
- return genInlinedStringIsEmptyOrLength(cUnit, info, true /* isEmpty */);
+ return GenInlinedStringIsEmptyOrLength(cUnit, info, true /* isEmpty */);
}
if (tgtMethod == "int java.lang.String.indexOf(int, int)") {
- return genInlinedIndexOf(cUnit, info, false /* base 0 */);
+ return GenInlinedIndexOf(cUnit, info, false /* base 0 */);
}
if (tgtMethod == "int java.lang.String.indexOf(int)") {
- return genInlinedIndexOf(cUnit, info, true /* base 0 */);
+ return GenInlinedIndexOf(cUnit, info, true /* base 0 */);
}
if (tgtMethod == "int java.lang.String.length()") {
- return genInlinedStringIsEmptyOrLength(cUnit, info, false /* isEmpty */);
+ return GenInlinedStringIsEmptyOrLength(cUnit, info, false /* isEmpty */);
}
} else if (tgtMethod.find("boolean sun.misc.Unsafe.compareAndSwap") != std::string::npos) {
if (tgtMethod == "boolean sun.misc.Unsafe.compareAndSwapInt(java.lang.Object, long, int, int)") {
- return genInlinedCas32(cUnit, info, false);
+ return GenInlinedCas32(cUnit, info, false);
}
if (tgtMethod == "boolean sun.misc.Unsafe.compareAndSwapObject(java.lang.Object, long, java.lang.Object, java.lang.Object)") {
- return genInlinedCas32(cUnit, info, true);
+ return GenInlinedCas32(cUnit, info, true);
}
}
return false;
}
-void genInvoke(CompilationUnit* cUnit, CallInfo* info)
+void GenInvoke(CompilationUnit* cUnit, CallInfo* info)
{
- if (genIntrinsic(cUnit, info)) {
+ if (GenIntrinsic(cUnit, info)) {
return;
}
InvokeType originalType = info->type; // avoiding mutation by ComputeInvokeInfo
@@ -1012,9 +1012,9 @@
LIR* nullCk;
LIR** pNullCk = NULL;
NextCallInsn nextCallInsn;
- oatFlushAllRegs(cUnit); /* Everything to home location */
+ FlushAllRegs(cUnit); /* Everything to home location */
// Explicit register usage
- oatLockCallTemps(cUnit);
+ LockCallTemps(cUnit);
OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
*cUnit->dex_file,
@@ -1035,34 +1035,34 @@
if (fastPath) {
pNullCk = &nullCk;
}
- nextCallInsn = fastPath ? nextInterfaceCallInsn
- : nextInterfaceCallInsnWithAccessCheck;
+ nextCallInsn = fastPath ? NextInterfaceCallInsn
+ : NextInterfaceCallInsnWithAccessCheck;
skipThis = false;
} else if (info->type == kDirect) {
if (fastPath) {
pNullCk = &nullCk;
}
- nextCallInsn = fastPath ? nextSDCallInsn : nextDirectCallInsnSP;
+ nextCallInsn = fastPath ? NextSDCallInsn : NextDirectCallInsnSP;
skipThis = false;
} else if (info->type == kStatic) {
- nextCallInsn = fastPath ? nextSDCallInsn : nextStaticCallInsnSP;
+ nextCallInsn = fastPath ? NextSDCallInsn : NextStaticCallInsnSP;
skipThis = false;
} else if (info->type == kSuper) {
DCHECK(!fastPath); // Fast path is a direct call.
- nextCallInsn = nextSuperCallInsnSP;
+ nextCallInsn = NextSuperCallInsnSP;
skipThis = false;
} else {
DCHECK_EQ(info->type, kVirtual);
- nextCallInsn = fastPath ? nextVCallInsn : nextVCallInsnSP;
+ nextCallInsn = fastPath ? NextVCallInsn : NextVCallInsnSP;
skipThis = fastPath;
}
if (!info->isRange) {
- callState = genDalvikArgsNoRange(cUnit, info, callState, pNullCk,
+ callState = GenDalvikArgsNoRange(cUnit, info, callState, pNullCk,
nextCallInsn, dexMethodIdx,
vtableIdx, directCode, directMethod,
originalType, skipThis);
} else {
- callState = genDalvikArgsRange(cUnit, info, callState, pNullCk,
+ callState = GenDalvikArgsRange(cUnit, info, callState, pNullCk,
nextCallInsn, dexMethodIdx, vtableIdx,
directCode, directMethod, originalType,
skipThis);
@@ -1074,14 +1074,14 @@
originalType);
}
if (cUnit->enableDebug & (1 << kDebugDisplayMissingTargets)) {
- genShowTarget(cUnit);
+ GenShowTarget(cUnit);
}
LIR* callInst;
if (cUnit->instructionSet != kX86) {
- callInst = opReg(cUnit, kOpBlx, targetReg(kInvokeTgt));
+ callInst = OpReg(cUnit, kOpBlx, TargetReg(kInvokeTgt));
} else {
if (fastPath && info->type != kInterface) {
- callInst = opMem(cUnit, kOpBlx, targetReg(kArg0),
+ callInst = OpMem(cUnit, kOpBlx, TargetReg(kArg0),
AbstractMethod::GetCodeOffset().Int32Value());
} else {
int trampoline = 0;
@@ -1105,20 +1105,20 @@
default:
LOG(FATAL) << "Unexpected invoke type";
}
- callInst = opThreadMem(cUnit, kOpBlx, trampoline);
+ callInst = OpThreadMem(cUnit, kOpBlx, trampoline);
}
}
- markSafepointPC(cUnit, callInst);
+ MarkSafepointPC(cUnit, callInst);
- oatClobberCalleeSave(cUnit);
+ ClobberCalleeSave(cUnit);
if (info->result.location != kLocInvalid) {
// We have a following MOVE_RESULT - do it now.
if (info->result.wide) {
- RegLocation retLoc = oatGetReturnWide(cUnit, info->result.fp);
- storeValueWide(cUnit, info->result, retLoc);
+ RegLocation retLoc = GetReturnWide(cUnit, info->result.fp);
+ StoreValueWide(cUnit, info->result, retLoc);
} else {
- RegLocation retLoc = oatGetReturn(cUnit, info->result.fp);
- storeValue(cUnit, info->result, retLoc);
+ RegLocation retLoc = GetReturn(cUnit, info->result.fp);
+ StoreValue(cUnit, info->result, retLoc);
}
}
}
@@ -1129,22 +1129,22 @@
* high-word loc for wide arguments. Also pull up any following
* MOVE_RESULT and incorporate it into the invoke.
*/
-CallInfo* oatNewCallInfo(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+CallInfo* NewMemCallInfo(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
InvokeType type, bool isRange)
{
- CallInfo* info = static_cast<CallInfo*>(oatNew(cUnit, sizeof(CallInfo), true, kAllocMisc));
- MIR* moveResultMIR = oatFindMoveResult(cUnit, bb, mir);
+ CallInfo* info = static_cast<CallInfo*>(NewMem(cUnit, sizeof(CallInfo), true, kAllocMisc));
+ MIR* moveResultMIR = FindMoveResult(cUnit, bb, mir);
if (moveResultMIR == NULL) {
info->result.location = kLocInvalid;
} else {
- info->result = oatGetRawDest(cUnit, moveResultMIR);
+ info->result = GetRawDest(cUnit, moveResultMIR);
moveResultMIR->dalvikInsn.opcode = Instruction::NOP;
}
info->numArgWords = mir->ssaRep->numUses;
info->args = (info->numArgWords == 0) ? NULL : static_cast<RegLocation*>
- (oatNew(cUnit, sizeof(RegLocation) * info->numArgWords, false, kAllocMisc));
+ (NewMem(cUnit, sizeof(RegLocation) * info->numArgWords, false, kAllocMisc));
for (int i = 0; i < info->numArgWords; i++) {
- info->args[i] = oatGetRawSrc(cUnit, mir, i);
+ info->args[i] = GetRawSrc(cUnit, mir, i);
}
info->optFlags = mir->optimizationFlags;
info->type = type;
diff --git a/src/compiler/codegen/gen_invoke.h b/src/compiler/codegen/gen_invoke.h
index ffff0b8..a20746d 100644
--- a/src/compiler/codegen/gen_invoke.h
+++ b/src/compiler/codegen/gen_invoke.h
@@ -21,21 +21,21 @@
uint32_t methodIdx, uintptr_t directCode,
uintptr_t directMethod, InvokeType type);
-void flushIns(CompilationUnit* cUnit, RegLocation* argLocs, RegLocation rlMethod);
-int genDalvikArgsNoRange(CompilationUnit* cUnit, CallInfo* info, int callState, LIR** pcrLabel, NextCallInsn nextCallInsn, uint32_t dexIdx, uint32_t methodIdx, uintptr_t directCode, uintptr_t directMethod, InvokeType type, bool skipThis);
-int genDalvikArgsRange(CompilationUnit* cUnit, CallInfo* info, int callState, LIR** pcrLabel, NextCallInsn nextCallInsn, uint32_t dexIdx, uint32_t methodIdx, uintptr_t directCode, uintptr_t directMethod, InvokeType type, bool skipThis);
-RegLocation inlineTarget(CompilationUnit* cUnit, CallInfo* info);
-RegLocation inlineTargetWide(CompilationUnit* cUnit, CallInfo* info);
-bool genInlinedCharAt(CompilationUnit* cUnit, CallInfo* info);
-bool genInlinedStringIsEmptyOrLength(CompilationUnit* cUnit, CallInfo* info, bool isEmpty);
-bool genInlinedAbsInt(CompilationUnit *cUnit, CallInfo* info);
-bool genInlinedAbsLong(CompilationUnit *cUnit, CallInfo* info);
-bool genInlinedFloatCvt(CompilationUnit *cUnit, CallInfo* info);
-bool genInlinedDoubleCvt(CompilationUnit *cUnit, CallInfo* info);
-bool genInlinedIndexOf(CompilationUnit* cUnit, CallInfo* info, bool zeroBased);
-bool genInlinedStringCompareTo(CompilationUnit* cUnit, CallInfo* info);
-bool genIntrinsic(CompilationUnit* cUnit, CallInfo* info);
-void genInvoke(CompilationUnit* cUnit, CallInfo* info);
-CallInfo* oatNewCallInfo(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir, InvokeType type, bool isRange);
+void FlushIns(CompilationUnit* cUnit, RegLocation* ArgLocs, RegLocation rlMethod);
+int GenDalvikArgsNoRange(CompilationUnit* cUnit, CallInfo* info, int callState, LIR** pcrLabel, NextCallInsn nextCallInsn, uint32_t dexIdx, uint32_t methodIdx, uintptr_t directCode, uintptr_t directMethod, InvokeType type, bool skipThis);
+int GenDalvikArgsRange(CompilationUnit* cUnit, CallInfo* info, int callState, LIR** pcrLabel, NextCallInsn nextCallInsn, uint32_t dexIdx, uint32_t methodIdx, uintptr_t directCode, uintptr_t directMethod, InvokeType type, bool skipThis);
+RegLocation InlineTarget(CompilationUnit* cUnit, CallInfo* info);
+RegLocation InlineTargetWide(CompilationUnit* cUnit, CallInfo* info);
+bool GenInlinedCharAt(CompilationUnit* cUnit, CallInfo* info);
+bool GenInlinedStringIsEmptyOrLength(CompilationUnit* cUnit, CallInfo* info, bool isEmpty);
+bool GenInlinedAbsInt(CompilationUnit *cUnit, CallInfo* info);
+bool GenInlinedAbsLong(CompilationUnit *cUnit, CallInfo* info);
+bool GenInlinedFloatCvt(CompilationUnit *cUnit, CallInfo* info);
+bool GenInlinedDoubleCvt(CompilationUnit *cUnit, CallInfo* info);
+bool GenInlinedIndexOf(CompilationUnit* cUnit, CallInfo* info, bool zeroBased);
+bool GenInlinedStringCompareTo(CompilationUnit* cUnit, CallInfo* info);
+bool GenIntrinsic(CompilationUnit* cUnit, CallInfo* info);
+void GenInvoke(CompilationUnit* cUnit, CallInfo* info);
+CallInfo* NewMemCallInfo(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir, InvokeType type, bool isRange);
#endif // ART_SRC_COMPILER_CODEGEN_GENINVOKE_H_
diff --git a/src/compiler/codegen/gen_loadstore.cc b/src/compiler/codegen/gen_loadstore.cc
index 996b5b7..8c3f059 100644
--- a/src/compiler/codegen/gen_loadstore.cc
+++ b/src/compiler/codegen/gen_loadstore.cc
@@ -26,27 +26,27 @@
* Load an immediate value into a fixed or temp register. Target
* register is clobbered, and marked inUse.
*/
-LIR* loadConstant(CompilationUnit* cUnit, int rDest, int value)
+LIR* LoadConstant(CompilationUnit* cUnit, int rDest, int value)
{
- if (oatIsTemp(cUnit, rDest)) {
- oatClobber(cUnit, rDest);
- oatMarkInUse(cUnit, rDest);
+ if (IsTemp(cUnit, rDest)) {
+ Clobber(cUnit, rDest);
+ MarkInUse(cUnit, rDest);
}
- return loadConstantNoClobber(cUnit, rDest, value);
+ return LoadConstantNoClobber(cUnit, rDest, value);
}
/* Load a word at base + displacement. Displacement must be word multiple */
-LIR* loadWordDisp(CompilationUnit* cUnit, int rBase, int displacement,
+LIR* LoadWordDisp(CompilationUnit* cUnit, int rBase, int displacement,
int rDest)
{
- return loadBaseDisp(cUnit, rBase, displacement, rDest, kWord,
+ return LoadBaseDisp(cUnit, rBase, displacement, rDest, kWord,
INVALID_SREG);
}
-LIR* storeWordDisp(CompilationUnit* cUnit, int rBase, int displacement,
+LIR* StoreWordDisp(CompilationUnit* cUnit, int rBase, int displacement,
int rSrc)
{
- return storeBaseDisp(cUnit, rBase, displacement, rSrc, kWord);
+ return StoreBaseDisp(cUnit, rBase, displacement, rSrc, kWord);
}
/*
@@ -54,28 +54,28 @@
* using this routine, as it doesn't perform any bookkeeping regarding
* register liveness. That is the responsibility of the caller.
*/
-void loadValueDirect(CompilationUnit* cUnit, RegLocation rlSrc, int rDest)
+void LoadValueDirect(CompilationUnit* cUnit, RegLocation rlSrc, int rDest)
{
- rlSrc = oatUpdateLoc(cUnit, rlSrc);
+ rlSrc = UpdateLoc(cUnit, rlSrc);
if (rlSrc.location == kLocPhysReg) {
- opRegCopy(cUnit, rDest, rlSrc.lowReg);
+ OpRegCopy(cUnit, rDest, rlSrc.lowReg);
} else {
DCHECK((rlSrc.location == kLocDalvikFrame) ||
(rlSrc.location == kLocCompilerTemp));
- loadWordDisp(cUnit, targetReg(kSp), oatSRegOffset(cUnit, rlSrc.sRegLow), rDest);
+ LoadWordDisp(cUnit, TargetReg(kSp), SRegOffset(cUnit, rlSrc.sRegLow), rDest);
}
}
/*
- * Similar to loadValueDirect, but clobbers and allocates the target
+ * Similar to LoadValueDirect, but clobbers and allocates the target
* register. Should be used when loading to a fixed register (for example,
* loading arguments to an out of line call.
*/
-void loadValueDirectFixed(CompilationUnit* cUnit, RegLocation rlSrc, int rDest)
+void LoadValueDirectFixed(CompilationUnit* cUnit, RegLocation rlSrc, int rDest)
{
- oatClobber(cUnit, rDest);
- oatMarkInUse(cUnit, rDest);
- loadValueDirect(cUnit, rlSrc, rDest);
+ Clobber(cUnit, rDest);
+ MarkInUse(cUnit, rDest);
+ LoadValueDirect(cUnit, rlSrc, rDest);
}
/*
@@ -83,56 +83,56 @@
* using this routine, as it doesn't perform any bookkeeping regarding
* register liveness. That is the responsibility of the caller.
*/
-void loadValueDirectWide(CompilationUnit* cUnit, RegLocation rlSrc, int regLo,
+void LoadValueDirectWide(CompilationUnit* cUnit, RegLocation rlSrc, int regLo,
int regHi)
{
- rlSrc = oatUpdateLocWide(cUnit, rlSrc);
+ rlSrc = UpdateLocWide(cUnit, rlSrc);
if (rlSrc.location == kLocPhysReg) {
- opRegCopyWide(cUnit, regLo, regHi, rlSrc.lowReg, rlSrc.highReg);
+ OpRegCopyWide(cUnit, regLo, regHi, rlSrc.lowReg, rlSrc.highReg);
} else {
DCHECK((rlSrc.location == kLocDalvikFrame) ||
(rlSrc.location == kLocCompilerTemp));
- loadBaseDispWide(cUnit, targetReg(kSp), oatSRegOffset(cUnit, rlSrc.sRegLow),
+ LoadBaseDispWide(cUnit, TargetReg(kSp), SRegOffset(cUnit, rlSrc.sRegLow),
regLo, regHi, INVALID_SREG);
}
}
/*
- * Similar to loadValueDirect, but clobbers and allocates the target
+ * Similar to LoadValueDirect, but clobbers and allocates the target
* registers. Should be used when loading to a fixed registers (for example,
* loading arguments to an out of line call.
*/
-void loadValueDirectWideFixed(CompilationUnit* cUnit, RegLocation rlSrc,
+void LoadValueDirectWideFixed(CompilationUnit* cUnit, RegLocation rlSrc,
int regLo, int regHi)
{
- oatClobber(cUnit, regLo);
- oatClobber(cUnit, regHi);
- oatMarkInUse(cUnit, regLo);
- oatMarkInUse(cUnit, regHi);
- loadValueDirectWide(cUnit, rlSrc, regLo, regHi);
+ Clobber(cUnit, regLo);
+ Clobber(cUnit, regHi);
+ MarkInUse(cUnit, regLo);
+ MarkInUse(cUnit, regHi);
+ LoadValueDirectWide(cUnit, rlSrc, regLo, regHi);
}
-RegLocation loadValue(CompilationUnit* cUnit, RegLocation rlSrc,
+RegLocation LoadValue(CompilationUnit* cUnit, RegLocation rlSrc,
RegisterClass opKind)
{
- rlSrc = oatEvalLoc(cUnit, rlSrc, opKind, false);
+ rlSrc = EvalLoc(cUnit, rlSrc, opKind, false);
if (rlSrc.location != kLocPhysReg) {
DCHECK((rlSrc.location == kLocDalvikFrame) ||
(rlSrc.location == kLocCompilerTemp));
- loadValueDirect(cUnit, rlSrc, rlSrc.lowReg);
+ LoadValueDirect(cUnit, rlSrc, rlSrc.lowReg);
rlSrc.location = kLocPhysReg;
- oatMarkLive(cUnit, rlSrc.lowReg, rlSrc.sRegLow);
+ MarkLive(cUnit, rlSrc.lowReg, rlSrc.sRegLow);
}
return rlSrc;
}
-void storeValue(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc)
+void StoreValue(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc)
{
#ifndef NDEBUG
/*
* Sanity checking - should never try to store to the same
* ssa name during the compilation of a single instruction
- * without an intervening oatClobberSReg().
+ * without an intervening ClobberSReg().
*/
DCHECK((cUnit->liveSReg == INVALID_SREG) ||
(rlDest.sRegLow != cUnit->liveSReg));
@@ -142,68 +142,68 @@
LIR* defEnd;
DCHECK(!rlDest.wide);
DCHECK(!rlSrc.wide);
- rlSrc = oatUpdateLoc(cUnit, rlSrc);
- rlDest = oatUpdateLoc(cUnit, rlDest);
+ rlSrc = UpdateLoc(cUnit, rlSrc);
+ rlDest = UpdateLoc(cUnit, rlDest);
if (rlSrc.location == kLocPhysReg) {
- if (oatIsLive(cUnit, rlSrc.lowReg) ||
- oatIsPromoted(cUnit, rlSrc.lowReg) ||
+ if (IsLive(cUnit, rlSrc.lowReg) ||
+ IsPromoted(cUnit, rlSrc.lowReg) ||
(rlDest.location == kLocPhysReg)) {
// Src is live/promoted or Dest has assigned reg.
- rlDest = oatEvalLoc(cUnit, rlDest, kAnyReg, false);
- opRegCopy(cUnit, rlDest.lowReg, rlSrc.lowReg);
+ rlDest = EvalLoc(cUnit, rlDest, kAnyReg, false);
+ OpRegCopy(cUnit, rlDest.lowReg, rlSrc.lowReg);
} else {
// Just re-assign the registers. Dest gets Src's regs
rlDest.lowReg = rlSrc.lowReg;
- oatClobber(cUnit, rlSrc.lowReg);
+ Clobber(cUnit, rlSrc.lowReg);
}
} else {
// Load Src either into promoted Dest or temps allocated for Dest
- rlDest = oatEvalLoc(cUnit, rlDest, kAnyReg, false);
- loadValueDirect(cUnit, rlSrc, rlDest.lowReg);
+ rlDest = EvalLoc(cUnit, rlDest, kAnyReg, false);
+ LoadValueDirect(cUnit, rlSrc, rlDest.lowReg);
}
// Dest is now live and dirty (until/if we flush it to home location)
- oatMarkLive(cUnit, rlDest.lowReg, rlDest.sRegLow);
- oatMarkDirty(cUnit, rlDest);
+ MarkLive(cUnit, rlDest.lowReg, rlDest.sRegLow);
+ MarkDirty(cUnit, rlDest);
- oatResetDefLoc(cUnit, rlDest);
- if (oatIsDirty(cUnit, rlDest.lowReg) &&
+ ResetDefLoc(cUnit, rlDest);
+ if (IsDirty(cUnit, rlDest.lowReg) &&
oatLiveOut(cUnit, rlDest.sRegLow)) {
defStart = cUnit->lastLIRInsn;
- storeBaseDisp(cUnit, targetReg(kSp), oatSRegOffset(cUnit, rlDest.sRegLow),
+ StoreBaseDisp(cUnit, TargetReg(kSp), SRegOffset(cUnit, rlDest.sRegLow),
rlDest.lowReg, kWord);
- oatMarkClean(cUnit, rlDest);
+ MarkClean(cUnit, rlDest);
defEnd = cUnit->lastLIRInsn;
- oatMarkDef(cUnit, rlDest, defStart, defEnd);
+ MarkDef(cUnit, rlDest, defStart, defEnd);
}
}
-RegLocation loadValueWide(CompilationUnit* cUnit, RegLocation rlSrc,
+RegLocation LoadValueWide(CompilationUnit* cUnit, RegLocation rlSrc,
RegisterClass opKind)
{
DCHECK(rlSrc.wide);
- rlSrc = oatEvalLoc(cUnit, rlSrc, opKind, false);
+ rlSrc = EvalLoc(cUnit, rlSrc, opKind, false);
if (rlSrc.location != kLocPhysReg) {
DCHECK((rlSrc.location == kLocDalvikFrame) ||
(rlSrc.location == kLocCompilerTemp));
- loadValueDirectWide(cUnit, rlSrc, rlSrc.lowReg, rlSrc.highReg);
+ LoadValueDirectWide(cUnit, rlSrc, rlSrc.lowReg, rlSrc.highReg);
rlSrc.location = kLocPhysReg;
- oatMarkLive(cUnit, rlSrc.lowReg, rlSrc.sRegLow);
- oatMarkLive(cUnit, rlSrc.highReg,
+ MarkLive(cUnit, rlSrc.lowReg, rlSrc.sRegLow);
+ MarkLive(cUnit, rlSrc.highReg,
oatSRegHi(rlSrc.sRegLow));
}
return rlSrc;
}
-void storeValueWide(CompilationUnit* cUnit, RegLocation rlDest,
+void StoreValueWide(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
#ifndef NDEBUG
/*
* Sanity checking - should never try to store to the same
* ssa name during the compilation of a single instruction
- * without an intervening oatClobberSReg().
+ * without an intervening ClobberSReg().
*/
DCHECK((cUnit->liveSReg == INVALID_SREG) ||
(rlDest.sRegLow != cUnit->liveSReg));
@@ -211,67 +211,67 @@
#endif
LIR* defStart;
LIR* defEnd;
- DCHECK_EQ(fpReg(rlSrc.lowReg), fpReg(rlSrc.highReg));
+ DCHECK_EQ(FpReg(rlSrc.lowReg), FpReg(rlSrc.highReg));
DCHECK(rlDest.wide);
DCHECK(rlSrc.wide);
if (rlSrc.location == kLocPhysReg) {
- if (oatIsLive(cUnit, rlSrc.lowReg) ||
- oatIsLive(cUnit, rlSrc.highReg) ||
- oatIsPromoted(cUnit, rlSrc.lowReg) ||
- oatIsPromoted(cUnit, rlSrc.highReg) ||
+ if (IsLive(cUnit, rlSrc.lowReg) ||
+ IsLive(cUnit, rlSrc.highReg) ||
+ IsPromoted(cUnit, rlSrc.lowReg) ||
+ IsPromoted(cUnit, rlSrc.highReg) ||
(rlDest.location == kLocPhysReg)) {
// Src is live or promoted or Dest has assigned reg.
- rlDest = oatEvalLoc(cUnit, rlDest, kAnyReg, false);
- opRegCopyWide(cUnit, rlDest.lowReg, rlDest.highReg,
+ rlDest = EvalLoc(cUnit, rlDest, kAnyReg, false);
+ OpRegCopyWide(cUnit, rlDest.lowReg, rlDest.highReg,
rlSrc.lowReg, rlSrc.highReg);
} else {
// Just re-assign the registers. Dest gets Src's regs
rlDest.lowReg = rlSrc.lowReg;
rlDest.highReg = rlSrc.highReg;
- oatClobber(cUnit, rlSrc.lowReg);
- oatClobber(cUnit, rlSrc.highReg);
+ Clobber(cUnit, rlSrc.lowReg);
+ Clobber(cUnit, rlSrc.highReg);
}
} else {
// Load Src either into promoted Dest or temps allocated for Dest
- rlDest = oatEvalLoc(cUnit, rlDest, kAnyReg, false);
- loadValueDirectWide(cUnit, rlSrc, rlDest.lowReg, rlDest.highReg);
+ rlDest = EvalLoc(cUnit, rlDest, kAnyReg, false);
+ LoadValueDirectWide(cUnit, rlSrc, rlDest.lowReg, rlDest.highReg);
}
// Dest is now live and dirty (until/if we flush it to home location)
- oatMarkLive(cUnit, rlDest.lowReg, rlDest.sRegLow);
- oatMarkLive(cUnit, rlDest.highReg, oatSRegHi(rlDest.sRegLow));
- oatMarkDirty(cUnit, rlDest);
- oatMarkPair(cUnit, rlDest.lowReg, rlDest.highReg);
+ MarkLive(cUnit, rlDest.lowReg, rlDest.sRegLow);
+ MarkLive(cUnit, rlDest.highReg, oatSRegHi(rlDest.sRegLow));
+ MarkDirty(cUnit, rlDest);
+ MarkPair(cUnit, rlDest.lowReg, rlDest.highReg);
- oatResetDefLocWide(cUnit, rlDest);
- if ((oatIsDirty(cUnit, rlDest.lowReg) ||
- oatIsDirty(cUnit, rlDest.highReg)) &&
+ ResetDefLocWide(cUnit, rlDest);
+ if ((IsDirty(cUnit, rlDest.lowReg) ||
+ IsDirty(cUnit, rlDest.highReg)) &&
(oatLiveOut(cUnit, rlDest.sRegLow) ||
oatLiveOut(cUnit, oatSRegHi(rlDest.sRegLow)))) {
defStart = cUnit->lastLIRInsn;
DCHECK_EQ((SRegToVReg(cUnit, rlDest.sRegLow)+1),
SRegToVReg(cUnit, oatSRegHi(rlDest.sRegLow)));
- storeBaseDispWide(cUnit, targetReg(kSp), oatSRegOffset(cUnit, rlDest.sRegLow),
+ StoreBaseDispWide(cUnit, TargetReg(kSp), SRegOffset(cUnit, rlDest.sRegLow),
rlDest.lowReg, rlDest.highReg);
- oatMarkClean(cUnit, rlDest);
+ MarkClean(cUnit, rlDest);
defEnd = cUnit->lastLIRInsn;
- oatMarkDefWide(cUnit, rlDest, defStart, defEnd);
+ MarkDefWide(cUnit, rlDest, defStart, defEnd);
}
}
/* Utilities to load the current Method* */
-void loadCurrMethodDirect(CompilationUnit *cUnit, int rTgt)
+void LoadCurrMethodDirect(CompilationUnit *cUnit, int rTgt)
{
- loadValueDirectFixed(cUnit, cUnit->methodLoc, rTgt);
+ LoadValueDirectFixed(cUnit, cUnit->methodLoc, rTgt);
}
-RegLocation loadCurrMethod(CompilationUnit *cUnit)
+RegLocation LoadCurrMethod(CompilationUnit *cUnit)
{
- return loadValue(cUnit, cUnit->methodLoc, kCoreReg);
+ return LoadValue(cUnit, cUnit->methodLoc, kCoreReg);
}
-bool methodStarInReg(CompilationUnit* cUnit)
+bool MethodStarInReg(CompilationUnit* cUnit)
{
return (cUnit->methodLoc.location == kLocPhysReg);
}
diff --git a/src/compiler/codegen/gen_loadstore.h b/src/compiler/codegen/gen_loadstore.h
index a06ed79..12c8011 100644
--- a/src/compiler/codegen/gen_loadstore.h
+++ b/src/compiler/codegen/gen_loadstore.h
@@ -17,19 +17,19 @@
#ifndef ART_SRC_COMPILER_CODEGEN_GENLOADSTORE_H_
#define ART_SRC_COMPILER_CODEGEN_GENLOADSTORE_H_
-LIR* loadConstant(CompilationUnit* cUnit, int rDest, int value);
-LIR* loadWordDisp(CompilationUnit* cUnit, int rBase, int displacement, int rDest);
-LIR* storeWordDisp(CompilationUnit* cUnit, int rBase, int displacement, int rSrc);
-void loadValueDirect(CompilationUnit* cUnit, RegLocation rlSrc, int rDest);
-void loadValueDirectFixed(CompilationUnit* cUnit, RegLocation rlSrc, int rDest);
-void loadValueDirectWide(CompilationUnit* cUnit, RegLocation rlSrc, int regLo, int regHi);
-void loadValueDirectWideFixed(CompilationUnit* cUnit, RegLocation rlSrc, int regLo, int regHi);
-RegLocation loadValue(CompilationUnit* cUnit, RegLocation rlSrc, RegisterClass opKind);
-void storeValue(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
-RegLocation loadValueWide(CompilationUnit* cUnit, RegLocation rlSrc, RegisterClass opKind);
-void storeValueWide(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
-void loadCurrMethodDirect(CompilationUnit *cUnit, int rTgt);
-RegLocation loadCurrMethod(CompilationUnit *cUnit);
-bool methodStarInReg(CompilationUnit* cUnit);
+LIR* LoadConstant(CompilationUnit* cUnit, int rDest, int value);
+LIR* LoadWordDisp(CompilationUnit* cUnit, int rBase, int displacement, int rDest);
+LIR* StoreWordDisp(CompilationUnit* cUnit, int rBase, int displacement, int rSrc);
+void LoadValueDirect(CompilationUnit* cUnit, RegLocation rlSrc, int rDest);
+void LoadValueDirectFixed(CompilationUnit* cUnit, RegLocation rlSrc, int rDest);
+void LoadValueDirectWide(CompilationUnit* cUnit, RegLocation rlSrc, int regLo, int regHi);
+void LoadValueDirectWideFixed(CompilationUnit* cUnit, RegLocation rlSrc, int regLo, int regHi);
+RegLocation LoadValue(CompilationUnit* cUnit, RegLocation rlSrc, RegisterClass opKind);
+void StoreValue(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
+RegLocation LoadValueWide(CompilationUnit* cUnit, RegLocation rlSrc, RegisterClass opKind);
+void StoreValueWide(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
+void LoadCurrMethodDirect(CompilationUnit *cUnit, int rTgt);
+RegLocation LoadCurrMethod(CompilationUnit *cUnit);
+bool MethodStarInReg(CompilationUnit* cUnit);
#endif // ART_SRC_COMPILER_CODEGEN_GENLOADSTORE_H_
diff --git a/src/compiler/codegen/local_optimizations.cc b/src/compiler/codegen/local_optimizations.cc
index 7956c05..d3897e7 100644
--- a/src/compiler/codegen/local_optimizations.cc
+++ b/src/compiler/codegen/local_optimizations.cc
@@ -29,7 +29,7 @@
#define LDLD_DISTANCE 4
#define LD_LATENCY 2
-inline bool isDalvikRegisterClobbered(LIR* lir1, LIR* lir2)
+inline bool IsDalvikRegisterClobbered(LIR* lir1, LIR* lir2)
{
int reg1Lo = DECODE_ALIAS_INFO_REG(lir1->aliasInfo);
int reg1Hi = reg1Lo + DECODE_ALIAS_INFO_WIDE(lir1->aliasInfo);
@@ -40,19 +40,19 @@
}
/* Convert a more expensive instruction (ie load) into a move */
-void convertMemOpIntoMove(CompilationUnit* cUnit, LIR* origLIR, int dest,
+void ConvertMemOpIntoMove(CompilationUnit* cUnit, LIR* origLIR, int dest,
int src)
{
/* Insert a move to replace the load */
LIR* moveLIR;
- moveLIR = opRegCopyNoInsert( cUnit, dest, src);
+ moveLIR = OpRegCopyNoInsert( cUnit, dest, src);
/*
* Insert the converted instruction after the original since the
* optimization is scannng in the top-down order and the new instruction
* will need to be re-checked (eg the new dest clobbers the src used in
* thisLIR).
*/
- oatInsertLIRAfter(origLIR, moveLIR);
+ InsertLIRAfter(origLIR, moveLIR);
}
/*
@@ -73,7 +73,7 @@
* 1) They are must-aliases
* 2) The memory location is not written to in between
*/
-void applyLoadStoreElimination(CompilationUnit* cUnit, LIR* headLIR,
+void ApplyLoadStoreElimination(CompilationUnit* cUnit, LIR* headLIR,
LIR* tailLIR)
{
LIR* thisLIR;
@@ -88,20 +88,20 @@
/* Skip non-interesting instructions */
if ((thisLIR->flags.isNop == true) ||
isPseudoOpcode(thisLIR->opcode) ||
- (getTargetInstFlags(thisLIR->opcode) & IS_BRANCH) ||
- !(getTargetInstFlags(thisLIR->opcode) & (IS_LOAD | IS_STORE))) {
+ (GetTargetInstFlags(thisLIR->opcode) & IS_BRANCH) ||
+ !(GetTargetInstFlags(thisLIR->opcode) & (IS_LOAD | IS_STORE))) {
continue;
}
int nativeRegId;
if (cUnit->instructionSet == kX86) {
// If x86, location differs depending on whether memory/reg operation.
- nativeRegId = (getTargetInstFlags(thisLIR->opcode) & IS_STORE) ? thisLIR->operands[2]
+ nativeRegId = (GetTargetInstFlags(thisLIR->opcode) & IS_STORE) ? thisLIR->operands[2]
: thisLIR->operands[0];
} else {
nativeRegId = thisLIR->operands[0];
}
- bool isThisLIRLoad = getTargetInstFlags(thisLIR->opcode) & IS_LOAD;
+ bool isThisLIRLoad = GetTargetInstFlags(thisLIR->opcode) & IS_LOAD;
LIR* checkLIR;
/* Use the mem mask to determine the rough memory location */
uint64_t thisMemMask = (thisLIR->useMask | thisLIR->defMask) & ENCODE_MEM;
@@ -123,7 +123,7 @@
* region bits since stopMask is used to check data/control
* dependencies.
*/
- stopUseRegMask = (getPCUseDefEncoding() | thisLIR->useMask) & ~ENCODE_MEM;
+ stopUseRegMask = (GetPCUseDefEncoding() | thisLIR->useMask) & ~ENCODE_MEM;
}
for (checkLIR = NEXT_LIR(thisLIR);
@@ -144,22 +144,22 @@
* Potential aliases seen - check the alias relations
*/
if (checkMemMask != ENCODE_MEM && aliasCondition != 0) {
- bool isCheckLIRLoad = getTargetInstFlags(checkLIR->opcode) & IS_LOAD;
+ bool isCheckLIRLoad = GetTargetInstFlags(checkLIR->opcode) & IS_LOAD;
if (aliasCondition == ENCODE_LITERAL) {
/*
* Should only see literal loads in the instruction
* stream.
*/
- DCHECK(!(getTargetInstFlags(checkLIR->opcode) & IS_STORE));
+ DCHECK(!(GetTargetInstFlags(checkLIR->opcode) & IS_STORE));
/* Same value && same register type */
if (checkLIR->aliasInfo == thisLIR->aliasInfo &&
- sameRegType(checkLIR->operands[0], nativeRegId)) {
+ SameRegType(checkLIR->operands[0], nativeRegId)) {
/*
* Different destination register - insert
* a move
*/
if (checkLIR->operands[0] != nativeRegId) {
- convertMemOpIntoMove(cUnit, checkLIR, checkLIR->operands[0],
+ ConvertMemOpIntoMove(cUnit, checkLIR, checkLIR->operands[0],
nativeRegId);
}
checkLIR->flags.isNop = true;
@@ -168,7 +168,7 @@
/* Must alias */
if (checkLIR->aliasInfo == thisLIR->aliasInfo) {
/* Only optimize compatible registers */
- bool regCompatible = sameRegType(checkLIR->operands[0], nativeRegId);
+ bool regCompatible = SameRegType(checkLIR->operands[0], nativeRegId);
if ((isThisLIRLoad && isCheckLIRLoad) ||
(!isThisLIRLoad && isCheckLIRLoad)) {
/* RAR or RAW */
@@ -179,7 +179,7 @@
*/
if (checkLIR->operands[0] !=
nativeRegId) {
- convertMemOpIntoMove(cUnit, checkLIR, checkLIR->operands[0],
+ ConvertMemOpIntoMove(cUnit, checkLIR, checkLIR->operands[0],
nativeRegId);
}
checkLIR->flags.isNop = true;
@@ -200,7 +200,7 @@
stopHere = true;
}
/* Partial overlap */
- } else if (isDalvikRegisterClobbered(thisLIR, checkLIR)) {
+ } else if (IsDalvikRegisterClobbered(thisLIR, checkLIR)) {
/*
* It is actually ok to continue if checkLIR
* is a read. But it is hard to make a test
@@ -233,7 +233,7 @@
if (cUnit->instructionSet == kX86) {
// Prevent stores from being sunk between ops that generate ccodes and
// ops that use them.
- uint64_t flags = getTargetInstFlags(checkLIR->opcode);
+ uint64_t flags = GetTargetInstFlags(checkLIR->opcode);
if (sinkDistance > 0 && (flags & IS_BRANCH) && (flags & USES_CCODES)) {
checkLIR = PREV_LIR(checkLIR);
sinkDistance--;
@@ -242,14 +242,14 @@
DEBUG_OPT(dumpDependentInsnPair(thisLIR, checkLIR, "REG CLOBBERED"));
/* Only sink store instructions */
if (sinkDistance && !isThisLIRLoad) {
- LIR* newStoreLIR = static_cast<LIR*>(oatNew(cUnit, sizeof(LIR), true, kAllocLIR));
+ LIR* newStoreLIR = static_cast<LIR*>(NewMem(cUnit, sizeof(LIR), true, kAllocLIR));
*newStoreLIR = *thisLIR;
/*
* Stop point found - insert *before* the checkLIR
* since the instruction list is scanned in the
* top-down order.
*/
- oatInsertLIRBefore(checkLIR, newStoreLIR);
+ InsertLIRBefore(checkLIR, newStoreLIR);
thisLIR->flags.isNop = true;
}
break;
@@ -264,7 +264,7 @@
* Perform a pass of bottom-up walk, from the second instruction in the
* superblock, to try to hoist loads to earlier slots.
*/
-void applyLoadHoisting(CompilationUnit* cUnit, LIR* headLIR, LIR* tailLIR)
+void ApplyLoadHoisting(CompilationUnit* cUnit, LIR* headLIR, LIR* tailLIR)
{
LIR* thisLIR, *checkLIR;
/*
@@ -284,7 +284,7 @@
/* Skip non-interesting instructions */
if ((thisLIR->flags.isNop == true) ||
isPseudoOpcode(thisLIR->opcode) ||
- !(getTargetInstFlags(thisLIR->opcode) & IS_LOAD)) {
+ !(GetTargetInstFlags(thisLIR->opcode) & IS_LOAD)) {
continue;
}
@@ -298,7 +298,7 @@
* conservatively here.
*/
if (stopUseAllMask & ENCODE_HEAP_REF) {
- stopUseAllMask |= getPCUseDefEncoding();
+ stopUseAllMask |= GetPCUseDefEncoding();
}
}
@@ -330,7 +330,7 @@
if (aliasCondition == ENCODE_DALVIK_REG) {
/* Must alias or partually overlap */
if ((checkLIR->aliasInfo == thisLIR->aliasInfo) ||
- isDalvikRegisterClobbered(thisLIR, checkLIR)) {
+ IsDalvikRegisterClobbered(thisLIR, checkLIR)) {
stopHere = true;
}
/* Conservatively treat all heap refs as may-alias */
@@ -384,7 +384,7 @@
LIR* depLIR = prevInstList[nextSlot-1];
/* If there is ld-ld dependency, wait LDLD_DISTANCE cycles */
if (!isPseudoOpcode(depLIR->opcode) &&
- (getTargetInstFlags(depLIR->opcode) & IS_LOAD)) {
+ (GetTargetInstFlags(depLIR->opcode) & IS_LOAD)) {
firstSlot -= LDLD_DISTANCE;
}
/*
@@ -401,7 +401,7 @@
* If the first instruction is a load, don't hoist anything
* above it since it is unlikely to be beneficial.
*/
- if (getTargetInstFlags(curLIR->opcode) & IS_LOAD) continue;
+ if (GetTargetInstFlags(curLIR->opcode) & IS_LOAD) continue;
/*
* If the remaining number of slots is less than LD_LATENCY,
* insert the hoisted load here.
@@ -421,7 +421,7 @@
* the remaining instructions are less than LD_LATENCY.
*/
bool prevIsLoad = isPseudoOpcode(prevLIR->opcode) ? false :
- (getTargetInstFlags(prevLIR->opcode) & IS_LOAD);
+ (GetTargetInstFlags(prevLIR->opcode) & IS_LOAD);
if (((curLIR->useMask & prevLIR->defMask) && prevIsLoad) || (slot < LD_LATENCY)) {
break;
}
@@ -430,27 +430,27 @@
/* Found a slot to hoist to */
if (slot >= 0) {
LIR* curLIR = prevInstList[slot];
- LIR* newLoadLIR = static_cast<LIR*>(oatNew(cUnit, sizeof(LIR), true, kAllocLIR));
+ LIR* newLoadLIR = static_cast<LIR*>(NewMem(cUnit, sizeof(LIR), true, kAllocLIR));
*newLoadLIR = *thisLIR;
/*
* Insertion is guaranteed to succeed since checkLIR
* is never the first LIR on the list
*/
- oatInsertLIRBefore(curLIR, newLoadLIR);
+ InsertLIRBefore(curLIR, newLoadLIR);
thisLIR->flags.isNop = true;
}
}
}
}
-void oatApplyLocalOptimizations(CompilationUnit* cUnit, LIR* headLIR,
+void ApplyLocalOptimizations(CompilationUnit* cUnit, LIR* headLIR,
LIR* tailLIR)
{
if (!(cUnit->disableOpt & (1 << kLoadStoreElimination))) {
- applyLoadStoreElimination(cUnit, headLIR, tailLIR);
+ ApplyLoadStoreElimination(cUnit, headLIR, tailLIR);
}
if (!(cUnit->disableOpt & (1 << kLoadHoisting))) {
- applyLoadHoisting(cUnit, headLIR, tailLIR);
+ ApplyLoadHoisting(cUnit, headLIR, tailLIR);
}
}
@@ -459,14 +459,14 @@
* Note: new redundant branches may be inserted later, and we'll
* use a check in final instruction assembly to nop those out.
*/
-void removeRedundantBranches(CompilationUnit* cUnit)
+void RemoveRedundantBranches(CompilationUnit* cUnit)
{
LIR* thisLIR;
for (thisLIR = cUnit->firstLIRInsn; thisLIR != cUnit->lastLIRInsn; thisLIR = NEXT_LIR(thisLIR)) {
/* Branch to the next instruction */
- if (branchUnconditional(thisLIR)) {
+ if (BranchUnconditional(thisLIR)) {
LIR* nextLIR = thisLIR;
while (true) {
diff --git a/src/compiler/codegen/local_optimizations.h b/src/compiler/codegen/local_optimizations.h
index 5f0c17b..e740b13 100644
--- a/src/compiler/codegen/local_optimizations.h
+++ b/src/compiler/codegen/local_optimizations.h
@@ -19,8 +19,8 @@
namespace art {
-void oatApplyLocalOptimizations(CompilationUnit* cUnit, LIR* headLIR, LIR* tailLIR);
-void removeRedundantBranches(CompilationUnit* cUnit);
+void ApplyLocalOptimizations(CompilationUnit* cUnit, LIR* headLIR, LIR* tailLIR);
+void RemoveRedundantBranches(CompilationUnit* cUnit);
} // namespace art
diff --git a/src/compiler/codegen/method_bitcode.cc b/src/compiler/codegen/method_bitcode.cc
index 72e3e68..0115484 100644
--- a/src/compiler/codegen/method_bitcode.cc
+++ b/src/compiler/codegen/method_bitcode.cc
@@ -43,22 +43,22 @@
const RegLocation badLoc = {kLocDalvikFrame, 0, 0, 0, 0, 0, 0, 0, 0,
INVALID_REG, INVALID_REG, INVALID_SREG,
INVALID_SREG};
-RegLocation getLoc(CompilationUnit* cUnit, llvm::Value* val);
+RegLocation GetLoc(CompilationUnit* cUnit, llvm::Value* val);
-llvm::BasicBlock* getLLVMBlock(CompilationUnit* cUnit, int id)
+llvm::BasicBlock* GetLLVMBlock(CompilationUnit* cUnit, int id)
{
return cUnit->idToBlockMap.Get(id);
}
-llvm::Value* getLLVMValue(CompilationUnit* cUnit, int sReg)
+llvm::Value* GetLLVMValue(CompilationUnit* cUnit, int sReg)
{
- return reinterpret_cast<llvm::Value*>(oatGrowableListGetElement(&cUnit->llvmValues, sReg));
+ return reinterpret_cast<llvm::Value*>(GrowableListGetElement(&cUnit->llvmValues, sReg));
}
// Replace the placeholder value with the real definition
-void defineValue(CompilationUnit* cUnit, llvm::Value* val, int sReg)
+void DefineValue(CompilationUnit* cUnit, llvm::Value* val, int sReg)
{
- llvm::Value* placeholder = getLLVMValue(cUnit, sReg);
+ llvm::Value* placeholder = GetLLVMValue(cUnit, sReg);
if (placeholder == NULL) {
// This can happen on instruction rewrite on verification failure
LOG(WARNING) << "Null placeholder";
@@ -83,7 +83,7 @@
}
}
-llvm::Type* llvmTypeFromLocRec(CompilationUnit* cUnit, RegLocation loc)
+llvm::Type* LlvmTypeFromLocRec(CompilationUnit* cUnit, RegLocation loc)
{
llvm::Type* res = NULL;
if (loc.wide) {
@@ -105,7 +105,7 @@
}
/* Create an in-memory RegLocation from an llvm Value. */
-void createLocFromValue(CompilationUnit* cUnit, llvm::Value* val)
+void CreateLocFromValue(CompilationUnit* cUnit, llvm::Value* val)
{
// NOTE: llvm takes shortcuts with c_str() - get to std::string firstt
std::string s(val->getName().str());
@@ -135,7 +135,7 @@
if (ty == cUnit->irb->getFloatTy()) {
loc.fp = true;
if (pMap.fpLocation == kLocPhysReg) {
- loc.lowReg = pMap.fpReg;
+ loc.lowReg = pMap.FpReg;
loc.location = kLocPhysReg;
loc.home = true;
}
@@ -144,10 +144,10 @@
PromotionMap pMapHigh = cUnit->promotionMap[baseSReg + 1];
if ((pMap.fpLocation == kLocPhysReg) &&
(pMapHigh.fpLocation == kLocPhysReg) &&
- ((pMap.fpReg & 0x1) == 0) &&
- (pMap.fpReg + 1 == pMapHigh.fpReg)) {
- loc.lowReg = pMap.fpReg;
- loc.highReg = pMapHigh.fpReg;
+ ((pMap.FpReg & 0x1) == 0) &&
+ (pMap.FpReg + 1 == pMapHigh.FpReg)) {
+ loc.lowReg = pMap.FpReg;
+ loc.highReg = pMapHigh.FpReg;
loc.location = kLocPhysReg;
loc.home = true;
}
@@ -186,7 +186,7 @@
}
cUnit->locMap.Put(val, loc);
}
-void initIR(CompilationUnit* cUnit)
+void InitIR(CompilationUnit* cUnit)
{
LLVMInfo* llvmInfo = cUnit->llvm_info;
if (llvmInfo == NULL) {
@@ -204,33 +204,33 @@
cUnit->irb = llvmInfo->GetIRBuilder();
}
-const char* llvmSSAName(CompilationUnit* cUnit, int ssaReg) {
+const char* LlvmSSAName(CompilationUnit* cUnit, int ssaReg) {
return GET_ELEM_N(cUnit->ssaStrings, char*, ssaReg);
}
-llvm::BasicBlock* findCaseTarget(CompilationUnit* cUnit, uint32_t vaddr)
+llvm::BasicBlock* FindCaseTarget(CompilationUnit* cUnit, uint32_t vaddr)
{
- BasicBlock* bb = oatFindBlock(cUnit, vaddr);
+ BasicBlock* bb = FindBlock(cUnit, vaddr);
DCHECK(bb != NULL);
- return getLLVMBlock(cUnit, bb->id);
+ return GetLLVMBlock(cUnit, bb->id);
}
-void convertPackedSwitch(CompilationUnit* cUnit, BasicBlock* bb,
+void ConvertPackedSwitch(CompilationUnit* cUnit, BasicBlock* bb,
int32_t tableOffset, RegLocation rlSrc)
{
const Instruction::PackedSwitchPayload* payload =
reinterpret_cast<const Instruction::PackedSwitchPayload*>(
cUnit->insns + cUnit->currentDalvikOffset + tableOffset);
- llvm::Value* value = getLLVMValue(cUnit, rlSrc.origSReg);
+ llvm::Value* value = GetLLVMValue(cUnit, rlSrc.origSReg);
llvm::SwitchInst* sw =
- cUnit->irb->CreateSwitch(value, getLLVMBlock(cUnit, bb->fallThrough->id),
+ cUnit->irb->CreateSwitch(value, GetLLVMBlock(cUnit, bb->fallThrough->id),
payload->case_count);
for (uint16_t i = 0; i < payload->case_count; ++i) {
llvm::BasicBlock* llvmBB =
- findCaseTarget(cUnit, cUnit->currentDalvikOffset + payload->targets[i]);
+ FindCaseTarget(cUnit, cUnit->currentDalvikOffset + payload->targets[i]);
sw->addCase(cUnit->irb->getInt32(payload->first_key + i), llvmBB);
}
llvm::MDNode* switchNode =
@@ -240,7 +240,7 @@
bb->fallThrough = NULL;
}
-void convertSparseSwitch(CompilationUnit* cUnit, BasicBlock* bb,
+void ConvertSparseSwitch(CompilationUnit* cUnit, BasicBlock* bb,
int32_t tableOffset, RegLocation rlSrc)
{
const Instruction::SparseSwitchPayload* payload =
@@ -250,15 +250,15 @@
const int32_t* keys = payload->GetKeys();
const int32_t* targets = payload->GetTargets();
- llvm::Value* value = getLLVMValue(cUnit, rlSrc.origSReg);
+ llvm::Value* value = GetLLVMValue(cUnit, rlSrc.origSReg);
llvm::SwitchInst* sw =
- cUnit->irb->CreateSwitch(value, getLLVMBlock(cUnit, bb->fallThrough->id),
+ cUnit->irb->CreateSwitch(value, GetLLVMBlock(cUnit, bb->fallThrough->id),
payload->case_count);
for (size_t i = 0; i < payload->case_count; ++i) {
llvm::BasicBlock* llvmBB =
- findCaseTarget(cUnit, cUnit->currentDalvikOffset + targets[i]);
+ FindCaseTarget(cUnit, cUnit->currentDalvikOffset + targets[i]);
sw->addCase(cUnit->irb->getInt32(keys[i]), llvmBB);
}
llvm::MDNode* switchNode =
@@ -268,40 +268,40 @@
bb->fallThrough = NULL;
}
-void convertSget(CompilationUnit* cUnit, int32_t fieldIndex,
+void ConvertSget(CompilationUnit* cUnit, int32_t fieldIndex,
greenland::IntrinsicHelper::IntrinsicId id,
RegLocation rlDest)
{
llvm::Constant* fieldIdx = cUnit->irb->getInt32(fieldIndex);
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::Value* res = cUnit->irb->CreateCall(intr, fieldIdx);
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertSput(CompilationUnit* cUnit, int32_t fieldIndex,
+void ConvertSput(CompilationUnit* cUnit, int32_t fieldIndex,
greenland::IntrinsicHelper::IntrinsicId id,
RegLocation rlSrc)
{
llvm::SmallVector<llvm::Value*, 2> args;
args.push_back(cUnit->irb->getInt32(fieldIndex));
- args.push_back(getLLVMValue(cUnit, rlSrc.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc.origSReg));
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
cUnit->irb->CreateCall(intr, args);
}
-void convertFillArrayData(CompilationUnit* cUnit, int32_t offset,
+void ConvertFillArrayData(CompilationUnit* cUnit, int32_t offset,
RegLocation rlArray)
{
greenland::IntrinsicHelper::IntrinsicId id;
id = greenland::IntrinsicHelper::HLFillArrayData;
llvm::SmallVector<llvm::Value*, 2> args;
args.push_back(cUnit->irb->getInt32(offset));
- args.push_back(getLLVMValue(cUnit, rlArray.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlArray.origSReg));
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
cUnit->irb->CreateCall(intr, args);
}
-llvm::Value* emitConst(CompilationUnit* cUnit, llvm::ArrayRef<llvm::Value*> src,
+llvm::Value* EmitConst(CompilationUnit* cUnit, llvm::ArrayRef<llvm::Value*> src,
RegLocation loc)
{
greenland::IntrinsicHelper::IntrinsicId id;
@@ -324,14 +324,14 @@
return cUnit->irb->CreateCall(intr, src);
}
-void emitPopShadowFrame(CompilationUnit* cUnit)
+void EmitPopShadowFrame(CompilationUnit* cUnit)
{
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(
greenland::IntrinsicHelper::PopShadowFrame);
cUnit->irb->CreateCall(intr);
}
-llvm::Value* emitCopy(CompilationUnit* cUnit, llvm::ArrayRef<llvm::Value*> src,
+llvm::Value* EmitCopy(CompilationUnit* cUnit, llvm::ArrayRef<llvm::Value*> src,
RegLocation loc)
{
greenland::IntrinsicHelper::IntrinsicId id;
@@ -354,46 +354,46 @@
return cUnit->irb->CreateCall(intr, src);
}
-void convertMoveException(CompilationUnit* cUnit, RegLocation rlDest)
+void ConvertMoveException(CompilationUnit* cUnit, RegLocation rlDest)
{
llvm::Function* func = cUnit->intrinsic_helper->GetIntrinsicFunction(
greenland::IntrinsicHelper::GetException);
llvm::Value* res = cUnit->irb->CreateCall(func);
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertThrow(CompilationUnit* cUnit, RegLocation rlSrc)
+void ConvertThrow(CompilationUnit* cUnit, RegLocation rlSrc)
{
- llvm::Value* src = getLLVMValue(cUnit, rlSrc.origSReg);
+ llvm::Value* src = GetLLVMValue(cUnit, rlSrc.origSReg);
llvm::Function* func = cUnit->intrinsic_helper->GetIntrinsicFunction(
greenland::IntrinsicHelper::HLThrowException);
cUnit->irb->CreateCall(func, src);
}
-void convertMonitorEnterExit(CompilationUnit* cUnit, int optFlags,
+void ConvertMonitorEnterExit(CompilationUnit* cUnit, int optFlags,
greenland::IntrinsicHelper::IntrinsicId id,
RegLocation rlSrc)
{
llvm::SmallVector<llvm::Value*, 2> args;
args.push_back(cUnit->irb->getInt32(optFlags));
- args.push_back(getLLVMValue(cUnit, rlSrc.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc.origSReg));
llvm::Function* func = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
cUnit->irb->CreateCall(func, args);
}
-void convertArrayLength(CompilationUnit* cUnit, int optFlags,
+void ConvertArrayLength(CompilationUnit* cUnit, int optFlags,
RegLocation rlDest, RegLocation rlSrc)
{
llvm::SmallVector<llvm::Value*, 2> args;
args.push_back(cUnit->irb->getInt32(optFlags));
- args.push_back(getLLVMValue(cUnit, rlSrc.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc.origSReg));
llvm::Function* func = cUnit->intrinsic_helper->GetIntrinsicFunction(
greenland::IntrinsicHelper::OptArrayLength);
llvm::Value* res = cUnit->irb->CreateCall(func, args);
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void emitSuspendCheck(CompilationUnit* cUnit)
+void EmitSuspendCheck(CompilationUnit* cUnit)
{
greenland::IntrinsicHelper::IntrinsicId id =
greenland::IntrinsicHelper::CheckSuspend;
@@ -401,7 +401,7 @@
cUnit->irb->CreateCall(intr);
}
-llvm::Value* convertCompare(CompilationUnit* cUnit, ConditionCode cc,
+llvm::Value* ConvertCompare(CompilationUnit* cUnit, ConditionCode cc,
llvm::Value* src1, llvm::Value* src2)
{
llvm::Value* res = NULL;
@@ -418,44 +418,44 @@
return res;
}
-void convertCompareAndBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+void ConvertCompareAndBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
ConditionCode cc, RegLocation rlSrc1,
RegLocation rlSrc2)
{
if (bb->taken->startOffset <= mir->offset) {
- emitSuspendCheck(cUnit);
+ EmitSuspendCheck(cUnit);
}
- llvm::Value* src1 = getLLVMValue(cUnit, rlSrc1.origSReg);
- llvm::Value* src2 = getLLVMValue(cUnit, rlSrc2.origSReg);
- llvm::Value* condValue = convertCompare(cUnit, cc, src1, src2);
+ llvm::Value* src1 = GetLLVMValue(cUnit, rlSrc1.origSReg);
+ llvm::Value* src2 = GetLLVMValue(cUnit, rlSrc2.origSReg);
+ llvm::Value* condValue = ConvertCompare(cUnit, cc, src1, src2);
condValue->setName(StringPrintf("t%d", cUnit->tempName++));
- cUnit->irb->CreateCondBr(condValue, getLLVMBlock(cUnit, bb->taken->id),
- getLLVMBlock(cUnit, bb->fallThrough->id));
+ cUnit->irb->CreateCondBr(condValue, GetLLVMBlock(cUnit, bb->taken->id),
+ GetLLVMBlock(cUnit, bb->fallThrough->id));
// Don't redo the fallthrough branch in the BB driver
bb->fallThrough = NULL;
}
-void convertCompareZeroAndBranch(CompilationUnit* cUnit, BasicBlock* bb,
+void ConvertCompareZeroAndBranch(CompilationUnit* cUnit, BasicBlock* bb,
MIR* mir, ConditionCode cc, RegLocation rlSrc1)
{
if (bb->taken->startOffset <= mir->offset) {
- emitSuspendCheck(cUnit);
+ EmitSuspendCheck(cUnit);
}
- llvm::Value* src1 = getLLVMValue(cUnit, rlSrc1.origSReg);
+ llvm::Value* src1 = GetLLVMValue(cUnit, rlSrc1.origSReg);
llvm::Value* src2;
if (rlSrc1.ref) {
src2 = cUnit->irb->GetJNull();
} else {
src2 = cUnit->irb->getInt32(0);
}
- llvm::Value* condValue = convertCompare(cUnit, cc, src1, src2);
- cUnit->irb->CreateCondBr(condValue, getLLVMBlock(cUnit, bb->taken->id),
- getLLVMBlock(cUnit, bb->fallThrough->id));
+ llvm::Value* condValue = ConvertCompare(cUnit, cc, src1, src2);
+ cUnit->irb->CreateCondBr(condValue, GetLLVMBlock(cUnit, bb->taken->id),
+ GetLLVMBlock(cUnit, bb->fallThrough->id));
// Don't redo the fallthrough branch in the BB driver
bb->fallThrough = NULL;
}
-llvm::Value* genDivModOp(CompilationUnit* cUnit, bool isDiv, bool isLong,
+llvm::Value* GenDivModOp(CompilationUnit* cUnit, bool isDiv, bool isLong,
llvm::Value* src1, llvm::Value* src2)
{
greenland::IntrinsicHelper::IntrinsicId id;
@@ -479,7 +479,7 @@
return cUnit->irb->CreateCall(intr, args);
}
-llvm::Value* genArithOp(CompilationUnit* cUnit, OpKind op, bool isLong,
+llvm::Value* GenArithOp(CompilationUnit* cUnit, OpKind op, bool isLong,
llvm::Value* src1, llvm::Value* src2)
{
llvm::Value* res = NULL;
@@ -491,8 +491,8 @@
case kOpOr: res = cUnit->irb->CreateOr(src1, src2); break;
case kOpAnd: res = cUnit->irb->CreateAnd(src1, src2); break;
case kOpXor: res = cUnit->irb->CreateXor(src1, src2); break;
- case kOpDiv: res = genDivModOp(cUnit, true, isLong, src1, src2); break;
- case kOpRem: res = genDivModOp(cUnit, false, isLong, src1, src2); break;
+ case kOpDiv: res = GenDivModOp(cUnit, true, isLong, src1, src2); break;
+ case kOpRem: res = GenDivModOp(cUnit, false, isLong, src1, src2); break;
case kOpLsl: res = cUnit->irb->CreateShl(src1, src2); break;
case kOpLsr: res = cUnit->irb->CreateLShr(src1, src2); break;
case kOpAsr: res = cUnit->irb->CreateAShr(src1, src2); break;
@@ -502,11 +502,11 @@
return res;
}
-void convertFPArithOp(CompilationUnit* cUnit, OpKind op, RegLocation rlDest,
+void ConvertFPArithOp(CompilationUnit* cUnit, OpKind op, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- llvm::Value* src1 = getLLVMValue(cUnit, rlSrc1.origSReg);
- llvm::Value* src2 = getLLVMValue(cUnit, rlSrc2.origSReg);
+ llvm::Value* src1 = GetLLVMValue(cUnit, rlSrc1.origSReg);
+ llvm::Value* src2 = GetLLVMValue(cUnit, rlSrc2.origSReg);
llvm::Value* res = NULL;
switch(op) {
case kOpAdd: res = cUnit->irb->CreateFAdd(src1, src2); break;
@@ -517,48 +517,48 @@
default:
LOG(FATAL) << "Invalid op " << op;
}
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertShift(CompilationUnit* cUnit,
+void ConvertShift(CompilationUnit* cUnit,
greenland::IntrinsicHelper::IntrinsicId id,
RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2)
{
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::SmallVector<llvm::Value*, 2>args;
- args.push_back(getLLVMValue(cUnit, rlSrc1.origSReg));
- args.push_back(getLLVMValue(cUnit, rlSrc2.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc1.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc2.origSReg));
llvm::Value* res = cUnit->irb->CreateCall(intr, args);
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertShiftLit(CompilationUnit* cUnit,
+void ConvertShiftLit(CompilationUnit* cUnit,
greenland::IntrinsicHelper::IntrinsicId id,
RegLocation rlDest, RegLocation rlSrc, int shiftAmount)
{
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::SmallVector<llvm::Value*, 2>args;
- args.push_back(getLLVMValue(cUnit, rlSrc.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc.origSReg));
args.push_back(cUnit->irb->getInt32(shiftAmount));
llvm::Value* res = cUnit->irb->CreateCall(intr, args);
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertArithOp(CompilationUnit* cUnit, OpKind op, RegLocation rlDest,
+void ConvertArithOp(CompilationUnit* cUnit, OpKind op, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- llvm::Value* src1 = getLLVMValue(cUnit, rlSrc1.origSReg);
- llvm::Value* src2 = getLLVMValue(cUnit, rlSrc2.origSReg);
+ llvm::Value* src1 = GetLLVMValue(cUnit, rlSrc1.origSReg);
+ llvm::Value* src2 = GetLLVMValue(cUnit, rlSrc2.origSReg);
DCHECK_EQ(src1->getType(), src2->getType());
- llvm::Value* res = genArithOp(cUnit, op, rlDest.wide, src1, src2);
- defineValue(cUnit, res, rlDest.origSReg);
+ llvm::Value* res = GenArithOp(cUnit, op, rlDest.wide, src1, src2);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void setShadowFrameEntry(CompilationUnit* cUnit, llvm::Value* newVal)
+void SetShadowFrameEntry(CompilationUnit* cUnit, llvm::Value* newVal)
{
int index = -1;
DCHECK(newVal != NULL);
- int vReg = SRegToVReg(cUnit, getLoc(cUnit, newVal).origSReg);
+ int vReg = SRegToVReg(cUnit, GetLoc(cUnit, newVal).origSReg);
for (int i = 0; i < cUnit->numShadowFrameEntries; i++) {
if (cUnit->shadowMap[i] == vReg) {
index = i;
@@ -582,13 +582,13 @@
cUnit->irb->CreateCall(func, args);
}
-void convertArithOpLit(CompilationUnit* cUnit, OpKind op, RegLocation rlDest,
+void ConvertArithOpLit(CompilationUnit* cUnit, OpKind op, RegLocation rlDest,
RegLocation rlSrc1, int32_t imm)
{
- llvm::Value* src1 = getLLVMValue(cUnit, rlSrc1.origSReg);
+ llvm::Value* src1 = GetLLVMValue(cUnit, rlSrc1.origSReg);
llvm::Value* src2 = cUnit->irb->getInt32(imm);
- llvm::Value* res = genArithOp(cUnit, op, rlDest.wide, src1, src2);
- defineValue(cUnit, res, rlDest.origSReg);
+ llvm::Value* res = GenArithOp(cUnit, op, rlDest.wide, src1, src2);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
/*
@@ -596,10 +596,10 @@
* collect and process arguments for NEW_FILLED_ARRAY and NEW_FILLED_ARRAY_RANGE.
* The requirements are similar.
*/
-void convertInvoke(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+void ConvertInvoke(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
InvokeType invokeType, bool isRange, bool isFilledNewArray)
{
- CallInfo* info = oatNewCallInfo(cUnit, bb, mir, invokeType, isRange);
+ CallInfo* info = NewMemCallInfo(cUnit, bb, mir, invokeType, isRange);
llvm::SmallVector<llvm::Value*, 10> args;
// Insert the invokeType
args.push_back(cUnit->irb->getInt32(static_cast<int>(invokeType)));
@@ -609,7 +609,7 @@
args.push_back(cUnit->irb->getInt32(info->optFlags));
// Now, insert the actual arguments
for (int i = 0; i < info->numArgWords;) {
- llvm::Value* val = getLLVMValue(cUnit, info->args[i].origSReg);
+ llvm::Value* val = GetLLVMValue(cUnit, info->args[i].origSReg);
args.push_back(val);
i += info->args[i].wide ? 2 : 1;
}
@@ -641,25 +641,25 @@
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::Value* res = cUnit->irb->CreateCall(intr, args);
if (info->result.location != kLocInvalid) {
- defineValue(cUnit, res, info->result.origSReg);
+ DefineValue(cUnit, res, info->result.origSReg);
if (info->result.ref) {
- setShadowFrameEntry(cUnit, reinterpret_cast<llvm::Value*>
+ SetShadowFrameEntry(cUnit, reinterpret_cast<llvm::Value*>
(cUnit->llvmValues.elemList[info->result.origSReg]));
}
}
}
-void convertConstObject(CompilationUnit* cUnit, uint32_t idx,
+void ConvertConstObject(CompilationUnit* cUnit, uint32_t idx,
greenland::IntrinsicHelper::IntrinsicId id,
RegLocation rlDest)
{
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::Value* index = cUnit->irb->getInt32(idx);
llvm::Value* res = cUnit->irb->CreateCall(intr, index);
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertCheckCast(CompilationUnit* cUnit, uint32_t type_idx,
+void ConvertCheckCast(CompilationUnit* cUnit, uint32_t type_idx,
RegLocation rlSrc)
{
greenland::IntrinsicHelper::IntrinsicId id;
@@ -667,11 +667,11 @@
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::SmallVector<llvm::Value*, 2> args;
args.push_back(cUnit->irb->getInt32(type_idx));
- args.push_back(getLLVMValue(cUnit, rlSrc.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc.origSReg));
cUnit->irb->CreateCall(intr, args);
}
-void convertNewInstance(CompilationUnit* cUnit, uint32_t type_idx,
+void ConvertNewInstance(CompilationUnit* cUnit, uint32_t type_idx,
RegLocation rlDest)
{
greenland::IntrinsicHelper::IntrinsicId id;
@@ -679,10 +679,10 @@
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::Value* index = cUnit->irb->getInt32(type_idx);
llvm::Value* res = cUnit->irb->CreateCall(intr, index);
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertNewArray(CompilationUnit* cUnit, uint32_t type_idx,
+void ConvertNewArray(CompilationUnit* cUnit, uint32_t type_idx,
RegLocation rlDest, RegLocation rlSrc)
{
greenland::IntrinsicHelper::IntrinsicId id;
@@ -690,64 +690,64 @@
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::SmallVector<llvm::Value*, 2> args;
args.push_back(cUnit->irb->getInt32(type_idx));
- args.push_back(getLLVMValue(cUnit, rlSrc.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc.origSReg));
llvm::Value* res = cUnit->irb->CreateCall(intr, args);
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertAget(CompilationUnit* cUnit, int optFlags,
+void ConvertAget(CompilationUnit* cUnit, int optFlags,
greenland::IntrinsicHelper::IntrinsicId id,
RegLocation rlDest, RegLocation rlArray, RegLocation rlIndex)
{
llvm::SmallVector<llvm::Value*, 3> args;
args.push_back(cUnit->irb->getInt32(optFlags));
- args.push_back(getLLVMValue(cUnit, rlArray.origSReg));
- args.push_back(getLLVMValue(cUnit, rlIndex.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlArray.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlIndex.origSReg));
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::Value* res = cUnit->irb->CreateCall(intr, args);
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertAput(CompilationUnit* cUnit, int optFlags,
+void ConvertAput(CompilationUnit* cUnit, int optFlags,
greenland::IntrinsicHelper::IntrinsicId id,
RegLocation rlSrc, RegLocation rlArray, RegLocation rlIndex)
{
llvm::SmallVector<llvm::Value*, 4> args;
args.push_back(cUnit->irb->getInt32(optFlags));
- args.push_back(getLLVMValue(cUnit, rlSrc.origSReg));
- args.push_back(getLLVMValue(cUnit, rlArray.origSReg));
- args.push_back(getLLVMValue(cUnit, rlIndex.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlArray.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlIndex.origSReg));
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
cUnit->irb->CreateCall(intr, args);
}
-void convertIget(CompilationUnit* cUnit, int optFlags,
+void ConvertIget(CompilationUnit* cUnit, int optFlags,
greenland::IntrinsicHelper::IntrinsicId id,
RegLocation rlDest, RegLocation rlObj, int fieldIndex)
{
llvm::SmallVector<llvm::Value*, 3> args;
args.push_back(cUnit->irb->getInt32(optFlags));
- args.push_back(getLLVMValue(cUnit, rlObj.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlObj.origSReg));
args.push_back(cUnit->irb->getInt32(fieldIndex));
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::Value* res = cUnit->irb->CreateCall(intr, args);
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertIput(CompilationUnit* cUnit, int optFlags,
+void ConvertIput(CompilationUnit* cUnit, int optFlags,
greenland::IntrinsicHelper::IntrinsicId id,
RegLocation rlSrc, RegLocation rlObj, int fieldIndex)
{
llvm::SmallVector<llvm::Value*, 4> args;
args.push_back(cUnit->irb->getInt32(optFlags));
- args.push_back(getLLVMValue(cUnit, rlSrc.origSReg));
- args.push_back(getLLVMValue(cUnit, rlObj.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlObj.origSReg));
args.push_back(cUnit->irb->getInt32(fieldIndex));
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
cUnit->irb->CreateCall(intr, args);
}
-void convertInstanceOf(CompilationUnit* cUnit, uint32_t type_idx,
+void ConvertInstanceOf(CompilationUnit* cUnit, uint32_t type_idx,
RegLocation rlDest, RegLocation rlSrc)
{
greenland::IntrinsicHelper::IntrinsicId id;
@@ -755,44 +755,44 @@
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::SmallVector<llvm::Value*, 2> args;
args.push_back(cUnit->irb->getInt32(type_idx));
- args.push_back(getLLVMValue(cUnit, rlSrc.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc.origSReg));
llvm::Value* res = cUnit->irb->CreateCall(intr, args);
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertIntToLong(CompilationUnit* cUnit, RegLocation rlDest,
+void ConvertIntToLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
- llvm::Value* res = cUnit->irb->CreateSExt(getLLVMValue(cUnit, rlSrc.origSReg),
+ llvm::Value* res = cUnit->irb->CreateSExt(GetLLVMValue(cUnit, rlSrc.origSReg),
cUnit->irb->getInt64Ty());
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertLongToInt(CompilationUnit* cUnit, RegLocation rlDest,
+void ConvertLongToInt(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
- llvm::Value* src = getLLVMValue(cUnit, rlSrc.origSReg);
+ llvm::Value* src = GetLLVMValue(cUnit, rlSrc.origSReg);
llvm::Value* res = cUnit->irb->CreateTrunc(src, cUnit->irb->getInt32Ty());
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertFloatToDouble(CompilationUnit* cUnit, RegLocation rlDest,
+void ConvertFloatToDouble(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
- llvm::Value* src = getLLVMValue(cUnit, rlSrc.origSReg);
+ llvm::Value* src = GetLLVMValue(cUnit, rlSrc.origSReg);
llvm::Value* res = cUnit->irb->CreateFPExt(src, cUnit->irb->getDoubleTy());
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertDoubleToFloat(CompilationUnit* cUnit, RegLocation rlDest,
+void ConvertDoubleToFloat(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
- llvm::Value* src = getLLVMValue(cUnit, rlSrc.origSReg);
+ llvm::Value* src = GetLLVMValue(cUnit, rlSrc.origSReg);
llvm::Value* res = cUnit->irb->CreateFPTrunc(src, cUnit->irb->getFloatTy());
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertWideComparison(CompilationUnit* cUnit,
+void ConvertWideComparison(CompilationUnit* cUnit,
greenland::IntrinsicHelper::IntrinsicId id,
RegLocation rlDest, RegLocation rlSrc1,
RegLocation rlSrc2)
@@ -801,62 +801,62 @@
DCHECK_EQ(rlSrc1.wide, rlSrc2.wide);
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::SmallVector<llvm::Value*, 2> args;
- args.push_back(getLLVMValue(cUnit, rlSrc1.origSReg));
- args.push_back(getLLVMValue(cUnit, rlSrc2.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc1.origSReg));
+ args.push_back(GetLLVMValue(cUnit, rlSrc2.origSReg));
llvm::Value* res = cUnit->irb->CreateCall(intr, args);
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertIntNarrowing(CompilationUnit* cUnit, RegLocation rlDest,
+void ConvertIntNarrowing(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc,
greenland::IntrinsicHelper::IntrinsicId id)
{
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
llvm::Value* res =
- cUnit->irb->CreateCall(intr, getLLVMValue(cUnit, rlSrc.origSReg));
- defineValue(cUnit, res, rlDest.origSReg);
+ cUnit->irb->CreateCall(intr, GetLLVMValue(cUnit, rlSrc.origSReg));
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertNeg(CompilationUnit* cUnit, RegLocation rlDest,
+void ConvertNeg(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
- llvm::Value* res = cUnit->irb->CreateNeg(getLLVMValue(cUnit, rlSrc.origSReg));
- defineValue(cUnit, res, rlDest.origSReg);
+ llvm::Value* res = cUnit->irb->CreateNeg(GetLLVMValue(cUnit, rlSrc.origSReg));
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertIntToFP(CompilationUnit* cUnit, llvm::Type* ty, RegLocation rlDest,
+void ConvertIntToFP(CompilationUnit* cUnit, llvm::Type* ty, RegLocation rlDest,
RegLocation rlSrc)
{
llvm::Value* res =
- cUnit->irb->CreateSIToFP(getLLVMValue(cUnit, rlSrc.origSReg), ty);
- defineValue(cUnit, res, rlDest.origSReg);
+ cUnit->irb->CreateSIToFP(GetLLVMValue(cUnit, rlSrc.origSReg), ty);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertFPToInt(CompilationUnit* cUnit,
+void ConvertFPToInt(CompilationUnit* cUnit,
greenland::IntrinsicHelper::IntrinsicId id,
RegLocation rlDest,
RegLocation rlSrc)
{
llvm::Function* intr = cUnit->intrinsic_helper->GetIntrinsicFunction(id);
- llvm::Value* res = cUnit->irb->CreateCall(intr, getLLVMValue(cUnit, rlSrc.origSReg));
- defineValue(cUnit, res, rlDest.origSReg);
+ llvm::Value* res = cUnit->irb->CreateCall(intr, GetLLVMValue(cUnit, rlSrc.origSReg));
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertNegFP(CompilationUnit* cUnit, RegLocation rlDest,
+void ConvertNegFP(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
llvm::Value* res =
- cUnit->irb->CreateFNeg(getLLVMValue(cUnit, rlSrc.origSReg));
- defineValue(cUnit, res, rlDest.origSReg);
+ cUnit->irb->CreateFNeg(GetLLVMValue(cUnit, rlSrc.origSReg));
+ DefineValue(cUnit, res, rlDest.origSReg);
}
-void convertNot(CompilationUnit* cUnit, RegLocation rlDest,
+void ConvertNot(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
- llvm::Value* src = getLLVMValue(cUnit, rlSrc.origSReg);
+ llvm::Value* src = GetLLVMValue(cUnit, rlSrc.origSReg);
llvm::Value* res = cUnit->irb->CreateXor(src, static_cast<uint64_t>(-1));
- defineValue(cUnit, res, rlDest.origSReg);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
/*
@@ -864,7 +864,7 @@
* load/store utilities here, or target-dependent genXX() handlers
* when necessary.
*/
-bool convertMIRNode(CompilationUnit* cUnit, MIR* mir, BasicBlock* bb,
+bool ConvertMIRNode(CompilationUnit* cUnit, MIR* mir, BasicBlock* bb,
llvm::BasicBlock* llvmBB, LIR* labelList)
{
bool res = false; // Assume success
@@ -893,34 +893,34 @@
rlSrc[0] = rlSrc[1] = rlSrc[2] = badLoc;
if (attrs & DF_UA) {
if (attrs & DF_A_WIDE) {
- rlSrc[nextLoc++] = oatGetSrcWide(cUnit, mir, nextSreg);
+ rlSrc[nextLoc++] = GetSrcWide(cUnit, mir, nextSreg);
nextSreg+= 2;
} else {
- rlSrc[nextLoc++] = oatGetSrc(cUnit, mir, nextSreg);
+ rlSrc[nextLoc++] = GetSrc(cUnit, mir, nextSreg);
nextSreg++;
}
}
if (attrs & DF_UB) {
if (attrs & DF_B_WIDE) {
- rlSrc[nextLoc++] = oatGetSrcWide(cUnit, mir, nextSreg);
+ rlSrc[nextLoc++] = GetSrcWide(cUnit, mir, nextSreg);
nextSreg+= 2;
} else {
- rlSrc[nextLoc++] = oatGetSrc(cUnit, mir, nextSreg);
+ rlSrc[nextLoc++] = GetSrc(cUnit, mir, nextSreg);
nextSreg++;
}
}
if (attrs & DF_UC) {
if (attrs & DF_C_WIDE) {
- rlSrc[nextLoc++] = oatGetSrcWide(cUnit, mir, nextSreg);
+ rlSrc[nextLoc++] = GetSrcWide(cUnit, mir, nextSreg);
} else {
- rlSrc[nextLoc++] = oatGetSrc(cUnit, mir, nextSreg);
+ rlSrc[nextLoc++] = GetSrc(cUnit, mir, nextSreg);
}
}
if (attrs & DF_DA) {
if (attrs & DF_A_WIDE) {
- rlDest = oatGetDestWide(cUnit, mir);
+ rlDest = GetDestWide(cUnit, mir);
} else {
- rlDest = oatGetDest(cUnit, mir);
+ rlDest = GetDest(cUnit, mir);
if (rlDest.ref) {
objectDefinition = true;
}
@@ -947,9 +947,9 @@
* Insert a dummy intrinsic copy call, which will be recognized
* by the quick path and removed by the portable path.
*/
- llvm::Value* src = getLLVMValue(cUnit, rlSrc[0].origSReg);
- llvm::Value* res = emitCopy(cUnit, src, rlDest);
- defineValue(cUnit, res, rlDest.origSReg);
+ llvm::Value* src = GetLLVMValue(cUnit, rlSrc[0].origSReg);
+ llvm::Value* res = EmitCopy(cUnit, src, rlDest);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
break;
@@ -960,8 +960,8 @@
objectDefinition = true;
}
llvm::Constant* immValue = cUnit->irb->GetJInt(vB);
- llvm::Value* res = emitConst(cUnit, immValue, rlDest);
- defineValue(cUnit, res, rlDest.origSReg);
+ llvm::Value* res = EmitConst(cUnit, immValue, rlDest);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
break;
@@ -970,96 +970,96 @@
// Sign extend to 64 bits
int64_t imm = static_cast<int32_t>(vB);
llvm::Constant* immValue = cUnit->irb->GetJLong(imm);
- llvm::Value* res = emitConst(cUnit, immValue, rlDest);
- defineValue(cUnit, res, rlDest.origSReg);
+ llvm::Value* res = EmitConst(cUnit, immValue, rlDest);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
break;
case Instruction::CONST_HIGH16: {
llvm::Constant* immValue = cUnit->irb->GetJInt(vB << 16);
- llvm::Value* res = emitConst(cUnit, immValue, rlDest);
- defineValue(cUnit, res, rlDest.origSReg);
+ llvm::Value* res = EmitConst(cUnit, immValue, rlDest);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
break;
case Instruction::CONST_WIDE: {
llvm::Constant* immValue =
cUnit->irb->GetJLong(mir->dalvikInsn.vB_wide);
- llvm::Value* res = emitConst(cUnit, immValue, rlDest);
- defineValue(cUnit, res, rlDest.origSReg);
+ llvm::Value* res = EmitConst(cUnit, immValue, rlDest);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
break;
case Instruction::CONST_WIDE_HIGH16: {
int64_t imm = static_cast<int64_t>(vB) << 48;
llvm::Constant* immValue = cUnit->irb->GetJLong(imm);
- llvm::Value* res = emitConst(cUnit, immValue, rlDest);
- defineValue(cUnit, res, rlDest.origSReg);
+ llvm::Value* res = EmitConst(cUnit, immValue, rlDest);
+ DefineValue(cUnit, res, rlDest.origSReg);
}
break;
case Instruction::SPUT_OBJECT:
- convertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputObject,
+ ConvertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputObject,
rlSrc[0]);
break;
case Instruction::SPUT:
if (rlSrc[0].fp) {
- convertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputFloat,
+ ConvertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputFloat,
rlSrc[0]);
} else {
- convertSput(cUnit, vB, greenland::IntrinsicHelper::HLSput, rlSrc[0]);
+ ConvertSput(cUnit, vB, greenland::IntrinsicHelper::HLSput, rlSrc[0]);
}
break;
case Instruction::SPUT_BOOLEAN:
- convertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputBoolean,
+ ConvertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputBoolean,
rlSrc[0]);
break;
case Instruction::SPUT_BYTE:
- convertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputByte, rlSrc[0]);
+ ConvertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputByte, rlSrc[0]);
break;
case Instruction::SPUT_CHAR:
- convertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputChar, rlSrc[0]);
+ ConvertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputChar, rlSrc[0]);
break;
case Instruction::SPUT_SHORT:
- convertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputShort, rlSrc[0]);
+ ConvertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputShort, rlSrc[0]);
break;
case Instruction::SPUT_WIDE:
if (rlSrc[0].fp) {
- convertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputDouble,
+ ConvertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputDouble,
rlSrc[0]);
} else {
- convertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputWide,
+ ConvertSput(cUnit, vB, greenland::IntrinsicHelper::HLSputWide,
rlSrc[0]);
}
break;
case Instruction::SGET_OBJECT:
- convertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetObject, rlDest);
+ ConvertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetObject, rlDest);
break;
case Instruction::SGET:
if (rlDest.fp) {
- convertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetFloat, rlDest);
+ ConvertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetFloat, rlDest);
} else {
- convertSget(cUnit, vB, greenland::IntrinsicHelper::HLSget, rlDest);
+ ConvertSget(cUnit, vB, greenland::IntrinsicHelper::HLSget, rlDest);
}
break;
case Instruction::SGET_BOOLEAN:
- convertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetBoolean, rlDest);
+ ConvertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetBoolean, rlDest);
break;
case Instruction::SGET_BYTE:
- convertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetByte, rlDest);
+ ConvertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetByte, rlDest);
break;
case Instruction::SGET_CHAR:
- convertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetChar, rlDest);
+ ConvertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetChar, rlDest);
break;
case Instruction::SGET_SHORT:
- convertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetShort, rlDest);
+ ConvertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetShort, rlDest);
break;
case Instruction::SGET_WIDE:
if (rlDest.fp) {
- convertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetDouble,
+ ConvertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetDouble,
rlDest);
} else {
- convertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetWide, rlDest);
+ ConvertSget(cUnit, vB, greenland::IntrinsicHelper::HLSgetWide, rlDest);
}
break;
@@ -1067,68 +1067,68 @@
case Instruction::RETURN:
case Instruction::RETURN_OBJECT: {
if (!(cUnit->attrs & METHOD_IS_LEAF)) {
- emitSuspendCheck(cUnit);
+ EmitSuspendCheck(cUnit);
}
- emitPopShadowFrame(cUnit);
- cUnit->irb->CreateRet(getLLVMValue(cUnit, rlSrc[0].origSReg));
+ EmitPopShadowFrame(cUnit);
+ cUnit->irb->CreateRet(GetLLVMValue(cUnit, rlSrc[0].origSReg));
bb->hasReturn = true;
}
break;
case Instruction::RETURN_VOID: {
if (!(cUnit->attrs & METHOD_IS_LEAF)) {
- emitSuspendCheck(cUnit);
+ EmitSuspendCheck(cUnit);
}
- emitPopShadowFrame(cUnit);
+ EmitPopShadowFrame(cUnit);
cUnit->irb->CreateRetVoid();
bb->hasReturn = true;
}
break;
case Instruction::IF_EQ:
- convertCompareAndBranch(cUnit, bb, mir, kCondEq, rlSrc[0], rlSrc[1]);
+ ConvertCompareAndBranch(cUnit, bb, mir, kCondEq, rlSrc[0], rlSrc[1]);
break;
case Instruction::IF_NE:
- convertCompareAndBranch(cUnit, bb, mir, kCondNe, rlSrc[0], rlSrc[1]);
+ ConvertCompareAndBranch(cUnit, bb, mir, kCondNe, rlSrc[0], rlSrc[1]);
break;
case Instruction::IF_LT:
- convertCompareAndBranch(cUnit, bb, mir, kCondLt, rlSrc[0], rlSrc[1]);
+ ConvertCompareAndBranch(cUnit, bb, mir, kCondLt, rlSrc[0], rlSrc[1]);
break;
case Instruction::IF_GE:
- convertCompareAndBranch(cUnit, bb, mir, kCondGe, rlSrc[0], rlSrc[1]);
+ ConvertCompareAndBranch(cUnit, bb, mir, kCondGe, rlSrc[0], rlSrc[1]);
break;
case Instruction::IF_GT:
- convertCompareAndBranch(cUnit, bb, mir, kCondGt, rlSrc[0], rlSrc[1]);
+ ConvertCompareAndBranch(cUnit, bb, mir, kCondGt, rlSrc[0], rlSrc[1]);
break;
case Instruction::IF_LE:
- convertCompareAndBranch(cUnit, bb, mir, kCondLe, rlSrc[0], rlSrc[1]);
+ ConvertCompareAndBranch(cUnit, bb, mir, kCondLe, rlSrc[0], rlSrc[1]);
break;
case Instruction::IF_EQZ:
- convertCompareZeroAndBranch(cUnit, bb, mir, kCondEq, rlSrc[0]);
+ ConvertCompareZeroAndBranch(cUnit, bb, mir, kCondEq, rlSrc[0]);
break;
case Instruction::IF_NEZ:
- convertCompareZeroAndBranch(cUnit, bb, mir, kCondNe, rlSrc[0]);
+ ConvertCompareZeroAndBranch(cUnit, bb, mir, kCondNe, rlSrc[0]);
break;
case Instruction::IF_LTZ:
- convertCompareZeroAndBranch(cUnit, bb, mir, kCondLt, rlSrc[0]);
+ ConvertCompareZeroAndBranch(cUnit, bb, mir, kCondLt, rlSrc[0]);
break;
case Instruction::IF_GEZ:
- convertCompareZeroAndBranch(cUnit, bb, mir, kCondGe, rlSrc[0]);
+ ConvertCompareZeroAndBranch(cUnit, bb, mir, kCondGe, rlSrc[0]);
break;
case Instruction::IF_GTZ:
- convertCompareZeroAndBranch(cUnit, bb, mir, kCondGt, rlSrc[0]);
+ ConvertCompareZeroAndBranch(cUnit, bb, mir, kCondGt, rlSrc[0]);
break;
case Instruction::IF_LEZ:
- convertCompareZeroAndBranch(cUnit, bb, mir, kCondLe, rlSrc[0]);
+ ConvertCompareZeroAndBranch(cUnit, bb, mir, kCondLe, rlSrc[0]);
break;
case Instruction::GOTO:
case Instruction::GOTO_16:
case Instruction::GOTO_32: {
if (bb->taken->startOffset <= bb->startOffset) {
- emitSuspendCheck(cUnit);
+ EmitSuspendCheck(cUnit);
}
- cUnit->irb->CreateBr(getLLVMBlock(cUnit, bb->taken->id));
+ cUnit->irb->CreateBr(GetLLVMBlock(cUnit, bb->taken->id));
}
break;
@@ -1136,123 +1136,123 @@
case Instruction::ADD_LONG_2ADDR:
case Instruction::ADD_INT:
case Instruction::ADD_INT_2ADDR:
- convertArithOp(cUnit, kOpAdd, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertArithOp(cUnit, kOpAdd, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::SUB_LONG:
case Instruction::SUB_LONG_2ADDR:
case Instruction::SUB_INT:
case Instruction::SUB_INT_2ADDR:
- convertArithOp(cUnit, kOpSub, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertArithOp(cUnit, kOpSub, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::MUL_LONG:
case Instruction::MUL_LONG_2ADDR:
case Instruction::MUL_INT:
case Instruction::MUL_INT_2ADDR:
- convertArithOp(cUnit, kOpMul, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertArithOp(cUnit, kOpMul, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::DIV_LONG:
case Instruction::DIV_LONG_2ADDR:
case Instruction::DIV_INT:
case Instruction::DIV_INT_2ADDR:
- convertArithOp(cUnit, kOpDiv, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertArithOp(cUnit, kOpDiv, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::REM_LONG:
case Instruction::REM_LONG_2ADDR:
case Instruction::REM_INT:
case Instruction::REM_INT_2ADDR:
- convertArithOp(cUnit, kOpRem, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertArithOp(cUnit, kOpRem, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::AND_LONG:
case Instruction::AND_LONG_2ADDR:
case Instruction::AND_INT:
case Instruction::AND_INT_2ADDR:
- convertArithOp(cUnit, kOpAnd, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertArithOp(cUnit, kOpAnd, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::OR_LONG:
case Instruction::OR_LONG_2ADDR:
case Instruction::OR_INT:
case Instruction::OR_INT_2ADDR:
- convertArithOp(cUnit, kOpOr, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertArithOp(cUnit, kOpOr, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::XOR_LONG:
case Instruction::XOR_LONG_2ADDR:
case Instruction::XOR_INT:
case Instruction::XOR_INT_2ADDR:
- convertArithOp(cUnit, kOpXor, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertArithOp(cUnit, kOpXor, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::SHL_LONG:
case Instruction::SHL_LONG_2ADDR:
- convertShift(cUnit, greenland::IntrinsicHelper::SHLLong,
+ ConvertShift(cUnit, greenland::IntrinsicHelper::SHLLong,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::SHL_INT:
case Instruction::SHL_INT_2ADDR:
- convertShift(cUnit, greenland::IntrinsicHelper::SHLInt,
+ ConvertShift(cUnit, greenland::IntrinsicHelper::SHLInt,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::SHR_LONG:
case Instruction::SHR_LONG_2ADDR:
- convertShift(cUnit, greenland::IntrinsicHelper::SHRLong,
+ ConvertShift(cUnit, greenland::IntrinsicHelper::SHRLong,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::SHR_INT:
case Instruction::SHR_INT_2ADDR:
- convertShift(cUnit, greenland::IntrinsicHelper::SHRInt,
+ ConvertShift(cUnit, greenland::IntrinsicHelper::SHRInt,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::USHR_LONG:
case Instruction::USHR_LONG_2ADDR:
- convertShift(cUnit, greenland::IntrinsicHelper::USHRLong,
+ ConvertShift(cUnit, greenland::IntrinsicHelper::USHRLong,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::USHR_INT:
case Instruction::USHR_INT_2ADDR:
- convertShift(cUnit, greenland::IntrinsicHelper::USHRInt,
+ ConvertShift(cUnit, greenland::IntrinsicHelper::USHRInt,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::ADD_INT_LIT16:
case Instruction::ADD_INT_LIT8:
- convertArithOpLit(cUnit, kOpAdd, rlDest, rlSrc[0], vC);
+ ConvertArithOpLit(cUnit, kOpAdd, rlDest, rlSrc[0], vC);
break;
case Instruction::RSUB_INT:
case Instruction::RSUB_INT_LIT8:
- convertArithOpLit(cUnit, kOpRsub, rlDest, rlSrc[0], vC);
+ ConvertArithOpLit(cUnit, kOpRsub, rlDest, rlSrc[0], vC);
break;
case Instruction::MUL_INT_LIT16:
case Instruction::MUL_INT_LIT8:
- convertArithOpLit(cUnit, kOpMul, rlDest, rlSrc[0], vC);
+ ConvertArithOpLit(cUnit, kOpMul, rlDest, rlSrc[0], vC);
break;
case Instruction::DIV_INT_LIT16:
case Instruction::DIV_INT_LIT8:
- convertArithOpLit(cUnit, kOpDiv, rlDest, rlSrc[0], vC);
+ ConvertArithOpLit(cUnit, kOpDiv, rlDest, rlSrc[0], vC);
break;
case Instruction::REM_INT_LIT16:
case Instruction::REM_INT_LIT8:
- convertArithOpLit(cUnit, kOpRem, rlDest, rlSrc[0], vC);
+ ConvertArithOpLit(cUnit, kOpRem, rlDest, rlSrc[0], vC);
break;
case Instruction::AND_INT_LIT16:
case Instruction::AND_INT_LIT8:
- convertArithOpLit(cUnit, kOpAnd, rlDest, rlSrc[0], vC);
+ ConvertArithOpLit(cUnit, kOpAnd, rlDest, rlSrc[0], vC);
break;
case Instruction::OR_INT_LIT16:
case Instruction::OR_INT_LIT8:
- convertArithOpLit(cUnit, kOpOr, rlDest, rlSrc[0], vC);
+ ConvertArithOpLit(cUnit, kOpOr, rlDest, rlSrc[0], vC);
break;
case Instruction::XOR_INT_LIT16:
case Instruction::XOR_INT_LIT8:
- convertArithOpLit(cUnit, kOpXor, rlDest, rlSrc[0], vC);
+ ConvertArithOpLit(cUnit, kOpXor, rlDest, rlSrc[0], vC);
break;
case Instruction::SHL_INT_LIT8:
- convertShiftLit(cUnit, greenland::IntrinsicHelper::SHLInt,
+ ConvertShiftLit(cUnit, greenland::IntrinsicHelper::SHLInt,
rlDest, rlSrc[0], vC & 0x1f);
break;
case Instruction::SHR_INT_LIT8:
- convertShiftLit(cUnit, greenland::IntrinsicHelper::SHRInt,
+ ConvertShiftLit(cUnit, greenland::IntrinsicHelper::SHRInt,
rlDest, rlSrc[0], vC & 0x1f);
break;
case Instruction::USHR_INT_LIT8:
- convertShiftLit(cUnit, greenland::IntrinsicHelper::USHRInt,
+ ConvertShiftLit(cUnit, greenland::IntrinsicHelper::USHRInt,
rlDest, rlSrc[0], vC & 0x1f);
break;
@@ -1260,115 +1260,115 @@
case Instruction::ADD_FLOAT_2ADDR:
case Instruction::ADD_DOUBLE:
case Instruction::ADD_DOUBLE_2ADDR:
- convertFPArithOp(cUnit, kOpAdd, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertFPArithOp(cUnit, kOpAdd, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::SUB_FLOAT:
case Instruction::SUB_FLOAT_2ADDR:
case Instruction::SUB_DOUBLE:
case Instruction::SUB_DOUBLE_2ADDR:
- convertFPArithOp(cUnit, kOpSub, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertFPArithOp(cUnit, kOpSub, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::MUL_FLOAT:
case Instruction::MUL_FLOAT_2ADDR:
case Instruction::MUL_DOUBLE:
case Instruction::MUL_DOUBLE_2ADDR:
- convertFPArithOp(cUnit, kOpMul, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertFPArithOp(cUnit, kOpMul, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::DIV_FLOAT:
case Instruction::DIV_FLOAT_2ADDR:
case Instruction::DIV_DOUBLE:
case Instruction::DIV_DOUBLE_2ADDR:
- convertFPArithOp(cUnit, kOpDiv, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertFPArithOp(cUnit, kOpDiv, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::REM_FLOAT:
case Instruction::REM_FLOAT_2ADDR:
case Instruction::REM_DOUBLE:
case Instruction::REM_DOUBLE_2ADDR:
- convertFPArithOp(cUnit, kOpRem, rlDest, rlSrc[0], rlSrc[1]);
+ ConvertFPArithOp(cUnit, kOpRem, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::INVOKE_STATIC:
- convertInvoke(cUnit, bb, mir, kStatic, false /*range*/,
+ ConvertInvoke(cUnit, bb, mir, kStatic, false /*range*/,
false /* NewFilledArray */);
break;
case Instruction::INVOKE_STATIC_RANGE:
- convertInvoke(cUnit, bb, mir, kStatic, true /*range*/,
+ ConvertInvoke(cUnit, bb, mir, kStatic, true /*range*/,
false /* NewFilledArray */);
break;
case Instruction::INVOKE_DIRECT:
- convertInvoke(cUnit, bb, mir, kDirect, false /*range*/,
+ ConvertInvoke(cUnit, bb, mir, kDirect, false /*range*/,
false /* NewFilledArray */);
break;
case Instruction::INVOKE_DIRECT_RANGE:
- convertInvoke(cUnit, bb, mir, kDirect, true /*range*/,
+ ConvertInvoke(cUnit, bb, mir, kDirect, true /*range*/,
false /* NewFilledArray */);
break;
case Instruction::INVOKE_VIRTUAL:
- convertInvoke(cUnit, bb, mir, kVirtual, false /*range*/,
+ ConvertInvoke(cUnit, bb, mir, kVirtual, false /*range*/,
false /* NewFilledArray */);
break;
case Instruction::INVOKE_VIRTUAL_RANGE:
- convertInvoke(cUnit, bb, mir, kVirtual, true /*range*/,
+ ConvertInvoke(cUnit, bb, mir, kVirtual, true /*range*/,
false /* NewFilledArray */);
break;
case Instruction::INVOKE_SUPER:
- convertInvoke(cUnit, bb, mir, kSuper, false /*range*/,
+ ConvertInvoke(cUnit, bb, mir, kSuper, false /*range*/,
false /* NewFilledArray */);
break;
case Instruction::INVOKE_SUPER_RANGE:
- convertInvoke(cUnit, bb, mir, kSuper, true /*range*/,
+ ConvertInvoke(cUnit, bb, mir, kSuper, true /*range*/,
false /* NewFilledArray */);
break;
case Instruction::INVOKE_INTERFACE:
- convertInvoke(cUnit, bb, mir, kInterface, false /*range*/,
+ ConvertInvoke(cUnit, bb, mir, kInterface, false /*range*/,
false /* NewFilledArray */);
break;
case Instruction::INVOKE_INTERFACE_RANGE:
- convertInvoke(cUnit, bb, mir, kInterface, true /*range*/,
+ ConvertInvoke(cUnit, bb, mir, kInterface, true /*range*/,
false /* NewFilledArray */);
break;
case Instruction::FILLED_NEW_ARRAY:
- convertInvoke(cUnit, bb, mir, kInterface, false /*range*/,
+ ConvertInvoke(cUnit, bb, mir, kInterface, false /*range*/,
true /* NewFilledArray */);
break;
case Instruction::FILLED_NEW_ARRAY_RANGE:
- convertInvoke(cUnit, bb, mir, kInterface, true /*range*/,
+ ConvertInvoke(cUnit, bb, mir, kInterface, true /*range*/,
true /* NewFilledArray */);
break;
case Instruction::CONST_STRING:
case Instruction::CONST_STRING_JUMBO:
- convertConstObject(cUnit, vB, greenland::IntrinsicHelper::ConstString,
+ ConvertConstObject(cUnit, vB, greenland::IntrinsicHelper::ConstString,
rlDest);
break;
case Instruction::CONST_CLASS:
- convertConstObject(cUnit, vB, greenland::IntrinsicHelper::ConstClass,
+ ConvertConstObject(cUnit, vB, greenland::IntrinsicHelper::ConstClass,
rlDest);
break;
case Instruction::CHECK_CAST:
- convertCheckCast(cUnit, vB, rlSrc[0]);
+ ConvertCheckCast(cUnit, vB, rlSrc[0]);
break;
case Instruction::NEW_INSTANCE:
- convertNewInstance(cUnit, vB, rlDest);
+ ConvertNewInstance(cUnit, vB, rlDest);
break;
case Instruction::MOVE_EXCEPTION:
- convertMoveException(cUnit, rlDest);
+ ConvertMoveException(cUnit, rlDest);
break;
case Instruction::THROW:
- convertThrow(cUnit, rlSrc[0]);
+ ConvertThrow(cUnit, rlSrc[0]);
/*
* If this throw is standalone, terminate.
* If it might rethrow, force termination
@@ -1392,291 +1392,291 @@
break;
case Instruction::MONITOR_ENTER:
- convertMonitorEnterExit(cUnit, optFlags,
+ ConvertMonitorEnterExit(cUnit, optFlags,
greenland::IntrinsicHelper::MonitorEnter,
rlSrc[0]);
break;
case Instruction::MONITOR_EXIT:
- convertMonitorEnterExit(cUnit, optFlags,
+ ConvertMonitorEnterExit(cUnit, optFlags,
greenland::IntrinsicHelper::MonitorExit,
rlSrc[0]);
break;
case Instruction::ARRAY_LENGTH:
- convertArrayLength(cUnit, optFlags, rlDest, rlSrc[0]);
+ ConvertArrayLength(cUnit, optFlags, rlDest, rlSrc[0]);
break;
case Instruction::NEW_ARRAY:
- convertNewArray(cUnit, vC, rlDest, rlSrc[0]);
+ ConvertNewArray(cUnit, vC, rlDest, rlSrc[0]);
break;
case Instruction::INSTANCE_OF:
- convertInstanceOf(cUnit, vC, rlDest, rlSrc[0]);
+ ConvertInstanceOf(cUnit, vC, rlDest, rlSrc[0]);
break;
case Instruction::AGET:
if (rlDest.fp) {
- convertAget(cUnit, optFlags,
+ ConvertAget(cUnit, optFlags,
greenland::IntrinsicHelper::HLArrayGetFloat,
rlDest, rlSrc[0], rlSrc[1]);
} else {
- convertAget(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayGet,
+ ConvertAget(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayGet,
rlDest, rlSrc[0], rlSrc[1]);
}
break;
case Instruction::AGET_OBJECT:
- convertAget(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayGetObject,
+ ConvertAget(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayGetObject,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::AGET_BOOLEAN:
- convertAget(cUnit, optFlags,
+ ConvertAget(cUnit, optFlags,
greenland::IntrinsicHelper::HLArrayGetBoolean,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::AGET_BYTE:
- convertAget(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayGetByte,
+ ConvertAget(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayGetByte,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::AGET_CHAR:
- convertAget(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayGetChar,
+ ConvertAget(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayGetChar,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::AGET_SHORT:
- convertAget(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayGetShort,
+ ConvertAget(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayGetShort,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::AGET_WIDE:
if (rlDest.fp) {
- convertAget(cUnit, optFlags,
+ ConvertAget(cUnit, optFlags,
greenland::IntrinsicHelper::HLArrayGetDouble,
rlDest, rlSrc[0], rlSrc[1]);
} else {
- convertAget(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayGetWide,
+ ConvertAget(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayGetWide,
rlDest, rlSrc[0], rlSrc[1]);
}
break;
case Instruction::APUT:
if (rlSrc[0].fp) {
- convertAput(cUnit, optFlags,
+ ConvertAput(cUnit, optFlags,
greenland::IntrinsicHelper::HLArrayPutFloat,
rlSrc[0], rlSrc[1], rlSrc[2]);
} else {
- convertAput(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayPut,
+ ConvertAput(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayPut,
rlSrc[0], rlSrc[1], rlSrc[2]);
}
break;
case Instruction::APUT_OBJECT:
- convertAput(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayPutObject,
+ ConvertAput(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayPutObject,
rlSrc[0], rlSrc[1], rlSrc[2]);
break;
case Instruction::APUT_BOOLEAN:
- convertAput(cUnit, optFlags,
+ ConvertAput(cUnit, optFlags,
greenland::IntrinsicHelper::HLArrayPutBoolean,
rlSrc[0], rlSrc[1], rlSrc[2]);
break;
case Instruction::APUT_BYTE:
- convertAput(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayPutByte,
+ ConvertAput(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayPutByte,
rlSrc[0], rlSrc[1], rlSrc[2]);
break;
case Instruction::APUT_CHAR:
- convertAput(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayPutChar,
+ ConvertAput(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayPutChar,
rlSrc[0], rlSrc[1], rlSrc[2]);
break;
case Instruction::APUT_SHORT:
- convertAput(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayPutShort,
+ ConvertAput(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayPutShort,
rlSrc[0], rlSrc[1], rlSrc[2]);
break;
case Instruction::APUT_WIDE:
if (rlSrc[0].fp) {
- convertAput(cUnit, optFlags,
+ ConvertAput(cUnit, optFlags,
greenland::IntrinsicHelper::HLArrayPutDouble,
rlSrc[0], rlSrc[1], rlSrc[2]);
} else {
- convertAput(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayPutWide,
+ ConvertAput(cUnit, optFlags, greenland::IntrinsicHelper::HLArrayPutWide,
rlSrc[0], rlSrc[1], rlSrc[2]);
}
break;
case Instruction::IGET:
if (rlDest.fp) {
- convertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetFloat,
+ ConvertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetFloat,
rlDest, rlSrc[0], vC);
} else {
- convertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGet,
+ ConvertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGet,
rlDest, rlSrc[0], vC);
}
break;
case Instruction::IGET_OBJECT:
- convertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetObject,
+ ConvertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetObject,
rlDest, rlSrc[0], vC);
break;
case Instruction::IGET_BOOLEAN:
- convertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetBoolean,
+ ConvertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetBoolean,
rlDest, rlSrc[0], vC);
break;
case Instruction::IGET_BYTE:
- convertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetByte,
+ ConvertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetByte,
rlDest, rlSrc[0], vC);
break;
case Instruction::IGET_CHAR:
- convertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetChar,
+ ConvertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetChar,
rlDest, rlSrc[0], vC);
break;
case Instruction::IGET_SHORT:
- convertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetShort,
+ ConvertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetShort,
rlDest, rlSrc[0], vC);
break;
case Instruction::IGET_WIDE:
if (rlDest.fp) {
- convertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetDouble,
+ ConvertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetDouble,
rlDest, rlSrc[0], vC);
} else {
- convertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetWide,
+ ConvertIget(cUnit, optFlags, greenland::IntrinsicHelper::HLIGetWide,
rlDest, rlSrc[0], vC);
}
break;
case Instruction::IPUT:
if (rlSrc[0].fp) {
- convertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutFloat,
+ ConvertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutFloat,
rlSrc[0], rlSrc[1], vC);
} else {
- convertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPut,
+ ConvertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPut,
rlSrc[0], rlSrc[1], vC);
}
break;
case Instruction::IPUT_OBJECT:
- convertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutObject,
+ ConvertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutObject,
rlSrc[0], rlSrc[1], vC);
break;
case Instruction::IPUT_BOOLEAN:
- convertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutBoolean,
+ ConvertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutBoolean,
rlSrc[0], rlSrc[1], vC);
break;
case Instruction::IPUT_BYTE:
- convertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutByte,
+ ConvertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutByte,
rlSrc[0], rlSrc[1], vC);
break;
case Instruction::IPUT_CHAR:
- convertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutChar,
+ ConvertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutChar,
rlSrc[0], rlSrc[1], vC);
break;
case Instruction::IPUT_SHORT:
- convertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutShort,
+ ConvertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutShort,
rlSrc[0], rlSrc[1], vC);
break;
case Instruction::IPUT_WIDE:
if (rlSrc[0].fp) {
- convertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutDouble,
+ ConvertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutDouble,
rlSrc[0], rlSrc[1], vC);
} else {
- convertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutWide,
+ ConvertIput(cUnit, optFlags, greenland::IntrinsicHelper::HLIPutWide,
rlSrc[0], rlSrc[1], vC);
}
break;
case Instruction::FILL_ARRAY_DATA:
- convertFillArrayData(cUnit, vB, rlSrc[0]);
+ ConvertFillArrayData(cUnit, vB, rlSrc[0]);
break;
case Instruction::LONG_TO_INT:
- convertLongToInt(cUnit, rlDest, rlSrc[0]);
+ ConvertLongToInt(cUnit, rlDest, rlSrc[0]);
break;
case Instruction::INT_TO_LONG:
- convertIntToLong(cUnit, rlDest, rlSrc[0]);
+ ConvertIntToLong(cUnit, rlDest, rlSrc[0]);
break;
case Instruction::INT_TO_CHAR:
- convertIntNarrowing(cUnit, rlDest, rlSrc[0],
+ ConvertIntNarrowing(cUnit, rlDest, rlSrc[0],
greenland::IntrinsicHelper::IntToChar);
break;
case Instruction::INT_TO_BYTE:
- convertIntNarrowing(cUnit, rlDest, rlSrc[0],
+ ConvertIntNarrowing(cUnit, rlDest, rlSrc[0],
greenland::IntrinsicHelper::IntToByte);
break;
case Instruction::INT_TO_SHORT:
- convertIntNarrowing(cUnit, rlDest, rlSrc[0],
+ ConvertIntNarrowing(cUnit, rlDest, rlSrc[0],
greenland::IntrinsicHelper::IntToShort);
break;
case Instruction::INT_TO_FLOAT:
case Instruction::LONG_TO_FLOAT:
- convertIntToFP(cUnit, cUnit->irb->getFloatTy(), rlDest, rlSrc[0]);
+ ConvertIntToFP(cUnit, cUnit->irb->getFloatTy(), rlDest, rlSrc[0]);
break;
case Instruction::INT_TO_DOUBLE:
case Instruction::LONG_TO_DOUBLE:
- convertIntToFP(cUnit, cUnit->irb->getDoubleTy(), rlDest, rlSrc[0]);
+ ConvertIntToFP(cUnit, cUnit->irb->getDoubleTy(), rlDest, rlSrc[0]);
break;
case Instruction::FLOAT_TO_DOUBLE:
- convertFloatToDouble(cUnit, rlDest, rlSrc[0]);
+ ConvertFloatToDouble(cUnit, rlDest, rlSrc[0]);
break;
case Instruction::DOUBLE_TO_FLOAT:
- convertDoubleToFloat(cUnit, rlDest, rlSrc[0]);
+ ConvertDoubleToFloat(cUnit, rlDest, rlSrc[0]);
break;
case Instruction::NEG_LONG:
case Instruction::NEG_INT:
- convertNeg(cUnit, rlDest, rlSrc[0]);
+ ConvertNeg(cUnit, rlDest, rlSrc[0]);
break;
case Instruction::NEG_FLOAT:
case Instruction::NEG_DOUBLE:
- convertNegFP(cUnit, rlDest, rlSrc[0]);
+ ConvertNegFP(cUnit, rlDest, rlSrc[0]);
break;
case Instruction::NOT_LONG:
case Instruction::NOT_INT:
- convertNot(cUnit, rlDest, rlSrc[0]);
+ ConvertNot(cUnit, rlDest, rlSrc[0]);
break;
case Instruction::FLOAT_TO_INT:
- convertFPToInt(cUnit, greenland::IntrinsicHelper::F2I, rlDest, rlSrc[0]);
+ ConvertFPToInt(cUnit, greenland::IntrinsicHelper::F2I, rlDest, rlSrc[0]);
break;
case Instruction::DOUBLE_TO_INT:
- convertFPToInt(cUnit, greenland::IntrinsicHelper::D2I, rlDest, rlSrc[0]);
+ ConvertFPToInt(cUnit, greenland::IntrinsicHelper::D2I, rlDest, rlSrc[0]);
break;
case Instruction::FLOAT_TO_LONG:
- convertFPToInt(cUnit, greenland::IntrinsicHelper::F2L, rlDest, rlSrc[0]);
+ ConvertFPToInt(cUnit, greenland::IntrinsicHelper::F2L, rlDest, rlSrc[0]);
break;
case Instruction::DOUBLE_TO_LONG:
- convertFPToInt(cUnit, greenland::IntrinsicHelper::D2L, rlDest, rlSrc[0]);
+ ConvertFPToInt(cUnit, greenland::IntrinsicHelper::D2L, rlDest, rlSrc[0]);
break;
case Instruction::CMPL_FLOAT:
- convertWideComparison(cUnit, greenland::IntrinsicHelper::CmplFloat,
+ ConvertWideComparison(cUnit, greenland::IntrinsicHelper::CmplFloat,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::CMPG_FLOAT:
- convertWideComparison(cUnit, greenland::IntrinsicHelper::CmpgFloat,
+ ConvertWideComparison(cUnit, greenland::IntrinsicHelper::CmpgFloat,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::CMPL_DOUBLE:
- convertWideComparison(cUnit, greenland::IntrinsicHelper::CmplDouble,
+ ConvertWideComparison(cUnit, greenland::IntrinsicHelper::CmplDouble,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::CMPG_DOUBLE:
- convertWideComparison(cUnit, greenland::IntrinsicHelper::CmpgDouble,
+ ConvertWideComparison(cUnit, greenland::IntrinsicHelper::CmpgDouble,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::CMP_LONG:
- convertWideComparison(cUnit, greenland::IntrinsicHelper::CmpLong,
+ ConvertWideComparison(cUnit, greenland::IntrinsicHelper::CmpLong,
rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::PACKED_SWITCH:
- convertPackedSwitch(cUnit, bb, vB, rlSrc[0]);
+ ConvertPackedSwitch(cUnit, bb, vB, rlSrc[0]);
break;
case Instruction::SPARSE_SWITCH:
- convertSparseSwitch(cUnit, bb, vB, rlSrc[0]);
+ ConvertSparseSwitch(cUnit, bb, vB, rlSrc[0]);
break;
default:
@@ -1684,14 +1684,14 @@
res = true;
}
if (objectDefinition) {
- setShadowFrameEntry(cUnit, reinterpret_cast<llvm::Value*>
+ SetShadowFrameEntry(cUnit, reinterpret_cast<llvm::Value*>
(cUnit->llvmValues.elemList[rlDest.origSReg]));
}
return res;
}
/* Extended MIR instructions like PHI */
-void convertExtendedMIR(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+void ConvertExtendedMIR(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
llvm::BasicBlock* llvmBB)
{
@@ -1710,12 +1710,12 @@
}
int* incoming = reinterpret_cast<int*>(mir->dalvikInsn.vB);
llvm::Type* phiType =
- llvmTypeFromLocRec(cUnit, rlDest);
+ LlvmTypeFromLocRec(cUnit, rlDest);
llvm::PHINode* phi = cUnit->irb->CreatePHI(phiType, mir->ssaRep->numUses);
for (int i = 0; i < mir->ssaRep->numUses; i++) {
RegLocation loc;
// Don't check width here.
- loc = oatGetRawSrc(cUnit, mir, i);
+ loc = GetRawSrc(cUnit, mir, i);
DCHECK_EQ(rlDest.wide, loc.wide);
DCHECK_EQ(rlDest.wide & rlDest.highWord, loc.wide & loc.highWord);
DCHECK_EQ(rlDest.fp, loc.fp);
@@ -1724,10 +1724,10 @@
SafeMap<unsigned int, unsigned int>::iterator it;
it = cUnit->blockIdMap.find(incoming[i]);
DCHECK(it != cUnit->blockIdMap.end());
- phi->addIncoming(getLLVMValue(cUnit, loc.origSReg),
- getLLVMBlock(cUnit, it->second));
+ phi->addIncoming(GetLLVMValue(cUnit, loc.origSReg),
+ GetLLVMBlock(cUnit, it->second));
}
- defineValue(cUnit, phi, rlDest.origSReg);
+ DefineValue(cUnit, phi, rlDest.origSReg);
break;
}
case kMirOpCopy: {
@@ -1762,7 +1762,7 @@
}
}
-void setDexOffset(CompilationUnit* cUnit, int32_t offset)
+void SetDexOffset(CompilationUnit* cUnit, int32_t offset)
{
cUnit->currentDalvikOffset = offset;
llvm::SmallVector<llvm::Value*, 1> arrayRef;
@@ -1772,7 +1772,7 @@
}
// Attach method info as metadata to special intrinsic
-void setMethodInfo(CompilationUnit* cUnit)
+void SetMethodInfo(CompilationUnit* cUnit)
{
// We don't want dex offset on this
cUnit->irb->SetDexOffset(NULL);
@@ -1793,7 +1793,7 @@
for (int i = 0; i < promoSize; i++) {
PromotionMap* p = &cUnit->promotionMap[i];
int32_t mapData = ((p->firstInPair & 0xff) << 24) |
- ((p->fpReg & 0xff) << 16) |
+ ((p->FpReg & 0xff) << 16) |
((p->coreReg & 0xff) << 8) |
((p->fpLocation & 0xf) << 4) |
(p->coreLocation & 0xf);
@@ -1801,19 +1801,19 @@
}
llvm::MDNode* mapNode = llvm::MDNode::get(*cUnit->context, pmap);
inst->setMetadata("PromotionMap", mapNode);
- setDexOffset(cUnit, cUnit->currentDalvikOffset);
+ SetDexOffset(cUnit, cUnit->currentDalvikOffset);
}
/* Handle the content in each basic block */
-bool methodBlockBitcodeConversion(CompilationUnit* cUnit, BasicBlock* bb)
+bool MethodBlockBitcodeConversion(CompilationUnit* cUnit, BasicBlock* bb)
{
if (bb->blockType == kDead) return false;
- llvm::BasicBlock* llvmBB = getLLVMBlock(cUnit, bb->id);
+ llvm::BasicBlock* llvmBB = GetLLVMBlock(cUnit, bb->id);
if (llvmBB == NULL) {
CHECK(bb->blockType == kExitBlock);
} else {
cUnit->irb->SetInsertPoint(llvmBB);
- setDexOffset(cUnit, bb->startOffset);
+ SetDexOffset(cUnit, bb->startOffset);
}
if (cUnit->printMe) {
@@ -1827,8 +1827,8 @@
}
if (bb->blockType == kEntryBlock) {
- setMethodInfo(cUnit);
- bool *canBeRef = static_cast<bool*>(oatNew(cUnit, sizeof(bool) * cUnit->numDalvikRegisters,
+ SetMethodInfo(cUnit);
+ bool *canBeRef = static_cast<bool*>(NewMem(cUnit, sizeof(bool) * cUnit->numDalvikRegisters,
true, kAllocMisc));
for (int i = 0; i < cUnit->numSSARegs; i++) {
int vReg = SRegToVReg(cUnit, i);
@@ -1842,7 +1842,7 @@
}
}
if (cUnit->numShadowFrameEntries > 0) {
- cUnit->shadowMap = static_cast<int*>(oatNew(cUnit, sizeof(int) * cUnit->numShadowFrameEntries,
+ cUnit->shadowMap = static_cast<int*>(NewMem(cUnit, sizeof(int) * cUnit->numShadowFrameEntries,
true, kAllocMisc));
for (int i = 0, j = 0; i < cUnit->numDalvikRegisters; i++) {
if (canBeRef[i]) {
@@ -1875,7 +1875,7 @@
for (MIR* mir = bb->firstMIRInsn; mir; mir = mir->next) {
- setDexOffset(cUnit, mir->offset);
+ SetDexOffset(cUnit, mir->offset);
int opcode = mir->dalvikInsn.opcode;
Instruction::Format dalvikFormat =
@@ -1896,7 +1896,7 @@
llvm::Value* switchKey =
cUnit->irb->CreateCall(intr, cUnit->irb->getInt32(mir->offset));
GrowableListIterator iter;
- oatGrowableListIteratorInit(&bb->successorBlockList.blocks, &iter);
+ GrowableListIteratorInit(&bb->successorBlockList.blocks, &iter);
// New basic block to use for work half
llvm::BasicBlock* workBB =
llvm::BasicBlock::Create(*cUnit->context, "", cUnit->func);
@@ -1905,10 +1905,10 @@
bb->successorBlockList.blocks.numUsed);
while (true) {
SuccessorBlockInfo *successorBlockInfo =
- reinterpret_cast<SuccessorBlockInfo*>(oatGrowableListIteratorNext(&iter));
+ reinterpret_cast<SuccessorBlockInfo*>(GrowableListIteratorNext(&iter));
if (successorBlockInfo == NULL) break;
llvm::BasicBlock *target =
- getLLVMBlock(cUnit, successorBlockInfo->block->id);
+ GetLLVMBlock(cUnit, successorBlockInfo->block->id);
int typeIndex = successorBlockInfo->key;
sw->addCase(cUnit->irb->getInt32(typeIndex), target);
}
@@ -1918,11 +1918,11 @@
}
if (opcode >= kMirOpFirst) {
- convertExtendedMIR(cUnit, bb, mir, llvmBB);
+ ConvertExtendedMIR(cUnit, bb, mir, llvmBB);
continue;
}
- bool notHandled = convertMIRNode(cUnit, mir, bb, llvmBB,
+ bool notHandled = ConvertMIRNode(cUnit, mir, bb, llvmBB,
NULL /* labelList */);
if (notHandled) {
Instruction::Code dalvikOpcode = static_cast<Instruction::Code>(opcode);
@@ -1934,15 +1934,15 @@
}
if (bb->blockType == kEntryBlock) {
- cUnit->entryTargetBB = getLLVMBlock(cUnit, bb->fallThrough->id);
+ cUnit->entryTargetBB = GetLLVMBlock(cUnit, bb->fallThrough->id);
} else if ((bb->fallThrough != NULL) && !bb->hasReturn) {
- cUnit->irb->CreateBr(getLLVMBlock(cUnit, bb->fallThrough->id));
+ cUnit->irb->CreateBr(GetLLVMBlock(cUnit, bb->fallThrough->id));
}
return false;
}
-char remapShorty(char shortyType) {
+char RemapShorty(char shortyType) {
/*
* TODO: might want to revisit this. Dalvik registers are 32-bits wide,
* and longs/doubles are represented as a pair of registers. When sub-word
@@ -1964,10 +1964,10 @@
return shortyType;
}
-llvm::FunctionType* getFunctionType(CompilationUnit* cUnit) {
+llvm::FunctionType* GetFunctionType(CompilationUnit* cUnit) {
// Get return type
- llvm::Type* ret_type = cUnit->irb->GetJType(remapShorty(cUnit->shorty[0]),
+ llvm::Type* ret_type = cUnit->irb->GetJType(RemapShorty(cUnit->shorty[0]),
greenland::kAccurate);
// Get argument type
@@ -1982,17 +1982,17 @@
}
for (uint32_t i = 1; i < strlen(cUnit->shorty); ++i) {
- args_type.push_back(cUnit->irb->GetJType(remapShorty(cUnit->shorty[i]),
+ args_type.push_back(cUnit->irb->GetJType(RemapShorty(cUnit->shorty[i]),
greenland::kAccurate));
}
return llvm::FunctionType::get(ret_type, args_type, false);
}
-bool createFunction(CompilationUnit* cUnit) {
+bool CreateFunction(CompilationUnit* cUnit) {
std::string func_name(PrettyMethod(cUnit->method_idx, *cUnit->dex_file,
/* with_signature */ false));
- llvm::FunctionType* func_type = getFunctionType(cUnit);
+ llvm::FunctionType* func_type = GetFunctionType(cUnit);
if (func_type == NULL) {
return false;
@@ -2018,7 +2018,7 @@
return true;
}
-bool createLLVMBasicBlock(CompilationUnit* cUnit, BasicBlock* bb)
+bool CreateLLVMBasicBlock(CompilationUnit* cUnit, BasicBlock* bb)
{
// Skip the exit block
if ((bb->blockType == kDead) ||(bb->blockType == kExitBlock)) {
@@ -2050,16 +2050,16 @@
* o Iterate through the MIR a basic block at a time, setting arguments
* to recovered ssa name.
*/
-void oatMethodMIR2Bitcode(CompilationUnit* cUnit)
+void MethodMIR2Bitcode(CompilationUnit* cUnit)
{
- initIR(cUnit);
- oatInitGrowableList(cUnit, &cUnit->llvmValues, cUnit->numSSARegs);
+ InitIR(cUnit);
+ CompilerInitGrowableList(cUnit, &cUnit->llvmValues, cUnit->numSSARegs);
// Create the function
- createFunction(cUnit);
+ CreateFunction(cUnit);
// Create an LLVM basic block for each MIR block in dfs preorder
- oatDataFlowAnalysisDispatcher(cUnit, createLLVMBasicBlock,
+ DataFlowAnalysisDispatcher(cUnit, CreateLLVMBasicBlock,
kPreOrderDFSTraversal, false /* isIterative */);
/*
* Create an llvm named value for each MIR SSA name. Note: we'll use
@@ -2073,22 +2073,22 @@
llvm::Value* val;
RegLocation rlTemp = cUnit->regLocation[i];
if ((SRegToVReg(cUnit, i) < 0) || rlTemp.highWord) {
- oatInsertGrowableList(cUnit, &cUnit->llvmValues, 0);
+ InsertGrowableList(cUnit, &cUnit->llvmValues, 0);
} else if ((i < cUnit->numRegs) ||
(i >= (cUnit->numRegs + cUnit->numIns))) {
llvm::Constant* immValue = cUnit->regLocation[i].wide ?
cUnit->irb->GetJLong(0) : cUnit->irb->GetJInt(0);
- val = emitConst(cUnit, immValue, cUnit->regLocation[i]);
- val->setName(llvmSSAName(cUnit, i));
- oatInsertGrowableList(cUnit, &cUnit->llvmValues, reinterpret_cast<uintptr_t>(val));
+ val = EmitConst(cUnit, immValue, cUnit->regLocation[i]);
+ val->setName(LlvmSSAName(cUnit, i));
+ InsertGrowableList(cUnit, &cUnit->llvmValues, reinterpret_cast<uintptr_t>(val));
} else {
// Recover previously-created argument values
llvm::Value* argVal = arg_iter++;
- oatInsertGrowableList(cUnit, &cUnit->llvmValues, reinterpret_cast<uintptr_t>(argVal));
+ InsertGrowableList(cUnit, &cUnit->llvmValues, reinterpret_cast<uintptr_t>(argVal));
}
}
- oatDataFlowAnalysisDispatcher(cUnit, methodBlockBitcodeConversion,
+ DataFlowAnalysisDispatcher(cUnit, MethodBlockBitcodeConversion,
kPreOrderDFSTraversal, false /* Iterative */);
/*
@@ -2114,7 +2114,7 @@
inst->eraseFromParent();
}
}
- setDexOffset(cUnit, 0);
+ SetDexOffset(cUnit, 0);
if (cUnit->placeholderBB->empty()) {
cUnit->placeholderBB->eraseFromParent();
} else {
@@ -2138,7 +2138,7 @@
// Write bitcode to file
std::string errmsg;
std::string fname(PrettyMethod(cUnit->method_idx, *cUnit->dex_file));
- oatReplaceSpecialChars(fname);
+ ReplaceSpecialChars(fname);
// TODO: make configurable change naming mechanism to avoid fname length issues.
fname = StringPrintf("/sdcard/Bitcode/%s.bc", fname.c_str());
@@ -2160,7 +2160,7 @@
}
}
-RegLocation getLoc(CompilationUnit* cUnit, llvm::Value* val) {
+RegLocation GetLoc(CompilationUnit* cUnit, llvm::Value* val) {
RegLocation res;
DCHECK(val != NULL);
SafeMap<llvm::Value*, RegLocation>::iterator it = cUnit->locMap.find(val);
@@ -2172,7 +2172,7 @@
UNIMPLEMENTED(WARNING) << "Need to handle unnamed llvm temps";
memset(&res, 0, sizeof(res));
res.location = kLocPhysReg;
- res.lowReg = oatAllocTemp(cUnit);
+ res.lowReg = AllocTemp(cUnit);
res.home = true;
res.sRegLow = INVALID_SREG;
res.origSReg = INVALID_SREG;
@@ -2180,7 +2180,7 @@
res.wide = ((ty == cUnit->irb->getInt64Ty()) ||
(ty == cUnit->irb->getDoubleTy()));
if (res.wide) {
- res.highReg = oatAllocTemp(cUnit);
+ res.highReg = AllocTemp(cUnit);
}
cUnit->locMap.Put(val, res);
} else {
@@ -2196,7 +2196,7 @@
return res;
}
-Instruction::Code getDalvikOpcode(OpKind op, bool isConst, bool isWide)
+Instruction::Code GetDalvikOpcode(OpKind op, bool isConst, bool isWide)
{
Instruction::Code res = Instruction::NOP;
if (isWide) {
@@ -2248,7 +2248,7 @@
return res;
}
-Instruction::Code getDalvikFPOpcode(OpKind op, bool isConst, bool isWide)
+Instruction::Code GetDalvikFPOpcode(OpKind op, bool isConst, bool isWide)
{
Instruction::Code res = Instruction::NOP;
if (isWide) {
@@ -2273,9 +2273,9 @@
return res;
}
-void cvtBinFPOp(CompilationUnit* cUnit, OpKind op, llvm::Instruction* inst)
+void CvtBinFPOp(CompilationUnit* cUnit, OpKind op, llvm::Instruction* inst)
{
- RegLocation rlDest = getLoc(cUnit, inst);
+ RegLocation rlDest = GetLoc(cUnit, inst);
/*
* Normally, we won't ever generate an FP operation with an immediate
* operand (not supported in Dex instruction set). However, the IR builder
@@ -2286,37 +2286,37 @@
llvm::ConstantFP* op2C = llvm::dyn_cast<llvm::ConstantFP>(inst->getOperand(1));
DCHECK(op2C == NULL);
if ((op1C != NULL) && (op == kOpSub)) {
- RegLocation rlSrc = getLoc(cUnit, inst->getOperand(1));
+ RegLocation rlSrc = GetLoc(cUnit, inst->getOperand(1));
if (rlDest.wide) {
- genArithOpDouble(cUnit, Instruction::NEG_DOUBLE, rlDest, rlSrc, rlSrc);
+ GenArithOpDouble(cUnit, Instruction::NEG_DOUBLE, rlDest, rlSrc, rlSrc);
} else {
- genArithOpFloat(cUnit, Instruction::NEG_FLOAT, rlDest, rlSrc, rlSrc);
+ GenArithOpFloat(cUnit, Instruction::NEG_FLOAT, rlDest, rlSrc, rlSrc);
}
} else {
DCHECK(op1C == NULL);
- RegLocation rlSrc1 = getLoc(cUnit, inst->getOperand(0));
- RegLocation rlSrc2 = getLoc(cUnit, inst->getOperand(1));
- Instruction::Code dalvikOp = getDalvikFPOpcode(op, false, rlDest.wide);
+ RegLocation rlSrc1 = GetLoc(cUnit, inst->getOperand(0));
+ RegLocation rlSrc2 = GetLoc(cUnit, inst->getOperand(1));
+ Instruction::Code dalvikOp = GetDalvikFPOpcode(op, false, rlDest.wide);
if (rlDest.wide) {
- genArithOpDouble(cUnit, dalvikOp, rlDest, rlSrc1, rlSrc2);
+ GenArithOpDouble(cUnit, dalvikOp, rlDest, rlSrc1, rlSrc2);
} else {
- genArithOpFloat(cUnit, dalvikOp, rlDest, rlSrc1, rlSrc2);
+ GenArithOpFloat(cUnit, dalvikOp, rlDest, rlSrc1, rlSrc2);
}
}
}
-void cvtIntNarrowing(CompilationUnit* cUnit, llvm::Instruction* inst,
+void CvtIntNarrowing(CompilationUnit* cUnit, llvm::Instruction* inst,
Instruction::Code opcode)
{
- RegLocation rlDest = getLoc(cUnit, inst);
- RegLocation rlSrc = getLoc(cUnit, inst->getOperand(0));
- genIntNarrowing(cUnit, opcode, rlDest, rlSrc);
+ RegLocation rlDest = GetLoc(cUnit, inst);
+ RegLocation rlSrc = GetLoc(cUnit, inst->getOperand(0));
+ GenIntNarrowing(cUnit, opcode, rlDest, rlSrc);
}
-void cvtIntToFP(CompilationUnit* cUnit, llvm::Instruction* inst)
+void CvtIntToFP(CompilationUnit* cUnit, llvm::Instruction* inst)
{
- RegLocation rlDest = getLoc(cUnit, inst);
- RegLocation rlSrc = getLoc(cUnit, inst->getOperand(0));
+ RegLocation rlDest = GetLoc(cUnit, inst);
+ RegLocation rlSrc = GetLoc(cUnit, inst->getOperand(0));
Instruction::Code opcode;
if (rlDest.wide) {
if (rlSrc.wide) {
@@ -2331,13 +2331,13 @@
opcode = Instruction::INT_TO_FLOAT;
}
}
- genConversion(cUnit, opcode, rlDest, rlSrc);
+ GenConversion(cUnit, opcode, rlDest, rlSrc);
}
-void cvtFPToInt(CompilationUnit* cUnit, llvm::CallInst* call_inst)
+void CvtFPToInt(CompilationUnit* cUnit, llvm::CallInst* call_inst)
{
- RegLocation rlDest = getLoc(cUnit, call_inst);
- RegLocation rlSrc = getLoc(cUnit, call_inst->getOperand(0));
+ RegLocation rlDest = GetLoc(cUnit, call_inst);
+ RegLocation rlSrc = GetLoc(cUnit, call_inst->getOperand(0));
Instruction::Code opcode;
if (rlDest.wide) {
if (rlSrc.wide) {
@@ -2352,82 +2352,82 @@
opcode = Instruction::FLOAT_TO_INT;
}
}
- genConversion(cUnit, opcode, rlDest, rlSrc);
+ GenConversion(cUnit, opcode, rlDest, rlSrc);
}
-void cvtFloatToDouble(CompilationUnit* cUnit, llvm::Instruction* inst)
+void CvtFloatToDouble(CompilationUnit* cUnit, llvm::Instruction* inst)
{
- RegLocation rlDest = getLoc(cUnit, inst);
- RegLocation rlSrc = getLoc(cUnit, inst->getOperand(0));
- genConversion(cUnit, Instruction::FLOAT_TO_DOUBLE, rlDest, rlSrc);
+ RegLocation rlDest = GetLoc(cUnit, inst);
+ RegLocation rlSrc = GetLoc(cUnit, inst->getOperand(0));
+ GenConversion(cUnit, Instruction::FLOAT_TO_DOUBLE, rlDest, rlSrc);
}
-void cvtTrunc(CompilationUnit* cUnit, llvm::Instruction* inst)
+void CvtTrunc(CompilationUnit* cUnit, llvm::Instruction* inst)
{
- RegLocation rlDest = getLoc(cUnit, inst);
- RegLocation rlSrc = getLoc(cUnit, inst->getOperand(0));
- rlSrc = oatUpdateLocWide(cUnit, rlSrc);
- rlSrc = oatWideToNarrow(cUnit, rlSrc);
- storeValue(cUnit, rlDest, rlSrc);
+ RegLocation rlDest = GetLoc(cUnit, inst);
+ RegLocation rlSrc = GetLoc(cUnit, inst->getOperand(0));
+ rlSrc = UpdateLocWide(cUnit, rlSrc);
+ rlSrc = WideToNarrow(cUnit, rlSrc);
+ StoreValue(cUnit, rlDest, rlSrc);
}
-void cvtDoubleToFloat(CompilationUnit* cUnit, llvm::Instruction* inst)
+void CvtDoubleToFloat(CompilationUnit* cUnit, llvm::Instruction* inst)
{
- RegLocation rlDest = getLoc(cUnit, inst);
- RegLocation rlSrc = getLoc(cUnit, inst->getOperand(0));
- genConversion(cUnit, Instruction::DOUBLE_TO_FLOAT, rlDest, rlSrc);
+ RegLocation rlDest = GetLoc(cUnit, inst);
+ RegLocation rlSrc = GetLoc(cUnit, inst->getOperand(0));
+ GenConversion(cUnit, Instruction::DOUBLE_TO_FLOAT, rlDest, rlSrc);
}
-void cvtIntExt(CompilationUnit* cUnit, llvm::Instruction* inst, bool isSigned)
+void CvtIntExt(CompilationUnit* cUnit, llvm::Instruction* inst, bool isSigned)
{
// TODO: evaluate src/tgt types and add general support for more than int to long
- RegLocation rlDest = getLoc(cUnit, inst);
- RegLocation rlSrc = getLoc(cUnit, inst->getOperand(0));
+ RegLocation rlDest = GetLoc(cUnit, inst);
+ RegLocation rlSrc = GetLoc(cUnit, inst->getOperand(0));
DCHECK(rlDest.wide);
DCHECK(!rlSrc.wide);
DCHECK(!rlDest.fp);
DCHECK(!rlSrc.fp);
- 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);
}
if (isSigned) {
- opRegRegImm(cUnit, kOpAsr, rlResult.highReg, rlResult.lowReg, 31);
+ OpRegRegImm(cUnit, kOpAsr, rlResult.highReg, rlResult.lowReg, 31);
} else {
- loadConstant(cUnit, rlResult.highReg, 0);
+ LoadConstant(cUnit, rlResult.highReg, 0);
}
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
}
-void cvtBinOp(CompilationUnit* cUnit, OpKind op, llvm::Instruction* inst)
+void CvtBinOp(CompilationUnit* cUnit, OpKind op, llvm::Instruction* inst)
{
- RegLocation rlDest = getLoc(cUnit, inst);
+ RegLocation rlDest = GetLoc(cUnit, inst);
llvm::Value* lhs = inst->getOperand(0);
// Special-case RSUB/NEG
llvm::ConstantInt* lhsImm = llvm::dyn_cast<llvm::ConstantInt>(lhs);
if ((op == kOpSub) && (lhsImm != NULL)) {
- RegLocation rlSrc1 = getLoc(cUnit, inst->getOperand(1));
+ RegLocation rlSrc1 = GetLoc(cUnit, inst->getOperand(1));
if (rlSrc1.wide) {
DCHECK_EQ(lhsImm->getSExtValue(), 0);
- genArithOpLong(cUnit, Instruction::NEG_LONG, rlDest, rlSrc1, rlSrc1);
+ GenArithOpLong(cUnit, Instruction::NEG_LONG, rlDest, rlSrc1, rlSrc1);
} else {
- genArithOpIntLit(cUnit, Instruction::RSUB_INT, rlDest, rlSrc1,
+ GenArithOpIntLit(cUnit, Instruction::RSUB_INT, rlDest, rlSrc1,
lhsImm->getSExtValue());
}
return;
}
DCHECK(lhsImm == NULL);
- RegLocation rlSrc1 = getLoc(cUnit, inst->getOperand(0));
+ RegLocation rlSrc1 = GetLoc(cUnit, inst->getOperand(0));
llvm::Value* rhs = inst->getOperand(1);
llvm::ConstantInt* constRhs = llvm::dyn_cast<llvm::ConstantInt>(rhs);
if (!rlDest.wide && (constRhs != NULL)) {
- Instruction::Code dalvikOp = getDalvikOpcode(op, true, false);
- genArithOpIntLit(cUnit, dalvikOp, rlDest, rlSrc1, constRhs->getSExtValue());
+ Instruction::Code dalvikOp = GetDalvikOpcode(op, true, false);
+ GenArithOpIntLit(cUnit, dalvikOp, rlDest, rlSrc1, constRhs->getSExtValue());
} else {
- Instruction::Code dalvikOp = getDalvikOpcode(op, false, rlDest.wide);
+ Instruction::Code dalvikOp = GetDalvikOpcode(op, false, rlDest.wide);
RegLocation rlSrc2;
if (constRhs != NULL) {
// ir_builder converts NOT_LONG to xor src, -1. Restore
@@ -2436,66 +2436,66 @@
dalvikOp = Instruction::NOT_LONG;
rlSrc2 = rlSrc1;
} else {
- rlSrc2 = getLoc(cUnit, rhs);
+ rlSrc2 = GetLoc(cUnit, rhs);
}
if (rlDest.wide) {
- genArithOpLong(cUnit, dalvikOp, rlDest, rlSrc1, rlSrc2);
+ GenArithOpLong(cUnit, dalvikOp, rlDest, rlSrc1, rlSrc2);
} else {
- genArithOpInt(cUnit, dalvikOp, rlDest, rlSrc1, rlSrc2);
+ GenArithOpInt(cUnit, dalvikOp, rlDest, rlSrc1, rlSrc2);
}
}
}
-void cvtShiftOp(CompilationUnit* cUnit, Instruction::Code opcode,
+void CvtShiftOp(CompilationUnit* cUnit, Instruction::Code opcode,
llvm::CallInst* callInst)
{
DCHECK_EQ(callInst->getNumArgOperands(), 2U);
- RegLocation rlDest = getLoc(cUnit, callInst);
- RegLocation rlSrc = getLoc(cUnit, callInst->getArgOperand(0));
+ RegLocation rlDest = GetLoc(cUnit, callInst);
+ RegLocation rlSrc = GetLoc(cUnit, callInst->getArgOperand(0));
llvm::Value* rhs = callInst->getArgOperand(1);
if (llvm::ConstantInt* src2 = llvm::dyn_cast<llvm::ConstantInt>(rhs)) {
DCHECK(!rlDest.wide);
- genArithOpIntLit(cUnit, opcode, rlDest, rlSrc, src2->getSExtValue());
+ GenArithOpIntLit(cUnit, opcode, rlDest, rlSrc, src2->getSExtValue());
} else {
- RegLocation rlShift = getLoc(cUnit, rhs);
+ RegLocation rlShift = GetLoc(cUnit, rhs);
if (callInst->getType() == cUnit->irb->getInt64Ty()) {
- genShiftOpLong(cUnit, opcode, rlDest, rlSrc, rlShift);
+ GenShiftOpLong(cUnit, opcode, rlDest, rlSrc, rlShift);
} else {
- genArithOpInt(cUnit, opcode, rlDest, rlSrc, rlShift);
+ GenArithOpInt(cUnit, opcode, rlDest, rlSrc, rlShift);
}
}
}
-void cvtBr(CompilationUnit* cUnit, llvm::Instruction* inst)
+void CvtBr(CompilationUnit* cUnit, llvm::Instruction* inst)
{
llvm::BranchInst* brInst = llvm::dyn_cast<llvm::BranchInst>(inst);
DCHECK(brInst != NULL);
DCHECK(brInst->isUnconditional()); // May change - but this is all we use now
llvm::BasicBlock* targetBB = brInst->getSuccessor(0);
- opUnconditionalBranch(cUnit, cUnit->blockToLabelMap.Get(targetBB));
+ OpUnconditionalBranch(cUnit, cUnit->blockToLabelMap.Get(targetBB));
}
-void cvtPhi(CompilationUnit* cUnit, llvm::Instruction* inst)
+void CvtPhi(CompilationUnit* cUnit, llvm::Instruction* inst)
{
// Nop - these have already been processed
}
-void cvtRet(CompilationUnit* cUnit, llvm::Instruction* inst)
+void CvtRet(CompilationUnit* cUnit, llvm::Instruction* inst)
{
llvm::ReturnInst* retInst = llvm::dyn_cast<llvm::ReturnInst>(inst);
llvm::Value* retVal = retInst->getReturnValue();
if (retVal != NULL) {
- RegLocation rlSrc = getLoc(cUnit, retVal);
+ RegLocation rlSrc = GetLoc(cUnit, retVal);
if (rlSrc.wide) {
- storeValueWide(cUnit, oatGetReturnWide(cUnit, rlSrc.fp), rlSrc);
+ StoreValueWide(cUnit, GetReturnWide(cUnit, rlSrc.fp), rlSrc);
} else {
- storeValue(cUnit, oatGetReturn(cUnit, rlSrc.fp), rlSrc);
+ StoreValue(cUnit, GetReturn(cUnit, rlSrc.fp), rlSrc);
}
}
- genExitSequence(cUnit);
+ GenExitSequence(cUnit);
}
-ConditionCode getCond(llvm::ICmpInst::Predicate llvmCond)
+ConditionCode GetCond(llvm::ICmpInst::Predicate llvmCond)
{
ConditionCode res = kCondAl;
switch(llvmCond) {
@@ -2510,13 +2510,13 @@
return res;
}
-void cvtICmp(CompilationUnit* cUnit, llvm::Instruction* inst)
+void CvtICmp(CompilationUnit* cUnit, llvm::Instruction* inst)
{
- // genCmpLong(cUnit, rlDest, rlSrc1, rlSrc2)
+ // GenCmpLong(cUnit, rlDest, rlSrc1, rlSrc2)
UNIMPLEMENTED(FATAL);
}
-void cvtICmpBr(CompilationUnit* cUnit, llvm::Instruction* inst,
+void CvtICmpBr(CompilationUnit* cUnit, llvm::Instruction* inst,
llvm::BranchInst* brInst)
{
// Get targets
@@ -2526,12 +2526,12 @@
LIR* fallThrough = cUnit->blockToLabelMap.Get(fallThroughBB);
// Get comparison operands
llvm::ICmpInst* iCmpInst = llvm::dyn_cast<llvm::ICmpInst>(inst);
- ConditionCode cond = getCond(iCmpInst->getPredicate());
+ ConditionCode cond = GetCond(iCmpInst->getPredicate());
llvm::Value* lhs = iCmpInst->getOperand(0);
// Not expecting a constant as 1st operand
DCHECK(llvm::dyn_cast<llvm::ConstantInt>(lhs) == NULL);
- RegLocation rlSrc1 = getLoc(cUnit, inst->getOperand(0));
- rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
+ RegLocation rlSrc1 = GetLoc(cUnit, inst->getOperand(0));
+ rlSrc1 = LoadValue(cUnit, rlSrc1, kCoreReg);
llvm::Value* rhs = inst->getOperand(1);
if (cUnit->instructionSet == kMips) {
// Compare and branch in one shot
@@ -2540,173 +2540,173 @@
//Compare, then branch
// TODO: handle fused CMP_LONG/IF_xxZ case
if (llvm::ConstantInt* src2 = llvm::dyn_cast<llvm::ConstantInt>(rhs)) {
- opRegImm(cUnit, kOpCmp, rlSrc1.lowReg, src2->getSExtValue());
+ OpRegImm(cUnit, kOpCmp, rlSrc1.lowReg, src2->getSExtValue());
} else if (llvm::dyn_cast<llvm::ConstantPointerNull>(rhs) != NULL) {
- opRegImm(cUnit, kOpCmp, rlSrc1.lowReg, 0);
+ OpRegImm(cUnit, kOpCmp, rlSrc1.lowReg, 0);
} else {
- RegLocation rlSrc2 = getLoc(cUnit, rhs);
- rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
- opRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
+ RegLocation rlSrc2 = GetLoc(cUnit, rhs);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kCoreReg);
+ OpRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
}
- opCondBranch(cUnit, cond, taken);
+ OpCondBranch(cUnit, cond, taken);
// Fallthrough
- opUnconditionalBranch(cUnit, fallThrough);
+ OpUnconditionalBranch(cUnit, fallThrough);
}
-void cvtCall(CompilationUnit* cUnit, llvm::CallInst* callInst,
+void CvtCall(CompilationUnit* cUnit, llvm::CallInst* callInst,
llvm::Function* callee)
{
UNIMPLEMENTED(FATAL);
}
-void cvtCopy(CompilationUnit* cUnit, llvm::CallInst* callInst)
+void CvtCopy(CompilationUnit* cUnit, llvm::CallInst* callInst)
{
DCHECK_EQ(callInst->getNumArgOperands(), 1U);
- RegLocation rlSrc = getLoc(cUnit, callInst->getArgOperand(0));
- RegLocation rlDest = getLoc(cUnit, callInst);
+ RegLocation rlSrc = GetLoc(cUnit, callInst->getArgOperand(0));
+ RegLocation rlDest = GetLoc(cUnit, callInst);
DCHECK_EQ(rlSrc.wide, rlDest.wide);
DCHECK_EQ(rlSrc.fp, rlDest.fp);
if (rlSrc.wide) {
- storeValueWide(cUnit, rlDest, rlSrc);
+ StoreValueWide(cUnit, rlDest, rlSrc);
} else {
- storeValue(cUnit, rlDest, rlSrc);
+ StoreValue(cUnit, rlDest, rlSrc);
}
}
// Note: Immediate arg is a ConstantInt regardless of result type
-void cvtConst(CompilationUnit* cUnit, llvm::CallInst* callInst)
+void CvtConst(CompilationUnit* cUnit, llvm::CallInst* callInst)
{
DCHECK_EQ(callInst->getNumArgOperands(), 1U);
llvm::ConstantInt* src =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
uint64_t immval = src->getZExtValue();
- RegLocation rlDest = getLoc(cUnit, callInst);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
+ RegLocation rlDest = GetLoc(cUnit, callInst);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
if (rlDest.wide) {
- loadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
+ LoadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
(immval) & 0xffffffff, (immval >> 32) & 0xffffffff);
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
} else {
- loadConstantNoClobber(cUnit, rlResult.lowReg, immval & 0xffffffff);
- storeValue(cUnit, rlDest, rlResult);
+ LoadConstantNoClobber(cUnit, rlResult.lowReg, immval & 0xffffffff);
+ StoreValue(cUnit, rlDest, rlResult);
}
}
-void cvtConstObject(CompilationUnit* cUnit, llvm::CallInst* callInst,
+void CvtConstObject(CompilationUnit* cUnit, llvm::CallInst* callInst,
bool isString)
{
DCHECK_EQ(callInst->getNumArgOperands(), 1U);
llvm::ConstantInt* idxVal =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
uint32_t index = idxVal->getZExtValue();
- RegLocation rlDest = getLoc(cUnit, callInst);
+ RegLocation rlDest = GetLoc(cUnit, callInst);
if (isString) {
- genConstString(cUnit, index, rlDest);
+ GenConstString(cUnit, index, rlDest);
} else {
- genConstClass(cUnit, index, rlDest);
+ GenConstClass(cUnit, index, rlDest);
}
}
-void cvtFillArrayData(CompilationUnit* cUnit, llvm::CallInst* callInst)
+void CvtFillArrayData(CompilationUnit* cUnit, llvm::CallInst* callInst)
{
DCHECK_EQ(callInst->getNumArgOperands(), 2U);
llvm::ConstantInt* offsetVal =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
- RegLocation rlSrc = getLoc(cUnit, callInst->getArgOperand(1));
- genFillArrayData(cUnit, offsetVal->getSExtValue(), rlSrc);
+ RegLocation rlSrc = GetLoc(cUnit, callInst->getArgOperand(1));
+ GenFillArrayData(cUnit, offsetVal->getSExtValue(), rlSrc);
}
-void cvtNewInstance(CompilationUnit* cUnit, llvm::CallInst* callInst)
+void CvtNewInstance(CompilationUnit* cUnit, llvm::CallInst* callInst)
{
DCHECK_EQ(callInst->getNumArgOperands(), 1U);
llvm::ConstantInt* typeIdxVal =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
uint32_t typeIdx = typeIdxVal->getZExtValue();
- RegLocation rlDest = getLoc(cUnit, callInst);
- genNewInstance(cUnit, typeIdx, rlDest);
+ RegLocation rlDest = GetLoc(cUnit, callInst);
+ GenNewInstance(cUnit, typeIdx, rlDest);
}
-void cvtNewArray(CompilationUnit* cUnit, llvm::CallInst* callInst)
+void CvtNewArray(CompilationUnit* cUnit, llvm::CallInst* callInst)
{
DCHECK_EQ(callInst->getNumArgOperands(), 2U);
llvm::ConstantInt* typeIdxVal =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
uint32_t typeIdx = typeIdxVal->getZExtValue();
llvm::Value* len = callInst->getArgOperand(1);
- RegLocation rlLen = getLoc(cUnit, len);
- RegLocation rlDest = getLoc(cUnit, callInst);
- genNewArray(cUnit, typeIdx, rlDest, rlLen);
+ RegLocation rlLen = GetLoc(cUnit, len);
+ RegLocation rlDest = GetLoc(cUnit, callInst);
+ GenNewArray(cUnit, typeIdx, rlDest, rlLen);
}
-void cvtInstanceOf(CompilationUnit* cUnit, llvm::CallInst* callInst)
+void CvtInstanceOf(CompilationUnit* cUnit, llvm::CallInst* callInst)
{
DCHECK_EQ(callInst->getNumArgOperands(), 2U);
llvm::ConstantInt* typeIdxVal =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
uint32_t typeIdx = typeIdxVal->getZExtValue();
llvm::Value* src = callInst->getArgOperand(1);
- RegLocation rlSrc = getLoc(cUnit, src);
- RegLocation rlDest = getLoc(cUnit, callInst);
- genInstanceof(cUnit, typeIdx, rlDest, rlSrc);
+ RegLocation rlSrc = GetLoc(cUnit, src);
+ RegLocation rlDest = GetLoc(cUnit, callInst);
+ GenInstanceof(cUnit, typeIdx, rlDest, rlSrc);
}
-void cvtThrow(CompilationUnit* cUnit, llvm::CallInst* callInst)
+void CvtThrow(CompilationUnit* cUnit, llvm::CallInst* callInst)
{
DCHECK_EQ(callInst->getNumArgOperands(), 1U);
llvm::Value* src = callInst->getArgOperand(0);
- RegLocation rlSrc = getLoc(cUnit, src);
- genThrow(cUnit, rlSrc);
+ RegLocation rlSrc = GetLoc(cUnit, src);
+ GenThrow(cUnit, rlSrc);
}
-void cvtMonitorEnterExit(CompilationUnit* cUnit, bool isEnter,
+void CvtMonitorEnterExit(CompilationUnit* cUnit, bool isEnter,
llvm::CallInst* callInst)
{
DCHECK_EQ(callInst->getNumArgOperands(), 2U);
llvm::ConstantInt* optFlags =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
llvm::Value* src = callInst->getArgOperand(1);
- RegLocation rlSrc = getLoc(cUnit, src);
+ RegLocation rlSrc = GetLoc(cUnit, src);
if (isEnter) {
- genMonitorEnter(cUnit, optFlags->getZExtValue(), rlSrc);
+ GenMonitorEnter(cUnit, optFlags->getZExtValue(), rlSrc);
} else {
- genMonitorExit(cUnit, optFlags->getZExtValue(), rlSrc);
+ GenMonitorExit(cUnit, optFlags->getZExtValue(), rlSrc);
}
}
-void cvtArrayLength(CompilationUnit* cUnit, llvm::CallInst* callInst)
+void CvtArrayLength(CompilationUnit* cUnit, llvm::CallInst* callInst)
{
DCHECK_EQ(callInst->getNumArgOperands(), 2U);
llvm::ConstantInt* optFlags =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
llvm::Value* src = callInst->getArgOperand(1);
- RegLocation rlSrc = getLoc(cUnit, src);
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- genNullCheck(cUnit, rlSrc.sRegLow, rlSrc.lowReg, optFlags->getZExtValue());
- RegLocation rlDest = getLoc(cUnit, callInst);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ RegLocation rlSrc = GetLoc(cUnit, src);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
+ GenNullCheck(cUnit, rlSrc.sRegLow, rlSrc.lowReg, optFlags->getZExtValue());
+ RegLocation rlDest = GetLoc(cUnit, callInst);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
int lenOffset = Array::LengthOffset().Int32Value();
- loadWordDisp(cUnit, rlSrc.lowReg, lenOffset, rlResult.lowReg);
- storeValue(cUnit, rlDest, rlResult);
+ LoadWordDisp(cUnit, rlSrc.lowReg, lenOffset, rlResult.lowReg);
+ StoreValue(cUnit, rlDest, rlResult);
}
-void cvtMoveException(CompilationUnit* cUnit, llvm::CallInst* callInst)
+void CvtMoveException(CompilationUnit* cUnit, llvm::CallInst* callInst)
{
- RegLocation rlDest = getLoc(cUnit, callInst);
- genMoveException(cUnit, rlDest);
+ RegLocation rlDest = GetLoc(cUnit, callInst);
+ GenMoveException(cUnit, rlDest);
}
-void cvtSget(CompilationUnit* cUnit, llvm::CallInst* callInst, bool isWide,
+void CvtSget(CompilationUnit* cUnit, llvm::CallInst* callInst, bool isWide,
bool isObject)
{
DCHECK_EQ(callInst->getNumArgOperands(), 1U);
llvm::ConstantInt* typeIdxVal =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
uint32_t typeIdx = typeIdxVal->getZExtValue();
- RegLocation rlDest = getLoc(cUnit, callInst);
- genSget(cUnit, typeIdx, rlDest, isWide, isObject);
+ RegLocation rlDest = GetLoc(cUnit, callInst);
+ GenSget(cUnit, typeIdx, rlDest, isWide, isObject);
}
-void cvtSput(CompilationUnit* cUnit, llvm::CallInst* callInst, bool isWide,
+void CvtSput(CompilationUnit* cUnit, llvm::CallInst* callInst, bool isWide,
bool isObject)
{
DCHECK_EQ(callInst->getNumArgOperands(), 2U);
@@ -2714,107 +2714,107 @@
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
uint32_t typeIdx = typeIdxVal->getZExtValue();
llvm::Value* src = callInst->getArgOperand(1);
- RegLocation rlSrc = getLoc(cUnit, src);
- genSput(cUnit, typeIdx, rlSrc, isWide, isObject);
+ RegLocation rlSrc = GetLoc(cUnit, src);
+ GenSput(cUnit, typeIdx, rlSrc, isWide, isObject);
}
-void cvtAget(CompilationUnit* cUnit, llvm::CallInst* callInst, OpSize size,
+void CvtAget(CompilationUnit* cUnit, llvm::CallInst* callInst, OpSize size,
int scale)
{
DCHECK_EQ(callInst->getNumArgOperands(), 3U);
llvm::ConstantInt* optFlags =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
- RegLocation rlArray = getLoc(cUnit, callInst->getArgOperand(1));
- RegLocation rlIndex = getLoc(cUnit, callInst->getArgOperand(2));
- RegLocation rlDest = getLoc(cUnit, callInst);
- genArrayGet(cUnit, optFlags->getZExtValue(), size, rlArray, rlIndex,
+ RegLocation rlArray = GetLoc(cUnit, callInst->getArgOperand(1));
+ RegLocation rlIndex = GetLoc(cUnit, callInst->getArgOperand(2));
+ RegLocation rlDest = GetLoc(cUnit, callInst);
+ GenArrayGet(cUnit, optFlags->getZExtValue(), size, rlArray, rlIndex,
rlDest, scale);
}
-void cvtAput(CompilationUnit* cUnit, llvm::CallInst* callInst, OpSize size,
+void CvtAput(CompilationUnit* cUnit, llvm::CallInst* callInst, OpSize size,
int scale, bool isObject)
{
DCHECK_EQ(callInst->getNumArgOperands(), 4U);
llvm::ConstantInt* optFlags =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
- RegLocation rlSrc = getLoc(cUnit, callInst->getArgOperand(1));
- RegLocation rlArray = getLoc(cUnit, callInst->getArgOperand(2));
- RegLocation rlIndex = getLoc(cUnit, callInst->getArgOperand(3));
+ RegLocation rlSrc = GetLoc(cUnit, callInst->getArgOperand(1));
+ RegLocation rlArray = GetLoc(cUnit, callInst->getArgOperand(2));
+ RegLocation rlIndex = GetLoc(cUnit, callInst->getArgOperand(3));
if (isObject) {
- genArrayObjPut(cUnit, optFlags->getZExtValue(), rlArray, rlIndex,
+ GenArrayObjPut(cUnit, optFlags->getZExtValue(), rlArray, rlIndex,
rlSrc, scale);
} else {
- genArrayPut(cUnit, optFlags->getZExtValue(), size, rlArray, rlIndex,
+ GenArrayPut(cUnit, optFlags->getZExtValue(), size, rlArray, rlIndex,
rlSrc, scale);
}
}
-void cvtAputObj(CompilationUnit* cUnit, llvm::CallInst* callInst)
+void CvtAputObj(CompilationUnit* cUnit, llvm::CallInst* callInst)
{
- cvtAput(cUnit, callInst, kWord, 2, true /* isObject */);
+ CvtAput(cUnit, callInst, kWord, 2, true /* isObject */);
}
-void cvtAputPrimitive(CompilationUnit* cUnit, llvm::CallInst* callInst,
+void CvtAputPrimitive(CompilationUnit* cUnit, llvm::CallInst* callInst,
OpSize size, int scale)
{
- cvtAput(cUnit, callInst, size, scale, false /* isObject */);
+ CvtAput(cUnit, callInst, size, scale, false /* isObject */);
}
-void cvtIget(CompilationUnit* cUnit, llvm::CallInst* callInst, OpSize size,
+void CvtIget(CompilationUnit* cUnit, llvm::CallInst* callInst, OpSize size,
bool isWide, bool isObj)
{
DCHECK_EQ(callInst->getNumArgOperands(), 3U);
llvm::ConstantInt* optFlags =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
- RegLocation rlObj = getLoc(cUnit, callInst->getArgOperand(1));
+ RegLocation rlObj = GetLoc(cUnit, callInst->getArgOperand(1));
llvm::ConstantInt* fieldIdx =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(2));
- RegLocation rlDest = getLoc(cUnit, callInst);
- genIGet(cUnit, fieldIdx->getZExtValue(), optFlags->getZExtValue(),
+ RegLocation rlDest = GetLoc(cUnit, callInst);
+ GenIGet(cUnit, fieldIdx->getZExtValue(), optFlags->getZExtValue(),
size, rlDest, rlObj, isWide, isObj);
}
-void cvtIput(CompilationUnit* cUnit, llvm::CallInst* callInst, OpSize size,
+void CvtIput(CompilationUnit* cUnit, llvm::CallInst* callInst, OpSize size,
bool isWide, bool isObj)
{
DCHECK_EQ(callInst->getNumArgOperands(), 4U);
llvm::ConstantInt* optFlags =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
- RegLocation rlSrc = getLoc(cUnit, callInst->getArgOperand(1));
- RegLocation rlObj = getLoc(cUnit, callInst->getArgOperand(2));
+ RegLocation rlSrc = GetLoc(cUnit, callInst->getArgOperand(1));
+ RegLocation rlObj = GetLoc(cUnit, callInst->getArgOperand(2));
llvm::ConstantInt* fieldIdx =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(3));
- genIPut(cUnit, fieldIdx->getZExtValue(), optFlags->getZExtValue(),
+ GenIPut(cUnit, fieldIdx->getZExtValue(), optFlags->getZExtValue(),
size, rlSrc, rlObj, isWide, isObj);
}
-void cvtCheckCast(CompilationUnit* cUnit, llvm::CallInst* callInst)
+void CvtCheckCast(CompilationUnit* cUnit, llvm::CallInst* callInst)
{
DCHECK_EQ(callInst->getNumArgOperands(), 2U);
llvm::ConstantInt* typeIdx =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
- RegLocation rlSrc = getLoc(cUnit, callInst->getArgOperand(1));
- genCheckCast(cUnit, typeIdx->getZExtValue(), rlSrc);
+ RegLocation rlSrc = GetLoc(cUnit, callInst->getArgOperand(1));
+ GenCheckCast(cUnit, typeIdx->getZExtValue(), rlSrc);
}
-void cvtFPCompare(CompilationUnit* cUnit, llvm::CallInst* callInst,
+void CvtFPCompare(CompilationUnit* cUnit, llvm::CallInst* callInst,
Instruction::Code opcode)
{
- RegLocation rlSrc1 = getLoc(cUnit, callInst->getArgOperand(0));
- RegLocation rlSrc2 = getLoc(cUnit, callInst->getArgOperand(1));
- RegLocation rlDest = getLoc(cUnit, callInst);
- genCmpFP(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
+ RegLocation rlSrc1 = GetLoc(cUnit, callInst->getArgOperand(0));
+ RegLocation rlSrc2 = GetLoc(cUnit, callInst->getArgOperand(1));
+ RegLocation rlDest = GetLoc(cUnit, callInst);
+ GenCmpFP(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
}
-void cvtLongCompare(CompilationUnit* cUnit, llvm::CallInst* callInst)
+void CvtLongCompare(CompilationUnit* cUnit, llvm::CallInst* callInst)
{
- RegLocation rlSrc1 = getLoc(cUnit, callInst->getArgOperand(0));
- RegLocation rlSrc2 = getLoc(cUnit, callInst->getArgOperand(1));
- RegLocation rlDest = getLoc(cUnit, callInst);
- genCmpLong(cUnit, rlDest, rlSrc1, rlSrc2);
+ RegLocation rlSrc1 = GetLoc(cUnit, callInst->getArgOperand(0));
+ RegLocation rlSrc2 = GetLoc(cUnit, callInst->getArgOperand(1));
+ RegLocation rlDest = GetLoc(cUnit, callInst);
+ GenCmpLong(cUnit, rlDest, rlSrc1, rlSrc2);
}
-void cvtSwitch(CompilationUnit* cUnit, llvm::Instruction* inst)
+void CvtSwitch(CompilationUnit* cUnit, llvm::Instruction* inst)
{
llvm::SwitchInst* swInst = llvm::dyn_cast<llvm::SwitchInst>(inst);
DCHECK(swInst != NULL);
@@ -2824,25 +2824,25 @@
llvm::ConstantInt* tableOffsetValue =
static_cast<llvm::ConstantInt*>(tableOffsetNode->getOperand(0));
int32_t tableOffset = tableOffsetValue->getSExtValue();
- RegLocation rlSrc = getLoc(cUnit, testVal);
+ RegLocation rlSrc = GetLoc(cUnit, testVal);
const uint16_t* table = cUnit->insns + cUnit->currentDalvikOffset + tableOffset;
uint16_t tableMagic = *table;
if (tableMagic == 0x100) {
- genPackedSwitch(cUnit, tableOffset, rlSrc);
+ GenPackedSwitch(cUnit, tableOffset, rlSrc);
} else {
DCHECK_EQ(tableMagic, 0x200);
- genSparseSwitch(cUnit, tableOffset, rlSrc);
+ GenSparseSwitch(cUnit, tableOffset, rlSrc);
}
}
-void cvtInvoke(CompilationUnit* cUnit, llvm::CallInst* callInst,
+void CvtInvoke(CompilationUnit* cUnit, llvm::CallInst* callInst,
bool isVoid, bool isFilledNewArray)
{
- CallInfo* info = static_cast<CallInfo*>(oatNew(cUnit, sizeof(CallInfo), true, kAllocMisc));
+ CallInfo* info = static_cast<CallInfo*>(NewMem(cUnit, sizeof(CallInfo), true, kAllocMisc));
if (isVoid) {
info->result.location = kLocInvalid;
} else {
- info->result = getLoc(cUnit, callInst);
+ info->result = GetLoc(cUnit, callInst);
}
llvm::ConstantInt* invokeTypeVal =
llvm::dyn_cast<llvm::ConstantInt>(callInst->getArgOperand(0));
@@ -2858,14 +2858,14 @@
// Count the argument words, and then build argument array.
info->numArgWords = 0;
for (unsigned int i = 3; i < callInst->getNumArgOperands(); i++) {
- RegLocation tLoc = getLoc(cUnit, callInst->getArgOperand(i));
+ RegLocation tLoc = GetLoc(cUnit, callInst->getArgOperand(i));
info->numArgWords += tLoc.wide ? 2 : 1;
}
info->args = (info->numArgWords == 0) ? NULL : static_cast<RegLocation*>
- (oatNew(cUnit, sizeof(RegLocation) * info->numArgWords, false, kAllocMisc));
+ (NewMem(cUnit, sizeof(RegLocation) * info->numArgWords, false, kAllocMisc));
// Now, fill in the location records, synthesizing high loc of wide vals
for (int i = 3, next = 0; next < info->numArgWords;) {
- info->args[next] = getLoc(cUnit, callInst->getArgOperand(i++));
+ info->args[next] = GetLoc(cUnit, callInst->getArgOperand(i++));
if (info->args[next].wide) {
next++;
// TODO: Might make sense to mark this as an invalid loc
@@ -2878,21 +2878,21 @@
info->isRange = (info->numArgWords > 5);
if (isFilledNewArray) {
- genFilledNewArray(cUnit, info);
+ GenFilledNewArray(cUnit, info);
} else {
- genInvoke(cUnit, info);
+ GenInvoke(cUnit, info);
}
}
/* Look up the RegLocation associated with a Value. Must already be defined */
-RegLocation valToLoc(CompilationUnit* cUnit, llvm::Value* val)
+RegLocation ValToLoc(CompilationUnit* cUnit, llvm::Value* val)
{
SafeMap<llvm::Value*, RegLocation>::iterator it = cUnit->locMap.find(val);
DCHECK(it != cUnit->locMap.end()) << "Missing definition";
return it->second;
}
-bool methodBitcodeBlockCodeGen(CompilationUnit* cUnit, llvm::BasicBlock* bb)
+bool MethodBitcodeBlockCodeGen(CompilationUnit* cUnit, llvm::BasicBlock* bb)
{
while (cUnit->llvmBlocks.find(bb) == cUnit->llvmBlocks.end()) {
llvm::BasicBlock* nextBB = NULL;
@@ -2919,42 +2919,42 @@
// Set the label kind
blockLabel->opcode = kPseudoNormalBlockLabel;
// Insert the label
- oatAppendLIR(cUnit, blockLabel);
+ AppendLIR(cUnit, blockLabel);
LIR* headLIR = NULL;
if (blockType == kCatchBlock) {
- headLIR = newLIR0(cUnit, kPseudoExportedPC);
+ headLIR = NewLIR0(cUnit, kPseudoExportedPC);
}
// Free temp registers and reset redundant store tracking */
- oatResetRegPool(cUnit);
- oatResetDefTracking(cUnit);
+ ResetRegPool(cUnit);
+ ResetDefTracking(cUnit);
//TODO: restore oat incoming liveness optimization
- oatClobberAllRegs(cUnit);
+ ClobberAllRegs(cUnit);
if (isEntry) {
- RegLocation* argLocs = static_cast<RegLocation*>
- (oatNew(cUnit, sizeof(RegLocation) * cUnit->numIns, true, kAllocMisc));
+ RegLocation* ArgLocs = static_cast<RegLocation*>
+ (NewMem(cUnit, sizeof(RegLocation) * cUnit->numIns, true, kAllocMisc));
llvm::Function::arg_iterator it(cUnit->func->arg_begin());
llvm::Function::arg_iterator it_end(cUnit->func->arg_end());
// Skip past Method*
it++;
for (unsigned i = 0; it != it_end; ++it) {
llvm::Value* val = it;
- argLocs[i++] = valToLoc(cUnit, val);
+ ArgLocs[i++] = ValToLoc(cUnit, val);
llvm::Type* ty = val->getType();
if ((ty == cUnit->irb->getInt64Ty()) || (ty == cUnit->irb->getDoubleTy())) {
- argLocs[i] = argLocs[i-1];
- argLocs[i].lowReg = argLocs[i].highReg;
- argLocs[i].origSReg++;
- argLocs[i].sRegLow = INVALID_SREG;
- argLocs[i].highWord = true;
+ ArgLocs[i] = ArgLocs[i-1];
+ ArgLocs[i].lowReg = ArgLocs[i].highReg;
+ ArgLocs[i].origSReg++;
+ ArgLocs[i].sRegLow = INVALID_SREG;
+ ArgLocs[i].highWord = true;
i++;
}
}
- genEntrySequence(cUnit, argLocs, cUnit->methodLoc);
+ GenEntrySequence(cUnit, ArgLocs, cUnit->methodLoc);
}
// Visit all of the instructions in the block
@@ -2970,13 +2970,13 @@
cUnit->currentDalvikOffset = dexOffsetValue->getZExtValue();
}
- oatResetRegPool(cUnit);
+ ResetRegPool(cUnit);
if (cUnit->disableOpt & (1 << kTrackLiveTemps)) {
- oatClobberAllRegs(cUnit);
+ ClobberAllRegs(cUnit);
}
if (cUnit->disableOpt & (1 << kSuppressLoads)) {
- oatResetDefTracking(cUnit);
+ ResetDefTracking(cUnit);
}
#ifndef NDEBUG
@@ -2985,7 +2985,7 @@
#endif
// TODO: use llvm opcode name here instead of "boundary" if verbose
- LIR* boundaryLIR = markBoundary(cUnit, cUnit->currentDalvikOffset, "boundary");
+ LIR* boundaryLIR = MarkBoundary(cUnit, cUnit->currentDalvikOffset, "boundary");
/* Remember the first LIR for thisl block*/
if (headLIR == NULL) {
@@ -2999,10 +2999,10 @@
llvm::Instruction* nextInst = nextIt;
llvm::BranchInst* brInst = llvm::dyn_cast<llvm::BranchInst>(nextInst);
if (brInst != NULL /* and... */) {
- cvtICmpBr(cUnit, inst, brInst);
+ CvtICmpBr(cUnit, inst, brInst);
++it;
} else {
- cvtICmp(cUnit, inst);
+ CvtICmp(cUnit, inst);
}
}
break;
@@ -3024,59 +3024,59 @@
case greenland::IntrinsicHelper::CopyFloat:
case greenland::IntrinsicHelper::CopyLong:
case greenland::IntrinsicHelper::CopyDouble:
- cvtCopy(cUnit, callInst);
+ CvtCopy(cUnit, callInst);
break;
case greenland::IntrinsicHelper::ConstInt:
case greenland::IntrinsicHelper::ConstObj:
case greenland::IntrinsicHelper::ConstLong:
case greenland::IntrinsicHelper::ConstFloat:
case greenland::IntrinsicHelper::ConstDouble:
- cvtConst(cUnit, callInst);
+ CvtConst(cUnit, callInst);
break;
case greenland::IntrinsicHelper::DivInt:
case greenland::IntrinsicHelper::DivLong:
- cvtBinOp(cUnit, kOpDiv, inst);
+ CvtBinOp(cUnit, kOpDiv, inst);
break;
case greenland::IntrinsicHelper::RemInt:
case greenland::IntrinsicHelper::RemLong:
- cvtBinOp(cUnit, kOpRem, inst);
+ CvtBinOp(cUnit, kOpRem, inst);
break;
case greenland::IntrinsicHelper::MethodInfo:
// Already dealt with - just ignore it here.
break;
case greenland::IntrinsicHelper::CheckSuspend:
- genSuspendTest(cUnit, 0 /* optFlags already applied */);
+ GenSuspendTest(cUnit, 0 /* optFlags already applied */);
break;
case greenland::IntrinsicHelper::HLInvokeObj:
case greenland::IntrinsicHelper::HLInvokeFloat:
case greenland::IntrinsicHelper::HLInvokeDouble:
case greenland::IntrinsicHelper::HLInvokeLong:
case greenland::IntrinsicHelper::HLInvokeInt:
- cvtInvoke(cUnit, callInst, false /* isVoid */, false /* newArray */);
+ CvtInvoke(cUnit, callInst, false /* isVoid */, false /* newArray */);
break;
case greenland::IntrinsicHelper::HLInvokeVoid:
- cvtInvoke(cUnit, callInst, true /* isVoid */, false /* newArray */);
+ CvtInvoke(cUnit, callInst, true /* isVoid */, false /* newArray */);
break;
case greenland::IntrinsicHelper::HLFilledNewArray:
- cvtInvoke(cUnit, callInst, false /* isVoid */, true /* newArray */);
+ CvtInvoke(cUnit, callInst, false /* isVoid */, true /* newArray */);
break;
case greenland::IntrinsicHelper::HLFillArrayData:
- cvtFillArrayData(cUnit, callInst);
+ CvtFillArrayData(cUnit, callInst);
break;
case greenland::IntrinsicHelper::ConstString:
- cvtConstObject(cUnit, callInst, true /* isString */);
+ CvtConstObject(cUnit, callInst, true /* isString */);
break;
case greenland::IntrinsicHelper::ConstClass:
- cvtConstObject(cUnit, callInst, false /* isString */);
+ CvtConstObject(cUnit, callInst, false /* isString */);
break;
case greenland::IntrinsicHelper::HLCheckCast:
- cvtCheckCast(cUnit, callInst);
+ CvtCheckCast(cUnit, callInst);
break;
case greenland::IntrinsicHelper::NewInstance:
- cvtNewInstance(cUnit, callInst);
+ CvtNewInstance(cUnit, callInst);
break;
case greenland::IntrinsicHelper::HLSgetObject:
- cvtSget(cUnit, callInst, false /* wide */, true /* Object */);
+ CvtSget(cUnit, callInst, false /* wide */, true /* Object */);
break;
case greenland::IntrinsicHelper::HLSget:
case greenland::IntrinsicHelper::HLSgetFloat:
@@ -3084,11 +3084,11 @@
case greenland::IntrinsicHelper::HLSgetByte:
case greenland::IntrinsicHelper::HLSgetChar:
case greenland::IntrinsicHelper::HLSgetShort:
- cvtSget(cUnit, callInst, false /* wide */, false /* Object */);
+ CvtSget(cUnit, callInst, false /* wide */, false /* Object */);
break;
case greenland::IntrinsicHelper::HLSgetWide:
case greenland::IntrinsicHelper::HLSgetDouble:
- cvtSget(cUnit, callInst, true /* wide */, false /* Object */);
+ CvtSget(cUnit, callInst, true /* wide */, false /* Object */);
break;
case greenland::IntrinsicHelper::HLSput:
case greenland::IntrinsicHelper::HLSputFloat:
@@ -3096,190 +3096,190 @@
case greenland::IntrinsicHelper::HLSputByte:
case greenland::IntrinsicHelper::HLSputChar:
case greenland::IntrinsicHelper::HLSputShort:
- cvtSput(cUnit, callInst, false /* wide */, false /* Object */);
+ CvtSput(cUnit, callInst, false /* wide */, false /* Object */);
break;
case greenland::IntrinsicHelper::HLSputWide:
case greenland::IntrinsicHelper::HLSputDouble:
- cvtSput(cUnit, callInst, true /* wide */, false /* Object */);
+ CvtSput(cUnit, callInst, true /* wide */, false /* Object */);
break;
case greenland::IntrinsicHelper::HLSputObject:
- cvtSput(cUnit, callInst, false /* wide */, true /* Object */);
+ CvtSput(cUnit, callInst, false /* wide */, true /* Object */);
break;
case greenland::IntrinsicHelper::GetException:
- cvtMoveException(cUnit, callInst);
+ CvtMoveException(cUnit, callInst);
break;
case greenland::IntrinsicHelper::HLThrowException:
- cvtThrow(cUnit, callInst);
+ CvtThrow(cUnit, callInst);
break;
case greenland::IntrinsicHelper::MonitorEnter:
- cvtMonitorEnterExit(cUnit, true /* isEnter */, callInst);
+ CvtMonitorEnterExit(cUnit, true /* isEnter */, callInst);
break;
case greenland::IntrinsicHelper::MonitorExit:
- cvtMonitorEnterExit(cUnit, false /* isEnter */, callInst);
+ CvtMonitorEnterExit(cUnit, false /* isEnter */, callInst);
break;
case greenland::IntrinsicHelper::OptArrayLength:
- cvtArrayLength(cUnit, callInst);
+ CvtArrayLength(cUnit, callInst);
break;
case greenland::IntrinsicHelper::NewArray:
- cvtNewArray(cUnit, callInst);
+ CvtNewArray(cUnit, callInst);
break;
case greenland::IntrinsicHelper::InstanceOf:
- cvtInstanceOf(cUnit, callInst);
+ CvtInstanceOf(cUnit, callInst);
break;
case greenland::IntrinsicHelper::HLArrayGet:
case greenland::IntrinsicHelper::HLArrayGetObject:
case greenland::IntrinsicHelper::HLArrayGetFloat:
- cvtAget(cUnit, callInst, kWord, 2);
+ CvtAget(cUnit, callInst, kWord, 2);
break;
case greenland::IntrinsicHelper::HLArrayGetWide:
case greenland::IntrinsicHelper::HLArrayGetDouble:
- cvtAget(cUnit, callInst, kLong, 3);
+ CvtAget(cUnit, callInst, kLong, 3);
break;
case greenland::IntrinsicHelper::HLArrayGetBoolean:
- cvtAget(cUnit, callInst, kUnsignedByte, 0);
+ CvtAget(cUnit, callInst, kUnsignedByte, 0);
break;
case greenland::IntrinsicHelper::HLArrayGetByte:
- cvtAget(cUnit, callInst, kSignedByte, 0);
+ CvtAget(cUnit, callInst, kSignedByte, 0);
break;
case greenland::IntrinsicHelper::HLArrayGetChar:
- cvtAget(cUnit, callInst, kUnsignedHalf, 1);
+ CvtAget(cUnit, callInst, kUnsignedHalf, 1);
break;
case greenland::IntrinsicHelper::HLArrayGetShort:
- cvtAget(cUnit, callInst, kSignedHalf, 1);
+ CvtAget(cUnit, callInst, kSignedHalf, 1);
break;
case greenland::IntrinsicHelper::HLArrayPut:
case greenland::IntrinsicHelper::HLArrayPutFloat:
- cvtAputPrimitive(cUnit, callInst, kWord, 2);
+ CvtAputPrimitive(cUnit, callInst, kWord, 2);
break;
case greenland::IntrinsicHelper::HLArrayPutObject:
- cvtAputObj(cUnit, callInst);
+ CvtAputObj(cUnit, callInst);
break;
case greenland::IntrinsicHelper::HLArrayPutWide:
case greenland::IntrinsicHelper::HLArrayPutDouble:
- cvtAputPrimitive(cUnit, callInst, kLong, 3);
+ CvtAputPrimitive(cUnit, callInst, kLong, 3);
break;
case greenland::IntrinsicHelper::HLArrayPutBoolean:
- cvtAputPrimitive(cUnit, callInst, kUnsignedByte, 0);
+ CvtAputPrimitive(cUnit, callInst, kUnsignedByte, 0);
break;
case greenland::IntrinsicHelper::HLArrayPutByte:
- cvtAputPrimitive(cUnit, callInst, kSignedByte, 0);
+ CvtAputPrimitive(cUnit, callInst, kSignedByte, 0);
break;
case greenland::IntrinsicHelper::HLArrayPutChar:
- cvtAputPrimitive(cUnit, callInst, kUnsignedHalf, 1);
+ CvtAputPrimitive(cUnit, callInst, kUnsignedHalf, 1);
break;
case greenland::IntrinsicHelper::HLArrayPutShort:
- cvtAputPrimitive(cUnit, callInst, kSignedHalf, 1);
+ CvtAputPrimitive(cUnit, callInst, kSignedHalf, 1);
break;
case greenland::IntrinsicHelper::HLIGet:
case greenland::IntrinsicHelper::HLIGetFloat:
- cvtIget(cUnit, callInst, kWord, false /* isWide */, false /* obj */);
+ CvtIget(cUnit, callInst, kWord, false /* isWide */, false /* obj */);
break;
case greenland::IntrinsicHelper::HLIGetObject:
- cvtIget(cUnit, callInst, kWord, false /* isWide */, true /* obj */);
+ CvtIget(cUnit, callInst, kWord, false /* isWide */, true /* obj */);
break;
case greenland::IntrinsicHelper::HLIGetWide:
case greenland::IntrinsicHelper::HLIGetDouble:
- cvtIget(cUnit, callInst, kLong, true /* isWide */, false /* obj */);
+ CvtIget(cUnit, callInst, kLong, true /* isWide */, false /* obj */);
break;
case greenland::IntrinsicHelper::HLIGetBoolean:
- cvtIget(cUnit, callInst, kUnsignedByte, false /* isWide */,
+ CvtIget(cUnit, callInst, kUnsignedByte, false /* isWide */,
false /* obj */);
break;
case greenland::IntrinsicHelper::HLIGetByte:
- cvtIget(cUnit, callInst, kSignedByte, false /* isWide */,
+ CvtIget(cUnit, callInst, kSignedByte, false /* isWide */,
false /* obj */);
break;
case greenland::IntrinsicHelper::HLIGetChar:
- cvtIget(cUnit, callInst, kUnsignedHalf, false /* isWide */,
+ CvtIget(cUnit, callInst, kUnsignedHalf, false /* isWide */,
false /* obj */);
break;
case greenland::IntrinsicHelper::HLIGetShort:
- cvtIget(cUnit, callInst, kSignedHalf, false /* isWide */,
+ CvtIget(cUnit, callInst, kSignedHalf, false /* isWide */,
false /* obj */);
break;
case greenland::IntrinsicHelper::HLIPut:
case greenland::IntrinsicHelper::HLIPutFloat:
- cvtIput(cUnit, callInst, kWord, false /* isWide */, false /* obj */);
+ CvtIput(cUnit, callInst, kWord, false /* isWide */, false /* obj */);
break;
case greenland::IntrinsicHelper::HLIPutObject:
- cvtIput(cUnit, callInst, kWord, false /* isWide */, true /* obj */);
+ CvtIput(cUnit, callInst, kWord, false /* isWide */, true /* obj */);
break;
case greenland::IntrinsicHelper::HLIPutWide:
case greenland::IntrinsicHelper::HLIPutDouble:
- cvtIput(cUnit, callInst, kLong, true /* isWide */, false /* obj */);
+ CvtIput(cUnit, callInst, kLong, true /* isWide */, false /* obj */);
break;
case greenland::IntrinsicHelper::HLIPutBoolean:
- cvtIput(cUnit, callInst, kUnsignedByte, false /* isWide */,
+ CvtIput(cUnit, callInst, kUnsignedByte, false /* isWide */,
false /* obj */);
break;
case greenland::IntrinsicHelper::HLIPutByte:
- cvtIput(cUnit, callInst, kSignedByte, false /* isWide */,
+ CvtIput(cUnit, callInst, kSignedByte, false /* isWide */,
false /* obj */);
break;
case greenland::IntrinsicHelper::HLIPutChar:
- cvtIput(cUnit, callInst, kUnsignedHalf, false /* isWide */,
+ CvtIput(cUnit, callInst, kUnsignedHalf, false /* isWide */,
false /* obj */);
break;
case greenland::IntrinsicHelper::HLIPutShort:
- cvtIput(cUnit, callInst, kSignedHalf, false /* isWide */,
+ CvtIput(cUnit, callInst, kSignedHalf, false /* isWide */,
false /* obj */);
break;
case greenland::IntrinsicHelper::IntToChar:
- cvtIntNarrowing(cUnit, callInst, Instruction::INT_TO_CHAR);
+ CvtIntNarrowing(cUnit, callInst, Instruction::INT_TO_CHAR);
break;
case greenland::IntrinsicHelper::IntToShort:
- cvtIntNarrowing(cUnit, callInst, Instruction::INT_TO_SHORT);
+ CvtIntNarrowing(cUnit, callInst, Instruction::INT_TO_SHORT);
break;
case greenland::IntrinsicHelper::IntToByte:
- cvtIntNarrowing(cUnit, callInst, Instruction::INT_TO_BYTE);
+ CvtIntNarrowing(cUnit, callInst, Instruction::INT_TO_BYTE);
break;
case greenland::IntrinsicHelper::F2I:
case greenland::IntrinsicHelper::D2I:
case greenland::IntrinsicHelper::F2L:
case greenland::IntrinsicHelper::D2L:
- cvtFPToInt(cUnit, callInst);
+ CvtFPToInt(cUnit, callInst);
break;
case greenland::IntrinsicHelper::CmplFloat:
- cvtFPCompare(cUnit, callInst, Instruction::CMPL_FLOAT);
+ CvtFPCompare(cUnit, callInst, Instruction::CMPL_FLOAT);
break;
case greenland::IntrinsicHelper::CmpgFloat:
- cvtFPCompare(cUnit, callInst, Instruction::CMPG_FLOAT);
+ CvtFPCompare(cUnit, callInst, Instruction::CMPG_FLOAT);
break;
case greenland::IntrinsicHelper::CmplDouble:
- cvtFPCompare(cUnit, callInst, Instruction::CMPL_DOUBLE);
+ CvtFPCompare(cUnit, callInst, Instruction::CMPL_DOUBLE);
break;
case greenland::IntrinsicHelper::CmpgDouble:
- cvtFPCompare(cUnit, callInst, Instruction::CMPG_DOUBLE);
+ CvtFPCompare(cUnit, callInst, Instruction::CMPG_DOUBLE);
break;
case greenland::IntrinsicHelper::CmpLong:
- cvtLongCompare(cUnit, callInst);
+ CvtLongCompare(cUnit, callInst);
break;
case greenland::IntrinsicHelper::SHLLong:
- cvtShiftOp(cUnit, Instruction::SHL_LONG, callInst);
+ CvtShiftOp(cUnit, Instruction::SHL_LONG, callInst);
break;
case greenland::IntrinsicHelper::SHRLong:
- cvtShiftOp(cUnit, Instruction::SHR_LONG, callInst);
+ CvtShiftOp(cUnit, Instruction::SHR_LONG, callInst);
break;
case greenland::IntrinsicHelper::USHRLong:
- cvtShiftOp(cUnit, Instruction::USHR_LONG, callInst);
+ CvtShiftOp(cUnit, Instruction::USHR_LONG, callInst);
break;
case greenland::IntrinsicHelper::SHLInt:
- cvtShiftOp(cUnit, Instruction::SHL_INT, callInst);
+ CvtShiftOp(cUnit, Instruction::SHL_INT, callInst);
break;
case greenland::IntrinsicHelper::SHRInt:
- cvtShiftOp(cUnit, Instruction::SHR_INT, callInst);
+ CvtShiftOp(cUnit, Instruction::SHR_INT, callInst);
break;
case greenland::IntrinsicHelper::USHRInt:
- cvtShiftOp(cUnit, Instruction::USHR_INT, callInst);
+ CvtShiftOp(cUnit, Instruction::USHR_INT, callInst);
break;
case greenland::IntrinsicHelper::CatchTargets: {
@@ -3294,7 +3294,7 @@
*/
llvm::BasicBlock* targetBB = swInst->getDefaultDest();
DCHECK(targetBB != NULL);
- opUnconditionalBranch(cUnit,
+ OpUnconditionalBranch(cUnit,
cUnit->blockToLabelMap.Get(targetBB));
++it;
// Set next bb to default target - improves code layout
@@ -3308,33 +3308,33 @@
}
break;
- case llvm::Instruction::Br: cvtBr(cUnit, inst); break;
- case llvm::Instruction::Add: cvtBinOp(cUnit, kOpAdd, inst); break;
- case llvm::Instruction::Sub: cvtBinOp(cUnit, kOpSub, inst); break;
- case llvm::Instruction::Mul: cvtBinOp(cUnit, kOpMul, inst); break;
- case llvm::Instruction::SDiv: cvtBinOp(cUnit, kOpDiv, inst); break;
- case llvm::Instruction::SRem: cvtBinOp(cUnit, kOpRem, inst); break;
- case llvm::Instruction::And: cvtBinOp(cUnit, kOpAnd, inst); break;
- case llvm::Instruction::Or: cvtBinOp(cUnit, kOpOr, inst); break;
- case llvm::Instruction::Xor: cvtBinOp(cUnit, kOpXor, inst); break;
- case llvm::Instruction::PHI: cvtPhi(cUnit, inst); break;
- case llvm::Instruction::Ret: cvtRet(cUnit, inst); break;
- case llvm::Instruction::FAdd: cvtBinFPOp(cUnit, kOpAdd, inst); break;
- case llvm::Instruction::FSub: cvtBinFPOp(cUnit, kOpSub, inst); break;
- case llvm::Instruction::FMul: cvtBinFPOp(cUnit, kOpMul, inst); break;
- case llvm::Instruction::FDiv: cvtBinFPOp(cUnit, kOpDiv, inst); break;
- case llvm::Instruction::FRem: cvtBinFPOp(cUnit, kOpRem, inst); break;
- case llvm::Instruction::SIToFP: cvtIntToFP(cUnit, inst); break;
- case llvm::Instruction::FPTrunc: cvtDoubleToFloat(cUnit, inst); break;
- case llvm::Instruction::FPExt: cvtFloatToDouble(cUnit, inst); break;
- case llvm::Instruction::Trunc: cvtTrunc(cUnit, inst); break;
+ case llvm::Instruction::Br: CvtBr(cUnit, inst); break;
+ case llvm::Instruction::Add: CvtBinOp(cUnit, kOpAdd, inst); break;
+ case llvm::Instruction::Sub: CvtBinOp(cUnit, kOpSub, inst); break;
+ case llvm::Instruction::Mul: CvtBinOp(cUnit, kOpMul, inst); break;
+ case llvm::Instruction::SDiv: CvtBinOp(cUnit, kOpDiv, inst); break;
+ case llvm::Instruction::SRem: CvtBinOp(cUnit, kOpRem, inst); break;
+ case llvm::Instruction::And: CvtBinOp(cUnit, kOpAnd, inst); break;
+ case llvm::Instruction::Or: CvtBinOp(cUnit, kOpOr, inst); break;
+ case llvm::Instruction::Xor: CvtBinOp(cUnit, kOpXor, inst); break;
+ case llvm::Instruction::PHI: CvtPhi(cUnit, inst); break;
+ case llvm::Instruction::Ret: CvtRet(cUnit, inst); break;
+ case llvm::Instruction::FAdd: CvtBinFPOp(cUnit, kOpAdd, inst); break;
+ case llvm::Instruction::FSub: CvtBinFPOp(cUnit, kOpSub, inst); break;
+ case llvm::Instruction::FMul: CvtBinFPOp(cUnit, kOpMul, inst); break;
+ case llvm::Instruction::FDiv: CvtBinFPOp(cUnit, kOpDiv, inst); break;
+ case llvm::Instruction::FRem: CvtBinFPOp(cUnit, kOpRem, inst); break;
+ case llvm::Instruction::SIToFP: CvtIntToFP(cUnit, inst); break;
+ case llvm::Instruction::FPTrunc: CvtDoubleToFloat(cUnit, inst); break;
+ case llvm::Instruction::FPExt: CvtFloatToDouble(cUnit, inst); break;
+ case llvm::Instruction::Trunc: CvtTrunc(cUnit, inst); break;
- case llvm::Instruction::ZExt: cvtIntExt(cUnit, inst, false /* signed */);
+ case llvm::Instruction::ZExt: CvtIntExt(cUnit, inst, false /* signed */);
break;
- case llvm::Instruction::SExt: cvtIntExt(cUnit, inst, true /* signed */);
+ case llvm::Instruction::SExt: CvtIntExt(cUnit, inst, true /* signed */);
break;
- case llvm::Instruction::Switch: cvtSwitch(cUnit, inst); break;
+ case llvm::Instruction::Switch: CvtSwitch(cUnit, inst); break;
case llvm::Instruction::Unreachable:
break; // FIXME: can we really ignore these?
@@ -3380,7 +3380,7 @@
}
if (headLIR != NULL) {
- oatApplyLocalOptimizations(cUnit, headLIR, cUnit->lastLIRInsn);
+ ApplyLocalOptimizations(cUnit, headLIR, cUnit->lastLIRInsn);
}
if (nextBB != NULL) {
bb = nextBB;
@@ -3404,13 +3404,13 @@
* o Assemble LIR as usual.
* o Profit.
*/
-void oatMethodBitcode2LIR(CompilationUnit* cUnit)
+void MethodBitcode2LIR(CompilationUnit* cUnit)
{
llvm::Function* func = cUnit->func;
int numBasicBlocks = func->getBasicBlockList().size();
// Allocate a list for LIR basic block labels
cUnit->blockLabelList =
- static_cast<LIR*>(oatNew(cUnit, sizeof(LIR) * numBasicBlocks, true, kAllocLIR));
+ static_cast<LIR*>(NewMem(cUnit, sizeof(LIR) * numBasicBlocks, true, kAllocLIR));
LIR* labelList = cUnit->blockLabelList;
int nextLabel = 0;
for (llvm::Function::iterator i = func->begin(),
@@ -3487,55 +3487,55 @@
uint32_t mapData = rawMapData->getZExtValue();
PromotionMap* p = &cUnit->promotionMap[i];
p->firstInPair = (mapData >> 24) & 0xff;
- p->fpReg = (mapData >> 16) & 0xff;
+ p->FpReg = (mapData >> 16) & 0xff;
p->coreReg = (mapData >> 8) & 0xff;
p->fpLocation = static_cast<RegLocationType>((mapData >> 4) & 0xf);
if (p->fpLocation == kLocPhysReg) {
- oatRecordFpPromotion(cUnit, p->fpReg, i);
+ RecordFpPromotion(cUnit, p->FpReg, i);
}
p->coreLocation = static_cast<RegLocationType>(mapData & 0xf);
if (p->coreLocation == kLocPhysReg) {
- oatRecordCorePromotion(cUnit, p->coreReg, i);
+ RecordCorePromotion(cUnit, p->coreReg, i);
}
}
if (cUnit->printMe) {
- oatDumpPromotionMap(cUnit);
+ DumpPromotionMap(cUnit);
}
}
break;
}
}
}
- oatAdjustSpillMask(cUnit);
- cUnit->frameSize = oatComputeFrameSize(cUnit);
+ AdjustSpillMask(cUnit);
+ cUnit->frameSize = ComputeFrameSize(cUnit);
// Create RegLocations for arguments
llvm::Function::arg_iterator it(cUnit->func->arg_begin());
llvm::Function::arg_iterator it_end(cUnit->func->arg_end());
for (; it != it_end; ++it) {
llvm::Value* val = it;
- createLocFromValue(cUnit, val);
+ CreateLocFromValue(cUnit, val);
}
// Create RegLocations for all non-argument defintions
for (llvm::inst_iterator i = llvm::inst_begin(func),
e = llvm::inst_end(func); i != e; ++i) {
llvm::Value* val = &*i;
if (val->hasName() && (val->getName().str().c_str()[0] == 'v')) {
- createLocFromValue(cUnit, val);
+ CreateLocFromValue(cUnit, val);
}
}
// Walk the blocks, generating code.
for (llvm::Function::iterator i = cUnit->func->begin(),
e = cUnit->func->end(); i != e; ++i) {
- methodBitcodeBlockCodeGen(cUnit, static_cast<llvm::BasicBlock*>(i));
+ MethodBitcodeBlockCodeGen(cUnit, static_cast<llvm::BasicBlock*>(i));
}
- handleSuspendLaunchpads(cUnit);
+ HandleSuspendLaunchPads(cUnit);
- handleThrowLaunchpads(cUnit);
+ HandleThrowLaunchPads(cUnit);
- handleIntrinsicLaunchpads(cUnit);
+ HandleIntrinsicLaunchPads(cUnit);
cUnit->func->eraseFromParent();
cUnit->func = NULL;
diff --git a/src/compiler/codegen/method_bitcode.h b/src/compiler/codegen/method_bitcode.h
index 8b14286..1d6a1c9 100644
--- a/src/compiler/codegen/method_bitcode.h
+++ b/src/compiler/codegen/method_bitcode.h
@@ -19,8 +19,8 @@
namespace art {
-void oatMethodMIR2Bitcode(CompilationUnit* cUnit);
-void oatMethodBitcode2LIR(CompilationUnit* cUnit);
+void MethodMIR2Bitcode(CompilationUnit* cUnit);
+void MethodBitcode2LIR(CompilationUnit* cUnit);
} // namespace art
diff --git a/src/compiler/codegen/method_codegen_driver.cc b/src/compiler/codegen/method_codegen_driver.cc
index 4bf5a40..f7480b1 100644
--- a/src/compiler/codegen/method_codegen_driver.cc
+++ b/src/compiler/codegen/method_codegen_driver.cc
@@ -29,29 +29,29 @@
INVALID_SREG};
/* Mark register usage state and return long retloc */
-RegLocation oatGetReturnWide(CompilationUnit* cUnit, bool isDouble)
+RegLocation GetReturnWide(CompilationUnit* cUnit, bool isDouble)
{
- RegLocation gpr_res = locCReturnWide();
- RegLocation fpr_res = locCReturnDouble();
+ RegLocation gpr_res = LocCReturnWide();
+ RegLocation fpr_res = LocCReturnDouble();
RegLocation res = isDouble ? fpr_res : gpr_res;
- oatClobber(cUnit, res.lowReg);
- oatClobber(cUnit, res.highReg);
- oatLockTemp(cUnit, res.lowReg);
- oatLockTemp(cUnit, res.highReg);
- oatMarkPair(cUnit, res.lowReg, res.highReg);
+ Clobber(cUnit, res.lowReg);
+ Clobber(cUnit, res.highReg);
+ LockTemp(cUnit, res.lowReg);
+ LockTemp(cUnit, res.highReg);
+ MarkPair(cUnit, res.lowReg, res.highReg);
return res;
}
-RegLocation oatGetReturn(CompilationUnit* cUnit, bool isFloat)
+RegLocation GetReturn(CompilationUnit* cUnit, bool isFloat)
{
- RegLocation gpr_res = locCReturn();
- RegLocation fpr_res = locCReturnFloat();
+ RegLocation gpr_res = LocCReturn();
+ RegLocation fpr_res = LocCReturnFloat();
RegLocation res = isFloat ? fpr_res : gpr_res;
- oatClobber(cUnit, res.lowReg);
+ Clobber(cUnit, res.lowReg);
if (cUnit->instructionSet == kMips) {
- oatMarkInUse(cUnit, res.lowReg);
+ MarkInUse(cUnit, res.lowReg);
} else {
- oatLockTemp(cUnit, res.lowReg);
+ LockTemp(cUnit, res.lowReg);
}
return res;
}
@@ -61,7 +61,7 @@
* load/store utilities here, or target-dependent genXX() handlers
* when necessary.
*/
-bool compileDalvikInstruction(CompilationUnit* cUnit, MIR* mir,
+bool CompileDalvikInstruction(CompilationUnit* cUnit, MIR* mir,
BasicBlock* bb, LIR* labelList)
{
bool res = false; // Assume success
@@ -80,34 +80,34 @@
rlSrc[0] = rlSrc[1] = rlSrc[2] = badLoc;
if (attrs & DF_UA) {
if (attrs & DF_A_WIDE) {
- rlSrc[nextLoc++] = oatGetSrcWide(cUnit, mir, nextSreg);
+ rlSrc[nextLoc++] = GetSrcWide(cUnit, mir, nextSreg);
nextSreg+= 2;
} else {
- rlSrc[nextLoc++] = oatGetSrc(cUnit, mir, nextSreg);
+ rlSrc[nextLoc++] = GetSrc(cUnit, mir, nextSreg);
nextSreg++;
}
}
if (attrs & DF_UB) {
if (attrs & DF_B_WIDE) {
- rlSrc[nextLoc++] = oatGetSrcWide(cUnit, mir, nextSreg);
+ rlSrc[nextLoc++] = GetSrcWide(cUnit, mir, nextSreg);
nextSreg+= 2;
} else {
- rlSrc[nextLoc++] = oatGetSrc(cUnit, mir, nextSreg);
+ rlSrc[nextLoc++] = GetSrc(cUnit, mir, nextSreg);
nextSreg++;
}
}
if (attrs & DF_UC) {
if (attrs & DF_C_WIDE) {
- rlSrc[nextLoc++] = oatGetSrcWide(cUnit, mir, nextSreg);
+ rlSrc[nextLoc++] = GetSrcWide(cUnit, mir, nextSreg);
} else {
- rlSrc[nextLoc++] = oatGetSrc(cUnit, mir, nextSreg);
+ rlSrc[nextLoc++] = GetSrc(cUnit, mir, nextSreg);
}
}
if (attrs & DF_DA) {
if (attrs & DF_A_WIDE) {
- rlDest = oatGetDestWide(cUnit, mir);
+ rlDest = GetDestWide(cUnit, mir);
} else {
- rlDest = oatGetDest(cUnit, mir);
+ rlDest = GetDest(cUnit, mir);
}
}
switch (opcode) {
@@ -115,41 +115,41 @@
break;
case Instruction::MOVE_EXCEPTION:
- genMoveException(cUnit, rlDest);
+ GenMoveException(cUnit, rlDest);
break;
case Instruction::RETURN_VOID:
if (!(cUnit->attrs & METHOD_IS_LEAF)) {
- genSuspendTest(cUnit, optFlags);
+ GenSuspendTest(cUnit, optFlags);
}
break;
case Instruction::RETURN:
case Instruction::RETURN_OBJECT:
if (!(cUnit->attrs & METHOD_IS_LEAF)) {
- genSuspendTest(cUnit, optFlags);
+ GenSuspendTest(cUnit, optFlags);
}
- storeValue(cUnit, oatGetReturn(cUnit, cUnit->shorty[0] == 'F'), rlSrc[0]);
+ StoreValue(cUnit, GetReturn(cUnit, cUnit->shorty[0] == 'F'), rlSrc[0]);
break;
case Instruction::RETURN_WIDE:
if (!(cUnit->attrs & METHOD_IS_LEAF)) {
- genSuspendTest(cUnit, optFlags);
+ GenSuspendTest(cUnit, optFlags);
}
- storeValueWide(cUnit, oatGetReturnWide(cUnit,
+ StoreValueWide(cUnit, GetReturnWide(cUnit,
cUnit->shorty[0] == 'D'), rlSrc[0]);
break;
case Instruction::MOVE_RESULT_WIDE:
if (optFlags & MIR_INLINED)
break; // Nop - combined w/ previous invoke
- storeValueWide(cUnit, rlDest, oatGetReturnWide(cUnit, rlDest.fp));
+ StoreValueWide(cUnit, rlDest, GetReturnWide(cUnit, rlDest.fp));
break;
case Instruction::MOVE_RESULT:
case Instruction::MOVE_RESULT_OBJECT:
if (optFlags & MIR_INLINED)
break; // Nop - combined w/ previous invoke
- storeValue(cUnit, rlDest, oatGetReturn(cUnit, rlDest.fp));
+ StoreValue(cUnit, rlDest, GetReturn(cUnit, rlDest.fp));
break;
case Instruction::MOVE:
@@ -158,140 +158,140 @@
case Instruction::MOVE_OBJECT_16:
case Instruction::MOVE_FROM16:
case Instruction::MOVE_OBJECT_FROM16:
- storeValue(cUnit, rlDest, rlSrc[0]);
+ StoreValue(cUnit, rlDest, rlSrc[0]);
break;
case Instruction::MOVE_WIDE:
case Instruction::MOVE_WIDE_16:
case Instruction::MOVE_WIDE_FROM16:
- storeValueWide(cUnit, rlDest, rlSrc[0]);
+ StoreValueWide(cUnit, rlDest, rlSrc[0]);
break;
case Instruction::CONST:
case Instruction::CONST_4:
case Instruction::CONST_16:
- rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
- loadConstantNoClobber(cUnit, rlResult.lowReg, vB);
- storeValue(cUnit, rlDest, rlResult);
+ rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
+ LoadConstantNoClobber(cUnit, rlResult.lowReg, vB);
+ StoreValue(cUnit, rlDest, rlResult);
break;
case Instruction::CONST_HIGH16:
- rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
- loadConstantNoClobber(cUnit, rlResult.lowReg, vB << 16);
- storeValue(cUnit, rlDest, rlResult);
+ rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
+ LoadConstantNoClobber(cUnit, rlResult.lowReg, vB << 16);
+ StoreValue(cUnit, rlDest, rlResult);
break;
case Instruction::CONST_WIDE_16:
case Instruction::CONST_WIDE_32:
- rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
- loadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg, vB,
+ rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
+ LoadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg, vB,
(vB & 0x80000000) ? -1 : 0);
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
break;
case Instruction::CONST_WIDE:
- rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
- loadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
+ rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
+ LoadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
mir->dalvikInsn.vB_wide & 0xffffffff,
(mir->dalvikInsn.vB_wide >> 32) & 0xffffffff);
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
break;
case Instruction::CONST_WIDE_HIGH16:
- rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
- loadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
+ rlResult = EvalLoc(cUnit, rlDest, kAnyReg, true);
+ LoadConstantValueWide(cUnit, rlResult.lowReg, rlResult.highReg,
0, vB << 16);
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
break;
case Instruction::MONITOR_ENTER:
- genMonitorEnter(cUnit, optFlags, rlSrc[0]);
+ GenMonitorEnter(cUnit, optFlags, rlSrc[0]);
break;
case Instruction::MONITOR_EXIT:
- genMonitorExit(cUnit, optFlags, rlSrc[0]);
+ GenMonitorExit(cUnit, optFlags, rlSrc[0]);
break;
case Instruction::CHECK_CAST:
- genCheckCast(cUnit, vB, rlSrc[0]);
+ GenCheckCast(cUnit, vB, rlSrc[0]);
break;
case Instruction::INSTANCE_OF:
- genInstanceof(cUnit, vC, rlDest, rlSrc[0]);
+ GenInstanceof(cUnit, vC, rlDest, rlSrc[0]);
break;
case Instruction::NEW_INSTANCE:
- genNewInstance(cUnit, vB, rlDest);
+ GenNewInstance(cUnit, vB, rlDest);
break;
case Instruction::THROW:
- genThrow(cUnit, rlSrc[0]);
+ GenThrow(cUnit, rlSrc[0]);
break;
case Instruction::ARRAY_LENGTH:
int lenOffset;
lenOffset = Array::LengthOffset().Int32Value();
- rlSrc[0] = loadValue(cUnit, rlSrc[0], kCoreReg);
- genNullCheck(cUnit, rlSrc[0].sRegLow, rlSrc[0].lowReg, optFlags);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- loadWordDisp(cUnit, rlSrc[0].lowReg, lenOffset, rlResult.lowReg);
- storeValue(cUnit, rlDest, rlResult);
+ rlSrc[0] = LoadValue(cUnit, rlSrc[0], kCoreReg);
+ GenNullCheck(cUnit, rlSrc[0].sRegLow, rlSrc[0].lowReg, optFlags);
+ rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ LoadWordDisp(cUnit, rlSrc[0].lowReg, lenOffset, rlResult.lowReg);
+ StoreValue(cUnit, rlDest, rlResult);
break;
case Instruction::CONST_STRING:
case Instruction::CONST_STRING_JUMBO:
- genConstString(cUnit, vB, rlDest);
+ GenConstString(cUnit, vB, rlDest);
break;
case Instruction::CONST_CLASS:
- genConstClass(cUnit, vB, rlDest);
+ GenConstClass(cUnit, vB, rlDest);
break;
case Instruction::FILL_ARRAY_DATA:
- genFillArrayData(cUnit, vB, rlSrc[0]);
+ GenFillArrayData(cUnit, vB, rlSrc[0]);
break;
case Instruction::FILLED_NEW_ARRAY:
- genFilledNewArray(cUnit, oatNewCallInfo(cUnit, bb, mir, kStatic,
+ GenFilledNewArray(cUnit, NewMemCallInfo(cUnit, bb, mir, kStatic,
false /* not range */));
break;
case Instruction::FILLED_NEW_ARRAY_RANGE:
- genFilledNewArray(cUnit, oatNewCallInfo(cUnit, bb, mir, kStatic,
+ GenFilledNewArray(cUnit, NewMemCallInfo(cUnit, bb, mir, kStatic,
true /* range */));
break;
case Instruction::NEW_ARRAY:
- genNewArray(cUnit, vC, rlDest, rlSrc[0]);
+ GenNewArray(cUnit, vC, rlDest, rlSrc[0]);
break;
case Instruction::GOTO:
case Instruction::GOTO_16:
case Instruction::GOTO_32:
if (bb->taken->startOffset <= mir->offset) {
- genSuspendTestAndBranch(cUnit, optFlags, &labelList[bb->taken->id]);
+ GenSuspendTestAndBranch(cUnit, optFlags, &labelList[bb->taken->id]);
} else {
- opUnconditionalBranch(cUnit, &labelList[bb->taken->id]);
+ OpUnconditionalBranch(cUnit, &labelList[bb->taken->id]);
}
break;
case Instruction::PACKED_SWITCH:
- genPackedSwitch(cUnit, vB, rlSrc[0]);
+ GenPackedSwitch(cUnit, vB, rlSrc[0]);
break;
case Instruction::SPARSE_SWITCH:
- genSparseSwitch(cUnit, vB, rlSrc[0]);
+ GenSparseSwitch(cUnit, vB, rlSrc[0]);
break;
case Instruction::CMPL_FLOAT:
case Instruction::CMPG_FLOAT:
case Instruction::CMPL_DOUBLE:
case Instruction::CMPG_DOUBLE:
- res = genCmpFP(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
+ res = GenCmpFP(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::CMP_LONG:
- genCmpLong(cUnit, rlDest, rlSrc[0], rlSrc[1]);
+ GenCmpLong(cUnit, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::IF_EQ:
@@ -305,9 +305,9 @@
bool backwardBranch;
backwardBranch = (bb->taken->startOffset <= mir->offset);
if (backwardBranch) {
- genSuspendTest(cUnit, optFlags);
+ GenSuspendTest(cUnit, optFlags);
}
- genCompareAndBranch(cUnit, opcode, rlSrc[0], rlSrc[1], taken,
+ GenCompareAndBranch(cUnit, opcode, rlSrc[0], rlSrc[1], taken,
fallThrough);
break;
}
@@ -323,123 +323,123 @@
bool backwardBranch;
backwardBranch = (bb->taken->startOffset <= mir->offset);
if (backwardBranch) {
- genSuspendTest(cUnit, optFlags);
+ GenSuspendTest(cUnit, optFlags);
}
- genCompareZeroAndBranch(cUnit, opcode, rlSrc[0], taken, fallThrough);
+ GenCompareZeroAndBranch(cUnit, opcode, rlSrc[0], taken, fallThrough);
break;
}
case Instruction::AGET_WIDE:
- genArrayGet(cUnit, optFlags, kLong, rlSrc[0], rlSrc[1], rlDest, 3);
+ GenArrayGet(cUnit, optFlags, kLong, rlSrc[0], rlSrc[1], rlDest, 3);
break;
case Instruction::AGET:
case Instruction::AGET_OBJECT:
- genArrayGet(cUnit, optFlags, kWord, rlSrc[0], rlSrc[1], rlDest, 2);
+ GenArrayGet(cUnit, optFlags, kWord, rlSrc[0], rlSrc[1], rlDest, 2);
break;
case Instruction::AGET_BOOLEAN:
- genArrayGet(cUnit, optFlags, kUnsignedByte, rlSrc[0], rlSrc[1], rlDest, 0);
+ GenArrayGet(cUnit, optFlags, kUnsignedByte, rlSrc[0], rlSrc[1], rlDest, 0);
break;
case Instruction::AGET_BYTE:
- genArrayGet(cUnit, optFlags, kSignedByte, rlSrc[0], rlSrc[1], rlDest, 0);
+ GenArrayGet(cUnit, optFlags, kSignedByte, rlSrc[0], rlSrc[1], rlDest, 0);
break;
case Instruction::AGET_CHAR:
- genArrayGet(cUnit, optFlags, kUnsignedHalf, rlSrc[0], rlSrc[1], rlDest, 1);
+ GenArrayGet(cUnit, optFlags, kUnsignedHalf, rlSrc[0], rlSrc[1], rlDest, 1);
break;
case Instruction::AGET_SHORT:
- genArrayGet(cUnit, optFlags, kSignedHalf, rlSrc[0], rlSrc[1], rlDest, 1);
+ GenArrayGet(cUnit, optFlags, kSignedHalf, rlSrc[0], rlSrc[1], rlDest, 1);
break;
case Instruction::APUT_WIDE:
- genArrayPut(cUnit, optFlags, kLong, rlSrc[1], rlSrc[2], rlSrc[0], 3);
+ GenArrayPut(cUnit, optFlags, kLong, rlSrc[1], rlSrc[2], rlSrc[0], 3);
break;
case Instruction::APUT:
- genArrayPut(cUnit, optFlags, kWord, rlSrc[1], rlSrc[2], rlSrc[0], 2);
+ GenArrayPut(cUnit, optFlags, kWord, rlSrc[1], rlSrc[2], rlSrc[0], 2);
break;
case Instruction::APUT_OBJECT:
- genArrayObjPut(cUnit, optFlags, rlSrc[1], rlSrc[2], rlSrc[0], 2);
+ GenArrayObjPut(cUnit, optFlags, rlSrc[1], rlSrc[2], rlSrc[0], 2);
break;
case Instruction::APUT_SHORT:
case Instruction::APUT_CHAR:
- genArrayPut(cUnit, optFlags, kUnsignedHalf, rlSrc[1], rlSrc[2], rlSrc[0], 1);
+ GenArrayPut(cUnit, optFlags, kUnsignedHalf, rlSrc[1], rlSrc[2], rlSrc[0], 1);
break;
case Instruction::APUT_BYTE:
case Instruction::APUT_BOOLEAN:
- genArrayPut(cUnit, optFlags, kUnsignedByte, rlSrc[1], rlSrc[2],
+ GenArrayPut(cUnit, optFlags, kUnsignedByte, rlSrc[1], rlSrc[2],
rlSrc[0], 0);
break;
case Instruction::IGET_OBJECT:
//case Instruction::IGET_OBJECT_VOLATILE:
- genIGet(cUnit, vC, optFlags, kWord, rlDest, rlSrc[0], false, true);
+ GenIGet(cUnit, vC, optFlags, kWord, rlDest, rlSrc[0], false, true);
break;
case Instruction::IGET_WIDE:
//case Instruction::IGET_WIDE_VOLATILE:
- genIGet(cUnit, vC, optFlags, kLong, rlDest, rlSrc[0], true, false);
+ GenIGet(cUnit, vC, optFlags, kLong, rlDest, rlSrc[0], true, false);
break;
case Instruction::IGET:
//case Instruction::IGET_VOLATILE:
- genIGet(cUnit, vC, optFlags, kWord, rlDest, rlSrc[0], false, false);
+ GenIGet(cUnit, vC, optFlags, kWord, rlDest, rlSrc[0], false, false);
break;
case Instruction::IGET_CHAR:
- genIGet(cUnit, vC, optFlags, kUnsignedHalf, rlDest, rlSrc[0], false, false);
+ GenIGet(cUnit, vC, optFlags, kUnsignedHalf, rlDest, rlSrc[0], false, false);
break;
case Instruction::IGET_SHORT:
- genIGet(cUnit, vC, optFlags, kSignedHalf, rlDest, rlSrc[0], false, false);
+ GenIGet(cUnit, vC, optFlags, kSignedHalf, rlDest, rlSrc[0], false, false);
break;
case Instruction::IGET_BOOLEAN:
case Instruction::IGET_BYTE:
- genIGet(cUnit, vC, optFlags, kUnsignedByte, rlDest, rlSrc[0], false, false);
+ GenIGet(cUnit, vC, optFlags, kUnsignedByte, rlDest, rlSrc[0], false, false);
break;
case Instruction::IPUT_WIDE:
//case Instruction::IPUT_WIDE_VOLATILE:
- genIPut(cUnit, vC, optFlags, kLong, rlSrc[0], rlSrc[1], true, false);
+ GenIPut(cUnit, vC, optFlags, kLong, rlSrc[0], rlSrc[1], true, false);
break;
case Instruction::IPUT_OBJECT:
//case Instruction::IPUT_OBJECT_VOLATILE:
- genIPut(cUnit, vC, optFlags, kWord, rlSrc[0], rlSrc[1], false, true);
+ GenIPut(cUnit, vC, optFlags, kWord, rlSrc[0], rlSrc[1], false, true);
break;
case Instruction::IPUT:
//case Instruction::IPUT_VOLATILE:
- genIPut(cUnit, vC, optFlags, kWord, rlSrc[0], rlSrc[1], false, false);
+ GenIPut(cUnit, vC, optFlags, kWord, rlSrc[0], rlSrc[1], false, false);
break;
case Instruction::IPUT_BOOLEAN:
case Instruction::IPUT_BYTE:
- genIPut(cUnit, vC, optFlags, kUnsignedByte, rlSrc[0], rlSrc[1], false, false);
+ GenIPut(cUnit, vC, optFlags, kUnsignedByte, rlSrc[0], rlSrc[1], false, false);
break;
case Instruction::IPUT_CHAR:
- genIPut(cUnit, vC, optFlags, kUnsignedHalf, rlSrc[0], rlSrc[1], false, false);
+ GenIPut(cUnit, vC, optFlags, kUnsignedHalf, rlSrc[0], rlSrc[1], false, false);
break;
case Instruction::IPUT_SHORT:
- genIPut(cUnit, vC, optFlags, kSignedHalf, rlSrc[0], rlSrc[1], false, false);
+ GenIPut(cUnit, vC, optFlags, kSignedHalf, rlSrc[0], rlSrc[1], false, false);
break;
case Instruction::SGET_OBJECT:
- genSget(cUnit, vB, rlDest, false, true);
+ GenSget(cUnit, vB, rlDest, false, true);
break;
case Instruction::SGET:
case Instruction::SGET_BOOLEAN:
case Instruction::SGET_BYTE:
case Instruction::SGET_CHAR:
case Instruction::SGET_SHORT:
- genSget(cUnit, vB, rlDest, false, false);
+ GenSget(cUnit, vB, rlDest, false, false);
break;
case Instruction::SGET_WIDE:
- genSget(cUnit, vB, rlDest, true, false);
+ GenSget(cUnit, vB, rlDest, true, false);
break;
case Instruction::SPUT_OBJECT:
- genSput(cUnit, vB, rlSrc[0], false, true);
+ GenSput(cUnit, vB, rlSrc[0], false, true);
break;
case Instruction::SPUT:
@@ -447,80 +447,80 @@
case Instruction::SPUT_BYTE:
case Instruction::SPUT_CHAR:
case Instruction::SPUT_SHORT:
- genSput(cUnit, vB, rlSrc[0], false, false);
+ GenSput(cUnit, vB, rlSrc[0], false, false);
break;
case Instruction::SPUT_WIDE:
- genSput(cUnit, vB, rlSrc[0], true, false);
+ GenSput(cUnit, vB, rlSrc[0], true, false);
break;
case Instruction::INVOKE_STATIC_RANGE:
- genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kStatic, true));
+ GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kStatic, true));
break;
case Instruction::INVOKE_STATIC:
- genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kStatic, false));
+ GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kStatic, false));
break;
case Instruction::INVOKE_DIRECT:
- genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kDirect, false));
+ GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kDirect, false));
break;
case Instruction::INVOKE_DIRECT_RANGE:
- genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kDirect, true));
+ GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kDirect, true));
break;
case Instruction::INVOKE_VIRTUAL:
- genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kVirtual, false));
+ GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kVirtual, false));
break;
case Instruction::INVOKE_VIRTUAL_RANGE:
- genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kVirtual, true));
+ GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kVirtual, true));
break;
case Instruction::INVOKE_SUPER:
- genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kSuper, false));
+ GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kSuper, false));
break;
case Instruction::INVOKE_SUPER_RANGE:
- genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kSuper, true));
+ GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kSuper, true));
break;
case Instruction::INVOKE_INTERFACE:
- genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kInterface, false));
+ GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kInterface, false));
break;
case Instruction::INVOKE_INTERFACE_RANGE:
- genInvoke(cUnit, oatNewCallInfo(cUnit, bb, mir, kInterface, true));
+ GenInvoke(cUnit, NewMemCallInfo(cUnit, bb, mir, kInterface, true));
break;
case Instruction::NEG_INT:
case Instruction::NOT_INT:
- res = genArithOpInt(cUnit, opcode, rlDest, rlSrc[0], rlSrc[0]);
+ res = GenArithOpInt(cUnit, opcode, rlDest, rlSrc[0], rlSrc[0]);
break;
case Instruction::NEG_LONG:
case Instruction::NOT_LONG:
- res = genArithOpLong(cUnit, opcode, rlDest, rlSrc[0], rlSrc[0]);
+ res = GenArithOpLong(cUnit, opcode, rlDest, rlSrc[0], rlSrc[0]);
break;
case Instruction::NEG_FLOAT:
- res = genArithOpFloat(cUnit, opcode, rlDest, rlSrc[0], rlSrc[0]);
+ res = GenArithOpFloat(cUnit, opcode, rlDest, rlSrc[0], rlSrc[0]);
break;
case Instruction::NEG_DOUBLE:
- res = genArithOpDouble(cUnit, opcode, rlDest, rlSrc[0], rlSrc[0]);
+ res = GenArithOpDouble(cUnit, opcode, rlDest, rlSrc[0], rlSrc[0]);
break;
case Instruction::INT_TO_LONG:
- genIntToLong(cUnit, rlDest, rlSrc[0]);
+ GenIntToLong(cUnit, rlDest, rlSrc[0]);
break;
case Instruction::LONG_TO_INT:
- rlSrc[0] = oatUpdateLocWide(cUnit, rlSrc[0]);
- rlSrc[0] = oatWideToNarrow(cUnit, rlSrc[0]);
- storeValue(cUnit, rlDest, rlSrc[0]);
+ rlSrc[0] = UpdateLocWide(cUnit, rlSrc[0]);
+ rlSrc[0] = WideToNarrow(cUnit, rlSrc[0]);
+ StoreValue(cUnit, rlDest, rlSrc[0]);
break;
case Instruction::INT_TO_BYTE:
case Instruction::INT_TO_SHORT:
case Instruction::INT_TO_CHAR:
- genIntNarrowing(cUnit, opcode, rlDest, rlSrc[0]);
+ GenIntNarrowing(cUnit, opcode, rlDest, rlSrc[0]);
break;
case Instruction::INT_TO_FLOAT:
@@ -533,7 +533,7 @@
case Instruction::DOUBLE_TO_INT:
case Instruction::DOUBLE_TO_LONG:
case Instruction::DOUBLE_TO_FLOAT:
- genConversion(cUnit, opcode, rlDest, rlSrc[0]);
+ GenConversion(cUnit, opcode, rlDest, rlSrc[0]);
break;
case Instruction::ADD_INT:
@@ -558,7 +558,7 @@
case Instruction::SHL_INT_2ADDR:
case Instruction::SHR_INT_2ADDR:
case Instruction::USHR_INT_2ADDR:
- genArithOpInt(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
+ GenArithOpInt(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::ADD_LONG:
@@ -577,7 +577,7 @@
case Instruction::AND_LONG_2ADDR:
case Instruction::OR_LONG_2ADDR:
case Instruction::XOR_LONG_2ADDR:
- genArithOpLong(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
+ GenArithOpLong(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::SHL_LONG:
@@ -586,7 +586,7 @@
case Instruction::SHL_LONG_2ADDR:
case Instruction::SHR_LONG_2ADDR:
case Instruction::USHR_LONG_2ADDR:
- genShiftOpLong(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
+ GenShiftOpLong(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::ADD_FLOAT:
@@ -599,7 +599,7 @@
case Instruction::MUL_FLOAT_2ADDR:
case Instruction::DIV_FLOAT_2ADDR:
case Instruction::REM_FLOAT_2ADDR:
- genArithOpFloat(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
+ GenArithOpFloat(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::ADD_DOUBLE:
@@ -612,7 +612,7 @@
case Instruction::MUL_DOUBLE_2ADDR:
case Instruction::DIV_DOUBLE_2ADDR:
case Instruction::REM_DOUBLE_2ADDR:
- genArithOpDouble(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
+ GenArithOpDouble(cUnit, opcode, rlDest, rlSrc[0], rlSrc[1]);
break;
case Instruction::RSUB_INT:
@@ -634,7 +634,7 @@
case Instruction::SHL_INT_LIT8:
case Instruction::SHR_INT_LIT8:
case Instruction::USHR_INT_LIT8:
- genArithOpIntLit(cUnit, opcode, rlDest, rlSrc[0], vC);
+ GenArithOpIntLit(cUnit, opcode, rlDest, rlSrc[0], vC);
break;
default:
@@ -644,47 +644,47 @@
}
/* Extended MIR instructions like PHI */
-void handleExtendedMethodMIR(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir)
+void HandleExtendedMethodMIR(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir)
{
int opOffset = mir->dalvikInsn.opcode - kMirOpFirst;
char* msg = NULL;
if (cUnit->printMe) {
- msg = static_cast<char*>(oatNew(cUnit, strlen(extendedMIROpNames[opOffset]) + 1,
+ msg = static_cast<char*>(NewMem(cUnit, strlen(extendedMIROpNames[opOffset]) + 1,
false, kAllocDebugInfo));
strcpy(msg, extendedMIROpNames[opOffset]);
}
- LIR* op = newLIR1(cUnit, kPseudoExtended, reinterpret_cast<uintptr_t>(msg));
+ LIR* op = NewLIR1(cUnit, kPseudoExtended, reinterpret_cast<uintptr_t>(msg));
switch (static_cast<ExtendedMIROpcode>(mir->dalvikInsn.opcode)) {
case kMirOpPhi: {
char* ssaString = NULL;
if (cUnit->printMe) {
- ssaString = oatGetSSAString(cUnit, mir->ssaRep);
+ ssaString = GetSSAString(cUnit, mir->ssaRep);
}
op->flags.isNop = true;
- newLIR1(cUnit, kPseudoSSARep, reinterpret_cast<uintptr_t>(ssaString));
+ NewLIR1(cUnit, kPseudoSSARep, reinterpret_cast<uintptr_t>(ssaString));
break;
}
case kMirOpCopy: {
- RegLocation rlSrc = oatGetSrc(cUnit, mir, 0);
- RegLocation rlDest = oatGetDest(cUnit, mir);
- storeValue(cUnit, rlDest, rlSrc);
+ RegLocation rlSrc = GetSrc(cUnit, mir, 0);
+ RegLocation rlDest = GetDest(cUnit, mir);
+ StoreValue(cUnit, rlDest, rlSrc);
break;
}
case kMirOpFusedCmplFloat:
- genFusedFPCmpBranch(cUnit, bb, mir, false /*gt bias*/, false /*double*/);
+ GenFusedFPCmpBranch(cUnit, bb, mir, false /*gt bias*/, false /*double*/);
break;
case kMirOpFusedCmpgFloat:
- genFusedFPCmpBranch(cUnit, bb, mir, true /*gt bias*/, false /*double*/);
+ GenFusedFPCmpBranch(cUnit, bb, mir, true /*gt bias*/, false /*double*/);
break;
case kMirOpFusedCmplDouble:
- genFusedFPCmpBranch(cUnit, bb, mir, false /*gt bias*/, true /*double*/);
+ GenFusedFPCmpBranch(cUnit, bb, mir, false /*gt bias*/, true /*double*/);
break;
case kMirOpFusedCmpgDouble:
- genFusedFPCmpBranch(cUnit, bb, mir, true /*gt bias*/, true /*double*/);
+ GenFusedFPCmpBranch(cUnit, bb, mir, true /*gt bias*/, true /*double*/);
break;
case kMirOpFusedCmpLong:
- genFusedLongCmpBranch(cUnit, bb, mir);
+ GenFusedLongCmpBranch(cUnit, bb, mir);
break;
default:
break;
@@ -692,7 +692,7 @@
}
/* Handle the content in each basic block */
-bool methodBlockCodeGen(CompilationUnit* cUnit, BasicBlock* bb)
+bool MethodBlockCodeGen(CompilationUnit* cUnit, BasicBlock* bb)
{
if (bb->blockType == kDead) return false;
cUnit->currentDalvikOffset = bb->startOffset;
@@ -705,38 +705,38 @@
/* Insert the block label */
labelList[blockId].opcode = kPseudoNormalBlockLabel;
- oatAppendLIR(cUnit, &labelList[blockId]);
+ AppendLIR(cUnit, &labelList[blockId]);
LIR* headLIR = NULL;
/* If this is a catch block, export the start address */
if (bb->catchEntry) {
- headLIR = newLIR0(cUnit, kPseudoExportedPC);
+ headLIR = NewLIR0(cUnit, kPseudoExportedPC);
}
/* Free temp registers and reset redundant store tracking */
- oatResetRegPool(cUnit);
- oatResetDefTracking(cUnit);
+ ResetRegPool(cUnit);
+ ResetDefTracking(cUnit);
- oatClobberAllRegs(cUnit);
+ ClobberAllRegs(cUnit);
if (bb->blockType == kEntryBlock) {
int startVReg = cUnit->numDalvikRegisters - cUnit->numIns;
- genEntrySequence(cUnit, &cUnit->regLocation[startVReg],
+ GenEntrySequence(cUnit, &cUnit->regLocation[startVReg],
cUnit->regLocation[cUnit->methodSReg]);
} else if (bb->blockType == kExitBlock) {
- genExitSequence(cUnit);
+ GenExitSequence(cUnit);
}
for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
- oatResetRegPool(cUnit);
+ ResetRegPool(cUnit);
if (cUnit->disableOpt & (1 << kTrackLiveTemps)) {
- oatClobberAllRegs(cUnit);
+ ClobberAllRegs(cUnit);
}
if (cUnit->disableOpt & (1 << kSuppressLoads)) {
- oatResetDefTracking(cUnit);
+ ResetDefTracking(cUnit);
}
#ifndef NDEBUG
@@ -750,8 +750,8 @@
/* Mark the beginning of a Dalvik instruction for line tracking */
char* instStr = cUnit->printMe ?
- oatGetDalvikDisassembly(cUnit, mir->dalvikInsn, "") : NULL;
- boundaryLIR = markBoundary(cUnit, mir->offset, instStr);
+ GetDalvikDisassembly(cUnit, mir->dalvikInsn, "") : NULL;
+ boundaryLIR = MarkBoundary(cUnit, mir->offset, instStr);
/* Remember the first LIR for this block */
if (headLIR == NULL) {
headLIR = boundaryLIR;
@@ -761,8 +761,8 @@
/* Don't generate the SSA annotation unless verbose mode is on */
if (cUnit->printMe && mir->ssaRep) {
- char* ssaString = oatGetSSAString(cUnit, mir->ssaRep);
- newLIR1(cUnit, kPseudoSSARep, reinterpret_cast<uintptr_t>(ssaString));
+ char* ssaString = GetSSAString(cUnit, mir->ssaRep);
+ NewLIR1(cUnit, kPseudoSSARep, reinterpret_cast<uintptr_t>(ssaString));
}
if (opcode == kMirOpCheck) {
@@ -777,11 +777,11 @@
}
if (opcode >= kMirOpFirst) {
- handleExtendedMethodMIR(cUnit, bb, mir);
+ HandleExtendedMethodMIR(cUnit, bb, mir);
continue;
}
- bool notHandled = compileDalvikInstruction(cUnit, mir, bb, labelList);
+ bool notHandled = CompileDalvikInstruction(cUnit, mir, bb, labelList);
if (notHandled) {
LOG(FATAL) << StringPrintf("%#06x: Opcode %#x (%s)",
mir->offset, opcode,
@@ -794,20 +794,20 @@
* Eliminate redundant loads/stores and delay stores into later
* slots
*/
- oatApplyLocalOptimizations(cUnit, headLIR, cUnit->lastLIRInsn);
+ ApplyLocalOptimizations(cUnit, headLIR, cUnit->lastLIRInsn);
/*
* Generate an unconditional branch to the fallthrough block.
*/
if (bb->fallThrough) {
- opUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
+ OpUnconditionalBranch(cUnit, &labelList[bb->fallThrough->id]);
}
}
return false;
}
/* Set basic block labels */
-bool labelBlocks(CompilationUnit* cUnit, BasicBlock* bb)
+bool LabelBlocks(CompilationUnit* cUnit, BasicBlock* bb)
{
LIR* labelList = cUnit->blockLabelList;
int blockId = bb->id;
@@ -820,7 +820,7 @@
return false;
}
-void oatSpecialMIR2LIR(CompilationUnit* cUnit, SpecialCaseHandler specialCase)
+void SpecialMIR2LIR(CompilationUnit* cUnit, SpecialCaseHandler specialCase)
{
/* Find the first DalvikByteCode block */
int numReachableBlocks = cUnit->numReachableBlocks;
@@ -828,7 +828,7 @@
BasicBlock*bb = NULL;
for (int idx = 0; idx < numReachableBlocks; idx++) {
int dfsIndex = cUnit->dfsOrder.elemList[idx];
- bb = reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, dfsIndex));
+ bb = reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, dfsIndex));
if (bb->blockType == kDalvikByteCode) {
break;
}
@@ -843,30 +843,30 @@
MIR* mir = bb->firstMIRInsn;
/* Free temp registers and reset redundant store tracking */
- oatResetRegPool(cUnit);
- oatResetDefTracking(cUnit);
- oatClobberAllRegs(cUnit);
+ ResetRegPool(cUnit);
+ ResetDefTracking(cUnit);
+ ClobberAllRegs(cUnit);
- genSpecialCase(cUnit, bb, mir, specialCase);
+ GenSpecialCase(cUnit, bb, mir, specialCase);
}
-void oatMethodMIR2LIR(CompilationUnit* cUnit)
+void MethodMIR2LIR(CompilationUnit* cUnit)
{
/* Used to hold the labels of each block */
cUnit->blockLabelList =
- static_cast<LIR*>(oatNew(cUnit, sizeof(LIR) * cUnit->numBlocks, true, kAllocLIR));
+ static_cast<LIR*>(NewMem(cUnit, sizeof(LIR) * cUnit->numBlocks, true, kAllocLIR));
- oatDataFlowAnalysisDispatcher(cUnit, methodBlockCodeGen,
+ DataFlowAnalysisDispatcher(cUnit, MethodBlockCodeGen,
kPreOrderDFSTraversal, false /* Iterative */);
- handleSuspendLaunchpads(cUnit);
+ HandleSuspendLaunchPads(cUnit);
- handleThrowLaunchpads(cUnit);
+ HandleThrowLaunchPads(cUnit);
- handleIntrinsicLaunchpads(cUnit);
+ HandleIntrinsicLaunchPads(cUnit);
if (!(cUnit->disableOpt & (1 << kSafeOptimizations))) {
- removeRedundantBranches(cUnit);
+ RemoveRedundantBranches(cUnit);
}
}
diff --git a/src/compiler/codegen/method_codegen_driver.h b/src/compiler/codegen/method_codegen_driver.h
index dbed049..5eb9b6e 100644
--- a/src/compiler/codegen/method_codegen_driver.h
+++ b/src/compiler/codegen/method_codegen_driver.h
@@ -18,12 +18,12 @@
#define ART_SRC_COMPILER_CODEGEN_METHODCODEGENDRIVER_H_
namespace art {
-// TODO: move genInvoke to gen_invoke.cc
-void genInvoke(CompilationUnit* cUnit, CallInfo* info);
-// TODO: move genInvoke to gen_invoke.cc or utils
-CallInfo* oatNewCallInfo(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir, InvokeType type, bool isRange);
-void oatSpecialMIR2LIR(CompilationUnit* cUnit, SpecialCaseHandler specialCase);
-void oatMethodMIR2LIR(CompilationUnit* cUnit);
+// TODO: move GenInvoke to gen_invoke.cc
+void GenInvoke(CompilationUnit* cUnit, CallInfo* info);
+// TODO: move GenInvoke to gen_invoke.cc or utils
+CallInfo* NewMemCallInfo(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir, InvokeType type, bool isRange);
+void SpecialMIR2LIR(CompilationUnit* cUnit, SpecialCaseHandler specialCase);
+void MethodMIR2LIR(CompilationUnit* cUnit);
} // namespace art
diff --git a/src/compiler/codegen/mips/assemble_mips.cc b/src/compiler/codegen/mips/assemble_mips.cc
index 79259fb..889541f 100644
--- a/src/compiler/codegen/mips/assemble_mips.cc
+++ b/src/compiler/codegen/mips/assemble_mips.cc
@@ -458,7 +458,7 @@
* NOTE: An out-of-range bal isn't supported because it should
* never happen with the current PIC model.
*/
-void convertShortToLongBranch(CompilationUnit* cUnit, LIR* lir)
+void ConvertShortToLongBranch(CompilationUnit* cUnit, LIR* lir)
{
// For conditional branches we'll need to reverse the sense
bool unconditional = false;
@@ -483,27 +483,27 @@
}
LIR* hopTarget = NULL;
if (!unconditional) {
- hopTarget = rawLIR(cUnit, dalvikOffset, kPseudoTargetLabel);
- LIR* hopBranch = rawLIR(cUnit, dalvikOffset, opcode, lir->operands[0],
+ hopTarget = RawLIR(cUnit, dalvikOffset, kPseudoTargetLabel);
+ LIR* hopBranch = RawLIR(cUnit, dalvikOffset, opcode, lir->operands[0],
lir->operands[1], 0, 0, 0, hopTarget);
- oatInsertLIRBefore(lir, hopBranch);
+ InsertLIRBefore(lir, hopBranch);
}
- LIR* currPC = rawLIR(cUnit, dalvikOffset, kMipsCurrPC);
- oatInsertLIRBefore(lir, currPC);
- LIR* anchor = rawLIR(cUnit, dalvikOffset, kPseudoTargetLabel);
- LIR* deltaHi = rawLIR(cUnit, dalvikOffset, kMipsDeltaHi, r_AT, 0,
+ LIR* currPC = RawLIR(cUnit, dalvikOffset, kMipsCurrPC);
+ InsertLIRBefore(lir, currPC);
+ LIR* anchor = RawLIR(cUnit, dalvikOffset, kPseudoTargetLabel);
+ LIR* deltaHi = RawLIR(cUnit, dalvikOffset, kMipsDeltaHi, r_AT, 0,
reinterpret_cast<uintptr_t>(anchor), 0, 0, lir->target);
- oatInsertLIRBefore(lir, deltaHi);
- oatInsertLIRBefore(lir, anchor);
- LIR* deltaLo = rawLIR(cUnit, dalvikOffset, kMipsDeltaLo, r_AT, 0,
+ InsertLIRBefore(lir, deltaHi);
+ InsertLIRBefore(lir, anchor);
+ LIR* deltaLo = RawLIR(cUnit, dalvikOffset, kMipsDeltaLo, r_AT, 0,
reinterpret_cast<uintptr_t>(anchor), 0, 0, lir->target);
- oatInsertLIRBefore(lir, deltaLo);
- LIR* addu = rawLIR(cUnit, dalvikOffset, kMipsAddu, r_AT, r_AT, r_RA);
- oatInsertLIRBefore(lir, addu);
- LIR* jr = rawLIR(cUnit, dalvikOffset, kMipsJr, r_AT);
- oatInsertLIRBefore(lir, jr);
+ InsertLIRBefore(lir, deltaLo);
+ LIR* addu = RawLIR(cUnit, dalvikOffset, kMipsAddu, r_AT, r_AT, r_RA);
+ InsertLIRBefore(lir, addu);
+ LIR* jr = RawLIR(cUnit, dalvikOffset, kMipsJr, r_AT);
+ InsertLIRBefore(lir, jr);
if (!unconditional) {
- oatInsertLIRBefore(lir, hopTarget);
+ InsertLIRBefore(lir, hopTarget);
}
lir->flags.isNop = true;
}
@@ -514,7 +514,7 @@
* instruction. In those cases we will try to substitute a new code
* sequence or request that the trace be shortened and retried.
*/
-AssemblerStatus oatAssembleInstructions(CompilationUnit *cUnit,
+AssemblerStatus AssembleInstructions(CompilationUnit *cUnit,
uintptr_t startAddr)
{
LIR *lir;
@@ -552,19 +552,19 @@
} else {
// Doesn't fit - must expand to kMipsDelta[Hi|Lo] pair
LIR *newDeltaHi =
- rawLIR(cUnit, lir->dalvikOffset, kMipsDeltaHi,
+ RawLIR(cUnit, lir->dalvikOffset, kMipsDeltaHi,
lir->operands[0], 0, lir->operands[2],
lir->operands[3], 0, lir->target);
- oatInsertLIRBefore(lir, newDeltaHi);
+ InsertLIRBefore(lir, newDeltaHi);
LIR *newDeltaLo =
- rawLIR(cUnit, lir->dalvikOffset, kMipsDeltaLo,
+ RawLIR(cUnit, lir->dalvikOffset, kMipsDeltaLo,
lir->operands[0], 0, lir->operands[2],
lir->operands[3], 0, lir->target);
- oatInsertLIRBefore(lir, newDeltaLo);
+ InsertLIRBefore(lir, newDeltaLo);
LIR *newAddu =
- rawLIR(cUnit, lir->dalvikOffset, kMipsAddu,
+ RawLIR(cUnit, lir->dalvikOffset, kMipsAddu,
lir->operands[0], lir->operands[0], r_RA);
- oatInsertLIRBefore(lir, newAddu);
+ InsertLIRBefore(lir, newAddu);
lir->flags.isNop = true;
res = kRetryAll;
}
@@ -590,7 +590,7 @@
}
if (delta > 131068 || delta < -131069) {
res = kRetryAll;
- convertShortToLongBranch(cUnit, lir);
+ ConvertShortToLongBranch(cUnit, lir);
} else {
lir->operands[0] = delta >> 2;
}
@@ -604,7 +604,7 @@
}
if (delta > 131068 || delta < -131069) {
res = kRetryAll;
- convertShortToLongBranch(cUnit, lir);
+ ConvertShortToLongBranch(cUnit, lir);
} else {
lir->operands[1] = delta >> 2;
}
@@ -618,7 +618,7 @@
}
if (delta > 131068 || delta < -131069) {
res = kRetryAll;
- convertShortToLongBranch(cUnit, lir);
+ ConvertShortToLongBranch(cUnit, lir);
} else {
lir->operands[2] = delta >> 2;
}
@@ -710,7 +710,7 @@
return res;
}
-int oatGetInsnSize(LIR* lir)
+int GetInsnSize(LIR* lir)
{
return EncodingMap[lir->opcode].size;
}
@@ -718,7 +718,7 @@
* Target-dependent offset assignment.
* independent.
*/
-int oatAssignInsnOffsets(CompilationUnit* cUnit)
+int AssignInsnOffsets(CompilationUnit* cUnit)
{
LIR* mipsLIR;
int offset = 0;
diff --git a/src/compiler/codegen/mips/call_mips.cc b/src/compiler/codegen/mips/call_mips.cc
index 5049eec..33a7aed 100644
--- a/src/compiler/codegen/mips/call_mips.cc
+++ b/src/compiler/codegen/mips/call_mips.cc
@@ -23,7 +23,7 @@
namespace art {
-void genSpecialCase(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+void GenSpecialCase(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
SpecialCaseHandler specialCase)
{
// TODO
@@ -60,22 +60,22 @@
* done:
*
*/
-void genSparseSwitch(CompilationUnit* cUnit, uint32_t tableOffset,
+void GenSparseSwitch(CompilationUnit* cUnit, uint32_t tableOffset,
RegLocation rlSrc)
{
const uint16_t* table = cUnit->insns + cUnit->currentDalvikOffset + tableOffset;
if (cUnit->printMe) {
- dumpSparseSwitchTable(table);
+ DumpSparseSwitchTable(table);
}
// Add the table to the list - we'll process it later
SwitchTable *tabRec =
- static_cast<SwitchTable*>(oatNew(cUnit, sizeof(SwitchTable), true, kAllocData));
+ static_cast<SwitchTable*>(NewMem(cUnit, sizeof(SwitchTable), true, kAllocData));
tabRec->table = table;
tabRec->vaddr = cUnit->currentDalvikOffset;
int elements = table[1];
tabRec->targets =
- static_cast<LIR**>(oatNew(cUnit, elements * sizeof(LIR*), true, kAllocLIR));
- oatInsertGrowableList(cUnit, &cUnit->switchTables, reinterpret_cast<uintptr_t>(tabRec));
+ static_cast<LIR**>(NewMem(cUnit, elements * sizeof(LIR*), true, kAllocLIR));
+ InsertGrowableList(cUnit, &cUnit->switchTables, reinterpret_cast<uintptr_t>(tabRec));
// The table is composed of 8-byte key/disp pairs
int byteSize = elements * 8;
@@ -83,47 +83,47 @@
int sizeHi = byteSize >> 16;
int sizeLo = byteSize & 0xffff;
- int rEnd = oatAllocTemp(cUnit);
+ int rEnd = AllocTemp(cUnit);
if (sizeHi) {
- newLIR2(cUnit, kMipsLui, rEnd, sizeHi);
+ NewLIR2(cUnit, kMipsLui, rEnd, sizeHi);
}
// Must prevent code motion for the curr pc pair
- genBarrier(cUnit); // Scheduling barrier
- newLIR0(cUnit, kMipsCurrPC); // Really a jal to .+8
+ GenBarrier(cUnit); // Scheduling barrier
+ NewLIR0(cUnit, kMipsCurrPC); // Really a jal to .+8
// Now, fill the branch delay slot
if (sizeHi) {
- newLIR3(cUnit, kMipsOri, rEnd, rEnd, sizeLo);
+ NewLIR3(cUnit, kMipsOri, rEnd, rEnd, sizeLo);
} else {
- newLIR3(cUnit, kMipsOri, rEnd, r_ZERO, sizeLo);
+ NewLIR3(cUnit, kMipsOri, rEnd, r_ZERO, sizeLo);
}
- genBarrier(cUnit); // Scheduling barrier
+ GenBarrier(cUnit); // Scheduling barrier
// Construct BaseLabel and set up table base register
- LIR* baseLabel = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* baseLabel = NewLIR0(cUnit, kPseudoTargetLabel);
// Remember base label so offsets can be computed later
tabRec->anchor = baseLabel;
- int rBase = oatAllocTemp(cUnit);
- newLIR4(cUnit, kMipsDelta, rBase, 0, reinterpret_cast<uintptr_t>(baseLabel),
+ int rBase = AllocTemp(cUnit);
+ NewLIR4(cUnit, kMipsDelta, rBase, 0, reinterpret_cast<uintptr_t>(baseLabel),
reinterpret_cast<uintptr_t>(tabRec));
- opRegRegReg(cUnit, kOpAdd, rEnd, rEnd, rBase);
+ OpRegRegReg(cUnit, kOpAdd, rEnd, rEnd, rBase);
// Grab switch test value
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
// Test loop
- int rKey = oatAllocTemp(cUnit);
- LIR* loopLabel = newLIR0(cUnit, kPseudoTargetLabel);
- LIR* exitBranch = opCmpBranch(cUnit , kCondEq, rBase, rEnd, NULL);
- loadWordDisp(cUnit, rBase, 0, rKey);
- opRegImm(cUnit, kOpAdd, rBase, 8);
- opCmpBranch(cUnit, kCondNe, rlSrc.lowReg, rKey, loopLabel);
- int rDisp = oatAllocTemp(cUnit);
- loadWordDisp(cUnit, rBase, -4, rDisp);
- opRegRegReg(cUnit, kOpAdd, r_RA, r_RA, rDisp);
- opReg(cUnit, kOpBx, r_RA);
+ int rKey = AllocTemp(cUnit);
+ LIR* loopLabel = NewLIR0(cUnit, kPseudoTargetLabel);
+ LIR* exitBranch = OpCmpBranch(cUnit , kCondEq, rBase, rEnd, NULL);
+ LoadWordDisp(cUnit, rBase, 0, rKey);
+ OpRegImm(cUnit, kOpAdd, rBase, 8);
+ OpCmpBranch(cUnit, kCondNe, rlSrc.lowReg, rKey, loopLabel);
+ int rDisp = AllocTemp(cUnit);
+ LoadWordDisp(cUnit, rBase, -4, rDisp);
+ OpRegRegReg(cUnit, kOpAdd, r_RA, r_RA, rDisp);
+ OpReg(cUnit, kOpBx, r_RA);
// Loop exit
- LIR* exitLabel = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* exitLabel = NewLIR0(cUnit, kPseudoTargetLabel);
exitBranch->target = exitLabel;
}
@@ -140,24 +140,24 @@
* jr r_RA
* done:
*/
-void genPackedSwitch(CompilationUnit* cUnit, uint32_t tableOffset,
+void GenPackedSwitch(CompilationUnit* cUnit, uint32_t tableOffset,
RegLocation rlSrc)
{
const uint16_t* table = cUnit->insns + cUnit->currentDalvikOffset + tableOffset;
if (cUnit->printMe) {
- dumpPackedSwitchTable(table);
+ DumpPackedSwitchTable(table);
}
// Add the table to the list - we'll process it later
SwitchTable *tabRec =
- static_cast<SwitchTable*>(oatNew(cUnit, sizeof(SwitchTable), true, kAllocData));
+ static_cast<SwitchTable*>(NewMem(cUnit, sizeof(SwitchTable), true, kAllocData));
tabRec->table = table;
tabRec->vaddr = cUnit->currentDalvikOffset;
int size = table[1];
- tabRec->targets = static_cast<LIR**>(oatNew(cUnit, size * sizeof(LIR*), true, kAllocLIR));
- oatInsertGrowableList(cUnit, &cUnit->switchTables, reinterpret_cast<uintptr_t>(tabRec));
+ tabRec->targets = static_cast<LIR**>(NewMem(cUnit, size * sizeof(LIR*), true, kAllocLIR));
+ InsertGrowableList(cUnit, &cUnit->switchTables, reinterpret_cast<uintptr_t>(tabRec));
// Get the switch value
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
// Prepare the bias. If too big, handle 1st stage here
int lowKey = s4FromSwitchData(&table[2]);
@@ -166,51 +166,51 @@
if (lowKey == 0) {
rKey = rlSrc.lowReg;
} else if ((lowKey & 0xffff) != lowKey) {
- rKey = oatAllocTemp(cUnit);
- loadConstant(cUnit, rKey, lowKey);
+ rKey = AllocTemp(cUnit);
+ LoadConstant(cUnit, rKey, lowKey);
largeBias = true;
} else {
- rKey = oatAllocTemp(cUnit);
+ rKey = AllocTemp(cUnit);
}
// Must prevent code motion for the curr pc pair
- genBarrier(cUnit);
- newLIR0(cUnit, kMipsCurrPC); // Really a jal to .+8
+ GenBarrier(cUnit);
+ NewLIR0(cUnit, kMipsCurrPC); // Really a jal to .+8
// Now, fill the branch delay slot with bias strip
if (lowKey == 0) {
- newLIR0(cUnit, kMipsNop);
+ NewLIR0(cUnit, kMipsNop);
} else {
if (largeBias) {
- opRegRegReg(cUnit, kOpSub, rKey, rlSrc.lowReg, rKey);
+ OpRegRegReg(cUnit, kOpSub, rKey, rlSrc.lowReg, rKey);
} else {
- opRegRegImm(cUnit, kOpSub, rKey, rlSrc.lowReg, lowKey);
+ OpRegRegImm(cUnit, kOpSub, rKey, rlSrc.lowReg, lowKey);
}
}
- genBarrier(cUnit); // Scheduling barrier
+ GenBarrier(cUnit); // Scheduling barrier
// Construct BaseLabel and set up table base register
- LIR* baseLabel = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* baseLabel = NewLIR0(cUnit, kPseudoTargetLabel);
// Remember base label so offsets can be computed later
tabRec->anchor = baseLabel;
// Bounds check - if < 0 or >= size continue following switch
- LIR* branchOver = opCmpImmBranch(cUnit, kCondHi, rKey, size-1, NULL);
+ LIR* branchOver = OpCmpImmBranch(cUnit, kCondHi, rKey, size-1, NULL);
// Materialize the table base pointer
- int rBase = oatAllocTemp(cUnit);
- newLIR4(cUnit, kMipsDelta, rBase, 0, reinterpret_cast<uintptr_t>(baseLabel),
+ int rBase = AllocTemp(cUnit);
+ NewLIR4(cUnit, kMipsDelta, rBase, 0, reinterpret_cast<uintptr_t>(baseLabel),
reinterpret_cast<uintptr_t>(tabRec));
// Load the displacement from the switch table
- int rDisp = oatAllocTemp(cUnit);
- loadBaseIndexed(cUnit, rBase, rKey, rDisp, 2, kWord);
+ int rDisp = AllocTemp(cUnit);
+ LoadBaseIndexed(cUnit, rBase, rKey, rDisp, 2, kWord);
// Add to r_AP and go
- opRegRegReg(cUnit, kOpAdd, r_RA, r_RA, rDisp);
- opReg(cUnit, kOpBx, r_RA);
+ OpRegRegReg(cUnit, kOpAdd, r_RA, r_RA, rDisp);
+ OpReg(cUnit, kOpBx, r_RA);
/* branchOver target here */
- LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
branchOver->target = target;
}
@@ -224,96 +224,96 @@
*
* Total size is 4+(width * size + 1)/2 16-bit code units.
*/
-void genFillArrayData(CompilationUnit* cUnit, uint32_t tableOffset,
+void GenFillArrayData(CompilationUnit* cUnit, uint32_t tableOffset,
RegLocation rlSrc)
{
const uint16_t* table = cUnit->insns + cUnit->currentDalvikOffset + tableOffset;
// Add the table to the list - we'll process it later
FillArrayData *tabRec =
- reinterpret_cast<FillArrayData*>(oatNew(cUnit, sizeof(FillArrayData), true, kAllocData));
+ reinterpret_cast<FillArrayData*>(NewMem(cUnit, sizeof(FillArrayData), true, kAllocData));
tabRec->table = table;
tabRec->vaddr = cUnit->currentDalvikOffset;
uint16_t width = tabRec->table[1];
uint32_t size = tabRec->table[2] | ((static_cast<uint32_t>(tabRec->table[3])) << 16);
tabRec->size = (size * width) + 8;
- oatInsertGrowableList(cUnit, &cUnit->fillArrayData, reinterpret_cast<uintptr_t>(tabRec));
+ InsertGrowableList(cUnit, &cUnit->fillArrayData, reinterpret_cast<uintptr_t>(tabRec));
// Making a call - use explicit registers
- oatFlushAllRegs(cUnit); /* Everything to home location */
- oatLockCallTemps(cUnit);
- loadValueDirectFixed(cUnit, rlSrc, rMIPS_ARG0);
+ FlushAllRegs(cUnit); /* Everything to home location */
+ LockCallTemps(cUnit);
+ LoadValueDirectFixed(cUnit, rlSrc, rMIPS_ARG0);
// Must prevent code motion for the curr pc pair
- genBarrier(cUnit);
- newLIR0(cUnit, kMipsCurrPC); // Really a jal to .+8
+ GenBarrier(cUnit);
+ NewLIR0(cUnit, kMipsCurrPC); // Really a jal to .+8
// Now, fill the branch delay slot with the helper load
- int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pHandleFillArrayDataFromCode));
- genBarrier(cUnit); // Scheduling barrier
+ int rTgt = LoadHelper(cUnit, ENTRYPOINT_OFFSET(pHandleFillArrayDataFromCode));
+ GenBarrier(cUnit); // Scheduling barrier
// Construct BaseLabel and set up table base register
- LIR* baseLabel = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* baseLabel = NewLIR0(cUnit, kPseudoTargetLabel);
// Materialize a pointer to the fill data image
- newLIR4(cUnit, kMipsDelta, rMIPS_ARG1, 0, reinterpret_cast<uintptr_t>(baseLabel),
+ NewLIR4(cUnit, kMipsDelta, rMIPS_ARG1, 0, reinterpret_cast<uintptr_t>(baseLabel),
reinterpret_cast<uintptr_t>(tabRec));
// And go...
- oatClobberCalleeSave(cUnit);
- LIR* callInst = opReg(cUnit, kOpBlx, rTgt); // ( array*, fill_data* )
- markSafepointPC(cUnit, callInst);
+ ClobberCalleeSave(cUnit);
+ LIR* callInst = OpReg(cUnit, kOpBlx, rTgt); // ( array*, fill_data* )
+ MarkSafepointPC(cUnit, callInst);
}
/*
* TODO: implement fast path to short-circuit thin-lock case
*/
-void genMonitorEnter(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc)
+void GenMonitorEnter(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc)
{
- oatFlushAllRegs(cUnit);
- loadValueDirectFixed(cUnit, rlSrc, rMIPS_ARG0); // Get obj
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- genNullCheck(cUnit, rlSrc.sRegLow, rMIPS_ARG0, optFlags);
+ FlushAllRegs(cUnit);
+ LoadValueDirectFixed(cUnit, rlSrc, rMIPS_ARG0); // Get obj
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ GenNullCheck(cUnit, rlSrc.sRegLow, rMIPS_ARG0, optFlags);
// Go expensive route - artLockObjectFromCode(self, obj);
- int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pLockObjectFromCode));
- oatClobberCalleeSave(cUnit);
- LIR* callInst = opReg(cUnit, kOpBlx, rTgt);
- markSafepointPC(cUnit, callInst);
+ int rTgt = LoadHelper(cUnit, ENTRYPOINT_OFFSET(pLockObjectFromCode));
+ ClobberCalleeSave(cUnit);
+ LIR* callInst = OpReg(cUnit, kOpBlx, rTgt);
+ MarkSafepointPC(cUnit, callInst);
}
/*
* TODO: implement fast path to short-circuit thin-lock case
*/
-void genMonitorExit(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc)
+void GenMonitorExit(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc)
{
- oatFlushAllRegs(cUnit);
- loadValueDirectFixed(cUnit, rlSrc, rMIPS_ARG0); // Get obj
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- genNullCheck(cUnit, rlSrc.sRegLow, rMIPS_ARG0, optFlags);
+ FlushAllRegs(cUnit);
+ LoadValueDirectFixed(cUnit, rlSrc, rMIPS_ARG0); // Get obj
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ GenNullCheck(cUnit, rlSrc.sRegLow, rMIPS_ARG0, optFlags);
// Go expensive route - UnlockObjectFromCode(obj);
- int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pUnlockObjectFromCode));
- oatClobberCalleeSave(cUnit);
- LIR* callInst = opReg(cUnit, kOpBlx, rTgt);
- markSafepointPC(cUnit, callInst);
+ int rTgt = LoadHelper(cUnit, ENTRYPOINT_OFFSET(pUnlockObjectFromCode));
+ ClobberCalleeSave(cUnit);
+ LIR* callInst = OpReg(cUnit, kOpBlx, rTgt);
+ MarkSafepointPC(cUnit, callInst);
}
/*
* Mark garbage collection card. Skip if the value we're storing is null.
*/
-void markGCCard(CompilationUnit* cUnit, int valReg, int tgtAddrReg)
+void MarkGCCard(CompilationUnit* cUnit, int valReg, int tgtAddrReg)
{
- int regCardBase = oatAllocTemp(cUnit);
- int regCardNo = oatAllocTemp(cUnit);
- LIR* branchOver = opCmpImmBranch(cUnit, kCondEq, valReg, 0, NULL);
- loadWordDisp(cUnit, rMIPS_SELF, Thread::CardTableOffset().Int32Value(), regCardBase);
- opRegRegImm(cUnit, kOpLsr, regCardNo, tgtAddrReg, CardTable::kCardShift);
- storeBaseIndexed(cUnit, regCardBase, regCardNo, regCardBase, 0,
+ int regCardBase = AllocTemp(cUnit);
+ int regCardNo = AllocTemp(cUnit);
+ LIR* branchOver = OpCmpImmBranch(cUnit, kCondEq, valReg, 0, NULL);
+ LoadWordDisp(cUnit, rMIPS_SELF, Thread::CardTableOffset().Int32Value(), regCardBase);
+ OpRegRegImm(cUnit, kOpLsr, regCardNo, tgtAddrReg, CardTable::kCardShift);
+ StoreBaseIndexed(cUnit, regCardBase, regCardNo, regCardBase, 0,
kUnsignedByte);
- LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
branchOver->target = target;
- oatFreeTemp(cUnit, regCardBase);
- oatFreeTemp(cUnit, regCardNo);
+ FreeTemp(cUnit, regCardBase);
+ FreeTemp(cUnit, regCardNo);
}
-void genEntrySequence(CompilationUnit* cUnit, RegLocation* argLocs,
+void GenEntrySequence(CompilationUnit* cUnit, RegLocation* ArgLocs,
RegLocation rlMethod)
{
int spillCount = cUnit->numCoreSpills + cUnit->numFPSpills;
@@ -323,10 +323,10 @@
* expanding the frame or flushing. This leaves the utility
* code with a single temp: r12. This should be enough.
*/
- oatLockTemp(cUnit, rMIPS_ARG0);
- oatLockTemp(cUnit, rMIPS_ARG1);
- oatLockTemp(cUnit, rMIPS_ARG2);
- oatLockTemp(cUnit, rMIPS_ARG3);
+ LockTemp(cUnit, rMIPS_ARG0);
+ LockTemp(cUnit, rMIPS_ARG1);
+ LockTemp(cUnit, rMIPS_ARG2);
+ LockTemp(cUnit, rMIPS_ARG3);
/*
* We can safely skip the stack overflow check if we're
@@ -334,45 +334,45 @@
*/
bool skipOverflowCheck = ((cUnit->attrs & METHOD_IS_LEAF) &&
(static_cast<size_t>(cUnit->frameSize) < Thread::kStackOverflowReservedBytes));
- newLIR0(cUnit, kPseudoMethodEntry);
- int checkReg = oatAllocTemp(cUnit);
- int newSP = oatAllocTemp(cUnit);
+ NewLIR0(cUnit, kPseudoMethodEntry);
+ int checkReg = AllocTemp(cUnit);
+ int newSP = AllocTemp(cUnit);
if (!skipOverflowCheck) {
/* Load stack limit */
- loadWordDisp(cUnit, rMIPS_SELF, Thread::StackEndOffset().Int32Value(), checkReg);
+ LoadWordDisp(cUnit, rMIPS_SELF, Thread::StackEndOffset().Int32Value(), checkReg);
}
/* Spill core callee saves */
- spillCoreRegs(cUnit);
+ SpillCoreRegs(cUnit);
/* NOTE: promotion of FP regs currently unsupported, thus no FP spill */
DCHECK_EQ(cUnit->numFPSpills, 0);
if (!skipOverflowCheck) {
- opRegRegImm(cUnit, kOpSub, newSP, rMIPS_SP, cUnit->frameSize - (spillCount * 4));
- genRegRegCheck(cUnit, kCondCc, newSP, checkReg, kThrowStackOverflow);
- opRegCopy(cUnit, rMIPS_SP, newSP); // Establish stack
+ OpRegRegImm(cUnit, kOpSub, newSP, rMIPS_SP, cUnit->frameSize - (spillCount * 4));
+ GenRegRegCheck(cUnit, kCondCc, newSP, checkReg, kThrowStackOverflow);
+ OpRegCopy(cUnit, rMIPS_SP, newSP); // Establish stack
} else {
- opRegImm(cUnit, kOpSub, rMIPS_SP, cUnit->frameSize - (spillCount * 4));
+ OpRegImm(cUnit, kOpSub, rMIPS_SP, cUnit->frameSize - (spillCount * 4));
}
- flushIns(cUnit, argLocs, rlMethod);
+ FlushIns(cUnit, ArgLocs, rlMethod);
- oatFreeTemp(cUnit, rMIPS_ARG0);
- oatFreeTemp(cUnit, rMIPS_ARG1);
- oatFreeTemp(cUnit, rMIPS_ARG2);
- oatFreeTemp(cUnit, rMIPS_ARG3);
+ FreeTemp(cUnit, rMIPS_ARG0);
+ FreeTemp(cUnit, rMIPS_ARG1);
+ FreeTemp(cUnit, rMIPS_ARG2);
+ FreeTemp(cUnit, rMIPS_ARG3);
}
-void genExitSequence(CompilationUnit* cUnit)
+void GenExitSequence(CompilationUnit* cUnit)
{
/*
* In the exit path, rMIPS_RET0/rMIPS_RET1 are live - make sure they aren't
* allocated by the register utilities as temps.
*/
- oatLockTemp(cUnit, rMIPS_RET0);
- oatLockTemp(cUnit, rMIPS_RET1);
+ LockTemp(cUnit, rMIPS_RET0);
+ LockTemp(cUnit, rMIPS_RET1);
- newLIR0(cUnit, kPseudoMethodExit);
- unSpillCoreRegs(cUnit);
- opReg(cUnit, kOpBx, r_RA);
+ NewLIR0(cUnit, kPseudoMethodExit);
+ UnSpillCoreRegs(cUnit);
+ OpReg(cUnit, kOpBx, r_RA);
}
} // namespace art
diff --git a/src/compiler/codegen/mips/fp_mips.cc b/src/compiler/codegen/mips/fp_mips.cc
index 268a88d..942259d 100644
--- a/src/compiler/codegen/mips/fp_mips.cc
+++ b/src/compiler/codegen/mips/fp_mips.cc
@@ -21,7 +21,7 @@
namespace art {
-bool genArithOpFloat(CompilationUnit *cUnit, Instruction::Code opcode, RegLocation rlDest,
+bool GenArithOpFloat(CompilationUnit *cUnit, Instruction::Code opcode, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
#ifdef __mips_hard_float
@@ -52,24 +52,24 @@
case Instruction::REM_FLOAT_2ADDR:
case Instruction::REM_FLOAT:
case Instruction::NEG_FLOAT: {
- return genArithOpFloatPortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
+ return GenArithOpFloatPortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
}
default:
return true;
}
- rlSrc1 = loadValue(cUnit, rlSrc1, kFPReg);
- rlSrc2 = loadValue(cUnit, rlSrc2, kFPReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
- newLIR3(cUnit, op, rlResult.lowReg, rlSrc1.lowReg, rlSrc2.lowReg);
- storeValue(cUnit, rlDest, rlResult);
+ rlSrc1 = LoadValue(cUnit, rlSrc1, kFPReg);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kFPReg);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
+ NewLIR3(cUnit, op, rlResult.lowReg, rlSrc1.lowReg, rlSrc2.lowReg);
+ StoreValue(cUnit, rlDest, rlResult);
return false;
#else
- return genArithOpFloatPortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
+ return GenArithOpFloatPortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
#endif
}
-bool genArithOpDouble(CompilationUnit *cUnit, Instruction::Code opcode,
+bool GenArithOpDouble(CompilationUnit *cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2)
{
#ifdef __mips_hard_float
@@ -96,28 +96,28 @@
case Instruction::REM_DOUBLE_2ADDR:
case Instruction::REM_DOUBLE:
case Instruction::NEG_DOUBLE: {
- return genArithOpDoublePortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
+ return GenArithOpDoublePortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
}
default:
return true;
}
- rlSrc1 = loadValueWide(cUnit, rlSrc1, kFPReg);
+ rlSrc1 = LoadValueWide(cUnit, rlSrc1, kFPReg);
DCHECK(rlSrc1.wide);
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kFPReg);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kFPReg);
DCHECK(rlSrc2.wide);
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
DCHECK(rlDest.wide);
DCHECK(rlResult.wide);
- newLIR3(cUnit, op, s2d(rlResult.lowReg, rlResult.highReg), s2d(rlSrc1.lowReg, rlSrc1.highReg),
- s2d(rlSrc2.lowReg, rlSrc2.highReg));
- storeValueWide(cUnit, rlDest, rlResult);
+ NewLIR3(cUnit, op, S2d(rlResult.lowReg, rlResult.highReg), S2d(rlSrc1.lowReg, rlSrc1.highReg),
+ S2d(rlSrc2.lowReg, rlSrc2.highReg));
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
#else
- return genArithOpDoublePortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
+ return GenArithOpDoublePortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
#endif
}
-bool genConversion(CompilationUnit *cUnit, Instruction::Code opcode, RegLocation rlDest,
+bool GenConversion(CompilationUnit *cUnit, Instruction::Code opcode, RegLocation rlDest,
RegLocation rlSrc)
{
#ifdef __mips_hard_float
@@ -143,33 +143,33 @@
case Instruction::FLOAT_TO_LONG:
case Instruction::LONG_TO_FLOAT:
case Instruction::DOUBLE_TO_LONG:
- return genConversionPortable(cUnit, opcode, rlDest, rlSrc);
+ return GenConversionPortable(cUnit, opcode, rlDest, rlSrc);
default:
return true;
}
if (rlSrc.wide) {
- rlSrc = loadValueWide(cUnit, rlSrc, kFPReg);
- srcReg = s2d(rlSrc.lowReg, rlSrc.highReg);
+ rlSrc = LoadValueWide(cUnit, rlSrc, kFPReg);
+ srcReg = S2d(rlSrc.lowReg, rlSrc.highReg);
} else {
- rlSrc = loadValue(cUnit, rlSrc, kFPReg);
+ rlSrc = LoadValue(cUnit, rlSrc, kFPReg);
srcReg = rlSrc.lowReg;
}
if (rlDest.wide) {
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
- newLIR2(cUnit, op, s2d(rlResult.lowReg, rlResult.highReg), srcReg);
- storeValueWide(cUnit, rlDest, rlResult);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
+ NewLIR2(cUnit, op, S2d(rlResult.lowReg, rlResult.highReg), srcReg);
+ StoreValueWide(cUnit, rlDest, rlResult);
} else {
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
- newLIR2(cUnit, op, rlResult.lowReg, srcReg);
- storeValue(cUnit, rlDest, rlResult);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
+ NewLIR2(cUnit, op, rlResult.lowReg, srcReg);
+ StoreValue(cUnit, rlDest, rlResult);
}
return false;
#else
- return genConversionPortable(cUnit, opcode, rlDest, rlSrc);
+ return GenConversionPortable(cUnit, opcode, rlDest, rlSrc);
#endif
}
-bool genCmpFP(CompilationUnit *cUnit, Instruction::Code opcode, RegLocation rlDest,
+bool GenCmpFP(CompilationUnit *cUnit, Instruction::Code opcode, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
bool wide = true;
@@ -193,49 +193,49 @@
default:
return true;
}
- oatFlushAllRegs(cUnit);
- oatLockCallTemps(cUnit);
+ FlushAllRegs(cUnit);
+ LockCallTemps(cUnit);
if (wide) {
- loadValueDirectWideFixed(cUnit, rlSrc1, rMIPS_FARG0, rMIPS_FARG1);
- loadValueDirectWideFixed(cUnit, rlSrc2, rMIPS_FARG2, rMIPS_FARG3);
+ LoadValueDirectWideFixed(cUnit, rlSrc1, rMIPS_FARG0, rMIPS_FARG1);
+ LoadValueDirectWideFixed(cUnit, rlSrc2, rMIPS_FARG2, rMIPS_FARG3);
} else {
- loadValueDirectFixed(cUnit, rlSrc1, rMIPS_FARG0);
- loadValueDirectFixed(cUnit, rlSrc2, rMIPS_FARG2);
+ LoadValueDirectFixed(cUnit, rlSrc1, rMIPS_FARG0);
+ LoadValueDirectFixed(cUnit, rlSrc2, rMIPS_FARG2);
}
- int rTgt = loadHelper(cUnit, offset);
+ int rTgt = LoadHelper(cUnit, offset);
// NOTE: not a safepoint
- opReg(cUnit, kOpBlx, rTgt);
- RegLocation rlResult = oatGetReturn(cUnit, false);
- storeValue(cUnit, rlDest, rlResult);
+ OpReg(cUnit, kOpBlx, rTgt);
+ RegLocation rlResult = GetReturn(cUnit, false);
+ StoreValue(cUnit, rlDest, rlResult);
return false;
}
-void genFusedFPCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+void GenFusedFPCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
bool gtBias, bool isDouble)
{
UNIMPLEMENTED(FATAL) << "Need codegen for fused fp cmp branch";
}
-void genNegFloat(CompilationUnit *cUnit, RegLocation rlDest, RegLocation rlSrc)
+void GenNegFloat(CompilationUnit *cUnit, RegLocation rlDest, RegLocation rlSrc)
{
RegLocation rlResult;
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- opRegRegImm(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, 0x80000000);
- storeValue(cUnit, rlDest, rlResult);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
+ rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ OpRegRegImm(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, 0x80000000);
+ StoreValue(cUnit, rlDest, rlResult);
}
-void genNegDouble(CompilationUnit *cUnit, RegLocation rlDest, RegLocation rlSrc)
+void GenNegDouble(CompilationUnit *cUnit, RegLocation rlDest, RegLocation rlSrc)
{
RegLocation rlResult;
- rlSrc = loadValueWide(cUnit, rlSrc, kCoreReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- opRegRegImm(cUnit, kOpAdd, rlResult.highReg, rlSrc.highReg, 0x80000000);
- opRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
- storeValueWide(cUnit, rlDest, rlResult);
+ rlSrc = LoadValueWide(cUnit, rlSrc, kCoreReg);
+ rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ OpRegRegImm(cUnit, kOpAdd, rlResult.highReg, rlSrc.highReg, 0x80000000);
+ OpRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
+ StoreValueWide(cUnit, rlDest, rlResult);
}
-bool genInlinedMinMaxInt(CompilationUnit *cUnit, CallInfo* info, bool isMin)
+bool GenInlinedMinMaxInt(CompilationUnit *cUnit, CallInfo* info, bool isMin)
{
// TODO: need Mips implementation
return false;
diff --git a/src/compiler/codegen/mips/int_mips.cc b/src/compiler/codegen/mips/int_mips.cc
index 297a5d92..29b08ed 100644
--- a/src/compiler/codegen/mips/int_mips.cc
+++ b/src/compiler/codegen/mips/int_mips.cc
@@ -39,29 +39,29 @@
* finish:
*
*/
-void genCmpLong(CompilationUnit* cUnit, RegLocation rlDest,
+void GenCmpLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- rlSrc1 = loadValueWide(cUnit, rlSrc1, kCoreReg);
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kCoreReg);
- int t0 = oatAllocTemp(cUnit);
- int t1 = oatAllocTemp(cUnit);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- newLIR3(cUnit, kMipsSlt, t0, rlSrc1.highReg, rlSrc2.highReg);
- newLIR3(cUnit, kMipsSlt, t1, rlSrc2.highReg, rlSrc1.highReg);
- newLIR3(cUnit, kMipsSubu, rlResult.lowReg, t1, t0);
- LIR* branch = opCmpImmBranch(cUnit, kCondNe, rlResult.lowReg, 0, NULL);
- newLIR3(cUnit, kMipsSltu, t0, rlSrc1.lowReg, rlSrc2.lowReg);
- newLIR3(cUnit, kMipsSltu, t1, rlSrc2.lowReg, rlSrc1.lowReg);
- newLIR3(cUnit, kMipsSubu, rlResult.lowReg, t1, t0);
- oatFreeTemp(cUnit, t0);
- oatFreeTemp(cUnit, t1);
- LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
+ rlSrc1 = LoadValueWide(cUnit, rlSrc1, kCoreReg);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kCoreReg);
+ int t0 = AllocTemp(cUnit);
+ int t1 = AllocTemp(cUnit);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ NewLIR3(cUnit, kMipsSlt, t0, rlSrc1.highReg, rlSrc2.highReg);
+ NewLIR3(cUnit, kMipsSlt, t1, rlSrc2.highReg, rlSrc1.highReg);
+ NewLIR3(cUnit, kMipsSubu, rlResult.lowReg, t1, t0);
+ LIR* branch = OpCmpImmBranch(cUnit, kCondNe, rlResult.lowReg, 0, NULL);
+ NewLIR3(cUnit, kMipsSltu, t0, rlSrc1.lowReg, rlSrc2.lowReg);
+ NewLIR3(cUnit, kMipsSltu, t1, rlSrc2.lowReg, rlSrc1.lowReg);
+ NewLIR3(cUnit, kMipsSubu, rlResult.lowReg, t1, t0);
+ FreeTemp(cUnit, t0);
+ FreeTemp(cUnit, t1);
+ LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
branch->target = target;
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
}
-LIR* opCmpBranch(CompilationUnit* cUnit, ConditionCode cond, int src1,
+LIR* OpCmpBranch(CompilationUnit* cUnit, ConditionCode cond, int src1,
int src2, LIR* target)
{
LIR* branch;
@@ -114,31 +114,31 @@
return NULL;
}
if (cmpZero) {
- branch = newLIR2(cUnit, brOp, src1, src2);
+ branch = NewLIR2(cUnit, brOp, src1, src2);
} else {
- int tReg = oatAllocTemp(cUnit);
+ int tReg = AllocTemp(cUnit);
if (swapped) {
- newLIR3(cUnit, sltOp, tReg, src2, src1);
+ NewLIR3(cUnit, sltOp, tReg, src2, src1);
} else {
- newLIR3(cUnit, sltOp, tReg, src1, src2);
+ NewLIR3(cUnit, sltOp, tReg, src1, src2);
}
- branch = newLIR1(cUnit, brOp, tReg);
- oatFreeTemp(cUnit, tReg);
+ branch = NewLIR1(cUnit, brOp, tReg);
+ FreeTemp(cUnit, tReg);
}
branch->target = target;
return branch;
}
-LIR* opCmpImmBranch(CompilationUnit* cUnit, ConditionCode cond, int reg,
+LIR* OpCmpImmBranch(CompilationUnit* cUnit, ConditionCode cond, int reg,
int checkValue, LIR* target)
{
LIR* branch;
if (checkValue != 0) {
// TUNING: handle s16 & kCondLt/Mi case using slti
- int tReg = oatAllocTemp(cUnit);
- loadConstant(cUnit, tReg, checkValue);
- branch = opCmpBranch(cUnit, cond, reg, tReg, target);
- oatFreeTemp(cUnit, tReg);
+ int tReg = AllocTemp(cUnit);
+ LoadConstant(cUnit, tReg, checkValue);
+ branch = OpCmpBranch(cUnit, cond, reg, tReg, target);
+ FreeTemp(cUnit, tReg);
return branch;
}
MipsOpCode opc;
@@ -152,24 +152,24 @@
case kCondNe: opc = kMipsBnez; break;
default:
// Tuning: use slti when applicable
- int tReg = oatAllocTemp(cUnit);
- loadConstant(cUnit, tReg, checkValue);
- branch = opCmpBranch(cUnit, cond, reg, tReg, target);
- oatFreeTemp(cUnit, tReg);
+ int tReg = AllocTemp(cUnit);
+ LoadConstant(cUnit, tReg, checkValue);
+ branch = OpCmpBranch(cUnit, cond, reg, tReg, target);
+ FreeTemp(cUnit, tReg);
return branch;
}
- branch = newLIR1(cUnit, opc, reg);
+ branch = NewLIR1(cUnit, opc, reg);
branch->target = target;
return branch;
}
-LIR* opRegCopyNoInsert(CompilationUnit *cUnit, int rDest, int rSrc)
+LIR* OpRegCopyNoInsert(CompilationUnit *cUnit, int rDest, int rSrc)
{
#ifdef __mips_hard_float
if (MIPS_FPREG(rDest) || MIPS_FPREG(rSrc))
- return fpRegCopy(cUnit, rDest, rSrc);
+ return FpRegCopy(cUnit, rDest, rSrc);
#endif
- LIR* res = rawLIR(cUnit, cUnit->currentDalvikOffset, kMipsMove,
+ LIR* res = RawLIR(cUnit, cUnit->currentDalvikOffset, kMipsMove,
rDest, rSrc);
if (!(cUnit->disableOpt & (1 << kSafeOptimizations)) && rDest == rSrc) {
res->flags.isNop = true;
@@ -177,14 +177,14 @@
return res;
}
-LIR* opRegCopy(CompilationUnit *cUnit, int rDest, int rSrc)
+LIR* OpRegCopy(CompilationUnit *cUnit, int rDest, int rSrc)
{
- LIR *res = opRegCopyNoInsert(cUnit, rDest, rSrc);
- oatAppendLIR(cUnit, res);
+ LIR *res = OpRegCopyNoInsert(cUnit, rDest, rSrc);
+ AppendLIR(cUnit, res);
return res;
}
-void opRegCopyWide(CompilationUnit *cUnit, int destLo, int destHi,
+void OpRegCopyWide(CompilationUnit *cUnit, int destLo, int destHi,
int srcLo, int srcHi)
{
#ifdef __mips_hard_float
@@ -194,169 +194,169 @@
assert(MIPS_FPREG(destLo) == MIPS_FPREG(destHi));
if (destFP) {
if (srcFP) {
- opRegCopy(cUnit, s2d(destLo, destHi), s2d(srcLo, srcHi));
+ OpRegCopy(cUnit, S2d(destLo, destHi), S2d(srcLo, srcHi));
} else {
/* note the operands are swapped for the mtc1 instr */
- newLIR2(cUnit, kMipsMtc1, srcLo, destLo);
- newLIR2(cUnit, kMipsMtc1, srcHi, destHi);
+ NewLIR2(cUnit, kMipsMtc1, srcLo, destLo);
+ NewLIR2(cUnit, kMipsMtc1, srcHi, destHi);
}
} else {
if (srcFP) {
- newLIR2(cUnit, kMipsMfc1, destLo, srcLo);
- newLIR2(cUnit, kMipsMfc1, destHi, srcHi);
+ NewLIR2(cUnit, kMipsMfc1, destLo, srcLo);
+ NewLIR2(cUnit, kMipsMfc1, destHi, srcHi);
} else {
// Handle overlap
if (srcHi == destLo) {
- opRegCopy(cUnit, destHi, srcHi);
- opRegCopy(cUnit, destLo, srcLo);
+ OpRegCopy(cUnit, destHi, srcHi);
+ OpRegCopy(cUnit, destLo, srcLo);
} else {
- opRegCopy(cUnit, destLo, srcLo);
- opRegCopy(cUnit, destHi, srcHi);
+ OpRegCopy(cUnit, destLo, srcLo);
+ OpRegCopy(cUnit, destHi, srcHi);
}
}
}
#else
// Handle overlap
if (srcHi == destLo) {
- opRegCopy(cUnit, destHi, srcHi);
- opRegCopy(cUnit, destLo, srcLo);
+ OpRegCopy(cUnit, destHi, srcHi);
+ OpRegCopy(cUnit, destLo, srcLo);
} else {
- opRegCopy(cUnit, destLo, srcLo);
- opRegCopy(cUnit, destHi, srcHi);
+ OpRegCopy(cUnit, destLo, srcLo);
+ OpRegCopy(cUnit, destHi, srcHi);
}
#endif
}
-void genFusedLongCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir)
+void GenFusedLongCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir)
{
UNIMPLEMENTED(FATAL) << "Need codegen for fused long cmp branch";
}
-LIR* genRegMemCheck(CompilationUnit* cUnit, ConditionCode cCode,
+LIR* GenRegMemCheck(CompilationUnit* cUnit, ConditionCode cCode,
int reg1, int base, int offset, ThrowKind kind)
{
- LOG(FATAL) << "Unexpected use of genRegMemCheck for Arm";
+ LOG(FATAL) << "Unexpected use of GenRegMemCheck for Arm";
return NULL;
}
-RegLocation genDivRem(CompilationUnit* cUnit, RegLocation rlDest, int reg1, int reg2, bool isDiv)
+RegLocation GenDivRem(CompilationUnit* cUnit, RegLocation rlDest, int reg1, int reg2, bool isDiv)
{
- newLIR4(cUnit, kMipsDiv, r_HI, r_LO, reg1, reg2);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ NewLIR4(cUnit, kMipsDiv, r_HI, r_LO, reg1, reg2);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
if (isDiv) {
- newLIR2(cUnit, kMipsMflo, rlResult.lowReg, r_LO);
+ NewLIR2(cUnit, kMipsMflo, rlResult.lowReg, r_LO);
} else {
- newLIR2(cUnit, kMipsMfhi, rlResult.lowReg, r_HI);
+ NewLIR2(cUnit, kMipsMfhi, rlResult.lowReg, r_HI);
}
return rlResult;
}
-RegLocation genDivRemLit(CompilationUnit* cUnit, RegLocation rlDest, int reg1, int lit, bool isDiv)
+RegLocation GenDivRemLit(CompilationUnit* cUnit, RegLocation rlDest, int reg1, int lit, bool isDiv)
{
- int tReg = oatAllocTemp(cUnit);
- newLIR3(cUnit, kMipsAddiu, tReg, r_ZERO, lit);
- newLIR4(cUnit, kMipsDiv, r_HI, r_LO, reg1, tReg);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ int tReg = AllocTemp(cUnit);
+ NewLIR3(cUnit, kMipsAddiu, tReg, r_ZERO, lit);
+ NewLIR4(cUnit, kMipsDiv, r_HI, r_LO, reg1, tReg);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
if (isDiv) {
- newLIR2(cUnit, kMipsMflo, rlResult.lowReg, r_LO);
+ NewLIR2(cUnit, kMipsMflo, rlResult.lowReg, r_LO);
} else {
- newLIR2(cUnit, kMipsMfhi, rlResult.lowReg, r_HI);
+ NewLIR2(cUnit, kMipsMfhi, rlResult.lowReg, r_HI);
}
- oatFreeTemp(cUnit, tReg);
+ FreeTemp(cUnit, tReg);
return rlResult;
}
-void opLea(CompilationUnit* cUnit, int rBase, int reg1, int reg2, int scale, int offset)
+void OpLea(CompilationUnit* cUnit, int rBase, int reg1, int reg2, int scale, int offset)
{
- LOG(FATAL) << "Unexpected use of opLea for Arm";
+ LOG(FATAL) << "Unexpected use of OpLea for Arm";
}
-void opTlsCmp(CompilationUnit* cUnit, int offset, int val)
+void OpTlsCmp(CompilationUnit* cUnit, int offset, int val)
{
- LOG(FATAL) << "Unexpected use of opTlsCmp for Arm";
+ LOG(FATAL) << "Unexpected use of OpTlsCmp for Arm";
}
-bool genInlinedCas32(CompilationUnit* cUnit, CallInfo* info, bool need_write_barrier) {
+bool GenInlinedCas32(CompilationUnit* cUnit, CallInfo* info, bool need_write_barrier) {
DCHECK_NE(cUnit->instructionSet, kThumb2);
return false;
}
-bool genInlinedSqrt(CompilationUnit* cUnit, CallInfo* info) {
+bool GenInlinedSqrt(CompilationUnit* cUnit, CallInfo* info) {
DCHECK_NE(cUnit->instructionSet, kThumb2);
return false;
}
-LIR* opPcRelLoad(CompilationUnit* cUnit, int reg, LIR* target) {
- LOG(FATAL) << "Unexpected use of opPcRelLoad for Mips";
+LIR* OpPcRelLoad(CompilationUnit* cUnit, int reg, LIR* target) {
+ LOG(FATAL) << "Unexpected use of OpPcRelLoad for Mips";
return NULL;
}
-LIR* opVldm(CompilationUnit* cUnit, int rBase, int count)
+LIR* OpVldm(CompilationUnit* cUnit, int rBase, int count)
{
- LOG(FATAL) << "Unexpected use of opVldm for Mips";
+ LOG(FATAL) << "Unexpected use of OpVldm for Mips";
return NULL;
}
-LIR* opVstm(CompilationUnit* cUnit, int rBase, int count)
+LIR* OpVstm(CompilationUnit* cUnit, int rBase, int count)
{
- LOG(FATAL) << "Unexpected use of opVstm for Mips";
+ LOG(FATAL) << "Unexpected use of OpVstm for Mips";
return NULL;
}
-void genMultiplyByTwoBitMultiplier(CompilationUnit* cUnit, RegLocation rlSrc,
+void GenMultiplyByTwoBitMultiplier(CompilationUnit* cUnit, RegLocation rlSrc,
RegLocation rlResult, int lit,
int firstBit, int secondBit)
{
- int tReg = oatAllocTemp(cUnit);
- opRegRegImm(cUnit, kOpLsl, tReg, rlSrc.lowReg, secondBit - firstBit);
- opRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, tReg);
- oatFreeTemp(cUnit, tReg);
+ int tReg = AllocTemp(cUnit);
+ OpRegRegImm(cUnit, kOpLsl, tReg, rlSrc.lowReg, secondBit - firstBit);
+ OpRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, tReg);
+ FreeTemp(cUnit, tReg);
if (firstBit != 0) {
- opRegRegImm(cUnit, kOpLsl, rlResult.lowReg, rlResult.lowReg, firstBit);
+ OpRegRegImm(cUnit, kOpLsl, rlResult.lowReg, rlResult.lowReg, firstBit);
}
}
-void genDivZeroCheck(CompilationUnit* cUnit, int regLo, int regHi)
+void GenDivZeroCheck(CompilationUnit* cUnit, int regLo, int regHi)
{
- int tReg = oatAllocTemp(cUnit);
- opRegRegReg(cUnit, kOpOr, tReg, regLo, regHi);
- genImmedCheck(cUnit, kCondEq, tReg, 0, kThrowDivZero);
- oatFreeTemp(cUnit, tReg);
+ int tReg = AllocTemp(cUnit);
+ OpRegRegReg(cUnit, kOpOr, tReg, regLo, regHi);
+ GenImmedCheck(cUnit, kCondEq, tReg, 0, kThrowDivZero);
+ FreeTemp(cUnit, tReg);
}
// Test suspend flag, return target of taken suspend branch
-LIR* opTestSuspend(CompilationUnit* cUnit, LIR* target)
+LIR* OpTestSuspend(CompilationUnit* cUnit, LIR* target)
{
- opRegImm(cUnit, kOpSub, rMIPS_SUSPEND, 1);
- return opCmpImmBranch(cUnit, (target == NULL) ? kCondEq : kCondNe, rMIPS_SUSPEND, 0, target);
+ OpRegImm(cUnit, kOpSub, rMIPS_SUSPEND, 1);
+ return OpCmpImmBranch(cUnit, (target == NULL) ? kCondEq : kCondNe, rMIPS_SUSPEND, 0, target);
}
// Decrement register and branch on condition
-LIR* opDecAndBranch(CompilationUnit* cUnit, ConditionCode cCode, int reg, LIR* target)
+LIR* OpDecAndBranch(CompilationUnit* cUnit, ConditionCode cCode, int reg, LIR* target)
{
- opRegImm(cUnit, kOpSub, reg, 1);
- return opCmpImmBranch(cUnit, cCode, reg, 0, target);
+ OpRegImm(cUnit, kOpSub, reg, 1);
+ return OpCmpImmBranch(cUnit, cCode, reg, 0, target);
}
-bool smallLiteralDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode,
+bool SmallLiteralDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode,
RegLocation rlSrc, RegLocation rlDest, int lit)
{
LOG(FATAL) << "Unexpected use of smallLiteralDive in Mips";
return false;
}
-LIR* opIT(CompilationUnit* cUnit, ArmConditionCode cond, const char* guide)
+LIR* OpIT(CompilationUnit* cUnit, ArmConditionCode cond, const char* guide)
{
- LOG(FATAL) << "Unexpected use of opIT in Mips";
+ LOG(FATAL) << "Unexpected use of OpIT in Mips";
return NULL;
}
-bool genAddLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenAddLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- rlSrc1 = loadValueWide(cUnit, rlSrc1, kCoreReg);
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kCoreReg);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ rlSrc1 = LoadValueWide(cUnit, rlSrc1, kCoreReg);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kCoreReg);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
/*
* [v1 v0] = [a1 a0] + [a3 a2];
* addu v0,a2,a0
@@ -365,22 +365,22 @@
* addu v1,v1,t1
*/
- opRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc2.lowReg, rlSrc1.lowReg);
- int tReg = oatAllocTemp(cUnit);
- opRegRegReg(cUnit, kOpAdd, tReg, rlSrc2.highReg, rlSrc1.highReg);
- newLIR3(cUnit, kMipsSltu, rlResult.highReg, rlResult.lowReg, rlSrc2.lowReg);
- opRegRegReg(cUnit, kOpAdd, rlResult.highReg, rlResult.highReg, tReg);
- oatFreeTemp(cUnit, tReg);
- storeValueWide(cUnit, rlDest, rlResult);
+ OpRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc2.lowReg, rlSrc1.lowReg);
+ int tReg = AllocTemp(cUnit);
+ OpRegRegReg(cUnit, kOpAdd, tReg, rlSrc2.highReg, rlSrc1.highReg);
+ NewLIR3(cUnit, kMipsSltu, rlResult.highReg, rlResult.lowReg, rlSrc2.lowReg);
+ OpRegRegReg(cUnit, kOpAdd, rlResult.highReg, rlResult.highReg, tReg);
+ FreeTemp(cUnit, tReg);
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
-bool genSubLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenSubLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- rlSrc1 = loadValueWide(cUnit, rlSrc1, kCoreReg);
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kCoreReg);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ rlSrc1 = LoadValueWide(cUnit, rlSrc1, kCoreReg);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kCoreReg);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
/*
* [v1 v0] = [a1 a0] - [a3 a2];
* sltu t1,a0,a2
@@ -389,21 +389,21 @@
* subu v1,v1,t1
*/
- int tReg = oatAllocTemp(cUnit);
- newLIR3(cUnit, kMipsSltu, tReg, rlSrc1.lowReg, rlSrc2.lowReg);
- opRegRegReg(cUnit, kOpSub, rlResult.lowReg, rlSrc1.lowReg, rlSrc2.lowReg);
- opRegRegReg(cUnit, kOpSub, rlResult.highReg, rlSrc1.highReg, rlSrc2.highReg);
- opRegRegReg(cUnit, kOpSub, rlResult.highReg, rlResult.highReg, tReg);
- oatFreeTemp(cUnit, tReg);
- storeValueWide(cUnit, rlDest, rlResult);
+ int tReg = AllocTemp(cUnit);
+ NewLIR3(cUnit, kMipsSltu, tReg, rlSrc1.lowReg, rlSrc2.lowReg);
+ OpRegRegReg(cUnit, kOpSub, rlResult.lowReg, rlSrc1.lowReg, rlSrc2.lowReg);
+ OpRegRegReg(cUnit, kOpSub, rlResult.highReg, rlSrc1.highReg, rlSrc2.highReg);
+ OpRegRegReg(cUnit, kOpSub, rlResult.highReg, rlResult.highReg, tReg);
+ FreeTemp(cUnit, tReg);
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
-bool genNegLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenNegLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
- rlSrc = loadValueWide(cUnit, rlSrc, kCoreReg);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
+ rlSrc = LoadValueWide(cUnit, rlSrc, kCoreReg);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
/*
* [v1 v0] = -[a1 a0]
* negu v0,a0
@@ -412,34 +412,34 @@
* subu v1,v1,t1
*/
- opRegReg(cUnit, kOpNeg, rlResult.lowReg, rlSrc.lowReg);
- opRegReg(cUnit, kOpNeg, rlResult.highReg, rlSrc.highReg);
- int tReg = oatAllocTemp(cUnit);
- newLIR3(cUnit, kMipsSltu, tReg, r_ZERO, rlResult.lowReg);
- opRegRegReg(cUnit, kOpSub, rlResult.highReg, rlResult.highReg, tReg);
- oatFreeTemp(cUnit, tReg);
- storeValueWide(cUnit, rlDest, rlResult);
+ OpRegReg(cUnit, kOpNeg, rlResult.lowReg, rlSrc.lowReg);
+ OpRegReg(cUnit, kOpNeg, rlResult.highReg, rlSrc.highReg);
+ int tReg = AllocTemp(cUnit);
+ NewLIR3(cUnit, kMipsSltu, tReg, r_ZERO, rlResult.lowReg);
+ OpRegRegReg(cUnit, kOpSub, rlResult.highReg, rlResult.highReg, tReg);
+ FreeTemp(cUnit, tReg);
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
-bool genAndLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenAndLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- LOG(FATAL) << "Unexpected use of genAndLong for Mips";
+ LOG(FATAL) << "Unexpected use of GenAndLong for Mips";
return false;
}
-bool genOrLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenOrLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- LOG(FATAL) << "Unexpected use of genOrLong for Mips";
+ LOG(FATAL) << "Unexpected use of GenOrLong for Mips";
return false;
}
-bool genXorLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenXorLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- LOG(FATAL) << "Unexpected use of genXorLong for Mips";
+ LOG(FATAL) << "Unexpected use of GenXorLong for Mips";
return false;
}
diff --git a/src/compiler/codegen/mips/target_mips.cc b/src/compiler/codegen/mips/target_mips.cc
index a3621f5..3623800 100644
--- a/src/compiler/codegen/mips/target_mips.cc
+++ b/src/compiler/codegen/mips/target_mips.cc
@@ -27,43 +27,43 @@
r_T0, r_T1, r_T2, r_T3, r_T4, r_T5, r_T6, r_T7,
r_S0, r_S1, r_S2, r_S3, r_S4, r_S5, r_S6, r_S7, r_T8,
r_T9, r_K0, r_K1, r_GP, r_SP, r_FP, r_RA};
-static int reservedRegs[] = {r_ZERO, r_AT, r_S0, r_S1, r_K0, r_K1, r_GP, r_SP,
+static int ReservedRegs[] = {r_ZERO, r_AT, r_S0, r_S1, r_K0, r_K1, r_GP, r_SP,
r_RA};
static int coreTemps[] = {r_V0, r_V1, r_A0, r_A1, r_A2, r_A3, r_T0, r_T1, r_T2,
r_T3, r_T4, r_T5, r_T6, r_T7, r_T8};
#ifdef __mips_hard_float
-static int fpRegs[] = {r_F0, r_F1, r_F2, r_F3, r_F4, r_F5, r_F6, r_F7,
+static int FpRegs[] = {r_F0, r_F1, r_F2, r_F3, r_F4, r_F5, r_F6, r_F7,
r_F8, r_F9, r_F10, r_F11, r_F12, r_F13, r_F14, r_F15};
static int fpTemps[] = {r_F0, r_F1, r_F2, r_F3, r_F4, r_F5, r_F6, r_F7,
r_F8, r_F9, r_F10, r_F11, r_F12, r_F13, r_F14, r_F15};
#endif
-RegLocation locCReturn()
+RegLocation LocCReturn()
{
RegLocation res = MIPS_LOC_C_RETURN;
return res;
}
-RegLocation locCReturnWide()
+RegLocation LocCReturnWide()
{
RegLocation res = MIPS_LOC_C_RETURN_WIDE;
return res;
}
-RegLocation locCReturnFloat()
+RegLocation LocCReturnFloat()
{
RegLocation res = MIPS_LOC_C_RETURN_FLOAT;
return res;
}
-RegLocation locCReturnDouble()
+RegLocation LocCReturnDouble()
{
RegLocation res = MIPS_LOC_C_RETURN_DOUBLE;
return res;
}
// Return a target-dependent special register.
-int targetReg(SpecialTargetRegister reg) {
+int TargetReg(SpecialTargetRegister reg) {
int res = INVALID_REG;
switch (reg) {
case kSelf: res = rMIPS_SELF; break;
@@ -88,37 +88,37 @@
}
// Create a double from a pair of singles.
-int s2d(int lowReg, int highReg)
+int S2d(int lowReg, int highReg)
{
return MIPS_S2D(lowReg, highReg);
}
// Is reg a single or double?
-bool fpReg(int reg)
+bool FpReg(int reg)
{
return MIPS_FPREG(reg);
}
// Is reg a single?
-bool singleReg(int reg)
+bool SingleReg(int reg)
{
return MIPS_SINGLEREG(reg);
}
// Is reg a double?
-bool doubleReg(int reg)
+bool DoubleReg(int reg)
{
return MIPS_DOUBLEREG(reg);
}
// Return mask to strip off fp reg flags and bias.
-uint32_t fpRegMask()
+uint32_t FpRegMask()
{
return MIPS_FP_REG_MASK;
}
// True if both regs single, both core or both double.
-bool sameRegType(int reg1, int reg2)
+bool SameRegType(int reg1, int reg2)
{
return (MIPS_REGTYPE(reg1) == MIPS_REGTYPE(reg2));
}
@@ -126,7 +126,7 @@
/*
* Decode the register id.
*/
-uint64_t getRegMaskCommon(CompilationUnit* cUnit, int reg)
+uint64_t GetRegMaskCommon(CompilationUnit* cUnit, int reg)
{
uint64_t seed;
int shift;
@@ -143,13 +143,13 @@
return (seed << shift);
}
-uint64_t getPCUseDefEncoding()
+uint64_t GetPCUseDefEncoding()
{
return ENCODE_MIPS_REG_PC;
}
-void setupTargetResourceMasks(CompilationUnit* cUnit, LIR* lir)
+void SetupTargetResourceMasks(CompilationUnit* cUnit, LIR* lir)
{
DCHECK_EQ(cUnit->instructionSet, kMips);
@@ -182,7 +182,7 @@
* Interpret a format string and build a string no longer than size
* See format key in Assemble.c.
*/
-std::string buildInsnString(const char *fmt, LIR *lir, unsigned char* baseAddr)
+std::string BuildInsnString(const char *fmt, LIR *lir, unsigned char* baseAddr)
{
std::string buf;
int i;
@@ -275,7 +275,7 @@
}
// FIXME: need to redo resource maps for MIPS - fix this at that time
-void oatDumpResourceMask(LIR *mipsLIR, uint64_t mask, const char *prefix)
+void DumpResourceMask(LIR *mipsLIR, uint64_t mask, const char *prefix)
{
char buf[256];
buf[0] = 0;
@@ -326,7 +326,7 @@
* machinery is in place, always spill lr.
*/
-void oatAdjustSpillMask(CompilationUnit* cUnit)
+void AdjustSpillMask(CompilationUnit* cUnit)
{
cUnit->coreSpillMask |= (1 << r_RA);
cUnit->numCoreSpills++;
@@ -338,15 +338,15 @@
* include any holes in the mask. Associate holes with
* Dalvik register INVALID_VREG (0xFFFFU).
*/
-void oatMarkPreservedSingle(CompilationUnit* cUnit, int sReg, int reg)
+void MarkPreservedSingle(CompilationUnit* cUnit, int sReg, int reg)
{
LOG(FATAL) << "No support yet for promoted FP regs";
}
-void oatFlushRegWide(CompilationUnit* cUnit, int reg1, int reg2)
+void FlushRegWide(CompilationUnit* cUnit, int reg1, int reg2)
{
- RegisterInfo* info1 = oatGetRegInfo(cUnit, reg1);
- RegisterInfo* info2 = oatGetRegInfo(cUnit, reg2);
+ RegisterInfo* info1 = GetRegInfo(cUnit, reg1);
+ RegisterInfo* info2 = GetRegInfo(cUnit, reg2);
DCHECK(info1 && info2 && info1->pair && info2->pair &&
(info1->partner == info2->reg) &&
(info2->partner == info1->reg));
@@ -361,130 +361,117 @@
if (SRegToVReg(cUnit, info2->sReg) < SRegToVReg(cUnit, info1->sReg))
info1 = info2;
int vReg = SRegToVReg(cUnit, info1->sReg);
- storeBaseDispWide(cUnit, rMIPS_SP, oatVRegOffset(cUnit, vReg), info1->reg, info1->partner);
+ StoreBaseDispWide(cUnit, rMIPS_SP, VRegOffset(cUnit, vReg), info1->reg, info1->partner);
}
}
-void oatFlushReg(CompilationUnit* cUnit, int reg)
+void FlushReg(CompilationUnit* cUnit, int reg)
{
- RegisterInfo* info = oatGetRegInfo(cUnit, reg);
+ RegisterInfo* info = GetRegInfo(cUnit, reg);
if (info->live && info->dirty) {
info->dirty = false;
int vReg = SRegToVReg(cUnit, info->sReg);
- storeBaseDisp(cUnit, rMIPS_SP, oatVRegOffset(cUnit, vReg), reg, kWord);
+ StoreBaseDisp(cUnit, rMIPS_SP, VRegOffset(cUnit, vReg), reg, kWord);
}
}
/* Give access to the target-dependent FP register encoding to common code */
-bool oatIsFpReg(int reg) {
+bool IsFpReg(int reg) {
return MIPS_FPREG(reg);
}
-uint32_t oatFpRegMask() {
- return MIPS_FP_REG_MASK;
-}
-
/* Clobber all regs that might be used by an external C call */
-extern void oatClobberCalleeSave(CompilationUnit *cUnit)
+extern void ClobberCalleeSave(CompilationUnit *cUnit)
{
- oatClobber(cUnit, r_ZERO);
- oatClobber(cUnit, r_AT);
- oatClobber(cUnit, r_V0);
- oatClobber(cUnit, r_V1);
- oatClobber(cUnit, r_A0);
- oatClobber(cUnit, r_A1);
- oatClobber(cUnit, r_A2);
- oatClobber(cUnit, r_A3);
- oatClobber(cUnit, r_T0);
- oatClobber(cUnit, r_T1);
- oatClobber(cUnit, r_T2);
- oatClobber(cUnit, r_T3);
- oatClobber(cUnit, r_T4);
- oatClobber(cUnit, r_T5);
- oatClobber(cUnit, r_T6);
- oatClobber(cUnit, r_T7);
- oatClobber(cUnit, r_T8);
- oatClobber(cUnit, r_T9);
- oatClobber(cUnit, r_K0);
- oatClobber(cUnit, r_K1);
- oatClobber(cUnit, r_GP);
- oatClobber(cUnit, r_FP);
- oatClobber(cUnit, r_RA);
- oatClobber(cUnit, r_F0);
- oatClobber(cUnit, r_F1);
- oatClobber(cUnit, r_F2);
- oatClobber(cUnit, r_F3);
- oatClobber(cUnit, r_F4);
- oatClobber(cUnit, r_F5);
- oatClobber(cUnit, r_F6);
- oatClobber(cUnit, r_F7);
- oatClobber(cUnit, r_F8);
- oatClobber(cUnit, r_F9);
- oatClobber(cUnit, r_F10);
- oatClobber(cUnit, r_F11);
- oatClobber(cUnit, r_F12);
- oatClobber(cUnit, r_F13);
- oatClobber(cUnit, r_F14);
- oatClobber(cUnit, r_F15);
+ Clobber(cUnit, r_ZERO);
+ Clobber(cUnit, r_AT);
+ Clobber(cUnit, r_V0);
+ Clobber(cUnit, r_V1);
+ Clobber(cUnit, r_A0);
+ Clobber(cUnit, r_A1);
+ Clobber(cUnit, r_A2);
+ Clobber(cUnit, r_A3);
+ Clobber(cUnit, r_T0);
+ Clobber(cUnit, r_T1);
+ Clobber(cUnit, r_T2);
+ Clobber(cUnit, r_T3);
+ Clobber(cUnit, r_T4);
+ Clobber(cUnit, r_T5);
+ Clobber(cUnit, r_T6);
+ Clobber(cUnit, r_T7);
+ Clobber(cUnit, r_T8);
+ Clobber(cUnit, r_T9);
+ Clobber(cUnit, r_K0);
+ Clobber(cUnit, r_K1);
+ Clobber(cUnit, r_GP);
+ Clobber(cUnit, r_FP);
+ Clobber(cUnit, r_RA);
+ Clobber(cUnit, r_F0);
+ Clobber(cUnit, r_F1);
+ Clobber(cUnit, r_F2);
+ Clobber(cUnit, r_F3);
+ Clobber(cUnit, r_F4);
+ Clobber(cUnit, r_F5);
+ Clobber(cUnit, r_F6);
+ Clobber(cUnit, r_F7);
+ Clobber(cUnit, r_F8);
+ Clobber(cUnit, r_F9);
+ Clobber(cUnit, r_F10);
+ Clobber(cUnit, r_F11);
+ Clobber(cUnit, r_F12);
+ Clobber(cUnit, r_F13);
+ Clobber(cUnit, r_F14);
+ Clobber(cUnit, r_F15);
}
-extern RegLocation oatGetReturnWideAlt(CompilationUnit* cUnit)
+extern RegLocation GetReturnWideAlt(CompilationUnit* cUnit)
{
- UNIMPLEMENTED(FATAL) << "No oatGetReturnWideAlt for MIPS";
- RegLocation res = locCReturnWide();
+ UNIMPLEMENTED(FATAL) << "No GetReturnWideAlt for MIPS";
+ RegLocation res = LocCReturnWide();
return res;
}
-extern RegLocation oatGetReturnAlt(CompilationUnit* cUnit)
+extern RegLocation GetReturnAlt(CompilationUnit* cUnit)
{
- UNIMPLEMENTED(FATAL) << "No oatGetReturnAlt for MIPS";
- RegLocation res = locCReturn();
+ UNIMPLEMENTED(FATAL) << "No GetReturnAlt for MIPS";
+ RegLocation res = LocCReturn();
return res;
}
-extern RegisterInfo* oatGetRegInfo(CompilationUnit* cUnit, int reg)
+extern RegisterInfo* GetRegInfo(CompilationUnit* cUnit, int reg)
{
return MIPS_FPREG(reg) ? &cUnit->regPool->FPRegs[reg & MIPS_FP_REG_MASK]
: &cUnit->regPool->coreRegs[reg];
}
/* To be used when explicitly managing register use */
-extern void oatLockCallTemps(CompilationUnit* cUnit)
+extern void LockCallTemps(CompilationUnit* cUnit)
{
- oatLockTemp(cUnit, rMIPS_ARG0);
- oatLockTemp(cUnit, rMIPS_ARG1);
- oatLockTemp(cUnit, rMIPS_ARG2);
- oatLockTemp(cUnit, rMIPS_ARG3);
+ LockTemp(cUnit, rMIPS_ARG0);
+ LockTemp(cUnit, rMIPS_ARG1);
+ LockTemp(cUnit, rMIPS_ARG2);
+ LockTemp(cUnit, rMIPS_ARG3);
}
/* To be used when explicitly managing register use */
-extern void oatFreeCallTemps(CompilationUnit* cUnit)
+extern void FreeCallTemps(CompilationUnit* cUnit)
{
- oatFreeTemp(cUnit, rMIPS_ARG0);
- oatFreeTemp(cUnit, rMIPS_ARG1);
- oatFreeTemp(cUnit, rMIPS_ARG2);
- oatFreeTemp(cUnit, rMIPS_ARG3);
-}
-
-/*
- * Determine the initial instruction set to be used for this trace.
- * Later components may decide to change this.
- */
-InstructionSet oatInstructionSet()
-{
- return kMips;
+ FreeTemp(cUnit, rMIPS_ARG0);
+ FreeTemp(cUnit, rMIPS_ARG1);
+ FreeTemp(cUnit, rMIPS_ARG2);
+ FreeTemp(cUnit, rMIPS_ARG3);
}
/* Architecture-specific initializations and checks go here */
-bool oatArchVariantInit(void)
+bool ArchVariantInit(void)
{
return true;
}
-void oatGenMemBarrier(CompilationUnit *cUnit, MemBarrierKind barrierKind)
+void GenMemBarrier(CompilationUnit *cUnit, MemBarrierKind barrierKind)
{
#if ANDROID_SMP != 0
- newLIR1(cUnit, kMipsSync, 0 /* Only stype currently supported */);
+ NewLIR1(cUnit, kMipsSync, 0 /* Only stype currently supported */);
#endif
}
@@ -492,7 +479,7 @@
* Alloc a pair of core registers, or a double. Low reg in low byte,
* high reg in next byte.
*/
-int oatAllocTypedTempPair(CompilationUnit *cUnit, bool fpHint,
+int AllocTypedTempPair(CompilationUnit *cUnit, bool fpHint,
int regClass)
{
int highReg;
@@ -501,71 +488,71 @@
#ifdef __mips_hard_float
if (((regClass == kAnyReg) && fpHint) || (regClass == kFPReg)) {
- lowReg = oatAllocTempDouble(cUnit);
+ lowReg = AllocTempDouble(cUnit);
highReg = lowReg + 1;
res = (lowReg & 0xff) | ((highReg & 0xff) << 8);
return res;
}
#endif
- lowReg = oatAllocTemp(cUnit);
- highReg = oatAllocTemp(cUnit);
+ lowReg = AllocTemp(cUnit);
+ highReg = AllocTemp(cUnit);
res = (lowReg & 0xff) | ((highReg & 0xff) << 8);
return res;
}
-int oatAllocTypedTemp(CompilationUnit *cUnit, bool fpHint, int regClass)
+int AllocTypedTemp(CompilationUnit *cUnit, bool fpHint, int regClass)
{
#ifdef __mips_hard_float
if (((regClass == kAnyReg) && fpHint) || (regClass == kFPReg))
{
- return oatAllocTempFloat(cUnit);
+ return AllocTempFloat(cUnit);
}
#endif
- return oatAllocTemp(cUnit);
+ return AllocTemp(cUnit);
}
-void oatInitializeRegAlloc(CompilationUnit* cUnit)
+void CompilerInitializeRegAlloc(CompilationUnit* cUnit)
{
int numRegs = sizeof(coreRegs)/sizeof(*coreRegs);
- int numReserved = sizeof(reservedRegs)/sizeof(*reservedRegs);
+ int numReserved = sizeof(ReservedRegs)/sizeof(*ReservedRegs);
int numTemps = sizeof(coreTemps)/sizeof(*coreTemps);
#ifdef __mips_hard_float
- int numFPRegs = sizeof(fpRegs)/sizeof(*fpRegs);
+ int numFPRegs = sizeof(FpRegs)/sizeof(*FpRegs);
int numFPTemps = sizeof(fpTemps)/sizeof(*fpTemps);
#else
int numFPRegs = 0;
int numFPTemps = 0;
#endif
RegisterPool *pool =
- static_cast<RegisterPool*>(oatNew(cUnit, sizeof(*pool), true, kAllocRegAlloc));
+ static_cast<RegisterPool*>(NewMem(cUnit, sizeof(*pool), true, kAllocRegAlloc));
cUnit->regPool = pool;
pool->numCoreRegs = numRegs;
pool->coreRegs = static_cast<RegisterInfo*>
- (oatNew(cUnit, numRegs * sizeof(*cUnit->regPool->coreRegs), true, kAllocRegAlloc));
+ (NewMem(cUnit, numRegs * sizeof(*cUnit->regPool->coreRegs), true, kAllocRegAlloc));
pool->numFPRegs = numFPRegs;
pool->FPRegs = static_cast<RegisterInfo*>
- (oatNew(cUnit, numFPRegs * sizeof(*cUnit->regPool->FPRegs), true, kAllocRegAlloc));
- oatInitPool(pool->coreRegs, coreRegs, pool->numCoreRegs);
- oatInitPool(pool->FPRegs, fpRegs, pool->numFPRegs);
+ (NewMem(cUnit, numFPRegs * sizeof(*cUnit->regPool->FPRegs), true, kAllocRegAlloc));
+ CompilerInitPool(pool->coreRegs, coreRegs, pool->numCoreRegs);
+ CompilerInitPool(pool->FPRegs, FpRegs, pool->numFPRegs);
// Keep special registers from being allocated
for (int i = 0; i < numReserved; i++) {
- if (NO_SUSPEND && (reservedRegs[i] == rMIPS_SUSPEND)) {
+ if (NO_SUSPEND && (ReservedRegs[i] == rMIPS_SUSPEND)) {
//To measure cost of suspend check
continue;
}
- oatMarkInUse(cUnit, reservedRegs[i]);
+ MarkInUse(cUnit, ReservedRegs[i]);
}
// Mark temp regs - all others not in use can be used for promotion
for (int i = 0; i < numTemps; i++) {
- oatMarkTemp(cUnit, coreTemps[i]);
+ MarkTemp(cUnit, coreTemps[i]);
}
for (int i = 0; i < numFPTemps; i++) {
- oatMarkTemp(cUnit, fpTemps[i]);
+ MarkTemp(cUnit, fpTemps[i]);
}
// Construct the alias map.
cUnit->phiAliasMap = static_cast<int*>
- (oatNew(cUnit, cUnit->numSSARegs * sizeof(cUnit->phiAliasMap[0]), false, kAllocDFInfo));
+ (NewMem(cUnit, cUnit->numSSARegs * sizeof(cUnit->phiAliasMap[0]), false, kAllocDFInfo));
for (int i = 0; i < cUnit->numSSARegs; i++) {
cUnit->phiAliasMap[i] = i;
}
@@ -581,14 +568,14 @@
}
}
-void freeRegLocTemps(CompilationUnit* cUnit, RegLocation rlKeep,
+void FreeRegLocTemps(CompilationUnit* cUnit, RegLocation rlKeep,
RegLocation rlFree)
{
if ((rlFree.lowReg != rlKeep.lowReg) && (rlFree.lowReg != rlKeep.highReg) &&
(rlFree.highReg != rlKeep.lowReg) && (rlFree.highReg != rlKeep.highReg)) {
// No overlap, free both
- oatFreeTemp(cUnit, rlFree.lowReg);
- oatFreeTemp(cUnit, rlFree.highReg);
+ FreeTemp(cUnit, rlFree.lowReg);
+ FreeTemp(cUnit, rlFree.highReg);
}
}
/*
@@ -597,29 +584,29 @@
* ensure that all branch instructions can be restarted if
* there is a trap in the shadow. Allocate a temp register.
*/
-int loadHelper(CompilationUnit* cUnit, int offset)
+int LoadHelper(CompilationUnit* cUnit, int offset)
{
- loadWordDisp(cUnit, rMIPS_SELF, offset, r_T9);
+ LoadWordDisp(cUnit, rMIPS_SELF, offset, r_T9);
return r_T9;
}
-void spillCoreRegs(CompilationUnit* cUnit)
+void SpillCoreRegs(CompilationUnit* cUnit)
{
if (cUnit->numCoreSpills == 0) {
return;
}
uint32_t mask = cUnit->coreSpillMask;
int offset = cUnit->numCoreSpills * 4;
- opRegImm(cUnit, kOpSub, rMIPS_SP, offset);
+ OpRegImm(cUnit, kOpSub, rMIPS_SP, offset);
for (int reg = 0; mask; mask >>= 1, reg++) {
if (mask & 0x1) {
offset -= 4;
- storeWordDisp(cUnit, rMIPS_SP, offset, reg);
+ StoreWordDisp(cUnit, rMIPS_SP, offset, reg);
}
}
}
-void unSpillCoreRegs(CompilationUnit* cUnit)
+void UnSpillCoreRegs(CompilationUnit* cUnit)
{
if (cUnit->numCoreSpills == 0) {
return;
@@ -629,19 +616,19 @@
for (int reg = 0; mask; mask >>= 1, reg++) {
if (mask & 0x1) {
offset -= 4;
- loadWordDisp(cUnit, rMIPS_SP, offset, reg);
+ LoadWordDisp(cUnit, rMIPS_SP, offset, reg);
}
}
- opRegImm(cUnit, kOpAdd, rMIPS_SP, cUnit->frameSize);
+ OpRegImm(cUnit, kOpAdd, rMIPS_SP, cUnit->frameSize);
}
-bool branchUnconditional(LIR* lir)
+bool BranchUnconditional(LIR* lir)
{
return (lir->opcode == kMipsB);
}
/* Common initialization routine for an architecture family */
-bool oatArchInit()
+bool ArchInit()
{
int i;
@@ -652,20 +639,20 @@
}
}
- return oatArchVariantInit();
+ return ArchVariantInit();
}
-uint64_t getTargetInstFlags(int opcode)
+uint64_t GetTargetInstFlags(int opcode)
{
return EncodingMap[opcode].flags;
}
-const char* getTargetInstName(int opcode)
+const char* GetTargetInstName(int opcode)
{
return EncodingMap[opcode].name;
}
-const char* getTargetInstFmt(int opcode)
+const char* GetTargetInstFmt(int opcode)
{
return EncodingMap[opcode].fmt;
}
diff --git a/src/compiler/codegen/mips/utility_mips.cc b/src/compiler/codegen/mips/utility_mips.cc
index 7a018c5..011fc34 100644
--- a/src/compiler/codegen/mips/utility_mips.cc
+++ b/src/compiler/codegen/mips/utility_mips.cc
@@ -22,16 +22,16 @@
/* This file contains codegen for the MIPS32 ISA. */
-void genBarrier(CompilationUnit *cUnit);
-void loadPair(CompilationUnit *cUnit, int base, int lowReg, int highReg);
-LIR *loadWordDisp(CompilationUnit *cUnit, int rBase, int displacement,
+void GenBarrier(CompilationUnit *cUnit);
+void LoadPair(CompilationUnit *cUnit, int base, int lowReg, int highReg);
+LIR *LoadWordDisp(CompilationUnit *cUnit, int rBase, int displacement,
int rDest);
-LIR *storeWordDisp(CompilationUnit *cUnit, int rBase,
+LIR *StoreWordDisp(CompilationUnit *cUnit, int rBase,
int displacement, int rSrc);
-LIR *loadConstant(CompilationUnit *cUnit, int rDest, int value);
+LIR *LoadConstant(CompilationUnit *cUnit, int rDest, int value);
#ifdef __mips_hard_float
-LIR *fpRegCopy(CompilationUnit *cUnit, int rDest, int rSrc)
+LIR *FpRegCopy(CompilationUnit *cUnit, int rDest, int rSrc)
{
int opcode;
/* must be both DOUBLE or both not DOUBLE */
@@ -54,7 +54,7 @@
opcode = kMipsMfc1;
}
}
- LIR* res = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, rSrc, rDest);
+ LIR* res = RawLIR(cUnit, cUnit->currentDalvikOffset, opcode, rSrc, rDest);
if (!(cUnit->disableOpt & (1 << kSafeOptimizations)) && rDest == rSrc) {
res->flags.isNop = true;
}
@@ -68,10 +68,10 @@
* a high register, build constant into a low register and copy.
*
* No additional register clobbering operation performed. Use this version when
- * 1) rDest is freshly returned from oatAllocTemp or
+ * 1) rDest is freshly returned from AllocTemp or
* 2) The codegen is under fixed register usage
*/
-LIR *loadConstantNoClobber(CompilationUnit *cUnit, int rDest, int value)
+LIR *LoadConstantNoClobber(CompilationUnit *cUnit, int rDest, int value)
{
LIR *res;
@@ -80,42 +80,42 @@
int isFpReg = MIPS_FPREG(rDest);
if (isFpReg) {
DCHECK(MIPS_SINGLEREG(rDest));
- rDest = oatAllocTemp(cUnit);
+ rDest = AllocTemp(cUnit);
}
#endif
/* See if the value can be constructed cheaply */
if (value == 0) {
- res = newLIR2(cUnit, kMipsMove, rDest, r_ZERO);
+ res = NewLIR2(cUnit, kMipsMove, rDest, r_ZERO);
} else if ((value > 0) && (value <= 65535)) {
- res = newLIR3(cUnit, kMipsOri, rDest, r_ZERO, value);
+ res = NewLIR3(cUnit, kMipsOri, rDest, r_ZERO, value);
} else if ((value < 0) && (value >= -32768)) {
- res = newLIR3(cUnit, kMipsAddiu, rDest, r_ZERO, value);
+ res = NewLIR3(cUnit, kMipsAddiu, rDest, r_ZERO, value);
} else {
- res = newLIR2(cUnit, kMipsLui, rDest, value>>16);
+ res = NewLIR2(cUnit, kMipsLui, rDest, value>>16);
if (value & 0xffff)
- newLIR3(cUnit, kMipsOri, rDest, rDest, value);
+ NewLIR3(cUnit, kMipsOri, rDest, rDest, value);
}
#ifdef __mips_hard_float
if (isFpReg) {
- newLIR2(cUnit, kMipsMtc1, rDest, rDestSave);
- oatFreeTemp(cUnit, rDest);
+ NewLIR2(cUnit, kMipsMtc1, rDest, rDestSave);
+ FreeTemp(cUnit, rDest);
}
#endif
return res;
}
-LIR *opBranchUnconditional(CompilationUnit *cUnit, OpKind op)
+LIR *OpBranchUnconditional(CompilationUnit *cUnit, OpKind op)
{
DCHECK_EQ(op, kOpUncondBr);
- return newLIR1(cUnit, kMipsB, 0 /* offset to be patched */ );
+ return NewLIR1(cUnit, kMipsB, 0 /* offset to be patched */ );
}
-LIR *loadMultiple(CompilationUnit *cUnit, int rBase, int rMask);
+LIR *LoadMultiple(CompilationUnit *cUnit, int rBase, int rMask);
-LIR *opReg(CompilationUnit *cUnit, OpKind op, int rDestSrc)
+LIR *OpReg(CompilationUnit *cUnit, OpKind op, int rDestSrc)
{
MipsOpCode opcode = kMipsNop;
switch (op) {
@@ -123,17 +123,17 @@
opcode = kMipsJalr;
break;
case kOpBx:
- return newLIR1(cUnit, kMipsJr, rDestSrc);
+ return NewLIR1(cUnit, kMipsJr, rDestSrc);
break;
default:
- LOG(FATAL) << "Bad case in opReg";
+ LOG(FATAL) << "Bad case in OpReg";
}
- return newLIR2(cUnit, opcode, r_RA, rDestSrc);
+ return NewLIR2(cUnit, opcode, r_RA, rDestSrc);
}
-LIR *opRegRegImm(CompilationUnit *cUnit, OpKind op, int rDest,
+LIR *OpRegRegImm(CompilationUnit *cUnit, OpKind op, int rDest,
int rSrc1, int value);
-LIR *opRegImm(CompilationUnit *cUnit, OpKind op, int rDestSrc1,
+LIR *OpRegImm(CompilationUnit *cUnit, OpKind op, int rDestSrc1,
int value)
{
LIR *res;
@@ -143,29 +143,29 @@
MipsOpCode opcode = kMipsNop;
switch (op) {
case kOpAdd:
- return opRegRegImm(cUnit, op, rDestSrc1, rDestSrc1, value);
+ return OpRegRegImm(cUnit, op, rDestSrc1, rDestSrc1, value);
break;
case kOpSub:
- return opRegRegImm(cUnit, op, rDestSrc1, rDestSrc1, value);
+ return OpRegRegImm(cUnit, op, rDestSrc1, rDestSrc1, value);
break;
default:
- LOG(FATAL) << "Bad case in opRegImm";
+ LOG(FATAL) << "Bad case in OpRegImm";
break;
}
if (shortForm)
- res = newLIR2(cUnit, opcode, rDestSrc1, absValue);
+ res = NewLIR2(cUnit, opcode, rDestSrc1, absValue);
else {
- int rScratch = oatAllocTemp(cUnit);
- res = loadConstant(cUnit, rScratch, value);
+ int rScratch = AllocTemp(cUnit);
+ res = LoadConstant(cUnit, rScratch, value);
if (op == kOpCmp)
- newLIR2(cUnit, opcode, rDestSrc1, rScratch);
+ NewLIR2(cUnit, opcode, rDestSrc1, rScratch);
else
- newLIR3(cUnit, opcode, rDestSrc1, rDestSrc1, rScratch);
+ NewLIR3(cUnit, opcode, rDestSrc1, rDestSrc1, rScratch);
}
return res;
}
-LIR *opRegRegReg(CompilationUnit *cUnit, OpKind op, int rDest,
+LIR *OpRegRegReg(CompilationUnit *cUnit, OpKind op, int rDest,
int rSrc1, int rSrc2)
{
MipsOpCode opcode = kMipsNop;
@@ -202,13 +202,13 @@
LOG(FATAL) << "No carry bit on MIPS";
break;
default:
- LOG(FATAL) << "bad case in opRegRegReg";
+ LOG(FATAL) << "bad case in OpRegRegReg";
break;
}
- return newLIR3(cUnit, opcode, rDest, rSrc1, rSrc2);
+ return NewLIR3(cUnit, opcode, rDest, rSrc1, rSrc2);
}
-LIR *opRegRegImm(CompilationUnit *cUnit, OpKind op, int rDest,
+LIR *OpRegRegImm(CompilationUnit *cUnit, OpKind op, int rDest,
int rSrc1, int value)
{
LIR *res;
@@ -279,26 +279,26 @@
opcode = kMipsMul;
break;
default:
- LOG(FATAL) << "Bad case in opRegRegImm";
+ LOG(FATAL) << "Bad case in OpRegRegImm";
break;
}
if (shortForm)
- res = newLIR3(cUnit, opcode, rDest, rSrc1, value);
+ res = NewLIR3(cUnit, opcode, rDest, rSrc1, value);
else {
if (rDest != rSrc1) {
- res = loadConstant(cUnit, rDest, value);
- newLIR3(cUnit, opcode, rDest, rSrc1, rDest);
+ res = LoadConstant(cUnit, rDest, value);
+ NewLIR3(cUnit, opcode, rDest, rSrc1, rDest);
} else {
- int rScratch = oatAllocTemp(cUnit);
- res = loadConstant(cUnit, rScratch, value);
- newLIR3(cUnit, opcode, rDest, rSrc1, rScratch);
+ int rScratch = AllocTemp(cUnit);
+ res = LoadConstant(cUnit, rScratch, value);
+ NewLIR3(cUnit, opcode, rDest, rSrc1, rScratch);
}
}
return res;
}
-LIR *opRegReg(CompilationUnit *cUnit, OpKind op, int rDestSrc1, int rSrc2)
+LIR *OpRegReg(CompilationUnit *cUnit, OpKind op, int rDestSrc1, int rSrc2)
{
MipsOpCode opcode = kMipsNop;
LIR *res;
@@ -307,58 +307,58 @@
opcode = kMipsMove;
break;
case kOpMvn:
- return newLIR3(cUnit, kMipsNor, rDestSrc1, rSrc2, r_ZERO);
+ return NewLIR3(cUnit, kMipsNor, rDestSrc1, rSrc2, r_ZERO);
case kOpNeg:
- return newLIR3(cUnit, kMipsSubu, rDestSrc1, r_ZERO, rSrc2);
+ return NewLIR3(cUnit, kMipsSubu, rDestSrc1, r_ZERO, rSrc2);
case kOpAdd:
case kOpAnd:
case kOpMul:
case kOpOr:
case kOpSub:
case kOpXor:
- return opRegRegReg(cUnit, op, rDestSrc1, rDestSrc1, rSrc2);
+ return OpRegRegReg(cUnit, op, rDestSrc1, rDestSrc1, rSrc2);
case kOp2Byte:
#if __mips_isa_rev>=2
- res = newLIR2(cUnit, kMipsSeb, rDestSrc1, rSrc2);
+ res = NewLIR2(cUnit, kMipsSeb, rDestSrc1, rSrc2);
#else
- res = opRegRegImm(cUnit, kOpLsl, rDestSrc1, rSrc2, 24);
- opRegRegImm(cUnit, kOpAsr, rDestSrc1, rDestSrc1, 24);
+ res = OpRegRegImm(cUnit, kOpLsl, rDestSrc1, rSrc2, 24);
+ OpRegRegImm(cUnit, kOpAsr, rDestSrc1, rDestSrc1, 24);
#endif
return res;
case kOp2Short:
#if __mips_isa_rev>=2
- res = newLIR2(cUnit, kMipsSeh, rDestSrc1, rSrc2);
+ res = NewLIR2(cUnit, kMipsSeh, rDestSrc1, rSrc2);
#else
- res = opRegRegImm(cUnit, kOpLsl, rDestSrc1, rSrc2, 16);
- opRegRegImm(cUnit, kOpAsr, rDestSrc1, rDestSrc1, 16);
+ res = OpRegRegImm(cUnit, kOpLsl, rDestSrc1, rSrc2, 16);
+ OpRegRegImm(cUnit, kOpAsr, rDestSrc1, rDestSrc1, 16);
#endif
return res;
case kOp2Char:
- return newLIR3(cUnit, kMipsAndi, rDestSrc1, rSrc2, 0xFFFF);
+ return NewLIR3(cUnit, kMipsAndi, rDestSrc1, rSrc2, 0xFFFF);
default:
- LOG(FATAL) << "Bad case in opRegReg";
+ LOG(FATAL) << "Bad case in OpRegReg";
break;
}
- return newLIR2(cUnit, opcode, rDestSrc1, rSrc2);
+ return NewLIR2(cUnit, opcode, rDestSrc1, rSrc2);
}
-LIR *loadConstantValueWide(CompilationUnit *cUnit, int rDestLo,
+LIR *LoadConstantValueWide(CompilationUnit *cUnit, int rDestLo,
int rDestHi, int valLo, int valHi)
{
LIR *res;
- res = loadConstantNoClobber(cUnit, rDestLo, valLo);
- loadConstantNoClobber(cUnit, rDestHi, valHi);
+ res = LoadConstantNoClobber(cUnit, rDestLo, valLo);
+ LoadConstantNoClobber(cUnit, rDestHi, valHi);
return res;
}
/* Load value from base + scaled index. */
-LIR *loadBaseIndexed(CompilationUnit *cUnit, int rBase,
+LIR *LoadBaseIndexed(CompilationUnit *cUnit, int rBase,
int rIndex, int rDest, int scale, OpSize size)
{
LIR *first = NULL;
LIR *res;
MipsOpCode opcode = kMipsNop;
- int tReg = oatAllocTemp(cUnit);
+ int tReg = AllocTemp(cUnit);
#ifdef __mips_hard_float
if (MIPS_FPREG(rDest)) {
@@ -372,10 +372,10 @@
#endif
if (!scale) {
- first = newLIR3(cUnit, kMipsAddu, tReg , rBase, rIndex);
+ first = NewLIR3(cUnit, kMipsAddu, tReg , rBase, rIndex);
} else {
- first = opRegRegImm(cUnit, kOpLsl, tReg, rIndex, scale);
- newLIR3(cUnit, kMipsAddu, tReg , rBase, tReg);
+ first = OpRegRegImm(cUnit, kOpLsl, tReg, rIndex, scale);
+ NewLIR3(cUnit, kMipsAddu, tReg , rBase, tReg);
}
switch (size) {
@@ -400,22 +400,22 @@
opcode = kMipsLb;
break;
default:
- LOG(FATAL) << "Bad case in loadBaseIndexed";
+ LOG(FATAL) << "Bad case in LoadBaseIndexed";
}
- res = newLIR3(cUnit, opcode, rDest, 0, tReg);
- oatFreeTemp(cUnit, tReg);
+ res = NewLIR3(cUnit, opcode, rDest, 0, tReg);
+ FreeTemp(cUnit, tReg);
return (first) ? first : res;
}
/* store value base base + scaled index. */
-LIR *storeBaseIndexed(CompilationUnit *cUnit, int rBase,
+LIR *StoreBaseIndexed(CompilationUnit *cUnit, int rBase,
int rIndex, int rSrc, int scale, OpSize size)
{
LIR *first = NULL;
MipsOpCode opcode = kMipsNop;
int rNewIndex = rIndex;
- int tReg = oatAllocTemp(cUnit);
+ int tReg = AllocTemp(cUnit);
#ifdef __mips_hard_float
if (MIPS_FPREG(rSrc)) {
@@ -429,10 +429,10 @@
#endif
if (!scale) {
- first = newLIR3(cUnit, kMipsAddu, tReg , rBase, rIndex);
+ first = NewLIR3(cUnit, kMipsAddu, tReg , rBase, rIndex);
} else {
- first = opRegRegImm(cUnit, kOpLsl, tReg, rIndex, scale);
- newLIR3(cUnit, kMipsAddu, tReg , rBase, tReg);
+ first = OpRegRegImm(cUnit, kOpLsl, tReg, rIndex, scale);
+ NewLIR3(cUnit, kMipsAddu, tReg , rBase, tReg);
}
switch (size) {
@@ -453,58 +453,58 @@
opcode = kMipsSb;
break;
default:
- LOG(FATAL) << "Bad case in storeBaseIndexed";
+ LOG(FATAL) << "Bad case in StoreBaseIndexed";
}
- newLIR3(cUnit, opcode, rSrc, 0, tReg);
- oatFreeTemp(cUnit, rNewIndex);
+ NewLIR3(cUnit, opcode, rSrc, 0, tReg);
+ FreeTemp(cUnit, rNewIndex);
return first;
}
-LIR *loadMultiple(CompilationUnit *cUnit, int rBase, int rMask)
+LIR *LoadMultiple(CompilationUnit *cUnit, int rBase, int rMask)
{
int i;
int loadCnt = 0;
LIR *res = NULL ;
- genBarrier(cUnit);
+ GenBarrier(cUnit);
for (i = 0; i < 8; i++, rMask >>= 1) {
if (rMask & 0x1) { /* map r0 to MIPS r_A0 */
- newLIR3(cUnit, kMipsLw, i+r_A0, loadCnt*4, rBase);
+ NewLIR3(cUnit, kMipsLw, i+r_A0, loadCnt*4, rBase);
loadCnt++;
}
}
if (loadCnt) {/* increment after */
- newLIR3(cUnit, kMipsAddiu, rBase, rBase, loadCnt*4);
+ NewLIR3(cUnit, kMipsAddiu, rBase, rBase, loadCnt*4);
}
- genBarrier(cUnit);
+ GenBarrier(cUnit);
return res; /* NULL always returned which should be ok since no callers use it */
}
-LIR *storeMultiple(CompilationUnit *cUnit, int rBase, int rMask)
+LIR *StoreMultiple(CompilationUnit *cUnit, int rBase, int rMask)
{
int i;
int storeCnt = 0;
LIR *res = NULL ;
- genBarrier(cUnit);
+ GenBarrier(cUnit);
for (i = 0; i < 8; i++, rMask >>= 1) {
if (rMask & 0x1) { /* map r0 to MIPS r_A0 */
- newLIR3(cUnit, kMipsSw, i+r_A0, storeCnt*4, rBase);
+ NewLIR3(cUnit, kMipsSw, i+r_A0, storeCnt*4, rBase);
storeCnt++;
}
}
if (storeCnt) { /* increment after */
- newLIR3(cUnit, kMipsAddiu, rBase, rBase, storeCnt*4);
+ NewLIR3(cUnit, kMipsAddiu, rBase, rBase, storeCnt*4);
}
- genBarrier(cUnit);
+ GenBarrier(cUnit);
return res; /* NULL always returned which should be ok since no callers use it */
}
-LIR *loadBaseDispBody(CompilationUnit *cUnit, int rBase,
+LIR *LoadBaseDispBody(CompilationUnit *cUnit, int rBase,
int displacement, int rDest, int rDestHi,
OpSize size, int sReg)
/*
@@ -569,61 +569,61 @@
opcode = kMipsLb;
break;
default:
- LOG(FATAL) << "Bad case in loadBaseIndexedBody";
+ LOG(FATAL) << "Bad case in LoadBaseIndexedBody";
}
if (shortForm) {
if (!pair) {
- load = res = newLIR3(cUnit, opcode, rDest, displacement, rBase);
+ load = res = NewLIR3(cUnit, opcode, rDest, displacement, rBase);
} else {
- load = res = newLIR3(cUnit, opcode, rDest,
+ load = res = NewLIR3(cUnit, opcode, rDest,
displacement + LOWORD_OFFSET, rBase);
- load2 = newLIR3(cUnit, opcode, rDestHi,
+ load2 = NewLIR3(cUnit, opcode, rDestHi,
displacement + HIWORD_OFFSET, rBase);
}
} else {
if (pair) {
- int rTmp = oatAllocFreeTemp(cUnit);
- res = opRegRegImm(cUnit, kOpAdd, rTmp, rBase, displacement);
- load = newLIR3(cUnit, opcode, rDest, LOWORD_OFFSET, rTmp);
- load2 = newLIR3(cUnit, opcode, rDestHi, HIWORD_OFFSET, rTmp);
- oatFreeTemp(cUnit, rTmp);
+ int rTmp = AllocFreeTemp(cUnit);
+ res = OpRegRegImm(cUnit, kOpAdd, rTmp, rBase, displacement);
+ load = NewLIR3(cUnit, opcode, rDest, LOWORD_OFFSET, rTmp);
+ load2 = NewLIR3(cUnit, opcode, rDestHi, HIWORD_OFFSET, rTmp);
+ FreeTemp(cUnit, rTmp);
} else {
- int rTmp = (rBase == rDest) ? oatAllocFreeTemp(cUnit) : rDest;
- res = opRegRegImm(cUnit, kOpAdd, rTmp, rBase, displacement);
- load = newLIR3(cUnit, opcode, rDest, 0, rTmp);
+ int rTmp = (rBase == rDest) ? AllocFreeTemp(cUnit) : rDest;
+ res = OpRegRegImm(cUnit, kOpAdd, rTmp, rBase, displacement);
+ load = NewLIR3(cUnit, opcode, rDest, 0, rTmp);
if (rTmp != rDest)
- oatFreeTemp(cUnit, rTmp);
+ FreeTemp(cUnit, rTmp);
}
}
if (rBase == rMIPS_SP) {
- annotateDalvikRegAccess(load,
+ AnnotateDalvikRegAccess(load,
(displacement + (pair ? LOWORD_OFFSET : 0)) >> 2,
true /* isLoad */, pair /* is64bit */);
if (pair) {
- annotateDalvikRegAccess(load2, (displacement + HIWORD_OFFSET) >> 2,
+ AnnotateDalvikRegAccess(load2, (displacement + HIWORD_OFFSET) >> 2,
true /* isLoad */, pair /* is64bit */);
}
}
return load;
}
-LIR *loadBaseDisp(CompilationUnit *cUnit, int rBase,
+LIR *LoadBaseDisp(CompilationUnit *cUnit, int rBase,
int displacement, int rDest, OpSize size, int sReg)
{
- return loadBaseDispBody(cUnit, rBase, displacement, rDest, -1,
+ return LoadBaseDispBody(cUnit, rBase, displacement, rDest, -1,
size, sReg);
}
-LIR *loadBaseDispWide(CompilationUnit *cUnit, int rBase,
+LIR *LoadBaseDispWide(CompilationUnit *cUnit, int rBase,
int displacement, int rDestLo, int rDestHi, int sReg)
{
- return loadBaseDispBody(cUnit, rBase, displacement, rDestLo, rDestHi,
+ return LoadBaseDispBody(cUnit, rBase, displacement, rDestLo, rDestHi,
kLong, sReg);
}
-LIR *storeBaseDispBody(CompilationUnit *cUnit, int rBase,
+LIR *StoreBaseDispBody(CompilationUnit *cUnit, int rBase,
int displacement, int rSrc, int rSrcHi, OpSize size)
{
LIR *res;
@@ -674,35 +674,35 @@
opcode = kMipsSb;
break;
default:
- LOG(FATAL) << "Bad case in storeBaseIndexedBody";
+ LOG(FATAL) << "Bad case in StoreBaseIndexedBody";
}
if (shortForm) {
if (!pair) {
- store = res = newLIR3(cUnit, opcode, rSrc, displacement, rBase);
+ store = res = NewLIR3(cUnit, opcode, rSrc, displacement, rBase);
} else {
- store = res = newLIR3(cUnit, opcode, rSrc, displacement + LOWORD_OFFSET,
+ store = res = NewLIR3(cUnit, opcode, rSrc, displacement + LOWORD_OFFSET,
rBase);
- store2 = newLIR3(cUnit, opcode, rSrcHi, displacement + HIWORD_OFFSET,
+ store2 = NewLIR3(cUnit, opcode, rSrcHi, displacement + HIWORD_OFFSET,
rBase);
}
} else {
- int rScratch = oatAllocTemp(cUnit);
- res = opRegRegImm(cUnit, kOpAdd, rScratch, rBase, displacement);
+ int rScratch = AllocTemp(cUnit);
+ res = OpRegRegImm(cUnit, kOpAdd, rScratch, rBase, displacement);
if (!pair) {
- store = newLIR3(cUnit, opcode, rSrc, 0, rScratch);
+ store = NewLIR3(cUnit, opcode, rSrc, 0, rScratch);
} else {
- store = newLIR3(cUnit, opcode, rSrc, LOWORD_OFFSET, rScratch);
- store2 = newLIR3(cUnit, opcode, rSrcHi, HIWORD_OFFSET, rScratch);
+ store = NewLIR3(cUnit, opcode, rSrc, LOWORD_OFFSET, rScratch);
+ store2 = NewLIR3(cUnit, opcode, rSrcHi, HIWORD_OFFSET, rScratch);
}
- oatFreeTemp(cUnit, rScratch);
+ FreeTemp(cUnit, rScratch);
}
if (rBase == rMIPS_SP) {
- annotateDalvikRegAccess(store, (displacement + (pair ? LOWORD_OFFSET : 0))
+ AnnotateDalvikRegAccess(store, (displacement + (pair ? LOWORD_OFFSET : 0))
>> 2, false /* isLoad */, pair /* is64bit */);
if (pair) {
- annotateDalvikRegAccess(store2, (displacement + HIWORD_OFFSET) >> 2,
+ AnnotateDalvikRegAccess(store2, (displacement + HIWORD_OFFSET) >> 2,
false /* isLoad */, pair /* is64bit */);
}
}
@@ -710,64 +710,64 @@
return res;
}
-LIR *storeBaseDisp(CompilationUnit *cUnit, int rBase,
+LIR *StoreBaseDisp(CompilationUnit *cUnit, int rBase,
int displacement, int rSrc, OpSize size)
{
- return storeBaseDispBody(cUnit, rBase, displacement, rSrc, -1, size);
+ return StoreBaseDispBody(cUnit, rBase, displacement, rSrc, -1, size);
}
-LIR *storeBaseDispWide(CompilationUnit *cUnit, int rBase,
+LIR *StoreBaseDispWide(CompilationUnit *cUnit, int rBase,
int displacement, int rSrcLo, int rSrcHi)
{
- return storeBaseDispBody(cUnit, rBase, displacement, rSrcLo, rSrcHi, kLong);
+ return StoreBaseDispBody(cUnit, rBase, displacement, rSrcLo, rSrcHi, kLong);
}
-void loadPair(CompilationUnit *cUnit, int base, int lowReg, int highReg)
+void LoadPair(CompilationUnit *cUnit, int base, int lowReg, int highReg)
{
- loadWordDisp(cUnit, base, LOWORD_OFFSET , lowReg);
- loadWordDisp(cUnit, base, HIWORD_OFFSET , highReg);
+ LoadWordDisp(cUnit, base, LOWORD_OFFSET , lowReg);
+ LoadWordDisp(cUnit, base, HIWORD_OFFSET , highReg);
}
-LIR* opThreadMem(CompilationUnit* cUnit, OpKind op, int threadOffset)
+LIR* OpThreadMem(CompilationUnit* cUnit, OpKind op, int threadOffset)
{
- LOG(FATAL) << "Unexpected use of opThreadMem for MIPS";
+ LOG(FATAL) << "Unexpected use of OpThreadMem for MIPS";
return NULL;
}
-LIR* opMem(CompilationUnit* cUnit, OpKind op, int rBase, int disp)
+LIR* OpMem(CompilationUnit* cUnit, OpKind op, int rBase, int disp)
{
- LOG(FATAL) << "Unexpected use of opMem for MIPS";
+ LOG(FATAL) << "Unexpected use of OpMem for MIPS";
return NULL;
}
-LIR* storeBaseIndexedDisp(CompilationUnit *cUnit,
+LIR* StoreBaseIndexedDisp(CompilationUnit *cUnit,
int rBase, int rIndex, int scale, int displacement,
int rSrc, int rSrcHi,
OpSize size, int sReg)
{
- LOG(FATAL) << "Unexpected use of storeBaseIndexedDisp for MIPS";
+ LOG(FATAL) << "Unexpected use of StoreBaseIndexedDisp for MIPS";
return NULL;
}
-LIR* opRegMem(CompilationUnit *cUnit, OpKind op, int rDest, int rBase,
+LIR* OpRegMem(CompilationUnit *cUnit, OpKind op, int rDest, int rBase,
int offset)
{
- LOG(FATAL) << "Unexpected use of opRegMem for MIPS";
+ LOG(FATAL) << "Unexpected use of OpRegMem for MIPS";
return NULL;
}
-LIR* loadBaseIndexedDisp(CompilationUnit *cUnit,
+LIR* LoadBaseIndexedDisp(CompilationUnit *cUnit,
int rBase, int rIndex, int scale, int displacement,
int rDest, int rDestHi,
OpSize size, int sReg)
{
- LOG(FATAL) << "Unexpected use of loadBaseIndexedDisp for MIPS";
+ LOG(FATAL) << "Unexpected use of LoadBaseIndexedDisp for MIPS";
return NULL;
}
-LIR* opCondBranch(CompilationUnit* cUnit, ConditionCode cc, LIR* target)
+LIR* OpCondBranch(CompilationUnit* cUnit, ConditionCode cc, LIR* target)
{
- LOG(FATAL) << "Unexpected use of opCondBranch for MIPS";
+ LOG(FATAL) << "Unexpected use of OpCondBranch for MIPS";
return NULL;
}
diff --git a/src/compiler/codegen/ralloc_util.cc b/src/compiler/codegen/ralloc_util.cc
index efdbd32..2a4880a 100644
--- a/src/compiler/codegen/ralloc_util.cc
+++ b/src/compiler/codegen/ralloc_util.cc
@@ -29,7 +29,7 @@
* not affect the "liveness" of a temp register, which will stay
* live until it is either explicitly killed or reallocated.
*/
-extern void oatResetRegPool(CompilationUnit* cUnit)
+extern void ResetRegPool(CompilationUnit* cUnit)
{
int i;
for (i=0; i < cUnit->regPool->numCoreRegs; i++) {
@@ -46,7 +46,7 @@
* Set up temp & preserved register pools specialized by target.
* Note: numRegs may be zero.
*/
-extern void oatInitPool(RegisterInfo* regs, int* regNums, int num)
+extern void CompilerInitPool(RegisterInfo* regs, int* regNums, int num)
{
int i;
for (i=0; i < num; i++) {
@@ -60,7 +60,7 @@
}
}
-void dumpRegPool(RegisterInfo* p, int numRegs)
+void DumpRegPool(RegisterInfo* p, int numRegs)
{
LOG(INFO) << "================================================";
for (int i = 0; i < numRegs; i++) {
@@ -73,18 +73,18 @@
LOG(INFO) << "================================================";
}
-void oatDumpCoreRegPool(CompilationUnit* cUnit)
+void DumpCoreRegPool(CompilationUnit* cUnit)
{
- dumpRegPool(cUnit->regPool->coreRegs, cUnit->regPool->numCoreRegs);
+ DumpRegPool(cUnit->regPool->coreRegs, cUnit->regPool->numCoreRegs);
}
-void oatDumpFpRegPool(CompilationUnit* cUnit)
+void DumpFpRegPool(CompilationUnit* cUnit)
{
- dumpRegPool(cUnit->regPool->FPRegs, cUnit->regPool->numFPRegs);
+ DumpRegPool(cUnit->regPool->FPRegs, cUnit->regPool->numFPRegs);
}
/* Mark a temp register as dead. Does not affect allocation state. */
-static inline void clobberBody(CompilationUnit *cUnit, RegisterInfo* p)
+static inline void ClobberBody(CompilationUnit *cUnit, RegisterInfo* p)
{
if (p->isTemp) {
DCHECK(!(p->live && p->dirty)) << "Live & dirty temp in clobber";
@@ -94,18 +94,18 @@
p->defEnd = NULL;
if (p->pair) {
p->pair = false;
- oatClobber(cUnit, p->partner);
+ Clobber(cUnit, p->partner);
}
}
}
/* Mark a temp register as dead. Does not affect allocation state. */
-void oatClobber(CompilationUnit* cUnit, int reg)
+void Clobber(CompilationUnit* cUnit, int reg)
{
- clobberBody(cUnit, oatGetRegInfo(cUnit, reg));
+ ClobberBody(cUnit, GetRegInfo(cUnit, reg));
}
-void clobberSRegBody(RegisterInfo* p, int numRegs, int sReg)
+void ClobberSRegBody(RegisterInfo* p, int numRegs, int sReg)
{
int i;
for (i=0; i< numRegs; i++) {
@@ -120,7 +120,7 @@
}
/* Clobber any temp associated with an sReg. Could be in either class */
-extern void oatClobberSReg(CompilationUnit* cUnit, int sReg)
+extern void ClobberSReg(CompilationUnit* cUnit, int sReg)
{
#ifndef NDEBUG
/* Reset live temp tracking sanity checker */
@@ -128,8 +128,8 @@
cUnit->liveSReg = INVALID_SREG;
}
#endif
- clobberSRegBody(cUnit->regPool->coreRegs, cUnit->regPool->numCoreRegs, sReg);
- clobberSRegBody(cUnit->regPool->FPRegs, cUnit->regPool->numFPRegs, sReg);
+ ClobberSRegBody(cUnit->regPool->coreRegs, cUnit->regPool->numCoreRegs, sReg);
+ ClobberSRegBody(cUnit->regPool->FPRegs, cUnit->regPool->numFPRegs, sReg);
}
/*
@@ -156,11 +156,11 @@
}
}
-void oatRecordCorePromotion(CompilationUnit* cUnit, int reg, int sReg)
+void RecordCorePromotion(CompilationUnit* cUnit, int reg, int sReg)
{
int pMapIdx = SRegToPMap(cUnit, sReg);
int vReg = SRegToVReg(cUnit, sReg);
- oatGetRegInfo(cUnit, reg)->inUse = true;
+ GetRegInfo(cUnit, reg)->inUse = true;
cUnit->coreSpillMask |= (1 << reg);
// Include reg for later sort
cUnit->coreVmapTable.push_back(reg << VREG_NUM_WIDTH |
@@ -171,28 +171,28 @@
}
/* Reserve a callee-save register. Return -1 if none available */
-extern int oatAllocPreservedCoreReg(CompilationUnit* cUnit, int sReg)
+extern int AllocPreservedCoreReg(CompilationUnit* cUnit, int sReg)
{
int res = -1;
RegisterInfo* coreRegs = cUnit->regPool->coreRegs;
for (int i = 0; i < cUnit->regPool->numCoreRegs; i++) {
if (!coreRegs[i].isTemp && !coreRegs[i].inUse) {
res = coreRegs[i].reg;
- oatRecordCorePromotion(cUnit, res, sReg);
+ RecordCorePromotion(cUnit, res, sReg);
break;
}
}
return res;
}
-void oatRecordFpPromotion(CompilationUnit* cUnit, int reg, int sReg)
+void RecordFpPromotion(CompilationUnit* cUnit, int reg, int sReg)
{
int pMapIdx = SRegToPMap(cUnit, sReg);
int vReg = SRegToVReg(cUnit, sReg);
- oatGetRegInfo(cUnit, reg)->inUse = true;
- oatMarkPreservedSingle(cUnit, vReg, reg);
+ GetRegInfo(cUnit, reg)->inUse = true;
+ MarkPreservedSingle(cUnit, vReg, reg);
cUnit->promotionMap[pMapIdx].fpLocation = kLocPhysReg;
- cUnit->promotionMap[pMapIdx].fpReg = reg;
+ cUnit->promotionMap[pMapIdx].FpReg = reg;
}
/*
@@ -200,7 +200,7 @@
* even/odd allocation, but go ahead and allocate anything if not
* available. If nothing's available, return -1.
*/
-int allocPreservedSingle(CompilationUnit* cUnit, int sReg, bool even)
+int AllocPreservedSingle(CompilationUnit* cUnit, int sReg, bool even)
{
int res = -1;
RegisterInfo* FPRegs = cUnit->regPool->FPRegs;
@@ -208,7 +208,7 @@
if (!FPRegs[i].isTemp && !FPRegs[i].inUse &&
((FPRegs[i].reg & 0x1) == 0) == even) {
res = FPRegs[i].reg;
- oatRecordFpPromotion(cUnit, res, sReg);
+ RecordFpPromotion(cUnit, res, sReg);
break;
}
}
@@ -223,20 +223,20 @@
* allocate if we can't meet the requirements for the pair of
* sReg<=sX[even] & (sReg+1)<= sX+1.
*/
-int allocPreservedDouble(CompilationUnit* cUnit, int sReg)
+int AllocPreservedDouble(CompilationUnit* cUnit, int sReg)
{
int res = -1; // Assume failure
int vReg = SRegToVReg(cUnit, sReg);
int pMapIdx = SRegToPMap(cUnit, sReg);
if (cUnit->promotionMap[pMapIdx+1].fpLocation == kLocPhysReg) {
// Upper reg is already allocated. Can we fit?
- int highReg = cUnit->promotionMap[pMapIdx+1].fpReg;
+ int highReg = cUnit->promotionMap[pMapIdx+1].FpReg;
if ((highReg & 1) == 0) {
// High reg is even - fail.
return res;
}
// Is the low reg of the pair free?
- RegisterInfo* p = oatGetRegInfo(cUnit, highReg-1);
+ RegisterInfo* p = GetRegInfo(cUnit, highReg-1);
if (p->inUse || p->isTemp) {
// Already allocated or not preserved - fail.
return res;
@@ -245,7 +245,7 @@
res = p->reg;
p->inUse = true;
DCHECK_EQ((res & 1), 0);
- oatMarkPreservedSingle(cUnit, vReg, res);
+ MarkPreservedSingle(cUnit, vReg, res);
} else {
RegisterInfo* FPRegs = cUnit->regPool->FPRegs;
for (int i = 0; i < cUnit->regPool->numFPRegs; i++) {
@@ -256,19 +256,19 @@
(FPRegs[i].reg + 1) == FPRegs[i+1].reg) {
res = FPRegs[i].reg;
FPRegs[i].inUse = true;
- oatMarkPreservedSingle(cUnit, vReg, res);
+ MarkPreservedSingle(cUnit, vReg, res);
FPRegs[i+1].inUse = true;
DCHECK_EQ(res + 1, FPRegs[i+1].reg);
- oatMarkPreservedSingle(cUnit, vReg+1, res+1);
+ MarkPreservedSingle(cUnit, vReg+1, res+1);
break;
}
}
}
if (res != -1) {
cUnit->promotionMap[pMapIdx].fpLocation = kLocPhysReg;
- cUnit->promotionMap[pMapIdx].fpReg = res;
+ cUnit->promotionMap[pMapIdx].FpReg = res;
cUnit->promotionMap[pMapIdx+1].fpLocation = kLocPhysReg;
- cUnit->promotionMap[pMapIdx+1].fpReg = res + 1;
+ cUnit->promotionMap[pMapIdx+1].FpReg = res + 1;
}
return res;
}
@@ -280,22 +280,22 @@
* single regs (but if can't still attempt to allocate a single, preferring
* first to allocate an odd register.
*/
-extern int oatAllocPreservedFPReg(CompilationUnit* cUnit, int sReg,
+extern int AllocPreservedFPReg(CompilationUnit* cUnit, int sReg,
bool doubleStart)
{
int res = -1;
if (doubleStart) {
- res = allocPreservedDouble(cUnit, sReg);
+ res = AllocPreservedDouble(cUnit, sReg);
}
if (res == -1) {
- res = allocPreservedSingle(cUnit, sReg, false /* try odd # */);
+ res = AllocPreservedSingle(cUnit, sReg, false /* try odd # */);
}
if (res == -1)
- res = allocPreservedSingle(cUnit, sReg, true /* try even # */);
+ res = AllocPreservedSingle(cUnit, sReg, true /* try even # */);
return res;
}
-int allocTempBody(CompilationUnit* cUnit, RegisterInfo* p, int numRegs,
+int AllocTempBody(CompilationUnit* cUnit, RegisterInfo* p, int numRegs,
int* nextTemp, bool required)
{
int i;
@@ -304,7 +304,7 @@
if (next >= numRegs)
next = 0;
if (p[next].isTemp && !p[next].inUse && !p[next].live) {
- oatClobber(cUnit, p[next].reg);
+ Clobber(cUnit, p[next].reg);
p[next].inUse = true;
p[next].pair = false;
*nextTemp = next + 1;
@@ -317,7 +317,7 @@
if (next >= numRegs)
next = 0;
if (p[next].isTemp && !p[next].inUse) {
- oatClobber(cUnit, p[next].reg);
+ Clobber(cUnit, p[next].reg);
p[next].inUse = true;
p[next].pair = false;
*nextTemp = next + 1;
@@ -326,8 +326,8 @@
next++;
}
if (required) {
- oatCodegenDump(cUnit);
- dumpRegPool(cUnit->regPool->coreRegs,
+ CodegenDump(cUnit);
+ DumpRegPool(cUnit->regPool->coreRegs,
cUnit->regPool->numCoreRegs);
LOG(FATAL) << "No free temp registers";
}
@@ -335,7 +335,7 @@
}
//REDO: too many assumptions.
-extern int oatAllocTempDouble(CompilationUnit* cUnit)
+extern int AllocTempDouble(CompilationUnit* cUnit)
{
RegisterInfo* p = cUnit->regPool->FPRegs;
int numRegs = cUnit->regPool->numFPRegs;
@@ -348,8 +348,8 @@
next = 0;
if ((p[next].isTemp && !p[next].inUse && !p[next].live) &&
(p[next+1].isTemp && !p[next+1].inUse && !p[next+1].live)) {
- oatClobber(cUnit, p[next].reg);
- oatClobber(cUnit, p[next+1].reg);
+ Clobber(cUnit, p[next].reg);
+ Clobber(cUnit, p[next+1].reg);
p[next].inUse = true;
p[next+1].inUse = true;
DCHECK_EQ((p[next].reg+1), p[next+1].reg);
@@ -370,8 +370,8 @@
next = 0;
if (p[next].isTemp && !p[next].inUse && p[next+1].isTemp &&
!p[next+1].inUse) {
- oatClobber(cUnit, p[next].reg);
- oatClobber(cUnit, p[next+1].reg);
+ Clobber(cUnit, p[next].reg);
+ Clobber(cUnit, p[next+1].reg);
p[next].inUse = true;
p[next+1].inUse = true;
DCHECK_EQ((p[next].reg+1), p[next+1].reg);
@@ -389,28 +389,28 @@
}
/* Return a temp if one is available, -1 otherwise */
-extern int oatAllocFreeTemp(CompilationUnit* cUnit)
+extern int AllocFreeTemp(CompilationUnit* cUnit)
{
- return allocTempBody(cUnit, cUnit->regPool->coreRegs,
+ return AllocTempBody(cUnit, cUnit->regPool->coreRegs,
cUnit->regPool->numCoreRegs,
&cUnit->regPool->nextCoreReg, true);
}
-extern int oatAllocTemp(CompilationUnit* cUnit)
+extern int AllocTemp(CompilationUnit* cUnit)
{
- return allocTempBody(cUnit, cUnit->regPool->coreRegs,
+ return AllocTempBody(cUnit, cUnit->regPool->coreRegs,
cUnit->regPool->numCoreRegs,
&cUnit->regPool->nextCoreReg, true);
}
-extern int oatAllocTempFloat(CompilationUnit* cUnit)
+extern int AllocTempFloat(CompilationUnit* cUnit)
{
- return allocTempBody(cUnit, cUnit->regPool->FPRegs,
+ return AllocTempBody(cUnit, cUnit->regPool->FPRegs,
cUnit->regPool->numFPRegs,
&cUnit->regPool->nextFPReg, true);
}
-RegisterInfo* allocLiveBody(RegisterInfo* p, int numRegs, int sReg)
+RegisterInfo* AllocLiveBody(RegisterInfo* p, int numRegs, int sReg)
{
int i;
if (sReg == -1)
@@ -425,22 +425,22 @@
return NULL;
}
-RegisterInfo* allocLive(CompilationUnit* cUnit, int sReg, int regClass)
+RegisterInfo* AllocLive(CompilationUnit* cUnit, int sReg, int regClass)
{
RegisterInfo* res = NULL;
switch (regClass) {
case kAnyReg:
- res = allocLiveBody(cUnit->regPool->FPRegs,
+ res = AllocLiveBody(cUnit->regPool->FPRegs,
cUnit->regPool->numFPRegs, sReg);
if (res)
break;
/* Intentional fallthrough */
case kCoreReg:
- res = allocLiveBody(cUnit->regPool->coreRegs,
+ res = AllocLiveBody(cUnit->regPool->coreRegs,
cUnit->regPool->numCoreRegs, sReg);
break;
case kFPReg:
- res = allocLiveBody(cUnit->regPool->FPRegs,
+ res = AllocLiveBody(cUnit->regPool->FPRegs,
cUnit->regPool->numFPRegs, sReg);
break;
default:
@@ -449,7 +449,7 @@
return res;
}
-extern void oatFreeTemp(CompilationUnit* cUnit, int reg)
+extern void FreeTemp(CompilationUnit* cUnit, int reg)
{
RegisterInfo* p = cUnit->regPool->coreRegs;
int numRegs = cUnit->regPool->numCoreRegs;
@@ -477,7 +477,7 @@
LOG(FATAL) << "Tried to free a non-existant temp: r" << reg;
}
-extern RegisterInfo* oatIsLive(CompilationUnit* cUnit, int reg)
+extern RegisterInfo* IsLive(CompilationUnit* cUnit, int reg)
{
RegisterInfo* p = cUnit->regPool->coreRegs;
int numRegs = cUnit->regPool->numCoreRegs;
@@ -497,30 +497,30 @@
return NULL;
}
-extern RegisterInfo* oatIsTemp(CompilationUnit* cUnit, int reg)
+extern RegisterInfo* IsTemp(CompilationUnit* cUnit, int reg)
{
- RegisterInfo* p = oatGetRegInfo(cUnit, reg);
+ RegisterInfo* p = GetRegInfo(cUnit, reg);
return (p->isTemp) ? p : NULL;
}
-extern RegisterInfo* oatIsPromoted(CompilationUnit* cUnit, int reg)
+extern RegisterInfo* IsPromoted(CompilationUnit* cUnit, int reg)
{
- RegisterInfo* p = oatGetRegInfo(cUnit, reg);
+ RegisterInfo* p = GetRegInfo(cUnit, reg);
return (p->isTemp) ? NULL : p;
}
-extern bool oatIsDirty(CompilationUnit* cUnit, int reg)
+extern bool IsDirty(CompilationUnit* cUnit, int reg)
{
- RegisterInfo* p = oatGetRegInfo(cUnit, reg);
+ RegisterInfo* p = GetRegInfo(cUnit, reg);
return p->dirty;
}
/*
- * Similar to oatAllocTemp(), but forces the allocation of a specific
+ * Similar to AllocTemp(), but forces the allocation of a specific
* register. No check is made to see if the register was previously
* allocated. Use with caution.
*/
-extern void oatLockTemp(CompilationUnit* cUnit, int reg)
+extern void LockTemp(CompilationUnit* cUnit, int reg)
{
RegisterInfo* p = cUnit->regPool->coreRegs;
int numRegs = cUnit->regPool->numCoreRegs;
@@ -546,25 +546,25 @@
LOG(FATAL) << "Tried to lock a non-existant temp: r" << reg;
}
-static inline void resetDefBody(RegisterInfo* p)
+static inline void ResetDefBody(RegisterInfo* p)
{
p->defStart = NULL;
p->defEnd = NULL;
}
-extern void oatResetDef(CompilationUnit* cUnit, int reg)
+extern void ResetDef(CompilationUnit* cUnit, int reg)
{
- resetDefBody(oatGetRegInfo(cUnit, reg));
+ ResetDefBody(GetRegInfo(cUnit, reg));
}
-void nullifyRange(CompilationUnit* cUnit, LIR *start, LIR *finish,
+void NullifyRange(CompilationUnit* cUnit, LIR *start, LIR *finish,
int sReg1, int sReg2)
{
if (start && finish) {
LIR *p;
DCHECK_EQ(sReg1, sReg2);
for (p = start; ;p = p->next) {
- oatNopLIR(p);
+ NopLIR(p);
if (p == finish)
break;
}
@@ -576,13 +576,13 @@
* on entry start points to the LIR prior to the beginning of the
* sequence.
*/
-extern void oatMarkDef(CompilationUnit* cUnit, RegLocation rl,
+extern void MarkDef(CompilationUnit* cUnit, RegLocation rl,
LIR *start, LIR *finish)
{
DCHECK(!rl.wide);
DCHECK(start && start->next);
DCHECK(finish);
- RegisterInfo* p = oatGetRegInfo(cUnit, rl.lowReg);
+ RegisterInfo* p = GetRegInfo(cUnit, rl.lowReg);
p->defStart = start->next;
p->defEnd = finish;
}
@@ -592,24 +592,24 @@
* on entry start points to the LIR prior to the beginning of the
* sequence.
*/
-extern void oatMarkDefWide(CompilationUnit* cUnit, RegLocation rl,
+extern void MarkDefWide(CompilationUnit* cUnit, RegLocation rl,
LIR *start, LIR *finish)
{
DCHECK(rl.wide);
DCHECK(start && start->next);
DCHECK(finish);
- RegisterInfo* p = oatGetRegInfo(cUnit, rl.lowReg);
- oatResetDef(cUnit, rl.highReg); // Only track low of pair
+ RegisterInfo* p = GetRegInfo(cUnit, rl.lowReg);
+ ResetDef(cUnit, rl.highReg); // Only track low of pair
p->defStart = start->next;
p->defEnd = finish;
}
-extern RegLocation oatWideToNarrow(CompilationUnit* cUnit, RegLocation rl)
+extern RegLocation WideToNarrow(CompilationUnit* cUnit, RegLocation rl)
{
DCHECK(rl.wide);
if (rl.location == kLocPhysReg) {
- RegisterInfo* infoLo = oatGetRegInfo(cUnit, rl.lowReg);
- RegisterInfo* infoHi = oatGetRegInfo(cUnit, rl.highReg);
+ RegisterInfo* infoLo = GetRegInfo(cUnit, rl.lowReg);
+ RegisterInfo* infoHi = GetRegInfo(cUnit, rl.highReg);
if (infoLo->isTemp) {
infoLo->pair = false;
infoLo->defStart = NULL;
@@ -625,100 +625,100 @@
return rl;
}
-extern void oatResetDefLoc(CompilationUnit* cUnit, RegLocation rl)
+extern void ResetDefLoc(CompilationUnit* cUnit, RegLocation rl)
{
DCHECK(!rl.wide);
- RegisterInfo* p = oatIsTemp(cUnit, rl.lowReg);
+ RegisterInfo* p = IsTemp(cUnit, rl.lowReg);
if (p && !(cUnit->disableOpt & (1 << kSuppressLoads))) {
DCHECK(!p->pair);
- nullifyRange(cUnit, p->defStart, p->defEnd, p->sReg, rl.sRegLow);
+ NullifyRange(cUnit, p->defStart, p->defEnd, p->sReg, rl.sRegLow);
}
- oatResetDef(cUnit, rl.lowReg);
+ ResetDef(cUnit, rl.lowReg);
}
-extern void oatResetDefLocWide(CompilationUnit* cUnit, RegLocation rl)
+extern void ResetDefLocWide(CompilationUnit* cUnit, RegLocation rl)
{
DCHECK(rl.wide);
- RegisterInfo* pLow = oatIsTemp(cUnit, rl.lowReg);
- RegisterInfo* pHigh = oatIsTemp(cUnit, rl.highReg);
+ RegisterInfo* pLow = IsTemp(cUnit, rl.lowReg);
+ RegisterInfo* pHigh = IsTemp(cUnit, rl.highReg);
if (pLow && !(cUnit->disableOpt & (1 << kSuppressLoads))) {
DCHECK(pLow->pair);
- nullifyRange(cUnit, pLow->defStart, pLow->defEnd, pLow->sReg, rl.sRegLow);
+ NullifyRange(cUnit, pLow->defStart, pLow->defEnd, pLow->sReg, rl.sRegLow);
}
if (pHigh && !(cUnit->disableOpt & (1 << kSuppressLoads))) {
DCHECK(pHigh->pair);
}
- oatResetDef(cUnit, rl.lowReg);
- oatResetDef(cUnit, rl.highReg);
+ ResetDef(cUnit, rl.lowReg);
+ ResetDef(cUnit, rl.highReg);
}
-extern void oatResetDefTracking(CompilationUnit* cUnit)
+extern void ResetDefTracking(CompilationUnit* cUnit)
{
int i;
for (i=0; i< cUnit->regPool->numCoreRegs; i++) {
- resetDefBody(&cUnit->regPool->coreRegs[i]);
+ ResetDefBody(&cUnit->regPool->coreRegs[i]);
}
for (i=0; i< cUnit->regPool->numFPRegs; i++) {
- resetDefBody(&cUnit->regPool->FPRegs[i]);
+ ResetDefBody(&cUnit->regPool->FPRegs[i]);
}
}
-extern void oatClobberAllRegs(CompilationUnit* cUnit)
+extern void ClobberAllRegs(CompilationUnit* cUnit)
{
int i;
for (i=0; i< cUnit->regPool->numCoreRegs; i++) {
- clobberBody(cUnit, &cUnit->regPool->coreRegs[i]);
+ ClobberBody(cUnit, &cUnit->regPool->coreRegs[i]);
}
for (i=0; i< cUnit->regPool->numFPRegs; i++) {
- clobberBody(cUnit, &cUnit->regPool->FPRegs[i]);
+ ClobberBody(cUnit, &cUnit->regPool->FPRegs[i]);
}
}
// Make sure nothing is live and dirty
-void flushAllRegsBody(CompilationUnit* cUnit, RegisterInfo* info,
+void FlushAllRegsBody(CompilationUnit* cUnit, RegisterInfo* info,
int numRegs)
{
int i;
for (i=0; i < numRegs; i++) {
if (info[i].live && info[i].dirty) {
if (info[i].pair) {
- oatFlushRegWide(cUnit, info[i].reg, info[i].partner);
+ FlushRegWide(cUnit, info[i].reg, info[i].partner);
} else {
- oatFlushReg(cUnit, info[i].reg);
+ FlushReg(cUnit, info[i].reg);
}
}
}
}
-extern void oatFlushAllRegs(CompilationUnit* cUnit)
+extern void FlushAllRegs(CompilationUnit* cUnit)
{
- flushAllRegsBody(cUnit, cUnit->regPool->coreRegs,
+ FlushAllRegsBody(cUnit, cUnit->regPool->coreRegs,
cUnit->regPool->numCoreRegs);
- flushAllRegsBody(cUnit, cUnit->regPool->FPRegs,
+ FlushAllRegsBody(cUnit, cUnit->regPool->FPRegs,
cUnit->regPool->numFPRegs);
- oatClobberAllRegs(cUnit);
+ ClobberAllRegs(cUnit);
}
//TUNING: rewrite all of this reg stuff. Probably use an attribute table
-bool regClassMatches(int regClass, int reg)
+bool RegClassMatches(int regClass, int reg)
{
if (regClass == kAnyReg) {
return true;
} else if (regClass == kCoreReg) {
- return !oatIsFpReg(reg);
+ return !IsFpReg(reg);
} else {
- return oatIsFpReg(reg);
+ return IsFpReg(reg);
}
}
-extern void oatMarkLive(CompilationUnit* cUnit, int reg, int sReg)
+extern void MarkLive(CompilationUnit* cUnit, int reg, int sReg)
{
- RegisterInfo* info = oatGetRegInfo(cUnit, reg);
+ RegisterInfo* info = GetRegInfo(cUnit, reg);
if ((info->reg == reg) && (info->sReg == sReg) && info->live) {
return; /* already live */
} else if (sReg != INVALID_SREG) {
- oatClobberSReg(cUnit, sReg);
+ ClobberSReg(cUnit, sReg);
if (info->isTemp) {
info->live = true;
}
@@ -730,61 +730,61 @@
info->sReg = sReg;
}
-extern void oatMarkTemp(CompilationUnit* cUnit, int reg)
+extern void MarkTemp(CompilationUnit* cUnit, int reg)
{
- RegisterInfo* info = oatGetRegInfo(cUnit, reg);
+ RegisterInfo* info = GetRegInfo(cUnit, reg);
info->isTemp = true;
}
-extern void oatUnmarkTemp(CompilationUnit* cUnit, int reg)
+extern void UnmarkTemp(CompilationUnit* cUnit, int reg)
{
- RegisterInfo* info = oatGetRegInfo(cUnit, reg);
+ RegisterInfo* info = GetRegInfo(cUnit, reg);
info->isTemp = false;
}
-extern void oatMarkPair(CompilationUnit* cUnit, int lowReg, int highReg)
+extern void MarkPair(CompilationUnit* cUnit, int lowReg, int highReg)
{
- RegisterInfo* infoLo = oatGetRegInfo(cUnit, lowReg);
- RegisterInfo* infoHi = oatGetRegInfo(cUnit, highReg);
+ RegisterInfo* infoLo = GetRegInfo(cUnit, lowReg);
+ RegisterInfo* infoHi = GetRegInfo(cUnit, highReg);
infoLo->pair = infoHi->pair = true;
infoLo->partner = highReg;
infoHi->partner = lowReg;
}
-extern void oatMarkClean(CompilationUnit* cUnit, RegLocation loc)
+extern void MarkClean(CompilationUnit* cUnit, RegLocation loc)
{
- RegisterInfo* info = oatGetRegInfo(cUnit, loc.lowReg);
+ RegisterInfo* info = GetRegInfo(cUnit, loc.lowReg);
info->dirty = false;
if (loc.wide) {
- info = oatGetRegInfo(cUnit, loc.highReg);
+ info = GetRegInfo(cUnit, loc.highReg);
info->dirty = false;
}
}
-extern void oatMarkDirty(CompilationUnit* cUnit, RegLocation loc)
+extern void MarkDirty(CompilationUnit* cUnit, RegLocation loc)
{
if (loc.home) {
// If already home, can't be dirty
return;
}
- RegisterInfo* info = oatGetRegInfo(cUnit, loc.lowReg);
+ RegisterInfo* info = GetRegInfo(cUnit, loc.lowReg);
info->dirty = true;
if (loc.wide) {
- info = oatGetRegInfo(cUnit, loc.highReg);
+ info = GetRegInfo(cUnit, loc.highReg);
info->dirty = true;
}
}
-extern void oatMarkInUse(CompilationUnit* cUnit, int reg)
+extern void MarkInUse(CompilationUnit* cUnit, int reg)
{
- RegisterInfo* info = oatGetRegInfo(cUnit, reg);
+ RegisterInfo* info = GetRegInfo(cUnit, reg);
info->inUse = true;
}
-void copyRegInfo(CompilationUnit* cUnit, int newReg, int oldReg)
+void CopyRegInfo(CompilationUnit* cUnit, int newReg, int oldReg)
{
- RegisterInfo* newInfo = oatGetRegInfo(cUnit, newReg);
- RegisterInfo* oldInfo = oatGetRegInfo(cUnit, oldReg);
+ RegisterInfo* newInfo = GetRegInfo(cUnit, newReg);
+ RegisterInfo* oldInfo = GetRegInfo(cUnit, oldReg);
// Target temp status must not change
bool isTemp = newInfo->isTemp;
*newInfo = *oldInfo;
@@ -803,19 +803,19 @@
* if it's worthwhile trying to be more clever here.
*/
-extern RegLocation oatUpdateLoc(CompilationUnit* cUnit, RegLocation loc)
+extern RegLocation UpdateLoc(CompilationUnit* cUnit, RegLocation loc)
{
DCHECK(!loc.wide);
- DCHECK(oatCheckCorePoolSanity(cUnit));
+ DCHECK(CheckCorePoolSanity(cUnit));
if (loc.location != kLocPhysReg) {
DCHECK((loc.location == kLocDalvikFrame) ||
(loc.location == kLocCompilerTemp));
- RegisterInfo* infoLo = allocLive(cUnit, loc.sRegLow, kAnyReg);
+ RegisterInfo* infoLo = AllocLive(cUnit, loc.sRegLow, kAnyReg);
if (infoLo) {
if (infoLo->pair) {
- oatClobber(cUnit, infoLo->reg);
- oatClobber(cUnit, infoLo->partner);
- oatFreeTemp(cUnit, infoLo->reg);
+ Clobber(cUnit, infoLo->reg);
+ Clobber(cUnit, infoLo->partner);
+ FreeTemp(cUnit, infoLo->reg);
} else {
loc.lowReg = infoLo->reg;
loc.location = kLocPhysReg;
@@ -826,14 +826,14 @@
return loc;
}
-bool oatCheckCorePoolSanity(CompilationUnit* cUnit)
+bool CheckCorePoolSanity(CompilationUnit* cUnit)
{
for (static int i = 0; i < cUnit->regPool->numCoreRegs; i++) {
if (cUnit->regPool->coreRegs[i].pair) {
static int myReg = cUnit->regPool->coreRegs[i].reg;
static int mySreg = cUnit->regPool->coreRegs[i].sReg;
static int partnerReg = cUnit->regPool->coreRegs[i].partner;
- static RegisterInfo* partner = oatGetRegInfo(cUnit, partnerReg);
+ static RegisterInfo* partner = GetRegInfo(cUnit, partnerReg);
DCHECK(partner != NULL);
DCHECK(partner->pair);
DCHECK_EQ(myReg, partner->partner);
@@ -854,24 +854,24 @@
}
/* see comments for updateLoc */
-extern RegLocation oatUpdateLocWide(CompilationUnit* cUnit, RegLocation loc)
+extern RegLocation UpdateLocWide(CompilationUnit* cUnit, RegLocation loc)
{
DCHECK(loc.wide);
- DCHECK(oatCheckCorePoolSanity(cUnit));
+ DCHECK(CheckCorePoolSanity(cUnit));
if (loc.location != kLocPhysReg) {
DCHECK((loc.location == kLocDalvikFrame) ||
(loc.location == kLocCompilerTemp));
// Are the dalvik regs already live in physical registers?
- RegisterInfo* infoLo = allocLive(cUnit, loc.sRegLow, kAnyReg);
- RegisterInfo* infoHi = allocLive(cUnit,
+ RegisterInfo* infoLo = AllocLive(cUnit, loc.sRegLow, kAnyReg);
+ RegisterInfo* infoHi = AllocLive(cUnit,
oatSRegHi(loc.sRegLow), kAnyReg);
bool match = true;
match = match && (infoLo != NULL);
match = match && (infoHi != NULL);
// Are they both core or both FP?
- match = match && (oatIsFpReg(infoLo->reg) == oatIsFpReg(infoHi->reg));
+ match = match && (IsFpReg(infoLo->reg) == IsFpReg(infoHi->reg));
// If a pair of floating point singles, are they properly aligned?
- if (match && oatIsFpReg(infoLo->reg)) {
+ if (match && IsFpReg(infoLo->reg)) {
match &= ((infoLo->reg & 0x1) == 0);
match &= ((infoHi->reg - infoLo->reg) == 1);
}
@@ -886,22 +886,22 @@
loc.lowReg = infoLo->reg;
loc.highReg = infoHi->reg;
loc.location = kLocPhysReg;
- oatMarkPair(cUnit, loc.lowReg, loc.highReg);
- DCHECK(!oatIsFpReg(loc.lowReg) || ((loc.lowReg & 0x1) == 0));
+ MarkPair(cUnit, loc.lowReg, loc.highReg);
+ DCHECK(!IsFpReg(loc.lowReg) || ((loc.lowReg & 0x1) == 0));
return loc;
}
// Can't easily reuse - clobber and free any overlaps
if (infoLo) {
- oatClobber(cUnit, infoLo->reg);
- oatFreeTemp(cUnit, infoLo->reg);
+ Clobber(cUnit, infoLo->reg);
+ FreeTemp(cUnit, infoLo->reg);
if (infoLo->pair)
- oatClobber(cUnit, infoLo->partner);
+ Clobber(cUnit, infoLo->partner);
}
if (infoHi) {
- oatClobber(cUnit, infoHi->reg);
- oatFreeTemp(cUnit, infoHi->reg);
+ Clobber(cUnit, infoHi->reg);
+ FreeTemp(cUnit, infoHi->reg);
if (infoHi->pair)
- oatClobber(cUnit, infoHi->partner);
+ Clobber(cUnit, infoHi->partner);
}
}
return loc;
@@ -909,15 +909,15 @@
/* For use in cases we don't know (or care) width */
-extern RegLocation oatUpdateRawLoc(CompilationUnit* cUnit, RegLocation loc)
+extern RegLocation UpdateRawLoc(CompilationUnit* cUnit, RegLocation loc)
{
if (loc.wide)
- return oatUpdateLocWide(cUnit, loc);
+ return UpdateLocWide(cUnit, loc);
else
- return oatUpdateLoc(cUnit, loc);
+ return UpdateLoc(cUnit, loc);
}
-RegLocation evalLocWide(CompilationUnit* cUnit, RegLocation loc,
+RegLocation EvalLocWide(CompilationUnit* cUnit, RegLocation loc,
int regClass, bool update)
{
DCHECK(loc.wide);
@@ -925,27 +925,27 @@
int lowReg;
int highReg;
- loc = oatUpdateLocWide(cUnit, loc);
+ loc = UpdateLocWide(cUnit, loc);
/* If already in registers, we can assume proper form. Right reg class? */
if (loc.location == kLocPhysReg) {
- DCHECK_EQ(oatIsFpReg(loc.lowReg), oatIsFpReg(loc.highReg));
- DCHECK(!oatIsFpReg(loc.lowReg) || ((loc.lowReg & 0x1) == 0));
- if (!regClassMatches(regClass, loc.lowReg)) {
+ DCHECK_EQ(IsFpReg(loc.lowReg), IsFpReg(loc.highReg));
+ DCHECK(!IsFpReg(loc.lowReg) || ((loc.lowReg & 0x1) == 0));
+ if (!RegClassMatches(regClass, loc.lowReg)) {
/* Wrong register class. Reallocate and copy */
- newRegs = oatAllocTypedTempPair(cUnit, loc.fp, regClass);
+ newRegs = AllocTypedTempPair(cUnit, loc.fp, regClass);
lowReg = newRegs & 0xff;
highReg = (newRegs >> 8) & 0xff;
- opRegCopyWide(cUnit, lowReg, highReg, loc.lowReg,
+ OpRegCopyWide(cUnit, lowReg, highReg, loc.lowReg,
loc.highReg);
- copyRegInfo(cUnit, lowReg, loc.lowReg);
- copyRegInfo(cUnit, highReg, loc.highReg);
- oatClobber(cUnit, loc.lowReg);
- oatClobber(cUnit, loc.highReg);
+ CopyRegInfo(cUnit, lowReg, loc.lowReg);
+ CopyRegInfo(cUnit, highReg, loc.highReg);
+ Clobber(cUnit, loc.lowReg);
+ Clobber(cUnit, loc.highReg);
loc.lowReg = lowReg;
loc.highReg = highReg;
- oatMarkPair(cUnit, loc.lowReg, loc.highReg);
- DCHECK(!oatIsFpReg(loc.lowReg) || ((loc.lowReg & 0x1) == 0));
+ MarkPair(cUnit, loc.lowReg, loc.highReg);
+ DCHECK(!IsFpReg(loc.lowReg) || ((loc.lowReg & 0x1) == 0));
}
return loc;
}
@@ -953,37 +953,37 @@
DCHECK_NE(loc.sRegLow, INVALID_SREG);
DCHECK_NE(oatSRegHi(loc.sRegLow), INVALID_SREG);
- newRegs = oatAllocTypedTempPair(cUnit, loc.fp, regClass);
+ newRegs = AllocTypedTempPair(cUnit, loc.fp, regClass);
loc.lowReg = newRegs & 0xff;
loc.highReg = (newRegs >> 8) & 0xff;
- oatMarkPair(cUnit, loc.lowReg, loc.highReg);
+ MarkPair(cUnit, loc.lowReg, loc.highReg);
if (update) {
loc.location = kLocPhysReg;
- oatMarkLive(cUnit, loc.lowReg, loc.sRegLow);
- oatMarkLive(cUnit, loc.highReg, oatSRegHi(loc.sRegLow));
+ MarkLive(cUnit, loc.lowReg, loc.sRegLow);
+ MarkLive(cUnit, loc.highReg, oatSRegHi(loc.sRegLow));
}
- DCHECK(!oatIsFpReg(loc.lowReg) || ((loc.lowReg & 0x1) == 0));
+ DCHECK(!IsFpReg(loc.lowReg) || ((loc.lowReg & 0x1) == 0));
return loc;
}
-extern RegLocation oatEvalLoc(CompilationUnit* cUnit, RegLocation loc,
+extern RegLocation EvalLoc(CompilationUnit* cUnit, RegLocation loc,
int regClass, bool update)
{
int newReg;
if (loc.wide)
- return evalLocWide(cUnit, loc, regClass, update);
+ return EvalLocWide(cUnit, loc, regClass, update);
- loc = oatUpdateLoc(cUnit, loc);
+ loc = UpdateLoc(cUnit, loc);
if (loc.location == kLocPhysReg) {
- if (!regClassMatches(regClass, loc.lowReg)) {
+ if (!RegClassMatches(regClass, loc.lowReg)) {
/* Wrong register class. Realloc, copy and transfer ownership */
- newReg = oatAllocTypedTemp(cUnit, loc.fp, regClass);
- opRegCopy(cUnit, newReg, loc.lowReg);
- copyRegInfo(cUnit, newReg, loc.lowReg);
- oatClobber(cUnit, loc.lowReg);
+ newReg = AllocTypedTemp(cUnit, loc.fp, regClass);
+ OpRegCopy(cUnit, newReg, loc.lowReg);
+ CopyRegInfo(cUnit, newReg, loc.lowReg);
+ Clobber(cUnit, loc.lowReg);
loc.lowReg = newReg;
}
return loc;
@@ -991,61 +991,61 @@
DCHECK_NE(loc.sRegLow, INVALID_SREG);
- newReg = oatAllocTypedTemp(cUnit, loc.fp, regClass);
+ newReg = AllocTypedTemp(cUnit, loc.fp, regClass);
loc.lowReg = newReg;
if (update) {
loc.location = kLocPhysReg;
- oatMarkLive(cUnit, loc.lowReg, loc.sRegLow);
+ MarkLive(cUnit, loc.lowReg, loc.sRegLow);
}
return loc;
}
-extern RegLocation oatGetRawSrc(CompilationUnit* cUnit, MIR* mir, int num)
+extern RegLocation GetRawSrc(CompilationUnit* cUnit, MIR* mir, int num)
{
DCHECK(num < mir->ssaRep->numUses);
RegLocation res = cUnit->regLocation[mir->ssaRep->uses[num]];
return res;
}
-extern RegLocation oatGetRawDest(CompilationUnit* cUnit, MIR* mir)
+extern RegLocation GetRawDest(CompilationUnit* cUnit, MIR* mir)
{
DCHECK_GT(mir->ssaRep->numDefs, 0);
RegLocation res = cUnit->regLocation[mir->ssaRep->defs[0]];
return res;
}
-extern RegLocation oatGetDest(CompilationUnit* cUnit, MIR* mir)
+extern RegLocation GetDest(CompilationUnit* cUnit, MIR* mir)
{
- RegLocation res = oatGetRawDest(cUnit, mir);
+ RegLocation res = GetRawDest(cUnit, mir);
DCHECK(!res.wide);
return res;
}
-extern RegLocation oatGetSrc(CompilationUnit* cUnit, MIR* mir, int num)
+extern RegLocation GetSrc(CompilationUnit* cUnit, MIR* mir, int num)
{
- RegLocation res = oatGetRawSrc(cUnit, mir, num);
+ RegLocation res = GetRawSrc(cUnit, mir, num);
DCHECK(!res.wide);
return res;
}
-extern RegLocation oatGetDestWide(CompilationUnit* cUnit, MIR* mir)
+extern RegLocation GetDestWide(CompilationUnit* cUnit, MIR* mir)
{
- RegLocation res = oatGetRawDest(cUnit, mir);
+ RegLocation res = GetRawDest(cUnit, mir);
DCHECK(res.wide);
return res;
}
-extern RegLocation oatGetSrcWide(CompilationUnit* cUnit, MIR* mir,
+extern RegLocation GetSrcWide(CompilationUnit* cUnit, MIR* mir,
int low)
{
- RegLocation res = oatGetRawSrc(cUnit, mir, low);
+ RegLocation res = GetRawSrc(cUnit, mir, low);
DCHECK(res.wide);
return res;
}
/* USE SSA names to count references of base Dalvik vRegs. */
-void oatCountRefs(CompilationUnit *cUnit, BasicBlock* bb,
+void CountRefs(CompilationUnit *cUnit, BasicBlock* bb,
RefCounts* coreCounts, RefCounts* fpCounts)
{
if ((cUnit->disableOpt & (1 << kPromoteRegs)) ||
@@ -1075,14 +1075,14 @@
}
/* qsort callback function, sort descending */
-int oatSortCounts(const void *val1, const void *val2)
+int SortCounts(const void *val1, const void *val2)
{
const RefCounts* op1 = reinterpret_cast<const RefCounts*>(val1);
const RefCounts* op2 = reinterpret_cast<const RefCounts*>(val2);
return (op1->count == op2->count) ? 0 : (op1->count < op2->count ? 1 : -1);
}
-void oatDumpCounts(const RefCounts* arr, int size, const char* msg)
+void DumpCounts(const RefCounts* arr, int size, const char* msg)
{
LOG(INFO) << msg;
for (int i = 0; i < size; i++) {
@@ -1094,7 +1094,7 @@
* Note: some portions of this code required even if the kPromoteRegs
* optimization is disabled.
*/
-extern void oatDoPromotion(CompilationUnit* cUnit)
+extern void DoPromotion(CompilationUnit* cUnit)
{
int regBias = cUnit->numCompilerTemps + 1;
int dalvikRegs = cUnit->numDalvikRegisters;
@@ -1102,7 +1102,7 @@
const int promotionThreshold = 2;
// Allow target code to add any special registers
- oatAdjustSpillMask(cUnit);
+ AdjustSpillMask(cUnit);
/*
* Simple register promotion. Just do a static count of the uses
@@ -1115,31 +1115,31 @@
* TUNING: replace with linear scan once we have the ability
* to describe register live ranges for GC.
*/
- RefCounts *coreRegs = static_cast<RefCounts*>(oatNew(cUnit, sizeof(RefCounts) * numRegs,
+ RefCounts *coreRegs = static_cast<RefCounts*>(NewMem(cUnit, sizeof(RefCounts) * numRegs,
true, kAllocRegAlloc));
- RefCounts *fpRegs = static_cast<RefCounts *>(oatNew(cUnit, sizeof(RefCounts) * numRegs,
+ RefCounts *FpRegs = static_cast<RefCounts *>(NewMem(cUnit, sizeof(RefCounts) * numRegs,
true, kAllocRegAlloc));
// Set ssa names for original Dalvik registers
for (int i = 0; i < dalvikRegs; i++) {
- coreRegs[i].sReg = fpRegs[i].sReg = i;
+ coreRegs[i].sReg = FpRegs[i].sReg = i;
}
// Set ssa name for Method*
coreRegs[dalvikRegs].sReg = cUnit->methodSReg;
- fpRegs[dalvikRegs].sReg = cUnit->methodSReg; // For consistecy
+ FpRegs[dalvikRegs].sReg = cUnit->methodSReg; // For consistecy
// Set ssa names for compilerTemps
for (int i = 1; i <= cUnit->numCompilerTemps; i++) {
CompilerTemp* ct = reinterpret_cast<CompilerTemp*>(cUnit->compilerTemps.elemList[i]);
coreRegs[dalvikRegs + i].sReg = ct->sReg;
- fpRegs[dalvikRegs + i].sReg = ct->sReg;
+ FpRegs[dalvikRegs + i].sReg = ct->sReg;
}
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&cUnit->blockList, &iterator);
+ GrowableListIteratorInit(&cUnit->blockList, &iterator);
while (true) {
BasicBlock* bb;
- bb = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iterator));
+ bb = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iterator));
if (bb == NULL) break;
- oatCountRefs(cUnit, bb, coreRegs, fpRegs);
+ CountRefs(cUnit, bb, coreRegs, FpRegs);
}
/*
@@ -1148,28 +1148,28 @@
* used as the start of a pair first.
*/
for (int i = 0; i < numRegs; i++) {
- if (fpRegs[i].doubleStart) {
- fpRegs[i].count *= 2;
+ if (FpRegs[i].doubleStart) {
+ FpRegs[i].count *= 2;
}
}
// Sort the count arrays
- qsort(coreRegs, numRegs, sizeof(RefCounts), oatSortCounts);
- qsort(fpRegs, numRegs, sizeof(RefCounts), oatSortCounts);
+ qsort(coreRegs, numRegs, sizeof(RefCounts), SortCounts);
+ qsort(FpRegs, numRegs, sizeof(RefCounts), SortCounts);
if (cUnit->printMe) {
- oatDumpCounts(coreRegs, numRegs, "Core regs after sort");
- oatDumpCounts(fpRegs, numRegs, "Fp regs after sort");
+ DumpCounts(coreRegs, numRegs, "Core regs after sort");
+ DumpCounts(FpRegs, numRegs, "Fp regs after sort");
}
if (!(cUnit->disableOpt & (1 << kPromoteRegs))) {
- // Promote fpRegs
+ // Promote FpRegs
for (int i = 0; (i < numRegs) &&
- (fpRegs[i].count >= promotionThreshold ); i++) {
- int pMapIdx = SRegToPMap(cUnit, fpRegs[i].sReg);
+ (FpRegs[i].count >= promotionThreshold ); i++) {
+ int pMapIdx = SRegToPMap(cUnit, FpRegs[i].sReg);
if (cUnit->promotionMap[pMapIdx].fpLocation != kLocPhysReg) {
- int reg = oatAllocPreservedFPReg(cUnit, fpRegs[i].sReg,
- fpRegs[i].doubleStart);
+ int reg = AllocPreservedFPReg(cUnit, FpRegs[i].sReg,
+ FpRegs[i].doubleStart);
if (reg < 0) {
break; // No more left
}
@@ -1182,16 +1182,16 @@
int pMapIdx = SRegToPMap(cUnit, coreRegs[i].sReg);
if (cUnit->promotionMap[pMapIdx].coreLocation !=
kLocPhysReg) {
- int reg = oatAllocPreservedCoreReg(cUnit, coreRegs[i].sReg);
+ int reg = AllocPreservedCoreReg(cUnit, coreRegs[i].sReg);
if (reg < 0) {
break; // No more left
}
}
}
} else if (cUnit->qdMode) {
- oatAllocPreservedCoreReg(cUnit, cUnit->methodSReg);
+ AllocPreservedCoreReg(cUnit, cUnit->methodSReg);
for (int i = 0; i < numRegs; i++) {
- int reg = oatAllocPreservedCoreReg(cUnit, i);
+ int reg = AllocPreservedCoreReg(cUnit, i);
if (reg < 0) {
break; // No more left
}
@@ -1207,7 +1207,7 @@
if (curr->fp) {
if (cUnit->promotionMap[pMapIdx].fpLocation == kLocPhysReg) {
curr->location = kLocPhysReg;
- curr->lowReg = cUnit->promotionMap[pMapIdx].fpReg;
+ curr->lowReg = cUnit->promotionMap[pMapIdx].FpReg;
curr->home = true;
}
} else {
@@ -1226,8 +1226,8 @@
if ((cUnit->promotionMap[pMapIdx].fpLocation == kLocPhysReg) &&
(cUnit->promotionMap[pMapIdx+1].fpLocation ==
kLocPhysReg)) {
- int lowReg = cUnit->promotionMap[pMapIdx].fpReg;
- int highReg = cUnit->promotionMap[pMapIdx+1].fpReg;
+ int lowReg = cUnit->promotionMap[pMapIdx].FpReg;
+ int highReg = cUnit->promotionMap[pMapIdx+1].FpReg;
// Doubles require pair of singles starting at even reg
if (((lowReg & 0x1) == 0) && ((lowReg + 1) == highReg)) {
curr->location = kLocPhysReg;
@@ -1249,21 +1249,21 @@
}
}
if (cUnit->printMe) {
- oatDumpPromotionMap(cUnit);
+ DumpPromotionMap(cUnit);
}
}
/* Returns sp-relative offset in bytes for a VReg */
-extern int oatVRegOffset(CompilationUnit* cUnit, int vReg)
+extern int VRegOffset(CompilationUnit* cUnit, int vReg)
{
return StackVisitor::GetVRegOffset(cUnit->code_item, cUnit->coreSpillMask,
cUnit->fpSpillMask, cUnit->frameSize, vReg);
}
/* Returns sp-relative offset in bytes for a SReg */
-extern int oatSRegOffset(CompilationUnit* cUnit, int sReg)
+extern int SRegOffset(CompilationUnit* cUnit, int sReg)
{
- return oatVRegOffset(cUnit, SRegToVReg(cUnit, sReg));
+ return VRegOffset(cUnit, SRegToVReg(cUnit, sReg));
}
} // namespace art
diff --git a/src/compiler/codegen/ralloc_util.h b/src/compiler/codegen/ralloc_util.h
index 56b1e22..6947656 100644
--- a/src/compiler/codegen/ralloc_util.h
+++ b/src/compiler/codegen/ralloc_util.h
@@ -60,164 +60,164 @@
return mir->ssaRep->uses[num];
}
-extern RegLocation oatEvalLoc(CompilationUnit* cUnit, RegLocation loc,
+extern RegLocation EvalLoc(CompilationUnit* cUnit, RegLocation loc,
int regClass, bool update);
/* Mark a temp register as dead. Does not affect allocation state. */
-extern void oatClobber(CompilationUnit* cUnit, int reg);
-extern RegLocation oatUpdateLoc(CompilationUnit* cUnit, RegLocation loc);
+extern void Clobber(CompilationUnit* cUnit, int reg);
+extern RegLocation UpdateLoc(CompilationUnit* cUnit, RegLocation loc);
/* see comments for updateLoc */
-extern RegLocation oatUpdateLocWide(CompilationUnit* cUnit, RegLocation loc);
+extern RegLocation UpdateLocWide(CompilationUnit* cUnit, RegLocation loc);
-extern RegLocation oatUpdateRawLoc(CompilationUnit* cUnit, RegLocation loc);
+extern RegLocation UpdateRawLoc(CompilationUnit* cUnit, RegLocation loc);
-extern void oatMarkLive(CompilationUnit* cUnit, int reg, int sReg);
+extern void MarkLive(CompilationUnit* cUnit, int reg, int sReg);
-extern void oatMarkTemp(CompilationUnit* cUnit, int reg);
+extern void MarkTemp(CompilationUnit* cUnit, int reg);
-extern void oatUnmarkTemp(CompilationUnit* cUnit, int reg);
+extern void UnmarkTemp(CompilationUnit* cUnit, int reg);
-extern void oatMarkDirty(CompilationUnit* cUnit, RegLocation loc);
+extern void MarkDirty(CompilationUnit* cUnit, RegLocation loc);
-extern void oatMarkPair(CompilationUnit* cUnit, int lowReg, int highReg);
+extern void MarkPair(CompilationUnit* cUnit, int lowReg, int highReg);
-extern void oatMarkClean(CompilationUnit* cUnit, RegLocation loc);
+extern void MarkClean(CompilationUnit* cUnit, RegLocation loc);
-extern void oatResetDef(CompilationUnit* cUnit, int reg);
+extern void ResetDef(CompilationUnit* cUnit, int reg);
-extern void oatResetDefLoc(CompilationUnit* cUnit, RegLocation rl);
+extern void ResetDefLoc(CompilationUnit* cUnit, RegLocation rl);
/* Set up temp & preserved register pools specialized by target */
-extern void oatInitPool(RegisterInfo* regs, int* regNums, int num);
+extern void CompilerInitPool(RegisterInfo* regs, int* regNums, int num);
/*
* Mark the beginning and end LIR of a def sequence. Note that
* on entry start points to the LIR prior to the beginning of the
* sequence.
*/
-extern void oatMarkDef(CompilationUnit* cUnit, RegLocation rl, LIR* start,
+extern void MarkDef(CompilationUnit* cUnit, RegLocation rl, LIR* start,
LIR* finish);
/*
* Mark the beginning and end LIR of a def sequence. Note that
* on entry start points to the LIR prior to the beginning of the
* sequence.
*/
-extern void oatMarkDefWide(CompilationUnit* cUnit, RegLocation rl,
+extern void MarkDefWide(CompilationUnit* cUnit, RegLocation rl,
LIR* start, LIR* finish);
// Get the LocRecord associated with an SSA name use.
-extern RegLocation oatGetSrc(CompilationUnit* cUnit, MIR* mir, int num);
-extern RegLocation oatGetSrcWide(CompilationUnit* cUnit, MIR* mir, int low);
+extern RegLocation GetSrc(CompilationUnit* cUnit, MIR* mir, int num);
+extern RegLocation GetSrcWide(CompilationUnit* cUnit, MIR* mir, int low);
// Non-width checking version
-extern RegLocation oatGetRawSrc(CompilationUnit* cUnit, MIR* mir, int num);
+extern RegLocation GetRawSrc(CompilationUnit* cUnit, MIR* mir, int num);
// Get the LocRecord associated with an SSA name def.
-extern RegLocation oatGetDest(CompilationUnit* cUnit, MIR* mir);
-extern RegLocation oatGetDestWide(CompilationUnit* cUnit, MIR* mir);
+extern RegLocation GetDest(CompilationUnit* cUnit, MIR* mir);
+extern RegLocation GetDestWide(CompilationUnit* cUnit, MIR* mir);
// Non-width checking version
-extern RegLocation oatGetRawDest(CompilationUnit* cUnit, MIR* mir);
+extern RegLocation GetRawDest(CompilationUnit* cUnit, MIR* mir);
-extern RegLocation oatGetReturnWide(CompilationUnit* cUnit, bool isDouble);
+extern RegLocation GetReturnWide(CompilationUnit* cUnit, bool isDouble);
/* Clobber all regs that might be used by an external C call */
-extern void oatClobberCalleeSave(CompilationUnit* cUnit);
+extern void ClobberCalleeSave(CompilationUnit* cUnit);
-extern RegisterInfo *oatIsTemp(CompilationUnit* cUnit, int reg);
+extern RegisterInfo *IsTemp(CompilationUnit* cUnit, int reg);
-extern RegisterInfo *oatIsPromoted(CompilationUnit* cUnit, int reg);
+extern RegisterInfo *IsPromoted(CompilationUnit* cUnit, int reg);
-extern bool oatIsDirty(CompilationUnit* cUnit, int reg);
+extern bool IsDirty(CompilationUnit* cUnit, int reg);
-extern void oatMarkInUse(CompilationUnit* cUnit, int reg);
+extern void MarkInUse(CompilationUnit* cUnit, int reg);
-extern int oatAllocTemp(CompilationUnit* cUnit);
+extern int AllocTemp(CompilationUnit* cUnit);
-extern int oatAllocTempFloat(CompilationUnit* cUnit);
+extern int AllocTempFloat(CompilationUnit* cUnit);
//REDO: too many assumptions.
-extern int oatAllocTempDouble(CompilationUnit* cUnit);
+extern int AllocTempDouble(CompilationUnit* cUnit);
-extern void oatFreeTemp(CompilationUnit* cUnit, int reg);
+extern void FreeTemp(CompilationUnit* cUnit, int reg);
-extern void oatResetDefLocWide(CompilationUnit* cUnit, RegLocation rl);
+extern void ResetDefLocWide(CompilationUnit* cUnit, RegLocation rl);
-extern void oatResetDefTracking(CompilationUnit* cUnit);
+extern void ResetDefTracking(CompilationUnit* cUnit);
-extern RegisterInfo *oatIsLive(CompilationUnit* cUnit, int reg);
+extern RegisterInfo *IsLive(CompilationUnit* cUnit, int reg);
/* To be used when explicitly managing register use */
-extern void oatLockCallTemps(CompilationUnit* cUnit);
+extern void LockCallTemps(CompilationUnit* cUnit);
-extern void oatFreeCallTemps(CompilationUnit* cUnit);
+extern void FreeCallTemps(CompilationUnit* cUnit);
-extern void oatFlushAllRegs(CompilationUnit* cUnit);
+extern void FlushAllRegs(CompilationUnit* cUnit);
-extern RegLocation oatGetReturnWideAlt(CompilationUnit* cUnit);
+extern RegLocation GetReturnWideAlt(CompilationUnit* cUnit);
-extern RegLocation oatGetReturn(CompilationUnit* cUnit, bool isFloat);
+extern RegLocation GetReturn(CompilationUnit* cUnit, bool isFloat);
-extern RegLocation oatGetReturnAlt(CompilationUnit* cUnit);
+extern RegLocation GetReturnAlt(CompilationUnit* cUnit);
/* Clobber any temp associated with an sReg. Could be in either class */
-extern void oatClobberSReg(CompilationUnit* cUnit, int sReg);
+extern void ClobberSReg(CompilationUnit* cUnit, int sReg);
/* Return a temp if one is available, -1 otherwise */
-extern int oatAllocFreeTemp(CompilationUnit* cUnit);
+extern int AllocFreeTemp(CompilationUnit* cUnit);
/* Attempt to allocate a callee-save register */
-extern int oatAllocPreservedCoreReg(CompilationUnit* cUnit, int sreg);
-extern int oatAllocPreservedFPReg(CompilationUnit* cUnit, int sReg,
+extern int AllocPreservedCoreReg(CompilationUnit* cUnit, int sreg);
+extern int AllocPreservedFPReg(CompilationUnit* cUnit, int sReg,
bool doubleStart);
/*
- * Similar to oatAllocTemp(), but forces the allocation of a specific
+ * Similar to AllocTemp(), but forces the allocation of a specific
* register. No check is made to see if the register was previously
* allocated. Use with caution.
*/
-extern void oatLockTemp(CompilationUnit* cUnit, int reg);
+extern void LockTemp(CompilationUnit* cUnit, int reg);
-extern RegLocation oatWideToNarrow(CompilationUnit* cUnit, RegLocation rl);
+extern RegLocation WideToNarrow(CompilationUnit* cUnit, RegLocation rl);
/*
* Free all allocated temps in the temp pools. Note that this does
* not affect the "liveness" of a temp register, which will stay
* live until it is either explicitly killed or reallocated.
*/
-extern void oatResetRegPool(CompilationUnit* cUnit);
+extern void ResetRegPool(CompilationUnit* cUnit);
-extern void oatClobberAllRegs(CompilationUnit* cUnit);
+extern void ClobberAllRegs(CompilationUnit* cUnit);
-extern void oatFlushRegWide(CompilationUnit* cUnit, int reg1, int reg2);
+extern void FlushRegWide(CompilationUnit* cUnit, int reg1, int reg2);
-extern void oatFlushReg(CompilationUnit* cUnit, int reg);
+extern void FlushReg(CompilationUnit* cUnit, int reg);
-extern void oatDoPromotion(CompilationUnit* cUnit);
-extern int oatVRegOffset(CompilationUnit* cUnit, int reg);
-extern int oatSRegOffset(CompilationUnit* cUnit, int reg);
-extern void oatCountRefs(CompilationUnit*, BasicBlock*, RefCounts*, RefCounts*);
-extern int oatSortCounts(const void *val1, const void *val2);
-extern void oatDumpCounts(const RefCounts* arr, int size, const char* msg);
-extern void oatRecordCorePromotion(CompilationUnit* cUnit, int reg, int sReg);
-extern void oatRecordFpPromotion(CompilationUnit* cUnit, int reg, int sReg);
+extern void DoPromotion(CompilationUnit* cUnit);
+extern int VRegOffset(CompilationUnit* cUnit, int reg);
+extern int SRegOffset(CompilationUnit* cUnit, int reg);
+extern void CountRefs(CompilationUnit*, BasicBlock*, RefCounts*, RefCounts*);
+extern int SortCounts(const void *val1, const void *val2);
+extern void DumpCounts(const RefCounts* arr, int size, const char* msg);
+extern void RecordCorePromotion(CompilationUnit* cUnit, int reg, int sReg);
+extern void RecordFpPromotion(CompilationUnit* cUnit, int reg, int sReg);
/* Architecture-dependent register allocation routines. */
-extern int oatAllocTypedTempPair(CompilationUnit* cUnit,
+extern int AllocTypedTempPair(CompilationUnit* cUnit,
bool fpHint, int regClass);
-extern int oatAllocTypedTemp(CompilationUnit* cUnit, bool fpHint, int regClass);
+extern int AllocTypedTemp(CompilationUnit* cUnit, bool fpHint, int regClass);
-extern void oatDumpCoreRegPool(CompilationUnit* cUint);
+extern void DumpCoreRegPool(CompilationUnit* cUint);
extern void oatDumpFPRegPool(CompilationUnit* cUint);
-extern bool oatCheckCorePoolSanity(CompilationUnit* cUnit);
-extern RegisterInfo* oatGetRegInfo(CompilationUnit* cUnit, int reg);
-extern void oatNopLIR(LIR* lir);
+extern bool CheckCorePoolSanity(CompilationUnit* cUnit);
+extern RegisterInfo* GetRegInfo(CompilationUnit* cUnit, int reg);
+extern void NopLIR(LIR* lir);
extern bool oatIsFPReg(int reg);
extern uint32_t oatFPRegMask(void);
-extern void oatAdjustSpillMask(CompilationUnit* cUnit);
-void oatMarkPreservedSingle(CompilationUnit* cUnit, int vReg, int reg);
-int oatComputeFrameSize(CompilationUnit* cUnit);
+extern void AdjustSpillMask(CompilationUnit* cUnit);
+void MarkPreservedSingle(CompilationUnit* cUnit, int vReg, int reg);
+int ComputeFrameSize(CompilationUnit* cUnit);
} // namespace art
diff --git a/src/compiler/codegen/target_list.h b/src/compiler/codegen/target_list.h
index 5fc3891..970be2d 100644
--- a/src/compiler/codegen/target_list.h
+++ b/src/compiler/codegen/target_list.h
@@ -1,146 +1,146 @@
-ArmConditionCode oatArmConditionEncoding(ConditionCode code);
-AssemblerStatus oatAssembleInstructions(CompilationUnit* cUnit, uintptr_t startAddr);
-bool doubleReg(int reg);
-bool fpReg(int reg);
-bool genAddLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool genAndLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool genArithOpDouble(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool genArithOpFloat(CompilationUnit *cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool genArithOpFloat(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool genCmpFP(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool genConversion(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc);
-bool genInlinedCas32(CompilationUnit* cUnit, CallInfo* info, bool need_write_barrier);
-bool genInlinedMinMaxInt(CompilationUnit *cUnit, CallInfo* info, bool isMin);
-bool genInlinedSqrt(CompilationUnit* cUnit, CallInfo* info);
-bool genNegLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
-bool genOrLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool genSubLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool genXorLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-bool oatArchInit();
-bool oatArchVariantInit(void);
-bool oatIsFpReg(int reg);
-bool sameRegType(int reg1, int reg2);
-bool singleReg(int reg);
-bool smallLiteralDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode, RegLocation rlSrc, RegLocation rlDest, int lit);
-char* decodeFPCSRegList(int count, int base, char* buf);
-char* decodeRegList(int opcode, int vector, char* buf);
-RegisterInfo* oatGetRegInfo(CompilationUnit* cUnit, int reg);
-RegLocation oatGetReturnAlt(CompilationUnit* cUnit);
-RegLocation oatGetReturnWideAlt(CompilationUnit* cUnit);
-void oatClobberCalleeSave(CompilationUnit *cUnit);
-void oatFreeCallTemps(CompilationUnit* cUnit);
-void oatLockCallTemps(CompilationUnit* cUnit);
-InstructionSet oatInstructionSet();
-int encodeImmDoubleHigh(int value);
-int encodeImmDouble(int valLo, int valHi);
-int encodeImmSingle(int value);
-int encodeShift(int code, int amount);
-int expandImmediate(int value);
-int inPosition(CompilationUnit* cUnit, int sReg);
-int leadingZeros(uint32_t val);
-int loadHelper(CompilationUnit* cUnit, int offset);
-int modifiedImmediate(uint32_t value);
-int oatAllocTypedTemp(CompilationUnit* cUnit, bool fpHint, int regClass);
-int oatAllocTypedTempPair(CompilationUnit* cUnit, bool fpHint, int regClass);
-int oatAssignInsnOffsets(CompilationUnit* cUnit);
-int oatGetInsnSize(LIR* lir);
-int s2d(int lowReg, int highReg);
-int targetReg(SpecialTargetRegister reg);
-LIR* fpRegCopy(CompilationUnit* cUnit, int rDest, int rSrc);
-LIR* genRegMemCheck(CompilationUnit* cUnit, ConditionCode cCode, int reg1, int base, int offset, ThrowKind kind);
-LIR* loadBaseDispBody(CompilationUnit* cUnit, int rBase, int displacement, int rDest, int rDestHi, OpSize size, int sReg);
-LIR* loadBaseDisp(CompilationUnit* cUnit, int rBase, int displacement, int rDest, OpSize size, int sReg);
-LIR* loadBaseDispWide(CompilationUnit* cUnit, int rBase, int displacement, int rDestLo, int rDestHi, int sReg);
-LIR* loadBaseIndexed(CompilationUnit* cUnit, int rBase, int rIndex, int rDest, int scale, OpSize size);
-LIR* loadBaseIndexedDisp(CompilationUnit *cUnit, int rBase, int rIndex, int scale, int displacement, int rDest, int rDestHi, OpSize size, int sReg);
-LIR* loadConstantNoClobber(CompilationUnit* cUnit, int rDest, int value);
-LIR* loadConstantValueWide(CompilationUnit* cUnit, int rDestLo, int rDestHi, int valLo, int valHi);
-LIR* loadFPConstantValue(CompilationUnit* cUnit, int rDest, int value);
-LIR* loadMultiple(CompilationUnit *cUnit, int rBase, int rMask);
-LIR* opBranchUnconditional(CompilationUnit* cUnit, OpKind op);
-LIR* opCmpBranch(CompilationUnit* cUnit, ConditionCode cond, int src1, int src2, LIR* target);
-LIR* opCmpImmBranch(CompilationUnit* cUnit, ConditionCode cond, int reg, int checkValue, LIR* target);
-LIR* opCondBranch(CompilationUnit* cUnit, ConditionCode cc, LIR* target);
-LIR* opDecAndBranch(CompilationUnit* cUnit, ConditionCode cCode, int reg, LIR* target);
-LIR* opIT(CompilationUnit* cUnit, ArmConditionCode cond, const char* guide);
-LIR* opMem(CompilationUnit* cUnit, OpKind op, int rBase, int disp);
-LIR* opPcRelLoad(CompilationUnit* cUnit, int reg, LIR* target);
-LIR* opReg(CompilationUnit* cUnit, OpKind op, int rDestSrc);
-LIR* opRegCopy(CompilationUnit* cUnit, int rDest, int rSrc);
-LIR* opRegCopyNoInsert(CompilationUnit* cUnit, int rDest, int rSrc);
-LIR* opRegImm(CompilationUnit* cUnit, OpKind op, int rDestSrc1, int value);
-LIR* opRegMem(CompilationUnit* cUnit, OpKind op, int rDest, int rBase, int offset);
-LIR* opRegReg(CompilationUnit* cUnit, OpKind op, int rDestSrc1, int rSrc2);
-LIR* opRegRegImm(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1, int value);
-LIR* opRegRegReg(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1, int rSrc2);
-LIR* opRegRegRegShift(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1, int rSrc2, int shift);
-LIR* opRegRegShift(CompilationUnit* cUnit, OpKind op, int rDestSrc1, int rSrc2, int shift);
-LIR* opTestSuspend(CompilationUnit* cUnit, LIR* target);
-LIR* opThreadMem(CompilationUnit* cUnit, OpKind op, int threadOffset);
-LIR* opVldm(CompilationUnit* cUnit, int rBase, int count);
-LIR* opVstm(CompilationUnit* cUnit, int rBase, int count);
-LIR* storeBaseDispBody(CompilationUnit* cUnit, int rBase, int displacement, int rSrc, int rSrcHi, OpSize size);
-LIR* storeBaseDisp(CompilationUnit* cUnit, int rBase, int displacement, int rSrc, OpSize size);
-LIR* storeBaseDispWide(CompilationUnit* cUnit, int rBase, int displacement, int rSrcLo, int rSrcHi);
-LIR* storeBaseIndexed(CompilationUnit* cUnit, int rBase, int rIndex, int rSrc, int scale, OpSize size);
-LIR* storeBaseIndexedDisp(CompilationUnit *cUnit, int rBase, int rIndex, int scale, int displacement, int rSrc, int rSrcHi, OpSize size, int sReg);
-LIR* storeMultiple(CompilationUnit *cUnit, int rBase, int rMask);
-MIR* getNextMir(CompilationUnit* cUnit, BasicBlock** pBb, MIR* mir);
-MIR* specialIdentity(CompilationUnit* cUnit, MIR* mir);
-MIR* specialIGet(CompilationUnit* cUnit, BasicBlock** bb, MIR* mir, OpSize size, bool longOrDouble, bool isObject);
-MIR* specialIPut(CompilationUnit* cUnit, BasicBlock** bb, MIR* mir, OpSize size, bool longOrDouble, bool isObject);
-RegLocation argLoc(CompilationUnit* cUnit, RegLocation loc);
-RegLocation genDivRem(CompilationUnit* cUnit, RegLocation rlDest, int regLo, int regHi, bool isDiv);
-RegLocation genDivRemLit(CompilationUnit* cUnit, RegLocation rlDest, int regLo, int lit, bool isDiv);
-RegLocation loadArg(CompilationUnit* cUnit, RegLocation loc);
-RegLocation locCReturn();
-RegLocation locCReturnDouble();
-RegLocation locCReturnFloat();
-RegLocation locCReturnWide();
-std::string buildInsnString(const char* fmt, LIR* lir, unsigned char* baseAddr);
-uint64_t getRegMaskCommon(CompilationUnit* cUnit, int reg);
-uint32_t fpRegMask();
-uint32_t oatFpRegMask();
-uint64_t getPCUseDefEncoding();
-void convertShortToLongBranch(CompilationUnit* cUnit, LIR* lir);
-void freeRegLocTemps(CompilationUnit* cUnit, RegLocation rlKeep, RegLocation rlFree);
-void genCmpLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
-void genDivZeroCheck(CompilationUnit* cUnit, int regLo, int regHi);
-void genEntrySequence(CompilationUnit* cUnit, RegLocation* argLocs, RegLocation rlMethod);
-void genExitSequence(CompilationUnit* cUnit);
-void genFillArrayData(CompilationUnit* cUnit, uint32_t tableOffset, RegLocation rlSrc);
-void genFusedFPCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir, bool gtBias, bool isDouble);
-void genFusedLongCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir);
-void genMonitorEnter(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc);
-void genMonitorExit(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc);
-void genMultiplyByTwoBitMultiplier(CompilationUnit* cUnit, RegLocation rlSrc, RegLocation rlResult, int lit, int firstBit, int secondBit);
-void genNegDouble(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
-void genNegFloat(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
-void genPackedSwitch(CompilationUnit* cUnit, uint32_t tableOffset, RegLocation rlSrc);
-void genPrintLabel(CompilationUnit *cUnit, MIR* mir);
-void genSparseSwitch(CompilationUnit* cUnit, uint32_t tableOffset, RegLocation rlSrc);
-void genSpecialCase(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir, SpecialCaseHandler specialCase);
-void loadPair(CompilationUnit* cUnit, int base, int lowReg, int highReg);
-void lockLiveArgs(CompilationUnit* cUnit, MIR* mir);
-void markGCCard(CompilationUnit* cUnit, int valReg, int tgtAddrReg);
-void oatAdjustSpillMask(CompilationUnit* cUnit);
-void oatClobberCalleeSave(CompilationUnit *cUnit);
-void oatDumpResourceMask(LIR* lir, uint64_t mask, const char* prefix);
-void oatFlushReg(CompilationUnit* cUnit, int reg);
-void oatFlushRegWide(CompilationUnit* cUnit, int reg1, int reg2);
-void oatGenMemBarrier(CompilationUnit* cUnit, MemBarrierKind barrierKind);
-void oatInitializeRegAlloc(CompilationUnit* cUnit);
-void oatMarkPreservedSingle(CompilationUnit* cUnit, int vReg, int reg);
-void oatNopLIR( LIR* lir);
-void opLea(CompilationUnit* cUnit, int rBase, int reg1, int reg2, int scale, int offset);
-void opRegCopyWide(CompilationUnit* cUnit, int destLo, int destHi, int srcLo, int srcHi);
-void opRegThreadMem(CompilationUnit* cUnit, OpKind op, int rDest, int threadOffset);
-void opTlsCmp(CompilationUnit* cUnit, int offset, int val);
-bool branchUnconditional(LIR* lir);
-void setupTargetResourceMasks(CompilationUnit* cUnit, LIR* lir);
-void spillCoreRegs(CompilationUnit* cUnit);
-void unSpillCoreRegs(CompilationUnit* cUnit);
-X86ConditionCode oatX86ConditionEncoding(ConditionCode cond);
-uint64_t getTargetInstFlags(int opcode);
-const char* getTargetInstName(int opcode);
-const char* getTargetInstFmt(int opcode);
+ArmConditionCode ArmConditionEncoding(ConditionCode code);
+AssemblerStatus AssembleInstructions(CompilationUnit* cUnit, uintptr_t startAddr);
+bool DoubleReg(int reg);
+bool FpReg(int reg);
+bool GenAddLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool GenAndLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool GenArithOpDouble(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool GenArithOpFloat(CompilationUnit *cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool GenArithOpFloat(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool GenCmpFP(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool GenConversion(CompilationUnit* cUnit, Instruction::Code opcode, RegLocation rlDest, RegLocation rlSrc);
+bool GenInlinedCas32(CompilationUnit* cUnit, CallInfo* info, bool need_write_barrier);
+bool GenInlinedMinMaxInt(CompilationUnit *cUnit, CallInfo* info, bool isMin);
+bool GenInlinedSqrt(CompilationUnit* cUnit, CallInfo* info);
+bool GenNegLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
+bool GenOrLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool GenSubLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool GenXorLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+bool ArchInit();
+bool ArchVariantInit(void);
+bool IsFpReg(int reg);
+bool SameRegType(int reg1, int reg2);
+bool SingleReg(int reg);
+bool SmallLiteralDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode, RegLocation rlSrc, RegLocation rlDest, int lit);
+char* DecodeFPCSRegList(int count, int base, char* buf);
+char* DecodeRegList(int opcode, int vector, char* buf);
+RegisterInfo* GetRegInfo(CompilationUnit* cUnit, int reg);
+RegLocation GetReturnAlt(CompilationUnit* cUnit);
+RegLocation GetReturnWideAlt(CompilationUnit* cUnit);
+void ClobberCalleeSave(CompilationUnit *cUnit);
+void FreeCallTemps(CompilationUnit* cUnit);
+void LockCallTemps(CompilationUnit* cUnit);
+InstructionSet InstructionSet();
+int EncodeImmDoubleHigh(int value);
+int EncodeImmDouble(int valLo, int valHi);
+int EncodeImmSingle(int value);
+int EncodeShift(int code, int amount);
+int ExpandImmediate(int value);
+int InPosition(CompilationUnit* cUnit, int sReg);
+int LeadingZeros(uint32_t val);
+int LoadHelper(CompilationUnit* cUnit, int offset);
+int ModifiedImmediate(uint32_t value);
+int AllocTypedTemp(CompilationUnit* cUnit, bool fpHint, int regClass);
+int AllocTypedTempPair(CompilationUnit* cUnit, bool fpHint, int regClass);
+int AssignInsnOffsets(CompilationUnit* cUnit);
+int GetInsnSize(LIR* lir);
+int S2d(int lowReg, int highReg);
+int TargetReg(SpecialTargetRegister reg);
+LIR* FpRegCopy(CompilationUnit* cUnit, int rDest, int rSrc);
+LIR* GenRegMemCheck(CompilationUnit* cUnit, ConditionCode cCode, int reg1, int base, int offset, ThrowKind kind);
+LIR* LoadBaseDispBody(CompilationUnit* cUnit, int rBase, int displacement, int rDest, int rDestHi, OpSize size, int sReg);
+LIR* LoadBaseDisp(CompilationUnit* cUnit, int rBase, int displacement, int rDest, OpSize size, int sReg);
+LIR* LoadBaseDispWide(CompilationUnit* cUnit, int rBase, int displacement, int rDestLo, int rDestHi, int sReg);
+LIR* LoadBaseIndexed(CompilationUnit* cUnit, int rBase, int rIndex, int rDest, int scale, OpSize size);
+LIR* LoadBaseIndexedDisp(CompilationUnit *cUnit, int rBase, int rIndex, int scale, int displacement, int rDest, int rDestHi, OpSize size, int sReg);
+LIR* LoadConstantNoClobber(CompilationUnit* cUnit, int rDest, int value);
+LIR* LoadConstantValueWide(CompilationUnit* cUnit, int rDestLo, int rDestHi, int valLo, int valHi);
+LIR* LoadFPConstantValue(CompilationUnit* cUnit, int rDest, int value);
+LIR* LoadMultiple(CompilationUnit *cUnit, int rBase, int rMask);
+LIR* OpBranchUnconditional(CompilationUnit* cUnit, OpKind op);
+LIR* OpCmpBranch(CompilationUnit* cUnit, ConditionCode cond, int src1, int src2, LIR* target);
+LIR* OpCmpImmBranch(CompilationUnit* cUnit, ConditionCode cond, int reg, int checkValue, LIR* target);
+LIR* OpCondBranch(CompilationUnit* cUnit, ConditionCode cc, LIR* target);
+LIR* OpDecAndBranch(CompilationUnit* cUnit, ConditionCode cCode, int reg, LIR* target);
+LIR* OpIT(CompilationUnit* cUnit, ArmConditionCode cond, const char* guide);
+LIR* OpMem(CompilationUnit* cUnit, OpKind op, int rBase, int disp);
+LIR* OpPcRelLoad(CompilationUnit* cUnit, int reg, LIR* target);
+LIR* OpReg(CompilationUnit* cUnit, OpKind op, int rDestSrc);
+LIR* OpRegCopy(CompilationUnit* cUnit, int rDest, int rSrc);
+LIR* OpRegCopyNoInsert(CompilationUnit* cUnit, int rDest, int rSrc);
+LIR* OpRegImm(CompilationUnit* cUnit, OpKind op, int rDestSrc1, int value);
+LIR* OpRegMem(CompilationUnit* cUnit, OpKind op, int rDest, int rBase, int offset);
+LIR* OpRegReg(CompilationUnit* cUnit, OpKind op, int rDestSrc1, int rSrc2);
+LIR* OpRegRegImm(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1, int value);
+LIR* OpRegRegReg(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1, int rSrc2);
+LIR* OpRegRegRegShift(CompilationUnit* cUnit, OpKind op, int rDest, int rSrc1, int rSrc2, int shift);
+LIR* OpRegRegShift(CompilationUnit* cUnit, OpKind op, int rDestSrc1, int rSrc2, int shift);
+LIR* OpTestSuspend(CompilationUnit* cUnit, LIR* target);
+LIR* OpThreadMem(CompilationUnit* cUnit, OpKind op, int threadOffset);
+LIR* OpVldm(CompilationUnit* cUnit, int rBase, int count);
+LIR* OpVstm(CompilationUnit* cUnit, int rBase, int count);
+LIR* StoreBaseDispBody(CompilationUnit* cUnit, int rBase, int displacement, int rSrc, int rSrcHi, OpSize size);
+LIR* StoreBaseDisp(CompilationUnit* cUnit, int rBase, int displacement, int rSrc, OpSize size);
+LIR* StoreBaseDispWide(CompilationUnit* cUnit, int rBase, int displacement, int rSrcLo, int rSrcHi);
+LIR* StoreBaseIndexed(CompilationUnit* cUnit, int rBase, int rIndex, int rSrc, int scale, OpSize size);
+LIR* StoreBaseIndexedDisp(CompilationUnit *cUnit, int rBase, int rIndex, int scale, int displacement, int rSrc, int rSrcHi, OpSize size, int sReg);
+LIR* StoreMultiple(CompilationUnit *cUnit, int rBase, int rMask);
+MIR* GetNextMir(CompilationUnit* cUnit, BasicBlock** pBb, MIR* mir);
+MIR* SpecialIdentity(CompilationUnit* cUnit, MIR* mir);
+MIR* SpecialIGet(CompilationUnit* cUnit, BasicBlock** bb, MIR* mir, OpSize size, bool longOrDouble, bool isObject);
+MIR* SpecialIPut(CompilationUnit* cUnit, BasicBlock** bb, MIR* mir, OpSize size, bool longOrDouble, bool isObject);
+RegLocation ArgLoc(CompilationUnit* cUnit, RegLocation loc);
+RegLocation GenDivRem(CompilationUnit* cUnit, RegLocation rlDest, int regLo, int regHi, bool isDiv);
+RegLocation GenDivRemLit(CompilationUnit* cUnit, RegLocation rlDest, int regLo, int lit, bool isDiv);
+RegLocation LoadArg(CompilationUnit* cUnit, RegLocation loc);
+RegLocation LocCReturn();
+RegLocation LocCReturnDouble();
+RegLocation LocCReturnFloat();
+RegLocation LocCReturnWide();
+std::string BuildInsnString(const char* fmt, LIR* lir, unsigned char* baseAddr);
+uint64_t GetRegMaskCommon(CompilationUnit* cUnit, int reg);
+uint32_t FpRegMask();
+uint32_t FpRegMask();
+uint64_t GetPCUseDefEncoding();
+void ConvertShortToLongBranch(CompilationUnit* cUnit, LIR* lir);
+void FreeRegLocTemps(CompilationUnit* cUnit, RegLocation rlKeep, RegLocation rlFree);
+void GenCmpLong(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2);
+void GenDivZeroCheck(CompilationUnit* cUnit, int regLo, int regHi);
+void GenEntrySequence(CompilationUnit* cUnit, RegLocation* ArgLocs, RegLocation rlMethod);
+void GenExitSequence(CompilationUnit* cUnit);
+void GenFillArrayData(CompilationUnit* cUnit, uint32_t tableOffset, RegLocation rlSrc);
+void GenFusedFPCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir, bool gtBias, bool isDouble);
+void GenFusedLongCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir);
+void GenMonitorEnter(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc);
+void GenMonitorExit(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc);
+void GenMultiplyByTwoBitMultiplier(CompilationUnit* cUnit, RegLocation rlSrc, RegLocation rlResult, int lit, int firstBit, int secondBit);
+void GenNegDouble(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
+void GenNegFloat(CompilationUnit* cUnit, RegLocation rlDest, RegLocation rlSrc);
+void GenPackedSwitch(CompilationUnit* cUnit, uint32_t tableOffset, RegLocation rlSrc);
+void GenPrintLabel(CompilationUnit *cUnit, MIR* mir);
+void GenSparseSwitch(CompilationUnit* cUnit, uint32_t tableOffset, RegLocation rlSrc);
+void GenSpecialCase(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir, SpecialCaseHandler specialCase);
+void LoadPair(CompilationUnit* cUnit, int base, int lowReg, int highReg);
+void LockLiveArgs(CompilationUnit* cUnit, MIR* mir);
+void MarkGCCard(CompilationUnit* cUnit, int valReg, int tgtAddrReg);
+void AdjustSpillMask(CompilationUnit* cUnit);
+void ClobberCalleeSave(CompilationUnit *cUnit);
+void DumpResourceMask(LIR* lir, uint64_t mask, const char* prefix);
+void FlushReg(CompilationUnit* cUnit, int reg);
+void FlushRegWide(CompilationUnit* cUnit, int reg1, int reg2);
+void GenMemBarrier(CompilationUnit* cUnit, MemBarrierKind barrierKind);
+void CompilerInitializeRegAlloc(CompilationUnit* cUnit);
+void MarkPreservedSingle(CompilationUnit* cUnit, int vReg, int reg);
+void NopLIR( LIR* lir);
+void OpLea(CompilationUnit* cUnit, int rBase, int reg1, int reg2, int scale, int offset);
+void OpRegCopyWide(CompilationUnit* cUnit, int destLo, int destHi, int srcLo, int srcHi);
+void OpRegThreadMem(CompilationUnit* cUnit, OpKind op, int rDest, int threadOffset);
+void OpTlsCmp(CompilationUnit* cUnit, int offset, int val);
+bool BranchUnconditional(LIR* lir);
+void SetupTargetResourceMasks(CompilationUnit* cUnit, LIR* lir);
+void SpillCoreRegs(CompilationUnit* cUnit);
+void UnSpillCoreRegs(CompilationUnit* cUnit);
+X86ConditionCode X86ConditionEncoding(ConditionCode cond);
+uint64_t GetTargetInstFlags(int opcode);
+const char* GetTargetInstName(int opcode);
+const char* GetTargetInstFmt(int opcode);
diff --git a/src/compiler/codegen/x86/assemble_x86.cc b/src/compiler/codegen/x86/assemble_x86.cc
index 0c2ff0d..50300a5 100644
--- a/src/compiler/codegen/x86/assemble_x86.cc
+++ b/src/compiler/codegen/x86/assemble_x86.cc
@@ -329,7 +329,7 @@
{ kX86PcRelAdr, kPcRel, IS_LOAD | IS_BINARY_OP | REG_DEF0, { 0, 0, 0xB8, 0, 0, 0, 0, 4 }, "PcRelAdr", "!0r,!1d" },
};
-static size_t computeSize(X86EncodingMap* entry, int displacement, bool has_sib) {
+static size_t ComputeSize(X86EncodingMap* entry, int displacement, bool has_sib) {
size_t size = 0;
if (entry->skeleton.prefix1 > 0) {
++size;
@@ -358,7 +358,7 @@
return size;
}
-int oatGetInsnSize(LIR* lir) {
+int GetInsnSize(LIR* lir) {
X86EncodingMap* entry = &EncodingMap[lir->opcode];
switch (entry->kind) {
case kData:
@@ -368,48 +368,48 @@
case kNullary:
return 1; // 1 byte of opcode
case kReg: // lir operands - 0: reg
- return computeSize(entry, 0, false);
+ return ComputeSize(entry, 0, false);
case kMem: { // lir operands - 0: base, 1: disp
int base = lir->operands[0];
int disp = lir->operands[1];
// SP requires a special extra SIB byte. BP requires explicit disp,
// so add a byte for disp 0 which would normally be omitted.
- return computeSize(entry, disp, false) + ((base == rX86_SP) || (base == rBP && disp == 0) ? 1 : 0);
+ return ComputeSize(entry, disp, false) + ((base == rX86_SP) || (base == rBP && disp == 0) ? 1 : 0);
}
case kArray: // lir operands - 0: base, 1: index, 2: scale, 3: disp
- return computeSize(entry, lir->operands[3], true);
+ return ComputeSize(entry, lir->operands[3], true);
case kMemReg: { // lir operands - 0: base, 1: disp, 2: reg
int base = lir->operands[0];
int disp = lir->operands[1];
// SP requires a special extra SIB byte. BP requires explicit disp,
// so add a byte for disp 0 which would normally be omitted.
- return computeSize(entry, disp, false) + ((base == rX86_SP) || (base == rBP && disp == 0) ? 1 : 0);
+ return ComputeSize(entry, disp, false) + ((base == rX86_SP) || (base == rBP && disp == 0) ? 1 : 0);
}
case kArrayReg: // lir operands - 0: base, 1: index, 2: scale, 3: disp, 4: reg
- return computeSize(entry, lir->operands[3], true);
+ return ComputeSize(entry, lir->operands[3], true);
case kThreadReg: // lir operands - 0: disp, 1: reg
- return computeSize(entry, lir->operands[0], false);
+ return ComputeSize(entry, lir->operands[0], false);
case kRegReg:
- return computeSize(entry, 0, false);
+ return ComputeSize(entry, 0, false);
case kRegRegStore:
- return computeSize(entry, 0, false);
+ return ComputeSize(entry, 0, false);
case kRegMem: { // lir operands - 0: reg, 1: base, 2: disp
int base = lir->operands[1];
int disp = lir->operands[2];
// SP requires a special extra SIB byte. BP requires explicit disp,
// so add a byte for disp 0 which would normally be omitted.
- return computeSize(entry, disp, false) + ((base == rX86_SP) || (base == rBP && disp == 0) ? 1 : 0);
+ return ComputeSize(entry, disp, false) + ((base == rX86_SP) || (base == rBP && disp == 0) ? 1 : 0);
}
case kRegArray: { // lir operands - 0: reg, 1: base, 2: index, 3: scale, 4: disp
int base = lir->operands[1];
int disp = lir->operands[4];
// BP requires explicit disp, so add a byte for disp 0 which would normally be omitted.
- return computeSize(entry, disp, true) + ((base == rBP && disp == 0) ? 1 : 0);
+ return ComputeSize(entry, disp, true) + ((base == rBP && disp == 0) ? 1 : 0);
}
case kRegThread: // lir operands - 0: reg, 1: disp
- return computeSize(entry, 0x12345678, false); // displacement size is always 32bit
+ return ComputeSize(entry, 0x12345678, false); // displacement size is always 32bit
case kRegImm: { // lir operands - 0: reg, 1: immediate
- size_t size = computeSize(entry, 0, false);
+ size_t size = ComputeSize(entry, 0, false);
if (entry->skeleton.ax_opcode == 0) {
return size;
} else {
@@ -420,44 +420,44 @@
}
case kMemImm: // lir operands - 0: base, 1: disp, 2: immediate
CHECK_NE(lir->operands[0], static_cast<int>(rX86_SP)); // TODO: add extra SIB byte
- return computeSize(entry, lir->operands[1], false);
+ return ComputeSize(entry, lir->operands[1], false);
case kArrayImm: // lir operands - 0: base, 1: index, 2: scale, 3: disp 4: immediate
- return computeSize(entry, lir->operands[3], true);
+ return ComputeSize(entry, lir->operands[3], true);
case kThreadImm: // lir operands - 0: disp, 1: imm
- return computeSize(entry, 0x12345678, false); // displacement size is always 32bit
+ return ComputeSize(entry, 0x12345678, false); // displacement size is always 32bit
case kRegRegImm: // lir operands - 0: reg, 1: reg, 2: imm
- return computeSize(entry, 0, false);
+ return ComputeSize(entry, 0, false);
case kRegMemImm: // lir operands - 0: reg, 1: base, 2: disp, 3: imm
CHECK_NE(lir->operands[1], static_cast<int>(rX86_SP)); // TODO: add extra SIB byte
- return computeSize(entry, lir->operands[2], false);
+ return ComputeSize(entry, lir->operands[2], false);
case kRegArrayImm: // lir operands - 0: reg, 1: base, 2: index, 3: scale, 4: disp, 5: imm
- return computeSize(entry, lir->operands[4], true);
+ return ComputeSize(entry, lir->operands[4], true);
case kMovRegImm: // lir operands - 0: reg, 1: immediate
return 1 + entry->skeleton.immediate_bytes;
case kShiftRegImm: // lir operands - 0: reg, 1: immediate
// Shift by immediate one has a shorter opcode.
- return computeSize(entry, 0, false) - (lir->operands[1] == 1 ? 1 : 0);
+ return ComputeSize(entry, 0, false) - (lir->operands[1] == 1 ? 1 : 0);
case kShiftMemImm: // lir operands - 0: base, 1: disp, 2: immediate
CHECK_NE(lir->operands[0], static_cast<int>(rX86_SP)); // TODO: add extra SIB byte
// Shift by immediate one has a shorter opcode.
- return computeSize(entry, lir->operands[1], false) - (lir->operands[2] == 1 ? 1 : 0);
+ return ComputeSize(entry, lir->operands[1], false) - (lir->operands[2] == 1 ? 1 : 0);
case kShiftArrayImm: // lir operands - 0: base, 1: index, 2: scale, 3: disp 4: immediate
// Shift by immediate one has a shorter opcode.
- return computeSize(entry, lir->operands[3], true) - (lir->operands[4] == 1 ? 1 : 0);
+ return ComputeSize(entry, lir->operands[3], true) - (lir->operands[4] == 1 ? 1 : 0);
case kShiftRegCl:
- return computeSize(entry, 0, false);
+ return ComputeSize(entry, 0, false);
case kShiftMemCl: // lir operands - 0: base, 1: disp, 2: cl
CHECK_NE(lir->operands[0], static_cast<int>(rX86_SP)); // TODO: add extra SIB byte
- return computeSize(entry, lir->operands[1], false);
+ return ComputeSize(entry, lir->operands[1], false);
case kShiftArrayCl: // lir operands - 0: base, 1: index, 2: scale, 3: disp, 4: reg
- return computeSize(entry, lir->operands[3], true);
+ return ComputeSize(entry, lir->operands[3], true);
case kRegCond: // lir operands - 0: reg, 1: cond
- return computeSize(entry, 0, false);
+ return ComputeSize(entry, 0, false);
case kMemCond: // lir operands - 0: base, 1: disp, 2: cond
CHECK_NE(lir->operands[0], static_cast<int>(rX86_SP)); // TODO: add extra SIB byte
- return computeSize(entry, lir->operands[1], false);
+ return ComputeSize(entry, lir->operands[1], false);
case kArrayCond: // lir operands - 0: base, 1: index, 2: scale, 3: disp, 4: cond
- return computeSize(entry, lir->operands[3], true);
+ return ComputeSize(entry, lir->operands[3], true);
case kJcc:
if (lir->opcode == kX86Jcc8) {
return 2; // opcode + rel8
@@ -478,11 +478,11 @@
switch (lir->opcode) {
case kX86CallR: return 2; // opcode modrm
case kX86CallM: // lir operands - 0: base, 1: disp
- return computeSize(entry, lir->operands[1], false);
+ return ComputeSize(entry, lir->operands[1], false);
case kX86CallA: // lir operands - 0: base, 1: index, 2: scale, 3: disp
- return computeSize(entry, lir->operands[3], true);
+ return ComputeSize(entry, lir->operands[3], true);
case kX86CallT: // lir operands - 0: disp
- return computeSize(entry, 0x12345678, false); // displacement size is always 32bit
+ return ComputeSize(entry, 0x12345678, false); // displacement size is always 32bit
default:
break;
}
@@ -490,7 +490,7 @@
case kPcRel:
if (entry->opcode == kX86PcRelLoadRA) {
// lir operands - 0: reg, 1: base, 2: index, 3: scale, 4: table
- return computeSize(entry, 0x12345678, true);
+ return ComputeSize(entry, 0x12345678, true);
} else {
DCHECK(entry->opcode == kX86PcRelAdr);
return 5; // opcode with reg + 4 byte immediate
@@ -498,7 +498,7 @@
case kMacro:
DCHECK_EQ(lir->opcode, static_cast<int>(kX86StartOfMethod));
return 5 /* call opcode + 4 byte displacement */ + 1 /* pop reg */ +
- computeSize(&EncodingMap[kX86Sub32RI], 0, false) -
+ ComputeSize(&EncodingMap[kX86Sub32RI], 0, false) -
(lir->operands[0] == rAX ? 1 : 0); // shorter ax encoding
default:
break;
@@ -507,7 +507,7 @@
return 0;
}
-static uint8_t modrmForDisp(int base, int disp) {
+static uint8_t ModrmForDisp(int base, int disp) {
// BP requires an explicit disp, so do not omit it in the 0 case
if (disp == 0 && base != rBP) {
return 0;
@@ -518,7 +518,7 @@
}
}
-static void emitDisp(CompilationUnit* cUnit, int base, int disp) {
+static void EmitDisp(CompilationUnit* cUnit, int base, int disp) {
// BP requires an explicit disp, so do not omit it in the 0 case
if (disp == 0 && base != rBP) {
return;
@@ -532,7 +532,7 @@
}
}
-static void emitOpReg(CompilationUnit* cUnit, const X86EncodingMap* entry, uint8_t reg) {
+static void EmitOpReg(CompilationUnit* cUnit, const X86EncodingMap* entry, uint8_t reg) {
if (entry->skeleton.prefix1 != 0) {
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
if (entry->skeleton.prefix2 != 0) {
@@ -567,7 +567,7 @@
DCHECK_EQ(0, entry->skeleton.immediate_bytes);
}
-static void emitOpMem(CompilationUnit* cUnit, const X86EncodingMap* entry, uint8_t base, int disp) {
+static void EmitOpMem(CompilationUnit* cUnit, const X86EncodingMap* entry, uint8_t base, int disp) {
if (entry->skeleton.prefix1 != 0) {
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
if (entry->skeleton.prefix2 != 0) {
@@ -581,14 +581,14 @@
DCHECK_EQ(0, entry->skeleton.extra_opcode2);
DCHECK_LT(entry->skeleton.modrm_opcode, 8);
DCHECK_LT(base, 8);
- uint8_t modrm = (modrmForDisp(base, disp) << 6) | (entry->skeleton.modrm_opcode << 3) | base;
+ uint8_t modrm = (ModrmForDisp(base, disp) << 6) | (entry->skeleton.modrm_opcode << 3) | base;
cUnit->codeBuffer.push_back(modrm);
- emitDisp(cUnit, base, disp);
+ EmitDisp(cUnit, base, disp);
DCHECK_EQ(0, entry->skeleton.ax_opcode);
DCHECK_EQ(0, entry->skeleton.immediate_bytes);
}
-static void emitMemReg(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitMemReg(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t base, int disp, uint8_t reg) {
if (entry->skeleton.prefix1 != 0) {
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
@@ -619,25 +619,25 @@
}
DCHECK_LT(reg, 8);
DCHECK_LT(base, 8);
- uint8_t modrm = (modrmForDisp(base, disp) << 6) | (reg << 3) | base;
+ uint8_t modrm = (ModrmForDisp(base, disp) << 6) | (reg << 3) | base;
cUnit->codeBuffer.push_back(modrm);
if (base == rX86_SP) {
// Special SIB for SP base
cUnit->codeBuffer.push_back(0 << 6 | (rX86_SP << 3) | rX86_SP);
}
- emitDisp(cUnit, base, disp);
+ EmitDisp(cUnit, base, disp);
DCHECK_EQ(0, entry->skeleton.modrm_opcode);
DCHECK_EQ(0, entry->skeleton.ax_opcode);
DCHECK_EQ(0, entry->skeleton.immediate_bytes);
}
-static void emitRegMem(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitRegMem(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t reg, uint8_t base, int disp) {
// Opcode will flip operands.
- emitMemReg(cUnit, entry, base, disp, reg);
+ EmitMemReg(cUnit, entry, base, disp, reg);
}
-static void emitRegArray(CompilationUnit* cUnit, const X86EncodingMap* entry, uint8_t reg,
+static void EmitRegArray(CompilationUnit* cUnit, const X86EncodingMap* entry, uint8_t reg,
uint8_t base, uint8_t index, int scale, int disp) {
if (entry->skeleton.prefix1 != 0) {
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
@@ -663,26 +663,26 @@
reg = reg & X86_FP_REG_MASK;
}
DCHECK_LT(reg, 8);
- uint8_t modrm = (modrmForDisp(base, disp) << 6) | (reg << 3) | rX86_SP;
+ uint8_t modrm = (ModrmForDisp(base, disp) << 6) | (reg << 3) | rX86_SP;
cUnit->codeBuffer.push_back(modrm);
DCHECK_LT(scale, 4);
DCHECK_LT(index, 8);
DCHECK_LT(base, 8);
uint8_t sib = (scale << 6) | (index << 3) | base;
cUnit->codeBuffer.push_back(sib);
- emitDisp(cUnit, base, disp);
+ EmitDisp(cUnit, base, disp);
DCHECK_EQ(0, entry->skeleton.modrm_opcode);
DCHECK_EQ(0, entry->skeleton.ax_opcode);
DCHECK_EQ(0, entry->skeleton.immediate_bytes);
}
-static void emitArrayReg(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitArrayReg(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t base, uint8_t index, int scale, int disp, uint8_t reg) {
// Opcode will flip operands.
- emitRegArray(cUnit, entry, reg, base, index, scale, disp);
+ EmitRegArray(cUnit, entry, reg, base, index, scale, disp);
}
-static void emitRegThread(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitRegThread(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t reg, int disp) {
DCHECK_NE(entry->skeleton.prefix1, 0);
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
@@ -720,7 +720,7 @@
DCHECK_EQ(0, entry->skeleton.immediate_bytes);
}
-static void emitRegReg(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitRegReg(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t reg1, uint8_t reg2) {
if (entry->skeleton.prefix1 != 0) {
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
@@ -757,7 +757,7 @@
DCHECK_EQ(0, entry->skeleton.immediate_bytes);
}
-static void emitRegRegImm(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitRegRegImm(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t reg1, uint8_t reg2, int32_t imm) {
if (entry->skeleton.prefix1 != 0) {
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
@@ -814,7 +814,7 @@
}
}
-static void emitRegImm(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitRegImm(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t reg, int imm) {
if (entry->skeleton.prefix1 != 0) {
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
@@ -868,7 +868,7 @@
}
}
-static void emitThreadImm(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitThreadImm(CompilationUnit* cUnit, const X86EncodingMap* entry,
int disp, int imm) {
if (entry->skeleton.prefix1 != 0) {
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
@@ -920,7 +920,7 @@
DCHECK_EQ(entry->skeleton.ax_opcode, 0);
}
-static void emitMovRegImm(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitMovRegImm(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t reg, int imm) {
DCHECK_LT(reg, 8);
cUnit->codeBuffer.push_back(0xB8 + reg);
@@ -930,7 +930,7 @@
cUnit->codeBuffer.push_back((imm >> 24) & 0xFF);
}
-static void emitShiftRegImm(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitShiftRegImm(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t reg, int imm) {
if (entry->skeleton.prefix1 != 0) {
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
@@ -971,7 +971,7 @@
}
}
-static void emitShiftRegCl(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitShiftRegCl(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t reg, uint8_t cl) {
DCHECK_EQ(cl, static_cast<uint8_t>(rCX));
if (entry->skeleton.prefix1 != 0) {
@@ -992,7 +992,7 @@
DCHECK_EQ(0, entry->skeleton.immediate_bytes);
}
-static void emitRegCond(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitRegCond(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t reg, uint8_t condition) {
if (entry->skeleton.prefix1 != 0) {
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
@@ -1014,7 +1014,7 @@
DCHECK_EQ(entry->skeleton.immediate_bytes, 0);
}
-static void emitJmp(CompilationUnit* cUnit, const X86EncodingMap* entry, int rel) {
+static void EmitJmp(CompilationUnit* cUnit, const X86EncodingMap* entry, int rel) {
if (entry->opcode == kX86Jmp8) {
DCHECK(IS_SIMM8(rel));
cUnit->codeBuffer.push_back(0xEB);
@@ -1035,7 +1035,7 @@
}
}
-static void emitJcc(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitJcc(CompilationUnit* cUnit, const X86EncodingMap* entry,
int rel, uint8_t cc) {
DCHECK_LT(cc, 16);
if (entry->opcode == kX86Jcc8) {
@@ -1053,7 +1053,7 @@
}
}
-static void emitCallMem(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitCallMem(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t base, int disp) {
if (entry->skeleton.prefix1 != 0) {
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
@@ -1075,18 +1075,18 @@
DCHECK_EQ(0, entry->skeleton.extra_opcode1);
DCHECK_EQ(0, entry->skeleton.extra_opcode2);
}
- uint8_t modrm = (modrmForDisp(base, disp) << 6) | (entry->skeleton.modrm_opcode << 3) | base;
+ uint8_t modrm = (ModrmForDisp(base, disp) << 6) | (entry->skeleton.modrm_opcode << 3) | base;
cUnit->codeBuffer.push_back(modrm);
if (base == rX86_SP) {
// Special SIB for SP base
cUnit->codeBuffer.push_back(0 << 6 | (rX86_SP << 3) | rX86_SP);
}
- emitDisp(cUnit, base, disp);
+ EmitDisp(cUnit, base, disp);
DCHECK_EQ(0, entry->skeleton.ax_opcode);
DCHECK_EQ(0, entry->skeleton.immediate_bytes);
}
-static void emitCallThread(CompilationUnit* cUnit, const X86EncodingMap* entry, int disp) {
+static void EmitCallThread(CompilationUnit* cUnit, const X86EncodingMap* entry, int disp) {
DCHECK_NE(entry->skeleton.prefix1, 0);
cUnit->codeBuffer.push_back(entry->skeleton.prefix1);
if (entry->skeleton.prefix2 != 0) {
@@ -1114,7 +1114,7 @@
DCHECK_EQ(0, entry->skeleton.immediate_bytes);
}
-static void emitPcRel(CompilationUnit* cUnit, const X86EncodingMap* entry, uint8_t reg,
+static void EmitPcRel(CompilationUnit* cUnit, const X86EncodingMap* entry, uint8_t reg,
int base_or_table, uint8_t index, int scale, int table_or_disp) {
int disp;
if (entry->opcode == kX86PcRelLoadRA) {
@@ -1161,7 +1161,7 @@
DCHECK_EQ(0, entry->skeleton.ax_opcode);
}
-static void emitMacro(CompilationUnit* cUnit, const X86EncodingMap* entry,
+static void EmitMacro(CompilationUnit* cUnit, const X86EncodingMap* entry,
uint8_t reg, int offset) {
DCHECK(entry->opcode == kX86StartOfMethod) << entry->name;
cUnit->codeBuffer.push_back(0xE8); // call +0
@@ -1173,12 +1173,12 @@
DCHECK_LT(reg, 8);
cUnit->codeBuffer.push_back(0x58 + reg); // pop reg
- emitRegImm(cUnit, &EncodingMap[kX86Sub32RI], reg, offset + 5 /* size of call +0 */);
+ EmitRegImm(cUnit, &EncodingMap[kX86Sub32RI], reg, offset + 5 /* size of call +0 */);
}
-void emitUnimplemented(CompilationUnit* cUnit, const X86EncodingMap* entry, LIR* lir) {
- UNIMPLEMENTED(WARNING) << "encoding kind for " << entry->name << " " << buildInsnString(entry->fmt, lir, 0);
- for (int i = 0; i < oatGetInsnSize(lir); ++i) {
+void EmitUnimplemented(CompilationUnit* cUnit, const X86EncodingMap* entry, LIR* lir) {
+ UNIMPLEMENTED(WARNING) << "encoding kind for " << entry->name << " " << BuildInsnString(entry->fmt, lir, 0);
+ for (int i = 0; i < GetInsnSize(lir); ++i) {
cUnit->codeBuffer.push_back(0xCC); // push breakpoint instruction - int 3
}
}
@@ -1189,7 +1189,7 @@
* instruction. In those cases we will try to substitute a new code
* sequence or request that the trace be shortened and retried.
*/
-AssemblerStatus oatAssembleInstructions(CompilationUnit *cUnit, uintptr_t startAddr) {
+AssemblerStatus AssembleInstructions(CompilationUnit *cUnit, uintptr_t startAddr) {
LIR *lir;
AssemblerStatus res = kSuccess; // Assume success
@@ -1223,14 +1223,14 @@
<< " delta: " << delta << " old delta: " << lir->operands[0];
}
lir->opcode = kX86Jcc32;
- oatSetupResourceMasks(cUnit, lir);
+ SetupResourceMasks(cUnit, lir);
res = kRetryAll;
}
if (kVerbosePcFixup) {
LOG(INFO) << "Source:";
- oatDumpLIRInsn(cUnit, lir, 0);
+ DumpLIRInsn(cUnit, lir, 0);
LOG(INFO) << "Target:";
- oatDumpLIRInsn(cUnit, targetLIR, 0);
+ DumpLIRInsn(cUnit, targetLIR, 0);
LOG(INFO) << "Delta " << delta;
}
lir->operands[0] = delta;
@@ -1244,9 +1244,9 @@
int delta = target - pc;
if (kVerbosePcFixup) {
LOG(INFO) << "Source:";
- oatDumpLIRInsn(cUnit, lir, 0);
+ DumpLIRInsn(cUnit, lir, 0);
LOG(INFO) << "Target:";
- oatDumpLIRInsn(cUnit, targetLIR, 0);
+ DumpLIRInsn(cUnit, targetLIR, 0);
LOG(INFO) << "Delta " << delta;
}
lir->operands[0] = delta;
@@ -1276,7 +1276,7 @@
LOG(INFO) << "Retry for JMP growth at " << lir->offset;
}
lir->opcode = kX86Jmp32;
- oatSetupResourceMasks(cUnit, lir);
+ SetupResourceMasks(cUnit, lir);
res = kRetryAll;
}
lir->operands[0] = delta;
@@ -1328,86 +1328,86 @@
DCHECK_EQ(0, entry->skeleton.immediate_bytes);
break;
case kReg: // lir operands - 0: reg
- emitOpReg(cUnit, entry, lir->operands[0]);
+ EmitOpReg(cUnit, entry, lir->operands[0]);
break;
case kMem: // lir operands - 0: base, 1: disp
- emitOpMem(cUnit, entry, lir->operands[0], lir->operands[1]);
+ EmitOpMem(cUnit, entry, lir->operands[0], lir->operands[1]);
break;
case kMemReg: // lir operands - 0: base, 1: disp, 2: reg
- emitMemReg(cUnit, entry, lir->operands[0], lir->operands[1], lir->operands[2]);
+ EmitMemReg(cUnit, entry, lir->operands[0], lir->operands[1], lir->operands[2]);
break;
case kArrayReg: // lir operands - 0: base, 1: index, 2: scale, 3: disp, 4: reg
- emitArrayReg(cUnit, entry, lir->operands[0], lir->operands[1], lir->operands[2],
+ EmitArrayReg(cUnit, entry, lir->operands[0], lir->operands[1], lir->operands[2],
lir->operands[3], lir->operands[4]);
break;
case kRegMem: // lir operands - 0: reg, 1: base, 2: disp
- emitRegMem(cUnit, entry, lir->operands[0], lir->operands[1], lir->operands[2]);
+ EmitRegMem(cUnit, entry, lir->operands[0], lir->operands[1], lir->operands[2]);
break;
case kRegArray: // lir operands - 0: reg, 1: base, 2: index, 3: scale, 4: disp
- emitRegArray(cUnit, entry, lir->operands[0], lir->operands[1], lir->operands[2],
+ EmitRegArray(cUnit, entry, lir->operands[0], lir->operands[1], lir->operands[2],
lir->operands[3], lir->operands[4]);
break;
case kRegThread: // lir operands - 0: reg, 1: disp
- emitRegThread(cUnit, entry, lir->operands[0], lir->operands[1]);
+ EmitRegThread(cUnit, entry, lir->operands[0], lir->operands[1]);
break;
case kRegReg: // lir operands - 0: reg1, 1: reg2
- emitRegReg(cUnit, entry, lir->operands[0], lir->operands[1]);
+ EmitRegReg(cUnit, entry, lir->operands[0], lir->operands[1]);
break;
case kRegRegStore: // lir operands - 0: reg2, 1: reg1
- emitRegReg(cUnit, entry, lir->operands[1], lir->operands[0]);
+ EmitRegReg(cUnit, entry, lir->operands[1], lir->operands[0]);
break;
case kRegRegImm:
- emitRegRegImm(cUnit, entry, lir->operands[0], lir->operands[1], lir->operands[2]);
+ EmitRegRegImm(cUnit, entry, lir->operands[0], lir->operands[1], lir->operands[2]);
break;
case kRegImm: // lir operands - 0: reg, 1: immediate
- emitRegImm(cUnit, entry, lir->operands[0], lir->operands[1]);
+ EmitRegImm(cUnit, entry, lir->operands[0], lir->operands[1]);
break;
case kThreadImm: // lir operands - 0: disp, 1: immediate
- emitThreadImm(cUnit, entry, lir->operands[0], lir->operands[1]);
+ EmitThreadImm(cUnit, entry, lir->operands[0], lir->operands[1]);
break;
case kMovRegImm: // lir operands - 0: reg, 1: immediate
- emitMovRegImm(cUnit, entry, lir->operands[0], lir->operands[1]);
+ EmitMovRegImm(cUnit, entry, lir->operands[0], lir->operands[1]);
break;
case kShiftRegImm: // lir operands - 0: reg, 1: immediate
- emitShiftRegImm(cUnit, entry, lir->operands[0], lir->operands[1]);
+ EmitShiftRegImm(cUnit, entry, lir->operands[0], lir->operands[1]);
break;
case kShiftRegCl: // lir operands - 0: reg, 1: cl
- emitShiftRegCl(cUnit, entry, lir->operands[0], lir->operands[1]);
+ EmitShiftRegCl(cUnit, entry, lir->operands[0], lir->operands[1]);
break;
case kRegCond: // lir operands - 0: reg, 1: condition
- emitRegCond(cUnit, entry, lir->operands[0], lir->operands[1]);
+ EmitRegCond(cUnit, entry, lir->operands[0], lir->operands[1]);
break;
case kJmp: // lir operands - 0: rel
- emitJmp(cUnit, entry, lir->operands[0]);
+ EmitJmp(cUnit, entry, lir->operands[0]);
break;
case kJcc: // lir operands - 0: rel, 1: CC, target assigned
- emitJcc(cUnit, entry, lir->operands[0], lir->operands[1]);
+ EmitJcc(cUnit, entry, lir->operands[0], lir->operands[1]);
break;
case kCall:
switch (entry->opcode) {
case kX86CallM: // lir operands - 0: base, 1: disp
- emitCallMem(cUnit, entry, lir->operands[0], lir->operands[1]);
+ EmitCallMem(cUnit, entry, lir->operands[0], lir->operands[1]);
break;
case kX86CallT: // lir operands - 0: disp
- emitCallThread(cUnit, entry, lir->operands[0]);
+ EmitCallThread(cUnit, entry, lir->operands[0]);
break;
default:
- emitUnimplemented(cUnit, entry, lir);
+ EmitUnimplemented(cUnit, entry, lir);
break;
}
break;
case kPcRel: // lir operands - 0: reg, 1: base, 2: index, 3: scale, 4: table
- emitPcRel(cUnit, entry, lir->operands[0], lir->operands[1], lir->operands[2],
+ EmitPcRel(cUnit, entry, lir->operands[0], lir->operands[1], lir->operands[2],
lir->operands[3], lir->operands[4]);
break;
case kMacro:
- emitMacro(cUnit, entry, lir->operands[0], lir->offset);
+ EmitMacro(cUnit, entry, lir->operands[0], lir->offset);
break;
default:
- emitUnimplemented(cUnit, entry, lir);
+ EmitUnimplemented(cUnit, entry, lir);
break;
}
- CHECK_EQ(static_cast<size_t>(oatGetInsnSize(lir)),
+ CHECK_EQ(static_cast<size_t>(GetInsnSize(lir)),
cUnit->codeBuffer.size() - starting_cbuf_size)
<< "Instruction size mismatch for entry: " << EncodingMap[lir->opcode].name;
}
@@ -1418,7 +1418,7 @@
* Target-dependent offset assignment.
* independent.
*/
-int oatAssignInsnOffsets(CompilationUnit* cUnit)
+int AssignInsnOffsets(CompilationUnit* cUnit)
{
LIR* x86LIR;
int offset = 0;
diff --git a/src/compiler/codegen/x86/call_x86.cc b/src/compiler/codegen/x86/call_x86.cc
index 51dda66..7ada136 100644
--- a/src/compiler/codegen/x86/call_x86.cc
+++ b/src/compiler/codegen/x86/call_x86.cc
@@ -22,7 +22,7 @@
namespace art {
-void genSpecialCase(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+void GenSpecialCase(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
SpecialCaseHandler specialCase)
{
// TODO
@@ -32,26 +32,26 @@
* The sparse table in the literal pool is an array of <key,displacement>
* pairs.
*/
-BasicBlock *findBlock(CompilationUnit* cUnit, unsigned int codeOffset,
+BasicBlock *FindBlock(CompilationUnit* cUnit, unsigned int codeOffset,
bool split, bool create, BasicBlock** immedPredBlockP);
-void genSparseSwitch(CompilationUnit* cUnit, uint32_t tableOffset,
+void GenSparseSwitch(CompilationUnit* cUnit, uint32_t tableOffset,
RegLocation rlSrc)
{
const uint16_t* table = cUnit->insns + cUnit->currentDalvikOffset + tableOffset;
if (cUnit->printMe) {
- dumpSparseSwitchTable(table);
+ DumpSparseSwitchTable(table);
}
int entries = table[1];
const int* keys = reinterpret_cast<const int*>(&table[2]);
const int* targets = &keys[entries];
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
for (int i = 0; i < entries; i++) {
int key = keys[i];
- BasicBlock* case_block = findBlock(cUnit,
+ BasicBlock* case_block = FindBlock(cUnit,
cUnit->currentDalvikOffset + targets[i],
false, false, NULL);
LIR* labelList = cUnit->blockLabelList;
- opCmpImmBranch(cUnit, kCondEq, rlSrc.lowReg, key,
+ OpCmpImmBranch(cUnit, kCondEq, rlSrc.lowReg, key,
&labelList[case_block->id]);
}
}
@@ -72,57 +72,57 @@
* jmp rStartOfMethod
* done:
*/
-void genPackedSwitch(CompilationUnit* cUnit, uint32_t tableOffset,
+void GenPackedSwitch(CompilationUnit* cUnit, uint32_t tableOffset,
RegLocation rlSrc)
{
const uint16_t* table = cUnit->insns + cUnit->currentDalvikOffset + tableOffset;
if (cUnit->printMe) {
- dumpPackedSwitchTable(table);
+ DumpPackedSwitchTable(table);
}
// Add the table to the list - we'll process it later
SwitchTable *tabRec =
- static_cast<SwitchTable *>(oatNew(cUnit, sizeof(SwitchTable), true, kAllocData));
+ static_cast<SwitchTable *>(NewMem(cUnit, sizeof(SwitchTable), true, kAllocData));
tabRec->table = table;
tabRec->vaddr = cUnit->currentDalvikOffset;
int size = table[1];
- tabRec->targets = static_cast<LIR**>(oatNew(cUnit, size * sizeof(LIR*), true, kAllocLIR));
- oatInsertGrowableList(cUnit, &cUnit->switchTables, reinterpret_cast<uintptr_t>(tabRec));
+ tabRec->targets = static_cast<LIR**>(NewMem(cUnit, size * sizeof(LIR*), true, kAllocLIR));
+ InsertGrowableList(cUnit, &cUnit->switchTables, reinterpret_cast<uintptr_t>(tabRec));
// Get the switch value
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- int startOfMethodReg = oatAllocTemp(cUnit);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
+ int startOfMethodReg = AllocTemp(cUnit);
// Materialize a pointer to the switch table
- //newLIR0(cUnit, kX86Bkpt);
- newLIR1(cUnit, kX86StartOfMethod, startOfMethodReg);
+ //NewLIR0(cUnit, kX86Bkpt);
+ NewLIR1(cUnit, kX86StartOfMethod, startOfMethodReg);
int lowKey = s4FromSwitchData(&table[2]);
int keyReg;
// Remove the bias, if necessary
if (lowKey == 0) {
keyReg = rlSrc.lowReg;
} else {
- keyReg = oatAllocTemp(cUnit);
- opRegRegImm(cUnit, kOpSub, keyReg, rlSrc.lowReg, lowKey);
+ keyReg = AllocTemp(cUnit);
+ OpRegRegImm(cUnit, kOpSub, keyReg, rlSrc.lowReg, lowKey);
}
// Bounds check - if < 0 or >= size continue following switch
- opRegImm(cUnit, kOpCmp, keyReg, size-1);
- LIR* branchOver = opCondBranch(cUnit, kCondHi, NULL);
+ OpRegImm(cUnit, kOpCmp, keyReg, size-1);
+ LIR* branchOver = OpCondBranch(cUnit, kCondHi, NULL);
// Load the displacement from the switch table
- int dispReg = oatAllocTemp(cUnit);
- newLIR5(cUnit, kX86PcRelLoadRA, dispReg, startOfMethodReg, keyReg, 2,
+ int dispReg = AllocTemp(cUnit);
+ NewLIR5(cUnit, kX86PcRelLoadRA, dispReg, startOfMethodReg, keyReg, 2,
reinterpret_cast<uintptr_t>(tabRec));
// Add displacement to start of method
- opRegReg(cUnit, kOpAdd, startOfMethodReg, dispReg);
+ OpRegReg(cUnit, kOpAdd, startOfMethodReg, dispReg);
// ..and go!
- LIR* switchBranch = newLIR1(cUnit, kX86JmpR, startOfMethodReg);
+ LIR* switchBranch = NewLIR1(cUnit, kX86JmpR, startOfMethodReg);
tabRec->anchor = switchBranch;
/* branchOver target here */
- LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
branchOver->target = target;
}
-void callRuntimeHelperRegReg(CompilationUnit* cUnit, int helperOffset,
+void CallRuntimeHelperRegReg(CompilationUnit* cUnit, int helperOffset,
int arg0, int arg1, bool safepointPC);
/*
* Array data table format:
@@ -134,90 +134,90 @@
*
* Total size is 4+(width * size + 1)/2 16-bit code units.
*/
-void genFillArrayData(CompilationUnit* cUnit, uint32_t tableOffset,
+void GenFillArrayData(CompilationUnit* cUnit, uint32_t tableOffset,
RegLocation rlSrc)
{
const uint16_t* table = cUnit->insns + cUnit->currentDalvikOffset + tableOffset;
// Add the table to the list - we'll process it later
FillArrayData *tabRec =
- static_cast<FillArrayData*>(oatNew(cUnit, sizeof(FillArrayData), true, kAllocData));
+ static_cast<FillArrayData*>(NewMem(cUnit, sizeof(FillArrayData), true, kAllocData));
tabRec->table = table;
tabRec->vaddr = cUnit->currentDalvikOffset;
uint16_t width = tabRec->table[1];
uint32_t size = tabRec->table[2] | ((static_cast<uint32_t>(tabRec->table[3])) << 16);
tabRec->size = (size * width) + 8;
- oatInsertGrowableList(cUnit, &cUnit->fillArrayData, reinterpret_cast<uintptr_t>(tabRec));
+ InsertGrowableList(cUnit, &cUnit->fillArrayData, reinterpret_cast<uintptr_t>(tabRec));
// Making a call - use explicit registers
- oatFlushAllRegs(cUnit); /* Everything to home location */
- loadValueDirectFixed(cUnit, rlSrc, rX86_ARG0);
+ FlushAllRegs(cUnit); /* Everything to home location */
+ LoadValueDirectFixed(cUnit, rlSrc, rX86_ARG0);
// Materialize a pointer to the fill data image
- newLIR1(cUnit, kX86StartOfMethod, rX86_ARG2);
- newLIR2(cUnit, kX86PcRelAdr, rX86_ARG1, reinterpret_cast<uintptr_t>(tabRec));
- newLIR2(cUnit, kX86Add32RR, rX86_ARG1, rX86_ARG2);
- callRuntimeHelperRegReg(cUnit, ENTRYPOINT_OFFSET(pHandleFillArrayDataFromCode), rX86_ARG0,
+ NewLIR1(cUnit, kX86StartOfMethod, rX86_ARG2);
+ NewLIR2(cUnit, kX86PcRelAdr, rX86_ARG1, reinterpret_cast<uintptr_t>(tabRec));
+ NewLIR2(cUnit, kX86Add32RR, rX86_ARG1, rX86_ARG2);
+ CallRuntimeHelperRegReg(cUnit, ENTRYPOINT_OFFSET(pHandleFillArrayDataFromCode), rX86_ARG0,
rX86_ARG1, true);
}
-void genMonitorEnter(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc)
+void GenMonitorEnter(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc)
{
- oatFlushAllRegs(cUnit);
- loadValueDirectFixed(cUnit, rlSrc, rCX); // Get obj
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- genNullCheck(cUnit, rlSrc.sRegLow, rCX, optFlags);
+ FlushAllRegs(cUnit);
+ LoadValueDirectFixed(cUnit, rlSrc, rCX); // Get obj
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ GenNullCheck(cUnit, rlSrc.sRegLow, rCX, optFlags);
// If lock is unheld, try to grab it quickly with compare and exchange
// TODO: copy and clear hash state?
- newLIR2(cUnit, kX86Mov32RT, rDX, Thread::ThinLockIdOffset().Int32Value());
- newLIR2(cUnit, kX86Sal32RI, rDX, LW_LOCK_OWNER_SHIFT);
- newLIR2(cUnit, kX86Xor32RR, rAX, rAX);
- newLIR3(cUnit, kX86LockCmpxchgMR, rCX, Object::MonitorOffset().Int32Value(), rDX);
- LIR* branch = newLIR2(cUnit, kX86Jcc8, 0, kX86CondEq);
+ NewLIR2(cUnit, kX86Mov32RT, rDX, Thread::ThinLockIdOffset().Int32Value());
+ NewLIR2(cUnit, kX86Sal32RI, rDX, LW_LOCK_OWNER_SHIFT);
+ NewLIR2(cUnit, kX86Xor32RR, rAX, rAX);
+ NewLIR3(cUnit, kX86LockCmpxchgMR, rCX, Object::MonitorOffset().Int32Value(), rDX);
+ LIR* branch = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondEq);
// If lock is held, go the expensive route - artLockObjectFromCode(self, obj);
- callRuntimeHelperReg(cUnit, ENTRYPOINT_OFFSET(pLockObjectFromCode), rCX, true);
- branch->target = newLIR0(cUnit, kPseudoTargetLabel);
+ CallRuntimeHelperReg(cUnit, ENTRYPOINT_OFFSET(pLockObjectFromCode), rCX, true);
+ branch->target = NewLIR0(cUnit, kPseudoTargetLabel);
}
-void genMonitorExit(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc)
+void GenMonitorExit(CompilationUnit* cUnit, int optFlags, RegLocation rlSrc)
{
- oatFlushAllRegs(cUnit);
- loadValueDirectFixed(cUnit, rlSrc, rAX); // Get obj
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- genNullCheck(cUnit, rlSrc.sRegLow, rAX, optFlags);
+ FlushAllRegs(cUnit);
+ LoadValueDirectFixed(cUnit, rlSrc, rAX); // Get obj
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ GenNullCheck(cUnit, rlSrc.sRegLow, rAX, optFlags);
// If lock is held by the current thread, clear it to quickly release it
// TODO: clear hash state?
- newLIR2(cUnit, kX86Mov32RT, rDX, Thread::ThinLockIdOffset().Int32Value());
- newLIR2(cUnit, kX86Sal32RI, rDX, LW_LOCK_OWNER_SHIFT);
- newLIR3(cUnit, kX86Mov32RM, rCX, rAX, Object::MonitorOffset().Int32Value());
- opRegReg(cUnit, kOpSub, rCX, rDX);
- LIR* branch = newLIR2(cUnit, kX86Jcc8, 0, kX86CondNe);
- newLIR3(cUnit, kX86Mov32MR, rAX, Object::MonitorOffset().Int32Value(), rCX);
- LIR* branch2 = newLIR1(cUnit, kX86Jmp8, 0);
- branch->target = newLIR0(cUnit, kPseudoTargetLabel);
+ NewLIR2(cUnit, kX86Mov32RT, rDX, Thread::ThinLockIdOffset().Int32Value());
+ NewLIR2(cUnit, kX86Sal32RI, rDX, LW_LOCK_OWNER_SHIFT);
+ NewLIR3(cUnit, kX86Mov32RM, rCX, rAX, Object::MonitorOffset().Int32Value());
+ OpRegReg(cUnit, kOpSub, rCX, rDX);
+ LIR* branch = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondNe);
+ NewLIR3(cUnit, kX86Mov32MR, rAX, Object::MonitorOffset().Int32Value(), rCX);
+ LIR* branch2 = NewLIR1(cUnit, kX86Jmp8, 0);
+ branch->target = NewLIR0(cUnit, kPseudoTargetLabel);
// Otherwise, go the expensive route - UnlockObjectFromCode(obj);
- callRuntimeHelperReg(cUnit, ENTRYPOINT_OFFSET(pUnlockObjectFromCode), rAX, true);
- branch2->target = newLIR0(cUnit, kPseudoTargetLabel);
+ CallRuntimeHelperReg(cUnit, ENTRYPOINT_OFFSET(pUnlockObjectFromCode), rAX, true);
+ branch2->target = NewLIR0(cUnit, kPseudoTargetLabel);
}
/*
* Mark garbage collection card. Skip if the value we're storing is null.
*/
-void markGCCard(CompilationUnit* cUnit, int valReg, int tgtAddrReg)
+void MarkGCCard(CompilationUnit* cUnit, int valReg, int tgtAddrReg)
{
- int regCardBase = oatAllocTemp(cUnit);
- int regCardNo = oatAllocTemp(cUnit);
- LIR* branchOver = opCmpImmBranch(cUnit, kCondEq, valReg, 0, NULL);
- newLIR2(cUnit, kX86Mov32RT, regCardBase, Thread::CardTableOffset().Int32Value());
- opRegRegImm(cUnit, kOpLsr, regCardNo, tgtAddrReg, CardTable::kCardShift);
- storeBaseIndexed(cUnit, regCardBase, regCardNo, regCardBase, 0,
+ int regCardBase = AllocTemp(cUnit);
+ int regCardNo = AllocTemp(cUnit);
+ LIR* branchOver = OpCmpImmBranch(cUnit, kCondEq, valReg, 0, NULL);
+ NewLIR2(cUnit, kX86Mov32RT, regCardBase, Thread::CardTableOffset().Int32Value());
+ OpRegRegImm(cUnit, kOpLsr, regCardNo, tgtAddrReg, CardTable::kCardShift);
+ StoreBaseIndexed(cUnit, regCardBase, regCardNo, regCardBase, 0,
kUnsignedByte);
- LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
+ LIR* target = NewLIR0(cUnit, kPseudoTargetLabel);
branchOver->target = target;
- oatFreeTemp(cUnit, regCardBase);
- oatFreeTemp(cUnit, regCardNo);
+ FreeTemp(cUnit, regCardBase);
+ FreeTemp(cUnit, regCardNo);
}
-void genEntrySequence(CompilationUnit* cUnit, RegLocation* argLocs,
+void GenEntrySequence(CompilationUnit* cUnit, RegLocation* ArgLocs,
RegLocation rlMethod)
{
/*
@@ -226,12 +226,12 @@
* expanding the frame or flushing. This leaves the utility
* code with no spare temps.
*/
- oatLockTemp(cUnit, rX86_ARG0);
- oatLockTemp(cUnit, rX86_ARG1);
- oatLockTemp(cUnit, rX86_ARG2);
+ LockTemp(cUnit, rX86_ARG0);
+ LockTemp(cUnit, rX86_ARG1);
+ LockTemp(cUnit, rX86_ARG2);
/* Build frame, return address already on stack */
- opRegImm(cUnit, kOpSub, rX86_SP, cUnit->frameSize - 4);
+ OpRegImm(cUnit, kOpSub, rX86_SP, cUnit->frameSize - 4);
/*
* We can safely skip the stack overflow check if we're
@@ -240,40 +240,40 @@
bool skipOverflowCheck = ((cUnit->attrs & METHOD_IS_LEAF) &&
(static_cast<size_t>(cUnit->frameSize) <
Thread::kStackOverflowReservedBytes));
- newLIR0(cUnit, kPseudoMethodEntry);
+ NewLIR0(cUnit, kPseudoMethodEntry);
/* Spill core callee saves */
- spillCoreRegs(cUnit);
+ SpillCoreRegs(cUnit);
/* NOTE: promotion of FP regs currently unsupported, thus no FP spill */
DCHECK_EQ(cUnit->numFPSpills, 0);
if (!skipOverflowCheck) {
// cmp rX86_SP, fs:[stack_end_]; jcc throw_launchpad
- LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kThrowStackOverflow, 0, 0, 0, 0);
- opRegThreadMem(cUnit, kOpCmp, rX86_SP, Thread::StackEndOffset().Int32Value());
- opCondBranch(cUnit, kCondUlt, tgt);
+ LIR* tgt = RawLIR(cUnit, 0, kPseudoThrowTarget, kThrowStackOverflow, 0, 0, 0, 0);
+ OpRegThreadMem(cUnit, kOpCmp, rX86_SP, Thread::StackEndOffset().Int32Value());
+ OpCondBranch(cUnit, kCondUlt, 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));
}
- flushIns(cUnit, argLocs, rlMethod);
+ FlushIns(cUnit, ArgLocs, rlMethod);
- oatFreeTemp(cUnit, rX86_ARG0);
- oatFreeTemp(cUnit, rX86_ARG1);
- oatFreeTemp(cUnit, rX86_ARG2);
+ FreeTemp(cUnit, rX86_ARG0);
+ FreeTemp(cUnit, rX86_ARG1);
+ FreeTemp(cUnit, rX86_ARG2);
}
-void genExitSequence(CompilationUnit* cUnit) {
+void GenExitSequence(CompilationUnit* cUnit) {
/*
* In the exit path, rX86_RET0/rX86_RET1 are live - make sure they aren't
* allocated by the register utilities as temps.
*/
- oatLockTemp(cUnit, rX86_RET0);
- oatLockTemp(cUnit, rX86_RET1);
+ LockTemp(cUnit, rX86_RET0);
+ LockTemp(cUnit, rX86_RET1);
- newLIR0(cUnit, kPseudoMethodExit);
- unSpillCoreRegs(cUnit);
+ NewLIR0(cUnit, kPseudoMethodExit);
+ UnSpillCoreRegs(cUnit);
/* Remove frame except for return address */
- opRegImm(cUnit, kOpAdd, rX86_SP, cUnit->frameSize - 4);
- newLIR0(cUnit, kX86Ret);
+ OpRegImm(cUnit, kOpAdd, rX86_SP, cUnit->frameSize - 4);
+ NewLIR0(cUnit, kX86Ret);
}
} // namespace art
diff --git a/src/compiler/codegen/x86/fp_x86.cc b/src/compiler/codegen/x86/fp_x86.cc
index 92190cc..9ab80f4 100644
--- a/src/compiler/codegen/x86/fp_x86.cc
+++ b/src/compiler/codegen/x86/fp_x86.cc
@@ -20,7 +20,7 @@
namespace art {
-bool genArithOpFloat(CompilationUnit *cUnit, Instruction::Code opcode,
+bool GenArithOpFloat(CompilationUnit *cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2) {
X86OpCode op = kX86Nop;
RegLocation rlResult;
@@ -49,28 +49,28 @@
case Instruction::NEG_FLOAT:
case Instruction::REM_FLOAT_2ADDR:
case Instruction::REM_FLOAT:
- return genArithOpFloatPortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
+ return GenArithOpFloatPortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
default:
return true;
}
- rlSrc1 = loadValue(cUnit, rlSrc1, kFPReg);
- rlSrc2 = loadValue(cUnit, rlSrc2, kFPReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
+ rlSrc1 = LoadValue(cUnit, rlSrc1, kFPReg);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kFPReg);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
int rDest = rlResult.lowReg;
int rSrc1 = rlSrc1.lowReg;
int rSrc2 = rlSrc2.lowReg;
if (rDest == rSrc2) {
- rSrc2 = oatAllocTempFloat(cUnit);
- opRegCopy(cUnit, rSrc2, rDest);
+ rSrc2 = AllocTempFloat(cUnit);
+ OpRegCopy(cUnit, rSrc2, rDest);
}
- opRegCopy(cUnit, rDest, rSrc1);
- newLIR2(cUnit, op, rDest, rSrc2);
- storeValue(cUnit, rlDest, rlResult);
+ OpRegCopy(cUnit, rDest, rSrc1);
+ NewLIR2(cUnit, op, rDest, rSrc2);
+ StoreValue(cUnit, rlDest, rlResult);
return false;
}
-bool genArithOpDouble(CompilationUnit *cUnit, Instruction::Code opcode,
+bool GenArithOpDouble(CompilationUnit *cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc1, RegLocation rlSrc2) {
X86OpCode op = kX86Nop;
RegLocation rlResult;
@@ -95,31 +95,31 @@
case Instruction::NEG_DOUBLE:
case Instruction::REM_DOUBLE_2ADDR:
case Instruction::REM_DOUBLE:
- return genArithOpDoublePortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
+ return GenArithOpDoublePortable(cUnit, opcode, rlDest, rlSrc1, rlSrc2);
default:
return true;
}
- rlSrc1 = loadValueWide(cUnit, rlSrc1, kFPReg);
+ rlSrc1 = LoadValueWide(cUnit, rlSrc1, kFPReg);
DCHECK(rlSrc1.wide);
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kFPReg);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kFPReg);
DCHECK(rlSrc2.wide);
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
DCHECK(rlDest.wide);
DCHECK(rlResult.wide);
- int rDest = s2d(rlResult.lowReg, rlResult.highReg);
- int rSrc1 = s2d(rlSrc1.lowReg, rlSrc1.highReg);
- int rSrc2 = s2d(rlSrc2.lowReg, rlSrc2.highReg);
+ int rDest = S2d(rlResult.lowReg, rlResult.highReg);
+ int rSrc1 = S2d(rlSrc1.lowReg, rlSrc1.highReg);
+ int rSrc2 = S2d(rlSrc2.lowReg, rlSrc2.highReg);
if (rDest == rSrc2) {
- rSrc2 = oatAllocTempDouble(cUnit) | X86_FP_DOUBLE;
- opRegCopy(cUnit, rSrc2, rDest);
+ rSrc2 = AllocTempDouble(cUnit) | X86_FP_DOUBLE;
+ OpRegCopy(cUnit, rSrc2, rDest);
}
- opRegCopy(cUnit, rDest, rSrc1);
- newLIR2(cUnit, op, rDest, rSrc2);
- storeValueWide(cUnit, rlDest, rlResult);
+ OpRegCopy(cUnit, rDest, rSrc1);
+ NewLIR2(cUnit, op, rDest, rSrc2);
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
-bool genConversion(CompilationUnit *cUnit, Instruction::Code opcode,
+bool GenConversion(CompilationUnit *cUnit, Instruction::Code opcode,
RegLocation rlDest, RegLocation rlSrc) {
RegisterClass rcSrc = kFPReg;
X86OpCode op = kX86Nop;
@@ -143,45 +143,45 @@
op = kX86Cvtsi2sdRR;
break;
case Instruction::FLOAT_TO_INT: {
- rlSrc = loadValue(cUnit, rlSrc, kFPReg);
+ rlSrc = LoadValue(cUnit, rlSrc, kFPReg);
srcReg = rlSrc.lowReg;
- oatClobberSReg(cUnit, rlDest.sRegLow);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- int tempReg = oatAllocTempFloat(cUnit);
+ ClobberSReg(cUnit, rlDest.sRegLow);
+ rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ int tempReg = AllocTempFloat(cUnit);
- loadConstant(cUnit, rlResult.lowReg, 0x7fffffff);
- newLIR2(cUnit, kX86Cvtsi2ssRR, tempReg, rlResult.lowReg);
- newLIR2(cUnit, kX86ComissRR, srcReg, tempReg);
- LIR* branchPosOverflow = newLIR2(cUnit, kX86Jcc8, 0, kX86CondA);
- LIR* branchNaN = newLIR2(cUnit, kX86Jcc8, 0, kX86CondP);
- newLIR2(cUnit, kX86Cvttss2siRR, rlResult.lowReg, srcReg);
- LIR* branchNormal = newLIR1(cUnit, kX86Jmp8, 0);
- branchNaN->target = newLIR0(cUnit, kPseudoTargetLabel);
- newLIR2(cUnit, kX86Xor32RR, rlResult.lowReg, rlResult.lowReg);
- branchPosOverflow->target = newLIR0(cUnit, kPseudoTargetLabel);
- branchNormal->target = newLIR0(cUnit, kPseudoTargetLabel);
- storeValue(cUnit, rlDest, rlResult);
+ LoadConstant(cUnit, rlResult.lowReg, 0x7fffffff);
+ NewLIR2(cUnit, kX86Cvtsi2ssRR, tempReg, rlResult.lowReg);
+ NewLIR2(cUnit, kX86ComissRR, srcReg, tempReg);
+ LIR* branchPosOverflow = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondA);
+ LIR* branchNaN = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondP);
+ NewLIR2(cUnit, kX86Cvttss2siRR, rlResult.lowReg, srcReg);
+ LIR* branchNormal = NewLIR1(cUnit, kX86Jmp8, 0);
+ branchNaN->target = NewLIR0(cUnit, kPseudoTargetLabel);
+ NewLIR2(cUnit, kX86Xor32RR, rlResult.lowReg, rlResult.lowReg);
+ branchPosOverflow->target = NewLIR0(cUnit, kPseudoTargetLabel);
+ branchNormal->target = NewLIR0(cUnit, kPseudoTargetLabel);
+ StoreValue(cUnit, rlDest, rlResult);
return false;
}
case Instruction::DOUBLE_TO_INT: {
- rlSrc = loadValueWide(cUnit, rlSrc, kFPReg);
+ rlSrc = LoadValueWide(cUnit, rlSrc, kFPReg);
srcReg = rlSrc.lowReg;
- oatClobberSReg(cUnit, rlDest.sRegLow);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- int tempReg = oatAllocTempDouble(cUnit) | X86_FP_DOUBLE;
+ ClobberSReg(cUnit, rlDest.sRegLow);
+ rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ int tempReg = AllocTempDouble(cUnit) | X86_FP_DOUBLE;
- loadConstant(cUnit, rlResult.lowReg, 0x7fffffff);
- newLIR2(cUnit, kX86Cvtsi2sdRR, tempReg, rlResult.lowReg);
- newLIR2(cUnit, kX86ComisdRR, srcReg, tempReg);
- LIR* branchPosOverflow = newLIR2(cUnit, kX86Jcc8, 0, kX86CondA);
- LIR* branchNaN = newLIR2(cUnit, kX86Jcc8, 0, kX86CondP);
- newLIR2(cUnit, kX86Cvttsd2siRR, rlResult.lowReg, srcReg);
- LIR* branchNormal = newLIR1(cUnit, kX86Jmp8, 0);
- branchNaN->target = newLIR0(cUnit, kPseudoTargetLabel);
- newLIR2(cUnit, kX86Xor32RR, rlResult.lowReg, rlResult.lowReg);
- branchPosOverflow->target = newLIR0(cUnit, kPseudoTargetLabel);
- branchNormal->target = newLIR0(cUnit, kPseudoTargetLabel);
- storeValue(cUnit, rlDest, rlResult);
+ LoadConstant(cUnit, rlResult.lowReg, 0x7fffffff);
+ NewLIR2(cUnit, kX86Cvtsi2sdRR, tempReg, rlResult.lowReg);
+ NewLIR2(cUnit, kX86ComisdRR, srcReg, tempReg);
+ LIR* branchPosOverflow = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondA);
+ LIR* branchNaN = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondP);
+ NewLIR2(cUnit, kX86Cvttsd2siRR, rlResult.lowReg, srcReg);
+ LIR* branchNormal = NewLIR1(cUnit, kX86Jmp8, 0);
+ branchNaN->target = NewLIR0(cUnit, kPseudoTargetLabel);
+ NewLIR2(cUnit, kX86Xor32RR, rlResult.lowReg, rlResult.lowReg);
+ branchPosOverflow->target = NewLIR0(cUnit, kPseudoTargetLabel);
+ branchNormal->target = NewLIR0(cUnit, kPseudoTargetLabel);
+ StoreValue(cUnit, rlDest, rlResult);
return false;
}
case Instruction::LONG_TO_DOUBLE:
@@ -189,81 +189,81 @@
// TODO: inline by using memory as a 64-bit source. Be careful about promoted registers.
case Instruction::FLOAT_TO_LONG:
case Instruction::DOUBLE_TO_LONG:
- return genConversionPortable(cUnit, opcode, rlDest, rlSrc);
+ return GenConversionPortable(cUnit, opcode, rlDest, rlSrc);
default:
return true;
}
if (rlSrc.wide) {
- rlSrc = loadValueWide(cUnit, rlSrc, rcSrc);
- srcReg = s2d(rlSrc.lowReg, rlSrc.highReg);
+ rlSrc = LoadValueWide(cUnit, rlSrc, rcSrc);
+ srcReg = S2d(rlSrc.lowReg, rlSrc.highReg);
} else {
- rlSrc = loadValue(cUnit, rlSrc, rcSrc);
+ rlSrc = LoadValue(cUnit, rlSrc, rcSrc);
srcReg = rlSrc.lowReg;
}
if (rlDest.wide) {
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
- newLIR2(cUnit, op, s2d(rlResult.lowReg, rlResult.highReg), srcReg);
- storeValueWide(cUnit, rlDest, rlResult);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
+ NewLIR2(cUnit, op, S2d(rlResult.lowReg, rlResult.highReg), srcReg);
+ StoreValueWide(cUnit, rlDest, rlResult);
} else {
- rlResult = oatEvalLoc(cUnit, rlDest, kFPReg, true);
- newLIR2(cUnit, op, rlResult.lowReg, srcReg);
- storeValue(cUnit, rlDest, rlResult);
+ rlResult = EvalLoc(cUnit, rlDest, kFPReg, true);
+ NewLIR2(cUnit, op, rlResult.lowReg, srcReg);
+ StoreValue(cUnit, rlDest, rlResult);
}
return false;
}
-bool genCmpFP(CompilationUnit *cUnit, Instruction::Code code, RegLocation rlDest,
+bool GenCmpFP(CompilationUnit *cUnit, Instruction::Code code, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2) {
bool single = (code == Instruction::CMPL_FLOAT) || (code == Instruction::CMPG_FLOAT);
bool unorderedGt = (code == Instruction::CMPG_DOUBLE) || (code == Instruction::CMPG_FLOAT);
int srcReg1;
int srcReg2;
if (single) {
- rlSrc1 = loadValue(cUnit, rlSrc1, kFPReg);
+ rlSrc1 = LoadValue(cUnit, rlSrc1, kFPReg);
srcReg1 = rlSrc1.lowReg;
- rlSrc2 = loadValue(cUnit, rlSrc2, kFPReg);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kFPReg);
srcReg2 = rlSrc2.lowReg;
} else {
- rlSrc1 = loadValueWide(cUnit, rlSrc1, kFPReg);
- srcReg1 = s2d(rlSrc1.lowReg, rlSrc1.highReg);
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kFPReg);
- srcReg2 = s2d(rlSrc2.lowReg, rlSrc2.highReg);
+ rlSrc1 = LoadValueWide(cUnit, rlSrc1, kFPReg);
+ srcReg1 = S2d(rlSrc1.lowReg, rlSrc1.highReg);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kFPReg);
+ srcReg2 = S2d(rlSrc2.lowReg, rlSrc2.highReg);
}
- oatClobberSReg(cUnit, rlDest.sRegLow);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- loadConstantNoClobber(cUnit, rlResult.lowReg, unorderedGt ? 1 : 0);
+ ClobberSReg(cUnit, rlDest.sRegLow);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ LoadConstantNoClobber(cUnit, rlResult.lowReg, unorderedGt ? 1 : 0);
if (single) {
- newLIR2(cUnit, kX86UcomissRR, srcReg1, srcReg2);
+ NewLIR2(cUnit, kX86UcomissRR, srcReg1, srcReg2);
} else {
- newLIR2(cUnit, kX86UcomisdRR, srcReg1, srcReg2);
+ NewLIR2(cUnit, kX86UcomisdRR, srcReg1, srcReg2);
}
LIR* branch = NULL;
if (unorderedGt) {
- branch = newLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
+ branch = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
}
// If the result reg can't be byte accessed, use a jump and move instead of a set.
if (rlResult.lowReg >= 4) {
LIR* branch2 = NULL;
if (unorderedGt) {
- branch2 = newLIR2(cUnit, kX86Jcc8, 0, kX86CondA);
- newLIR2(cUnit, kX86Mov32RI, rlResult.lowReg, 0x0);
+ branch2 = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondA);
+ NewLIR2(cUnit, kX86Mov32RI, rlResult.lowReg, 0x0);
} else {
- branch2 = newLIR2(cUnit, kX86Jcc8, 0, kX86CondBe);
- newLIR2(cUnit, kX86Mov32RI, rlResult.lowReg, 0x1);
+ branch2 = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondBe);
+ NewLIR2(cUnit, kX86Mov32RI, rlResult.lowReg, 0x1);
}
- branch2->target = newLIR0(cUnit, kPseudoTargetLabel);
+ branch2->target = NewLIR0(cUnit, kPseudoTargetLabel);
} else {
- newLIR2(cUnit, kX86Set8R, rlResult.lowReg, kX86CondA /* above - unsigned > */);
+ NewLIR2(cUnit, kX86Set8R, rlResult.lowReg, kX86CondA /* above - unsigned > */);
}
- newLIR2(cUnit, kX86Sbb32RI, rlResult.lowReg, 0);
+ NewLIR2(cUnit, kX86Sbb32RI, rlResult.lowReg, 0);
if (unorderedGt) {
- branch->target = newLIR0(cUnit, kPseudoTargetLabel);
+ branch->target = NewLIR0(cUnit, kPseudoTargetLabel);
}
- storeValue(cUnit, rlDest, rlResult);
+ StoreValue(cUnit, rlDest, rlResult);
return false;
}
-void genFusedFPCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
+void GenFusedFPCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir,
bool gtBias, bool isDouble) {
LIR* labelList = cUnit->blockLabelList;
LIR* taken = &labelList[bb->taken->id];
@@ -272,57 +272,57 @@
RegLocation rlSrc1;
RegLocation rlSrc2;
if (isDouble) {
- rlSrc1 = oatGetSrcWide(cUnit, mir, 0);
- rlSrc2 = oatGetSrcWide(cUnit, mir, 2);
- rlSrc1 = loadValueWide(cUnit, rlSrc1, kFPReg);
- rlSrc2 = loadValueWide(cUnit, rlSrc2, kFPReg);
- newLIR2(cUnit, kX86UcomisdRR, s2d(rlSrc1.lowReg, rlSrc1.highReg),
- s2d(rlSrc2.lowReg, rlSrc2.highReg));
+ rlSrc1 = GetSrcWide(cUnit, mir, 0);
+ rlSrc2 = GetSrcWide(cUnit, mir, 2);
+ rlSrc1 = LoadValueWide(cUnit, rlSrc1, kFPReg);
+ rlSrc2 = LoadValueWide(cUnit, rlSrc2, kFPReg);
+ NewLIR2(cUnit, kX86UcomisdRR, S2d(rlSrc1.lowReg, rlSrc1.highReg),
+ S2d(rlSrc2.lowReg, rlSrc2.highReg));
} else {
- rlSrc1 = oatGetSrc(cUnit, mir, 0);
- rlSrc2 = oatGetSrc(cUnit, mir, 1);
- rlSrc1 = loadValue(cUnit, rlSrc1, kFPReg);
- rlSrc2 = loadValue(cUnit, rlSrc2, kFPReg);
- newLIR2(cUnit, kX86UcomissRR, rlSrc1.lowReg, rlSrc2.lowReg);
+ rlSrc1 = GetSrc(cUnit, mir, 0);
+ rlSrc2 = GetSrc(cUnit, mir, 1);
+ rlSrc1 = LoadValue(cUnit, rlSrc1, kFPReg);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kFPReg);
+ NewLIR2(cUnit, kX86UcomissRR, rlSrc1.lowReg, rlSrc2.lowReg);
}
ConditionCode ccode = static_cast<ConditionCode>(mir->dalvikInsn.arg[0]);
switch (ccode) {
case kCondEq:
if (!gtBias) {
- branch = newLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
+ branch = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
branch->target = notTaken;
}
break;
case kCondNe:
if (!gtBias) {
- branch = newLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
+ branch = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
branch->target = taken;
}
break;
case kCondLt:
if (gtBias) {
- branch = newLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
+ branch = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
branch->target = notTaken;
}
ccode = kCondCs;
break;
case kCondLe:
if (gtBias) {
- branch = newLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
+ branch = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
branch->target = notTaken;
}
ccode = kCondLs;
break;
case kCondGt:
if (gtBias) {
- branch = newLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
+ branch = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
branch->target = taken;
}
ccode = kCondHi;
break;
case kCondGe:
if (gtBias) {
- branch = newLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
+ branch = NewLIR2(cUnit, kX86Jcc8, 0, kX86CondPE);
branch->target = taken;
}
ccode = kCondCc;
@@ -330,29 +330,29 @@
default:
LOG(FATAL) << "Unexpected ccode: " << ccode;
}
- opCondBranch(cUnit, ccode, taken);
+ OpCondBranch(cUnit, ccode, taken);
}
-void genNegFloat(CompilationUnit *cUnit, RegLocation rlDest, RegLocation rlSrc)
+void GenNegFloat(CompilationUnit *cUnit, RegLocation rlDest, RegLocation rlSrc)
{
RegLocation rlResult;
- rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- opRegRegImm(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, 0x80000000);
- storeValue(cUnit, rlDest, rlResult);
+ rlSrc = LoadValue(cUnit, rlSrc, kCoreReg);
+ rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ OpRegRegImm(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, 0x80000000);
+ StoreValue(cUnit, rlDest, rlResult);
}
-void genNegDouble(CompilationUnit *cUnit, RegLocation rlDest, RegLocation rlSrc)
+void GenNegDouble(CompilationUnit *cUnit, RegLocation rlDest, RegLocation rlSrc)
{
RegLocation rlResult;
- rlSrc = loadValueWide(cUnit, rlSrc, kCoreReg);
- rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- opRegRegImm(cUnit, kOpAdd, rlResult.highReg, rlSrc.highReg, 0x80000000);
- opRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
- storeValueWide(cUnit, rlDest, rlResult);
+ rlSrc = LoadValueWide(cUnit, rlSrc, kCoreReg);
+ rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ OpRegRegImm(cUnit, kOpAdd, rlResult.highReg, rlSrc.highReg, 0x80000000);
+ OpRegCopy(cUnit, rlResult.lowReg, rlSrc.lowReg);
+ StoreValueWide(cUnit, rlDest, rlResult);
}
-bool genInlinedSqrt(CompilationUnit* cUnit, CallInfo* info) {
+bool GenInlinedSqrt(CompilationUnit* cUnit, CallInfo* info) {
DCHECK_NE(cUnit->instructionSet, kThumb2);
return false;
}
diff --git a/src/compiler/codegen/x86/int_x86.cc b/src/compiler/codegen/x86/int_x86.cc
index adde482..c501bc3 100644
--- a/src/compiler/codegen/x86/int_x86.cc
+++ b/src/compiler/codegen/x86/int_x86.cc
@@ -25,15 +25,15 @@
/*
* Perform register memory operation.
*/
-LIR* genRegMemCheck(CompilationUnit* cUnit, ConditionCode cCode,
+LIR* GenRegMemCheck(CompilationUnit* cUnit, ConditionCode cCode,
int reg1, int base, int offset, ThrowKind kind)
{
- LIR* tgt = rawLIR(cUnit, 0, kPseudoThrowTarget, kind,
+ LIR* tgt = RawLIR(cUnit, 0, kPseudoThrowTarget, kind,
cUnit->currentDalvikOffset, reg1, base, offset);
- opRegMem(cUnit, kOpCmp, reg1, base, offset);
- LIR* branch = opCondBranch(cUnit, cCode, tgt);
+ OpRegMem(cUnit, kOpCmp, reg1, base, offset);
+ 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;
}
@@ -53,28 +53,28 @@
* finish:
*
*/
-void genCmpLong(CompilationUnit* cUnit, RegLocation rlDest,
+void GenCmpLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- oatFlushAllRegs(cUnit);
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- loadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
- loadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
+ FlushAllRegs(cUnit);
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ LoadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
+ LoadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
// Compute (r1:r0) = (r1:r0) - (r3:r2)
- opRegReg(cUnit, kOpSub, r0, r2); // r0 = r0 - r2
- opRegReg(cUnit, kOpSbc, r1, r3); // r1 = r1 - r3 - CF
- newLIR2(cUnit, kX86Set8R, r2, kX86CondL); // r2 = (r1:r0) < (r3:r2) ? 1 : 0
- newLIR2(cUnit, kX86Movzx8RR, r2, r2);
- opReg(cUnit, kOpNeg, r2); // r2 = -r2
- opRegReg(cUnit, kOpOr, r0, r1); // r0 = high | low - sets ZF
- newLIR2(cUnit, kX86Set8R, r0, kX86CondNz); // r0 = (r1:r0) != (r3:r2) ? 1 : 0
- newLIR2(cUnit, kX86Movzx8RR, r0, r0);
- opRegReg(cUnit, kOpOr, r0, r2); // r0 = r0 | r2
- RegLocation rlResult = locCReturn();
- storeValue(cUnit, rlDest, rlResult);
+ OpRegReg(cUnit, kOpSub, r0, r2); // r0 = r0 - r2
+ OpRegReg(cUnit, kOpSbc, r1, r3); // r1 = r1 - r3 - CF
+ NewLIR2(cUnit, kX86Set8R, r2, kX86CondL); // r2 = (r1:r0) < (r3:r2) ? 1 : 0
+ NewLIR2(cUnit, kX86Movzx8RR, r2, r2);
+ OpReg(cUnit, kOpNeg, r2); // r2 = -r2
+ OpRegReg(cUnit, kOpOr, r0, r1); // r0 = high | low - sets ZF
+ NewLIR2(cUnit, kX86Set8R, r0, kX86CondNz); // r0 = (r1:r0) != (r3:r2) ? 1 : 0
+ NewLIR2(cUnit, kX86Movzx8RR, r0, r0);
+ OpRegReg(cUnit, kOpOr, r0, r2); // r0 = r0 | r2
+ RegLocation rlResult = LocCReturn();
+ StoreValue(cUnit, rlDest, rlResult);
}
-X86ConditionCode oatX86ConditionEncoding(ConditionCode cond) {
+X86ConditionCode X86ConditionEncoding(ConditionCode cond) {
switch (cond) {
case kCondEq: return kX86CondEq;
case kCondNe: return kX86CondNe;
@@ -96,37 +96,37 @@
return kX86CondO;
}
-LIR* opCmpBranch(CompilationUnit* cUnit, ConditionCode cond, int src1,
+LIR* OpCmpBranch(CompilationUnit* cUnit, ConditionCode cond, int src1,
int src2, LIR* target)
{
- newLIR2(cUnit, kX86Cmp32RR, src1, src2);
- X86ConditionCode cc = oatX86ConditionEncoding(cond);
- LIR* branch = newLIR2(cUnit, kX86Jcc8, 0 /* lir operand for Jcc offset */ ,
+ NewLIR2(cUnit, kX86Cmp32RR, src1, src2);
+ X86ConditionCode cc = X86ConditionEncoding(cond);
+ LIR* branch = NewLIR2(cUnit, kX86Jcc8, 0 /* lir operand for Jcc offset */ ,
cc);
branch->target = target;
return branch;
}
-LIR* opCmpImmBranch(CompilationUnit* cUnit, ConditionCode cond, int reg,
+LIR* OpCmpImmBranch(CompilationUnit* cUnit, ConditionCode cond, int reg,
int checkValue, LIR* target)
{
if ((checkValue == 0) && (cond == kCondEq || cond == kCondNe)) {
// TODO: when checkValue == 0 and reg is rCX, use the jcxz/nz opcode
- newLIR2(cUnit, kX86Test32RR, reg, reg);
+ NewLIR2(cUnit, kX86Test32RR, reg, reg);
} else {
- newLIR2(cUnit, IS_SIMM8(checkValue) ? kX86Cmp32RI8 : kX86Cmp32RI, reg, checkValue);
+ NewLIR2(cUnit, IS_SIMM8(checkValue) ? kX86Cmp32RI8 : kX86Cmp32RI, reg, checkValue);
}
- X86ConditionCode cc = oatX86ConditionEncoding(cond);
- LIR* branch = newLIR2(cUnit, kX86Jcc8, 0 /* lir operand for Jcc offset */ , cc);
+ X86ConditionCode cc = X86ConditionEncoding(cond);
+ LIR* branch = NewLIR2(cUnit, kX86Jcc8, 0 /* lir operand for Jcc offset */ , cc);
branch->target = target;
return branch;
}
-LIR* opRegCopyNoInsert(CompilationUnit *cUnit, int rDest, int rSrc)
+LIR* OpRegCopyNoInsert(CompilationUnit *cUnit, int rDest, int rSrc)
{
if (X86_FPREG(rDest) || X86_FPREG(rSrc))
- return fpRegCopy(cUnit, rDest, rSrc);
- LIR* res = rawLIR(cUnit, cUnit->currentDalvikOffset, kX86Mov32RR,
+ return FpRegCopy(cUnit, rDest, rSrc);
+ LIR* res = RawLIR(cUnit, cUnit->currentDalvikOffset, kX86Mov32RR,
rDest, rSrc);
if (rDest == rSrc) {
res->flags.isNop = true;
@@ -134,14 +134,14 @@
return res;
}
-LIR* opRegCopy(CompilationUnit *cUnit, int rDest, int rSrc)
+LIR* OpRegCopy(CompilationUnit *cUnit, int rDest, int rSrc)
{
- LIR *res = opRegCopyNoInsert(cUnit, rDest, rSrc);
- oatAppendLIR(cUnit, res);
+ LIR *res = OpRegCopyNoInsert(cUnit, rDest, rSrc);
+ AppendLIR(cUnit, res);
return res;
}
-void opRegCopyWide(CompilationUnit *cUnit, int destLo, int destHi,
+void OpRegCopyWide(CompilationUnit *cUnit, int destLo, int destHi,
int srcLo, int srcHi)
{
bool destFP = X86_FPREG(destLo) && X86_FPREG(destHi);
@@ -150,57 +150,57 @@
assert(X86_FPREG(destLo) == X86_FPREG(destHi));
if (destFP) {
if (srcFP) {
- opRegCopy(cUnit, s2d(destLo, destHi), s2d(srcLo, srcHi));
+ OpRegCopy(cUnit, S2d(destLo, destHi), S2d(srcLo, srcHi));
} else {
// TODO: Prevent this from happening in the code. The result is often
// unused or could have been loaded more easily from memory.
- newLIR2(cUnit, kX86MovdxrRR, destLo, srcLo);
- newLIR2(cUnit, kX86MovdxrRR, destHi, srcHi);
- newLIR2(cUnit, kX86PsllqRI, destHi, 32);
- newLIR2(cUnit, kX86OrpsRR, destLo, destHi);
+ NewLIR2(cUnit, kX86MovdxrRR, destLo, srcLo);
+ NewLIR2(cUnit, kX86MovdxrRR, destHi, srcHi);
+ NewLIR2(cUnit, kX86PsllqRI, destHi, 32);
+ NewLIR2(cUnit, kX86OrpsRR, destLo, destHi);
}
} else {
if (srcFP) {
- newLIR2(cUnit, kX86MovdrxRR, destLo, srcLo);
- newLIR2(cUnit, kX86PsrlqRI, srcLo, 32);
- newLIR2(cUnit, kX86MovdrxRR, destHi, srcLo);
+ NewLIR2(cUnit, kX86MovdrxRR, destLo, srcLo);
+ NewLIR2(cUnit, kX86PsrlqRI, srcLo, 32);
+ NewLIR2(cUnit, kX86MovdrxRR, destHi, srcLo);
} else {
// Handle overlap
if (srcHi == destLo) {
- opRegCopy(cUnit, destHi, srcHi);
- opRegCopy(cUnit, destLo, srcLo);
+ OpRegCopy(cUnit, destHi, srcHi);
+ OpRegCopy(cUnit, destLo, srcLo);
} else {
- opRegCopy(cUnit, destLo, srcLo);
- opRegCopy(cUnit, destHi, srcHi);
+ OpRegCopy(cUnit, destLo, srcLo);
+ OpRegCopy(cUnit, destHi, srcHi);
}
}
}
}
-void genFusedLongCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir) {
+void GenFusedLongCmpBranch(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir) {
LIR* labelList = cUnit->blockLabelList;
LIR* taken = &labelList[bb->taken->id];
- RegLocation rlSrc1 = oatGetSrcWide(cUnit, mir, 0);
- RegLocation rlSrc2 = oatGetSrcWide(cUnit, mir, 2);
- oatFlushAllRegs(cUnit);
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- loadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
- loadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
+ RegLocation rlSrc1 = GetSrcWide(cUnit, mir, 0);
+ RegLocation rlSrc2 = GetSrcWide(cUnit, mir, 2);
+ FlushAllRegs(cUnit);
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ LoadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
+ LoadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
ConditionCode ccode = static_cast<ConditionCode>(mir->dalvikInsn.arg[0]);
// Swap operands and condition code to prevent use of zero flag.
if (ccode == kCondLe || ccode == kCondGt) {
// Compute (r3:r2) = (r3:r2) - (r1:r0)
- opRegReg(cUnit, kOpSub, r2, r0); // r2 = r2 - r0
- opRegReg(cUnit, kOpSbc, r3, r1); // r3 = r3 - r1 - CF
+ OpRegReg(cUnit, kOpSub, r2, r0); // r2 = r2 - r0
+ OpRegReg(cUnit, kOpSbc, r3, r1); // r3 = r3 - r1 - CF
} else {
// Compute (r1:r0) = (r1:r0) - (r3:r2)
- opRegReg(cUnit, kOpSub, r0, r2); // r0 = r0 - r2
- opRegReg(cUnit, kOpSbc, r1, r3); // r1 = r1 - r3 - CF
+ OpRegReg(cUnit, kOpSub, r0, r2); // r0 = r0 - r2
+ OpRegReg(cUnit, kOpSbc, r1, r3); // r1 = r1 - r3 - CF
}
switch (ccode) {
case kCondEq:
case kCondNe:
- opRegReg(cUnit, kOpOr, r0, r1); // r0 = r0 | r1
+ OpRegReg(cUnit, kOpOr, r0, r1); // r0 = r0 | r1
break;
case kCondLe:
ccode = kCondGe;
@@ -214,217 +214,217 @@
default:
LOG(FATAL) << "Unexpected ccode: " << ccode;
}
- opCondBranch(cUnit, ccode, taken);
+ OpCondBranch(cUnit, ccode, taken);
}
-RegLocation genDivRemLit(CompilationUnit* cUnit, RegLocation rlDest, int regLo, int lit, bool isDiv)
+RegLocation GenDivRemLit(CompilationUnit* cUnit, RegLocation rlDest, int regLo, int lit, bool isDiv)
{
- LOG(FATAL) << "Unexpected use of genDivRemLit for x86";
+ LOG(FATAL) << "Unexpected use of GenDivRemLit for x86";
return rlDest;
}
-RegLocation genDivRem(CompilationUnit* cUnit, RegLocation rlDest, int regLo, int regHi, bool isDiv)
+RegLocation GenDivRem(CompilationUnit* cUnit, RegLocation rlDest, int regLo, int regHi, bool isDiv)
{
- LOG(FATAL) << "Unexpected use of genDivRem for x86";
+ LOG(FATAL) << "Unexpected use of GenDivRem for x86";
return rlDest;
}
-bool genInlinedMinMaxInt(CompilationUnit *cUnit, CallInfo* info, bool isMin)
+bool GenInlinedMinMaxInt(CompilationUnit *cUnit, CallInfo* info, bool isMin)
{
DCHECK_EQ(cUnit->instructionSet, kX86);
RegLocation rlSrc1 = info->args[0];
RegLocation rlSrc2 = info->args[1];
- rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
- rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
- RegLocation rlDest = inlineTarget(cUnit, info);
- RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
- opRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
+ rlSrc1 = LoadValue(cUnit, rlSrc1, kCoreReg);
+ rlSrc2 = LoadValue(cUnit, rlSrc2, kCoreReg);
+ RegLocation rlDest = InlineTarget(cUnit, info);
+ RegLocation rlResult = EvalLoc(cUnit, rlDest, kCoreReg, true);
+ OpRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
DCHECK_EQ(cUnit->instructionSet, kX86);
- LIR* branch = newLIR2(cUnit, kX86Jcc8, 0, isMin ? kX86CondG : kX86CondL);
- opRegReg(cUnit, kOpMov, rlResult.lowReg, rlSrc1.lowReg);
- LIR* branch2 = newLIR1(cUnit, kX86Jmp8, 0);
- branch->target = newLIR0(cUnit, kPseudoTargetLabel);
- opRegReg(cUnit, kOpMov, rlResult.lowReg, rlSrc2.lowReg);
- branch2->target = newLIR0(cUnit, kPseudoTargetLabel);
- storeValue(cUnit, rlDest, rlResult);
+ LIR* branch = NewLIR2(cUnit, kX86Jcc8, 0, isMin ? kX86CondG : kX86CondL);
+ OpRegReg(cUnit, kOpMov, rlResult.lowReg, rlSrc1.lowReg);
+ LIR* branch2 = NewLIR1(cUnit, kX86Jmp8, 0);
+ branch->target = NewLIR0(cUnit, kPseudoTargetLabel);
+ OpRegReg(cUnit, kOpMov, rlResult.lowReg, rlSrc2.lowReg);
+ branch2->target = NewLIR0(cUnit, kPseudoTargetLabel);
+ StoreValue(cUnit, rlDest, rlResult);
return true;
}
-void opLea(CompilationUnit* cUnit, int rBase, int reg1, int reg2, int scale, int offset)
+void OpLea(CompilationUnit* cUnit, int rBase, int reg1, int reg2, int scale, int offset)
{
- newLIR5(cUnit, kX86Lea32RA, rBase, reg1, reg2, scale, offset);
+ NewLIR5(cUnit, kX86Lea32RA, rBase, reg1, reg2, scale, offset);
}
-void opTlsCmp(CompilationUnit* cUnit, int offset, int val)
+void OpTlsCmp(CompilationUnit* cUnit, int offset, int val)
{
- newLIR2(cUnit, kX86Cmp16TI8, offset, val);
+ NewLIR2(cUnit, kX86Cmp16TI8, offset, val);
}
-bool genInlinedCas32(CompilationUnit* cUnit, CallInfo* info, bool need_write_barrier) {
+bool GenInlinedCas32(CompilationUnit* cUnit, CallInfo* info, bool need_write_barrier) {
DCHECK_NE(cUnit->instructionSet, kThumb2);
return false;
}
-LIR* opPcRelLoad(CompilationUnit* cUnit, int reg, LIR* target) {
- LOG(FATAL) << "Unexpected use of opPcRelLoad for x86";
+LIR* OpPcRelLoad(CompilationUnit* cUnit, int reg, LIR* target) {
+ LOG(FATAL) << "Unexpected use of OpPcRelLoad for x86";
return NULL;
}
-LIR* opVldm(CompilationUnit* cUnit, int rBase, int count)
+LIR* OpVldm(CompilationUnit* cUnit, int rBase, int count)
{
- LOG(FATAL) << "Unexpected use of opVldm for x86";
+ LOG(FATAL) << "Unexpected use of OpVldm for x86";
return NULL;
}
-LIR* opVstm(CompilationUnit* cUnit, int rBase, int count)
+LIR* OpVstm(CompilationUnit* cUnit, int rBase, int count)
{
- LOG(FATAL) << "Unexpected use of opVstm for x86";
+ LOG(FATAL) << "Unexpected use of OpVstm for x86";
return NULL;
}
-void genMultiplyByTwoBitMultiplier(CompilationUnit* cUnit, RegLocation rlSrc,
+void GenMultiplyByTwoBitMultiplier(CompilationUnit* cUnit, RegLocation rlSrc,
RegLocation rlResult, int lit,
int firstBit, int secondBit)
{
- int tReg = oatAllocTemp(cUnit);
- opRegRegImm(cUnit, kOpLsl, tReg, rlSrc.lowReg, secondBit - firstBit);
- opRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, tReg);
- oatFreeTemp(cUnit, tReg);
+ int tReg = AllocTemp(cUnit);
+ OpRegRegImm(cUnit, kOpLsl, tReg, rlSrc.lowReg, secondBit - firstBit);
+ OpRegRegReg(cUnit, kOpAdd, rlResult.lowReg, rlSrc.lowReg, tReg);
+ FreeTemp(cUnit, tReg);
if (firstBit != 0) {
- opRegRegImm(cUnit, kOpLsl, rlResult.lowReg, rlResult.lowReg, firstBit);
+ OpRegRegImm(cUnit, kOpLsl, rlResult.lowReg, rlResult.lowReg, firstBit);
}
}
-void genDivZeroCheck(CompilationUnit* cUnit, int regLo, int regHi)
+void GenDivZeroCheck(CompilationUnit* cUnit, int regLo, int regHi)
{
- int tReg = oatAllocTemp(cUnit);
- opRegRegReg(cUnit, kOpOr, tReg, regLo, regHi);
- genImmedCheck(cUnit, kCondEq, tReg, 0, kThrowDivZero);
- oatFreeTemp(cUnit, tReg);
+ int tReg = AllocTemp(cUnit);
+ OpRegRegReg(cUnit, kOpOr, tReg, regLo, regHi);
+ GenImmedCheck(cUnit, kCondEq, tReg, 0, kThrowDivZero);
+ FreeTemp(cUnit, tReg);
}
// Test suspend flag, return target of taken suspend branch
-LIR* opTestSuspend(CompilationUnit* cUnit, LIR* target)
+LIR* OpTestSuspend(CompilationUnit* cUnit, LIR* target)
{
- opTlsCmp(cUnit, Thread::ThreadFlagsOffset().Int32Value(), 0);
- return opCondBranch(cUnit, (target == NULL) ? kCondNe : kCondEq, target);
+ OpTlsCmp(cUnit, Thread::ThreadFlagsOffset().Int32Value(), 0);
+ return OpCondBranch(cUnit, (target == NULL) ? kCondNe : kCondEq, target);
}
// Decrement register and branch on condition
-LIR* opDecAndBranch(CompilationUnit* cUnit, ConditionCode cCode, int reg, LIR* target)
+LIR* OpDecAndBranch(CompilationUnit* cUnit, ConditionCode cCode, int reg, LIR* target)
{
- opRegImm(cUnit, kOpSub, reg, 1);
- return opCmpImmBranch(cUnit, cCode, reg, 0, target);
+ OpRegImm(cUnit, kOpSub, reg, 1);
+ return OpCmpImmBranch(cUnit, cCode, reg, 0, target);
}
-bool smallLiteralDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode,
+bool SmallLiteralDivide(CompilationUnit* cUnit, Instruction::Code dalvikOpcode,
RegLocation rlSrc, RegLocation rlDest, int lit)
{
LOG(FATAL) << "Unexpected use of smallLiteralDive in x86";
return false;
}
-LIR* opIT(CompilationUnit* cUnit, ArmConditionCode cond, const char* guide)
+LIR* OpIT(CompilationUnit* cUnit, ArmConditionCode cond, const char* guide)
{
- LOG(FATAL) << "Unexpected use of opIT in x86";
+ LOG(FATAL) << "Unexpected use of OpIT in x86";
return NULL;
}
-bool genAddLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenAddLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- oatFlushAllRegs(cUnit);
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- loadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
- loadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
+ FlushAllRegs(cUnit);
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ LoadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
+ LoadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
// Compute (r1:r0) = (r1:r0) + (r2:r3)
- opRegReg(cUnit, kOpAdd, r0, r2); // r0 = r0 + r2
- opRegReg(cUnit, kOpAdc, r1, r3); // r1 = r1 + r3 + CF
+ OpRegReg(cUnit, kOpAdd, r0, r2); // r0 = r0 + r2
+ OpRegReg(cUnit, kOpAdc, r1, r3); // r1 = r1 + r3 + CF
RegLocation rlResult = {kLocPhysReg, 1, 0, 0, 0, 0, 0, 0, 1, r0, r1,
INVALID_SREG, INVALID_SREG};
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
-bool genSubLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenSubLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- oatFlushAllRegs(cUnit);
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- loadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
- loadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
+ FlushAllRegs(cUnit);
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ LoadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
+ LoadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
// Compute (r1:r0) = (r1:r0) + (r2:r3)
- opRegReg(cUnit, kOpSub, r0, r2); // r0 = r0 - r2
- opRegReg(cUnit, kOpSbc, r1, r3); // r1 = r1 - r3 - CF
+ OpRegReg(cUnit, kOpSub, r0, r2); // r0 = r0 - r2
+ OpRegReg(cUnit, kOpSbc, r1, r3); // r1 = r1 - r3 - CF
RegLocation rlResult = {kLocPhysReg, 1, 0, 0, 0, 0, 0, 0, 1, r0, r1,
INVALID_SREG, INVALID_SREG};
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
-bool genAndLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenAndLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- oatFlushAllRegs(cUnit);
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- loadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
- loadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
+ FlushAllRegs(cUnit);
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ LoadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
+ LoadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
// Compute (r1:r0) = (r1:r0) + (r2:r3)
- opRegReg(cUnit, kOpAnd, r0, r2); // r0 = r0 - r2
- opRegReg(cUnit, kOpAnd, r1, r3); // r1 = r1 - r3 - CF
+ OpRegReg(cUnit, kOpAnd, r0, r2); // r0 = r0 - r2
+ OpRegReg(cUnit, kOpAnd, r1, r3); // r1 = r1 - r3 - CF
RegLocation rlResult = {kLocPhysReg, 1, 0, 0, 0, 0, 0, 0, 1, r0, r1,
INVALID_SREG, INVALID_SREG};
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
-bool genOrLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenOrLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- oatFlushAllRegs(cUnit);
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- loadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
- loadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
+ FlushAllRegs(cUnit);
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ LoadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
+ LoadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
// Compute (r1:r0) = (r1:r0) + (r2:r3)
- opRegReg(cUnit, kOpOr, r0, r2); // r0 = r0 - r2
- opRegReg(cUnit, kOpOr, r1, r3); // r1 = r1 - r3 - CF
+ OpRegReg(cUnit, kOpOr, r0, r2); // r0 = r0 - r2
+ OpRegReg(cUnit, kOpOr, r1, r3); // r1 = r1 - r3 - CF
RegLocation rlResult = {kLocPhysReg, 1, 0, 0, 0, 0, 0, 0, 1, r0, r1,
INVALID_SREG, INVALID_SREG};
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
-bool genXorLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenXorLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc1, RegLocation rlSrc2)
{
- oatFlushAllRegs(cUnit);
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- loadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
- loadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
+ FlushAllRegs(cUnit);
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ LoadValueDirectWideFixed(cUnit, rlSrc1, r0, r1);
+ LoadValueDirectWideFixed(cUnit, rlSrc2, r2, r3);
// Compute (r1:r0) = (r1:r0) + (r2:r3)
- opRegReg(cUnit, kOpXor, r0, r2); // r0 = r0 - r2
- opRegReg(cUnit, kOpXor, r1, r3); // r1 = r1 - r3 - CF
+ OpRegReg(cUnit, kOpXor, r0, r2); // r0 = r0 - r2
+ OpRegReg(cUnit, kOpXor, r1, r3); // r1 = r1 - r3 - CF
RegLocation rlResult = {kLocPhysReg, 1, 0, 0, 0, 0, 0, 0, 1, r0, r1,
INVALID_SREG, INVALID_SREG};
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
-bool genNegLong(CompilationUnit* cUnit, RegLocation rlDest,
+bool GenNegLong(CompilationUnit* cUnit, RegLocation rlDest,
RegLocation rlSrc)
{
- oatFlushAllRegs(cUnit);
- oatLockCallTemps(cUnit); // Prepare for explicit register usage
- loadValueDirectWideFixed(cUnit, rlSrc, r0, r1);
+ FlushAllRegs(cUnit);
+ LockCallTemps(cUnit); // Prepare for explicit register usage
+ LoadValueDirectWideFixed(cUnit, rlSrc, r0, r1);
// Compute (r1:r0) = -(r1:r0)
- opRegReg(cUnit, kOpNeg, r0, r0); // r0 = -r0
- opRegImm(cUnit, kOpAdc, r1, 0); // r1 = r1 + CF
- opRegReg(cUnit, kOpNeg, r1, r1); // r1 = -r1
+ OpRegReg(cUnit, kOpNeg, r0, r0); // r0 = -r0
+ OpRegImm(cUnit, kOpAdc, r1, 0); // r1 = r1 + CF
+ OpRegReg(cUnit, kOpNeg, r1, r1); // r1 = -r1
RegLocation rlResult = {kLocPhysReg, 1, 0, 0, 0, 0, 0, 0, 1, r0, r1,
INVALID_SREG, INVALID_SREG};
- storeValueWide(cUnit, rlDest, rlResult);
+ StoreValueWide(cUnit, rlDest, rlResult);
return false;
}
-void opRegThreadMem(CompilationUnit* cUnit, OpKind op, int rDest, int threadOffset) {
+void OpRegThreadMem(CompilationUnit* cUnit, OpKind op, int rDest, int threadOffset) {
X86OpCode opcode = kX86Bkpt;
switch (op) {
case kOpCmp: opcode = kX86Cmp32RT; break;
@@ -432,7 +432,7 @@
LOG(FATAL) << "Bad opcode: " << op;
break;
}
- newLIR2(cUnit, opcode, rDest, threadOffset);
+ NewLIR2(cUnit, opcode, rDest, threadOffset);
}
} // namespace art
diff --git a/src/compiler/codegen/x86/target_x86.cc b/src/compiler/codegen/x86/target_x86.cc
index 7c2adf1..64343e5 100644
--- a/src/compiler/codegen/x86/target_x86.cc
+++ b/src/compiler/codegen/x86/target_x86.cc
@@ -30,9 +30,9 @@
r8, r9, r10, r11, r12, r13, r14, 15
#endif
};
-/*static*/ int reservedRegs[] = {rX86_SP};
+/*static*/ int ReservedRegs[] = {rX86_SP};
/*static*/ int coreTemps[] = {rAX, rCX, rDX, rBX};
-/*static*/ int fpRegs[] = {
+/*static*/ int FpRegs[] = {
fr0, fr1, fr2, fr3, fr4, fr5, fr6, fr7,
#ifdef TARGET_REX_SUPPORT
fr8, fr9, fr10, fr11, fr12, fr13, fr14, fr15
@@ -45,32 +45,32 @@
#endif
};
-RegLocation locCReturn()
+RegLocation LocCReturn()
{
RegLocation res = X86_LOC_C_RETURN;
return res;
}
-RegLocation locCReturnWide()
+RegLocation LocCReturnWide()
{
RegLocation res = X86_LOC_C_RETURN_WIDE;
return res;
}
-RegLocation locCReturnFloat()
+RegLocation LocCReturnFloat()
{
RegLocation res = X86_LOC_C_RETURN_FLOAT;
return res;
}
-RegLocation locCReturnDouble()
+RegLocation LocCReturnDouble()
{
RegLocation res = X86_LOC_C_RETURN_DOUBLE;
return res;
}
// Return a target-dependent special register.
-int targetReg(SpecialTargetRegister reg) {
+int TargetReg(SpecialTargetRegister reg) {
int res = INVALID_REG;
switch (reg) {
case kSelf: res = rX86_SELF; break;
@@ -95,37 +95,37 @@
}
// Create a double from a pair of singles.
-int s2d(int lowReg, int highReg)
+int S2d(int lowReg, int highReg)
{
return X86_S2D(lowReg, highReg);
}
// Is reg a single or double?
-bool fpReg(int reg)
+bool FpReg(int reg)
{
return X86_FPREG(reg);
}
// Is reg a single?
-bool singleReg(int reg)
+bool SingleReg(int reg)
{
return X86_SINGLEREG(reg);
}
// Is reg a double?
-bool doubleReg(int reg)
+bool DoubleReg(int reg)
{
return X86_DOUBLEREG(reg);
}
// Return mask to strip off fp reg flags and bias.
-uint32_t fpRegMask()
+uint32_t FpRegMask()
{
return X86_FP_REG_MASK;
}
// True if both regs single, both core or both double.
-bool sameRegType(int reg1, int reg2)
+bool SameRegType(int reg1, int reg2)
{
return (X86_REGTYPE(reg1) == X86_REGTYPE(reg2));
}
@@ -133,7 +133,7 @@
/*
* Decode the register id.
*/
-uint64_t getRegMaskCommon(CompilationUnit* cUnit, int reg)
+uint64_t GetRegMaskCommon(CompilationUnit* cUnit, int reg)
{
uint64_t seed;
int shift;
@@ -149,17 +149,17 @@
return (seed << shift);
}
-uint64_t getPCUseDefEncoding()
+uint64_t GetPCUseDefEncoding()
{
/*
* FIXME: might make sense to use a virtual resource encoding bit for pc. Might be
* able to clean up some of the x86/Arm_Mips differences
*/
- LOG(FATAL) << "Unexpected call to getPCUseDefEncoding for x86";
+ LOG(FATAL) << "Unexpected call to GetPCUseDefEncoding for x86";
return 0ULL;
}
-void setupTargetResourceMasks(CompilationUnit* cUnit, LIR* lir)
+void SetupTargetResourceMasks(CompilationUnit* cUnit, LIR* lir)
{
DCHECK_EQ(cUnit->instructionSet, kX86);
@@ -175,22 +175,22 @@
}
if (flags & REG_DEFA) {
- oatSetupRegMask(cUnit, &lir->defMask, rAX);
+ SetupRegMask(cUnit, &lir->defMask, rAX);
}
if (flags & REG_DEFD) {
- oatSetupRegMask(cUnit, &lir->defMask, rDX);
+ SetupRegMask(cUnit, &lir->defMask, rDX);
}
if (flags & REG_USEA) {
- oatSetupRegMask(cUnit, &lir->useMask, rAX);
+ SetupRegMask(cUnit, &lir->useMask, rAX);
}
if (flags & REG_USEC) {
- oatSetupRegMask(cUnit, &lir->useMask, rCX);
+ SetupRegMask(cUnit, &lir->useMask, rCX);
}
if (flags & REG_USED) {
- oatSetupRegMask(cUnit, &lir->useMask, rDX);
+ SetupRegMask(cUnit, &lir->useMask, rDX);
}
}
@@ -223,7 +223,7 @@
* Interpret a format string and build a string no longer than size
* See format key in Assemble.cc.
*/
-std::string buildInsnString(const char *fmt, LIR *lir, unsigned char* baseAddr) {
+std::string BuildInsnString(const char *fmt, LIR *lir, unsigned char* baseAddr) {
std::string buf;
size_t i = 0;
size_t fmt_len = strlen(fmt);
@@ -281,7 +281,7 @@
return buf;
}
-void oatDumpResourceMask(LIR *x86LIR, uint64_t mask, const char *prefix)
+void DumpResourceMask(LIR *x86LIR, uint64_t mask, const char *prefix)
{
char buf[256];
buf[0] = 0;
@@ -322,7 +322,7 @@
LOG(INFO) << prefix << ": " << buf;
}
}
-void oatAdjustSpillMask(CompilationUnit* cUnit) {
+void AdjustSpillMask(CompilationUnit* cUnit) {
// Adjustment for LR spilling, x86 has no LR so nothing to do here
cUnit->coreSpillMask |= (1 << rRET);
cUnit->numCoreSpills++;
@@ -334,18 +334,18 @@
* include any holes in the mask. Associate holes with
* Dalvik register INVALID_VREG (0xFFFFU).
*/
-void oatMarkPreservedSingle(CompilationUnit* cUnit, int vReg, int reg)
+void MarkPreservedSingle(CompilationUnit* cUnit, int vReg, int reg)
{
- UNIMPLEMENTED(WARNING) << "oatMarkPreservedSingle";
+ UNIMPLEMENTED(WARNING) << "MarkPreservedSingle";
#if 0
LOG(FATAL) << "No support yet for promoted FP regs";
#endif
}
-void oatFlushRegWide(CompilationUnit* cUnit, int reg1, int reg2)
+void FlushRegWide(CompilationUnit* cUnit, int reg1, int reg2)
{
- RegisterInfo* info1 = oatGetRegInfo(cUnit, reg1);
- RegisterInfo* info2 = oatGetRegInfo(cUnit, reg2);
+ RegisterInfo* info1 = GetRegInfo(cUnit, reg1);
+ RegisterInfo* info2 = GetRegInfo(cUnit, reg2);
DCHECK(info1 && info2 && info1->pair && info2->pair &&
(info1->partner == info2->reg) &&
(info2->partner == info1->reg));
@@ -360,109 +360,96 @@
if (SRegToVReg(cUnit, info2->sReg) < SRegToVReg(cUnit, info1->sReg))
info1 = info2;
int vReg = SRegToVReg(cUnit, info1->sReg);
- storeBaseDispWide(cUnit, rX86_SP, oatVRegOffset(cUnit, vReg), info1->reg, info1->partner);
+ StoreBaseDispWide(cUnit, rX86_SP, VRegOffset(cUnit, vReg), info1->reg, info1->partner);
}
}
-void oatFlushReg(CompilationUnit* cUnit, int reg)
+void FlushReg(CompilationUnit* cUnit, int reg)
{
- RegisterInfo* info = oatGetRegInfo(cUnit, reg);
+ RegisterInfo* info = GetRegInfo(cUnit, reg);
if (info->live && info->dirty) {
info->dirty = false;
int vReg = SRegToVReg(cUnit, info->sReg);
- storeBaseDisp(cUnit, rX86_SP, oatVRegOffset(cUnit, vReg), reg, kWord);
+ StoreBaseDisp(cUnit, rX86_SP, VRegOffset(cUnit, vReg), reg, kWord);
}
}
/* Give access to the target-dependent FP register encoding to common code */
-bool oatIsFpReg(int reg) {
+bool IsFpReg(int reg) {
return X86_FPREG(reg);
}
-uint32_t oatFpRegMask() {
- return X86_FP_REG_MASK;
-}
-
/* Clobber all regs that might be used by an external C call */
-extern void oatClobberCalleeSave(CompilationUnit *cUnit)
+extern void ClobberCalleeSave(CompilationUnit *cUnit)
{
- oatClobber(cUnit, rAX);
- oatClobber(cUnit, rCX);
- oatClobber(cUnit, rDX);
+ Clobber(cUnit, rAX);
+ Clobber(cUnit, rCX);
+ Clobber(cUnit, rDX);
}
-extern RegLocation oatGetReturnWideAlt(CompilationUnit* cUnit) {
- RegLocation res = locCReturnWide();
+extern RegLocation GetReturnWideAlt(CompilationUnit* cUnit) {
+ RegLocation res = LocCReturnWide();
CHECK(res.lowReg == rAX);
CHECK(res.highReg == rDX);
- oatClobber(cUnit, rAX);
- oatClobber(cUnit, rDX);
- oatMarkInUse(cUnit, rAX);
- oatMarkInUse(cUnit, rDX);
- oatMarkPair(cUnit, res.lowReg, res.highReg);
+ Clobber(cUnit, rAX);
+ Clobber(cUnit, rDX);
+ MarkInUse(cUnit, rAX);
+ MarkInUse(cUnit, rDX);
+ MarkPair(cUnit, res.lowReg, res.highReg);
return res;
}
-extern RegLocation oatGetReturnAlt(CompilationUnit* cUnit)
+extern RegLocation GetReturnAlt(CompilationUnit* cUnit)
{
- RegLocation res = locCReturn();
+ RegLocation res = LocCReturn();
res.lowReg = rDX;
- oatClobber(cUnit, rDX);
- oatMarkInUse(cUnit, rDX);
+ Clobber(cUnit, rDX);
+ MarkInUse(cUnit, rDX);
return res;
}
-extern RegisterInfo* oatGetRegInfo(CompilationUnit* cUnit, int reg)
+extern RegisterInfo* GetRegInfo(CompilationUnit* cUnit, int reg)
{
return X86_FPREG(reg) ? &cUnit->regPool->FPRegs[reg & X86_FP_REG_MASK]
: &cUnit->regPool->coreRegs[reg];
}
/* To be used when explicitly managing register use */
-extern void oatLockCallTemps(CompilationUnit* cUnit)
+extern void LockCallTemps(CompilationUnit* cUnit)
{
- oatLockTemp(cUnit, rX86_ARG0);
- oatLockTemp(cUnit, rX86_ARG1);
- oatLockTemp(cUnit, rX86_ARG2);
- oatLockTemp(cUnit, rX86_ARG3);
+ LockTemp(cUnit, rX86_ARG0);
+ LockTemp(cUnit, rX86_ARG1);
+ LockTemp(cUnit, rX86_ARG2);
+ LockTemp(cUnit, rX86_ARG3);
}
/* To be used when explicitly managing register use */
-extern void oatFreeCallTemps(CompilationUnit* cUnit)
+extern void FreeCallTemps(CompilationUnit* cUnit)
{
- oatFreeTemp(cUnit, rX86_ARG0);
- oatFreeTemp(cUnit, rX86_ARG1);
- oatFreeTemp(cUnit, rX86_ARG2);
- oatFreeTemp(cUnit, rX86_ARG3);
-}
-
-/*
- * Determine the initial instruction set to be used for this trace.
- * Later components may decide to change this.
- */
-InstructionSet oatInstructionSet()
-{
- return kX86;
+ FreeTemp(cUnit, rX86_ARG0);
+ FreeTemp(cUnit, rX86_ARG1);
+ FreeTemp(cUnit, rX86_ARG2);
+ FreeTemp(cUnit, rX86_ARG3);
}
/* Architecture-specific initializations and checks go here */
-bool oatArchVariantInit(void)
+bool ArchVariantInit(void)
{
return true;
}
-void oatGenMemBarrier(CompilationUnit *cUnit, MemBarrierKind barrierKind)
+void GenMemBarrier(CompilationUnit *cUnit, MemBarrierKind barrierKind)
{
#if ANDROID_SMP != 0
// TODO: optimize fences
- newLIR0(cUnit, kX86Mfence);
+ NewLIR0(cUnit, kX86Mfence);
#endif
}
/*
* Alloc a pair of core registers, or a double. Low reg in low byte,
* high reg in next byte.
*/
-int oatAllocTypedTempPair(CompilationUnit *cUnit, bool fpHint,
+int AllocTypedTempPair(CompilationUnit *cUnit, bool fpHint,
int regClass)
{
int highReg;
@@ -470,58 +457,58 @@
int res = 0;
if (((regClass == kAnyReg) && fpHint) || (regClass == kFPReg)) {
- lowReg = oatAllocTempDouble(cUnit);
+ lowReg = AllocTempDouble(cUnit);
highReg = lowReg + 1;
res = (lowReg & 0xff) | ((highReg & 0xff) << 8);
return res;
}
- lowReg = oatAllocTemp(cUnit);
- highReg = oatAllocTemp(cUnit);
+ lowReg = AllocTemp(cUnit);
+ highReg = AllocTemp(cUnit);
res = (lowReg & 0xff) | ((highReg & 0xff) << 8);
return res;
}
-int oatAllocTypedTemp(CompilationUnit *cUnit, bool fpHint, int regClass) {
+int AllocTypedTemp(CompilationUnit *cUnit, bool fpHint, int regClass) {
if (((regClass == kAnyReg) && fpHint) || (regClass == kFPReg)) {
- return oatAllocTempFloat(cUnit);
+ return AllocTempFloat(cUnit);
}
- return oatAllocTemp(cUnit);
+ return AllocTemp(cUnit);
}
-void oatInitializeRegAlloc(CompilationUnit* cUnit) {
+void CompilerInitializeRegAlloc(CompilationUnit* cUnit) {
int numRegs = sizeof(coreRegs)/sizeof(*coreRegs);
- int numReserved = sizeof(reservedRegs)/sizeof(*reservedRegs);
+ int numReserved = sizeof(ReservedRegs)/sizeof(*ReservedRegs);
int numTemps = sizeof(coreTemps)/sizeof(*coreTemps);
- int numFPRegs = sizeof(fpRegs)/sizeof(*fpRegs);
+ int numFPRegs = sizeof(FpRegs)/sizeof(*FpRegs);
int numFPTemps = sizeof(fpTemps)/sizeof(*fpTemps);
RegisterPool *pool =
- static_cast<RegisterPool*>(oatNew(cUnit, sizeof(*pool), true, kAllocRegAlloc));
+ static_cast<RegisterPool*>(NewMem(cUnit, sizeof(*pool), true, kAllocRegAlloc));
cUnit->regPool = pool;
pool->numCoreRegs = numRegs;
pool->coreRegs =
- static_cast<RegisterInfo*>(oatNew(cUnit, numRegs * sizeof(*cUnit->regPool->coreRegs),
+ static_cast<RegisterInfo*>(NewMem(cUnit, numRegs * sizeof(*cUnit->regPool->coreRegs),
true, kAllocRegAlloc));
pool->numFPRegs = numFPRegs;
pool->FPRegs =
- static_cast<RegisterInfo *>(oatNew(cUnit, numFPRegs * sizeof(*cUnit->regPool->FPRegs),
+ static_cast<RegisterInfo *>(NewMem(cUnit, numFPRegs * sizeof(*cUnit->regPool->FPRegs),
true, kAllocRegAlloc));
- oatInitPool(pool->coreRegs, coreRegs, pool->numCoreRegs);
- oatInitPool(pool->FPRegs, fpRegs, pool->numFPRegs);
+ CompilerInitPool(pool->coreRegs, coreRegs, pool->numCoreRegs);
+ CompilerInitPool(pool->FPRegs, FpRegs, pool->numFPRegs);
// Keep special registers from being allocated
for (int i = 0; i < numReserved; i++) {
- oatMarkInUse(cUnit, reservedRegs[i]);
+ MarkInUse(cUnit, ReservedRegs[i]);
}
// Mark temp regs - all others not in use can be used for promotion
for (int i = 0; i < numTemps; i++) {
- oatMarkTemp(cUnit, coreTemps[i]);
+ MarkTemp(cUnit, coreTemps[i]);
}
for (int i = 0; i < numFPTemps; i++) {
- oatMarkTemp(cUnit, fpTemps[i]);
+ MarkTemp(cUnit, fpTemps[i]);
}
// Construct the alias map.
cUnit->phiAliasMap = static_cast<int*>
- (oatNew(cUnit, cUnit->numSSARegs * sizeof(cUnit->phiAliasMap[0]), false, kAllocDFInfo));
+ (NewMem(cUnit, cUnit->numSSARegs * sizeof(cUnit->phiAliasMap[0]), false, kAllocDFInfo));
for (int i = 0; i < cUnit->numSSARegs; i++) {
cUnit->phiAliasMap[i] = i;
}
@@ -537,18 +524,18 @@
}
}
-void freeRegLocTemps(CompilationUnit* cUnit, RegLocation rlKeep,
+void FreeRegLocTemps(CompilationUnit* cUnit, RegLocation rlKeep,
RegLocation rlFree)
{
if ((rlFree.lowReg != rlKeep.lowReg) && (rlFree.lowReg != rlKeep.highReg) &&
(rlFree.highReg != rlKeep.lowReg) && (rlFree.highReg != rlKeep.highReg)) {
// No overlap, free both
- oatFreeTemp(cUnit, rlFree.lowReg);
- oatFreeTemp(cUnit, rlFree.highReg);
+ FreeTemp(cUnit, rlFree.lowReg);
+ FreeTemp(cUnit, rlFree.highReg);
}
}
-void spillCoreRegs(CompilationUnit* cUnit) {
+void SpillCoreRegs(CompilationUnit* cUnit) {
if (cUnit->numCoreSpills == 0) {
return;
}
@@ -557,13 +544,13 @@
int offset = cUnit->frameSize - (4 * cUnit->numCoreSpills);
for (int reg = 0; mask; mask >>= 1, reg++) {
if (mask & 0x1) {
- storeWordDisp(cUnit, rX86_SP, offset, reg);
+ StoreWordDisp(cUnit, rX86_SP, offset, reg);
offset += 4;
}
}
}
-void unSpillCoreRegs(CompilationUnit* cUnit) {
+void UnSpillCoreRegs(CompilationUnit* cUnit) {
if (cUnit->numCoreSpills == 0) {
return;
}
@@ -572,19 +559,19 @@
int offset = cUnit->frameSize - (4 * cUnit->numCoreSpills);
for (int reg = 0; mask; mask >>= 1, reg++) {
if (mask & 0x1) {
- loadWordDisp(cUnit, rX86_SP, offset, reg);
+ LoadWordDisp(cUnit, rX86_SP, offset, reg);
offset += 4;
}
}
}
-bool branchUnconditional(LIR* lir)
+bool BranchUnconditional(LIR* lir)
{
return (lir->opcode == kX86Jmp8 || lir->opcode == kX86Jmp32);
}
/* Common initialization routine for an architecture family */
-bool oatArchInit() {
+bool ArchInit() {
int i;
for (i = 0; i < kX86Last; i++) {
@@ -595,27 +582,27 @@
}
}
- return oatArchVariantInit();
+ return ArchVariantInit();
}
// Not used in x86
-int loadHelper(CompilationUnit* cUnit, int offset)
+int LoadHelper(CompilationUnit* cUnit, int offset)
{
- LOG(FATAL) << "Unexpected use of loadHelper in x86";
+ LOG(FATAL) << "Unexpected use of LoadHelper in x86";
return INVALID_REG;
}
-uint64_t getTargetInstFlags(int opcode)
+uint64_t GetTargetInstFlags(int opcode)
{
return EncodingMap[opcode].flags;
}
-const char* getTargetInstName(int opcode)
+const char* GetTargetInstName(int opcode)
{
return EncodingMap[opcode].name;
}
-const char* getTargetInstFmt(int opcode)
+const char* GetTargetInstFmt(int opcode)
{
return EncodingMap[opcode].fmt;
}
diff --git a/src/compiler/codegen/x86/utility_x86.cc b/src/compiler/codegen/x86/utility_x86.cc
index 9d24dda..87a7942 100644
--- a/src/compiler/codegen/x86/utility_x86.cc
+++ b/src/compiler/codegen/x86/utility_x86.cc
@@ -22,15 +22,15 @@
/* This file contains codegen for the X86 ISA */
-void genBarrier(CompilationUnit *cUnit);
-void loadPair(CompilationUnit *cUnit, int base, int lowReg, int highReg);
-LIR *loadWordDisp(CompilationUnit *cUnit, int rBase, int displacement,
+void GenBarrier(CompilationUnit *cUnit);
+void LoadPair(CompilationUnit *cUnit, int base, int lowReg, int highReg);
+LIR *LoadWordDisp(CompilationUnit *cUnit, int rBase, int displacement,
int rDest);
-LIR *storeWordDisp(CompilationUnit *cUnit, int rBase,
+LIR *StoreWordDisp(CompilationUnit *cUnit, int rBase,
int displacement, int rSrc);
-LIR *loadConstant(CompilationUnit *cUnit, int rDest, int value);
+LIR *LoadConstant(CompilationUnit *cUnit, int rDest, int value);
-LIR *fpRegCopy(CompilationUnit *cUnit, int rDest, int rSrc)
+LIR *FpRegCopy(CompilationUnit *cUnit, int rDest, int rSrc)
{
int opcode;
/* must be both DOUBLE or both not DOUBLE */
@@ -50,7 +50,7 @@
}
}
DCHECK_NE((EncodingMap[opcode].flags & IS_BINARY_OP), 0ULL);
- LIR* res = rawLIR(cUnit, cUnit->currentDalvikOffset, opcode, rDest, rSrc);
+ LIR* res = RawLIR(cUnit, cUnit->currentDalvikOffset, opcode, rDest, rSrc);
if (rDest == rSrc) {
res->flags.isNop = true;
}
@@ -63,54 +63,54 @@
* a high register, build constant into a low register and copy.
*
* No additional register clobbering operation performed. Use this version when
- * 1) rDest is freshly returned from oatAllocTemp or
+ * 1) rDest is freshly returned from AllocTemp or
* 2) The codegen is under fixed register usage
*/
-LIR *loadConstantNoClobber(CompilationUnit *cUnit, int rDest, int value)
+LIR *LoadConstantNoClobber(CompilationUnit *cUnit, int rDest, int value)
{
int rDestSave = rDest;
if (X86_FPREG(rDest)) {
if (value == 0) {
- return newLIR2(cUnit, kX86XorpsRR, rDest, rDest);
+ return NewLIR2(cUnit, kX86XorpsRR, rDest, rDest);
}
DCHECK(X86_SINGLEREG(rDest));
- rDest = oatAllocTemp(cUnit);
+ rDest = AllocTemp(cUnit);
}
LIR *res;
if (value == 0) {
- res = newLIR2(cUnit, kX86Xor32RR, rDest, rDest);
+ res = NewLIR2(cUnit, kX86Xor32RR, rDest, rDest);
} else {
// Note, there is no byte immediate form of a 32 bit immediate move.
- res = newLIR2(cUnit, kX86Mov32RI, rDest, value);
+ res = NewLIR2(cUnit, kX86Mov32RI, rDest, value);
}
if (X86_FPREG(rDestSave)) {
- newLIR2(cUnit, kX86MovdxrRR, rDestSave, rDest);
- oatFreeTemp(cUnit, rDest);
+ NewLIR2(cUnit, kX86MovdxrRR, rDestSave, rDest);
+ FreeTemp(cUnit, rDest);
}
return res;
}
-LIR* opBranchUnconditional(CompilationUnit *cUnit, OpKind op)
+LIR* OpBranchUnconditional(CompilationUnit *cUnit, OpKind op)
{
CHECK_EQ(op, kOpUncondBr);
- return newLIR1(cUnit, kX86Jmp8, 0 /* offset to be patched */ );
+ return NewLIR1(cUnit, kX86Jmp8, 0 /* offset to be patched */ );
}
-LIR *loadMultiple(CompilationUnit *cUnit, int rBase, int rMask);
+LIR *LoadMultiple(CompilationUnit *cUnit, int rBase, int rMask);
-X86ConditionCode oatX86ConditionEncoding(ConditionCode cond);
-LIR* opCondBranch(CompilationUnit* cUnit, ConditionCode cc, LIR* target)
+X86ConditionCode X86ConditionEncoding(ConditionCode cond);
+LIR* OpCondBranch(CompilationUnit* cUnit, ConditionCode cc, LIR* target)
{
- LIR* branch = newLIR2(cUnit, kX86Jcc8, 0 /* offset to be patched */,
- oatX86ConditionEncoding(cc));
+ LIR* branch = NewLIR2(cUnit, kX86Jcc8, 0 /* offset to be patched */,
+ X86ConditionEncoding(cc));
branch->target = target;
return branch;
}
-LIR *opReg(CompilationUnit *cUnit, OpKind op, int rDestSrc)
+LIR *OpReg(CompilationUnit *cUnit, OpKind op, int rDestSrc)
{
X86OpCode opcode = kX86Bkpt;
switch (op) {
@@ -118,12 +118,12 @@
case kOpNot: opcode = kX86Not32R; break;
case kOpBlx: opcode = kX86CallR; break;
default:
- LOG(FATAL) << "Bad case in opReg " << op;
+ LOG(FATAL) << "Bad case in OpReg " << op;
}
- return newLIR1(cUnit, opcode, rDestSrc);
+ return NewLIR1(cUnit, opcode, rDestSrc);
}
-LIR *opRegImm(CompilationUnit *cUnit, OpKind op, int rDestSrc1, int value)
+LIR *OpRegImm(CompilationUnit *cUnit, OpKind op, int rDestSrc1, int value)
{
X86OpCode opcode = kX86Bkpt;
bool byteImm = IS_SIMM8(value);
@@ -140,28 +140,28 @@
case kOpSub: opcode = byteImm ? kX86Sub32RI8 : kX86Sub32RI; break;
case kOpXor: opcode = byteImm ? kX86Xor32RI8 : kX86Xor32RI; break;
case kOpCmp: opcode = byteImm ? kX86Cmp32RI8 : kX86Cmp32RI; break;
- case kOpMov: return loadConstantNoClobber(cUnit, rDestSrc1, value);
+ case kOpMov: return LoadConstantNoClobber(cUnit, rDestSrc1, value);
case kOpMul:
opcode = byteImm ? kX86Imul32RRI8 : kX86Imul32RRI;
- return newLIR3(cUnit, opcode, rDestSrc1, rDestSrc1, value);
+ return NewLIR3(cUnit, opcode, rDestSrc1, rDestSrc1, value);
default:
- LOG(FATAL) << "Bad case in opRegImm " << op;
+ LOG(FATAL) << "Bad case in OpRegImm " << op;
}
- return newLIR2(cUnit, opcode, rDestSrc1, value);
+ return NewLIR2(cUnit, opcode, rDestSrc1, value);
}
-LIR *opRegReg(CompilationUnit *cUnit, OpKind op, int rDestSrc1, int rSrc2)
+LIR *OpRegReg(CompilationUnit *cUnit, OpKind op, int rDestSrc1, int rSrc2)
{
X86OpCode opcode = kX86Nop;
bool src2_must_be_cx = false;
switch (op) {
// X86 unary opcodes
case kOpMvn:
- opRegCopy(cUnit, rDestSrc1, rSrc2);
- return opReg(cUnit, kOpNot, rDestSrc1);
+ OpRegCopy(cUnit, rDestSrc1, rSrc2);
+ return OpReg(cUnit, kOpNot, rDestSrc1);
case kOpNeg:
- opRegCopy(cUnit, rDestSrc1, rSrc2);
- return opReg(cUnit, kOpNeg, rDestSrc1);
+ OpRegCopy(cUnit, rDestSrc1, rSrc2);
+ return OpReg(cUnit, kOpNeg, rDestSrc1);
// X86 binary opcodes
case kOpSub: opcode = kX86Sub32RR; break;
case kOpSbc: opcode = kX86Sbb32RR; break;
@@ -178,9 +178,9 @@
case kOp2Byte:
// Use shifts instead of a byte operand if the source can't be byte accessed.
if (rSrc2 >= 4) {
- newLIR2(cUnit, kX86Mov32RR, rDestSrc1, rSrc2);
- newLIR2(cUnit, kX86Sal32RI, rDestSrc1, 24);
- return newLIR2(cUnit, kX86Sar32RI, rDestSrc1, 24);
+ NewLIR2(cUnit, kX86Mov32RR, rDestSrc1, rSrc2);
+ NewLIR2(cUnit, kX86Sal32RI, rDestSrc1, 24);
+ return NewLIR2(cUnit, kX86Sar32RI, rDestSrc1, 24);
} else {
opcode = kX86Movsx8RR;
}
@@ -189,14 +189,14 @@
case kOp2Char: opcode = kX86Movzx16RR; break;
case kOpMul: opcode = kX86Imul32RR; break;
default:
- LOG(FATAL) << "Bad case in opRegReg " << op;
+ LOG(FATAL) << "Bad case in OpRegReg " << op;
break;
}
CHECK(!src2_must_be_cx || rSrc2 == rCX);
- return newLIR2(cUnit, opcode, rDestSrc1, rSrc2);
+ return NewLIR2(cUnit, opcode, rDestSrc1, rSrc2);
}
-LIR* opRegMem(CompilationUnit *cUnit, OpKind op, int rDest, int rBase,
+LIR* OpRegMem(CompilationUnit *cUnit, OpKind op, int rDest, int rBase,
int offset)
{
X86OpCode opcode = kX86Nop;
@@ -214,46 +214,46 @@
case kOp2Char: opcode = kX86Movzx16RM; break;
case kOpMul:
default:
- LOG(FATAL) << "Bad case in opRegMem " << op;
+ LOG(FATAL) << "Bad case in OpRegMem " << op;
break;
}
- return newLIR3(cUnit, opcode, rDest, rBase, offset);
+ return NewLIR3(cUnit, opcode, rDest, rBase, offset);
}
-LIR* opRegRegReg(CompilationUnit *cUnit, OpKind op, int rDest, int rSrc1,
+LIR* OpRegRegReg(CompilationUnit *cUnit, OpKind op, int rDest, int rSrc1,
int rSrc2)
{
if (rDest != rSrc1 && rDest != rSrc2) {
if (op == kOpAdd) { // lea special case, except can't encode rbp as base
if (rSrc1 == rSrc2) {
- opRegCopy(cUnit, rDest, rSrc1);
- return opRegImm(cUnit, kOpLsl, rDest, 1);
+ OpRegCopy(cUnit, rDest, rSrc1);
+ return OpRegImm(cUnit, kOpLsl, rDest, 1);
} else if (rSrc1 != rBP) {
- return newLIR5(cUnit, kX86Lea32RA, rDest, rSrc1 /* base */,
+ return NewLIR5(cUnit, kX86Lea32RA, rDest, rSrc1 /* base */,
rSrc2 /* index */, 0 /* scale */, 0 /* disp */);
} else {
- return newLIR5(cUnit, kX86Lea32RA, rDest, rSrc2 /* base */,
+ return NewLIR5(cUnit, kX86Lea32RA, rDest, rSrc2 /* base */,
rSrc1 /* index */, 0 /* scale */, 0 /* disp */);
}
} else {
- opRegCopy(cUnit, rDest, rSrc1);
- return opRegReg(cUnit, op, rDest, rSrc2);
+ OpRegCopy(cUnit, rDest, rSrc1);
+ return OpRegReg(cUnit, op, rDest, rSrc2);
}
} else if (rDest == rSrc1) {
- return opRegReg(cUnit, op, rDest, rSrc2);
+ return OpRegReg(cUnit, op, rDest, rSrc2);
} else { // rDest == rSrc2
switch (op) {
case kOpSub: // non-commutative
- opReg(cUnit, kOpNeg, rDest);
+ OpReg(cUnit, kOpNeg, rDest);
op = kOpAdd;
break;
case kOpSbc:
case kOpLsl: case kOpLsr: case kOpAsr: case kOpRor: {
- int tReg = oatAllocTemp(cUnit);
- opRegCopy(cUnit, tReg, rSrc1);
- opRegReg(cUnit, op, tReg, rSrc2);
- LIR* res = opRegCopy(cUnit, rDest, tReg);
- oatFreeTemp(cUnit, tReg);
+ int tReg = AllocTemp(cUnit);
+ OpRegCopy(cUnit, tReg, rSrc1);
+ OpRegReg(cUnit, op, tReg, rSrc2);
+ LIR* res = OpRegCopy(cUnit, rDest, tReg);
+ FreeTemp(cUnit, tReg);
return res;
}
case kOpAdd: // commutative
@@ -263,40 +263,40 @@
case kOpXor:
break;
default:
- LOG(FATAL) << "Bad case in opRegRegReg " << op;
+ LOG(FATAL) << "Bad case in OpRegRegReg " << op;
}
- return opRegReg(cUnit, op, rDest, rSrc1);
+ return OpRegReg(cUnit, op, rDest, rSrc1);
}
}
-LIR* opRegRegImm(CompilationUnit *cUnit, OpKind op, int rDest, int rSrc,
+LIR* OpRegRegImm(CompilationUnit *cUnit, OpKind op, int rDest, int rSrc,
int value)
{
if (op == kOpMul) {
X86OpCode opcode = IS_SIMM8(value) ? kX86Imul32RRI8 : kX86Imul32RRI;
- return newLIR3(cUnit, opcode, rDest, rSrc, value);
+ return NewLIR3(cUnit, opcode, rDest, rSrc, value);
} else if (op == kOpAnd) {
if (value == 0xFF && rSrc < 4) {
- return newLIR2(cUnit, kX86Movzx8RR, rDest, rSrc);
+ return NewLIR2(cUnit, kX86Movzx8RR, rDest, rSrc);
} else if (value == 0xFFFF) {
- return newLIR2(cUnit, kX86Movzx16RR, rDest, rSrc);
+ return NewLIR2(cUnit, kX86Movzx16RR, rDest, rSrc);
}
}
if (rDest != rSrc) {
if (false && op == kOpLsl && value >= 0 && value <= 3) { // lea shift special case
// TODO: fix bug in LEA encoding when disp == 0
- return newLIR5(cUnit, kX86Lea32RA, rDest, r5sib_no_base /* base */,
+ return NewLIR5(cUnit, kX86Lea32RA, rDest, r5sib_no_base /* base */,
rSrc /* index */, value /* scale */, 0 /* disp */);
} else if (op == kOpAdd) { // lea add special case
- return newLIR5(cUnit, kX86Lea32RA, rDest, rSrc /* base */,
+ return NewLIR5(cUnit, kX86Lea32RA, rDest, rSrc /* base */,
r4sib_no_index /* index */, 0 /* scale */, value /* disp */);
}
- opRegCopy(cUnit, rDest, rSrc);
+ OpRegCopy(cUnit, rDest, rSrc);
}
- return opRegImm(cUnit, op, rDest, value);
+ return OpRegImm(cUnit, op, rDest, value);
}
-LIR* opThreadMem(CompilationUnit* cUnit, OpKind op, int threadOffset)
+LIR* OpThreadMem(CompilationUnit* cUnit, OpKind op, int threadOffset)
{
X86OpCode opcode = kX86Bkpt;
switch (op) {
@@ -305,10 +305,10 @@
LOG(FATAL) << "Bad opcode: " << op;
break;
}
- return newLIR1(cUnit, opcode, threadOffset);
+ return NewLIR1(cUnit, opcode, threadOffset);
}
-LIR* opMem(CompilationUnit* cUnit, OpKind op, int rBase, int disp)
+LIR* OpMem(CompilationUnit* cUnit, OpKind op, int rBase, int disp)
{
X86OpCode opcode = kX86Bkpt;
switch (op) {
@@ -317,51 +317,51 @@
LOG(FATAL) << "Bad opcode: " << op;
break;
}
- return newLIR2(cUnit, opcode, rBase, disp);
+ return NewLIR2(cUnit, opcode, rBase, disp);
}
-LIR *loadConstantValueWide(CompilationUnit *cUnit, int rDestLo,
+LIR *LoadConstantValueWide(CompilationUnit *cUnit, int rDestLo,
int rDestHi, int valLo, int valHi)
{
LIR *res;
if (X86_FPREG(rDestLo)) {
DCHECK(X86_FPREG(rDestHi)); // ignore rDestHi
if (valLo == 0 && valHi == 0) {
- return newLIR2(cUnit, kX86XorpsRR, rDestLo, rDestLo);
+ return NewLIR2(cUnit, kX86XorpsRR, rDestLo, rDestLo);
} else {
if (valLo == 0) {
- res = newLIR2(cUnit, kX86XorpsRR, rDestLo, rDestLo);
+ res = NewLIR2(cUnit, kX86XorpsRR, rDestLo, rDestLo);
} else {
- res = loadConstantNoClobber(cUnit, rDestLo, valLo);
+ res = LoadConstantNoClobber(cUnit, rDestLo, valLo);
}
if (valHi != 0) {
- loadConstantNoClobber(cUnit, rDestHi, valHi);
- newLIR2(cUnit, kX86PsllqRI, rDestHi, 32);
- newLIR2(cUnit, kX86OrpsRR, rDestLo, rDestHi);
+ LoadConstantNoClobber(cUnit, rDestHi, valHi);
+ NewLIR2(cUnit, kX86PsllqRI, rDestHi, 32);
+ NewLIR2(cUnit, kX86OrpsRR, rDestLo, rDestHi);
}
}
} else {
- res = loadConstantNoClobber(cUnit, rDestLo, valLo);
- loadConstantNoClobber(cUnit, rDestHi, valHi);
+ res = LoadConstantNoClobber(cUnit, rDestLo, valLo);
+ LoadConstantNoClobber(cUnit, rDestHi, valHi);
}
return res;
}
-LIR *loadMultiple(CompilationUnit *cUnit, int rBase, int rMask)
+LIR *LoadMultiple(CompilationUnit *cUnit, int rBase, int rMask)
{
- UNIMPLEMENTED(FATAL) << "loadMultiple";
- newLIR0(cUnit, kX86Bkpt);
+ UNIMPLEMENTED(FATAL) << "LoadMultiple";
+ NewLIR0(cUnit, kX86Bkpt);
return NULL;
}
-LIR *storeMultiple(CompilationUnit *cUnit, int rBase, int rMask)
+LIR *StoreMultiple(CompilationUnit *cUnit, int rBase, int rMask)
{
- UNIMPLEMENTED(FATAL) << "storeMultiple";
- newLIR0(cUnit, kX86Bkpt);
+ UNIMPLEMENTED(FATAL) << "StoreMultiple";
+ NewLIR0(cUnit, kX86Bkpt);
return NULL;
}
-LIR* loadBaseIndexedDisp(CompilationUnit *cUnit,
+LIR* LoadBaseIndexedDisp(CompilationUnit *cUnit,
int rBase, int rIndex, int scale, int displacement,
int rDest, int rDestHi,
OpSize size, int sReg) {
@@ -380,7 +380,7 @@
if (X86_SINGLEREG(rDest)) {
DCHECK(X86_FPREG(rDestHi));
DCHECK_EQ(rDest, (rDestHi - 1));
- rDest = s2d(rDest, rDestHi);
+ rDest = S2d(rDest, rDestHi);
}
rDestHi = rDest + 1;
} else {
@@ -414,45 +414,45 @@
opcode = isArray ? kX86Movsx8RA : kX86Movsx8RM;
break;
default:
- LOG(FATAL) << "Bad case in loadBaseIndexedDispBody";
+ LOG(FATAL) << "Bad case in LoadBaseIndexedDispBody";
}
if (!isArray) {
if (!pair) {
- load = newLIR3(cUnit, opcode, rDest, rBase, displacement + LOWORD_OFFSET);
+ load = NewLIR3(cUnit, opcode, rDest, rBase, displacement + LOWORD_OFFSET);
} else {
if (rBase == rDest) {
- load2 = newLIR3(cUnit, opcode, rDestHi, rBase,
+ load2 = NewLIR3(cUnit, opcode, rDestHi, rBase,
displacement + HIWORD_OFFSET);
- load = newLIR3(cUnit, opcode, rDest, rBase, displacement + LOWORD_OFFSET);
+ load = NewLIR3(cUnit, opcode, rDest, rBase, displacement + LOWORD_OFFSET);
} else {
- load = newLIR3(cUnit, opcode, rDest, rBase, displacement + LOWORD_OFFSET);
- load2 = newLIR3(cUnit, opcode, rDestHi, rBase,
+ load = NewLIR3(cUnit, opcode, rDest, rBase, displacement + LOWORD_OFFSET);
+ load2 = NewLIR3(cUnit, opcode, rDestHi, rBase,
displacement + HIWORD_OFFSET);
}
}
if (rBase == rX86_SP) {
- annotateDalvikRegAccess(load, (displacement + (pair ? LOWORD_OFFSET : 0))
+ AnnotateDalvikRegAccess(load, (displacement + (pair ? LOWORD_OFFSET : 0))
>> 2, true /* isLoad */, is64bit);
if (pair) {
- annotateDalvikRegAccess(load2, (displacement + HIWORD_OFFSET) >> 2,
+ AnnotateDalvikRegAccess(load2, (displacement + HIWORD_OFFSET) >> 2,
true /* isLoad */, is64bit);
}
}
} else {
if (!pair) {
- load = newLIR5(cUnit, opcode, rDest, rBase, rIndex, scale,
+ load = NewLIR5(cUnit, opcode, rDest, rBase, rIndex, scale,
displacement + LOWORD_OFFSET);
} else {
if (rBase == rDest) {
- load2 = newLIR5(cUnit, opcode, rDestHi, rBase, rIndex, scale,
+ load2 = NewLIR5(cUnit, opcode, rDestHi, rBase, rIndex, scale,
displacement + HIWORD_OFFSET);
- load = newLIR5(cUnit, opcode, rDest, rBase, rIndex, scale,
+ load = NewLIR5(cUnit, opcode, rDest, rBase, rIndex, scale,
displacement + LOWORD_OFFSET);
} else {
- load = newLIR5(cUnit, opcode, rDest, rBase, rIndex, scale,
+ load = NewLIR5(cUnit, opcode, rDest, rBase, rIndex, scale,
displacement + LOWORD_OFFSET);
- load2 = newLIR5(cUnit, opcode, rDestHi, rBase, rIndex, scale,
+ load2 = NewLIR5(cUnit, opcode, rDestHi, rBase, rIndex, scale,
displacement + HIWORD_OFFSET);
}
}
@@ -462,29 +462,29 @@
}
/* Load value from base + scaled index. */
-LIR *loadBaseIndexed(CompilationUnit *cUnit, int rBase,
+LIR *LoadBaseIndexed(CompilationUnit *cUnit, int rBase,
int rIndex, int rDest, int scale, OpSize size) {
- return loadBaseIndexedDisp(cUnit, rBase, rIndex, scale, 0,
+ return LoadBaseIndexedDisp(cUnit, rBase, rIndex, scale, 0,
rDest, INVALID_REG, size, INVALID_SREG);
}
-LIR *loadBaseDisp(CompilationUnit *cUnit,
+LIR *LoadBaseDisp(CompilationUnit *cUnit,
int rBase, int displacement,
int rDest,
OpSize size, int sReg) {
- return loadBaseIndexedDisp(cUnit, rBase, INVALID_REG, 0, displacement,
+ return LoadBaseIndexedDisp(cUnit, rBase, INVALID_REG, 0, displacement,
rDest, INVALID_REG, size, sReg);
}
-LIR *loadBaseDispWide(CompilationUnit *cUnit,
+LIR *LoadBaseDispWide(CompilationUnit *cUnit,
int rBase, int displacement,
int rDestLo, int rDestHi,
int sReg) {
- return loadBaseIndexedDisp(cUnit, rBase, INVALID_REG, 0, displacement,
+ return LoadBaseIndexedDisp(cUnit, rBase, INVALID_REG, 0, displacement,
rDestLo, rDestHi, kLong, sReg);
}
-LIR* storeBaseIndexedDisp(CompilationUnit *cUnit,
+LIR* StoreBaseIndexedDisp(CompilationUnit *cUnit,
int rBase, int rIndex, int scale, int displacement,
int rSrc, int rSrcHi,
OpSize size, int sReg) {
@@ -503,7 +503,7 @@
if (X86_SINGLEREG(rSrc)) {
DCHECK(X86_FPREG(rSrcHi));
DCHECK_EQ(rSrc, (rSrcHi - 1));
- rSrc = s2d(rSrc, rSrcHi);
+ rSrc = S2d(rSrc, rSrcHi);
}
rSrcHi = rSrc + 1;
} else {
@@ -532,32 +532,32 @@
opcode = isArray ? kX86Mov8AR : kX86Mov8MR;
break;
default:
- LOG(FATAL) << "Bad case in loadBaseIndexedDispBody";
+ LOG(FATAL) << "Bad case in LoadBaseIndexedDispBody";
}
if (!isArray) {
if (!pair) {
- store = newLIR3(cUnit, opcode, rBase, displacement + LOWORD_OFFSET, rSrc);
+ store = NewLIR3(cUnit, opcode, rBase, displacement + LOWORD_OFFSET, rSrc);
} else {
- store = newLIR3(cUnit, opcode, rBase, displacement + LOWORD_OFFSET, rSrc);
- store2 = newLIR3(cUnit, opcode, rBase, displacement + HIWORD_OFFSET, rSrcHi);
+ store = NewLIR3(cUnit, opcode, rBase, displacement + LOWORD_OFFSET, rSrc);
+ store2 = NewLIR3(cUnit, opcode, rBase, displacement + HIWORD_OFFSET, rSrcHi);
}
if (rBase == rX86_SP) {
- annotateDalvikRegAccess(store, (displacement + (pair ? LOWORD_OFFSET : 0))
+ AnnotateDalvikRegAccess(store, (displacement + (pair ? LOWORD_OFFSET : 0))
>> 2, false /* isLoad */, is64bit);
if (pair) {
- annotateDalvikRegAccess(store2, (displacement + HIWORD_OFFSET) >> 2,
+ AnnotateDalvikRegAccess(store2, (displacement + HIWORD_OFFSET) >> 2,
false /* isLoad */, is64bit);
}
}
} else {
if (!pair) {
- store = newLIR5(cUnit, opcode, rBase, rIndex, scale,
+ store = NewLIR5(cUnit, opcode, rBase, rIndex, scale,
displacement + LOWORD_OFFSET, rSrc);
} else {
- store = newLIR5(cUnit, opcode, rBase, rIndex, scale,
+ store = NewLIR5(cUnit, opcode, rBase, rIndex, scale,
displacement + LOWORD_OFFSET, rSrc);
- store2 = newLIR5(cUnit, opcode, rBase, rIndex, scale,
+ store2 = NewLIR5(cUnit, opcode, rBase, rIndex, scale,
displacement + HIWORD_OFFSET, rSrcHi);
}
}
@@ -566,31 +566,31 @@
}
/* store value base base + scaled index. */
-LIR *storeBaseIndexed(CompilationUnit *cUnit, int rBase, int rIndex, int rSrc,
+LIR *StoreBaseIndexed(CompilationUnit *cUnit, int rBase, int rIndex, int rSrc,
int scale, OpSize size)
{
- return storeBaseIndexedDisp(cUnit, rBase, rIndex, scale, 0,
+ return StoreBaseIndexedDisp(cUnit, rBase, rIndex, scale, 0,
rSrc, INVALID_REG, size, INVALID_SREG);
}
-LIR *storeBaseDisp(CompilationUnit *cUnit, int rBase, int displacement,
+LIR *StoreBaseDisp(CompilationUnit *cUnit, int rBase, int displacement,
int rSrc, OpSize size)
{
- return storeBaseIndexedDisp(cUnit, rBase, INVALID_REG, 0,
+ return StoreBaseIndexedDisp(cUnit, rBase, INVALID_REG, 0,
displacement, rSrc, INVALID_REG, size,
INVALID_SREG);
}
-LIR *storeBaseDispWide(CompilationUnit *cUnit, int rBase, int displacement,
+LIR *StoreBaseDispWide(CompilationUnit *cUnit, int rBase, int displacement,
int rSrcLo, int rSrcHi)
{
- return storeBaseIndexedDisp(cUnit, rBase, INVALID_REG, 0, displacement,
+ return StoreBaseIndexedDisp(cUnit, rBase, INVALID_REG, 0, displacement,
rSrcLo, rSrcHi, kLong, INVALID_SREG);
}
-void loadPair(CompilationUnit *cUnit, int base, int lowReg, int highReg)
+void LoadPair(CompilationUnit *cUnit, int base, int lowReg, int highReg)
{
- loadBaseDispWide(cUnit, base, 0, lowReg, highReg, INVALID_SREG);
+ LoadBaseDispWide(cUnit, base, 0, lowReg, highReg, INVALID_SREG);
}
} // namespace art
diff --git a/src/compiler/compiler_ir.h b/src/compiler/compiler_ir.h
index df0bd77..4fa019f 100644
--- a/src/compiler/compiler_ir.h
+++ b/src/compiler/compiler_ir.h
@@ -47,7 +47,7 @@
RegLocationType coreLocation:3;
uint8_t coreReg;
RegLocationType fpLocation:3;
- uint8_t fpReg;
+ uint8_t FpReg;
bool firstInPair;
};
@@ -491,7 +491,7 @@
const uint16_t* insns;
uint32_t insnsSize;
bool disableDataflow; // Skip dataflow analysis if possible
- SafeMap<unsigned int, BasicBlock*> blockMap; // findBlock lookup cache
+ SafeMap<unsigned int, BasicBlock*> blockMap; // FindBlock lookup cache
SafeMap<unsigned int, unsigned int> blockIdMap; // Block collapse lookup cache
SafeMap<unsigned int, LIR*> boundaryMap; // boundary lookup cache
int defCount; // Used to estimate number of SSA names
@@ -583,23 +583,23 @@
{{Instruction::RETURN_WIDE}, kIdentity},
};
-BasicBlock* oatNewBB(CompilationUnit* cUnit, BBType blockType, int blockId);
+BasicBlock* NewMemBB(CompilationUnit* cUnit, BBType blockType, int blockId);
-void oatAppendMIR(BasicBlock* bb, MIR* mir);
+void AppendMIR(BasicBlock* bb, MIR* mir);
-void oatPrependMIR(BasicBlock* bb, MIR* mir);
+void PrependMIR(BasicBlock* bb, MIR* mir);
-void oatInsertMIRAfter(BasicBlock* bb, MIR* currentMIR, MIR* newMIR);
+void InsertMIRAfter(BasicBlock* bb, MIR* currentMIR, MIR* newMIR);
-void oatAppendLIR(CompilationUnit* cUnit, LIR* lir);
+void AppendLIR(CompilationUnit* cUnit, LIR* lir);
-void oatInsertLIRBefore(LIR* currentLIR, LIR* newLIR);
+void InsertLIRBefore(LIR* currentLIR, LIR* newLIR);
-void oatInsertLIRAfter(LIR* currentLIR, LIR* newLIR);
+void InsertLIRAfter(LIR* currentLIR, LIR* newLIR);
-MIR* oatFindMoveResult(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir);
+MIR* FindMoveResult(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir);
/* Debug Utilities */
-void oatDumpCompilationUnit(CompilationUnit* cUnit);
+void DumpCompilationUnit(CompilationUnit* cUnit);
} // namespace art
diff --git a/src/compiler/compiler_utility.cc b/src/compiler/compiler_utility.cc
index a0ab292..47dfb50 100644
--- a/src/compiler/compiler_utility.cc
+++ b/src/compiler/compiler_utility.cc
@@ -99,7 +99,7 @@
#define kArenaBitVectorGrowth 4 /* increase by 4 uint32_ts when limit hit */
/* Allocate the initial memory block for arena-based allocation */
-bool oatHeapInit(CompilationUnit* cUnit)
+bool HeapInit(CompilationUnit* cUnit)
{
DCHECK(cUnit->arenaHead == NULL);
cUnit->arenaHead =
@@ -113,14 +113,14 @@
cUnit->currentArena->next = NULL;
cUnit->numArenaBlocks = 1;
#ifdef WITH_MEMSTATS
- cUnit->mstats = (Memstats*) oatNew(cUnit, sizeof(Memstats), true,
+ cUnit->mstats = (Memstats*) NewMem(cUnit, sizeof(Memstats), true,
kAllocDebugInfo);
#endif
return true;
}
/* Arena-based malloc for compilation tasks */
-void* oatNew(CompilationUnit* cUnit, size_t size, bool zero, oatAllocKind kind)
+void* NewMem(CompilationUnit* cUnit, size_t size, bool zero, oatAllocKind kind)
{
size = (size + 3) & ~3;
#ifdef WITH_MEMSTATS
@@ -171,7 +171,7 @@
}
/* Reclaim all the arena blocks allocated so far */
-void oatArenaReset(CompilationUnit* cUnit)
+void ArenaReset(CompilationUnit* cUnit)
{
ArenaMemBlock* head = cUnit->arenaHead;
while (head != NULL) {
@@ -184,12 +184,12 @@
}
/* Growable List initialization */
-void oatInitGrowableList(CompilationUnit* cUnit, GrowableList* gList,
+void CompilerInitGrowableList(CompilationUnit* cUnit, GrowableList* gList,
size_t initLength, oatListKind kind)
{
gList->numAllocated = initLength;
gList->numUsed = 0;
- gList->elemList = static_cast<uintptr_t *>(oatNew(cUnit, sizeof(intptr_t) * initLength,
+ gList->elemList = static_cast<uintptr_t *>(NewMem(cUnit, sizeof(intptr_t) * initLength,
true, kAllocGrowableList));
#ifdef WITH_MEMSTATS
cUnit->mstats->listSizes[kind] += sizeof(uintptr_t) * initLength;
@@ -201,7 +201,7 @@
}
/* Expand the capacity of a growable list */
-void expandGrowableList(CompilationUnit* cUnit, GrowableList* gList)
+static void ExpandGrowableList(CompilationUnit* cUnit, GrowableList* gList)
{
int newLength = gList->numAllocated;
if (newLength < 128) {
@@ -210,7 +210,7 @@
newLength += 128;
}
uintptr_t *newArray =
- static_cast<uintptr_t*>(oatNew(cUnit, sizeof(uintptr_t) * newLength, true,
+ static_cast<uintptr_t*>(NewMem(cUnit, sizeof(uintptr_t) * newLength, true,
kAllocGrowableList));
memcpy(newArray, gList->elemList, sizeof(uintptr_t) * gList->numAllocated);
#ifdef WITH_MEMSTATS
@@ -227,18 +227,18 @@
}
/* Insert a new element into the growable list */
-void oatInsertGrowableList(CompilationUnit* cUnit, GrowableList* gList,
+void InsertGrowableList(CompilationUnit* cUnit, GrowableList* gList,
uintptr_t elem)
{
DCHECK_NE(gList->numAllocated, 0U);
if (gList->numUsed == gList->numAllocated) {
- expandGrowableList(cUnit, gList);
+ ExpandGrowableList(cUnit, gList);
}
gList->elemList[gList->numUsed++] = elem;
}
/* Delete an element from a growable list. Element must be present */
-void oatDeleteGrowableList(GrowableList* gList, uintptr_t elem)
+void DeleteGrowableList(GrowableList* gList, uintptr_t elem)
{
bool found = false;
for (unsigned int i = 0; i < gList->numUsed; i++) {
@@ -253,7 +253,7 @@
gList->numUsed--;
}
-void oatGrowableListIteratorInit(GrowableList* gList,
+void GrowableListIteratorInit(GrowableList* gList,
GrowableListIterator* iterator)
{
iterator->list = gList;
@@ -261,14 +261,14 @@
iterator->size = gList->numUsed;
}
-uintptr_t oatGrowableListIteratorNext(GrowableListIterator* iterator)
+uintptr_t GrowableListIteratorNext(GrowableListIterator* iterator)
{
DCHECK_EQ(iterator->size, iterator->list->numUsed);
if (iterator->idx == iterator->size) return 0;
return iterator->list->elemList[iterator->idx++];
}
-uintptr_t oatGrowableListGetElement(const GrowableList* gList, size_t idx)
+uintptr_t GrowableListGetElement(const GrowableList* gList, size_t idx)
{
DCHECK_LT(idx, gList->numUsed);
return gList->elemList[idx];
@@ -276,7 +276,7 @@
#ifdef WITH_MEMSTATS
/* Dump memory usage stats */
-void oatDumpMemStats(CompilationUnit* cUnit)
+void DumpMemStats(CompilationUnit* cUnit)
{
uint32_t total = 0;
for (int i = 0; i < kNumAllocKinds; i++) {
@@ -314,7 +314,7 @@
#endif
/* Debug Utility - dump a compilation unit */
-void oatDumpCompilationUnit(CompilationUnit* cUnit)
+void DumpCompilationUnit(CompilationUnit* cUnit)
{
BasicBlock* bb;
const char* blockTypeNames[] = {
@@ -330,10 +330,10 @@
LOG(INFO) << cUnit->numBlocks << " blocks in total";
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&cUnit->blockList, &iterator);
+ GrowableListIteratorInit(&cUnit->blockList, &iterator);
while (true) {
- bb = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iterator));
+ bb = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iterator));
if (bb == NULL) break;
LOG(INFO) << StringPrintf("Block %d (%s) (insn %04x - %04x%s)",
bb->id,
@@ -367,7 +367,7 @@
*
* NOTE: memory is allocated from the compiler arena.
*/
-ArenaBitVector* oatAllocBitVector(CompilationUnit* cUnit,
+ArenaBitVector* AllocBitVector(CompilationUnit* cUnit,
unsigned int startBits, bool expandable,
oatBitMapKind kind)
{
@@ -376,14 +376,14 @@
DCHECK_EQ(sizeof(bv->storage[0]), 4U); /* assuming 32-bit units */
- bv = static_cast<ArenaBitVector*>(oatNew(cUnit, sizeof(ArenaBitVector), false,
+ bv = static_cast<ArenaBitVector*>(NewMem(cUnit, sizeof(ArenaBitVector), false,
kAllocGrowableBitMap));
count = (startBits + 31) >> 5;
bv->storageSize = count;
bv->expandable = expandable;
- bv->storage = static_cast<uint32_t*>(oatNew(cUnit, count * sizeof(uint32_t), true,
+ bv->storage = static_cast<uint32_t*>(NewMem(cUnit, count * sizeof(uint32_t), true,
kAllocGrowableBitMap));
#ifdef WITH_MEMSTATS
bv->kind = kind;
@@ -395,7 +395,7 @@
/*
* Determine whether or not the specified bit is set.
*/
-bool oatIsBitSet(const ArenaBitVector* pBits, unsigned int num)
+bool IsBitSet(const ArenaBitVector* pBits, unsigned int num)
{
DCHECK_LT(num, pBits->storageSize * sizeof(uint32_t) * 8);
@@ -406,7 +406,7 @@
/*
* Mark all bits bit as "clear".
*/
-void oatClearAllBits(ArenaBitVector* pBits)
+void ClearAllBits(ArenaBitVector* pBits)
{
unsigned int count = pBits->storageSize;
memset(pBits->storage, 0, count * sizeof(uint32_t));
@@ -420,7 +420,7 @@
*
* NOTE: memory is allocated from the compiler arena.
*/
-bool oatSetBit(CompilationUnit* cUnit, ArenaBitVector* pBits, unsigned int num)
+bool SetBit(CompilationUnit* cUnit, ArenaBitVector* pBits, unsigned int num)
{
if (num >= pBits->storageSize * sizeof(uint32_t) * 8) {
if (!pBits->expandable) {
@@ -430,7 +430,7 @@
/* Round up to word boundaries for "num+1" bits */
unsigned int newSize = (num + 1 + 31) >> 5;
DCHECK_GT(newSize, pBits->storageSize);
- uint32_t *newStorage = static_cast<uint32_t*>(oatNew(cUnit, newSize * sizeof(uint32_t), false,
+ uint32_t *newStorage = static_cast<uint32_t*>(NewMem(cUnit, newSize * sizeof(uint32_t), false,
kAllocGrowableBitMap));
memcpy(newStorage, pBits->storage, pBits->storageSize * sizeof(uint32_t));
memset(&newStorage[pBits->storageSize], 0,
@@ -457,7 +457,7 @@
*
* NOTE: memory is allocated from the compiler arena.
*/
-bool oatClearBit(ArenaBitVector* pBits, unsigned int num)
+bool ClearBit(ArenaBitVector* pBits, unsigned int num)
{
if (num >= pBits->storageSize * sizeof(uint32_t) * 8) {
LOG(FATAL) << "Attempt to clear a bit not set in the vector yet";;
@@ -467,49 +467,8 @@
return true;
}
-/*
- * If set is true, mark all bits as 1. Otherwise mark all bits as 0.
- */
-void oatMarkAllBits(ArenaBitVector* pBits, bool set)
-{
- int value = set ? -1 : 0;
- memset(pBits->storage, value, pBits->storageSize * static_cast<int>(sizeof(uint32_t)));
-}
-
-void oatDebugBitVector(char* msg, const ArenaBitVector* bv, int length)
-{
- int i;
-
- LOG(INFO) << msg;
- for (i = 0; i < length; i++) {
- if (oatIsBitSet(bv, i)) {
- LOG(INFO) << " Bit " << i << " is set";
- }
- }
-}
-
-void oatAbort(CompilationUnit* cUnit)
-{
- LOG(FATAL) << "Compiler aborting";
-}
-
-void oatDumpBlockBitVector(const GrowableList* blocks, char* msg,
- const ArenaBitVector* bv, int length)
-{
- int i;
-
- LOG(INFO) << msg;
- for (i = 0; i < length; i++) {
- if (oatIsBitSet(bv, i)) {
- BasicBlock *bb = reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blocks, i));
- char blockName[BLOCK_NAME_LEN];
- oatGetBlockName(bb, blockName);
- LOG(INFO) << "Bit " << i << " / " << blockName << " is set";
- }
- }
-}
/* Initialize the iterator structure */
-void oatBitVectorIteratorInit(ArenaBitVector* pBits,
+void BitVectorIteratorInit(ArenaBitVector* pBits,
ArenaBitVectorIterator* iterator)
{
iterator->pBits = pBits;
@@ -520,7 +479,7 @@
/*
* If the vector sizes don't match, log an error and abort.
*/
-void checkSizes(const ArenaBitVector* bv1, const ArenaBitVector* bv2)
+static void CheckSizes(const ArenaBitVector* bv1, const ArenaBitVector* bv2)
{
if (bv1->storageSize != bv2->storageSize) {
LOG(FATAL) << "Mismatched vector sizes (" << bv1->storageSize
@@ -532,10 +491,10 @@
* Copy a whole vector to the other. Only do that when the both vectors have
* the same size.
*/
-void oatCopyBitVector(ArenaBitVector* dest, const ArenaBitVector* src)
+void CopyBitVector(ArenaBitVector* dest, const ArenaBitVector* src)
{
/* if dest is expandable and < src, we could expand dest to match */
- checkSizes(dest, src);
+ CheckSizes(dest, src);
memcpy(dest->storage, src->storage, sizeof(uint32_t) * dest->storageSize);
}
@@ -544,7 +503,7 @@
* Intersect two bit vectors and store the result to the dest vector.
*/
-bool oatIntersectBitVectors(ArenaBitVector* dest, const ArenaBitVector* src1,
+bool IntersectBitVectors(ArenaBitVector* dest, const ArenaBitVector* src1,
const ArenaBitVector* src2)
{
DCHECK(src1 != NULL);
@@ -565,7 +524,7 @@
/*
* Unify two bit vectors and store the result to the dest vector.
*/
-bool oatUnifyBitVectors(ArenaBitVector* dest, const ArenaBitVector* src1,
+bool UnifyBitVetors(ArenaBitVector* dest, const ArenaBitVector* src1,
const ArenaBitVector* src2)
{
DCHECK(src1 != NULL);
@@ -586,7 +545,7 @@
/*
* Return true if any bits collide. Vectors must be same size.
*/
-bool oatTestBitVectors(const ArenaBitVector* src1,
+bool TestBitVectors(const ArenaBitVector* src1,
const ArenaBitVector* src2)
{
DCHECK_EQ(src1->storageSize, src2->storageSize);
@@ -599,7 +558,7 @@
/*
* Compare two bit vectors and return true if difference is seen.
*/
-bool oatCompareBitVectors(const ArenaBitVector* src1,
+bool CompareBitVectors(const ArenaBitVector* src1,
const ArenaBitVector* src2)
{
if (src1->storageSize != src2->storageSize ||
@@ -616,7 +575,7 @@
/*
* Count the number of bits that are set.
*/
-int oatCountSetBits(const ArenaBitVector* pBits)
+int CountSetBits(const ArenaBitVector* pBits)
{
unsigned int word;
unsigned int count = 0;
@@ -641,7 +600,7 @@
}
/* Return the next position set to 1. -1 means end-of-element reached */
-int oatBitVectorIteratorNext(ArenaBitVectorIterator* iterator)
+int BitVectorIteratorNext(ArenaBitVectorIterator* iterator)
{
ArenaBitVector* pBits = iterator->pBits;
uint32_t bitIndex = iterator->idx;
@@ -684,7 +643,7 @@
* since there might be unused bits - setting those to one will confuse the
* iterator.
*/
-void oatSetInitialBits(ArenaBitVector* pBits, unsigned int numBits)
+void SetInitialBits(ArenaBitVector* pBits, unsigned int numBits)
{
unsigned int idx;
DCHECK_LE(((numBits + 31) >> 5), pBits->storageSize);
@@ -697,7 +656,7 @@
}
}
-void oatGetBlockName(BasicBlock* bb, char* name)
+void GetBlockName(BasicBlock* bb, char* name)
{
switch (bb->blockType) {
case kEntryBlock:
@@ -719,7 +678,7 @@
}
}
-const char* oatGetShortyFromTargetIdx(CompilationUnit *cUnit, int targetIdx)
+const char* GetShortyFromTargetIdx(CompilationUnit *cUnit, int targetIdx)
{
const DexFile::MethodId& methodId = cUnit->dex_file->GetMethodId(targetIdx);
return cUnit->dex_file->GetShorty(methodId.proto_idx_);
diff --git a/src/compiler/compiler_utility.h b/src/compiler/compiler_utility.h
index ab91549..f498d35 100644
--- a/src/compiler/compiler_utility.h
+++ b/src/compiler/compiler_utility.h
@@ -84,7 +84,7 @@
};
/* Allocate the initial memory block for arena-based allocation */
-bool oatHeapInit(CompilationUnit* cUnit);
+bool HeapInit(CompilationUnit* cUnit);
/* Collect memory usage statistics */
//#define WITH_MEMSTATS
@@ -96,9 +96,9 @@
char ptr[0];
};
-void* oatNew(CompilationUnit* cUnit, size_t size, bool zero, oatAllocKind kind);
+void* NewMem(CompilationUnit* cUnit, size_t size, bool zero, oatAllocKind kind);
-void oatArenaReset(CompilationUnit *cUnit);
+void ArenaReset(CompilationUnit *cUnit);
struct GrowableList {
GrowableList() : numAllocated(0), numUsed(0), elemList(NULL) {
@@ -150,48 +150,46 @@
struct LIR;
struct RegLocation;
-void oatInitGrowableList(CompilationUnit* cUnit,GrowableList* gList,
+void CompilerInitGrowableList(CompilationUnit* cUnit,GrowableList* gList,
size_t initLength, oatListKind kind = kListMisc);
-void oatInsertGrowableList(CompilationUnit* cUnit, GrowableList* gList,
+void InsertGrowableList(CompilationUnit* cUnit, GrowableList* gList,
uintptr_t elem);
-void oatDeleteGrowableList(GrowableList* gList, uintptr_t elem);
-void oatGrowableListIteratorInit(GrowableList* gList,
+void DeleteGrowableList(GrowableList* gList, uintptr_t elem);
+void GrowableListIteratorInit(GrowableList* gList,
GrowableListIterator* iterator);
-uintptr_t oatGrowableListIteratorNext(GrowableListIterator* iterator);
-uintptr_t oatGrowableListGetElement(const GrowableList* gList, size_t idx);
+uintptr_t GrowableListIteratorNext(GrowableListIterator* iterator);
+uintptr_t GrowableListGetElement(const GrowableList* gList, size_t idx);
-ArenaBitVector* oatAllocBitVector(CompilationUnit* cUnit,
+ArenaBitVector* AllocBitVector(CompilationUnit* cUnit,
unsigned int startBits, bool expandable,
oatBitMapKind = kBitMapMisc);
-void oatBitVectorIteratorInit(ArenaBitVector* pBits,
+void BitVectorIteratorInit(ArenaBitVector* pBits,
ArenaBitVectorIterator* iterator);
-int oatBitVectorIteratorNext(ArenaBitVectorIterator* iterator);
-bool oatSetBit(CompilationUnit *cUnit, ArenaBitVector* pBits, unsigned int num);
-bool oatClearBit(ArenaBitVector* pBits, unsigned int num);
-void oatMarkAllBits(ArenaBitVector* pBits, bool set);
-void oatDebugBitVector(char* msg, const ArenaBitVector* bv, int length);
-bool oatIsBitSet(const ArenaBitVector* pBits, unsigned int num);
-void oatClearAllBits(ArenaBitVector* pBits);
-void oatSetInitialBits(ArenaBitVector* pBits, unsigned int numBits);
-void oatCopyBitVector(ArenaBitVector* dest, const ArenaBitVector* src);
-bool oatIntersectBitVectors(ArenaBitVector* dest, const ArenaBitVector* src1,
+int BitVectorIteratorNext(ArenaBitVectorIterator* iterator);
+bool SetBit(CompilationUnit *cUnit, ArenaBitVector* pBits, unsigned int num);
+bool ClearBit(ArenaBitVector* pBits, unsigned int num);
+void MarkAllBits(ArenaBitVector* pBits, bool set);
+void DebugBitVector(char* msg, const ArenaBitVector* bv, int length);
+bool IsBitSet(const ArenaBitVector* pBits, unsigned int num);
+void ClearAllBits(ArenaBitVector* pBits);
+void SetInitialBits(ArenaBitVector* pBits, unsigned int numBits);
+void CopyBitVector(ArenaBitVector* dest, const ArenaBitVector* src);
+bool IntersectBitVectors(ArenaBitVector* dest, const ArenaBitVector* src1,
const ArenaBitVector* src2);
-bool oatUnifyBitVectors(ArenaBitVector* dest, const ArenaBitVector* src1,
+bool UnifyBitVetors(ArenaBitVector* dest, const ArenaBitVector* src1,
const ArenaBitVector* src2);
-bool oatCompareBitVectors(const ArenaBitVector* src1,
+bool CompareBitVectors(const ArenaBitVector* src1,
const ArenaBitVector* src2);
-bool oatTestBitVectors(const ArenaBitVector* src1, const ArenaBitVector* src2);
-int oatCountSetBits(const ArenaBitVector* pBits);
+bool TestBitVectors(const ArenaBitVector* src1, const ArenaBitVector* src2);
+int CountSetBits(const ArenaBitVector* pBits);
-void oatDumpLIRInsn(CompilationUnit* cUnit, LIR* lir, unsigned char* baseAddr);
-void oatDumpResourceMask(LIR* lir, uint64_t mask, const char* prefix);
-void oatDumpBlockBitVector(const GrowableList* blocks, char* msg,
+void DumpLIRInsn(CompilationUnit* cUnit, LIR* lir, unsigned char* baseAddr);
+void DumpResourceMask(LIR* lir, uint64_t mask, const char* prefix);
+void DumpBlockBitVector(const GrowableList* blocks, char* msg,
const ArenaBitVector* bv, int length);
-void oatGetBlockName(BasicBlock* bb, char* name);
-const char* oatGetShortyFromTargetIdx(CompilationUnit*, int);
-void oatDumpRegLocTable(RegLocation*, int);
-void oatDumpMemStats(CompilationUnit* cUnit);
-void oatDumpRegLoc(RegLocation loc);
+void GetBlockName(BasicBlock* bb, char* name);
+const char* GetShortyFromTargetIdx(CompilationUnit*, int);
+void DumpMemStats(CompilationUnit* cUnit);
} // namespace art
diff --git a/src/compiler/dataflow.cc b/src/compiler/dataflow.cc
index 5ec5bc2..f538fc4 100644
--- a/src/compiler/dataflow.cc
+++ b/src/compiler/dataflow.cc
@@ -848,14 +848,14 @@
return GET_ELEM_N(cUnit->ssaSubscripts, int, ssaReg);
}
-int getSSAUseCount(CompilationUnit* cUnit, int sReg)
+static int GetSSAUseCount(CompilationUnit* cUnit, int sReg)
{
DCHECK(sReg < static_cast<int>(cUnit->rawUseCounts.numUsed));
return cUnit->rawUseCounts.elemList[sReg];
}
-char* oatGetDalvikDisassembly(CompilationUnit* cUnit,
+char* GetDalvikDisassembly(CompilationUnit* cUnit,
const DecodedInstruction& insn, const char* note)
{
std::string str;
@@ -931,12 +931,12 @@
}
}
int length = str.length() + 1;
- ret = static_cast<char*>(oatNew(cUnit, length, false, kAllocDFInfo));
+ ret = static_cast<char*>(NewMem(cUnit, length, false, kAllocDFInfo));
strncpy(ret, str.c_str(), length);
return ret;
}
-std::string getSSAName(const CompilationUnit* cUnit, int ssaReg)
+static std::string GetSSAName(const CompilationUnit* cUnit, int ssaReg)
{
return StringPrintf("v%d_%d", SRegToVReg(cUnit, ssaReg),
SRegToSubscript(cUnit, ssaReg));
@@ -945,7 +945,7 @@
/*
* Dalvik instruction disassembler with optional SSA printing.
*/
-char* oatFullDisassembler(CompilationUnit* cUnit, const MIR* mir)
+char* FullDisassembler(CompilationUnit* cUnit, const MIR* mir)
{
std::string str;
const DecodedInstruction* insn = &mir->dalvikInsn;
@@ -958,13 +958,13 @@
if (opcode == kMirOpPhi) {
int* incoming = reinterpret_cast<int*>(mir->dalvikInsn.vB);
str.append(StringPrintf("PHI %s = (%s",
- getSSAName(cUnit, mir->ssaRep->defs[0]).c_str(),
- getSSAName(cUnit, mir->ssaRep->uses[0]).c_str()));
+ GetSSAName(cUnit, mir->ssaRep->defs[0]).c_str(),
+ GetSSAName(cUnit, mir->ssaRep->uses[0]).c_str()));
str.append(StringPrintf(":%d",incoming[0]));
int i;
for (i = 1; i < mir->ssaRep->numUses; i++) {
str.append(StringPrintf(", %s:%d",
- getSSAName(cUnit, mir->ssaRep->uses[i]).c_str(),
+ GetSSAName(cUnit, mir->ssaRep->uses[i]).c_str(),
incoming[i]));
}
str.append(")");
@@ -988,13 +988,13 @@
switch (dalvikFormat) {
case Instruction::k21t:
str.append(StringPrintf(" %s, ",
- getSSAName(cUnit, mir->ssaRep->uses[0]).c_str()));
+ GetSSAName(cUnit, mir->ssaRep->uses[0]).c_str()));
delta = insn->vB;
break;
case Instruction::k22t:
str.append(StringPrintf(" %s, %s, ",
- getSSAName(cUnit, mir->ssaRep->uses[0]).c_str(),
- getSSAName(cUnit, mir->ssaRep->uses[1]).c_str()));
+ GetSSAName(cUnit, mir->ssaRep->uses[0]).c_str(),
+ GetSSAName(cUnit, mir->ssaRep->uses[1]).c_str()));
delta = insn->vC;
break;
case Instruction::k10t:
@@ -1011,7 +1011,7 @@
for (i = 0; i < insn->vA; i++) {
if (i != 0) str.append(",");
str.append(" ");
- str.append(getSSAName(cUnit, mir->ssaRep->uses[i]));
+ str.append(GetSSAName(cUnit, mir->ssaRep->uses[i]));
}
} else {
int udIdx;
@@ -1019,17 +1019,17 @@
for (udIdx = 0; udIdx < mir->ssaRep->numDefs; udIdx++) {
str.append(" ");
- str.append(getSSAName(cUnit, mir->ssaRep->defs[udIdx]));
+ str.append(GetSSAName(cUnit, mir->ssaRep->defs[udIdx]));
}
str.append(",");
}
if (mir->ssaRep->numUses) {
/* No leading ',' for the first use */
str.append(" ");
- str.append(getSSAName(cUnit, mir->ssaRep->uses[0]));
+ str.append(GetSSAName(cUnit, mir->ssaRep->uses[0]));
for (udIdx = 1; udIdx < mir->ssaRep->numUses; udIdx++) {
str.append(", ");
- str.append(getSSAName(cUnit, mir->ssaRep->uses[udIdx]));
+ str.append(GetSSAName(cUnit, mir->ssaRep->uses[udIdx]));
}
}
if (static_cast<int>(opcode) < static_cast<int>(kMirOpFirst)) {
@@ -1062,12 +1062,12 @@
done:
length = str.length() + 1;
- ret = static_cast<char*>(oatNew(cUnit, length, false, kAllocDFInfo));
+ ret = static_cast<char*>(NewMem(cUnit, length, false, kAllocDFInfo));
strncpy(ret, str.c_str(), length);
return ret;
}
-char* oatGetSSAString(CompilationUnit* cUnit, SSARepresentation* ssaRep)
+char* GetSSAString(CompilationUnit* cUnit, SSARepresentation* ssaRep)
{
std::string str;
char* ret;
@@ -1091,34 +1091,32 @@
}
int length = str.length() + 1;
- ret = static_cast<char*>(oatNew(cUnit, length, false, kAllocDFInfo));
+ ret = static_cast<char*>(NewMem(cUnit, length, false, kAllocDFInfo));
strncpy(ret, str.c_str(), length);
return ret;
}
/* Any register that is used before being defined is considered live-in */
-inline void handleLiveInUse(CompilationUnit* cUnit, ArenaBitVector* useV,
- ArenaBitVector* defV, ArenaBitVector* liveInV,
- int dalvikRegId)
+static inline void HandleLiveInUse(CompilationUnit* cUnit, ArenaBitVector* useV,
+ ArenaBitVector* defV, ArenaBitVector* liveInV, int dalvikRegId)
{
- oatSetBit(cUnit, useV, dalvikRegId);
- if (!oatIsBitSet(defV, dalvikRegId)) {
- oatSetBit(cUnit, liveInV, dalvikRegId);
+ SetBit(cUnit, useV, dalvikRegId);
+ if (!IsBitSet(defV, dalvikRegId)) {
+ SetBit(cUnit, liveInV, dalvikRegId);
}
}
/* Mark a reg as being defined */
-inline void handleDef(CompilationUnit* cUnit, ArenaBitVector* defV,
- int dalvikRegId)
+static inline void HandleDef(CompilationUnit* cUnit, ArenaBitVector* defV, int dalvikRegId)
{
- oatSetBit(cUnit, defV, dalvikRegId);
+ SetBit(cUnit, defV, dalvikRegId);
}
/*
* Find out live-in variables for natural loops. Variables that are live-in in
* the main loop body are considered to be defined in the entry block.
*/
-bool oatFindLocalLiveIn(CompilationUnit* cUnit, BasicBlock* bb)
+bool FindLocalLiveIn(CompilationUnit* cUnit, BasicBlock* bb)
{
MIR* mir;
ArenaBitVector *useV, *defV, *liveInV;
@@ -1126,11 +1124,11 @@
if (bb->dataFlowInfo == NULL) return false;
useV = bb->dataFlowInfo->useV =
- oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false, kBitMapUse);
+ AllocBitVector(cUnit, cUnit->numDalvikRegisters, false, kBitMapUse);
defV = bb->dataFlowInfo->defV =
- oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false, kBitMapDef);
+ AllocBitVector(cUnit, cUnit->numDalvikRegisters, false, kBitMapDef);
liveInV = bb->dataFlowInfo->liveInV =
- oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false,
+ AllocBitVector(cUnit, cUnit->numDalvikRegisters, false,
kBitMapLiveIn);
for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
@@ -1139,122 +1137,120 @@
if (dfAttributes & DF_HAS_USES) {
if (dfAttributes & DF_UA) {
- handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vA);
+ HandleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vA);
if (dfAttributes & DF_A_WIDE) {
- handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vA+1);
+ HandleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vA+1);
}
}
if (dfAttributes & DF_UB) {
- handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vB);
+ HandleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vB);
if (dfAttributes & DF_B_WIDE) {
- handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vB+1);
+ HandleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vB+1);
}
}
if (dfAttributes & DF_UC) {
- handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC);
+ HandleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC);
if (dfAttributes & DF_C_WIDE) {
- handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC+1);
+ HandleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC+1);
}
}
}
if (dfAttributes & DF_FORMAT_35C) {
for (unsigned int i = 0; i < dInsn->vA; i++) {
- handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->arg[i]);
+ HandleLiveInUse(cUnit, useV, defV, liveInV, dInsn->arg[i]);
}
}
if (dfAttributes & DF_FORMAT_3RC) {
for (unsigned int i = 0; i < dInsn->vA; i++) {
- handleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC+i);
+ HandleLiveInUse(cUnit, useV, defV, liveInV, dInsn->vC+i);
}
}
if (dfAttributes & DF_HAS_DEFS) {
- handleDef(cUnit, defV, dInsn->vA);
+ HandleDef(cUnit, defV, dInsn->vA);
if (dfAttributes & DF_A_WIDE) {
- handleDef(cUnit, defV, dInsn->vA+1);
+ HandleDef(cUnit, defV, dInsn->vA+1);
}
}
}
return true;
}
-int addNewSReg(CompilationUnit* cUnit, int vReg)
+static int AddNewSReg(CompilationUnit* cUnit, int vReg)
{
// Compiler temps always have a subscript of 0
int subscript = (vReg < 0) ? 0 : ++cUnit->SSALastDefs[vReg];
int ssaReg = cUnit->numSSARegs++;
- oatInsertGrowableList(cUnit, cUnit->ssaBaseVRegs, vReg);
- oatInsertGrowableList(cUnit, cUnit->ssaSubscripts, subscript);
- std::string ssaName = getSSAName(cUnit, ssaReg);
- char* name = static_cast<char*>(oatNew(cUnit, ssaName.length() + 1, false, kAllocDFInfo));
+ InsertGrowableList(cUnit, cUnit->ssaBaseVRegs, vReg);
+ InsertGrowableList(cUnit, cUnit->ssaSubscripts, subscript);
+ std::string ssaName = GetSSAName(cUnit, ssaReg);
+ char* name = static_cast<char*>(NewMem(cUnit, ssaName.length() + 1, false, kAllocDFInfo));
strncpy(name, ssaName.c_str(), ssaName.length() + 1);
- oatInsertGrowableList(cUnit, cUnit->ssaStrings, reinterpret_cast<uintptr_t>(name));
+ InsertGrowableList(cUnit, cUnit->ssaStrings, reinterpret_cast<uintptr_t>(name));
DCHECK_EQ(cUnit->ssaBaseVRegs->numUsed, cUnit->ssaSubscripts->numUsed);
return ssaReg;
}
/* Find out the latest SSA register for a given Dalvik register */
-void handleSSAUse(CompilationUnit* cUnit, int* uses, int dalvikReg,
- int regIndex)
+static void HandleSSAUse(CompilationUnit* cUnit, int* uses, int dalvikReg, int regIndex)
{
DCHECK((dalvikReg >= 0) && (dalvikReg < cUnit->numDalvikRegisters));
uses[regIndex] = cUnit->vRegToSSAMap[dalvikReg];
}
/* Setup a new SSA register for a given Dalvik register */
-void handleSSADef(CompilationUnit* cUnit, int* defs, int dalvikReg,
- int regIndex)
+static void HandleSSADef(CompilationUnit* cUnit, int* defs, int dalvikReg, int regIndex)
{
DCHECK((dalvikReg >= 0) && (dalvikReg < cUnit->numDalvikRegisters));
- int ssaReg = addNewSReg(cUnit, dalvikReg);
+ int ssaReg = AddNewSReg(cUnit, dalvikReg);
cUnit->vRegToSSAMap[dalvikReg] = ssaReg;
defs[regIndex] = ssaReg;
}
/* Look up new SSA names for format_35c instructions */
-void dataFlowSSAFormat35C(CompilationUnit* cUnit, MIR* mir)
+static void DataFlowSSAFormat35C(CompilationUnit* cUnit, MIR* mir)
{
DecodedInstruction *dInsn = &mir->dalvikInsn;
int numUses = dInsn->vA;
int i;
mir->ssaRep->numUses = numUses;
- mir->ssaRep->uses = static_cast<int*>(oatNew(cUnit, sizeof(int) * numUses, true, kAllocDFInfo));
+ mir->ssaRep->uses = static_cast<int*>(NewMem(cUnit, sizeof(int) * numUses, true, kAllocDFInfo));
// NOTE: will be filled in during type & size inference pass
- mir->ssaRep->fpUse = static_cast<bool*>(oatNew(cUnit, sizeof(bool) * numUses, true,
+ mir->ssaRep->fpUse = static_cast<bool*>(NewMem(cUnit, sizeof(bool) * numUses, true,
kAllocDFInfo));
for (i = 0; i < numUses; i++) {
- handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->arg[i], i);
+ HandleSSAUse(cUnit, mir->ssaRep->uses, dInsn->arg[i], i);
}
}
/* Look up new SSA names for format_3rc instructions */
-void dataFlowSSAFormat3RC(CompilationUnit* cUnit, MIR* mir)
+static void DataFlowSSAFormat3RC(CompilationUnit* cUnit, MIR* mir)
{
DecodedInstruction *dInsn = &mir->dalvikInsn;
int numUses = dInsn->vA;
int i;
mir->ssaRep->numUses = numUses;
- mir->ssaRep->uses = static_cast<int*>(oatNew(cUnit, sizeof(int) * numUses, true, kAllocDFInfo));
+ mir->ssaRep->uses = static_cast<int*>(NewMem(cUnit, sizeof(int) * numUses, true, kAllocDFInfo));
// NOTE: will be filled in during type & size inference pass
- mir->ssaRep->fpUse = static_cast<bool*>(oatNew(cUnit, sizeof(bool) * numUses, true,
+ mir->ssaRep->fpUse = static_cast<bool*>(NewMem(cUnit, sizeof(bool) * numUses, true,
kAllocDFInfo));
for (i = 0; i < numUses; i++) {
- handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC+i, i);
+ HandleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC+i, i);
}
}
/* Entry function to convert a block into SSA representation */
-bool oatDoSSAConversion(CompilationUnit* cUnit, BasicBlock* bb)
+bool DoSSAConversion(CompilationUnit* cUnit, BasicBlock* bb)
{
MIR* mir;
if (bb->dataFlowInfo == NULL) return false;
for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
- mir->ssaRep = static_cast<struct SSARepresentation *>(oatNew(cUnit, sizeof(SSARepresentation),
+ mir->ssaRep = static_cast<struct SSARepresentation *>(NewMem(cUnit, sizeof(SSARepresentation),
true, kAllocDFInfo));
int dfAttributes = oatDataFlowAttributes[mir->dalvikInsn.opcode];
@@ -1276,12 +1272,12 @@
int numUses = 0;
if (dfAttributes & DF_FORMAT_35C) {
- dataFlowSSAFormat35C(cUnit, mir);
+ DataFlowSSAFormat35C(cUnit, mir);
continue;
}
if (dfAttributes & DF_FORMAT_3RC) {
- dataFlowSSAFormat3RC(cUnit, mir);
+ DataFlowSSAFormat3RC(cUnit, mir);
continue;
}
@@ -1308,9 +1304,9 @@
if (numUses) {
mir->ssaRep->numUses = numUses;
- mir->ssaRep->uses = static_cast<int*>(oatNew(cUnit, sizeof(int) * numUses, false,
+ mir->ssaRep->uses = static_cast<int*>(NewMem(cUnit, sizeof(int) * numUses, false,
kAllocDFInfo));
- mir->ssaRep->fpUse = static_cast<bool*>(oatNew(cUnit, sizeof(bool) * numUses, false,
+ mir->ssaRep->fpUse = static_cast<bool*>(NewMem(cUnit, sizeof(bool) * numUses, false,
kAllocDFInfo));
}
@@ -1325,9 +1321,9 @@
if (numDefs) {
mir->ssaRep->numDefs = numDefs;
- mir->ssaRep->defs = static_cast<int*>(oatNew(cUnit, sizeof(int) * numDefs, false,
+ mir->ssaRep->defs = static_cast<int*>(NewMem(cUnit, sizeof(int) * numDefs, false,
kAllocDFInfo));
- mir->ssaRep->fpDef = static_cast<bool*>(oatNew(cUnit, sizeof(bool) * numDefs, false,
+ mir->ssaRep->fpDef = static_cast<bool*>(NewMem(cUnit, sizeof(bool) * numDefs, false,
kAllocDFInfo));
}
@@ -1337,35 +1333,35 @@
numUses = 0;
if (dfAttributes & DF_UA) {
mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_A;
- handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vA, numUses++);
+ HandleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vA, numUses++);
if (dfAttributes & DF_A_WIDE) {
mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_A;
- handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vA+1, numUses++);
+ HandleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vA+1, numUses++);
}
}
if (dfAttributes & DF_UB) {
mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_B;
- handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vB, numUses++);
+ HandleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vB, numUses++);
if (dfAttributes & DF_B_WIDE) {
mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_B;
- handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vB+1, numUses++);
+ HandleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vB+1, numUses++);
}
}
if (dfAttributes & DF_UC) {
mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_C;
- handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC, numUses++);
+ HandleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC, numUses++);
if (dfAttributes & DF_C_WIDE) {
mir->ssaRep->fpUse[numUses] = dfAttributes & DF_FP_C;
- handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC+1, numUses++);
+ HandleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC+1, numUses++);
}
}
}
if (dfAttributes & DF_HAS_DEFS) {
mir->ssaRep->fpDef[0] = dfAttributes & DF_FP_A;
- handleSSADef(cUnit, mir->ssaRep->defs, dInsn->vA, 0);
+ HandleSSADef(cUnit, mir->ssaRep->defs, dInsn->vA, 0);
if (dfAttributes & DF_A_WIDE) {
mir->ssaRep->fpDef[1] = dfAttributes & DF_FP_A;
- handleSSADef(cUnit, mir->ssaRep->defs, dInsn->vA+1, 1);
+ HandleSSADef(cUnit, mir->ssaRep->defs, dInsn->vA+1, 1);
}
}
}
@@ -1377,7 +1373,7 @@
* predecessor blocks.
*/
bb->dataFlowInfo->vRegToSSAMap =
- static_cast<int*>(oatNew(cUnit, sizeof(int) * cUnit->numDalvikRegisters, false,
+ static_cast<int*>(NewMem(cUnit, sizeof(int) * cUnit->numDalvikRegisters, false,
kAllocDFInfo));
memcpy(bb->dataFlowInfo->vRegToSSAMap, cUnit->vRegToSSAMap,
@@ -1387,13 +1383,13 @@
}
/* Setup a constant value for opcodes thare have the DF_SETS_CONST attribute */
-void setConstant(CompilationUnit* cUnit, int ssaReg, int value)
+static void SetConstant(CompilationUnit* cUnit, int ssaReg, int value)
{
- oatSetBit(cUnit, cUnit->isConstantV, ssaReg);
+ SetBit(cUnit, cUnit->isConstantV, ssaReg);
cUnit->constantValues[ssaReg] = value;
}
-bool oatDoConstantPropagation(CompilationUnit* cUnit, BasicBlock* bb)
+bool DoConstantPropogation(CompilationUnit* cUnit, BasicBlock* bb)
{
MIR* mir;
ArenaBitVector *isConstantV = cUnit->isConstantV;
@@ -1412,23 +1408,23 @@
case Instruction::CONST_4:
case Instruction::CONST_16:
case Instruction::CONST:
- setConstant(cUnit, mir->ssaRep->defs[0], dInsn->vB);
+ SetConstant(cUnit, mir->ssaRep->defs[0], dInsn->vB);
break;
case Instruction::CONST_HIGH16:
- setConstant(cUnit, mir->ssaRep->defs[0], dInsn->vB << 16);
+ SetConstant(cUnit, mir->ssaRep->defs[0], dInsn->vB << 16);
break;
case Instruction::CONST_WIDE_16:
case Instruction::CONST_WIDE_32:
- setConstant(cUnit, mir->ssaRep->defs[0], dInsn->vB);
- setConstant(cUnit, mir->ssaRep->defs[1], 0);
+ SetConstant(cUnit, mir->ssaRep->defs[0], dInsn->vB);
+ SetConstant(cUnit, mir->ssaRep->defs[1], 0);
break;
case Instruction::CONST_WIDE:
- setConstant(cUnit, mir->ssaRep->defs[0], static_cast<int>(dInsn->vB_wide));
- setConstant(cUnit, mir->ssaRep->defs[1], static_cast<int>(dInsn->vB_wide >> 32));
+ SetConstant(cUnit, mir->ssaRep->defs[0], static_cast<int>(dInsn->vB_wide));
+ SetConstant(cUnit, mir->ssaRep->defs[1], static_cast<int>(dInsn->vB_wide >> 32));
break;
case Instruction::CONST_WIDE_HIGH16:
- setConstant(cUnit, mir->ssaRep->defs[0], 0);
- setConstant(cUnit, mir->ssaRep->defs[1], dInsn->vB << 16);
+ SetConstant(cUnit, mir->ssaRep->defs[0], 0);
+ SetConstant(cUnit, mir->ssaRep->defs[1], dInsn->vB << 16);
break;
default:
break;
@@ -1439,14 +1435,14 @@
int i;
for (i = 0; i < mir->ssaRep->numUses; i++) {
- if (!oatIsBitSet(isConstantV, mir->ssaRep->uses[i])) break;
+ if (!IsBitSet(isConstantV, mir->ssaRep->uses[i])) break;
}
/* Move a register holding a constant to another register */
if (i == mir->ssaRep->numUses) {
- setConstant(cUnit, mir->ssaRep->defs[0],
+ SetConstant(cUnit, mir->ssaRep->defs[0],
cUnit->constantValues[mir->ssaRep->uses[0]]);
if (dfAttributes & DF_A_WIDE) {
- setConstant(cUnit, mir->ssaRep->defs[1],
+ SetConstant(cUnit, mir->ssaRep->defs[1],
cUnit->constantValues[mir->ssaRep->uses[1]]);
}
}
@@ -1457,25 +1453,25 @@
}
/* Setup the basic data structures for SSA conversion */
-void oatInitializeSSAConversion(CompilationUnit* cUnit)
+void CompilerInitializeSSAConversion(CompilationUnit* cUnit)
{
int i;
int numDalvikReg = cUnit->numDalvikRegisters;
cUnit->ssaBaseVRegs =
- static_cast<GrowableList*>(oatNew(cUnit, sizeof(GrowableList), false, kAllocDFInfo));
+ static_cast<GrowableList*>(NewMem(cUnit, sizeof(GrowableList), false, kAllocDFInfo));
cUnit->ssaSubscripts =
- static_cast<GrowableList*>(oatNew(cUnit, sizeof(GrowableList), false, kAllocDFInfo));
+ static_cast<GrowableList*>(NewMem(cUnit, sizeof(GrowableList), false, kAllocDFInfo));
cUnit->ssaStrings =
- static_cast<GrowableList*>(oatNew(cUnit, sizeof(GrowableList), false, kAllocDFInfo));
+ static_cast<GrowableList*>(NewMem(cUnit, sizeof(GrowableList), false, kAllocDFInfo));
// Create the ssa mappings, estimating the max size
- oatInitGrowableList(cUnit, cUnit->ssaBaseVRegs,
+ CompilerInitGrowableList(cUnit, cUnit->ssaBaseVRegs,
numDalvikReg + cUnit->defCount + 128,
kListSSAtoDalvikMap);
- oatInitGrowableList(cUnit, cUnit->ssaSubscripts,
+ CompilerInitGrowableList(cUnit, cUnit->ssaSubscripts,
numDalvikReg + cUnit->defCount + 128,
kListSSAtoDalvikMap);
- oatInitGrowableList(cUnit, cUnit->ssaStrings,
+ CompilerInitGrowableList(cUnit, cUnit->ssaStrings,
numDalvikReg + cUnit->defCount + 128,
kListSSAtoDalvikMap);
/*
@@ -1490,12 +1486,12 @@
* into "(0 << 16) | i"
*/
for (i = 0; i < numDalvikReg; i++) {
- oatInsertGrowableList(cUnit, cUnit->ssaBaseVRegs, i);
- oatInsertGrowableList(cUnit, cUnit->ssaSubscripts, 0);
- std::string ssaName = getSSAName(cUnit, i);
- char* name = static_cast<char*>(oatNew(cUnit, ssaName.length() + 1, true, kAllocDFInfo));
+ InsertGrowableList(cUnit, cUnit->ssaBaseVRegs, i);
+ InsertGrowableList(cUnit, cUnit->ssaSubscripts, 0);
+ std::string ssaName = GetSSAName(cUnit, i);
+ char* name = static_cast<char*>(NewMem(cUnit, ssaName.length() + 1, true, kAllocDFInfo));
strncpy(name, ssaName.c_str(), ssaName.length() + 1);
- oatInsertGrowableList(cUnit, cUnit->ssaStrings, reinterpret_cast<uintptr_t>(name));
+ InsertGrowableList(cUnit, cUnit->ssaStrings, reinterpret_cast<uintptr_t>(name));
}
/*
@@ -1503,10 +1499,10 @@
* Dalvik register, and the SSA names for those are the same.
*/
cUnit->vRegToSSAMap =
- static_cast<int*>(oatNew(cUnit, sizeof(int) * numDalvikReg, false, kAllocDFInfo));
+ static_cast<int*>(NewMem(cUnit, sizeof(int) * numDalvikReg, false, kAllocDFInfo));
/* Keep track of the higest def for each dalvik reg */
cUnit->SSALastDefs =
- static_cast<int*>(oatNew(cUnit, sizeof(int) * numDalvikReg, false, kAllocDFInfo));
+ static_cast<int*>(NewMem(cUnit, sizeof(int) * numDalvikReg, false, kAllocDFInfo));
for (i = 0; i < numDalvikReg; i++) {
cUnit->vRegToSSAMap[i] = i;
@@ -1514,36 +1510,36 @@
}
/* Add ssa reg for Method* */
- cUnit->methodSReg = addNewSReg(cUnit, SSA_METHOD_BASEREG);
+ cUnit->methodSReg = AddNewSReg(cUnit, SSA_METHOD_BASEREG);
/*
* Allocate the BasicBlockDataFlow structure for the entry and code blocks
*/
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&cUnit->blockList, &iterator);
+ GrowableListIteratorInit(&cUnit->blockList, &iterator);
while (true) {
- BasicBlock* bb = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iterator));
+ BasicBlock* bb = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iterator));
if (bb == NULL) break;
if (bb->hidden == true) continue;
if (bb->blockType == kDalvikByteCode ||
bb->blockType == kEntryBlock ||
bb->blockType == kExitBlock) {
- bb->dataFlowInfo = static_cast<BasicBlockDataFlow*>(oatNew(cUnit, sizeof(BasicBlockDataFlow),
+ bb->dataFlowInfo = static_cast<BasicBlockDataFlow*>(NewMem(cUnit, sizeof(BasicBlockDataFlow),
true, kAllocDFInfo));
}
}
}
/* Clear the visited flag for each BB */
-bool oatClearVisitedFlag(struct CompilationUnit* cUnit, struct BasicBlock* bb)
+bool ClearVisitedFlag(struct CompilationUnit* cUnit, struct BasicBlock* bb)
{
bb->visited = false;
return true;
}
-void oatDataFlowAnalysisDispatcher(CompilationUnit* cUnit,
+void DataFlowAnalysisDispatcher(CompilationUnit* cUnit,
bool (*func)(CompilationUnit*, BasicBlock*),
DataFlowAnalysisMode dfaMode,
bool isIterative)
@@ -1558,9 +1554,9 @@
case kAllNodes:
{
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&cUnit->blockList, &iterator);
+ GrowableListIteratorInit(&cUnit->blockList, &iterator);
while (true) {
- BasicBlock* bb = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iterator));
+ BasicBlock* bb = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iterator));
if (bb == NULL) break;
if (bb->hidden == true) continue;
change |= (*func)(cUnit, bb);
@@ -1577,7 +1573,7 @@
for (idx = 0; idx < numReachableBlocks; idx++) {
int blockIdx = cUnit->dfsOrder.elemList[idx];
BasicBlock* bb =
- reinterpret_cast<BasicBlock*>( oatGrowableListGetElement(blockList, blockIdx));
+ reinterpret_cast<BasicBlock*>( GrowableListGetElement(blockList, blockIdx));
change |= (*func)(cUnit, bb);
}
}
@@ -1593,7 +1589,7 @@
for (idx = 0; idx < numReachableBlocks; idx++) {
int dfsIdx = cUnit->dfsOrder.elemList[idx];
BasicBlock* bb =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, dfsIdx));
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, dfsIdx));
change |= (*func)(cUnit, bb);
}
}
@@ -1608,7 +1604,7 @@
for (idx = numReachableBlocks - 1; idx >= 0; idx--) {
int dfsIdx = cUnit->dfsOrder.elemList[idx];
BasicBlock* bb =
- reinterpret_cast<BasicBlock *>( oatGrowableListGetElement(blockList, dfsIdx));
+ reinterpret_cast<BasicBlock *>( GrowableListGetElement(blockList, dfsIdx));
change |= (*func)(cUnit, bb);
}
}
@@ -1623,7 +1619,7 @@
for (idx = 0; idx < numReachableBlocks; idx++) {
int domIdx = cUnit->domPostOrderTraversal.elemList[idx];
BasicBlock* bb =
- reinterpret_cast<BasicBlock*>( oatGrowableListGetElement(blockList, domIdx));
+ reinterpret_cast<BasicBlock*>( GrowableListGetElement(blockList, domIdx));
change |= (*func)(cUnit, bb);
}
}
@@ -1638,7 +1634,7 @@
for (idx = numReachableBlocks - 1; idx >= 0; idx--) {
int revIdx = cUnit->dfsPostOrder.elemList[idx];
BasicBlock* bb =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, revIdx));
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, revIdx));
change |= (*func)(cUnit, bb);
}
}
@@ -1652,8 +1648,8 @@
}
/* Advance to next strictly dominated MIR node in an extended basic block */
-MIR* advanceMIR(CompilationUnit* cUnit, BasicBlock** pBb, MIR* mir,
- ArenaBitVector* bv, bool clearMark) {
+static MIR* AdvanceMIR(CompilationUnit* cUnit, BasicBlock** pBb, MIR* mir,
+ ArenaBitVector* bv, bool clearMark) {
BasicBlock* bb = *pBb;
if (mir != NULL) {
mir = mir->next;
@@ -1663,7 +1659,7 @@
mir = NULL;
} else {
if (bv) {
- oatSetBit(cUnit, bv, bb->id);
+ SetBit(cUnit, bv, bb->id);
}
*pBb = bb;
mir = bb->firstMIRInsn;
@@ -1683,10 +1679,10 @@
* opcodes or incoming arcs. However, if the result of the invoke is not
* used, a move-result may not be present.
*/
-MIR* oatFindMoveResult(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir)
+MIR* FindMoveResult(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir)
{
BasicBlock* tbb = bb;
- mir = advanceMIR(cUnit, &tbb, mir, NULL, false);
+ mir = AdvanceMIR(cUnit, &tbb, mir, NULL, false);
while (mir != NULL) {
int opcode = mir->dalvikInsn.opcode;
if ((mir->dalvikInsn.opcode == Instruction::MOVE_RESULT) ||
@@ -1698,17 +1694,17 @@
if (opcode < kNumPackedOpcodes) {
mir = NULL;
} else {
- mir = advanceMIR(cUnit, &tbb, mir, NULL, false);
+ mir = AdvanceMIR(cUnit, &tbb, mir, NULL, false);
}
}
return mir;
}
-void squashDupRangeChecks(CompilationUnit* cUnit, BasicBlock** pBp, MIR* mir,
- int arraySreg, int indexSreg)
+static void SquashDupRangeChecks(CompilationUnit* cUnit, BasicBlock** pBp, MIR* mir,
+ int arraySreg, int indexSreg)
{
while (true) {
- mir = advanceMIR(cUnit, pBp, mir, NULL, false);
+ mir = AdvanceMIR(cUnit, pBp, mir, NULL, false);
if (!mir) {
break;
}
@@ -1756,55 +1752,8 @@
}
}
-/* Allocate a compiler temp, return Sreg. Reuse existing if no conflict */
-int allocCompilerTempSreg(CompilationUnit* cUnit, ArenaBitVector* bv)
-{
- for (int i = 0; i < cUnit->numCompilerTemps; i++) {
- CompilerTemp* ct = reinterpret_cast<CompilerTemp*>(cUnit->compilerTemps.elemList[i]);
- ArenaBitVector* tBv = ct->bv;
- if (!oatTestBitVectors(bv, tBv)) {
- // Combine live maps and reuse existing temp
- oatUnifyBitVectors(tBv, tBv, bv);
- return ct->sReg;
- }
- }
-
- // Create a new compiler temp & associated live bitmap
- CompilerTemp* ct =
- static_cast<CompilerTemp*>(oatNew(cUnit, sizeof(CompilerTemp), true, kAllocMisc));
- ArenaBitVector *nBv = oatAllocBitVector(cUnit, cUnit->numBlocks, true,
- kBitMapMisc);
- oatCopyBitVector(nBv, bv);
- ct->bv = nBv;
- ct->sReg = addNewSReg(cUnit, SSA_CTEMP_BASEREG - cUnit->numCompilerTemps);
- cUnit->numCompilerTemps++;
- oatInsertGrowableList(cUnit, &cUnit->compilerTemps, reinterpret_cast<uintptr_t>(ct));
- DCHECK_EQ(cUnit->numCompilerTemps, static_cast<int>(cUnit->compilerTemps.numUsed));
- return ct->sReg;
-}
-
-/* Creata a new MIR node for a new pseudo op. */
-MIR* rawMIR(CompilationUnit* cUnit, Instruction::Code opcode, int defs,
- int uses)
-{
- MIR* res = static_cast<MIR*>(oatNew(cUnit, sizeof(MIR), true, kAllocMIR));
- res->ssaRep = static_cast<struct SSARepresentation*>
- (oatNew(cUnit, sizeof(SSARepresentation), true, kAllocDFInfo));
- if (uses) {
- res->ssaRep->numUses = uses;
- res->ssaRep->uses = static_cast<int*>(oatNew(cUnit, sizeof(int) * uses, false, kAllocDFInfo));
- }
- if (defs) {
- res->ssaRep->numDefs = defs;
- res->ssaRep->defs = static_cast<int*>(oatNew(cUnit, sizeof(int) * defs, false, kAllocDFInfo));
- res->ssaRep->fpDef = static_cast<bool*>(oatNew(cUnit, sizeof(bool) * defs, true, kAllocDFInfo));
- }
- res->dalvikInsn.opcode = opcode;
- return res;
-}
-
/* Do some MIR-level basic block optimizations */
-bool basicBlockOpt(CompilationUnit* cUnit, BasicBlock* bb)
+static bool BasicBlockOpt(CompilationUnit* cUnit, BasicBlock* bb)
{
int numTemps = 0;
@@ -1823,7 +1772,7 @@
int arrSreg = mir->ssaRep->uses[0];
int idxSreg = mir->ssaRep->uses[1];
BasicBlock* tbb = bb;
- squashDupRangeChecks(cUnit, &tbb, mir, arrSreg, idxSreg);
+ SquashDupRangeChecks(cUnit, &tbb, mir, arrSreg, idxSreg);
}
break;
case Instruction::APUT:
@@ -1838,7 +1787,7 @@
int arrSreg = mir->ssaRep->uses[start];
int idxSreg = mir->ssaRep->uses[start + 1];
BasicBlock* tbb = bb;
- squashDupRangeChecks(cUnit, &tbb, mir, arrSreg, idxSreg);
+ SquashDupRangeChecks(cUnit, &tbb, mir, arrSreg, idxSreg);
}
break;
case Instruction::CMPL_FLOAT:
@@ -1879,7 +1828,7 @@
// Make sure result of cmp is used by next insn and nowhere else
if ((ccode != kCondNv) &&
(mir->ssaRep->defs[0] == mirNext->ssaRep->uses[0]) &&
- (getSSAUseCount(cUnit, mir->ssaRep->defs[0]) == 1)) {
+ (GetSSAUseCount(cUnit, mir->ssaRep->defs[0]) == 1)) {
mirNext->dalvikInsn.arg[0] = ccode;
switch(opcode) {
case Instruction::CMPL_FLOAT:
@@ -1925,18 +1874,17 @@
return true;
}
-bool nullCheckEliminationInit(struct CompilationUnit* cUnit,
- struct BasicBlock* bb)
+static bool NullCheckEliminationInit(struct CompilationUnit* cUnit, struct BasicBlock* bb)
{
if (bb->dataFlowInfo == NULL) return false;
bb->dataFlowInfo->endingNullCheckV =
- oatAllocBitVector(cUnit, cUnit->numSSARegs, false, kBitMapNullCheck);
- oatClearAllBits(bb->dataFlowInfo->endingNullCheckV);
+ AllocBitVector(cUnit, cUnit->numSSARegs, false, kBitMapNullCheck);
+ ClearAllBits(bb->dataFlowInfo->endingNullCheckV);
return true;
}
/* Collect stats on number of checks removed */
-bool countChecks( struct CompilationUnit* cUnit, struct BasicBlock* bb)
+static bool CountChecks( struct CompilationUnit* cUnit, struct BasicBlock* bb)
{
if (bb->dataFlowInfo == NULL) return false;
for (MIR* mir = bb->firstMIRInsn; mir; mir = mir->next) {
@@ -1961,7 +1909,7 @@
}
/* Try to make common case the fallthrough path */
-bool layoutBlocks(struct CompilationUnit* cUnit, struct BasicBlock* bb)
+static bool LayoutBlocks(struct CompilationUnit* cUnit, struct BasicBlock* bb)
{
// TODO: For now, just looking for direct throws. Consider generalizing for profile feedback
if (!bb->explicitThrow) {
@@ -2009,7 +1957,7 @@
}
/* Combine any basic blocks terminated by instructions that we now know can't throw */
-bool combineBlocks(struct CompilationUnit* cUnit, struct BasicBlock* bb)
+static bool CombineBlocks(struct CompilationUnit* cUnit, struct BasicBlock* bb)
{
// Loop here to allow combining a sequence of blocks
while (true) {
@@ -2073,7 +2021,7 @@
}
/* Eliminate unnecessary null checks for a basic block. */
-bool eliminateNullChecks( struct CompilationUnit* cUnit, struct BasicBlock* bb)
+static bool EliminateNullChecks( struct CompilationUnit* cUnit, struct BasicBlock* bb)
{
if (bb->dataFlowInfo == NULL) return false;
@@ -2083,28 +2031,28 @@
* status (except for "this").
*/
if ((bb->blockType == kEntryBlock) | bb->catchEntry) {
- oatClearAllBits(cUnit->tempSSARegisterV);
+ ClearAllBits(cUnit->tempSSARegisterV);
if ((cUnit->access_flags & kAccStatic) == 0) {
// If non-static method, mark "this" as non-null
int thisReg = cUnit->numDalvikRegisters - cUnit->numIns;
- oatSetBit(cUnit, cUnit->tempSSARegisterV, thisReg);
+ SetBit(cUnit, cUnit->tempSSARegisterV, thisReg);
}
} else {
// Starting state is intesection of all incoming arcs
GrowableListIterator iter;
- oatGrowableListIteratorInit(bb->predecessors, &iter);
- BasicBlock* predBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter));
+ GrowableListIteratorInit(bb->predecessors, &iter);
+ BasicBlock* predBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter));
DCHECK(predBB != NULL);
- oatCopyBitVector(cUnit->tempSSARegisterV,
+ CopyBitVector(cUnit->tempSSARegisterV,
predBB->dataFlowInfo->endingNullCheckV);
while (true) {
- predBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter));
+ predBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter));
if (!predBB) break;
if ((predBB->dataFlowInfo == NULL) ||
(predBB->dataFlowInfo->endingNullCheckV == NULL)) {
continue;
}
- oatIntersectBitVectors(cUnit->tempSSARegisterV,
+ IntersectBitVectors(cUnit->tempSSARegisterV,
cUnit->tempSSARegisterV,
predBB->dataFlowInfo->endingNullCheckV);
}
@@ -2119,7 +2067,7 @@
// Mark target of NEW* as non-null
if (dfAttributes & DF_NON_NULL_DST) {
- oatSetBit(cUnit, cUnit->tempSSARegisterV, mir->ssaRep->defs[0]);
+ SetBit(cUnit, cUnit->tempSSARegisterV, mir->ssaRep->defs[0]);
}
// Mark non-null returns from invoke-style NEW*
@@ -2129,7 +2077,7 @@
if (nextMir &&
nextMir->dalvikInsn.opcode == Instruction::MOVE_RESULT_OBJECT) {
// Mark as null checked
- oatSetBit(cUnit, cUnit->tempSSARegisterV, nextMir->ssaRep->defs[0]);
+ SetBit(cUnit, cUnit->tempSSARegisterV, nextMir->ssaRep->defs[0]);
} else {
if (nextMir) {
LOG(WARNING) << "Unexpected opcode following new: " << nextMir->dalvikInsn.opcode;
@@ -2144,7 +2092,7 @@
// First non-pseudo should be MOVE_RESULT_OBJECT
if (tmir->dalvikInsn.opcode == Instruction::MOVE_RESULT_OBJECT) {
// Mark as null checked
- oatSetBit(cUnit, cUnit->tempSSARegisterV, tmir->ssaRep->defs[0]);
+ SetBit(cUnit, cUnit->tempSSARegisterV, tmir->ssaRep->defs[0]);
} else {
LOG(WARNING) << "Unexpected op after new: " << tmir->dalvikInsn.opcode;
}
@@ -2165,11 +2113,11 @@
mir->ssaRep->numUses;
bool nullChecked = true;
for (int i = 0; i < operands; i++) {
- nullChecked &= oatIsBitSet(cUnit->tempSSARegisterV,
+ nullChecked &= IsBitSet(cUnit->tempSSARegisterV,
mir->ssaRep->uses[i]);
}
if (nullChecked) {
- oatSetBit(cUnit, cUnit->tempSSARegisterV, tgtSreg);
+ SetBit(cUnit, cUnit->tempSSARegisterV, tgtSreg);
}
}
@@ -2184,54 +2132,54 @@
srcIdx = 0;
}
int srcSreg = mir->ssaRep->uses[srcIdx];
- if (oatIsBitSet(cUnit->tempSSARegisterV, srcSreg)) {
+ if (IsBitSet(cUnit->tempSSARegisterV, srcSreg)) {
// Eliminate the null check
mir->optimizationFlags |= MIR_IGNORE_NULL_CHECK;
} else {
// Mark sReg as null-checked
- oatSetBit(cUnit, cUnit->tempSSARegisterV, srcSreg);
+ SetBit(cUnit, cUnit->tempSSARegisterV, srcSreg);
}
}
}
// Did anything change?
- bool res = oatCompareBitVectors(bb->dataFlowInfo->endingNullCheckV,
+ bool res = CompareBitVectors(bb->dataFlowInfo->endingNullCheckV,
cUnit->tempSSARegisterV);
if (res) {
- oatCopyBitVector(bb->dataFlowInfo->endingNullCheckV,
+ CopyBitVector(bb->dataFlowInfo->endingNullCheckV,
cUnit->tempSSARegisterV);
}
return res;
}
-void oatMethodNullCheckElimination(CompilationUnit *cUnit)
+void NullCheckElimination(CompilationUnit *cUnit)
{
if (!(cUnit->disableOpt & (1 << kNullCheckElimination))) {
DCHECK(cUnit->tempSSARegisterV != NULL);
- oatDataFlowAnalysisDispatcher(cUnit, nullCheckEliminationInit, kAllNodes,
+ DataFlowAnalysisDispatcher(cUnit, NullCheckEliminationInit, kAllNodes,
false /* isIterative */);
- oatDataFlowAnalysisDispatcher(cUnit, eliminateNullChecks,
+ DataFlowAnalysisDispatcher(cUnit, EliminateNullChecks,
kPreOrderDFSTraversal,
true /* isIterative */);
}
}
-void oatMethodBasicBlockCombine(CompilationUnit* cUnit)
+void BasicBlockCombine(CompilationUnit* cUnit)
{
- oatDataFlowAnalysisDispatcher(cUnit, combineBlocks, kPreOrderDFSTraversal, false);
+ DataFlowAnalysisDispatcher(cUnit, CombineBlocks, kPreOrderDFSTraversal, false);
}
-void oatMethodCodeLayout(CompilationUnit* cUnit)
+void CodeLayout(CompilationUnit* cUnit)
{
- oatDataFlowAnalysisDispatcher(cUnit, layoutBlocks, kAllNodes, false);
+ DataFlowAnalysisDispatcher(cUnit, LayoutBlocks, kAllNodes, false);
}
-void oatDumpCheckStats(CompilationUnit *cUnit)
+void DumpCheckStats(CompilationUnit *cUnit)
{
Checkstats* stats =
- static_cast<Checkstats*>(oatNew(cUnit, sizeof(Checkstats), true, kAllocDFInfo));
+ static_cast<Checkstats*>(NewMem(cUnit, sizeof(Checkstats), true, kAllocDFInfo));
cUnit->checkstats = stats;
- oatDataFlowAnalysisDispatcher(cUnit, countChecks, kAllNodes, false /* isIterative */);
+ DataFlowAnalysisDispatcher(cUnit, CountChecks, kAllNodes, false /* isIterative */);
if (stats->nullChecks > 0) {
float eliminated = static_cast<float>(stats->nullChecksEliminated);
float checks = static_cast<float>(stats->nullChecks);
@@ -2248,37 +2196,37 @@
}
}
-void oatMethodBasicBlockOptimization(CompilationUnit *cUnit)
+void BasicBlockOptimization(CompilationUnit *cUnit)
{
if (!(cUnit->disableOpt & (1 << kBBOpt))) {
- oatInitGrowableList(cUnit, &cUnit->compilerTemps, 6, kListMisc);
+ CompilerInitGrowableList(cUnit, &cUnit->compilerTemps, 6, kListMisc);
DCHECK_EQ(cUnit->numCompilerTemps, 0);
- oatDataFlowAnalysisDispatcher(cUnit, basicBlockOpt,
+ DataFlowAnalysisDispatcher(cUnit, BasicBlockOpt,
kAllNodes, false /* isIterative */);
}
}
-void addLoopHeader(CompilationUnit* cUnit, BasicBlock* header,
- BasicBlock* backEdge)
+static void AddLoopHeader(CompilationUnit* cUnit, BasicBlock* header,
+ BasicBlock* backEdge)
{
GrowableListIterator iter;
- oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
- for (LoopInfo* loop = reinterpret_cast<LoopInfo*>(oatGrowableListIteratorNext(&iter));
- (loop != NULL); loop = reinterpret_cast<LoopInfo*>(oatGrowableListIteratorNext(&iter))) {
+ GrowableListIteratorInit(&cUnit->loopHeaders, &iter);
+ for (LoopInfo* loop = reinterpret_cast<LoopInfo*>(GrowableListIteratorNext(&iter));
+ (loop != NULL); loop = reinterpret_cast<LoopInfo*>(GrowableListIteratorNext(&iter))) {
if (loop->header == header) {
- oatInsertGrowableList(cUnit, &loop->incomingBackEdges,
+ InsertGrowableList(cUnit, &loop->incomingBackEdges,
reinterpret_cast<uintptr_t>(backEdge));
return;
}
}
- LoopInfo* info = static_cast<LoopInfo*>(oatNew(cUnit, sizeof(LoopInfo), true, kAllocDFInfo));
+ LoopInfo* info = static_cast<LoopInfo*>(NewMem(cUnit, sizeof(LoopInfo), true, kAllocDFInfo));
info->header = header;
- oatInitGrowableList(cUnit, &info->incomingBackEdges, 2, kListMisc);
- oatInsertGrowableList(cUnit, &info->incomingBackEdges, reinterpret_cast<uintptr_t>(backEdge));
- oatInsertGrowableList(cUnit, &cUnit->loopHeaders, reinterpret_cast<uintptr_t>(info));
+ CompilerInitGrowableList(cUnit, &info->incomingBackEdges, 2, kListMisc);
+ InsertGrowableList(cUnit, &info->incomingBackEdges, reinterpret_cast<uintptr_t>(backEdge));
+ InsertGrowableList(cUnit, &cUnit->loopHeaders, reinterpret_cast<uintptr_t>(info));
}
-bool findBackEdges(struct CompilationUnit* cUnit, struct BasicBlock* bb)
+static bool FindBackEdges(struct CompilationUnit* cUnit, struct BasicBlock* bb)
{
if ((bb->dataFlowInfo == NULL) || (bb->lastMIRInsn == NULL)) {
return false;
@@ -2287,58 +2235,58 @@
if (Instruction::FlagsOf(opcode) & Instruction::kBranch) {
if (bb->taken && (bb->taken->startOffset <= bb->startOffset)) {
DCHECK(bb->dominators != NULL);
- if (oatIsBitSet(bb->dominators, bb->taken->id)) {
+ if (IsBitSet(bb->dominators, bb->taken->id)) {
if (cUnit->printMe) {
LOG(INFO) << "Loop backedge from 0x"
<< std::hex << bb->lastMIRInsn->offset
<< " to 0x" << std::hex << bb->taken->startOffset;
}
- addLoopHeader(cUnit, bb->taken, bb);
+ AddLoopHeader(cUnit, bb->taken, bb);
}
}
}
return false;
}
-void addBlocksToLoop(CompilationUnit* cUnit, ArenaBitVector* blocks,
- BasicBlock* bb, int headId)
+static void AddBlocksToLoop(CompilationUnit* cUnit, ArenaBitVector* blocks,
+ BasicBlock* bb, int headId)
{
- if (!oatIsBitSet(bb->dominators, headId) ||
- oatIsBitSet(blocks, bb->id)) {
+ if (!IsBitSet(bb->dominators, headId) ||
+ IsBitSet(blocks, bb->id)) {
return;
}
- oatSetBit(cUnit, blocks, bb->id);
+ SetBit(cUnit, blocks, bb->id);
GrowableListIterator iter;
- oatGrowableListIteratorInit(bb->predecessors, &iter);
+ GrowableListIteratorInit(bb->predecessors, &iter);
BasicBlock* predBB;
- for (predBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter)); predBB;
- predBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter))) {
- addBlocksToLoop(cUnit, blocks, predBB, headId);
+ for (predBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter)); predBB;
+ predBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter))) {
+ AddBlocksToLoop(cUnit, blocks, predBB, headId);
}
}
-void oatDumpLoops(CompilationUnit *cUnit)
+static void DumpLoops(CompilationUnit *cUnit)
{
GrowableListIterator iter;
- oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
- for (LoopInfo* loop = reinterpret_cast<LoopInfo*>(oatGrowableListIteratorNext(&iter));
- (loop != NULL); loop = reinterpret_cast<LoopInfo*>(oatGrowableListIteratorNext(&iter))) {
+ GrowableListIteratorInit(&cUnit->loopHeaders, &iter);
+ for (LoopInfo* loop = reinterpret_cast<LoopInfo*>(GrowableListIteratorNext(&iter));
+ (loop != NULL); loop = reinterpret_cast<LoopInfo*>(GrowableListIteratorNext(&iter))) {
LOG(INFO) << "Loop head block id " << loop->header->id
<< ", offset 0x" << std::hex << loop->header->startOffset
<< ", Depth: " << loop->header->nestingDepth;
GrowableListIterator iter;
- oatGrowableListIteratorInit(&loop->incomingBackEdges, &iter);
+ GrowableListIteratorInit(&loop->incomingBackEdges, &iter);
BasicBlock* edgeBB;
- for (edgeBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter)); edgeBB;
- edgeBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter))) {
+ for (edgeBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter)); edgeBB;
+ edgeBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter))) {
LOG(INFO) << " Backedge block id " << edgeBB->id
<< ", offset 0x" << std::hex << edgeBB->startOffset;
ArenaBitVectorIterator bIter;
- oatBitVectorIteratorInit(loop->blocks, &bIter);
- for (int bbId = oatBitVectorIteratorNext(&bIter); bbId != -1;
- bbId = oatBitVectorIteratorNext(&bIter)) {
+ BitVectorIteratorInit(loop->blocks, &bIter);
+ for (int bbId = BitVectorIteratorNext(&bIter); bbId != -1;
+ bbId = BitVectorIteratorNext(&bIter)) {
BasicBlock *bb;
- bb = reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(&cUnit->blockList, bbId));
+ bb = reinterpret_cast<BasicBlock*>(GrowableListGetElement(&cUnit->blockList, bbId));
LOG(INFO) << " (" << bb->id << ", 0x" << std::hex
<< bb->startOffset << ")";
}
@@ -2346,60 +2294,60 @@
}
}
-void oatMethodLoopDetection(CompilationUnit *cUnit)
+void LoopDetection(CompilationUnit *cUnit)
{
if (cUnit->disableOpt & (1 << kPromoteRegs)) {
return;
}
- oatInitGrowableList(cUnit, &cUnit->loopHeaders, 6, kListMisc);
+ CompilerInitGrowableList(cUnit, &cUnit->loopHeaders, 6, kListMisc);
// Find the loop headers
- oatDataFlowAnalysisDispatcher(cUnit, findBackEdges, kAllNodes, false /* isIterative */);
+ DataFlowAnalysisDispatcher(cUnit, FindBackEdges, kAllNodes, false /* isIterative */);
GrowableListIterator iter;
- oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
+ GrowableListIteratorInit(&cUnit->loopHeaders, &iter);
// Add blocks to each header
- for (LoopInfo* loop = reinterpret_cast<LoopInfo*>(oatGrowableListIteratorNext(&iter));
- loop; loop = reinterpret_cast<LoopInfo*>(oatGrowableListIteratorNext(&iter))) {
- loop->blocks = oatAllocBitVector(cUnit, cUnit->numBlocks, true,
+ for (LoopInfo* loop = reinterpret_cast<LoopInfo*>(GrowableListIteratorNext(&iter));
+ loop; loop = reinterpret_cast<LoopInfo*>(GrowableListIteratorNext(&iter))) {
+ loop->blocks = AllocBitVector(cUnit, cUnit->numBlocks, true,
kBitMapMisc);
- oatSetBit(cUnit, loop->blocks, loop->header->id);
+ SetBit(cUnit, loop->blocks, loop->header->id);
GrowableListIterator iter;
- oatGrowableListIteratorInit(&loop->incomingBackEdges, &iter);
+ GrowableListIteratorInit(&loop->incomingBackEdges, &iter);
BasicBlock* edgeBB;
- for (edgeBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter)); edgeBB;
- edgeBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter))) {
- addBlocksToLoop(cUnit, loop->blocks, edgeBB, loop->header->id);
+ for (edgeBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter)); edgeBB;
+ edgeBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter))) {
+ AddBlocksToLoop(cUnit, loop->blocks, edgeBB, loop->header->id);
}
}
// Compute the nesting depth of each header
- oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
- for (LoopInfo* loop = reinterpret_cast<LoopInfo*>(oatGrowableListIteratorNext(&iter));
- loop; loop = reinterpret_cast<LoopInfo*>(oatGrowableListIteratorNext(&iter))) {
+ GrowableListIteratorInit(&cUnit->loopHeaders, &iter);
+ for (LoopInfo* loop = reinterpret_cast<LoopInfo*>(GrowableListIteratorNext(&iter));
+ loop; loop = reinterpret_cast<LoopInfo*>(GrowableListIteratorNext(&iter))) {
GrowableListIterator iter2;
- oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter2);
+ GrowableListIteratorInit(&cUnit->loopHeaders, &iter2);
LoopInfo* loop2;
- for (loop2 = reinterpret_cast<LoopInfo*>(oatGrowableListIteratorNext(&iter2));
- loop2; loop2 = reinterpret_cast<LoopInfo*>(oatGrowableListIteratorNext(&iter2))) {
- if (oatIsBitSet(loop2->blocks, loop->header->id)) {
+ for (loop2 = reinterpret_cast<LoopInfo*>(GrowableListIteratorNext(&iter2));
+ loop2; loop2 = reinterpret_cast<LoopInfo*>(GrowableListIteratorNext(&iter2))) {
+ if (IsBitSet(loop2->blocks, loop->header->id)) {
loop->header->nestingDepth++;
}
}
}
// Assign nesting depth to each block in all loops
- oatGrowableListIteratorInit(&cUnit->loopHeaders, &iter);
- for (LoopInfo* loop = reinterpret_cast<LoopInfo*>(oatGrowableListIteratorNext(&iter));
- (loop != NULL); loop = reinterpret_cast<LoopInfo*>(oatGrowableListIteratorNext(&iter))) {
+ GrowableListIteratorInit(&cUnit->loopHeaders, &iter);
+ for (LoopInfo* loop = reinterpret_cast<LoopInfo*>(GrowableListIteratorNext(&iter));
+ (loop != NULL); loop = reinterpret_cast<LoopInfo*>(GrowableListIteratorNext(&iter))) {
ArenaBitVectorIterator bIter;
- oatBitVectorIteratorInit(loop->blocks, &bIter);
- for (int bbId = oatBitVectorIteratorNext(&bIter); bbId != -1;
- bbId = oatBitVectorIteratorNext(&bIter)) {
+ BitVectorIteratorInit(loop->blocks, &bIter);
+ for (int bbId = BitVectorIteratorNext(&bIter); bbId != -1;
+ bbId = BitVectorIteratorNext(&bIter)) {
BasicBlock *bb;
- bb = reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(&cUnit->blockList, bbId));
+ bb = reinterpret_cast<BasicBlock*>(GrowableListGetElement(&cUnit->blockList, bbId));
bb->nestingDepth = std::max(bb->nestingDepth,
loop->header->nestingDepth);
}
}
if (cUnit->printMe) {
- oatDumpLoops(cUnit);
+ DumpLoops(cUnit);
}
}
@@ -2409,7 +2357,7 @@
* and attempting to do would involve more complexity than it's
* worth.
*/
-bool invokeUsesMethodStar(CompilationUnit* cUnit, MIR* mir)
+static bool InvokeUsesMethodStar(CompilationUnit* cUnit, MIR* mir)
{
InvokeType type;
Instruction::Code opcode = mir->dalvikInsn.opcode;
@@ -2460,7 +2408,7 @@
* counts explicitly used sRegs. A later phase will add implicit
* counts for things such as Method*, null-checked references, etc.
*/
-bool countUses(struct CompilationUnit* cUnit, struct BasicBlock* bb)
+static bool CountUses(struct CompilationUnit* cUnit, struct BasicBlock* bb)
{
if (bb->blockType != kDalvikByteCode) {
return false;
@@ -2482,14 +2430,14 @@
if (dfAttributes & DF_UMS) {
/*
* Some invokes will not use Method* - need to perform test similar
- * to that found in genInvoke() to decide whether to count refs
+ * to that found in GenInvoke() to decide whether to count refs
* for Method* on invoke-class opcodes.
- * TODO: refactor for common test here, save results for genInvoke
+ * TODO: refactor for common test here, save results for GenInvoke
*/
int usesMethodStar = true;
if ((dfAttributes & (DF_FORMAT_35C | DF_FORMAT_3RC)) &&
!(dfAttributes & DF_NON_NULL_RET)) {
- usesMethodStar &= invokeUsesMethodStar(cUnit, mir);
+ usesMethodStar &= InvokeUsesMethodStar(cUnit, mir);
}
if (usesMethodStar) {
cUnit->rawUseCounts.elemList[cUnit->methodSReg]++;
@@ -2501,19 +2449,19 @@
return false;
}
-void oatMethodUseCount(CompilationUnit *cUnit)
+void MethodUseCount(CompilationUnit *cUnit)
{
- oatInitGrowableList(cUnit, &cUnit->useCounts, cUnit->numSSARegs + 32, kListMisc);
- oatInitGrowableList(cUnit, &cUnit->rawUseCounts, cUnit->numSSARegs + 32, kListMisc);
+ CompilerInitGrowableList(cUnit, &cUnit->useCounts, cUnit->numSSARegs + 32, kListMisc);
+ CompilerInitGrowableList(cUnit, &cUnit->rawUseCounts, cUnit->numSSARegs + 32, kListMisc);
// Initialize list
for (int i = 0; i < cUnit->numSSARegs; i++) {
- oatInsertGrowableList(cUnit, &cUnit->useCounts, 0);
- oatInsertGrowableList(cUnit, &cUnit->rawUseCounts, 0);
+ InsertGrowableList(cUnit, &cUnit->useCounts, 0);
+ InsertGrowableList(cUnit, &cUnit->rawUseCounts, 0);
}
if (cUnit->disableOpt & (1 << kPromoteRegs)) {
return;
}
- oatDataFlowAnalysisDispatcher(cUnit, countUses,
+ DataFlowAnalysisDispatcher(cUnit, CountUses,
kAllNodes, false /* isIterative */);
}
diff --git a/src/compiler/dataflow.h b/src/compiler/dataflow.h
index ff15939..35259ed 100644
--- a/src/compiler/dataflow.h
+++ b/src/compiler/dataflow.h
@@ -158,24 +158,23 @@
};
int SRegToVReg(const CompilationUnit* cUnit, int ssaReg);
-char* oatGetDalvikDisassembly(CompilationUnit* cUnit, const DecodedInstruction& insn, const char* note);
-char* oatFullDisassembler(CompilationUnit* cUnit, const MIR* mir);
-char* oatGetSSAString(CompilationUnit* cUnit, SSARepresentation* ssaRep);
-bool oatFindLocalLiveIn(CompilationUnit* cUnit, BasicBlock* bb);
-bool oatDoSSAConversion(CompilationUnit* cUnit, BasicBlock* bb);
-bool oatDoConstantPropagation(CompilationUnit* cUnit, BasicBlock* bb);
-void oatInitializeSSAConversion(CompilationUnit* cUnit);
-bool oatClearVisitedFlag(struct CompilationUnit* cUnit, struct BasicBlock* bb);
-void oatDataFlowAnalysisDispatcher(CompilationUnit* cUnit, bool (*func)(CompilationUnit*, BasicBlock*), DataFlowAnalysisMode dfaMode, bool isIterative);
-MIR* oatFindMoveResult(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir);
-void oatMethodNullCheckElimination(CompilationUnit *cUnit);
-void oatMethodBasicBlockCombine(CompilationUnit* cUnit);
-void oatMethodCodeLayout(CompilationUnit* cUnit);
-void oatDumpCheckStats(CompilationUnit *cUnit);
-void oatMethodBasicBlockOptimization(CompilationUnit *cUnit);
-void oatDumpLoops(CompilationUnit *cUnit);
-void oatMethodLoopDetection(CompilationUnit *cUnit);
-void oatMethodUseCount(CompilationUnit *cUnit);
+char* GetDalvikDisassembly(CompilationUnit* cUnit, const DecodedInstruction& insn, const char* note);
+char* FullDisassembler(CompilationUnit* cUnit, const MIR* mir);
+char* GetSSAString(CompilationUnit* cUnit, SSARepresentation* ssaRep);
+bool FindLocalLiveIn(CompilationUnit* cUnit, BasicBlock* bb);
+bool DoSSAConversion(CompilationUnit* cUnit, BasicBlock* bb);
+bool DoConstantPropogation(CompilationUnit* cUnit, BasicBlock* bb);
+void CompilerInitializeSSAConversion(CompilationUnit* cUnit);
+bool ClearVisitedFlag(struct CompilationUnit* cUnit, struct BasicBlock* bb);
+void DataFlowAnalysisDispatcher(CompilationUnit* cUnit, bool (*func)(CompilationUnit*, BasicBlock*), DataFlowAnalysisMode dfaMode, bool isIterative);
+MIR* FindMoveResult(CompilationUnit* cUnit, BasicBlock* bb, MIR* mir);
+void NullCheckElimination(CompilationUnit *cUnit);
+void BasicBlockCombine(CompilationUnit* cUnit);
+void CodeLayout(CompilationUnit* cUnit);
+void DumpCheckStats(CompilationUnit *cUnit);
+void BasicBlockOptimization(CompilationUnit *cUnit);
+void LoopDetection(CompilationUnit *cUnit);
+void MethodUseCount(CompilationUnit *cUnit);
} // namespace art
diff --git a/src/compiler/frontend.cc b/src/compiler/frontend.cc
index c329e9d..7fb8011 100644
--- a/src/compiler/frontend.cc
+++ b/src/compiler/frontend.cc
@@ -98,7 +98,7 @@
//(1 << kDebugVerifyBitcode) |
0;
-inline bool contentIsInsn(const uint16_t* codePtr) {
+static inline bool ContentIsInsn(const uint16_t* codePtr) {
uint16_t instr = *codePtr;
Instruction::Code opcode = static_cast<Instruction::Code>(instr & 0xff);
@@ -112,11 +112,11 @@
/*
* Parse an instruction, return the length of the instruction
*/
-inline int parseInsn(CompilationUnit* cUnit, const uint16_t* codePtr,
- DecodedInstruction* decoded_instruction, bool printMe)
+static inline int ParseInsn(CompilationUnit* cUnit, const uint16_t* codePtr,
+ DecodedInstruction* decoded_instruction, bool printMe)
{
// Don't parse instruction data
- if (!contentIsInsn(codePtr)) {
+ if (!ContentIsInsn(codePtr)) {
return 0;
}
@@ -124,7 +124,7 @@
*decoded_instruction = DecodedInstruction(instruction);
if (printMe) {
- char* decodedString = oatGetDalvikDisassembly(cUnit, *decoded_instruction,
+ char* decodedString = GetDalvikDisassembly(cUnit, *decoded_instruction,
NULL);
LOG(INFO) << codePtr << ": 0x" << std::hex << static_cast<int>(decoded_instruction->opcode)
<< " " << decodedString;
@@ -134,7 +134,7 @@
#define UNKNOWN_TARGET 0xffffffff
-inline bool isGoto(MIR* insn) {
+static inline bool IsGoto(MIR* insn) {
switch (insn->dalvikInsn.opcode) {
case Instruction::GOTO:
case Instruction::GOTO_16:
@@ -145,24 +145,9 @@
}
}
-/*
- * Identify unconditional branch instructions
- */
-inline bool isUnconditionalBranch(MIR* insn) {
- switch (insn->dalvikInsn.opcode) {
- case Instruction::RETURN_VOID:
- case Instruction::RETURN:
- case Instruction::RETURN_WIDE:
- case Instruction::RETURN_OBJECT:
- return true;
- default:
- return isGoto(insn);
- }
-}
-
/* Split an existing block from the specified code offset into two */
-BasicBlock *splitBlock(CompilationUnit* cUnit, unsigned int codeOffset,
- BasicBlock* origBlock, BasicBlock** immedPredBlockP)
+static BasicBlock *SplitBlock(CompilationUnit* cUnit, unsigned int codeOffset,
+ BasicBlock* origBlock, BasicBlock** immedPredBlockP)
{
MIR* insn = origBlock->firstMIRInsn;
while (insn) {
@@ -172,9 +157,9 @@
if (insn == NULL) {
LOG(FATAL) << "Break split failed";
}
- BasicBlock *bottomBlock = oatNewBB(cUnit, kDalvikByteCode,
+ BasicBlock *bottomBlock = NewMemBB(cUnit, kDalvikByteCode,
cUnit->numBlocks++);
- oatInsertGrowableList(cUnit, &cUnit->blockList, reinterpret_cast<uintptr_t>(bottomBlock));
+ InsertGrowableList(cUnit, &cUnit->blockList, reinterpret_cast<uintptr_t>(bottomBlock));
bottomBlock->startOffset = codeOffset;
bottomBlock->firstMIRInsn = insn;
@@ -187,20 +172,20 @@
bottomBlock->taken = origBlock->taken;
if (bottomBlock->taken) {
origBlock->taken = NULL;
- oatDeleteGrowableList(bottomBlock->taken->predecessors, reinterpret_cast<uintptr_t>(origBlock));
- oatInsertGrowableList(cUnit, bottomBlock->taken->predecessors,
+ DeleteGrowableList(bottomBlock->taken->predecessors, reinterpret_cast<uintptr_t>(origBlock));
+ InsertGrowableList(cUnit, bottomBlock->taken->predecessors,
reinterpret_cast<uintptr_t>(bottomBlock));
}
/* Handle the fallthrough path */
bottomBlock->fallThrough = origBlock->fallThrough;
origBlock->fallThrough = bottomBlock;
- oatInsertGrowableList(cUnit, bottomBlock->predecessors,
+ InsertGrowableList(cUnit, bottomBlock->predecessors,
reinterpret_cast<uintptr_t>(origBlock));
if (bottomBlock->fallThrough) {
- oatDeleteGrowableList(bottomBlock->fallThrough->predecessors,
+ DeleteGrowableList(bottomBlock->fallThrough->predecessors,
reinterpret_cast<uintptr_t>(origBlock));
- oatInsertGrowableList(cUnit, bottomBlock->fallThrough->predecessors,
+ InsertGrowableList(cUnit, bottomBlock->fallThrough->predecessors,
reinterpret_cast<uintptr_t>(bottomBlock));
}
@@ -210,15 +195,15 @@
origBlock->successorBlockList.blockListType = kNotUsed;
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&bottomBlock->successorBlockList.blocks,
+ GrowableListIteratorInit(&bottomBlock->successorBlockList.blocks,
&iterator);
while (true) {
SuccessorBlockInfo *successorBlockInfo =
- reinterpret_cast<SuccessorBlockInfo*>(oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<SuccessorBlockInfo*>(GrowableListIteratorNext(&iterator));
if (successorBlockInfo == NULL) break;
BasicBlock *bb = successorBlockInfo->block;
- oatDeleteGrowableList(bb->predecessors, reinterpret_cast<uintptr_t>(origBlock));
- oatInsertGrowableList(cUnit, bb->predecessors, reinterpret_cast<uintptr_t>(bottomBlock));
+ DeleteGrowableList(bb->predecessors, reinterpret_cast<uintptr_t>(origBlock));
+ InsertGrowableList(cUnit, bb->predecessors, reinterpret_cast<uintptr_t>(bottomBlock));
}
}
@@ -245,7 +230,7 @@
* (by the caller)
* Utilizes a map for fast lookup of the typical cases.
*/
-BasicBlock *findBlock(CompilationUnit* cUnit, unsigned int codeOffset,
+BasicBlock *FindBlock(CompilationUnit* cUnit, unsigned int codeOffset,
bool split, bool create, BasicBlock** immedPredBlockP)
{
GrowableList* blockList = &cUnit->blockList;
@@ -267,7 +252,7 @@
/* Check if a branch jumps into the middle of an existing block */
if ((codeOffset > bb->startOffset) && (bb->lastMIRInsn != NULL) &&
(codeOffset <= bb->lastMIRInsn->offset)) {
- BasicBlock *newBB = splitBlock(cUnit, codeOffset, bb,
+ BasicBlock *newBB = SplitBlock(cUnit, codeOffset, bb,
bb == *immedPredBlockP ?
immedPredBlockP : NULL);
return newBB;
@@ -276,21 +261,21 @@
}
/* Create a new one */
- bb = oatNewBB(cUnit, kDalvikByteCode, cUnit->numBlocks++);
- oatInsertGrowableList(cUnit, &cUnit->blockList, reinterpret_cast<uintptr_t>(bb));
+ bb = NewMemBB(cUnit, kDalvikByteCode, cUnit->numBlocks++);
+ InsertGrowableList(cUnit, &cUnit->blockList, reinterpret_cast<uintptr_t>(bb));
bb->startOffset = codeOffset;
cUnit->blockMap.Put(bb->startOffset, bb);
return bb;
}
/* Find existing block */
-BasicBlock* oatFindBlock(CompilationUnit* cUnit, unsigned int codeOffset)
+BasicBlock* FindBlock(CompilationUnit* cUnit, unsigned int codeOffset)
{
- return findBlock(cUnit, codeOffset, false, false, NULL);
+ return FindBlock(cUnit, codeOffset, false, false, NULL);
}
/* Turn method name into a legal Linux file name */
-void oatReplaceSpecialChars(std::string& str)
+void ReplaceSpecialChars(std::string& str)
{
static const struct { const char before; const char after; } match[] =
{{'/','-'}, {';','#'}, {' ','#'}, {'$','+'},
@@ -301,11 +286,11 @@
}
/* Dump the CFG into a DOT graph */
-void oatDumpCFG(CompilationUnit* cUnit, const char* dirPrefix)
+void DumpCFG(CompilationUnit* cUnit, const char* dirPrefix)
{
FILE* file;
std::string fname(PrettyMethod(cUnit->method_idx, *cUnit->dex_file));
- oatReplaceSpecialChars(fname);
+ ReplaceSpecialChars(fname);
fname = StringPrintf("%s%s%x.dot", dirPrefix, fname.c_str(),
cUnit->entryBlock->fallThrough->startOffset);
file = fopen(fname.c_str(), "w");
@@ -322,7 +307,7 @@
for (idx = 0; idx < numReachableBlocks; idx++) {
int blockIdx = cUnit->dfsOrder.elemList[idx];
- BasicBlock *bb = reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, blockIdx));
+ BasicBlock *bb = reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, blockIdx));
if (bb == NULL) break;
if (bb->blockType == kDead) continue;
if (bb->blockType == kEntryBlock) {
@@ -337,7 +322,7 @@
bb->firstMIRInsn ? " | " : " ");
for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
fprintf(file, " {%04x %s\\l}%s\\\n", mir->offset,
- mir->ssaRep ? oatFullDisassembler(cUnit, mir) :
+ mir->ssaRep ? FullDisassembler(cUnit, mir) :
Instruction::Name(mir->dalvikInsn.opcode),
mir->next ? " | " : " ");
}
@@ -345,21 +330,21 @@
} else if (bb->blockType == kExceptionHandling) {
char blockName[BLOCK_NAME_LEN];
- oatGetBlockName(bb, blockName);
+ GetBlockName(bb, blockName);
fprintf(file, " %s [shape=invhouse];\n", blockName);
}
char blockName1[BLOCK_NAME_LEN], blockName2[BLOCK_NAME_LEN];
if (bb->taken) {
- oatGetBlockName(bb, blockName1);
- oatGetBlockName(bb->taken, blockName2);
+ GetBlockName(bb, blockName1);
+ GetBlockName(bb->taken, blockName2);
fprintf(file, " %s:s -> %s:n [style=dotted]\n",
blockName1, blockName2);
}
if (bb->fallThrough) {
- oatGetBlockName(bb, blockName1);
- oatGetBlockName(bb->fallThrough, blockName2);
+ GetBlockName(bb, blockName1);
+ GetBlockName(bb->fallThrough, blockName2);
fprintf(file, " %s:s -> %s:n\n", blockName1, blockName2);
}
@@ -369,10 +354,10 @@
(bb->successorBlockList.blockListType == kCatch) ?
"Mrecord" : "record");
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
+ GrowableListIteratorInit(&bb->successorBlockList.blocks,
&iterator);
SuccessorBlockInfo *successorBlockInfo =
- reinterpret_cast<SuccessorBlockInfo*>(oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<SuccessorBlockInfo*>(GrowableListIteratorNext(&iterator));
int succId = 0;
while (true) {
@@ -380,7 +365,7 @@
BasicBlock *destBlock = successorBlockInfo->block;
SuccessorBlockInfo *nextSuccessorBlockInfo =
- reinterpret_cast<SuccessorBlockInfo*>(oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<SuccessorBlockInfo*>(GrowableListIteratorNext(&iterator));
fprintf(file, " {<f%d> %04x: %04x\\l}%s\\\n",
succId++,
@@ -392,25 +377,25 @@
}
fprintf(file, " }\"];\n\n");
- oatGetBlockName(bb, blockName1);
+ GetBlockName(bb, blockName1);
fprintf(file, " %s:s -> succ%04x_%d:n [style=dashed]\n",
blockName1, bb->startOffset, bb->id);
if (bb->successorBlockList.blockListType == kPackedSwitch ||
bb->successorBlockList.blockListType == kSparseSwitch) {
- oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
+ GrowableListIteratorInit(&bb->successorBlockList.blocks,
&iterator);
succId = 0;
while (true) {
SuccessorBlockInfo *successorBlockInfo =
- reinterpret_cast<SuccessorBlockInfo*>( oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<SuccessorBlockInfo*>( GrowableListIteratorNext(&iterator));
if (successorBlockInfo == NULL) break;
BasicBlock *destBlock = successorBlockInfo->block;
- oatGetBlockName(destBlock, blockName2);
+ GetBlockName(destBlock, blockName2);
fprintf(file, " succ%04x_%d:f%d:e -> %s:n\n", bb->startOffset,
bb->id, succId++, blockName2);
}
@@ -419,11 +404,11 @@
fprintf(file, "\n");
/* Display the dominator tree */
- oatGetBlockName(bb, blockName1);
+ GetBlockName(bb, blockName1);
fprintf(file, " cfg%s [label=\"%s\", shape=none];\n",
blockName1, blockName1);
if (bb->iDom) {
- oatGetBlockName(bb->iDom, blockName2);
+ GetBlockName(bb->iDom, blockName2);
fprintf(file, " cfg%s:s -> cfg%s:n\n\n", blockName2, blockName1);
}
}
@@ -432,13 +417,13 @@
}
/* Verify if all the successor is connected with all the claimed predecessors */
-bool verifyPredInfo(CompilationUnit* cUnit, BasicBlock* bb)
+static bool VerifyPredInfo(CompilationUnit* cUnit, BasicBlock* bb)
{
GrowableListIterator iter;
- oatGrowableListIteratorInit(bb->predecessors, &iter);
+ GrowableListIteratorInit(bb->predecessors, &iter);
while (true) {
- BasicBlock *predBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter));
+ BasicBlock *predBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter));
if (!predBB) break;
bool found = false;
if (predBB->taken == bb) {
@@ -447,11 +432,11 @@
found = true;
} else if (predBB->successorBlockList.blockListType != kNotUsed) {
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&predBB->successorBlockList.blocks,
+ GrowableListIteratorInit(&predBB->successorBlockList.blocks,
&iterator);
while (true) {
SuccessorBlockInfo *successorBlockInfo =
- reinterpret_cast<SuccessorBlockInfo*>(oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<SuccessorBlockInfo*>(GrowableListIteratorNext(&iterator));
if (successorBlockInfo == NULL) break;
BasicBlock *succBB = successorBlockInfo->block;
if (succBB == bb) {
@@ -462,9 +447,9 @@
}
if (found == false) {
char blockName1[BLOCK_NAME_LEN], blockName2[BLOCK_NAME_LEN];
- oatGetBlockName(bb, blockName1);
- oatGetBlockName(predBB, blockName2);
- oatDumpCFG(cUnit, "/sdcard/cfg/");
+ GetBlockName(bb, blockName1);
+ GetBlockName(predBB, blockName2);
+ DumpCFG(cUnit, "/sdcard/cfg/");
LOG(FATAL) << "Successor " << blockName1 << "not found from "
<< blockName2;
}
@@ -473,7 +458,7 @@
}
/* Identify code range in try blocks and set up the empty catch blocks */
-void processTryCatchBlocks(CompilationUnit* cUnit)
+static void ProcessTryCatchBlocks(CompilationUnit* cUnit)
{
const DexFile::CodeItem* code_item = cUnit->code_item;
int triesSize = code_item->tries_size_;
@@ -491,7 +476,7 @@
int startOffset = pTry->start_addr_;
int endOffset = startOffset + pTry->insn_count_;
for (offset = startOffset; offset < endOffset; offset++) {
- oatSetBit(cUnit, tryBlockAddr, offset);
+ SetBit(cUnit, tryBlockAddr, offset);
}
}
@@ -502,7 +487,7 @@
CatchHandlerIterator iterator(handlers_ptr);
for (; iterator.HasNext(); iterator.Next()) {
uint32_t address = iterator.GetHandlerAddress();
- findBlock(cUnit, address, false /* split */, true /*create*/,
+ FindBlock(cUnit, address, false /* split */, true /*create*/,
/* immedPredBlockP */ NULL);
}
handlers_ptr = iterator.EndDataPointer();
@@ -510,9 +495,9 @@
}
/* Process instructions with the kBranch flag */
-BasicBlock* processCanBranch(CompilationUnit* cUnit, BasicBlock* curBlock,
- MIR* insn, int curOffset, int width, int flags,
- const uint16_t* codePtr, const uint16_t* codeEnd)
+static BasicBlock* ProcessCanBranch(CompilationUnit* cUnit, BasicBlock* curBlock,
+ MIR* insn, int curOffset, int width, int flags,
+ const uint16_t* codePtr, const uint16_t* codeEnd)
{
int target = curOffset;
switch (insn->dalvikInsn.opcode) {
@@ -542,7 +527,7 @@
default:
LOG(FATAL) << "Unexpected opcode(" << insn->dalvikInsn.opcode << ") with kBranch set";
}
- BasicBlock *takenBlock = findBlock(cUnit, target,
+ BasicBlock *takenBlock = FindBlock(cUnit, target,
/* split */
true,
/* create */
@@ -550,11 +535,11 @@
/* immedPredBlockP */
&curBlock);
curBlock->taken = takenBlock;
- oatInsertGrowableList(cUnit, takenBlock->predecessors, reinterpret_cast<uintptr_t>(curBlock));
+ InsertGrowableList(cUnit, takenBlock->predecessors, reinterpret_cast<uintptr_t>(curBlock));
/* Always terminate the current block for conditional branches */
if (flags & Instruction::kContinue) {
- BasicBlock *fallthroughBlock = findBlock(cUnit,
+ BasicBlock *fallthroughBlock = FindBlock(cUnit,
curOffset + width,
/*
* If the method is processed
@@ -574,12 +559,12 @@
/* immedPredBlockP */
&curBlock);
curBlock->fallThrough = fallthroughBlock;
- oatInsertGrowableList(cUnit, fallthroughBlock->predecessors,
+ InsertGrowableList(cUnit, fallthroughBlock->predecessors,
reinterpret_cast<uintptr_t>(curBlock));
} else if (codePtr < codeEnd) {
/* Create a fallthrough block for real instructions (incl. NOP) */
- if (contentIsInsn(codePtr)) {
- findBlock(cUnit, curOffset + width,
+ if (ContentIsInsn(codePtr)) {
+ FindBlock(cUnit, curOffset + width,
/* split */
false,
/* create */
@@ -592,8 +577,8 @@
}
/* Process instructions with the kSwitch flag */
-void processCanSwitch(CompilationUnit* cUnit, BasicBlock* curBlock,
- MIR* insn, int curOffset, int width, int flags)
+static void ProcessCanSwitch(CompilationUnit* cUnit, BasicBlock* curBlock,
+ MIR* insn, int curOffset, int width, int flags)
{
const uint16_t* switchData =
reinterpret_cast<const uint16_t*>(cUnit->insns + curOffset + insn->dalvikInsn.vB);
@@ -644,11 +629,11 @@
curBlock->successorBlockList.blockListType =
(insn->dalvikInsn.opcode == Instruction::PACKED_SWITCH) ?
kPackedSwitch : kSparseSwitch;
- oatInitGrowableList(cUnit, &curBlock->successorBlockList.blocks, size,
+ CompilerInitGrowableList(cUnit, &curBlock->successorBlockList.blocks, size,
kListSuccessorBlocks);
for (i = 0; i < size; i++) {
- BasicBlock *caseBlock = findBlock(cUnit, curOffset + targetTable[i],
+ BasicBlock *caseBlock = FindBlock(cUnit, curOffset + targetTable[i],
/* split */
true,
/* create */
@@ -656,20 +641,20 @@
/* immedPredBlockP */
&curBlock);
SuccessorBlockInfo *successorBlockInfo =
- static_cast<SuccessorBlockInfo*>(oatNew(cUnit, sizeof(SuccessorBlockInfo),
+ static_cast<SuccessorBlockInfo*>(NewMem(cUnit, sizeof(SuccessorBlockInfo),
false, kAllocSuccessor));
successorBlockInfo->block = caseBlock;
successorBlockInfo->key =
(insn->dalvikInsn.opcode == Instruction::PACKED_SWITCH) ?
firstKey + i : keyTable[i];
- oatInsertGrowableList(cUnit, &curBlock->successorBlockList.blocks,
+ InsertGrowableList(cUnit, &curBlock->successorBlockList.blocks,
reinterpret_cast<uintptr_t>(successorBlockInfo));
- oatInsertGrowableList(cUnit, caseBlock->predecessors,
+ InsertGrowableList(cUnit, caseBlock->predecessors,
reinterpret_cast<uintptr_t>(curBlock));
}
/* Fall-through case */
- BasicBlock* fallthroughBlock = findBlock(cUnit,
+ BasicBlock* fallthroughBlock = FindBlock(cUnit,
curOffset + width,
/* split */
false,
@@ -678,18 +663,18 @@
/* immedPredBlockP */
NULL);
curBlock->fallThrough = fallthroughBlock;
- oatInsertGrowableList(cUnit, fallthroughBlock->predecessors,
+ InsertGrowableList(cUnit, fallthroughBlock->predecessors,
reinterpret_cast<uintptr_t>(curBlock));
}
/* Process instructions with the kThrow flag */
-BasicBlock* processCanThrow(CompilationUnit* cUnit, BasicBlock* curBlock,
- MIR* insn, int curOffset, int width, int flags,
- ArenaBitVector* tryBlockAddr, const uint16_t* codePtr,
- const uint16_t* codeEnd)
+static BasicBlock* ProcessCanThrow(CompilationUnit* cUnit, BasicBlock* curBlock,
+ MIR* insn, int curOffset, int width, int flags,
+ ArenaBitVector* tryBlockAddr, const uint16_t* codePtr,
+ const uint16_t* codeEnd)
{
const DexFile::CodeItem* code_item = cUnit->code_item;
- bool inTryBlock = oatIsBitSet(tryBlockAddr, curOffset);
+ bool inTryBlock = IsBitSet(tryBlockAddr, curOffset);
/* In try block */
if (inTryBlock) {
@@ -702,39 +687,39 @@
}
curBlock->successorBlockList.blockListType = kCatch;
- oatInitGrowableList(cUnit, &curBlock->successorBlockList.blocks, 2,
+ CompilerInitGrowableList(cUnit, &curBlock->successorBlockList.blocks, 2,
kListSuccessorBlocks);
for (;iterator.HasNext(); iterator.Next()) {
- BasicBlock *catchBlock = findBlock(cUnit, iterator.GetHandlerAddress(),
+ BasicBlock *catchBlock = FindBlock(cUnit, iterator.GetHandlerAddress(),
false /* split*/,
false /* creat */,
NULL /* immedPredBlockP */);
catchBlock->catchEntry = true;
cUnit->catches.insert(catchBlock->startOffset);
SuccessorBlockInfo *successorBlockInfo = reinterpret_cast<SuccessorBlockInfo*>
- (oatNew(cUnit, sizeof(SuccessorBlockInfo), false, kAllocSuccessor));
+ (NewMem(cUnit, sizeof(SuccessorBlockInfo), false, kAllocSuccessor));
successorBlockInfo->block = catchBlock;
successorBlockInfo->key = iterator.GetHandlerTypeIndex();
- oatInsertGrowableList(cUnit, &curBlock->successorBlockList.blocks,
+ InsertGrowableList(cUnit, &curBlock->successorBlockList.blocks,
reinterpret_cast<uintptr_t>(successorBlockInfo));
- oatInsertGrowableList(cUnit, catchBlock->predecessors,
+ InsertGrowableList(cUnit, catchBlock->predecessors,
reinterpret_cast<uintptr_t>(curBlock));
}
} else {
- BasicBlock *ehBlock = oatNewBB(cUnit, kExceptionHandling,
+ BasicBlock *ehBlock = NewMemBB(cUnit, kExceptionHandling,
cUnit->numBlocks++);
curBlock->taken = ehBlock;
- oatInsertGrowableList(cUnit, &cUnit->blockList, reinterpret_cast<uintptr_t>(ehBlock));
+ InsertGrowableList(cUnit, &cUnit->blockList, reinterpret_cast<uintptr_t>(ehBlock));
ehBlock->startOffset = curOffset;
- oatInsertGrowableList(cUnit, ehBlock->predecessors, reinterpret_cast<uintptr_t>(curBlock));
+ InsertGrowableList(cUnit, ehBlock->predecessors, reinterpret_cast<uintptr_t>(curBlock));
}
if (insn->dalvikInsn.opcode == Instruction::THROW){
curBlock->explicitThrow = true;
- if ((codePtr < codeEnd) && contentIsInsn(codePtr)) {
+ if ((codePtr < codeEnd) && ContentIsInsn(codePtr)) {
// Force creation of new block following THROW via side-effect
- findBlock(cUnit, curOffset + width, /* split */ false,
+ FindBlock(cUnit, curOffset + width, /* split */ false,
/* create */ true, /* immedPredBlockP */ NULL);
}
if (!inTryBlock) {
@@ -757,39 +742,38 @@
* not automatically terminated after the work portion, and may
* contain following instructions.
*/
- BasicBlock *newBlock = oatNewBB(cUnit, kDalvikByteCode, cUnit->numBlocks++);
- oatInsertGrowableList(cUnit, &cUnit->blockList, reinterpret_cast<uintptr_t>(newBlock));
+ BasicBlock *newBlock = NewMemBB(cUnit, kDalvikByteCode, cUnit->numBlocks++);
+ InsertGrowableList(cUnit, &cUnit->blockList, reinterpret_cast<uintptr_t>(newBlock));
newBlock->startOffset = insn->offset;
curBlock->fallThrough = newBlock;
- oatInsertGrowableList(cUnit, newBlock->predecessors, reinterpret_cast<uintptr_t>(curBlock));
- MIR* newInsn = static_cast<MIR*>(oatNew(cUnit, sizeof(MIR), true, kAllocMIR));
+ InsertGrowableList(cUnit, newBlock->predecessors, reinterpret_cast<uintptr_t>(curBlock));
+ MIR* newInsn = static_cast<MIR*>(NewMem(cUnit, sizeof(MIR), true, kAllocMIR));
*newInsn = *insn;
insn->dalvikInsn.opcode =
static_cast<Instruction::Code>(kMirOpCheck);
// Associate the two halves
insn->meta.throwInsn = newInsn;
newInsn->meta.throwInsn = insn;
- oatAppendMIR(newBlock, newInsn);
+ AppendMIR(newBlock, newInsn);
return newBlock;
}
-void oatInit(CompilationUnit* cUnit, const Compiler& compiler) {
- if (!oatArchInit()) {
+void CompilerInit(CompilationUnit* cUnit, const Compiler& compiler) {
+ if (!ArchInit()) {
LOG(FATAL) << "Failed to initialize oat";
}
- if (!oatHeapInit(cUnit)) {
+ if (!HeapInit(cUnit)) {
LOG(FATAL) << "Failed to initialize oat heap";
}
}
-CompiledMethod* compileMethod(Compiler& compiler,
- const CompilerBackend compilerBackend,
- const DexFile::CodeItem* code_item,
- uint32_t access_flags, InvokeType invoke_type,
- uint32_t method_idx, jobject class_loader,
- const DexFile& dex_file,
- LLVMInfo* llvm_info
- )
+static CompiledMethod* CompileMethod(Compiler& compiler,
+ const CompilerBackend compilerBackend,
+ const DexFile::CodeItem* code_item,
+ uint32_t access_flags, InvokeType invoke_type,
+ uint32_t method_idx, jobject class_loader,
+ const DexFile& dex_file,
+ LLVMInfo* llvm_info)
{
VLOG(compiler) << "Compiling " << PrettyMethod(method_idx, dex_file) << "...";
@@ -801,7 +785,7 @@
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
UniquePtr<CompilationUnit> cUnit(new CompilationUnit);
- oatInit(cUnit.get(), compiler);
+ CompilerInit(cUnit.get(), compiler);
cUnit->compiler = &compiler;
cUnit->class_linker = class_linker;
@@ -890,61 +874,61 @@
/* Gathering opcode stats? */
if (kCompilerDebugFlags & (1 << kDebugCountOpcodes)) {
cUnit->opcodeCount =
- static_cast<int*>(oatNew(cUnit.get(), kNumPackedOpcodes * sizeof(int), true, kAllocMisc));
+ static_cast<int*>(NewMem(cUnit.get(), kNumPackedOpcodes * sizeof(int), true, kAllocMisc));
}
/* Assume non-throwing leaf */
cUnit->attrs = (METHOD_IS_LEAF | METHOD_IS_THROW_FREE);
/* Initialize the block list, estimate size based on insnsSize */
- oatInitGrowableList(cUnit.get(), &cUnit->blockList, cUnit->insnsSize,
+ CompilerInitGrowableList(cUnit.get(), &cUnit->blockList, cUnit->insnsSize,
kListBlockList);
/* Initialize the switchTables list */
- oatInitGrowableList(cUnit.get(), &cUnit->switchTables, 4,
+ CompilerInitGrowableList(cUnit.get(), &cUnit->switchTables, 4,
kListSwitchTables);
/* Intialize the fillArrayData list */
- oatInitGrowableList(cUnit.get(), &cUnit->fillArrayData, 4,
+ CompilerInitGrowableList(cUnit.get(), &cUnit->fillArrayData, 4,
kListFillArrayData);
/* Intialize the throwLaunchpads list, estimate size based on insnsSize */
- oatInitGrowableList(cUnit.get(), &cUnit->throwLaunchpads, cUnit->insnsSize,
+ CompilerInitGrowableList(cUnit.get(), &cUnit->throwLaunchpads, cUnit->insnsSize,
kListThrowLaunchPads);
/* Intialize the instrinsicLaunchpads list */
- oatInitGrowableList(cUnit.get(), &cUnit->intrinsicLaunchpads, 4,
+ CompilerInitGrowableList(cUnit.get(), &cUnit->intrinsicLaunchpads, 4,
kListMisc);
/* Intialize the suspendLaunchpads list */
- oatInitGrowableList(cUnit.get(), &cUnit->suspendLaunchpads, 2048,
+ CompilerInitGrowableList(cUnit.get(), &cUnit->suspendLaunchpads, 2048,
kListSuspendLaunchPads);
/* Allocate the bit-vector to track the beginning of basic blocks */
- ArenaBitVector *tryBlockAddr = oatAllocBitVector(cUnit.get(),
+ ArenaBitVector *tryBlockAddr = AllocBitVector(cUnit.get(),
cUnit->insnsSize,
true /* expandable */);
cUnit->tryBlockAddr = tryBlockAddr;
/* Create the default entry and exit blocks and enter them to the list */
- BasicBlock *entryBlock = oatNewBB(cUnit.get(), kEntryBlock, numBlocks++);
- BasicBlock *exitBlock = oatNewBB(cUnit.get(), kExitBlock, numBlocks++);
+ BasicBlock *entryBlock = NewMemBB(cUnit.get(), kEntryBlock, numBlocks++);
+ BasicBlock *exitBlock = NewMemBB(cUnit.get(), kExitBlock, numBlocks++);
cUnit->entryBlock = entryBlock;
cUnit->exitBlock = exitBlock;
- oatInsertGrowableList(cUnit.get(), &cUnit->blockList, reinterpret_cast<uintptr_t>(entryBlock));
- oatInsertGrowableList(cUnit.get(), &cUnit->blockList, reinterpret_cast<uintptr_t>(exitBlock));
+ InsertGrowableList(cUnit.get(), &cUnit->blockList, reinterpret_cast<uintptr_t>(entryBlock));
+ InsertGrowableList(cUnit.get(), &cUnit->blockList, reinterpret_cast<uintptr_t>(exitBlock));
/* Current block to record parsed instructions */
- BasicBlock *curBlock = oatNewBB(cUnit.get(), kDalvikByteCode, numBlocks++);
+ BasicBlock *curBlock = NewMemBB(cUnit.get(), kDalvikByteCode, numBlocks++);
curBlock->startOffset = 0;
- oatInsertGrowableList(cUnit.get(), &cUnit->blockList, reinterpret_cast<uintptr_t>(curBlock));
+ InsertGrowableList(cUnit.get(), &cUnit->blockList, reinterpret_cast<uintptr_t>(curBlock));
/* Add first block to the fast lookup cache */
cUnit->blockMap.Put(curBlock->startOffset, curBlock);
entryBlock->fallThrough = curBlock;
- oatInsertGrowableList(cUnit.get(), curBlock->predecessors,
+ InsertGrowableList(cUnit.get(), curBlock->predecessors,
reinterpret_cast<uintptr_t>(entryBlock));
/*
@@ -954,21 +938,21 @@
cUnit->numBlocks = numBlocks;
/* Identify code range in try blocks and set up the empty catch blocks */
- processTryCatchBlocks(cUnit.get());
+ ProcessTryCatchBlocks(cUnit.get());
/* Set up for simple method detection */
int numPatterns = sizeof(specialPatterns)/sizeof(specialPatterns[0]);
bool livePattern = (numPatterns > 0) && !(cUnit->disableOpt & (1 << kMatch));
bool* deadPattern =
- static_cast<bool*>(oatNew(cUnit.get(), sizeof(bool) * numPatterns, true, kAllocMisc));
+ static_cast<bool*>(NewMem(cUnit.get(), sizeof(bool) * numPatterns, true, kAllocMisc));
SpecialCaseHandler specialCase = kNoHandler;
int patternPos = 0;
/* Parse all instructions and put them into containing basic blocks */
while (codePtr < codeEnd) {
- MIR *insn = static_cast<MIR *>(oatNew(cUnit.get(), sizeof(MIR), true, kAllocMIR));
+ MIR *insn = static_cast<MIR *>(NewMem(cUnit.get(), sizeof(MIR), true, kAllocMIR));
insn->offset = curOffset;
- int width = parseInsn(cUnit.get(), codePtr, &insn->dalvikInsn, false);
+ int width = ParseInsn(cUnit.get(), codePtr, &insn->dalvikInsn, false);
insn->width = width;
Instruction::Code opcode = insn->dalvikInsn.opcode;
if (cUnit->opcodeCount != NULL) {
@@ -996,7 +980,7 @@
patternPos++;
}
- oatAppendMIR(curBlock, insn);
+ AppendMIR(curBlock, insn);
codePtr += width;
int flags = Instruction::FlagsOf(insn->dalvikInsn.opcode);
@@ -1008,11 +992,11 @@
}
if (flags & Instruction::kBranch) {
- curBlock = processCanBranch(cUnit.get(), curBlock, insn, curOffset,
+ curBlock = ProcessCanBranch(cUnit.get(), curBlock, insn, curOffset,
width, flags, codePtr, codeEnd);
} else if (flags & Instruction::kReturn) {
curBlock->fallThrough = exitBlock;
- oatInsertGrowableList(cUnit.get(), exitBlock->predecessors,
+ InsertGrowableList(cUnit.get(), exitBlock->predecessors,
reinterpret_cast<uintptr_t>(curBlock));
/*
* Terminate the current block if there are instructions
@@ -1023,8 +1007,8 @@
* Create a fallthrough block for real instructions
* (incl. NOP).
*/
- if (contentIsInsn(codePtr)) {
- findBlock(cUnit.get(), curOffset + width,
+ if (ContentIsInsn(codePtr)) {
+ FindBlock(cUnit.get(), curOffset + width,
/* split */
false,
/* create */
@@ -1034,13 +1018,13 @@
}
}
} else if (flags & Instruction::kThrow) {
- curBlock = processCanThrow(cUnit.get(), curBlock, insn, curOffset,
+ curBlock = ProcessCanThrow(cUnit.get(), curBlock, insn, curOffset,
width, flags, tryBlockAddr, codePtr, codeEnd);
} else if (flags & Instruction::kSwitch) {
- processCanSwitch(cUnit.get(), curBlock, insn, curOffset, width, flags);
+ ProcessCanSwitch(cUnit.get(), curBlock, insn, curOffset, width, flags);
}
curOffset += width;
- BasicBlock *nextBlock = findBlock(cUnit.get(), curOffset,
+ BasicBlock *nextBlock = FindBlock(cUnit.get(), curOffset,
/* split */
false,
/* create */
@@ -1060,7 +1044,7 @@
if ((curBlock->fallThrough == NULL) && (flags & Instruction::kContinue)) {
curBlock->fallThrough = nextBlock;
- oatInsertGrowableList(cUnit.get(), nextBlock->predecessors,
+ InsertGrowableList(cUnit.get(), nextBlock->predecessors,
reinterpret_cast<uintptr_t>(curBlock));
}
curBlock = nextBlock;
@@ -1089,67 +1073,67 @@
}
if (cUnit->printMe) {
- oatDumpCompilationUnit(cUnit.get());
+ DumpCompilationUnit(cUnit.get());
}
/* Do a code layout pass */
- oatMethodCodeLayout(cUnit.get());
+ CodeLayout(cUnit.get());
if (cUnit->enableDebug & (1 << kDebugVerifyDataflow)) {
/* Verify if all blocks are connected as claimed */
- oatDataFlowAnalysisDispatcher(cUnit.get(), verifyPredInfo, kAllNodes,
+ DataFlowAnalysisDispatcher(cUnit.get(), VerifyPredInfo, kAllNodes,
false /* isIterative */);
}
/* Perform SSA transformation for the whole method */
- oatMethodSSATransformation(cUnit.get());
+ SSATransformation(cUnit.get());
/* Do constant propagation */
// TODO: Probably need to make these expandable to support new ssa names
// introducted during MIR optimization passes
- cUnit->isConstantV = oatAllocBitVector(cUnit.get(), cUnit->numSSARegs,
+ cUnit->isConstantV = AllocBitVector(cUnit.get(), cUnit->numSSARegs,
false /* not expandable */);
cUnit->constantValues =
- static_cast<int*>(oatNew(cUnit.get(), sizeof(int) * cUnit->numSSARegs, true, kAllocDFInfo));
- oatDataFlowAnalysisDispatcher(cUnit.get(), oatDoConstantPropagation,
+ static_cast<int*>(NewMem(cUnit.get(), sizeof(int) * cUnit->numSSARegs, true, kAllocDFInfo));
+ DataFlowAnalysisDispatcher(cUnit.get(), DoConstantPropogation,
kAllNodes,
false /* isIterative */);
/* Detect loops */
- oatMethodLoopDetection(cUnit.get());
+ LoopDetection(cUnit.get());
/* Count uses */
- oatMethodUseCount(cUnit.get());
+ MethodUseCount(cUnit.get());
/* Perform null check elimination */
- oatMethodNullCheckElimination(cUnit.get());
+ NullCheckElimination(cUnit.get());
/* Combine basic blocks where possible */
- oatMethodBasicBlockCombine(cUnit.get());
+ BasicBlockCombine(cUnit.get());
/* Do some basic block optimizations */
- oatMethodBasicBlockOptimization(cUnit.get());
+ BasicBlockOptimization(cUnit.get());
if (cUnit->enableDebug & (1 << kDebugDumpCheckStats)) {
- oatDumpCheckStats(cUnit.get());
+ DumpCheckStats(cUnit.get());
}
- oatInitializeRegAlloc(cUnit.get()); // Needs to happen after SSA naming
+ CompilerInitializeRegAlloc(cUnit.get()); // Needs to happen after SSA naming
/* Allocate Registers using simple local allocation scheme */
- oatSimpleRegAlloc(cUnit.get());
+ SimpleRegAlloc(cUnit.get());
/* Go the LLVM path? */
if (cUnit->genBitcode) {
// MIR->Bitcode
- oatMethodMIR2Bitcode(cUnit.get());
+ MethodMIR2Bitcode(cUnit.get());
if (compilerBackend == kPortable) {
// all done
- oatArenaReset(cUnit.get());
+ ArenaReset(cUnit.get());
return NULL;
}
// Bitcode->LIR
- oatMethodBitcode2LIR(cUnit.get());
+ MethodBitcode2LIR(cUnit.get());
} else {
if (specialCase != kNoHandler) {
/*
@@ -1157,31 +1141,31 @@
* special codegen doesn't succeed, cUnit->firstLIRInsn will
* set to NULL;
*/
- oatSpecialMIR2LIR(cUnit.get(), specialCase);
+ SpecialMIR2LIR(cUnit.get(), specialCase);
}
/* Convert MIR to LIR, etc. */
if (cUnit->firstLIRInsn == NULL) {
- oatMethodMIR2LIR(cUnit.get());
+ MethodMIR2LIR(cUnit.get());
}
}
// Debugging only
if (cUnit->enableDebug & (1 << kDebugDumpCFG)) {
- oatDumpCFG(cUnit.get(), "/sdcard/cfg/");
+ DumpCFG(cUnit.get(), "/sdcard/cfg/");
}
/* Method is not empty */
if (cUnit->firstLIRInsn) {
// mark the targets of switch statement case labels
- oatProcessSwitchTables(cUnit.get());
+ ProcessSwitchTables(cUnit.get());
/* Convert LIR into machine code. */
- oatAssembleLIR(cUnit.get());
+ AssembleLIR(cUnit.get());
if (cUnit->printMe) {
- oatCodegenDump(cUnit.get());
+ CodegenDump(cUnit.get());
}
if (cUnit->opcodeCount != NULL) {
@@ -1226,16 +1210,16 @@
#ifdef WITH_MEMSTATS
if (cUnit->enableDebug & (1 << kDebugShowMemoryUsage)) {
- oatDumpMemStats(cUnit.get());
+ DumpMemStats(cUnit.get());
}
#endif
- oatArenaReset(cUnit.get());
+ ArenaReset(cUnit.get());
return result;
}
-CompiledMethod* oatCompileMethod(Compiler& compiler,
+CompiledMethod* CompileOneMethod(Compiler& compiler,
const CompilerBackend backend,
const DexFile::CodeItem* code_item,
uint32_t access_flags, InvokeType invoke_type,
@@ -1243,7 +1227,7 @@
const DexFile& dex_file,
LLVMInfo* llvmInfo)
{
- return compileMethod(compiler, backend, code_item, access_flags, invoke_type, method_idx, class_loader,
+ return CompileMethod(compiler, backend, code_item, access_flags, invoke_type, method_idx, class_loader,
dex_file, llvmInfo);
}
@@ -1256,9 +1240,8 @@
uint32_t method_idx, jobject class_loader,
const art::DexFile& dex_file)
{
- CHECK_EQ(compiler.GetInstructionSet(), art::oatInstructionSet());
// TODO: check method fingerprint here to determine appropriate backend type. Until then, use build default
art::CompilerBackend backend = compiler.GetCompilerBackend();
- return art::oatCompileMethod(compiler, backend, code_item, access_flags, invoke_type,
+ return art::CompileOneMethod(compiler, backend, code_item, access_flags, invoke_type,
method_idx, class_loader, dex_file, NULL /* use thread llvmInfo */);
}
diff --git a/src/compiler/frontend.h b/src/compiler/frontend.h
index 702d5d4..1898b9b 100644
--- a/src/compiler/frontend.h
+++ b/src/compiler/frontend.h
@@ -136,8 +136,8 @@
struct CompilationUnit;
struct BasicBlock;
-BasicBlock* oatFindBlock(CompilationUnit* cUnit, unsigned int codeOffset);
-void oatReplaceSpecialChars(std::string& str);
+BasicBlock* FindBlock(CompilationUnit* cUnit, unsigned int codeOffset);
+void ReplaceSpecialChars(std::string& str);
} // namespace art
diff --git a/src/compiler/intermediate_rep.cc b/src/compiler/intermediate_rep.cc
index 6930d76..dd2740d 100644
--- a/src/compiler/intermediate_rep.cc
+++ b/src/compiler/intermediate_rep.cc
@@ -19,14 +19,14 @@
namespace art {
/* Allocate a new basic block */
-BasicBlock* oatNewBB(CompilationUnit* cUnit, BBType blockType, int blockId)
+BasicBlock* NewMemBB(CompilationUnit* cUnit, BBType blockType, int blockId)
{
- BasicBlock* bb = static_cast<BasicBlock*>(oatNew(cUnit, sizeof(BasicBlock), true, kAllocBB));
+ BasicBlock* bb = static_cast<BasicBlock*>(NewMem(cUnit, sizeof(BasicBlock), true, kAllocBB));
bb->blockType = blockType;
bb->id = blockId;
bb->predecessors = static_cast<GrowableList*>
- (oatNew(cUnit, sizeof(GrowableList), false, kAllocPredecessors));
- oatInitGrowableList(cUnit, bb->predecessors,
+ (NewMem(cUnit, sizeof(GrowableList), false, kAllocPredecessors));
+ CompilerInitGrowableList(cUnit, bb->predecessors,
(blockType == kExitBlock) ? 2048 : 2,
kListPredecessors);
cUnit->blockIdMap.Put(blockId, blockId);
@@ -34,7 +34,7 @@
}
/* Insert an MIR instruction to the end of a basic block */
-void oatAppendMIR(BasicBlock* bb, MIR* mir)
+void AppendMIR(BasicBlock* bb, MIR* mir)
{
if (bb->firstMIRInsn == NULL) {
DCHECK(bb->lastMIRInsn == NULL);
@@ -49,7 +49,7 @@
}
/* Insert an MIR instruction to the head of a basic block */
-void oatPrependMIR(BasicBlock* bb, MIR* mir)
+void PrependMIR(BasicBlock* bb, MIR* mir)
{
if (bb->firstMIRInsn == NULL) {
DCHECK(bb->lastMIRInsn == NULL);
@@ -64,7 +64,7 @@
}
/* Insert a MIR instruction after the specified MIR */
-void oatInsertMIRAfter(BasicBlock* bb, MIR* currentMIR, MIR* newMIR)
+void InsertMIRAfter(BasicBlock* bb, MIR* currentMIR, MIR* newMIR)
{
newMIR->prev = currentMIR;
newMIR->next = currentMIR->next;
@@ -83,7 +83,7 @@
* Append an LIR instruction to the LIR list maintained by a compilation
* unit
*/
-void oatAppendLIR(CompilationUnit *cUnit, LIR* lir)
+void AppendLIR(CompilationUnit *cUnit, LIR* lir)
{
if (cUnit->firstLIRInsn == NULL) {
DCHECK(cUnit->lastLIRInsn == NULL);
@@ -103,7 +103,7 @@
*
* prevLIR <-> newLIR <-> currentLIR
*/
-void oatInsertLIRBefore(LIR* currentLIR, LIR* newLIR)
+void InsertLIRBefore(LIR* currentLIR, LIR* newLIR)
{
DCHECK(currentLIR->prev != NULL);
LIR *prevLIR = currentLIR->prev;
@@ -120,7 +120,7 @@
*
* currentLIR -> newLIR -> oldNext
*/
-void oatInsertLIRAfter(LIR* currentLIR, LIR* newLIR)
+void InsertLIRAfter(LIR* currentLIR, LIR* newLIR)
{
newLIR->prev = currentLIR;
newLIR->next = currentLIR->next;
diff --git a/src/compiler/ralloc.cc b/src/compiler/ralloc.cc
index 34edb51..4eab177 100644
--- a/src/compiler/ralloc.cc
+++ b/src/compiler/ralloc.cc
@@ -20,7 +20,7 @@
namespace art {
-bool setFp(CompilationUnit* cUnit, int index, bool isFP) {
+static bool SetFp(CompilationUnit* cUnit, int index, bool isFP) {
bool change = false;
if (isFP && !cUnit->regLocation[index].fp) {
cUnit->regLocation[index].fp = true;
@@ -30,7 +30,7 @@
return change;
}
-bool setCore(CompilationUnit* cUnit, int index, bool isCore) {
+static bool SetCore(CompilationUnit* cUnit, int index, bool isCore) {
bool change = false;
if (isCore && !cUnit->regLocation[index].defined) {
cUnit->regLocation[index].core = true;
@@ -40,7 +40,7 @@
return change;
}
-bool setRef(CompilationUnit* cUnit, int index, bool isRef) {
+static bool SetRef(CompilationUnit* cUnit, int index, bool isRef) {
bool change = false;
if (isRef && !cUnit->regLocation[index].defined) {
cUnit->regLocation[index].ref = true;
@@ -50,7 +50,7 @@
return change;
}
-bool setWide(CompilationUnit* cUnit, int index, bool isWide) {
+static bool SetWide(CompilationUnit* cUnit, int index, bool isWide) {
bool change = false;
if (isWide && !cUnit->regLocation[index].wide) {
cUnit->regLocation[index].wide = true;
@@ -59,7 +59,7 @@
return change;
}
-bool setHigh(CompilationUnit* cUnit, int index, bool isHigh) {
+static bool SetHigh(CompilationUnit* cUnit, int index, bool isHigh) {
bool change = false;
if (isHigh && !cUnit->regLocation[index].highWord) {
cUnit->regLocation[index].highWord = true;
@@ -68,7 +68,7 @@
return change;
}
-bool remapNames(CompilationUnit* cUnit, BasicBlock* bb)
+static bool RemapNames(CompilationUnit* cUnit, BasicBlock* bb)
{
if (bb->blockType != kDalvikByteCode && bb->blockType != kEntryBlock &&
bb->blockType != kExitBlock)
@@ -93,7 +93,7 @@
* as it doesn't propagate. We're guaranteed at least one pass through
* the cfg.
*/
-bool inferTypeAndSize(CompilationUnit* cUnit, BasicBlock* bb)
+static bool InferTypeAndSize(CompilationUnit* cUnit, BasicBlock* bb)
{
MIR *mir;
bool changed = false; // Did anything change?
@@ -110,10 +110,10 @@
// Handle defs
if (attrs & DF_DA) {
if (attrs & DF_CORE_A) {
- changed |= setCore(cUnit, ssaRep->defs[0], true);
+ changed |= SetCore(cUnit, ssaRep->defs[0], true);
}
if (attrs & DF_REF_A) {
- changed |= setRef(cUnit, ssaRep->defs[0], true);
+ changed |= SetRef(cUnit, ssaRep->defs[0], true);
}
if (attrs & DF_A_WIDE) {
cUnit->regLocation[ssaRep->defs[0]].wide = true;
@@ -128,10 +128,10 @@
int next = 0;
if (attrs & DF_UA) {
if (attrs & DF_CORE_A) {
- changed |= setCore(cUnit, ssaRep->uses[next], true);
+ changed |= SetCore(cUnit, ssaRep->uses[next], true);
}
if (attrs & DF_REF_A) {
- changed |= setRef(cUnit, ssaRep->uses[next], true);
+ changed |= SetRef(cUnit, ssaRep->uses[next], true);
}
if (attrs & DF_A_WIDE) {
cUnit->regLocation[ssaRep->uses[next]].wide = true;
@@ -146,10 +146,10 @@
}
if (attrs & DF_UB) {
if (attrs & DF_CORE_B) {
- changed |= setCore(cUnit, ssaRep->uses[next], true);
+ changed |= SetCore(cUnit, ssaRep->uses[next], true);
}
if (attrs & DF_REF_B) {
- changed |= setRef(cUnit, ssaRep->uses[next], true);
+ changed |= SetRef(cUnit, ssaRep->uses[next], true);
}
if (attrs & DF_B_WIDE) {
cUnit->regLocation[ssaRep->uses[next]].wide = true;
@@ -164,10 +164,10 @@
}
if (attrs & DF_UC) {
if (attrs & DF_CORE_C) {
- changed |= setCore(cUnit, ssaRep->uses[next], true);
+ changed |= SetCore(cUnit, ssaRep->uses[next], true);
}
if (attrs & DF_REF_C) {
- changed |= setRef(cUnit, ssaRep->uses[next], true);
+ changed |= SetRef(cUnit, ssaRep->uses[next], true);
}
if (attrs & DF_C_WIDE) {
cUnit->regLocation[ssaRep->uses[next]].wide = true;
@@ -184,27 +184,27 @@
(mir->dalvikInsn.opcode == Instruction::RETURN_OBJECT)) {
switch(cUnit->shorty[0]) {
case 'I':
- changed |= setCore(cUnit, ssaRep->uses[0], true);
+ changed |= SetCore(cUnit, ssaRep->uses[0], true);
break;
case 'J':
- changed |= setCore(cUnit, ssaRep->uses[0], true);
- changed |= setCore(cUnit, ssaRep->uses[1], true);
+ changed |= SetCore(cUnit, ssaRep->uses[0], true);
+ changed |= SetCore(cUnit, ssaRep->uses[1], true);
cUnit->regLocation[ssaRep->uses[0]].wide = true;
cUnit->regLocation[ssaRep->uses[1]].wide = true;
cUnit->regLocation[ssaRep->uses[1]].highWord = true;
break;
case 'F':
- changed |= setFp(cUnit, ssaRep->uses[0], true);
+ changed |= SetFp(cUnit, ssaRep->uses[0], true);
break;
case 'D':
- changed |= setFp(cUnit, ssaRep->uses[0], true);
- changed |= setFp(cUnit, ssaRep->uses[1], true);
+ changed |= SetFp(cUnit, ssaRep->uses[0], true);
+ changed |= SetFp(cUnit, ssaRep->uses[1], true);
cUnit->regLocation[ssaRep->uses[0]].wide = true;
cUnit->regLocation[ssaRep->uses[1]].wide = true;
cUnit->regLocation[ssaRep->uses[1]].highWord = true;
break;
case 'L':
- changed |= setRef(cUnit, ssaRep->uses[0], true);
+ changed |= SetRef(cUnit, ssaRep->uses[0], true);
break;
default: break;
}
@@ -218,20 +218,20 @@
(attrs & (DF_FORMAT_35C | DF_FORMAT_3RC))) {
DCHECK_EQ(next, 0);
int target_idx = mir->dalvikInsn.vB;
- const char* shorty = oatGetShortyFromTargetIdx(cUnit, target_idx);
+ const char* shorty = GetShortyFromTargetIdx(cUnit, target_idx);
// Handle result type if floating point
if ((shorty[0] == 'F') || (shorty[0] == 'D')) {
- MIR* moveResultMIR = oatFindMoveResult(cUnit, bb, mir);
+ MIR* moveResultMIR = FindMoveResult(cUnit, bb, mir);
// Result might not be used at all, so no move-result
if (moveResultMIR && (moveResultMIR->dalvikInsn.opcode !=
Instruction::MOVE_RESULT_OBJECT)) {
SSARepresentation* tgtRep = moveResultMIR->ssaRep;
DCHECK(tgtRep != NULL);
tgtRep->fpDef[0] = true;
- changed |= setFp(cUnit, tgtRep->defs[0], true);
+ changed |= SetFp(cUnit, tgtRep->defs[0], true);
if (shorty[0] == 'D') {
tgtRep->fpDef[1] = true;
- changed |= setFp(cUnit, tgtRep->defs[1], true);
+ changed |= SetFp(cUnit, tgtRep->defs[1], true);
}
}
}
@@ -264,17 +264,17 @@
cUnit->regLocation[ssaRep->uses[i+1]].highWord = true;
DCHECK_EQ(SRegToVReg(cUnit, ssaRep->uses[i])+1,
SRegToVReg(cUnit, ssaRep->uses[i+1]));
- changed |= setCore(cUnit, ssaRep->uses[i],true);
+ changed |= SetCore(cUnit, ssaRep->uses[i],true);
i++;
break;
case 'F':
ssaRep->fpUse[i] = true;
break;
case 'L':
- changed |= setRef(cUnit,ssaRep->uses[i], true);
+ changed |= SetRef(cUnit,ssaRep->uses[i], true);
break;
default:
- changed |= setCore(cUnit,ssaRep->uses[i], true);
+ changed |= SetCore(cUnit,ssaRep->uses[i], true);
break;
}
i++;
@@ -284,11 +284,11 @@
for (int i=0; ssaRep->fpUse && i< ssaRep->numUses; i++) {
if (ssaRep->fpUse[i])
- changed |= setFp(cUnit, ssaRep->uses[i], true);
+ changed |= SetFp(cUnit, ssaRep->uses[i], true);
}
for (int i=0; ssaRep->fpDef && i< ssaRep->numDefs; i++) {
if (ssaRep->fpDef[i])
- changed |= setFp(cUnit, ssaRep->defs[i], true);
+ changed |= SetFp(cUnit, ssaRep->defs[i], true);
}
// Special-case handling for moves & Phi
if (attrs & (DF_IS_MOVE | DF_NULL_TRANSFER_N)) {
@@ -335,26 +335,26 @@
<< " has both fp and core/ref uses for same def.";
cUnit->disableOpt |= (1 << kPromoteRegs);
}
- changed |= setFp(cUnit, ssaRep->defs[0], definedFP);
- changed |= setCore(cUnit, ssaRep->defs[0], definedCore);
- changed |= setRef(cUnit, ssaRep->defs[0], definedRef);
- changed |= setWide(cUnit, ssaRep->defs[0], isWide);
- changed |= setHigh(cUnit, ssaRep->defs[0], isHigh);
+ changed |= SetFp(cUnit, ssaRep->defs[0], definedFP);
+ changed |= SetCore(cUnit, ssaRep->defs[0], definedCore);
+ changed |= SetRef(cUnit, ssaRep->defs[0], definedRef);
+ changed |= SetWide(cUnit, ssaRep->defs[0], isWide);
+ changed |= SetHigh(cUnit, ssaRep->defs[0], isHigh);
if (attrs & DF_A_WIDE) {
- changed |= setWide(cUnit, ssaRep->defs[1], true);
- changed |= setHigh(cUnit, ssaRep->defs[1], true);
+ changed |= SetWide(cUnit, ssaRep->defs[1], true);
+ changed |= SetHigh(cUnit, ssaRep->defs[1], true);
}
for (int i = 0; i < ssaRep->numUses; i++) {
- changed |= setFp(cUnit, ssaRep->uses[i], definedFP);
- changed |= setCore(cUnit, ssaRep->uses[i], definedCore);
- changed |= setRef(cUnit, ssaRep->uses[i], definedRef);
- changed |= setWide(cUnit, ssaRep->uses[i], isWide);
- changed |= setHigh(cUnit, ssaRep->uses[i], isHigh);
+ changed |= SetFp(cUnit, ssaRep->uses[i], definedFP);
+ changed |= SetCore(cUnit, ssaRep->uses[i], definedCore);
+ changed |= SetRef(cUnit, ssaRep->uses[i], definedRef);
+ changed |= SetWide(cUnit, ssaRep->uses[i], isWide);
+ changed |= SetHigh(cUnit, ssaRep->uses[i], isHigh);
}
if (attrs & DF_A_WIDE) {
DCHECK_EQ(ssaRep->numUses, 2);
- changed |= setWide(cUnit, ssaRep->uses[1], true);
- changed |= setHigh(cUnit, ssaRep->uses[1], true);
+ changed |= SetWide(cUnit, ssaRep->uses[1], true);
+ changed |= SetHigh(cUnit, ssaRep->uses[1], true);
}
}
}
@@ -364,7 +364,7 @@
static const char* storageName[] = {" Frame ", "PhysReg", " Spill "};
-void oatDumpRegLocTable(RegLocation* table, int count)
+static void DumpRegLocTable(RegLocation* table, int count)
{
for (int i = 0; i < count; i++) {
LOG(INFO) << StringPrintf("Loc[%02d] : %s, %c %c %c %c %c %c%d %c%d S%d",
@@ -372,22 +372,18 @@
table[i].wide ? 'W' : 'N', table[i].defined ? 'D' : 'U',
table[i].fp ? 'F' : table[i].ref ? 'R' :'C',
table[i].highWord ? 'H' : 'L', table[i].home ? 'h' : 't',
- oatIsFpReg(table[i].lowReg) ? 's' : 'r',
- table[i].lowReg & oatFpRegMask(),
- oatIsFpReg(table[i].highReg) ? 's' : 'r',
- table[i].highReg & oatFpRegMask(), table[i].sRegLow);
+ IsFpReg(table[i].lowReg) ? 's' : 'r',
+ table[i].lowReg & FpRegMask(),
+ IsFpReg(table[i].highReg) ? 's' : 'r',
+ table[i].highReg & FpRegMask(), table[i].sRegLow);
}
}
-void oatDumpRegLoc(RegLocation loc) {
- oatDumpRegLocTable(&loc, 1);
-}
-
static const RegLocation freshLoc = {kLocDalvikFrame, 0, 0, 0, 0, 0, 0, 0, 0,
INVALID_REG, INVALID_REG, INVALID_SREG,
INVALID_SREG};
-int oatComputeFrameSize(CompilationUnit* cUnit) {
+int ComputeFrameSize(CompilationUnit* cUnit) {
/* Figure out the frame size */
static const uint32_t kAlignMask = kStackAlignment - 1;
uint32_t size = (cUnit->numCoreSpills + cUnit->numFPSpills +
@@ -404,18 +400,18 @@
* allocation is done on the fly. We also do some initialization and
* type inference here.
*/
-void oatSimpleRegAlloc(CompilationUnit* cUnit)
+void SimpleRegAlloc(CompilationUnit* cUnit)
{
int i;
RegLocation* loc;
/* Allocate the location map */
- loc = static_cast<RegLocation*>(oatNew(cUnit, cUnit->numSSARegs * sizeof(*loc),
+ loc = static_cast<RegLocation*>(NewMem(cUnit, cUnit->numSSARegs * sizeof(*loc),
true, kAllocRegAlloc));
for (i=0; i< cUnit->numSSARegs; i++) {
loc[i] = freshLoc;
loc[i].sRegLow = i;
- loc[i].isConst = oatIsBitSet(cUnit->isConstantV, i);
+ loc[i].isConst = IsBitSet(cUnit->isConstantV, i);
}
/* Patch up the locations for Method* and the compiler temps */
@@ -432,7 +428,7 @@
/* Allocation the promotion map */
int numRegs = cUnit->numDalvikRegisters;
cUnit->promotionMap = static_cast<PromotionMap*>
- (oatNew(cUnit, (numRegs + cUnit->numCompilerTemps + 1) * sizeof(cUnit->promotionMap[0]),
+ (NewMem(cUnit, (numRegs + cUnit->numCompilerTemps + 1) * sizeof(cUnit->promotionMap[0]),
true, kAllocRegAlloc));
/* Add types of incoming arguments based on signature */
@@ -485,13 +481,13 @@
if (!cUnit->genBitcode) {
/* Remap names */
- oatDataFlowAnalysisDispatcher(cUnit, remapNames,
+ DataFlowAnalysisDispatcher(cUnit, RemapNames,
kPreOrderDFSTraversal,
false /* isIterative */);
}
/* Do type & size inference pass */
- oatDataFlowAnalysisDispatcher(cUnit, inferTypeAndSize,
+ DataFlowAnalysisDispatcher(cUnit, InferTypeAndSize,
kPreOrderDFSTraversal,
true /* isIterative */);
@@ -512,18 +508,18 @@
cUnit->fpSpillMask = 0;
cUnit->numCoreSpills = 0;
- oatDoPromotion(cUnit);
+ DoPromotion(cUnit);
/* Get easily-accessable post-promotion copy of RegLocation for Method* */
cUnit->methodLoc = cUnit->regLocation[cUnit->methodSReg];
if (cUnit->printMe && !(cUnit->disableOpt & (1 << kPromoteRegs))) {
LOG(INFO) << "After Promotion";
- oatDumpRegLocTable(cUnit->regLocation, cUnit->numSSARegs);
+ DumpRegLocTable(cUnit->regLocation, cUnit->numSSARegs);
}
/* Set the frame size */
- cUnit->frameSize = oatComputeFrameSize(cUnit);
+ cUnit->frameSize = ComputeFrameSize(cUnit);
}
} // namespace art
diff --git a/src/compiler/ralloc.h b/src/compiler/ralloc.h
index be94419..51bee9f 100644
--- a/src/compiler/ralloc.h
+++ b/src/compiler/ralloc.h
@@ -21,7 +21,7 @@
namespace art {
-void oatSimpleRegAlloc(CompilationUnit* cUnit);
+void SimpleRegAlloc(CompilationUnit* cUnit);
} // namespace art
diff --git a/src/compiler/ssa_transformation.cc b/src/compiler/ssa_transformation.cc
index bbe08f5..664893e 100644
--- a/src/compiler/ssa_transformation.cc
+++ b/src/compiler/ssa_transformation.cc
@@ -22,7 +22,7 @@
// Make sure iterative dfs recording matches old recursive version
//#define TEST_DFS
-inline BasicBlock* needsVisit(BasicBlock* bb) {
+static inline BasicBlock* NeedsVisit(BasicBlock* bb) {
if (bb != NULL) {
if (bb->visited || bb->hidden) {
bb = NULL;
@@ -31,21 +31,21 @@
return bb;
}
-BasicBlock* nextUnvisitedSuccessor(BasicBlock* bb)
+static BasicBlock* NextUnvisitedSuccessor(BasicBlock* bb)
{
- BasicBlock* res = needsVisit(bb->fallThrough);
+ BasicBlock* res = NeedsVisit(bb->fallThrough);
if (res == NULL) {
- res = needsVisit(bb->taken);
+ res = NeedsVisit(bb->taken);
if (res == NULL) {
if (bb->successorBlockList.blockListType != kNotUsed) {
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
+ GrowableListIteratorInit(&bb->successorBlockList.blocks,
&iterator);
while (true) {
SuccessorBlockInfo *sbi = reinterpret_cast<SuccessorBlockInfo*>
- (oatGrowableListIteratorNext(&iterator));
+ (GrowableListIteratorNext(&iterator));
if (sbi == NULL) break;
- res = needsVisit(sbi->block);
+ res = NeedsVisit(sbi->block);
if (res != NULL) break;
}
}
@@ -54,35 +54,35 @@
return res;
}
-void markPreOrder(CompilationUnit* cUnit, BasicBlock* block)
+static void MarkPreOrder(CompilationUnit* cUnit, BasicBlock* block)
{
block->visited = true;
/* Enqueue the preOrder block id */
- oatInsertGrowableList(cUnit, &cUnit->dfsOrder, block->id);
+ InsertGrowableList(cUnit, &cUnit->dfsOrder, block->id);
}
-void recordDFSOrders(CompilationUnit* cUnit, BasicBlock* block)
+static void RecordDFSOrders(CompilationUnit* cUnit, BasicBlock* block)
{
std::vector<BasicBlock*> succ;
- markPreOrder(cUnit, block);
+ MarkPreOrder(cUnit, block);
succ.push_back(block);
while (!succ.empty()) {
BasicBlock* curr = succ.back();
- BasicBlock* nextSuccessor = nextUnvisitedSuccessor(curr);
+ BasicBlock* nextSuccessor = NextUnvisitedSuccessor(curr);
if (nextSuccessor != NULL) {
- markPreOrder(cUnit, nextSuccessor);
+ MarkPreOrder(cUnit, nextSuccessor);
succ.push_back(nextSuccessor);
continue;
}
curr->dfsId = cUnit->dfsPostOrder.numUsed;
- oatInsertGrowableList(cUnit, &cUnit->dfsPostOrder, curr->id);
+ InsertGrowableList(cUnit, &cUnit->dfsPostOrder, curr->id);
succ.pop_back();
}
}
#if defined(TEST_DFS)
/* Enter the node to the dfsOrder list then visit its successors */
-void recursiveRecordDFSOrders(CompilationUnit* cUnit, BasicBlock* block)
+static void RecursiveRecordDFSOrders(CompilationUnit* cUnit, BasicBlock* block)
{
if (block->visited || block->hidden) return;
@@ -98,38 +98,38 @@
}
/* Enqueue the preOrder block id */
- oatInsertGrowableList(cUnit, &cUnit->dfsOrder, block->id);
+ InsertGrowableList(cUnit, &cUnit->dfsOrder, block->id);
if (block->fallThrough) {
- recursiveRecordDFSOrders(cUnit, block->fallThrough);
+ RecursiveRecordDFSOrders(cUnit, block->fallThrough);
}
- if (block->taken) recursiveRecordDFSOrders(cUnit, block->taken);
+ if (block->taken) RecursiveRecordDFSOrders(cUnit, block->taken);
if (block->successorBlockList.blockListType != kNotUsed) {
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&block->successorBlockList.blocks,
+ GrowableListIteratorInit(&block->successorBlockList.blocks,
&iterator);
while (true) {
SuccessorBlockInfo *successorBlockInfo =
- (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
+ (SuccessorBlockInfo *) GrowableListIteratorNext(&iterator);
if (successorBlockInfo == NULL) break;
BasicBlock* succBB = successorBlockInfo->block;
- recursiveRecordDFSOrders(cUnit, succBB);
+ RecursiveRecordDFSOrders(cUnit, succBB);
}
}
/* Record postorder in basic block and enqueue normal id in dfsPostOrder */
block->dfsId = cUnit->dfsPostOrder.numUsed;
- oatInsertGrowableList(cUnit, &cUnit->dfsPostOrder, block->id);
+ InsertGrowableList(cUnit, &cUnit->dfsPostOrder, block->id);
return;
}
#endif
/* Sort the blocks by the Depth-First-Search */
-void computeDFSOrders(CompilationUnit* cUnit)
+static void ComputeDFSOrders(CompilationUnit* cUnit)
{
/* Initialize or reset the DFS preOrder list */
if (cUnit->dfsOrder.elemList == NULL) {
- oatInitGrowableList(cUnit, &cUnit->dfsOrder, cUnit->numBlocks,
+ CompilerInitGrowableList(cUnit, &cUnit->dfsOrder, cUnit->numBlocks,
kListDfsOrder);
} else {
/* Just reset the used length on the counter */
@@ -138,7 +138,7 @@
/* Initialize or reset the DFS postOrder list */
if (cUnit->dfsPostOrder.elemList == NULL) {
- oatInitGrowableList(cUnit, &cUnit->dfsPostOrder, cUnit->numBlocks,
+ CompilerInitGrowableList(cUnit, &cUnit->dfsPostOrder, cUnit->numBlocks,
kListDfsPostOrder);
} else {
/* Just reset the used length on the counter */
@@ -147,34 +147,34 @@
#if defined(TEST_DFS)
// Reset visited flags
- oatDataFlowAnalysisDispatcher(cUnit, oatClearVisitedFlag,
+ DataFlowAnalysisDispatcher(cUnit, ClearVisitedFlag,
kAllNodes, false /* isIterative */);
// Record pre and post order dfs
- recursiveRecordDFSOrders(cUnit, cUnit->entryBlock);
+ RecursiveRecordDFSOrders(cUnit, cUnit->entryBlock);
// Copy the results for later comparison and reset the lists
GrowableList recursiveDfsOrder;
GrowableList recursiveDfsPostOrder;
- oatInitGrowableList(cUnit, &recursiveDfsOrder, cUnit->dfsOrder.numUsed,
+ CompilerInitGrowableList(cUnit, &recursiveDfsOrder, cUnit->dfsOrder.numUsed,
kListDfsOrder);
for (unsigned int i = 0; i < cUnit->dfsOrder.numUsed; i++) {
- oatInsertGrowableList(cUnit, &recursiveDfsOrder,
+ InsertGrowableList(cUnit, &recursiveDfsOrder,
cUnit->dfsOrder.elemList[i]);
}
cUnit->dfsOrder.numUsed = 0;
- oatInitGrowableList(cUnit, &recursiveDfsPostOrder,
+ CompilerInitGrowableList(cUnit, &recursiveDfsPostOrder,
cUnit->dfsPostOrder.numUsed, kListDfsOrder);
for (unsigned int i = 0; i < cUnit->dfsPostOrder.numUsed; i++) {
- oatInsertGrowableList(cUnit, &recursiveDfsPostOrder,
+ InsertGrowableList(cUnit, &recursiveDfsPostOrder,
cUnit->dfsPostOrder.elemList[i]);
}
cUnit->dfsPostOrder.numUsed = 0;
#endif
// Reset visited flags from all nodes
- oatDataFlowAnalysisDispatcher(cUnit, oatClearVisitedFlag,
+ DataFlowAnalysisDispatcher(cUnit, ClearVisitedFlag,
kAllNodes, false /* isIterative */);
// Record dfs orders
- recordDFSOrders(cUnit, cUnit->entryBlock);
+ RecordDFSOrders(cUnit, cUnit->entryBlock);
#if defined(TEST_DFS)
bool mismatch = false;
@@ -226,38 +226,38 @@
* Mark block bit on the per-Dalvik register vector to denote that Dalvik
* register idx is defined in BasicBlock bb.
*/
-bool fillDefBlockMatrix(CompilationUnit* cUnit, BasicBlock* bb)
+static bool FillDefBlockMatrix(CompilationUnit* cUnit, BasicBlock* bb)
{
if (bb->dataFlowInfo == NULL) return false;
ArenaBitVectorIterator iterator;
- oatBitVectorIteratorInit(bb->dataFlowInfo->defV, &iterator);
+ BitVectorIteratorInit(bb->dataFlowInfo->defV, &iterator);
while (true) {
- int idx = oatBitVectorIteratorNext(&iterator);
+ int idx = BitVectorIteratorNext(&iterator);
if (idx == -1) break;
/* Block bb defines register idx */
- oatSetBit(cUnit, cUnit->defBlockMatrix[idx], bb->id);
+ SetBit(cUnit, cUnit->defBlockMatrix[idx], bb->id);
}
return true;
}
-void computeDefBlockMatrix(CompilationUnit* cUnit)
+static void ComputeDefBlockMatrix(CompilationUnit* cUnit)
{
int numRegisters = cUnit->numDalvikRegisters;
/* Allocate numDalvikRegisters bit vector pointers */
cUnit->defBlockMatrix = static_cast<ArenaBitVector**>
- (oatNew(cUnit, sizeof(ArenaBitVector *) * numRegisters, true, kAllocDFInfo));
+ (NewMem(cUnit, sizeof(ArenaBitVector *) * numRegisters, true, kAllocDFInfo));
int i;
/* Initialize numRegister vectors with numBlocks bits each */
for (i = 0; i < numRegisters; i++) {
- cUnit->defBlockMatrix[i] = oatAllocBitVector(cUnit, cUnit->numBlocks,
+ cUnit->defBlockMatrix[i] = AllocBitVector(cUnit, cUnit->numBlocks,
false, kBitMapBMatrix);
}
- oatDataFlowAnalysisDispatcher(cUnit, oatFindLocalLiveIn,
+ DataFlowAnalysisDispatcher(cUnit, FindLocalLiveIn,
kAllNodes, false /* isIterative */);
- oatDataFlowAnalysisDispatcher(cUnit, fillDefBlockMatrix,
+ DataFlowAnalysisDispatcher(cUnit, FillDefBlockMatrix,
kAllNodes, false /* isIterative */);
/*
@@ -267,38 +267,38 @@
int numRegs = cUnit->numDalvikRegisters;
int inReg = numRegs - cUnit->numIns;
for (; inReg < numRegs; inReg++) {
- oatSetBit(cUnit, cUnit->defBlockMatrix[inReg], cUnit->entryBlock->id);
+ SetBit(cUnit, cUnit->defBlockMatrix[inReg], cUnit->entryBlock->id);
}
}
/* Compute the post-order traversal of the CFG */
-void computeDomPostOrderTraversal(CompilationUnit* cUnit, BasicBlock* bb)
+static void ComputeDomPostOrderTraversal(CompilationUnit* cUnit, BasicBlock* bb)
{
ArenaBitVectorIterator bvIterator;
- oatBitVectorIteratorInit(bb->iDominated, &bvIterator);
+ BitVectorIteratorInit(bb->iDominated, &bvIterator);
GrowableList* blockList = &cUnit->blockList;
/* Iterate through the dominated blocks first */
while (true) {
- //TUNING: hot call to oatBitVectorIteratorNext
- int bbIdx = oatBitVectorIteratorNext(&bvIterator);
+ //TUNING: hot call to BitVectorIteratorNext
+ int bbIdx = BitVectorIteratorNext(&bvIterator);
if (bbIdx == -1) break;
BasicBlock* dominatedBB =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, bbIdx));
- computeDomPostOrderTraversal(cUnit, dominatedBB);
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, bbIdx));
+ ComputeDomPostOrderTraversal(cUnit, dominatedBB);
}
/* Enter the current block id */
- oatInsertGrowableList(cUnit, &cUnit->domPostOrderTraversal, bb->id);
+ InsertGrowableList(cUnit, &cUnit->domPostOrderTraversal, bb->id);
/* hacky loop detection */
- if (bb->taken && oatIsBitSet(bb->dominators, bb->taken->id)) {
+ if (bb->taken && IsBitSet(bb->dominators, bb->taken->id)) {
cUnit->hasLoop = true;
}
}
-void checkForDominanceFrontier(CompilationUnit* cUnit, BasicBlock* domBB,
- const BasicBlock* succBB)
+static void CheckForDominanceFrontier(CompilationUnit* cUnit, BasicBlock* domBB,
+ const BasicBlock* succBB)
{
/*
* TODO - evaluate whether phi will ever need to be inserted into exit
@@ -307,53 +307,53 @@
if (succBB->iDom != domBB &&
succBB->blockType == kDalvikByteCode &&
succBB->hidden == false) {
- oatSetBit(cUnit, domBB->domFrontier, succBB->id);
+ SetBit(cUnit, domBB->domFrontier, succBB->id);
}
}
/* Worker function to compute the dominance frontier */
-bool computeDominanceFrontier(CompilationUnit* cUnit, BasicBlock* bb)
+static bool ComputeDominanceFrontier(CompilationUnit* cUnit, BasicBlock* bb)
{
GrowableList* blockList = &cUnit->blockList;
/* Calculate DF_local */
if (bb->taken) {
- checkForDominanceFrontier(cUnit, bb, bb->taken);
+ CheckForDominanceFrontier(cUnit, bb, bb->taken);
}
if (bb->fallThrough) {
- checkForDominanceFrontier(cUnit, bb, bb->fallThrough);
+ CheckForDominanceFrontier(cUnit, bb, bb->fallThrough);
}
if (bb->successorBlockList.blockListType != kNotUsed) {
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
+ GrowableListIteratorInit(&bb->successorBlockList.blocks,
&iterator);
while (true) {
SuccessorBlockInfo *successorBlockInfo =
- reinterpret_cast<SuccessorBlockInfo*>(oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<SuccessorBlockInfo*>(GrowableListIteratorNext(&iterator));
if (successorBlockInfo == NULL) break;
BasicBlock* succBB = successorBlockInfo->block;
- checkForDominanceFrontier(cUnit, bb, succBB);
+ CheckForDominanceFrontier(cUnit, bb, succBB);
}
}
/* Calculate DF_up */
ArenaBitVectorIterator bvIterator;
- oatBitVectorIteratorInit(bb->iDominated, &bvIterator);
+ BitVectorIteratorInit(bb->iDominated, &bvIterator);
while (true) {
- //TUNING: hot call to oatBitVectorIteratorNext
- int dominatedIdx = oatBitVectorIteratorNext(&bvIterator);
+ //TUNING: hot call to BitVectorIteratorNext
+ int dominatedIdx = BitVectorIteratorNext(&bvIterator);
if (dominatedIdx == -1) break;
BasicBlock* dominatedBB =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, dominatedIdx));
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, dominatedIdx));
ArenaBitVectorIterator dfIterator;
- oatBitVectorIteratorInit(dominatedBB->domFrontier, &dfIterator);
+ BitVectorIteratorInit(dominatedBB->domFrontier, &dfIterator);
while (true) {
- //TUNING: hot call to oatBitVectorIteratorNext
- int dfUpIdx = oatBitVectorIteratorNext(&dfIterator);
+ //TUNING: hot call to BitVectorIteratorNext
+ int dfUpIdx = BitVectorIteratorNext(&dfIterator);
if (dfUpIdx == -1) break;
BasicBlock* dfUpBlock =
- reinterpret_cast<BasicBlock*>( oatGrowableListGetElement(blockList, dfUpIdx));
- checkForDominanceFrontier(cUnit, bb, dfUpBlock);
+ reinterpret_cast<BasicBlock*>( GrowableListGetElement(blockList, dfUpIdx));
+ CheckForDominanceFrontier(cUnit, bb, dfUpBlock);
}
}
@@ -361,27 +361,27 @@
}
/* Worker function for initializing domination-related data structures */
-bool initializeDominationInfo(CompilationUnit* cUnit, BasicBlock* bb)
+static bool InitializeDominationInfo(CompilationUnit* cUnit, BasicBlock* bb)
{
int numTotalBlocks = cUnit->blockList.numUsed;
if (bb->dominators == NULL ) {
- bb->dominators = oatAllocBitVector(cUnit, numTotalBlocks,
+ bb->dominators = AllocBitVector(cUnit, numTotalBlocks,
false /* expandable */,
kBitMapDominators);
- bb->iDominated = oatAllocBitVector(cUnit, numTotalBlocks,
+ bb->iDominated = AllocBitVector(cUnit, numTotalBlocks,
false /* expandable */,
kBitMapIDominated);
- bb->domFrontier = oatAllocBitVector(cUnit, numTotalBlocks,
+ bb->domFrontier = AllocBitVector(cUnit, numTotalBlocks,
false /* expandable */,
kBitMapDomFrontier);
} else {
- oatClearAllBits(bb->dominators);
- oatClearAllBits(bb->iDominated);
- oatClearAllBits(bb->domFrontier);
+ ClearAllBits(bb->dominators);
+ ClearAllBits(bb->iDominated);
+ ClearAllBits(bb->domFrontier);
}
/* Set all bits in the dominator vector */
- oatSetInitialBits(bb->dominators, numTotalBlocks);
+ SetInitialBits(bb->dominators, numTotalBlocks);
return true;
}
@@ -389,9 +389,9 @@
/*
* Worker function to compute each block's dominators. This implementation
* is only used when kDebugVerifyDataflow is active and should compute
- * the same dominator sets as computeBlockDominators.
+ * the same dominator sets as ComputeBlockDominiators.
*/
-bool slowComputeBlockDominators(CompilationUnit* cUnit, BasicBlock* bb)
+static bool SlowComputeBlockDominators(CompilationUnit* cUnit, BasicBlock* bb)
{
GrowableList* blockList = &cUnit->blockList;
int numTotalBlocks = blockList->numUsed;
@@ -404,21 +404,21 @@
*/
if (bb == cUnit->entryBlock) return false;
- oatSetInitialBits(tempBlockV, numTotalBlocks);
+ SetInitialBits(tempBlockV, numTotalBlocks);
/* Iterate through the predecessors */
- oatGrowableListIteratorInit(bb->predecessors, &iter);
+ GrowableListIteratorInit(bb->predecessors, &iter);
while (true) {
- BasicBlock* predBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter));
+ BasicBlock* predBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter));
if (!predBB) break;
/* tempBlockV = tempBlockV ^ dominators */
if (predBB->dominators != NULL) {
- oatIntersectBitVectors(tempBlockV, tempBlockV, predBB->dominators);
+ IntersectBitVectors(tempBlockV, tempBlockV, predBB->dominators);
}
}
- oatSetBit(cUnit, tempBlockV, bb->id);
- if (oatCompareBitVectors(tempBlockV, bb->dominators)) {
- oatCopyBitVector(bb->dominators, tempBlockV);
+ SetBit(cUnit, tempBlockV, bb->id);
+ if (CompareBitVectors(tempBlockV, bb->dominators)) {
+ CopyBitVector(bb->dominators, tempBlockV);
return true;
}
return false;
@@ -427,9 +427,9 @@
/*
* Worker function to compute the idom. This implementation is only
* used when kDebugVerifyDataflow is active and should compute the
- * same iDom as computeBlockIDom.
+ * same iDom as ComputeblockIDom.
*/
-bool slowComputeBlockIDom(CompilationUnit* cUnit, BasicBlock* bb)
+static bool SlowComputeBlockIDom(CompilationUnit* cUnit, BasicBlock* bb)
{
GrowableList* blockList = &cUnit->blockList;
ArenaBitVector* tempBlockV = cUnit->tempBlockV;
@@ -438,36 +438,36 @@
if (bb == cUnit->entryBlock) return false;
- oatCopyBitVector(tempBlockV, bb->dominators);
- oatClearBit(tempBlockV, bb->id);
- oatBitVectorIteratorInit(tempBlockV, &bvIterator);
+ CopyBitVector(tempBlockV, bb->dominators);
+ ClearBit(tempBlockV, bb->id);
+ BitVectorIteratorInit(tempBlockV, &bvIterator);
/* Should not see any dead block */
- DCHECK_NE(oatCountSetBits(tempBlockV), 0);
- if (oatCountSetBits(tempBlockV) == 1) {
+ DCHECK_NE(CountSetBits(tempBlockV), 0);
+ if (CountSetBits(tempBlockV) == 1) {
iDom = reinterpret_cast<BasicBlock*>
- (oatGrowableListGetElement(blockList, oatBitVectorIteratorNext(&bvIterator)));
+ (GrowableListGetElement(blockList, BitVectorIteratorNext(&bvIterator)));
bb->iDom = iDom;
} else {
- int iDomIdx = oatBitVectorIteratorNext(&bvIterator);
+ int iDomIdx = BitVectorIteratorNext(&bvIterator);
DCHECK_NE(iDomIdx, -1);
while (true) {
- int nextDom = oatBitVectorIteratorNext(&bvIterator);
+ int nextDom = BitVectorIteratorNext(&bvIterator);
if (nextDom == -1) break;
BasicBlock* nextDomBB =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, nextDom));
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, nextDom));
/* iDom dominates nextDom - set new iDom */
- if (oatIsBitSet(nextDomBB->dominators, iDomIdx)) {
+ if (IsBitSet(nextDomBB->dominators, iDomIdx)) {
iDomIdx = nextDom;
}
}
- iDom = reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, iDomIdx));
+ iDom = reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, iDomIdx));
/* Set the immediate dominator block for bb */
bb->iDom = iDom;
}
/* Add bb to the iDominated set of the immediate dominator block */
- oatSetBit(cUnit, iDom->iDominated, bb->id);
+ SetBit(cUnit, iDom->iDominated, bb->id);
return true;
}
@@ -476,7 +476,7 @@
* Given the ordering of iDomList, this common parent represents the
* last element of the intersection of block1 and block2 dominators.
*/
-int findCommonParent(CompilationUnit *cUnit, int block1, int block2)
+static int FindCommonParent(CompilationUnit *cUnit, int block1, int block2)
{
while (block1 != block2) {
while (block1 < block2) {
@@ -492,7 +492,7 @@
}
/* Worker function to compute each block's immediate dominator */
-bool computeBlockIDom(CompilationUnit* cUnit, BasicBlock* bb)
+static bool ComputeblockIDom(CompilationUnit* cUnit, BasicBlock* bb)
{
GrowableListIterator iter;
int idom = -1;
@@ -503,11 +503,11 @@
}
/* Iterate through the predecessors */
- oatGrowableListIteratorInit(bb->predecessors, &iter);
+ GrowableListIteratorInit(bb->predecessors, &iter);
/* Find the first processed predecessor */
while (true) {
- BasicBlock* predBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter));
+ BasicBlock* predBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter));
CHECK(predBB != NULL);
if (cUnit->iDomList[predBB->dfsId] != NOTVISITED) {
idom = predBB->dfsId;
@@ -517,12 +517,12 @@
/* Scan the rest of the predecessors */
while (true) {
- BasicBlock* predBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter));
+ BasicBlock* predBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter));
if (!predBB) break;
if (cUnit->iDomList[predBB->dfsId] == NOTVISITED) {
continue;
} else {
- idom = findCommonParent(cUnit, predBB->dfsId, idom);
+ idom = FindCommonParent(cUnit, predBB->dfsId, idom);
}
}
@@ -537,48 +537,48 @@
}
/* Worker function to compute each block's domintors */
-bool computeBlockDominators(CompilationUnit* cUnit, BasicBlock* bb)
+static bool ComputeBlockDominiators(CompilationUnit* cUnit, BasicBlock* bb)
{
if (bb == cUnit->entryBlock) {
- oatClearAllBits(bb->dominators);
+ ClearAllBits(bb->dominators);
} else {
- oatCopyBitVector(bb->dominators, bb->iDom->dominators);
+ CopyBitVector(bb->dominators, bb->iDom->dominators);
}
- oatSetBit(cUnit, bb->dominators, bb->id);
+ SetBit(cUnit, bb->dominators, bb->id);
return false;
}
-bool setDominators(CompilationUnit* cUnit, BasicBlock* bb)
+static bool SetDominators(CompilationUnit* cUnit, BasicBlock* bb)
{
if (bb != cUnit->entryBlock) {
int iDomDFSIdx = cUnit->iDomList[bb->dfsId];
DCHECK_NE(iDomDFSIdx, NOTVISITED);
int iDomIdx = cUnit->dfsPostOrder.elemList[iDomDFSIdx];
BasicBlock* iDom =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(&cUnit->blockList, iDomIdx));
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(&cUnit->blockList, iDomIdx));
if (cUnit->enableDebug & (1 << kDebugVerifyDataflow)) {
DCHECK_EQ(bb->iDom->id, iDom->id);
}
bb->iDom = iDom;
/* Add bb to the iDominated set of the immediate dominator block */
- oatSetBit(cUnit, iDom->iDominated, bb->id);
+ SetBit(cUnit, iDom->iDominated, bb->id);
}
return false;
}
/* Compute dominators, immediate dominator, and dominance fronter */
-void computeDominators(CompilationUnit* cUnit)
+static void ComputeDominators(CompilationUnit* cUnit)
{
int numReachableBlocks = cUnit->numReachableBlocks;
int numTotalBlocks = cUnit->blockList.numUsed;
/* Initialize domination-related data structures */
- oatDataFlowAnalysisDispatcher(cUnit, initializeDominationInfo,
+ DataFlowAnalysisDispatcher(cUnit, InitializeDominationInfo,
kReachableNodes, false /* isIterative */);
/* Initalize & Clear iDomList */
if (cUnit->iDomList == NULL) {
- cUnit->iDomList = static_cast<int*>(oatNew(cUnit, sizeof(int) * numReachableBlocks,
+ cUnit->iDomList = static_cast<int*>(NewMem(cUnit, sizeof(int) * numReachableBlocks,
false, kAllocDFInfo));
}
for (int i = 0; i < numReachableBlocks; i++) {
@@ -590,40 +590,40 @@
cUnit->iDomList[cUnit->entryBlock->dfsId] = cUnit->entryBlock->dfsId;
/* Compute the immediate dominators */
- oatDataFlowAnalysisDispatcher(cUnit, computeBlockIDom,
+ DataFlowAnalysisDispatcher(cUnit, ComputeblockIDom,
kReversePostOrderTraversal,
true /* isIterative */);
/* Set the dominator for the root node */
- oatClearAllBits(cUnit->entryBlock->dominators);
- oatSetBit(cUnit, cUnit->entryBlock->dominators, cUnit->entryBlock->id);
+ ClearAllBits(cUnit->entryBlock->dominators);
+ SetBit(cUnit, cUnit->entryBlock->dominators, cUnit->entryBlock->id);
if (cUnit->tempBlockV == NULL) {
- cUnit->tempBlockV = oatAllocBitVector(cUnit, numTotalBlocks,
+ cUnit->tempBlockV = AllocBitVector(cUnit, numTotalBlocks,
false /* expandable */,
kBitMapTmpBlockV);
} else {
- oatClearAllBits(cUnit->tempBlockV);
+ ClearAllBits(cUnit->tempBlockV);
}
cUnit->entryBlock->iDom = NULL;
/* For testing, compute sets using alternate mechanism */
if (cUnit->enableDebug & (1 << kDebugVerifyDataflow)) {
// Use alternate mechanism to compute dominators for comparison
- oatDataFlowAnalysisDispatcher(cUnit, slowComputeBlockDominators,
+ DataFlowAnalysisDispatcher(cUnit, SlowComputeBlockDominators,
kPreOrderDFSTraversal,
true /* isIterative */);
- oatDataFlowAnalysisDispatcher(cUnit, slowComputeBlockIDom,
+ DataFlowAnalysisDispatcher(cUnit, SlowComputeBlockIDom,
kReachableNodes,
false /* isIterative */);
}
- oatDataFlowAnalysisDispatcher(cUnit, setDominators,
+ DataFlowAnalysisDispatcher(cUnit, SetDominators,
kReachableNodes,
false /* isIterative */);
- oatDataFlowAnalysisDispatcher(cUnit, computeBlockDominators,
+ DataFlowAnalysisDispatcher(cUnit, ComputeBlockDominiators,
kReversePostOrderTraversal,
false /* isIterative */);
@@ -632,17 +632,17 @@
* iDominated sets.
*/
if (cUnit->domPostOrderTraversal.elemList == NULL) {
- oatInitGrowableList(cUnit, &cUnit->domPostOrderTraversal,
+ CompilerInitGrowableList(cUnit, &cUnit->domPostOrderTraversal,
numReachableBlocks, kListDomPostOrderTraversal);
} else {
cUnit->domPostOrderTraversal.numUsed = 0;
}
- computeDomPostOrderTraversal(cUnit, cUnit->entryBlock);
+ ComputeDomPostOrderTraversal(cUnit, cUnit->entryBlock);
DCHECK_EQ(cUnit->domPostOrderTraversal.numUsed, static_cast<unsigned>(cUnit->numReachableBlocks));
/* Now compute the dominance frontier for each block */
- oatDataFlowAnalysisDispatcher(cUnit, computeDominanceFrontier,
+ DataFlowAnalysisDispatcher(cUnit, ComputeDominanceFrontier,
kPostOrderDOMTraversal,
false /* isIterative */);
}
@@ -651,9 +651,8 @@
* Perform dest U= src1 ^ ~src2
* This is probably not general enough to be placed in BitVector.[ch].
*/
-void computeSuccLiveIn(ArenaBitVector* dest,
- const ArenaBitVector* src1,
- const ArenaBitVector* src2)
+static void ComputeSuccLineIn(ArenaBitVector* dest, const ArenaBitVector* src1,
+ const ArenaBitVector* src2)
{
if (dest->storageSize != src1->storageSize ||
dest->storageSize != src2->storageSize ||
@@ -673,59 +672,59 @@
* The calculated result is used for phi-node pruning - where we only need to
* insert a phi node if the variable is live-in to the block.
*/
-bool computeBlockLiveIns(CompilationUnit* cUnit, BasicBlock* bb)
+static bool ComputeBlockLiveIns(CompilationUnit* cUnit, BasicBlock* bb)
{
ArenaBitVector* tempDalvikRegisterV = cUnit->tempDalvikRegisterV;
if (bb->dataFlowInfo == NULL) return false;
- oatCopyBitVector(tempDalvikRegisterV, bb->dataFlowInfo->liveInV);
+ CopyBitVector(tempDalvikRegisterV, bb->dataFlowInfo->liveInV);
if (bb->taken && bb->taken->dataFlowInfo)
- computeSuccLiveIn(tempDalvikRegisterV, bb->taken->dataFlowInfo->liveInV,
+ ComputeSuccLineIn(tempDalvikRegisterV, bb->taken->dataFlowInfo->liveInV,
bb->dataFlowInfo->defV);
if (bb->fallThrough && bb->fallThrough->dataFlowInfo)
- computeSuccLiveIn(tempDalvikRegisterV,
+ ComputeSuccLineIn(tempDalvikRegisterV,
bb->fallThrough->dataFlowInfo->liveInV,
bb->dataFlowInfo->defV);
if (bb->successorBlockList.blockListType != kNotUsed) {
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
+ GrowableListIteratorInit(&bb->successorBlockList.blocks,
&iterator);
while (true) {
SuccessorBlockInfo *successorBlockInfo =
- reinterpret_cast<SuccessorBlockInfo*>(oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<SuccessorBlockInfo*>(GrowableListIteratorNext(&iterator));
if (successorBlockInfo == NULL) break;
BasicBlock* succBB = successorBlockInfo->block;
if (succBB->dataFlowInfo) {
- computeSuccLiveIn(tempDalvikRegisterV,
+ ComputeSuccLineIn(tempDalvikRegisterV,
succBB->dataFlowInfo->liveInV,
bb->dataFlowInfo->defV);
}
}
}
- if (oatCompareBitVectors(tempDalvikRegisterV, bb->dataFlowInfo->liveInV)) {
- oatCopyBitVector(bb->dataFlowInfo->liveInV, tempDalvikRegisterV);
+ if (CompareBitVectors(tempDalvikRegisterV, bb->dataFlowInfo->liveInV)) {
+ CopyBitVector(bb->dataFlowInfo->liveInV, tempDalvikRegisterV);
return true;
}
return false;
}
/* Insert phi nodes to for each variable to the dominance frontiers */
-void insertPhiNodes(CompilationUnit* cUnit)
+static void InsertPhiNodes(CompilationUnit* cUnit)
{
int dalvikReg;
const GrowableList* blockList = &cUnit->blockList;
ArenaBitVector* phiBlocks =
- oatAllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapPhi);
+ AllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapPhi);
ArenaBitVector* tmpBlocks =
- oatAllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapTmpBlocks);
+ AllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapTmpBlocks);
ArenaBitVector* inputBlocks =
- oatAllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapInputBlocks);
+ AllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapInputBlocks);
cUnit->tempDalvikRegisterV =
- oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false,
+ AllocBitVector(cUnit, cUnit->numDalvikRegisters, false,
kBitMapRegisterV);
- oatDataFlowAnalysisDispatcher(cUnit, computeBlockLiveIns,
+ DataFlowAnalysisDispatcher(cUnit, ComputeBlockLiveIns,
kPostOrderDFSTraversal, true /* isIterative */);
/* Iterate through each Dalvik register */
@@ -733,37 +732,37 @@
bool change;
ArenaBitVectorIterator iterator;
- oatCopyBitVector(inputBlocks, cUnit->defBlockMatrix[dalvikReg]);
- oatClearAllBits(phiBlocks);
+ CopyBitVector(inputBlocks, cUnit->defBlockMatrix[dalvikReg]);
+ ClearAllBits(phiBlocks);
/* Calculate the phi blocks for each Dalvik register */
do {
change = false;
- oatClearAllBits(tmpBlocks);
- oatBitVectorIteratorInit(inputBlocks, &iterator);
+ ClearAllBits(tmpBlocks);
+ BitVectorIteratorInit(inputBlocks, &iterator);
while (true) {
- int idx = oatBitVectorIteratorNext(&iterator);
+ int idx = BitVectorIteratorNext(&iterator);
if (idx == -1) break;
BasicBlock* defBB =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, idx));
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, idx));
/* Merge the dominance frontier to tmpBlocks */
- //TUNING: hot call to oatUnifyBitVectors
+ //TUNING: hot call to UnifyBitVetors
if (defBB->domFrontier != NULL) {
- oatUnifyBitVectors(tmpBlocks, tmpBlocks, defBB->domFrontier);
+ UnifyBitVetors(tmpBlocks, tmpBlocks, defBB->domFrontier);
}
}
- if (oatCompareBitVectors(phiBlocks, tmpBlocks)) {
+ if (CompareBitVectors(phiBlocks, tmpBlocks)) {
change = true;
- oatCopyBitVector(phiBlocks, tmpBlocks);
+ CopyBitVector(phiBlocks, tmpBlocks);
/*
* Iterate through the original blocks plus the new ones in
* the dominance frontier.
*/
- oatCopyBitVector(inputBlocks, phiBlocks);
- oatUnifyBitVectors(inputBlocks, inputBlocks,
+ CopyBitVector(inputBlocks, phiBlocks);
+ UnifyBitVetors(inputBlocks, inputBlocks,
cUnit->defBlockMatrix[dalvikReg]);
}
} while (change);
@@ -772,21 +771,21 @@
* Insert a phi node for dalvikReg in the phiBlocks if the Dalvik
* register is in the live-in set.
*/
- oatBitVectorIteratorInit(phiBlocks, &iterator);
+ BitVectorIteratorInit(phiBlocks, &iterator);
while (true) {
- int idx = oatBitVectorIteratorNext(&iterator);
+ int idx = BitVectorIteratorNext(&iterator);
if (idx == -1) break;
BasicBlock* phiBB =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, idx));
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, idx));
/* Variable will be clobbered before being used - no need for phi */
- if (!oatIsBitSet(phiBB->dataFlowInfo->liveInV, dalvikReg)) continue;
- MIR *phi = static_cast<MIR*>(oatNew(cUnit, sizeof(MIR), true, kAllocDFInfo));
+ if (!IsBitSet(phiBB->dataFlowInfo->liveInV, dalvikReg)) continue;
+ MIR *phi = static_cast<MIR*>(NewMem(cUnit, sizeof(MIR), true, kAllocDFInfo));
phi->dalvikInsn.opcode = static_cast<Instruction::Code>(kMirOpPhi);
phi->dalvikInsn.vA = dalvikReg;
phi->offset = phiBB->startOffset;
phi->meta.phiNext = cUnit->phiList;
cUnit->phiList = phi;
- oatPrependMIR(phiBB, phi);
+ PrependMIR(phiBB, phi);
}
}
}
@@ -795,7 +794,7 @@
* Worker function to insert phi-operands with latest SSA names from
* predecessor blocks
*/
-bool insertPhiNodeOperands(CompilationUnit* cUnit, BasicBlock* bb)
+static bool InsertPhiNodeOperands(CompilationUnit* cUnit, BasicBlock* bb)
{
GrowableListIterator iter;
MIR *mir;
@@ -814,10 +813,10 @@
incomingArc.clear();
/* Iterate through the predecessors */
- oatGrowableListIteratorInit(bb->predecessors, &iter);
+ GrowableListIteratorInit(bb->predecessors, &iter);
while (true) {
BasicBlock* predBB =
- reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter));
+ reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter));
if (!predBB) break;
int ssaReg = predBB->dataFlowInfo->vRegToSSAMap[vReg];
uses.push_back(ssaReg);
@@ -828,11 +827,11 @@
int numUses = uses.size();
mir->ssaRep->numUses = numUses;
mir->ssaRep->uses =
- static_cast<int*>(oatNew(cUnit, sizeof(int) * numUses, false, kAllocDFInfo));
+ static_cast<int*>(NewMem(cUnit, sizeof(int) * numUses, false, kAllocDFInfo));
mir->ssaRep->fpUse =
- static_cast<bool*>(oatNew(cUnit, sizeof(bool) * numUses, true, kAllocDFInfo));
+ static_cast<bool*>(NewMem(cUnit, sizeof(bool) * numUses, true, kAllocDFInfo));
int* incoming =
- static_cast<int*>(oatNew(cUnit, sizeof(int) * numUses, false, kAllocDFInfo));
+ static_cast<int*>(NewMem(cUnit, sizeof(int) * numUses, false, kAllocDFInfo));
// TODO: Ugly, rework (but don't burden each MIR/LIR for Phi-only needs)
mir->dalvikInsn.vB = reinterpret_cast<uintptr_t>(incoming);
@@ -847,39 +846,39 @@
return true;
}
-void doDFSPreOrderSSARename(CompilationUnit* cUnit, BasicBlock* block)
+static void DoDFSPreOrderSSARename(CompilationUnit* cUnit, BasicBlock* block)
{
if (block->visited || block->hidden) return;
block->visited = true;
/* Process this block */
- oatDoSSAConversion(cUnit, block);
+ DoSSAConversion(cUnit, block);
int mapSize = sizeof(int) * cUnit->numDalvikRegisters;
/* Save SSA map snapshot */
- int* savedSSAMap = static_cast<int*>(oatNew(cUnit, mapSize, false, kAllocDalvikToSSAMap));
+ int* savedSSAMap = static_cast<int*>(NewMem(cUnit, mapSize, false, kAllocDalvikToSSAMap));
memcpy(savedSSAMap, cUnit->vRegToSSAMap, mapSize);
if (block->fallThrough) {
- doDFSPreOrderSSARename(cUnit, block->fallThrough);
+ DoDFSPreOrderSSARename(cUnit, block->fallThrough);
/* Restore SSA map snapshot */
memcpy(cUnit->vRegToSSAMap, savedSSAMap, mapSize);
}
if (block->taken) {
- doDFSPreOrderSSARename(cUnit, block->taken);
+ DoDFSPreOrderSSARename(cUnit, block->taken);
/* Restore SSA map snapshot */
memcpy(cUnit->vRegToSSAMap, savedSSAMap, mapSize);
}
if (block->successorBlockList.blockListType != kNotUsed) {
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&block->successorBlockList.blocks, &iterator);
+ GrowableListIteratorInit(&block->successorBlockList.blocks, &iterator);
while (true) {
SuccessorBlockInfo *successorBlockInfo =
- reinterpret_cast<SuccessorBlockInfo*>(oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<SuccessorBlockInfo*>(GrowableListIteratorNext(&iterator));
if (successorBlockInfo == NULL) break;
BasicBlock* succBB = successorBlockInfo->block;
- doDFSPreOrderSSARename(cUnit, succBB);
+ DoDFSPreOrderSSARename(cUnit, succBB);
/* Restore SSA map snapshot */
memcpy(cUnit->vRegToSSAMap, savedSSAMap, mapSize);
}
@@ -889,45 +888,45 @@
}
/* Perform SSA transformation for the whole method */
-void oatMethodSSATransformation(CompilationUnit* cUnit)
+void SSATransformation(CompilationUnit* cUnit)
{
/* Compute the DFS order */
- computeDFSOrders(cUnit);
+ ComputeDFSOrders(cUnit);
if (!cUnit->disableDataflow) {
/* Compute the dominator info */
- computeDominators(cUnit);
+ ComputeDominators(cUnit);
}
/* Allocate data structures in preparation for SSA conversion */
- oatInitializeSSAConversion(cUnit);
+ CompilerInitializeSSAConversion(cUnit);
if (!cUnit->disableDataflow) {
/* Find out the "Dalvik reg def x block" relation */
- computeDefBlockMatrix(cUnit);
+ ComputeDefBlockMatrix(cUnit);
/* Insert phi nodes to dominance frontiers for all variables */
- insertPhiNodes(cUnit);
+ InsertPhiNodes(cUnit);
}
/* Rename register names by local defs and phi nodes */
- oatDataFlowAnalysisDispatcher(cUnit, oatClearVisitedFlag,
+ DataFlowAnalysisDispatcher(cUnit, ClearVisitedFlag,
kAllNodes, false /* isIterative */);
- doDFSPreOrderSSARename(cUnit, cUnit->entryBlock);
+ DoDFSPreOrderSSARename(cUnit, cUnit->entryBlock);
if (!cUnit->disableDataflow) {
/*
* Shared temp bit vector used by each block to count the number of defs
* from all the predecessor blocks.
*/
- cUnit->tempSSARegisterV = oatAllocBitVector(cUnit, cUnit->numSSARegs,
+ cUnit->tempSSARegisterV = AllocBitVector(cUnit, cUnit->numSSARegs,
false, kBitMapTempSSARegisterV);
cUnit->tempSSABlockIdV =
- static_cast<int*>(oatNew(cUnit, sizeof(int) * cUnit->numSSARegs, false, kAllocDFInfo));
+ static_cast<int*>(NewMem(cUnit, sizeof(int) * cUnit->numSSARegs, false, kAllocDFInfo));
/* Insert phi-operands with latest SSA names from predecessor blocks */
- oatDataFlowAnalysisDispatcher(cUnit, insertPhiNodeOperands,
+ DataFlowAnalysisDispatcher(cUnit, InsertPhiNodeOperands,
kReachableNodes, false /* isIterative */);
}
}
diff --git a/src/compiler/ssa_transformation.h b/src/compiler/ssa_transformation.h
index 4c3ceb3..aef7782 100644
--- a/src/compiler/ssa_transformation.h
+++ b/src/compiler/ssa_transformation.h
@@ -21,7 +21,7 @@
namespace art {
-void oatMethodSSATransformation(CompilationUnit* cUnit);
+void SSATransformation(CompilationUnit* cUnit);
} // namespace art