OSDN Git Service

2002-03-15 Eric Blake <ebb9@email.byu.edu>
[pf3gnuchains/gcc-fork.git] / libjava / jni.cc
index 6190f4f..1abd2d2 100644 (file)
@@ -1,6 +1,6 @@
 // jni.cc - JNI implementation, including the jump table.
 
-/* Copyright (C) 1998, 1999, 2000, 2001  Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2002  Free Software Foundation
 
    This file is part of libgcj.
 
@@ -13,9 +13,6 @@ details.  */
 #include <stddef.h>
 #include <string.h>
 
-// Define this before including jni.h.
-#define __GCJ_JNI_IMPL__
-
 #include <gcj/cni.h>
 #include <jvm.h>
 #include <java-assert.h>
@@ -29,7 +26,7 @@ details.  */
 #include <java/lang/Throwable.h>
 #include <java/lang/ArrayIndexOutOfBoundsException.h>
 #include <java/lang/StringIndexOutOfBoundsException.h>
-#include <java/lang/AbstractMethodError.h>
+#include <java/lang/UnsatisfiedLinkError.h>
 #include <java/lang/InstantiationException.h>
 #include <java/lang/NoSuchFieldError.h>
 #include <java/lang/NoSuchMethodError.h>
@@ -37,23 +34,18 @@ details.  */
 #include <java/lang/reflect/Method.h>
 #include <java/lang/reflect/Modifier.h>
 #include <java/lang/OutOfMemoryError.h>
-#include <java/util/Hashtable.h>
+#include <java/util/IdentityHashMap.h>
 #include <java/lang/Integer.h>
 #include <java/lang/ThreadGroup.h>
-#include <gnu/gcj/jni/NativeThread.h>
+#include <java/lang/Thread.h>
 
 #include <gcj/method.h>
 #include <gcj/field.h>
 
 #include <java-interp.h>
+#include <java-threads.h>
 
-// FIXME: remove these defines.
-#define ClassClass java::lang::Class::class$
-#define ObjectClass java::lang::Object::class$
-#define ThrowableClass java::lang::Throwable::class$
-#define MethodClass java::lang::reflect::Method::class$
-#define ThreadGroupClass java::lang::ThreadGroup::class$
-#define NativeThreadClass gnu::gcj::jni::NativeThread::class$
+using namespace gcj;
 
 // This enum is used to select different template instantiations in
 // the invocation code.
@@ -97,8 +89,10 @@ struct _Jv_JNI_LocalFrame
   jobject vec[0];
 };
 
-// This holds a reference count for all local and global references.
-static java::util::Hashtable *ref_table;
+// This holds a reference count for all local references.
+static java::util::IdentityHashMap *local_ref_table;
+// This holds a reference count for all global references.
+static java::util::IdentityHashMap *global_ref_table;
 
 // The only VM.
 static JavaVM *the_vm;
@@ -115,19 +109,19 @@ jvmpiEnableEvent (jint event_type, void *)
     case JVMPI_EVENT_OBJECT_ALLOC:
       _Jv_JVMPI_Notify_OBJECT_ALLOC = _Jv_JVMPI_Interface.NotifyEvent;
       break;
-      
+
     case JVMPI_EVENT_THREAD_START:
       _Jv_JVMPI_Notify_THREAD_START = _Jv_JVMPI_Interface.NotifyEvent;
       break;
-      
+
     case JVMPI_EVENT_THREAD_END:
       _Jv_JVMPI_Notify_THREAD_END = _Jv_JVMPI_Interface.NotifyEvent;
       break;
-      
+
     default:
       return JVMPI_NOT_AVAILABLE;
     }
-  
+
   return JVMPI_SUCCESS;
 }
 
@@ -139,11 +133,11 @@ jvmpiDisableEvent (jint event_type, void *)
     case JVMPI_EVENT_OBJECT_ALLOC:
       _Jv_JVMPI_Notify_OBJECT_ALLOC = NULL;
       break;
-      
+
     default:
       return JVMPI_NOT_AVAILABLE;
     }
-  
+
   return JVMPI_SUCCESS;
 }
 #endif
@@ -153,8 +147,9 @@ jvmpiDisableEvent (jint event_type, void *)
 void
 _Jv_JNI_Init (void)
 {
-  ref_table = new java::util::Hashtable;
-  
+  local_ref_table = new java::util::IdentityHashMap;
+  global_ref_table = new java::util::IdentityHashMap;
+
 #ifdef ENABLE_JVMPI
   _Jv_JVMPI_Interface.version = 1;
   _Jv_JVMPI_Interface.EnableEvent = &jvmpiEnableEvent;
@@ -167,7 +162,7 @@ _Jv_JNI_Init (void)
 
 // Tell the GC that a certain pointer is live.
 static void
-mark_for_gc (jobject obj)
+mark_for_gc (jobject obj, java::util::IdentityHashMap *ref_table)
 {
   JvSynchronize sync (ref_table);
 
@@ -180,7 +175,7 @@ mark_for_gc (jobject obj)
 
 // Unmark a pointer.
 static void
-unmark_for_gc (jobject obj)
+unmark_for_gc (jobject obj, java::util::IdentityHashMap *ref_table)
 {
   JvSynchronize sync (ref_table);
 
@@ -188,6 +183,7 @@ unmark_for_gc (jobject obj)
   Integer *refcount = (Integer *) ref_table->get (obj);
   JvAssert (refcount);
   jint val = refcount->intValue () - 1;
+  JvAssert (val >= 0);
   if (val == 0)
     ref_table->remove (obj);
   else
@@ -195,19 +191,46 @@ unmark_for_gc (jobject obj)
     ref_table->put (obj, new Integer (val));
 }
 
+// "Unwrap" some random non-reference type.  This exists to simplify
+// other template functions.
+template<typename T>
+static T
+unwrap (T val)
+{
+  return val;
+}
+
+// Unwrap a weak reference, if required.
+template<typename T>
+static T *
+unwrap (T *obj)
+{
+  using namespace gnu::gcj::runtime;
+  // We can compare the class directly because JNIWeakRef is `final'.
+  // Doing it this way is much faster.
+  if (obj == NULL || obj->getClass () != &JNIWeakRef::class$)
+    return obj;
+  JNIWeakRef *wr = reinterpret_cast<JNIWeakRef *> (obj);
+  return reinterpret_cast<T *> (wr->get ());
+}
+
 \f
 
 static jobject
 _Jv_JNI_NewGlobalRef (JNIEnv *, jobject obj)
 {
-  mark_for_gc (obj);
+  // This seems weird but I think it is correct.
+  obj = unwrap (obj);
+  mark_for_gc (obj, global_ref_table);
   return obj;
 }
 
 static void
 _Jv_JNI_DeleteGlobalRef (JNIEnv *, jobject obj)
 {
-  unmark_for_gc (obj);
+  // This seems weird but I think it is correct.
+  obj = unwrap (obj);
+  unmark_for_gc (obj, global_ref_table);
 }
 
 static void
@@ -215,14 +238,17 @@ _Jv_JNI_DeleteLocalRef (JNIEnv *env, jobject obj)
 {
   _Jv_JNI_LocalFrame *frame;
 
+  // This seems weird but I think it is correct.
+  obj = unwrap (obj);
+
   for (frame = env->locals; frame != NULL; frame = frame->next)
     {
-      for (int i = 0; i < FRAME_SIZE; ++i)
+      for (int i = 0; i < frame->size; ++i)
        {
          if (frame->vec[i] == obj)
            {
              frame->vec[i] = NULL;
-             unmark_for_gc (obj);
+             unmark_for_gc (obj, local_ref_table);
              return;
            }
        }
@@ -278,19 +304,29 @@ _Jv_JNI_PushLocalFrame (JNIEnv *env, jint size)
 static jobject
 _Jv_JNI_NewLocalRef (JNIEnv *env, jobject obj)
 {
+  // This seems weird but I think it is correct.
+  obj = unwrap (obj);
+
   // Try to find an open slot somewhere in the topmost frame.
   _Jv_JNI_LocalFrame *frame = env->locals;
   bool done = false, set = false;
-  while (frame != NULL && ! done)
+  for (; frame != NULL && ! done; frame = frame->next)
     {
       for (int i = 0; i < frame->size; ++i)
-       if (frame->vec[i] == NULL)
-         {
-           set = true;
-           done = true;
-           frame->vec[i] = obj;
-           break;
-         }
+       {
+         if (frame->vec[i] == NULL)
+           {
+             set = true;
+             done = true;
+             frame->vec[i] = obj;
+             break;
+           }
+       }
+
+      // If we found a slot, or if the frame we just searched is the
+      // mark frame, then we are done.
+      if (done || frame == NULL || frame->marker != MARK_NONE)
+       break;
     }
 
   if (! set)
@@ -302,7 +338,7 @@ _Jv_JNI_NewLocalRef (JNIEnv *env, jobject obj)
       env->locals->vec[0] = obj;
     }
 
-  mark_for_gc (obj);
+  mark_for_gc (obj, local_ref_table);
   return obj;
 }
 
@@ -313,10 +349,10 @@ _Jv_JNI_PopLocalFrame (JNIEnv *env, jobject result, int stop)
 
   bool done = false;
   while (rf != NULL && ! done)
-    {  
+    {
       for (int i = 0; i < rf->size; ++i)
        if (rf->vec[i] != NULL)
-         unmark_for_gc (rf->vec[i]);
+         unmark_for_gc (rf->vec[i], local_ref_table);
 
       // If the frame we just freed is the marker frame, we are done.
       done = (rf->marker == stop);
@@ -392,11 +428,13 @@ _Jv_JNI_GetVersion (JNIEnv *)
 }
 
 static jclass
-_Jv_JNI_DefineClass (JNIEnv *env, jobject loader, 
+_Jv_JNI_DefineClass (JNIEnv *env, jobject loader,
                     const jbyte *buf, jsize bufLen)
 {
   try
     {
+      loader = unwrap (loader);
+
       jbyteArray bytes = JvNewByteArray (bufLen);
 
       jbyte *elts = elements (bytes);
@@ -454,20 +492,21 @@ _Jv_JNI_FindClass (JNIEnv *env, const char *name)
 static jclass
 _Jv_JNI_GetSuperclass (JNIEnv *env, jclass clazz)
 {
-  return (jclass) wrap_value (env, clazz->getSuperclass ());
+  return (jclass) wrap_value (env, unwrap (clazz)->getSuperclass ());
 }
 
 static jboolean
 _Jv_JNI_IsAssignableFrom(JNIEnv *, jclass clazz1, jclass clazz2)
 {
-  return clazz1->isAssignableFrom (clazz2);
+  return unwrap (clazz1)->isAssignableFrom (unwrap (clazz2));
 }
 
 static jint
 _Jv_JNI_Throw (JNIEnv *env, jthrowable obj)
 {
   // We check in case the user did some funky cast.
-  JvAssert (obj != NULL && (&ThrowableClass)->isInstance (obj));
+  obj = unwrap (obj);
+  JvAssert (obj != NULL && java::lang::Throwable::class$.isInstance (obj));
   env->ex = obj;
   return 0;
 }
@@ -477,13 +516,15 @@ _Jv_JNI_ThrowNew (JNIEnv *env, jclass clazz, const char *message)
 {
   using namespace java::lang::reflect;
 
-  JvAssert ((&ThrowableClass)->isAssignableFrom (clazz));
+  clazz = unwrap (clazz);
+  JvAssert (java::lang::Throwable::class$.isAssignableFrom (clazz));
 
   int r = JNI_OK;
   try
     {
       JArray<jclass> *argtypes
-       = (JArray<jclass> *) JvNewObjectArray (1, &ClassClass, NULL);
+       = (JArray<jclass> *) JvNewObjectArray (1, &java::lang::Class::class$,
+                                              NULL);
 
       jclass *elts = elements (argtypes);
       elts[0] = &StringClass;
@@ -543,7 +584,7 @@ _Jv_JNI_FatalError (JNIEnv *, const char *message)
 static jboolean
 _Jv_JNI_IsSameObject (JNIEnv *, jobject obj1, jobject obj2)
 {
-  return obj1 == obj2;
+  return unwrap (obj1) == unwrap (obj2);
 }
 
 static jobject
@@ -554,6 +595,7 @@ _Jv_JNI_AllocObject (JNIEnv *env, jclass clazz)
 
   try
     {
+      clazz = unwrap (clazz);
       JvAssert (clazz && ! clazz->isArray ());
       if (clazz->isInterface() || Modifier::isAbstract(clazz->getModifiers()))
        env->ex = new java::lang::InstantiationException ();
@@ -574,6 +616,7 @@ _Jv_JNI_AllocObject (JNIEnv *env, jclass clazz)
 static jclass
 _Jv_JNI_GetObjectClass (JNIEnv *env, jobject obj)
 {
+  obj = unwrap (obj);
   JvAssert (obj);
   return (jclass) wrap_value (env, obj->getClass());
 }
@@ -581,7 +624,7 @@ _Jv_JNI_GetObjectClass (JNIEnv *env, jobject obj)
 static jboolean
 _Jv_JNI_IsInstanceOf (JNIEnv *, jobject obj, jclass clazz)
 {
-  return clazz->isInstance(obj);
+  return unwrap (clazz)->isInstance(unwrap (obj));
 }
 
 \f
@@ -597,6 +640,7 @@ _Jv_JNI_GetAnyMethodID (JNIEnv *env, jclass clazz,
 {
   try
     {
+      clazz = unwrap (clazz);
       _Jv_InitClass (clazz);
 
       _Jv_Utf8Const *name_u = _Jv_makeUtf8Const ((char *) name, -1);
@@ -651,9 +695,9 @@ array_from_valist (jvalue *values, JArray<jclass> *arg_types, va_list vargs)
   for (int i = 0; i < arg_types->length; ++i)
     {
       if (arg_elts[i] == JvPrimClass (byte))
-       values[i].b = va_arg (vargs, jbyte);
+       values[i].b = (jbyte) va_arg (vargs, int);
       else if (arg_elts[i] == JvPrimClass (short))
-       values[i].s = va_arg (vargs, jshort);
+       values[i].s = (jshort) va_arg (vargs, int);
       else if (arg_elts[i] == JvPrimClass (int))
        values[i].i = va_arg (vargs, jint);
       else if (arg_elts[i] == JvPrimClass (long))
@@ -663,13 +707,13 @@ array_from_valist (jvalue *values, JArray<jclass> *arg_types, va_list vargs)
       else if (arg_elts[i] == JvPrimClass (double))
        values[i].d = va_arg (vargs, jdouble);
       else if (arg_elts[i] == JvPrimClass (boolean))
-       values[i].z = va_arg (vargs, jboolean);
+       values[i].z = (jboolean) va_arg (vargs, int);
       else if (arg_elts[i] == JvPrimClass (char))
-       values[i].c = va_arg (vargs, jchar);
+       values[i].c = (jchar) va_arg (vargs, int);
       else
        {
          // An object.
-         values[i].l = va_arg (vargs, jobject);
+         values[i].l = unwrap (va_arg (vargs, jobject));
        }
     }
 }
@@ -681,6 +725,9 @@ static T
 _Jv_JNI_CallAnyMethodV (JNIEnv *env, jobject obj, jclass klass,
                        jmethodID id, va_list vargs)
 {
+  obj = unwrap (obj);
+  klass = unwrap (klass);
+
   if (style == normal)
     id = _Jv_LookupDeclaredMethod (obj->getClass (), id->name, id->signature);
 
@@ -741,6 +788,9 @@ static T
 _Jv_JNI_CallAnyMethodA (JNIEnv *env, jobject obj, jclass klass,
                        jmethodID id, jvalue *args)
 {
+  obj = unwrap (obj);
+  klass = unwrap (klass);
+
   if (style == normal)
     id = _Jv_LookupDeclaredMethod (obj->getClass (), id->name, id->signature);
 
@@ -758,10 +808,21 @@ _Jv_JNI_CallAnyMethodA (JNIEnv *env, jobject obj, jclass klass,
       if (style == constructor)
        return_type = klass;
 
+      // Unwrap arguments as required.  Eww.
+      jclass *type_elts = elements (arg_types);
+      jvalue arg_copy[arg_types->length];
+      for (int i = 0; i < arg_types->length; ++i)
+       {
+         if (type_elts[i]->isPrimitive ())
+           arg_copy[i] = args[i];
+         else
+           arg_copy[i].l = unwrap (args[i].l);
+       }
+
       jvalue result;
       jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
                                          style == constructor,
-                                         arg_types, args, &result);
+                                         arg_types, arg_copy, &result);
 
       if (ex != NULL)
        env->ex = ex;
@@ -782,6 +843,9 @@ static void
 _Jv_JNI_CallAnyVoidMethodV (JNIEnv *env, jobject obj, jclass klass,
                            jmethodID id, va_list vargs)
 {
+  obj = unwrap (obj);
+  klass = unwrap (klass);
+
   if (style == normal)
     id = _Jv_LookupDeclaredMethod (obj->getClass (), id->name, id->signature);
 
@@ -845,6 +909,17 @@ _Jv_JNI_CallAnyVoidMethodA (JNIEnv *env, jobject obj, jclass klass,
       _Jv_GetTypesFromSignature (id, decl_class,
                                 &arg_types, &return_type);
 
+      // Unwrap arguments as required.  Eww.
+      jclass *type_elts = elements (arg_types);
+      jvalue arg_copy[arg_types->length];
+      for (int i = 0; i < arg_types->length; ++i)
+       {
+         if (type_elts[i]->isPrimitive ())
+           arg_copy[i] = args[i];
+         else
+           arg_copy[i].l = unwrap (args[i].l);
+       }
+
       jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
                                          style == constructor,
                                          arg_types, args, NULL);
@@ -922,7 +997,7 @@ _Jv_JNI_CallStaticMethodV (JNIEnv *env, jclass klass,
                           jmethodID id, va_list args)
 {
   JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC));
-  JvAssert ((&ClassClass)->isInstance (klass));
+  JvAssert (java::lang::Class::class$.isInstance (unwrap (klass)));
 
   return _Jv_JNI_CallAnyMethodV<T, static_type> (env, NULL, klass, id, args);
 }
@@ -937,7 +1012,7 @@ _Jv_JNI_CallStaticMethod (JNIEnv *env, jclass klass, jmethodID id, ...)
   T result;
 
   JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC));
-  JvAssert ((&ClassClass)->isInstance (klass));
+  JvAssert (java::lang::Class::class$.isInstance (unwrap (klass)));
 
   va_start (args, id);
   result = _Jv_JNI_CallAnyMethodV<T, static_type> (env, NULL, klass,
@@ -955,7 +1030,7 @@ _Jv_JNI_CallStaticMethodA (JNIEnv *env, jclass klass, jmethodID id,
                           jvalue *args)
 {
   JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC));
-  JvAssert ((&ClassClass)->isInstance (klass));
+  JvAssert (java::lang::Class::class$.isInstance (unwrap (klass)));
 
   return _Jv_JNI_CallAnyMethodA<T, static_type> (env, NULL, klass, id, args);
 }
@@ -1039,8 +1114,9 @@ _Jv_JNI_NewObjectA (JNIEnv *env, jclass klass, jmethodID id,
 
 template<typename T>
 static T
-_Jv_JNI_GetField (JNIEnv *env, jobject obj, jfieldID field) 
+_Jv_JNI_GetField (JNIEnv *env, jobject obj, jfieldID field)
 {
+  obj = unwrap (obj);
   JvAssert (obj);
   T *ptr = (T *) ((char *) obj + field->getOffset ());
   return wrap_value (env, *ptr);
@@ -1050,6 +1126,9 @@ template<typename T>
 static void
 _Jv_JNI_SetField (JNIEnv *, jobject obj, jfieldID field, T value)
 {
+  obj = unwrap (obj);
+  value = unwrap (value);
+
   JvAssert (obj);
   T *ptr = (T *) ((char *) obj + field->getOffset ());
   *ptr = value;
@@ -1062,6 +1141,8 @@ _Jv_JNI_GetAnyFieldID (JNIEnv *env, jclass clazz,
 {
   try
     {
+      clazz = unwrap (clazz);
+
       _Jv_InitClass (clazz);
 
       _Jv_Utf8Const *a_name = _Jv_makeUtf8Const ((char *) name, -1);
@@ -1126,6 +1207,7 @@ template<typename T>
 static void
 _Jv_JNI_SetStaticField (JNIEnv *, jclass, jfieldID field, T value)
 {
+  value = unwrap (value);
   T *ptr = (T *) field->u.addr;
   *ptr = value;
 }
@@ -1148,14 +1230,15 @@ _Jv_JNI_NewString (JNIEnv *env, const jchar *unichars, jsize len)
 static jsize
 _Jv_JNI_GetStringLength (JNIEnv *, jstring string)
 {
-  return string->length();
+  return unwrap (string)->length();
 }
 
 static const jchar *
 _Jv_JNI_GetStringChars (JNIEnv *, jstring string, jboolean *isCopy)
 {
+  string = unwrap (string);
   jchar *result = _Jv_GetStringChars (string);
-  mark_for_gc (string);
+  mark_for_gc (string, global_ref_table);
   if (isCopy)
     *isCopy = false;
   return (const jchar *) result;
@@ -1164,7 +1247,7 @@ _Jv_JNI_GetStringChars (JNIEnv *, jstring string, jboolean *isCopy)
 static void
 _Jv_JNI_ReleaseStringChars (JNIEnv *, jstring string, const jchar *)
 {
-  unmark_for_gc (string);
+  unmark_for_gc (unwrap (string), global_ref_table);
 }
 
 static jstring
@@ -1185,12 +1268,13 @@ _Jv_JNI_NewStringUTF (JNIEnv *env, const char *bytes)
 static jsize
 _Jv_JNI_GetStringUTFLength (JNIEnv *, jstring string)
 {
-  return JvGetStringUTFLength (string);
+  return JvGetStringUTFLength (unwrap (string));
 }
 
 static const char *
 _Jv_JNI_GetStringUTFChars (JNIEnv *env, jstring string, jboolean *isCopy)
 {
+  string = unwrap (string);
   jsize len = JvGetStringUTFLength (string);
   try
     {
@@ -1220,6 +1304,7 @@ static void
 _Jv_JNI_GetStringRegion (JNIEnv *env, jstring string, jsize start, jsize len,
                         jchar *buf)
 {
+  string = unwrap (string);
   jchar *result = _Jv_GetStringChars (string);
   if (start < 0 || start > string->length ()
       || len < 0 || start + len > string->length ())
@@ -1241,6 +1326,8 @@ static void
 _Jv_JNI_GetStringUTFRegion (JNIEnv *env, jstring str, jsize start,
                            jsize len, char *buf)
 {
+  str = unwrap (str);
+    
   if (start < 0 || start > str->length ()
       || len < 0 || start + len > str->length ())
     {
@@ -1260,7 +1347,7 @@ _Jv_JNI_GetStringUTFRegion (JNIEnv *env, jstring str, jsize start,
 static const jchar *
 _Jv_JNI_GetStringCritical (JNIEnv *, jstring str, jboolean *isCopy)
 {
-  jchar *result = _Jv_GetStringChars (str);
+  jchar *result = _Jv_GetStringChars (unwrap (str));
   if (isCopy)
     *isCopy = false;
   return result;
@@ -1275,7 +1362,7 @@ _Jv_JNI_ReleaseStringCritical (JNIEnv *, jstring, const jchar *)
 static jsize
 _Jv_JNI_GetArrayLength (JNIEnv *, jarray array)
 {
-  return array->length;
+  return unwrap (array)->length;
 }
 
 static jarray
@@ -1284,6 +1371,9 @@ _Jv_JNI_NewObjectArray (JNIEnv *env, jsize length, jclass elementClass,
 {
   try
     {
+      elementClass = unwrap (elementClass);
+      init = unwrap (init);
+
       jarray result = JvNewObjectArray (length, elementClass, init);
       return (jarray) wrap_value (env, result);
     }
@@ -1297,7 +1387,7 @@ _Jv_JNI_NewObjectArray (JNIEnv *env, jsize length, jclass elementClass,
 static jobject
 _Jv_JNI_GetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index)
 {
-  jobject *elts = elements (array);
+  jobject *elts = elements (unwrap (array));
   return wrap_value (env, elts[index]);
 }
 
@@ -1307,6 +1397,9 @@ _Jv_JNI_SetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index,
 {
   try
     {
+      array = unwrap (array);
+      value = unwrap (value);
+
       _Jv_CheckArrayStore (array, value);
       jobject *elts = elements (array);
       elts[index] = value;
@@ -1337,13 +1430,14 @@ static T *
 _Jv_JNI_GetPrimitiveArrayElements (JNIEnv *, JArray<T> *array,
                                   jboolean *isCopy)
 {
+  array = unwrap (array);
   T *elts = elements (array);
   if (isCopy)
     {
       // We elect never to copy.
       *isCopy = false;
     }
-  mark_for_gc (array);
+  mark_for_gc (array, global_ref_table);
   return elts;
 }
 
@@ -1352,10 +1446,11 @@ static void
 _Jv_JNI_ReleasePrimitiveArrayElements (JNIEnv *, JArray<T> *array,
                                       T *, jint /* mode */)
 {
+  array = unwrap (array);
   // Note that we ignore MODE.  We can do this because we never copy
   // the array elements.  My reading of the JNI documentation is that
   // this is an option for the implementor.
-  unmark_for_gc (array);
+  unmark_for_gc (array, global_ref_table);
 }
 
 template<typename T>
@@ -1364,7 +1459,11 @@ _Jv_JNI_GetPrimitiveArrayRegion (JNIEnv *env, JArray<T> *array,
                                 jsize start, jsize len,
                                 T *buf)
 {
-  if (start < 0 || len >= array->length || start + len >= array->length)
+  array = unwrap (array);
+
+  // The cast to unsigned lets us save a comparison.
+  if (start < 0 || len < 0
+      || (unsigned long) (start + len) > (unsigned long) array->length)
     {
       try
        {
@@ -1386,10 +1485,14 @@ _Jv_JNI_GetPrimitiveArrayRegion (JNIEnv *env, JArray<T> *array,
 
 template<typename T>
 static void
-_Jv_JNI_SetPrimitiveArrayRegion (JNIEnv *env, JArray<T> *array, 
+_Jv_JNI_SetPrimitiveArrayRegion (JNIEnv *env, JArray<T> *array,
                                 jsize start, jsize len, T *buf)
 {
-  if (start < 0 || len >= array->length || start + len >= array->length)
+  array = unwrap (array);
+
+  // The cast to unsigned lets us save a comparison.
+  if (start < 0 || len < 0
+      || (unsigned long) (start + len) > (unsigned long) array->length)
     {
       try
        {
@@ -1412,6 +1515,7 @@ static void *
 _Jv_JNI_GetPrimitiveArrayCritical (JNIEnv *, jarray array,
                                   jboolean *isCopy)
 {
+  array = unwrap (array);
   // FIXME: does this work?
   jclass klass = array->getClass()->getComponentType();
   JvAssert (klass->isPrimitive ());
@@ -1432,7 +1536,8 @@ _Jv_JNI_MonitorEnter (JNIEnv *env, jobject obj)
 {
   try
     {
-      return _Jv_MonitorEnter (obj);
+      _Jv_MonitorEnter (unwrap (obj));
+      return 0;
     }
   catch (jthrowable t)
     {
@@ -1446,7 +1551,8 @@ _Jv_JNI_MonitorExit (JNIEnv *env, jobject obj)
 {
   try
     {
-      return _Jv_MonitorExit (obj);
+      _Jv_MonitorExit (unwrap (obj));
+      return 0;
     }
   catch (jthrowable t)
     {
@@ -1462,6 +1568,7 @@ _Jv_JNI_ToReflectedField (JNIEnv *env, jclass cls, jfieldID fieldID,
 {
   try
     {
+      cls = unwrap (cls);
       java::lang::reflect::Field *field = new java::lang::reflect::Field();
       field->declaringClass = cls;
       field->offset = (char*) fieldID - (char *) cls->fields;
@@ -1481,6 +1588,7 @@ _Jv_JNI_FromReflectedField (JNIEnv *, jobject f)
 {
   using namespace java::lang::reflect;
 
+  f = unwrap (f);
   Field *field = reinterpret_cast<Field *> (f);
   return _Jv_FromReflectedField (field);
 }
@@ -1491,10 +1599,8 @@ _Jv_JNI_ToReflectedMethod (JNIEnv *env, jclass klass, jmethodID id,
 {
   using namespace java::lang::reflect;
 
-  // FIXME.
-  static _Jv_Utf8Const *init_name = _Jv_makeUtf8Const ("<init>", 6);
-
   jobject result = NULL;
+  klass = unwrap (klass);
 
   try
     {
@@ -1526,25 +1632,169 @@ static jmethodID
 _Jv_JNI_FromReflectedMethod (JNIEnv *, jobject method)
 {
   using namespace java::lang::reflect;
-  if ((&MethodClass)->isInstance (method))
+  method = unwrap (method);
+  if (Method::class$.isInstance (method))
     return _Jv_FromReflectedMethod (reinterpret_cast<Method *> (method));
   return
     _Jv_FromReflectedConstructor (reinterpret_cast<Constructor *> (method));
 }
 
+// JDK 1.2.
+jweak
+_Jv_JNI_NewWeakGlobalRef (JNIEnv *env, jobject obj)
+{
+  using namespace gnu::gcj::runtime;
+  JNIWeakRef *ref = NULL;
+
+  try
+    {
+      // This seems weird but I think it is correct.
+      obj = unwrap (obj);
+      ref = new JNIWeakRef (obj);
+      mark_for_gc (ref, global_ref_table);
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+    }
+
+  return reinterpret_cast<jweak> (ref);
+}
+
+void
+_Jv_JNI_DeleteWeakGlobalRef (JNIEnv *, jweak obj)
+{
+  using namespace gnu::gcj::runtime;
+  JNIWeakRef *ref = reinterpret_cast<JNIWeakRef *> (obj);
+  unmark_for_gc (ref, global_ref_table);
+  ref->clear ();
+}
+
+\f
+
+// Hash table of native methods.
+static JNINativeMethod *nathash;
+// Number of slots used.
+static int nathash_count = 0;
+// Number of slots available.  Must be power of 2.
+static int nathash_size = 0;
+
+#define DELETED_ENTRY ((char *) (~0))
+
+// Compute a hash value for a native method descriptor.
+static int
+hash (const JNINativeMethod *method)
+{
+  char *ptr;
+  int hash = 0;
+
+  ptr = method->name;
+  while (*ptr)
+    hash = (31 * hash) + *ptr++;
+
+  ptr = method->signature;
+  while (*ptr)
+    hash = (31 * hash) + *ptr++;
+
+  return hash;
+}
+
+// Find the slot where a native method goes.
+static JNINativeMethod *
+nathash_find_slot (const JNINativeMethod *method)
+{
+  jint h = hash (method);
+  int step = (h ^ (h >> 16)) | 1;
+  int w = h & (nathash_size - 1);
+  int del = -1;
+
+  for (;;)
+    {
+      JNINativeMethod *slotp = &nathash[w];
+      if (slotp->name == NULL)
+       {
+         if (del >= 0)
+           return &nathash[del];
+         else
+           return slotp;
+       }
+      else if (slotp->name == DELETED_ENTRY)
+       del = w;
+      else if (! strcmp (slotp->name, method->name)
+              && ! strcmp (slotp->signature, method->signature))
+       return slotp;
+      w = (w + step) & (nathash_size - 1);
+    }
+}
+
+// Find a method.  Return NULL if it isn't in the hash table.
+static void *
+nathash_find (JNINativeMethod *method)
+{
+  if (nathash == NULL)
+    return NULL;
+  JNINativeMethod *slot = nathash_find_slot (method);
+  if (slot->name == NULL || slot->name == DELETED_ENTRY)
+    return NULL;
+  return slot->fnPtr;
+}
+
+static void
+natrehash ()
+{
+  if (nathash == NULL)
+    {
+      nathash_size = 1024;
+      nathash =
+       (JNINativeMethod *) _Jv_AllocBytes (nathash_size
+                                           * sizeof (JNINativeMethod));
+      memset (nathash, 0, nathash_size * sizeof (JNINativeMethod));
+    }
+  else
+    {
+      int savesize = nathash_size;
+      JNINativeMethod *savehash = nathash;
+      nathash_size *= 2;
+      nathash =
+       (JNINativeMethod *) _Jv_AllocBytes (nathash_size
+                                           * sizeof (JNINativeMethod));
+      memset (nathash, 0, nathash_size * sizeof (JNINativeMethod));
+
+      for (int i = 0; i < savesize; ++i)
+       {
+         if (savehash[i].name != NULL && savehash[i].name != DELETED_ENTRY)
+           {
+             JNINativeMethod *slot = nathash_find_slot (&savehash[i]);
+             *slot = savehash[i];
+           }
+       }
+    }
+}
+
+static void
+nathash_add (const JNINativeMethod *method)
+{
+  if (3 * nathash_count >= 2 * nathash_size)
+    natrehash ();
+  JNINativeMethod *slot = nathash_find_slot (method);
+  // If the slot has a real entry in it, then there is no work to do.
+  if (slot->name != NULL && slot->name != DELETED_ENTRY)
+    return;
+  // FIXME
+  slot->name = strdup (method->name);
+  slot->signature = strdup (method->signature);
+  slot->fnPtr = method->fnPtr;
+}
+
 static jint
-_Jv_JNI_RegisterNatives (JNIEnv *env, jclass k,
+_Jv_JNI_RegisterNatives (JNIEnv *env, jclass klass,
                         const JNINativeMethod *methods,
                         jint nMethods)
 {
-#ifdef INTERPRETER
-  // For now, this only matters for interpreted methods.  FIXME.
-  if (! _Jv_IsInterpretedClass (k))
-    {
-      // FIXME: throw exception.
-      return JNI_ERR;
-    }
-  _Jv_InterpClass *klass = reinterpret_cast<_Jv_InterpClass *> (k);
+  // Synchronize while we do the work.  This must match
+  // synchronization in some other functions that manipulate or use
+  // the nathash table.
+  JvSynchronize sync (global_ref_table);
 
   // Look at each descriptor given us, and find the corresponding
   // method in the class.
@@ -1552,11 +1802,10 @@ _Jv_JNI_RegisterNatives (JNIEnv *env, jclass k,
     {
       bool found = false;
 
-      _Jv_MethodBase **imeths = _Jv_GetFirstMethod (klass);
+      _Jv_Method *imeths = JvGetFirstMethod (klass);
       for (int i = 0; i < JvNumMethods (klass); ++i)
        {
-         _Jv_MethodBase *meth = imeths[i];
-         _Jv_Method *self = meth->get_method ();
+         _Jv_Method *self = &imeths[i];
 
          if (! strcmp (self->name->data, methods[j].name)
              && ! strcmp (self->signature->data, methods[j].signature))
@@ -1566,9 +1815,9 @@ _Jv_JNI_RegisterNatives (JNIEnv *env, jclass k,
                break;
 
              // Found a match that is native.
-             _Jv_JNIMethod *jmeth = reinterpret_cast<_Jv_JNIMethod *> (meth);
-             jmeth->set_function (methods[i].fnPtr);
              found = true;
+             nathash_add (&methods[j]);
+
              break;
            }
        }
@@ -1589,14 +1838,12 @@ _Jv_JNI_RegisterNatives (JNIEnv *env, jclass k,
     }
 
   return JNI_OK;
-#else /* INTERPRETER */
-  return JNI_ERR;
-#endif /* INTERPRETER */
 }
 
 static jint
 _Jv_JNI_UnregisterNatives (JNIEnv *, jclass)
 {
+  // FIXME -- we could implement this.
   return JNI_ERR;
 }
 
@@ -1740,6 +1987,22 @@ _Jv_LookupJNIMethod (jclass klass, _Jv_Utf8Const *name,
   int long_start;
   void *function;
 
+  // Synchronize on something convenient.  Right now we use the hash.
+  JvSynchronize sync (global_ref_table);
+
+  // First see if we have an override in the hash table.
+  strncpy (buf, name->data, name->length);
+  buf[name->length] = '\0';
+  strncpy (buf + name->length + 1, signature->data, signature->length);
+  buf[name->length + signature->length + 1] = '\0';
+  JNINativeMethod meth;
+  meth.name = buf;
+  meth.signature = buf + name->length + 1;
+  function = nathash_find (&meth);
+  if (function != NULL)
+    return function;
+
+  // If there was no override, then look in the symbol table.
   mangled_name (klass, name, signature, buf, &long_start);
   char c = buf[long_start];
   buf[long_start] = '\0';
@@ -1751,7 +2014,7 @@ _Jv_LookupJNIMethod (jclass klass, _Jv_Utf8Const *name,
       if (function == NULL)
        {
          jstring str = JvNewStringUTF (name->data);
-         throw new java::lang::AbstractMethodError (str);
+         throw new java::lang::UnsatisfiedLinkError (str);
        }
     }
 
@@ -1776,10 +2039,16 @@ _Jv_JNIMethod::call (ffi_cif *, void *ret, ffi_raw *args, void *__this)
   // We cache the value that we find, of course, but if we don't find
   // a value we don't cache that fact -- we might subsequently load a
   // library which finds the function in question.
-  if (_this->function == NULL)
-    _this->function = _Jv_LookupJNIMethod (_this->defining_class,
-                                          _this->self->name,
-                                          _this->self->signature);
+  {
+    // Synchronize on a convenient object to ensure sanity in case two
+    // threads reach this point for the same function at the same
+    // time.
+    JvSynchronize sync (global_ref_table);
+    if (_this->function == NULL)
+      _this->function = _Jv_LookupJNIMethod (_this->defining_class,
+                                            _this->self->name,
+                                            _this->self->signature);
+  }
 
   JvAssert (_this->args_raw_size % sizeof (ffi_raw) == 0);
   ffi_raw real_args[2 + _this->args_raw_size / sizeof (ffi_raw)];
@@ -1793,6 +2062,17 @@ _Jv_JNIMethod::call (ffi_cif *, void *ret, ffi_raw *args, void *__this)
   if ((_this->self->accflags & java::lang::reflect::Modifier::STATIC))
     real_args[offset++].ptr = _this->defining_class;
 
+  // In libgcj, the callee synchronizes.
+  jobject sync = NULL;
+  if ((_this->self->accflags & java::lang::reflect::Modifier::SYNCHRONIZED))
+    {
+      if ((_this->self->accflags & java::lang::reflect::Modifier::STATIC))
+       sync = _this->defining_class;
+      else
+       sync = (jobject) args[0].ptr;
+      _Jv_MonitorEnter (sync);
+    }
+
   // Copy over passed-in arguments.
   memcpy (&real_args[offset], args, _this->args_raw_size);
 
@@ -1800,6 +2080,9 @@ _Jv_JNIMethod::call (ffi_cif *, void *ret, ffi_raw *args, void *__this)
   ffi_raw_call (&_this->jni_cif, (void (*)()) _this->function,
                ret, real_args);
 
+  if (sync != NULL)
+    _Jv_MonitorExit (sync);
+
   _Jv_JNI_PopSystemFrame (env);
 }
 
@@ -1825,7 +2108,7 @@ _Jv_JNI_AttachCurrentThread (JavaVM *, jstring name, void **penv, void *args)
          && attach->version != JNI_VERSION_1_1)
        return JNI_EVERSION;
 
-      JvAssert ((&ThreadGroupClass)->isInstance (attach->group));
+      JvAssert (java::lang::ThreadGroup::class$.isInstance (attach->group));
       group = reinterpret_cast<java::lang::ThreadGroup *> (attach->group);
     }
 
@@ -1848,6 +2131,14 @@ _Jv_JNI_AttachCurrentThread (JavaVM *, jstring name, void **penv, void *args)
       _Jv_Free (env);
       return JNI_ERR;
     }
+
+  env->locals->marker = MARK_SYSTEM;
+  env->locals->size = FRAME_SIZE;
+  env->locals->next = NULL;
+
+  for (int i = 0; i < env->locals->size; ++i)
+    env->locals->vec[i] = NULL;
+
   *penv = reinterpret_cast<void *> (env);
 
   // This thread might already be a Java thread -- this function might
@@ -1856,7 +2147,7 @@ _Jv_JNI_AttachCurrentThread (JavaVM *, jstring name, void **penv, void *args)
     {
       try
        {
-         (void) new gnu::gcj::jni::NativeThread (group, name);
+         _Jv_AttachCurrentThread (name, group);
        }
       catch (jthrowable t)
        {
@@ -1910,28 +2201,11 @@ _Jv_JNI_DestroyJavaVM (JavaVM *vm)
   return JNI_ERR;
 }
 
-static jint
+jint
 _Jv_JNI_DetachCurrentThread (JavaVM *)
 {
-  java::lang::Thread *t = _Jv_ThreadCurrent ();
-  if (t == NULL)
-    return JNI_EDETACHED;
-
-  // FIXME: we only allow threads attached via AttachCurrentThread to
-  // be detached.  I have no idea how we could implement detaching
-  // other threads, given the requirement that we must release all the
-  // monitors.  That just seems evil.
-  JvAssert ((&NativeThreadClass)->isInstance (t));
-
-  // FIXME: release the monitors.  We'll take this to mean all
-  // monitors acquired via the JNI interface.  This means we have to
-  // keep track of them.
-
-  gnu::gcj::jni::NativeThread *nt
-    = reinterpret_cast<gnu::gcj::jni::NativeThread *> (t);
-  nt->finish ();
-
-  return 0;
+  jint code = _Jv_DetachCurrentThread ();
+  return code  ? JNI_EDETACHED : 0;
 }
 
 static jint
@@ -1984,6 +2258,9 @@ jint
 JNI_CreateJavaVM (JavaVM **vm, void **penv, void *args)
 {
   JvAssert (! the_vm);
+
+  _Jv_CreateJavaVM (NULL);
+
   // FIXME: synchronize
   JavaVM *nvm = (JavaVM *) _Jv_MallocUnchecked (sizeof (JavaVM));
   if (nvm == NULL)
@@ -2038,6 +2315,7 @@ JNI_CreateJavaVM (JavaVM **vm, void **penv, void *args)
 
   the_vm = nvm;
   *vm = the_vm;
+
   return 0;
 }
 
@@ -2090,7 +2368,6 @@ _Jv_JNI_GetJavaVM (JNIEnv *, JavaVM **vm)
 
 \f
 
-#define NOT_IMPL NULL
 #define RESERVED NULL
 
 struct JNINativeInterface _Jv_JNIFunctions =
@@ -2334,8 +2611,8 @@ struct JNINativeInterface _Jv_JNIFunctions =
   _Jv_JNI_GetStringCritical,               // GetStringCritical
   _Jv_JNI_ReleaseStringCritical,           // ReleaseStringCritical
 
-  NOT_IMPL /* newweakglobalref */,
-  NOT_IMPL /* deleteweakglobalref */,
+  _Jv_JNI_NewWeakGlobalRef,                // NewWeakGlobalRef
+  _Jv_JNI_DeleteWeakGlobalRef,             // DeleteWeakGlobalRef
 
   _Jv_JNI_ExceptionCheck
 };