Quick Compiler function renaming
Move the Quick compiler's function naming to Art coding conventions. Will
be done is pieces: names first, then arguments and locals. Also removed
some dead code and marked statics for the top level source files
No logic changes aside from eliminating a few useless exported "oat"
routines.
Change-Id: Iadaddc560942a0fc1199ba5b1c261cd6ac5cfd9a
diff --git a/src/compiler/codegen/gen_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);
}