diff --git a/src/compiler/codegen/arm/MethodCodegenDriver.cc b/src/compiler/codegen/arm/MethodCodegenDriver.cc
index 44cbc0e..cf1ad04 100644
--- a/src/compiler/codegen/arm/MethodCodegenDriver.cc
+++ b/src/compiler/codegen/arm/MethodCodegenDriver.cc
@@ -14,9 +14,6 @@
  * limitations under the License.
  */
 
-#define FORCE_SLOW 0
-#define DISPLAY_MISSING_TARGETS
-
 static const RegLocation badLoc = {kLocDalvikFrame, 0, 0, INVALID_REG,
                                    INVALID_REG, INVALID_SREG, 0,
                                    kLocDalvikFrame, INVALID_REG, INVALID_REG,
@@ -146,6 +143,8 @@
     Field* field = cUnit->method->GetDexCacheResolvedFields()->Get(fieldIdx);
     if (field == NULL) {
         // Slow path
+        LOG(INFO) << "Field " << fieldNameFromIndex(cUnit->method, fieldIdx)
+            << " unresolved at compile time";
         int funcOffset = isObject ? OFFSETOF_MEMBER(Thread, pSetObjStatic)
                                   : OFFSETOF_MEMBER(Thread, pSet32Static);
         oatFlushAllRegs(cUnit);
@@ -203,7 +202,9 @@
 {
     int fieldIdx = mir->dalvikInsn.vB;
     Field* field = cUnit->method->GetDexCacheResolvedFields()->Get(fieldIdx);
-    if (FORCE_SLOW || field == NULL) {
+    if (SLOW_FIELD_PATH || field == NULL) {
+        LOG(INFO) << "Field " << fieldNameFromIndex(cUnit->method, fieldIdx)
+            << " unresolved at compile time";
         oatFlushAllRegs(cUnit);
         loadWordDisp(cUnit, rSELF, OFFSETOF_MEMBER(Thread, pSet64Static), rLR);
         loadConstant(cUnit, r0, mir->dalvikInsn.vB);
@@ -259,7 +260,9 @@
 {
     int fieldIdx = mir->dalvikInsn.vB;
     Field* field = cUnit->method->GetDexCacheResolvedFields()->Get(fieldIdx);
-    if (FORCE_SLOW || field == NULL) {
+    if (SLOW_FIELD_PATH || field == NULL) {
+        LOG(INFO) << "Field " << fieldNameFromIndex(cUnit->method, fieldIdx)
+            << " unresolved at compile time";
         oatFlushAllRegs(cUnit);
         loadWordDisp(cUnit, rSELF, OFFSETOF_MEMBER(Thread, pGet64Static), rLR);
         loadConstant(cUnit, r0, mir->dalvikInsn.vB);
@@ -317,7 +320,9 @@
     Field* field = cUnit->method->GetDexCacheResolvedFields()->Get(fieldIdx);
     bool isObject = ((mir->dalvikInsn.opcode == OP_SGET_OBJECT) ||
                      (mir->dalvikInsn.opcode == OP_SGET_OBJECT_VOLATILE));
-    if (FORCE_SLOW || field == NULL) {
+    if (SLOW_FIELD_PATH || field == NULL) {
+        LOG(INFO) << "Field " << fieldNameFromIndex(cUnit->method, fieldIdx)
+            << " unresolved at compile time";
         // Slow path
         int funcOffset = isObject ? OFFSETOF_MEMBER(Thread, pGetObjStatic)
                                   : OFFSETOF_MEMBER(Thread, pGet32Static);
@@ -950,7 +955,7 @@
 
     // Explicit register usage
     oatLockCallTemps(cUnit);
-    if (FORCE_SLOW || baseMethod == NULL) {
+    if (SLOW_INVOKE_PATH || baseMethod == NULL) {
         fastPath = false;
     } else {
         Class* superClass = cUnit->method->GetDeclaringClass()->GetSuperClass();
@@ -1001,7 +1006,7 @@
 
     // Explicit register usage
     oatLockCallTemps(cUnit);
-    if (FORCE_SLOW || method == NULL) {
+    if (SLOW_INVOKE_PATH || method == NULL) {
         // Slow path
         nextCallInsn = nextVCallInsnSP;
         // If we need a slow-path callout, we'll restart here
diff --git a/src/compiler/codegen/arm/Thumb2/Gen.cc b/src/compiler/codegen/arm/Thumb2/Gen.cc
index dbaf9ea..4ae254b 100644
--- a/src/compiler/codegen/arm/Thumb2/Gen.cc
+++ b/src/compiler/codegen/arm/Thumb2/Gen.cc
@@ -22,6 +22,22 @@
  *
  */
 
+#define SLOW_FIELD_PATH 0
+#define SLOW_INVOKE_PATH 0
+#define DISPLAY_MISSING_TARGETS
+//#define EXERCISE_SLOWEST_FIELD_PATH
+
+std::string fieldNameFromIndex(const Method* method, uint32_t fieldIdx)
+{
+    art::ClassLinker* class_linker = art::Runtime::Current()->GetClassLinker();
+    const art::DexFile& dex_file = class_linker->FindDexFile(
+         method->GetDeclaringClass()->GetDexCache());
+    const art::DexFile::FieldId& field_id = dex_file.GetFieldId(fieldIdx);
+    std::string class_name = dex_file.dexStringById(field_id.class_idx_);
+    std::string field_name = dex_file.dexStringById(field_id.name_idx_);
+    return class_name + "." + field_name;
+}
+
 /*
  * Construct an s4 from two consecutive half-words of switch data.
  * This needs to check endianness because the DEX optimizer only swaps
@@ -380,33 +396,80 @@
 #endif
 }
 
+/*
+ * Helper function for Iget/put when field not resolved at compile time.
+ * Will trash call temps and return with the field offset in r0.
+ */
+static void getFieldOffset(CompilationUnit* cUnit, MIR* mir)
+{
+    int fieldIdx = mir->dalvikInsn.vC;
+    LOG(INFO) << "Field " << fieldNameFromIndex(cUnit->method, fieldIdx)
+        << " unresolved at compile time";
+    oatLockCallTemps(cUnit);  // Explicit register usage
+    loadCurrMethodDirect(cUnit, r1);              // arg1 <= Method*
+    loadWordDisp(cUnit, r1,
+                 Method::DexCacheResolvedFieldsOffset().Int32Value(), r0);
+    loadWordDisp(cUnit, r0, art::Array::DataOffset().Int32Value() +
+                 sizeof(int32_t*)* fieldIdx, r0);
+    /*
+     * For testing, omit the test for run-time resolution. This will
+     * force all accesses to go through the runtime resolution path.
+     */
+#ifndef EXERCISE_SLOWEST_FIELD_PATH
+    ArmLIR* branchOver = genCmpImmBranch(cUnit, kArmCondNe, r0, 0);
+#endif
+    // Resolve
+    loadWordDisp(cUnit, rSELF,
+                 OFFSETOF_MEMBER(Thread, pFindFieldFromCode), rLR);
+    loadConstant(cUnit, r0, fieldIdx);
+    opReg(cUnit, kOpBlx, rLR); // resolveTypeFromCode(idx, method)
+    ArmLIR* target = newLIR0(cUnit, kArmPseudoTargetLabel);
+    target->defMask = ENCODE_ALL;
+#ifndef EXERCISE_SLOWEST_FIELD_PATH
+    branchOver->generic.target = (LIR*)target;
+#endif
+    // Free temps (except for r0)
+    oatFreeTemp(cUnit, r1);
+    oatFreeTemp(cUnit, r2);
+    oatFreeTemp(cUnit, r3);
+    loadWordDisp(cUnit, r0, art::Field::OffsetOffset().Int32Value(), r0);
+}
+
 static void genIGetX(CompilationUnit* cUnit, MIR* mir, OpSize size,
                      RegLocation rlDest, RegLocation rlObj)
 {
     Field* fieldPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
         GetResolvedField(mir->dalvikInsn.vC);
-    if (fieldPtr == NULL) {
-        UNIMPLEMENTED(FATAL) << "Need to handle unresolved field";
-    }
-#if ANDROID_SMP != 0
-    bool isVolatile = dvmIsVolatileField(fieldPtr);
-#else
-    bool isVolatile = false;
-#endif
-    int fieldOffset = fieldPtr->GetOffset().Int32Value();
     RegLocation rlResult;
     RegisterClass regClass = oatRegClassBySize(size);
-    rlObj = loadValue(cUnit, rlObj, kCoreReg);
-    rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
-    genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
-                 NULL);/* null object? */
-    loadBaseDisp(cUnit, mir, rlObj.lowReg, fieldOffset, rlResult.lowReg,
-                 size, rlObj.sRegLow);
-    if (isVolatile) {
+    if (SLOW_FIELD_PATH || fieldPtr == NULL) {
+        getFieldOffset(cUnit, mir);
+        // Field offset in r0
+        rlObj = loadValue(cUnit, rlObj, kCoreReg);
+        rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
+        genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
+                     NULL);/* null object? */
+        loadBaseIndexed(cUnit, rlObj.lowReg, r0, rlResult.lowReg, 0, size);
         oatGenMemBarrier(cUnit, kSY);
+        storeValue(cUnit, rlDest, rlResult);
+    } else {
+#if ANDROID_SMP != 0
+        bool isVolatile = dvmIsVolatileField(fieldPtr);
+#else
+        bool isVolatile = false;
+#endif
+        int fieldOffset = fieldPtr->GetOffset().Int32Value();
+        rlObj = loadValue(cUnit, rlObj, kCoreReg);
+        rlResult = oatEvalLoc(cUnit, rlDest, regClass, true);
+        genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
+                     NULL);/* null object? */
+        loadBaseDisp(cUnit, mir, rlObj.lowReg, fieldOffset, rlResult.lowReg,
+                     size, rlObj.sRegLow);
+        if (isVolatile) {
+            oatGenMemBarrier(cUnit, kSY);
+        }
+        storeValue(cUnit, rlDest, rlResult);
     }
-
-    storeValue(cUnit, rlDest, rlResult);
 }
 
 static void genIPutX(CompilationUnit* cUnit, MIR* mir, OpSize size,
@@ -414,25 +477,33 @@
 {
     Field* fieldPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
         GetResolvedField(mir->dalvikInsn.vC);
-    if (fieldPtr == NULL) {
-        UNIMPLEMENTED(FATAL) << "Need to handle unresolved field";
-    }
-#if ANDROID_SMP != 0
-    bool isVolatile = dvmIsVolatileField(fieldPtr);
-#else
-    bool isVolatile = false;
-#endif
-    int fieldOffset = fieldPtr->GetOffset().Int32Value();
     RegisterClass regClass = oatRegClassBySize(size);
-    rlObj = loadValue(cUnit, rlObj, kCoreReg);
-    rlSrc = loadValue(cUnit, rlSrc, regClass);
-    genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
-                 NULL);/* null object? */
-
-    if (isVolatile) {
+    if (SLOW_FIELD_PATH || fieldPtr == NULL) {
+        getFieldOffset(cUnit, mir);
+        // Field offset in r0
+        rlObj = loadValue(cUnit, rlObj, kCoreReg);
+        rlSrc = loadValue(cUnit, rlSrc, regClass);
+        genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
+                     NULL);/* null object? */
         oatGenMemBarrier(cUnit, kSY);
+        storeBaseIndexed(cUnit, rlObj.lowReg, r0, rlSrc.lowReg, 0, size);
+    } else {
+#if ANDROID_SMP != 0
+        bool isVolatile = dvmIsVolatileField(fieldPtr);
+#else
+        bool isVolatile = false;
+#endif
+        int fieldOffset = fieldPtr->GetOffset().Int32Value();
+        rlObj = loadValue(cUnit, rlObj, kCoreReg);
+        rlSrc = loadValue(cUnit, rlSrc, regClass);
+        genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
+                    NULL);/* null object? */
+
+        if (isVolatile) {
+            oatGenMemBarrier(cUnit, kSY);
+        }
+        storeBaseDisp(cUnit, rlObj.lowReg, fieldOffset, rlSrc.lowReg, size);
     }
-    storeBaseDisp(cUnit, rlObj.lowReg, fieldOffset, rlSrc.lowReg, size);
     if (isObject) {
         /* NOTE: marking card based on object head */
         markGCCard(cUnit, rlSrc.lowReg, rlObj.lowReg);
@@ -444,34 +515,44 @@
 {
     Field* fieldPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
         GetResolvedField(mir->dalvikInsn.vC);
-    if (fieldPtr == NULL) {
-        UNIMPLEMENTED(FATAL) << "Need to handle unresolved field";
-    }
-#if ANDROID_SMP != 0
-    bool isVolatile = dvmIsVolatileField(fieldPtr);
-#else
-    bool isVolatile = false;
-#endif
-    int fieldOffset = fieldPtr->GetOffset().Int32Value();
     RegLocation rlResult;
-    rlObj = loadValue(cUnit, rlObj, kCoreReg);
-    int regPtr = oatAllocTemp(cUnit);
-
-    assert(rlDest.wide);
-
-    genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
-                 NULL);/* null object? */
-    opRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
-    rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
-
-    loadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
-
-    if (isVolatile) {
+    if (fieldPtr == NULL) {
+        getFieldOffset(cUnit, mir);
+        // Field offset in r0
+        rlObj = loadValue(cUnit, rlObj, kCoreReg);
+        rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
+        genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
+                     NULL);/* null object? */
+        opRegReg(cUnit, kOpAdd, r0, rlObj.lowReg);
+        loadPair(cUnit, r0, rlResult.lowReg, rlResult.highReg);
         oatGenMemBarrier(cUnit, kSY);
-    }
+        storeValue(cUnit, rlDest, rlResult);
+    } else {
+#if ANDROID_SMP != 0
+        bool isVolatile = dvmIsVolatileField(fieldPtr);
+#else
+        bool isVolatile = false;
+#endif
+        int fieldOffset = fieldPtr->GetOffset().Int32Value();
+        rlObj = loadValue(cUnit, rlObj, kCoreReg);
+        int regPtr = oatAllocTemp(cUnit);
 
-    oatFreeTemp(cUnit, regPtr);
-    storeValueWide(cUnit, rlDest, rlResult);
+        assert(rlDest.wide);
+
+        genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
+                     NULL);/* null object? */
+        opRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
+        rlResult = oatEvalLoc(cUnit, rlDest, kAnyReg, true);
+
+        loadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
+
+        if (isVolatile) {
+            oatGenMemBarrier(cUnit, kSY);
+        }
+
+        oatFreeTemp(cUnit, regPtr);
+        storeValueWide(cUnit, rlDest, rlResult);
+    }
 }
 
 static void genIPutWideX(CompilationUnit* cUnit, MIR* mir, RegLocation rlSrc,
@@ -480,29 +561,38 @@
     Field* fieldPtr = cUnit->method->GetDeclaringClass()->GetDexCache()->
         GetResolvedField(mir->dalvikInsn.vC);
     if (fieldPtr == NULL) {
-        UNIMPLEMENTED(FATAL) << "Need to handle unresolved field";
-    }
-#if ANDROID_SMP != 0
-    bool isVolatile = dvmIsVolatileField(fieldPtr);
-#else
-    bool isVolatile = false;
-#endif
-    int fieldOffset = fieldPtr->GetOffset().Int32Value();
-
-    rlObj = loadValue(cUnit, rlObj, kCoreReg);
-    int regPtr;
-    rlSrc = loadValueWide(cUnit, rlSrc, kAnyReg);
-    genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
-                 NULL);/* null object? */
-    regPtr = oatAllocTemp(cUnit);
-    opRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
-
-    if (isVolatile) {
+        getFieldOffset(cUnit, mir);
+        // Field offset in r0
+        rlObj = loadValue(cUnit, rlObj, kCoreReg);
+        rlSrc = loadValueWide(cUnit, rlSrc, kAnyReg);
+        genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
+                     NULL);/* null object? */
+        opRegReg(cUnit, kOpAdd, r0, rlObj.lowReg);
         oatGenMemBarrier(cUnit, kSY);
-    }
-    storePair(cUnit, regPtr, rlSrc.lowReg, rlSrc.highReg);
+        storePair(cUnit, r0, rlSrc.lowReg, rlSrc.highReg);
+    } else {
+#if ANDROID_SMP != 0
+        bool isVolatile = dvmIsVolatileField(fieldPtr);
+#else
+        bool isVolatile = false;
+#endif
+        int fieldOffset = fieldPtr->GetOffset().Int32Value();
 
-    oatFreeTemp(cUnit, regPtr);
+        rlObj = loadValue(cUnit, rlObj, kCoreReg);
+        int regPtr;
+        rlSrc = loadValueWide(cUnit, rlSrc, kAnyReg);
+        genNullCheck(cUnit, rlObj.sRegLow, rlObj.lowReg, mir->offset,
+                     NULL);/* null object? */
+        regPtr = oatAllocTemp(cUnit);
+        opRegRegImm(cUnit, kOpAdd, regPtr, rlObj.lowReg, fieldOffset);
+
+        if (isVolatile) {
+            oatGenMemBarrier(cUnit, kSY);
+        }
+        storePair(cUnit, regPtr, rlSrc.lowReg, rlSrc.highReg);
+
+        oatFreeTemp(cUnit, regPtr);
+    }
 }
 
 static void genConstClass(CompilationUnit* cUnit, MIR* mir,
diff --git a/src/object.cc b/src/object.cc
index 7c27ec7..c66791b 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -56,7 +56,7 @@
   return Runtime::Current()->GetClassLinker()->ResolveType(GetTypeIdx(), this);
 }
 
-Field* FindFieldFromCode(uint32_t field_idx, const Method* referrer) {
+Field* Field::FindFieldFromCode(uint32_t field_idx, const Method* referrer) {
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   Field* f = class_linker->ResolveField(field_idx, referrer);
   if (f != NULL) {
diff --git a/src/object.h b/src/object.h
index 9e5cf2d..72a03ba 100644
--- a/src/object.h
+++ b/src/object.h
@@ -524,6 +524,12 @@
   // Offset to field within an Object
   MemberOffset GetOffset() const;
 
+  static MemberOffset OffsetOffset() {
+    return MemberOffset(OFFSETOF_MEMBER(Field, offset_));
+  }
+
+  static Field* FindFieldFromCode(uint32_t field_idx, const Method* referrer);
+
   MemberOffset GetOffsetDuringLinking() const;
 
   void SetOffset(MemberOffset num_bytes);
@@ -778,6 +784,10 @@
     return OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_resolved_types_);
   }
 
+  static MemberOffset DexCacheResolvedFieldsOffset() {
+    return OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_resolved_fields_);
+  }
+
   static MemberOffset DexCacheInitializedStaticStorageOffset() {
     return OFFSET_OF_OBJECT_MEMBER(Method,
         dex_cache_initialized_static_storage_);
diff --git a/src/thread.cc b/src/thread.cc
index 3081d91..98f7f78 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -177,6 +177,7 @@
   pCheckCastFromCode = CheckCastFromCode;
   pLockObjectFromCode = LockObjectFromCode;
   pUnlockObjectFromCode = UnlockObjectFromCode;
+  pFindFieldFromCode = Field::FindFieldFromCode;
   pDebugMe = DebugMe;
 }
 
diff --git a/src/thread.h b/src/thread.h
index df162b9..a5a6911 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -229,6 +229,7 @@
   void (*pResolveMethodFromCode)(Method*, uint32_t);
   void (*pInvokeInterfaceTrampoline)(void*, void*, void*, void*);
   StaticStorageBase* (*pInitializeStaticStorage)(uint32_t, const Method*);
+  Field* (*pFindFieldFromCode)(uint32_t, const Method*);
 
   class StackVisitor {
    public: