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);