diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index 7d5a447..ce08b1b 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -243,9 +243,7 @@
   EXPECT_EQ(1U, inner->NumDirectMethods());
 }
 
-TEST_F(ClassLinkerTest, FindClass) {
-  ClassLinker* linker = class_linker_;
-
+TEST_F(ClassLinkerTest, FindClass_Primitives) {
   StringPiece expected = "BCDFIJSZV";
   for (int ch = 0; ch < 255; ch++) {
     char* s = reinterpret_cast<char*>(&ch);
@@ -256,8 +254,10 @@
       AssertPrimitiveClass(descriptor);
     }
   }
+}
 
-  Class* JavaLangObject = linker->FindSystemClass("Ljava/lang/Object;");
+TEST_F(ClassLinkerTest, FindClass) {
+  Class* JavaLangObject = class_linker_->FindSystemClass("Ljava/lang/Object;");
   ASSERT_TRUE(JavaLangObject != NULL);
   ASSERT_TRUE(JavaLangObject->GetClass() != NULL);
   ASSERT_EQ(JavaLangObject->GetClass(), JavaLangObject->GetClass()->GetClass());
@@ -283,11 +283,10 @@
   EXPECT_EQ(0U, JavaLangObject->NumStaticFields());
   EXPECT_EQ(0U, JavaLangObject->NumInterfaces());
 
-
   scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassDex, "kMyClassDex"));
   PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
   AssertNonExistentClass("LMyClass;");
-  Class* MyClass = linker->FindClass("LMyClass;", class_loader);
+  Class* MyClass = class_linker_->FindClass("LMyClass;", class_loader);
   ASSERT_TRUE(MyClass != NULL);
   ASSERT_TRUE(MyClass->GetClass() != NULL);
   ASSERT_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass());
@@ -343,6 +342,14 @@
   EXPECT_TRUE(string->GetInstanceField(2)->GetName()->Equals("offset"));
   EXPECT_TRUE(string->GetInstanceField(3)->GetName()->Equals("count"));
 
+  Class* throwable = class_linker_->FindSystemClass( "Ljava/lang/Throwable;");
+  ASSERT_EQ(5U, throwable->NumInstanceFields());
+  EXPECT_TRUE(throwable->GetInstanceField(0)->GetName()->Equals("cause"));
+  EXPECT_TRUE(throwable->GetInstanceField(1)->GetName()->Equals("detailMessage"));
+  EXPECT_TRUE(throwable->GetInstanceField(2)->GetName()->Equals("stackState"));
+  EXPECT_TRUE(throwable->GetInstanceField(3)->GetName()->Equals("stackTrace"));
+  EXPECT_TRUE(throwable->GetInstanceField(4)->GetName()->Equals("suppressedExceptions"));
+
   Class* accessible_object = class_linker_->FindSystemClass("Ljava/lang/reflect/AccessibleObject;");
   ASSERT_EQ(1U, accessible_object->NumInstanceFields());
   EXPECT_TRUE(accessible_object->GetInstanceField(0)->GetName()->Equals("flag"));
diff --git a/src/jni_compiler_test.cc b/src/jni_compiler_test.cc
index f315d1f..29e8942 100644
--- a/src/jni_compiler_test.cc
+++ b/src/jni_compiler_test.cc
@@ -367,7 +367,7 @@
   EXPECT_EQ(1, gJava_MyClass_foo_calls);
   EXPECT_EQ(0, gExceptionHandler_calls);
   // TODO: create a real exception here
-  Thread::Current()->SetException(reinterpret_cast<Object*>(jobj_));
+  Thread::Current()->SetException(reinterpret_cast<Throwable*>(jobj_));
   env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
   EXPECT_EQ(2, gJava_MyClass_foo_calls);
   EXPECT_EQ(1, gExceptionHandler_calls);
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 9aa23bb..0d46f29 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -218,9 +218,9 @@
   if (ts.Env()->check_jni) {
     size_t entry_count = locals.Capacity();
     if (entry_count > 16) {
-      std::string class_name(PrettyDescriptor(obj->GetClass()->GetDescriptor()));
+      std::string class_descriptor(PrettyDescriptor(obj->GetClass()->GetDescriptor()));
       LOG(WARNING) << "Warning: more than 16 JNI local references: "
-                   << entry_count << " (most recent was a " << class_name << ")";
+                   << entry_count << " (most recent was a " << class_descriptor << ")";
       locals.Dump();
       // TODO: dvmDumpThread(dvmThreadSelf(), false);
       // dvmAbort();
@@ -514,10 +514,10 @@
 
   if (field == NULL) {
     Thread* self = Thread::Current();
-    std::string class_name(c->GetDescriptor()->ToModifiedUtf8());
+    std::string class_descriptor(c->GetDescriptor()->ToModifiedUtf8());
     self->ThrowNewException("Ljava/lang/NoSuchFieldError;",
         "no \"%s\" field \"%s\" in class \"%s\" or its superclasses", sig,
-        name, class_name.c_str());
+        name, class_descriptor.c_str());
     return NULL;
   }
 
@@ -616,7 +616,7 @@
 
   static jint Throw(JNIEnv* env, jthrowable java_exception) {
     ScopedJniThreadState ts(env);
-    Object* exception = Decode<Object*>(ts, java_exception);
+    Throwable* exception = Decode<Throwable*>(ts, java_exception);
     if (exception == NULL) {
       return JNI_ERR;
     }
@@ -624,10 +624,32 @@
     return JNI_OK;
   }
 
-  static jint ThrowNew(JNIEnv* env, jclass java_class, const char* msg) {
+  static jint ThrowNew(JNIEnv* env, jclass c, const char* msg) {
     ScopedJniThreadState ts(env);
-    Class* c = Decode<Class*>(ts, java_class);
-    ts.Self()->ThrowNewException(c, msg);
+    // TODO: check for a pending exception to decide what constructor to call.
+    jmethodID mid = env->GetMethodID(c, "<init>", "(Ljava/lang/String;)V");
+    if (mid == NULL) {
+      return JNI_ERR;
+    }
+    jstring s = env->NewStringUTF(msg);
+    if (s == NULL) {
+      return JNI_ERR;
+    }
+
+    jvalue args[1];
+    args[0].l = s;
+    jthrowable exception = reinterpret_cast<jthrowable>(env->NewObjectA(c, mid, args));
+    if (exception == NULL) {
+      return JNI_ERR;
+    }
+
+    LOG(INFO) << "Throwing " << PrettyType(Decode<Throwable*>(ts, exception))
+              << ": " << msg;
+    ts.Self()->SetException(Decode<Throwable*>(ts, exception));
+
+    env->DeleteLocalRef(exception);
+    env->DeleteLocalRef(s);
+
     return JNI_OK;
   }
 
@@ -1994,17 +2016,17 @@
       }
       if (method == NULL) {
         Thread* self = Thread::Current();
-        std::string class_name = klass->GetDescriptor()->ToModifiedUtf8();
+        std::string class_descriptor(klass->GetDescriptor()->ToModifiedUtf8());
         self->ThrowNewException("Ljava/lang/NoSuchMethodError;",
             "no method \"%s.%s%s\"",
-            class_name.c_str(), name, sig);
+            class_descriptor.c_str(), name, sig);
         return JNI_ERR;
       } else if (!method->IsNative()) {
         Thread* self = Thread::Current();
-        std::string class_name = klass->GetDescriptor()->ToModifiedUtf8();
+        std::string class_descriptor(klass->GetDescriptor()->ToModifiedUtf8());
         self->ThrowNewException("Ljava/lang/NoSuchMethodError;",
             "method \"%s.%s%s\" is not native",
-            class_name.c_str(), name, sig);
+            class_descriptor.c_str(), name, sig);
         return JNI_ERR;
       }
       method->RegisterNative(methods[i].fnPtr);
diff --git a/src/jni_internal_test.cc b/src/jni_internal_test.cc
index f205169..ee4f2b1 100644
--- a/src/jni_internal_test.cc
+++ b/src/jni_internal_test.cc
@@ -260,12 +260,12 @@
   EXPECT_FALSE(env_->ExceptionCheck());
 }
 
-#define EXPECT_PRIMITIVE_ARRAY(fn, size, expected_class_name) \
+#define EXPECT_PRIMITIVE_ARRAY(fn, size, expected_class_descriptor) \
   do { \
     jarray a = env_->fn(size); \
     EXPECT_TRUE(a != NULL); \
     EXPECT_TRUE(env_->IsInstanceOf(a, \
-        env_->FindClass(expected_class_name))); \
+        env_->FindClass(expected_class_descriptor))); \
     EXPECT_EQ(size, env_->GetArrayLength(a)); \
   } while (false)
 
diff --git a/src/main.cc b/src/main.cc
index b4eb151..0330d0d 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -77,7 +77,7 @@
   // Find [class].main(String[]).
 
   // Convert "com.android.Blah" to "com/android/Blah".
-  std::string class_name = argv[0];
+  std::string class_name(argv[0]);
   std::replace(class_name.begin(), class_name.end(), '.', '/');
 
   ScopedLocalRef<jclass> klass(env, env->FindClass(class_name.c_str()));
diff --git a/src/object.h b/src/object.h
index 5a8f5be..0b1c072 100644
--- a/src/object.h
+++ b/src/object.h
@@ -1715,6 +1715,18 @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(String);
 };
 
+class Throwable : public Object {
+ private:
+  // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
+  Throwable* cause_;
+  String* detail_message_;
+  Object* stack_state_; // Note this is Java volatile:
+  Object* stack_trace_;
+  Object* suppressed_exceptions_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(Throwable);
+};
+
 inline bool Object::IsString() const {
   // TODO use "klass_ == String::GetJavaLangString()" instead?
   return klass_ == klass_->descriptor_->klass_;
diff --git a/src/thread.cc b/src/thread.cc
index db4c59f..30012b9 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -174,38 +174,24 @@
   return false;
 }
 
-void Thread::ThrowNewException(Class* exception_class, const char* msg) {
-  Object* exception = exception_class->NewInstance();
-  CHECK(exception != NULL);
-
-  String* java_msg = String::AllocFromModifiedUtf8(msg);
-  CHECK(java_msg != NULL);
-
-  // TODO: what if there's already a pending exception?
-  // TODO: support the other constructors.
-  Method* ctor = exception_class->FindDirectMethod("<init>", "(Ljava/lang/String;)V");
-  CHECK(ctor != NULL);
-
-  // TODO: need to *call* the constructor!
-  UNIMPLEMENTED(WARNING) << "can't call "
-                         << exception_class->GetDescriptor()->ToModifiedUtf8() << ".<init> "
-                         << "\"" << msg << "\"";
-
-  SetException(exception);
-}
-
-void Thread::ThrowNewException(const char* exception_class_name, const char* fmt, ...) {
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  Class* exception_class = class_linker->FindSystemClass(exception_class_name);
-  CHECK(exception_class != NULL);
-
+void Thread::ThrowNewException(const char* exception_class_descriptor, const char* fmt, ...) {
   std::string msg;
   va_list args;
   va_start(args, fmt);
   StringAppendV(&msg, fmt, args);
   va_end(args);
 
-  ThrowNewException(exception_class, msg.c_str());
+  // Convert "Ljava/lang/Exception;" into JNI-style "java/lang/Exception".
+  CHECK(exception_class_descriptor[0] == 'L');
+  std::string descriptor(exception_class_descriptor + 1);
+  CHECK(descriptor[descriptor.length() - 1] == ';');
+  descriptor.erase(descriptor.length() - 1);
+
+  JNIEnv* env = GetJniEnv();
+  jclass exception_class = env->FindClass(descriptor.c_str());
+  CHECK(exception_class != NULL) << "descriptor=\"" << descriptor << "\"";
+  int rc = env->ThrowNew(exception_class, msg.c_str());
+  CHECK_EQ(rc, JNI_OK);
 }
 
 Frame Thread::FindExceptionHandler(void* throw_pc, void** handler_pc) {
@@ -243,7 +229,7 @@
                                            void* throw_pc,
                                            const DexFile& dex_file,
                                            ClassLinker* class_linker) {
-  Object* exception_obj = exception_;
+  Throwable* exception_obj = exception_;
   exception_ = NULL;
 
   intptr_t dex_pc = -1;
diff --git a/src/thread.h b/src/thread.h
index b6fad0f..979a3e3 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -25,6 +25,7 @@
 class StackHandleBlock;
 class Thread;
 class ThreadList;
+class Throwable;
 
 class Mutex {
  public:
@@ -230,12 +231,10 @@
     return exception_ != NULL;
   }
 
-  // TODO: Throwable*
-  Object* GetException() const {
+  Throwable* GetException() const {
     return exception_;
   }
 
-  // TODO: Throwable*
   Frame GetTopOfStack() const {
     return top_of_managed_stack_;
   }
@@ -246,15 +245,13 @@
     top_of_managed_stack_.SetSP(reinterpret_cast<const Method**>(stack));
   }
 
-  void SetException(Object* new_exception) {
+  void SetException(Throwable* new_exception) {
     CHECK(new_exception != NULL);
     // TODO: CHECK(exception_ == NULL);
     exception_ = new_exception;  // TODO
   }
 
-  void ThrowNewException(Class* c, const char* msg);
-
-  void ThrowNewException(const char* exception_class_name, const char* fmt, ...)
+  void ThrowNewException(const char* exception_class_descriptor, const char* fmt, ...)
       __attribute__ ((format(printf, 3, 4)));
 
   void ClearException() {
@@ -434,8 +431,7 @@
   Runtime* runtime_;
 
   // The pending exception or NULL.
-  // TODO: Throwable*
-  Object* exception_;
+  Throwable* exception_;
 
   // A non-zero value is used to tell the current thread to enter a safe point
   // at the next poll.