+2006-10-18 Tom Tromey <tromey@redhat.com>
+ Bryce McKinlay <mckinlay@redhat.com>
+
+ * testsuite/libjava.jni/register2.java: New file.
+ * testsuite/libjava.jni/register2.out: New file.
+ * testsuite/libjava.jni/register2.c: New file.
+ * java/lang/natClass.cc (_Jv_GetClassNameUtf8): New function.
+ * java/lang/Class.h (_Jv_GetClassNameUtf8): Declare.
+ * jni.cc (struct NativeMethodCacheEntry): New struct.
+ (nathash): Changed type.
+ (hash): Updated.
+ (nathash_find_slot): Likewise.
+ (nathash_find): Likewise.
+ (natrehash): Likewise.
+ (nathash_add): Likewise.
+ (_Jv_JNI_RegisterNatives): Likewise.
+ (_Jv_LookupJNIMethod): Likewise.
+ Idea from Juerg Lehni <juerg@scratchdisk.com>
+
2006-10-16 Geoffrey Keating <geoffk@apple.com>
* testsuite/libjava.jvmti/natevents.cc (env): Delete.
\f
+struct NativeMethodCacheEntry : public JNINativeMethod
+{
+ char *className;
+};
+
// Hash table of native methods.
-static JNINativeMethod *nathash;
+static NativeMethodCacheEntry *nathash;
// Number of slots used.
static int nathash_count = 0;
// Number of slots available. Must be power of 2.
// Compute a hash value for a native method descriptor.
static int
-hash (const JNINativeMethod *method)
+hash (const NativeMethodCacheEntry *method)
{
char *ptr;
int hash = 0;
+ ptr = method->className;
+ while (*ptr)
+ hash = (31 * hash) + *ptr++;
+
ptr = method->name;
while (*ptr)
hash = (31 * hash) + *ptr++;
}
// Find the slot where a native method goes.
-static JNINativeMethod *
-nathash_find_slot (const JNINativeMethod *method)
+static NativeMethodCacheEntry *
+nathash_find_slot (const NativeMethodCacheEntry *method)
{
jint h = hash (method);
int step = (h ^ (h >> 16)) | 1;
for (;;)
{
- JNINativeMethod *slotp = &nathash[w];
+ NativeMethodCacheEntry *slotp = &nathash[w];
if (slotp->name == NULL)
{
if (del >= 0)
else if (slotp->name == DELETED_ENTRY)
del = w;
else if (! strcmp (slotp->name, method->name)
- && ! strcmp (slotp->signature, method->signature))
+ && ! strcmp (slotp->signature, method->signature)
+ && ! strcmp (slotp->className, method->className))
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)
+nathash_find (NativeMethodCacheEntry *method)
{
if (nathash == NULL)
return NULL;
- JNINativeMethod *slot = nathash_find_slot (method);
+ NativeMethodCacheEntry *slot = nathash_find_slot (method);
if (slot->name == NULL || slot->name == DELETED_ENTRY)
return NULL;
return slot->fnPtr;
{
nathash_size = 1024;
nathash =
- (JNINativeMethod *) _Jv_AllocBytes (nathash_size
- * sizeof (JNINativeMethod));
+ (NativeMethodCacheEntry *) _Jv_AllocBytes (nathash_size
+ * sizeof (NativeMethodCacheEntry));
}
else
{
int savesize = nathash_size;
- JNINativeMethod *savehash = nathash;
+ NativeMethodCacheEntry *savehash = nathash;
nathash_size *= 2;
nathash =
- (JNINativeMethod *) _Jv_AllocBytes (nathash_size
- * sizeof (JNINativeMethod));
+ (NativeMethodCacheEntry *) _Jv_AllocBytes (nathash_size
+ * sizeof (NativeMethodCacheEntry));
for (int i = 0; i < savesize; ++i)
{
if (savehash[i].name != NULL && savehash[i].name != DELETED_ENTRY)
{
- JNINativeMethod *slot = nathash_find_slot (&savehash[i]);
+ NativeMethodCacheEntry *slot = nathash_find_slot (&savehash[i]);
*slot = savehash[i];
}
}
}
static void
-nathash_add (const JNINativeMethod *method)
+nathash_add (const NativeMethodCacheEntry *method)
{
if (3 * nathash_count >= 2 * nathash_size)
natrehash ();
- JNINativeMethod *slot = nathash_find_slot (method);
+ NativeMethodCacheEntry *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
+ // FIXME: memory leak?
slot->name = strdup (method->name);
+ slot->className = strdup (method->className);
// This was already strduped in _Jv_JNI_RegisterNatives.
slot->signature = method->signature;
slot->fnPtr = method->fnPtr;
// the nathash table.
JvSynchronize sync (global_ref_table);
- JNINativeMethod dottedMethod;
+ NativeMethodCacheEntry dottedMethod;
// Look at each descriptor given us, and find the corresponding
// method in the class.
// Copy this JNINativeMethod and do a slash to dot
// conversion on the signature.
dottedMethod.name = methods[j].name;
+ // FIXME: we leak a little memory here if the method
+ // is not found.
dottedMethod.signature = strdup (methods[j].signature);
dottedMethod.fnPtr = methods[j].fnPtr;
+ dottedMethod.className = _Jv_GetClassNameUtf8 (klass)->chars();
char *c = dottedMethod.signature;
while (*c)
{
buf[name_length] = '\0';
strncpy (buf + name_length + 1, signature->chars (), sig_length);
buf[name_length + sig_length + 1] = '\0';
- JNINativeMethod meth;
+ NativeMethodCacheEntry meth;
meth.name = buf;
meth.signature = buf + name_length + 1;
+ meth.className = _Jv_GetClassNameUtf8(klass)->chars();
function = nathash_find (&meth);
if (function != NULL)
return function;
--- /dev/null
+#include <stdlib.h>
+#include <assert.h>
+#include <register2.h>
+
+static int
+twentythree (JNIEnv *env, jclass k)
+{
+ return 23;
+}
+
+static int
+oneninetyseven (JNIEnv *env, jclass k)
+{
+ return 197;
+}
+
+JNIEXPORT jint JNICALL
+JNI_OnLoad (JavaVM *vm, void *nothing)
+{
+ JNIEnv *env;
+ JNINativeMethod meth;
+ jclass k;
+ jint r;
+
+ r = (*vm)->GetEnv (vm, (void **) &env, JNI_VERSION_1_2);
+ assert (r == JNI_OK);
+ k = (*env)->FindClass (env, "register2$I1");
+ assert (k != NULL);
+
+ meth.name = "doit";
+ meth.signature = "()I";
+ meth.fnPtr = twentythree;
+
+ r = (*env)->RegisterNatives (env, k, &meth, 1);
+ assert (r == JNI_OK);
+
+ k = (*env)->FindClass (env, "register2$I2");
+ assert (k != NULL);
+
+ meth.name = "doit";
+ meth.signature = "()I";
+ meth.fnPtr = oneninetyseven;
+
+ r = (*env)->RegisterNatives (env, k, &meth, 1);
+ assert (r == JNI_OK);
+
+ return JNI_VERSION_1_2;
+}
OSDN Git Service
