diff --git a/src/dex2oat.cc b/src/dex2oat.cc
index 1261bb9..61d445e 100644
--- a/src/dex2oat.cc
+++ b/src/dex2oat.cc
@@ -14,6 +14,7 @@
 #include "compiler.h"
 #include "file.h"
 #include "image_writer.h"
+#include "leb128.h"
 #include "oat_writer.h"
 #include "object_utils.h"
 #include "os.h"
@@ -119,7 +120,7 @@
       return NULL;
     }
 
-    // Load all the classes specifed in the file
+    // Load all the classes specified in the file
     ClassLinker* class_linker = runtime_->GetClassLinker();
     while (image_classes_file->good()) {
       std::string dot;
@@ -136,11 +137,40 @@
     }
     image_classes_file->close();
 
+    // Resolve exception classes referenced by the loaded classes. The catch logic assumes
+    // exceptions are resolved by the verifier when there is a catch block in an interested method.
+    // Do this here so that exception classes appear to have been specified image classes.
+    std::set<std::pair<uint16_t, const DexFile*> > unresolved_exception_types;
+    do {
+      unresolved_exception_types.clear();
+      class_linker->VisitClasses(ResolveCatchBlockExceptionsClassVisitor,
+                                 &unresolved_exception_types);
+      typedef std::set<std::pair<uint16_t, const DexFile*> >::const_iterator It;  // TODO: C++0x auto
+      for (It it = unresolved_exception_types.begin(),
+           end = unresolved_exception_types.end();
+           it != end; ++it) {
+        uint16_t exception_type_idx = it->first;
+        const DexFile* dex_file = it->second;
+        DexCache* dex_cache = class_linker->FindDexCache(*dex_file);
+        ClassLoader* class_loader = NULL;
+        SirtRef<Class> klass(class_linker->ResolveType(*dex_file, exception_type_idx, dex_cache,
+                                                       class_loader));
+        if (klass.get() == NULL) {
+          const DexFile::TypeId& type_id = dex_file->GetTypeId(exception_type_idx);
+          const char* descriptor = dex_file->GetTypeDescriptor(type_id);
+          LOG(FATAL) << "Failed to resolve class " << descriptor;
+        }
+        DCHECK(klass->IsThrowableClass());
+      }
+      // Resolving exceptions may load classes that reference more exceptions, iterate until no
+      // more are found
+    } while (!unresolved_exception_types.empty());
+
     // We walk the roots looking for classes so that we'll pick up the
     // above classes plus any classes them depend on such super
     // classes, interfaces, and the required ClassLinker roots.
     UniquePtr<std::set<std::string> > image_classes(new std::set<std::string>());
-    class_linker->VisitClasses(ClassVisitor, image_classes.get());
+    class_linker->VisitClasses(RecordImageClassesVisitor, image_classes.get());
     CHECK_NE(image_classes->size(), 0U);
     return image_classes.release();
   }
@@ -238,7 +268,59 @@
     return runtime;
   }
 
-  static bool ClassVisitor(Class* klass, void* arg) {
+  static void ResolveExceptionsForMethod(MethodHelper* mh,
+                           std::set<std::pair<uint16_t, const DexFile*> >& exceptions_to_resolve) {
+    const DexFile::CodeItem* code_item = mh->GetCodeItem();
+    if (code_item == NULL) {
+      return;  // native or abstract method
+    }
+    if (code_item->tries_size_ == 0) {
+      return;  // nothing to process
+    }
+    const byte* encoded_catch_handler_list = DexFile::GetCatchHandlerData(*code_item, 0);
+    size_t num_encoded_catch_handlers = DecodeUnsignedLeb128(&encoded_catch_handler_list);
+    for (size_t i = 0; i < num_encoded_catch_handlers; i++) {
+      int32_t encoded_catch_handler_size = DecodeSignedLeb128(&encoded_catch_handler_list);
+      bool has_catch_all = false;
+      if (encoded_catch_handler_size <= 0) {
+        encoded_catch_handler_size = -encoded_catch_handler_size;
+        has_catch_all = true;
+      }
+      for (int32_t j = 0; j < encoded_catch_handler_size; j++) {
+        uint16_t encoded_catch_handler_handlers_type_idx =
+            DecodeUnsignedLeb128(&encoded_catch_handler_list);
+        // Add to set of types to resolve if not already in the dex cache resolved types
+        if (!mh->IsResolvedTypeIdx(encoded_catch_handler_handlers_type_idx)) {
+          exceptions_to_resolve.insert(
+              std::pair<uint16_t, const DexFile*>(encoded_catch_handler_handlers_type_idx,
+                                                  &mh->GetDexFile()));
+        }
+        // ignore address associated with catch handler
+        DecodeUnsignedLeb128(&encoded_catch_handler_list);
+      }
+      if (has_catch_all) {
+        // ignore catch all address
+        DecodeUnsignedLeb128(&encoded_catch_handler_list);
+      }
+    }
+  }
+  static bool ResolveCatchBlockExceptionsClassVisitor(Class* c, void* arg) {
+    std::set<std::pair<uint16_t, const DexFile*> >* exceptions_to_resolve =
+        reinterpret_cast<std::set<std::pair<uint16_t, const DexFile*> >*>(arg);
+    MethodHelper mh;
+    for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
+      Method* m = c->GetVirtualMethod(i);
+      mh.ChangeMethod(m);
+      ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
+    }
+    for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
+      Method* m = c->GetDirectMethod(i);
+      mh.ChangeMethod(m);
+      ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
+    }
+    return true;
+  }
+  static bool RecordImageClassesVisitor(Class* klass, void* arg) {
     std::set<std::string>* image_classes = reinterpret_cast<std::set<std::string>*>(arg);
     if (klass->IsArrayClass() || klass->IsPrimitive()) {
       return true;
diff --git a/src/object.cc b/src/object.cc
index 8d48250..c08e122 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -815,6 +815,11 @@
   return this == String::GetJavaLangString();
 }
 
+bool Class::IsThrowableClass() const {
+  Class* throwable = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/Throwable;");
+  return throwable->IsAssignableFrom(this);
+}
+
 ClassLoader* Class::GetClassLoader() const {
   return GetFieldObject<ClassLoader*>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), false);
 }
diff --git a/src/object.h b/src/object.h
index 1a58364..ddba9db 100644
--- a/src/object.h
+++ b/src/object.h
@@ -1246,6 +1246,8 @@
 
   bool IsStringClass() const;
 
+  bool IsThrowableClass() const;
+
   Class* GetComponentType() const {
     return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, component_type_), false);
   }
diff --git a/src/object_utils.h b/src/object_utils.h
index dc48aa0..f323190 100644
--- a/src/object_utils.h
+++ b/src/object_utils.h
@@ -438,6 +438,9 @@
   const DexFile::CodeItem* GetCodeItem() {
     return GetDexFile().GetCodeItem(method_->GetCodeItemOffset());
   }
+  bool IsResolvedTypeIdx(uint16_t type_idx) const {
+    return method_->GetDexCacheResolvedTypes()->Get(type_idx) != NULL;
+  }
   Class* GetClassFromTypeIdx(uint16_t type_idx) {
     Class* type = method_->GetDexCacheResolvedTypes()->Get(type_idx);
     if (type == NULL) {