diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index c5b06bb..ca40e598 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -8,6 +8,7 @@
 #include <utility>
 #include <vector>
 
+#include "ScopedLocalRef.h"
 #include "assembler.h"
 #include "class_linker.h"
 #include "jni.h"
@@ -386,10 +387,8 @@
   return arg_array.release();
 }
 
-JValue InvokeWithArgArray(ScopedJniThreadState& ts, jobject obj,
-                          jmethodID mid, byte* args) {
-  Method* method = DecodeMethod(ts, mid);
-  Object* rcvr = Decode<Object*>(ts, obj);
+JValue InvokeWithArgArray(ScopedJniThreadState& ts, Object* receiver,
+                          Method* method, byte* args) {
   Thread* self = ts.Self();
 
   // Push a transition back into managed code onto the linked list in thread
@@ -410,7 +409,7 @@
 
   JValue result;
   if (method->HasCode()) {
-    (*stub)(method, rcvr, self, args, &result);
+    (*stub)(method, receiver, self, args, &result);
   } else {
     LOG(WARNING) << "Not invoking method with no associated code: "
                  << PrettyMethod(method, true);
@@ -424,16 +423,36 @@
 
 JValue InvokeWithJValues(ScopedJniThreadState& ts, jobject obj,
                          jmethodID mid, jvalue* args) {
+  Object* receiver = Decode<Object*>(ts, obj);
   Method* method = DecodeMethod(ts, mid);
   scoped_array<byte> arg_array(CreateArgArray(ts, method, args));
-  return InvokeWithArgArray(ts, obj, mid, arg_array.get());
+  return InvokeWithArgArray(ts, receiver, method, arg_array.get());
 }
 
 JValue InvokeWithVarArgs(ScopedJniThreadState& ts, jobject obj,
                          jmethodID mid, va_list args) {
+  Object* receiver = Decode<Object*>(ts, obj);
   Method* method = DecodeMethod(ts, mid);
   scoped_array<byte> arg_array(CreateArgArray(ts, method, args));
-  return InvokeWithArgArray(ts, obj, mid, arg_array.get());
+  return InvokeWithArgArray(ts, receiver, method, arg_array.get());
+}
+
+static Method* FindVirtualMethod(Object* receiver, Method* method) {
+  return receiver->GetClass()->GetMethodByVtableIndex(method->GetVtableIndex());
+}
+
+JValue InvokeVirtualWithJValues(ScopedJniThreadState& ts, jobject obj, jmethodID mid, jvalue* args) {
+  Object* receiver = Decode<Object*>(ts, obj);
+  Method* method = FindVirtualMethod(receiver, DecodeMethod(ts, mid));
+  scoped_array<byte> arg_array(CreateArgArray(ts, method, args));
+  return InvokeWithArgArray(ts, receiver, method, arg_array.get());
+}
+
+JValue InvokeVirtualWithVarArgs(ScopedJniThreadState& ts, jobject obj, jmethodID mid, va_list args) {
+  Object* receiver = Decode<Object*>(ts, obj);
+  Method* method = FindVirtualMethod(receiver, DecodeMethod(ts, mid));
+  scoped_array<byte> arg_array(CreateArgArray(ts, method, args));
+  return InvokeWithArgArray(ts, receiver, method, arg_array.get());
 }
 
 // Section 12.3.2 of the JNI spec describes JNI class descriptors. They're
@@ -659,24 +678,21 @@
     if (mid == NULL) {
       return JNI_ERR;
     }
-    jstring s = env->NewStringUTF(msg);
-    if (s == NULL) {
+    ScopedLocalRef<jstring> s(env, env->NewStringUTF(msg));
+    if (s.get() == NULL) {
       return JNI_ERR;
     }
 
     jvalue args[1];
-    args[0].l = s;
-    jthrowable exception = reinterpret_cast<jthrowable>(env->NewObjectA(c, mid, args));
-    if (exception == NULL) {
+    args[0].l = s.get();
+    ScopedLocalRef<jthrowable> exception(env, reinterpret_cast<jthrowable>(env->NewObjectA(c, mid, args)));
+    if (exception.get() == NULL) {
       return JNI_ERR;
     }
 
-    LOG(INFO) << "Throwing " << PrettyType(Decode<Throwable*>(ts, exception))
+    LOG(INFO) << "Throwing " << PrettyType(Decode<Throwable*>(ts, exception.get()))
               << ": " << msg;
-    ts.Self()->SetException(Decode<Throwable*>(ts, exception));
-
-    env->DeleteLocalRef(exception);
-    env->DeleteLocalRef(s);
+    ts.Self()->SetException(Decode<Throwable*>(ts, exception.get()));
 
     return JNI_OK;
   }
@@ -693,7 +709,27 @@
 
   static void ExceptionDescribe(JNIEnv* env) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
+
+    Thread* self = ts.Self();
+    Throwable* original_exception = self->GetException();
+    self->ClearException();
+
+    ScopedLocalRef<jthrowable> exception(env, AddLocalReference<jthrowable>(ts, original_exception));
+    ScopedLocalRef<jclass> exception_class(env, env->GetObjectClass(exception.get()));
+    jmethodID mid = env->GetMethodID(exception_class.get(), "printStackTrace", "()V");
+    if (mid == NULL) {
+      LOG(WARNING) << "JNI WARNING: no printStackTrace()V in "
+                   << PrettyType(original_exception);
+    } else {
+      env->CallVoidMethod(exception.get(), mid);
+      if (self->IsExceptionPending()) {
+        LOG(WARNING) << "JNI WARNING: " << PrettyType(self->GetException())
+                     << " thrown while calling printStackTrace";
+        self->ClearException();
+      }
+    }
+
+    self->SetException(original_exception);
   }
 
   static jthrowable ExceptionOccurred(JNIEnv* env) {
@@ -734,6 +770,12 @@
     return res;
   }
 
+  static jint EnsureLocalCapacity(JNIEnv* env, jint cap) {
+    ScopedJniThreadState ts(env);
+    UNIMPLEMENTED(WARNING) << "ignoring EnsureLocalCapacity(" << cap << ")";
+    return 0;
+  }
+
   static jobject NewGlobalRef(JNIEnv* env, jobject obj) {
     ScopedJniThreadState ts(env);
     if (obj == NULL) {
@@ -823,12 +865,6 @@
         ? JNI_TRUE : JNI_FALSE;
   }
 
-  static jint EnsureLocalCapacity(JNIEnv* env, jint) {
-    ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
-  }
-
   static jobject AllocObject(JNIEnv* env, jclass java_class) {
     ScopedJniThreadState ts(env);
     Class* c = Decode<Class*>(ts, java_class);
@@ -838,16 +874,16 @@
     return AddLocalReference<jobject>(ts, c->NewInstance());
   }
 
-  static jobject NewObject(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
+  static jobject NewObject(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list args;
-    va_start(args, methodID);
-    jobject result = NewObjectV(env, clazz, methodID, args);
+    va_start(args, mid);
+    jobject result = NewObjectV(env, clazz, mid, args);
     va_end(args);
     return result;
   }
 
-  static jobject NewObjectV(JNIEnv* env, jclass java_class, jmethodID methodID, va_list args) {
+  static jobject NewObjectV(JNIEnv* env, jclass java_class, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
     Class* c = Decode<Class*>(ts, java_class);
     if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c)) {
@@ -855,11 +891,11 @@
     }
     Object* result = c->NewInstance();
     jobject local_result = AddLocalReference<jobject>(ts, result);
-    CallNonvirtualVoidMethodV(env, local_result, java_class, methodID, args);
+    CallNonvirtualVoidMethodV(env, local_result, java_class, mid, args);
     return local_result;
   }
 
-  static jobject NewObjectA(JNIEnv* env, jclass java_class, jmethodID methodID, jvalue* args) {
+  static jobject NewObjectA(JNIEnv* env, jclass java_class, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
     Class* c = Decode<Class*>(ts, java_class);
     if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c)) {
@@ -867,7 +903,7 @@
     }
     Object* result = c->NewInstance();
     jobject local_result = AddLocalReference<jobjectArray>(ts, result);
-    CallNonvirtualVoidMethodA(env, local_result, java_class, methodID, args);
+    CallNonvirtualVoidMethodA(env, local_result, java_class, mid, args);
     return local_result;
   }
 
@@ -881,423 +917,417 @@
     return FindMethodID(ts, c, name, sig, true);
   }
 
-  static jobject CallObjectMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
+  static jobject CallObjectMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return NULL;
+    va_list ap;
+    va_start(ap, mid);
+    JValue result = InvokeVirtualWithVarArgs(ts, obj, mid, ap);
+    va_end(ap);
+    return AddLocalReference<jobject>(ts, result.l);
   }
 
-  static jobject CallObjectMethodV(JNIEnv* env,
-      jobject obj, jmethodID methodID, va_list args) {
+  static jobject CallObjectMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return NULL;
+    JValue result = InvokeVirtualWithVarArgs(ts, obj, mid, args);
+    return AddLocalReference<jobject>(ts, result.l);
   }
 
-  static jobject CallObjectMethodA(JNIEnv* env,
-      jobject obj, jmethodID methodID, jvalue*  args) {
+  static jobject CallObjectMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return NULL;
+    JValue result = InvokeVirtualWithJValues(ts, obj, mid, args);
+    return AddLocalReference<jobject>(ts, result.l);
   }
 
-  static jboolean CallBooleanMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
+  static jboolean CallBooleanMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return JNI_FALSE;
+    va_list ap;
+    va_start(ap, mid);
+    JValue result = InvokeVirtualWithVarArgs(ts, obj, mid, ap);
+    va_end(ap);
+    return result.z;
   }
 
-  static jboolean CallBooleanMethodV(JNIEnv* env,
-      jobject obj, jmethodID methodID, va_list args) {
+  static jboolean CallBooleanMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return JNI_FALSE;
+    return InvokeVirtualWithVarArgs(ts, obj, mid, args).z;
   }
 
-  static jboolean CallBooleanMethodA(JNIEnv* env,
-      jobject obj, jmethodID methodID, jvalue*  args) {
+  static jboolean CallBooleanMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return JNI_FALSE;
+    return InvokeVirtualWithJValues(ts, obj, mid, args).z;
   }
 
-  static jbyte CallByteMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
+  static jbyte CallByteMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    va_list ap;
+    va_start(ap, mid);
+    JValue result = InvokeVirtualWithVarArgs(ts, obj, mid, ap);
+    va_end(ap);
+    return result.b;
   }
 
-  static jbyte CallByteMethodV(JNIEnv* env,
-      jobject obj, jmethodID methodID, va_list args) {
+  static jbyte CallByteMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithVarArgs(ts, obj, mid, args).b;
   }
 
-  static jbyte CallByteMethodA(JNIEnv* env,
-      jobject obj, jmethodID methodID, jvalue* args) {
+  static jbyte CallByteMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithJValues(ts, obj, mid, args).b;
   }
 
-  static jchar CallCharMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
+  static jchar CallCharMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    va_list ap;
+    va_start(ap, mid);
+    JValue result = InvokeVirtualWithVarArgs(ts, obj, mid, ap);
+    va_end(ap);
+    return result.c;
   }
 
-  static jchar CallCharMethodV(JNIEnv* env,
-      jobject obj, jmethodID methodID, va_list args) {
+  static jchar CallCharMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithVarArgs(ts, obj, mid, args).c;
   }
 
-  static jchar CallCharMethodA(JNIEnv* env,
-      jobject obj, jmethodID methodID, jvalue* args) {
+  static jchar CallCharMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithJValues(ts, obj, mid, args).c;
   }
 
-  static jshort CallShortMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
+  static jdouble CallDoubleMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    va_list ap;
+    va_start(ap, mid);
+    JValue result = InvokeVirtualWithVarArgs(ts, obj, mid, ap);
+    va_end(ap);
+    return result.d;
   }
 
-  static jshort CallShortMethodV(JNIEnv* env,
-      jobject obj, jmethodID methodID, va_list args) {
+  static jdouble CallDoubleMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithVarArgs(ts, obj, mid, args).d;
   }
 
-  static jshort CallShortMethodA(JNIEnv* env,
-      jobject obj, jmethodID methodID, jvalue* args) {
+  static jdouble CallDoubleMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithJValues(ts, obj, mid, args).d;
   }
 
-  static jint CallIntMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
+  static jfloat CallFloatMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    va_list ap;
+    va_start(ap, mid);
+    JValue result = InvokeVirtualWithVarArgs(ts, obj, mid, ap);
+    va_end(ap);
+    return result.f;
   }
 
-  static jint CallIntMethodV(JNIEnv* env,
-      jobject obj, jmethodID methodID, va_list args) {
+  static jfloat CallFloatMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithVarArgs(ts, obj, mid, args).f;
   }
 
-  static jint CallIntMethodA(JNIEnv* env,
-      jobject obj, jmethodID methodID, jvalue* args) {
+  static jfloat CallFloatMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithJValues(ts, obj, mid, args).f;
   }
 
-  static jlong CallLongMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
+  static jint CallIntMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    va_list ap;
+    va_start(ap, mid);
+    JValue result = InvokeVirtualWithVarArgs(ts, obj, mid, ap);
+    va_end(ap);
+    return result.i;
   }
 
-  static jlong CallLongMethodV(JNIEnv* env,
-      jobject obj, jmethodID methodID, va_list args) {
+  static jint CallIntMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithVarArgs(ts, obj, mid, args).i;
   }
 
-  static jlong CallLongMethodA(JNIEnv* env,
-      jobject obj, jmethodID methodID, jvalue* args) {
+  static jint CallIntMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithJValues(ts, obj, mid, args).i;
   }
 
-  static jfloat CallFloatMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
+  static jlong CallLongMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    va_list ap;
+    va_start(ap, mid);
+    JValue result = InvokeVirtualWithVarArgs(ts, obj, mid, ap);
+    va_end(ap);
+    return result.j;
   }
 
-  static jfloat CallFloatMethodV(JNIEnv* env,
-      jobject obj, jmethodID methodID, va_list args) {
+  static jlong CallLongMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithVarArgs(ts, obj, mid, args).j;
   }
 
-  static jfloat CallFloatMethodA(JNIEnv* env,
-      jobject obj, jmethodID methodID, jvalue* args) {
+  static jlong CallLongMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithJValues(ts, obj, mid, args).j;
   }
 
-  static jdouble CallDoubleMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
+  static jshort CallShortMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    va_list ap;
+    va_start(ap, mid);
+    JValue result = InvokeVirtualWithVarArgs(ts, obj, mid, ap);
+    va_end(ap);
+    return result.s;
   }
 
-  static jdouble CallDoubleMethodV(JNIEnv* env,
-      jobject obj, jmethodID methodID, va_list args) {
+  static jshort CallShortMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithVarArgs(ts, obj, mid, args).s;
   }
 
-  static jdouble CallDoubleMethodA(JNIEnv* env,
-      jobject obj, jmethodID methodID, jvalue* args) {
+  static jshort CallShortMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
-    return 0;
+    return InvokeVirtualWithJValues(ts, obj, mid, args).s;
   }
 
-  static void CallVoidMethod(JNIEnv* env, jobject obj, jmethodID methodID, ...) {
+  static void CallVoidMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
+    va_list ap;
+    va_start(ap, mid);
+    JValue result = InvokeVirtualWithVarArgs(ts, obj, mid, ap);
+    va_end(ap);
   }
 
-  static void CallVoidMethodV(JNIEnv* env, jobject obj,
-      jmethodID methodID, va_list args) {
+  static void CallVoidMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
+    InvokeVirtualWithVarArgs(ts, obj, mid, args);
   }
 
-  static void CallVoidMethodA(JNIEnv* env, jobject obj,
-      jmethodID methodID, jvalue*  args) {
+  static void CallVoidMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(FATAL);
+    InvokeVirtualWithJValues(ts, obj, mid, args);
   }
 
   static jobject CallNonvirtualObjectMethod(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, ...) {
+      jobject obj, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, obj, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, obj, mid, ap);
     jobject local_result = AddLocalReference<jobject>(ts, result.l);
     va_end(ap);
     return local_result;
   }
 
   static jobject CallNonvirtualObjectMethodV(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, va_list args) {
+      jobject obj, jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    JValue result = InvokeWithVarArgs(ts, obj, methodID, args);
+    JValue result = InvokeWithVarArgs(ts, obj, mid, args);
     return AddLocalReference<jobject>(ts, result.l);
   }
 
   static jobject CallNonvirtualObjectMethodA(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, jvalue*  args) {
+      jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    JValue result = InvokeWithJValues(ts, obj, methodID, args);
+    JValue result = InvokeWithJValues(ts, obj, mid, args);
     return AddLocalReference<jobject>(ts, result.l);
   }
 
   static jboolean CallNonvirtualBooleanMethod(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, ...) {
+      jobject obj, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, obj, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, obj, mid, ap);
     va_end(ap);
     return result.z;
   }
 
   static jboolean CallNonvirtualBooleanMethodV(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, va_list args) {
+      jobject obj, jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, methodID, args).z;
+    return InvokeWithVarArgs(ts, obj, mid, args).z;
   }
 
   static jboolean CallNonvirtualBooleanMethodA(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, jvalue*  args) {
+      jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, methodID, args).z;
+    return InvokeWithJValues(ts, obj, mid, args).z;
   }
 
   static jbyte CallNonvirtualByteMethod(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, ...) {
+      jobject obj, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, obj, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, obj, mid, ap);
     va_end(ap);
     return result.b;
   }
 
   static jbyte CallNonvirtualByteMethodV(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, va_list args) {
+      jobject obj, jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, methodID, args).b;
+    return InvokeWithVarArgs(ts, obj, mid, args).b;
   }
 
   static jbyte CallNonvirtualByteMethodA(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
+      jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, methodID, args).b;
+    return InvokeWithJValues(ts, obj, mid, args).b;
   }
 
   static jchar CallNonvirtualCharMethod(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, ...) {
+      jobject obj, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, obj, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, obj, mid, ap);
     va_end(ap);
     return result.c;
   }
 
   static jchar CallNonvirtualCharMethodV(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, va_list args) {
+      jobject obj, jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, methodID, args).c;
+    return InvokeWithVarArgs(ts, obj, mid, args).c;
   }
 
   static jchar CallNonvirtualCharMethodA(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
+      jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, methodID, args).c;
+    return InvokeWithJValues(ts, obj, mid, args).c;
   }
 
   static jshort CallNonvirtualShortMethod(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, ...) {
+      jobject obj, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, obj, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, obj, mid, ap);
     va_end(ap);
     return result.s;
   }
 
   static jshort CallNonvirtualShortMethodV(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, va_list args) {
+      jobject obj, jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, methodID, args).s;
+    return InvokeWithVarArgs(ts, obj, mid, args).s;
   }
 
   static jshort CallNonvirtualShortMethodA(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
+      jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, methodID, args).s;
+    return InvokeWithJValues(ts, obj, mid, args).s;
   }
 
   static jint CallNonvirtualIntMethod(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, ...) {
+      jobject obj, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, obj, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, obj, mid, ap);
     va_end(ap);
     return result.i;
   }
 
   static jint CallNonvirtualIntMethodV(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, va_list args) {
+      jobject obj, jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, methodID, args).i;
+    return InvokeWithVarArgs(ts, obj, mid, args).i;
   }
 
   static jint CallNonvirtualIntMethodA(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
+      jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, methodID, args).i;
+    return InvokeWithJValues(ts, obj, mid, args).i;
   }
 
   static jlong CallNonvirtualLongMethod(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, ...) {
+      jobject obj, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, obj, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, obj, mid, ap);
     va_end(ap);
     return result.j;
   }
 
   static jlong CallNonvirtualLongMethodV(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, va_list args) {
+      jobject obj, jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, methodID, args).j;
+    return InvokeWithVarArgs(ts, obj, mid, args).j;
   }
 
   static jlong CallNonvirtualLongMethodA(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
+      jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, methodID, args).j;
+    return InvokeWithJValues(ts, obj, mid, args).j;
   }
 
   static jfloat CallNonvirtualFloatMethod(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, ...) {
+      jobject obj, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, obj, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, obj, mid, ap);
     va_end(ap);
     return result.f;
   }
 
   static jfloat CallNonvirtualFloatMethodV(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, va_list args) {
+      jobject obj, jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, methodID, args).f;
+    return InvokeWithVarArgs(ts, obj, mid, args).f;
   }
 
   static jfloat CallNonvirtualFloatMethodA(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
+      jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, methodID, args).f;
+    return InvokeWithJValues(ts, obj, mid, args).f;
   }
 
   static jdouble CallNonvirtualDoubleMethod(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, ...) {
+      jobject obj, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, obj, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, obj, mid, ap);
     va_end(ap);
     return result.d;
   }
 
   static jdouble CallNonvirtualDoubleMethodV(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, va_list args) {
+      jobject obj, jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, methodID, args).d;
+    return InvokeWithVarArgs(ts, obj, mid, args).d;
   }
 
   static jdouble CallNonvirtualDoubleMethodA(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, jvalue* args) {
+      jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, methodID, args).d;
+    return InvokeWithJValues(ts, obj, mid, args).d;
   }
 
   static void CallNonvirtualVoidMethod(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, ...) {
+      jobject obj, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    InvokeWithVarArgs(ts, obj, methodID, ap);
+    va_start(ap, mid);
+    InvokeWithVarArgs(ts, obj, mid, ap);
     va_end(ap);
   }
 
   static void CallNonvirtualVoidMethodV(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, va_list args) {
+      jobject obj, jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    InvokeWithVarArgs(ts, obj, methodID, args);
+    InvokeWithVarArgs(ts, obj, mid, args);
   }
 
   static void CallNonvirtualVoidMethodA(JNIEnv* env,
-      jobject obj, jclass clazz, jmethodID methodID, jvalue*  args) {
+      jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    InvokeWithJValues(ts, obj, methodID, args);
+    InvokeWithJValues(ts, obj, mid, args);
   }
 
   static jfieldID GetFieldID(JNIEnv* env,
@@ -1482,217 +1512,217 @@
   }
 
   static jobject CallStaticObjectMethod(JNIEnv* env,
-      jclass clazz, jmethodID methodID, ...) {
+      jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, NULL, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, NULL, mid, ap);
     jobject local_result = AddLocalReference<jobject>(ts, result.l);
     va_end(ap);
     return local_result;
   }
 
   static jobject CallStaticObjectMethodV(JNIEnv* env,
-      jclass clazz, jmethodID methodID, va_list args) {
+      jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    JValue result = InvokeWithVarArgs(ts, NULL, methodID, args);
+    JValue result = InvokeWithVarArgs(ts, NULL, mid, args);
     return AddLocalReference<jobject>(ts, result.l);
   }
 
   static jobject CallStaticObjectMethodA(JNIEnv* env,
-      jclass clazz, jmethodID methodID, jvalue* args) {
+      jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    JValue result = InvokeWithJValues(ts, NULL, methodID, args);
+    JValue result = InvokeWithJValues(ts, NULL, mid, args);
     return AddLocalReference<jobject>(ts, result.l);
   }
 
   static jboolean CallStaticBooleanMethod(JNIEnv* env,
-      jclass clazz, jmethodID methodID, ...) {
+      jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, NULL, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, NULL, mid, ap);
     va_end(ap);
     return result.z;
   }
 
   static jboolean CallStaticBooleanMethodV(JNIEnv* env,
-      jclass clazz, jmethodID methodID, va_list args) {
+      jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, methodID, args).z;
+    return InvokeWithVarArgs(ts, NULL, mid, args).z;
   }
 
   static jboolean CallStaticBooleanMethodA(JNIEnv* env,
-      jclass clazz, jmethodID methodID, jvalue* args) {
+      jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, methodID, args).z;
+    return InvokeWithJValues(ts, NULL, mid, args).z;
   }
 
-  static jbyte CallStaticByteMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
+  static jbyte CallStaticByteMethod(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, NULL, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, NULL, mid, ap);
     va_end(ap);
     return result.b;
   }
 
   static jbyte CallStaticByteMethodV(JNIEnv* env,
-      jclass clazz, jmethodID methodID, va_list args) {
+      jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, methodID, args).b;
+    return InvokeWithVarArgs(ts, NULL, mid, args).b;
   }
 
   static jbyte CallStaticByteMethodA(JNIEnv* env,
-      jclass clazz, jmethodID methodID, jvalue* args) {
+      jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, methodID, args).b;
+    return InvokeWithJValues(ts, NULL, mid, args).b;
   }
 
-  static jchar CallStaticCharMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
+  static jchar CallStaticCharMethod(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, NULL, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, NULL, mid, ap);
     va_end(ap);
     return result.c;
   }
 
   static jchar CallStaticCharMethodV(JNIEnv* env,
-      jclass clazz, jmethodID methodID, va_list args) {
+      jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, methodID, args).c;
+    return InvokeWithVarArgs(ts, NULL, mid, args).c;
   }
 
   static jchar CallStaticCharMethodA(JNIEnv* env,
-      jclass clazz, jmethodID methodID, jvalue* args) {
+      jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, methodID, args).c;
+    return InvokeWithJValues(ts, NULL, mid, args).c;
   }
 
-  static jshort CallStaticShortMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
+  static jshort CallStaticShortMethod(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, NULL, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, NULL, mid, ap);
     va_end(ap);
     return result.s;
   }
 
   static jshort CallStaticShortMethodV(JNIEnv* env,
-      jclass clazz, jmethodID methodID, va_list args) {
+      jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, methodID, args).s;
+    return InvokeWithVarArgs(ts, NULL, mid, args).s;
   }
 
   static jshort CallStaticShortMethodA(JNIEnv* env,
-      jclass clazz, jmethodID methodID, jvalue* args) {
+      jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, methodID, args).s;
+    return InvokeWithJValues(ts, NULL, mid, args).s;
   }
 
-  static jint CallStaticIntMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
+  static jint CallStaticIntMethod(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, NULL, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, NULL, mid, ap);
     va_end(ap);
     return result.i;
   }
 
   static jint CallStaticIntMethodV(JNIEnv* env,
-      jclass clazz, jmethodID methodID, va_list args) {
+      jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, methodID, args).i;
+    return InvokeWithVarArgs(ts, NULL, mid, args).i;
   }
 
   static jint CallStaticIntMethodA(JNIEnv* env,
-      jclass clazz, jmethodID methodID, jvalue* args) {
+      jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, methodID, args).i;
+    return InvokeWithJValues(ts, NULL, mid, args).i;
   }
 
-  static jlong CallStaticLongMethod(JNIEnv* env, jclass clazz, jmethodID methodID, ...) {
+  static jlong CallStaticLongMethod(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, NULL, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, NULL, mid, ap);
     va_end(ap);
     return result.j;
   }
 
   static jlong CallStaticLongMethodV(JNIEnv* env,
-      jclass clazz, jmethodID methodID, va_list args) {
+      jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, methodID, args).j;
+    return InvokeWithVarArgs(ts, NULL, mid, args).j;
   }
 
   static jlong CallStaticLongMethodA(JNIEnv* env,
-      jclass clazz, jmethodID methodID, jvalue* args) {
+      jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, methodID, args).j;
+    return InvokeWithJValues(ts, NULL, mid, args).j;
   }
 
-  static jfloat CallStaticFloatMethod(JNIEnv* env, jclass cls, jmethodID methodID, ...) {
+  static jfloat CallStaticFloatMethod(JNIEnv* env, jclass cls, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, NULL, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, NULL, mid, ap);
     va_end(ap);
     return result.f;
   }
 
   static jfloat CallStaticFloatMethodV(JNIEnv* env,
-      jclass clazz, jmethodID methodID, va_list args) {
+      jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, methodID, args).f;
+    return InvokeWithVarArgs(ts, NULL, mid, args).f;
   }
 
   static jfloat CallStaticFloatMethodA(JNIEnv* env,
-      jclass clazz, jmethodID methodID, jvalue* args) {
+      jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, methodID, args).f;
+    return InvokeWithJValues(ts, NULL, mid, args).f;
   }
 
-  static jdouble CallStaticDoubleMethod(JNIEnv* env, jclass cls, jmethodID methodID, ...) {
+  static jdouble CallStaticDoubleMethod(JNIEnv* env, jclass cls, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    JValue result = InvokeWithVarArgs(ts, NULL, methodID, ap);
+    va_start(ap, mid);
+    JValue result = InvokeWithVarArgs(ts, NULL, mid, ap);
     va_end(ap);
     return result.d;
   }
 
   static jdouble CallStaticDoubleMethodV(JNIEnv* env,
-      jclass clazz, jmethodID methodID, va_list args) {
+      jclass clazz, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, methodID, args).d;
+    return InvokeWithVarArgs(ts, NULL, mid, args).d;
   }
 
   static jdouble CallStaticDoubleMethodA(JNIEnv* env,
-      jclass clazz, jmethodID methodID, jvalue* args) {
+      jclass clazz, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, methodID, args).d;
+    return InvokeWithJValues(ts, NULL, mid, args).d;
   }
 
-  static void CallStaticVoidMethod(JNIEnv* env, jclass cls, jmethodID methodID, ...) {
+  static void CallStaticVoidMethod(JNIEnv* env, jclass cls, jmethodID mid, ...) {
     ScopedJniThreadState ts(env);
     va_list ap;
-    va_start(ap, methodID);
-    InvokeWithVarArgs(ts, NULL, methodID, ap);
+    va_start(ap, mid);
+    InvokeWithVarArgs(ts, NULL, mid, ap);
     va_end(ap);
   }
 
   static void CallStaticVoidMethodV(JNIEnv* env,
-      jclass cls, jmethodID methodID, va_list args) {
+      jclass cls, jmethodID mid, va_list args) {
     ScopedJniThreadState ts(env);
-    InvokeWithVarArgs(ts, NULL, methodID, args);
+    InvokeWithVarArgs(ts, NULL, mid, args);
   }
 
   static void CallStaticVoidMethodA(JNIEnv* env,
-      jclass cls, jmethodID methodID, jvalue* args) {
+      jclass cls, jmethodID mid, jvalue* args) {
     ScopedJniThreadState ts(env);
-    InvokeWithJValues(ts, NULL, methodID, args);
+    InvokeWithJValues(ts, NULL, mid, args);
   }
 
   static jstring NewString(JNIEnv* env, const jchar* chars, jsize char_count) {
@@ -2091,16 +2121,16 @@
     return JNI_OK;
   }
 
-  static jint MonitorEnter(JNIEnv* env, jobject obj) {
+  static jint MonitorEnter(JNIEnv* env, jobject java_object) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(WARNING);
-    return 0;
+    Decode<Object*>(ts, java_object)->MonitorEnter();
+    return ts.Self()->IsExceptionPending() ? JNI_ERR : JNI_OK;
   }
 
-  static jint MonitorExit(JNIEnv* env, jobject obj) {
+  static jint MonitorExit(JNIEnv* env, jobject java_object) {
     ScopedJniThreadState ts(env);
-    UNIMPLEMENTED(WARNING);
-    return 0;
+    Decode<Object*>(ts, java_object)->MonitorEnter();
+    return ts.Self()->IsExceptionPending() ? JNI_ERR : JNI_OK;
   }
 
   static jint GetJavaVM(JNIEnv* env, JavaVM** vm) {
diff --git a/src/object.h b/src/object.h
index 3c7ec49..bdba37f 100644
--- a/src/object.h
+++ b/src/object.h
@@ -498,6 +498,10 @@
     return pc;
   }
 
+  size_t GetVtableIndex() const {
+    return method_index_;
+  }
+
  public:  // TODO: private
   // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
   // the class we are a part of
@@ -1105,6 +1109,10 @@
     virtual_methods_->Set(i, f);
   }
 
+  Method* GetMethodByVtableIndex(size_t vtable_index) {
+    return vtable_->Get(vtable_index);
+  }
+
   Method* FindDeclaredVirtualMethod(const StringPiece& name,
                                     const StringPiece& descriptor);