Updating the compiler to use the new-world model
New compiler is integrated and passes first test (Fibonacci).
Change-Id: Ic5448ab89ebd22baa30fafc3d1300324687d1fc2
diff --git a/src/compiler/codegen/arm/ArchUtility.cc b/src/compiler/codegen/arm/ArchUtility.cc
index 16a0200..2f3af44 100644
--- a/src/compiler/codegen/arm/ArchUtility.cc
+++ b/src/compiler/codegen/arm/ArchUtility.cc
@@ -318,8 +318,7 @@
switch(lir->opcode) {
case kArmPseudoMethodEntry:
LOG(INFO) << "-------- method entry " <<
- cUnit->method->clazz->descriptor << ":" <<
- cUnit->method->name;
+ art::PrettyMethod(cUnit->method, true);
break;
case kArmPseudoMethodExit:
LOG(INFO) << "-------- Method_Exit";
@@ -390,8 +389,8 @@
{
const Method *method = cUnit->method;
LOG(INFO) << "/*";
- LOG(INFO) << "Dumping LIR insns for " << method->clazz->descriptor <<
- ":" << method->name;
+ LOG(INFO) << "Dumping LIR insns for " <<
+ art::PrettyMethod(cUnit->method, true);
LIR* lirInsn;
ArmLIR* armLIR;
int insnsSize = cUnit->insnsSize;
@@ -408,7 +407,7 @@
" bytes, Dalvik size is " << insnsSize * 2;
LOG(INFO) << "expansion factor: " <<
(float)cUnit->totalSize / (float)(insnsSize * 2);
- for (int i = 0; i < method->registersSize; i++) {
+ for (int i = 0; i < method->num_registers_; i++) {
RegLocation loc = cUnit->regLocation[i];
char buf[100];
if (loc.fpLocation == kLocPhysReg) {
@@ -425,41 +424,42 @@
}
for (lirInsn = cUnit->firstLIRInsn; lirInsn; lirInsn = lirInsn->next) {
- oatDumpLIRInsn(cUnit, lirInsn, (unsigned char*) cUnit->baseAddr);
+ oatDumpLIRInsn(cUnit, lirInsn, 0);
}
for (lirInsn = cUnit->classPointerList; lirInsn; lirInsn = lirInsn->next) {
armLIR = (ArmLIR*) lirInsn;
char buf[100];
- snprintf(buf, 100, "%p (%04x): .class (%s)",
- (char*)cUnit->baseAddr + armLIR->generic.offset,
- armLIR->generic.offset,
+ snprintf(buf, 100, "%x (%04x): .class (%s)",
+ armLIR->generic.offset, armLIR->generic.offset,
((CallsiteInfo *) armLIR->operands[0])->classDescriptor);
LOG(INFO) << buf;
}
for (lirInsn = cUnit->literalList; lirInsn; lirInsn = lirInsn->next) {
armLIR = (ArmLIR*) lirInsn;
char buf[100];
- snprintf(buf, 100, "%p (%04x): .word (%#x)",
- (char*)cUnit->baseAddr + armLIR->generic.offset,
- armLIR->generic.offset,
+ snprintf(buf, 100, "%x (%04x): .word (%#x)",
+ armLIR->generic.offset, armLIR->generic.offset,
armLIR->operands[0]);
LOG(INFO) << buf;
}
int linebreak = 0;
+ std::string signature = method->GetSignature()->ToModifiedUtf8();
+ std::string name = method->GetName()->ToModifiedUtf8();
+ std::string descriptor = method->GetDeclaringClass()->GetDescriptor()->
+ ToModifiedUtf8();
+
char buf[100];
LOG(INFO) << "*/";
- sprintf(buf,"\n u1 %s%s_%s_code[] = {",
- cUnit->method->clazz->descriptor, cUnit->method->name,
- cUnit->method->shorty);
+ sprintf(buf,"\n u1 %s%s_%s_code[] = {", descriptor.c_str(),
+ name.c_str(), signature.c_str());
for (unsigned int i = 0; i < strlen(buf); i++)
if (buf[i] == ';') buf[i] = '_';
LOG(INFO) << buf;
strcpy(buf," ");
- for (int i = 0; i < cUnit->totalSize; i++) {
- sprintf(buf+strlen(buf),"0x%02x,",
- ((u1*)cUnit->baseAddr)[i]);
+ for (int i = 0; i < cUnit->totalSize/2; i++) {
+ sprintf(buf+strlen(buf),"0x%04x,", cUnit->codeBuffer[i]);
if (++linebreak == 8) {
linebreak = 0;
LOG(INFO) << buf;
@@ -478,8 +478,8 @@
LOG(FATAL) << "Null table";
}
sprintf(buf,"\n MappingTable %s%s_%s_mappingTable[%d] = {",
- cUnit->method->clazz->descriptor, cUnit->method->name,
- cUnit->method->shorty, cUnit->mappingTableSize);
+ descriptor.c_str(), name.c_str(), signature.c_str(),
+ cUnit->mappingTableSize);
for (unsigned int i = 0; i < strlen(buf); i++)
if (buf[i] == ';') buf[i] = '_';
LOG(INFO) << buf;
diff --git a/src/compiler/codegen/arm/ArmRallocUtil.cc b/src/compiler/codegen/arm/ArmRallocUtil.cc
index 2fc1603..0a0c9bc 100644
--- a/src/compiler/codegen/arm/ArmRallocUtil.cc
+++ b/src/compiler/codegen/arm/ArmRallocUtil.cc
@@ -86,7 +86,7 @@
for (i=0; i< ssaRep->numUses; i++) {
int origSreg = DECODE_REG(
oatConvertSSARegToDalvik(cUnit, ssaRep->uses[i]));
- assert(origSreg < cUnit->method->registersSize);
+ assert(origSreg < cUnit->method->num_registers_);
bool fpUse = ssaRep->fpUse ? ssaRep->fpUse[i] : false;
if (fp == fpUse) {
counts[origSreg].count++;
@@ -99,7 +99,7 @@
}
int origSreg = DECODE_REG(
oatConvertSSARegToDalvik(cUnit, ssaRep->defs[i]));
- assert(origSreg < cUnit->method->registersSize);
+ assert(origSreg < cUnit->method->num_registers_);
bool fpDef = ssaRep->fpDef ? ssaRep->fpDef[i] : false;
if (fp == fpDef) {
counts[origSreg].count++;
@@ -131,8 +131,8 @@
*/
extern void oatDoPromotion(CompilationUnit* cUnit)
{
- int numRegs = cUnit->method->registersSize;
- int numIns = cUnit->method->insSize;
+ int numRegs = cUnit->method->num_registers_;
+ int numIns = cUnit->method->num_ins_;
/*
* Because ins don't have explicit definitions, we need to type
@@ -140,10 +140,9 @@
*/
if (numIns > 0) {
int sReg = numRegs - numIns;
- const char *shorty = cUnit->method->shorty;
- shorty++; // Move past return type;
- while (*shorty) {
- char arg = *shorty++;
+ const art::StringPiece& shorty = cUnit->method->GetShorty();
+ for (int i = 1; i < shorty.size(); i++) {
+ char arg = shorty[i];
// Is it wide?
if ((arg == 'D') || (arg == 'J')) {
cUnit->regLocation[sReg].wide = true;
diff --git a/src/compiler/codegen/arm/Assemble.cc b/src/compiler/codegen/arm/Assemble.cc
index a601286..9981d64 100644
--- a/src/compiler/codegen/arm/Assemble.cc
+++ b/src/compiler/codegen/arm/Assemble.cc
@@ -965,13 +965,23 @@
*/
#define PADDING_MOV_R5_R5 0x1C2D
+static void pushWord(std::vector<short>&buf, int data) {
+ buf.push_back( (data >> 16) & 0xffff);
+ buf.push_back( data & 0xffff);
+}
+
+void alignBuffer(std::vector<short>&buf, size_t offset) {
+ while (buf.size() < (offset/2))
+ buf.push_back(0);
+}
+
/* Write the numbers in the constant to the output stream */
static void installLiteralPools(CompilationUnit* cUnit)
{
- int* dataPtr = (int*) ((char*) cUnit->baseAddr + cUnit->dataOffset);
+ alignBuffer(cUnit->codeBuffer, cUnit->dataOffset);
ArmLIR* dataLIR = (ArmLIR*) cUnit->literalList;
while (dataLIR) {
- *dataPtr++ = dataLIR->operands[0];
+ pushWord(cUnit->codeBuffer, dataLIR->operands[0]);
dataLIR = NEXT_LIR(dataLIR);
}
}
@@ -985,7 +995,7 @@
SwitchTable* tabRec = (SwitchTable *) oatGrowableListIteratorNext(
&iterator);
if (tabRec == NULL) break;
- int* dataPtr = (int*)((char*)cUnit->baseAddr + tabRec->offset);
+ alignBuffer(cUnit->codeBuffer, tabRec->offset);
int bxOffset = tabRec->bxInst->generic.offset + 4;
if (cUnit->printMe) {
LOG(INFO) << "Switch table for offset 0x" /*<< hex*/ << bxOffset;
@@ -999,8 +1009,9 @@
std::hex << keys[elems] << ", disp: 0x" <<
std::hex << disp;
}
- *dataPtr++ = keys[elems];
- *dataPtr++ = tabRec->targets[elems]->generic.offset - bxOffset;
+ pushWord(cUnit->codeBuffer, keys[elems]);
+ pushWord(cUnit->codeBuffer,
+ tabRec->targets[elems]->generic.offset - bxOffset);
}
} else {
assert(tabRec->table[0] == kPackedSwitchSignature);
@@ -1010,7 +1021,8 @@
LOG(INFO) << " Case[" << elems << "] disp: 0x" <<
std::hex << disp;
}
- *dataPtr++ = tabRec->targets[elems]->generic.offset - bxOffset;
+ pushWord(cUnit->codeBuffer,
+ tabRec->targets[elems]->generic.offset - bxOffset);
}
}
}
@@ -1025,8 +1037,10 @@
FillArrayData *tabRec = (FillArrayData *) oatGrowableListIteratorNext(
&iterator);
if (tabRec == NULL) break;
- char* dataPtr = (char*)cUnit->baseAddr + tabRec->offset;
- memcpy(dataPtr, (char*)tabRec->table, tabRec->size);
+ alignBuffer(cUnit->codeBuffer, tabRec->offset);
+ cUnit->codeBuffer.reserve(cUnit->codeBuffer.size() + (tabRec->size/2));
+ memcpy(&cUnit->codeBuffer[tabRec->offset/2],
+ (char*)tabRec->table, tabRec->size);
}
}
@@ -1038,7 +1052,6 @@
static AssemblerStatus assembleInstructions(CompilationUnit* cUnit,
intptr_t startAddr)
{
- short* bufferAddr = (short*) cUnit->codeBuffer;
ArmLIR* lir;
AssemblerStatus res = kSuccess; // Assume success
@@ -1047,7 +1060,7 @@
if ((lir->opcode == kArmPseudoPseudoAlign4) &&
/* 1 means padding is needed */
(lir->operands[0] == 1)) {
- *bufferAddr++ = PADDING_MOV_R5_R5;
+ cUnit->codeBuffer.push_back(PADDING_MOV_R5_R5);
}
continue;
}
@@ -1394,9 +1407,9 @@
}
}
if (encoder->size == 2) {
- *bufferAddr++ = (bits >> 16) & 0xffff;
+ cUnit->codeBuffer.push_back((bits >> 16) & 0xffff);
}
- *bufferAddr++ = bits & 0xffff;
+ cUnit->codeBuffer.push_back(bits & 0xffff);
}
return res;
}
@@ -1526,23 +1539,6 @@
void oatAssembleLIR(CompilationUnit* cUnit)
{
assignOffsets(cUnit);
-
-#ifdef TESTMODE
-//For testing - caller will allocate buffer
- int testSize = 1024 * 1024;
- int fd = ashmem_create_region("dalvik-test-code-cache",testSize);
- if (fd < 0) {
- LOG(FATAL) << "Coudln't create ashmem region";
- }
- cUnit->baseAddr = cUnit->codeBuffer = (unsigned char *)
- mmap(NULL, testSize, PROT_READ | PROT_WRITE | PROT_EXEC,
- MAP_PRIVATE, fd, 0);
- close(fd);
- if (cUnit->baseAddr == MAP_FAILED) {
- LOG(FATAL) << "Failed to mmap the test region: " << strerror(errno);
- }
-#endif
-
/*
* 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.
@@ -1559,6 +1555,7 @@
}
// Redo offsets and try again
assignOffsets(cUnit);
+ cUnit->codeBuffer.clear();
}
}
diff --git a/src/compiler/codegen/arm/MethodCodegenDriver.cc b/src/compiler/codegen/arm/MethodCodegenDriver.cc
index 417fdca..b8dcdb2 100644
--- a/src/compiler/codegen/arm/MethodCodegenDriver.cc
+++ b/src/compiler/codegen/arm/MethodCodegenDriver.cc
@@ -14,12 +14,6 @@
* limitations under the License.
*/
-//#define TESTMODE
-
-#ifdef TESTMODE
-#include "CalloutHelper.h"
-#endif
-
static const RegLocation badLoc = {kLocDalvikFrame, 0, 0, INVALID_REG,
INVALID_REG, INVALID_SREG, 0,
kLocDalvikFrame, INVALID_REG, INVALID_REG,
@@ -31,8 +25,8 @@
RegLocation rlSrc)
{
oatFlushAllRegs(cUnit); /* All temps to home location */
- void* classPtr = (void*)
- (cUnit->method->clazz->pDvmDex->pResClasses[mir->dalvikInsn.vC]);
+ Class* classPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
+ GetResolvedClass(mir->dalvikInsn.vC);
if (classPtr == NULL) {
LOG(FATAL) << "Unexpected null passPtr";
} else {
@@ -41,14 +35,8 @@
}
// FIXME: need this to throw errNegativeArraySize
genRegImmCheck(cUnit, kArmCondMi, r1, 0, mir->offset, NULL);
-#ifdef TESTMODE
-// Hack until we get rSELF setup
- loadConstant(cUnit, rLR, (int)dvmAllocArrayByClass);
-#else
loadWordDisp(cUnit, rSELF, OFFSETOF_MEMBER(Thread, pArtAllocArrayByClass),
rLR);
-#endif
- loadConstant(cUnit, r2, ALLOC_DONT_TRACK);
newLIR1(cUnit, kThumbBlxR, rLR); // (arrayClass, length, allocFlags)
storeValue(cUnit, rlDest, retLoc);
}
@@ -72,8 +60,8 @@
typeIndex = dInsn->vC;
}
oatFlushAllRegs(cUnit); /* All temps to home location */
- void* classPtr = (void*)
- (cUnit->method->clazz->pDvmDex->pResClasses[typeIndex]);
+ Class* classPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
+ GetResolvedClass(typeIndex);
if (classPtr == NULL) {
LOG(FATAL) << "Unexpected null passPtr";
} else {
@@ -88,14 +76,8 @@
* the above mentioned bad cases of 'D', 'J' or !('L' | '[' | 'I').
* That will keep us from wasting space generating an inline check here.
*/
-#ifdef TESTMODE
-// Hack until we get rSELF setup
- loadConstant(cUnit, rLR, (int)dvmAllocArrayByClass);
-#else
loadWordDisp(cUnit, rSELF, OFFSETOF_MEMBER(Thread, pArtAllocArrayByClass),
rLR);
-#endif
- loadConstant(cUnit, r2, ALLOC_DONT_TRACK);
newLIR1(cUnit, kThumbBlxR, rLR); // (arrayClass, length, allocFlags)
// Reserve ret0 (r0) - we'll use it in place.
oatLockTemp(cUnit, r0);
@@ -130,7 +112,7 @@
opRegRegImm(cUnit, kOpAdd, rSrc, rSP, rlFirst.spOffset);
// Set up the target pointer
opRegRegImm(cUnit, kOpAdd, rDst, r0,
- OFFSETOF_MEMBER(ArrayObject, contents));
+ Array::DataOffset().Int32Value());
// Set up the loop counter (known to be > 0)
loadConstant(cUnit, rIdx, dInsn->vA);
// Generate the copy loop. Going backwards for convenience
@@ -148,7 +130,8 @@
for (unsigned int i = 0; i < dInsn->vA; i++) {
RegLocation rlArg = loadValue(cUnit,
oatGetSrc(cUnit, mir, i), kCoreReg);
- storeBaseDisp(cUnit, r0, OFFSETOF_MEMBER(ArrayObject, contents) +
+ storeBaseDisp(cUnit, r0,
+ Array::DataOffset().Int32Value() +
i * 4, rlArg.lowReg, kWord);
// If the loadValue caused a temp to be allocated, free it
if (oatIsTemp(cUnit, rlArg.lowReg)) {
@@ -160,6 +143,8 @@
static void genSput(CompilationUnit* cUnit, MIR* mir, RegLocation rlSrc)
{
+ UNIMPLEMENTED(FATAL) << "Must update for new world";
+#if 0
int valOffset = OFFSETOF_MEMBER(StaticField, value);
int tReg = oatAllocTemp(cUnit);
int objHead;
@@ -181,9 +166,9 @@
(opcode == OP_SPUT_VOLATILE_JUMBO) ||
(opcode == OP_SPUT_OBJECT_VOLATILE) ||
(opcode == OP_SPUT_OBJECT_VOLATILE_JUMBO);
- assert(isVolatile == dvmIsVolatileField((Field *) fieldPtr));
+ assert(isVolatile == artIsVolatileField((Field *) fieldPtr));
#else
- isVolatile = dvmIsVolatileField((Field *) fieldPtr);
+ isVolatile = artIsVolatileField((Field *) fieldPtr);
#endif
isSputObject = (opcode == OP_SPUT_OBJECT) ||
@@ -206,10 +191,13 @@
markGCCard(cUnit, rlSrc.lowReg, objHead);
oatFreeTemp(cUnit, objHead);
}
+#endif
}
static void genSputWide(CompilationUnit* cUnit, MIR* mir, RegLocation rlSrc)
{
+ UNIMPLEMENTED(FATAL) << "Must update for new world";
+#if 0
int tReg = oatAllocTemp(cUnit);
int valOffset = OFFSETOF_MEMBER(StaticField, value);
const Method *method = (mir->OptimizationFlags & MIR_CALLEE) ?
@@ -227,6 +215,7 @@
loadConstant(cUnit, tReg, (int) fieldPtr + valOffset);
storePair(cUnit, tReg, rlSrc.lowReg, rlSrc.highReg);
+#endif
}
@@ -234,6 +223,8 @@
static void genSgetWide(CompilationUnit* cUnit, MIR* mir,
RegLocation rlResult, RegLocation rlDest)
{
+ UNIMPLEMENTED(FATAL) << "Must update for new world";
+#if 0
int valOffset = OFFSETOF_MEMBER(StaticField, value);
const Method *method = (mir->OptimizationFlags & MIR_CALLEE) ?
mir->meta.calleeMethod : cUnit->method;
@@ -253,11 +244,14 @@
loadPair(cUnit, tReg, rlResult.lowReg, rlResult.highReg);
storeValueWide(cUnit, rlDest, rlResult);
+#endif
}
static void genSget(CompilationUnit* cUnit, MIR* mir,
RegLocation rlResult, RegLocation rlDest)
{
+ UNIMPLEMENTED(FATAL) << "Must update for new world";
+#if 0
int valOffset = OFFSETOF_MEMBER(StaticField, value);
int tReg = oatAllocTemp(cUnit);
bool isVolatile;
@@ -282,9 +276,9 @@
Opcode opcode = mir->dalvikInsn.opcode;
isVolatile = (opcode == OP_SGET_VOLATILE) ||
(opcode == OP_SGET_OBJECT_VOLATILE);
- assert(isVolatile == dvmIsVolatileField((Field *) fieldPtr));
+ assert(isVolatile == artIsVolatileField((Field *) fieldPtr));
#else
- isVolatile = dvmIsVolatileField((Field *) fieldPtr);
+ isVolatile = artIsVolatileField((Field *) fieldPtr);
#endif
rlDest = oatGetDest(cUnit, mir, 0);
@@ -297,6 +291,7 @@
loadWordDisp(cUnit, tReg, 0, rlResult.lowReg);
storeValue(cUnit, rlDest, rlResult);
+#endif
}
typedef int (*NextCallInsn)(CompilationUnit*, MIR*, DecodedInstruction*, int);
@@ -308,11 +303,14 @@
static int nextSDCallInsn(CompilationUnit* cUnit, MIR* mir,
DecodedInstruction* dInsn, int state)
{
+ UNIMPLEMENTED(FATAL) << "Update with new cache model";
+#if 0
switch(state) {
case 0: // Get the current Method* [sets r0]
loadBaseDisp(cUnit, mir, rSP, 0, r0, kWord, INVALID_SREG);
break;
case 1: // Get the pResMethods pointer [uses r0, sets r0]
+ UNIMPLEMENTED(FATAL) << "Update with new cache";
loadBaseDisp(cUnit, mir, r0, OFFSETOF_MEMBER(Method, pResMethods),
r0, kWord, INVALID_SREG);
break;
@@ -328,6 +326,7 @@
default:
return -1;
}
+#endif
return state + 1;
}
@@ -341,6 +340,8 @@
static int nextVCallInsn(CompilationUnit* cUnit, MIR* mir,
DecodedInstruction* dInsn, int state)
{
+ UNIMPLEMENTED(FATAL) << "Update with new cache model";
+#if 0
RegLocation rlArg;
switch(state) {
case 0: // Get the current Method* [set r0]
@@ -368,19 +369,21 @@
r12, kUnsignedHalf, INVALID_SREG);
// get this->clazz->vtable [use rLR, set rLR]
loadBaseDisp(cUnit, mir, rLR,
- OFFSETOF_MEMBER(ClassObject, vtable), rLR, kWord,
+ OFFSETOF_MEMBER(Class, vtable), rLR, kWord,
INVALID_SREG);
break;
case 4: // get target Method* [use rLR, use r12, set r0]
loadBaseIndexed(cUnit, rLR, r12, r0, 2, kWord);
break;
case 5: // Get the target compiled code address [use r0, set rLR]
+ UNIMPLEMENTED(FATAL) << "Update with new cache";
loadBaseDisp(cUnit, mir, r0, OFFSETOF_MEMBER(Method, compiledInsns),
rLR, kWord, INVALID_SREG);
break;
default:
return -1;
}
+#endif
return state + 1;
}
@@ -412,6 +415,8 @@
static int nextInterfaceCallInsn(CompilationUnit* cUnit, MIR* mir,
DecodedInstruction* dInsn, int state)
{
+ UNIMPLEMENTED(FATAL) << "Update with new cache model";
+#if 0
RegLocation rlArg;
switch(state) {
case 0:
@@ -427,14 +432,14 @@
loadBaseDisp(cUnit, mir, r2, OFFSETOF_MEMBER(Method, clazz),
r3, kWord, INVALID_SREG);
// Load this->class [usr r12, set arg0]
- loadBaseDisp(cUnit, mir, r12, OFFSETOF_MEMBER(ClassObject, clazz),
+ loadBaseDisp(cUnit, mir, r12, OFFSETOF_MEMBER(Class, clazz),
r3, kWord, INVALID_SREG);
// Load address of helper function
loadBaseDisp(cUnit, mir, rSELF,
OFFSETOF_MEMBER(Thread, pArtFindInterfaceMethodInCache),
rLR, kWord, INVALID_SREG);
// Get dvmDex
- loadBaseDisp(cUnit, mir, r3, OFFSETOF_MEMBER(ClassObject, pDvmDex),
+ loadBaseDisp(cUnit, mir, r3, OFFSETOF_MEMBER(Class, pDvmDex),
r3, kWord, INVALID_SREG);
// Load ref [set arg1]
loadConstant(cUnit, r1, dInsn->vB);
@@ -447,6 +452,7 @@
default:
return -1;
}
+#endif
return state + 1;
}
@@ -458,6 +464,8 @@
static int nextSuperCallInsn(CompilationUnit* cUnit, MIR* mir,
DecodedInstruction* dInsn, int state)
{
+ UNIMPLEMENTED(FATAL) << "Update with new cache model";
+#if 0
RegLocation rlArg;
switch(state) {
case 0:
@@ -473,7 +481,7 @@
loadBaseDisp(cUnit, mir, r0, OFFSETOF_MEMBER(Method, pResMethods),
rLR, kWord, INVALID_SREG);
// Get clazz->super [use r12, set r12]
- loadBaseDisp(cUnit, mir, r12, OFFSETOF_MEMBER(ClassObject, super),
+ loadBaseDisp(cUnit, mir, r12, OFFSETOF_MEMBER(Class, super),
r12, kWord, INVALID_SREG);
// Get base method [use rLR, set r0]
loadBaseDisp(cUnit, mir, rLR, dInsn->vB * 4, r0,
@@ -486,7 +494,7 @@
rLR, kUnsignedHalf, INVALID_SREG);
// Get vtableCount [use r12, set r0]
loadBaseDisp(cUnit, mir, r12,
- OFFSETOF_MEMBER(ClassObject, vtableCount),
+ OFFSETOF_MEMBER(Class, vtableCount),
r0, kWord, INVALID_SREG);
// Compare method index w/ vtable count [use r12, use rLR]
genRegRegCheck(cUnit, kArmCondGe, rLR, r0, mir->offset, NULL);
@@ -498,6 +506,7 @@
default:
return -1;
}
+#endif
return state + 1;
}
@@ -591,7 +600,8 @@
* Dalvik vRegs and the ins.
*/
int highestVreg = oatGetSrc(cUnit, mir, numArgs-1).sRegLow;
- if (highestVreg >= cUnit->method->registersSize - cUnit->method->insSize) {
+ if (highestVreg >= cUnit->method->num_registers_ -
+ cUnit->method->num_ins_) {
LOG(FATAL) << "Wide argument spanned locals & args";
}
@@ -622,7 +632,7 @@
newLIR1(cUnit, kThumbBlxR, rLR);
} else {
// Use vldm/vstm pair using r3 as a temp
- int regsLeft = MIN(numArgs - 3, 16);
+ int regsLeft = std::min(numArgs - 3, 16);
callState = nextCallInsn(cUnit, mir, dInsn, callState);
opRegRegImm(cUnit, kOpAdd, r3, rSP, startOffset);
newLIR3(cUnit, kThumb2Vldms, r3, fr0 & FP_REG_MASK, regsLeft);
@@ -791,7 +801,7 @@
case OP_MOVE_EXCEPTION:
int exOffset;
int resetReg;
- exOffset = OFFSETOF_MEMBER(Thread, exception);
+ exOffset = Thread::ExceptionOffset().Int32Value();
resetReg = oatAllocTemp(cUnit);
rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
loadWordDisp(cUnit, rSELF, exOffset, rlResult.lowReg);
@@ -923,7 +933,7 @@
case OP_ARRAY_LENGTH:
int lenOffset;
- lenOffset = OFFSETOF_MEMBER(ArrayObject, length);
+ lenOffset = Array::LengthOffset().Int32Value();
genNullCheck(cUnit, rlSrc[0].sRegLow, rlSrc[0].lowReg,
mir->offset, NULL);
rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
@@ -1101,7 +1111,7 @@
genArrayPut(cUnit, mir, kWord, rlSrc[1], rlSrc[2], rlSrc[0], 2);
break;
case OP_APUT_OBJECT:
- genArrayObjectPut(cUnit, mir, rlSrc[1], rlSrc[2], rlSrc[0], 2);
+ genArrayPut(cUnit, mir, rlSrc[1], rlSrc[2], rlSrc[0], 2);
break;
case OP_APUT_SHORT:
case OP_APUT_CHAR:
@@ -1432,11 +1442,11 @@
* Note: at this pointCopy any ins that are passed in register to their home location */
static void flushIns(CompilationUnit* cUnit)
{
- if (cUnit->method->insSize == 0)
+ if (cUnit->method->num_ins_ == 0)
return;
- int inRegs = (cUnit->method->insSize > 2) ? 3 : cUnit->method->insSize;
+ int inRegs = (cUnit->method->num_ins_ > 2) ? 3 : cUnit->method->num_ins_;
int startReg = r1;
- int startLoc = cUnit->method->registersSize - cUnit->method->insSize;
+ int startLoc = cUnit->method->num_registers_ - cUnit->method->num_ins_;
for (int i = 0; i < inRegs; i++) {
RegLocation loc = cUnit->regLocation[startLoc + i];
if (loc.location == kLocPhysReg) {
@@ -1459,7 +1469,7 @@
}
// Now, do initial assignment of all promoted arguments passed in frame
- for (int i = inRegs; i < cUnit->method->insSize;) {
+ for (int i = inRegs; i < cUnit->method->num_ins_;) {
RegLocation loc = cUnit->regLocation[startLoc + i];
if (loc.fpLocation == kLocPhysReg) {
loc.location = kLocPhysReg;
@@ -1721,45 +1731,3 @@
{
storeBaseDispWide(cUnit, rBase, displacement, rSrcLo, rSrcHi);
}
-
-#ifdef TESTMODE
-// Will be done at runtime by art. Keep for debugging
-void oatInitHelpers(Thread* thread)
-{
- thread->pMemcpy = memcpy;
- thread->pI2f = __aeabi_i2f;
- thread->pF2iz = __aeabi_f2iz;
- thread->pD2f = __aeabi_d2f;
- thread->pF2d = __aeabi_f2d;
- thread->pI2d = __aeabi_i2d;
- thread->pD2iz = __aeabi_d2iz;
- thread->pL2f = __aeabi_l2f;
- thread->pL2d = __aeabi_l2d;
- thread->pArtF2l = artF2L;
- thread->pArtD2l = artD2L;
- thread->pFadd = __aeabi_fadd;
- thread->pFsub = __aeabi_fsub;
- thread->pFdiv = __aeabi_fdiv;
- thread->pFmul = __aeabi_fmul;
- thread->pFmodf = fmodf;
- thread->pDadd = __aeabi_dadd;
- thread->pDsub = __aeabi_dsub;
- thread->pDdiv = __aeabi_ddiv;
- thread->pDmul = __aeabi_dmul;
- thread->pFmod = fmod;
- thread->pIdivmod = __aeabi_idivmod;
- thread->pIdiv = __aeabi_idiv;
- thread->pLdivmod = __aeabi_ldivmod;
- thread->pArtUnlockObject = dvmUnlockObject;
- thread->pArtCanPutArrayElementNoThrow = dvmCanPutArrayElement;
- thread->pArtInstanceofNonTrivialNoThrow = dvmInstanceofNonTrivial;
- thread->pArtInstanceofNonTrivial = dvmInstanceofNonTrivial;
- thread->pArtAllocArrayByClass = dvmAllocArrayByClass;
- thread->pArtFindInterfaceMethodInCache = dvmFindInterfaceMethodInCache;
- thread->pArtUnlockObjectNoThrow = dvmUnlockObject;
- thread->pArtLockObjectNoThrow = dvmLockObject;
- thread->pArtAllocObjectNoThrow = dvmAllocObject;
- thread->pArtThrowException = NULL; //TBD
- thread->pArtHandleFillArrayDataNoThrow = dvmInterpHandleFillArrayData;
-}
-#endif
diff --git a/src/compiler/codegen/arm/Thumb2/Gen.cc b/src/compiler/codegen/arm/Thumb2/Gen.cc
index c9d72f7..1a126e4 100644
--- a/src/compiler/codegen/arm/Thumb2/Gen.cc
+++ b/src/compiler/codegen/arm/Thumb2/Gen.cc
@@ -356,7 +356,7 @@
int regCardBase = oatAllocTemp(cUnit);
int regCardNo = oatAllocTemp(cUnit);
ArmLIR* branchOver = genCmpImmBranch(cUnit, kArmCondEq, valReg, 0);
- loadWordDisp(cUnit, rSELF, offsetof(Thread, cardTable),
+ loadWordDisp(cUnit, rSELF, Thread::CardTableOffset().Int32Value(),
regCardBase);
opRegRegImm(cUnit, kOpLsr, regCardNo, tgtAddrReg, GC_CARD_SHIFT);
storeBaseIndexed(cUnit, regCardBase, regCardNo, regCardBase, 0,
@@ -371,8 +371,8 @@
static void genIGetX(CompilationUnit* cUnit, MIR* mir, OpSize size,
RegLocation rlDest, RegLocation rlObj)
{
- Field* fieldPtr =
- cUnit->method->clazz->pDvmDex->pResFields[mir->dalvikInsn.vC];
+ Field* fieldPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
+ GetResolvedField(mir->dalvikInsn.vC);
if (fieldPtr == NULL) {
/*
* With current scheme, we should never be in a situation
@@ -387,7 +387,7 @@
#else
bool isVolatile = false;
#endif
- int fieldOffset = ((InstField *)fieldPtr)->byteOffset;
+ int fieldOffset = fieldPtr->GetOffset();
RegLocation rlResult;
RegisterClass regClass = oatRegClassBySize(size);
rlObj = loadValue(cUnit, rlObj, kCoreReg);
@@ -406,8 +406,8 @@
static void genIPutX(CompilationUnit* cUnit, MIR* mir, OpSize size,
RegLocation rlSrc, RegLocation rlObj, bool isObject)
{
- Field* fieldPtr =
- cUnit->method->clazz->pDvmDex->pResFields[mir->dalvikInsn.vC];
+ Field* fieldPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
+ GetResolvedField(mir->dalvikInsn.vC);
if (fieldPtr == NULL) {
/*
* With current scheme, we should never be in a situation
@@ -422,7 +422,7 @@
#else
bool isVolatile = false;
#endif
- int fieldOffset = ((InstField *)fieldPtr)->byteOffset;
+ int fieldOffset = fieldPtr->GetOffset();
RegisterClass regClass = oatRegClassBySize(size);
rlObj = loadValue(cUnit, rlObj, kCoreReg);
rlSrc = loadValue(cUnit, rlSrc, regClass);
@@ -442,8 +442,8 @@
static void genIGetWideX(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
RegLocation rlObj)
{
- Field* fieldPtr =
- cUnit->method->clazz->pDvmDex->pResFields[mir->dalvikInsn.vC];
+ Field* fieldPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
+ GetResolvedField(mir->dalvikInsn.vC);
if (fieldPtr == NULL) {
/*
* With current scheme, we should never be in a situation
@@ -458,7 +458,7 @@
#else
bool isVolatile = false;
#endif
- int fieldOffset = ((InstField *)fieldPtr)->byteOffset;
+ int fieldOffset = fieldPtr->GetOffset();
RegLocation rlResult;
rlObj = loadValue(cUnit, rlObj, kCoreReg);
int regPtr = oatAllocTemp(cUnit);
@@ -483,8 +483,8 @@
static void genIPutWideX(CompilationUnit* cUnit, MIR* mir, RegLocation rlSrc,
RegLocation rlObj)
{
- Field* fieldPtr =
- cUnit->method->clazz->pDvmDex->pResFields[mir->dalvikInsn.vC];
+ Field* fieldPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
+ GetResolvedField(mir->dalvikInsn.vC);
if (fieldPtr == NULL) {
/*
* With current scheme, we should never be in a situation
@@ -499,7 +499,7 @@
#else
bool isVolatile = false;
#endif
- int fieldOffset = ((InstField *)fieldPtr)->byteOffset;
+ int fieldOffset = fieldPtr->GetOffset();
rlObj = loadValue(cUnit, rlObj, kCoreReg);
int regPtr;
@@ -520,13 +520,14 @@
static void genConstClass(CompilationUnit* cUnit, MIR* mir,
RegLocation rlDest, RegLocation rlSrc)
{
- void* classPtr = (void*)
- (cUnit->method->clazz->pDvmDex->pResClasses[mir->dalvikInsn.vB]);
+ Class* classPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
+ GetResolvedClass(mir->dalvikInsn.vB);
if (classPtr == NULL) {
LOG(FATAL) << "Unexpected null class pointer";
}
+ UNIMPLEMENTED(WARNING) << "Not position independent. Fix";
RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
loadConstantNoClobber(cUnit, rlResult.lowReg, (int) classPtr );
storeValue(cUnit, rlDest, rlResult);
@@ -535,14 +536,15 @@
static void genConstString(CompilationUnit* cUnit, MIR* mir,
RegLocation rlDest, RegLocation rlSrc)
{
- void* strPtr = (void*)
- (cUnit->method->clazz->pDvmDex->pResStrings[mir->dalvikInsn.vB]);
+ String* strPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
+ GetResolvedString(mir->dalvikInsn.vB);
if (strPtr == NULL) {
/* Shouldn't happen */
LOG(FATAL) << "Unexpected null const string pointer";
}
+ UNIMPLEMENTED(WARNING) << "Not position indendent. Fix";
RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
loadConstantNoClobber(cUnit, rlResult.lowReg, (int) strPtr );
storeValue(cUnit, rlDest, rlResult);
@@ -551,8 +553,8 @@
static void genNewInstance(CompilationUnit* cUnit, MIR* mir,
RegLocation rlDest)
{
- ClassObject* classPtr = (ClassObject *)
- (cUnit->method->clazz->pDvmDex->pResClasses[mir->dalvikInsn.vB]);
+ Class* classPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
+ GetResolvedClass(mir->dalvikInsn.vB);
if (classPtr == NULL) {
/* Shouldn't happen */
@@ -560,12 +562,13 @@
}
// Verifier should have already rejected abstract/interface
- assert((classPtr->accessFlags & (ACC_INTERFACE|ACC_ABSTRACT)) == 0);
+ assert((classPtr->access_flags_ &
+ (art::kAccInterface|art::kAccAbstract)) == 0);
oatFlushAllRegs(cUnit); /* Everything to home location */
loadWordDisp(cUnit, rSELF,
OFFSETOF_MEMBER(Thread, pArtAllocObjectNoThrow), rLR);
loadConstant(cUnit, r0, (int) classPtr);
- loadConstant(cUnit, r1, ALLOC_DONT_TRACK);
+ UNIMPLEMENTED(WARNING) << "Need NewWorld dvmAllocObject";
opReg(cUnit, kOpBlx, rLR);
oatClobberCallRegs(cUnit);
RegLocation rlResult = oatGetReturn(cUnit);
@@ -586,8 +589,8 @@
{
// May generate a call - use explicit registers
RegLocation rlResult;
- ClassObject* classPtr =
- (cUnit->method->clazz->pDvmDex->pResClasses[mir->dalvikInsn.vC]);
+ Class* classPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
+ GetResolvedClass(mir->dalvikInsn.vC);
if (classPtr == NULL) {
/* Shouldn't happen */
LOG(FATAL) << "Unexpected null class pointer";
@@ -598,7 +601,8 @@
/* When taken r0 has NULL which can be used for store directly */
ArmLIR* branch1 = genCmpImmBranch(cUnit, kArmCondEq, r0, 0);
/* r1 now contains object->clazz */
- loadWordDisp(cUnit, r0, offsetof(Object, clazz), r1);
+ assert(OFFSETOF_MEMBER(Object, klass_) == 0);
+ loadWordDisp(cUnit, r0, OFFSETOF_MEMBER(Object, klass_), r1);
/* r1 now contains object->clazz */
loadWordDisp(cUnit, rSELF,
OFFSETOF_MEMBER(Thread, pArtInstanceofNonTrivial), rLR);
@@ -620,8 +624,8 @@
static void genCheckCast(CompilationUnit* cUnit, MIR* mir, RegLocation rlSrc)
{
- ClassObject* classPtr =
- (cUnit->method->clazz->pDvmDex->pResClasses[mir->dalvikInsn.vB]);
+ Class* classPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
+ GetResolvedClass(mir->dalvikInsn.vB);
if (classPtr == NULL) {
/* Shouldn't happen with our current model */
LOG(FATAL) << "Unexpected null class pointer";
@@ -639,7 +643,7 @@
* with clazz.
*/
/* r0 now contains object->clazz */
- loadWordDisp(cUnit, rlSrc.lowReg, offsetof(Object, clazz), r0);
+ loadWordDisp(cUnit, rlSrc.lowReg, OFFSETOF_MEMBER(Object, klass_), r0);
loadWordDisp(cUnit, rSELF,
OFFSETOF_MEMBER(Thread, pArtInstanceofNonTrivialNoThrow), rLR);
opRegReg(cUnit, kOpCmp, r0, r1);
@@ -783,20 +787,23 @@
ArmLIR* hopBranch;
oatFlushAllRegs(cUnit);
- assert(LW_SHAPE_THIN == 0);
+ assert(art::Monitor::kLwShapeThin == 0);
loadValueDirectFixed(cUnit, rlSrc, r1); // Get obj
oatLockAllTemps(cUnit); // Prepare for explicit register usage
genNullCheck(cUnit, rlSrc.sRegLow, r1, mir->offset, NULL);
- loadWordDisp(cUnit, rSELF, offsetof(Thread, threadId), r3); // Get threadId
+ loadWordDisp(cUnit, rSELF, Thread::IdOffset().Int32Value(), r3);
newLIR3(cUnit, kThumb2Ldrex, r2, r1,
- offsetof(Object, lock) >> 2); // Get object->lock
- opRegImm(cUnit, kOpLsl, r3, LW_LOCK_OWNER_SHIFT); // Align owner
+ OFFSETOF_MEMBER(Object, monitor_) >> 2); // Get object->lock
+ // Align owner
+ opRegImm(cUnit, kOpLsl, r3, art::Monitor::kLwLockOwnerShift);
// Is lock unheld on lock or held by us (==threadId) on unlock?
- newLIR4(cUnit, kThumb2Bfi, r3, r2, 0, LW_LOCK_OWNER_SHIFT - 1);
- newLIR3(cUnit, kThumb2Bfc, r2, LW_HASH_STATE_SHIFT,
- LW_LOCK_OWNER_SHIFT - 1);
+ newLIR4(cUnit, kThumb2Bfi, r3, r2, 0, art::Monitor::kLwLockOwnerShift
+ - 1);
+ newLIR3(cUnit, kThumb2Bfc, r2, art::Monitor::kLwHashStateShift,
+ art::Monitor::kLwLockOwnerShift - 1);
hopBranch = newLIR2(cUnit, kThumb2Cbnz, r2, 0);
- newLIR4(cUnit, kThumb2Strex, r2, r3, r1, offsetof(Object, lock) >> 2);
+ newLIR4(cUnit, kThumb2Strex, r2, r3, r1,
+ OFFSETOF_MEMBER(Object, monitor_) >> 2);
oatGenMemBarrier(cUnit, kSY);
branch = newLIR2(cUnit, kThumb2Cbz, r2, 0);
@@ -830,23 +837,24 @@
ArmLIR* hopTarget;
ArmLIR* hopBranch;
- assert(LW_SHAPE_THIN == 0);
+ assert(art::Monitor::kLwShapeThin == 0);
oatFlushAllRegs(cUnit);
loadValueDirectFixed(cUnit, rlSrc, r1); // Get obj
oatLockAllTemps(cUnit); // Prepare for explicit register usage
genNullCheck(cUnit, rlSrc.sRegLow, r1, mir->offset, NULL);
- loadWordDisp(cUnit, r1, offsetof(Object, lock), r2); // Get object->lock
- loadWordDisp(cUnit, rSELF, offsetof(Thread, threadId), r3); // Get threadId
+ loadWordDisp(cUnit, r1, OFFSETOF_MEMBER(Object, monitor_), r2); // Get lock
+ loadWordDisp(cUnit, rSELF, Thread::IdOffset().Int32Value(), r3);
// Is lock unheld on lock or held by us (==threadId) on unlock?
- opRegRegImm(cUnit, kOpAnd, r12, r2,
- (LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT));
- opRegImm(cUnit, kOpLsl, r3, LW_LOCK_OWNER_SHIFT); // Align owner
- newLIR3(cUnit, kThumb2Bfc, r2, LW_HASH_STATE_SHIFT,
- LW_LOCK_OWNER_SHIFT - 1);
+ opRegRegImm(cUnit, kOpAnd, r12, r2, (art::Monitor::kLwHashStateMask <<
+ art::Monitor::kLwHashStateShift));
+ // Align owner
+ opRegImm(cUnit, kOpLsl, r3, art::Monitor::kLwLockOwnerShift);
+ newLIR3(cUnit, kThumb2Bfc, r2, art::Monitor::kLwHashStateShift,
+ art::Monitor::kLwLockOwnerShift - 1);
opRegReg(cUnit, kOpSub, r2, r3);
hopBranch = opCondBranch(cUnit, kArmCondNe);
oatGenMemBarrier(cUnit, kSY);
- storeWordDisp(cUnit, r1, offsetof(Object, lock), r12);
+ storeWordDisp(cUnit, r1, OFFSETOF_MEMBER(Object, monitor_), r12);
branch = opNone(cUnit, kOpUncondBr);
hopTarget = newLIR0(cUnit, kArmPseudoTargetLabel);
@@ -1116,13 +1124,13 @@
* Generate array store
*
*/
-static void genArrayObjectPut(CompilationUnit* cUnit, MIR* mir,
+static void genArrayPut(CompilationUnit* cUnit, MIR* mir,
RegLocation rlArray, RegLocation rlIndex,
RegLocation rlSrc, int scale)
{
RegisterClass regClass = oatRegClassBySize(kWord);
- int lenOffset = OFFSETOF_MEMBER(ArrayObject, length);
- int dataOffset = OFFSETOF_MEMBER(ArrayObject, contents);
+ int lenOffset = Array::LengthOffset().Int32Value();
+ int dataOffset = Array::DataOffset().Int32Value();
/* Make sure it's a legal object Put. Use direct regs at first */
loadValueDirectFixed(cUnit, rlArray, r1);
@@ -1138,9 +1146,9 @@
loadWordDisp(cUnit, rSELF,
OFFSETOF_MEMBER(Thread, pArtCanPutArrayElementNoThrow), rLR);
/* Get the array's clazz */
- loadWordDisp(cUnit, r1, offsetof(Object, clazz), r1);
+ loadWordDisp(cUnit, r1, OFFSETOF_MEMBER(Object, klass_), r1);
/* Get the object's clazz */
- loadWordDisp(cUnit, r0, offsetof(Object, clazz), r0);
+ loadWordDisp(cUnit, r0, OFFSETOF_MEMBER(Object, klass_), r0);
opReg(cUnit, kOpBlx, rLR);
oatClobberCallRegs(cUnit);
@@ -1186,8 +1194,8 @@
RegLocation rlDest, int scale)
{
RegisterClass regClass = oatRegClassBySize(size);
- int lenOffset = OFFSETOF_MEMBER(ArrayObject, length);
- int dataOffset = OFFSETOF_MEMBER(ArrayObject, contents);
+ int lenOffset = Array::LengthOffset().Int32Value();
+ int dataOffset = Array::DataOffset().Int32Value();
RegLocation rlResult;
rlArray = loadValue(cUnit, rlArray, kCoreReg);
rlIndex = loadValue(cUnit, rlIndex, kCoreReg);
@@ -1251,8 +1259,8 @@
RegLocation rlSrc, int scale)
{
RegisterClass regClass = oatRegClassBySize(size);
- int lenOffset = OFFSETOF_MEMBER(ArrayObject, length);
- int dataOffset = OFFSETOF_MEMBER(ArrayObject, contents);
+ int lenOffset = Array::LengthOffset().Int32Value();
+ int dataOffset = Array::DataOffset().Int32Value();
int regPtr;
rlArray = loadValue(cUnit, rlArray, kCoreReg);