diff --git a/src/check_jni.cc b/src/check_jni.cc
index b39b521..c724eb2 100644
--- a/src/check_jni.cc
+++ b/src/check_jni.cc
@@ -310,13 +310,13 @@
   }
 
   /*
-   * Verify that "mid" is appropriate for "clazz".
+   * Verify that "mid" is appropriate for "java_class".
    *
    * A mismatch isn't dangerous, because the jmethodID defines the class.  In
-   * fact, jclazz is unused in the implementation.  It's best if we don't
+   * fact, java_class is unused in the implementation.  It's best if we don't
    * allow bad code in the system though.
    *
-   * Instances of "jclazz" must be instances of the method's declaring class.
+   * Instances of "java_class" must be instances of the method's declaring class.
    */
   void CheckStaticMethod(jclass java_class, jmethodID mid) {
     ScopedJniThreadState ts(env_);
@@ -1170,14 +1170,14 @@
     return CHECK_JNI_EXIT("c", baseEnv(env)->FindClass(env, name));
   }
 
-  static jclass GetSuperclass(JNIEnv* env, jclass clazz) {
-    CHECK_JNI_ENTRY(kFlag_Default, "Ec", env, clazz);
-    return CHECK_JNI_EXIT("c", baseEnv(env)->GetSuperclass(env, clazz));
+  static jclass GetSuperclass(JNIEnv* env, jclass c) {
+    CHECK_JNI_ENTRY(kFlag_Default, "Ec", env, c);
+    return CHECK_JNI_EXIT("c", baseEnv(env)->GetSuperclass(env, c));
   }
 
-  static jboolean IsAssignableFrom(JNIEnv* env, jclass clazz1, jclass clazz2) {
-    CHECK_JNI_ENTRY(kFlag_Default, "Ecc", env, clazz1, clazz2);
-    return CHECK_JNI_EXIT("b", baseEnv(env)->IsAssignableFrom(env, clazz1, clazz2));
+  static jboolean IsAssignableFrom(JNIEnv* env, jclass c1, jclass c2) {
+    CHECK_JNI_ENTRY(kFlag_Default, "Ecc", env, c1, c2);
+    return CHECK_JNI_EXIT("b", baseEnv(env)->IsAssignableFrom(env, c1, c2));
   }
 
   static jmethodID FromReflectedMethod(JNIEnv* env, jobject method) {
@@ -1208,9 +1208,9 @@
     return CHECK_JNI_EXIT("I", baseEnv(env)->Throw(env, obj));
   }
 
-  static jint ThrowNew(JNIEnv* env, jclass clazz, const char* message) {
-    CHECK_JNI_ENTRY(kFlag_NullableUtf, "Ecu", env, clazz, message);
-    return CHECK_JNI_EXIT("I", baseEnv(env)->ThrowNew(env, clazz, message));
+  static jint ThrowNew(JNIEnv* env, jclass c, const char* message) {
+    CHECK_JNI_ENTRY(kFlag_NullableUtf, "Ecu", env, c, message);
+    return CHECK_JNI_EXIT("I", baseEnv(env)->ThrowNew(env, c, message));
   }
 
   static jthrowable ExceptionOccurred(JNIEnv* env) {
@@ -1299,28 +1299,28 @@
     return CHECK_JNI_EXIT("b", baseEnv(env)->IsSameObject(env, ref1, ref2));
   }
 
-  static jobject AllocObject(JNIEnv* env, jclass clazz) {
-    CHECK_JNI_ENTRY(kFlag_Default, "Ec", env, clazz);
-    return CHECK_JNI_EXIT("L", baseEnv(env)->AllocObject(env, clazz));
+  static jobject AllocObject(JNIEnv* env, jclass c) {
+    CHECK_JNI_ENTRY(kFlag_Default, "Ec", env, c);
+    return CHECK_JNI_EXIT("L", baseEnv(env)->AllocObject(env, c));
   }
 
-  static jobject NewObject(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
-    CHECK_JNI_ENTRY(kFlag_Default, "Ecm.", env, clazz, mid);
+  static jobject NewObject(JNIEnv* env, jclass c, jmethodID mid, ...) {
+    CHECK_JNI_ENTRY(kFlag_Default, "Ecm.", env, c, mid);
     va_list args;
     va_start(args, mid);
-    jobject result = baseEnv(env)->NewObjectV(env, clazz, mid, args);
+    jobject result = baseEnv(env)->NewObjectV(env, c, mid, args);
     va_end(args);
     return CHECK_JNI_EXIT("L", result);
   }
 
-  static jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID mid, va_list args) {
-    CHECK_JNI_ENTRY(kFlag_Default, "Ecm.", env, clazz, mid);
-    return CHECK_JNI_EXIT("L", baseEnv(env)->NewObjectV(env, clazz, mid, args));
+  static jobject NewObjectV(JNIEnv* env, jclass c, jmethodID mid, va_list args) {
+    CHECK_JNI_ENTRY(kFlag_Default, "Ecm.", env, c, mid);
+    return CHECK_JNI_EXIT("L", baseEnv(env)->NewObjectV(env, c, mid, args));
   }
 
-  static jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID mid, jvalue* args) {
-    CHECK_JNI_ENTRY(kFlag_Default, "Ecm.", env, clazz, mid);
-    return CHECK_JNI_EXIT("L", baseEnv(env)->NewObjectA(env, clazz, mid, args));
+  static jobject NewObjectA(JNIEnv* env, jclass c, jmethodID mid, jvalue* args) {
+    CHECK_JNI_ENTRY(kFlag_Default, "Ecm.", env, c, mid);
+    return CHECK_JNI_EXIT("L", baseEnv(env)->NewObjectA(env, c, mid, args));
   }
 
   static jclass GetObjectClass(JNIEnv* env, jobject obj) {
@@ -1328,48 +1328,48 @@
     return CHECK_JNI_EXIT("c", baseEnv(env)->GetObjectClass(env, obj));
   }
 
-  static jboolean IsInstanceOf(JNIEnv* env, jobject obj, jclass clazz) {
-    CHECK_JNI_ENTRY(kFlag_Default, "ELc", env, obj, clazz);
-    return CHECK_JNI_EXIT("b", baseEnv(env)->IsInstanceOf(env, obj, clazz));
+  static jboolean IsInstanceOf(JNIEnv* env, jobject obj, jclass c) {
+    CHECK_JNI_ENTRY(kFlag_Default, "ELc", env, obj, c);
+    return CHECK_JNI_EXIT("b", baseEnv(env)->IsInstanceOf(env, obj, c));
   }
 
-  static jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char* name, const char* sig) {
-    CHECK_JNI_ENTRY(kFlag_Default, "Ecuu", env, clazz, name, sig);
-    return CHECK_JNI_EXIT("m", baseEnv(env)->GetMethodID(env, clazz, name, sig));
+  static jmethodID GetMethodID(JNIEnv* env, jclass c, const char* name, const char* sig) {
+    CHECK_JNI_ENTRY(kFlag_Default, "Ecuu", env, c, name, sig);
+    return CHECK_JNI_EXIT("m", baseEnv(env)->GetMethodID(env, c, name, sig));
   }
 
-  static jfieldID GetFieldID(JNIEnv* env, jclass clazz, const char* name, const char* sig) {
-    CHECK_JNI_ENTRY(kFlag_Default, "Ecuu", env, clazz, name, sig);
-    return CHECK_JNI_EXIT("f", baseEnv(env)->GetFieldID(env, clazz, name, sig));
+  static jfieldID GetFieldID(JNIEnv* env, jclass c, const char* name, const char* sig) {
+    CHECK_JNI_ENTRY(kFlag_Default, "Ecuu", env, c, name, sig);
+    return CHECK_JNI_EXIT("f", baseEnv(env)->GetFieldID(env, c, name, sig));
   }
 
-  static jmethodID GetStaticMethodID(JNIEnv* env, jclass clazz, const char* name, const char* sig) {
-    CHECK_JNI_ENTRY(kFlag_Default, "Ecuu", env, clazz, name, sig);
-    return CHECK_JNI_EXIT("m", baseEnv(env)->GetStaticMethodID(env, clazz, name, sig));
+  static jmethodID GetStaticMethodID(JNIEnv* env, jclass c, const char* name, const char* sig) {
+    CHECK_JNI_ENTRY(kFlag_Default, "Ecuu", env, c, name, sig);
+    return CHECK_JNI_EXIT("m", baseEnv(env)->GetStaticMethodID(env, c, name, sig));
   }
 
-  static jfieldID GetStaticFieldID(JNIEnv* env, jclass clazz, const char* name, const char* sig) {
-    CHECK_JNI_ENTRY(kFlag_Default, "Ecuu", env, clazz, name, sig);
-    return CHECK_JNI_EXIT("f", baseEnv(env)->GetStaticFieldID(env, clazz, name, sig));
+  static jfieldID GetStaticFieldID(JNIEnv* env, jclass c, const char* name, const char* sig) {
+    CHECK_JNI_ENTRY(kFlag_Default, "Ecuu", env, c, name, sig);
+    return CHECK_JNI_EXIT("f", baseEnv(env)->GetStaticFieldID(env, c, name, sig));
   }
 
 #define FIELD_ACCESSORS(_ctype, _jname, _type) \
-    static _ctype GetStatic##_jname##Field(JNIEnv* env, jclass clazz, jfieldID fid) { \
-        CHECK_JNI_ENTRY(kFlag_Default, "Ecf", env, clazz, fid); \
-        sc.CheckStaticFieldID(clazz, fid); \
-        return CHECK_JNI_EXIT(_type, baseEnv(env)->GetStatic##_jname##Field(env, clazz, fid)); \
+    static _ctype GetStatic##_jname##Field(JNIEnv* env, jclass c, jfieldID fid) { \
+        CHECK_JNI_ENTRY(kFlag_Default, "Ecf", env, c, fid); \
+        sc.CheckStaticFieldID(c, fid); \
+        return CHECK_JNI_EXIT(_type, baseEnv(env)->GetStatic##_jname##Field(env, c, fid)); \
     } \
     static _ctype Get##_jname##Field(JNIEnv* env, jobject obj, jfieldID fid) { \
         CHECK_JNI_ENTRY(kFlag_Default, "ELf", env, obj, fid); \
         sc.CheckInstanceFieldID(obj, fid); \
         return CHECK_JNI_EXIT(_type, baseEnv(env)->Get##_jname##Field(env, obj, fid)); \
     } \
-    static void SetStatic##_jname##Field(JNIEnv* env, jclass clazz, jfieldID fid, _ctype value) { \
-        CHECK_JNI_ENTRY(kFlag_Default, "Ecf" _type, env, clazz, fid, value); \
-        sc.CheckStaticFieldID(clazz, fid); \
+    static void SetStatic##_jname##Field(JNIEnv* env, jclass c, jfieldID fid, _ctype value) { \
+        CHECK_JNI_ENTRY(kFlag_Default, "Ecf" _type, env, c, fid, value); \
+        sc.CheckStaticFieldID(c, fid); \
         /* "value" arg only used when type == ref */ \
         sc.CheckFieldType((jobject)(uint32_t)value, fid, _type[0], true); \
-        baseEnv(env)->SetStatic##_jname##Field(env, clazz, fid, value); \
+        baseEnv(env)->SetStatic##_jname##Field(env, c, fid, value); \
         CHECK_JNI_EXIT_VOID(); \
     } \
     static void Set##_jname##Field(JNIEnv* env, jobject obj, jfieldID fid, _ctype value) { \
@@ -1428,70 +1428,67 @@
     } \
     /* Non-virtual... */ \
     static _ctype CallNonvirtual##_jname##Method(JNIEnv* env, \
-        jobject obj, jclass clazz, jmethodID mid, ...) \
+        jobject obj, jclass c, jmethodID mid, ...) \
     { \
-        CHECK_JNI_ENTRY(kFlag_Default, "ELcm.", env, obj, clazz, mid); /* TODO: args! */ \
+        CHECK_JNI_ENTRY(kFlag_Default, "ELcm.", env, obj, c, mid); /* TODO: args! */ \
         sc.CheckSig(mid, _retsig, false); \
         sc.CheckVirtualMethod(obj, mid); \
         _retdecl; \
         va_list args; \
         va_start(args, mid); \
-        _retasgn(baseEnv(env)->CallNonvirtual##_jname##MethodV(env, obj, clazz, mid, args)); \
+        _retasgn(baseEnv(env)->CallNonvirtual##_jname##MethodV(env, obj, c, mid, args)); \
         va_end(args); \
         _retok; \
     } \
     static _ctype CallNonvirtual##_jname##MethodV(JNIEnv* env, \
-        jobject obj, jclass clazz, jmethodID mid, va_list args) \
+        jobject obj, jclass c, jmethodID mid, va_list args) \
     { \
-        CHECK_JNI_ENTRY(kFlag_Default, "ELcm.", env, obj, clazz, mid); /* TODO: args! */ \
+        CHECK_JNI_ENTRY(kFlag_Default, "ELcm.", env, obj, c, mid); /* TODO: args! */ \
         sc.CheckSig(mid, _retsig, false); \
         sc.CheckVirtualMethod(obj, mid); \
         _retdecl; \
-        _retasgn(baseEnv(env)->CallNonvirtual##_jname##MethodV(env, obj, clazz, mid, args)); \
+        _retasgn(baseEnv(env)->CallNonvirtual##_jname##MethodV(env, obj, c, mid, args)); \
         _retok; \
     } \
     static _ctype CallNonvirtual##_jname##MethodA(JNIEnv* env, \
-        jobject obj, jclass clazz, jmethodID mid, jvalue* args) \
+        jobject obj, jclass c, jmethodID mid, jvalue* args) \
     { \
-        CHECK_JNI_ENTRY(kFlag_Default, "ELcm.", env, obj, clazz, mid); /* TODO: args! */ \
+        CHECK_JNI_ENTRY(kFlag_Default, "ELcm.", env, obj, c, mid); /* TODO: args! */ \
         sc.CheckSig(mid, _retsig, false); \
         sc.CheckVirtualMethod(obj, mid); \
         _retdecl; \
-        _retasgn(baseEnv(env)->CallNonvirtual##_jname##MethodA(env, obj, clazz, mid, args)); \
+        _retasgn(baseEnv(env)->CallNonvirtual##_jname##MethodA(env, obj, c, mid, args)); \
         _retok; \
     } \
     /* Static... */ \
-    static _ctype CallStatic##_jname##Method(JNIEnv* env, \
-        jclass clazz, jmethodID mid, ...) \
+    static _ctype CallStatic##_jname##Method(JNIEnv* env, jclass c, jmethodID mid, ...) \
     { \
-        CHECK_JNI_ENTRY(kFlag_Default, "Ecm.", env, clazz, mid); /* TODO: args! */ \
+        CHECK_JNI_ENTRY(kFlag_Default, "Ecm.", env, c, mid); /* TODO: args! */ \
         sc.CheckSig(mid, _retsig, true); \
-        sc.CheckStaticMethod(clazz, mid); \
+        sc.CheckStaticMethod(c, mid); \
         _retdecl; \
         va_list args; \
         va_start(args, mid); \
-        _retasgn(baseEnv(env)->CallStatic##_jname##MethodV(env, clazz, mid, args)); \
+        _retasgn(baseEnv(env)->CallStatic##_jname##MethodV(env, c, mid, args)); \
         va_end(args); \
         _retok; \
     } \
-    static _ctype CallStatic##_jname##MethodV(JNIEnv* env, \
-        jclass clazz, jmethodID mid, va_list args) \
+    static _ctype CallStatic##_jname##MethodV(JNIEnv* env, jclass c, jmethodID mid, va_list args) \
     { \
-        CHECK_JNI_ENTRY(kFlag_Default, "Ecm.", env, clazz, mid); /* TODO: args! */ \
+        CHECK_JNI_ENTRY(kFlag_Default, "Ecm.", env, c, mid); /* TODO: args! */ \
         sc.CheckSig(mid, _retsig, true); \
-        sc.CheckStaticMethod(clazz, mid); \
+        sc.CheckStaticMethod(c, mid); \
         _retdecl; \
-         _retasgn(baseEnv(env)->CallStatic##_jname##MethodV(env, clazz, mid, args)); \
+         _retasgn(baseEnv(env)->CallStatic##_jname##MethodV(env, c, mid, args)); \
         _retok; \
     } \
-    static _ctype CallStatic##_jname##MethodA(JNIEnv* env, \
-        jclass clazz, jmethodID mid, jvalue* args) \
+    static _ctype CallStatic##_jname##MethodA(JNIEnv* env, jclass c, jmethodID mid, jvalue* args) \
     { \
-        CHECK_JNI_ENTRY(kFlag_Default, "Ecm.", env, clazz, mid); /* TODO: args! */ \
+        CHECK_JNI_ENTRY(kFlag_Default, "Ecm.", env, c, mid); /* TODO: args! */ \
         sc.CheckSig(mid, _retsig, true); \
-        sc.CheckStaticMethod(clazz, mid); \
+        sc.CheckStaticMethod(c, mid); \
         _retdecl; \
-        _retasgn(baseEnv(env)->CallStatic##_jname##MethodA(env, clazz, mid, args)); \
+        _retasgn(baseEnv(env)->CallStatic##_jname##MethodA(env, c, mid, args)); \
         _retok; \
     }
 
@@ -1685,14 +1682,14 @@
 PRIMITIVE_ARRAY_FUNCTIONS(jfloat, Float, 'F');
 PRIMITIVE_ARRAY_FUNCTIONS(jdouble, Double, 'D');
 
-  static jint RegisterNatives(JNIEnv* env, jclass clazz, const JNINativeMethod* methods, jint nMethods) {
-    CHECK_JNI_ENTRY(kFlag_Default, "EcpI", env, clazz, methods, nMethods);
-    return CHECK_JNI_EXIT("I", baseEnv(env)->RegisterNatives(env, clazz, methods, nMethods));
+  static jint RegisterNatives(JNIEnv* env, jclass c, const JNINativeMethod* methods, jint nMethods) {
+    CHECK_JNI_ENTRY(kFlag_Default, "EcpI", env, c, methods, nMethods);
+    return CHECK_JNI_EXIT("I", baseEnv(env)->RegisterNatives(env, c, methods, nMethods));
   }
 
-  static jint UnregisterNatives(JNIEnv* env, jclass clazz) {
-    CHECK_JNI_ENTRY(kFlag_Default, "Ec", env, clazz);
-    return CHECK_JNI_EXIT("I", baseEnv(env)->UnregisterNatives(env, clazz));
+  static jint UnregisterNatives(JNIEnv* env, jclass c) {
+    CHECK_JNI_ENTRY(kFlag_Default, "Ec", env, c);
+    return CHECK_JNI_EXIT("I", baseEnv(env)->UnregisterNatives(env, c));
   }
 
   static jint MonitorEnter(JNIEnv* env, jobject obj) {
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 38ce30a..0fd184c 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -1142,6 +1142,9 @@
 }
 
 Class* ClassLinker::FindClass(const char* descriptor, const ClassLoader* class_loader) {
+  if (strstr(descriptor, "TestClass") != NULL) {
+    LOG(INFO) << "ClassLinker::FindClass " << descriptor;
+  }
   DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
   Thread* self = Thread::Current();
   DCHECK(self != NULL);
@@ -1221,6 +1224,10 @@
                                 const ClassLoader* class_loader,
                                 const DexFile& dex_file,
                                 const DexFile::ClassDef& dex_class_def) {
+  if (strstr(descriptor.ToString().c_str(), "TestClass") != NULL) {
+    LOG(INFO) << "ClassLinker::DefineClass " << descriptor;
+    Thread::Current()->Dump(LOG(INFO));
+  }
   SirtRef<Class> klass(NULL);
   // Load the class from the dex file.
   if (!init_done_) {
@@ -2603,6 +2610,9 @@
 }
 
 bool ClassLinker::EnsureInitialized(Class* c, bool can_run_clinit) {
+  if (PrettyClass(c).find("TestClass") != std::string::npos) {
+    LOG(INFO) << "ClassLinker::EnsureInitialized " << PrettyClass(c);
+  }
   CHECK(c != NULL);
   if (c->IsInitialized()) {
     return true;
diff --git a/src/compiler/codegen/GenCommon.cc b/src/compiler/codegen/GenCommon.cc
index b45fbaa6..3ca0450 100644
--- a/src/compiler/codegen/GenCommon.cc
+++ b/src/compiler/codegen/GenCommon.cc
@@ -1258,10 +1258,10 @@
     }
     /* rARG0 is ref, rARG2 is class. If ref==null, use directly as bool result */
     LIR* branch1 = opCmpImmBranch(cUnit, kCondEq, rARG0, 0, NULL);
-    /* load object->clazz */
+    /* load object->klass_ */
     DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
     loadWordDisp(cUnit, rARG0,  Object::ClassOffset().Int32Value(), rARG1);
-    /* rARG0 is ref, rARG1 is ref->clazz, rARG2 is class */
+    /* rARG0 is ref, rARG1 is ref->klass_, rARG2 is class */
 #if defined(TARGET_ARM)
     /* Uses conditional nullification */
     int rTgt = loadHelper(cUnit, OFFSETOF_MEMBER(Thread,
@@ -1348,10 +1348,10 @@
     loadValueDirectFixed(cUnit, rlSrc, rARG0);  // rARG0 <= ref
     /* Null is OK - continue */
     LIR* branch1 = opCmpImmBranch(cUnit, kCondEq, rARG0, 0, NULL);
-    /* load object->clazz */
+    /* load object->klass_ */
     DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
     loadWordDisp(cUnit, rARG0,  Object::ClassOffset().Int32Value(), rARG1);
-    /* rARG1 now contains object->clazz */
+    /* rARG1 now contains object->klass_ */
 #if defined(TARGET_MIPS) || defined(TARGET_X86)
     LIR* branch2 = opCmpBranch(cUnit, kCondEq, rARG1, classReg, NULL);
     callRuntimeHelperRegReg(cUnit, OFFSETOF_MEMBER(Thread,
@@ -1392,7 +1392,7 @@
 
     /* null array object? */
     genNullCheck(cUnit, rlArray.sRegLow, rARG1, mir);
-    /* Get the array's clazz */
+    /* Get the array's class */
     loadWordDisp(cUnit, rARG1, Object::ClassOffset().Int32Value(), rARG1);
     callRuntimeHelperRegReg(cUnit, OFFSETOF_MEMBER(Thread,
                                                   pCanPutArrayElementFromCode),
diff --git a/src/hprof/hprof.cc b/src/hprof/hprof.cc
index 04e43d2..532eada 100644
--- a/src/hprof/hprof.cc
+++ b/src/hprof/hprof.cc
@@ -146,7 +146,7 @@
 // for class static overhead.
 #define STATIC_OVERHEAD_NAME    "$staticOverhead"
 // The ID for the synthetic object generated to account for class static overhead.
-#define CLASS_STATICS_ID(clazz) ((HprofObjectId)(((uint32_t)(clazz)) | 1))
+#define CLASS_STATICS_ID(c) ((HprofObjectId)(((uint32_t)(c)) | 1))
 
 HprofBasicType Hprof::SignatureToBasicTypeAndSize(const char* sig, size_t* sizeOut) {
   char c = sig[0];
@@ -319,8 +319,8 @@
     current_heap_ = desiredHeap;
   }
 
-  Class* clazz = obj->GetClass();
-  if (clazz == NULL) {
+  Class* c = obj->GetClass();
+  if (c == NULL) {
     // This object will bother HprofReader, because it has a NULL
     // class, so just don't dump it. It could be
     // gDvm.unlinkedJavaLangClass or it could be an object just
@@ -408,7 +408,7 @@
         rec->AddId(LookupStringId(fh.GetName()));
         rec->AddU1(t);
       }
-    } else if (clazz->IsArrayClass()) {
+    } else if (c->IsArrayClass()) {
       Array *aobj = (Array *)obj;
       uint32_t length = aobj->GetLength();
 
@@ -419,13 +419,13 @@
         rec->AddId((HprofObjectId)obj);
         rec->AddU4(StackTraceSerialNumber(obj));
         rec->AddU4(length);
-        rec->AddId(LookupClassId(clazz));
+        rec->AddId(LookupClassId(c));
 
         // Dump the elements, which are always objects or NULL.
         rec->AddIdList((const HprofObjectId *)aobj->GetRawData(sizeof(Object*)), length);
       } else {
         size_t size;
-        HprofBasicType t = PrimitiveToBasicTypeAndSize(clazz->GetComponentType()->GetPrimitiveType(), &size);
+        HprofBasicType t = PrimitiveToBasicTypeAndSize(c->GetComponentType()->GetPrimitiveType(), &size);
 
         // obj is a primitive array.
 #if DUMP_PRIM_DATA
@@ -458,7 +458,7 @@
       rec->AddU1(HPROF_INSTANCE_DUMP);
       rec->AddId((HprofObjectId)obj);
       rec->AddU4(StackTraceSerialNumber(obj));
-      rec->AddId(LookupClassId(clazz));
+      rec->AddId(LookupClassId(c));
 
       // Reserve some space for the length of the instance data, which we won't
       // know until we're done writing it.
@@ -467,7 +467,7 @@
 
       // Write the instance data;  fields for this class, followed by super class fields,
       // and so on. Don't write the klass or monitor fields of Object.class.
-      const Class* sclass = clazz;
+      const Class* sclass = c;
       FieldHelper fh;
       while (!sclass->IsObjectClass()) {
         int ifieldCount = sclass->NumInstanceFields();
@@ -684,23 +684,23 @@
   return 0;
 }
 
-HprofStringId Hprof::LookupClassNameId(Class* clazz) {
-  return LookupStringId(PrettyDescriptor(clazz));
+HprofStringId Hprof::LookupClassNameId(Class* c) {
+  return LookupStringId(PrettyDescriptor(c));
 }
 
-HprofClassObjectId Hprof::LookupClassId(Class* clazz) {
-  if (clazz == NULL) {
-    // clazz is the superclass of java.lang.Object or a primitive
+HprofClassObjectId Hprof::LookupClassId(Class* c) {
+  if (c == NULL) {
+    // c is the superclass of java.lang.Object or a primitive
     return (HprofClassObjectId)0;
   }
 
-  std::pair<ClassSetIterator, bool> result = classes_.insert(clazz);
+  std::pair<ClassSetIterator, bool> result = classes_.insert(c);
   Class* present = *result.first;
 
   // Make sure that we've assigned a string ID for this class' name
-  LookupClassNameId(clazz);
+  LookupClassNameId(c);
 
-  CHECK_EQ(present, clazz);
+  CHECK_EQ(present, c);
   return (HprofStringId) present;
 }
 
@@ -709,8 +709,8 @@
   uint32_t nextSerialNumber = 1;
 
   for (ClassSetIterator it = classes_.begin(); it != classes_.end(); ++it) {
-    Class* clazz = *it;
-    CHECK(clazz != NULL);
+    Class* c = *it;
+    CHECK(c != NULL);
 
     int err = StartNewRecord(HPROF_TAG_LOAD_CLASS, HPROF_TIME);
     if (err != 0) {
@@ -723,9 +723,9 @@
     // U4: stack trace serial number
     // ID: class name string ID
     rec->AddU4(nextSerialNumber++);
-    rec->AddId((HprofClassObjectId) clazz);
+    rec->AddId((HprofClassObjectId) c);
     rec->AddU4(HPROF_NULL_STACK_TRACE);
-    rec->AddId(LookupClassNameId(clazz));
+    rec->AddId(LookupClassNameId(c));
   }
 
   return 0;
diff --git a/src/hprof/hprof.h b/src/hprof/hprof.h
index 9595b2b..c4a0dd3 100644
--- a/src/hprof/hprof.h
+++ b/src/hprof/hprof.h
@@ -193,11 +193,11 @@
   int StartNewRecord(uint8_t tag, uint32_t time);
   int FlushCurrentRecord();
   int MarkRootObject(const Object *obj, jobject jniObj);
-  HprofClassObjectId LookupClassId(Class* clazz);
+  HprofClassObjectId LookupClassId(Class* c);
   HprofStringId LookupStringId(String* string);
   HprofStringId LookupStringId(const char* string);
   HprofStringId LookupStringId(std::string string);
-  HprofStringId LookupClassNameId(Class* clazz);
+  HprofStringId LookupClassNameId(Class* c);
   static HprofBasicType SignatureToBasicTypeAndSize(const char* sig, size_t* sizeOut);
   static HprofBasicType PrimitiveToBasicTypeAndSize(Primitive::Type prim, size_t* sizeOut);
   static int StackTraceSerialNumber(const void *obj);
diff --git a/src/indirect_reference_table.h b/src/indirect_reference_table.h
index cdf2f8b..72ff1c8 100644
--- a/src/indirect_reference_table.h
+++ b/src/indirect_reference_table.h
@@ -259,9 +259,7 @@
   ~IndirectReferenceTable();
 
   /*
-   * Add a new entry.  "obj" must be a valid non-NULL object reference
-   * (though it's okay if it's not fully-formed, e.g. the result from
-   * dvmMalloc doesn't have obj->clazz set).
+   * Add a new entry.  "obj" must be a valid non-NULL object reference.
    *
    * Returns NULL if the table is full (max entries reached, or alloc
    * failed during expansion).
diff --git a/src/jdwp/jdwp_handler.cc b/src/jdwp/jdwp_handler.cc
index 804f683..fb2264a 100644
--- a/src/jdwp/jdwp_handler.cc
+++ b/src/jdwp/jdwp_handler.cc
@@ -1208,9 +1208,9 @@
       break;
     case MK_CLASS_ONLY:     /* for ClassPrepare, MethodEntry */
       {
-        RefTypeId clazzId = ReadRefTypeId(&buf);
-        VLOG(jdwp) << StringPrintf("    ClassOnly: %#llx (%s)", clazzId, Dbg::GetClassName(clazzId).c_str());
-        mod.classOnly.refTypeId = clazzId;
+        RefTypeId classId = ReadRefTypeId(&buf);
+        VLOG(jdwp) << StringPrintf("    ClassOnly: %#llx (%s)", classId, Dbg::GetClassName(classId).c_str());
+        mod.classOnly.refTypeId = classId;
       }
       break;
     case MK_CLASS_MATCH:    /* restrict events to matching classes */
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 37ca93d..56589a1 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -748,16 +748,16 @@
     return c1->IsAssignableFrom(c2) ? JNI_TRUE : JNI_FALSE;
   }
 
-  static jboolean IsInstanceOf(JNIEnv* env, jobject jobj, jclass clazz) {
+  static jboolean IsInstanceOf(JNIEnv* env, jobject jobj, jclass java_class) {
     ScopedJniThreadState ts(env);
-    CHECK_NE(static_cast<jclass>(NULL), clazz); // TODO: ReportJniError
+    CHECK_NE(static_cast<jclass>(NULL), java_class); // TODO: ReportJniError
     if (jobj == NULL) {
       // Note: JNI is different from regular Java instanceof in this respect
       return JNI_TRUE;
     } else {
       Object* obj = Decode<Object*>(ts, jobj);
-      Class* klass = Decode<Class*>(ts, clazz);
-      return obj->InstanceOf(klass) ? JNI_TRUE : JNI_FALSE;
+      Class* c = Decode<Class*>(ts, java_class);
+      return obj->InstanceOf(c) ? JNI_TRUE : JNI_FALSE;
     }
   }
 
@@ -992,11 +992,11 @@
     return AddLocalReference<jobject>(env, c->AllocObject());
   }
 
-  static jobject NewObject(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
+  static jobject NewObject(JNIEnv* env, jclass c, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list args;
     va_start(args, mid);
-    jobject result = NewObjectV(env, clazz, mid, args);
+    jobject result = NewObjectV(env, c, mid, args);
     va_end(args);
     return result;
   }
diff --git a/src/oatexec.cc b/src/oatexec.cc
index 2de355b..340c058 100644
--- a/src/oatexec.cc
+++ b/src/oatexec.cc
@@ -31,8 +31,8 @@
 namespace art {
 
 // Determine whether or not the specified method is public.
-static bool IsMethodPublic(JNIEnv* env, jclass clazz, jmethodID method_id) {
-  ScopedLocalRef<jobject> reflected(env, env->ToReflectedMethod(clazz, method_id, JNI_FALSE));
+static bool IsMethodPublic(JNIEnv* env, jclass c, jmethodID method_id) {
+  ScopedLocalRef<jobject> reflected(env, env->ToReflectedMethod(c, method_id, JNI_FALSE));
   if (reflected.get() == NULL) {
     fprintf(stderr, "Failed to get reflected method\n");
     return false;
diff --git a/src/object.cc b/src/object.cc
index 979c79a..13e4732 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -830,7 +830,7 @@
   return false;
 }
 
-// Determine whether "this" is assignable from "klazz", where both of these
+// Determine whether "this" is assignable from "src", where both of these
 // are array classes.
 //
 // Consider an array class, e.g. Y[][], where Y is a subclass of X.