diff --git a/build/Android.common.mk b/build/Android.common.mk
index 7dbe04c..d02b998 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -146,6 +146,7 @@
 	src/card_table.cc \
 	src/check_jni.cc \
 	src/class_linker.cc \
+	src/common_throws.cc \
 	src/compiled_method.cc \
 	src/compiler.cc \
 	src/debugger.cc \
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 8ee3b1e..f6fb470 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -118,7 +118,9 @@
   // a NoClassDefFoundError (v2 2.17.5).  The exception to this rule is if we
   // failed in verification, in which case v2 5.4.1 says we need to re-throw
   // the previous error.
-  LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
+  if (!Runtime::Current()->IsCompiler()) {  // Give info if this occurs at runtime.
+    LOG(INFO) << "Rejecting re-init on previously-failed class " << PrettyClass(c);
+  }
 
   CHECK(c->IsErroneous()) << PrettyClass(c) << " " << c->GetStatus();
   if (c->GetVerifyErrorClass() != NULL) {
@@ -3465,31 +3467,8 @@
   }
   if (resolved != NULL) {
     // We found a method, check for incompatible class changes.
-    switch (type) {
-      case kDirect:
-        if (resolved->IsStatic()) {
-          resolved = NULL;  // Incompatible class change.
-        }
-        break;
-      case kStatic:
-        if (!resolved->IsStatic()) {
-          resolved = NULL;  // Incompatible class change.
-        }
-        break;
-      case kInterface:
-        if (resolved->IsConstructor() || !resolved->GetDeclaringClass()->IsInterface()) {
-          resolved = NULL;  // Incompatible class change.
-        }
-        break;
-      case kSuper:
-        // TODO: appropriate checks for call to super class.
-        break;
-      case kVirtual:
-        if (resolved->IsConstructor() || (resolved->GetDeclaringClass()->IsInterface() &&
-                                          !resolved->IsMiranda())) {
-          resolved = NULL;  // Incompatible class change.
-        }
-        break;
+    if (resolved->CheckIncompatibleClassChange(type)) {
+      resolved = NULL;
     }
   }
   if (resolved != NULL) {
@@ -3518,12 +3497,12 @@
       Class* methods_class = resolved->GetDeclaringClass();
       Class* referring_class = referrer->GetDeclaringClass();
       if (!referring_class->CanAccess(methods_class)) {
-        ThrowNewIllegalAccessErrorClassForMethodDispatch(Thread::Current(), referring_class, methods_class,
-                                                         referrer, resolved, type);
+        ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class,
+                                                      referrer, resolved, type);
         return NULL;
       } else if (!referring_class->CanAccessMember(methods_class,
                                                    resolved->GetAccessFlags())) {
-        ThrowNewIllegalAccessErrorMethod(Thread::Current(), referring_class, resolved);
+        ThrowIllegalAccessErrorMethod(referring_class, resolved);
         return NULL;
       }
     }
diff --git a/src/common_throws.cc b/src/common_throws.cc
new file mode 100644
index 0000000..5bd30b4
--- /dev/null
+++ b/src/common_throws.cc
@@ -0,0 +1,250 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "common_throws.h"
+
+#include "dex_instruction.h"
+#include "invoke_type.h"
+#include "logging.h"
+#include "object_utils.h"
+#include "thread.h"
+
+#include <sstream>
+
+namespace art {
+
+static void AddReferrerLocation(std::ostream& os, const Method* referrer)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  if (referrer != NULL) {
+    ClassHelper kh(referrer->GetDeclaringClass());
+    std::string location(kh.GetLocation());
+    if (!location.empty()) {
+      os << " (accessed from " << location << ")";
+    }
+  }
+}
+
+static void AddReferrerLocationFromClass(std::ostream& os, Class* referrer)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  if (referrer != NULL) {
+    ClassHelper kh(referrer);
+    std::string location(kh.GetLocation());
+    if (!location.empty()) {
+      os << " (declaration of '" << PrettyDescriptor(referrer)
+            << "' appears in " << location << ")";
+    }
+  }
+}
+
+// NullPointerException
+
+void ThrowNullPointerExceptionForFieldAccess(Field* field, bool is_read) {
+  std::ostringstream msg;
+  msg << "Attempt to " << (is_read ? "read from" : "write to")
+      << " field '" << PrettyField(field, true) << "' on a null object reference";
+  Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", msg.str().c_str());
+}
+
+void ThrowNullPointerExceptionForMethodAccess(Method* caller, uint32_t method_idx,
+                                              InvokeType type) {
+  DexCache* dex_cache = caller->GetDeclaringClass()->GetDexCache();
+  const DexFile& dex_file = Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache);
+  std::ostringstream msg;
+  msg << "Attempt to invoke " << ToStr<InvokeType>(type).str() << " method '"
+      << PrettyMethod(method_idx, dex_file, true) << "' on a null object reference";
+  Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", msg.str().c_str());
+}
+
+void ThrowNullPointerExceptionFromDexPC(Method* throw_method, uint32_t dex_pc) {
+  const DexFile::CodeItem* code = MethodHelper(throw_method).GetCodeItem();
+  CHECK_LT(dex_pc, code->insns_size_in_code_units_);
+  const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
+  DecodedInstruction dec_insn(instr);
+  switch (instr->Opcode()) {
+    case Instruction::INVOKE_DIRECT:
+    case Instruction::INVOKE_DIRECT_RANGE:
+      ThrowNullPointerExceptionForMethodAccess(throw_method, dec_insn.vB, kDirect);
+      break;
+    case Instruction::INVOKE_VIRTUAL:
+    case Instruction::INVOKE_VIRTUAL_RANGE:
+      ThrowNullPointerExceptionForMethodAccess(throw_method, dec_insn.vB, kVirtual);
+      break;
+    case Instruction::IGET:
+    case Instruction::IGET_WIDE:
+    case Instruction::IGET_OBJECT:
+    case Instruction::IGET_BOOLEAN:
+    case Instruction::IGET_BYTE:
+    case Instruction::IGET_CHAR:
+    case Instruction::IGET_SHORT: {
+      Field* field =
+          Runtime::Current()->GetClassLinker()->ResolveField(dec_insn.vC, throw_method, false);
+      ThrowNullPointerExceptionForFieldAccess(field, true /* read */);
+      break;
+    }
+    case Instruction::IPUT:
+    case Instruction::IPUT_WIDE:
+    case Instruction::IPUT_OBJECT:
+    case Instruction::IPUT_BOOLEAN:
+    case Instruction::IPUT_BYTE:
+    case Instruction::IPUT_CHAR:
+    case Instruction::IPUT_SHORT: {
+      Field* field =
+          Runtime::Current()->GetClassLinker()->ResolveField(dec_insn.vC, throw_method, false);
+      ThrowNullPointerExceptionForFieldAccess(field, false /* write */);
+      break;
+    }
+    case Instruction::AGET:
+    case Instruction::AGET_WIDE:
+    case Instruction::AGET_OBJECT:
+    case Instruction::AGET_BOOLEAN:
+    case Instruction::AGET_BYTE:
+    case Instruction::AGET_CHAR:
+    case Instruction::AGET_SHORT:
+      Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;",
+                                           "Attempt to read from null array");
+      break;
+    case Instruction::APUT:
+    case Instruction::APUT_WIDE:
+    case Instruction::APUT_OBJECT:
+    case Instruction::APUT_BOOLEAN:
+    case Instruction::APUT_BYTE:
+    case Instruction::APUT_CHAR:
+    case Instruction::APUT_SHORT:
+      Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;",
+                                           "Attempt to write to null array");
+      break;
+    case Instruction::ARRAY_LENGTH:
+      Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;",
+                                           "Attempt to get length of null array");
+      break;
+    default: {
+      const DexFile& dex_file = Runtime::Current()->GetClassLinker()
+          ->FindDexFile(throw_method->GetDeclaringClass()->GetDexCache());
+      std::string message("Null pointer exception during instruction '");
+      message += instr->DumpString(&dex_file);
+      message += "'";
+      Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", message.c_str());
+      break;
+    }
+  }
+}
+
+// IllegalAccessError
+
+void ThrowIllegalAccessErrorClass(Class* referrer, Class* accessed) {
+  std::ostringstream msg;
+  msg << "Illegal class access: '" << PrettyDescriptor(referrer) << "' -> '"
+      << PrettyDescriptor(accessed) << "'";
+  AddReferrerLocationFromClass(msg, referrer);
+  Thread::Current()->ThrowNewException("Ljava/lang/IllegalAccessError;", msg.str().c_str());
+}
+
+void ThrowIllegalAccessErrorClassForMethodDispatch(Class* referrer, Class* accessed,
+                                                   const Method* caller,
+                                                   const Method* called,
+                                                   InvokeType type) {
+  std::ostringstream msg;
+  msg << "Illegal class access ('" << PrettyDescriptor(referrer) << "' -> '"
+      << PrettyDescriptor(accessed) << "') in attempt to invoke " << ToStr<InvokeType>(type).str()
+      << " method " << PrettyMethod(called).c_str();
+  AddReferrerLocation(msg, caller);
+  Thread::Current()->ThrowNewException("Ljava/lang/IllegalAccessError;", msg.str().c_str());
+}
+
+void ThrowIllegalAccessErrorMethod(Class* referrer, Method* accessed) {
+  std::ostringstream msg;
+  msg << "Method '" << PrettyMethod(accessed) << "' is inaccessible to class '"
+      << PrettyDescriptor(referrer) << "'";
+  AddReferrerLocationFromClass(msg, referrer);
+  Thread::Current()->ThrowNewException("Ljava/lang/IllegalAccessError;", msg.str().c_str());
+}
+
+void ThrowIllegalAccessErrorField(Class* referrer, Field* accessed) {
+  std::ostringstream msg;
+  msg << "Field '" << PrettyField(accessed, false) << "' is inaccessible to class '"
+      << PrettyDescriptor(referrer) << "'";
+  AddReferrerLocationFromClass(msg, referrer);
+  Thread::Current()->ThrowNewException("Ljava/lang/IllegalAccessError;", msg.str().c_str());
+}
+
+void ThrowIllegalAccessErrorFinalField(const Method* referrer, Field* accessed) {
+  std::ostringstream msg;
+  msg << "Final field '" << PrettyField(accessed, false) << "' cannot be written to by method '"
+      << PrettyMethod(referrer) << "'";
+  AddReferrerLocation(msg, referrer);
+  Thread::Current()->ThrowNewException("Ljava/lang/IllegalAccessError;", msg.str().c_str());
+}
+
+// IncompatibleClassChangeError
+
+void ThrowIncompatibleClassChangeError(InvokeType expected_type, InvokeType found_type,
+                                       Method* method, const Method* referrer) {
+  std::ostringstream msg;
+  msg << "The method '" << PrettyMethod(method) << "' was expected to be of type "
+      << expected_type << " but instead was found to be of type " << found_type;
+  AddReferrerLocation(msg, referrer);
+  Thread::Current()->ThrowNewException("Ljava/lang/IncompatibleClassChangeError;",
+                                       msg.str().c_str());
+}
+
+void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const Method* interface_method,
+                                                                Object* this_object,
+                                                                const Method* referrer) {
+  // Referrer is calling interface_method on this_object, however, the interface_method isn't
+  // implemented by this_object.
+  CHECK(this_object != NULL);
+  std::ostringstream msg;
+  msg << "Class '" << PrettyDescriptor(this_object->GetClass())
+      << "' does not implement interface '"
+      << PrettyDescriptor(interface_method->GetDeclaringClass())
+      << "' in call to '" << PrettyMethod(interface_method) << "'";
+  AddReferrerLocation(msg, referrer);
+  Thread::Current()->ThrowNewException("Ljava/lang/IncompatibleClassChangeError;",
+                                       msg.str().c_str());
+}
+
+void ThrowIncompatibleClassChangeErrorField(const Field* resolved_field, bool is_static,
+                                            const Method* referrer) {
+  std::ostringstream msg;
+  msg << "Expected '" << PrettyField(resolved_field) << "' to be a "
+      << (is_static ? "static" : "instance") << " field";
+  AddReferrerLocation(msg, referrer);
+  Thread::Current()->ThrowNewException("Ljava/lang/IncompatibleClassChangeError;",
+                                       msg.str().c_str());
+}
+
+// NoSuchMethodError
+
+void ThrowNoSuchMethodError(InvokeType type, Class* c, const StringPiece& name,
+                            const StringPiece& signature, const Method* referrer) {
+  std::ostringstream msg;
+  ClassHelper kh(c);
+  msg << "No " << type << " method " << name << signature
+      << " in class " << kh.GetDescriptor() << " or its super classes";
+  AddReferrerLocation(msg, referrer);
+  Thread::Current()->ThrowNewException("Ljava/lang/NoSuchMethodError;", msg.str().c_str());
+}
+
+void ThrowNoSuchMethodError(uint32_t method_idx, const Method* referrer) {
+  DexCache* dex_cache = referrer->GetDeclaringClass()->GetDexCache();
+  const DexFile& dex_file = Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache);
+  std::ostringstream msg;
+  msg << "No method '" << PrettyMethod(method_idx, dex_file, true) << "'";
+  AddReferrerLocation(msg, referrer);
+  Thread::Current()->ThrowNewException("Ljava/lang/NoSuchMethodError;", msg.str().c_str());
+}
+
+}  // namespace art
diff --git a/src/common_throws.h b/src/common_throws.h
new file mode 100644
index 0000000..47186b0
--- /dev/null
+++ b/src/common_throws.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_SRC_COMMON_THROWS__H_
+#define ART_SRC_COMMON_THROWS_H_
+
+#include "mutex.h"
+#include "object.h"
+
+namespace art {
+
+// NullPointerException
+
+void ThrowNullPointerExceptionForFieldAccess(Field* field, bool is_read)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+void ThrowNullPointerExceptionForMethodAccess(Method* caller, uint32_t method_idx, InvokeType type)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+void ThrowNullPointerExceptionFromDexPC(Method* throw_method, uint32_t dex_pc)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+// IllegalAccessError
+
+void ThrowIllegalAccessErrorClass(Class* referrer, Class* accessed)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+void ThrowIllegalAccessErrorClassForMethodDispatch(Class* referrer, Class* accessed,
+                                                   const Method* caller, const Method* called,
+                                                   InvokeType type)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+void ThrowIllegalAccessErrorMethod(Class* referrer, Method* accessed)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+void ThrowIllegalAccessErrorField(Class* referrer, Field* accessed)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+void ThrowIllegalAccessErrorFinalField(const Method* referrer, Field* accessed)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+// IncompatibleClassChangeError
+
+void ThrowIncompatibleClassChangeError(InvokeType expected_type, InvokeType found_type,
+                                       Method* method, const Method* referrer)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const Method* interface_method,
+                                                                Object* this_object,
+                                                                const Method* referrer)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+void ThrowIncompatibleClassChangeErrorField(const Field* resolved_field, bool is_static,
+                                            const Method* referrer)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+// NoSuchMethodError
+
+void ThrowNoSuchMethodError(InvokeType type, Class* c, const StringPiece& name,
+                            const StringPiece& signature, const Method* referrer)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+void ThrowNoSuchMethodError(uint32_t method_idx, const Method* referrer)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+}  // namespace art
+
+#endif  // ART_SRC_COMMON_THROWS_H_
diff --git a/src/compiler_llvm/runtime_support_llvm.cc b/src/compiler_llvm/runtime_support_llvm.cc
index a6fa80d..dd56ac8 100644
--- a/src/compiler_llvm/runtime_support_llvm.cc
+++ b/src/compiler_llvm/runtime_support_llvm.cc
@@ -133,11 +133,7 @@
   Thread* thread = art_get_current_thread_from_code();
   // We need the calling method as context for the method_idx
   Method* method = thread->GetCurrentMethod();
-  thread->ThrowNewException("Ljava/lang/NoSuchMethodError;",
-                            MethodNameFromIndex(method,
-                                                method_idx,
-                                                verifier::VERIFY_ERROR_REF_METHOD,
-                                                false).c_str());
+  ThrowNoSuchMethodError(method_idx, method);
 }
 
 void art_throw_null_pointer_exception_from_code(uint32_t dex_pc)
@@ -146,7 +142,7 @@
   NthCallerVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), 0);
   visitor.WalkStack();
   Method* throw_method = visitor.caller;
-  ThrowNullPointerExceptionFromDexPC(thread, throw_method, dex_pc);
+  ThrowNullPointerExceptionFromDexPC(throw_method, dex_pc);
 }
 
 void art_throw_stack_overflow_from_code()
@@ -226,17 +222,17 @@
 Object* art_alloc_array_from_code(uint32_t type_idx,
                                   Method* referrer,
                                   uint32_t length,
-                                  Thread* thread)
+                                  Thread* /*thread*/)
     SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
-  return AllocArrayFromCode(type_idx, referrer, length, thread, false);
+  return AllocArrayFromCode(type_idx, referrer, length, false);
 }
 
 Object* art_alloc_array_from_code_with_access_check(uint32_t type_idx,
                                                     Method* referrer,
                                                     uint32_t length,
-                                                    Thread* thread)
+                                                    Thread* /*thread*/)
     SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
-  return AllocArrayFromCode(type_idx, referrer, length, thread, true);
+  return AllocArrayFromCode(type_idx, referrer, length, true);
 }
 
 Object* art_check_and_alloc_array_from_code(uint32_t type_idx,
diff --git a/src/oat/runtime/support_alloc.cc b/src/oat/runtime/support_alloc.cc
index 4a03f98..528198d 100644
--- a/src/oat/runtime/support_alloc.cc
+++ b/src/oat/runtime/support_alloc.cc
@@ -37,7 +37,7 @@
                                         Thread* self, Method** sp)
     SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-  return AllocArrayFromCode(type_idx, method, component_count, self, false);
+  return AllocArrayFromCode(type_idx, method, component_count, false);
 }
 
 extern "C" Array* artAllocArrayFromCodeWithAccessCheck(uint32_t type_idx, Method* method,
@@ -45,7 +45,7 @@
                                                        Thread* self, Method** sp)
     SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-  return AllocArrayFromCode(type_idx, method, component_count, self, true);
+  return AllocArrayFromCode(type_idx, method, component_count, true);
 }
 
 extern "C" Array* artCheckAndAllocArrayFromCode(uint32_t type_idx, Method* method,
diff --git a/src/oat/runtime/support_field.cc b/src/oat/runtime/support_field.cc
index 289553e..fe8974b 100644
--- a/src/oat/runtime/support_field.cc
+++ b/src/oat/runtime/support_field.cc
@@ -77,7 +77,7 @@
   field = FindFieldFromCode(field_idx, referrer, self, InstancePrimitiveRead, sizeof(int32_t));
   if (LIKELY(field != NULL)) {
     if (UNLIKELY(obj == NULL)) {
-      ThrowNullPointerExceptionForFieldAccess(self, field, true);
+      ThrowNullPointerExceptionForFieldAccess(field, true);
     } else {
       return field->Get32(obj);
     }
@@ -96,7 +96,7 @@
   field = FindFieldFromCode(field_idx, referrer, self, InstancePrimitiveRead, sizeof(int64_t));
   if (LIKELY(field != NULL)) {
     if (UNLIKELY(obj == NULL)) {
-      ThrowNullPointerExceptionForFieldAccess(self, field, true);
+      ThrowNullPointerExceptionForFieldAccess(field, true);
     } else {
       return field->Get64(obj);
     }
@@ -115,7 +115,7 @@
   field = FindFieldFromCode(field_idx, referrer, self, InstanceObjectRead, sizeof(Object*));
   if (LIKELY(field != NULL)) {
     if (UNLIKELY(obj == NULL)) {
-      ThrowNullPointerExceptionForFieldAccess(self, field, true);
+      ThrowNullPointerExceptionForFieldAccess(field, true);
     } else {
       return field->GetObj(obj);
     }
@@ -188,7 +188,7 @@
   field = FindFieldFromCode(field_idx, referrer, self, InstancePrimitiveWrite, sizeof(int32_t));
   if (LIKELY(field != NULL)) {
     if (UNLIKELY(obj == NULL)) {
-      ThrowNullPointerExceptionForFieldAccess(self, field, false);
+      ThrowNullPointerExceptionForFieldAccess(field, false);
     } else {
       field->Set32(obj, new_value);
       return 0;  // success
@@ -212,7 +212,7 @@
   field = FindFieldFromCode(field_idx, referrer, self, InstancePrimitiveWrite, sizeof(int64_t));
   if (LIKELY(field != NULL)) {
     if (UNLIKELY(obj == NULL)) {
-      ThrowNullPointerExceptionForFieldAccess(self, field, false);
+      ThrowNullPointerExceptionForFieldAccess(field, false);
     } else {
       field->Set64(obj, new_value);
       return 0;  // success
@@ -233,7 +233,7 @@
   field = FindFieldFromCode(field_idx, referrer, self, InstanceObjectWrite, sizeof(Object*));
   if (LIKELY(field != NULL)) {
     if (UNLIKELY(obj == NULL)) {
-      ThrowNullPointerExceptionForFieldAccess(self, field, false);
+      ThrowNullPointerExceptionForFieldAccess(field, false);
     } else {
       field->SetObj(obj, new_value);
       return 0;  // success
diff --git a/src/oat/runtime/support_invoke.cc b/src/oat/runtime/support_invoke.cc
index 9c7b3a2..b2867ef 100644
--- a/src/oat/runtime/support_invoke.cc
+++ b/src/oat/runtime/support_invoke.cc
@@ -26,7 +26,7 @@
   if (UNLIKELY(method == NULL)) {
     FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
     if (UNLIKELY(this_object == NULL && type != kDirect && type != kStatic)) {
-      ThrowNullPointerExceptionForMethodAccess(self, caller_method, method_idx, type);
+      ThrowNullPointerExceptionForMethodAccess(caller_method, method_idx, type);
       return 0;  // failure
     }
     method = FindMethodFromCode(method_idx, this_object, caller_method, self, access_check, type);
diff --git a/src/oat/runtime/support_throw.cc b/src/oat/runtime/support_throw.cc
index 9776290..0abdb04 100644
--- a/src/oat/runtime/support_throw.cc
+++ b/src/oat/runtime/support_throw.cc
@@ -54,7 +54,7 @@
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
   uint32_t dex_pc;
   Method* throw_method = self->GetCurrentMethod(&dex_pc);
-  ThrowNullPointerExceptionFromDexPC(self, throw_method, dex_pc);
+  ThrowNullPointerExceptionFromDexPC(throw_method, dex_pc);
   self->DeliverException();
 }
 
@@ -93,8 +93,7 @@
     SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
   Method* method = self->GetCurrentMethod();
-  self->ThrowNewException("Ljava/lang/NoSuchMethodError;",
-      MethodNameFromIndex(method, method_idx, verifier::VERIFY_ERROR_REF_METHOD, false).c_str());
+  ThrowNoSuchMethodError(method_idx, method);
   self->DeliverException();
 }
 
diff --git a/src/object.h b/src/object.h
index 85b1721..6d686f4 100644
--- a/src/object.h
+++ b/src/object.h
@@ -2452,27 +2452,25 @@
 }
 
 inline bool Method::CheckIncompatibleClassChange(InvokeType type) {
-  bool icce = true;
   switch (type) {
     case kStatic:
-      icce = !IsStatic();
-      break;
+      return !IsStatic();
     case kDirect:
-      icce = !IsDirect();
-      break;
-    case kVirtual:
-      icce = IsDirect();
-      break;
+      return !IsDirect() || IsStatic();
+    case kVirtual: {
+      Class* methods_class = GetDeclaringClass();
+      return IsDirect() || (methods_class->IsInterface() && !IsMiranda());
+    }
     case kSuper:
-      icce = false;
-      break;
+      return false;  // TODO: appropriate checks for call to super class.
     case kInterface: {
       Class* methods_class = GetDeclaringClass();
-      icce = IsDirect() || !(methods_class->IsInterface() || methods_class->IsObjectClass());
-      break;
+      return IsDirect() || !(methods_class->IsInterface() || methods_class->IsObjectClass());
     }
+    default:
+      LOG(FATAL) << "UNREACHABLE";
+      return true;
   }
-  return icce;
 }
 
 inline void Method::AssertPcIsWithinCode(uintptr_t pc) const {
diff --git a/src/runtime_support.cc b/src/runtime_support.cc
index 16406c4..01bdf9a 100644
--- a/src/runtime_support.cc
+++ b/src/runtime_support.cc
@@ -89,259 +89,6 @@
 
 namespace art {
 
-void ThrowNewIllegalAccessErrorClass(Thread* self,
-                                     Class* referrer,
-                                     Class* accessed) {
-  self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
-                           "Illegal class access: '%s' -> '%s'",
-                           PrettyDescriptor(referrer).c_str(),
-                           PrettyDescriptor(accessed).c_str());
-}
-
-void ThrowNewIllegalAccessErrorClassForMethodDispatch(Thread* self,
-                                                      Class* referrer,
-                                                      Class* accessed,
-                                                      const Method* caller,
-                                                      const Method* called,
-                                                      InvokeType type) {
-  self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
-                           "Illegal class access ('%s' -> '%s')"
-                           "in attempt to invoke %s method '%s' from '%s'",
-                           PrettyDescriptor(referrer).c_str(),
-                           PrettyDescriptor(accessed).c_str(),
-                           ToStr<InvokeType>(type).c_str(),
-                           PrettyMethod(called).c_str(),
-                           PrettyMethod(caller).c_str());
-}
-
-static void ThrowNewIncompatibleClassChangeErrorClassForInterfaceDispatch(Thread* self,
-                                                                          const Method* interface_method,
-                                                                          Object* this_object)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
-  std::string interface_method_name(PrettyMethod(interface_method));
-  if (this_object != NULL) {
-    std::string this_class_descriptor(PrettyDescriptor(this_object->GetClass()));
-    std::string interface_class_descriptor(PrettyDescriptor(interface_method->GetDeclaringClass()));
-    self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
-                             "Class '%s' does not implement interface '%s' in call to '%s'",
-                             this_class_descriptor.c_str(),
-                             interface_class_descriptor.c_str(),
-                             interface_method_name.c_str());
-  } else {
-    self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
-                             "Expected '%s' to be an interface method",
-                             interface_method_name.c_str());
-  }
-}
-
-static void ThrowNewIncompatibleClassChangeErrorField(Thread* self, const Field* resolved_field,
-                                               bool is_static)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
-  self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
-                           "Expected '%s' to be a %s field",
-                           PrettyField(resolved_field).c_str(),
-                           is_static ? "static" : "instance");
-}
-
-void ThrowIncompatibleClassChangeError(InvokeType expected_type, InvokeType found_type,
-                                       Method* method, const Method* referrer) {
-  std::ostringstream msg;
-  msg << "The method '" << PrettyMethod(method) << "' was expected to be of type "
-      << expected_type << " but instead was found to be of type " << found_type;
-  if (referrer != NULL) {
-    ClassHelper kh(referrer->GetDeclaringClass());
-    std::string location(kh.GetLocation());
-    if (!location.empty()) {
-      msg << " (accessed from " << location << ")";
-    }
-  }
-  Thread::Current()->ThrowNewException("Ljava/lang/IncompatibleClassChangeError;",
-                                       msg.str().c_str());
-}
-
-void ThrowNoSuchMethodError(InvokeType type, Class* c, const StringPiece& name,
-                            const StringPiece& signature, const Method* referrer) {
-  ClassHelper kh(c);
-  std::ostringstream msg;
-  msg << "No " << type << " method " << name << signature
-      << " in class " << kh.GetDescriptor() << " or its superclasses";
-  if (referrer != NULL) {
-    kh.ChangeClass(referrer->GetDeclaringClass());
-    std::string location(kh.GetLocation());
-    if (!location.empty()) {
-      msg << " (accessed from " << location << ")";
-    }
-  }
-  Thread::Current()->ThrowNewException("Ljava/lang/NoSuchMethodError;", msg.str().c_str());
-}
-
-void ThrowNewIllegalAccessErrorField(Thread* self,
-                                     Class* referrer,
-                                     Field* accessed) {
-  self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
-                           "Field '%s' is inaccessible to class '%s'",
-                           PrettyField(accessed, false).c_str(),
-                           PrettyDescriptor(referrer).c_str());
-}
-
-void ThrowNewIllegalAccessErrorFinalField(Thread* self,
-                                          const Method* referrer,
-                                          Field* accessed) {
-  self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
-                           "Final field '%s' cannot be written to by method '%s'",
-                           PrettyField(accessed, false).c_str(),
-                           PrettyMethod(referrer).c_str());
-}
-
-void ThrowNewIllegalAccessErrorMethod(Thread* self,
-                                      Class* referrer,
-                                      Method* accessed) {
-  self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
-                           "Method '%s' is inaccessible to class '%s'",
-                           PrettyMethod(accessed).c_str(),
-                           PrettyDescriptor(referrer).c_str());
-}
-
-void ThrowNullPointerExceptionForFieldAccess(Thread* self,
-                                                           Field* field,
-                                                           bool is_read) {
-  self->ThrowNewExceptionF("Ljava/lang/NullPointerException;",
-                           "Attempt to %s field '%s' on a null object reference",
-                           is_read ? "read from" : "write to",
-                           PrettyField(field, true).c_str());
-}
-
-void ThrowNullPointerExceptionForMethodAccess(Thread* self,
-                                              Method* caller,
-                                              uint32_t method_idx,
-                                              InvokeType type) {
-  const DexFile& dex_file =
-      Runtime::Current()->GetClassLinker()->FindDexFile(caller->GetDeclaringClass()->GetDexCache());
-  self->ThrowNewExceptionF("Ljava/lang/NullPointerException;",
-                           "Attempt to invoke %s method '%s' on a null object reference",
-                           ToStr<InvokeType>(type).c_str(),
-                           PrettyMethod(method_idx, dex_file, true).c_str());
-}
-
-void ThrowNullPointerExceptionFromDexPC(Thread* self, Method* throw_method, uint32_t dex_pc) {
-  const DexFile::CodeItem* code = MethodHelper(throw_method).GetCodeItem();
-  CHECK_LT(dex_pc, code->insns_size_in_code_units_);
-  const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
-  DecodedInstruction dec_insn(instr);
-  switch (instr->Opcode()) {
-    case Instruction::INVOKE_DIRECT:
-    case Instruction::INVOKE_DIRECT_RANGE:
-      ThrowNullPointerExceptionForMethodAccess(self, throw_method, dec_insn.vB, kDirect);
-      break;
-    case Instruction::INVOKE_VIRTUAL:
-    case Instruction::INVOKE_VIRTUAL_RANGE:
-      ThrowNullPointerExceptionForMethodAccess(self, throw_method, dec_insn.vB, kVirtual);
-      break;
-    case Instruction::IGET:
-    case Instruction::IGET_WIDE:
-    case Instruction::IGET_OBJECT:
-    case Instruction::IGET_BOOLEAN:
-    case Instruction::IGET_BYTE:
-    case Instruction::IGET_CHAR:
-    case Instruction::IGET_SHORT: {
-      Field* field =
-          Runtime::Current()->GetClassLinker()->ResolveField(dec_insn.vC, throw_method, false);
-      ThrowNullPointerExceptionForFieldAccess(self, field, true /* read */);
-      break;
-    }
-    case Instruction::IPUT:
-    case Instruction::IPUT_WIDE:
-    case Instruction::IPUT_OBJECT:
-    case Instruction::IPUT_BOOLEAN:
-    case Instruction::IPUT_BYTE:
-    case Instruction::IPUT_CHAR:
-    case Instruction::IPUT_SHORT: {
-      Field* field =
-          Runtime::Current()->GetClassLinker()->ResolveField(dec_insn.vC, throw_method, false);
-      ThrowNullPointerExceptionForFieldAccess(self, field, false /* write */);
-      break;
-    }
-    case Instruction::AGET:
-    case Instruction::AGET_WIDE:
-    case Instruction::AGET_OBJECT:
-    case Instruction::AGET_BOOLEAN:
-    case Instruction::AGET_BYTE:
-    case Instruction::AGET_CHAR:
-    case Instruction::AGET_SHORT:
-      self->ThrowNewException("Ljava/lang/NullPointerException;",
-                              "Attempt to read from null array");
-      break;
-    case Instruction::APUT:
-    case Instruction::APUT_WIDE:
-    case Instruction::APUT_OBJECT:
-    case Instruction::APUT_BOOLEAN:
-    case Instruction::APUT_BYTE:
-    case Instruction::APUT_CHAR:
-    case Instruction::APUT_SHORT:
-      self->ThrowNewException("Ljava/lang/NullPointerException;",
-                              "Attempt to write to null array");
-      break;
-    case Instruction::ARRAY_LENGTH:
-      self->ThrowNewException("Ljava/lang/NullPointerException;",
-                              "Attempt to get length of null array");
-      break;
-    default: {
-      const DexFile& dex_file = Runtime::Current()->GetClassLinker()
-          ->FindDexFile(throw_method->GetDeclaringClass()->GetDexCache());
-      std::string message("Null pointer exception during instruction '");
-      message += instr->DumpString(&dex_file);
-      message += "'";
-      self->ThrowNewException("Ljava/lang/NullPointerException;", message.c_str());
-      break;
-    }
-  }
-}
-
-std::string FieldNameFromIndex(const Method* method, uint32_t ref,
-                               verifier::VerifyErrorRefType ref_type, bool access) {
-  CHECK_EQ(static_cast<int>(ref_type), static_cast<int>(verifier::VERIFY_ERROR_REF_FIELD));
-
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  const DexFile& dex_file = class_linker->FindDexFile(method->GetDeclaringClass()->GetDexCache());
-
-  const DexFile::FieldId& id = dex_file.GetFieldId(ref);
-  std::string class_name(PrettyDescriptor(dex_file.GetFieldDeclaringClassDescriptor(id)));
-  const char* field_name = dex_file.StringDataByIdx(id.name_idx_);
-  if (!access) {
-    return class_name + "." + field_name;
-  }
-
-  std::string result;
-  result += "tried to access field ";
-  result += class_name + "." + field_name;
-  result += " from class ";
-  result += PrettyDescriptor(method->GetDeclaringClass());
-  return result;
-}
-
-std::string MethodNameFromIndex(const Method* method, uint32_t ref,
-                                verifier::VerifyErrorRefType ref_type, bool access) {
-  CHECK_EQ(static_cast<int>(ref_type), static_cast<int>(verifier::VERIFY_ERROR_REF_METHOD));
-
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  const DexFile& dex_file = class_linker->FindDexFile(method->GetDeclaringClass()->GetDexCache());
-
-  const DexFile::MethodId& id = dex_file.GetMethodId(ref);
-  std::string class_name(PrettyDescriptor(dex_file.GetMethodDeclaringClassDescriptor(id)));
-  const char* method_name = dex_file.StringDataByIdx(id.name_idx_);
-  if (!access) {
-    return class_name + "." + method_name;
-  }
-
-  std::string result;
-  result += "tried to access method ";
-  result += class_name + "." + method_name + ":" +
-      dex_file.CreateMethodSignature(id.proto_idx_, NULL);
-  result += " from class ";
-  result += PrettyDescriptor(method->GetDeclaringClass());
-  return result;
-}
-
 // Helper function to allocate array for FILLED_NEW_ARRAY.
 Array* CheckAndAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count,
                                   Thread* self, bool access_check) {
@@ -372,7 +119,7 @@
     if (access_check) {
       Class* referrer = method->GetDeclaringClass();
       if (UNLIKELY(!referrer->CanAccess(klass))) {
-        ThrowNewIllegalAccessErrorClass(self, referrer, klass);
+        ThrowIllegalAccessErrorClass(referrer, klass);
         return NULL;  // Failure
       }
     }
@@ -404,7 +151,7 @@
     return NULL;  // Failure.
   } else {
     if (resolved_field->IsStatic() != is_static) {
-      ThrowNewIncompatibleClassChangeErrorField(self, resolved_field, is_static);
+      ThrowIncompatibleClassChangeErrorField(resolved_field, is_static, referrer);
       return NULL;
     }
     Class* fields_class = resolved_field->GetDeclaringClass();
@@ -420,16 +167,16 @@
                                                dex_file.GetFieldId(field_idx).class_idx_,
                                                referring_class);
       if (UNLIKELY(!referring_class->CanAccess(fields_class))) {
-        ThrowNewIllegalAccessErrorClass(self, referring_class, fields_class);
+        ThrowIllegalAccessErrorClass(referring_class, fields_class);
         return NULL;  // failure
       } else if (UNLIKELY(!referring_class->CanAccessMember(fields_class,
                                                             resolved_field->GetAccessFlags()))) {
-        ThrowNewIllegalAccessErrorField(self, referring_class, resolved_field);
+        ThrowIllegalAccessErrorField(referring_class, resolved_field);
         return NULL;  // failure
       }
     }
     if (UNLIKELY(is_set && resolved_field->IsFinal() && (fields_class != referring_class))) {
-      ThrowNewIllegalAccessErrorFinalField(self, referrer, resolved_field);
+      ThrowIllegalAccessErrorFinalField(referrer, resolved_field);
       return NULL;  // failure
     } else {
       FieldHelper fh(resolved_field);
@@ -477,9 +224,8 @@
         Method* interface_method =
             this_object->GetClass()->FindVirtualMethodForInterface(resolved_method);
         if (UNLIKELY(interface_method == NULL)) {
-          ThrowNewIncompatibleClassChangeErrorClassForInterfaceDispatch(self,
-                                                                        resolved_method,
-                                                                        this_object);
+          ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(resolved_method, this_object,
+                                                                     referrer);
           return NULL;  // Failure.
         } else {
           return interface_method;
@@ -515,12 +261,12 @@
                                                   dex_file.GetMethodId(method_idx).class_idx_,
                                                   referring_class);
         if (UNLIKELY(!referring_class->CanAccess(methods_class))) {
-          ThrowNewIllegalAccessErrorClassForMethodDispatch(self, referring_class, methods_class,
-                                                           referrer, resolved_method, type);
+          ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class,
+                                                        referrer, resolved_method, type);
           return NULL;  // Failure.
         } else if (UNLIKELY(!referring_class->CanAccessMember(methods_class,
                                                               resolved_method->GetAccessFlags()))) {
-          ThrowNewIllegalAccessErrorMethod(self, referring_class, resolved_method);
+          ThrowIllegalAccessErrorMethod(referring_class, resolved_method);
           return NULL;  // Failure.
         }
       }
@@ -530,9 +276,8 @@
         Method* interface_method =
             this_object->GetClass()->FindVirtualMethodForInterface(resolved_method);
         if (UNLIKELY(interface_method == NULL)) {
-          ThrowNewIncompatibleClassChangeErrorClassForInterfaceDispatch(self,
-                                                                        resolved_method,
-                                                                        this_object);
+          ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(resolved_method, this_object,
+                                                                     referrer);
           return NULL;  // Failure.
         } else {
           return interface_method;
@@ -576,7 +321,7 @@
   // Perform access check if necessary.
   Class* referring_class = referrer->GetDeclaringClass();
   if (verify_access && UNLIKELY(!referring_class->CanAccess(klass))) {
-    ThrowNewIllegalAccessErrorClass(self, referring_class, klass);
+    ThrowIllegalAccessErrorClass(referring_class, klass);
     return NULL;  // Failure - Indicate to caller to deliver exception
   }
   // If we're just implementing const-class, we shouldn't call <clinit>.
diff --git a/src/runtime_support.h b/src/runtime_support.h
index 2956ea7..8f6b655 100644
--- a/src/runtime_support.h
+++ b/src/runtime_support.h
@@ -18,6 +18,7 @@
 #define ART_SRC_RUNTIME_SUPPORT_H_
 
 #include "class_linker.h"
+#include "common_throws.h"
 #include "dex_file.h"
 #include "invoke_type.h"
 #include "object.h"
@@ -43,47 +44,6 @@
 class Method;
 class Object;
 
-// Helpers to give consistent descriptive exception messages
-void ThrowNewIllegalAccessErrorClass(Thread* self, Class* referrer, Class* accessed)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-void ThrowNewIllegalAccessErrorClassForMethodDispatch(Thread* self, Class* referrer,
-                                                      Class* accessed,
-                                                      const Method* caller,
-                                                      const Method* called,
-                                                      InvokeType type)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-void ThrowNewIncompatibleClassChangeErrorClassForInterfaceDispatch(Thread* self,
-                                                                   const Method* referrer,
-                                                                   const Method* interface_method,
-                                                                   Object* this_object)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-void ThrowIncompatibleClassChangeError(InvokeType expected_type, InvokeType found_type,
-                                       Method* method, const Method* referrer)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-void ThrowNoSuchMethodError(InvokeType type, Class* c, const StringPiece& name,
-                            const StringPiece& signature, const Method* referrer)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-void ThrowNewIllegalAccessErrorField(Thread* self, Class* referrer, Field* accessed)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-void ThrowNewIllegalAccessErrorFinalField(Thread* self, const Method* referrer, Field* accessed)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-void ThrowNewIllegalAccessErrorMethod(Thread* self, Class* referrer, Method* accessed)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-void ThrowNullPointerExceptionForFieldAccess(Thread* self, Field* field, bool is_read)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-void ThrowNullPointerExceptionForMethodAccess(Thread* self, Method* caller, uint32_t method_idx,
-                                              InvokeType type)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-void ThrowNullPointerExceptionFromDexPC(Thread* self, Method* caller, uint32_t dex_pc)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-
-std::string FieldNameFromIndex(const Method* method, uint32_t ref,
-                               verifier::VerifyErrorRefType ref_type, bool access)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-std::string MethodNameFromIndex(const Method* method, uint32_t ref,
-                                verifier::VerifyErrorRefType ref_type, bool access)
-    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
-
 // Given the context of a calling Method, use its DexCache to resolve a type to a Class. If it
 // cannot be resolved, throw an error. If it can, use it to create an instance.
 // When verification/compiler hasn't been able to verify access, optionally perform an access
@@ -108,7 +68,7 @@
     }
     Class* referrer = method->GetDeclaringClass();
     if (UNLIKELY(!referrer->CanAccess(klass))) {
-      ThrowNewIllegalAccessErrorClass(self, referrer, klass);
+      ThrowIllegalAccessErrorClass(referrer, klass);
       return NULL;  // Failure
     }
   }
@@ -124,7 +84,7 @@
 // When verification/compiler hasn't been able to verify access, optionally perform an access
 // check.
 static inline Array* AllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count,
-                                        Thread* self, bool access_check)
+                                        bool access_check)
     SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (UNLIKELY(component_count < 0)) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d",
@@ -143,7 +103,7 @@
   if (access_check) {
     Class* referrer = method->GetDeclaringClass();
     if (UNLIKELY(!referrer->CanAccess(klass))) {
-      ThrowNewIllegalAccessErrorClass(self, referrer, klass);
+      ThrowIllegalAccessErrorClass(referrer, klass);
       return NULL;  // Failure
     }
   }