libjava/jni.cc

   1 // jni.cc - JNI implementation, including the jump table.
   2
   3 /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   4    Free Software Foundation
   5
   6    This file is part of libgcj.
   7
   8 This software is copyrighted work licensed under the terms of the
   9 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
  10 details.  */
  11
  12 #include <config.h>
  13
  14 #include <stdio.h>
  15 #include <stddef.h>
  16 #include <string.h>
  17
  18 #include <gcj/cni.h>
  19 #include <jvm.h>
  20 #include <java-assert.h>
  21 #include <jni.h>
  22 #ifdef ENABLE_JVMPI
  23 #include <jvmpi.h>
  24 #endif
  25 #ifdef INTERPRETER
  26 #include <jvmti.h>
  27 #include "jvmti-int.h"
  28 #endif
  29 #include <java/lang/Class.h>
  30 #include <java/lang/ClassLoader.h>
  31 #include <java/lang/Throwable.h>
  32 #include <java/lang/ArrayIndexOutOfBoundsException.h>
  33 #include <java/lang/StringIndexOutOfBoundsException.h>
  34 #include <java/lang/StringBuffer.h>
  35 #include <java/lang/UnsatisfiedLinkError.h>
  36 #include <java/lang/InstantiationException.h>
  37 #include <java/lang/NoSuchFieldError.h>
  38 #include <java/lang/NoSuchMethodError.h>
  39 #include <java/lang/reflect/Constructor.h>
  40 #include <java/lang/reflect/Method.h>
  41 #include <java/lang/reflect/Modifier.h>
  42 #include <java/lang/OutOfMemoryError.h>
  43 #include <java/lang/Integer.h>
  44 #include <java/lang/ThreadGroup.h>
  45 #include <java/lang/Thread.h>
  46 #include <java/lang/IllegalAccessError.h>
  47 #include <java/nio/Buffer.h>
  48 #include <java/nio/DirectByteBufferImpl.h>
  49 #include <java/nio/DirectByteBufferImpl$ReadWrite.h>
  50 #include <java/util/IdentityHashMap.h>
  51 #include <gnu/gcj/RawData.h>
  52 #include <java/lang/ClassNotFoundException.h>
  53
  54 #include <gcj/method.h>
  55 #include <gcj/field.h>
  56
  57 #include <java-interp.h>
  58 #include <java-threads.h>
  59
  60 using namespace gcj;
  61
  62 // This enum is used to select different template instantiations in
  63 // the invocation code.
  64 enum invocation_type
  65 {
  66   normal,
  67   nonvirtual,
  68   static_type,
  69   constructor
  70 };
  71
  72 // Forward declarations.
  73 extern struct JNINativeInterface_ _Jv_JNIFunctions;
  74 extern struct JNIInvokeInterface_ _Jv_JNI_InvokeFunctions;
  75
  76 // Number of slots in the default frame.  The VM must allow at least
  77 // 16.
  78 #define FRAME_SIZE 16
  79
  80 // Mark value indicating this is an overflow frame.
  81 #define MARK_NONE    0
  82 // Mark value indicating this is a user frame.
  83 #define MARK_USER    1
  84 // Mark value indicating this is a system frame.
  85 #define MARK_SYSTEM  2
  86
  87 // This structure is used to keep track of local references.
  88 struct _Jv_JNI_LocalFrame
  89 {
  90   // This is one of the MARK_ constants.
  91   unsigned char marker;
  92
  93   // Flag to indicate some locals were allocated.
  94   bool allocated_p;
  95
  96   // Number of elements in frame.
  97   int size;
  98
  99   // The class loader of the JNI method that allocated this frame.
 100   ::java::lang::ClassLoader *loader;
 101
 102   // Next frame in chain.
 103   _Jv_JNI_LocalFrame *next;
 104
 105   // The elements.  These are allocated using the C "struct hack".
 106   jobject vec[0];
 107 };
 108
 109 // This holds a reference count for all local references.
 110 static java::util::IdentityHashMap *local_ref_table;
 111 // This holds a reference count for all global references.
 112 static java::util::IdentityHashMap *global_ref_table;
 113
 114 // The only VM.
 115 JavaVM *_Jv_the_vm;
 116
 117 #ifdef ENABLE_JVMPI
 118 // The only JVMPI interface description.
 119 static JVMPI_Interface _Jv_JVMPI_Interface;
 120
 121 static jint
 122 jvmpiEnableEvent (jint event_type, void *)
 123 {
 124   switch (event_type)
 125     {
 126     case JVMPI_EVENT_OBJECT_ALLOC:
 127       _Jv_JVMPI_Notify_OBJECT_ALLOC = _Jv_JVMPI_Interface.NotifyEvent;
 128       break;
 129
 130     case JVMPI_EVENT_THREAD_START:
 131       _Jv_JVMPI_Notify_THREAD_START = _Jv_JVMPI_Interface.NotifyEvent;
 132       break;
 133
 134     case JVMPI_EVENT_THREAD_END:
 135       _Jv_JVMPI_Notify_THREAD_END = _Jv_JVMPI_Interface.NotifyEvent;
 136       break;
 137
 138     default:
 139       return JVMPI_NOT_AVAILABLE;
 140     }
 141
 142   return JVMPI_SUCCESS;
 143 }
 144
 145 static jint
 146 jvmpiDisableEvent (jint event_type, void *)
 147 {
 148   switch (event_type)
 149     {
 150     case JVMPI_EVENT_OBJECT_ALLOC:
 151       _Jv_JVMPI_Notify_OBJECT_ALLOC = NULL;
 152       break;
 153
 154     default:
 155       return JVMPI_NOT_AVAILABLE;
 156     }
 157
 158   return JVMPI_SUCCESS;
 159 }
 160 #endif
 161
 162 \f
 163
 164 void
 165 _Jv_JNI_Init (void)
 166 {
 167   local_ref_table = new java::util::IdentityHashMap;
 168   global_ref_table = new java::util::IdentityHashMap;
 169
 170 #ifdef ENABLE_JVMPI
 171   _Jv_JVMPI_Interface.version = 1;
 172   _Jv_JVMPI_Interface.EnableEvent = &jvmpiEnableEvent;
 173   _Jv_JVMPI_Interface.DisableEvent = &jvmpiDisableEvent;
 174   _Jv_JVMPI_Interface.EnableGC = &_Jv_EnableGC;
 175   _Jv_JVMPI_Interface.DisableGC = &_Jv_DisableGC;
 176   _Jv_JVMPI_Interface.RunGC = &_Jv_RunGC;
 177 #endif
 178 }
 179
 180 // Tell the GC that a certain pointer is live.
 181 static void
 182 mark_for_gc (jobject obj, java::util::IdentityHashMap *ref_table)
 183 {
 184   JvSynchronize sync (ref_table);
 185
 186   using namespace java::lang;
 187   Integer *refcount = (Integer *) ref_table->get (obj);
 188   jint val = (refcount == NULL) ? 0 : refcount->intValue ();
 189   // FIXME: what about out of memory error?
 190   ref_table->put (obj, new Integer (val + 1));
 191 }
 192
 193 // Unmark a pointer.
 194 static void
 195 unmark_for_gc (jobject obj, java::util::IdentityHashMap *ref_table)
 196 {
 197   JvSynchronize sync (ref_table);
 198
 199   using namespace java::lang;
 200   Integer *refcount = (Integer *) ref_table->get (obj);
 201   JvAssert (refcount);
 202   jint val = refcount->intValue () - 1;
 203   JvAssert (val >= 0);
 204   if (val == 0)
 205     ref_table->remove (obj);
 206   else
 207     // FIXME: what about out of memory error?
 208     ref_table->put (obj, new Integer (val));
 209 }
 210
 211 // "Unwrap" some random non-reference type.  This exists to simplify
 212 // other template functions.
 213 template<typename T>
 214 static T
 215 unwrap (T val)
 216 {
 217   return val;
 218 }
 219
 220 // Unwrap a weak reference, if required.
 221 template<typename T>
 222 static T *
 223 unwrap (T *obj)
 224 {
 225   using namespace gnu::gcj::runtime;
 226   // We can compare the class directly because JNIWeakRef is `final'.
 227   // Doing it this way is much faster.
 228   if (obj == NULL || obj->getClass () != &JNIWeakRef::class$)
 229     return obj;
 230   JNIWeakRef *wr = reinterpret_cast<JNIWeakRef *> (obj);
 231   return reinterpret_cast<T *> (wr->get ());
 232 }
 233
 234 jobject
 235 _Jv_UnwrapJNIweakReference (jobject obj)
 236 {
 237   return unwrap (obj);
 238 }
 239
 240 \f
 241
 242 static jobject JNICALL
 243 _Jv_JNI_NewGlobalRef (JNIEnv *, jobject obj)
 244 {
 245   // This seems weird but I think it is correct.
 246   obj = unwrap (obj);
 247   mark_for_gc (obj, global_ref_table);
 248   return obj;
 249 }
 250
 251 static void JNICALL
 252 _Jv_JNI_DeleteGlobalRef (JNIEnv *, jobject obj)
 253 {
 254   // This seems weird but I think it is correct.
 255   obj = unwrap (obj);
 256
 257   // NULL is ok here -- the JNI specification doesn't say so, but this
 258   // is a no-op.
 259   if (! obj)
 260     return;
 261
 262   unmark_for_gc (obj, global_ref_table);
 263 }
 264
 265 static void JNICALL
 266 _Jv_JNI_DeleteLocalRef (JNIEnv *env, jobject obj)
 267 {
 268   _Jv_JNI_LocalFrame *frame;
 269
 270   // This seems weird but I think it is correct.
 271   obj = unwrap (obj);
 272
 273   // NULL is ok here -- the JNI specification doesn't say so, but this
 274   // is a no-op.
 275   if (! obj)
 276     return;
 277
 278   for (frame = env->locals; frame != NULL; frame = frame->next)
 279     {
 280       for (int i = 0; i < frame->size; ++i)
 281         {
 282           if (frame->vec[i] == obj)
 283             {
 284               frame->vec[i] = NULL;
 285               unmark_for_gc (obj, local_ref_table);
 286               return;
 287             }
 288         }
 289
 290       // Don't go past a marked frame.
 291       JvAssert (frame->marker == MARK_NONE);
 292     }
 293
 294   JvAssert (0);
 295 }
 296
 297 static jint JNICALL
 298 _Jv_JNI_EnsureLocalCapacity (JNIEnv *env, jint size)
 299 {
 300   // It is easier to just always allocate a new frame of the requested
 301   // size.  This isn't the most efficient thing, but for now we don't
 302   // care.  Note that _Jv_JNI_PushLocalFrame relies on this right now.
 303
 304   _Jv_JNI_LocalFrame *frame;
 305   try
 306     {
 307       frame = (_Jv_JNI_LocalFrame *) _Jv_Malloc (sizeof (_Jv_JNI_LocalFrame)
 308                                                  + size * sizeof (jobject));
 309     }
 310   catch (jthrowable t)
 311     {
 312       env->ex = t;
 313       return JNI_ERR;
 314     }
 315
 316   frame->marker = MARK_NONE;
 317   frame->size = size;
 318   frame->allocated_p = false;
 319   memset (&frame->vec[0], 0, size * sizeof (jobject));
 320   frame->loader = env->locals->loader;
 321   frame->next = env->locals;
 322   env->locals = frame;
 323
 324   return 0;
 325 }
 326
 327 static jint JNICALL
 328 _Jv_JNI_PushLocalFrame (JNIEnv *env, jint size)
 329 {
 330   jint r = _Jv_JNI_EnsureLocalCapacity (env, size);
 331   if (r < 0)
 332     return r;
 333
 334   // The new frame is on top.
 335   env->locals->marker = MARK_USER;
 336
 337   return 0;
 338 }
 339
 340 static jobject JNICALL
 341 _Jv_JNI_NewLocalRef (JNIEnv *env, jobject obj)
 342 {
 343   // This seems weird but I think it is correct.
 344   obj = unwrap (obj);
 345
 346   // Try to find an open slot somewhere in the topmost frame.
 347   _Jv_JNI_LocalFrame *frame = env->locals;
 348   bool done = false, set = false;
 349   for (; frame != NULL && ! done; frame = frame->next)
 350     {
 351       for (int i = 0; i < frame->size; ++i)
 352         {
 353           if (frame->vec[i] == NULL)
 354             {
 355               set = true;
 356               done = true;
 357               frame->vec[i] = obj;
 358               frame->allocated_p = true;
 359               break;
 360             }
 361         }
 362
 363       // If we found a slot, or if the frame we just searched is the
 364       // mark frame, then we are done.
 365       if (done || frame == NULL || frame->marker != MARK_NONE)
 366         break;
 367     }
 368
 369   if (! set)
 370     {
 371       // No slots, so we allocate a new frame.  According to the spec
 372       // we could just die here.  FIXME: return value.
 373       _Jv_JNI_EnsureLocalCapacity (env, 16);
 374       // We know the first element of the new frame will be ok.
 375       env->locals->vec[0] = obj;
 376       env->locals->allocated_p = true;
 377     }
 378
 379   mark_for_gc (obj, local_ref_table);
 380   return obj;
 381 }
 382
 383 static jobject JNICALL
 384 _Jv_JNI_PopLocalFrame (JNIEnv *env, jobject result, int stop)
 385 {
 386   _Jv_JNI_LocalFrame *rf = env->locals;
 387
 388   bool done = false;
 389   while (rf != NULL && ! done)
 390     {
 391       for (int i = 0; i < rf->size; ++i)
 392         if (rf->vec[i] != NULL)
 393           unmark_for_gc (rf->vec[i], local_ref_table);
 394
 395       // If the frame we just freed is the marker frame, we are done.
 396       done = (rf->marker == stop);
 397
 398       _Jv_JNI_LocalFrame *n = rf->next;
 399       // When N==NULL, we've reached the reusable bottom_locals, and we must
 400       // not free it.  However, we must be sure to clear all its elements.
 401       if (n == NULL)
 402         {
 403           if (rf->allocated_p)
 404             memset (&rf->vec[0], 0, rf->size * sizeof (jobject));
 405           rf->allocated_p = false;
 406           rf = NULL;
 407           break;
 408         }
 409
 410       _Jv_Free (rf);
 411       rf = n;
 412     }
 413
 414   // Update the local frame information.
 415   env->locals = rf;
 416
 417   return result == NULL ? NULL : _Jv_JNI_NewLocalRef (env, result);
 418 }
 419
 420 static jobject JNICALL
 421 _Jv_JNI_PopLocalFrame (JNIEnv *env, jobject result)
 422 {
 423   return _Jv_JNI_PopLocalFrame (env, result, MARK_USER);
 424 }
 425
 426 // Make sure an array's type is compatible with the type of the
 427 // destination.
 428 template<typename T>
 429 static bool
 430 _Jv_JNI_check_types (JNIEnv *env, JArray<T> *array, jclass K)
 431 {
 432   jclass klass = array->getClass()->getComponentType();
 433   if (__builtin_expect (klass != K, false))
 434     {
 435       env->ex = new java::lang::IllegalAccessError ();
 436       return false;
 437     }
 438   else
 439     return true;
 440 }
 441
 442 // Pop a `system' frame from the stack.  This is `extern "C"' as it is
 443 // used by the compiler.
 444 extern "C" void
 445 _Jv_JNI_PopSystemFrame (JNIEnv *env)
 446 {
 447   // Only enter slow path when we're not at the bottom, or there have been
 448   // allocations. Usually this is false and we can just null out the locals
 449   // field.
 450
 451   if (__builtin_expect ((env->locals->next
 452                          || env->locals->allocated_p), false))
 453     _Jv_JNI_PopLocalFrame (env, NULL, MARK_SYSTEM);
 454   else
 455     env->locals = NULL;
 456
 457 #ifdef INTERPRETER
 458   if (__builtin_expect (env->ex != NULL, false))
 459     {
 460       jthrowable t = env->ex;
 461       env->ex = NULL;
 462       if (JVMTI_REQUESTED_EVENT (Exception))
 463         _Jv_ReportJVMTIExceptionThrow (t);
 464       throw t;
 465     }
 466 #endif
 467 }
 468
 469 template<typename T> T extract_from_jvalue(jvalue const & t);
 470 template<> jboolean extract_from_jvalue(jvalue const & jv) { return jv.z; }
 471 template<> jbyte    extract_from_jvalue(jvalue const & jv) { return jv.b; }
 472 template<> jchar    extract_from_jvalue(jvalue const & jv) { return jv.c; }
 473 template<> jshort   extract_from_jvalue(jvalue const & jv) { return jv.s; }
 474 template<> jint     extract_from_jvalue(jvalue const & jv) { return jv.i; }
 475 template<> jlong    extract_from_jvalue(jvalue const & jv) { return jv.j; }
 476 template<> jfloat   extract_from_jvalue(jvalue const & jv) { return jv.f; }
 477 template<> jdouble  extract_from_jvalue(jvalue const & jv) { return jv.d; }
 478 template<> jobject  extract_from_jvalue(jvalue const & jv) { return jv.l; }
 479
 480
 481 // This function is used from other template functions.  It wraps the
 482 // return value appropriately; we specialize it so that object returns
 483 // are turned into local references.
 484 template<typename T>
 485 static T
 486 wrap_value (JNIEnv *, T value)
 487 {
 488   return value;
 489 }
 490
 491 // This specialization is used for jobject, jclass, jstring, jarray,
 492 // etc.
 493 template<typename R, typename T>
 494 static T *
 495 wrap_value (JNIEnv *env, T *value)
 496 {
 497   return (value == NULL
 498           ? value
 499           : (T *) _Jv_JNI_NewLocalRef (env, (jobject) value));
 500 }
 501
 502 \f
 503
 504 static jint JNICALL
 505 _Jv_JNI_GetVersion (JNIEnv *)
 506 {
 507   return JNI_VERSION_1_4;
 508 }
 509
 510 static jclass JNICALL
 511 _Jv_JNI_DefineClass (JNIEnv *env, const char *name, jobject loader,
 512                      const jbyte *buf, jsize bufLen)
 513 {
 514   try
 515     {
 516       loader = unwrap (loader);
 517
 518       jstring sname = JvNewStringUTF (name);
 519       jbyteArray bytes = JvNewByteArray (bufLen);
 520
 521       jbyte *elts = elements (bytes);
 522       memcpy (elts, buf, bufLen * sizeof (jbyte));
 523
 524       java::lang::ClassLoader *l
 525         = reinterpret_cast<java::lang::ClassLoader *> (loader);
 526
 527       jclass result = l->defineClass (sname, bytes, 0, bufLen);
 528       return (jclass) wrap_value (env, result);
 529     }
 530   catch (jthrowable t)
 531     {
 532       env->ex = t;
 533       return NULL;
 534     }
 535 }
 536
 537 static jclass JNICALL
 538 _Jv_JNI_FindClass (JNIEnv *env, const char *name)
 539 {
 540   // FIXME: assume that NAME isn't too long.
 541   int len = strlen (name);
 542   char s[len + 1];
 543   for (int i = 0; i <= len; ++i)
 544     s[i] = (name[i] == '/') ? '.' : name[i];
 545
 546   jclass r = NULL;
 547   try
 548     {
 549       // This might throw an out of memory exception.
 550       jstring n = JvNewStringUTF (s);
 551
 552       java::lang::ClassLoader *loader = NULL;
 553       if (env->locals->loader != NULL)
 554         loader = env->locals->loader;
 555
 556       if (loader == NULL)
 557         {
 558           // FIXME: should use getBaseClassLoader, but we don't have that
 559           // yet.
 560           loader = java::lang::ClassLoader::getSystemClassLoader ();
 561         }
 562
 563       r = loader->loadClass (n);
 564       _Jv_InitClass (r);
 565     }
 566   catch (jthrowable t)
 567     {
 568       env->ex = t;
 569     }
 570
 571   return (jclass) wrap_value (env, r);
 572 }
 573
 574 static jclass JNICALL
 575 _Jv_JNI_GetSuperclass (JNIEnv *env, jclass clazz)
 576 {
 577   return (jclass) wrap_value (env, unwrap (clazz)->getSuperclass ());
 578 }
 579
 580 static jboolean JNICALL
 581 _Jv_JNI_IsAssignableFrom (JNIEnv *, jclass clazz1, jclass clazz2)
 582 {
 583   return unwrap (clazz2)->isAssignableFrom (unwrap (clazz1));
 584 }
 585
 586 static jint JNICALL
 587 _Jv_JNI_Throw (JNIEnv *env, jthrowable obj)
 588 {
 589   // We check in case the user did some funky cast.
 590   obj = unwrap (obj);
 591   JvAssert (obj != NULL && java::lang::Throwable::class$.isInstance (obj));
 592   env->ex = obj;
 593   return 0;
 594 }
 595
 596 static jint JNICALL
 597 _Jv_JNI_ThrowNew (JNIEnv *env, jclass clazz, const char *message)
 598 {
 599   using namespace java::lang::reflect;
 600
 601   clazz = unwrap (clazz);
 602   JvAssert (java::lang::Throwable::class$.isAssignableFrom (clazz));
 603
 604   int r = JNI_OK;
 605   try
 606     {
 607       JArray<jclass> *argtypes
 608         = (JArray<jclass> *) JvNewObjectArray (1, &java::lang::Class::class$,
 609                                                NULL);
 610
 611       jclass *elts = elements (argtypes);
 612       elts[0] = &java::lang::String::class$;
 613
 614       Constructor *cons = clazz->getConstructor (argtypes);
 615
 616       jobjectArray values = JvNewObjectArray (1, &java::lang::String::class$,
 617                                               NULL);
 618       jobject *velts = elements (values);
 619       velts[0] = JvNewStringUTF (message);
 620
 621       jobject obj = cons->newInstance (values);
 622
 623       env->ex = reinterpret_cast<jthrowable> (obj);
 624     }
 625   catch (jthrowable t)
 626     {
 627       env->ex = t;
 628       r = JNI_ERR;
 629     }
 630
 631   return r;
 632 }
 633
 634 static jthrowable JNICALL
 635 _Jv_JNI_ExceptionOccurred (JNIEnv *env)
 636 {
 637   return (jthrowable) wrap_value (env, env->ex);
 638 }
 639
 640 static void JNICALL
 641 _Jv_JNI_ExceptionDescribe (JNIEnv *env)
 642 {
 643   if (env->ex != NULL)
 644     env->ex->printStackTrace();
 645 }
 646
 647 static void JNICALL
 648 _Jv_JNI_ExceptionClear (JNIEnv *env)
 649 {
 650   env->ex = NULL;
 651 }
 652
 653 static jboolean JNICALL
 654 _Jv_JNI_ExceptionCheck (JNIEnv *env)
 655 {
 656   return env->ex != NULL;
 657 }
 658
 659 static void JNICALL
 660 _Jv_JNI_FatalError (JNIEnv *, const char *message)
 661 {
 662   JvFail (message);
 663 }
 664
 665 \f
 666
 667 static jboolean JNICALL
 668 _Jv_JNI_IsSameObject (JNIEnv *, jobject obj1, jobject obj2)
 669 {
 670   return unwrap (obj1) == unwrap (obj2);
 671 }
 672
 673 static jobject JNICALL
 674 _Jv_JNI_AllocObject (JNIEnv *env, jclass clazz)
 675 {
 676   jobject obj = NULL;
 677   using namespace java::lang::reflect;
 678
 679   try
 680     {
 681       clazz = unwrap (clazz);
 682       JvAssert (clazz && ! clazz->isArray ());
 683       if (clazz->isInterface() || Modifier::isAbstract(clazz->getModifiers()))
 684         env->ex = new java::lang::InstantiationException ();
 685       else
 686         obj = _Jv_AllocObject (clazz);
 687     }
 688   catch (jthrowable t)
 689     {
 690       env->ex = t;
 691     }
 692
 693   return wrap_value (env, obj);
 694 }
 695
 696 static jclass JNICALL
 697 _Jv_JNI_GetObjectClass (JNIEnv *env, jobject obj)
 698 {
 699   obj = unwrap (obj);
 700   JvAssert (obj);
 701   return (jclass) wrap_value (env, obj->getClass());
 702 }
 703
 704 static jboolean JNICALL
 705 _Jv_JNI_IsInstanceOf (JNIEnv *, jobject obj, jclass clazz)
 706 {
 707   return unwrap (clazz)->isInstance(unwrap (obj));
 708 }
 709
 710 \f
 711
 712 //
 713 // This section concerns method invocation.
 714 //
 715
 716 template<jboolean is_static>
 717 static jmethodID JNICALL
 718 _Jv_JNI_GetAnyMethodID (JNIEnv *env, jclass clazz,
 719                         const char *name, const char *sig)
 720 {
 721   try
 722     {
 723       clazz = unwrap (clazz);
 724       _Jv_InitClass (clazz);
 725
 726       _Jv_Utf8Const *name_u = _Jv_makeUtf8Const ((char *) name, -1);
 727
 728       // FIXME: assume that SIG isn't too long.
 729       int len = strlen (sig);
 730       char s[len + 1];
 731       for (int i = 0; i <= len; ++i)
 732         s[i] = (sig[i] == '/') ? '.' : sig[i];
 733       _Jv_Utf8Const *sig_u = _Jv_makeUtf8Const ((char *) s, -1);
 734
 735       JvAssert (! clazz->isPrimitive());
 736
 737       using namespace java::lang::reflect;
 738
 739       while (clazz != NULL)
 740         {
 741           jint count = JvNumMethods (clazz);
 742           jmethodID meth = JvGetFirstMethod (clazz);
 743
 744           for (jint i = 0; i < count; ++i)
 745             {
 746               if (((is_static && Modifier::isStatic (meth->accflags))
 747                    || (! is_static && ! Modifier::isStatic (meth->accflags)))
 748                   && _Jv_equalUtf8Consts (meth->name, name_u)
 749                   && _Jv_equalUtf8Consts (meth->signature, sig_u))
 750                 return meth;
 751
 752               meth = meth->getNextMethod();
 753             }
 754
 755           clazz = clazz->getSuperclass ();
 756         }
 757
 758       java::lang::StringBuffer *name_sig =
 759         new java::lang::StringBuffer (JvNewStringUTF (name));
 760       name_sig->append ((jchar) ' ');
 761       name_sig->append (JvNewStringUTF (s));
 762       env->ex = new java::lang::NoSuchMethodError (name_sig->toString ());
 763     }
 764   catch (jthrowable t)
 765     {
 766       env->ex = t;
 767     }
 768
 769   return NULL;
 770 }
 771
 772 // This is a helper function which turns a va_list into an array of
 773 // `jvalue's.  It needs signature information in order to do its work.
 774 // The array of values must already be allocated.
 775 static void
 776 array_from_valist (jvalue *values, JArray<jclass> *arg_types, va_list vargs)
 777 {
 778   jclass *arg_elts = elements (arg_types);
 779   for (int i = 0; i < arg_types->length; ++i)
 780     {
 781       // Here we assume that sizeof(int) >= sizeof(jint), because we
 782       // use `int' when decoding the varargs.  Likewise for
 783       // float, and double.  Also we assume that sizeof(jlong) >=
 784       // sizeof(int), i.e. that jlong values are not further
 785       // promoted.
 786       JvAssert (sizeof (int) >= sizeof (jint));
 787       JvAssert (sizeof (jlong) >= sizeof (int));
 788       JvAssert (sizeof (double) >= sizeof (jfloat));
 789       JvAssert (sizeof (double) >= sizeof (jdouble));
 790       if (arg_elts[i] == JvPrimClass (byte))
 791         values[i].b = (jbyte) va_arg (vargs, int);
 792       else if (arg_elts[i] == JvPrimClass (short))
 793         values[i].s = (jshort) va_arg (vargs, int);
 794       else if (arg_elts[i] == JvPrimClass (int))
 795         values[i].i = (jint) va_arg (vargs, int);
 796       else if (arg_elts[i] == JvPrimClass (long))
 797         values[i].j = (jlong) va_arg (vargs, jlong);
 798       else if (arg_elts[i] == JvPrimClass (float))
 799         values[i].f = (jfloat) va_arg (vargs, double);
 800       else if (arg_elts[i] == JvPrimClass (double))
 801         values[i].d = (jdouble) va_arg (vargs, double);
 802       else if (arg_elts[i] == JvPrimClass (boolean))
 803         values[i].z = (jboolean) va_arg (vargs, int);
 804       else if (arg_elts[i] == JvPrimClass (char))
 805         values[i].c = (jchar) va_arg (vargs, int);
 806       else
 807         {
 808           // An object.
 809           values[i].l = unwrap (va_arg (vargs, jobject));
 810         }
 811     }
 812 }
 813
 814 // This can call any sort of method: virtual, "nonvirtual", static, or
 815 // constructor.
 816 template<typename T, invocation_type style>
 817 static T JNICALL
 818 _Jv_JNI_CallAnyMethodV (JNIEnv *env, jobject obj, jclass klass,
 819                         jmethodID id, va_list vargs)
 820 {
 821   obj = unwrap (obj);
 822   klass = unwrap (klass);
 823
 824   jclass decl_class = klass ? klass : obj->getClass ();
 825   JvAssert (decl_class != NULL);
 826
 827   jclass return_type;
 828   JArray<jclass> *arg_types;
 829
 830   try
 831     {
 832       _Jv_GetTypesFromSignature (id, decl_class,
 833                                  &arg_types, &return_type);
 834
 835       jvalue args[arg_types->length];
 836       array_from_valist (args, arg_types, vargs);
 837
 838       // For constructors we need to pass the Class we are instantiating.
 839       if (style == constructor)
 840         return_type = klass;
 841
 842       jvalue result;
 843       _Jv_CallAnyMethodA (obj, return_type, id,
 844                           style == constructor,
 845                           style == normal,
 846                           arg_types, args, &result);
 847
 848       return wrap_value (env, extract_from_jvalue<T>(result));
 849     }
 850   catch (jthrowable t)
 851     {
 852       env->ex = t;
 853     }
 854
 855   return wrap_value (env, (T) 0);
 856 }
 857
 858 template<typename T, invocation_type style>
 859 static T JNICALL
 860 _Jv_JNI_CallAnyMethod (JNIEnv *env, jobject obj, jclass klass,
 861                        jmethodID method, ...)
 862 {
 863   va_list args;
 864   T result;
 865
 866   va_start (args, method);
 867   result = _Jv_JNI_CallAnyMethodV<T, style> (env, obj, klass, method, args);
 868   va_end (args);
 869
 870   return result;
 871 }
 872
 873 template<typename T, invocation_type style>
 874 static T JNICALL
 875 _Jv_JNI_CallAnyMethodA (JNIEnv *env, jobject obj, jclass klass,
 876                         jmethodID id, const jvalue *args)
 877 {
 878   obj = unwrap (obj);
 879   klass = unwrap (klass);
 880
 881   jclass decl_class = klass ? klass : obj->getClass ();
 882   JvAssert (decl_class != NULL);
 883
 884   jclass return_type;
 885   JArray<jclass> *arg_types;
 886   try
 887     {
 888       _Jv_GetTypesFromSignature (id, decl_class,
 889                                  &arg_types, &return_type);
 890
 891       // For constructors we need to pass the Class we are instantiating.
 892       if (style == constructor)
 893         return_type = klass;
 894
 895       // Unwrap arguments as required.  Eww.
 896       jclass *type_elts = elements (arg_types);
 897       jvalue arg_copy[arg_types->length];
 898       for (int i = 0; i < arg_types->length; ++i)
 899         {
 900           if (type_elts[i]->isPrimitive ())
 901             arg_copy[i] = args[i];
 902           else
 903             arg_copy[i].l = unwrap (args[i].l);
 904         }
 905
 906       jvalue result;
 907       _Jv_CallAnyMethodA (obj, return_type, id,
 908                           style == constructor,
 909                           style == normal,
 910                           arg_types, arg_copy, &result);
 911
 912       return wrap_value (env, extract_from_jvalue<T>(result));
 913     }
 914   catch (jthrowable t)
 915     {
 916       env->ex = t;
 917     }
 918
 919   return wrap_value (env, (T) 0);
 920 }
 921
 922 template<invocation_type style>
 923 static void JNICALL
 924 _Jv_JNI_CallAnyVoidMethodV (JNIEnv *env, jobject obj, jclass klass,
 925                             jmethodID id, va_list vargs)
 926 {
 927   obj = unwrap (obj);
 928   klass = unwrap (klass);
 929
 930   jclass decl_class = klass ? klass : obj->getClass ();
 931   JvAssert (decl_class != NULL);
 932
 933   jclass return_type;
 934   JArray<jclass> *arg_types;
 935   try
 936     {
 937       _Jv_GetTypesFromSignature (id, decl_class,
 938                                  &arg_types, &return_type);
 939
 940       jvalue args[arg_types->length];
 941       array_from_valist (args, arg_types, vargs);
 942
 943       // For constructors we need to pass the Class we are instantiating.
 944       if (style == constructor)
 945         return_type = klass;
 946
 947       _Jv_CallAnyMethodA (obj, return_type, id,
 948                           style == constructor,
 949                           style == normal,
 950                           arg_types, args, NULL);
 951     }
 952   catch (jthrowable t)
 953     {
 954       env->ex = t;
 955     }
 956 }
 957
 958 template<invocation_type style>
 959 static void JNICALL
 960 _Jv_JNI_CallAnyVoidMethod (JNIEnv *env, jobject obj, jclass klass,
 961                            jmethodID method, ...)
 962 {
 963   va_list args;
 964
 965   va_start (args, method);
 966   _Jv_JNI_CallAnyVoidMethodV<style> (env, obj, klass, method, args);
 967   va_end (args);
 968 }
 969
 970 template<invocation_type style>
 971 static void JNICALL
 972 _Jv_JNI_CallAnyVoidMethodA (JNIEnv *env, jobject obj, jclass klass,
 973                             jmethodID id, const jvalue *args)
 974 {
 975   jclass decl_class = klass ? klass : obj->getClass ();
 976   JvAssert (decl_class != NULL);
 977
 978   jclass return_type;
 979   JArray<jclass> *arg_types;
 980   try
 981     {
 982       _Jv_GetTypesFromSignature (id, decl_class,
 983                                  &arg_types, &return_type);
 984
 985       // Unwrap arguments as required.  Eww.
 986       jclass *type_elts = elements (arg_types);
 987       jvalue arg_copy[arg_types->length];
 988       for (int i = 0; i < arg_types->length; ++i)
 989         {
 990           if (type_elts[i]->isPrimitive ())
 991             arg_copy[i] = args[i];
 992           else
 993             arg_copy[i].l = unwrap (args[i].l);
 994         }
 995
 996       _Jv_CallAnyMethodA (obj, return_type, id,
 997                           style == constructor,
 998                           style == normal,
 999                           arg_types, args, NULL);
1000     }
1001   catch (jthrowable t)
1002     {
1003       env->ex = t;
1004     }
1005 }
1006
1007 // Functions with this signature are used to implement functions in
1008 // the CallMethod family.
1009 template<typename T>
1010 static T JNICALL
1011 _Jv_JNI_CallMethodV (JNIEnv *env, jobject obj,
1012                      jmethodID id, va_list args)
1013 {
1014   return _Jv_JNI_CallAnyMethodV<T, normal> (env, obj, NULL, id, args);
1015 }
1016
1017 // Functions with this signature are used to implement functions in
1018 // the CallMethod family.
1019 template<typename T>
1020 static T JNICALL
1021 _Jv_JNI_CallMethod (JNIEnv *env, jobject obj, jmethodID id, ...)
1022 {
1023   va_list args;
1024   T result;
1025
1026   va_start (args, id);
1027   result = _Jv_JNI_CallAnyMethodV<T, normal> (env, obj, NULL, id, args);
1028   va_end (args);
1029
1030   return result;
1031 }
1032
1033 // Functions with this signature are used to implement functions in
1034 // the CallMethod family.
1035 template<typename T>
1036 static T JNICALL
1037 _Jv_JNI_CallMethodA (JNIEnv *env, jobject obj,
1038                      jmethodID id, const jvalue *args)
1039 {
1040   return _Jv_JNI_CallAnyMethodA<T, normal> (env, obj, NULL, id, args);
1041 }
1042
1043 static void JNICALL
1044 _Jv_JNI_CallVoidMethodV (JNIEnv *env, jobject obj,
1045                          jmethodID id, va_list args)
1046 {
1047   _Jv_JNI_CallAnyVoidMethodV<normal> (env, obj, NULL, id, args);
1048 }
1049
1050 static void JNICALL
1051 _Jv_JNI_CallVoidMethod (JNIEnv *env, jobject obj, jmethodID id, ...)
1052 {
1053   va_list args;
1054
1055   va_start (args, id);
1056   _Jv_JNI_CallAnyVoidMethodV<normal> (env, obj, NULL, id, args);
1057   va_end (args);
1058 }
1059
1060 static void JNICALL
1061 _Jv_JNI_CallVoidMethodA (JNIEnv *env, jobject obj,
1062                          jmethodID id, const jvalue *args)
1063 {
1064   _Jv_JNI_CallAnyVoidMethodA<normal> (env, obj, NULL, id, args);
1065 }
1066
1067 // Functions with this signature are used to implement functions in
1068 // the CallStaticMethod family.
1069 template<typename T>
1070 static T JNICALL
1071 _Jv_JNI_CallStaticMethodV (JNIEnv *env, jclass klass,
1072                            jmethodID id, va_list args)
1073 {
1074   JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC));
1075   JvAssert (java::lang::Class::class$.isInstance (unwrap (klass)));
1076
1077   return _Jv_JNI_CallAnyMethodV<T, static_type> (env, NULL, klass, id, args);
1078 }
1079
1080 // Functions with this signature are used to implement functions in
1081 // the CallStaticMethod family.
1082 template<typename T>
1083 static T JNICALL
1084 _Jv_JNI_CallStaticMethod (JNIEnv *env, jclass klass,
1085                           jmethodID id, ...)
1086 {
1087   va_list args;
1088   T result;
1089
1090   JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC));
1091   JvAssert (java::lang::Class::class$.isInstance (unwrap (klass)));
1092
1093   va_start (args, id);
1094   result = _Jv_JNI_CallAnyMethodV<T, static_type> (env, NULL, klass,
1095                                                    id, args);
1096   va_end (args);
1097
1098   return result;
1099 }
1100
1101 // Functions with this signature are used to implement functions in
1102 // the CallStaticMethod family.
1103 template<typename T>
1104 static T JNICALL
1105 _Jv_JNI_CallStaticMethodA (JNIEnv *env, jclass klass, jmethodID id,
1106                            const jvalue *args)
1107 {
1108   JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC));
1109   JvAssert (java::lang::Class::class$.isInstance (unwrap (klass)));
1110
1111   return _Jv_JNI_CallAnyMethodA<T, static_type> (env, NULL, klass, id, args);
1112 }
1113
1114 static void JNICALL
1115 _Jv_JNI_CallStaticVoidMethodV (JNIEnv *env, jclass klass,
1116                                jmethodID id, va_list args)
1117 {
1118   _Jv_JNI_CallAnyVoidMethodV<static_type> (env, NULL, klass, id, args);
1119 }
1120
1121 static void JNICALL
1122 _Jv_JNI_CallStaticVoidMethod (JNIEnv *env, jclass klass,
1123                               jmethodID id, ...)
1124 {
1125   va_list args;
1126
1127   va_start (args, id);
1128   _Jv_JNI_CallAnyVoidMethodV<static_type> (env, NULL, klass, id, args);
1129   va_end (args);
1130 }
1131
1132 static void JNICALL
1133 _Jv_JNI_CallStaticVoidMethodA (JNIEnv *env, jclass klass,
1134                                jmethodID id, const jvalue *args)
1135 {
1136   _Jv_JNI_CallAnyVoidMethodA<static_type> (env, NULL, klass, id, args);
1137 }
1138
1139 static jobject JNICALL
1140 _Jv_JNI_NewObjectV (JNIEnv *env, jclass klass,
1141                     jmethodID id, va_list args)
1142 {
1143   JvAssert (klass && ! klass->isArray ());
1144   JvAssert (! strcmp (id->name->chars(), "<init>")
1145             && id->signature->len() > 2
1146             && id->signature->chars()[0] == '('
1147             && ! strcmp (&id->signature->chars()[id->signature->len() - 2],
1148                          ")V"));
1149
1150   return _Jv_JNI_CallAnyMethodV<jobject, constructor> (env, NULL, klass,
1151                                                        id, args);
1152 }
1153
1154 static jobject JNICALL
1155 _Jv_JNI_NewObject (JNIEnv *env, jclass klass, jmethodID id, ...)
1156 {
1157   JvAssert (klass && ! klass->isArray ());
1158   JvAssert (! strcmp (id->name->chars(), "<init>")
1159             && id->signature->len() > 2
1160             && id->signature->chars()[0] == '('
1161             && ! strcmp (&id->signature->chars()[id->signature->len() - 2],
1162                          ")V"));
1163
1164   va_list args;
1165   jobject result;
1166
1167   va_start (args, id);
1168   result = _Jv_JNI_CallAnyMethodV<jobject, constructor> (env, NULL, klass,
1169                                                          id, args);
1170   va_end (args);
1171
1172   return result;
1173 }
1174
1175 static jobject JNICALL
1176 _Jv_JNI_NewObjectA (JNIEnv *env, jclass klass, jmethodID id,
1177                     const jvalue *args)
1178 {
1179   JvAssert (klass && ! klass->isArray ());
1180   JvAssert (! strcmp (id->name->chars(), "<init>")
1181             && id->signature->len() > 2
1182             && id->signature->chars()[0] == '('
1183             && ! strcmp (&id->signature->chars()[id->signature->len() - 2],
1184                          ")V"));
1185
1186   return _Jv_JNI_CallAnyMethodA<jobject, constructor> (env, NULL, klass,
1187                                                        id, args);
1188 }
1189
1190 \f
1191
1192 template<typename T>
1193 static T JNICALL
1194 _Jv_JNI_GetField (JNIEnv *env, jobject obj, jfieldID field)
1195 {
1196   obj = unwrap (obj);
1197   JvAssert (obj);
1198   T *ptr = (T *) ((char *) obj + field->getOffset ());
1199   return wrap_value (env, *ptr);
1200 }
1201
1202 template<typename T>
1203 static void JNICALL
1204 _Jv_JNI_SetField (JNIEnv *, jobject obj, jfieldID field, T value)
1205 {
1206   obj = unwrap (obj);
1207   value = unwrap (value);
1208
1209   JvAssert (obj);
1210   T *ptr = (T *) ((char *) obj + field->getOffset ());
1211   *ptr = value;
1212 }
1213
1214 template<jboolean is_static>
1215 static jfieldID JNICALL
1216 _Jv_JNI_GetAnyFieldID (JNIEnv *env, jclass clazz,
1217                        const char *name, const char *sig)
1218 {
1219   try
1220     {
1221       clazz = unwrap (clazz);
1222
1223       _Jv_InitClass (clazz);
1224
1225       _Jv_Utf8Const *a_name = _Jv_makeUtf8Const ((char *) name, -1);
1226
1227       // FIXME: assume that SIG isn't too long.
1228       int len = strlen (sig);
1229       char s[len + 1];
1230       for (int i = 0; i <= len; ++i)
1231         s[i] = (sig[i] == '/') ? '.' : sig[i];
1232       java::lang::ClassLoader *loader = clazz->getClassLoaderInternal ();
1233       jclass field_class = _Jv_FindClassFromSignature ((char *) s, loader);
1234       if (! field_class)
1235         throw new java::lang::ClassNotFoundException(JvNewStringUTF(s));
1236
1237       while (clazz != NULL)
1238         {
1239           // We acquire the class lock so that fields aren't resolved
1240           // while we are running.
1241           JvSynchronize sync (clazz);
1242
1243           jint count = (is_static
1244                         ? JvNumStaticFields (clazz)
1245                         : JvNumInstanceFields (clazz));
1246           jfieldID field = (is_static
1247                             ? JvGetFirstStaticField (clazz)
1248                             : JvGetFirstInstanceField (clazz));
1249           for (jint i = 0; i < count; ++i)
1250             {
1251               _Jv_Utf8Const *f_name = field->getNameUtf8Const(clazz);
1252
1253               // The field might be resolved or it might not be.  It
1254               // is much simpler to always resolve it.
1255               _Jv_Linker::resolve_field (field, loader);
1256               if (_Jv_equalUtf8Consts (f_name, a_name)
1257                   && field->getClass() == field_class)
1258                 return field;
1259
1260               field = field->getNextField ();
1261             }
1262
1263           clazz = clazz->getSuperclass ();
1264         }
1265
1266       env->ex = new java::lang::NoSuchFieldError ();
1267     }
1268   catch (jthrowable t)
1269     {
1270       env->ex = t;
1271     }
1272   return NULL;
1273 }
1274
1275 template<typename T>
1276 static T JNICALL
1277 _Jv_JNI_GetStaticField (JNIEnv *env, jclass, jfieldID field)
1278 {
1279   T *ptr = (T *) field->u.addr;
1280   return wrap_value (env, *ptr);
1281 }
1282
1283 template<typename T>
1284 static void JNICALL
1285 _Jv_JNI_SetStaticField (JNIEnv *, jclass, jfieldID field, T value)
1286 {
1287   value = unwrap (value);
1288   T *ptr = (T *) field->u.addr;
1289   *ptr = value;
1290 }
1291
1292 static jstring JNICALL
1293 _Jv_JNI_NewString (JNIEnv *env, const jchar *unichars, jsize len)
1294 {
1295   try
1296     {
1297       jstring r = _Jv_NewString (unichars, len);
1298       return (jstring) wrap_value (env, r);
1299     }
1300   catch (jthrowable t)
1301     {
1302       env->ex = t;
1303       return NULL;
1304     }
1305 }
1306
1307 static jsize JNICALL
1308 _Jv_JNI_GetStringLength (JNIEnv *, jstring string)
1309 {
1310   return unwrap (string)->length();
1311 }
1312
1313 static const jchar * JNICALL
1314 _Jv_JNI_GetStringChars (JNIEnv *, jstring string, jboolean *isCopy)
1315 {
1316   string = unwrap (string);
1317   jchar *result = _Jv_GetStringChars (string);
1318   mark_for_gc (string, global_ref_table);
1319   if (isCopy)
1320     *isCopy = false;
1321   return (const jchar *) result;
1322 }
1323
1324 static void JNICALL
1325 _Jv_JNI_ReleaseStringChars (JNIEnv *, jstring string, const jchar *)
1326 {
1327   unmark_for_gc (unwrap (string), global_ref_table);
1328 }
1329
1330 static jstring JNICALL
1331 _Jv_JNI_NewStringUTF (JNIEnv *env, const char *bytes)
1332 {
1333   try
1334     {
1335       // For compatibility with the JDK.
1336       if (!bytes)
1337         return NULL;
1338       jstring result = JvNewStringUTF (bytes);
1339       return (jstring) wrap_value (env, result);
1340     }
1341   catch (jthrowable t)
1342     {
1343       env->ex = t;
1344       return NULL;
1345     }
1346 }
1347
1348 static jsize JNICALL
1349 _Jv_JNI_GetStringUTFLength (JNIEnv *, jstring string)
1350 {
1351   return JvGetStringUTFLength (unwrap (string));
1352 }
1353
1354 static const char * JNICALL
1355 _Jv_JNI_GetStringUTFChars (JNIEnv *env, jstring string,
1356                            jboolean *isCopy)
1357 {
1358   try
1359     {
1360       string = unwrap (string);
1361       if (string == NULL)
1362         return NULL;
1363       jsize len = JvGetStringUTFLength (string);
1364       char *r = (char *) _Jv_Malloc (len + 1);
1365       JvGetStringUTFRegion (string, 0, string->length(), r);
1366       r[len] = '\0';
1367
1368       if (isCopy)
1369         *isCopy = true;
1370
1371       return (const char *) r;
1372     }
1373   catch (jthrowable t)
1374     {
1375       env->ex = t;
1376       return NULL;
1377     }
1378 }
1379
1380 static void JNICALL
1381 _Jv_JNI_ReleaseStringUTFChars (JNIEnv *, jstring, const char *utf)
1382 {
1383   _Jv_Free ((void *) utf);
1384 }
1385
1386 static void JNICALL
1387 _Jv_JNI_GetStringRegion (JNIEnv *env, jstring string, jsize start,
1388                          jsize len, jchar *buf)
1389 {
1390   string = unwrap (string);
1391   jchar *result = _Jv_GetStringChars (string);
1392   if (start < 0 || start > string->length ()
1393       || len < 0 || start + len > string->length ())
1394     {
1395       try
1396         {
1397           env->ex = new java::lang::StringIndexOutOfBoundsException ();
1398         }
1399       catch (jthrowable t)
1400         {
1401           env->ex = t;
1402         }
1403     }
1404   else
1405     memcpy (buf, &result[start], len * sizeof (jchar));
1406 }
1407
1408 static void JNICALL
1409 _Jv_JNI_GetStringUTFRegion (JNIEnv *env, jstring str, jsize start,
1410                             jsize len, char *buf)
1411 {
1412   str = unwrap (str);
1413
1414   if (start < 0 || start > str->length ()
1415       || len < 0 || start + len > str->length ())
1416     {
1417       try
1418         {
1419           env->ex = new java::lang::StringIndexOutOfBoundsException ();
1420         }
1421       catch (jthrowable t)
1422         {
1423           env->ex = t;
1424         }
1425     }
1426   else
1427     _Jv_GetStringUTFRegion (str, start, len, buf);
1428 }
1429
1430 static const jchar * JNICALL
1431 _Jv_JNI_GetStringCritical (JNIEnv *, jstring str, jboolean *isCopy)
1432 {
1433   jchar *result = _Jv_GetStringChars (unwrap (str));
1434   if (isCopy)
1435     *isCopy = false;
1436   return result;
1437 }
1438
1439 static void JNICALL
1440 _Jv_JNI_ReleaseStringCritical (JNIEnv *, jstring, const jchar *)
1441 {
1442   // Nothing.
1443 }
1444
1445 static jsize JNICALL
1446 _Jv_JNI_GetArrayLength (JNIEnv *, jarray array)
1447 {
1448   return unwrap (array)->length;
1449 }
1450
1451 static jobjectArray JNICALL
1452 _Jv_JNI_NewObjectArray (JNIEnv *env, jsize length,
1453                         jclass elementClass, jobject init)
1454 {
1455   try
1456     {
1457       elementClass = unwrap (elementClass);
1458       init = unwrap (init);
1459
1460       _Jv_CheckCast (elementClass, init);
1461       jarray result = JvNewObjectArray (length, elementClass, init);
1462       return (jobjectArray) wrap_value (env, result);
1463     }
1464   catch (jthrowable t)
1465     {
1466       env->ex = t;
1467       return NULL;
1468     }
1469 }
1470
1471 static jobject JNICALL
1472 _Jv_JNI_GetObjectArrayElement (JNIEnv *env, jobjectArray array,
1473                                jsize index)
1474 {
1475   if ((unsigned) index >= (unsigned) array->length)
1476     _Jv_ThrowBadArrayIndex (index);
1477   jobject *elts = elements (unwrap (array));
1478   return wrap_value (env, elts[index]);
1479 }
1480
1481 static void JNICALL
1482 _Jv_JNI_SetObjectArrayElement (JNIEnv *env, jobjectArray array,
1483                                jsize index, jobject value)
1484 {
1485   try
1486     {
1487       array = unwrap (array);
1488       value = unwrap (value);
1489
1490       _Jv_CheckArrayStore (array, value);
1491       if ((unsigned) index >= (unsigned) array->length)
1492         _Jv_ThrowBadArrayIndex (index);
1493       jobject *elts = elements (array);
1494       elts[index] = value;
1495     }
1496   catch (jthrowable t)
1497     {
1498       env->ex = t;
1499     }
1500 }
1501
1502 template<typename T, jclass K>
1503 static JArray<T> * JNICALL
1504 _Jv_JNI_NewPrimitiveArray (JNIEnv *env, jsize length)
1505 {
1506   try
1507     {
1508       return (JArray<T> *) wrap_value (env, _Jv_NewPrimArray (K, length));
1509     }
1510   catch (jthrowable t)
1511     {
1512       env->ex = t;
1513       return NULL;
1514     }
1515 }
1516
1517 template<typename T, jclass K>
1518 static T * JNICALL
1519 _Jv_JNI_GetPrimitiveArrayElements (JNIEnv *env, JArray<T> *array,
1520                                    jboolean *isCopy)
1521 {
1522   array = unwrap (array);
1523   if (! _Jv_JNI_check_types (env, array, K))
1524     return NULL;
1525   T *elts = elements (array);
1526   if (isCopy)
1527     {
1528       // We elect never to copy.
1529       *isCopy = false;
1530     }
1531   mark_for_gc (array, global_ref_table);
1532   return elts;
1533 }
1534
1535 template<typename T, jclass K>
1536 static void JNICALL
1537 _Jv_JNI_ReleasePrimitiveArrayElements (JNIEnv *env, JArray<T> *array,
1538                                        T *, jint /* mode */)
1539 {
1540   array = unwrap (array);
1541   _Jv_JNI_check_types (env, array, K);
1542   // Note that we ignore MODE.  We can do this because we never copy
1543   // the array elements.  My reading of the JNI documentation is that
1544   // this is an option for the implementor.
1545   unmark_for_gc (array, global_ref_table);
1546 }
1547
1548 template<typename T, jclass K>
1549 static void JNICALL
1550 _Jv_JNI_GetPrimitiveArrayRegion (JNIEnv *env, JArray<T> *array,
1551                                  jsize start, jsize len,
1552                                  T *buf)
1553 {
1554   array = unwrap (array);
1555   if (! _Jv_JNI_check_types (env, array, K))
1556     return;
1557
1558   // The cast to unsigned lets us save a comparison.
1559   if (start < 0 || len < 0
1560       || (unsigned long) (start + len) > (unsigned long) array->length)
1561     {
1562       try
1563         {
1564           // FIXME: index.
1565           env->ex = new java::lang::ArrayIndexOutOfBoundsException ();
1566         }
1567       catch (jthrowable t)
1568         {
1569           // Could have thown out of memory error.
1570           env->ex = t;
1571         }
1572     }
1573   else
1574     {
1575       T *elts = elements (array) + start;
1576       memcpy (buf, elts, len * sizeof (T));
1577     }
1578 }
1579
1580 template<typename T, jclass K>
1581 static void JNICALL
1582 _Jv_JNI_SetPrimitiveArrayRegion (JNIEnv *env, JArray<T> *array,
1583                                  jsize start, jsize len, const T *buf)
1584 {
1585   array = unwrap (array);
1586   if (! _Jv_JNI_check_types (env, array, K))
1587     return;
1588
1589   // The cast to unsigned lets us save a comparison.
1590   if (start < 0 || len < 0
1591       || (unsigned long) (start + len) > (unsigned long) array->length)
1592     {
1593       try
1594         {
1595           // FIXME: index.
1596           env->ex = new java::lang::ArrayIndexOutOfBoundsException ();
1597         }
1598       catch (jthrowable t)
1599         {
1600           env->ex = t;
1601         }
1602     }
1603   else
1604     {
1605       T *elts = elements (array) + start;
1606       memcpy (elts, buf, len * sizeof (T));
1607     }
1608 }
1609
1610 static void * JNICALL
1611 _Jv_JNI_GetPrimitiveArrayCritical (JNIEnv *, jarray array,
1612                                    jboolean *isCopy)
1613 {
1614   array = unwrap (array);
1615   // FIXME: does this work?
1616   jclass klass = array->getClass()->getComponentType();
1617   JvAssert (klass->isPrimitive ());
1618   char *r = _Jv_GetArrayElementFromElementType (array, klass);
1619   if (isCopy)
1620     *isCopy = false;
1621   return r;
1622 }
1623
1624 static void JNICALL
1625 _Jv_JNI_ReleasePrimitiveArrayCritical (JNIEnv *, jarray, void *, jint)
1626 {
1627   // Nothing.
1628 }
1629
1630 static jint JNICALL
1631 _Jv_JNI_MonitorEnter (JNIEnv *env, jobject obj)
1632 {
1633   try
1634     {
1635       _Jv_MonitorEnter (unwrap (obj));
1636       return 0;
1637     }
1638   catch (jthrowable t)
1639     {
1640       env->ex = t;
1641     }
1642   return JNI_ERR;
1643 }
1644
1645 static jint JNICALL
1646 _Jv_JNI_MonitorExit (JNIEnv *env, jobject obj)
1647 {
1648   try
1649     {
1650       _Jv_MonitorExit (unwrap (obj));
1651       return 0;
1652     }
1653   catch (jthrowable t)
1654     {
1655       env->ex = t;
1656     }
1657   return JNI_ERR;
1658 }
1659
1660 // JDK 1.2
1661 jobject JNICALL
1662 _Jv_JNI_ToReflectedField (JNIEnv *env, jclass cls, jfieldID fieldID,
1663                           jboolean)
1664 {
1665   try
1666     {
1667       cls = unwrap (cls);
1668       java::lang::reflect::Field *field = new java::lang::reflect::Field();
1669       field->declaringClass = cls;
1670       field->offset = (char*) fieldID - (char *) cls->fields;
1671       field->name = _Jv_NewStringUtf8Const (fieldID->getNameUtf8Const (cls));
1672       return wrap_value (env, field);
1673     }
1674   catch (jthrowable t)
1675     {
1676       env->ex = t;
1677     }
1678   return NULL;
1679 }
1680
1681 // JDK 1.2
1682 static jfieldID JNICALL
1683 _Jv_JNI_FromReflectedField (JNIEnv *, jobject f)
1684 {
1685   using namespace java::lang::reflect;
1686
1687   f = unwrap (f);
1688   Field *field = reinterpret_cast<Field *> (f);
1689   return _Jv_FromReflectedField (field);
1690 }
1691
1692 jobject JNICALL
1693 _Jv_JNI_ToReflectedMethod (JNIEnv *env, jclass klass, jmethodID id,
1694                            jboolean)
1695 {
1696   using namespace java::lang::reflect;
1697
1698   jobject result = NULL;
1699   klass = unwrap (klass);
1700
1701   try
1702     {
1703       if (_Jv_equalUtf8Consts (id->name, init_name))
1704         {
1705           // A constructor.
1706           Constructor *cons = new Constructor ();
1707           cons->offset = (char *) id - (char *) &klass->methods;
1708           cons->declaringClass = klass;
1709           result = cons;
1710         }
1711       else
1712         {
1713           Method *meth = new Method ();
1714           meth->offset = (char *) id - (char *) &klass->methods;
1715           meth->declaringClass = klass;
1716           result = meth;
1717         }
1718     }
1719   catch (jthrowable t)
1720     {
1721       env->ex = t;
1722     }
1723
1724   return wrap_value (env, result);
1725 }
1726
1727 static jmethodID JNICALL
1728 _Jv_JNI_FromReflectedMethod (JNIEnv *, jobject method)
1729 {
1730   using namespace java::lang::reflect;
1731   method = unwrap (method);
1732   if (Method::class$.isInstance (method))
1733     return _Jv_FromReflectedMethod (reinterpret_cast<Method *> (method));
1734   return
1735     _Jv_FromReflectedConstructor (reinterpret_cast<Constructor *> (method));
1736 }
1737
1738 // JDK 1.2.
1739 jweak JNICALL
1740 _Jv_JNI_NewWeakGlobalRef (JNIEnv *env, jobject obj)
1741 {
1742   using namespace gnu::gcj::runtime;
1743   JNIWeakRef *ref = NULL;
1744
1745   try
1746     {
1747       // This seems weird but I think it is correct.
1748       obj = unwrap (obj);
1749       ref = new JNIWeakRef (obj);
1750       mark_for_gc (ref, global_ref_table);
1751     }
1752   catch (jthrowable t)
1753     {
1754       env->ex = t;
1755     }
1756
1757   return reinterpret_cast<jweak> (ref);
1758 }
1759
1760 void JNICALL
1761 _Jv_JNI_DeleteWeakGlobalRef (JNIEnv *, jweak obj)
1762 {
1763   // JDK compatibility.
1764   if (obj == NULL)
1765     return;
1766
1767   using namespace gnu::gcj::runtime;
1768   JNIWeakRef *ref = reinterpret_cast<JNIWeakRef *> (obj);
1769   unmark_for_gc (ref, global_ref_table);
1770   ref->clear ();
1771 }
1772
1773 \f
1774
1775 // Direct byte buffers.
1776
1777 static jobject JNICALL
1778 _Jv_JNI_NewDirectByteBuffer (JNIEnv *, void *address, jlong length)
1779 {
1780   using namespace gnu::gcj;
1781   using namespace java::nio;
1782   return new DirectByteBufferImpl$ReadWrite
1783     (reinterpret_cast<RawData *> (address), length);
1784 }
1785
1786 static void * JNICALL
1787 _Jv_JNI_GetDirectBufferAddress (JNIEnv *, jobject buffer)
1788 {
1789   using namespace java::nio;
1790   if (! _Jv_IsInstanceOf (buffer, &Buffer::class$))
1791     return NULL;
1792   Buffer *tmp = static_cast<Buffer *> (buffer);
1793   return reinterpret_cast<void *> (tmp->address);
1794 }
1795
1796 static jlong JNICALL
1797 _Jv_JNI_GetDirectBufferCapacity (JNIEnv *, jobject buffer)
1798 {
1799   using namespace java::nio;
1800   if (! _Jv_IsInstanceOf (buffer, &Buffer::class$))
1801     return -1;
1802   Buffer *tmp = static_cast<Buffer *> (buffer);
1803   if (tmp->address == NULL)
1804     return -1;
1805   return tmp->capacity();
1806 }
1807
1808 static jobjectRefType JNICALL
1809 _Jv_JNI_GetObjectRefType (JNIEnv *, MAYBE_UNUSED jobject object)
1810 {
1811   JvFail("GetObjectRefType not implemented");
1812   return JNIInvalidRefType;
1813 }
1814
1815 \f
1816
1817 struct NativeMethodCacheEntry : public JNINativeMethod
1818 {
1819   char *className;
1820 };
1821
1822 // Hash table of native methods.
1823 static NativeMethodCacheEntry *nathash;
1824 // Number of slots used.
1825 static int nathash_count = 0;
1826 // Number of slots available.  Must be power of 2.
1827 static int nathash_size = 0;
1828
1829 #define DELETED_ENTRY ((char *) (~0))
1830
1831 // Compute a hash value for a native method descriptor.
1832 static int
1833 hash (const NativeMethodCacheEntry *method)
1834 {
1835   char *ptr;
1836   int hash = 0;
1837
1838   ptr = method->className;
1839   while (*ptr)
1840     hash = (31 * hash) + *ptr++;
1841
1842   ptr = method->name;
1843   while (*ptr)
1844     hash = (31 * hash) + *ptr++;
1845
1846   ptr = method->signature;
1847   while (*ptr)
1848     hash = (31 * hash) + *ptr++;
1849
1850   return hash;
1851 }
1852
1853 // Find the slot where a native method goes.
1854 static NativeMethodCacheEntry *
1855 nathash_find_slot (const NativeMethodCacheEntry *method)
1856 {
1857   jint h = hash (method);
1858   int step = (h ^ (h >> 16)) | 1;
1859   int w = h & (nathash_size - 1);
1860   int del = -1;
1861
1862   for (;;)
1863     {
1864       NativeMethodCacheEntry *slotp = &nathash[w];
1865       if (slotp->name == NULL)
1866         {
1867           if (del >= 0)
1868             return &nathash[del];
1869           else
1870             return slotp;
1871         }
1872       else if (slotp->name == DELETED_ENTRY)
1873         del = w;
1874       else if (! strcmp (slotp->name, method->name)
1875                && ! strcmp (slotp->signature, method->signature)
1876                && ! strcmp (slotp->className, method->className))
1877         return slotp;
1878       w = (w + step) & (nathash_size - 1);
1879     }
1880 }
1881
1882 // Find a method.  Return NULL if it isn't in the hash table.
1883 static void *
1884 nathash_find (NativeMethodCacheEntry *method)
1885 {
1886   if (nathash == NULL)
1887     return NULL;
1888   NativeMethodCacheEntry *slot = nathash_find_slot (method);
1889   if (slot->name == NULL || slot->name == DELETED_ENTRY)
1890     return NULL;
1891   return slot->fnPtr;
1892 }
1893
1894 static void
1895 natrehash ()
1896 {
1897   if (nathash == NULL)
1898     {
1899       nathash_size = 1024;
1900       nathash =
1901         (NativeMethodCacheEntry *) _Jv_AllocBytes (nathash_size
1902                                                    * sizeof (NativeMethodCacheEntry));
1903     }
1904   else
1905     {
1906       int savesize = nathash_size;
1907       NativeMethodCacheEntry *savehash = nathash;
1908       nathash_size *= 2;
1909       nathash =
1910         (NativeMethodCacheEntry *) _Jv_AllocBytes (nathash_size
1911                                                    * sizeof (NativeMethodCacheEntry));
1912
1913       for (int i = 0; i < savesize; ++i)
1914         {
1915           if (savehash[i].name != NULL && savehash[i].name != DELETED_ENTRY)
1916             {
1917               NativeMethodCacheEntry *slot = nathash_find_slot (&savehash[i]);
1918               *slot = savehash[i];
1919             }
1920         }
1921     }
1922 }
1923
1924 static void
1925 nathash_add (const NativeMethodCacheEntry *method)
1926 {
1927   if (3 * nathash_count >= 2 * nathash_size)
1928     natrehash ();
1929   NativeMethodCacheEntry *slot = nathash_find_slot (method);
1930   // If the slot has a real entry in it, then there is no work to do.
1931   if (slot->name != NULL && slot->name != DELETED_ENTRY)
1932     return;
1933   // FIXME: memory leak?
1934   slot->name = strdup (method->name);
1935   slot->className = strdup (method->className);
1936   // This was already strduped in _Jv_JNI_RegisterNatives.
1937   slot->signature = method->signature;
1938   slot->fnPtr = method->fnPtr;
1939 }
1940
1941 static jint JNICALL
1942 _Jv_JNI_RegisterNatives (JNIEnv *env, jclass klass,
1943                          const JNINativeMethod *methods,
1944                          jint nMethods)
1945 {
1946   // Synchronize while we do the work.  This must match
1947   // synchronization in some other functions that manipulate or use
1948   // the nathash table.
1949   JvSynchronize sync (global_ref_table);
1950
1951   NativeMethodCacheEntry dottedMethod;
1952
1953   // Look at each descriptor given us, and find the corresponding
1954   // method in the class.
1955   for (int j = 0; j < nMethods; ++j)
1956     {
1957       bool found = false;
1958
1959       _Jv_Method *imeths = JvGetFirstMethod (klass);
1960       for (int i = 0; i < JvNumMethods (klass); ++i)
1961         {
1962           _Jv_Method *self = &imeths[i];
1963
1964           // Copy this JNINativeMethod and do a slash to dot
1965           // conversion on the signature.
1966           dottedMethod.name = methods[j].name;
1967           // FIXME: we leak a little memory here if the method
1968           // is not found.
1969           dottedMethod.signature = strdup (methods[j].signature);
1970           dottedMethod.fnPtr = methods[j].fnPtr;
1971           dottedMethod.className = _Jv_GetClassNameUtf8 (klass)->chars();
1972           char *c = dottedMethod.signature;
1973           while (*c)
1974             {
1975               if (*c == '/')
1976                 *c = '.';
1977               c++;
1978             }
1979
1980           if (! strcmp (self->name->chars (), dottedMethod.name)
1981               && ! strcmp (self->signature->chars (), dottedMethod.signature))
1982             {
1983               if (! (self->accflags & java::lang::reflect::Modifier::NATIVE))
1984                 break;
1985
1986               // Found a match that is native.
1987               found = true;
1988               nathash_add (&dottedMethod);
1989
1990               break;
1991             }
1992         }
1993
1994       if (! found)
1995         {
1996           jstring m = JvNewStringUTF (methods[j].name);
1997           try
1998             {
1999               env->ex = new java::lang::NoSuchMethodError (m);
2000             }
2001           catch (jthrowable t)
2002             {
2003               env->ex = t;
2004             }
2005           return JNI_ERR;
2006         }
2007     }
2008
2009   return JNI_OK;
2010 }
2011
2012 static jint JNICALL
2013 _Jv_JNI_UnregisterNatives (JNIEnv *, jclass)
2014 {
2015   // FIXME -- we could implement this.
2016   return JNI_ERR;
2017 }
2018
2019 \f
2020
2021 // Add a character to the buffer, encoding properly.
2022 static void
2023 add_char (char *buf, jchar c, int *here)
2024 {
2025   if (c == '_')
2026     {
2027       buf[(*here)++] = '_';
2028       buf[(*here)++] = '1';
2029     }
2030   else if (c == ';')
2031     {
2032       buf[(*here)++] = '_';
2033       buf[(*here)++] = '2';
2034     }
2035   else if (c == '[')
2036     {
2037       buf[(*here)++] = '_';
2038       buf[(*here)++] = '3';
2039     }
2040
2041   // Also check for `.' here because we might be passed an internal
2042   // qualified class name like `foo.bar'.
2043   else if (c == '/' || c == '.')
2044     buf[(*here)++] = '_';
2045   else if ((c >= '0' && c <= '9')
2046            || (c >= 'a' && c <= 'z')
2047            || (c >= 'A' && c <= 'Z'))
2048     buf[(*here)++] = (char) c;
2049   else
2050     {
2051       // "Unicode" character.
2052       buf[(*here)++] = '_';
2053       buf[(*here)++] = '0';
2054       for (int i = 0; i < 4; ++i)
2055         {
2056           int val = c & 0x0f;
2057           buf[(*here) + 3 - i] = (val > 10) ? ('a' + val - 10) : ('0' + val);
2058           c >>= 4;
2059         }
2060       *here += 4;
2061     }
2062 }
2063
2064 // Compute a mangled name for a native function.  This computes the
2065 // long name, and also returns an index which indicates where a NUL
2066 // can be placed to create the short name.  This function assumes that
2067 // the buffer is large enough for its results.
2068 static void
2069 mangled_name (jclass klass, _Jv_Utf8Const *func_name,
2070               _Jv_Utf8Const *signature, char *buf, int *long_start)
2071 {
2072   strcpy (buf, "Java_");
2073   int here = 5;
2074
2075   // Add fully qualified class name.
2076   jchar *chars = _Jv_GetStringChars (klass->getName ());
2077   jint len = klass->getName ()->length ();
2078   for (int i = 0; i < len; ++i)
2079     add_char (buf, chars[i], &here);
2080
2081   // Don't use add_char because we need a literal `_'.
2082   buf[here++] = '_';
2083
2084   const unsigned char *fn = (const unsigned char *) func_name->chars ();
2085   const unsigned char *limit = fn + func_name->len ();
2086   for (int i = 0; ; ++i)
2087     {
2088       int ch = UTF8_GET (fn, limit);
2089       if (ch < 0)
2090         break;
2091       add_char (buf, ch, &here);
2092     }
2093
2094   // This is where the long signature begins.
2095   *long_start = here;
2096   buf[here++] = '_';
2097   buf[here++] = '_';
2098
2099   const unsigned char *sig = (const unsigned char *) signature->chars ();
2100   limit = sig + signature->len ();
2101   JvAssert (sig[0] == '(');
2102   ++sig;
2103   while (1)
2104     {
2105       int ch = UTF8_GET (sig, limit);
2106       if (ch == ')' || ch < 0)
2107         break;
2108       add_char (buf, ch, &here);
2109     }
2110
2111   buf[here] = '\0';
2112 }
2113
2114 JNIEnv *
2115 _Jv_GetJNIEnvNewFrameWithLoader (::java::lang::ClassLoader *loader)
2116 {
2117   JNIEnv *env = _Jv_GetCurrentJNIEnv ();
2118   if (__builtin_expect (env == NULL, false))
2119     {
2120       env = (JNIEnv *) _Jv_MallocUnchecked (sizeof (JNIEnv));
2121       env->functions = &_Jv_JNIFunctions;
2122       env->locals = NULL;
2123       // We set env->ex below.
2124
2125       // Set up the bottom, reusable frame.
2126       env->bottom_locals = (_Jv_JNI_LocalFrame *)
2127         _Jv_MallocUnchecked (sizeof (_Jv_JNI_LocalFrame)
2128                              + (FRAME_SIZE
2129                                 * sizeof (jobject)));
2130
2131       env->bottom_locals->marker = MARK_SYSTEM;
2132       env->bottom_locals->size = FRAME_SIZE;
2133       env->bottom_locals->next = NULL;
2134       env->bottom_locals->allocated_p = false;
2135       // We set the klass field below.
2136       memset (&env->bottom_locals->vec[0], 0,
2137               env->bottom_locals->size * sizeof (jobject));
2138
2139       _Jv_SetCurrentJNIEnv (env);
2140     }
2141
2142   // If we're in a simple JNI call (non-nested), we can just reuse the
2143   // locals frame we allocated many calls ago, back when the env was first
2144   // built, above.
2145
2146   if (__builtin_expect (env->locals == NULL, true))
2147     {
2148       env->locals = env->bottom_locals;
2149       env->locals->loader = loader;
2150     }
2151   else
2152     {
2153       // Alternatively, we might be re-entering JNI, in which case we can't
2154       // reuse the bottom_locals frame, because it is already underneath
2155       // us. So we need to make a new one.
2156       _Jv_JNI_LocalFrame *frame
2157         = (_Jv_JNI_LocalFrame *) _Jv_MallocUnchecked (sizeof (_Jv_JNI_LocalFrame)
2158                                                       + (FRAME_SIZE
2159                                                          * sizeof (jobject)));
2160
2161       frame->marker = MARK_SYSTEM;
2162       frame->size = FRAME_SIZE;
2163       frame->allocated_p = false;
2164       frame->next = env->locals;
2165       frame->loader = loader;
2166
2167       memset (&frame->vec[0], 0,
2168               frame->size * sizeof (jobject));
2169
2170       env->locals = frame;
2171     }
2172
2173   env->ex = NULL;
2174
2175   return env;
2176 }
2177
2178 // Return the current thread's JNIEnv; if one does not exist, create
2179 // it.  Also create a new system frame for use.  This is `extern "C"'
2180 // because the compiler calls it.
2181 extern "C" JNIEnv *
2182 _Jv_GetJNIEnvNewFrame (jclass klass)
2183 {
2184   return _Jv_GetJNIEnvNewFrameWithLoader (klass->getClassLoaderInternal());
2185 }
2186
2187 // Destroy the env's reusable resources. This is called from the thread
2188 // destructor "finalize_native" in natThread.cc
2189 void
2190 _Jv_FreeJNIEnv (_Jv_JNIEnv *env)
2191 {
2192   if (env == NULL)
2193     return;
2194
2195   if (env->bottom_locals != NULL)
2196     _Jv_Free (env->bottom_locals);
2197
2198   _Jv_Free (env);
2199 }
2200
2201 // Return the function which implements a particular JNI method.  If
2202 // we can't find the function, we throw the appropriate exception.
2203 // This is `extern "C"' because the compiler uses it.
2204 extern "C" void *
2205 _Jv_LookupJNIMethod (jclass klass, _Jv_Utf8Const *name,
2206                      _Jv_Utf8Const *signature, MAYBE_UNUSED int args_size)
2207 {
2208   int name_length = name->len();
2209   int sig_length = signature->len();
2210   char buf[10 + 6 * (name_length + sig_length) + 12];
2211   int long_start;
2212   void *function;
2213
2214   // Synchronize on something convenient.  Right now we use the hash.
2215   JvSynchronize sync (global_ref_table);
2216
2217   // First see if we have an override in the hash table.
2218   strncpy (buf, name->chars (), name_length);
2219   buf[name_length] = '\0';
2220   strncpy (buf + name_length + 1, signature->chars (), sig_length);
2221   buf[name_length + sig_length + 1] = '\0';
2222   NativeMethodCacheEntry meth;
2223   meth.name = buf;
2224   meth.signature = buf + name_length + 1;
2225   meth.className = _Jv_GetClassNameUtf8(klass)->chars();
2226   function = nathash_find (&meth);
2227   if (function != NULL)
2228     return function;
2229
2230   // If there was no override, then look in the symbol table.
2231   buf[0] = '_';
2232   mangled_name (klass, name, signature, buf + 1, &long_start);
2233   char c = buf[long_start + 1];
2234   buf[long_start + 1] = '\0';
2235
2236   function = _Jv_FindSymbolInExecutable (buf + 1);
2237 #ifdef WIN32
2238   // On Win32, we use the "stdcall" calling convention (see JNICALL
2239   // in jni.h).
2240   //
2241   // For a function named 'fooBar' that takes 'nn' bytes as arguments,
2242   // by default, MinGW GCC exports it as 'fooBar@nn', MSVC exports it
2243   // as '_fooBar@nn' and Borland C exports it as 'fooBar'. We try to
2244   // take care of all these variations here.
2245
2246   char asz_buf[12];    /* '@' + '2147483647' (32-bit INT_MAX) + '\0' */
2247   char long_nm_sv[11]; /* Ditto, except for the '\0'. */
2248
2249   if (function == NULL)
2250     {
2251       // We have tried searching for the 'fooBar' form (BCC) - now
2252       // try the others.
2253
2254       // First, save the part of the long name that will be damaged
2255       // by appending '@nn'.
2256       memcpy (long_nm_sv, (buf + long_start + 1 + 1), sizeof (long_nm_sv));
2257
2258       sprintf (asz_buf, "@%d", args_size);
2259       strcat (buf, asz_buf);
2260
2261       // Search for the '_fooBar@nn' form (MSVC).
2262       function = _Jv_FindSymbolInExecutable (buf);
2263
2264       if (function == NULL)
2265         {
2266           // Search for the 'fooBar@nn' form (MinGW GCC).
2267           function = _Jv_FindSymbolInExecutable (buf + 1);
2268         }
2269     }
2270 #endif /* WIN32 */
2271
2272   if (function == NULL)
2273     {
2274       buf[long_start + 1] = c;
2275 #ifdef WIN32
2276       // Restore the part of the long name that was damaged by
2277       // appending the '@nn'.
2278       memcpy ((buf + long_start + 1 + 1), long_nm_sv, sizeof (long_nm_sv));
2279 #endif /* WIN32 */
2280       function = _Jv_FindSymbolInExecutable (buf + 1);
2281       if (function == NULL)
2282         {
2283 #ifdef WIN32
2284           strcat (buf, asz_buf);
2285           function = _Jv_FindSymbolInExecutable (buf);
2286           if (function == NULL)
2287             function = _Jv_FindSymbolInExecutable (buf + 1);
2288
2289           if (function == NULL)
2290 #endif /* WIN32 */
2291             {
2292               jstring str = JvNewStringUTF (name->chars ());
2293               throw new java::lang::UnsatisfiedLinkError (str);
2294             }
2295         }
2296     }
2297
2298   return function;
2299 }
2300
2301 #ifdef INTERPRETER
2302
2303 // This function is the stub which is used to turn an ordinary (CNI)
2304 // method call into a JNI call.
2305 void
2306 _Jv_JNIMethod::call (ffi_cif *, void *ret, INTERP_FFI_RAW_TYPE *args,
2307                      void *__this)
2308 {
2309   _Jv_JNIMethod* _this = (_Jv_JNIMethod *) __this;
2310
2311   JNIEnv *env = _Jv_GetJNIEnvNewFrame (_this->defining_class);
2312
2313   // FIXME: we should mark every reference parameter as a local.  For
2314   // now we assume a conservative GC, and we assume that the
2315   // references are on the stack somewhere.
2316
2317   // We cache the value that we find, of course, but if we don't find
2318   // a value we don't cache that fact -- we might subsequently load a
2319   // library which finds the function in question.
2320   {
2321     // Synchronize on a convenient object to ensure sanity in case two
2322     // threads reach this point for the same function at the same
2323     // time.
2324     JvSynchronize sync (global_ref_table);
2325     if (_this->function == NULL)
2326       {
2327         int args_size = sizeof (JNIEnv *) + _this->args_raw_size;
2328
2329         if (_this->self->accflags & java::lang::reflect::Modifier::STATIC)
2330           args_size += sizeof (_this->defining_class);
2331
2332         _this->function = _Jv_LookupJNIMethod (_this->defining_class,
2333                                                _this->self->name,
2334                                                _this->self->signature,
2335                                                args_size);
2336       }
2337   }
2338
2339   JvAssert (_this->args_raw_size % sizeof (INTERP_FFI_RAW_TYPE) == 0);
2340   INTERP_FFI_RAW_TYPE
2341       real_args[2 + _this->args_raw_size / sizeof (INTERP_FFI_RAW_TYPE)];
2342   int offset = 0;
2343
2344   // First argument is always the environment pointer.
2345   real_args[offset++].ptr = env;
2346
2347   // For a static method, we pass in the Class.  For non-static
2348   // methods, the `this' argument is already handled.
2349   if ((_this->self->accflags & java::lang::reflect::Modifier::STATIC))
2350     real_args[offset++].ptr = _this->defining_class;
2351
2352   // In libgcj, the callee synchronizes.
2353   jobject sync = NULL;
2354   if ((_this->self->accflags & java::lang::reflect::Modifier::SYNCHRONIZED))
2355     {
2356       if ((_this->self->accflags & java::lang::reflect::Modifier::STATIC))
2357         sync = _this->defining_class;
2358       else
2359         sync = (jobject) args[0].ptr;
2360       _Jv_MonitorEnter (sync);
2361     }
2362
2363   // Copy over passed-in arguments.
2364   memcpy (&real_args[offset], args, _this->args_raw_size);
2365
2366   // Add a frame to the composite (interpreted + JNI) call stack
2367   java::lang::Thread *thread = java::lang::Thread::currentThread();
2368   _Jv_NativeFrame nat_frame (_this, thread);
2369
2370   // The actual call to the JNI function.
2371 #if FFI_NATIVE_RAW_API
2372   ffi_raw_call (&_this->jni_cif, (void (*)()) _this->function,
2373                 ret, real_args);
2374 #else
2375   ffi_java_raw_call (&_this->jni_cif, (void (*)()) _this->function,
2376                      ret, real_args);
2377 #endif
2378
2379   // We might need to unwrap a JNI weak reference here.
2380   if (_this->jni_cif.rtype == &ffi_type_pointer)
2381     {
2382       _Jv_value *val = (_Jv_value *) ret;
2383       val->object_value = unwrap (val->object_value);
2384     }
2385
2386   if (sync != NULL)
2387     _Jv_MonitorExit (sync);
2388
2389   _Jv_JNI_PopSystemFrame (env);
2390 }
2391
2392 #endif /* INTERPRETER */
2393
2394 \f
2395
2396 //
2397 // Invocation API.
2398 //
2399
2400 // An internal helper function.
2401 static jint
2402 _Jv_JNI_AttachCurrentThread (JavaVM *, jstring name, void **penv,
2403                              void *args, jboolean is_daemon)
2404 {
2405   JavaVMAttachArgs *attach = reinterpret_cast<JavaVMAttachArgs *> (args);
2406   java::lang::ThreadGroup *group = NULL;
2407
2408   if (attach)
2409     {
2410       // FIXME: do we really want to support 1.1?
2411       if (attach->version != JNI_VERSION_1_4
2412           && attach->version != JNI_VERSION_1_2
2413           && attach->version != JNI_VERSION_1_1)
2414         return JNI_EVERSION;
2415
2416       JvAssert (java::lang::ThreadGroup::class$.isInstance (attach->group));
2417       group = reinterpret_cast<java::lang::ThreadGroup *> (attach->group);
2418     }
2419
2420   // Attaching an already-attached thread is a no-op.
2421   JNIEnv *env = _Jv_GetCurrentJNIEnv ();
2422   if (env != NULL)
2423     {
2424       *penv = reinterpret_cast<void *> (env);
2425       return 0;
2426     }
2427
2428   env = (JNIEnv *) _Jv_MallocUnchecked (sizeof (JNIEnv));
2429   if (env == NULL)
2430     return JNI_ERR;
2431   env->functions = &_Jv_JNIFunctions;
2432   env->ex = NULL;
2433   env->bottom_locals
2434     = (_Jv_JNI_LocalFrame *) _Jv_MallocUnchecked (sizeof (_Jv_JNI_LocalFrame)
2435                                                   + (FRAME_SIZE
2436                                                      * sizeof (jobject)));
2437   env->locals = env->bottom_locals;
2438   if (env->locals == NULL)
2439     {
2440       _Jv_Free (env);
2441       return JNI_ERR;
2442     }
2443
2444   env->locals->allocated_p = false;
2445   env->locals->marker = MARK_SYSTEM;
2446   env->locals->size = FRAME_SIZE;
2447   env->locals->loader = NULL;
2448   env->locals->next = NULL;
2449
2450   for (int i = 0; i < env->locals->size; ++i)
2451     env->locals->vec[i] = NULL;
2452
2453   *penv = reinterpret_cast<void *> (env);
2454
2455   // This thread might already be a Java thread -- this function might
2456   // have been called simply to set the new JNIEnv.
2457   if (_Jv_ThreadCurrent () == NULL)
2458     {
2459       try
2460         {
2461           if (is_daemon)
2462             _Jv_AttachCurrentThreadAsDaemon (name, group);
2463           else
2464             _Jv_AttachCurrentThread (name, group);
2465         }
2466       catch (jthrowable t)
2467         {
2468           return JNI_ERR;
2469         }
2470     }
2471   _Jv_SetCurrentJNIEnv (env);
2472
2473   return 0;
2474 }
2475
2476 // This is the one actually used by JNI.
2477 jint JNICALL
2478 _Jv_JNI_AttachCurrentThread (JavaVM *vm, void **penv, void *args)
2479 {
2480   return _Jv_JNI_AttachCurrentThread (vm, NULL, penv, args, false);
2481 }
2482
2483 static jint JNICALL
2484 _Jv_JNI_AttachCurrentThreadAsDaemon (JavaVM *vm, void **penv,
2485                                      void *args)
2486 {
2487   return _Jv_JNI_AttachCurrentThread (vm, NULL, penv, args, true);
2488 }
2489
2490 static jint JNICALL
2491 _Jv_JNI_DestroyJavaVM (JavaVM *vm)
2492 {
2493   JvAssert (_Jv_the_vm && vm == _Jv_the_vm);
2494
2495   union
2496   {
2497     JNIEnv *env;
2498     void *env_p;
2499   };
2500
2501   if (_Jv_ThreadCurrent () != NULL)
2502     {
2503       jstring main_name;
2504       // This sucks.
2505       try
2506         {
2507           main_name = JvNewStringLatin1 ("main");
2508         }
2509       catch (jthrowable t)
2510         {
2511           return JNI_ERR;
2512         }
2513
2514       jint r = _Jv_JNI_AttachCurrentThread (vm, main_name, &env_p,
2515                                             NULL, false);
2516       if (r < 0)
2517         return r;
2518     }
2519   else
2520     env = _Jv_GetCurrentJNIEnv ();
2521
2522   _Jv_ThreadWait ();
2523
2524   // Docs say that this always returns an error code.
2525   return JNI_ERR;
2526 }
2527
2528 jint JNICALL
2529 _Jv_JNI_DetachCurrentThread (JavaVM *)
2530 {
2531   jint code = _Jv_DetachCurrentThread ();
2532   return code  ? JNI_EDETACHED : 0;
2533 }
2534
2535 static jint JNICALL
2536 _Jv_JNI_GetEnv (JavaVM *, void **penv, jint version)
2537 {
2538   if (_Jv_ThreadCurrent () == NULL)
2539     {
2540       *penv = NULL;
2541       return JNI_EDETACHED;
2542     }
2543
2544 #ifdef ENABLE_JVMPI
2545   // Handle JVMPI requests.
2546   if (version == JVMPI_VERSION_1)
2547     {
2548       *penv = (void *) &_Jv_JVMPI_Interface;
2549       return 0;
2550     }
2551 #endif
2552
2553 #ifdef INTERPRETER
2554   // Handle JVMTI requests
2555   if (version == JVMTI_VERSION_1_0)
2556     {
2557       *penv = (void *) _Jv_GetJVMTIEnv ();
2558       return 0;
2559     }
2560 #endif
2561
2562   // FIXME: do we really want to support 1.1?
2563   if (version != JNI_VERSION_1_4 && version != JNI_VERSION_1_2
2564       && version != JNI_VERSION_1_1)
2565     {
2566       *penv = NULL;
2567       return JNI_EVERSION;
2568     }
2569
2570   *penv = (void *) _Jv_GetCurrentJNIEnv ();
2571   return 0;
2572 }
2573
2574 JavaVM *
2575 _Jv_GetJavaVM ()
2576 {
2577   // FIXME: synchronize
2578   if (! _Jv_the_vm)
2579     {
2580       JavaVM *nvm = (JavaVM *) _Jv_MallocUnchecked (sizeof (JavaVM));
2581       if (nvm != NULL)
2582         nvm->functions = &_Jv_JNI_InvokeFunctions;
2583       _Jv_the_vm = nvm;
2584     }
2585
2586   // If this is a Java thread, we want to make sure it has an
2587   // associated JNIEnv.
2588   if (_Jv_ThreadCurrent () != NULL)
2589     {
2590       void *ignore;
2591       _Jv_JNI_AttachCurrentThread (_Jv_the_vm, &ignore, NULL);
2592     }
2593
2594   return _Jv_the_vm;
2595 }
2596
2597 static jint JNICALL
2598 _Jv_JNI_GetJavaVM (JNIEnv *, JavaVM **vm)
2599 {
2600   *vm = _Jv_GetJavaVM ();
2601   return *vm == NULL ? JNI_ERR : JNI_OK;
2602 }
2603
2604 \f
2605
2606 #define RESERVED NULL
2607
2608 struct JNINativeInterface_ _Jv_JNIFunctions =
2609 {
2610   RESERVED,
2611   RESERVED,
2612   RESERVED,
2613   RESERVED,
2614   _Jv_JNI_GetVersion,           // GetVersion
2615   _Jv_JNI_DefineClass,          // DefineClass
2616   _Jv_JNI_FindClass,            // FindClass
2617   _Jv_JNI_FromReflectedMethod,  // FromReflectedMethod
2618   _Jv_JNI_FromReflectedField,   // FromReflectedField
2619   _Jv_JNI_ToReflectedMethod,    // ToReflectedMethod
2620   _Jv_JNI_GetSuperclass,        // GetSuperclass
2621   _Jv_JNI_IsAssignableFrom,     // IsAssignableFrom
2622   _Jv_JNI_ToReflectedField,     // ToReflectedField
2623   _Jv_JNI_Throw,                // Throw
2624   _Jv_JNI_ThrowNew,             // ThrowNew
2625   _Jv_JNI_ExceptionOccurred,    // ExceptionOccurred
2626   _Jv_JNI_ExceptionDescribe,    // ExceptionDescribe
2627   _Jv_JNI_ExceptionClear,       // ExceptionClear
2628   _Jv_JNI_FatalError,           // FatalError
2629
2630   _Jv_JNI_PushLocalFrame,       // PushLocalFrame
2631   _Jv_JNI_PopLocalFrame,        // PopLocalFrame
2632   _Jv_JNI_NewGlobalRef,         // NewGlobalRef
2633   _Jv_JNI_DeleteGlobalRef,      // DeleteGlobalRef
2634   _Jv_JNI_DeleteLocalRef,       // DeleteLocalRef
2635
2636   _Jv_JNI_IsSameObject,         // IsSameObject
2637
2638   _Jv_JNI_NewLocalRef,          // NewLocalRef
2639   _Jv_JNI_EnsureLocalCapacity,  // EnsureLocalCapacity
2640
2641   _Jv_JNI_AllocObject,              // AllocObject
2642   _Jv_JNI_NewObject,                // NewObject
2643   _Jv_JNI_NewObjectV,               // NewObjectV
2644   _Jv_JNI_NewObjectA,               // NewObjectA
2645   _Jv_JNI_GetObjectClass,           // GetObjectClass
2646   _Jv_JNI_IsInstanceOf,             // IsInstanceOf
2647   _Jv_JNI_GetAnyMethodID<false>,    // GetMethodID
2648
2649   _Jv_JNI_CallMethod<jobject>,          // CallObjectMethod
2650   _Jv_JNI_CallMethodV<jobject>,         // CallObjectMethodV
2651   _Jv_JNI_CallMethodA<jobject>,         // CallObjectMethodA
2652   _Jv_JNI_CallMethod<jboolean>,         // CallBooleanMethod
2653   _Jv_JNI_CallMethodV<jboolean>,        // CallBooleanMethodV
2654   _Jv_JNI_CallMethodA<jboolean>,        // CallBooleanMethodA
2655   _Jv_JNI_CallMethod<jbyte>,            // CallByteMethod
2656   _Jv_JNI_CallMethodV<jbyte>,           // CallByteMethodV
2657   _Jv_JNI_CallMethodA<jbyte>,           // CallByteMethodA
2658   _Jv_JNI_CallMethod<jchar>,            // CallCharMethod
2659   _Jv_JNI_CallMethodV<jchar>,           // CallCharMethodV
2660   _Jv_JNI_CallMethodA<jchar>,           // CallCharMethodA
2661   _Jv_JNI_CallMethod<jshort>,           // CallShortMethod
2662   _Jv_JNI_CallMethodV<jshort>,          // CallShortMethodV
2663   _Jv_JNI_CallMethodA<jshort>,          // CallShortMethodA
2664   _Jv_JNI_CallMethod<jint>,             // CallIntMethod
2665   _Jv_JNI_CallMethodV<jint>,            // CallIntMethodV
2666   _Jv_JNI_CallMethodA<jint>,            // CallIntMethodA
2667   _Jv_JNI_CallMethod<jlong>,            // CallLongMethod
2668   _Jv_JNI_CallMethodV<jlong>,           // CallLongMethodV
2669   _Jv_JNI_CallMethodA<jlong>,           // CallLongMethodA
2670   _Jv_JNI_CallMethod<jfloat>,           // CallFloatMethod
2671   _Jv_JNI_CallMethodV<jfloat>,          // CallFloatMethodV
2672   _Jv_JNI_CallMethodA<jfloat>,          // CallFloatMethodA
2673   _Jv_JNI_CallMethod<jdouble>,          // CallDoubleMethod
2674   _Jv_JNI_CallMethodV<jdouble>,         // CallDoubleMethodV
2675   _Jv_JNI_CallMethodA<jdouble>,         // CallDoubleMethodA
2676   _Jv_JNI_CallVoidMethod,               // CallVoidMethod
2677   _Jv_JNI_CallVoidMethodV,              // CallVoidMethodV
2678   _Jv_JNI_CallVoidMethodA,              // CallVoidMethodA
2679
2680   // Nonvirtual method invocation functions follow.
2681   _Jv_JNI_CallAnyMethod<jobject, nonvirtual>,   // CallNonvirtualObjectMethod
2682   _Jv_JNI_CallAnyMethodV<jobject, nonvirtual>,  // CallNonvirtualObjectMethodV
2683   _Jv_JNI_CallAnyMethodA<jobject, nonvirtual>,  // CallNonvirtualObjectMethodA
2684   _Jv_JNI_CallAnyMethod<jboolean, nonvirtual>,  // CallNonvirtualBooleanMethod
2685   _Jv_JNI_CallAnyMethodV<jboolean, nonvirtual>, // CallNonvirtualBooleanMethodV
2686   _Jv_JNI_CallAnyMethodA<jboolean, nonvirtual>, // CallNonvirtualBooleanMethodA
2687   _Jv_JNI_CallAnyMethod<jbyte, nonvirtual>,     // CallNonvirtualByteMethod
2688   _Jv_JNI_CallAnyMethodV<jbyte, nonvirtual>,    // CallNonvirtualByteMethodV
2689   _Jv_JNI_CallAnyMethodA<jbyte, nonvirtual>,    // CallNonvirtualByteMethodA
2690   _Jv_JNI_CallAnyMethod<jchar, nonvirtual>,     // CallNonvirtualCharMethod
2691   _Jv_JNI_CallAnyMethodV<jchar, nonvirtual>,    // CallNonvirtualCharMethodV
2692   _Jv_JNI_CallAnyMethodA<jchar, nonvirtual>,    // CallNonvirtualCharMethodA
2693   _Jv_JNI_CallAnyMethod<jshort, nonvirtual>,    // CallNonvirtualShortMethod
2694   _Jv_JNI_CallAnyMethodV<jshort, nonvirtual>,   // CallNonvirtualShortMethodV
2695   _Jv_JNI_CallAnyMethodA<jshort, nonvirtual>,   // CallNonvirtualShortMethodA
2696   _Jv_JNI_CallAnyMethod<jint, nonvirtual>,      // CallNonvirtualIntMethod
2697   _Jv_JNI_CallAnyMethodV<jint, nonvirtual>,     // CallNonvirtualIntMethodV
2698   _Jv_JNI_CallAnyMethodA<jint, nonvirtual>,     // CallNonvirtualIntMethodA
2699   _Jv_JNI_CallAnyMethod<jlong, nonvirtual>,     // CallNonvirtualLongMethod
2700   _Jv_JNI_CallAnyMethodV<jlong, nonvirtual>,    // CallNonvirtualLongMethodV
2701   _Jv_JNI_CallAnyMethodA<jlong, nonvirtual>,    // CallNonvirtualLongMethodA
2702   _Jv_JNI_CallAnyMethod<jfloat, nonvirtual>,    // CallNonvirtualFloatMethod
2703   _Jv_JNI_CallAnyMethodV<jfloat, nonvirtual>,   // CallNonvirtualFloatMethodV
2704   _Jv_JNI_CallAnyMethodA<jfloat, nonvirtual>,   // CallNonvirtualFloatMethodA
2705   _Jv_JNI_CallAnyMethod<jdouble, nonvirtual>,   // CallNonvirtualDoubleMethod
2706   _Jv_JNI_CallAnyMethodV<jdouble, nonvirtual>,  // CallNonvirtualDoubleMethodV
2707   _Jv_JNI_CallAnyMethodA<jdouble, nonvirtual>,  // CallNonvirtualDoubleMethodA
2708   _Jv_JNI_CallAnyVoidMethod<nonvirtual>,        // CallNonvirtualVoidMethod
2709   _Jv_JNI_CallAnyVoidMethodV<nonvirtual>,       // CallNonvirtualVoidMethodV
2710   _Jv_JNI_CallAnyVoidMethodA<nonvirtual>,       // CallNonvirtualVoidMethodA
2711
2712   _Jv_JNI_GetAnyFieldID<false>, // GetFieldID
2713   _Jv_JNI_GetField<jobject>,    // GetObjectField
2714   _Jv_JNI_GetField<jboolean>,   // GetBooleanField
2715   _Jv_JNI_GetField<jbyte>,      // GetByteField
2716   _Jv_JNI_GetField<jchar>,      // GetCharField
2717   _Jv_JNI_GetField<jshort>,     // GetShortField
2718   _Jv_JNI_GetField<jint>,       // GetIntField
2719   _Jv_JNI_GetField<jlong>,      // GetLongField
2720   _Jv_JNI_GetField<jfloat>,     // GetFloatField
2721   _Jv_JNI_GetField<jdouble>,    // GetDoubleField
2722   _Jv_JNI_SetField,             // SetObjectField
2723   _Jv_JNI_SetField,             // SetBooleanField
2724   _Jv_JNI_SetField,             // SetByteField
2725   _Jv_JNI_SetField,             // SetCharField
2726   _Jv_JNI_SetField,             // SetShortField
2727   _Jv_JNI_SetField,             // SetIntField
2728   _Jv_JNI_SetField,             // SetLongField
2729   _Jv_JNI_SetField,             // SetFloatField
2730   _Jv_JNI_SetField,             // SetDoubleField
2731   _Jv_JNI_GetAnyMethodID<true>, // GetStaticMethodID
2732
2733   _Jv_JNI_CallStaticMethod<jobject>,      // CallStaticObjectMethod
2734   _Jv_JNI_CallStaticMethodV<jobject>,     // CallStaticObjectMethodV
2735   _Jv_JNI_CallStaticMethodA<jobject>,     // CallStaticObjectMethodA
2736   _Jv_JNI_CallStaticMethod<jboolean>,     // CallStaticBooleanMethod
2737   _Jv_JNI_CallStaticMethodV<jboolean>,    // CallStaticBooleanMethodV
2738   _Jv_JNI_CallStaticMethodA<jboolean>,    // CallStaticBooleanMethodA
2739   _Jv_JNI_CallStaticMethod<jbyte>,        // CallStaticByteMethod
2740   _Jv_JNI_CallStaticMethodV<jbyte>,       // CallStaticByteMethodV
2741   _Jv_JNI_CallStaticMethodA<jbyte>,       // CallStaticByteMethodA
2742   _Jv_JNI_CallStaticMethod<jchar>,        // CallStaticCharMethod
2743   _Jv_JNI_CallStaticMethodV<jchar>,       // CallStaticCharMethodV
2744   _Jv_JNI_CallStaticMethodA<jchar>,       // CallStaticCharMethodA
2745   _Jv_JNI_CallStaticMethod<jshort>,       // CallStaticShortMethod
2746   _Jv_JNI_CallStaticMethodV<jshort>,      // CallStaticShortMethodV
2747   _Jv_JNI_CallStaticMethodA<jshort>,      // CallStaticShortMethodA
2748   _Jv_JNI_CallStaticMethod<jint>,         // CallStaticIntMethod
2749   _Jv_JNI_CallStaticMethodV<jint>,        // CallStaticIntMethodV
2750   _Jv_JNI_CallStaticMethodA<jint>,        // CallStaticIntMethodA
2751   _Jv_JNI_CallStaticMethod<jlong>,        // CallStaticLongMethod
2752   _Jv_JNI_CallStaticMethodV<jlong>,       // CallStaticLongMethodV
2753   _Jv_JNI_CallStaticMethodA<jlong>,       // CallStaticLongMethodA
2754   _Jv_JNI_CallStaticMethod<jfloat>,       // CallStaticFloatMethod
2755   _Jv_JNI_CallStaticMethodV<jfloat>,      // CallStaticFloatMethodV
2756   _Jv_JNI_CallStaticMethodA<jfloat>,      // CallStaticFloatMethodA
2757   _Jv_JNI_CallStaticMethod<jdouble>,      // CallStaticDoubleMethod
2758   _Jv_JNI_CallStaticMethodV<jdouble>,     // CallStaticDoubleMethodV
2759   _Jv_JNI_CallStaticMethodA<jdouble>,     // CallStaticDoubleMethodA
2760   _Jv_JNI_CallStaticVoidMethod,           // CallStaticVoidMethod
2761   _Jv_JNI_CallStaticVoidMethodV,          // CallStaticVoidMethodV
2762   _Jv_JNI_CallStaticVoidMethodA,          // CallStaticVoidMethodA
2763
2764   _Jv_JNI_GetAnyFieldID<true>,         // GetStaticFieldID
2765   _Jv_JNI_GetStaticField<jobject>,     // GetStaticObjectField
2766   _Jv_JNI_GetStaticField<jboolean>,    // GetStaticBooleanField
2767   _Jv_JNI_GetStaticField<jbyte>,       // GetStaticByteField
2768   _Jv_JNI_GetStaticField<jchar>,       // GetStaticCharField
2769   _Jv_JNI_GetStaticField<jshort>,      // GetStaticShortField
2770   _Jv_JNI_GetStaticField<jint>,        // GetStaticIntField
2771   _Jv_JNI_GetStaticField<jlong>,       // GetStaticLongField
2772   _Jv_JNI_GetStaticField<jfloat>,      // GetStaticFloatField
2773   _Jv_JNI_GetStaticField<jdouble>,     // GetStaticDoubleField
2774   _Jv_JNI_SetStaticField,              // SetStaticObjectField
2775   _Jv_JNI_SetStaticField,              // SetStaticBooleanField
2776   _Jv_JNI_SetStaticField,              // SetStaticByteField
2777   _Jv_JNI_SetStaticField,              // SetStaticCharField
2778   _Jv_JNI_SetStaticField,              // SetStaticShortField
2779   _Jv_JNI_SetStaticField,              // SetStaticIntField
2780   _Jv_JNI_SetStaticField,              // SetStaticLongField
2781   _Jv_JNI_SetStaticField,              // SetStaticFloatField
2782   _Jv_JNI_SetStaticField,              // SetStaticDoubleField
2783   _Jv_JNI_NewString,                   // NewString
2784   _Jv_JNI_GetStringLength,             // GetStringLength
2785   _Jv_JNI_GetStringChars,              // GetStringChars
2786   _Jv_JNI_ReleaseStringChars,          // ReleaseStringChars
2787   _Jv_JNI_NewStringUTF,                // NewStringUTF
2788   _Jv_JNI_GetStringUTFLength,          // GetStringUTFLength
2789   _Jv_JNI_GetStringUTFChars,           // GetStringUTFChars
2790   _Jv_JNI_ReleaseStringUTFChars,       // ReleaseStringUTFChars
2791   _Jv_JNI_GetArrayLength,              // GetArrayLength
2792   _Jv_JNI_NewObjectArray,              // NewObjectArray
2793   _Jv_JNI_GetObjectArrayElement,       // GetObjectArrayElement
2794   _Jv_JNI_SetObjectArrayElement,       // SetObjectArrayElement
2795   _Jv_JNI_NewPrimitiveArray<jboolean, JvPrimClass (boolean)>,
2796                                                             // NewBooleanArray
2797   _Jv_JNI_NewPrimitiveArray<jbyte, JvPrimClass (byte)>,     // NewByteArray
2798   _Jv_JNI_NewPrimitiveArray<jchar, JvPrimClass (char)>,     // NewCharArray
2799   _Jv_JNI_NewPrimitiveArray<jshort, JvPrimClass (short)>,   // NewShortArray
2800   _Jv_JNI_NewPrimitiveArray<jint, JvPrimClass (int)>,       // NewIntArray
2801   _Jv_JNI_NewPrimitiveArray<jlong, JvPrimClass (long)>,     // NewLongArray
2802   _Jv_JNI_NewPrimitiveArray<jfloat, JvPrimClass (float)>,   // NewFloatArray
2803   _Jv_JNI_NewPrimitiveArray<jdouble, JvPrimClass (double)>, // NewDoubleArray
2804   _Jv_JNI_GetPrimitiveArrayElements<jboolean, JvPrimClass (boolean)>,
2805                                             // GetBooleanArrayElements
2806   _Jv_JNI_GetPrimitiveArrayElements<jbyte, JvPrimClass (byte)>,
2807                                             // GetByteArrayElements
2808   _Jv_JNI_GetPrimitiveArrayElements<jchar, JvPrimClass (char)>,
2809                                             // GetCharArrayElements
2810   _Jv_JNI_GetPrimitiveArrayElements<jshort, JvPrimClass (short)>,
2811                                             // GetShortArrayElements
2812   _Jv_JNI_GetPrimitiveArrayElements<jint, JvPrimClass (int)>,
2813                                             // GetIntArrayElements
2814   _Jv_JNI_GetPrimitiveArrayElements<jlong, JvPrimClass (long)>,
2815                                             // GetLongArrayElements
2816   _Jv_JNI_GetPrimitiveArrayElements<jfloat, JvPrimClass (float)>,
2817                                             // GetFloatArrayElements
2818   _Jv_JNI_GetPrimitiveArrayElements<jdouble, JvPrimClass (double)>,
2819                                             // GetDoubleArrayElements
2820   _Jv_JNI_ReleasePrimitiveArrayElements<jboolean, JvPrimClass (boolean)>,
2821                                             // ReleaseBooleanArrayElements
2822   _Jv_JNI_ReleasePrimitiveArrayElements<jbyte, JvPrimClass (byte)>,
2823                                             // ReleaseByteArrayElements
2824   _Jv_JNI_ReleasePrimitiveArrayElements<jchar, JvPrimClass (char)>,
2825                                             // ReleaseCharArrayElements
2826   _Jv_JNI_ReleasePrimitiveArrayElements<jshort, JvPrimClass (short)>,
2827                                             // ReleaseShortArrayElements
2828   _Jv_JNI_ReleasePrimitiveArrayElements<jint, JvPrimClass (int)>,
2829                                             // ReleaseIntArrayElements
2830   _Jv_JNI_ReleasePrimitiveArrayElements<jlong, JvPrimClass (long)>,
2831                                             // ReleaseLongArrayElements
2832   _Jv_JNI_ReleasePrimitiveArrayElements<jfloat, JvPrimClass (float)>,
2833                                             // ReleaseFloatArrayElements
2834   _Jv_JNI_ReleasePrimitiveArrayElements<jdouble, JvPrimClass (double)>,
2835                                             // ReleaseDoubleArrayElements
2836   _Jv_JNI_GetPrimitiveArrayRegion<jboolean, JvPrimClass (boolean)>,
2837                                             // GetBooleanArrayRegion
2838   _Jv_JNI_GetPrimitiveArrayRegion<jbyte, JvPrimClass (byte)>,
2839                                             // GetByteArrayRegion
2840   _Jv_JNI_GetPrimitiveArrayRegion<jchar, JvPrimClass (char)>,
2841                                             // GetCharArrayRegion
2842   _Jv_JNI_GetPrimitiveArrayRegion<jshort, JvPrimClass (short)>,
2843                                             // GetShortArrayRegion
2844   _Jv_JNI_GetPrimitiveArrayRegion<jint, JvPrimClass (int)>,
2845                                             // GetIntArrayRegion
2846   _Jv_JNI_GetPrimitiveArrayRegion<jlong, JvPrimClass (long)>,
2847                                             // GetLongArrayRegion
2848   _Jv_JNI_GetPrimitiveArrayRegion<jfloat, JvPrimClass (float)>,
2849                                             // GetFloatArrayRegion
2850   _Jv_JNI_GetPrimitiveArrayRegion<jdouble, JvPrimClass (double)>,
2851                                             // GetDoubleArrayRegion
2852   _Jv_JNI_SetPrimitiveArrayRegion<jboolean, JvPrimClass (boolean)>,
2853                                             // SetBooleanArrayRegion
2854   _Jv_JNI_SetPrimitiveArrayRegion<jbyte, JvPrimClass (byte)>,
2855                                             // SetByteArrayRegion
2856   _Jv_JNI_SetPrimitiveArrayRegion<jchar, JvPrimClass (char)>,
2857                                             // SetCharArrayRegion
2858   _Jv_JNI_SetPrimitiveArrayRegion<jshort, JvPrimClass (short)>,
2859                                             // SetShortArrayRegion
2860   _Jv_JNI_SetPrimitiveArrayRegion<jint, JvPrimClass (int)>,
2861                                             // SetIntArrayRegion
2862   _Jv_JNI_SetPrimitiveArrayRegion<jlong, JvPrimClass (long)>,
2863                                             // SetLongArrayRegion
2864   _Jv_JNI_SetPrimitiveArrayRegion<jfloat, JvPrimClass (float)>,
2865                                             // SetFloatArrayRegion
2866   _Jv_JNI_SetPrimitiveArrayRegion<jdouble, JvPrimClass (double)>,
2867                                             // SetDoubleArrayRegion
2868   _Jv_JNI_RegisterNatives,                  // RegisterNatives
2869   _Jv_JNI_UnregisterNatives,                // UnregisterNatives
2870   _Jv_JNI_MonitorEnter,                     // MonitorEnter
2871   _Jv_JNI_MonitorExit,                      // MonitorExit
2872   _Jv_JNI_GetJavaVM,                        // GetJavaVM
2873
2874   _Jv_JNI_GetStringRegion,                  // GetStringRegion
2875   _Jv_JNI_GetStringUTFRegion,               // GetStringUTFRegion
2876   _Jv_JNI_GetPrimitiveArrayCritical,        // GetPrimitiveArrayCritical
2877   _Jv_JNI_ReleasePrimitiveArrayCritical,    // ReleasePrimitiveArrayCritical
2878   _Jv_JNI_GetStringCritical,                // GetStringCritical
2879   _Jv_JNI_ReleaseStringCritical,            // ReleaseStringCritical
2880
2881   _Jv_JNI_NewWeakGlobalRef,                 // NewWeakGlobalRef
2882   _Jv_JNI_DeleteWeakGlobalRef,              // DeleteWeakGlobalRef
2883
2884   _Jv_JNI_ExceptionCheck,                   // ExceptionCheck
2885
2886   _Jv_JNI_NewDirectByteBuffer,              // NewDirectByteBuffer
2887   _Jv_JNI_GetDirectBufferAddress,           // GetDirectBufferAddress
2888   _Jv_JNI_GetDirectBufferCapacity,          // GetDirectBufferCapacity
2889
2890   _Jv_JNI_GetObjectRefType                  // GetObjectRefType
2891 };
2892
2893 struct JNIInvokeInterface_ _Jv_JNI_InvokeFunctions =
2894 {
2895   RESERVED,
2896   RESERVED,
2897   RESERVED,
2898
2899   _Jv_JNI_DestroyJavaVM,
2900   _Jv_JNI_AttachCurrentThread,
2901   _Jv_JNI_DetachCurrentThread,
2902   _Jv_JNI_GetEnv,
2903   _Jv_JNI_AttachCurrentThreadAsDaemon
2904 };