diff --git a/vm/CheckJni.cpp b/vm/CheckJni.cpp
index 7f3e631..cd71a5c 100644
--- a/vm/CheckJni.cpp
+++ b/vm/CheckJni.cpp
@@ -199,22 +199,6 @@
     return ((JavaVMExt*) vm)->baseFuncTable;
 }
 
-/*
- * Prints trace messages when a native method calls a JNI function such as
- * NewByteArray. Enabled if both "-Xcheck:jni" and "-verbose:jni" are enabled.
- */
-static inline void jniTrace(bool hasMethod, const char* functionName) {
-    static const char* classDescriptor = "???";
-    static const char* methodName = "???";
-    if (hasMethod) {
-        const Method* method = dvmGetCurrentJNIMethod();
-        classDescriptor = method->clazz->descriptor;
-        methodName = method->name;
-    }
-    /* use +6 to drop the leading "Check_" */
-    LOGI("JNI: %s (from %s.%s)", functionName + 6, classDescriptor, methodName);
-}
-
 class ScopedJniThreadState {
 public:
     explicit ScopedJniThreadState(JNIEnv* env) {
@@ -231,25 +215,6 @@
     void operator=(const ScopedJniThreadState&);
 };
 
-class ScopedVmCheck {
-public:
-    /*
-     * Set "hasMethod" to true if we have a valid thread with a method pointer.
-     * We won't have one before attaching a thread, after detaching a thread, or
-     * after destroying the VM.
-     */
-    ScopedVmCheck(bool hasMethod, const char* functionName) {
-        if (gDvm.verboseJni) {
-            jniTrace(hasMethod, functionName);
-        }
-    }
-
-private:
-    // Disallow copy and assignment.
-    ScopedVmCheck(const ScopedVmCheck&);
-    void operator=(const ScopedVmCheck&);
-};
-
 /*
  * Flags passed into ScopedCheck.
  */
@@ -264,6 +229,11 @@
 #define kFlag_ExcepBad      0x0000      /* raised exceptions are bad */
 #define kFlag_ExcepOkay     0x0004      /* ...okay */
 
+#define kFlag_Release       0x0010      /* are we in a non-critical release function? */
+#define kFlag_NullableUtf   0x0020      /* are our UTF parameters nullable? */
+
+#define kFlag_Invocation    0x8000      /* Part of the invocation interface (JavaVM*) */
+
 static const char* indirectRefKindName(IndirectRef iref)
 {
     return indirectRefKindToString(indirectRefKind(iref));
@@ -271,47 +241,15 @@
 
 class ScopedCheck {
 public:
-    explicit ScopedCheck(JNIEnv* env, int flags, const char* functionName)
-    : mEnv(env), mFunctionName(functionName)
-    {
-        if (gDvm.verboseJni) {
-            jniTrace(true, mFunctionName);
-        }
+    // For JNIEnv* functions.
+    explicit ScopedCheck(JNIEnv* env, int flags, const char* functionName) {
+        init(env, flags, functionName, true);
         checkThread(flags);
     }
 
-    /*
-     * Verify that "array" is non-NULL and points to an Array object.
-     *
-     * Since we're dealing with objects, switch to "running" mode.
-     */
-    void checkArray(jarray jarr) {
-        if (jarr == NULL) {
-            LOGW("JNI WARNING: received null array");
-            showLocation();
-            abortMaybe();
-            return;
-        }
-
-        ScopedJniThreadState ts(mEnv);
-        bool printWarn = false;
-
-        Object* obj = dvmDecodeIndirectRef(mEnv, jarr);
-
-        if (!dvmIsValidObject(obj)) {
-            LOGW("JNI WARNING: jarray is an invalid %s reference (%p)",
-                    indirectRefKindName(jarr), jarr);
-            printWarn = true;
-        } else if (obj->clazz->descriptor[0] != '[') {
-            LOGW("JNI WARNING: jarray arg has wrong type (expected array, got %s)",
-                    obj->clazz->descriptor);
-            printWarn = true;
-        }
-
-        if (printWarn) {
-            showLocation();
-            abortMaybe();
-        }
+    // For JavaVM* functions.
+    explicit ScopedCheck(bool hasMethod, const char* functionName) {
+        init(NULL, kFlag_Invocation, functionName, hasMethod);
     }
 
     /*
@@ -324,7 +262,7 @@
      * This is incorrect and could cause strange behavior or compatibility
      * problems, so we want to screen that out here.
      *
-     * We expect "full-qualified" class names, like "java/lang/Thread" or
+     * We expect "fully-qualified" class names, like "java/lang/Thread" or
      * "[Ljava/lang/Object;".
      */
     void checkClassName(const char* className) {
@@ -430,16 +368,6 @@
     }
 
     /*
-     * Verify that the length argument to array-creation calls is >= 0.
-     */
-    void checkLengthPositive(jsize length) {
-        if (length < 0) {
-            LOGW("JNI WARNING: negative length for array allocation (%s)", mFunctionName);
-            abortMaybe();
-        }
-    }
-
-    /*
      * Verify that the pointer value is non-NULL.
      */
     void checkNonNull(const void* ptr) {
@@ -450,53 +378,6 @@
     }
 
     /*
-     * Verify that "jobj" is a valid object, and that it's an object that JNI
-     * is allowed to know about.  We allow NULL references.
-     *
-     * Switches to "running" mode before performing checks.
-     */
-    void checkObject(jobject jobj) {
-        if (jobj == NULL) {
-            return;
-        }
-
-        ScopedJniThreadState ts(mEnv);
-
-        bool printWarn = false;
-        if (dvmGetJNIRefType(mEnv, jobj) == JNIInvalidRefType) {
-            LOGW("JNI WARNING: %p is not a valid JNI reference", jobj);
-            printWarn = true;
-        } else {
-            Object* obj = dvmDecodeIndirectRef(mEnv, jobj);
-
-            /*
-             * The decoded object will be NULL if this is a weak global ref
-             * with a cleared referent.
-             */
-            if (obj == kInvalidIndirectRefObject || (obj != NULL && !dvmIsValidObject(obj))) {
-                LOGW("JNI WARNING: native code passing in bad object %p %p", jobj, obj);
-                printWarn = true;
-            }
-        }
-
-        if (printWarn) {
-            showLocation();
-            abortMaybe();
-        }
-    }
-
-    /*
-     * Verify that the "mode" argument passed to a primitive array Release
-     * function is one of the valid values.
-     */
-    void checkReleaseMode(jint mode) {
-        if (mode != 0 && mode != JNI_COMMIT && mode != JNI_ABORT) {
-            LOGW("JNI WARNING: bad value for mode (%d) (%s)", mode, mFunctionName);
-            abortMaybe();
-        }
-    }
-
-    /*
      * Verify that the method's return type matches the type of call.
      *
      * "expectedSigByte" will be 'L' for all objects, including arrays.
@@ -568,39 +449,6 @@
         }
     }
 
-    void checkString(jstring s) {
-        checkInstance(s, gDvm.classJavaLangString, "jstring");
-    }
-
-    void checkClass(jclass c) {
-        checkInstance(c, gDvm.classJavaLangClass, "jclass");
-    }
-
-    /*
-     * Verify that "bytes" points to valid "modified UTF-8" data.
-     * If "identifier" is NULL, "bytes" is allowed to be NULL; otherwise,
-     * "identifier" is the name to use when reporting the null pointer.
-     */
-    void checkUtfString(const char* bytes, const char* identifier) {
-        if (bytes == NULL) {
-            if (identifier != NULL) {
-                LOGW("JNI WARNING: %s == NULL", identifier);
-                showLocation();
-                abortMaybe();
-            }
-            return;
-        }
-
-        const char* errorKind = NULL;
-        u1 utf8 = checkUtfBytes(bytes, &errorKind);
-        if (errorKind != NULL) {
-            LOGW("JNI WARNING: input is not valid UTF-8: illegal %s byte %#x", errorKind, utf8);
-            LOGW("             string: '%s'", bytes);
-            showLocation();
-            abortMaybe();
-        }
-    }
-
     /*
      * Verify that "methodID" is appropriate for "jobj".
      *
@@ -622,9 +470,296 @@
         }
     }
 
+    /**
+     * The format string is a sequence of the following characters,
+     * and must be followed by arguments of the corresponding types
+     * in the same order.
+     *
+     * TODO: BCDFIJSZ are reserved for the Java primitive types.
+     * a - jarray
+     * b - jboolean
+     * c - jclass
+     * f - jfieldID
+     * i - jint
+     * m - jmethodID
+     * o - jobject
+     * p - void*
+     * r - jint (for release mode arguments)
+     * s - jstring
+     * u - const char* (modified UTF-8)
+     * z - jsize (for lengths; use i if negative values are okay)
+     * V - JavaVM*
+     * E - JNIEnv*
+     * . - no argument; just print "..." (used for varargs JNI calls)
+     *
+     * Use the kFlag_NullableUtf flag where 'u' field(s) are nullable.
+     */
+    void trace(const char* fmt0, ...) {
+        va_list ap;
+
+        // If both "-Xcheck:jni" and "-Xjnitrace:" are enabled, we print trace messages
+        // when a native method that matches the Xjnitrace argument calls a JNI function
+        // such as NewByteArray.
+        bool shouldTrace = false;
+        const Method* method = NULL;
+        if (gDvm.jniTrace && mHasMethod) {
+            // We need to guard some of the invocation interface's calls: a bad caller might
+            // use DetachCurrentThread or GetEnv on a thread that's not yet attached.
+            if ((mFlags & kFlag_Invocation) == 0 || dvmThreadSelf() != NULL) {
+                method = dvmGetCurrentJNIMethod();
+                if (strstr(method->clazz->descriptor, gDvm.jniTrace) != NULL) {
+                    shouldTrace = true;
+                }
+            }
+        }
+
+        if (shouldTrace) {
+            va_start(ap, fmt0);
+            std::string msg(mFunctionName);
+            msg += '(';
+            for (const char* fmt = fmt0; *fmt;) {
+                char ch = *fmt++;
+                if (ch == 'V') {
+                    JavaVM* vm = va_arg(ap, JavaVM*);
+                    StringAppendF(&msg, "(JavaVM*)%p", vm);
+                } else if (ch == 'E') {
+                    JNIEnv* env = va_arg(ap, JNIEnv*);
+                    StringAppendF(&msg, "(JNIEnv*)%p", env);
+                } else if (ch == 'a' || ch == 'o' || ch == 's') {
+                    // For logging purposes, jarray, jobject, and jstring are identical.
+                    jobject o = va_arg(ap, jobject);
+                    if (o == NULL) {
+                        msg += "NULL";
+                    } else {
+                        StringAppendF(&msg, "%p", o);
+                    }
+                } else if (ch == 'b') {
+                    jboolean b = va_arg(ap, int);
+                    msg += (b ? "JNI_TRUE" : "JNI_FALSE");
+                } else if (ch == 'c') {
+                    jclass jc = va_arg(ap, jclass);
+                    Object* c = dvmDecodeIndirectRef(mEnv, jc);
+                    if (c == NULL) {
+                        msg += "NULL";
+                    } else if (c == kInvalidIndirectRefObject || !dvmIsValidObject(c)) {
+                        StringAppendF(&msg, "%p(INVALID)", jc);
+                    } else {
+                        std::string className(dvmHumanReadableType(c));
+                        StringAppendF(&msg, "%s", className.c_str());
+                    }
+                } else if (ch == 'f') {
+                    jfieldID fid = va_arg(ap, jfieldID);
+                    std::string name(dvmHumanReadableField((Field*) fid));
+                    StringAppendF(&msg, "%s", name.c_str());
+                } else if (ch == 'i' || ch == 'z') {
+                    // You might expect jsize to be size_t, but it's not; it's the same as jint.
+                    jint i = va_arg(ap, jint);
+                    StringAppendF(&msg, "%d", i);
+                } else if (ch == 'l') {
+                    jlong l = va_arg(ap, jlong);
+                    StringAppendF(&msg, "%lld", l);
+                } else if (ch == 'm') {
+                    jmethodID mid = va_arg(ap, jmethodID);
+                    std::string name(dvmHumanReadableMethod((Method*) mid, true));
+                    StringAppendF(&msg, "%s", name.c_str());
+                } else if (ch == 'p') {
+                    void* p = va_arg(ap, void*);
+                    if (p == NULL) {
+                        msg += "NULL";
+                    } else {
+                        StringAppendF(&msg, "(void*) %p", p);
+                    }
+                } else if (ch == 'r') {
+                    jint releaseMode = va_arg(ap, jint);
+                    if (releaseMode == 0) {
+                        msg += "0";
+                    } else if (releaseMode == JNI_ABORT) {
+                        msg += "JNI_ABORT";
+                    } else if (releaseMode == JNI_COMMIT) {
+                        msg += "JNI_COMMIT";
+                    } else {
+                        StringAppendF(&msg, "invalid release mode %d", releaseMode);
+                    }
+                } else if (ch == 'u') {
+                    const char* utf = va_arg(ap, const char*);
+                    if (utf == NULL) {
+                        msg += "NULL";
+                    } else {
+                        StringAppendF(&msg, "\"%s\"", utf);
+                    }
+                } else if (ch == '.') {
+                    msg += "...";
+                } else {
+                    LOGE("unknown trace format specifier %c", ch);
+                    dvmAbort();
+                }
+                if (*fmt) {
+                    StringAppendF(&msg, ", ");
+                }
+            }
+            msg += ')';
+            va_end(ap);
+            output(method, msg.c_str());
+        }
+
+        // We always do the thorough checks...
+        va_start(ap, fmt0);
+        for (const char* fmt = fmt0; *fmt; ++fmt) {
+            // TODO: BCDFIJSZ are reserved for the Java primitive types.
+            char ch = *fmt;
+            if (ch == 'a') {
+                checkArray(va_arg(ap, jarray));
+            } else if (ch == 'c') {
+                checkClass(va_arg(ap, jclass));
+            } else if (ch == 'o') {
+                checkObject(va_arg(ap, jobject));
+            } else if (ch == 'r') {
+                checkReleaseMode(va_arg(ap, jint));
+            } else if (ch == 's') {
+                checkString(va_arg(ap, jstring));
+            } else if (ch == 'u') {
+                if ((mFlags & kFlag_Release) != 0) {
+                    checkNonNull(va_arg(ap, const char*));
+                } else {
+                    bool nullable = ((mFlags & kFlag_NullableUtf) != 0);
+                    checkUtfString(va_arg(ap, const char*), nullable);
+                }
+            } else if (ch == 'z') {
+                checkLengthPositive(va_arg(ap, jsize));
+            } else if (ch == 'V' || ch == 'E' || ch == 'b' || ch == 'f' || ch == 'i' || ch == 'm' || ch == 'p') {
+                va_arg(ap, void*); // Skip this argument.
+            } else if (ch == '.') {
+            } else {
+                LOGE("unknown check format specifier %c", ch);
+                dvmAbort();
+            }
+        }
+        va_end(ap);
+    }
+
 private:
     JNIEnv* mEnv;
     const char* mFunctionName;
+    int mFlags;
+    bool mHasMethod;
+
+    void init(JNIEnv* env, int flags, const char* functionName, bool hasMethod) {
+        mEnv = env;
+        mFlags = flags;
+
+        // Use +6 to drop the leading "Check_"...
+        mFunctionName = functionName + 6;
+
+        // Set "hasMethod" to true if we have a valid thread with a method pointer.
+        // We won't have one before attaching a thread, after detaching a thread, or
+        // after destroying the VM.
+        mHasMethod = hasMethod;
+    }
+
+    void output(const Method* method, const char* msg) {
+        if (mHasMethod) {
+            std::string methodName(dvmHumanReadableMethod(method, false));
+            LOGI("JNI: %s called %s", methodName.c_str(), msg);
+        } else {
+            LOGI("JNI: call to %s", msg);
+        }
+    }
+
+    /*
+     * Verify that "array" is non-NULL and points to an Array object.
+     *
+     * Since we're dealing with objects, switch to "running" mode.
+     */
+    void checkArray(jarray jarr) {
+        if (jarr == NULL) {
+            LOGW("JNI WARNING: received null array");
+            showLocation();
+            abortMaybe();
+            return;
+        }
+
+        ScopedJniThreadState ts(mEnv);
+        bool printWarn = false;
+
+        Object* obj = dvmDecodeIndirectRef(mEnv, jarr);
+
+        if (!dvmIsValidObject(obj)) {
+            LOGW("JNI WARNING: jarray is an invalid %s reference (%p)",
+            indirectRefKindName(jarr), jarr);
+            printWarn = true;
+        } else if (obj->clazz->descriptor[0] != '[') {
+            LOGW("JNI WARNING: jarray arg has wrong type (expected array, got %s)",
+            obj->clazz->descriptor);
+            printWarn = true;
+        }
+
+        if (printWarn) {
+            showLocation();
+            abortMaybe();
+        }
+    }
+
+    void checkClass(jclass c) {
+        checkInstance(c, gDvm.classJavaLangClass, "jclass");
+    }
+
+    void checkLengthPositive(jsize length) {
+        if (length < 0) {
+            LOGW("JNI WARNING: negative jsize (%s)", mFunctionName);
+            abortMaybe();
+        }
+    }
+
+    /*
+     * Verify that "jobj" is a valid object, and that it's an object that JNI
+     * is allowed to know about.  We allow NULL references.
+     *
+     * Switches to "running" mode before performing checks.
+     */
+    void checkObject(jobject jobj) {
+        if (jobj == NULL) {
+            return;
+        }
+
+        ScopedJniThreadState ts(mEnv);
+
+        bool printWarn = false;
+        if (dvmGetJNIRefType(mEnv, jobj) == JNIInvalidRefType) {
+            LOGW("JNI WARNING: %p is not a valid JNI reference", jobj);
+            printWarn = true;
+        } else {
+            Object* obj = dvmDecodeIndirectRef(mEnv, jobj);
+
+            /*
+             * The decoded object will be NULL if this is a weak global ref
+             * with a cleared referent.
+             */
+            if (obj == kInvalidIndirectRefObject || (obj != NULL && !dvmIsValidObject(obj))) {
+                LOGW("JNI WARNING: native code passing in bad object %p %p", jobj, obj);
+                printWarn = true;
+            }
+        }
+
+        if (printWarn) {
+            showLocation();
+            abortMaybe();
+        }
+    }
+
+    /*
+     * Verify that the "mode" argument passed to a primitive array Release
+     * function is one of the valid values.
+     */
+    void checkReleaseMode(jint mode) {
+        if (mode != 0 && mode != JNI_COMMIT && mode != JNI_ABORT) {
+            LOGW("JNI WARNING: bad value for mode (%d) (%s)", mode, mFunctionName);
+            abortMaybe();
+        }
+    }
+
+    void checkString(jstring s) {
+        checkInstance(s, gDvm.classJavaLangString, "jstring");
+    }
 
     void checkThread(int flags) {
         // Get the *correct* JNIEnv by going through our TLS pointer.
@@ -712,6 +847,29 @@
     }
 
     /*
+     * Verify that "bytes" points to valid "modified UTF-8" data.
+     */
+    void checkUtfString(const char* bytes, bool nullable) {
+        if (bytes == NULL) {
+            if (!nullable) {
+                LOGW("JNI WARNING: non-nullable const char* was NULL");
+                showLocation();
+                abortMaybe();
+            }
+            return;
+        }
+
+        const char* errorKind = NULL;
+        u1 utf8 = checkUtfBytes(bytes, &errorKind);
+        if (errorKind != NULL) {
+            LOGW("JNI WARNING: input is not valid UTF-8: illegal %s byte %#x", errorKind, utf8);
+            LOGW("             string: '%s'", bytes);
+            showLocation();
+            abortMaybe();
+        }
+    }
+
+    /*
      * Verify that "jobj" is a valid non-NULL object reference, and points to
      * an instance of expectedClass.
      *
@@ -816,11 +974,9 @@
     }
 
     void showLocation() {
-        // mFunctionName looks like "Check_DeleteLocalRef"; we drop the "Check_".
-        const char* name = mFunctionName + 6;
         const Method* method = dvmGetCurrentJNIMethod();
         char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
-        LOGW("             in %s.%s:%s (%s)", method->clazz->descriptor, method->name, desc, name);
+        LOGW("             in %s.%s:%s (%s)", method->clazz->descriptor, method->name, desc, mFunctionName);
         free(desc);
     }
 
@@ -1089,6 +1245,7 @@
 
 static jint Check_GetVersion(JNIEnv* env) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
+    sc.trace("E", env);
     return baseEnv(env)->GetVersion(env);
 }
 
@@ -1096,41 +1253,41 @@
     const jbyte* buf, jsize bufLen)
 {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(loader);
-    sc.checkUtfString(name, "name");
+    sc.trace("Euopz", env, name, loader, buf, bufLen);
     sc.checkClassName(name);
     return baseEnv(env)->DefineClass(env, name, loader, buf, bufLen);
 }
 
 static jclass Check_FindClass(JNIEnv* env, const char* name) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkUtfString(name, "name");
+    sc.trace("Eu", env, name);
     sc.checkClassName(name);
     return baseEnv(env)->FindClass(env, name);
 }
 
 static jclass Check_GetSuperclass(JNIEnv* env, jclass clazz) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz);
+    sc.trace("Ec", env, clazz);
     return baseEnv(env)->GetSuperclass(env, clazz);
 }
 
 static jboolean Check_IsAssignableFrom(JNIEnv* env, jclass clazz1, jclass clazz2) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz1);
-    sc.checkClass(clazz2);
+    sc.trace("Ecc", env, clazz1, clazz2);
     return baseEnv(env)->IsAssignableFrom(env, clazz1, clazz2);
 }
 
 static jmethodID Check_FromReflectedMethod(JNIEnv* env, jobject method) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(method);
+    sc.trace("Eo", env, method);
+    // TODO: check that 'field' is a java.lang.reflect.Method.
     return baseEnv(env)->FromReflectedMethod(env, method);
 }
 
 static jfieldID Check_FromReflectedField(JNIEnv* env, jobject field) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(field);
+    sc.trace("Eo", env, field);
+    // TODO: check that 'field' is a java.lang.reflect.Field.
     return baseEnv(env)->FromReflectedField(env, field);
 }
 
@@ -1138,7 +1295,7 @@
         jmethodID methodID, jboolean isStatic)
 {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(cls);
+    sc.trace("Ecmb", env, cls, methodID, isStatic);
     return baseEnv(env)->ToReflectedMethod(env, cls, methodID, isStatic);
 }
 
@@ -1146,65 +1303,68 @@
         jfieldID fieldID, jboolean isStatic)
 {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(cls);
+    sc.trace("Ecfb", env, cls, fieldID, isStatic);
     return baseEnv(env)->ToReflectedField(env, cls, fieldID, isStatic);
 }
 
 static jint Check_Throw(JNIEnv* env, jthrowable obj) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(obj);
+    sc.trace("Eo", env, obj);
     /* TODO: verify that "obj" is an instance of Throwable */
     return baseEnv(env)->Throw(env, obj);
 }
 
 static jint Check_ThrowNew(JNIEnv* env, jclass clazz, const char* message) {
-    ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz);
-    sc.checkUtfString(message, NULL);
+    ScopedCheck sc(env, kFlag_NullableUtf, __FUNCTION__);
+    sc.trace("Ecu", env, clazz, message);
     return baseEnv(env)->ThrowNew(env, clazz, message);
 }
 
 static jthrowable Check_ExceptionOccurred(JNIEnv* env) {
     ScopedCheck sc(env, kFlag_ExcepOkay, __FUNCTION__);
+    sc.trace("E", env);
     return baseEnv(env)->ExceptionOccurred(env);
 }
 
 static void Check_ExceptionDescribe(JNIEnv* env) {
     ScopedCheck sc(env, kFlag_ExcepOkay, __FUNCTION__);
+    sc.trace("E", env);
     baseEnv(env)->ExceptionDescribe(env);
 }
 
 static void Check_ExceptionClear(JNIEnv* env) {
     ScopedCheck sc(env, kFlag_ExcepOkay, __FUNCTION__);
+    sc.trace("E", env);
     baseEnv(env)->ExceptionClear(env);
 }
 
 static void Check_FatalError(JNIEnv* env, const char* msg) {
-    ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkUtfString(msg, NULL);
+    ScopedCheck sc(env, kFlag_NullableUtf, __FUNCTION__);
+    sc.trace("Eu", env, msg);
     baseEnv(env)->FatalError(env, msg);
 }
 
 static jint Check_PushLocalFrame(JNIEnv* env, jint capacity) {
     ScopedCheck sc(env, kFlag_Default | kFlag_ExcepOkay, __FUNCTION__);
+    sc.trace("Ei", env, capacity);
     return baseEnv(env)->PushLocalFrame(env, capacity);
 }
 
 static jobject Check_PopLocalFrame(JNIEnv* env, jobject res) {
     ScopedCheck sc(env, kFlag_Default | kFlag_ExcepOkay, __FUNCTION__);
-    sc.checkObject(res);
+    sc.trace("Eo", env, res);
     return baseEnv(env)->PopLocalFrame(env, res);
 }
 
 static jobject Check_NewGlobalRef(JNIEnv* env, jobject obj) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(obj);
+    sc.trace("Eo", env, obj);
     return baseEnv(env)->NewGlobalRef(env, obj);
 }
 
 static void Check_DeleteGlobalRef(JNIEnv* env, jobject globalRef) {
     ScopedCheck sc(env, kFlag_Default | kFlag_ExcepOkay, __FUNCTION__);
-    sc.checkObject(globalRef);
+    sc.trace("Eo", env, globalRef);
     if (globalRef != NULL && dvmGetJNIRefType(env, globalRef) != JNIGlobalRefType) {
         LOGW("JNI WARNING: DeleteGlobalRef on non-global %p (type=%d)",
             globalRef, dvmGetJNIRefType(env, globalRef));
@@ -1216,13 +1376,13 @@
 
 static jobject Check_NewLocalRef(JNIEnv* env, jobject ref) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(ref);
+    sc.trace("Eo", env, ref);
     return baseEnv(env)->NewLocalRef(env, ref);
 }
 
 static void Check_DeleteLocalRef(JNIEnv* env, jobject localRef) {
     ScopedCheck sc(env, kFlag_Default | kFlag_ExcepOkay, __FUNCTION__);
-    sc.checkObject(localRef);
+    sc.trace("Eo", env, localRef);
     if (localRef != NULL && dvmGetJNIRefType(env, localRef) != JNILocalRefType) {
         LOGW("JNI WARNING: DeleteLocalRef on non-local %p (type=%d)",
             localRef, dvmGetJNIRefType(env, localRef));
@@ -1234,25 +1394,25 @@
 
 static jint Check_EnsureLocalCapacity(JNIEnv *env, jint capacity) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
+    sc.trace("Ei", env, capacity);
     return baseEnv(env)->EnsureLocalCapacity(env, capacity);
 }
 
 static jboolean Check_IsSameObject(JNIEnv* env, jobject ref1, jobject ref2) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(ref1);
-    sc.checkObject(ref2);
+    sc.trace("Eoo", env, ref1, ref2);
     return baseEnv(env)->IsSameObject(env, ref1, ref2);
 }
 
 static jobject Check_AllocObject(JNIEnv* env, jclass clazz) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz);
+    sc.trace("Ec", env, clazz);
     return baseEnv(env)->AllocObject(env, clazz);
 }
 
 static jobject Check_NewObject(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz);
+    sc.trace("Ecm.", env, clazz, methodID);
     va_list args;
 
     va_start(args, methodID);
@@ -1264,42 +1424,40 @@
 
 static jobject Check_NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz);
+    sc.trace("Ecm.", env, clazz, methodID);
     return baseEnv(env)->NewObjectV(env, clazz, methodID, args);
 }
 
 static jobject Check_NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue* args) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz);
+    sc.trace("Ecm.", env, clazz, methodID);
     return baseEnv(env)->NewObjectA(env, clazz, methodID, args);
 }
 
 static jclass Check_GetObjectClass(JNIEnv* env, jobject obj) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(obj);
-    return baseEnv(env)->GetObjectClass(env, obj);
+    sc.trace("Eo", env, obj);
+    jclass result = baseEnv(env)->GetObjectClass(env, obj);
+    std::string className(dvmHumanReadableType((Object*) dvmDecodeIndirectRef(env, result)));
+    LOGI("Check_GetObjectClass returning %s", className.c_str());
+    return result;
 }
 
 static jboolean Check_IsInstanceOf(JNIEnv* env, jobject obj, jclass clazz) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(obj);
-    sc.checkClass(clazz);
+    sc.trace("Eoc", env, obj, clazz);
     return baseEnv(env)->IsInstanceOf(env, obj, clazz);
 }
 
 static jmethodID Check_GetMethodID(JNIEnv* env, jclass clazz, const char* name, const char* sig) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz);
-    sc.checkUtfString(name, "name");
-    sc.checkUtfString(sig, "sig");
+    sc.trace("Ecuu", env, clazz, name, sig);
     return baseEnv(env)->GetMethodID(env, clazz, name, sig);
 }
 
 static jfieldID Check_GetFieldID(JNIEnv* env, jclass clazz, const char* name, const char* sig) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz);
-    sc.checkUtfString(name, "name");
-    sc.checkUtfString(sig, "sig");
+    sc.trace("Ecuu", env, clazz, name, sig);
     return baseEnv(env)->GetFieldID(env, clazz, name, sig);
 }
 
@@ -1307,9 +1465,7 @@
         const char* name, const char* sig)
 {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz);
-    sc.checkUtfString(name, "name");
-    sc.checkUtfString(sig, "sig");
+    sc.trace("Ecuu", env, clazz, name, sig);
     return baseEnv(env)->GetStaticMethodID(env, clazz, name, sig);
 }
 
@@ -1317,9 +1473,7 @@
         const char* name, const char* sig)
 {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz);
-    sc.checkUtfString(name, "name");
-    sc.checkUtfString(sig, "sig");
+    sc.trace("Ecuu", env, clazz, name, sig);
     return baseEnv(env)->GetStaticFieldID(env, clazz, name, sig);
 }
 
@@ -1327,7 +1481,7 @@
     static _ctype Check_GetStatic##_jname##Field(JNIEnv* env, jclass clazz, jfieldID fieldID) \
     { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkClass(clazz); \
+        sc.trace("Ecf", env, clazz, fieldID); \
         sc.checkStaticFieldID(clazz, fieldID); \
         return baseEnv(env)->GetStatic##_jname##Field(env, clazz, fieldID); \
     }
@@ -1345,7 +1499,7 @@
     static void Check_SetStatic##_jname##Field(JNIEnv* env, jclass clazz, \
         jfieldID fieldID, _ctype value) { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkClass(clazz); \
+        sc.trace("Ecf.", env, clazz, fieldID); /* TODO: value! */ \
         sc.checkStaticFieldID(clazz, fieldID); \
         /* "value" arg only used when type == ref */ \
         sc.checkFieldType((jobject)(u4)value, fieldID, _ftype, true); \
@@ -1361,12 +1515,12 @@
 SET_STATIC_TYPE_FIELD(jfloat, Float, PRIM_FLOAT);
 SET_STATIC_TYPE_FIELD(jdouble, Double, PRIM_DOUBLE);
 
-#define GET_TYPE_FIELD(_ctype, _jname)                                      \
+#define GET_TYPE_FIELD(_ctype, _jname) \
     static _ctype Check_Get##_jname##Field(JNIEnv* env, jobject obj, jfieldID fieldID) { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkObject(obj); \
+        sc.trace("Eof", env, obj, fieldID); \
         sc.checkInstanceFieldID(obj, fieldID); \
-        return baseEnv(env)->Get##_jname##Field(env, obj, fieldID);      \
+        return baseEnv(env)->Get##_jname##Field(env, obj, fieldID); \
     }
 GET_TYPE_FIELD(jobject, Object);
 GET_TYPE_FIELD(jboolean, Boolean);
@@ -1382,7 +1536,7 @@
     static void Check_Set##_jname##Field(JNIEnv* env, jobject obj, jfieldID fieldID, _ctype value) \
     { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkObject(obj); \
+        sc.trace("Eof.", env, obj, fieldID); /* TODO: value! */ \
         sc.checkInstanceFieldID(obj, fieldID); \
         /* "value" arg only used when type == ref */ \
         sc.checkFieldType((jobject)(u4) value, fieldID, _ftype, false); \
@@ -1398,45 +1552,42 @@
 SET_TYPE_FIELD(jfloat, Float, PRIM_FLOAT);
 SET_TYPE_FIELD(jdouble, Double, PRIM_DOUBLE);
 
-#define CALL_VIRTUAL(_ctype, _jname, _retdecl, _retasgn, _retok, _retsig)   \
-    static _ctype Check_Call##_jname##Method(JNIEnv* env, jobject obj,      \
-        jmethodID methodID, ...)                                            \
-    {                                                                       \
+#define CALL_VIRTUAL(_ctype, _jname, _retdecl, _retasgn, _retok, _retsig) \
+    static _ctype Check_Call##_jname##Method(JNIEnv* env, jobject obj, \
+        jmethodID methodID, ...) \
+    { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkObject(obj); \
+        sc.trace("Eom.", env, obj, methodID); /* TODO: args! */ \
         sc.checkSig(methodID, _retsig, false); \
         sc.checkVirtualMethod(obj, methodID); \
-        _retdecl;                                                           \
-        va_list args;                                                       \
-        va_start(args, methodID);                                           \
-        _retasgn baseEnv(env)->Call##_jname##MethodV(env, obj, methodID,   \
-            args);                                                          \
-        va_end(args);                                                       \
-        return _retok;                                                      \
-    }                                                                       \
-    static _ctype Check_Call##_jname##MethodV(JNIEnv* env, jobject obj,     \
-        jmethodID methodID, va_list args)                                   \
-    {                                                                       \
+        _retdecl; \
+        va_list args; \
+        va_start(args, methodID); \
+        _retasgn baseEnv(env)->Call##_jname##MethodV(env, obj, methodID, args); \
+        va_end(args); \
+        return _retok; \
+    } \
+    static _ctype Check_Call##_jname##MethodV(JNIEnv* env, jobject obj, \
+        jmethodID methodID, va_list args) \
+    { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkObject(obj); \
+        sc.trace("Eom.", env, obj, methodID); /* TODO: args! */ \
         sc.checkSig(methodID, _retsig, false); \
         sc.checkVirtualMethod(obj, methodID); \
-        _retdecl;                                                           \
-        _retasgn baseEnv(env)->Call##_jname##MethodV(env, obj, methodID,   \
-            args);                                                          \
-        return _retok;                                                      \
-    }                                                                       \
-    static _ctype Check_Call##_jname##MethodA(JNIEnv* env, jobject obj,     \
-        jmethodID methodID, jvalue* args)                                   \
-    {                                                                       \
+        _retdecl; \
+        _retasgn baseEnv(env)->Call##_jname##MethodV(env, obj, methodID, args); \
+        return _retok; \
+    } \
+    static _ctype Check_Call##_jname##MethodA(JNIEnv* env, jobject obj, \
+        jmethodID methodID, jvalue* args) \
+    { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkObject(obj); \
+        sc.trace("Eom.", env, obj, methodID); /* TODO: args! */ \
         sc.checkSig(methodID, _retsig, false); \
         sc.checkVirtualMethod(obj, methodID); \
-        _retdecl;                                                           \
-        _retasgn baseEnv(env)->Call##_jname##MethodA(env, obj, methodID,   \
-            args);                                                          \
-        return _retok;                                                      \
+        _retdecl; \
+        _retasgn baseEnv(env)->Call##_jname##MethodA(env, obj, methodID, args); \
+        return _retok; \
     }
 CALL_VIRTUAL(jobject, Object, Object* result, result=(Object*), (jobject) result, 'L');
 CALL_VIRTUAL(jboolean, Boolean, jboolean result, result=, (jboolean) result, 'Z');
@@ -1449,49 +1600,43 @@
 CALL_VIRTUAL(jdouble, Double, jdouble result, result=, (jdouble) result, 'D');
 CALL_VIRTUAL(void, Void, , , , 'V');
 
-#define CALL_NONVIRTUAL(_ctype, _jname, _retdecl, _retasgn, _retok,         \
-        _retsig)                                                            \
-    static _ctype Check_CallNonvirtual##_jname##Method(JNIEnv* env,         \
-        jobject obj, jclass clazz, jmethodID methodID, ...)                 \
-    {                                                                       \
+#define CALL_NONVIRTUAL(_ctype, _jname, _retdecl, _retasgn, _retok, \
+        _retsig) \
+    static _ctype Check_CallNonvirtual##_jname##Method(JNIEnv* env, \
+        jobject obj, jclass clazz, jmethodID methodID, ...) \
+    { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkClass(clazz); \
-        sc.checkObject(obj); \
+        sc.trace("Eocm.", env, obj, clazz, methodID); /* TODO: args! */ \
         sc.checkSig(methodID, _retsig, false); \
         sc.checkVirtualMethod(obj, methodID); \
-        _retdecl;                                                           \
-        va_list args;                                                       \
-        va_start(args, methodID);                                           \
-        _retasgn baseEnv(env)->CallNonvirtual##_jname##MethodV(env, obj,   \
-            clazz, methodID, args);                                         \
-        va_end(args);                                                       \
-        return _retok;                                                      \
-    }                                                                       \
-    static _ctype Check_CallNonvirtual##_jname##MethodV(JNIEnv* env,        \
-        jobject obj, jclass clazz, jmethodID methodID, va_list args)        \
-    {                                                                       \
+        _retdecl; \
+        va_list args; \
+        va_start(args, methodID); \
+        _retasgn baseEnv(env)->CallNonvirtual##_jname##MethodV(env, obj, clazz, methodID, args); \
+        va_end(args); \
+        return _retok; \
+    } \
+    static _ctype Check_CallNonvirtual##_jname##MethodV(JNIEnv* env, \
+        jobject obj, jclass clazz, jmethodID methodID, va_list args) \
+    { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkClass(clazz); \
-        sc.checkObject(obj); \
+        sc.trace("Eocm.", env, obj, clazz, methodID); /* TODO: args! */ \
         sc.checkSig(methodID, _retsig, false); \
         sc.checkVirtualMethod(obj, methodID); \
-        _retdecl;                                                           \
-        _retasgn baseEnv(env)->CallNonvirtual##_jname##MethodV(env, obj,   \
-            clazz, methodID, args);                                         \
-        return _retok;                                                      \
-    }                                                                       \
-    static _ctype Check_CallNonvirtual##_jname##MethodA(JNIEnv* env,        \
-        jobject obj, jclass clazz, jmethodID methodID, jvalue* args)        \
-    {                                                                       \
+        _retdecl; \
+        _retasgn baseEnv(env)->CallNonvirtual##_jname##MethodV(env, obj, clazz, methodID, args); \
+        return _retok; \
+    } \
+    static _ctype Check_CallNonvirtual##_jname##MethodA(JNIEnv* env, \
+        jobject obj, jclass clazz, jmethodID methodID, jvalue* args) \
+    { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkClass(clazz); \
-        sc.checkObject(obj); \
+        sc.trace("Eocm.", env, obj, clazz, methodID); /* TODO: args! */ \
         sc.checkSig(methodID, _retsig, false); \
         sc.checkVirtualMethod(obj, methodID); \
-        _retdecl;                                                           \
-        _retasgn baseEnv(env)->CallNonvirtual##_jname##MethodA(env, obj,   \
-            clazz, methodID, args);                                         \
-        return _retok;                                                      \
+        _retdecl; \
+        _retasgn baseEnv(env)->CallNonvirtual##_jname##MethodA(env, obj, clazz, methodID, args); \
+        return _retok; \
     }
 CALL_NONVIRTUAL(jobject, Object, Object* result, result=(Object*), (jobject) result, 'L');
 CALL_NONVIRTUAL(jboolean, Boolean, jboolean result, result=, (jboolean) result, 'Z');
@@ -1505,45 +1650,42 @@
 CALL_NONVIRTUAL(void, Void, , , , 'V');
 
 
-#define CALL_STATIC(_ctype, _jname, _retdecl, _retasgn, _retok, _retsig)    \
-    static _ctype Check_CallStatic##_jname##Method(JNIEnv* env,             \
-        jclass clazz, jmethodID methodID, ...)                              \
-    {                                                                       \
+#define CALL_STATIC(_ctype, _jname, _retdecl, _retasgn, _retok, _retsig) \
+    static _ctype Check_CallStatic##_jname##Method(JNIEnv* env, \
+        jclass clazz, jmethodID methodID, ...) \
+    { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkClass(clazz); \
+        sc.trace("Ecm.", env, clazz, methodID); /* TODO: args! */ \
         sc.checkSig(methodID, _retsig, true); \
         sc.checkStaticMethod(clazz, methodID); \
-        _retdecl;                                                           \
-        va_list args;                                                       \
-        va_start(args, methodID);                                           \
-        _retasgn baseEnv(env)->CallStatic##_jname##MethodV(env, clazz,     \
-            methodID, args);                                                \
-        va_end(args);                                                       \
-        return _retok;                                                      \
-    }                                                                       \
-    static _ctype Check_CallStatic##_jname##MethodV(JNIEnv* env,            \
-        jclass clazz, jmethodID methodID, va_list args)                     \
-    {                                                                       \
+        _retdecl; \
+        va_list args; \
+        va_start(args, methodID); \
+        _retasgn baseEnv(env)->CallStatic##_jname##MethodV(env, clazz, methodID, args); \
+        va_end(args); \
+        return _retok; \
+    } \
+    static _ctype Check_CallStatic##_jname##MethodV(JNIEnv* env, \
+        jclass clazz, jmethodID methodID, va_list args) \
+    { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkClass(clazz); \
+        sc.trace("Ecm.", env, clazz, methodID); /* TODO: args! */ \
         sc.checkSig(methodID, _retsig, true); \
         sc.checkStaticMethod(clazz, methodID); \
-        _retdecl;                                                           \
-        _retasgn baseEnv(env)->CallStatic##_jname##MethodV(env, clazz,     \
-            methodID, args);                                                \
-        return _retok;                                                      \
-    }                                                                       \
-    static _ctype Check_CallStatic##_jname##MethodA(JNIEnv* env,            \
-        jclass clazz, jmethodID methodID, jvalue* args)                     \
-    {                                                                       \
+        _retdecl; \
+        _retasgn baseEnv(env)->CallStatic##_jname##MethodV(env, clazz, methodID, args); \
+        return _retok; \
+    } \
+    static _ctype Check_CallStatic##_jname##MethodA(JNIEnv* env, \
+        jclass clazz, jmethodID methodID, jvalue* args) \
+    { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkClass(clazz); \
+        sc.trace("Ecm.", env, clazz, methodID); /* TODO: args! */ \
         sc.checkSig(methodID, _retsig, true); \
         sc.checkStaticMethod(clazz, methodID); \
-        _retdecl;                                                           \
-        _retasgn baseEnv(env)->CallStatic##_jname##MethodA(env, clazz,     \
-            methodID, args);                                                \
-        return _retok;                                                      \
+        _retdecl; \
+        _retasgn baseEnv(env)->CallStatic##_jname##MethodA(env, clazz, methodID, args); \
+        return _retok; \
     }
 CALL_STATIC(jobject, Object, Object* result, result=(Object*), (jobject) result, 'L');
 CALL_STATIC(jboolean, Boolean, jboolean result, result=, (jboolean) result, 'Z');
@@ -1558,18 +1700,19 @@
 
 static jstring Check_NewString(JNIEnv* env, const jchar* unicodeChars, jsize len) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
+    sc.trace("Epz", env, unicodeChars, len);
     return baseEnv(env)->NewString(env, unicodeChars, len);
 }
 
 static jsize Check_GetStringLength(JNIEnv* env, jstring string) {
     ScopedCheck sc(env, kFlag_CritOkay, __FUNCTION__);
-    sc.checkString(string);
+    sc.trace("Es", env, string);
     return baseEnv(env)->GetStringLength(env, string);
 }
 
 static const jchar* Check_GetStringChars(JNIEnv* env, jstring string, jboolean* isCopy) {
     ScopedCheck sc(env, kFlag_CritOkay, __FUNCTION__);
-    sc.checkString(string);
+    sc.trace("Esp", env, string, isCopy);
     const jchar* result = baseEnv(env)->GetStringChars(env, string, isCopy);
     if (gDvmJni.forceCopy && result != NULL) {
         ScopedJniThreadState ts(env);
@@ -1585,7 +1728,7 @@
 
 static void Check_ReleaseStringChars(JNIEnv* env, jstring string, const jchar* chars) {
     ScopedCheck sc(env, kFlag_Default | kFlag_ExcepOkay, __FUNCTION__);
-    sc.checkString(string);
+    sc.trace("Esp", env, string, chars);
     sc.checkNonNull(chars);
     if (gDvmJni.forceCopy) {
         if (!GuardedCopy::check(chars, false)) {
@@ -1599,20 +1742,20 @@
 }
 
 static jstring Check_NewStringUTF(JNIEnv* env, const char* bytes) {
-    ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkUtfString(bytes, NULL);
+    ScopedCheck sc(env, kFlag_NullableUtf, __FUNCTION__);
+    sc.trace("Eu", env, bytes); // TODO: show pointer and truncate string.
     return baseEnv(env)->NewStringUTF(env, bytes);
 }
 
 static jsize Check_GetStringUTFLength(JNIEnv* env, jstring string) {
     ScopedCheck sc(env, kFlag_CritOkay, __FUNCTION__);
-    sc.checkString(string);
+    sc.trace("Es", env, string);
     return baseEnv(env)->GetStringUTFLength(env, string);
 }
 
 static const char* Check_GetStringUTFChars(JNIEnv* env, jstring string, jboolean* isCopy) {
     ScopedCheck sc(env, kFlag_CritOkay, __FUNCTION__);
-    sc.checkString(string);
+    sc.trace("Esp", env, string, isCopy);
     const char* result = baseEnv(env)->GetStringUTFChars(env, string, isCopy);
     if (gDvmJni.forceCopy && result != NULL) {
         result = (const char*) GuardedCopy::create(result, strlen(result) + 1, false);
@@ -1624,9 +1767,8 @@
 }
 
 static void Check_ReleaseStringUTFChars(JNIEnv* env, jstring string, const char* utf) {
-    ScopedCheck sc(env, kFlag_ExcepOkay, __FUNCTION__);
-    sc.checkString(string);
-    sc.checkNonNull(utf);
+    ScopedCheck sc(env, kFlag_ExcepOkay | kFlag_Release, __FUNCTION__);
+    sc.trace("Esu", env, string, utf); // TODO: show pointer and truncate string.
     if (gDvmJni.forceCopy) {
         if (!GuardedCopy::check(utf, false)) {
             LOGE("JNI: failed guarded copy check in ReleaseStringUTFChars");
@@ -1640,7 +1782,7 @@
 
 static jsize Check_GetArrayLength(JNIEnv* env, jarray array) {
     ScopedCheck sc(env, kFlag_CritOkay, __FUNCTION__);
-    sc.checkArray(array);
+    sc.trace("Ea", env, array);
     return baseEnv(env)->GetArrayLength(env, array);
 }
 
@@ -1648,29 +1790,27 @@
     jclass elementClass, jobject initialElement)
 {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(elementClass);
-    sc.checkObject(initialElement);
-    sc.checkLengthPositive(length);
+    sc.trace("Ezco", env, length, elementClass, initialElement);
     return baseEnv(env)->NewObjectArray(env, length, elementClass, initialElement);
 }
 
 static jobject Check_GetObjectArrayElement(JNIEnv* env, jobjectArray array, jsize index) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkArray(array);
+    sc.trace("Eai", env, array, index);
     return baseEnv(env)->GetObjectArrayElement(env, array, index);
 }
 
 static void Check_SetObjectArrayElement(JNIEnv* env, jobjectArray array, jsize index, jobject value)
 {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkArray(array);
+    sc.trace("Eaio", env, array, index, value);
     baseEnv(env)->SetObjectArrayElement(env, array, index, value);
 }
 
 #define NEW_PRIMITIVE_ARRAY(_artype, _jname) \
     static _artype Check_New##_jname##Array(JNIEnv* env, jsize length) { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkLengthPositive(length); \
+        sc.trace("Ez", env, length); \
         return baseEnv(env)->New##_jname##Array(env, length); \
     }
 NEW_PRIMITIVE_ARRAY(jbooleanArray, Boolean);
@@ -1691,68 +1831,66 @@
  */
 #define kNoCopyMagic    0xd5aab57f
 
-#define GET_PRIMITIVE_ARRAY_ELEMENTS(_ctype, _jname)                        \
-    static _ctype* Check_Get##_jname##ArrayElements(JNIEnv* env,            \
-        _ctype##Array array, jboolean* isCopy)                              \
-    {                                                                       \
+#define GET_PRIMITIVE_ARRAY_ELEMENTS(_ctype, _jname) \
+    static _ctype* Check_Get##_jname##ArrayElements(JNIEnv* env, \
+        _ctype##Array array, jboolean* isCopy) \
+    { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkArray(array); \
-        u4 noCopy = 0;                                                      \
+        sc.trace("Eap", env, array, isCopy); \
+        u4 noCopy = 0; \
         if (gDvmJni.forceCopy && isCopy != NULL) { \
-            /* capture this before the base call tramples on it */          \
-            noCopy = *(u4*) isCopy;                                         \
-        }                                                                   \
+            /* capture this before the base call tramples on it */ \
+            noCopy = *(u4*) isCopy; \
+        } \
         _ctype* result = baseEnv(env)->Get##_jname##ArrayElements(env, array, isCopy); \
         if (gDvmJni.forceCopy && result != NULL) { \
-            if (noCopy == kNoCopyMagic) {                                   \
+            if (noCopy == kNoCopyMagic) { \
                 LOGV("FC: not copying %p %x", array, noCopy); \
-            } else {                                                        \
+            } else { \
                 result = (_ctype*) createGuardedPACopy(env, array, isCopy); \
-            }                                                               \
-        }                                                                   \
-        return result;                                                      \
+            } \
+        } \
+        return result; \
     }
 
-#define RELEASE_PRIMITIVE_ARRAY_ELEMENTS(_ctype, _jname)                    \
-    static void Check_Release##_jname##ArrayElements(JNIEnv* env,           \
-        _ctype##Array array, _ctype* elems, jint mode)                      \
-    {                                                                       \
+#define RELEASE_PRIMITIVE_ARRAY_ELEMENTS(_ctype, _jname) \
+    static void Check_Release##_jname##ArrayElements(JNIEnv* env, \
+        _ctype##Array array, _ctype* elems, jint mode) \
+    { \
         ScopedCheck sc(env, kFlag_Default | kFlag_ExcepOkay, __FUNCTION__); \
-        sc.checkArray(array);                                            \
+        sc.trace("Eapr", env, array, elems, mode); \
         sc.checkNonNull(elems); \
-        sc.checkReleaseMode(mode); \
         if (gDvmJni.forceCopy) { \
-            if ((uintptr_t)elems == kNoCopyMagic) {                         \
+            if ((uintptr_t)elems == kNoCopyMagic) { \
                 LOGV("FC: not freeing %p", array); \
-                elems = NULL;   /* base JNI call doesn't currently need */  \
-            } else {                                                        \
-                elems = (_ctype*) releaseGuardedPACopy(env, array, elems,   \
-                        mode);                                              \
-            }                                                               \
-        }                                                                   \
+                elems = NULL;   /* base JNI call doesn't currently need */ \
+            } else { \
+                elems = (_ctype*) releaseGuardedPACopy(env, array, elems, mode); \
+            } \
+        } \
         baseEnv(env)->Release##_jname##ArrayElements(env, array, elems, mode); \
     }
 
 #define GET_PRIMITIVE_ARRAY_REGION(_ctype, _jname) \
     static void Check_Get##_jname##ArrayRegion(JNIEnv* env, \
-        _ctype##Array array, jsize start, jsize len, _ctype* buf) { \
+            _ctype##Array array, jsize start, jsize len, _ctype* buf) { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkArray(array); \
+        sc.trace("Eaiip", env, array, start, len, buf); \
         baseEnv(env)->Get##_jname##ArrayRegion(env, array, start, len, buf); \
     }
 
 #define SET_PRIMITIVE_ARRAY_REGION(_ctype, _jname) \
     static void Check_Set##_jname##ArrayRegion(JNIEnv* env, \
-        _ctype##Array array, jsize start, jsize len, const _ctype* buf) { \
+            _ctype##Array array, jsize start, jsize len, const _ctype* buf) { \
         ScopedCheck sc(env, kFlag_Default, __FUNCTION__); \
-        sc.checkArray(array); \
+        sc.trace("Eaiip", env, array, start, len, buf); \
         baseEnv(env)->Set##_jname##ArrayRegion(env, array, start, len, buf); \
     }
 
-#define PRIMITIVE_ARRAY_FUNCTIONS(_ctype, _jname, _typechar)                \
-    GET_PRIMITIVE_ARRAY_ELEMENTS(_ctype, _jname);                           \
-    RELEASE_PRIMITIVE_ARRAY_ELEMENTS(_ctype, _jname);                       \
-    GET_PRIMITIVE_ARRAY_REGION(_ctype, _jname);                             \
+#define PRIMITIVE_ARRAY_FUNCTIONS(_ctype, _jname, _typechar) \
+    GET_PRIMITIVE_ARRAY_ELEMENTS(_ctype, _jname); \
+    RELEASE_PRIMITIVE_ARRAY_ELEMENTS(_ctype, _jname); \
+    GET_PRIMITIVE_ARRAY_REGION(_ctype, _jname); \
     SET_PRIMITIVE_ARRAY_REGION(_ctype, _jname);
 
 /* TODO: verify primitive array type matches call type */
@@ -1769,48 +1907,49 @@
         jint nMethods)
 {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz);
+    sc.trace("Ecpi", env, clazz, methods, nMethods);
     return baseEnv(env)->RegisterNatives(env, clazz, methods, nMethods);
 }
 
 static jint Check_UnregisterNatives(JNIEnv* env, jclass clazz) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkClass(clazz);
+    sc.trace("Ec", env, clazz);
     return baseEnv(env)->UnregisterNatives(env, clazz);
 }
 
 static jint Check_MonitorEnter(JNIEnv* env, jobject obj) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(obj);
+    sc.trace("Eo", env, obj);
     return baseEnv(env)->MonitorEnter(env, obj);
 }
 
 static jint Check_MonitorExit(JNIEnv* env, jobject obj) {
     ScopedCheck sc(env, kFlag_Default | kFlag_ExcepOkay, __FUNCTION__);
-    sc.checkObject(obj);
+    sc.trace("Eo", env, obj);
     return baseEnv(env)->MonitorExit(env, obj);
 }
 
 static jint Check_GetJavaVM(JNIEnv *env, JavaVM **vm) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
+    sc.trace("Ep", env, vm);
     return baseEnv(env)->GetJavaVM(env, vm);
 }
 
 static void Check_GetStringRegion(JNIEnv* env, jstring str, jsize start, jsize len, jchar* buf) {
     ScopedCheck sc(env, kFlag_CritOkay, __FUNCTION__);
-    sc.checkString(str);
+    sc.trace("Esiip", env, str, start, len, buf);
     baseEnv(env)->GetStringRegion(env, str, start, len, buf);
 }
 
 static void Check_GetStringUTFRegion(JNIEnv* env, jstring str, jsize start, jsize len, char* buf) {
     ScopedCheck sc(env, kFlag_CritOkay, __FUNCTION__);
-    sc.checkString(str);
+    sc.trace("Esiip", env, str, start, len, buf);
     baseEnv(env)->GetStringUTFRegion(env, str, start, len, buf);
 }
 
 static void* Check_GetPrimitiveArrayCritical(JNIEnv* env, jarray array, jboolean* isCopy) {
     ScopedCheck sc(env, kFlag_CritGet, __FUNCTION__);
-    sc.checkArray(array);
+    sc.trace("Eap", env, array, isCopy);
     void* result = baseEnv(env)->GetPrimitiveArrayCritical(env, array, isCopy);
     if (gDvmJni.forceCopy && result != NULL) {
         result = createGuardedPACopy(env, array, isCopy);
@@ -1821,9 +1960,8 @@
 static void Check_ReleasePrimitiveArrayCritical(JNIEnv* env, jarray array, void* carray, jint mode)
 {
     ScopedCheck sc(env, kFlag_CritRelease | kFlag_ExcepOkay, __FUNCTION__);
-    sc.checkArray(array);
+    sc.trace("Eapr", env, array, carray, mode);
     sc.checkNonNull(carray);
-    sc.checkReleaseMode(mode);
     if (gDvmJni.forceCopy) {
         carray = releaseGuardedPACopy(env, array, carray, mode);
     }
@@ -1832,7 +1970,7 @@
 
 static const jchar* Check_GetStringCritical(JNIEnv* env, jstring string, jboolean* isCopy) {
     ScopedCheck sc(env, kFlag_CritGet, __FUNCTION__);
-    sc.checkString(string);
+    sc.trace("Esp", env, string, isCopy);
     const jchar* result = baseEnv(env)->GetStringCritical(env, string, isCopy);
     if (gDvmJni.forceCopy && result != NULL) {
         ScopedJniThreadState ts(env);
@@ -1848,7 +1986,7 @@
 
 static void Check_ReleaseStringCritical(JNIEnv* env, jstring string, const jchar* carray) {
     ScopedCheck sc(env, kFlag_CritRelease | kFlag_ExcepOkay, __FUNCTION__);
-    sc.checkString(string);
+    sc.trace("Esp", env, string, carray);
     sc.checkNonNull(carray);
     if (gDvmJni.forceCopy) {
         if (!GuardedCopy::check(carray, false)) {
@@ -1863,29 +2001,31 @@
 
 static jweak Check_NewWeakGlobalRef(JNIEnv* env, jobject obj) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(obj);
+    sc.trace("Eo", env, obj);
     return baseEnv(env)->NewWeakGlobalRef(env, obj);
 }
 
 static void Check_DeleteWeakGlobalRef(JNIEnv* env, jweak obj) {
     ScopedCheck sc(env, kFlag_Default | kFlag_ExcepOkay, __FUNCTION__);
-    sc.checkObject(obj);
+    sc.trace("Eo", env, obj);
     baseEnv(env)->DeleteWeakGlobalRef(env, obj);
 }
 
 static jboolean Check_ExceptionCheck(JNIEnv* env) {
     ScopedCheck sc(env, kFlag_CritOkay | kFlag_ExcepOkay, __FUNCTION__);
+    sc.trace("E", env);
     return baseEnv(env)->ExceptionCheck(env);
 }
 
 static jobjectRefType Check_GetObjectRefType(JNIEnv* env, jobject obj) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(obj);
+    sc.trace("Eo", env, obj);
     return baseEnv(env)->GetObjectRefType(env, obj);
 }
 
 static jobject Check_NewDirectByteBuffer(JNIEnv* env, void* address, jlong capacity) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
+    sc.trace("Epl", env, address, capacity);
     if (address == NULL || capacity < 0) {
         LOGW("JNI WARNING: invalid values for address (%p) or capacity (%ld)",
             address, (long) capacity);
@@ -1897,14 +2037,15 @@
 
 static void* Check_GetDirectBufferAddress(JNIEnv* env, jobject buf) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(buf);
+    sc.trace("Eo", env, buf);
+    // TODO: check that 'buf' is a java.nio.Buffer.
     return baseEnv(env)->GetDirectBufferAddress(env, buf);
 }
 
 static jlong Check_GetDirectBufferCapacity(JNIEnv* env, jobject buf) {
     ScopedCheck sc(env, kFlag_Default, __FUNCTION__);
-    sc.checkObject(buf);
-    /* TODO: verify "buf" is an instance of java.nio.Buffer */
+    sc.trace("Eo", env, buf);
+    // TODO: check that 'buf' is a java.nio.Buffer.
     return baseEnv(env)->GetDirectBufferCapacity(env, buf);
 }
 
@@ -1916,27 +2057,32 @@
  */
 
 static jint Check_DestroyJavaVM(JavaVM* vm) {
-    ScopedVmCheck svc(false, __FUNCTION__);
+    ScopedCheck sc(false, __FUNCTION__);
+    sc.trace("V", vm);
     return baseVm(vm)->DestroyJavaVM(vm);
 }
 
 static jint Check_AttachCurrentThread(JavaVM* vm, JNIEnv** p_env, void* thr_args) {
-    ScopedVmCheck svc(false, __FUNCTION__);
+    ScopedCheck sc(false, __FUNCTION__);
+    sc.trace("Vpp", vm, p_env, thr_args);
     return baseVm(vm)->AttachCurrentThread(vm, p_env, thr_args);
 }
 
 static jint Check_AttachCurrentThreadAsDaemon(JavaVM* vm, JNIEnv** p_env, void* thr_args) {
-    ScopedVmCheck svc(false, __FUNCTION__);
+    ScopedCheck sc(false, __FUNCTION__);
+    sc.trace("Vpp", vm, p_env, thr_args);
     return baseVm(vm)->AttachCurrentThreadAsDaemon(vm, p_env, thr_args);
 }
 
 static jint Check_DetachCurrentThread(JavaVM* vm) {
-    ScopedVmCheck svc(true, __FUNCTION__);
+    ScopedCheck sc(true, __FUNCTION__);
+    sc.trace("V", vm);
     return baseVm(vm)->DetachCurrentThread(vm);
 }
 
 static jint Check_GetEnv(JavaVM* vm, void** env, jint version) {
-    ScopedVmCheck svc(true, __FUNCTION__);
+    ScopedCheck sc(true, __FUNCTION__);
+    sc.trace("V", vm);
     return baseVm(vm)->GetEnv(vm, env, version);
 }
 
diff --git a/vm/Init.cpp b/vm/Init.cpp
index c797f25..cb5eb68 100644
--- a/vm/Init.cpp
+++ b/vm/Init.cpp
@@ -1149,35 +1149,54 @@
     }
 }
 
+class ScopedShutdown {
+public:
+    ScopedShutdown() : armed_(true) {
+    }
+
+    ~ScopedShutdown() {
+        if (armed_) {
+            dvmShutdown();
+        }
+    }
+
+    void disarm() {
+        armed_ = false;
+    }
+
+private:
+    bool armed_;
+};
+
 /*
  * VM initialization.  Pass in any options provided on the command line.
  * Do not pass in the class name or the options for the class.
  *
  * Returns 0 on success.
  */
-int dvmStartup(int argc, const char* const argv[], bool ignoreUnrecognized,
-    JNIEnv* pEnv)
+std::string dvmStartup(int argc, const char* const argv[],
+        bool ignoreUnrecognized, JNIEnv* pEnv)
 {
-    int i, cc;
+    ScopedShutdown scopedShutdown;
 
     assert(gDvm.initializing);
 
     LOGV("VM init args (%d):", argc);
-    for (i = 0; i < argc; i++)
+    for (int i = 0; i < argc; i++) {
         LOGV("  %d: '%s'", i, argv[i]);
-
+    }
     setCommandLineDefaults();
 
     /*
      * Process the option flags (if any).
      */
-    cc = processOptions(argc, argv, ignoreUnrecognized);
+    int cc = processOptions(argc, argv, ignoreUnrecognized);
     if (cc != 0) {
         if (cc < 0) {
             dvmFprintf(stderr, "\n");
             usage("dalvikvm");
         }
-        goto fail;
+        return "syntax error";
     }
 
 #if WITH_EXTRA_GC_CHECKS > 1
@@ -1202,9 +1221,8 @@
 
     /* verify system page size */
     if (sysconf(_SC_PAGESIZE) != SYSTEM_PAGE_SIZE) {
-        LOGE("ERROR: expected page size %d, got %d",
-            SYSTEM_PAGE_SIZE, (int) sysconf(_SC_PAGESIZE));
-        goto fail;
+        return StringPrintf("expected page size %d, got %d",
+                SYSTEM_PAGE_SIZE, (int) sysconf(_SC_PAGESIZE));
     }
 
     /* mterp setup */
@@ -1214,20 +1232,27 @@
     /*
      * Initialize components.
      */
-    if (!dvmAllocTrackerStartup())
-        goto fail;
-    if (!dvmGcStartup())
-        goto fail;
-    if (!dvmThreadStartup())
-        goto fail;
-    if (!dvmInlineNativeStartup())
-        goto fail;
-    if (!dvmRegisterMapStartup())
-        goto fail;
-    if (!dvmInstanceofStartup())
-        goto fail;
-    if (!dvmClassStartup())
-        goto fail;
+    if (!dvmAllocTrackerStartup()) {
+        return "dvmAllocTrackerStartup failed";
+    }
+    if (!dvmGcStartup()) {
+        return "dvmGcStartup failed";
+    }
+    if (!dvmThreadStartup()) {
+        return "dvmThreadStartup failed";
+    }
+    if (!dvmInlineNativeStartup()) {
+        return "dvmInlineNativeStartup";
+    }
+    if (!dvmRegisterMapStartup()) {
+        return "dvmRegisterMapStartup failed";
+    }
+    if (!dvmInstanceofStartup()) {
+        return "dvmInstanceofStartup failed";
+    }
+    if (!dvmClassStartup()) {
+        return "dvmClassStartup failed";
+    }
 
     /*
      * At this point, the system is guaranteed to be sufficiently
@@ -1235,39 +1260,48 @@
      * call populates the gDvm instance with all the class and member
      * references that the VM wants to use directly.
      */
-    if (!dvmFindRequiredClassesAndMembers())
-        goto fail;
+    if (!dvmFindRequiredClassesAndMembers()) {
+        return "dvmFindRequiredClassesAndMembers failed";
+    }
 
-    if (!dvmStringInternStartup())
-        goto fail;
-    if (!dvmNativeStartup())
-        goto fail;
-    if (!dvmInternalNativeStartup())
-        goto fail;
-    if (!dvmJniStartup())
-        goto fail;
-    if (!dvmProfilingStartup())
-        goto fail;
+    if (!dvmStringInternStartup()) {
+        return "dvmStringInternStartup failed";
+    }
+    if (!dvmNativeStartup()) {
+        return "dvmNativeStartup failed";
+    }
+    if (!dvmInternalNativeStartup()) {
+        return "dvmInternalNativeStartup failed";
+    }
+    if (!dvmJniStartup()) {
+        return "dvmJniStartup failed";
+    }
+    if (!dvmProfilingStartup()) {
+        return "dvmProfilingStartup failed";
+    }
 
     /*
      * Create a table of methods for which we will substitute an "inline"
      * version for performance.
      */
-    if (!dvmCreateInlineSubsTable())
-        goto fail;
+    if (!dvmCreateInlineSubsTable()) {
+        return "dvmCreateInlineSubsTable failed";
+    }
 
     /*
      * Miscellaneous class library validation.
      */
-    if (!dvmValidateBoxClasses())
-        goto fail;
+    if (!dvmValidateBoxClasses()) {
+        return "dvmValidateBoxClasses failed";
+    }
 
     /*
      * Do the last bits of Thread struct initialization we need to allow
      * JNI calls to work.
      */
-    if (!dvmPrepMainForJni(pEnv))
-        goto fail;
+    if (!dvmPrepMainForJni(pEnv)) {
+        return "dvmPrepMainForJni failed";
+    }
 
     /*
      * Explicitly initialize java.lang.Class.  This doesn't happen
@@ -1276,21 +1310,24 @@
      * which make some calls that throw assertions if the classes they
      * operate on aren't initialized.
      */
-    if (!dvmInitClass(gDvm.classJavaLangClass))
-        goto fail;
+    if (!dvmInitClass(gDvm.classJavaLangClass)) {
+        return "couldn't initialized java.lang.Class";
+    }
 
     /*
      * Register the system native methods, which are registered through JNI.
      */
-    if (!registerSystemNatives(pEnv))
-        goto fail;
+    if (!registerSystemNatives(pEnv)) {
+        return "couldn't register system natives";
+    }
 
     /*
      * Do some "late" initialization for the memory allocator.  This may
      * allocate storage and initialize classes.
      */
-    if (!dvmCreateStockExceptions())
-        goto fail;
+    if (!dvmCreateStockExceptions()) {
+        return "dvmCreateStockExceptions failed";
+    }
 
     /*
      * At this point, the VM is in a pretty good state.  Finish prep on
@@ -1298,8 +1335,9 @@
      * along with our Thread struct).  Note we will probably be executing
      * some interpreted class initializer code in here.
      */
-    if (!dvmPrepMainThread())
-        goto fail;
+    if (!dvmPrepMainThread()) {
+        return "dvmPrepMainThread failed";
+    }
 
     /*
      * Make sure we haven't accumulated any tracked references.  The main
@@ -1312,22 +1350,26 @@
     }
 
     /* general debugging setup */
-    if (!dvmDebuggerStartup())
-        goto fail;
+    if (!dvmDebuggerStartup()) {
+        return "dvmDebuggerStartup failed";
+    }
 
-    if (!dvmGcStartupClasses())
-        goto fail;
+    if (!dvmGcStartupClasses()) {
+        return "dvmGcStartupClasses failed";
+    }
 
     /*
      * Init for either zygote mode or non-zygote mode.  The key difference
      * is that we don't start any additional threads in Zygote mode.
      */
     if (gDvm.zygote) {
-        if (!initZygote())
-            goto fail;
+        if (!initZygote()) {
+            return "initZygote failed";
+        }
     } else {
-        if (!dvmInitAfterZygote())
-            goto fail;
+        if (!dvmInitAfterZygote()) {
+            return "dvmInitAfterZygote failed";
+        }
     }
 
 
@@ -1339,16 +1381,12 @@
 #endif
 
     if (dvmCheckException(dvmThreadSelf())) {
-        LOGE("Exception pending at end of VM initialization");
         dvmLogExceptionStackTrace();
-        goto fail;
+        return "Exception pending at end of VM initialization";
     }
 
-    return 0;
-
-fail:
-    dvmShutdown();
-    return 1;
+    scopedShutdown.disarm();
+    return "";
 }
 
 /*
diff --git a/vm/Init.h b/vm/Init.h
index 5a331a7..1b585fa 100644
--- a/vm/Init.h
+++ b/vm/Init.h
@@ -23,8 +23,8 @@
 /*
  * Standard VM initialization, usually invoked through JNI.
  */
-int dvmStartup(int argc, const char* const argv[], bool ignoreUnrecognized,
-    JNIEnv* pEnv);
+std::string dvmStartup(int argc, const char* const argv[],
+        bool ignoreUnrecognized, JNIEnv* pEnv);
 void dvmShutdown(void);
 bool dvmInitAfterZygote(void);
 
diff --git a/vm/Jni.cpp b/vm/Jni.cpp
index 3e45e87..4686647 100644
--- a/vm/Jni.cpp
+++ b/vm/Jni.cpp
@@ -388,6 +388,18 @@
         }
     }
 
+#if 0 // TODO: fix this to understand PushLocalFrame, so we can turn it on.
+    if (gDvmJni.useCheckJni) {
+        size_t entryCount = pRefTable->capacity();
+        if (entryCount > 16) {
+            LOGW("Warning: more than 16 JNI local references: %d (most recent was a %s)", entryCount, obj->clazz->descriptor);
+            pRefTable->dump("JNI local");
+            dvmDumpThread(dvmThreadSelf(), false);
+            //dvmAbort();
+        }
+    }
+#endif
+
     return jobj;
 }
 
@@ -3523,13 +3535,14 @@
 
     /* Initialize VM. */
     gDvm.initializing = true;
-    int rc = dvmStartup(argc, argv.get(), args->ignoreUnrecognized, (JNIEnv*)pEnv);
+    std::string status =
+            dvmStartup(argc, argv.get(), args->ignoreUnrecognized, (JNIEnv*)pEnv);
     gDvm.initializing = false;
 
-    if (rc != 0) {
+    if (!status.empty()) {
         free(pEnv);
         free(pVM);
-        LOGW("CreateJavaVM failed");
+        LOGW("CreateJavaVM failed: %s", status.c_str());
         return JNI_ERR;
     }
 
diff --git a/vm/Misc.cpp b/vm/Misc.cpp
index 12e3b88..059e6bb 100644
--- a/vm/Misc.cpp
+++ b/vm/Misc.cpp
@@ -283,6 +283,34 @@
     return result;
 }
 
+std::string dvmHumanReadableField(const Field* field)
+{
+    if (field == NULL) {
+        return "(null)";
+    }
+    std::string result(dvmHumanReadableDescriptor(field->clazz->descriptor));
+    result += '.';
+    result += field->name;
+    return result;
+}
+
+std::string dvmHumanReadableMethod(const Method* method, bool withSignature)
+{
+    if (method == NULL) {
+        return "(null)";
+    }
+    std::string result(dvmHumanReadableDescriptor(method->clazz->descriptor));
+    result += '.';
+    result += method->name;
+    if (withSignature) {
+        // TODO: the types in this aren't human readable!
+        char* signature = dexProtoCopyMethodDescriptor(&method->prototype);
+        result += signature;
+        free(signature);
+    }
+    return result;
+}
+
 /*
  * Return a newly-allocated string for the "dot version" of the class
  * name for the given type descriptor. That is, The initial "L" and
@@ -734,7 +762,7 @@
 }
 
 // From RE2.
-static void StringAppendV(std::string* dst, const char* format, va_list ap) {
+void StringAppendV(std::string* dst, const char* format, va_list ap) {
     // First try with a small fixed size buffer
     char space[1024];
 
diff --git a/vm/Misc.h b/vm/Misc.h
index e027f0c..86e0a71 100644
--- a/vm/Misc.h
+++ b/vm/Misc.h
@@ -155,6 +155,19 @@
  */
 std::string dvmHumanReadableType(const Object* obj);
 
+/**
+ * Returns a human-readable string of the form "package.Class.fieldName".
+ */
+struct Field;
+std::string dvmHumanReadableField(const Field* field);
+
+/**
+ * Returns a human-readable string of the form "package.Class.methodName"
+ * or "package.Class.methodName(Ljava/lang/String;I)V".
+ */
+struct Method;
+std::string dvmHumanReadableMethod(const Method* method, bool withSignature);
+
 /*
  * Return a newly-allocated string for the "dot version" of the class
  * name for the given type descriptor. That is, The initial "L" and
@@ -324,4 +337,9 @@
 void StringAppendF(std::string* dst, const char* fmt, ...)
         __attribute__((__format__ (__printf__, 2, 3)));
 
+/**
+ * Appends a printf-like formatting of the arguments to 'dst'.
+ */
+void StringAppendV(std::string* dst, const char* format, va_list ap);
+
 #endif  // DALVIK_MISC_H_
diff --git a/vm/Native.cpp b/vm/Native.cpp
index 1974863..5132dcc 100644
--- a/vm/Native.cpp
+++ b/vm/Native.cpp
@@ -430,7 +430,9 @@
 
             self->classLoaderOverride = classLoader;
             oldStatus = dvmChangeStatus(self, THREAD_NATIVE);
-            LOGV("+++ calling JNI_OnLoad(%s)", pathName);
+            if (gDvm.verboseJni) {
+                LOGI("[Calling JNI_OnLoad for \"%s\"]", pathName);
+            }
             version = (*func)(gDvmJni.jniVm, NULL);
             dvmChangeStatus(self, oldStatus);
             self->classLoaderOverride = prevOverride;
@@ -451,7 +453,9 @@
                  */
                 result = false;
             } else {
-                LOGV("+++ finished JNI_OnLoad %s", pathName);
+                if (gDvm.verboseJni) {
+                    LOGI("[Returned from JNI_OnLoad for \"%s\"]", pathName);
+                }
             }
         }
 
diff --git a/vm/interp/Stack.cpp b/vm/interp/Stack.cpp
index db1bd89..a6f6bbd 100644
--- a/vm/interp/Stack.cpp
+++ b/vm/interp/Stack.cpp
@@ -1228,13 +1228,13 @@
             else
                 relPc = -1;
 
-            std::string className(dvmHumanReadableDescriptor(method->clazz->descriptor));
+            std::string methodName(dvmHumanReadableMethod(method, false));
             if (dvmIsNativeMethod(method)) {
-                dvmPrintDebugMessage(target, "  at %s.%s(Native Method)\n",
-                        className.c_str(), method->name);
+                dvmPrintDebugMessage(target, "  at %s(Native Method)\n",
+                        methodName.c_str());
             } else {
-                dvmPrintDebugMessage(target, "  at %s.%s(%s:%s%d)\n",
-                        className.c_str(), method->name, dvmGetMethodSourceFile(method),
+                dvmPrintDebugMessage(target, "  at %s(%s:%s%d)\n",
+                        methodName.c_str(), dvmGetMethodSourceFile(method),
                         (relPc >= 0 && first) ? "~" : "",
                         relPc < 0 ? -1 : dvmLineNumFromPC(method, relPc));
             }