diff --git a/src/class_linker.cc b/src/class_linker.cc
index f49f546..8f4029a 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -1039,6 +1039,7 @@
   if (!LoadSuperAndInterfaces(klass, dex_file)) {
     // Loading failed.
     CHECK(self->IsExceptionPending());
+    klass->SetStatus(Class::kStatusError);
     lock.NotifyAll();
     return NULL;
   }
@@ -1048,6 +1049,7 @@
   if (!LinkClass(klass)) {
     // Linking failed.
     CHECK(self->IsExceptionPending());
+    klass->SetStatus(Class::kStatusError);
     lock.NotifyAll();
     return NULL;
   }
diff --git a/src/compiler.cc b/src/compiler.cc
index cbfd35c..ba61b4d 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -333,6 +333,9 @@
   // TODO: this fails if we have an abstract method defined in more than one input dex file.
   CHECK(compiled_invoke_stubs_.find(method) == compiled_invoke_stubs_.end()) << PrettyMethod(method);
   compiled_invoke_stubs_[method] = compiled_invoke_stub;
+
+  Thread* self = Thread::Current();
+  CHECK(!self->IsExceptionPending()) << PrettyMethod(method);
 }
 
 const CompiledMethod* Compiler::GetCompiledMethod(const Method* method) const {
diff --git a/src/compiler.h b/src/compiler.h
index 0fc68df..55bab59 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -55,6 +55,21 @@
   const CompiledMethod* GetCompiledMethod(const Method* method) const;
   const CompiledInvokeStub* GetCompiledInvokeStub(const Method* method) const;
 
+  // Callbacks from OAT/ART compiler to see what runtime checks must be generated
+  bool CanAssumeTypeIsPresentInDexCache(const Method* referrer, uint32_t type_idx) const {
+    return IsImage() && referrer->GetDexCacheResolvedTypes()->Get(type_idx) != NULL;
+  }
+  bool CanAssumeStringIsPresentInDexCache(const Method* referrer, uint32_t string_idx) const {
+    return IsImage() && referrer->GetDexCacheStrings()->Get(string_idx) != NULL;
+  }
+  bool CanAccessTypeWithoutChecks(const Method* referrer, uint32_t type_idx) const {
+    Class* resolved_class = referrer->GetDexCacheResolvedTypes()->Get(type_idx);
+    // We should never ask whether a type needs access checks to raise a verification error,
+    // all other cases where this following test could fail should have been rewritten by the
+    // verifier to verification errors.
+    DCHECK(resolved_class == NULL || referrer->GetDeclaringClass()->CanAccess(resolved_class));
+    return resolved_class != NULL;
+  }
  private:
   // Attempt to resolve all type, methods, fields, and strings
   // referenced from code in the dex file following PathClassLoader
diff --git a/src/compiler/codegen/arm/MethodCodegenDriver.cc b/src/compiler/codegen/arm/MethodCodegenDriver.cc
index 7ea7d69..4326a9e 100644
--- a/src/compiler/codegen/arm/MethodCodegenDriver.cc
+++ b/src/compiler/codegen/arm/MethodCodegenDriver.cc
@@ -46,10 +46,19 @@
                         RegLocation rlSrc)
 {
     oatFlushAllRegs(cUnit);    /* Everything to home location */
-    loadWordDisp(cUnit, rSELF,
-                 OFFSETOF_MEMBER(Thread, pAllocArrayFromCode), rLR);
+    uint32_t type_idx = mir->dalvikInsn.vC;
+    if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method, type_idx)) {
+        loadWordDisp(cUnit, rSELF,
+                     OFFSETOF_MEMBER(Thread, pAllocArrayFromCode), rLR);
+    } else {
+        UNIMPLEMENTED(WARNING) << "Need to check access of '"
+                               << PrettyMethod(cUnit->method)
+                               << "' to unresolved type " << type_idx;
+        loadWordDisp(cUnit, rSELF,
+                     OFFSETOF_MEMBER(Thread, pAllocArrayFromCode), rLR);
+    }
     loadCurrMethodDirect(cUnit, r1);              // arg1 <- Method*
-    loadConstant(cUnit, r0, mir->dalvikInsn.vC);  // arg0 <- type_id
+    loadConstant(cUnit, r0, type_idx);            // arg0 <- type_id
     loadValueDirectFixed(cUnit, rlSrc, r2);       // arg2 <- count
     callRuntimeHelper(cUnit, rLR);
     RegLocation rlResult = oatGetReturn(cUnit);
@@ -70,6 +79,10 @@
     oatFlushAllRegs(cUnit);    /* Everything to home location */
     loadWordDisp(cUnit, rSELF,
                  OFFSETOF_MEMBER(Thread, pCheckAndAllocArrayFromCode), rLR);
+    if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method, typeId)) {
+        UNIMPLEMENTED(WARNING) << "Need to check access of '" << PrettyMethod(cUnit->method)
+                               << "' to unresolved type " << typeId;
+    }
     loadCurrMethodDirect(cUnit, r1);              // arg1 <- Method*
     loadConstant(cUnit, r0, typeId);              // arg0 <- type_id
     loadConstant(cUnit, r2, elems);               // arg2 <- count
diff --git a/src/compiler/codegen/arm/Thumb2/Gen.cc b/src/compiler/codegen/arm/Thumb2/Gen.cc
index 7098188..4e3888d 100644
--- a/src/compiler/codegen/arm/Thumb2/Gen.cc
+++ b/src/compiler/codegen/arm/Thumb2/Gen.cc
@@ -442,7 +442,7 @@
     loadWordDisp(cUnit, rSELF,
                  OFFSETOF_MEMBER(Thread, pFindInstanceFieldFromCode), rLR);
     loadConstant(cUnit, r0, fieldIdx);
-    callRuntimeHelper(cUnit, rLR);  // resolveTypeFromCode(idx, method)
+    callRuntimeHelper(cUnit, rLR);  // FindInstanceFieldFromCoderesolveTypeFromCode(idx, method)
     ArmLIR* target = newLIR0(cUnit, kArmPseudoTargetLabel);
     target->defMask = ENCODE_ALL;
     if (!EXERCISE_SLOWEST_FIELD_PATH) {
@@ -606,42 +606,46 @@
 STATIC void genConstClass(CompilationUnit* cUnit, MIR* mir,
                           RegLocation rlDest, RegLocation rlSrc)
 {
-    art::Class* classPtr = cUnit->method->GetDexCacheResolvedTypes()->
-        Get(mir->dalvikInsn.vB);
+    uint32_t type_idx = mir->dalvikInsn.vB;
     int mReg = loadCurrMethod(cUnit);
     int resReg = oatAllocTemp(cUnit);
     RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
-    loadWordDisp(cUnit, mReg, Method::DexCacheResolvedTypesOffset().Int32Value(),
-                 resReg);
-    loadWordDisp(cUnit, resReg, Array::DataOffset().Int32Value() +
-                 (sizeof(String*) * mir->dalvikInsn.vB), rlResult.lowReg);
-    if (SLOW_TYPE_PATH || (classPtr == NULL)) {
-        // Fast path, we're done - just store result
-        storeValue(cUnit, rlDest, rlResult);
+    if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method, type_idx)) {
+        // Check we have access to type_idx and if not throw IllegalAccessError
+        UNIMPLEMENTED(FATAL);
     } else {
-        // Slow path.  Must test at runtime
-        oatFlushAllRegs(cUnit);
-        ArmLIR* branch1 = genCmpImmBranch(cUnit, kArmCondEq, rlResult.lowReg,
-                                          0);
-        // Resolved, store and hop over following code
-        storeValue(cUnit, rlDest, rlResult);
-        ArmLIR* branch2 = genUnconditionalBranch(cUnit,0);
-        // TUNING: move slow path to end & remove unconditional branch
-        ArmLIR* target1 = newLIR0(cUnit, kArmPseudoTargetLabel);
-        target1->defMask = ENCODE_ALL;
-        // Call out to helper, which will return resolved type in r0
-        loadWordDisp(cUnit, rSELF,
-                     OFFSETOF_MEMBER(Thread, pInitializeTypeFromCode), rLR);
-        genRegCopy(cUnit, r1, mReg);
-        loadConstant(cUnit, r0, mir->dalvikInsn.vB);
-        callRuntimeHelper(cUnit, rLR);
-        RegLocation rlResult = oatGetReturn(cUnit);
-        storeValue(cUnit, rlDest, rlResult);
-        // Rejoin code paths
-        ArmLIR* target2 = newLIR0(cUnit, kArmPseudoTargetLabel);
-        target2->defMask = ENCODE_ALL;
-        branch1->generic.target = (LIR*)target1;
-        branch2->generic.target = (LIR*)target2;
+        // We're don't need access checks, load type from dex cache
+        int32_t dex_cache_offset = Method::DexCacheResolvedTypesOffset().Int32Value();
+        loadWordDisp(cUnit, mReg, dex_cache_offset, resReg);
+        int32_t offset_of_type = Array::DataOffset().Int32Value() + (sizeof(Class*) * type_idx);
+        loadWordDisp(cUnit, resReg, offset_of_type, rlResult.lowReg);
+        if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(cUnit->method, type_idx) ||
+            SLOW_TYPE_PATH) {
+            // Slow path, at runtime test if the type is null and if so initialize
+            oatFlushAllRegs(cUnit);
+            ArmLIR* branch1 = genCmpImmBranch(cUnit, kArmCondEq, rlResult.lowReg, 0);
+            // Resolved, store and hop over following code
+            storeValue(cUnit, rlDest, rlResult);
+            ArmLIR* branch2 = genUnconditionalBranch(cUnit,0);
+            // TUNING: move slow path to end & remove unconditional branch
+            ArmLIR* target1 = newLIR0(cUnit, kArmPseudoTargetLabel);
+            target1->defMask = ENCODE_ALL;
+            // Call out to helper, which will return resolved type in r0
+            loadWordDisp(cUnit, rSELF, OFFSETOF_MEMBER(Thread, pInitializeTypeFromCode), rLR);
+            genRegCopy(cUnit, r1, mReg);
+            loadConstant(cUnit, r0, type_idx);
+            callRuntimeHelper(cUnit, rLR);
+            RegLocation rlResult = oatGetReturn(cUnit);
+            storeValue(cUnit, rlDest, rlResult);
+            // Rejoin code paths
+            ArmLIR* target2 = newLIR0(cUnit, kArmPseudoTargetLabel);
+            target2->defMask = ENCODE_ALL;
+            branch1->generic.target = (LIR*)target1;
+            branch2->generic.target = (LIR*)target2;
+        } else {
+            // Fast path, we're done - just store result
+            storeValue(cUnit, rlDest, rlResult);
+        }
     }
 }
 
@@ -649,20 +653,19 @@
                            RegLocation rlDest, RegLocation rlSrc)
 {
     /* NOTE: Most strings should be available at compile time */
-    const art::String* str = cUnit->method->GetDexCacheStrings()->
-        Get(mir->dalvikInsn.vB);
-    if (SLOW_STRING_PATH || (str == NULL) || !cUnit->compiler->IsImage()) {
+    uint32_t string_idx = mir->dalvikInsn.vB;
+    int32_t offset_of_string = Array::DataOffset().Int32Value() + (sizeof(String*) * string_idx);
+    if (!cUnit->compiler->CanAssumeStringIsPresentInDexCache(cUnit->method, string_idx) ||
+        SLOW_STRING_PATH) {
+        // slow path, resolve string if not in dex cache
         oatFlushAllRegs(cUnit);
         oatLockCallTemps(cUnit); // Using explicit registers
         loadCurrMethodDirect(cUnit, r2);
-        loadWordDisp(cUnit, r2, Method::DexCacheStringsOffset().Int32Value(),
-                     r0);
+        loadWordDisp(cUnit, r2, Method::DexCacheStringsOffset().Int32Value(), r0);
         // Might call out to helper, which will return resolved string in r0
-        loadWordDisp(cUnit, rSELF,
-                     OFFSETOF_MEMBER(Thread, pResolveStringFromCode), rLR);
-        loadWordDisp(cUnit, r0, Array::DataOffset().Int32Value() +
-                 (sizeof(String*) * mir->dalvikInsn.vB), r0);
-        loadConstant(cUnit, r1, mir->dalvikInsn.vB);
+        loadWordDisp(cUnit, rSELF, OFFSETOF_MEMBER(Thread, pResolveStringFromCode), rLR);
+        loadWordDisp(cUnit, r0, offset_of_string, r0);
+        loadConstant(cUnit, r1, string_idx);
         opRegImm(cUnit, kOpCmp, r0, 0);  // Is resolved?
         genBarrier(cUnit);
         // For testing, always force through helper
@@ -677,10 +680,8 @@
         int mReg = loadCurrMethod(cUnit);
         int resReg = oatAllocTemp(cUnit);
         RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
-        loadWordDisp(cUnit, mReg, Method::DexCacheStringsOffset().Int32Value(),
-                     resReg);
-        loadWordDisp(cUnit, resReg, Array::DataOffset().Int32Value() +
-                    (sizeof(String*) * mir->dalvikInsn.vB), rlResult.lowReg);
+        loadWordDisp(cUnit, mReg, Method::DexCacheStringsOffset().Int32Value(), resReg);
+        loadWordDisp(cUnit, resReg, offset_of_string, rlResult.lowReg);
         storeValue(cUnit, rlDest, rlResult);
     }
 }
@@ -693,13 +694,17 @@
                            RegLocation rlDest)
 {
     oatFlushAllRegs(cUnit);    /* Everything to home location */
-    art::Class* classPtr = cUnit->method->GetDexCacheResolvedTypes()->
-        Get(mir->dalvikInsn.vB);
-    loadWordDisp(cUnit, rSELF, (classPtr != NULL)
-                 ? OFFSETOF_MEMBER(Thread, pAllocObjectFromCode)
-                 : OFFSETOF_MEMBER(Thread, pAllocObjectFromCodeSlowPath), rLR);
-    loadCurrMethodDirect(cUnit, r1);              // arg1 <= Method*
-    loadConstant(cUnit, r0, mir->dalvikInsn.vB);  // arg0 <- type_id
+    uint32_t type_idx = mir->dalvikInsn.vB;
+    // alloc will always check for resolution, do we also need to verify access because the
+    // verifier was unable to?
+    if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method, type_idx)) {
+        loadWordDisp(cUnit, rSELF, OFFSETOF_MEMBER(Thread, pAllocObjectFromCode), rLR);
+    } else {
+        loadWordDisp(cUnit, rSELF,
+                     OFFSETOF_MEMBER(Thread, pAllocObjectFromCodeWithAccessCheck), rLR);
+    }
+    loadCurrMethodDirect(cUnit, r1);    // arg1 <= Method*
+    loadConstant(cUnit, r0, type_idx);  // arg0 <- type_idx
     callRuntimeHelper(cUnit, rLR);
     RegLocation rlResult = oatGetReturn(cUnit);
     storeValue(cUnit, rlDest, rlResult);
@@ -708,8 +713,7 @@
 void genThrow(CompilationUnit* cUnit, MIR* mir, RegLocation rlSrc)
 {
     oatFlushAllRegs(cUnit);
-    loadWordDisp(cUnit, rSELF,
-                 OFFSETOF_MEMBER(Thread, pDeliverException), rLR);
+    loadWordDisp(cUnit, rSELF, OFFSETOF_MEMBER(Thread, pDeliverException), rLR);
     loadValueDirectFixed(cUnit, rlSrc, r0);  // Get exception object
     callRuntimeHelper(cUnit, rLR);  // art_deliver_exception(exception);
 }
@@ -720,30 +724,33 @@
     oatFlushAllRegs(cUnit);
     // May generate a call - use explicit registers
     oatLockCallTemps(cUnit);
-    art::Class* classPtr = cUnit->method->GetDexCacheResolvedTypes()->
-        Get(mir->dalvikInsn.vC);
-    int classReg = r2;   // Fixed usage
+    uint32_t type_idx = mir->dalvikInsn.vC;
     loadCurrMethodDirect(cUnit, r1);  // r1 <= current Method*
-    loadValueDirectFixed(cUnit, rlSrc, r0);  /* Ref */
-    loadWordDisp(cUnit, r1, Method::DexCacheResolvedTypesOffset().Int32Value(),
-                 classReg);
-    loadWordDisp(cUnit, classReg, Array::DataOffset().Int32Value() +
-                 (sizeof(String*) * mir->dalvikInsn.vC), classReg);
-    if (classPtr == NULL) {
-        // Generate a runtime test
-        ArmLIR* hopBranch = genCmpImmBranch(cUnit, kArmCondNe, classReg, 0);
-        // Not resolved
-        // Call out to helper, which will return resolved type in r0
-        loadWordDisp(cUnit, rSELF,
-                     OFFSETOF_MEMBER(Thread, pInitializeTypeFromCode), rLR);
-        loadConstant(cUnit, r0, mir->dalvikInsn.vC);
-        callRuntimeHelper(cUnit, rLR);  // resolveTypeFromCode(idx, method)
-        genRegCopy(cUnit, r2, r0); // Align usage with fast path
-        loadValueDirectFixed(cUnit, rlSrc, r0);  /* reload Ref */
-        // Rejoin code paths
-        ArmLIR* hopTarget = newLIR0(cUnit, kArmPseudoTargetLabel);
-        hopTarget->defMask = ENCODE_ALL;
-        hopBranch->generic.target = (LIR*)hopTarget;
+    loadValueDirectFixed(cUnit, rlSrc, r0);  // r0 <= ref
+    int classReg = r2;  // r2 will hold the Class*
+    if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method, type_idx)) {
+        // Check we have access to type_idx and if not throw IllegalAccessError
+        UNIMPLEMENTED(FATAL);
+    } else {
+        // Load dex cache entry into classReg (r2)
+        loadWordDisp(cUnit, r1, Method::DexCacheResolvedTypesOffset().Int32Value(), classReg);
+        int32_t offset_of_type = Array::DataOffset().Int32Value() + (sizeof(Class*) * type_idx);
+        loadWordDisp(cUnit, classReg, offset_of_type, classReg);
+        if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(cUnit->method, type_idx)) {
+            // Need to test presence of type in dex cache at runtime
+            ArmLIR* hopBranch = genCmpImmBranch(cUnit, kArmCondNe, classReg, 0);
+            // Not resolved
+            // Call out to helper, which will return resolved type in r0
+            loadWordDisp(cUnit, rSELF, OFFSETOF_MEMBER(Thread, pInitializeTypeFromCode), rLR);
+            loadConstant(cUnit, r0, type_idx);
+            callRuntimeHelper(cUnit, rLR);  // resolveTypeFromCode(idx, method)
+            genRegCopy(cUnit, r2, r0); // Align usage with fast path
+            loadValueDirectFixed(cUnit, rlSrc, r0);  /* reload Ref */
+            // Rejoin code paths
+            ArmLIR* hopTarget = newLIR0(cUnit, kArmPseudoTargetLabel);
+            hopTarget->defMask = ENCODE_ALL;
+            hopBranch->generic.target = (LIR*)hopTarget;
+        }
     }
     /* r0 is ref, r2 is class.  If ref==null, use directly as bool result */
     ArmLIR* branch1 = genCmpImmBranch(cUnit, kArmCondEq, r0, 0);
@@ -751,8 +758,7 @@
     DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
     loadWordDisp(cUnit, r0,  Object::ClassOffset().Int32Value(), r1);
     /* r0 is ref, r1 is ref->clazz, r2 is class */
-    loadWordDisp(cUnit, rSELF,
-                 OFFSETOF_MEMBER(Thread, pInstanceofNonTrivialFromCode), rLR);
+    loadWordDisp(cUnit, rSELF, OFFSETOF_MEMBER(Thread, pInstanceofNonTrivialFromCode), rLR);
     opRegReg(cUnit, kOpCmp, r1, r2);  // Same?
     genBarrier(cUnit);
     genIT(cUnit, kArmCondEq, "EE");   // if-convert the test
@@ -774,39 +780,41 @@
     oatFlushAllRegs(cUnit);
     // May generate a call - use explicit registers
     oatLockCallTemps(cUnit);
-    art::Class* classPtr = cUnit->method->GetDexCacheResolvedTypes()->
-        Get(mir->dalvikInsn.vB);
-    int classReg = r2;   // Fixed usage
+    uint32_t type_idx = mir->dalvikInsn.vB;
     loadCurrMethodDirect(cUnit, r1);  // r1 <= current Method*
-    loadWordDisp(cUnit, r1, Method::DexCacheResolvedTypesOffset().Int32Value(),
-                 classReg);
-    loadWordDisp(cUnit, classReg, Array::DataOffset().Int32Value() +
-                 (sizeof(String*) * mir->dalvikInsn.vB), classReg);
-    if (classPtr == NULL) {
-        // Generate a runtime test
-        ArmLIR* hopBranch = genCmpImmBranch(cUnit, kArmCondNe, classReg, 0);
-        // Not resolved
-        // Call out to helper, which will return resolved type in r0
-        loadWordDisp(cUnit, rSELF,
-                     OFFSETOF_MEMBER(Thread, pInitializeTypeFromCode), rLR);
-        loadConstant(cUnit, r0, mir->dalvikInsn.vB);
-        callRuntimeHelper(cUnit, rLR);  // resolveTypeFromCode(idx, method)
-        genRegCopy(cUnit, r2, r0); // Align usage with fast path
-        // Rejoin code paths
-        ArmLIR* hopTarget = newLIR0(cUnit, kArmPseudoTargetLabel);
-        hopTarget->defMask = ENCODE_ALL;
-        hopBranch->generic.target = (LIR*)hopTarget;
+    int classReg = r2;  // r2 will hold the Class*
+    if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method, type_idx)) {
+        // Check we have access to type_idx and if not throw IllegalAccessError
+        UNIMPLEMENTED(FATAL);
+    } else {
+        // Load dex cache entry into classReg (r2)
+        loadWordDisp(cUnit, r1, Method::DexCacheResolvedTypesOffset().Int32Value(), classReg);
+        int32_t offset_of_type = Array::DataOffset().Int32Value() + (sizeof(Class*) * type_idx);
+        loadWordDisp(cUnit, classReg, offset_of_type, classReg);
+        if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(cUnit->method, type_idx)) {
+            // Need to test presence of type in dex cache at runtime
+            ArmLIR* hopBranch = genCmpImmBranch(cUnit, kArmCondNe, classReg, 0);
+            // Not resolved
+            // Call out to helper, which will return resolved type in r0
+            loadWordDisp(cUnit, rSELF, OFFSETOF_MEMBER(Thread, pInitializeTypeFromCode), rLR);
+            loadConstant(cUnit, r0, type_idx);
+            callRuntimeHelper(cUnit, rLR);  // resolveTypeFromCode(idx, method)
+            genRegCopy(cUnit, r2, r0); // Align usage with fast path
+            // Rejoin code paths
+            ArmLIR* hopTarget = newLIR0(cUnit, kArmPseudoTargetLabel);
+            hopTarget->defMask = ENCODE_ALL;
+            hopBranch->generic.target = (LIR*)hopTarget;
+        }
     }
-    // At this point, r2 has class
-    loadValueDirectFixed(cUnit, rlSrc, r0);  /* Ref */
+    // At this point, classReg (r2) has class
+    loadValueDirectFixed(cUnit, rlSrc, r0);  // r0 <= ref
     /* Null is OK - continue */
     ArmLIR* branch1 = genCmpImmBranch(cUnit, kArmCondEq, r0, 0);
     /* load object->clazz */
     DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
     loadWordDisp(cUnit, r0,  Object::ClassOffset().Int32Value(), r1);
     /* r1 now contains object->clazz */
-    loadWordDisp(cUnit, rSELF,
-                 OFFSETOF_MEMBER(Thread, pCheckCastFromCode), rLR);
+    loadWordDisp(cUnit, rSELF, OFFSETOF_MEMBER(Thread, pCheckCastFromCode), rLR);
     opRegReg(cUnit, kOpCmp, r1, r2);
     ArmLIR* branch2 = opCondBranch(cUnit, kArmCondEq); /* If equal, trivial yes */
     genRegCopy(cUnit, r0, r1);
diff --git a/src/dex_verifier.cc b/src/dex_verifier.cc
index 79a455e..79f90e7 100644
--- a/src/dex_verifier.cc
+++ b/src/dex_verifier.cc
@@ -43,7 +43,7 @@
     "Unresolved Reference",
     "Uninitialized Reference",
     "Uninitialized This Reference",
-    "Unresolved And Uninitialized This Reference",
+    "Unresolved And Uninitialized Reference",
     "Reference",
 };
 
@@ -65,7 +65,7 @@
     result = type_strings[type_];
     if (IsReferenceTypes()) {
       result += ": ";
-      if (IsUnresolvedReference()) {
+      if (IsUnresolvedTypes()) {
         result += PrettyDescriptor(GetDescriptor());
       } else {
         result += PrettyDescriptor(GetClass()->GetDescriptor());
@@ -370,15 +370,23 @@
       entries_.push_back(entry);
       return *entry;
     } else {
+      // TODO: we assume unresolved, but we may be able to do better by validating whether the
+      // descriptor string is valid
       // Unable to resolve so create unresolved register type
       DCHECK(Thread::Current()->IsExceptionPending());
       Thread::Current()->ClearException();
-      String* string_descriptor =
-          Runtime::Current()->GetInternTable()->InternStrong(descriptor.c_str());
-      RegType* entry = new RegType(RegType::kRegTypeUnresolvedReference, string_descriptor, 0,
-                                   entries_.size());
-      entries_.push_back(entry);
-      return *entry;
+      if (IsValidDescriptor(descriptor.c_str())) {
+        String* string_descriptor =
+            Runtime::Current()->GetInternTable()->InternStrong(descriptor.c_str());
+        RegType* entry = new RegType(RegType::kRegTypeUnresolvedReference, string_descriptor, 0,
+                                     entries_.size());
+        entries_.push_back(entry);
+        return *entry;
+      } else {
+        // The descriptor is broken return the unknown type as there's nothing sensible that
+        // could be done at runtime
+        return Unknown();
+      }
     }
   }
 }
@@ -407,15 +415,58 @@
   }
 }
 
-const RegType& RegTypeCache::Uninitialized(Class* klass, uint32_t allocation_pc) {
-  for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
-    RegType* cur_entry = entries_[i];
-    if (cur_entry->IsUninitializedReference() && cur_entry->GetAllocationPc() == allocation_pc &&
-        cur_entry->GetClass() == klass) {
-      return *cur_entry;
+const RegType& RegTypeCache::Uninitialized(const RegType& type, uint32_t allocation_pc) {
+  RegType* entry;
+  if (type.IsUnresolvedTypes()) {
+    String* descriptor = type.GetDescriptor();
+    for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
+      RegType* cur_entry = entries_[i];
+      if (cur_entry->IsUnresolvedAndUninitializedReference() &&
+          cur_entry->GetAllocationPc() == allocation_pc &&
+          cur_entry->GetDescriptor() == descriptor) {
+        return *cur_entry;
+      }
     }
+    entry = new RegType(RegType::kRegTypeUnresolvedAndUninitializedReference,
+                        descriptor, allocation_pc, entries_.size());
+  } else {
+    Class* klass = type.GetClass();
+    for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
+      RegType* cur_entry = entries_[i];
+      if (cur_entry->IsUninitializedReference() &&
+          cur_entry->GetAllocationPc() == allocation_pc &&
+          cur_entry->GetClass() == klass) {
+        return *cur_entry;
+      }
+    }
+    entry = new RegType(RegType::kRegTypeUninitializedReference,
+                        klass, allocation_pc, entries_.size());
   }
-  RegType* entry = new RegType(RegType::kRegTypeUninitializedReference, klass, allocation_pc, entries_.size());
+  entries_.push_back(entry);
+  return *entry;
+}
+
+const RegType& RegTypeCache::FromUninitialized(const RegType& uninit_type) {
+  RegType* entry;
+  if (uninit_type.IsUnresolvedTypes()) {
+    String* descriptor = uninit_type.GetDescriptor();
+    for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
+      RegType* cur_entry = entries_[i];
+      if (cur_entry->IsUnresolvedReference() && cur_entry->GetDescriptor() == descriptor) {
+        return *cur_entry;
+      }
+    }
+    entry = new RegType(RegType::kRegTypeUnresolvedReference, descriptor, 0, entries_.size());
+  } else {
+    Class* klass = uninit_type.GetClass();
+    for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
+      RegType* cur_entry = entries_[i];
+      if (cur_entry->IsReference() && cur_entry->GetClass() == klass) {
+        return *cur_entry;
+      }
+    }
+    entry = new RegType(RegType::kRegTypeReference, klass, 0, entries_.size());
+  }
   entries_.push_back(entry);
   return *entry;
 }
@@ -462,6 +513,18 @@
   return *entry;
 }
 
+const RegType& RegTypeCache::GetComponentType(const RegType& array, const ClassLoader* loader) {
+  CHECK(array.IsArrayClass());
+  if (array.IsUnresolvedTypes()) {
+    std::string descriptor = array.GetDescriptor()->ToModifiedUtf8();
+    std::string component = descriptor.substr(1, descriptor.size() - 1);
+    return FromDescriptor(loader, component);
+  } else {
+    return FromClass(array.GetClass()->GetComponentType());
+  }
+}
+
+
 bool RegisterLine::CheckConstructorReturn() const {
   for (size_t i = 0; i < num_regs_; i++) {
     if (GetRegisterType(i).IsUninitializedThisReference()) {
@@ -561,20 +624,16 @@
 }
 
 void RegisterLine::MarkRefsAsInitialized(const RegType& uninit_type) {
-  Class* klass = uninit_type.GetClass();
-  if (klass == NULL) {
-    verifier_->Fail(VERIFY_ERROR_GENERIC) << "Unable to find type=" << uninit_type;
-  } else {
-    const RegType& init_type = verifier_->GetRegTypeCache()->FromClass(klass);
-    size_t changed = 0;
-    for (size_t i = 0; i < num_regs_; i++) {
-      if (GetRegisterType(i).Equals(uninit_type)) {
-        line_[i] = init_type.GetId();
-        changed++;
-      }
+  DCHECK(uninit_type.IsUninitializedTypes());
+  const RegType& init_type = verifier_->GetRegTypeCache()->FromUninitialized(uninit_type);
+  size_t changed = 0;
+  for (size_t i = 0; i < num_regs_; i++) {
+    if (GetRegisterType(i).Equals(uninit_type)) {
+      line_[i] = init_type.GetId();
+      changed++;
     }
-    DCHECK_GT(changed, 0u);
   }
+  DCHECK_GT(changed, 0u);
 }
 
 void RegisterLine::MarkUninitRefsAsInvalid(const RegType& uninit_type) {
@@ -895,8 +954,9 @@
             << verifier.info_messages_.str() << Dumpable<DexVerifier>(verifier);
 }
 
-DexVerifier::DexVerifier(Method* method) : java_lang_throwable_(NULL), work_insn_idx_(-1),
-                                           method_(method), failure_(VERIFY_ERROR_NONE),
+DexVerifier::DexVerifier(Method* method) : work_insn_idx_(-1), method_(method),
+                                           failure_(VERIFY_ERROR_NONE),
+
                                            new_instance_count_(0), monitor_enter_count_(0) {
   const DexCache* dex_cache = method->GetDeclaringClass()->GetDexCache();
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
@@ -994,15 +1054,26 @@
   /* Iterate over each of the handlers to verify target addresses. */
   const byte* handlers_ptr = DexFile::dexGetCatchHandlerData(*code_item_, 0);
   uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
+  ClassLinker* linker = Runtime::Current()->GetClassLinker();
   for (uint32_t idx = 0; idx < handlers_size; idx++) {
     DexFile::CatchHandlerIterator iterator(handlers_ptr);
     for (; !iterator.HasNext(); iterator.Next()) {
-      uint32_t dex_pc= iterator.Get().address_;
+      const DexFile::CatchHandlerItem& handler = iterator.Get();
+      uint32_t dex_pc= handler.address_;
       if (!insn_flags_[dex_pc].IsOpcode()) {
         Fail(VERIFY_ERROR_GENERIC) << "exception handler starts at bad address (" << dex_pc << ")";
         return false;
       }
       insn_flags_[dex_pc].SetBranchTarget();
+      // Ensure exception types are resolved so that they don't need resolution to be delivered,
+      // unresolved exception types will be ignored by exception delivery
+      if (handler.type_idx_ != DexFile::kDexNoIndex) {
+        Class* exception_type = linker->ResolveType(handler.type_idx_, method_);
+        if (exception_type == NULL) {
+          DCHECK(Thread::Current()->IsExceptionPending());
+          Thread::Current()->ClearException();
+        }
+      }
     }
     handlers_ptr = iterator.GetData();
   }
@@ -1814,12 +1885,8 @@
        * all exception handlers need to have one of these). We verify that as part of extracting the
        * exception type from the catch block list.
        */
-      Class* res_class = GetCaughtExceptionType();
-      if (res_class == NULL) {
-        DCHECK(failure_ != VERIFY_ERROR_NONE);
-      } else {
-        work_line_->SetRegisterType(dec_insn.vA_, reg_types_.FromClass(res_class));
-      }
+      const RegType& res_type = GetCaughtExceptionType();
+      work_line_->SetRegisterType(dec_insn.vA_, res_type);
       break;
     }
     case Instruction::RETURN_VOID:
@@ -1911,17 +1978,12 @@
       work_line_->SetRegisterType(dec_insn.vA_, reg_types_.JavaLangString());
       break;
     case Instruction::CONST_CLASS: {
-      /* make sure we can resolve the class; access check is important */
-      Class* res_class = ResolveClassAndCheckAccess(dec_insn.vB_);
-      if (res_class == NULL) {
-        const char* bad_class_desc = dex_file_->dexStringByTypeIdx(dec_insn.vB_);
-        fail_messages_ << "unable to resolve const-class " << dec_insn.vB_
-                       << " (" << bad_class_desc << ") in "
-                       << PrettyDescriptor(method_->GetDeclaringClass()->GetDescriptor());
-        DCHECK(failure_ != VERIFY_ERROR_GENERIC);
-      } else {
-        work_line_->SetRegisterType(dec_insn.vA_, reg_types_.JavaLangClass());
-      }
+      // Get type from instruction if unresolved then we need an access check
+      // TODO: check Compiler::CanAccessTypeWithoutChecks returns false when res_type is unresolved
+      const RegType& res_type = ResolveClassAndCheckAccess(dec_insn.vB_);
+      // Register holds class, ie its type is class, but on error we keep it Unknown
+      work_line_->SetRegisterType(dec_insn.vA_,
+                                  res_type.IsUnknown() ? res_type : reg_types_.JavaLangClass());
       break;
     }
     case Instruction::MONITOR_ENTER:
@@ -1952,58 +2014,39 @@
       work_line_->PopMonitor(dec_insn.vA_);
       break;
 
-    case Instruction::CHECK_CAST: {
-      /*
-       * If this instruction succeeds, we will promote register vA to
-       * the type in vB. (This could be a demotion -- not expected, so
-       * we don't try to address it.)
-       *
-       * If it fails, an exception is thrown, which we deal with later
-       * by ignoring the update to dec_insn.vA_ when branching to a handler.
-       */
-      Class* res_class = ResolveClassAndCheckAccess(dec_insn.vB_);
-      if (res_class == NULL) {
-        const char* bad_class_desc = dex_file_->dexStringByTypeIdx(dec_insn.vB_);
-        fail_messages_ << "unable to resolve check-cast " << dec_insn.vB_
-                       << " (" << bad_class_desc << ") in "
-                       << PrettyDescriptor(method_->GetDeclaringClass()->GetDescriptor());
-        DCHECK(failure_ != VERIFY_ERROR_GENERIC);
-      } else {
-        const RegType& orig_type = work_line_->GetRegisterType(dec_insn.vA_);
-        if (!orig_type.IsReferenceTypes()) {
-          Fail(VERIFY_ERROR_GENERIC) << "check-cast on non-reference in v" << dec_insn.vA_;
-        } else {
-          work_line_->SetRegisterType(dec_insn.vA_, reg_types_.FromClass(res_class));
-        }
-      }
-      break;
-    }
+    case Instruction::CHECK_CAST:
     case Instruction::INSTANCE_OF: {
-      /* make sure we're checking a reference type */
-      const RegType& tmp_type = work_line_->GetRegisterType(dec_insn.vB_);
-      if (!tmp_type.IsReferenceTypes()) {
-        Fail(VERIFY_ERROR_GENERIC) << "vB not a reference (" << tmp_type << ")";
+      /*
+       * If this instruction succeeds, we will "downcast" register vA to the type in vB. (This
+       * could be a "upcast" -- not expected, so we don't try to address it.)
+       *
+       * If it fails, an exception is thrown, which we deal with later by ignoring the update to
+       * dec_insn.vA_ when branching to a handler.
+       */
+      bool is_checkcast = dec_insn.opcode_ == Instruction::CHECK_CAST;
+      const RegType& res_type =
+          ResolveClassAndCheckAccess(is_checkcast ? dec_insn.vB_ : dec_insn.vC_);
+      // TODO: check Compiler::CanAccessTypeWithoutChecks returns false when res_type is unresolved
+      const RegType& orig_type =
+          work_line_->GetRegisterType(is_checkcast ? dec_insn.vA_ : dec_insn.vB_);
+      if (!res_type.IsNonZeroReferenceTypes()) {
+        Fail(VERIFY_ERROR_GENERIC) << "check-cast on unexpected class " << res_type;
+      } else if (!orig_type.IsReferenceTypes()) {
+        Fail(VERIFY_ERROR_GENERIC) << "check-cast on non-reference in v" << dec_insn.vA_;
       } else {
-        /* make sure we can resolve the class; access check is important */
-        Class* res_class = ResolveClassAndCheckAccess(dec_insn.vC_);
-        if (res_class == NULL) {
-          const char* bad_class_desc = dex_file_->dexStringByTypeIdx(dec_insn.vC_);
-          fail_messages_ << "unable to resolve instance of " << dec_insn.vC_
-                         << " (" << bad_class_desc << ") in "
-                         << PrettyDescriptor(method_->GetDeclaringClass()->GetDescriptor());
-          DCHECK(failure_ != VERIFY_ERROR_GENERIC);
+        if (is_checkcast) {
+          work_line_->SetRegisterType(dec_insn.vA_, res_type);
         } else {
-          /* result is boolean */
           work_line_->SetRegisterType(dec_insn.vA_, reg_types_.Boolean());
         }
       }
       break;
     }
     case Instruction::ARRAY_LENGTH: {
-      Class* res_class = work_line_->GetClassFromRegister(dec_insn.vB_);
-      if (failure_ == VERIFY_ERROR_NONE) {
-        if (res_class != NULL && !res_class->IsArrayClass()) {
-          Fail(VERIFY_ERROR_GENERIC) << "array-length on non-array";
+      const RegType& res_type = work_line_->GetRegisterType(dec_insn.vB_);
+      if (res_type.IsReferenceTypes()) {
+        if (!res_type.IsArrayClass()) {
+          Fail(VERIFY_ERROR_GENERIC) << "array-length on non-array " << res_type;
         } else {
           work_line_->SetRegisterType(dec_insn.vA_, reg_types_.Integer());
         }
@@ -2011,66 +2054,47 @@
       break;
     }
     case Instruction::NEW_INSTANCE: {
-      Class* res_class = ResolveClassAndCheckAccess(dec_insn.vB_);
-      if (res_class == NULL) {
-        const char* bad_class_desc = dex_file_->dexStringByTypeIdx(dec_insn.vB_);
-        fail_messages_ << "unable to resolve new-instance " << dec_insn.vB_
-                       << " (" << bad_class_desc << ") in "
-                       << PrettyDescriptor(method_->GetDeclaringClass()->GetDescriptor());
-        DCHECK(failure_ != VERIFY_ERROR_GENERIC);
+      const RegType& res_type = ResolveClassAndCheckAccess(dec_insn.vB_);
+      // TODO: check Compiler::CanAccessTypeWithoutChecks returns false when res_type is unresolved
+      // can't create an instance of an interface or abstract class */
+      if (!res_type.IsInstantiableTypes()) {
+        Fail(VERIFY_ERROR_INSTANTIATION)
+            << "new-instance on primitive, interface or abstract class" << res_type;
       } else {
-        /* can't create an instance of an interface or abstract class */
-        if (res_class->IsPrimitive() || res_class->IsAbstract() || res_class->IsInterface()) {
-          Fail(VERIFY_ERROR_INSTANTIATION)
-              << "new-instance on primitive, interface or abstract class"
-              << PrettyDescriptor(res_class->GetDescriptor());
-        } else {
-          const RegType& uninit_type = reg_types_.Uninitialized(res_class, work_insn_idx_);
-          // Any registers holding previous allocations from this address that have not yet been
-          // initialized must be marked invalid.
-          work_line_->MarkUninitRefsAsInvalid(uninit_type);
-
-          /* add the new uninitialized reference to the register state */
-          work_line_->SetRegisterType(dec_insn.vA_, uninit_type);
-        }
+        const RegType& uninit_type = reg_types_.Uninitialized(res_type, work_insn_idx_);
+        // Any registers holding previous allocations from this address that have not yet been
+        // initialized must be marked invalid.
+        work_line_->MarkUninitRefsAsInvalid(uninit_type);
+        // add the new uninitialized reference to the register state
+        work_line_->SetRegisterType(dec_insn.vA_, uninit_type);
       }
       break;
     }
     case Instruction::NEW_ARRAY: {
-      Class* res_class = ResolveClassAndCheckAccess(dec_insn.vC_);
-      if (res_class == NULL) {
-        const char* bad_class_desc = dex_file_->dexStringByTypeIdx(dec_insn.vC_);
-        fail_messages_ << "unable to resolve new-array " << dec_insn.vC_
-                       << " (" << bad_class_desc << ") in "
-                       << PrettyDescriptor(method_->GetDeclaringClass()->GetDescriptor());
-        DCHECK(failure_ != VERIFY_ERROR_GENERIC);
-      } else if (!res_class->IsArrayClass()) {
-        Fail(VERIFY_ERROR_GENERIC) << "new-array on non-array class";
+      const RegType& res_type = ResolveClassAndCheckAccess(dec_insn.vC_);
+      // TODO: check Compiler::CanAccessTypeWithoutChecks returns false when res_type is unresolved
+      if (!res_type.IsArrayClass()) {
+        Fail(VERIFY_ERROR_GENERIC) << "new-array on non-array class " << res_type;
       } else {
         /* make sure "size" register is valid type */
         work_line_->VerifyRegisterType(dec_insn.vB_, reg_types_.Integer());
         /* set register type to array class */
-        work_line_->SetRegisterType(dec_insn.vA_, reg_types_.FromClass(res_class));
+        work_line_->SetRegisterType(dec_insn.vA_, res_type);
       }
       break;
     }
     case Instruction::FILLED_NEW_ARRAY:
     case Instruction::FILLED_NEW_ARRAY_RANGE: {
-      Class* res_class = ResolveClassAndCheckAccess(dec_insn.vB_);
-      if (res_class == NULL) {
-        const char* bad_class_desc = dex_file_->dexStringByTypeIdx(dec_insn.vB_);
-        fail_messages_ << "unable to resolve filled-array " << dec_insn.vB_
-                       << " (" << bad_class_desc << ") in "
-                       << PrettyDescriptor(method_->GetDeclaringClass()->GetDescriptor());
-        DCHECK(failure_ != VERIFY_ERROR_GENERIC);
-      } else if (!res_class->IsArrayClass()) {
+      const RegType& res_type = ResolveClassAndCheckAccess(dec_insn.vB_);
+      // TODO: check Compiler::CanAccessTypeWithoutChecks returns false when res_type is unresolved
+      if (!res_type.IsArrayClass()) {
         Fail(VERIFY_ERROR_GENERIC) << "filled-new-array on non-array class";
       } else {
         bool is_range = (dec_insn.opcode_ == Instruction::FILLED_NEW_ARRAY_RANGE);
         /* check the arguments to the instruction */
-        VerifyFilledNewArrayRegs(dec_insn, res_class, is_range);
+        VerifyFilledNewArrayRegs(dec_insn, res_type, is_range);
         /* filled-array result goes into "result" register */
-        work_line_->SetResultRegisterType(reg_types_.FromClass(res_class));
+        work_line_->SetResultRegisterType(res_type);
         just_set_result = true;
       }
       break;
@@ -2093,12 +2117,9 @@
       work_line_->SetRegisterType(dec_insn.vA_, reg_types_.Integer());
       break;
     case Instruction::THROW: {
-      Class* res_class = work_line_->GetClassFromRegister(dec_insn.vA_);
-      if (failure_ == VERIFY_ERROR_NONE && res_class != NULL) {
-        if (!JavaLangThrowable()->IsAssignableFrom(res_class)) {
-          Fail(VERIFY_ERROR_GENERIC) << "thrown class "
-              << PrettyDescriptor(res_class->GetDescriptor()) << " not instanceof Throwable";
-        }
+      const RegType& res_type = work_line_->GetRegisterType(dec_insn.vA_);
+      if (!reg_types_.JavaLangThrowable().IsAssignableFrom(res_type)) {
+        Fail(VERIFY_ERROR_GENERIC) << "thrown class " << res_type << " not instanceof Throwable";
       }
       break;
     }
@@ -2338,9 +2359,17 @@
                         dec_insn.opcode_ == Instruction::INVOKE_SUPER_RANGE);
       Method* called_method = VerifyInvocationArgs(dec_insn, METHOD_VIRTUAL, is_range, is_super);
       if (failure_ == VERIFY_ERROR_NONE) {
+        const char* descriptor;
+        if (called_method == NULL) {
+          uint32_t method_idx = dec_insn.vB_;
+          const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
+          uint32_t return_type_idx = dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
+          descriptor =  dex_file_->dexStringByTypeIdx(return_type_idx);
+        } else {
+          descriptor = called_method->GetReturnTypeDescriptor();
+        }
         const RegType& return_type =
-            reg_types_.FromDescriptor(called_method->GetDeclaringClass()->GetClassLoader(),
-                                      called_method->GetReturnTypeDescriptor());
+            reg_types_.FromDescriptor(method_->GetDeclaringClass()->GetClassLoader(), descriptor);
         work_line_->SetResultRegisterType(return_type);
         just_set_result = true;
       }
@@ -2358,7 +2387,16 @@
          * allowing the latter only if the "this" argument is the same as the "this" argument to
          * this method (which implies that we're in a constructor ourselves).
          */
-        if (called_method->IsConstructor()) {
+        bool is_constructor;
+        if (called_method != NULL) {
+          is_constructor = called_method->IsConstructor();
+        } else {
+          uint32_t method_idx = dec_insn.vB_;
+          const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
+          const char* name = dex_file_->GetMethodName(method_id);
+          is_constructor = strcmp(name, "<init>") == 0;
+        }
+        if (is_constructor) {
           const RegType& this_type = work_line_->GetInvocationThis(dec_insn);
           if (failure_ != VERIFY_ERROR_NONE)
             break;
@@ -2368,19 +2406,20 @@
             Fail(VERIFY_ERROR_GENERIC) << "unable to initialize null ref";
             break;
           }
-          Class* this_class = this_type.GetClass();
-          DCHECK(this_class != NULL);
-
-          /* must be in same class or in superclass */
-          if (called_method->GetDeclaringClass() == this_class->GetSuperClass()) {
-            if (this_class != method_->GetDeclaringClass()) {
-              Fail(VERIFY_ERROR_GENERIC)
-                  << "invoke-direct <init> on super only allowed for 'this' in <init>";
+          if (called_method != NULL) {
+            Class* this_class = this_type.GetClass();
+            DCHECK(this_class != NULL);
+            /* must be in same class or in superclass */
+            if (called_method->GetDeclaringClass() == this_class->GetSuperClass()) {
+              if (this_class != method_->GetDeclaringClass()) {
+                Fail(VERIFY_ERROR_GENERIC)
+                    << "invoke-direct <init> on super only allowed for 'this' in <init>";
+                break;
+              }
+            }  else if (called_method->GetDeclaringClass() != this_class) {
+              Fail(VERIFY_ERROR_GENERIC) << "invoke-direct <init> must be on current class or super";
               break;
             }
-          }  else if (called_method->GetDeclaringClass() != this_class) {
-            Fail(VERIFY_ERROR_GENERIC) << "invoke-direct <init> must be on current class or super";
-            break;
           }
 
           /* arg must be an uninitialized reference */
@@ -2398,9 +2437,17 @@
           if (failure_ != VERIFY_ERROR_NONE)
             break;
         }
+        const char* descriptor;
+        if (called_method == NULL) {
+          uint32_t method_idx = dec_insn.vB_;
+          const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
+          uint32_t return_type_idx = dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
+          descriptor =  dex_file_->dexStringByTypeIdx(return_type_idx);
+        } else {
+          descriptor = called_method->GetReturnTypeDescriptor();
+        }
         const RegType& return_type =
-            reg_types_.FromDescriptor(called_method->GetDeclaringClass()->GetClassLoader(),
-                                      called_method->GetReturnTypeDescriptor());
+            reg_types_.FromDescriptor(method_->GetDeclaringClass()->GetClassLoader(), descriptor);
         work_line_->SetResultRegisterType(return_type);
         just_set_result = true;
       }
@@ -2411,9 +2458,17 @@
         bool is_range = (dec_insn.opcode_ == Instruction::INVOKE_STATIC_RANGE);
         Method* called_method = VerifyInvocationArgs(dec_insn, METHOD_STATIC, is_range, false);
         if (failure_ == VERIFY_ERROR_NONE) {
+          const char* descriptor;
+          if (called_method == NULL) {
+            uint32_t method_idx = dec_insn.vB_;
+            const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
+            uint32_t return_type_idx = dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
+            descriptor =  dex_file_->dexStringByTypeIdx(return_type_idx);
+          } else {
+            descriptor = called_method->GetReturnTypeDescriptor();
+          }
           const RegType& return_type =
-              reg_types_.FromDescriptor(called_method->GetDeclaringClass()->GetClassLoader(),
-                                        called_method->GetReturnTypeDescriptor());
+              reg_types_.FromDescriptor(method_->GetDeclaringClass()->GetClassLoader(), descriptor);
           work_line_->SetResultRegisterType(return_type);
           just_set_result = true;
         }
@@ -2424,42 +2479,52 @@
       bool is_range =  (dec_insn.opcode_ == Instruction::INVOKE_INTERFACE_RANGE);
       Method* abs_method = VerifyInvocationArgs(dec_insn, METHOD_INTERFACE, is_range, false);
       if (failure_ == VERIFY_ERROR_NONE) {
-        Class* called_interface = abs_method->GetDeclaringClass();
-        if (!called_interface->IsInterface()) {
-          Fail(VERIFY_ERROR_CLASS_CHANGE) << "expected interface class in invoke-interface '"
-                                          << PrettyMethod(abs_method) << "'";
-          break;
-        } else {
-          /* Get the type of the "this" arg, which should either be a sub-interface of called
-           * interface or Object (see comments in RegType::JoinClass).
-           */
-          const RegType& this_type = work_line_->GetInvocationThis(dec_insn);
-          if (failure_ == VERIFY_ERROR_NONE) {
-            if (this_type.IsZero()) {
-              /* null pointer always passes (and always fails at runtime) */
-            } else {
-              if (this_type.IsUninitializedTypes()) {
-                Fail(VERIFY_ERROR_GENERIC) << "interface call on uninitialized object "
-                    << this_type;
-                break;
-              }
-              // In the past we have tried to assert that "called_interface" is assignable
-              // from "this_type.GetClass()", however, as we do an imprecise Join
-              // (RegType::JoinClass) we don't have full information on what interfaces are
-              // implemented by "this_type". For example, two classes may implement the same
-              // interfaces and have a common parent that doesn't implement the interface. The
-              // join will set "this_type" to the parent class and a test that this implements
-              // the interface will incorrectly fail.
+        if (abs_method != NULL) {
+          Class* called_interface = abs_method->GetDeclaringClass();
+          if (!called_interface->IsInterface()) {
+            Fail(VERIFY_ERROR_CLASS_CHANGE) << "expected interface class in invoke-interface '"
+                                            << PrettyMethod(abs_method) << "'";
+            break;
+          }
+        }
+        /* Get the type of the "this" arg, which should either be a sub-interface of called
+         * interface or Object (see comments in RegType::JoinClass).
+         */
+        const RegType& this_type = work_line_->GetInvocationThis(dec_insn);
+        if (failure_ == VERIFY_ERROR_NONE) {
+          if (this_type.IsZero()) {
+            /* null pointer always passes (and always fails at runtime) */
+          } else {
+            if (this_type.IsUninitializedTypes()) {
+              Fail(VERIFY_ERROR_GENERIC) << "interface call on uninitialized object "
+                  << this_type;
+              break;
             }
+            // In the past we have tried to assert that "called_interface" is assignable
+            // from "this_type.GetClass()", however, as we do an imprecise Join
+            // (RegType::JoinClass) we don't have full information on what interfaces are
+            // implemented by "this_type". For example, two classes may implement the same
+            // interfaces and have a common parent that doesn't implement the interface. The
+            // join will set "this_type" to the parent class and a test that this implements
+            // the interface will incorrectly fail.
           }
         }
         /*
          * We don't have an object instance, so we can't find the concrete method. However, all of
          * the type information is in the abstract method, so we're good.
          */
+        const char* descriptor;
+        if (abs_method == NULL) {
+          uint32_t method_idx = dec_insn.vB_;
+          const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
+          uint32_t return_type_idx = dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
+          descriptor =  dex_file_->dexStringByTypeIdx(return_type_idx);
+        } else {
+          descriptor = abs_method->GetReturnTypeDescriptor();
+        }
         const RegType& return_type =
-            reg_types_.FromDescriptor(abs_method->GetDeclaringClass()->GetClassLoader(),
-                                      abs_method->GetReturnTypeDescriptor());
+            reg_types_.FromDescriptor(method_->GetDeclaringClass()->GetClassLoader(), descriptor);
+        work_line_->SetResultRegisterType(return_type);
         work_line_->SetResultRegisterType(return_type);
         just_set_result = true;
       }
@@ -2887,24 +2952,30 @@
   return true;
 }
 
-Class* DexVerifier::ResolveClassAndCheckAccess(uint32_t class_idx) {
-  const Class* referrer = method_->GetDeclaringClass();
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  Class* res_class = class_linker->ResolveType(*dex_file_, class_idx, referrer);
-
-  if (res_class == NULL) {
-    Thread::Current()->ClearException();
-    Fail(VERIFY_ERROR_NO_CLASS) << "can't find class with index " << (void*) class_idx;
-  } else if (!referrer->CanAccess(res_class)) {   /* Check if access is allowed. */
-    Fail(VERIFY_ERROR_ACCESS_CLASS) << "illegal class access: "
-                                    << referrer->GetDescriptor()->ToModifiedUtf8() << " -> "
-                                    << res_class->GetDescriptor()->ToModifiedUtf8();
+const RegType& DexVerifier::ResolveClassAndCheckAccess(uint32_t class_idx) {
+  const char* descriptor = dex_file_->dexStringByTypeIdx(class_idx);
+  Class* referrer = method_->GetDeclaringClass();
+  Class* klass = method_->GetDexCacheResolvedTypes()->Get(class_idx);
+  const RegType& result =
+      klass != NULL ? reg_types_.FromClass(klass)
+                    : reg_types_.FromDescriptor(referrer->GetClassLoader(), descriptor);
+  if (klass == NULL && !result.IsUnresolvedTypes()) {
+    method_->GetDexCacheResolvedTypes()->Set(class_idx, result.GetClass());
   }
-  return res_class;
+  // Check if access is allowed. Unresolved types use AllocObjectFromCodeWithAccessCheck to
+  // check at runtime if access is allowed and so pass here.
+  if (!result.IsUnresolvedTypes() && !referrer->CanAccess(result.GetClass())) {
+    Fail(VERIFY_ERROR_ACCESS_CLASS) << "illegal class access: '"
+                                    << PrettyDescriptor(referrer->GetDescriptor()) << "' -> '"
+                                    << result << "'";
+    return reg_types_.Unknown();
+  } else {
+    return result;
+  }
 }
 
-Class* DexVerifier::GetCaughtExceptionType() {
-  Class* common_super = NULL;
+const RegType& DexVerifier::GetCaughtExceptionType() {
+  const RegType* common_super = NULL;
   if (code_item_->tries_size_ != 0) {
     const byte* handlers_ptr = DexFile::dexGetCatchHandlerData(*code_item_, 0);
     uint32_t handlers_size = DecodeUnsignedLeb128(&handlers_ptr);
@@ -2914,25 +2985,23 @@
         DexFile::CatchHandlerItem handler = iterator.Get();
         if (handler.address_ == (uint32_t) work_insn_idx_) {
           if (handler.type_idx_ == DexFile::kDexNoIndex) {
-            common_super = JavaLangThrowable();
+            common_super = &reg_types_.JavaLangThrowable();
           } else {
-            Class* klass = ResolveClassAndCheckAccess(handler.type_idx_);
+            const RegType& exception = ResolveClassAndCheckAccess(handler.type_idx_);
             /* TODO: on error do we want to keep going?  If we don't fail this we run the risk of
              * having a non-Throwable introduced at runtime. However, that won't pass an instanceof
              * test, so is essentially harmless.
              */
-            if (klass == NULL) {
-              Fail(VERIFY_ERROR_GENERIC) << "unable to resolve exception class "
-                                         << handler.type_idx_ << " ("
-                                         << dex_file_->dexStringByTypeIdx(handler.type_idx_) << ")";
-              return NULL;
-            } else if(!JavaLangThrowable()->IsAssignableFrom(klass)) {
-              Fail(VERIFY_ERROR_GENERIC) << "unexpected non-exception class " << PrettyClass(klass);
-              return NULL;
+            if(!reg_types_.JavaLangThrowable().IsAssignableFrom(exception)) {
+              Fail(VERIFY_ERROR_GENERIC) << "unexpected non-exception class " << exception;
+              return reg_types_.Unknown();
             } else if (common_super == NULL) {
-              common_super = klass;
+              common_super = &exception;
+            } else if (common_super->Equals(exception)) {
+              // nothing to do
             } else {
-              common_super = RegType::ClassJoin(common_super, klass);
+              common_super = &common_super->Merge(exception, &reg_types_);
+              CHECK(reg_types_.JavaLangThrowable().IsAssignableFrom(*common_super));
             }
           }
         }
@@ -2944,7 +3013,7 @@
     /* no catch blocks, or no catches with classes we can find */
     Fail(VERIFY_ERROR_GENERIC) << "unable to find exception handler";
   }
-  return common_super;
+  return *common_super;
 }
 
 Method* DexVerifier::ResolveMethodAndCheckAccess(uint32_t method_idx, bool is_direct) {
@@ -2953,11 +3022,11 @@
   Method* res_method = dex_cache->GetResolvedMethod(method_idx);
   if (res_method == NULL) {
     const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
-    Class* klass = ResolveClassAndCheckAccess(method_id.class_idx_);
-    if (klass == NULL) {
-      DCHECK(failure_ != VERIFY_ERROR_NONE);
-      return NULL;
+    const RegType& klass_type = ResolveClassAndCheckAccess(method_id.class_idx_);
+    if(klass_type.IsUnresolvedTypes()) {
+      return NULL;  // Can't resolve Class so no more to do here
     }
+    Class* klass = klass_type.GetClass();
     const char* name = dex_file_->GetMethodName(method_id);
     std::string signature(dex_file_->CreateMethodDescriptor(method_id.proto_idx_, NULL));
     if (is_direct) {
@@ -2991,14 +3060,7 @@
   // we're making.
   Method* res_method = ResolveMethodAndCheckAccess(dec_insn.vB_,
                            (method_type == METHOD_DIRECT || method_type == METHOD_STATIC));
-  if (res_method == NULL) {
-    const DexFile::MethodId& method_id = dex_file_->GetMethodId(dec_insn.vB_);
-    const char* method_name = dex_file_->GetMethodName(method_id);
-    std::string method_signature = dex_file_->GetMethodSignature(method_id);
-    const char* class_descriptor = dex_file_->GetMethodDeclaringClassDescriptor(method_id);
-    DCHECK_NE(failure_, VERIFY_ERROR_NONE);
-    fail_messages_ << "unable to resolve method " << dec_insn.vB_ << ": "
-                   << class_descriptor << "." << method_name << " " << method_signature;
+  if (res_method == NULL) {  // error or class is unresolved
     return NULL;
   }
   // Make sure calls to constructors are "direct". There are additional restrictions but we don't
@@ -3410,13 +3472,14 @@
 }
 
 void DexVerifier::VerifyFilledNewArrayRegs(const Instruction::DecodedInstruction& dec_insn,
-                                           Class* res_class, bool is_range) {
-  DCHECK(res_class->IsArrayClass()) << PrettyClass(res_class);  // Checked before calling.
+                                           const RegType& res_type, bool is_range) {
+  DCHECK(res_type.IsArrayClass()) << res_type;  // Checked before calling.
   /*
    * Verify each register. If "arg_count" is bad, VerifyRegisterType() will run off the end of the
    * list and fail. It's legal, if silly, for arg_count to be zero.
    */
-  const RegType& expected_type = reg_types_.FromClass(res_class->GetComponentType());
+  const RegType& expected_type = reg_types_.GetComponentType(res_type,
+                                                   method_->GetDeclaringClass()->GetClassLoader());
   uint32_t arg_count = dec_insn.vA_;
   for (size_t ui = 0; ui < arg_count; ui++) {
     uint32_t get_reg;
@@ -3663,15 +3726,6 @@
   }
 }
 
-Class* DexVerifier::JavaLangThrowable() {
-  if (java_lang_throwable_ == NULL) {
-    java_lang_throwable_ =
-        Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/Throwable;");
-   DCHECK(java_lang_throwable_ != NULL);
-  }
-  return java_lang_throwable_;
-}
-
 const uint8_t* PcToReferenceMap::FindBitMap(uint16_t dex_pc, bool error_if_not_present) const {
   size_t num_entries = NumEntries();
   // Do linear or binary search?
diff --git a/src/dex_verifier.h b/src/dex_verifier.h
index 9041c95..dbe92f6 100644
--- a/src/dex_verifier.h
+++ b/src/dex_verifier.h
@@ -143,7 +143,7 @@
 
   bool IsReferenceTypes() const {
     return IsReference() || IsUnresolvedReference() || IsUninitializedReference() ||
-        IsUninitializedThisReference() || IsZero();
+        IsUninitializedThisReference() || IsUnresolvedAndUninitializedReference() || IsZero();
   }
   bool IsNonZeroReferenceTypes() const {
     return IsReference() || IsUnresolvedReference() || IsUninitializedReference() ||
@@ -182,7 +182,7 @@
   }
 
   uint32_t GetAllocationPc() const {
-    DCHECK(IsUninitializedReference());
+    DCHECK(IsUninitializedTypes());
     return allocation_pc_or_constant_;
   }
 
@@ -196,12 +196,24 @@
   bool IsJavaLangObject() const {
     return IsReference() && GetClass()->IsObjectClass();
   }
+  bool IsInstantiableTypes() const {
+    return IsUnresolvedTypes() || (IsNonZeroReferenceTypes() && GetClass()->IsInstantiable());
+  }
   String* GetDescriptor() const {
-    DCHECK(IsUnresolvedReference());
+    DCHECK(IsUnresolvedTypes());
     DCHECK(klass_or_descriptor_ != NULL);
     DCHECK(klass_or_descriptor_->IsString());
     return down_cast<String*>(klass_or_descriptor_);
   }
+  bool IsArrayClass() const {
+    if (IsUnresolvedTypes()) {
+      return GetDescriptor()->CharAt(0) == '[';
+    } else if (!IsConstant()) {
+      return GetClass()->IsArrayClass();
+    } else {
+      return false;
+    }
+  }
 
   uint16_t GetId() const {
     return cache_id_;
@@ -239,12 +251,12 @@
   RegType(Type type, Object* klass_or_descriptor, uint32_t allocation_pc_or_constant, uint16_t cache_id) :
     type_(type), klass_or_descriptor_(klass_or_descriptor), allocation_pc_or_constant_(allocation_pc_or_constant),
     cache_id_(cache_id) {
-    DCHECK(IsConstant() || IsUninitializedReference() || allocation_pc_or_constant == 0);
+    DCHECK(IsConstant() || IsUninitializedTypes() || allocation_pc_or_constant == 0);
     if (!IsConstant() && !IsLongConstant() && !IsLongConstantHigh() && !IsUnknown() &&
         !IsConflict()) {
       DCHECK(klass_or_descriptor != NULL);
-      DCHECK(IsUnresolvedReference() || klass_or_descriptor_->IsClass());
-      DCHECK(!IsUnresolvedReference() || klass_or_descriptor_->IsString());
+      DCHECK(IsUnresolvedTypes() || klass_or_descriptor_->IsClass());
+      DCHECK(!IsUnresolvedTypes() || klass_or_descriptor_->IsString());
     }
   }
 
@@ -300,14 +312,16 @@
   const RegType& JavaLangClass()  { return From(RegType::kRegTypeReference, NULL, "Ljava/lang/Class;"); }
   const RegType& JavaLangObject() { return From(RegType::kRegTypeReference, NULL, "Ljava/lang/Object;"); }
   const RegType& JavaLangString() { return From(RegType::kRegTypeReference, NULL, "Ljava/lang/String;"); }
+  const RegType& JavaLangThrowable() { return From(RegType::kRegTypeReference, NULL, "Ljava/lang/Throwable;"); }
 
   const RegType& Unknown()  { return FromType(RegType::kRegTypeUnknown); }
   const RegType& Conflict() { return FromType(RegType::kRegTypeConflict); }
   const RegType& ConstLo()  { return FromType(RegType::kRegTypeConstLo); }
   const RegType& Zero()     { return FromCat1Const(0); }
 
-  const RegType& Uninitialized(Class* klass, uint32_t allocation_pc);
+  const RegType& Uninitialized(const RegType& type, uint32_t allocation_pc);
   const RegType& UninitializedThisArgument(Class* klass);
+  const RegType& FromUninitialized(const RegType& uninit_type);
 
   // Representatives of various constant types. When merging constants we can't infer a type,
   // (an int may later be used as a float) so we select these representative values meaning future
@@ -315,6 +329,8 @@
   const RegType& ByteConstant() { return FromCat1Const(std::numeric_limits<jbyte>::min()); }
   const RegType& ShortConstant() { return FromCat1Const(std::numeric_limits<jshort>::min()); }
   const RegType& IntConstant() { return FromCat1Const(std::numeric_limits<jint>::max()); }
+
+  const RegType& GetComponentType(const RegType& array, const ClassLoader* loader);
  private:
   // The allocated entries
   std::vector<RegType*> entries_;
@@ -1073,17 +1089,12 @@
                    bool is_primitive, bool is_static);
 
   // Verify that the arguments in a filled-new-array instruction are valid.
-  // "res_class" is the class refered to by dec_insn->vB_.
-  void VerifyFilledNewArrayRegs(const Instruction::DecodedInstruction& dec_insn, Class* res_class,
-                                bool is_range);
+  void VerifyFilledNewArrayRegs(const Instruction::DecodedInstruction& dec_insn,
+                                const RegType& res_type, bool is_range);
 
-  /*
-   * Resolves a class based on an index and performs access checks to ensure the referrer can
-   * access the resolved class.
-   * Exceptions caused by failures are cleared before returning.
-   * Sets "*failure" on failure.
-   */
-  Class* ResolveClassAndCheckAccess(uint32_t class_idx);
+  // Resolves a class based on an index and performs access checks to ensure the referrer can
+  // access the resolved class.
+  const RegType& ResolveClassAndCheckAccess(uint32_t class_idx);
 
   /*
    * For the "move-exception" instruction at "work_insn_idx_", which must be at an exception handler
@@ -1091,7 +1102,7 @@
    * Returns NULL if no matching exception handler can be found, or if the exception is not a
    * subclass of Throwable.
    */
-  Class* GetCaughtExceptionType();
+  const RegType& GetCaughtExceptionType();
 
   /*
    * Resolves a method based on an index and performs access checks to ensure
@@ -1169,8 +1180,6 @@
   // Compute sizes for GC map data
   void ComputeGcMapSizes(size_t* gc_points, size_t* ref_bitmap_bits, size_t* log2_max_gc_pc);
 
-  Class* JavaLangThrowable();
-
   InsnFlags CurrentInsnFlags() {
     return insn_flags_[work_insn_idx_];
   }
@@ -1182,9 +1191,6 @@
   // Storage for the register status we're currently working on.
   UniquePtr<RegisterLine> work_line_;
 
-  // Lazily initialized reference to java.lang.Class<java.lang.Throwable>
-  Class* java_lang_throwable_;
-
   // The address of the instruction we're currently working on, note that this is in 2 byte
   // quantities
   uint32_t work_insn_idx_;
diff --git a/src/object.cc b/src/object.cc
index e59e79a..45fc781 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -668,7 +668,6 @@
 
 uint32_t Method::FindCatchBlock(Class* exception_type, uint32_t dex_pc) const {
   DexCache* dex_cache = GetDeclaringClass()->GetDexCache();
-  const ClassLoader* class_loader = GetDeclaringClass()->GetClassLoader();
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   const DexFile& dex_file = class_linker->FindDexFile(dex_cache);
   const DexFile::CodeItem* code_item = dex_file.GetCodeItem(GetCodeItemOffset());
@@ -681,9 +680,12 @@
       return iter.Get().address_;
     }
     // Does this catch exception type apply?
-    Class* iter_exception_type =
-        class_linker->ResolveType(dex_file, iter_type_idx, dex_cache, class_loader);
-    if (iter_exception_type->IsAssignableFrom(exception_type)) {
+    Class* iter_exception_type = dex_cache->GetResolvedType(iter_type_idx);
+    if (iter_exception_type == NULL) {
+      // The verifier should take care of resolving all exception classes early
+      LOG(WARNING) << "Unresolved exception class when finding catch block: "
+          << dex_file.GetTypeDescriptor(dex_file.GetTypeId(iter_type_idx));
+    } else if (iter_exception_type->IsAssignableFrom(exception_type)) {
       return iter.Get().address_;
     }
   }
@@ -764,10 +766,8 @@
 }
 
 Object* Class::AllocObject() {
-  DCHECK(!IsAbstract()) << PrettyClass(this);
-  DCHECK(!IsInterface()) << PrettyClass(this);
-  DCHECK(!IsPrimitive()) << PrettyClass(this);
   DCHECK(!IsArrayClass()) << PrettyClass(this);
+  DCHECK(IsInstantiable()) << PrettyClass(this);
   DCHECK(!Runtime::Current()->IsStarted() || IsInitializing()) << PrettyClass(this);
   DCHECK_GE(this->object_size_, sizeof(Object));
   return Heap::AllocObject(this, this->object_size_);
diff --git a/src/object.h b/src/object.h
index 58c6ba7..1051985 100644
--- a/src/object.h
+++ b/src/object.h
@@ -1463,6 +1463,9 @@
   bool IsObjectClass() const {
     return !IsPrimitive() && GetSuperClass() == NULL;
   }
+  bool IsInstantiable() const {
+    return !IsPrimitive() && !IsInterface() && !IsAbstract();
+  }
 
   // Creates a raw object instance but does not invoke the default constructor.
   Object* AllocObject();
@@ -2022,8 +2025,7 @@
   Class* super_class_;
 
   // If class verify fails, we must return same error on subsequent tries.
-  // Update with SetVerifyErrorClass to ensure a write barrier is used.
-  const Class* verify_error_class_;
+  Class* verify_error_class_;
 
   // virtual methods defined in this class; invoked through vtable
   ObjectArray<Method>* virtual_methods_;
diff --git a/src/runtime_support.cc b/src/runtime_support.cc
index 6773338..8df2abe 100644
--- a/src/runtime_support.cc
+++ b/src/runtime_support.cc
@@ -425,30 +425,6 @@
   return code;
 }
 
-// TODO: placeholder.  Helper function to type
-Class* InitializeTypeFromCode(uint32_t type_idx, Method* method) {
-  /*
-   * Should initialize & fix up method->dex_cache_resolved_types_[].
-   * Returns initialized type.  Does not return normally if an exception
-   * is thrown, but instead initiates the catch.  Should be similar to
-   * ClassLinker::InitializeStaticStorageFromCode.
-   */
-  UNIMPLEMENTED(FATAL);
-  return NULL;
-}
-
-// TODO: placeholder.  Helper function to resolve virtual method
-void ResolveMethodFromCode(Method* method, uint32_t method_idx) {
-    /*
-     * Slow-path handler on invoke virtual method path in which
-     * base method is unresolved at compile-time.  Doesn't need to
-     * return anything - just either ensure that
-     * method->dex_cache_resolved_methods_(method_idx) != NULL or
-     * throw and unwind.  The caller will restart call sequence
-     * from the beginning.
-     */
-}
-
 // Fast path field resolution that can't throw exceptions
 static Field* FindFieldFast(uint32_t field_idx, const Method* referrer) {
   Field* resolved_field = referrer->GetDexCacheResolvedFields()->Get(field_idx);
@@ -651,11 +627,30 @@
   return klass->AllocObject();
 }
 
-extern "C" Object* artAllocObjectFromCodeSlowPath(uint32_t type_idx,
-                                                  Method* method,
-                                                  Thread* self, Method** sp) {
-  //TODO: Add delayed verification checks here
-  return artAllocObjectFromCode(type_idx, method, self, sp);
+extern "C" Object* artAllocObjectFromCodeWithAccessCheck(uint32_t type_idx, Method* method,
+                                                         Thread* self, Method** sp) {
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
+  Runtime* runtime = Runtime::Current();
+  if (UNLIKELY(klass == NULL)) {
+    klass = runtime->GetClassLinker()->ResolveType(type_idx, method);
+    if (klass == NULL) {
+      DCHECK(self->IsExceptionPending());
+      return NULL;  // Failure
+    }
+  }
+  Class* referrer = method->GetDeclaringClass();
+  if (UNLIKELY(!referrer->CanAccess(klass))) {
+    self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;", "illegal class access: '%s' -> '%s'",
+                             PrettyDescriptor(referrer->GetDescriptor()).c_str(),
+                             PrettyDescriptor(klass->GetDescriptor()).c_str());
+    return NULL;  // Failure
+  }
+  if (!runtime->GetClassLinker()->EnsureInitialized(klass, true)) {
+    DCHECK(self->IsExceptionPending());
+    return NULL;  // Failure
+  }
+  return klass->AllocObject();
 }
 
 Array* CheckAndAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count,
@@ -789,6 +784,25 @@
   return InitializeStaticStorage(type_idx, referrer, self);
 }
 
+extern "C" Class* artInitializeTypeFromCode(uint32_t type_idx, const Method* referrer, Thread* self,
+                                            Method** sp) {
+  // Called when method->dex_cache_resolved_types_[] misses
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  return InitializeStaticStorage(type_idx, referrer, self);
+}
+
+// TODO: placeholder.  Helper function to resolve virtual method
+void ResolveMethodFromCode(Method* method, uint32_t method_idx) {
+    /*
+     * Slow-path handler on invoke virtual method path in which
+     * base method is unresolved at compile-time.  Doesn't need to
+     * return anything - just either ensure that
+     * method->dex_cache_resolved_methods_(method_idx) != NULL or
+     * throw and unwind.  The caller will restart call sequence
+     * from the beginning.
+     */
+}
+
 String* ResolveStringFromCode(const Method* referrer, uint32_t string_idx) {
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   return class_linker->ResolveString(string_idx, referrer);
diff --git a/src/runtime_support.h b/src/runtime_support.h
index 4ed6455..90fcf2c 100644
--- a/src/runtime_support.h
+++ b/src/runtime_support.h
@@ -59,12 +59,13 @@
   extern "C" void art_unlock_object_from_code(void*);
   extern "C" void* art_alloc_array_from_code(uint32_t, void*, int32_t);
   extern "C" void* art_alloc_object_from_code(uint32_t type_idx, void* method);
-  extern "C" void* art_alloc_object_from_code_slow_path(uint32_t type_idx, void* method);
+  extern "C" void* art_alloc_object_from_code_with_access_check(uint32_t type_idx, void* method);
   extern "C" void* art_check_and_alloc_array_from_code(uint32_t, void*, int32_t);
   extern "C" void* art_find_instance_field_from_code(uint32_t, void*);
   extern "C" void* art_find_static_field_from_code(uint32_t, void*);
   extern "C" void* art_get_obj_static_from_code(uint32_t, void*);
   extern "C" void* art_initialize_static_storage_from_code(uint32_t, void*);
+  extern "C" void* art_initialize_type_from_code(uint32_t, void*);
   extern "C" void* art_resolve_string_from_code(void*, uint32_t);
 
   /* Conversions */
diff --git a/src/runtime_support_asm.S b/src/runtime_support_asm.S
index b6d8928..112a114 100644
--- a/src/runtime_support_asm.S
+++ b/src/runtime_support_asm.S
@@ -280,6 +280,22 @@
     bxne   lr                                  @ return on success
     DELIVER_PENDING_EXCEPTION
 
+    .global art_initialize_type_from_code
+    .extern artInitializeTypeFromCode
+    /*
+     * Entry from managed code when dex cache misses for a type_idx
+     */
+art_initialize_type_from_code:
+    SETUP_REF_ONLY_CALLEE_SAVE_FRAME           @ save callee saves in case of GC
+    mov    r2, r9                              @ pass Thread::Current
+    mov    r3, sp                              @ pass SP
+    @ artInitializeTypeFromCode(uint32_t type_idx, Method* referrer, Thread*, SP)
+    bl     artInitializeTypeFromCode
+    RESTORE_REF_ONLY_CALLEE_SAVE_FRAME
+    cmp    r0, #0                              @ success if result is non-null
+    bxne   lr                                  @ return on success
+    DELIVER_PENDING_EXCEPTION
+
     .global art_find_instance_field_from_code
     .extern artFindInstanceFieldFromCode
     /*
@@ -441,16 +457,17 @@
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_alloc_object_from_code_slow_path
-    .extern artAllocObjectFromCodeSlowPath
+    .global art_alloc_object_from_code_with_access_check
+    .extern artAllocObjectFromCodeWithAccessCheck
     /*
-     * Called by managed code to allocate an object
+     * Called by managed code to allocate an object when the caller doesn't know whether it has
+     * access to the created type
      */
-art_alloc_object_from_code_slow_path:
+art_alloc_object_from_code_with_access_check:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r2, r9                     @ pass Thread::Current
     mov    r3, sp                     @ pass SP
-    bl     artAllocObjectFromCodeSlowPath     @ (uint32_t type_idx, Method* method, Thread*, SP)
+    bl     artAllocObjectFromCodeWithAccessCheck  @ (uint32_t type_idx, Method* method, Thread*, SP)
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME
     cmp    r0, #0                     @ success if result is non-null
     bxne   lr                         @ return on success
diff --git a/src/thread.cc b/src/thread.cc
index 841ea9b..a8c58bf 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -91,7 +91,7 @@
   pLmul = __aeabi_lmul;
   pAllocArrayFromCode = art_alloc_array_from_code;
   pAllocObjectFromCode = art_alloc_object_from_code;
-  pAllocObjectFromCodeSlowPath = art_alloc_object_from_code_slow_path;
+  pAllocObjectFromCodeWithAccessCheck = art_alloc_object_from_code_with_access_check;
   pCanPutArrayElementFromCode = art_can_put_array_element_from_code;
   pCheckAndAllocArrayFromCode = art_check_and_alloc_array_from_code;
   pCheckCastFromCode = art_check_cast_from_code;
@@ -101,6 +101,7 @@
   pGetObjStatic = art_get_obj_static_from_code;
   pHandleFillArrayDataFromCode = art_handle_fill_data_from_code;
   pInitializeStaticStorage = art_initialize_static_storage_from_code;
+  pInitializeTypeFromCode = art_initialize_type_from_code;
   pInvokeInterfaceTrampoline = art_invoke_interface_trampoline;
   pLockObjectFromCode = art_lock_object_from_code;
   pObjectInit = art_object_init_from_code;
@@ -126,7 +127,6 @@
   pDecodeJObjectInThread = DecodeJObjectInThread;
   pDeliverException = art_deliver_exception_from_code;
   pFindNativeMethod = FindNativeMethod;
-  pInitializeTypeFromCode = InitializeTypeFromCode;
   pInstanceofNonTrivialFromCode = IsAssignableFromCode;
   pResolveMethodFromCode = ResolveMethodFromCode;
   pThrowAbstractMethodErrorFromCode = ThrowAbstractMethodErrorFromCode;
@@ -482,7 +482,8 @@
 
 struct StackDumpVisitor : public Thread::StackVisitor {
   StackDumpVisitor(std::ostream& os, const Thread* thread)
-      : os(os), thread(thread), frame_count(0) {
+      : last_method(NULL), last_line_number(0), repetition_count(0), os(os), thread(thread),
+        frame_count(0) {
   }
 
   virtual ~StackDumpVisitor() {
@@ -492,28 +493,41 @@
     if (!frame.HasMethod()) {
       return;
     }
-
+    const int kMaxRepetition = 3;
     Method* m = frame.GetMethod();
     Class* c = m->GetDeclaringClass();
     ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
     const DexFile& dex_file = class_linker->FindDexFile(c->GetDexCache());
-
-    os << "  at " << PrettyMethod(m, false);
-    if (m->IsNative()) {
-      os << "(Native method)";
+    int line_number = dex_file.GetLineNumFromPC(m, m->ToDexPC(pc));
+    if (line_number == last_line_number && last_method == m) {
+      repetition_count++;
     } else {
-      int line_number = dex_file.GetLineNumFromPC(m, m->ToDexPC(pc));
-      SirtRef<String> source_file(c->GetSourceFile());
-      os << "(" << (source_file.get() != NULL ? source_file->ToModifiedUtf8() : "unavailable")
-         << ":" << line_number << ")";
+      if (repetition_count >= kMaxRepetition) {
+        os << "  ... repeated " << (repetition_count - kMaxRepetition) << " times\n";
+      }
+      repetition_count = 0;
+      last_line_number = line_number;
+      last_method = m;
     }
-    os << "\n";
+    if (repetition_count < kMaxRepetition) {
+      os << "  at " << PrettyMethod(m, false);
+      if (m->IsNative()) {
+        os << "(Native method)";
+      } else {
+        SirtRef<String> source_file(c->GetSourceFile());
+        os << "(" << (source_file.get() != NULL ? source_file->ToModifiedUtf8() : "unavailable")
+           << ":" << line_number << ")";
+      }
+      os << "\n";
+    }
 
     if (frame_count++ == 0) {
       Monitor::DescribeWait(os, thread);
     }
   }
-
+  Method* last_method;
+  int last_line_number;
+  int repetition_count;
   std::ostream& os;
   const Thread* thread;
   int frame_count;
@@ -1316,13 +1330,35 @@
 };
 
 void Thread::DeliverException() {
-  Throwable *exception = GetException();  // Set exception on thread
+  const bool kDebugExceptionDelivery = false;
+  Throwable *exception = GetException();  // Get exception from thread
   CHECK(exception != NULL);
+  // Don't leave exception visible while we try to find the handler, which may cause class
+  // resolution
+  ClearException();
+  if (kDebugExceptionDelivery) {
+    DumpStack(LOG(INFO) << "Delivering exception: " << PrettyTypeOf(exception) << std::endl);
+  }
 
   Context* long_jump_context = GetLongJumpContext();
   CatchBlockStackVisitor catch_finder(exception->GetClass(), long_jump_context);
   WalkStackUntilUpCall(&catch_finder, true);
 
+  if (kDebugExceptionDelivery) {
+    Method* handler_method = catch_finder.handler_frame_.GetMethod();
+    if (handler_method == NULL) {
+      LOG(INFO) << "Handler is upcall";
+    } else {
+      ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+      const DexFile& dex_file =
+          class_linker->FindDexFile(handler_method->GetDeclaringClass()->GetDexCache());
+      int line_number = dex_file.GetLineNumFromPC(handler_method,
+                                                handler_method->ToDexPC(catch_finder.handler_pc_));
+      LOG(INFO) << "Handler: " << PrettyMethod(handler_method)
+          << " (line: " << line_number << ")";
+    }
+  }
+  SetException(exception);
   long_jump_context->SetSP(reinterpret_cast<intptr_t>(catch_finder.handler_frame_.GetSP()));
   long_jump_context->SetPC(catch_finder.handler_pc_);
   long_jump_context->DoLongJump();
diff --git a/src/thread.h b/src/thread.h
index ac97ebe..eec9df4 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -120,7 +120,7 @@
   void (*pCheckSuspendFromCode)(Thread*);  // Stub that is called when the suspend count is non-zero
   void (*pTestSuspendFromCode)();  // Stub that is periodically called to test the suspend count
   void* (*pAllocObjectFromCode)(uint32_t, void*);
-  void* (*pAllocObjectFromCodeSlowPath)(uint32_t, void*);
+  void* (*pAllocObjectFromCodeWithAccessCheck)(uint32_t, void*);
   void* (*pAllocArrayFromCode)(uint32_t, void*, int32_t);
   void (*pCanPutArrayElementFromCode)(void*, void*);
   void* (*pCheckAndAllocArrayFromCode)(uint32_t, void*, int32_t);
@@ -137,7 +137,7 @@
   void* (*pInitializeStaticStorage)(uint32_t, void*);
   uint32_t (*pInstanceofNonTrivialFromCode)(const Class*, const Class*);
   void (*pInvokeInterfaceTrampoline)(uint32_t, void*);
-  Class* (*pInitializeTypeFromCode)(uint32_t, Method*);
+  void* (*pInitializeTypeFromCode)(uint32_t, void*);
   void (*pLockObjectFromCode)(void*);
   void (*pObjectInit)(void*);
   void (*pResolveMethodFromCode)(Method*, uint32_t);