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

6941466: Oracle rebranding changes for Hotspot repositories
Summary: Change all the Sun copyrights to Oracle copyright
Reviewed-by: ohair

     1 /*

     2  * Copyright (c) 2001, 2009, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * 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_non_weak_method = "non-weak methodID passed to JNI call";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   116 // When in VM state:

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

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

   119   thr->print_stack();

   120 }

   122 // When in NATIVE state:

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

   124   IN_VM(

   125     ReportJNIFatalError(thr, msg);

   126   )

   127 }

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

   130   IN_VM(

   131     ReportJNIWarning(thr, msg);

   132   )

   133 }

   138 /*

   139  * SUPPORT FUNCTIONS

   140  */

   142 static inline void

   143 functionEnterCritical(JavaThread* thr)

   144 {

   145   if (thr->has_pending_exception()) {

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

   147   }

   148 }

   150 static inline void

   151 functionEnterCriticalExceptionAllowed(JavaThread* thr)

   152 {

   153 }

   155 static inline void

   156 functionEnter(JavaThread* thr)

   157 {

   158   if (thr->in_critical()) {

   159     tty->print_cr(warn_other_function_in_critical);

   160   }

   161   if (thr->has_pending_exception()) {

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

   163   }

   164 }

   166 static inline void

   167 functionEnterExceptionAllowed(JavaThread* thr)

   168 {

   169   if (thr->in_critical()) {

   170     tty->print_cr(warn_other_function_in_critical);

   171   }

   172 }

   174 static inline void

   175 functionExit(JNIEnv *env)

   176 {

   177   /* nothing to do at this time */

   178 }

   180 static inline void

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

   182 {

   183   fieldDescriptor fd;

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

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

   187     ReportJNIFatalError(thr, fatal_should_be_static);

   189   /* validate the class being passed */

   190   ASSERT_OOPS_ALLOWED;

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

   193   /* check for proper subclass hierarchy */

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

   195   klassOop f_oop = id->holder();

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

   197     ReportJNIFatalError(thr, fatal_wrong_static_field);

   199   /* check for proper field type */

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

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

   202     ReportJNIFatalError(thr, fatal_static_field_not_found);

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

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

   205     ReportJNIFatalError(thr, fatal_static_field_mismatch);

   206   }

   207 }

   209 static inline void

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

   211 {

   212   fieldDescriptor fd;

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

   215   if (jfieldIDWorkaround::is_static_jfieldID(fid))

   216     ReportJNIFatalError(thr, fatal_should_be_nonstatic);

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

   219   ASSERT_OOPS_ALLOWED;

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

   221   if (!oopObj) {

   222     ReportJNIFatalError(thr, fatal_null_object);

   223   }

   224   klassOop k_oop = oopObj->klass();

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

   227     ReportJNIFatalError(thr, fatal_wrong_field);

   228   }

   230   /* make sure the field exists */

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

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

   233     ReportJNIFatalError(thr, fatal_wrong_field);

   235   /* check for proper field type */

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

   237                                                               false, &fd))

   238     ReportJNIFatalError(thr, fatal_instance_field_not_found);

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

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

   242     ReportJNIFatalError(thr, fatal_instance_field_mismatch);

   243   }

   244 }

   246 static inline void

   247 checkString(JavaThread* thr, jstring js)

   248 {

   249   ASSERT_OOPS_ALLOWED;

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

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

   252     ReportJNIFatalError(thr, fatal_non_string);

   253 }

   255 static inline void

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

   257 {

   258   ASSERT_OOPS_ALLOWED;

   259   arrayOop aOop;

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

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

   263     ReportJNIFatalError(thr, fatal_non_array);

   265   if (elementType != -1) {

   266     if (aOop->is_typeArray()) {

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

   268       if (array_type != elementType)

   269         ReportJNIFatalError(thr, fatal_element_type_mismatch);

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

   271         if ( T_OBJECT != elementType)

   272           ReportJNIFatalError(thr, fatal_object_array_expected);

   273       } else {

   274         ReportJNIFatalError(thr, fatal_unknown_array_object);

   275     }

   276   }

   277 }

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

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

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

   283       JNIHandles::is_global_handle(obj) ||

   284       JNIHandles::is_weak_global_handle(obj)) {

   285     ASSERT_OOPS_ALLOWED;

   286     return JNIHandles::resolve_external_guard(obj);

   287   }

   288   ReportJNIFatalError(thr, fatal_bad_ref_to_jni);

   289   return NULL;

   290 }

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

   294   ASSERT_OOPS_ALLOWED;

   295   // do the fast jmethodID check first

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

   297   if (moop == NULL) {

   298     ReportJNIFatalError(thr, fatal_wrong_class_or_method);

   299   }

   300   // jmethodIDs are supposed to be weak global handles, but that

   301   // can be expensive so check it last

   302   else if (!JNIHandles::is_weak_global_handle((jobject) method_id)) {

   303     ReportJNIFatalError(thr, fatal_non_weak_method);

   304   }

   305   return moop;

   306 }

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

   310     if (!obj)

   311         return NULL;

   312     ASSERT_OOPS_ALLOWED;

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

   314     if (!oopObj) {

   315       ReportJNIFatalError(thr, fatal_bad_ref_to_jni);

   316     }

   317     return oopObj;

   318 }

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

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

   322 // array descriptors.

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

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

   326   size_t len = strlen(name);

   328   if (len >= 2 &&

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

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

   331     char msg[JVM_MAXPATHLEN];

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

   333     ReportJNIWarning(thr, msg);

   334   }

   335 }

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

   338   ASSERT_OOPS_ALLOWED;

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

   340   if (!mirror) {

   341     ReportJNIFatalError(thr, fatal_received_null_class);

   342   }

   344   if (mirror->klass() != SystemDictionary::Class_klass()) {

   345     ReportJNIFatalError(thr, fatal_class_not_a_class);

   346   }

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

   349   // Make allowances for primitive classes ...

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

   351     ReportJNIFatalError(thr, fatal_class_not_a_class);

   352   }

   353   return k;

   354 }

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

   357   ASSERT_OOPS_ALLOWED;

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

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

   361       !instanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) {

   362     ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);

   363   }

   364 }

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

   367   /* validate the object being passed */

   368   ASSERT_OOPS_ALLOWED;

   369   jniCheck::validate_jmethod_id(thr, method_id);

   370   jniCheck::validate_object(thr, obj);

   371 }

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

   374   /* validate the class being passed */

   375   ASSERT_OOPS_ALLOWED;

   376   jniCheck::validate_jmethod_id(thr, method_id);

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

   378 }

   381 /*

   382  * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE

   383  */

   385 JNI_ENTRY_CHECKED(jclass,

   386   checked_jni_DefineClass(JNIEnv *env,

   387                           const char *name,

   388                           jobject loader,

   389                           const jbyte *buf,

   390                           jsize len))

   391     functionEnter(thr);

   392     IN_VM(

   393       jniCheck::validate_object(thr, loader);

   394     )

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

   396     functionExit(env);

   397     return result;

   398 JNI_END

   400 JNI_ENTRY_CHECKED(jclass,

   401   checked_jni_FindClass(JNIEnv *env,

   402                         const char *name))

   403     functionEnter(thr);

   404     IN_VM(

   405       jniCheck::validate_class_descriptor(thr, name);

   406     )

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

   408     functionExit(env);

   409     return result;

   410 JNI_END

   412 JNI_ENTRY_CHECKED(jmethodID,

   413   checked_jni_FromReflectedMethod(JNIEnv *env,

   414                                   jobject method))

   415     functionEnter(thr);

   416     IN_VM(

   417       jniCheck::validate_object(thr, method);

   418     )

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

   420     functionExit(env);

   421     return result;

   422 JNI_END

   424 JNI_ENTRY_CHECKED(jfieldID,

   425   checked_jni_FromReflectedField(JNIEnv *env,

   426                                  jobject field))

   427     functionEnter(thr);

   428     IN_VM(

   429       jniCheck::validate_object(thr, field);

   430     )

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

   432     functionExit(env);

   433     return result;

   434 JNI_END

   436 JNI_ENTRY_CHECKED(jobject,

   437   checked_jni_ToReflectedMethod(JNIEnv *env,

   438                                 jclass cls,

   439                                 jmethodID methodID,

   440                                 jboolean isStatic))

   441     functionEnter(thr);

   442     IN_VM(

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

   444       jniCheck::validate_jmethod_id(thr, methodID);

   445     )

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

   447                                                     isStatic);

   448     functionExit(env);

   449     return result;

   450 JNI_END

   452 JNI_ENTRY_CHECKED(jclass,

   453   checked_jni_GetSuperclass(JNIEnv *env,

   454                             jclass sub))

   455     functionEnter(thr);

   456     IN_VM(

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

   458     )

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

   460     functionExit(env);

   461     return result;

   462 JNI_END

   464 JNI_ENTRY_CHECKED(jboolean,

   465   checked_jni_IsAssignableFrom(JNIEnv *env,

   466                                jclass sub,

   467                                jclass sup))

   468     functionEnter(thr);

   469     IN_VM(

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

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

   472     )

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

   474     functionExit(env);

   475     return result;

   476 JNI_END

   478 JNI_ENTRY_CHECKED(jobject,

   479   checked_jni_ToReflectedField(JNIEnv *env,

   480                                jclass cls,

   481                                jfieldID fieldID,

   482                                jboolean isStatic))

   483     functionEnter(thr);

   484     IN_VM(

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

   486     )

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

   488                                                    isStatic);

   489     functionExit(env);

   490     return result;

   491 JNI_END

   493 JNI_ENTRY_CHECKED(jint,

   494   checked_jni_Throw(JNIEnv *env,

   495                     jthrowable obj))

   496     functionEnter(thr);

   497     IN_VM(

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

   499       if (oopObj == NULL) {

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

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

   502       } else {

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

   504       }

   505     )

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

   507     functionExit(env);

   508     return result;

   509 JNI_END

   511 JNI_ENTRY_CHECKED(jint,

   512   checked_jni_ThrowNew(JNIEnv *env,

   513                        jclass clazz,

   514                        const char *msg))

   515     functionEnter(thr);

   516     IN_VM(

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

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

   519       jniCheck::validate_throwable_klass(thr, k);

   520     )

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

   522     functionExit(env);

   523     return result;

   524 JNI_END

   526 JNI_ENTRY_CHECKED(jthrowable,

   527   checked_jni_ExceptionOccurred(JNIEnv *env))

   528     functionEnterExceptionAllowed(thr);

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

   530     functionExit(env);

   531     return result;

   532 JNI_END

   534 JNI_ENTRY_CHECKED(void,

   535   checked_jni_ExceptionDescribe(JNIEnv *env))

   536     functionEnterExceptionAllowed(thr);

   537     UNCHECKED()->ExceptionDescribe(env);

   538     functionExit(env);

   539 JNI_END

   541 JNI_ENTRY_CHECKED(void,

   542   checked_jni_ExceptionClear(JNIEnv *env))

   543     functionEnterExceptionAllowed(thr);

   544     UNCHECKED()->ExceptionClear(env);

   545     functionExit(env);

   546 JNI_END

   548 JNI_ENTRY_CHECKED(void,

   549   checked_jni_FatalError(JNIEnv *env,

   550                          const char *msg))

   551     functionEnter(thr);

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

   553     functionExit(env);

   554 JNI_END

   556 JNI_ENTRY_CHECKED(jint,

   557   checked_jni_PushLocalFrame(JNIEnv *env,

   558                              jint capacity))

   559     functionEnterExceptionAllowed(thr);

   560     if (capacity < 0)

   561       NativeReportJNIFatalError(thr, "negative capacity");

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

   563     functionExit(env);

   564     return result;

   565 JNI_END

   567 JNI_ENTRY_CHECKED(jobject,

   568   checked_jni_PopLocalFrame(JNIEnv *env,

   569                             jobject result))

   570     functionEnterExceptionAllowed(thr);

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

   572     functionExit(env);

   573     return res;

   574 JNI_END

   576 JNI_ENTRY_CHECKED(jobject,

   577   checked_jni_NewGlobalRef(JNIEnv *env,

   578                            jobject lobj))

   579     functionEnter(thr);

   580     IN_VM(

   581       if (lobj != NULL) {

   582         jniCheck::validate_handle(thr, lobj);

   583       }

   584     )

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

   586     functionExit(env);

   587     return result;

   588 JNI_END

   590 JNI_ENTRY_CHECKED(void,

   591   checked_jni_DeleteGlobalRef(JNIEnv *env,

   592                               jobject gref))

   593     functionEnterExceptionAllowed(thr);

   594     IN_VM(

   595       jniCheck::validate_object(thr, gref);

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

   597         ReportJNIFatalError(thr,

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

   599       }

   600     )

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

   602     functionExit(env);

   603 JNI_END

   605 JNI_ENTRY_CHECKED(void,

   606   checked_jni_DeleteLocalRef(JNIEnv *env,

   607                              jobject obj))

   608     functionEnterExceptionAllowed(thr);

   609     IN_VM(

   610       jniCheck::validate_object(thr, obj);

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

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

   613         ReportJNIFatalError(thr,

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

   615     )

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

   617     functionExit(env);

   618 JNI_END

   620 JNI_ENTRY_CHECKED(jboolean,

   621   checked_jni_IsSameObject(JNIEnv *env,

   622                            jobject obj1,

   623                            jobject obj2))

   624     functionEnterExceptionAllowed(thr);

   625     IN_VM(

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

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

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

   629        */

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

   631         jniCheck::validate_object(thr, obj1);

   632       }

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

   634         jniCheck::validate_object(thr, obj2);

   635       }

   636     )

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

   638     functionExit(env);

   639     return result;

   640 JNI_END

   642 JNI_ENTRY_CHECKED(jobject,

   643   checked_jni_NewLocalRef(JNIEnv *env,

   644                           jobject ref))

   645     functionEnter(thr);

   646     IN_VM(

   647       if (ref != NULL) {

   648         jniCheck::validate_handle(thr, ref);

   649       }

   650     )

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

   652     functionExit(env);

   653     return result;

   654 JNI_END

   656 JNI_ENTRY_CHECKED(jint,

   657   checked_jni_EnsureLocalCapacity(JNIEnv *env,

   658                                   jint capacity))

   659     functionEnter(thr);

   660     if (capacity < 0) {

   661       NativeReportJNIFatalError(thr, "negative capacity");

   662     }

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

   664     functionExit(env);

   665     return result;

   666 JNI_END

   668 JNI_ENTRY_CHECKED(jobject,

   669   checked_jni_AllocObject(JNIEnv *env,

   670                           jclass clazz))

   671     functionEnter(thr);

   672     IN_VM(

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

   674     )

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

   676     functionExit(env);

   677     return result;

   678 JNI_END

   680 JNI_ENTRY_CHECKED(jobject,

   681   checked_jni_NewObject(JNIEnv *env,

   682                         jclass clazz,

   683                         jmethodID methodID,

   684                         ...))

   685     functionEnter(thr);

   686     va_list args;

   687     IN_VM(

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

   689       jniCheck::validate_jmethod_id(thr, methodID);

   690     )

   691     va_start(args, methodID);

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

   693     va_end(args);

   694     functionExit(env);

   695     return result;

   696 JNI_END

   698 JNI_ENTRY_CHECKED(jobject,

   699   checked_jni_NewObjectV(JNIEnv *env,

   700                          jclass clazz,

   701                          jmethodID methodID,

   702                          va_list args))

   703     functionEnter(thr);

   704     IN_VM(

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

   706       jniCheck::validate_jmethod_id(thr, methodID);

   707     )

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

   709     functionExit(env);

   710     return result;

   711 JNI_END

   713 JNI_ENTRY_CHECKED(jobject,

   714   checked_jni_NewObjectA(JNIEnv *env,

   715                          jclass clazz,

   716                          jmethodID methodID,

   717                          const jvalue *args))

   718     functionEnter(thr);

   719     IN_VM(

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

   721       jniCheck::validate_jmethod_id(thr, methodID);

   722     )

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

   724     functionExit(env);

   725     return result;

   726 JNI_END

   728 JNI_ENTRY_CHECKED(jclass,

   729   checked_jni_GetObjectClass(JNIEnv *env,

   730                              jobject obj))

   731     functionEnter(thr);

   732     IN_VM(

   733       jniCheck::validate_object(thr, obj);

   734     )

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

   736     functionExit(env);

   737     return result;

   738 JNI_END

   740 JNI_ENTRY_CHECKED(jboolean,

   741   checked_jni_IsInstanceOf(JNIEnv *env,

   742                            jobject obj,

   743                            jclass clazz))

   744     functionEnter(thr);

   745     IN_VM(

   746       jniCheck::validate_object(thr, obj);

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

   748     )

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

   750     functionExit(env);

   751     return result;

   752 JNI_END

   754 JNI_ENTRY_CHECKED(jmethodID,

   755   checked_jni_GetMethodID(JNIEnv *env,

   756                           jclass clazz,

   757                           const char *name,

   758                           const char *sig))

   759     functionEnter(thr);

   760     IN_VM(

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

   762     )

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

   764     functionExit(env);

   765     return result;

   766 JNI_END

   768 #define WRAPPER_CallMethod(ResultType, Result) \

   769 JNI_ENTRY_CHECKED(ResultType,  \

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

   771                                    jobject obj, \

   772                                    jmethodID methodID, \

   773                                    ...)) \

   774     functionEnter(thr); \

   775     va_list args; \

   776     IN_VM( \

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

   778     ) \

   779     va_start(args,methodID); \

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

   781                                                           args); \

   782     va_end(args); \

   783     functionExit(env); \

   784     return result; \

   785 JNI_END \

   786 \

   787 JNI_ENTRY_CHECKED(ResultType,  \

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

   789                                     jobject obj, \

   790                                     jmethodID methodID, \

   791                                     va_list args)) \

   792     functionEnter(thr); \

   793     IN_VM(\

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

   795     ) \

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

   797                                                            args); \

   798     functionExit(env); \

   799     return result; \

   800 JNI_END \

   801 \

   802 JNI_ENTRY_CHECKED(ResultType,  \

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

   804                                     jobject obj, \

   805                                     jmethodID methodID, \

   806                                     const jvalue * args)) \

   807     functionEnter(thr); \

   808     IN_VM( \

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

   810     ) \

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

   812                                                            args); \

   813     functionExit(env); \

   814     return result; \

   815 JNI_END

   817 WRAPPER_CallMethod(jobject,Object)

   818 WRAPPER_CallMethod(jboolean,Boolean)

   819 WRAPPER_CallMethod(jbyte,Byte)

   820 WRAPPER_CallMethod(jshort,Short)

   821 WRAPPER_CallMethod(jchar,Char)

   822 WRAPPER_CallMethod(jint,Int)

   823 WRAPPER_CallMethod(jlong,Long)

   824 WRAPPER_CallMethod(jfloat,Float)

   825 WRAPPER_CallMethod(jdouble,Double)

   827 JNI_ENTRY_CHECKED(void,

   828   checked_jni_CallVoidMethod(JNIEnv *env, \

   829                              jobject obj, \

   830                              jmethodID methodID, \

   831                              ...))

   832     functionEnter(thr);

   833     va_list args;

   834     IN_VM(

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

   836     )

   837     va_start(args,methodID);

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

   839     va_end(args);

   840     functionExit(env);

   841 JNI_END

   843 JNI_ENTRY_CHECKED(void,

   844   checked_jni_CallVoidMethodV(JNIEnv *env,

   845                               jobject obj,

   846                               jmethodID methodID,

   847                               va_list args))

   848     functionEnter(thr);

   849     IN_VM(

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

   851     )

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

   853     functionExit(env);

   854 JNI_END

   856 JNI_ENTRY_CHECKED(void,

   857   checked_jni_CallVoidMethodA(JNIEnv *env,

   858                               jobject obj,

   859                               jmethodID methodID,

   860                               const jvalue * args))

   861     functionEnter(thr);

   862     IN_VM(

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

   864     )

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

   866     functionExit(env);

   867 JNI_END

   869 #define WRAPPER_CallNonvirtualMethod(ResultType, Result) \

   870 JNI_ENTRY_CHECKED(ResultType,  \

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

   872                                              jobject obj, \

   873                                              jclass clazz, \

   874                                              jmethodID methodID, \

   875                                              ...)) \

   876     functionEnter(thr); \

   877     va_list args; \

   878     IN_VM( \

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

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

   881     ) \

   882     va_start(args,methodID); \

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

   884                                                                      obj, \

   885                                                                      clazz, \

   886                                                                      methodID,\

   887                                                                      args); \

   888     va_end(args); \

   889     functionExit(env); \

   890     return result; \

   891 JNI_END \

   892 \

   893 JNI_ENTRY_CHECKED(ResultType,  \

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

   895                                               jobject obj, \

   896                                               jclass clazz, \

   897                                               jmethodID methodID, \

   898                                               va_list args)) \

   899     functionEnter(thr); \

   900     IN_VM( \

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

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

   903     ) \

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

   905                                                                      obj, \

   906                                                                      clazz, \

   907                                                                      methodID,\

   908                                                                      args); \

   909     functionExit(env); \

   910     return result; \

   911 JNI_END \

   912 \

   913 JNI_ENTRY_CHECKED(ResultType,  \

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

   915                                               jobject obj, \

   916                                               jclass clazz, \

   917                                               jmethodID methodID, \

   918                                               const jvalue * args)) \

   919     functionEnter(thr); \

   920     IN_VM( \

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

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

   923     ) \

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

   925                                                                      obj, \

   926                                                                      clazz, \

   927                                                                      methodID,\

   928                                                                      args); \

   929     functionExit(env); \

   930     return result; \

   931 JNI_END

   933 WRAPPER_CallNonvirtualMethod(jobject,Object)

   934 WRAPPER_CallNonvirtualMethod(jboolean,Boolean)

   935 WRAPPER_CallNonvirtualMethod(jbyte,Byte)

   936 WRAPPER_CallNonvirtualMethod(jshort,Short)

   937 WRAPPER_CallNonvirtualMethod(jchar,Char)

   938 WRAPPER_CallNonvirtualMethod(jint,Int)

   939 WRAPPER_CallNonvirtualMethod(jlong,Long)

   940 WRAPPER_CallNonvirtualMethod(jfloat,Float)

   941 WRAPPER_CallNonvirtualMethod(jdouble,Double)

   943 JNI_ENTRY_CHECKED(void,

   944   checked_jni_CallNonvirtualVoidMethod(JNIEnv *env,

   945                                        jobject obj,

   946                                        jclass clazz,

   947                                        jmethodID methodID,

   948                                        ...))

   949     functionEnter(thr);

   950     va_list args;

   951     IN_VM(

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

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

   954     )

   955     va_start(args,methodID);

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

   957     va_end(args);

   958     functionExit(env);

   959 JNI_END

   961 JNI_ENTRY_CHECKED(void,

   962   checked_jni_CallNonvirtualVoidMethodV(JNIEnv *env,

   963                                         jobject obj,

   964                                         jclass clazz,

   965                                         jmethodID methodID,

   966                                         va_list args))

   967     functionEnter(thr);

   968     IN_VM(

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

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

   971     )

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

   973     functionExit(env);

   974 JNI_END

   976 JNI_ENTRY_CHECKED(void,

   977   checked_jni_CallNonvirtualVoidMethodA(JNIEnv *env,

   978                                         jobject obj,

   979                                         jclass clazz,

   980                                         jmethodID methodID,

   981                                         const jvalue * args))

   982     functionEnter(thr);

   983     IN_VM(

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

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

   986     )

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

   988     functionExit(env);

   989 JNI_END

   991 JNI_ENTRY_CHECKED(jfieldID,

   992   checked_jni_GetFieldID(JNIEnv *env,

   993                          jclass clazz,

   994                          const char *name,

   995                          const char *sig))

   996     functionEnter(thr);

   997     IN_VM(

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

   999     )

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

  1001     functionExit(env);

  1002     return result;

  1003 JNI_END

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

  1006 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1008                                  jobject obj, \

  1009                                  jfieldID fieldID)) \

  1010     functionEnter(thr); \

  1011     IN_VM( \

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

  1013     ) \

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

  1015     functionExit(env); \

  1016     return result; \

  1017 JNI_END

  1019 WRAPPER_GetField(jobject,  Object,  T_OBJECT)

  1020 WRAPPER_GetField(jboolean, Boolean, T_BOOLEAN)

  1021 WRAPPER_GetField(jbyte,    Byte,    T_BYTE)

  1022 WRAPPER_GetField(jshort,   Short,   T_SHORT)

  1023 WRAPPER_GetField(jchar,    Char,    T_CHAR)

  1024 WRAPPER_GetField(jint,     Int,     T_INT)

  1025 WRAPPER_GetField(jlong,    Long,    T_LONG)

  1026 WRAPPER_GetField(jfloat,   Float,   T_FLOAT)

  1027 WRAPPER_GetField(jdouble,  Double,  T_DOUBLE)

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

  1030 JNI_ENTRY_CHECKED(void,  \

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

  1032                                  jobject obj, \

  1033                                  jfieldID fieldID, \

  1034                                  ValueType val)) \

  1035     functionEnter(thr); \

  1036     IN_VM( \

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

  1038     ) \

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

  1040     functionExit(env); \

  1041 JNI_END

  1043 WRAPPER_SetField(jobject,  Object,  T_OBJECT)

  1044 WRAPPER_SetField(jboolean, Boolean, T_BOOLEAN)

  1045 WRAPPER_SetField(jbyte,    Byte,    T_BYTE)

  1046 WRAPPER_SetField(jshort,   Short,   T_SHORT)

  1047 WRAPPER_SetField(jchar,    Char,    T_CHAR)

  1048 WRAPPER_SetField(jint,     Int,     T_INT)

  1049 WRAPPER_SetField(jlong,    Long,    T_LONG)

  1050 WRAPPER_SetField(jfloat,   Float,   T_FLOAT)

  1051 WRAPPER_SetField(jdouble,  Double,  T_DOUBLE)

  1054 JNI_ENTRY_CHECKED(jmethodID,

  1055   checked_jni_GetStaticMethodID(JNIEnv *env,

  1056                                 jclass clazz,

  1057                                 const char *name,

  1058                                 const char *sig))

  1059     functionEnter(thr);

  1060     IN_VM(

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

  1062     )

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

  1064     functionExit(env);

  1065     return result;

  1066 JNI_END

  1068 #define WRAPPER_CallStaticMethod(ReturnType,Result) \

  1069 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1071                                          jclass clazz, \

  1072                                          jmethodID methodID, \

  1073                                          ...)) \

  1074     functionEnter(thr); \

  1075     va_list args; \

  1076     IN_VM( \

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

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

  1079     ) \

  1080     va_start(args,methodID); \

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

  1082                                                                  clazz, \

  1083                                                                  methodID, \

  1084                                                                  args); \

  1085     va_end(args); \

  1086     functionExit(env); \

  1087     return result; \

  1088 JNI_END \

  1089 \

  1090 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1092                                           jclass clazz, \

  1093                                           jmethodID methodID,\

  1094                                           va_list args)) \

  1095     functionEnter(thr); \

  1096     IN_VM( \

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

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

  1099     ) \

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

  1101                                                                  clazz, \

  1102                                                                  methodID, \

  1103                                                                  args); \

  1104     functionExit(env); \

  1105     return result; \

  1106 JNI_END \

  1107 \

  1108 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1110                                           jclass clazz, \

  1111                                           jmethodID methodID, \

  1112                                           const jvalue *args)) \

  1113     functionEnter(thr); \

  1114     IN_VM( \

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

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

  1117     ) \

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

  1119                                                                  clazz, \

  1120                                                                  methodID, \

  1121                                                                  args); \

  1122     functionExit(env); \

  1123     return result; \

  1124 JNI_END

  1126 WRAPPER_CallStaticMethod(jobject,Object)

  1127 WRAPPER_CallStaticMethod(jboolean,Boolean)

  1128 WRAPPER_CallStaticMethod(jbyte,Byte)

  1129 WRAPPER_CallStaticMethod(jshort,Short)

  1130 WRAPPER_CallStaticMethod(jchar,Char)

  1131 WRAPPER_CallStaticMethod(jint,Int)

  1132 WRAPPER_CallStaticMethod(jlong,Long)

  1133 WRAPPER_CallStaticMethod(jfloat,Float)

  1134 WRAPPER_CallStaticMethod(jdouble,Double)

  1136 JNI_ENTRY_CHECKED(void,

  1137   checked_jni_CallStaticVoidMethod(JNIEnv *env,

  1138                                    jclass cls,

  1139                                    jmethodID methodID,

  1140                                    ...))

  1141     functionEnter(thr);

  1142     va_list args;

  1143     IN_VM(

  1144       jniCheck::validate_jmethod_id(thr, methodID);

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

  1146     )

  1147     va_start(args,methodID);

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

  1149     va_end(args);

  1150     functionExit(env);

  1151 JNI_END

  1153 JNI_ENTRY_CHECKED(void,

  1154   checked_jni_CallStaticVoidMethodV(JNIEnv *env,

  1155                                     jclass cls,

  1156                                     jmethodID methodID,

  1157                                     va_list args))

  1158     functionEnter(thr);

  1159     IN_VM(

  1160       jniCheck::validate_jmethod_id(thr, methodID);

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

  1162     )

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

  1164     functionExit(env);

  1165 JNI_END

  1167 JNI_ENTRY_CHECKED(void,

  1168   checked_jni_CallStaticVoidMethodA(JNIEnv *env,

  1169                                     jclass cls,

  1170                                     jmethodID methodID,

  1171                                     const jvalue * args))

  1172     functionEnter(thr);

  1173     IN_VM(

  1174       jniCheck::validate_jmethod_id(thr, methodID);

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

  1176     )

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

  1178     functionExit(env);

  1179 JNI_END

  1181 JNI_ENTRY_CHECKED(jfieldID,

  1182   checked_jni_GetStaticFieldID(JNIEnv *env,

  1183                                jclass clazz,

  1184                                const char *name,

  1185                                const char *sig))

  1186     functionEnter(thr);

  1187     IN_VM(

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

  1189     )

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

  1191     functionExit(env);

  1192     return result;

  1193 JNI_END

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

  1196 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1198                                        jclass clazz, \

  1199                                        jfieldID fieldID)) \

  1200     functionEnter(thr); \

  1201     IN_VM( \

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

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

  1204     ) \

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

  1206                                                               clazz, \

  1207                                                               fieldID); \

  1208     functionExit(env); \

  1209     return result; \

  1210 JNI_END

  1212 WRAPPER_GetStaticField(jobject,  Object,  T_OBJECT)

  1213 WRAPPER_GetStaticField(jboolean, Boolean, T_BOOLEAN)

  1214 WRAPPER_GetStaticField(jbyte,    Byte,    T_BYTE)

  1215 WRAPPER_GetStaticField(jshort,   Short,   T_SHORT)

  1216 WRAPPER_GetStaticField(jchar,    Char,    T_CHAR)

  1217 WRAPPER_GetStaticField(jint,     Int,     T_INT)

  1218 WRAPPER_GetStaticField(jlong,    Long,    T_LONG)

  1219 WRAPPER_GetStaticField(jfloat,   Float,   T_FLOAT)

  1220 WRAPPER_GetStaticField(jdouble,  Double,  T_DOUBLE)

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

  1223 JNI_ENTRY_CHECKED(void,  \

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

  1225                                        jclass clazz, \

  1226                                        jfieldID fieldID, \

  1227                                        ValueType value)) \

  1228     functionEnter(thr); \

  1229     IN_VM( \

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

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

  1232     ) \

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

  1234     functionExit(env); \

  1235 JNI_END

  1237 WRAPPER_SetStaticField(jobject,  Object,  T_OBJECT)

  1238 WRAPPER_SetStaticField(jboolean, Boolean, T_BOOLEAN)

  1239 WRAPPER_SetStaticField(jbyte,    Byte,    T_BYTE)

  1240 WRAPPER_SetStaticField(jshort,   Short,   T_SHORT)

  1241 WRAPPER_SetStaticField(jchar,    Char,    T_CHAR)

  1242 WRAPPER_SetStaticField(jint,     Int,     T_INT)

  1243 WRAPPER_SetStaticField(jlong,    Long,    T_LONG)

  1244 WRAPPER_SetStaticField(jfloat,   Float,   T_FLOAT)

  1245 WRAPPER_SetStaticField(jdouble,  Double,  T_DOUBLE)

  1248 JNI_ENTRY_CHECKED(jstring,

  1249   checked_jni_NewString(JNIEnv *env,

  1250                         const jchar *unicode,

  1251                         jsize len))

  1252     functionEnter(thr);

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

  1254     functionExit(env);

  1255     return result;

  1256 JNI_END

  1258 JNI_ENTRY_CHECKED(jsize,

  1259   checked_jni_GetStringLength(JNIEnv *env,

  1260                               jstring str))

  1261     functionEnter(thr);

  1262     IN_VM(

  1263       checkString(thr, str);

  1264     )

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

  1266     functionExit(env);

  1267     return result;

  1268 JNI_END

  1270 JNI_ENTRY_CHECKED(const jchar *,

  1271   checked_jni_GetStringChars(JNIEnv *env,

  1272                              jstring str,

  1273                              jboolean *isCopy))

  1274     functionEnter(thr);

  1275     IN_VM(

  1276       checkString(thr, str);

  1277     )

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

  1279     functionExit(env);

  1280     return result;

  1281 JNI_END

  1283 JNI_ENTRY_CHECKED(void,

  1284   checked_jni_ReleaseStringChars(JNIEnv *env,

  1285                                  jstring str,

  1286                                  const jchar *chars))

  1287     functionEnterExceptionAllowed(thr);

  1288     IN_VM(

  1289       checkString(thr, str);

  1290     )

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

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

  1293      * subsequent release.

  1294      */

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

  1296     functionExit(env);

  1297 JNI_END

  1299 JNI_ENTRY_CHECKED(jstring,

  1300   checked_jni_NewStringUTF(JNIEnv *env,

  1301                            const char *utf))

  1302     functionEnter(thr);

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

  1304     functionExit(env);

  1305     return result;

  1306 JNI_END

  1308 JNI_ENTRY_CHECKED(jsize,

  1309   checked_jni_GetStringUTFLength(JNIEnv *env,

  1310                                  jstring str))

  1311     functionEnter(thr);

  1312     IN_VM(

  1313       checkString(thr, str);

  1314     )

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

  1316     functionExit(env);

  1317     return result;

  1318 JNI_END

  1320 JNI_ENTRY_CHECKED(const char *,

  1321   checked_jni_GetStringUTFChars(JNIEnv *env,

  1322                                 jstring str,

  1323                                 jboolean *isCopy))

  1324     functionEnter(thr);

  1325     IN_VM(

  1326       checkString(thr, str);

  1327     )

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

  1329     functionExit(env);

  1330     return result;

  1331 JNI_END

  1333 JNI_ENTRY_CHECKED(void,

  1334   checked_jni_ReleaseStringUTFChars(JNIEnv *env,

  1335                                     jstring str,

  1336                                     const char* chars))

  1337     functionEnterExceptionAllowed(thr);

  1338     IN_VM(

  1339       checkString(thr, str);

  1340     )

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

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

  1343      * subsequent release.

  1344      */

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

  1346     functionExit(env);

  1347 JNI_END

  1349 JNI_ENTRY_CHECKED(jsize,

  1350   checked_jni_GetArrayLength(JNIEnv *env,

  1351                              jarray array))

  1352     functionEnter(thr);

  1353     IN_VM(

  1354       checkArray(thr, array, -1);

  1355     )

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

  1357     functionExit(env);

  1358     return result;

  1359 JNI_END

  1361 JNI_ENTRY_CHECKED(jobjectArray,

  1362   checked_jni_NewObjectArray(JNIEnv *env,

  1363                              jsize len,

  1364                              jclass clazz,

  1365                              jobject init))

  1366     functionEnter(thr);

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

  1368     functionExit(env);

  1369     return result;

  1370 JNI_END

  1372 JNI_ENTRY_CHECKED(jobject,

  1373   checked_jni_GetObjectArrayElement(JNIEnv *env,

  1374                                     jobjectArray array,

  1375                                     jsize index))

  1376     functionEnter(thr);

  1377     IN_VM(

  1378       checkArray(thr, array, T_OBJECT);

  1379     )

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

  1381     functionExit(env);

  1382     return result;

  1383 JNI_END

  1385 JNI_ENTRY_CHECKED(void,

  1386   checked_jni_SetObjectArrayElement(JNIEnv *env,

  1387                                     jobjectArray array,

  1388                                     jsize index,

  1389                                     jobject val))

  1390     functionEnter(thr);

  1391     IN_VM(

  1392       checkArray(thr, array, T_OBJECT);

  1393     )

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

  1395     functionExit(env);

  1396 JNI_END

  1398 #define WRAPPER_NewScalarArray(Return, Result) \

  1399 JNI_ENTRY_CHECKED(Return, \

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

  1401                                  jsize len)) \

  1402     functionEnter(thr); \

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

  1404     functionExit(env); \

  1405     return (Return) result; \

  1406 JNI_END

  1408 WRAPPER_NewScalarArray(jbooleanArray, Boolean)

  1409 WRAPPER_NewScalarArray(jbyteArray, Byte)

  1410 WRAPPER_NewScalarArray(jshortArray, Short)

  1411 WRAPPER_NewScalarArray(jcharArray, Char)

  1412 WRAPPER_NewScalarArray(jintArray, Int)

  1413 WRAPPER_NewScalarArray(jlongArray, Long)

  1414 WRAPPER_NewScalarArray(jfloatArray, Float)

  1415 WRAPPER_NewScalarArray(jdoubleArray, Double)

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

  1418 JNI_ENTRY_CHECKED(ElementType *,  \

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

  1420                                          ElementType##Array array, \

  1421                                          jboolean *isCopy)) \

  1422     functionEnter(thr); \

  1423     IN_VM( \

  1424       checkArray(thr, array, ElementTag); \

  1425     ) \

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

  1427                                                                   array, \

  1428                                                                   isCopy); \

  1429     functionExit(env); \

  1430     return result; \

  1431 JNI_END

  1433 WRAPPER_GetScalarArrayElements(T_BOOLEAN, jboolean, Boolean)

  1434 WRAPPER_GetScalarArrayElements(T_BYTE,    jbyte,    Byte)

  1435 WRAPPER_GetScalarArrayElements(T_SHORT,   jshort,   Short)

  1436 WRAPPER_GetScalarArrayElements(T_CHAR,    jchar,    Char)

  1437 WRAPPER_GetScalarArrayElements(T_INT,     jint,     Int)

  1438 WRAPPER_GetScalarArrayElements(T_LONG,    jlong,    Long)

  1439 WRAPPER_GetScalarArrayElements(T_FLOAT,   jfloat,   Float)

  1440 WRAPPER_GetScalarArrayElements(T_DOUBLE,  jdouble,  Double)

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

  1443 JNI_ENTRY_CHECKED(void,  \

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

  1445                                              ElementType##Array array, \

  1446                                              ElementType *elems, \

  1447                                              jint mode)) \

  1448     functionEnterExceptionAllowed(thr); \

  1449     IN_VM( \

  1450       checkArray(thr, array, ElementTag); \

  1451       ASSERT_OOPS_ALLOWED; \

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

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

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

  1455        * subsequent release.

  1456        */ \

  1457     ) \

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

  1459     functionExit(env); \

  1460 JNI_END

  1462 WRAPPER_ReleaseScalarArrayElements(T_BOOLEAN,jboolean, Boolean, bool)

  1463 WRAPPER_ReleaseScalarArrayElements(T_BYTE,   jbyte,    Byte,    byte)

  1464 WRAPPER_ReleaseScalarArrayElements(T_SHORT,  jshort,   Short,   short)

  1465 WRAPPER_ReleaseScalarArrayElements(T_CHAR,   jchar,    Char,    char)

  1466 WRAPPER_ReleaseScalarArrayElements(T_INT,    jint,     Int,     int)

  1467 WRAPPER_ReleaseScalarArrayElements(T_LONG,   jlong,    Long,    long)

  1468 WRAPPER_ReleaseScalarArrayElements(T_FLOAT,  jfloat,   Float,   float)

  1469 WRAPPER_ReleaseScalarArrayElements(T_DOUBLE, jdouble,  Double,  double)

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

  1472 JNI_ENTRY_CHECKED(void,  \

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

  1474                                        ElementType##Array array, \

  1475                                        jsize start, \

  1476                                        jsize len, \

  1477                                        ElementType *buf)) \

  1478     functionEnter(thr); \

  1479     IN_VM( \

  1480       checkArray(thr, array, ElementTag); \

  1481     ) \

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

  1483     functionExit(env); \

  1484 JNI_END

  1486 WRAPPER_GetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)

  1487 WRAPPER_GetScalarArrayRegion(T_BYTE,    jbyte,    Byte)

  1488 WRAPPER_GetScalarArrayRegion(T_SHORT,   jshort,   Short)

  1489 WRAPPER_GetScalarArrayRegion(T_CHAR,    jchar,    Char)

  1490 WRAPPER_GetScalarArrayRegion(T_INT,     jint,     Int)

  1491 WRAPPER_GetScalarArrayRegion(T_LONG,    jlong,    Long)

  1492 WRAPPER_GetScalarArrayRegion(T_FLOAT,   jfloat,   Float)

  1493 WRAPPER_GetScalarArrayRegion(T_DOUBLE,  jdouble,  Double)

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

  1496 JNI_ENTRY_CHECKED(void,  \

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

  1498                                        ElementType##Array array, \

  1499                                        jsize start, \

  1500                                        jsize len, \

  1501                                        const ElementType *buf)) \

  1502     functionEnter(thr); \

  1503     IN_VM( \

  1504       checkArray(thr, array, ElementTag); \

  1505     ) \

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

  1507     functionExit(env); \

  1508 JNI_END

  1510 WRAPPER_SetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)

  1511 WRAPPER_SetScalarArrayRegion(T_BYTE,    jbyte,    Byte)

  1512 WRAPPER_SetScalarArrayRegion(T_SHORT,   jshort,   Short)

  1513 WRAPPER_SetScalarArrayRegion(T_CHAR,    jchar,    Char)

  1514 WRAPPER_SetScalarArrayRegion(T_INT,     jint,     Int)

  1515 WRAPPER_SetScalarArrayRegion(T_LONG,    jlong,    Long)

  1516 WRAPPER_SetScalarArrayRegion(T_FLOAT,   jfloat,   Float)

  1517 WRAPPER_SetScalarArrayRegion(T_DOUBLE,  jdouble,  Double)

  1519 JNI_ENTRY_CHECKED(jint,

  1520   checked_jni_RegisterNatives(JNIEnv *env,

  1521                               jclass clazz,

  1522                               const JNINativeMethod *methods,

  1523                               jint nMethods))

  1524     functionEnter(thr);

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

  1526     functionExit(env);

  1527     return result;

  1528 JNI_END

  1530 JNI_ENTRY_CHECKED(jint,

  1531   checked_jni_UnregisterNatives(JNIEnv *env,

  1532                                 jclass clazz))

  1533     functionEnter(thr);

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

  1535     functionExit(env);

  1536     return result;

  1537 JNI_END

  1539 JNI_ENTRY_CHECKED(jint,

  1540   checked_jni_MonitorEnter(JNIEnv *env,

  1541                            jobject obj))

  1542     functionEnter(thr);

  1543     IN_VM(

  1544       jniCheck::validate_object(thr, obj);

  1545     )

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

  1547     functionExit(env);

  1548     return result;

  1549 JNI_END

  1551 JNI_ENTRY_CHECKED(jint,

  1552   checked_jni_MonitorExit(JNIEnv *env,

  1553                           jobject obj))

  1554     functionEnterExceptionAllowed(thr);

  1555     IN_VM(

  1556       jniCheck::validate_object(thr, obj);

  1557     )

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

  1559     functionExit(env);

  1560     return result;

  1561 JNI_END

  1563 JNI_ENTRY_CHECKED(jint,

  1564   checked_jni_GetJavaVM(JNIEnv *env,

  1565                         JavaVM **vm))

  1566     functionEnter(thr);

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

  1568     functionExit(env);

  1569     return result;

  1570 JNI_END

  1572 JNI_ENTRY_CHECKED(void,

  1573   checked_jni_GetStringRegion(JNIEnv *env,

  1574                               jstring str,

  1575                               jsize start,

  1576                               jsize len,

  1577                               jchar *buf))

  1578     functionEnter(thr);

  1579     IN_VM(

  1580       checkString(thr, str);

  1581     )

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

  1583     functionExit(env);

  1584 JNI_END

  1586 JNI_ENTRY_CHECKED(void,

  1587   checked_jni_GetStringUTFRegion(JNIEnv *env,

  1588                                  jstring str,

  1589                                  jsize start,

  1590                                  jsize len,

  1591                                  char *buf))

  1592     functionEnter(thr);

  1593     IN_VM(

  1594       checkString(thr, str);

  1595     )

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

  1597     functionExit(env);

  1598 JNI_END

  1600 JNI_ENTRY_CHECKED(void *,

  1601   checked_jni_GetPrimitiveArrayCritical(JNIEnv *env,

  1602                                         jarray array,

  1603                                         jboolean *isCopy))

  1604     functionEnterCritical(thr);

  1605     IN_VM(

  1606       checkArray(thr, array, -1);

  1607     )

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

  1609     functionExit(env);

  1610     return result;

  1611 JNI_END

  1613 JNI_ENTRY_CHECKED(void,

  1614   checked_jni_ReleasePrimitiveArrayCritical(JNIEnv *env,

  1615                                             jarray array,

  1616                                             void *carray,

  1617                                             jint mode))

  1618     functionEnterCriticalExceptionAllowed(thr);

  1619     IN_VM(

  1620       checkArray(thr, array, -1);

  1621     )

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

  1623      * array parameter as a minor sanity check

  1624      */

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

  1626     functionExit(env);

  1627 JNI_END

  1629 JNI_ENTRY_CHECKED(const jchar*,

  1630   checked_jni_GetStringCritical(JNIEnv *env,

  1631                                 jstring string,

  1632                                 jboolean *isCopy))

  1633     functionEnterCritical(thr);

  1634     IN_VM(

  1635       checkString(thr, string);

  1636     )

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

  1638     functionExit(env);

  1639     return result;

  1640 JNI_END

  1642 JNI_ENTRY_CHECKED(void,

  1643   checked_jni_ReleaseStringCritical(JNIEnv *env,

  1644                                     jstring str,

  1645                                     const jchar *chars))

  1646     functionEnterCriticalExceptionAllowed(thr);

  1647     IN_VM(

  1648       checkString(thr, str);

  1649     )

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

  1651      * string parameter as a minor sanity check

  1652      */

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

  1654     functionExit(env);

  1655 JNI_END

  1657 JNI_ENTRY_CHECKED(jweak,

  1658   checked_jni_NewWeakGlobalRef(JNIEnv *env,

  1659                                jobject obj))

  1660     functionEnter(thr);

  1661     IN_VM(

  1662       if (obj != NULL) {

  1663         jniCheck::validate_handle(thr, obj);

  1664       }

  1665     )

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

  1667     functionExit(env);

  1668     return result;

  1669 JNI_END

  1671 JNI_ENTRY_CHECKED(void,

  1672   checked_jni_DeleteWeakGlobalRef(JNIEnv *env,

  1673                                   jweak ref))

  1674     functionEnterExceptionAllowed(thr);

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

  1676     functionExit(env);

  1677 JNI_END

  1679 JNI_ENTRY_CHECKED(jboolean,

  1680   checked_jni_ExceptionCheck(JNIEnv *env))

  1681     functionEnterExceptionAllowed(thr);

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

  1683     functionExit(env);

  1684     return result;

  1685 JNI_END

  1687 JNI_ENTRY_CHECKED(jobject,

  1688   checked_jni_NewDirectByteBuffer(JNIEnv *env,

  1689                                   void *address,

  1690                                   jlong capacity))

  1691     functionEnter(thr);

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

  1693     functionExit(env);

  1694     return result;

  1695 JNI_END

  1697 JNI_ENTRY_CHECKED(void *,

  1698   checked_jni_GetDirectBufferAddress(JNIEnv *env,

  1699                                      jobject buf))

  1700     functionEnter(thr);

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

  1702     functionExit(env);

  1703     return result;

  1704 JNI_END

  1706 JNI_ENTRY_CHECKED(jlong,

  1707   checked_jni_GetDirectBufferCapacity(JNIEnv *env,

  1708                                       jobject buf))

  1709     functionEnter(thr);

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

  1711     functionExit(env);

  1712     return result;

  1713 JNI_END

  1715 JNI_ENTRY_CHECKED(jobjectRefType,

  1716   checked_jni_GetObjectRefType(JNIEnv *env,

  1717                                jobject obj))

  1718     functionEnter(thr);

  1719     /* validate the object being passed */

  1720     IN_VM(

  1721       jniCheck::validate_object(thr, obj);

  1722     )

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

  1724     functionExit(env);

  1725     return result;

  1726 JNI_END

  1729 JNI_ENTRY_CHECKED(jint,

  1730   checked_jni_GetVersion(JNIEnv *env))

  1731     functionEnter(thr);

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

  1733     functionExit(env);

  1734     return result;

  1735 JNI_END

  1739 /*

  1740  * Structure containing all checked jni functions

  1741  */

  1742 struct JNINativeInterface_  checked_jni_NativeInterface = {

  1743     NULL,

  1744     NULL,

  1745     NULL,

  1747     NULL,

  1749     checked_jni_GetVersion,

  1751     checked_jni_DefineClass,

  1752     checked_jni_FindClass,

  1754     checked_jni_FromReflectedMethod,

  1755     checked_jni_FromReflectedField,

  1757     checked_jni_ToReflectedMethod,

  1759     checked_jni_GetSuperclass,

  1760     checked_jni_IsAssignableFrom,

  1762     checked_jni_ToReflectedField,

  1764     checked_jni_Throw,

  1765     checked_jni_ThrowNew,

  1766     checked_jni_ExceptionOccurred,

  1767     checked_jni_ExceptionDescribe,

  1768     checked_jni_ExceptionClear,

  1769     checked_jni_FatalError,

  1771     checked_jni_PushLocalFrame,

  1772     checked_jni_PopLocalFrame,

  1774     checked_jni_NewGlobalRef,

  1775     checked_jni_DeleteGlobalRef,

  1776     checked_jni_DeleteLocalRef,

  1777     checked_jni_IsSameObject,

  1779     checked_jni_NewLocalRef,

  1780     checked_jni_EnsureLocalCapacity,

  1782     checked_jni_AllocObject,

  1783     checked_jni_NewObject,

  1784     checked_jni_NewObjectV,

  1785     checked_jni_NewObjectA,

  1787     checked_jni_GetObjectClass,

  1788     checked_jni_IsInstanceOf,

  1790     checked_jni_GetMethodID,

  1792     checked_jni_CallObjectMethod,

  1793     checked_jni_CallObjectMethodV,

  1794     checked_jni_CallObjectMethodA,

  1795     checked_jni_CallBooleanMethod,

  1796     checked_jni_CallBooleanMethodV,

  1797     checked_jni_CallBooleanMethodA,

  1798     checked_jni_CallByteMethod,

  1799     checked_jni_CallByteMethodV,

  1800     checked_jni_CallByteMethodA,

  1801     checked_jni_CallCharMethod,

  1802     checked_jni_CallCharMethodV,

  1803     checked_jni_CallCharMethodA,

  1804     checked_jni_CallShortMethod,

  1805     checked_jni_CallShortMethodV,

  1806     checked_jni_CallShortMethodA,

  1807     checked_jni_CallIntMethod,

  1808     checked_jni_CallIntMethodV,

  1809     checked_jni_CallIntMethodA,

  1810     checked_jni_CallLongMethod,

  1811     checked_jni_CallLongMethodV,

  1812     checked_jni_CallLongMethodA,

  1813     checked_jni_CallFloatMethod,

  1814     checked_jni_CallFloatMethodV,

  1815     checked_jni_CallFloatMethodA,

  1816     checked_jni_CallDoubleMethod,

  1817     checked_jni_CallDoubleMethodV,

  1818     checked_jni_CallDoubleMethodA,

  1819     checked_jni_CallVoidMethod,

  1820     checked_jni_CallVoidMethodV,

  1821     checked_jni_CallVoidMethodA,

  1823     checked_jni_CallNonvirtualObjectMethod,

  1824     checked_jni_CallNonvirtualObjectMethodV,

  1825     checked_jni_CallNonvirtualObjectMethodA,

  1826     checked_jni_CallNonvirtualBooleanMethod,

  1827     checked_jni_CallNonvirtualBooleanMethodV,

  1828     checked_jni_CallNonvirtualBooleanMethodA,

  1829     checked_jni_CallNonvirtualByteMethod,

  1830     checked_jni_CallNonvirtualByteMethodV,

  1831     checked_jni_CallNonvirtualByteMethodA,

  1832     checked_jni_CallNonvirtualCharMethod,

  1833     checked_jni_CallNonvirtualCharMethodV,

  1834     checked_jni_CallNonvirtualCharMethodA,

  1835     checked_jni_CallNonvirtualShortMethod,

  1836     checked_jni_CallNonvirtualShortMethodV,

  1837     checked_jni_CallNonvirtualShortMethodA,

  1838     checked_jni_CallNonvirtualIntMethod,

  1839     checked_jni_CallNonvirtualIntMethodV,

  1840     checked_jni_CallNonvirtualIntMethodA,

  1841     checked_jni_CallNonvirtualLongMethod,

  1842     checked_jni_CallNonvirtualLongMethodV,

  1843     checked_jni_CallNonvirtualLongMethodA,

  1844     checked_jni_CallNonvirtualFloatMethod,

  1845     checked_jni_CallNonvirtualFloatMethodV,

  1846     checked_jni_CallNonvirtualFloatMethodA,

  1847     checked_jni_CallNonvirtualDoubleMethod,

  1848     checked_jni_CallNonvirtualDoubleMethodV,

  1849     checked_jni_CallNonvirtualDoubleMethodA,

  1850     checked_jni_CallNonvirtualVoidMethod,

  1851     checked_jni_CallNonvirtualVoidMethodV,

  1852     checked_jni_CallNonvirtualVoidMethodA,

  1854     checked_jni_GetFieldID,

  1856     checked_jni_GetObjectField,

  1857     checked_jni_GetBooleanField,

  1858     checked_jni_GetByteField,

  1859     checked_jni_GetCharField,

  1860     checked_jni_GetShortField,

  1861     checked_jni_GetIntField,

  1862     checked_jni_GetLongField,

  1863     checked_jni_GetFloatField,

  1864     checked_jni_GetDoubleField,

  1866     checked_jni_SetObjectField,

  1867     checked_jni_SetBooleanField,

  1868     checked_jni_SetByteField,

  1869     checked_jni_SetCharField,

  1870     checked_jni_SetShortField,

  1871     checked_jni_SetIntField,

  1872     checked_jni_SetLongField,

  1873     checked_jni_SetFloatField,

  1874     checked_jni_SetDoubleField,

  1876     checked_jni_GetStaticMethodID,

  1878     checked_jni_CallStaticObjectMethod,

  1879     checked_jni_CallStaticObjectMethodV,

  1880     checked_jni_CallStaticObjectMethodA,

  1881     checked_jni_CallStaticBooleanMethod,

  1882     checked_jni_CallStaticBooleanMethodV,

  1883     checked_jni_CallStaticBooleanMethodA,

  1884     checked_jni_CallStaticByteMethod,

  1885     checked_jni_CallStaticByteMethodV,

  1886     checked_jni_CallStaticByteMethodA,

  1887     checked_jni_CallStaticCharMethod,

  1888     checked_jni_CallStaticCharMethodV,

  1889     checked_jni_CallStaticCharMethodA,

  1890     checked_jni_CallStaticShortMethod,

  1891     checked_jni_CallStaticShortMethodV,

  1892     checked_jni_CallStaticShortMethodA,

  1893     checked_jni_CallStaticIntMethod,

  1894     checked_jni_CallStaticIntMethodV,

  1895     checked_jni_CallStaticIntMethodA,

  1896     checked_jni_CallStaticLongMethod,

  1897     checked_jni_CallStaticLongMethodV,

  1898     checked_jni_CallStaticLongMethodA,

  1899     checked_jni_CallStaticFloatMethod,

  1900     checked_jni_CallStaticFloatMethodV,

  1901     checked_jni_CallStaticFloatMethodA,

  1902     checked_jni_CallStaticDoubleMethod,

  1903     checked_jni_CallStaticDoubleMethodV,

  1904     checked_jni_CallStaticDoubleMethodA,

  1905     checked_jni_CallStaticVoidMethod,

  1906     checked_jni_CallStaticVoidMethodV,

  1907     checked_jni_CallStaticVoidMethodA,

  1909     checked_jni_GetStaticFieldID,

  1911     checked_jni_GetStaticObjectField,

  1912     checked_jni_GetStaticBooleanField,

  1913     checked_jni_GetStaticByteField,

  1914     checked_jni_GetStaticCharField,

  1915     checked_jni_GetStaticShortField,

  1916     checked_jni_GetStaticIntField,

  1917     checked_jni_GetStaticLongField,

  1918     checked_jni_GetStaticFloatField,

  1919     checked_jni_GetStaticDoubleField,

  1921     checked_jni_SetStaticObjectField,

  1922     checked_jni_SetStaticBooleanField,

  1923     checked_jni_SetStaticByteField,

  1924     checked_jni_SetStaticCharField,

  1925     checked_jni_SetStaticShortField,

  1926     checked_jni_SetStaticIntField,

  1927     checked_jni_SetStaticLongField,

  1928     checked_jni_SetStaticFloatField,

  1929     checked_jni_SetStaticDoubleField,

  1931     checked_jni_NewString,

  1932     checked_jni_GetStringLength,

  1933     checked_jni_GetStringChars,

  1934     checked_jni_ReleaseStringChars,

  1936     checked_jni_NewStringUTF,

  1937     checked_jni_GetStringUTFLength,

  1938     checked_jni_GetStringUTFChars,

  1939     checked_jni_ReleaseStringUTFChars,

  1941     checked_jni_GetArrayLength,

  1943     checked_jni_NewObjectArray,

  1944     checked_jni_GetObjectArrayElement,

  1945     checked_jni_SetObjectArrayElement,

  1947     checked_jni_NewBooleanArray,

  1948     checked_jni_NewByteArray,

  1949     checked_jni_NewCharArray,

  1950     checked_jni_NewShortArray,

  1951     checked_jni_NewIntArray,

  1952     checked_jni_NewLongArray,

  1953     checked_jni_NewFloatArray,

  1954     checked_jni_NewDoubleArray,

  1956     checked_jni_GetBooleanArrayElements,

  1957     checked_jni_GetByteArrayElements,

  1958     checked_jni_GetCharArrayElements,

  1959     checked_jni_GetShortArrayElements,

  1960     checked_jni_GetIntArrayElements,

  1961     checked_jni_GetLongArrayElements,

  1962     checked_jni_GetFloatArrayElements,

  1963     checked_jni_GetDoubleArrayElements,

  1965     checked_jni_ReleaseBooleanArrayElements,

  1966     checked_jni_ReleaseByteArrayElements,

  1967     checked_jni_ReleaseCharArrayElements,

  1968     checked_jni_ReleaseShortArrayElements,

  1969     checked_jni_ReleaseIntArrayElements,

  1970     checked_jni_ReleaseLongArrayElements,

  1971     checked_jni_ReleaseFloatArrayElements,

  1972     checked_jni_ReleaseDoubleArrayElements,

  1974     checked_jni_GetBooleanArrayRegion,

  1975     checked_jni_GetByteArrayRegion,

  1976     checked_jni_GetCharArrayRegion,

  1977     checked_jni_GetShortArrayRegion,

  1978     checked_jni_GetIntArrayRegion,

  1979     checked_jni_GetLongArrayRegion,

  1980     checked_jni_GetFloatArrayRegion,

  1981     checked_jni_GetDoubleArrayRegion,

  1983     checked_jni_SetBooleanArrayRegion,

  1984     checked_jni_SetByteArrayRegion,

  1985     checked_jni_SetCharArrayRegion,

  1986     checked_jni_SetShortArrayRegion,

  1987     checked_jni_SetIntArrayRegion,

  1988     checked_jni_SetLongArrayRegion,

  1989     checked_jni_SetFloatArrayRegion,

  1990     checked_jni_SetDoubleArrayRegion,

  1992     checked_jni_RegisterNatives,

  1993     checked_jni_UnregisterNatives,

  1995     checked_jni_MonitorEnter,

  1996     checked_jni_MonitorExit,

  1998     checked_jni_GetJavaVM,

  2000     checked_jni_GetStringRegion,

  2001     checked_jni_GetStringUTFRegion,

  2003     checked_jni_GetPrimitiveArrayCritical,

  2004     checked_jni_ReleasePrimitiveArrayCritical,

  2006     checked_jni_GetStringCritical,

  2007     checked_jni_ReleaseStringCritical,

  2009     checked_jni_NewWeakGlobalRef,

  2010     checked_jni_DeleteWeakGlobalRef,

  2012     checked_jni_ExceptionCheck,

  2014     checked_jni_NewDirectByteBuffer,

  2015     checked_jni_GetDirectBufferAddress,

  2016     checked_jni_GetDirectBufferCapacity,

  2018     // New 1.6 Features

  2020     checked_jni_GetObjectRefType

  2021 };

  2024 // Returns the function structure

  2025 struct JNINativeInterface_* jni_functions_check() {

  2027   unchecked_jni_NativeInterface = jni_functions_nocheck();

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

  2030   // an addition to the JNINativeInterface_ structure without initializing

  2031   // it in the checked table.

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

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

  2034   assert(*lastPtr != 0,

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

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

  2038   if (PrintJNIResolving) {

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

  2040                   "validate JNI usage");

  2041   }

  2043   return &checked_jni_NativeInterface;

  2044 }

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

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

src/share/vm/prims/jniCheck.cpp