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/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