jdk8-mips64-public/hotspot: src/share/vm/prims/jniCheck.cpp@f008d3631bd1

6755845: JVM_FindClassFromBoot triggers assertions
Summary: Fixes assertions caused by one jvm_entry calling another, solved by refactoring code and modified gamma test.
Reviewed-by: dholmes, xlu

     1 /*

     2  * Copyright 2001-2007 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    25 # include "incls/_precompiled.incl"

    26 # include "incls/_jniCheck.cpp.incl"

    29 // Heap objects are allowed to be directly referenced only in VM code,

    30 // not in native code.

    32 #define ASSERT_OOPS_ALLOWED                                          \

    33     assert(JavaThread::current()->thread_state() == _thread_in_vm,   \

    34            "jniCheck examining oops in bad state.")

    37 // Execute the given block of source code with the thread in VM state.

    38 // To do this, transition from the NATIVE state to the VM state, execute

    39 // the code, and transtition back.  The ThreadInVMfromNative constructor

    40 // performs the transition to VM state, its destructor restores the

    41 // NATIVE state.

    43 #define IN_VM(source_code)   {                                         \

    44     {                                                                  \

    45       ThreadInVMfromNative __tiv(thr);                                 \

    46       source_code                                                      \

    47     }                                                                  \

    48   }

    51 /*

    52  * DECLARATIONS

    53  */

    55 static struct JNINativeInterface_ * unchecked_jni_NativeInterface;

    58 /*

    59  * MACRO DEFINITIONS

    60  */

    62 // All JNI checked functions here use JNI_ENTRY_CHECKED() instead of the

    63 // QUICK_ENTRY or LEAF variants found in jni.cpp.  This allows handles

    64 // to be created if a fatal error should occur.

    66 // Check for thread not attached to VM;  need to catch this before

    67 // assertions in the wrapper routines might fire

    69 // Check for env being the one value appropriate for this thread.

    71 #define JNI_ENTRY_CHECKED(result_type, header)                           \

    72 extern "C" {                                                             \

    73   result_type JNICALL header {                                           \

    74     JavaThread* thr = (JavaThread*)ThreadLocalStorage::get_thread_slow();\

    75     if (thr == NULL || !thr->is_Java_thread()) {                         \

    76       tty->print_cr(fatal_using_jnienv_in_nonjava);                      \

    77       os::abort(true);                                                   \

    78     }                                                                    \

    79     JNIEnv* xenv = thr->jni_environment();                               \

    80     if (env != xenv) {                                                   \

    81       NativeReportJNIFatalError(thr, warn_wrong_jnienv);                 \

    82     }                                                                    \

    83     __ENTRY(result_type, header, thr)

    86 #define UNCHECKED() (unchecked_jni_NativeInterface)

    88 static const char * warn_wrong_jnienv = "Using JNIEnv in the wrong thread";

    89 static const char * warn_bad_class_descriptor = "JNI FindClass received a bad class descriptor \"%s\".  A correct class descriptor " \

    90   "has no leading \"L\" or trailing \";\".  Incorrect descriptors will not be accepted in future releases.";

    91 static const char * fatal_using_jnienv_in_nonjava = "FATAL ERROR in native method: Using JNIEnv in non-Java thread";

    92 static const char * warn_other_function_in_critical = "Warning: Calling other JNI functions in the scope of " \

    93   "Get/ReleasePrimitiveArrayCritical or Get/ReleaseStringCritical";

    94 static const char * fatal_bad_ref_to_jni = "Bad global or local ref passed to JNI";

    95 static const char * fatal_received_null_class = "JNI received a null class";

    96 static const char * fatal_class_not_a_class = "JNI received a class argument that is not a class";

    97 static const char * fatal_class_not_a_throwable_class = "JNI Throw or ThrowNew received a class argument that is not a Throwable or Throwable subclass";

    98 static const char * fatal_wrong_class_or_method = "Wrong object class or methodID passed to JNI call";

    99 static const char * fatal_unknown_array_object = "Unknown array object passed to JNI array operations";

   100 static const char * fatal_object_array_expected = "Object array expected but not received for JNI array operation";

   101 static const char * fatal_non_array  = "Non-array passed to JNI array operations";

   102 static const char * fatal_element_type_mismatch = "Array element type mismatch in JNI";

   103 static const char * fatal_should_be_static = "Non-static field ID passed to JNI";

   104 static const char * fatal_wrong_static_field = "Wrong static field ID passed to JNI";

   105 static const char * fatal_static_field_not_found = "Static field not found in JNI get/set field operations";

   106 static const char * fatal_static_field_mismatch = "Field type (static) mismatch in JNI get/set field operations";

   107 static const char * fatal_should_be_nonstatic = "Static field ID passed to JNI";

   108 static const char * fatal_null_object = "Null object passed to JNI";

   109 static const char * fatal_wrong_field = "Wrong field ID passed to JNI";

   110 static const char * fatal_instance_field_not_found = "Instance field not found in JNI get/set field operations";

   111 static const char * fatal_instance_field_mismatch = "Field type (instance) mismatch in JNI get/set field operations";

   112 static const char * fatal_non_string = "JNI string operation received a non-string";

   116 // Report a JNI failure caught by -Xcheck:jni.  Perform a core dump.

   117 // Note: two variations -- one to be called when in VM state (e.g. when

   118 // within IN_VM macro), one to be called when in NATIVE state.

   120 // When in VM state:

   121 static void ReportJNIFatalError(JavaThread* thr, const char *msg) {

   122   tty->print_cr("FATAL ERROR in native method: %s", msg);

   123   thr->print_stack();

   124   os::abort(true);

   125 }

   127 // When in VM state:

   128 static void ReportJNIWarning(JavaThread* thr, const char *msg) {

   129   tty->print_cr("WARNING in native method: %s", msg);

   130   thr->print_stack();

   131 }

   133 // When in NATIVE state:

   134 static void NativeReportJNIFatalError(JavaThread* thr, const char *msg) {

   135   IN_VM(

   136     ReportJNIFatalError(thr, msg);

   137   )

   138 }

   140 static void NativeReportJNIWarning(JavaThread* thr, const char *msg) {

   141   IN_VM(

   142     ReportJNIWarning(thr, msg);

   143   )

   144 }

   149 /*

   150  * SUPPORT FUNCTIONS

   151  */

   153 static inline void

   154 functionEnterCritical(JavaThread* thr)

   155 {

   156   if (thr->has_pending_exception()) {

   157     NativeReportJNIWarning(thr, "JNI call made with exception pending");

   158   }

   159 }

   161 static inline void

   162 functionEnterCriticalExceptionAllowed(JavaThread* thr)

   163 {

   164 }

   166 static inline void

   167 functionEnter(JavaThread* thr)

   168 {

   169   if (thr->in_critical()) {

   170     tty->print_cr(warn_other_function_in_critical);

   171   }

   172   if (thr->has_pending_exception()) {

   173     NativeReportJNIWarning(thr, "JNI call made with exception pending");

   174   }

   175 }

   177 static inline void

   178 functionEnterExceptionAllowed(JavaThread* thr)

   179 {

   180   if (thr->in_critical()) {

   181     tty->print_cr(warn_other_function_in_critical);

   182   }

   183 }

   185 static inline void

   186 functionExit(JNIEnv *env)

   187 {

   188   /* nothing to do at this time */

   189 }

   191 static inline void

   192 checkStaticFieldID(JavaThread* thr, jfieldID fid, jclass cls, int ftype)

   193 {

   194   fieldDescriptor fd;

   196   /* make sure it is a static field */

   197   if (!jfieldIDWorkaround::is_static_jfieldID(fid))

   198     ReportJNIFatalError(thr, fatal_should_be_static);

   200   /* validate the class being passed */

   201   ASSERT_OOPS_ALLOWED;

   202   klassOop k_oop = jniCheck::validate_class(thr, cls, false);

   204   /* check for proper subclass hierarchy */

   205   JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fid);

   206   klassOop f_oop = id->holder();

   207   if (!instanceKlass::cast(k_oop)->is_subtype_of(f_oop))

   208     ReportJNIFatalError(thr, fatal_wrong_static_field);

   210   /* check for proper field type */

   211   if (!instanceKlass::cast(f_oop)->find_local_field_from_offset(

   212           id->offset(), true, &fd))

   213     ReportJNIFatalError(thr, fatal_static_field_not_found);

   214   if ((fd.field_type() != ftype) &&

   215       !(fd.field_type() == T_ARRAY && ftype == T_OBJECT)) {

   216     ReportJNIFatalError(thr, fatal_static_field_mismatch);

   217   }

   218 }

   220 static inline void

   221 checkInstanceFieldID(JavaThread* thr, jfieldID fid, jobject obj, int ftype)

   222 {

   223   fieldDescriptor fd;

   225   /* make sure it is an instance field */

   226   if (jfieldIDWorkaround::is_static_jfieldID(fid))

   227     ReportJNIFatalError(thr, fatal_should_be_nonstatic);

   229   /* validate the object being passed and then get its class */

   230   ASSERT_OOPS_ALLOWED;

   231   oop oopObj = jniCheck::validate_object(thr, obj);

   232   if (!oopObj) {

   233     ReportJNIFatalError(thr, fatal_null_object);

   234   }

   235   klassOop k_oop = oopObj->klass();

   237   if (!jfieldIDWorkaround::is_valid_jfieldID(k_oop, fid)) {

   238     ReportJNIFatalError(thr, fatal_wrong_field);

   239   }

   241   /* make sure the field exists */

   242   int offset = jfieldIDWorkaround::from_instance_jfieldID(k_oop, fid);

   243   if (!instanceKlass::cast(k_oop)->contains_field_offset(offset))

   244     ReportJNIFatalError(thr, fatal_wrong_field);

   246   /* check for proper field type */

   247   if (!instanceKlass::cast(k_oop)->find_field_from_offset(offset,

   248                                                               false, &fd))

   249     ReportJNIFatalError(thr, fatal_instance_field_not_found);

   251   if ((fd.field_type() != ftype) &&

   252       !(fd.field_type() == T_ARRAY && ftype == T_OBJECT)) {

   253     ReportJNIFatalError(thr, fatal_instance_field_mismatch);

   254   }

   255 }

   257 static inline void

   258 checkString(JavaThread* thr, jstring js)

   259 {

   260   ASSERT_OOPS_ALLOWED;

   261   oop s = jniCheck::validate_object(thr, js);

   262   if (!s || !java_lang_String::is_instance(s))

   263     ReportJNIFatalError(thr, fatal_non_string);

   264 }

   266 static inline void

   267 checkArray(JavaThread* thr, jarray jArray, int elementType)

   268 {

   269   ASSERT_OOPS_ALLOWED;

   270   arrayOop aOop;

   272   aOop = (arrayOop)jniCheck::validate_object(thr, jArray);

   273   if (aOop == NULL || !aOop->is_array())

   274     ReportJNIFatalError(thr, fatal_non_array);

   276   if (elementType != -1) {

   277     if (aOop->is_typeArray()) {

   278       BasicType array_type = typeArrayKlass::cast(aOop->klass())->element_type();

   279       if (array_type != elementType)

   280         ReportJNIFatalError(thr, fatal_element_type_mismatch);

   281       } else if (aOop->is_objArray()) {

   282         if ( T_OBJECT != elementType)

   283           ReportJNIFatalError(thr, fatal_object_array_expected);

   284       } else {

   285         ReportJNIFatalError(thr, fatal_unknown_array_object);

   286     }

   287   }

   288 }

   291 oop jniCheck::validate_handle(JavaThread* thr, jobject obj) {

   292   if (JNIHandles::is_frame_handle(thr, obj) ||

   293       JNIHandles::is_local_handle(thr, obj) ||

   294       JNIHandles::is_global_handle(obj) ||

   295       JNIHandles::is_weak_global_handle(obj)) {

   296     ASSERT_OOPS_ALLOWED;

   297     return JNIHandles::resolve_external_guard(obj);

   298   }

   299   ReportJNIFatalError(thr, fatal_bad_ref_to_jni);

   300   return NULL;

   301 }

   304 methodOop jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) {

   305   ASSERT_OOPS_ALLOWED;

   306   methodOop moop = JNIHandles::checked_resolve_jmethod_id(method_id);

   307   if (moop == NULL) {

   308     ReportJNIFatalError(thr, fatal_wrong_class_or_method);

   309   }

   310   return moop;

   311 }

   314 oop jniCheck::validate_object(JavaThread* thr, jobject obj) {

   315     if (!obj)

   316         return NULL;

   317     ASSERT_OOPS_ALLOWED;

   318     oop oopObj = jniCheck::validate_handle(thr, obj);

   319     if (!oopObj) {

   320       ReportJNIFatalError(thr, fatal_bad_ref_to_jni);

   321     }

   322     return oopObj;

   323 }

   325 // Warn if a class descriptor is in decorated form; class descriptors

   326 // passed to JNI findClass should not be decorated unless they are

   327 // array descriptors.

   328 void jniCheck::validate_class_descriptor(JavaThread* thr, const char* name) {

   329   if (name == NULL) return;  // implementation accepts NULL so just return

   331   size_t len = strlen(name);

   333   if (len >= 2 &&

   334       name[0] == JVM_SIGNATURE_CLASS &&            // 'L'

   335       name[len-1] == JVM_SIGNATURE_ENDCLASS ) {    // ';'

   336     char msg[JVM_MAXPATHLEN];

   337     jio_snprintf(msg, JVM_MAXPATHLEN, warn_bad_class_descriptor, name);

   338     ReportJNIWarning(thr, msg);

   339   }

   340 }

   342 klassOop jniCheck::validate_class(JavaThread* thr, jclass clazz, bool allow_primitive) {

   343   ASSERT_OOPS_ALLOWED;

   344   oop mirror = jniCheck::validate_handle(thr, clazz);

   345   if (!mirror) {

   346     ReportJNIFatalError(thr, fatal_received_null_class);

   347   }

   349   if (mirror->klass() != SystemDictionary::class_klass()) {

   350     ReportJNIFatalError(thr, fatal_class_not_a_class);

   351   }

   353   klassOop k = java_lang_Class::as_klassOop(mirror);

   354   // Make allowances for primitive classes ...

   355   if (!(k != NULL || allow_primitive && java_lang_Class::is_primitive(mirror))) {

   356     ReportJNIFatalError(thr, fatal_class_not_a_class);

   357   }

   358   return k;

   359 }

   361 void jniCheck::validate_throwable_klass(JavaThread* thr, klassOop klass) {

   362   ASSERT_OOPS_ALLOWED;

   363   assert(klass != NULL, "klass argument must have a value");

   365   if (!Klass::cast(klass)->oop_is_instance() ||

   366       !instanceKlass::cast(klass)->is_subclass_of(SystemDictionary::throwable_klass())) {

   367     ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);

   368   }

   369 }

   371 void jniCheck::validate_call_object(JavaThread* thr, jobject obj, jmethodID method_id) {

   372   /* validate the object being passed */

   373   ASSERT_OOPS_ALLOWED;

   374   jniCheck::validate_jmethod_id(thr, method_id);

   375   jniCheck::validate_object(thr, obj);

   376 }

   378 void jniCheck::validate_call_class(JavaThread* thr, jclass clazz, jmethodID method_id) {

   379   /* validate the class being passed */

   380   ASSERT_OOPS_ALLOWED;

   381   jniCheck::validate_jmethod_id(thr, method_id);

   382   jniCheck::validate_class(thr, clazz, false);

   383 }

   386 /*

   387  * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE

   388  */

   390 JNI_ENTRY_CHECKED(jclass,

   391   checked_jni_DefineClass(JNIEnv *env,

   392                           const char *name,

   393                           jobject loader,

   394                           const jbyte *buf,

   395                           jsize len))

   396     functionEnter(thr);

   397     IN_VM(

   398       jniCheck::validate_object(thr, loader);

   399     )

   400     jclass result = UNCHECKED()->DefineClass(env, name, loader, buf, len);

   401     functionExit(env);

   402     return result;

   403 JNI_END

   405 JNI_ENTRY_CHECKED(jclass,

   406   checked_jni_FindClass(JNIEnv *env,

   407                         const char *name))

   408     functionEnter(thr);

   409     IN_VM(

   410       jniCheck::validate_class_descriptor(thr, name);

   411     )

   412     jclass result = UNCHECKED()->FindClass(env, name);

   413     functionExit(env);

   414     return result;

   415 JNI_END

   417 JNI_ENTRY_CHECKED(jmethodID,

   418   checked_jni_FromReflectedMethod(JNIEnv *env,

   419                                   jobject method))

   420     functionEnter(thr);

   421     IN_VM(

   422       jniCheck::validate_object(thr, method);

   423     )

   424     jmethodID result = UNCHECKED()->FromReflectedMethod(env, method);

   425     functionExit(env);

   426     return result;

   427 JNI_END

   429 JNI_ENTRY_CHECKED(jfieldID,

   430   checked_jni_FromReflectedField(JNIEnv *env,

   431                                  jobject field))

   432     functionEnter(thr);

   433     IN_VM(

   434       jniCheck::validate_object(thr, field);

   435     )

   436     jfieldID result = UNCHECKED()->FromReflectedField(env, field);

   437     functionExit(env);

   438     return result;

   439 JNI_END

   441 JNI_ENTRY_CHECKED(jobject,

   442   checked_jni_ToReflectedMethod(JNIEnv *env,

   443                                 jclass cls,

   444                                 jmethodID methodID,

   445                                 jboolean isStatic))

   446     functionEnter(thr);

   447     IN_VM(

   448       jniCheck::validate_class(thr, cls, false);

   449       jniCheck::validate_jmethod_id(thr, methodID);

   450     )

   451     jobject result = UNCHECKED()->ToReflectedMethod(env, cls, methodID,

   452                                                     isStatic);

   453     functionExit(env);

   454     return result;

   455 JNI_END

   457 JNI_ENTRY_CHECKED(jclass,

   458   checked_jni_GetSuperclass(JNIEnv *env,

   459                             jclass sub))

   460     functionEnter(thr);

   461     IN_VM(

   462       jniCheck::validate_class(thr, sub, true);

   463     )

   464     jclass result = UNCHECKED()->GetSuperclass(env, sub);

   465     functionExit(env);

   466     return result;

   467 JNI_END

   469 JNI_ENTRY_CHECKED(jboolean,

   470   checked_jni_IsAssignableFrom(JNIEnv *env,

   471                                jclass sub,

   472                                jclass sup))

   473     functionEnter(thr);

   474     IN_VM(

   475       jniCheck::validate_class(thr, sub, true);

   476       jniCheck::validate_class(thr, sup, true);

   477     )

   478     jboolean result = UNCHECKED()->IsAssignableFrom(env, sub, sup);

   479     functionExit(env);

   480     return result;

   481 JNI_END

   483 JNI_ENTRY_CHECKED(jobject,

   484   checked_jni_ToReflectedField(JNIEnv *env,

   485                                jclass cls,

   486                                jfieldID fieldID,

   487                                jboolean isStatic))

   488     functionEnter(thr);

   489     IN_VM(

   490       jniCheck::validate_class(thr, cls, false);

   491     )

   492     jobject result = UNCHECKED()->ToReflectedField(env, cls, fieldID,

   493                                                    isStatic);

   494     functionExit(env);

   495     return result;

   496 JNI_END

   498 JNI_ENTRY_CHECKED(jint,

   499   checked_jni_Throw(JNIEnv *env,

   500                     jthrowable obj))

   501     functionEnter(thr);

   502     IN_VM(

   503       oop oopObj = jniCheck::validate_object(thr, obj);

   504       if (oopObj == NULL) {

   505         // Unchecked Throw tolerates a NULL obj, so just warn

   506         ReportJNIWarning(thr, "JNI Throw called with NULL throwable");

   507       } else {

   508         jniCheck::validate_throwable_klass(thr, oopObj->klass());

   509       }

   510     )

   511     jint result = UNCHECKED()->Throw(env, obj);

   512     functionExit(env);

   513     return result;

   514 JNI_END

   516 JNI_ENTRY_CHECKED(jint,

   517   checked_jni_ThrowNew(JNIEnv *env,

   518                        jclass clazz,

   519                        const char *msg))

   520     functionEnter(thr);

   521     IN_VM(

   522       klassOop k = jniCheck::validate_class(thr, clazz, false);

   523       assert(k != NULL, "validate_class shouldn't return NULL klassOop");

   524       jniCheck::validate_throwable_klass(thr, k);

   525     )

   526     jint result = UNCHECKED()->ThrowNew(env, clazz, msg);

   527     functionExit(env);

   528     return result;

   529 JNI_END

   531 JNI_ENTRY_CHECKED(jthrowable,

   532   checked_jni_ExceptionOccurred(JNIEnv *env))

   533     functionEnterExceptionAllowed(thr);

   534     jthrowable result = UNCHECKED()->ExceptionOccurred(env);

   535     functionExit(env);

   536     return result;

   537 JNI_END

   539 JNI_ENTRY_CHECKED(void,

   540   checked_jni_ExceptionDescribe(JNIEnv *env))

   541     functionEnterExceptionAllowed(thr);

   542     UNCHECKED()->ExceptionDescribe(env);

   543     functionExit(env);

   544 JNI_END

   546 JNI_ENTRY_CHECKED(void,

   547   checked_jni_ExceptionClear(JNIEnv *env))

   548     functionEnterExceptionAllowed(thr);

   549     UNCHECKED()->ExceptionClear(env);

   550     functionExit(env);

   551 JNI_END

   553 JNI_ENTRY_CHECKED(void,

   554   checked_jni_FatalError(JNIEnv *env,

   555                          const char *msg))

   556     functionEnter(thr);

   557     UNCHECKED()->FatalError(env, msg);

   558     functionExit(env);

   559 JNI_END

   561 JNI_ENTRY_CHECKED(jint,

   562   checked_jni_PushLocalFrame(JNIEnv *env,

   563                              jint capacity))

   564     functionEnterExceptionAllowed(thr);

   565     if (capacity < 0)

   566       NativeReportJNIFatalError(thr, "negative capacity");

   567     jint result = UNCHECKED()->PushLocalFrame(env, capacity);

   568     functionExit(env);

   569     return result;

   570 JNI_END

   572 JNI_ENTRY_CHECKED(jobject,

   573   checked_jni_PopLocalFrame(JNIEnv *env,

   574                             jobject result))

   575     functionEnterExceptionAllowed(thr);

   576     jobject res = UNCHECKED()->PopLocalFrame(env, result);

   577     functionExit(env);

   578     return res;

   579 JNI_END

   581 JNI_ENTRY_CHECKED(jobject,

   582   checked_jni_NewGlobalRef(JNIEnv *env,

   583                            jobject lobj))

   584     functionEnter(thr);

   585     IN_VM(

   586       if (lobj != NULL) {

   587         jniCheck::validate_handle(thr, lobj);

   588       }

   589     )

   590     jobject result = UNCHECKED()->NewGlobalRef(env,lobj);

   591     functionExit(env);

   592     return result;

   593 JNI_END

   595 JNI_ENTRY_CHECKED(void,

   596   checked_jni_DeleteGlobalRef(JNIEnv *env,

   597                               jobject gref))

   598     functionEnterExceptionAllowed(thr);

   599     IN_VM(

   600       jniCheck::validate_object(thr, gref);

   601       if (gref && !JNIHandles::is_global_handle(gref)) {

   602         ReportJNIFatalError(thr,

   603             "Invalid global JNI handle passed to DeleteGlobalRef");

   604       }

   605     )

   606     UNCHECKED()->DeleteGlobalRef(env,gref);

   607     functionExit(env);

   608 JNI_END

   610 JNI_ENTRY_CHECKED(void,

   611   checked_jni_DeleteLocalRef(JNIEnv *env,

   612                              jobject obj))

   613     functionEnterExceptionAllowed(thr);

   614     IN_VM(

   615       jniCheck::validate_object(thr, obj);

   616       if (obj && !(JNIHandles::is_local_handle(thr, obj) ||

   617                    JNIHandles::is_frame_handle(thr, obj)))

   618         ReportJNIFatalError(thr,

   619             "Invalid local JNI handle passed to DeleteLocalRef");

   620     )

   621     UNCHECKED()->DeleteLocalRef(env, obj);

   622     functionExit(env);

   623 JNI_END

   625 JNI_ENTRY_CHECKED(jboolean,

   626   checked_jni_IsSameObject(JNIEnv *env,

   627                            jobject obj1,

   628                            jobject obj2))

   629     functionEnterExceptionAllowed(thr);

   630     IN_VM(

   631       /* This JNI function can be used to compare weak global references

   632        * to NULL objects. If the handles are valid, but contain NULL,

   633        * then don't attempt to validate the object.

   634        */

   635       if (obj1 != NULL && jniCheck::validate_handle(thr, obj1) != NULL) {

   636         jniCheck::validate_object(thr, obj1);

   637       }

   638       if (obj2 != NULL && jniCheck::validate_handle(thr, obj2) != NULL) {

   639         jniCheck::validate_object(thr, obj2);

   640       }

   641     )

   642     jboolean result = UNCHECKED()->IsSameObject(env,obj1,obj2);

   643     functionExit(env);

   644     return result;

   645 JNI_END

   647 JNI_ENTRY_CHECKED(jobject,

   648   checked_jni_NewLocalRef(JNIEnv *env,

   649                           jobject ref))

   650     functionEnter(thr);

   651     IN_VM(

   652       if (ref != NULL) {

   653         jniCheck::validate_handle(thr, ref);

   654       }

   655     )

   656     jobject result = UNCHECKED()->NewLocalRef(env, ref);

   657     functionExit(env);

   658     return result;

   659 JNI_END

   661 JNI_ENTRY_CHECKED(jint,

   662   checked_jni_EnsureLocalCapacity(JNIEnv *env,

   663                                   jint capacity))

   664     functionEnter(thr);

   665     if (capacity < 0) {

   666       NativeReportJNIFatalError(thr, "negative capacity");

   667     }

   668     jint result = UNCHECKED()->EnsureLocalCapacity(env, capacity);

   669     functionExit(env);

   670     return result;

   671 JNI_END

   673 JNI_ENTRY_CHECKED(jobject,

   674   checked_jni_AllocObject(JNIEnv *env,

   675                           jclass clazz))

   676     functionEnter(thr);

   677     IN_VM(

   678       jniCheck::validate_class(thr, clazz, false);

   679     )

   680     jobject result = UNCHECKED()->AllocObject(env,clazz);

   681     functionExit(env);

   682     return result;

   683 JNI_END

   685 JNI_ENTRY_CHECKED(jobject,

   686   checked_jni_NewObject(JNIEnv *env,

   687                         jclass clazz,

   688                         jmethodID methodID,

   689                         ...))

   690     functionEnter(thr);

   691     va_list args;

   692     IN_VM(

   693       jniCheck::validate_class(thr, clazz, false);

   694       jniCheck::validate_jmethod_id(thr, methodID);

   695     )

   696     va_start(args, methodID);

   697     jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);

   698     va_end(args);

   699     functionExit(env);

   700     return result;

   701 JNI_END

   703 JNI_ENTRY_CHECKED(jobject,

   704   checked_jni_NewObjectV(JNIEnv *env,

   705                          jclass clazz,

   706                          jmethodID methodID,

   707                          va_list args))

   708     functionEnter(thr);

   709     IN_VM(

   710       jniCheck::validate_class(thr, clazz, false);

   711       jniCheck::validate_jmethod_id(thr, methodID);

   712     )

   713     jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);

   714     functionExit(env);

   715     return result;

   716 JNI_END

   718 JNI_ENTRY_CHECKED(jobject,

   719   checked_jni_NewObjectA(JNIEnv *env,

   720                          jclass clazz,

   721                          jmethodID methodID,

   722                          const jvalue *args))

   723     functionEnter(thr);

   724     IN_VM(

   725       jniCheck::validate_class(thr, clazz, false);

   726       jniCheck::validate_jmethod_id(thr, methodID);

   727     )

   728     jobject result = UNCHECKED()->NewObjectA(env,clazz,methodID,args);

   729     functionExit(env);

   730     return result;

   731 JNI_END

   733 JNI_ENTRY_CHECKED(jclass,

   734   checked_jni_GetObjectClass(JNIEnv *env,

   735                              jobject obj))

   736     functionEnter(thr);

   737     IN_VM(

   738       jniCheck::validate_object(thr, obj);

   739     )

   740     jclass result = UNCHECKED()->GetObjectClass(env,obj);

   741     functionExit(env);

   742     return result;

   743 JNI_END

   745 JNI_ENTRY_CHECKED(jboolean,

   746   checked_jni_IsInstanceOf(JNIEnv *env,

   747                            jobject obj,

   748                            jclass clazz))

   749     functionEnter(thr);

   750     IN_VM(

   751       jniCheck::validate_object(thr, obj);

   752       jniCheck::validate_class(thr, clazz, true);

   753     )

   754     jboolean result = UNCHECKED()->IsInstanceOf(env,obj,clazz);

   755     functionExit(env);

   756     return result;

   757 JNI_END

   759 JNI_ENTRY_CHECKED(jmethodID,

   760   checked_jni_GetMethodID(JNIEnv *env,

   761                           jclass clazz,

   762                           const char *name,

   763                           const char *sig))

   764     functionEnter(thr);

   765     IN_VM(

   766       jniCheck::validate_class(thr, clazz, false);

   767     )

   768     jmethodID result = UNCHECKED()->GetMethodID(env,clazz,name,sig);

   769     functionExit(env);

   770     return result;

   771 JNI_END

   773 #define WRAPPER_CallMethod(ResultType, Result) \

   774 JNI_ENTRY_CHECKED(ResultType,  \

   775   checked_jni_Call##Result##Method(JNIEnv *env, \

   776                                    jobject obj, \

   777                                    jmethodID methodID, \

   778                                    ...)) \

   779     functionEnter(thr); \

   780     va_list args; \

   781     IN_VM( \

   782       jniCheck::validate_call_object(thr, obj, methodID); \

   783     ) \

   784     va_start(args,methodID); \

   785     ResultType result =UNCHECKED()->Call##Result##MethodV(env, obj, methodID, \

   786                                                           args); \

   787     va_end(args); \

   788     functionExit(env); \

   789     return result; \

   790 JNI_END \

   791 \

   792 JNI_ENTRY_CHECKED(ResultType,  \

   793   checked_jni_Call##Result##MethodV(JNIEnv *env, \

   794                                     jobject obj, \

   795                                     jmethodID methodID, \

   796                                     va_list args)) \

   797     functionEnter(thr); \

   798     IN_VM(\

   799       jniCheck::validate_call_object(thr, obj, methodID); \

   800     ) \

   801     ResultType result = UNCHECKED()->Call##Result##MethodV(env, obj, methodID,\

   802                                                            args); \

   803     functionExit(env); \

   804     return result; \

   805 JNI_END \

   806 \

   807 JNI_ENTRY_CHECKED(ResultType,  \

   808   checked_jni_Call##Result##MethodA(JNIEnv *env, \

   809                                     jobject obj, \

   810                                     jmethodID methodID, \

   811                                     const jvalue * args)) \

   812     functionEnter(thr); \

   813     IN_VM( \

   814       jniCheck::validate_call_object(thr, obj, methodID); \

   815     ) \

   816     ResultType result = UNCHECKED()->Call##Result##MethodA(env, obj, methodID,\

   817                                                            args); \

   818     functionExit(env); \

   819     return result; \

   820 JNI_END

   822 WRAPPER_CallMethod(jobject,Object)

   823 WRAPPER_CallMethod(jboolean,Boolean)

   824 WRAPPER_CallMethod(jbyte,Byte)

   825 WRAPPER_CallMethod(jshort,Short)

   826 WRAPPER_CallMethod(jchar,Char)

   827 WRAPPER_CallMethod(jint,Int)

   828 WRAPPER_CallMethod(jlong,Long)

   829 WRAPPER_CallMethod(jfloat,Float)

   830 WRAPPER_CallMethod(jdouble,Double)

   832 JNI_ENTRY_CHECKED(void,

   833   checked_jni_CallVoidMethod(JNIEnv *env, \

   834                              jobject obj, \

   835                              jmethodID methodID, \

   836                              ...))

   837     functionEnter(thr);

   838     va_list args;

   839     IN_VM(

   840       jniCheck::validate_call_object(thr, obj, methodID);

   841     )

   842     va_start(args,methodID);

   843     UNCHECKED()->CallVoidMethodV(env,obj,methodID,args);

   844     va_end(args);

   845     functionExit(env);

   846 JNI_END

   848 JNI_ENTRY_CHECKED(void,

   849   checked_jni_CallVoidMethodV(JNIEnv *env,

   850                               jobject obj,

   851                               jmethodID methodID,

   852                               va_list args))

   853     functionEnter(thr);

   854     IN_VM(

   855       jniCheck::validate_call_object(thr, obj, methodID);

   856     )

   857     UNCHECKED()->CallVoidMethodV(env,obj,methodID,args);

   858     functionExit(env);

   859 JNI_END

   861 JNI_ENTRY_CHECKED(void,

   862   checked_jni_CallVoidMethodA(JNIEnv *env,

   863                               jobject obj,

   864                               jmethodID methodID,

   865                               const jvalue * args))

   866     functionEnter(thr);

   867     IN_VM(

   868       jniCheck::validate_call_object(thr, obj, methodID);

   869     )

   870     UNCHECKED()->CallVoidMethodA(env,obj,methodID,args);

   871     functionExit(env);

   872 JNI_END

   874 #define WRAPPER_CallNonvirtualMethod(ResultType, Result) \

   875 JNI_ENTRY_CHECKED(ResultType,  \

   876   checked_jni_CallNonvirtual##Result##Method(JNIEnv *env, \

   877                                              jobject obj, \

   878                                              jclass clazz, \

   879                                              jmethodID methodID, \

   880                                              ...)) \

   881     functionEnter(thr); \

   882     va_list args; \

   883     IN_VM( \

   884       jniCheck::validate_call_object(thr, obj, methodID); \

   885       jniCheck::validate_call_class(thr, clazz, methodID); \

   886     ) \

   887     va_start(args,methodID); \

   888     ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \

   889                                                                      obj, \

   890                                                                      clazz, \

   891                                                                      methodID,\

   892                                                                      args); \

   893     va_end(args); \

   894     functionExit(env); \

   895     return result; \

   896 JNI_END \

   897 \

   898 JNI_ENTRY_CHECKED(ResultType,  \

   899   checked_jni_CallNonvirtual##Result##MethodV(JNIEnv *env, \

   900                                               jobject obj, \

   901                                               jclass clazz, \

   902                                               jmethodID methodID, \

   903                                               va_list args)) \

   904     functionEnter(thr); \

   905     IN_VM( \

   906       jniCheck::validate_call_object(thr, obj, methodID); \

   907       jniCheck::validate_call_class(thr, clazz, methodID); \

   908     ) \

   909     ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \

   910                                                                      obj, \

   911                                                                      clazz, \

   912                                                                      methodID,\

   913                                                                      args); \

   914     functionExit(env); \

   915     return result; \

   916 JNI_END \

   917 \

   918 JNI_ENTRY_CHECKED(ResultType,  \

   919   checked_jni_CallNonvirtual##Result##MethodA(JNIEnv *env, \

   920                                               jobject obj, \

   921                                               jclass clazz, \

   922                                               jmethodID methodID, \

   923                                               const jvalue * args)) \

   924     functionEnter(thr); \

   925     IN_VM( \

   926       jniCheck::validate_call_object(thr, obj, methodID); \

   927       jniCheck::validate_call_class(thr, clazz, methodID); \

   928     ) \

   929     ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodA(env, \

   930                                                                      obj, \

   931                                                                      clazz, \

   932                                                                      methodID,\

   933                                                                      args); \

   934     functionExit(env); \

   935     return result; \

   936 JNI_END

   938 WRAPPER_CallNonvirtualMethod(jobject,Object)

   939 WRAPPER_CallNonvirtualMethod(jboolean,Boolean)

   940 WRAPPER_CallNonvirtualMethod(jbyte,Byte)

   941 WRAPPER_CallNonvirtualMethod(jshort,Short)

   942 WRAPPER_CallNonvirtualMethod(jchar,Char)

   943 WRAPPER_CallNonvirtualMethod(jint,Int)

   944 WRAPPER_CallNonvirtualMethod(jlong,Long)

   945 WRAPPER_CallNonvirtualMethod(jfloat,Float)

   946 WRAPPER_CallNonvirtualMethod(jdouble,Double)

   948 JNI_ENTRY_CHECKED(void,

   949   checked_jni_CallNonvirtualVoidMethod(JNIEnv *env,

   950                                        jobject obj,

   951                                        jclass clazz,

   952                                        jmethodID methodID,

   953                                        ...))

   954     functionEnter(thr);

   955     va_list args;

   956     IN_VM(

   957       jniCheck::validate_call_object(thr, obj, methodID);

   958       jniCheck::validate_call_class(thr, clazz, methodID);

   959     )

   960     va_start(args,methodID);

   961     UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);

   962     va_end(args);

   963     functionExit(env);

   964 JNI_END

   966 JNI_ENTRY_CHECKED(void,

   967   checked_jni_CallNonvirtualVoidMethodV(JNIEnv *env,

   968                                         jobject obj,

   969                                         jclass clazz,

   970                                         jmethodID methodID,

   971                                         va_list args))

   972     functionEnter(thr);

   973     IN_VM(

   974       jniCheck::validate_call_object(thr, obj, methodID);

   975       jniCheck::validate_call_class(thr, clazz, methodID);

   976     )

   977     UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);

   978     functionExit(env);

   979 JNI_END

   981 JNI_ENTRY_CHECKED(void,

   982   checked_jni_CallNonvirtualVoidMethodA(JNIEnv *env,

   983                                         jobject obj,

   984                                         jclass clazz,

   985                                         jmethodID methodID,

   986                                         const jvalue * args))

   987     functionEnter(thr);

   988     IN_VM(

   989       jniCheck::validate_call_object(thr, obj, methodID);

   990       jniCheck::validate_call_class(thr, clazz, methodID);

   991     )

   992     UNCHECKED()->CallNonvirtualVoidMethodA(env,obj,clazz,methodID,args);

   993     functionExit(env);

   994 JNI_END

   996 JNI_ENTRY_CHECKED(jfieldID,

   997   checked_jni_GetFieldID(JNIEnv *env,

   998                          jclass clazz,

   999                          const char *name,

  1000                          const char *sig))

  1001     functionEnter(thr);

  1002     IN_VM(

  1003       jniCheck::validate_class(thr, clazz, false);

  1004     )

  1005     jfieldID result = UNCHECKED()->GetFieldID(env,clazz,name,sig);

  1006     functionExit(env);

  1007     return result;

  1008 JNI_END

  1010 #define WRAPPER_GetField(ReturnType,Result,FieldType) \

  1011 JNI_ENTRY_CHECKED(ReturnType,  \

  1012   checked_jni_Get##Result##Field(JNIEnv *env, \

  1013                                  jobject obj, \

  1014                                  jfieldID fieldID)) \

  1015     functionEnter(thr); \

  1016     IN_VM( \

  1017       checkInstanceFieldID(thr, fieldID, obj, FieldType); \

  1018     ) \

  1019     ReturnType result = UNCHECKED()->Get##Result##Field(env,obj,fieldID); \

  1020     functionExit(env); \

  1021     return result; \

  1022 JNI_END

  1024 WRAPPER_GetField(jobject,  Object,  T_OBJECT)

  1025 WRAPPER_GetField(jboolean, Boolean, T_BOOLEAN)

  1026 WRAPPER_GetField(jbyte,    Byte,    T_BYTE)

  1027 WRAPPER_GetField(jshort,   Short,   T_SHORT)

  1028 WRAPPER_GetField(jchar,    Char,    T_CHAR)

  1029 WRAPPER_GetField(jint,     Int,     T_INT)

  1030 WRAPPER_GetField(jlong,    Long,    T_LONG)

  1031 WRAPPER_GetField(jfloat,   Float,   T_FLOAT)

  1032 WRAPPER_GetField(jdouble,  Double,  T_DOUBLE)

  1034 #define WRAPPER_SetField(ValueType,Result,FieldType) \

  1035 JNI_ENTRY_CHECKED(void,  \

  1036   checked_jni_Set##Result##Field(JNIEnv *env, \

  1037                                  jobject obj, \

  1038                                  jfieldID fieldID, \

  1039                                  ValueType val)) \

  1040     functionEnter(thr); \

  1041     IN_VM( \

  1042       checkInstanceFieldID(thr, fieldID, obj, FieldType); \

  1043     ) \

  1044     UNCHECKED()->Set##Result##Field(env,obj,fieldID,val); \

  1045     functionExit(env); \

  1046 JNI_END

  1048 WRAPPER_SetField(jobject,  Object,  T_OBJECT)

  1049 WRAPPER_SetField(jboolean, Boolean, T_BOOLEAN)

  1050 WRAPPER_SetField(jbyte,    Byte,    T_BYTE)

  1051 WRAPPER_SetField(jshort,   Short,   T_SHORT)

  1052 WRAPPER_SetField(jchar,    Char,    T_CHAR)

  1053 WRAPPER_SetField(jint,     Int,     T_INT)

  1054 WRAPPER_SetField(jlong,    Long,    T_LONG)

  1055 WRAPPER_SetField(jfloat,   Float,   T_FLOAT)

  1056 WRAPPER_SetField(jdouble,  Double,  T_DOUBLE)

  1059 JNI_ENTRY_CHECKED(jmethodID,

  1060   checked_jni_GetStaticMethodID(JNIEnv *env,

  1061                                 jclass clazz,

  1062                                 const char *name,

  1063                                 const char *sig))

  1064     functionEnter(thr);

  1065     IN_VM(

  1066       jniCheck::validate_class(thr, clazz, false);

  1067     )

  1068     jmethodID result = UNCHECKED()->GetStaticMethodID(env,clazz,name,sig);

  1069     functionExit(env);

  1070     return result;

  1071 JNI_END

  1073 #define WRAPPER_CallStaticMethod(ReturnType,Result) \

  1074 JNI_ENTRY_CHECKED(ReturnType,  \

  1075   checked_jni_CallStatic##Result##Method(JNIEnv *env, \

  1076                                          jclass clazz, \

  1077                                          jmethodID methodID, \

  1078                                          ...)) \

  1079     functionEnter(thr); \

  1080     va_list args; \

  1081     IN_VM( \

  1082       jniCheck::validate_jmethod_id(thr, methodID); \

  1083       jniCheck::validate_class(thr, clazz, false); \

  1084     ) \

  1085     va_start(args,methodID); \

  1086     ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \

  1087                                                                  clazz, \

  1088                                                                  methodID, \

  1089                                                                  args); \

  1090     va_end(args); \

  1091     functionExit(env); \

  1092     return result; \

  1093 JNI_END \

  1094 \

  1095 JNI_ENTRY_CHECKED(ReturnType,  \

  1096   checked_jni_CallStatic##Result##MethodV(JNIEnv *env, \

  1097                                           jclass clazz, \

  1098                                           jmethodID methodID,\

  1099                                           va_list args)) \

  1100     functionEnter(thr); \

  1101     IN_VM( \

  1102       jniCheck::validate_jmethod_id(thr, methodID); \

  1103       jniCheck::validate_class(thr, clazz, false); \

  1104     ) \

  1105     ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \

  1106                                                                  clazz, \

  1107                                                                  methodID, \

  1108                                                                  args); \

  1109     functionExit(env); \

  1110     return result; \

  1111 JNI_END \

  1112 \

  1113 JNI_ENTRY_CHECKED(ReturnType,  \

  1114   checked_jni_CallStatic##Result##MethodA(JNIEnv *env, \

  1115                                           jclass clazz, \

  1116                                           jmethodID methodID, \

  1117                                           const jvalue *args)) \

  1118     functionEnter(thr); \

  1119     IN_VM( \

  1120       jniCheck::validate_jmethod_id(thr, methodID); \

  1121       jniCheck::validate_class(thr, clazz, false); \

  1122     ) \

  1123     ReturnType result = UNCHECKED()->CallStatic##Result##MethodA(env, \

  1124                                                                  clazz, \

  1125                                                                  methodID, \

  1126                                                                  args); \

  1127     functionExit(env); \

  1128     return result; \

  1129 JNI_END

  1131 WRAPPER_CallStaticMethod(jobject,Object)

  1132 WRAPPER_CallStaticMethod(jboolean,Boolean)

  1133 WRAPPER_CallStaticMethod(jbyte,Byte)

  1134 WRAPPER_CallStaticMethod(jshort,Short)

  1135 WRAPPER_CallStaticMethod(jchar,Char)

  1136 WRAPPER_CallStaticMethod(jint,Int)

  1137 WRAPPER_CallStaticMethod(jlong,Long)

  1138 WRAPPER_CallStaticMethod(jfloat,Float)

  1139 WRAPPER_CallStaticMethod(jdouble,Double)

  1141 JNI_ENTRY_CHECKED(void,

  1142   checked_jni_CallStaticVoidMethod(JNIEnv *env,

  1143                                    jclass cls,

  1144                                    jmethodID methodID,

  1145                                    ...))

  1146     functionEnter(thr);

  1147     va_list args;

  1148     IN_VM(

  1149       jniCheck::validate_jmethod_id(thr, methodID);

  1150       jniCheck::validate_class(thr, cls, false);

  1151     )

  1152     va_start(args,methodID);

  1153     UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);

  1154     va_end(args);

  1155     functionExit(env);

  1156 JNI_END

  1158 JNI_ENTRY_CHECKED(void,

  1159   checked_jni_CallStaticVoidMethodV(JNIEnv *env,

  1160                                     jclass cls,

  1161                                     jmethodID methodID,

  1162                                     va_list args))

  1163     functionEnter(thr);

  1164     IN_VM(

  1165       jniCheck::validate_jmethod_id(thr, methodID);

  1166       jniCheck::validate_class(thr, cls, false);

  1167     )

  1168     UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);

  1169     functionExit(env);

  1170 JNI_END

  1172 JNI_ENTRY_CHECKED(void,

  1173   checked_jni_CallStaticVoidMethodA(JNIEnv *env,

  1174                                     jclass cls,

  1175                                     jmethodID methodID,

  1176                                     const jvalue * args))

  1177     functionEnter(thr);

  1178     IN_VM(

  1179       jniCheck::validate_jmethod_id(thr, methodID);

  1180       jniCheck::validate_class(thr, cls, false);

  1181     )

  1182     UNCHECKED()->CallStaticVoidMethodA(env,cls,methodID,args);

  1183     functionExit(env);

  1184 JNI_END

  1186 JNI_ENTRY_CHECKED(jfieldID,

  1187   checked_jni_GetStaticFieldID(JNIEnv *env,

  1188                                jclass clazz,

  1189                                const char *name,

  1190                                const char *sig))

  1191     functionEnter(thr);

  1192     IN_VM(

  1193       jniCheck::validate_class(thr, clazz, false);

  1194     )

  1195     jfieldID result = UNCHECKED()->GetStaticFieldID(env,clazz,name,sig);

  1196     functionExit(env);

  1197     return result;

  1198 JNI_END

  1200 #define WRAPPER_GetStaticField(ReturnType,Result,FieldType) \

  1201 JNI_ENTRY_CHECKED(ReturnType,  \

  1202   checked_jni_GetStatic##Result##Field(JNIEnv *env, \

  1203                                        jclass clazz, \

  1204                                        jfieldID fieldID)) \

  1205     functionEnter(thr); \

  1206     IN_VM( \

  1207       jniCheck::validate_class(thr, clazz, false); \

  1208       checkStaticFieldID(thr, fieldID, clazz, FieldType); \

  1209     ) \

  1210     ReturnType result = UNCHECKED()->GetStatic##Result##Field(env, \

  1211                                                               clazz, \

  1212                                                               fieldID); \

  1213     functionExit(env); \

  1214     return result; \

  1215 JNI_END

  1217 WRAPPER_GetStaticField(jobject,  Object,  T_OBJECT)

  1218 WRAPPER_GetStaticField(jboolean, Boolean, T_BOOLEAN)

  1219 WRAPPER_GetStaticField(jbyte,    Byte,    T_BYTE)

  1220 WRAPPER_GetStaticField(jshort,   Short,   T_SHORT)

  1221 WRAPPER_GetStaticField(jchar,    Char,    T_CHAR)

  1222 WRAPPER_GetStaticField(jint,     Int,     T_INT)

  1223 WRAPPER_GetStaticField(jlong,    Long,    T_LONG)

  1224 WRAPPER_GetStaticField(jfloat,   Float,   T_FLOAT)

  1225 WRAPPER_GetStaticField(jdouble,  Double,  T_DOUBLE)

  1227 #define WRAPPER_SetStaticField(ValueType,Result,FieldType) \

  1228 JNI_ENTRY_CHECKED(void,  \

  1229   checked_jni_SetStatic##Result##Field(JNIEnv *env, \

  1230                                        jclass clazz, \

  1231                                        jfieldID fieldID, \

  1232                                        ValueType value)) \

  1233     functionEnter(thr); \

  1234     IN_VM( \

  1235       jniCheck::validate_class(thr, clazz, false); \

  1236       checkStaticFieldID(thr, fieldID, clazz, FieldType); \

  1237     ) \

  1238     UNCHECKED()->SetStatic##Result##Field(env,clazz,fieldID,value); \

  1239     functionExit(env); \

  1240 JNI_END

  1242 WRAPPER_SetStaticField(jobject,  Object,  T_OBJECT)

  1243 WRAPPER_SetStaticField(jboolean, Boolean, T_BOOLEAN)

  1244 WRAPPER_SetStaticField(jbyte,    Byte,    T_BYTE)

  1245 WRAPPER_SetStaticField(jshort,   Short,   T_SHORT)

  1246 WRAPPER_SetStaticField(jchar,    Char,    T_CHAR)

  1247 WRAPPER_SetStaticField(jint,     Int,     T_INT)

  1248 WRAPPER_SetStaticField(jlong,    Long,    T_LONG)

  1249 WRAPPER_SetStaticField(jfloat,   Float,   T_FLOAT)

  1250 WRAPPER_SetStaticField(jdouble,  Double,  T_DOUBLE)

  1253 JNI_ENTRY_CHECKED(jstring,

  1254   checked_jni_NewString(JNIEnv *env,

  1255                         const jchar *unicode,

  1256                         jsize len))

  1257     functionEnter(thr);

  1258     jstring result = UNCHECKED()->NewString(env,unicode,len);

  1259     functionExit(env);

  1260     return result;

  1261 JNI_END

  1263 JNI_ENTRY_CHECKED(jsize,

  1264   checked_jni_GetStringLength(JNIEnv *env,

  1265                               jstring str))

  1266     functionEnter(thr);

  1267     IN_VM(

  1268       checkString(thr, str);

  1269     )

  1270     jsize result = UNCHECKED()->GetStringLength(env,str);

  1271     functionExit(env);

  1272     return result;

  1273 JNI_END

  1275 JNI_ENTRY_CHECKED(const jchar *,

  1276   checked_jni_GetStringChars(JNIEnv *env,

  1277                              jstring str,

  1278                              jboolean *isCopy))

  1279     functionEnter(thr);

  1280     IN_VM(

  1281       checkString(thr, str);

  1282     )

  1283     const jchar *result = UNCHECKED()->GetStringChars(env,str,isCopy);

  1284     functionExit(env);

  1285     return result;

  1286 JNI_END

  1288 JNI_ENTRY_CHECKED(void,

  1289   checked_jni_ReleaseStringChars(JNIEnv *env,

  1290                                  jstring str,

  1291                                  const jchar *chars))

  1292     functionEnterExceptionAllowed(thr);

  1293     IN_VM(

  1294       checkString(thr, str);

  1295     )

  1296     /* cannot check validity of copy, unless every request is logged by

  1297      * checking code.  Implementation of this check is deferred until a

  1298      * subsequent release.

  1299      */

  1300     UNCHECKED()->ReleaseStringChars(env,str,chars);

  1301     functionExit(env);

  1302 JNI_END

  1304 JNI_ENTRY_CHECKED(jstring,

  1305   checked_jni_NewStringUTF(JNIEnv *env,

  1306                            const char *utf))

  1307     functionEnter(thr);

  1308     jstring result = UNCHECKED()->NewStringUTF(env,utf);

  1309     functionExit(env);

  1310     return result;

  1311 JNI_END

  1313 JNI_ENTRY_CHECKED(jsize,

  1314   checked_jni_GetStringUTFLength(JNIEnv *env,

  1315                                  jstring str))

  1316     functionEnter(thr);

  1317     IN_VM(

  1318       checkString(thr, str);

  1319     )

  1320     jsize result = UNCHECKED()->GetStringUTFLength(env,str);

  1321     functionExit(env);

  1322     return result;

  1323 JNI_END

  1325 JNI_ENTRY_CHECKED(const char *,

  1326   checked_jni_GetStringUTFChars(JNIEnv *env,

  1327                                 jstring str,

  1328                                 jboolean *isCopy))

  1329     functionEnter(thr);

  1330     IN_VM(

  1331       checkString(thr, str);

  1332     )

  1333     const char *result = UNCHECKED()->GetStringUTFChars(env,str,isCopy);

  1334     functionExit(env);

  1335     return result;

  1336 JNI_END

  1338 JNI_ENTRY_CHECKED(void,

  1339   checked_jni_ReleaseStringUTFChars(JNIEnv *env,

  1340                                     jstring str,

  1341                                     const char* chars))

  1342     functionEnterExceptionAllowed(thr);

  1343     IN_VM(

  1344       checkString(thr, str);

  1345     )

  1346     /* cannot check validity of copy, unless every request is logged by

  1347      * checking code.  Implementation of this check is deferred until a

  1348      * subsequent release.

  1349      */

  1350     UNCHECKED()->ReleaseStringUTFChars(env,str,chars);

  1351     functionExit(env);

  1352 JNI_END

  1354 JNI_ENTRY_CHECKED(jsize,

  1355   checked_jni_GetArrayLength(JNIEnv *env,

  1356                              jarray array))

  1357     functionEnter(thr);

  1358     IN_VM(

  1359       checkArray(thr, array, -1);

  1360     )

  1361     jsize result = UNCHECKED()->GetArrayLength(env,array);

  1362     functionExit(env);

  1363     return result;

  1364 JNI_END

  1366 JNI_ENTRY_CHECKED(jobjectArray,

  1367   checked_jni_NewObjectArray(JNIEnv *env,

  1368                              jsize len,

  1369                              jclass clazz,

  1370                              jobject init))

  1371     functionEnter(thr);

  1372     jobjectArray result = UNCHECKED()->NewObjectArray(env,len,clazz,init);

  1373     functionExit(env);

  1374     return result;

  1375 JNI_END

  1377 JNI_ENTRY_CHECKED(jobject,

  1378   checked_jni_GetObjectArrayElement(JNIEnv *env,

  1379                                     jobjectArray array,

  1380                                     jsize index))

  1381     functionEnter(thr);

  1382     IN_VM(

  1383       checkArray(thr, array, T_OBJECT);

  1384     )

  1385     jobject result = UNCHECKED()->GetObjectArrayElement(env,array,index);

  1386     functionExit(env);

  1387     return result;

  1388 JNI_END

  1390 JNI_ENTRY_CHECKED(void,

  1391   checked_jni_SetObjectArrayElement(JNIEnv *env,

  1392                                     jobjectArray array,

  1393                                     jsize index,

  1394                                     jobject val))

  1395     functionEnter(thr);

  1396     IN_VM(

  1397       checkArray(thr, array, T_OBJECT);

  1398     )

  1399     UNCHECKED()->SetObjectArrayElement(env,array,index,val);

  1400     functionExit(env);

  1401 JNI_END

  1403 #define WRAPPER_NewScalarArray(Return, Result) \

  1404 JNI_ENTRY_CHECKED(Return, \

  1405   checked_jni_New##Result##Array(JNIEnv *env, \

  1406                                  jsize len)) \

  1407     functionEnter(thr); \

  1408     Return result = UNCHECKED()->New##Result##Array(env,len); \

  1409     functionExit(env); \

  1410     return (Return) result; \

  1411 JNI_END

  1413 WRAPPER_NewScalarArray(jbooleanArray, Boolean)

  1414 WRAPPER_NewScalarArray(jbyteArray, Byte)

  1415 WRAPPER_NewScalarArray(jshortArray, Short)

  1416 WRAPPER_NewScalarArray(jcharArray, Char)

  1417 WRAPPER_NewScalarArray(jintArray, Int)

  1418 WRAPPER_NewScalarArray(jlongArray, Long)

  1419 WRAPPER_NewScalarArray(jfloatArray, Float)

  1420 WRAPPER_NewScalarArray(jdoubleArray, Double)

  1422 #define WRAPPER_GetScalarArrayElements(ElementTag,ElementType,Result) \

  1423 JNI_ENTRY_CHECKED(ElementType *,  \

  1424   checked_jni_Get##Result##ArrayElements(JNIEnv *env, \

  1425                                          ElementType##Array array, \

  1426                                          jboolean *isCopy)) \

  1427     functionEnter(thr); \

  1428     IN_VM( \

  1429       checkArray(thr, array, ElementTag); \

  1430     ) \

  1431     ElementType *result = UNCHECKED()->Get##Result##ArrayElements(env, \

  1432                                                                   array, \

  1433                                                                   isCopy); \

  1434     functionExit(env); \

  1435     return result; \

  1436 JNI_END

  1438 WRAPPER_GetScalarArrayElements(T_BOOLEAN, jboolean, Boolean)

  1439 WRAPPER_GetScalarArrayElements(T_BYTE,    jbyte,    Byte)

  1440 WRAPPER_GetScalarArrayElements(T_SHORT,   jshort,   Short)

  1441 WRAPPER_GetScalarArrayElements(T_CHAR,    jchar,    Char)

  1442 WRAPPER_GetScalarArrayElements(T_INT,     jint,     Int)

  1443 WRAPPER_GetScalarArrayElements(T_LONG,    jlong,    Long)

  1444 WRAPPER_GetScalarArrayElements(T_FLOAT,   jfloat,   Float)

  1445 WRAPPER_GetScalarArrayElements(T_DOUBLE,  jdouble,  Double)

  1447 #define WRAPPER_ReleaseScalarArrayElements(ElementTag,ElementType,Result,Tag) \

  1448 JNI_ENTRY_CHECKED(void,  \

  1449   checked_jni_Release##Result##ArrayElements(JNIEnv *env, \

  1450                                              ElementType##Array array, \

  1451                                              ElementType *elems, \

  1452                                              jint mode)) \

  1453     functionEnterExceptionAllowed(thr); \

  1454     IN_VM( \

  1455       checkArray(thr, array, ElementTag); \

  1456       ASSERT_OOPS_ALLOWED; \

  1457       typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \

  1458       /* cannot check validity of copy, unless every request is logged by

  1459        * checking code.  Implementation of this check is deferred until a

  1460        * subsequent release.

  1461        */ \

  1462     ) \

  1463     UNCHECKED()->Release##Result##ArrayElements(env,array,elems,mode); \

  1464     functionExit(env); \

  1465 JNI_END

  1467 WRAPPER_ReleaseScalarArrayElements(T_BOOLEAN,jboolean, Boolean, bool)

  1468 WRAPPER_ReleaseScalarArrayElements(T_BYTE,   jbyte,    Byte,    byte)

  1469 WRAPPER_ReleaseScalarArrayElements(T_SHORT,  jshort,   Short,   short)

  1470 WRAPPER_ReleaseScalarArrayElements(T_CHAR,   jchar,    Char,    char)

  1471 WRAPPER_ReleaseScalarArrayElements(T_INT,    jint,     Int,     int)

  1472 WRAPPER_ReleaseScalarArrayElements(T_LONG,   jlong,    Long,    long)

  1473 WRAPPER_ReleaseScalarArrayElements(T_FLOAT,  jfloat,   Float,   float)

  1474 WRAPPER_ReleaseScalarArrayElements(T_DOUBLE, jdouble,  Double,  double)

  1476 #define WRAPPER_GetScalarArrayRegion(ElementTag,ElementType,Result) \

  1477 JNI_ENTRY_CHECKED(void,  \

  1478   checked_jni_Get##Result##ArrayRegion(JNIEnv *env, \

  1479                                        ElementType##Array array, \

  1480                                        jsize start, \

  1481                                        jsize len, \

  1482                                        ElementType *buf)) \

  1483     functionEnter(thr); \

  1484     IN_VM( \

  1485       checkArray(thr, array, ElementTag); \

  1486     ) \

  1487     UNCHECKED()->Get##Result##ArrayRegion(env,array,start,len,buf); \

  1488     functionExit(env); \

  1489 JNI_END

  1491 WRAPPER_GetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)

  1492 WRAPPER_GetScalarArrayRegion(T_BYTE,    jbyte,    Byte)

  1493 WRAPPER_GetScalarArrayRegion(T_SHORT,   jshort,   Short)

  1494 WRAPPER_GetScalarArrayRegion(T_CHAR,    jchar,    Char)

  1495 WRAPPER_GetScalarArrayRegion(T_INT,     jint,     Int)

  1496 WRAPPER_GetScalarArrayRegion(T_LONG,    jlong,    Long)

  1497 WRAPPER_GetScalarArrayRegion(T_FLOAT,   jfloat,   Float)

  1498 WRAPPER_GetScalarArrayRegion(T_DOUBLE,  jdouble,  Double)

  1500 #define WRAPPER_SetScalarArrayRegion(ElementTag,ElementType,Result) \

  1501 JNI_ENTRY_CHECKED(void,  \

  1502   checked_jni_Set##Result##ArrayRegion(JNIEnv *env, \

  1503                                        ElementType##Array array, \

  1504                                        jsize start, \

  1505                                        jsize len, \

  1506                                        const ElementType *buf)) \

  1507     functionEnter(thr); \

  1508     IN_VM( \

  1509       checkArray(thr, array, ElementTag); \

  1510     ) \

  1511     UNCHECKED()->Set##Result##ArrayRegion(env,array,start,len,buf); \

  1512     functionExit(env); \

  1513 JNI_END

  1515 WRAPPER_SetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)

  1516 WRAPPER_SetScalarArrayRegion(T_BYTE,    jbyte,    Byte)

  1517 WRAPPER_SetScalarArrayRegion(T_SHORT,   jshort,   Short)

  1518 WRAPPER_SetScalarArrayRegion(T_CHAR,    jchar,    Char)

  1519 WRAPPER_SetScalarArrayRegion(T_INT,     jint,     Int)

  1520 WRAPPER_SetScalarArrayRegion(T_LONG,    jlong,    Long)

  1521 WRAPPER_SetScalarArrayRegion(T_FLOAT,   jfloat,   Float)

  1522 WRAPPER_SetScalarArrayRegion(T_DOUBLE,  jdouble,  Double)

  1524 JNI_ENTRY_CHECKED(jint,

  1525   checked_jni_RegisterNatives(JNIEnv *env,

  1526                               jclass clazz,

  1527                               const JNINativeMethod *methods,

  1528                               jint nMethods))

  1529     functionEnter(thr);

  1530     jint result = UNCHECKED()->RegisterNatives(env,clazz,methods,nMethods);

  1531     functionExit(env);

  1532     return result;

  1533 JNI_END

  1535 JNI_ENTRY_CHECKED(jint,

  1536   checked_jni_UnregisterNatives(JNIEnv *env,

  1537                                 jclass clazz))

  1538     functionEnter(thr);

  1539     jint result = UNCHECKED()->UnregisterNatives(env,clazz);

  1540     functionExit(env);

  1541     return result;

  1542 JNI_END

  1544 JNI_ENTRY_CHECKED(jint,

  1545   checked_jni_MonitorEnter(JNIEnv *env,

  1546                            jobject obj))

  1547     functionEnter(thr);

  1548     IN_VM(

  1549       jniCheck::validate_object(thr, obj);

  1550     )

  1551     jint result = UNCHECKED()->MonitorEnter(env,obj);

  1552     functionExit(env);

  1553     return result;

  1554 JNI_END

  1556 JNI_ENTRY_CHECKED(jint,

  1557   checked_jni_MonitorExit(JNIEnv *env,

  1558                           jobject obj))

  1559     functionEnterExceptionAllowed(thr);

  1560     IN_VM(

  1561       jniCheck::validate_object(thr, obj);

  1562     )

  1563     jint result = UNCHECKED()->MonitorExit(env,obj);

  1564     functionExit(env);

  1565     return result;

  1566 JNI_END

  1568 JNI_ENTRY_CHECKED(jint,

  1569   checked_jni_GetJavaVM(JNIEnv *env,

  1570                         JavaVM **vm))

  1571     functionEnter(thr);

  1572     jint result = UNCHECKED()->GetJavaVM(env,vm);

  1573     functionExit(env);

  1574     return result;

  1575 JNI_END

  1577 JNI_ENTRY_CHECKED(void,

  1578   checked_jni_GetStringRegion(JNIEnv *env,

  1579                               jstring str,

  1580                               jsize start,

  1581                               jsize len,

  1582                               jchar *buf))

  1583     functionEnter(thr);

  1584     IN_VM(

  1585       checkString(thr, str);

  1586     )

  1587     UNCHECKED()->GetStringRegion(env, str, start, len, buf);

  1588     functionExit(env);

  1589 JNI_END

  1591 JNI_ENTRY_CHECKED(void,

  1592   checked_jni_GetStringUTFRegion(JNIEnv *env,

  1593                                  jstring str,

  1594                                  jsize start,

  1595                                  jsize len,

  1596                                  char *buf))

  1597     functionEnter(thr);

  1598     IN_VM(

  1599       checkString(thr, str);

  1600     )

  1601     UNCHECKED()->GetStringUTFRegion(env, str, start, len, buf);

  1602     functionExit(env);

  1603 JNI_END

  1605 JNI_ENTRY_CHECKED(void *,

  1606   checked_jni_GetPrimitiveArrayCritical(JNIEnv *env,

  1607                                         jarray array,

  1608                                         jboolean *isCopy))

  1609     functionEnterCritical(thr);

  1610     IN_VM(

  1611       checkArray(thr, array, -1);

  1612     )

  1613     void *result = UNCHECKED()->GetPrimitiveArrayCritical(env, array, isCopy);

  1614     functionExit(env);

  1615     return result;

  1616 JNI_END

  1618 JNI_ENTRY_CHECKED(void,

  1619   checked_jni_ReleasePrimitiveArrayCritical(JNIEnv *env,

  1620                                             jarray array,

  1621                                             void *carray,

  1622                                             jint mode))

  1623     functionEnterCriticalExceptionAllowed(thr);

  1624     IN_VM(

  1625       checkArray(thr, array, -1);

  1626     )

  1627     /* The Hotspot JNI code does not use the parameters, so just check the

  1628      * array parameter as a minor sanity check

  1629      */

  1630     UNCHECKED()->ReleasePrimitiveArrayCritical(env, array, carray, mode);

  1631     functionExit(env);

  1632 JNI_END

  1634 JNI_ENTRY_CHECKED(const jchar*,

  1635   checked_jni_GetStringCritical(JNIEnv *env,

  1636                                 jstring string,

  1637                                 jboolean *isCopy))

  1638     functionEnterCritical(thr);

  1639     IN_VM(

  1640       checkString(thr, string);

  1641     )

  1642     const jchar *result = UNCHECKED()->GetStringCritical(env, string, isCopy);

  1643     functionExit(env);

  1644     return result;

  1645 JNI_END

  1647 JNI_ENTRY_CHECKED(void,

  1648   checked_jni_ReleaseStringCritical(JNIEnv *env,

  1649                                     jstring str,

  1650                                     const jchar *chars))

  1651     functionEnterCriticalExceptionAllowed(thr);

  1652     IN_VM(

  1653       checkString(thr, str);

  1654     )

  1655     /* The Hotspot JNI code does not use the parameters, so just check the

  1656      * string parameter as a minor sanity check

  1657      */

  1658     UNCHECKED()->ReleaseStringCritical(env, str, chars);

  1659     functionExit(env);

  1660 JNI_END

  1662 JNI_ENTRY_CHECKED(jweak,

  1663   checked_jni_NewWeakGlobalRef(JNIEnv *env,

  1664                                jobject obj))

  1665     functionEnter(thr);

  1666     IN_VM(

  1667       if (obj != NULL) {

  1668         jniCheck::validate_handle(thr, obj);

  1669       }

  1670     )

  1671     jweak result = UNCHECKED()->NewWeakGlobalRef(env, obj);

  1672     functionExit(env);

  1673     return result;

  1674 JNI_END

  1676 JNI_ENTRY_CHECKED(void,

  1677   checked_jni_DeleteWeakGlobalRef(JNIEnv *env,

  1678                                   jweak ref))

  1679     functionEnterExceptionAllowed(thr);

  1680     UNCHECKED()->DeleteWeakGlobalRef(env, ref);

  1681     functionExit(env);

  1682 JNI_END

  1684 JNI_ENTRY_CHECKED(jboolean,

  1685   checked_jni_ExceptionCheck(JNIEnv *env))

  1686     functionEnterExceptionAllowed(thr);

  1687     jboolean result = UNCHECKED()->ExceptionCheck(env);

  1688     functionExit(env);

  1689     return result;

  1690 JNI_END

  1692 JNI_ENTRY_CHECKED(jobject,

  1693   checked_jni_NewDirectByteBuffer(JNIEnv *env,

  1694                                   void *address,

  1695                                   jlong capacity))

  1696     functionEnter(thr);

  1697     jobject result = UNCHECKED()->NewDirectByteBuffer(env, address, capacity);

  1698     functionExit(env);

  1699     return result;

  1700 JNI_END

  1702 JNI_ENTRY_CHECKED(void *,

  1703   checked_jni_GetDirectBufferAddress(JNIEnv *env,

  1704                                      jobject buf))

  1705     functionEnter(thr);

  1706     void* result = UNCHECKED()->GetDirectBufferAddress(env, buf);

  1707     functionExit(env);

  1708     return result;

  1709 JNI_END

  1711 JNI_ENTRY_CHECKED(jlong,

  1712   checked_jni_GetDirectBufferCapacity(JNIEnv *env,

  1713                                       jobject buf))

  1714     functionEnter(thr);

  1715     jlong result = UNCHECKED()->GetDirectBufferCapacity(env, buf);

  1716     functionExit(env);

  1717     return result;

  1718 JNI_END

  1720 JNI_ENTRY_CHECKED(jobjectRefType,

  1721   checked_jni_GetObjectRefType(JNIEnv *env,

  1722                                jobject obj))

  1723     functionEnter(thr);

  1724     /* validate the object being passed */

  1725     IN_VM(

  1726       jniCheck::validate_object(thr, obj);

  1727     )

  1728     jobjectRefType result = UNCHECKED()->GetObjectRefType(env, obj);

  1729     functionExit(env);

  1730     return result;

  1731 JNI_END

  1734 JNI_ENTRY_CHECKED(jint,

  1735   checked_jni_GetVersion(JNIEnv *env))

  1736     functionEnter(thr);

  1737     jint result = UNCHECKED()->GetVersion(env);

  1738     functionExit(env);

  1739     return result;

  1740 JNI_END

  1744 /*

  1745  * Structure containing all checked jni functions

  1746  */

  1747 struct JNINativeInterface_  checked_jni_NativeInterface = {

  1748     NULL,

  1749     NULL,

  1750     NULL,

  1752     NULL,

  1754     checked_jni_GetVersion,

  1756     checked_jni_DefineClass,

  1757     checked_jni_FindClass,

  1759     checked_jni_FromReflectedMethod,

  1760     checked_jni_FromReflectedField,

  1762     checked_jni_ToReflectedMethod,

  1764     checked_jni_GetSuperclass,

  1765     checked_jni_IsAssignableFrom,

  1767     checked_jni_ToReflectedField,

  1769     checked_jni_Throw,

  1770     checked_jni_ThrowNew,

  1771     checked_jni_ExceptionOccurred,

  1772     checked_jni_ExceptionDescribe,

  1773     checked_jni_ExceptionClear,

  1774     checked_jni_FatalError,

  1776     checked_jni_PushLocalFrame,

  1777     checked_jni_PopLocalFrame,

  1779     checked_jni_NewGlobalRef,

  1780     checked_jni_DeleteGlobalRef,

  1781     checked_jni_DeleteLocalRef,

  1782     checked_jni_IsSameObject,

  1784     checked_jni_NewLocalRef,

  1785     checked_jni_EnsureLocalCapacity,

  1787     checked_jni_AllocObject,

  1788     checked_jni_NewObject,

  1789     checked_jni_NewObjectV,

  1790     checked_jni_NewObjectA,

  1792     checked_jni_GetObjectClass,

  1793     checked_jni_IsInstanceOf,

  1795     checked_jni_GetMethodID,

  1797     checked_jni_CallObjectMethod,

  1798     checked_jni_CallObjectMethodV,

  1799     checked_jni_CallObjectMethodA,

  1800     checked_jni_CallBooleanMethod,

  1801     checked_jni_CallBooleanMethodV,

  1802     checked_jni_CallBooleanMethodA,

  1803     checked_jni_CallByteMethod,

  1804     checked_jni_CallByteMethodV,

  1805     checked_jni_CallByteMethodA,

  1806     checked_jni_CallCharMethod,

  1807     checked_jni_CallCharMethodV,

  1808     checked_jni_CallCharMethodA,

  1809     checked_jni_CallShortMethod,

  1810     checked_jni_CallShortMethodV,

  1811     checked_jni_CallShortMethodA,

  1812     checked_jni_CallIntMethod,

  1813     checked_jni_CallIntMethodV,

  1814     checked_jni_CallIntMethodA,

  1815     checked_jni_CallLongMethod,

  1816     checked_jni_CallLongMethodV,

  1817     checked_jni_CallLongMethodA,

  1818     checked_jni_CallFloatMethod,

  1819     checked_jni_CallFloatMethodV,

  1820     checked_jni_CallFloatMethodA,

  1821     checked_jni_CallDoubleMethod,

  1822     checked_jni_CallDoubleMethodV,

  1823     checked_jni_CallDoubleMethodA,

  1824     checked_jni_CallVoidMethod,

  1825     checked_jni_CallVoidMethodV,

  1826     checked_jni_CallVoidMethodA,

  1828     checked_jni_CallNonvirtualObjectMethod,

  1829     checked_jni_CallNonvirtualObjectMethodV,

  1830     checked_jni_CallNonvirtualObjectMethodA,

  1831     checked_jni_CallNonvirtualBooleanMethod,

  1832     checked_jni_CallNonvirtualBooleanMethodV,

  1833     checked_jni_CallNonvirtualBooleanMethodA,

  1834     checked_jni_CallNonvirtualByteMethod,

  1835     checked_jni_CallNonvirtualByteMethodV,

  1836     checked_jni_CallNonvirtualByteMethodA,

  1837     checked_jni_CallNonvirtualCharMethod,

  1838     checked_jni_CallNonvirtualCharMethodV,

  1839     checked_jni_CallNonvirtualCharMethodA,

  1840     checked_jni_CallNonvirtualShortMethod,

  1841     checked_jni_CallNonvirtualShortMethodV,

  1842     checked_jni_CallNonvirtualShortMethodA,

  1843     checked_jni_CallNonvirtualIntMethod,

  1844     checked_jni_CallNonvirtualIntMethodV,

  1845     checked_jni_CallNonvirtualIntMethodA,

  1846     checked_jni_CallNonvirtualLongMethod,

  1847     checked_jni_CallNonvirtualLongMethodV,

  1848     checked_jni_CallNonvirtualLongMethodA,

  1849     checked_jni_CallNonvirtualFloatMethod,

  1850     checked_jni_CallNonvirtualFloatMethodV,

  1851     checked_jni_CallNonvirtualFloatMethodA,

  1852     checked_jni_CallNonvirtualDoubleMethod,

  1853     checked_jni_CallNonvirtualDoubleMethodV,

  1854     checked_jni_CallNonvirtualDoubleMethodA,

  1855     checked_jni_CallNonvirtualVoidMethod,

  1856     checked_jni_CallNonvirtualVoidMethodV,

  1857     checked_jni_CallNonvirtualVoidMethodA,

  1859     checked_jni_GetFieldID,

  1861     checked_jni_GetObjectField,

  1862     checked_jni_GetBooleanField,

  1863     checked_jni_GetByteField,

  1864     checked_jni_GetCharField,

  1865     checked_jni_GetShortField,

  1866     checked_jni_GetIntField,

  1867     checked_jni_GetLongField,

  1868     checked_jni_GetFloatField,

  1869     checked_jni_GetDoubleField,

  1871     checked_jni_SetObjectField,

  1872     checked_jni_SetBooleanField,

  1873     checked_jni_SetByteField,

  1874     checked_jni_SetCharField,

  1875     checked_jni_SetShortField,

  1876     checked_jni_SetIntField,

  1877     checked_jni_SetLongField,

  1878     checked_jni_SetFloatField,

  1879     checked_jni_SetDoubleField,

  1881     checked_jni_GetStaticMethodID,

  1883     checked_jni_CallStaticObjectMethod,

  1884     checked_jni_CallStaticObjectMethodV,

  1885     checked_jni_CallStaticObjectMethodA,

  1886     checked_jni_CallStaticBooleanMethod,

  1887     checked_jni_CallStaticBooleanMethodV,

  1888     checked_jni_CallStaticBooleanMethodA,

  1889     checked_jni_CallStaticByteMethod,

  1890     checked_jni_CallStaticByteMethodV,

  1891     checked_jni_CallStaticByteMethodA,

  1892     checked_jni_CallStaticCharMethod,

  1893     checked_jni_CallStaticCharMethodV,

  1894     checked_jni_CallStaticCharMethodA,

  1895     checked_jni_CallStaticShortMethod,

  1896     checked_jni_CallStaticShortMethodV,

  1897     checked_jni_CallStaticShortMethodA,

  1898     checked_jni_CallStaticIntMethod,

  1899     checked_jni_CallStaticIntMethodV,

  1900     checked_jni_CallStaticIntMethodA,

  1901     checked_jni_CallStaticLongMethod,

  1902     checked_jni_CallStaticLongMethodV,

  1903     checked_jni_CallStaticLongMethodA,

  1904     checked_jni_CallStaticFloatMethod,

  1905     checked_jni_CallStaticFloatMethodV,

  1906     checked_jni_CallStaticFloatMethodA,

  1907     checked_jni_CallStaticDoubleMethod,

  1908     checked_jni_CallStaticDoubleMethodV,

  1909     checked_jni_CallStaticDoubleMethodA,

  1910     checked_jni_CallStaticVoidMethod,

  1911     checked_jni_CallStaticVoidMethodV,

  1912     checked_jni_CallStaticVoidMethodA,

  1914     checked_jni_GetStaticFieldID,

  1916     checked_jni_GetStaticObjectField,

  1917     checked_jni_GetStaticBooleanField,

  1918     checked_jni_GetStaticByteField,

  1919     checked_jni_GetStaticCharField,

  1920     checked_jni_GetStaticShortField,

  1921     checked_jni_GetStaticIntField,

  1922     checked_jni_GetStaticLongField,

  1923     checked_jni_GetStaticFloatField,

  1924     checked_jni_GetStaticDoubleField,

  1926     checked_jni_SetStaticObjectField,

  1927     checked_jni_SetStaticBooleanField,

  1928     checked_jni_SetStaticByteField,

  1929     checked_jni_SetStaticCharField,

  1930     checked_jni_SetStaticShortField,

  1931     checked_jni_SetStaticIntField,

  1932     checked_jni_SetStaticLongField,

  1933     checked_jni_SetStaticFloatField,

  1934     checked_jni_SetStaticDoubleField,

  1936     checked_jni_NewString,

  1937     checked_jni_GetStringLength,

  1938     checked_jni_GetStringChars,

  1939     checked_jni_ReleaseStringChars,

  1941     checked_jni_NewStringUTF,

  1942     checked_jni_GetStringUTFLength,

  1943     checked_jni_GetStringUTFChars,

  1944     checked_jni_ReleaseStringUTFChars,

  1946     checked_jni_GetArrayLength,

  1948     checked_jni_NewObjectArray,

  1949     checked_jni_GetObjectArrayElement,

  1950     checked_jni_SetObjectArrayElement,

  1952     checked_jni_NewBooleanArray,

  1953     checked_jni_NewByteArray,

  1954     checked_jni_NewCharArray,

  1955     checked_jni_NewShortArray,

  1956     checked_jni_NewIntArray,

  1957     checked_jni_NewLongArray,

  1958     checked_jni_NewFloatArray,

  1959     checked_jni_NewDoubleArray,

  1961     checked_jni_GetBooleanArrayElements,

  1962     checked_jni_GetByteArrayElements,

  1963     checked_jni_GetCharArrayElements,

  1964     checked_jni_GetShortArrayElements,

  1965     checked_jni_GetIntArrayElements,

  1966     checked_jni_GetLongArrayElements,

  1967     checked_jni_GetFloatArrayElements,

  1968     checked_jni_GetDoubleArrayElements,

  1970     checked_jni_ReleaseBooleanArrayElements,

  1971     checked_jni_ReleaseByteArrayElements,

  1972     checked_jni_ReleaseCharArrayElements,

  1973     checked_jni_ReleaseShortArrayElements,

  1974     checked_jni_ReleaseIntArrayElements,

  1975     checked_jni_ReleaseLongArrayElements,

  1976     checked_jni_ReleaseFloatArrayElements,

  1977     checked_jni_ReleaseDoubleArrayElements,

  1979     checked_jni_GetBooleanArrayRegion,

  1980     checked_jni_GetByteArrayRegion,

  1981     checked_jni_GetCharArrayRegion,

  1982     checked_jni_GetShortArrayRegion,

  1983     checked_jni_GetIntArrayRegion,

  1984     checked_jni_GetLongArrayRegion,

  1985     checked_jni_GetFloatArrayRegion,

  1986     checked_jni_GetDoubleArrayRegion,

  1988     checked_jni_SetBooleanArrayRegion,

  1989     checked_jni_SetByteArrayRegion,

  1990     checked_jni_SetCharArrayRegion,

  1991     checked_jni_SetShortArrayRegion,

  1992     checked_jni_SetIntArrayRegion,

  1993     checked_jni_SetLongArrayRegion,

  1994     checked_jni_SetFloatArrayRegion,

  1995     checked_jni_SetDoubleArrayRegion,

  1997     checked_jni_RegisterNatives,

  1998     checked_jni_UnregisterNatives,

  2000     checked_jni_MonitorEnter,

  2001     checked_jni_MonitorExit,

  2003     checked_jni_GetJavaVM,

  2005     checked_jni_GetStringRegion,

  2006     checked_jni_GetStringUTFRegion,

  2008     checked_jni_GetPrimitiveArrayCritical,

  2009     checked_jni_ReleasePrimitiveArrayCritical,

  2011     checked_jni_GetStringCritical,

  2012     checked_jni_ReleaseStringCritical,

  2014     checked_jni_NewWeakGlobalRef,

  2015     checked_jni_DeleteWeakGlobalRef,

  2017     checked_jni_ExceptionCheck,

  2019     checked_jni_NewDirectByteBuffer,

  2020     checked_jni_GetDirectBufferAddress,

  2021     checked_jni_GetDirectBufferCapacity,

  2023     // New 1.6 Features

  2025     checked_jni_GetObjectRefType

  2026 };

  2029 // Returns the function structure

  2030 struct JNINativeInterface_* jni_functions_check() {

  2032   unchecked_jni_NativeInterface = jni_functions_nocheck();

  2034   // make sure the last pointer in the checked table is not null, indicating

  2035   // an addition to the JNINativeInterface_ structure without initializing

  2036   // it in the checked table.

  2037   debug_only(int *lastPtr = (int *)((char *)&checked_jni_NativeInterface + \

  2038              sizeof(*unchecked_jni_NativeInterface) - sizeof(char *));)

  2039   assert(*lastPtr != 0,

  2040          "Mismatched JNINativeInterface tables, check for new entries");

  2042   // with -verbose:jni this message will print

  2043   if (PrintJNIResolving) {

  2044     tty->print_cr("Checked JNI functions are being used to " \

  2045                   "validate JNI usage");

  2046   }

  2048   return &checked_jni_NativeInterface;

  2049 }

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/prims/jniCheck.cpp@f008d3631bd1

src/share/vm/prims/jniCheck.cpp