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

     1 /*

     2  * Copyright (c) 2001, 2019, 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 /*

    26  * This file has been modified by Loongson Technology in 2015. These

    27  * modifications are Copyright (c) 2015 Loongson Technology, and are made

    28  * available on the same license terms set forth above.

    29  */

    31 #include "precompiled.hpp"

    32 #include "classfile/systemDictionary.hpp"

    33 #include "classfile/vmSymbols.hpp"

    34 #include "memory/guardedMemory.hpp"

    35 #include "oops/instanceKlass.hpp"

    36 #include "oops/oop.inline.hpp"

    37 #include "oops/symbol.hpp"

    38 #include "prims/jni.h"

    39 #include "prims/jniCheck.hpp"

    40 #include "prims/jvm_misc.hpp"

    41 #include "runtime/fieldDescriptor.hpp"

    42 #include "runtime/handles.hpp"

    43 #include "runtime/interfaceSupport.hpp"

    44 #include "runtime/jfieldIDWorkaround.hpp"

    45 #include "runtime/thread.inline.hpp"

    46 #ifdef TARGET_ARCH_x86

    47 # include "jniTypes_x86.hpp"

    48 #endif

    49 #ifdef TARGET_ARCH_sparc

    50 # include "jniTypes_sparc.hpp"

    51 #endif

    52 #ifdef TARGET_ARCH_zero

    53 # include "jniTypes_zero.hpp"

    54 #endif

    55 #ifdef TARGET_ARCH_arm

    56 # include "jniTypes_arm.hpp"

    57 #endif

    58 #ifdef TARGET_ARCH_ppc

    59 # include "jniTypes_ppc.hpp"

    60 #endif

    61 #ifdef TARGET_ARCH_mips

    62 # include "jniTypes_mips.hpp"

    63 #endif

    65 // Complain every extra number of unplanned local refs

    66 #define CHECK_JNI_LOCAL_REF_CAP_WARN_THRESHOLD 32

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

    69 // not in native code.

    71 #define ASSERT_OOPS_ALLOWED                                          \

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

    73            "jniCheck examining oops in bad state.")

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

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

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

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

    80 // NATIVE state.

    82 #define IN_VM(source_code)   {                                         \

    83     {                                                                  \

    84       ThreadInVMfromNative __tiv(thr);                                 \

    85       source_code                                                      \

    86     }                                                                  \

    87   }

    90 /*

    91  * DECLARATIONS

    92  */

    94 static struct JNINativeInterface_ * unchecked_jni_NativeInterface;

    97 /*

    98  * MACRO DEFINITIONS

    99  */

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

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

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

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

   106 // assertions in the wrapper routines might fire

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

   110 #define JNI_ENTRY_CHECKED(result_type, header)                           \

   111 extern "C" {                                                             \

   112   result_type JNICALL header {                                           \

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

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

   115       tty->print_cr("%s", fatal_using_jnienv_in_nonjava);                      \

   116       os::abort(true);                                                   \

   117     }                                                                    \

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

   119     if (env != xenv) {                                                   \

   120       NativeReportJNIFatalError(thr, warn_wrong_jnienv);                 \

   121     }                                                                    \

   122     VM_ENTRY_BASE(result_type, header, thr)

   125 #define UNCHECKED() (unchecked_jni_NativeInterface)

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

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

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

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

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

   132   "Get/ReleasePrimitiveArrayCritical or Get/ReleaseStringCritical";

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

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

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

   136 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";

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

   138 static const char * fatal_non_weak_method = "non-weak methodID passed to JNI call";

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

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

   141 static const char * fatal_prim_type_array_expected = "Primitive type array expected but not received for JNI array operation";

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

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

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

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

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

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

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

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

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

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

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

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

   156 // When in VM state:

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

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

   159   thr->print_stack();

   160 }

   162 // When in NATIVE state:

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

   164   IN_VM(

   165     ReportJNIFatalError(thr, msg);

   166   )

   167 }

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

   170   IN_VM(

   171     ReportJNIWarning(thr, msg);

   172   )

   173 }

   178 /*

   179  * SUPPORT FUNCTIONS

   180  */

   182 /**

   183  * Check whether or not a programmer has actually checked for exceptions. According

   184  * to the JNI Specification ("jni/spec/design.html#java_exceptions"):

   185  *

   186  * There are two cases where the programmer needs to check for exceptions without

   187  * being able to first check an error code:

   188  *

   189  * - The JNI functions that invoke a Java method return the result of the Java method.

   190  * The programmer must call ExceptionOccurred() to check for possible exceptions

   191  * that occurred during the execution of the Java method.

   192  *

   193  * - Some of the JNI array access functions do not return an error code, but may

   194  * throw an ArrayIndexOutOfBoundsException or ArrayStoreException.

   195  *

   196  * In all other cases, a non-error return value guarantees that no exceptions have been thrown.

   197  *

   198  * Programmers often defend against ArrayIndexOutOfBoundsException, so warning

   199  * for these functions would be pedantic.

   200  */

   201 static inline void

   202 check_pending_exception(JavaThread* thr) {

   203   if (thr->has_pending_exception()) {

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

   205   }

   206   if (thr->is_pending_jni_exception_check()) {

   207     IN_VM(

   208       tty->print_cr("WARNING in native method: JNI call made without checking exceptions when required to from %s",

   209         thr->get_pending_jni_exception_check());

   210       thr->print_stack();

   211     )

   212     thr->clear_pending_jni_exception_check(); // Just complain once

   213   }

   214 }

   216 /**

   217  * Add to the planned number of handles. I.e. plus current live & warning threshold

   218  */

   219 static inline void

   220 add_planned_handle_capacity(JNIHandleBlock* handles, size_t capacity) {

   221   handles->set_planned_capacity(capacity +

   222                                 handles->get_number_of_live_handles() +

   223                                 CHECK_JNI_LOCAL_REF_CAP_WARN_THRESHOLD);

   224 }

   227 static inline void

   228 functionEnterCritical(JavaThread* thr)

   229 {

   230   check_pending_exception(thr);

   231 }

   233 static inline void

   234 functionEnterCriticalExceptionAllowed(JavaThread* thr)

   235 {

   236 }

   238 static inline void

   239 functionEnter(JavaThread* thr)

   240 {

   241   if (thr->in_critical()) {

   242     tty->print_cr("%s", warn_other_function_in_critical);

   243   }

   244   check_pending_exception(thr);

   245 }

   247 static inline void

   248 functionEnterExceptionAllowed(JavaThread* thr)

   249 {

   250   if (thr->in_critical()) {

   251     tty->print_cr("%s", warn_other_function_in_critical);

   252   }

   253 }

   255 static inline void

   256 functionExit(JavaThread* thr)

   257 {

   258   JNIHandleBlock* handles = thr->active_handles();

   259   size_t planned_capacity = handles->get_planned_capacity();

   260   size_t live_handles = handles->get_number_of_live_handles();

   261   if (live_handles > planned_capacity) {

   262     IN_VM(

   263       tty->print_cr("WARNING: JNI local refs: %zu, exceeds capacity: %zu",

   264           live_handles, planned_capacity);

   265       thr->print_stack();

   266     )

   267     // Complain just the once, reset to current + warn threshold

   268     add_planned_handle_capacity(handles, 0);

   269   }

   270 }

   272 static inline void

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

   274 {

   275   fieldDescriptor fd;

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

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

   279     ReportJNIFatalError(thr, fatal_should_be_static);

   281   /* validate the class being passed */

   282   ASSERT_OOPS_ALLOWED;

   283   Klass* k_oop = jniCheck::validate_class(thr, cls, false);

   285   /* check for proper subclass hierarchy */

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

   287   Klass* f_oop = id->holder();

   288   if (!InstanceKlass::cast(k_oop)->is_subtype_of(f_oop))

   289     ReportJNIFatalError(thr, fatal_wrong_static_field);

   291   /* check for proper field type */

   292   if (!id->find_local_field(&fd))

   293     ReportJNIFatalError(thr, fatal_static_field_not_found);

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

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

   296     ReportJNIFatalError(thr, fatal_static_field_mismatch);

   297   }

   298 }

   300 static inline void

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

   302 {

   303   fieldDescriptor fd;

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

   306   if (jfieldIDWorkaround::is_static_jfieldID(fid))

   307     ReportJNIFatalError(thr, fatal_should_be_nonstatic);

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

   310   ASSERT_OOPS_ALLOWED;

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

   312   if (!oopObj) {

   313     ReportJNIFatalError(thr, fatal_null_object);

   314   }

   315   Klass* k_oop = oopObj->klass();

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

   318     ReportJNIFatalError(thr, fatal_wrong_field);

   319   }

   321   /* make sure the field exists */

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

   323   if (!InstanceKlass::cast(k_oop)->contains_field_offset(offset))

   324     ReportJNIFatalError(thr, fatal_wrong_field);

   326   /* check for proper field type */

   327   if (!InstanceKlass::cast(k_oop)->find_field_from_offset(offset,

   328                                                               false, &fd))

   329     ReportJNIFatalError(thr, fatal_instance_field_not_found);

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

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

   333     ReportJNIFatalError(thr, fatal_instance_field_mismatch);

   334   }

   335 }

   337 static inline void

   338 checkString(JavaThread* thr, jstring js)

   339 {

   340   ASSERT_OOPS_ALLOWED;

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

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

   343     ReportJNIFatalError(thr, fatal_non_string);

   344 }

   346 static inline arrayOop

   347 check_is_array(JavaThread* thr, jarray jArray)

   348 {

   349   ASSERT_OOPS_ALLOWED;

   350   arrayOop aOop;

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

   353   if (aOop == NULL || !aOop->is_array()) {

   354     ReportJNIFatalError(thr, fatal_non_array);

   355   }

   356   return aOop;

   357 }

   359 static inline arrayOop

   360 check_is_primitive_array(JavaThread* thr, jarray jArray) {

   361   arrayOop aOop = check_is_array(thr, jArray);

   363   if (!aOop->is_typeArray()) {

   364      ReportJNIFatalError(thr, fatal_prim_type_array_expected);

   365   }

   366   return aOop;

   367 }

   369 static inline void

   370 check_primitive_array_type(JavaThread* thr, jarray jArray, BasicType elementType)

   371 {

   372   BasicType array_type;

   373   arrayOop aOop;

   375   aOop = check_is_primitive_array(thr, jArray);

   376   array_type = TypeArrayKlass::cast(aOop->klass())->element_type();

   377   if (array_type != elementType) {

   378     ReportJNIFatalError(thr, fatal_element_type_mismatch);

   379   }

   380 }

   382 static inline void

   383 check_is_obj_array(JavaThread* thr, jarray jArray) {

   384   arrayOop aOop = check_is_array(thr, jArray);

   385   if (!aOop->is_objArray()) {

   386     ReportJNIFatalError(thr, fatal_object_array_expected);

   387   }

   388 }

   390 /*

   391  * Copy and wrap array elements for bounds checking.

   392  * Remember the original elements (GuardedMemory::get_tag())

   393  */

   394 static void* check_jni_wrap_copy_array(JavaThread* thr, jarray array,

   395     void* orig_elements) {

   396   void* result;

   397   IN_VM(

   398     oop a = JNIHandles::resolve_non_null(array);

   399     size_t len = arrayOop(a)->length() <<

   400         TypeArrayKlass::cast(a->klass())->log2_element_size();

   401     result = GuardedMemory::wrap_copy(orig_elements, len, orig_elements);

   402   )

   403   return result;

   404 }

   406 static void* check_wrapped_array(JavaThread* thr, const char* fn_name,

   407     void* obj, void* carray, size_t* rsz) {

   408   if (carray == NULL) {

   409     tty->print_cr("%s: elements vector NULL" PTR_FORMAT, fn_name, p2i(obj));

   410     NativeReportJNIFatalError(thr, "Elements vector NULL");

   411   }

   412   GuardedMemory guarded(carray);

   413   void* orig_result = guarded.get_tag();

   414   if (!guarded.verify_guards()) {

   415     tty->print_cr("ReleasePrimitiveArrayCritical: release array failed bounds "

   416         "check, incorrect pointer returned ? array: " PTR_FORMAT " carray: "

   417         PTR_FORMAT, p2i(obj), p2i(carray));

   418     guarded.print_on(tty);

   419     NativeReportJNIFatalError(thr, "ReleasePrimitiveArrayCritical: "

   420         "failed bounds check");

   421   }

   422   if (orig_result == NULL) {

   423     tty->print_cr("ReleasePrimitiveArrayCritical: unrecognized elements. array: "

   424         PTR_FORMAT " carray: " PTR_FORMAT, p2i(obj), p2i(carray));

   425     guarded.print_on(tty);

   426     NativeReportJNIFatalError(thr, "ReleasePrimitiveArrayCritical: "

   427         "unrecognized elements");

   428   }

   429   if (rsz != NULL) {

   430     *rsz = guarded.get_user_size();

   431   }

   432   return orig_result;

   433 }

   435 static void* check_wrapped_array_release(JavaThread* thr, const char* fn_name,

   436     void* obj, void* carray, jint mode) {

   437   size_t sz;

   438   void* orig_result = check_wrapped_array(thr, fn_name, obj, carray, &sz);

   439   switch (mode) {

   440   // As we never make copies, mode 0 and JNI_COMMIT are the same.

   441   case 0:

   442   case JNI_COMMIT:

   443     memcpy(orig_result, carray, sz);

   444     break;

   445   case JNI_ABORT:

   446     break;

   447   default:

   448     tty->print_cr("%s: Unrecognized mode %i releasing array "

   449         PTR_FORMAT " elements " PTR_FORMAT, fn_name, mode, p2i(obj), p2i(carray));

   450     NativeReportJNIFatalError(thr, "Unrecognized array release mode");

   451   }

   452   // We always need to release the copy we made with GuardedMemory

   453   GuardedMemory::free_copy(carray);

   454   return orig_result;

   455 }

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

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

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

   460       JNIHandles::is_global_handle(obj) ||

   461       JNIHandles::is_weak_global_handle(obj)) {

   462     ASSERT_OOPS_ALLOWED;

   463     return JNIHandles::resolve_external_guard(obj);

   464   }

   465   ReportJNIFatalError(thr, fatal_bad_ref_to_jni);

   466   return NULL;

   467 }

   470 Method* jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) {

   471   ASSERT_OOPS_ALLOWED;

   472   // Do the jmethodID check

   473   Method* moop = Method::checked_resolve_jmethod_id(method_id);

   474   if (moop == NULL) {

   475     ReportJNIFatalError(thr, fatal_wrong_class_or_method);

   476   }

   477   return moop;

   478 }

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

   482     if (!obj)

   483         return NULL;

   484     ASSERT_OOPS_ALLOWED;

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

   486     if (!oopObj) {

   487       ReportJNIFatalError(thr, fatal_bad_ref_to_jni);

   488     }

   489     return oopObj;

   490 }

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

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

   494 // array descriptors.

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

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

   498   size_t len = strlen(name);

   500   if (len >= 2 &&

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

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

   503     char msg[JVM_MAXPATHLEN];

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

   505     ReportJNIWarning(thr, msg);

   506   }

   507 }

   509 Klass* jniCheck::validate_class(JavaThread* thr, jclass clazz, bool allow_primitive) {

   510   ASSERT_OOPS_ALLOWED;

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

   512   if (!mirror) {

   513     ReportJNIFatalError(thr, fatal_received_null_class);

   514   }

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

   517     ReportJNIFatalError(thr, fatal_class_not_a_class);

   518   }

   520   Klass* k = java_lang_Class::as_Klass(mirror);

   521   // Make allowances for primitive classes ...

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

   523     ReportJNIFatalError(thr, fatal_class_not_a_class);

   524   }

   525   return k;

   526 }

   528 void jniCheck::validate_throwable_klass(JavaThread* thr, Klass* klass) {

   529   ASSERT_OOPS_ALLOWED;

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

   532   if (!klass->oop_is_instance() ||

   533       !InstanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) {

   534     ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);

   535   }

   536 }

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

   539   /* validate the object being passed */

   540   ASSERT_OOPS_ALLOWED;

   541   jniCheck::validate_jmethod_id(thr, method_id);

   542   jniCheck::validate_object(thr, obj);

   543 }

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

   546   /* validate the class being passed */

   547   ASSERT_OOPS_ALLOWED;

   548   jniCheck::validate_jmethod_id(thr, method_id);

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

   550 }

   553 /*

   554  * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE

   555  */

   557 JNI_ENTRY_CHECKED(jclass,

   558   checked_jni_DefineClass(JNIEnv *env,

   559                           const char *name,

   560                           jobject loader,

   561                           const jbyte *buf,

   562                           jsize len))

   563     functionEnter(thr);

   564     IN_VM(

   565       jniCheck::validate_object(thr, loader);

   566     )

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

   568     functionExit(thr);

   569     return result;

   570 JNI_END

   572 JNI_ENTRY_CHECKED(jclass,

   573   checked_jni_FindClass(JNIEnv *env,

   574                         const char *name))

   575     functionEnter(thr);

   576     IN_VM(

   577       jniCheck::validate_class_descriptor(thr, name);

   578     )

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

   580     functionExit(thr);

   581     return result;

   582 JNI_END

   584 JNI_ENTRY_CHECKED(jmethodID,

   585   checked_jni_FromReflectedMethod(JNIEnv *env,

   586                                   jobject method))

   587     functionEnter(thr);

   588     IN_VM(

   589       jniCheck::validate_object(thr, method);

   590     )

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

   592     functionExit(thr);

   593     return result;

   594 JNI_END

   596 JNI_ENTRY_CHECKED(jfieldID,

   597   checked_jni_FromReflectedField(JNIEnv *env,

   598                                  jobject field))

   599     functionEnter(thr);

   600     IN_VM(

   601       jniCheck::validate_object(thr, field);

   602     )

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

   604     functionExit(thr);

   605     return result;

   606 JNI_END

   608 JNI_ENTRY_CHECKED(jobject,

   609   checked_jni_ToReflectedMethod(JNIEnv *env,

   610                                 jclass cls,

   611                                 jmethodID methodID,

   612                                 jboolean isStatic))

   613     functionEnter(thr);

   614     IN_VM(

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

   616       jniCheck::validate_jmethod_id(thr, methodID);

   617     )

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

   619                                                     isStatic);

   620     functionExit(thr);

   621     return result;

   622 JNI_END

   624 JNI_ENTRY_CHECKED(jclass,

   625   checked_jni_GetSuperclass(JNIEnv *env,

   626                             jclass sub))

   627     functionEnter(thr);

   628     IN_VM(

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

   630     )

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

   632     functionExit(thr);

   633     return result;

   634 JNI_END

   636 JNI_ENTRY_CHECKED(jboolean,

   637   checked_jni_IsAssignableFrom(JNIEnv *env,

   638                                jclass sub,

   639                                jclass sup))

   640     functionEnter(thr);

   641     IN_VM(

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

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

   644     )

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

   646     functionExit(thr);

   647     return result;

   648 JNI_END

   650 JNI_ENTRY_CHECKED(jobject,

   651   checked_jni_ToReflectedField(JNIEnv *env,

   652                                jclass cls,

   653                                jfieldID fieldID,

   654                                jboolean isStatic))

   655     functionEnter(thr);

   656     IN_VM(

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

   658     )

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

   660                                                    isStatic);

   661     functionExit(thr);

   662     return result;

   663 JNI_END

   665 JNI_ENTRY_CHECKED(jint,

   666   checked_jni_Throw(JNIEnv *env,

   667                     jthrowable obj))

   668     functionEnter(thr);

   669     IN_VM(

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

   671       if (oopObj == NULL) {

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

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

   674       } else {

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

   676       }

   677     )

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

   679     functionExit(thr);

   680     return result;

   681 JNI_END

   683 JNI_ENTRY_CHECKED(jint,

   684   checked_jni_ThrowNew(JNIEnv *env,

   685                        jclass clazz,

   686                        const char *msg))

   687     functionEnter(thr);

   688     IN_VM(

   689       Klass* k = jniCheck::validate_class(thr, clazz, false);

   690       assert(k != NULL, "validate_class shouldn't return NULL Klass*");

   691       jniCheck::validate_throwable_klass(thr, k);

   692     )

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

   694     functionExit(thr);

   695     return result;

   696 JNI_END

   698 JNI_ENTRY_CHECKED(jthrowable,

   699   checked_jni_ExceptionOccurred(JNIEnv *env))

   700     thr->clear_pending_jni_exception_check();

   701     functionEnterExceptionAllowed(thr);

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

   703     functionExit(thr);

   704     return result;

   705 JNI_END

   707 JNI_ENTRY_CHECKED(void,

   708   checked_jni_ExceptionDescribe(JNIEnv *env))

   709     functionEnterExceptionAllowed(thr);

   710     UNCHECKED()->ExceptionDescribe(env);

   711     functionExit(thr);

   712 JNI_END

   714 JNI_ENTRY_CHECKED(void,

   715   checked_jni_ExceptionClear(JNIEnv *env))

   716     thr->clear_pending_jni_exception_check();

   717     functionEnterExceptionAllowed(thr);

   718     UNCHECKED()->ExceptionClear(env);

   719     functionExit(thr);

   720 JNI_END

   722 JNI_ENTRY_CHECKED(void,

   723   checked_jni_FatalError(JNIEnv *env,

   724                          const char *msg))

   725     thr->clear_pending_jni_exception_check();

   726     functionEnter(thr);

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

   728     functionExit(thr);

   729 JNI_END

   731 JNI_ENTRY_CHECKED(jint,

   732   checked_jni_PushLocalFrame(JNIEnv *env,

   733                              jint capacity))

   734     functionEnterExceptionAllowed(thr);

   735     if (capacity < 0)

   736       NativeReportJNIFatalError(thr, "negative capacity");

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

   738     if (result == JNI_OK) {

   739       add_planned_handle_capacity(thr->active_handles(), capacity);

   740     }

   741     functionExit(thr);

   742     return result;

   743 JNI_END

   745 JNI_ENTRY_CHECKED(jobject,

   746   checked_jni_PopLocalFrame(JNIEnv *env,

   747                             jobject result))

   748     functionEnterExceptionAllowed(thr);

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

   750     functionExit(thr);

   751     return res;

   752 JNI_END

   754 JNI_ENTRY_CHECKED(jobject,

   755   checked_jni_NewGlobalRef(JNIEnv *env,

   756                            jobject lobj))

   757     functionEnter(thr);

   758     IN_VM(

   759       if (lobj != NULL) {

   760         jniCheck::validate_handle(thr, lobj);

   761       }

   762     )

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

   764     functionExit(thr);

   765     return result;

   766 JNI_END

   768 JNI_ENTRY_CHECKED(void,

   769   checked_jni_DeleteGlobalRef(JNIEnv *env,

   770                               jobject gref))

   771     functionEnterExceptionAllowed(thr);

   772     IN_VM(

   773       jniCheck::validate_object(thr, gref);

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

   775         ReportJNIFatalError(thr,

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

   777       }

   778     )

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

   780     functionExit(thr);

   781 JNI_END

   783 JNI_ENTRY_CHECKED(void,

   784   checked_jni_DeleteLocalRef(JNIEnv *env,

   785                              jobject obj))

   786     functionEnterExceptionAllowed(thr);

   787     IN_VM(

   788       jniCheck::validate_object(thr, obj);

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

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

   791         ReportJNIFatalError(thr,

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

   793     )

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

   795     functionExit(thr);

   796 JNI_END

   798 JNI_ENTRY_CHECKED(jboolean,

   799   checked_jni_IsSameObject(JNIEnv *env,

   800                            jobject obj1,

   801                            jobject obj2))

   802     functionEnterExceptionAllowed(thr);

   803     IN_VM(

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

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

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

   807        */

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

   809         jniCheck::validate_object(thr, obj1);

   810       }

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

   812         jniCheck::validate_object(thr, obj2);

   813       }

   814     )

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

   816     functionExit(thr);

   817     return result;

   818 JNI_END

   820 JNI_ENTRY_CHECKED(jobject,

   821   checked_jni_NewLocalRef(JNIEnv *env,

   822                           jobject ref))

   823     functionEnter(thr);

   824     IN_VM(

   825       if (ref != NULL) {

   826         jniCheck::validate_handle(thr, ref);

   827       }

   828     )

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

   830     functionExit(thr);

   831     return result;

   832 JNI_END

   834 JNI_ENTRY_CHECKED(jint,

   835   checked_jni_EnsureLocalCapacity(JNIEnv *env,

   836                                   jint capacity))

   837     functionEnter(thr);

   838     if (capacity < 0) {

   839       NativeReportJNIFatalError(thr, "negative capacity");

   840     }

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

   842     if (result == JNI_OK) {

   843       add_planned_handle_capacity(thr->active_handles(), capacity);

   844     }

   845     functionExit(thr);

   846     return result;

   847 JNI_END

   849 JNI_ENTRY_CHECKED(jobject,

   850   checked_jni_AllocObject(JNIEnv *env,

   851                           jclass clazz))

   852     functionEnter(thr);

   853     IN_VM(

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

   855     )

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

   857     functionExit(thr);

   858     return result;

   859 JNI_END

   861 JNI_ENTRY_CHECKED(jobject,

   862   checked_jni_NewObject(JNIEnv *env,

   863                         jclass clazz,

   864                         jmethodID methodID,

   865                         ...))

   866     functionEnter(thr);

   867     va_list args;

   868     IN_VM(

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

   870       jniCheck::validate_jmethod_id(thr, methodID);

   871     )

   872     va_start(args, methodID);

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

   874     va_end(args);

   875     functionExit(thr);

   876     return result;

   877 JNI_END

   879 JNI_ENTRY_CHECKED(jobject,

   880   checked_jni_NewObjectV(JNIEnv *env,

   881                          jclass clazz,

   882                          jmethodID methodID,

   883                          va_list args))

   884     functionEnter(thr);

   885     IN_VM(

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

   887       jniCheck::validate_jmethod_id(thr, methodID);

   888     )

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

   890     functionExit(thr);

   891     return result;

   892 JNI_END

   894 JNI_ENTRY_CHECKED(jobject,

   895   checked_jni_NewObjectA(JNIEnv *env,

   896                          jclass clazz,

   897                          jmethodID methodID,

   898                          const jvalue *args))

   899     functionEnter(thr);

   900     IN_VM(

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

   902       jniCheck::validate_jmethod_id(thr, methodID);

   903     )

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

   905     functionExit(thr);

   906     return result;

   907 JNI_END

   909 JNI_ENTRY_CHECKED(jclass,

   910   checked_jni_GetObjectClass(JNIEnv *env,

   911                              jobject obj))

   912     functionEnter(thr);

   913     IN_VM(

   914       jniCheck::validate_object(thr, obj);

   915     )

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

   917     functionExit(thr);

   918     return result;

   919 JNI_END

   921 JNI_ENTRY_CHECKED(jboolean,

   922   checked_jni_IsInstanceOf(JNIEnv *env,

   923                            jobject obj,

   924                            jclass clazz))

   925     functionEnter(thr);

   926     IN_VM(

   927       jniCheck::validate_object(thr, obj);

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

   929     )

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

   931     functionExit(thr);

   932     return result;

   933 JNI_END

   935 JNI_ENTRY_CHECKED(jmethodID,

   936   checked_jni_GetMethodID(JNIEnv *env,

   937                           jclass clazz,

   938                           const char *name,

   939                           const char *sig))

   940     functionEnter(thr);

   941     IN_VM(

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

   943     )

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

   945     functionExit(thr);

   946     return result;

   947 JNI_END

   949 #define WRAPPER_CallMethod(ResultType, Result) \

   950 JNI_ENTRY_CHECKED(ResultType,  \

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

   952                                    jobject obj, \

   953                                    jmethodID methodID, \

   954                                    ...)) \

   955     functionEnter(thr); \

   956     va_list args; \

   957     IN_VM( \

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

   959     ) \

   960     va_start(args,methodID); \

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

   962                                                           args); \

   963     va_end(args); \

   964     thr->set_pending_jni_exception_check("Call"#Result"Method"); \

   965     functionExit(thr); \

   966     return result; \

   967 JNI_END \

   968 \

   969 JNI_ENTRY_CHECKED(ResultType,  \

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

   971                                     jobject obj, \

   972                                     jmethodID methodID, \

   973                                     va_list args)) \

   974     functionEnter(thr); \

   975     IN_VM(\

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

   977     ) \

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

   979                                                            args); \

   980     thr->set_pending_jni_exception_check("Call"#Result"MethodV"); \

   981     functionExit(thr); \

   982     return result; \

   983 JNI_END \

   984 \

   985 JNI_ENTRY_CHECKED(ResultType,  \

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

   987                                     jobject obj, \

   988                                     jmethodID methodID, \

   989                                     const jvalue * args)) \

   990     functionEnter(thr); \

   991     IN_VM( \

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

   993     ) \

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

   995                                                            args); \

   996     thr->set_pending_jni_exception_check("Call"#Result"MethodA"); \

   997     functionExit(thr); \

   998     return result; \

   999 JNI_END

  1001 WRAPPER_CallMethod(jobject,Object)

  1002 WRAPPER_CallMethod(jboolean,Boolean)

  1003 WRAPPER_CallMethod(jbyte,Byte)

  1004 WRAPPER_CallMethod(jshort,Short)

  1005 WRAPPER_CallMethod(jchar,Char)

  1006 WRAPPER_CallMethod(jint,Int)

  1007 WRAPPER_CallMethod(jlong,Long)

  1008 WRAPPER_CallMethod(jfloat,Float)

  1009 WRAPPER_CallMethod(jdouble,Double)

  1011 JNI_ENTRY_CHECKED(void,

  1012   checked_jni_CallVoidMethod(JNIEnv *env, \

  1013                              jobject obj, \

  1014                              jmethodID methodID, \

  1015                              ...))

  1016     functionEnter(thr);

  1017     va_list args;

  1018     IN_VM(

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

  1020     )

  1021     va_start(args,methodID);

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

  1023     va_end(args);

  1024     thr->set_pending_jni_exception_check("CallVoidMethod");

  1025     functionExit(thr);

  1026 JNI_END

  1028 JNI_ENTRY_CHECKED(void,

  1029   checked_jni_CallVoidMethodV(JNIEnv *env,

  1030                               jobject obj,

  1031                               jmethodID methodID,

  1032                               va_list args))

  1033     functionEnter(thr);

  1034     IN_VM(

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

  1036     )

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

  1038     thr->set_pending_jni_exception_check("CallVoidMethodV");

  1039     functionExit(thr);

  1040 JNI_END

  1042 JNI_ENTRY_CHECKED(void,

  1043   checked_jni_CallVoidMethodA(JNIEnv *env,

  1044                               jobject obj,

  1045                               jmethodID methodID,

  1046                               const jvalue * args))

  1047     functionEnter(thr);

  1048     IN_VM(

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

  1050     )

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

  1052     thr->set_pending_jni_exception_check("CallVoidMethodA");

  1053     functionExit(thr);

  1054 JNI_END

  1056 #define WRAPPER_CallNonvirtualMethod(ResultType, Result) \

  1057 JNI_ENTRY_CHECKED(ResultType,  \

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

  1059                                              jobject obj, \

  1060                                              jclass clazz, \

  1061                                              jmethodID methodID, \

  1062                                              ...)) \

  1063     functionEnter(thr); \

  1064     va_list args; \

  1065     IN_VM( \

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

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

  1068     ) \

  1069     va_start(args,methodID); \

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

  1071                                                                      obj, \

  1072                                                                      clazz, \

  1073                                                                      methodID,\

  1074                                                                      args); \

  1075     va_end(args); \

  1076     thr->set_pending_jni_exception_check("CallNonvirtual"#Result"Method"); \

  1077     functionExit(thr); \

  1078     return result; \

  1079 JNI_END \

  1080 \

  1081 JNI_ENTRY_CHECKED(ResultType,  \

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

  1083                                               jobject obj, \

  1084                                               jclass clazz, \

  1085                                               jmethodID methodID, \

  1086                                               va_list args)) \

  1087     functionEnter(thr); \

  1088     IN_VM( \

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

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

  1091     ) \

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

  1093                                                                      obj, \

  1094                                                                      clazz, \

  1095                                                                      methodID,\

  1096                                                                      args); \

  1097     thr->set_pending_jni_exception_check("CallNonvirtual"#Result"MethodV"); \

  1098     functionExit(thr); \

  1099     return result; \

  1100 JNI_END \

  1101 \

  1102 JNI_ENTRY_CHECKED(ResultType,  \

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

  1104                                               jobject obj, \

  1105                                               jclass clazz, \

  1106                                               jmethodID methodID, \

  1107                                               const jvalue * args)) \

  1108     functionEnter(thr); \

  1109     IN_VM( \

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

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

  1112     ) \

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

  1114                                                                      obj, \

  1115                                                                      clazz, \

  1116                                                                      methodID,\

  1117                                                                      args); \

  1118     thr->set_pending_jni_exception_check("CallNonvirtual"#Result"MethodA"); \

  1119     functionExit(thr); \

  1120     return result; \

  1121 JNI_END

  1123 WRAPPER_CallNonvirtualMethod(jobject,Object)

  1124 WRAPPER_CallNonvirtualMethod(jboolean,Boolean)

  1125 WRAPPER_CallNonvirtualMethod(jbyte,Byte)

  1126 WRAPPER_CallNonvirtualMethod(jshort,Short)

  1127 WRAPPER_CallNonvirtualMethod(jchar,Char)

  1128 WRAPPER_CallNonvirtualMethod(jint,Int)

  1129 WRAPPER_CallNonvirtualMethod(jlong,Long)

  1130 WRAPPER_CallNonvirtualMethod(jfloat,Float)

  1131 WRAPPER_CallNonvirtualMethod(jdouble,Double)

  1133 JNI_ENTRY_CHECKED(void,

  1134   checked_jni_CallNonvirtualVoidMethod(JNIEnv *env,

  1135                                        jobject obj,

  1136                                        jclass clazz,

  1137                                        jmethodID methodID,

  1138                                        ...))

  1139     functionEnter(thr);

  1140     va_list args;

  1141     IN_VM(

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

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

  1144     )

  1145     va_start(args,methodID);

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

  1147     va_end(args);

  1148     thr->set_pending_jni_exception_check("CallNonvirtualVoidMethod");

  1149     functionExit(thr);

  1150 JNI_END

  1152 JNI_ENTRY_CHECKED(void,

  1153   checked_jni_CallNonvirtualVoidMethodV(JNIEnv *env,

  1154                                         jobject obj,

  1155                                         jclass clazz,

  1156                                         jmethodID methodID,

  1157                                         va_list args))

  1158     functionEnter(thr);

  1159     IN_VM(

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

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

  1162     )

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

  1164     thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodV");

  1165     functionExit(thr);

  1166 JNI_END

  1168 JNI_ENTRY_CHECKED(void,

  1169   checked_jni_CallNonvirtualVoidMethodA(JNIEnv *env,

  1170                                         jobject obj,

  1171                                         jclass clazz,

  1172                                         jmethodID methodID,

  1173                                         const jvalue * args))

  1174     functionEnter(thr);

  1175     IN_VM(

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

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

  1178     )

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

  1180     thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodA");

  1181     functionExit(thr);

  1182 JNI_END

  1184 JNI_ENTRY_CHECKED(jfieldID,

  1185   checked_jni_GetFieldID(JNIEnv *env,

  1186                          jclass clazz,

  1187                          const char *name,

  1188                          const char *sig))

  1189     functionEnter(thr);

  1190     IN_VM(

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

  1192     )

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

  1194     functionExit(thr);

  1195     return result;

  1196 JNI_END

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

  1199 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1201                                  jobject obj, \

  1202                                  jfieldID fieldID)) \

  1203     functionEnter(thr); \

  1204     IN_VM( \

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

  1206     ) \

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

  1208     functionExit(thr); \

  1209     return result; \

  1210 JNI_END

  1212 WRAPPER_GetField(jobject,  Object,  T_OBJECT)

  1213 WRAPPER_GetField(jboolean, Boolean, T_BOOLEAN)

  1214 WRAPPER_GetField(jbyte,    Byte,    T_BYTE)

  1215 WRAPPER_GetField(jshort,   Short,   T_SHORT)

  1216 WRAPPER_GetField(jchar,    Char,    T_CHAR)

  1217 WRAPPER_GetField(jint,     Int,     T_INT)

  1218 WRAPPER_GetField(jlong,    Long,    T_LONG)

  1219 WRAPPER_GetField(jfloat,   Float,   T_FLOAT)

  1220 WRAPPER_GetField(jdouble,  Double,  T_DOUBLE)

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

  1223 JNI_ENTRY_CHECKED(void,  \

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

  1225                                  jobject obj, \

  1226                                  jfieldID fieldID, \

  1227                                  ValueType val)) \

  1228     functionEnter(thr); \

  1229     IN_VM( \

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

  1231     ) \

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

  1233     functionExit(thr); \

  1234 JNI_END

  1236 WRAPPER_SetField(jobject,  Object,  T_OBJECT)

  1237 WRAPPER_SetField(jboolean, Boolean, T_BOOLEAN)

  1238 WRAPPER_SetField(jbyte,    Byte,    T_BYTE)

  1239 WRAPPER_SetField(jshort,   Short,   T_SHORT)

  1240 WRAPPER_SetField(jchar,    Char,    T_CHAR)

  1241 WRAPPER_SetField(jint,     Int,     T_INT)

  1242 WRAPPER_SetField(jlong,    Long,    T_LONG)

  1243 WRAPPER_SetField(jfloat,   Float,   T_FLOAT)

  1244 WRAPPER_SetField(jdouble,  Double,  T_DOUBLE)

  1247 JNI_ENTRY_CHECKED(jmethodID,

  1248   checked_jni_GetStaticMethodID(JNIEnv *env,

  1249                                 jclass clazz,

  1250                                 const char *name,

  1251                                 const char *sig))

  1252     functionEnter(thr);

  1253     IN_VM(

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

  1255     )

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

  1257     functionExit(thr);

  1258     return result;

  1259 JNI_END

  1261 #define WRAPPER_CallStaticMethod(ReturnType,Result) \

  1262 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1264                                          jclass clazz, \

  1265                                          jmethodID methodID, \

  1266                                          ...)) \

  1267     functionEnter(thr); \

  1268     va_list args; \

  1269     IN_VM( \

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

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

  1272     ) \

  1273     va_start(args,methodID); \

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

  1275                                                                  clazz, \

  1276                                                                  methodID, \

  1277                                                                  args); \

  1278     va_end(args); \

  1279     thr->set_pending_jni_exception_check("CallStatic"#Result"Method"); \

  1280     functionExit(thr); \

  1281     return result; \

  1282 JNI_END \

  1283 \

  1284 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1286                                           jclass clazz, \

  1287                                           jmethodID methodID,\

  1288                                           va_list args)) \

  1289     functionEnter(thr); \

  1290     IN_VM( \

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

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

  1293     ) \

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

  1295                                                                  clazz, \

  1296                                                                  methodID, \

  1297                                                                  args); \

  1298     thr->set_pending_jni_exception_check("CallStatic"#Result"MethodV"); \

  1299     functionExit(thr); \

  1300     return result; \

  1301 JNI_END \

  1302 \

  1303 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1305                                           jclass clazz, \

  1306                                           jmethodID methodID, \

  1307                                           const jvalue *args)) \

  1308     functionEnter(thr); \

  1309     IN_VM( \

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

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

  1312     ) \

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

  1314                                                                  clazz, \

  1315                                                                  methodID, \

  1316                                                                  args); \

  1317     thr->set_pending_jni_exception_check("CallStatic"#Result"MethodA"); \

  1318     functionExit(thr); \

  1319     return result; \

  1320 JNI_END

  1322 WRAPPER_CallStaticMethod(jobject,Object)

  1323 WRAPPER_CallStaticMethod(jboolean,Boolean)

  1324 WRAPPER_CallStaticMethod(jbyte,Byte)

  1325 WRAPPER_CallStaticMethod(jshort,Short)

  1326 WRAPPER_CallStaticMethod(jchar,Char)

  1327 WRAPPER_CallStaticMethod(jint,Int)

  1328 WRAPPER_CallStaticMethod(jlong,Long)

  1329 WRAPPER_CallStaticMethod(jfloat,Float)

  1330 WRAPPER_CallStaticMethod(jdouble,Double)

  1332 JNI_ENTRY_CHECKED(void,

  1333   checked_jni_CallStaticVoidMethod(JNIEnv *env,

  1334                                    jclass cls,

  1335                                    jmethodID methodID,

  1336                                    ...))

  1337     functionEnter(thr);

  1338     va_list args;

  1339     IN_VM(

  1340       jniCheck::validate_jmethod_id(thr, methodID);

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

  1342     )

  1343     va_start(args,methodID);

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

  1345     va_end(args);

  1346     thr->set_pending_jni_exception_check("CallStaticVoidMethod");

  1347     functionExit(thr);

  1348 JNI_END

  1350 JNI_ENTRY_CHECKED(void,

  1351   checked_jni_CallStaticVoidMethodV(JNIEnv *env,

  1352                                     jclass cls,

  1353                                     jmethodID methodID,

  1354                                     va_list args))

  1355     functionEnter(thr);

  1356     IN_VM(

  1357       jniCheck::validate_jmethod_id(thr, methodID);

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

  1359     )

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

  1361     thr->set_pending_jni_exception_check("CallStaticVoidMethodV");

  1362     functionExit(thr);

  1363 JNI_END

  1365 JNI_ENTRY_CHECKED(void,

  1366   checked_jni_CallStaticVoidMethodA(JNIEnv *env,

  1367                                     jclass cls,

  1368                                     jmethodID methodID,

  1369                                     const jvalue * args))

  1370     functionEnter(thr);

  1371     IN_VM(

  1372       jniCheck::validate_jmethod_id(thr, methodID);

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

  1374     )

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

  1376     thr->set_pending_jni_exception_check("CallStaticVoidMethodA");

  1377     functionExit(thr);

  1378 JNI_END

  1380 JNI_ENTRY_CHECKED(jfieldID,

  1381   checked_jni_GetStaticFieldID(JNIEnv *env,

  1382                                jclass clazz,

  1383                                const char *name,

  1384                                const char *sig))

  1385     functionEnter(thr);

  1386     IN_VM(

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

  1388     )

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

  1390     functionExit(thr);

  1391     return result;

  1392 JNI_END

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

  1395 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1397                                        jclass clazz, \

  1398                                        jfieldID fieldID)) \

  1399     functionEnter(thr); \

  1400     IN_VM( \

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

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

  1403     ) \

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

  1405                                                               clazz, \

  1406                                                               fieldID); \

  1407     functionExit(thr); \

  1408     return result; \

  1409 JNI_END

  1411 WRAPPER_GetStaticField(jobject,  Object,  T_OBJECT)

  1412 WRAPPER_GetStaticField(jboolean, Boolean, T_BOOLEAN)

  1413 WRAPPER_GetStaticField(jbyte,    Byte,    T_BYTE)

  1414 WRAPPER_GetStaticField(jshort,   Short,   T_SHORT)

  1415 WRAPPER_GetStaticField(jchar,    Char,    T_CHAR)

  1416 WRAPPER_GetStaticField(jint,     Int,     T_INT)

  1417 WRAPPER_GetStaticField(jlong,    Long,    T_LONG)

  1418 WRAPPER_GetStaticField(jfloat,   Float,   T_FLOAT)

  1419 WRAPPER_GetStaticField(jdouble,  Double,  T_DOUBLE)

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

  1422 JNI_ENTRY_CHECKED(void,  \

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

  1424                                        jclass clazz, \

  1425                                        jfieldID fieldID, \

  1426                                        ValueType value)) \

  1427     functionEnter(thr); \

  1428     IN_VM( \

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

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

  1431     ) \

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

  1433     functionExit(thr); \

  1434 JNI_END

  1436 WRAPPER_SetStaticField(jobject,  Object,  T_OBJECT)

  1437 WRAPPER_SetStaticField(jboolean, Boolean, T_BOOLEAN)

  1438 WRAPPER_SetStaticField(jbyte,    Byte,    T_BYTE)

  1439 WRAPPER_SetStaticField(jshort,   Short,   T_SHORT)

  1440 WRAPPER_SetStaticField(jchar,    Char,    T_CHAR)

  1441 WRAPPER_SetStaticField(jint,     Int,     T_INT)

  1442 WRAPPER_SetStaticField(jlong,    Long,    T_LONG)

  1443 WRAPPER_SetStaticField(jfloat,   Float,   T_FLOAT)

  1444 WRAPPER_SetStaticField(jdouble,  Double,  T_DOUBLE)

  1447 JNI_ENTRY_CHECKED(jstring,

  1448   checked_jni_NewString(JNIEnv *env,

  1449                         const jchar *unicode,

  1450                         jsize len))

  1451     functionEnter(thr);

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

  1453     functionExit(thr);

  1454     return result;

  1455 JNI_END

  1457 JNI_ENTRY_CHECKED(jsize,

  1458   checked_jni_GetStringLength(JNIEnv *env,

  1459                               jstring str))

  1460     functionEnter(thr);

  1461     IN_VM(

  1462       checkString(thr, str);

  1463     )

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

  1465     functionExit(thr);

  1466     return result;

  1467 JNI_END

  1469 // Arbitrary (but well-known) tag

  1470 const void* STRING_TAG = (void*)0x47114711;

  1472 JNI_ENTRY_CHECKED(const jchar *,

  1473   checked_jni_GetStringChars(JNIEnv *env,

  1474                              jstring str,

  1475                              jboolean *isCopy))

  1476     functionEnter(thr);

  1477     IN_VM(

  1478       checkString(thr, str);

  1479     )

  1480     jchar* new_result = NULL;

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

  1482     assert (isCopy == NULL || *isCopy == JNI_TRUE, "GetStringChars didn't return a copy as expected");

  1483     if (result != NULL) {

  1484       size_t len = UNCHECKED()->GetStringLength(env,str) + 1; // + 1 for NULL termination

  1485       len *= sizeof(jchar);

  1486       new_result = (jchar*) GuardedMemory::wrap_copy(result, len, STRING_TAG);

  1487       if (new_result == NULL) {

  1488         vm_exit_out_of_memory(len, OOM_MALLOC_ERROR, "checked_jni_GetStringChars");

  1489       }

  1490       // Avoiding call to UNCHECKED()->ReleaseStringChars() since that will fire unexpected dtrace probes

  1491       // Note that the dtrace arguments for the allocated memory will not match up with this solution.

  1492       FreeHeap((char*)result);

  1493     }

  1494     functionExit(thr);

  1495     return new_result;

  1496 JNI_END

  1498 JNI_ENTRY_CHECKED(void,

  1499   checked_jni_ReleaseStringChars(JNIEnv *env,

  1500                                  jstring str,

  1501                                  const jchar *chars))

  1502     functionEnterExceptionAllowed(thr);

  1503     IN_VM(

  1504       checkString(thr, str);

  1505     )

  1506     if (chars == NULL) {

  1507        // still do the unchecked call to allow dtrace probes

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

  1509     }

  1510     else {

  1511       GuardedMemory guarded((void*)chars);

  1512       if (!guarded.verify_guards()) {

  1513         tty->print_cr("ReleaseStringChars: release chars failed bounds check. "

  1514             "string: " PTR_FORMAT " chars: " PTR_FORMAT, p2i(str), p2i(chars));

  1515         guarded.print_on(tty);

  1516         NativeReportJNIFatalError(thr, "ReleaseStringChars: "

  1517             "release chars failed bounds check.");

  1518       }

  1519       if (guarded.get_tag() != STRING_TAG) {

  1520         tty->print_cr("ReleaseStringChars: called on something not allocated "

  1521             "by GetStringChars. string: " PTR_FORMAT " chars: " PTR_FORMAT,

  1522             p2i(str), p2i(chars));

  1523         NativeReportJNIFatalError(thr, "ReleaseStringChars called on something "

  1524             "not allocated by GetStringChars");

  1525       }

  1526        UNCHECKED()->ReleaseStringChars(env, str,

  1527            (const jchar*) guarded.release_for_freeing());

  1528     }

  1529     functionExit(thr);

  1530 JNI_END

  1532 JNI_ENTRY_CHECKED(jstring,

  1533   checked_jni_NewStringUTF(JNIEnv *env,

  1534                            const char *utf))

  1535     functionEnter(thr);

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

  1537     functionExit(thr);

  1538     return result;

  1539 JNI_END

  1541 JNI_ENTRY_CHECKED(jsize,

  1542   checked_jni_GetStringUTFLength(JNIEnv *env,

  1543                                  jstring str))

  1544     functionEnter(thr);

  1545     IN_VM(

  1546       checkString(thr, str);

  1547     )

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

  1549     functionExit(thr);

  1550     return result;

  1551 JNI_END

  1553 // Arbitrary (but well-known) tag - different than GetStringChars

  1554 const void* STRING_UTF_TAG = (void*) 0x48124812;

  1556 JNI_ENTRY_CHECKED(const char *,

  1557   checked_jni_GetStringUTFChars(JNIEnv *env,

  1558                                 jstring str,

  1559                                 jboolean *isCopy))

  1560     functionEnter(thr);

  1561     IN_VM(

  1562       checkString(thr, str);

  1563     )

  1564     char* new_result = NULL;

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

  1566     assert (isCopy == NULL || *isCopy == JNI_TRUE, "GetStringUTFChars didn't return a copy as expected");

  1567     if (result != NULL) {

  1568       size_t len = strlen(result) + 1; // + 1 for NULL termination

  1569       new_result = (char*) GuardedMemory::wrap_copy(result, len, STRING_UTF_TAG);

  1570       if (new_result == NULL) {

  1571         vm_exit_out_of_memory(len, OOM_MALLOC_ERROR, "checked_jni_GetStringUTFChars");

  1572       }

  1573       // Avoiding call to UNCHECKED()->ReleaseStringUTFChars() since that will fire unexpected dtrace probes

  1574       // Note that the dtrace arguments for the allocated memory will not match up with this solution.

  1575       FreeHeap((char*)result, mtInternal);

  1576     }

  1577     functionExit(thr);

  1578     return new_result;

  1579 JNI_END

  1581 JNI_ENTRY_CHECKED(void,

  1582   checked_jni_ReleaseStringUTFChars(JNIEnv *env,

  1583                                     jstring str,

  1584                                     const char* chars))

  1585     functionEnterExceptionAllowed(thr);

  1586     IN_VM(

  1587       checkString(thr, str);

  1588     )

  1589     if (chars == NULL) {

  1590        // still do the unchecked call to allow dtrace probes

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

  1592     }

  1593     else {

  1594       GuardedMemory guarded((void*)chars);

  1595       if (!guarded.verify_guards()) {

  1596         tty->print_cr("ReleaseStringUTFChars: release chars failed bounds check. "

  1597             "string: " PTR_FORMAT " chars: " PTR_FORMAT, p2i(str), p2i(chars));

  1598         guarded.print_on(tty);

  1599         NativeReportJNIFatalError(thr, "ReleaseStringUTFChars: "

  1600             "release chars failed bounds check.");

  1601       }

  1602       if (guarded.get_tag() != STRING_UTF_TAG) {

  1603         tty->print_cr("ReleaseStringUTFChars: called on something not "

  1604             "allocated by GetStringUTFChars. string: " PTR_FORMAT " chars: "

  1605             PTR_FORMAT, p2i(str), p2i(chars));

  1606         NativeReportJNIFatalError(thr, "ReleaseStringUTFChars "

  1607             "called on something not allocated by GetStringUTFChars");

  1608       }

  1609       UNCHECKED()->ReleaseStringUTFChars(env, str,

  1610           (const char*) guarded.release_for_freeing());

  1611     }

  1612     functionExit(thr);

  1613 JNI_END

  1615 JNI_ENTRY_CHECKED(jsize,

  1616   checked_jni_GetArrayLength(JNIEnv *env,

  1617                              jarray array))

  1618     functionEnter(thr);

  1619     IN_VM(

  1620       check_is_array(thr, array);

  1621     )

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

  1623     functionExit(thr);

  1624     return result;

  1625 JNI_END

  1627 JNI_ENTRY_CHECKED(jobjectArray,

  1628   checked_jni_NewObjectArray(JNIEnv *env,

  1629                              jsize len,

  1630                              jclass clazz,

  1631                              jobject init))

  1632     functionEnter(thr);

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

  1634     functionExit(thr);

  1635     return result;

  1636 JNI_END

  1638 JNI_ENTRY_CHECKED(jobject,

  1639   checked_jni_GetObjectArrayElement(JNIEnv *env,

  1640                                     jobjectArray array,

  1641                                     jsize index))

  1642     functionEnter(thr);

  1643     IN_VM(

  1644       check_is_obj_array(thr, array);

  1645     )

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

  1647     functionExit(thr);

  1648     return result;

  1649 JNI_END

  1651 JNI_ENTRY_CHECKED(void,

  1652   checked_jni_SetObjectArrayElement(JNIEnv *env,

  1653                                     jobjectArray array,

  1654                                     jsize index,

  1655                                     jobject val))

  1656     functionEnter(thr);

  1657     IN_VM(

  1658       check_is_obj_array(thr, array);

  1659     )

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

  1661     functionExit(thr);

  1662 JNI_END

  1664 #define WRAPPER_NewScalarArray(Return, Result) \

  1665 JNI_ENTRY_CHECKED(Return, \

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

  1667                                  jsize len)) \

  1668     functionEnter(thr); \

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

  1670     functionExit(thr); \

  1671     return (Return) result; \

  1672 JNI_END

  1674 WRAPPER_NewScalarArray(jbooleanArray, Boolean)

  1675 WRAPPER_NewScalarArray(jbyteArray, Byte)

  1676 WRAPPER_NewScalarArray(jshortArray, Short)

  1677 WRAPPER_NewScalarArray(jcharArray, Char)

  1678 WRAPPER_NewScalarArray(jintArray, Int)

  1679 WRAPPER_NewScalarArray(jlongArray, Long)

  1680 WRAPPER_NewScalarArray(jfloatArray, Float)

  1681 WRAPPER_NewScalarArray(jdoubleArray, Double)

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

  1684 JNI_ENTRY_CHECKED(ElementType *,  \

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

  1686                                          ElementType##Array array, \

  1687                                          jboolean *isCopy)) \

  1688     functionEnter(thr); \

  1689     IN_VM( \

  1690       check_primitive_array_type(thr, array, ElementTag); \

  1691     ) \

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

  1693                                                                   array, \

  1694                                                                   isCopy); \

  1695     if (result != NULL) { \

  1696       result = (ElementType *) check_jni_wrap_copy_array(thr, array, result); \

  1697     } \

  1698     functionExit(thr); \

  1699     return result; \

  1700 JNI_END

  1702 WRAPPER_GetScalarArrayElements(T_BOOLEAN, jboolean, Boolean)

  1703 WRAPPER_GetScalarArrayElements(T_BYTE,    jbyte,    Byte)

  1704 WRAPPER_GetScalarArrayElements(T_SHORT,   jshort,   Short)

  1705 WRAPPER_GetScalarArrayElements(T_CHAR,    jchar,    Char)

  1706 WRAPPER_GetScalarArrayElements(T_INT,     jint,     Int)

  1707 WRAPPER_GetScalarArrayElements(T_LONG,    jlong,    Long)

  1708 WRAPPER_GetScalarArrayElements(T_FLOAT,   jfloat,   Float)

  1709 WRAPPER_GetScalarArrayElements(T_DOUBLE,  jdouble,  Double)

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

  1712 JNI_ENTRY_CHECKED(void,  \

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

  1714                                              ElementType##Array array, \

  1715                                              ElementType *elems, \

  1716                                              jint mode)) \

  1717     functionEnterExceptionAllowed(thr); \

  1718     IN_VM( \

  1719       check_primitive_array_type(thr, array, ElementTag); \

  1720       ASSERT_OOPS_ALLOWED; \

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

  1722     ) \

  1723     ElementType* orig_result = (ElementType *) check_wrapped_array_release( \

  1724         thr, "checked_jni_Release"#Result"ArrayElements", array, elems, mode); \

  1725     UNCHECKED()->Release##Result##ArrayElements(env, array, orig_result, mode); \

  1726     functionExit(thr); \

  1727 JNI_END

  1729 WRAPPER_ReleaseScalarArrayElements(T_BOOLEAN,jboolean, Boolean, bool)

  1730 WRAPPER_ReleaseScalarArrayElements(T_BYTE,   jbyte,    Byte,    byte)

  1731 WRAPPER_ReleaseScalarArrayElements(T_SHORT,  jshort,   Short,   short)

  1732 WRAPPER_ReleaseScalarArrayElements(T_CHAR,   jchar,    Char,    char)

  1733 WRAPPER_ReleaseScalarArrayElements(T_INT,    jint,     Int,     int)

  1734 WRAPPER_ReleaseScalarArrayElements(T_LONG,   jlong,    Long,    long)

  1735 WRAPPER_ReleaseScalarArrayElements(T_FLOAT,  jfloat,   Float,   float)

  1736 WRAPPER_ReleaseScalarArrayElements(T_DOUBLE, jdouble,  Double,  double)

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

  1739 JNI_ENTRY_CHECKED(void,  \

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

  1741                                        ElementType##Array array, \

  1742                                        jsize start, \

  1743                                        jsize len, \

  1744                                        ElementType *buf)) \

  1745     functionEnter(thr); \

  1746     IN_VM( \

  1747       check_primitive_array_type(thr, array, ElementTag); \

  1748     ) \

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

  1750     functionExit(thr); \

  1751 JNI_END

  1753 WRAPPER_GetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)

  1754 WRAPPER_GetScalarArrayRegion(T_BYTE,    jbyte,    Byte)

  1755 WRAPPER_GetScalarArrayRegion(T_SHORT,   jshort,   Short)

  1756 WRAPPER_GetScalarArrayRegion(T_CHAR,    jchar,    Char)

  1757 WRAPPER_GetScalarArrayRegion(T_INT,     jint,     Int)

  1758 WRAPPER_GetScalarArrayRegion(T_LONG,    jlong,    Long)

  1759 WRAPPER_GetScalarArrayRegion(T_FLOAT,   jfloat,   Float)

  1760 WRAPPER_GetScalarArrayRegion(T_DOUBLE,  jdouble,  Double)

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

  1763 JNI_ENTRY_CHECKED(void,  \

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

  1765                                        ElementType##Array array, \

  1766                                        jsize start, \

  1767                                        jsize len, \

  1768                                        const ElementType *buf)) \

  1769     functionEnter(thr); \

  1770     IN_VM( \

  1771       check_primitive_array_type(thr, array, ElementTag); \

  1772     ) \

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

  1774     functionExit(thr); \

  1775 JNI_END

  1777 WRAPPER_SetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)

  1778 WRAPPER_SetScalarArrayRegion(T_BYTE,    jbyte,    Byte)

  1779 WRAPPER_SetScalarArrayRegion(T_SHORT,   jshort,   Short)

  1780 WRAPPER_SetScalarArrayRegion(T_CHAR,    jchar,    Char)

  1781 WRAPPER_SetScalarArrayRegion(T_INT,     jint,     Int)

  1782 WRAPPER_SetScalarArrayRegion(T_LONG,    jlong,    Long)

  1783 WRAPPER_SetScalarArrayRegion(T_FLOAT,   jfloat,   Float)

  1784 WRAPPER_SetScalarArrayRegion(T_DOUBLE,  jdouble,  Double)

  1786 JNI_ENTRY_CHECKED(jint,

  1787   checked_jni_RegisterNatives(JNIEnv *env,

  1788                               jclass clazz,

  1789                               const JNINativeMethod *methods,

  1790                               jint nMethods))

  1791     functionEnter(thr);

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

  1793     functionExit(thr);

  1794     return result;

  1795 JNI_END

  1797 JNI_ENTRY_CHECKED(jint,

  1798   checked_jni_UnregisterNatives(JNIEnv *env,

  1799                                 jclass clazz))

  1800     functionEnter(thr);

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

  1802     functionExit(thr);

  1803     return result;

  1804 JNI_END

  1806 JNI_ENTRY_CHECKED(jint,

  1807   checked_jni_MonitorEnter(JNIEnv *env,

  1808                            jobject obj))

  1809     functionEnter(thr);

  1810     IN_VM(

  1811       jniCheck::validate_object(thr, obj);

  1812     )

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

  1814     functionExit(thr);

  1815     return result;

  1816 JNI_END

  1818 JNI_ENTRY_CHECKED(jint,

  1819   checked_jni_MonitorExit(JNIEnv *env,

  1820                           jobject obj))

  1821     functionEnterExceptionAllowed(thr);

  1822     IN_VM(

  1823       jniCheck::validate_object(thr, obj);

  1824     )

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

  1826     functionExit(thr);

  1827     return result;

  1828 JNI_END

  1830 JNI_ENTRY_CHECKED(jint,

  1831   checked_jni_GetJavaVM(JNIEnv *env,

  1832                         JavaVM **vm))

  1833     functionEnter(thr);

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

  1835     functionExit(thr);

  1836     return result;

  1837 JNI_END

  1839 JNI_ENTRY_CHECKED(void,

  1840   checked_jni_GetStringRegion(JNIEnv *env,

  1841                               jstring str,

  1842                               jsize start,

  1843                               jsize len,

  1844                               jchar *buf))

  1845     functionEnter(thr);

  1846     IN_VM(

  1847       checkString(thr, str);

  1848     )

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

  1850     functionExit(thr);

  1851 JNI_END

  1853 JNI_ENTRY_CHECKED(void,

  1854   checked_jni_GetStringUTFRegion(JNIEnv *env,

  1855                                  jstring str,

  1856                                  jsize start,

  1857                                  jsize len,

  1858                                  char *buf))

  1859     functionEnter(thr);

  1860     IN_VM(

  1861       checkString(thr, str);

  1862     )

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

  1864     functionExit(thr);

  1865 JNI_END

  1867 JNI_ENTRY_CHECKED(void *,

  1868   checked_jni_GetPrimitiveArrayCritical(JNIEnv *env,

  1869                                         jarray array,

  1870                                         jboolean *isCopy))

  1871     functionEnterCritical(thr);

  1872     IN_VM(

  1873       check_is_primitive_array(thr, array);

  1874     )

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

  1876     if (result != NULL) {

  1877       result = check_jni_wrap_copy_array(thr, array, result);

  1878     }

  1879     functionExit(thr);

  1880     return result;

  1881 JNI_END

  1883 JNI_ENTRY_CHECKED(void,

  1884   checked_jni_ReleasePrimitiveArrayCritical(JNIEnv *env,

  1885                                             jarray array,

  1886                                             void *carray,

  1887                                             jint mode))

  1888     functionEnterCriticalExceptionAllowed(thr);

  1889     IN_VM(

  1890       check_is_primitive_array(thr, array);

  1891     )

  1892     // Check the element array...

  1893     void* orig_result = check_wrapped_array_release(thr, "ReleasePrimitiveArrayCritical", array, carray, mode);

  1894     UNCHECKED()->ReleasePrimitiveArrayCritical(env, array, orig_result, mode);

  1895     functionExit(thr);

  1896 JNI_END

  1898 JNI_ENTRY_CHECKED(const jchar*,

  1899   checked_jni_GetStringCritical(JNIEnv *env,

  1900                                 jstring string,

  1901                                 jboolean *isCopy))

  1902     functionEnterCritical(thr);

  1903     IN_VM(

  1904       checkString(thr, string);

  1905     )

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

  1907     functionExit(thr);

  1908     return result;

  1909 JNI_END

  1911 JNI_ENTRY_CHECKED(void,

  1912   checked_jni_ReleaseStringCritical(JNIEnv *env,

  1913                                     jstring str,

  1914                                     const jchar *chars))

  1915     functionEnterCriticalExceptionAllowed(thr);

  1916     IN_VM(

  1917       checkString(thr, str);

  1918     )

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

  1920      * string parameter as a minor sanity check

  1921      */

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

  1923     functionExit(thr);

  1924 JNI_END

  1926 JNI_ENTRY_CHECKED(jweak,

  1927   checked_jni_NewWeakGlobalRef(JNIEnv *env,

  1928                                jobject obj))

  1929     functionEnter(thr);

  1930     IN_VM(

  1931       if (obj != NULL) {

  1932         jniCheck::validate_handle(thr, obj);

  1933       }

  1934     )

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

  1936     functionExit(thr);

  1937     return result;

  1938 JNI_END

  1940 JNI_ENTRY_CHECKED(void,

  1941   checked_jni_DeleteWeakGlobalRef(JNIEnv *env,

  1942                                   jweak ref))

  1943     functionEnterExceptionAllowed(thr);

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

  1945     functionExit(thr);

  1946 JNI_END

  1948 JNI_ENTRY_CHECKED(jboolean,

  1949   checked_jni_ExceptionCheck(JNIEnv *env))

  1950     thr->clear_pending_jni_exception_check();

  1951     functionEnterExceptionAllowed(thr);

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

  1953     functionExit(thr);

  1954     return result;

  1955 JNI_END

  1957 JNI_ENTRY_CHECKED(jobject,

  1958   checked_jni_NewDirectByteBuffer(JNIEnv *env,

  1959                                   void *address,

  1960                                   jlong capacity))

  1961     functionEnter(thr);

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

  1963     functionExit(thr);

  1964     return result;

  1965 JNI_END

  1967 JNI_ENTRY_CHECKED(void *,

  1968   checked_jni_GetDirectBufferAddress(JNIEnv *env,

  1969                                      jobject buf))

  1970     functionEnter(thr);

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

  1972     functionExit(thr);

  1973     return result;

  1974 JNI_END

  1976 JNI_ENTRY_CHECKED(jlong,

  1977   checked_jni_GetDirectBufferCapacity(JNIEnv *env,

  1978                                       jobject buf))

  1979     functionEnter(thr);

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

  1981     functionExit(thr);

  1982     return result;

  1983 JNI_END

  1985 JNI_ENTRY_CHECKED(jobjectRefType,

  1986   checked_jni_GetObjectRefType(JNIEnv *env,

  1987                                jobject obj))

  1988     functionEnter(thr);

  1989     /* validate the object being passed */

  1990     IN_VM(

  1991       jniCheck::validate_object(thr, obj);

  1992     )

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

  1994     functionExit(thr);

  1995     return result;

  1996 JNI_END

  1999 JNI_ENTRY_CHECKED(jint,

  2000   checked_jni_GetVersion(JNIEnv *env))

  2001     functionEnter(thr);

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

  2003     functionExit(thr);

  2004     return result;

  2005 JNI_END

  2009 /*

  2010  * Structure containing all checked jni functions

  2011  */

  2012 struct JNINativeInterface_  checked_jni_NativeInterface = {

  2013     NULL,

  2014     NULL,

  2015     NULL,

  2017     NULL,

  2019     checked_jni_GetVersion,

  2021     checked_jni_DefineClass,

  2022     checked_jni_FindClass,

  2024     checked_jni_FromReflectedMethod,

  2025     checked_jni_FromReflectedField,

  2027     checked_jni_ToReflectedMethod,

  2029     checked_jni_GetSuperclass,

  2030     checked_jni_IsAssignableFrom,

  2032     checked_jni_ToReflectedField,

  2034     checked_jni_Throw,

  2035     checked_jni_ThrowNew,

  2036     checked_jni_ExceptionOccurred,

  2037     checked_jni_ExceptionDescribe,

  2038     checked_jni_ExceptionClear,

  2039     checked_jni_FatalError,

  2041     checked_jni_PushLocalFrame,

  2042     checked_jni_PopLocalFrame,

  2044     checked_jni_NewGlobalRef,

  2045     checked_jni_DeleteGlobalRef,

  2046     checked_jni_DeleteLocalRef,

  2047     checked_jni_IsSameObject,

  2049     checked_jni_NewLocalRef,

  2050     checked_jni_EnsureLocalCapacity,

  2052     checked_jni_AllocObject,

  2053     checked_jni_NewObject,

  2054     checked_jni_NewObjectV,

  2055     checked_jni_NewObjectA,

  2057     checked_jni_GetObjectClass,

  2058     checked_jni_IsInstanceOf,

  2060     checked_jni_GetMethodID,

  2062     checked_jni_CallObjectMethod,

  2063     checked_jni_CallObjectMethodV,

  2064     checked_jni_CallObjectMethodA,

  2065     checked_jni_CallBooleanMethod,

  2066     checked_jni_CallBooleanMethodV,

  2067     checked_jni_CallBooleanMethodA,

  2068     checked_jni_CallByteMethod,

  2069     checked_jni_CallByteMethodV,

  2070     checked_jni_CallByteMethodA,

  2071     checked_jni_CallCharMethod,

  2072     checked_jni_CallCharMethodV,

  2073     checked_jni_CallCharMethodA,

  2074     checked_jni_CallShortMethod,

  2075     checked_jni_CallShortMethodV,

  2076     checked_jni_CallShortMethodA,

  2077     checked_jni_CallIntMethod,

  2078     checked_jni_CallIntMethodV,

  2079     checked_jni_CallIntMethodA,

  2080     checked_jni_CallLongMethod,

  2081     checked_jni_CallLongMethodV,

  2082     checked_jni_CallLongMethodA,

  2083     checked_jni_CallFloatMethod,

  2084     checked_jni_CallFloatMethodV,

  2085     checked_jni_CallFloatMethodA,

  2086     checked_jni_CallDoubleMethod,

  2087     checked_jni_CallDoubleMethodV,

  2088     checked_jni_CallDoubleMethodA,

  2089     checked_jni_CallVoidMethod,

  2090     checked_jni_CallVoidMethodV,

  2091     checked_jni_CallVoidMethodA,

  2093     checked_jni_CallNonvirtualObjectMethod,

  2094     checked_jni_CallNonvirtualObjectMethodV,

  2095     checked_jni_CallNonvirtualObjectMethodA,

  2096     checked_jni_CallNonvirtualBooleanMethod,

  2097     checked_jni_CallNonvirtualBooleanMethodV,

  2098     checked_jni_CallNonvirtualBooleanMethodA,

  2099     checked_jni_CallNonvirtualByteMethod,

  2100     checked_jni_CallNonvirtualByteMethodV,

  2101     checked_jni_CallNonvirtualByteMethodA,

  2102     checked_jni_CallNonvirtualCharMethod,

  2103     checked_jni_CallNonvirtualCharMethodV,

  2104     checked_jni_CallNonvirtualCharMethodA,

  2105     checked_jni_CallNonvirtualShortMethod,

  2106     checked_jni_CallNonvirtualShortMethodV,

  2107     checked_jni_CallNonvirtualShortMethodA,

  2108     checked_jni_CallNonvirtualIntMethod,

  2109     checked_jni_CallNonvirtualIntMethodV,

  2110     checked_jni_CallNonvirtualIntMethodA,

  2111     checked_jni_CallNonvirtualLongMethod,

  2112     checked_jni_CallNonvirtualLongMethodV,

  2113     checked_jni_CallNonvirtualLongMethodA,

  2114     checked_jni_CallNonvirtualFloatMethod,

  2115     checked_jni_CallNonvirtualFloatMethodV,

  2116     checked_jni_CallNonvirtualFloatMethodA,

  2117     checked_jni_CallNonvirtualDoubleMethod,

  2118     checked_jni_CallNonvirtualDoubleMethodV,

  2119     checked_jni_CallNonvirtualDoubleMethodA,

  2120     checked_jni_CallNonvirtualVoidMethod,

  2121     checked_jni_CallNonvirtualVoidMethodV,

  2122     checked_jni_CallNonvirtualVoidMethodA,

  2124     checked_jni_GetFieldID,

  2126     checked_jni_GetObjectField,

  2127     checked_jni_GetBooleanField,

  2128     checked_jni_GetByteField,

  2129     checked_jni_GetCharField,

  2130     checked_jni_GetShortField,

  2131     checked_jni_GetIntField,

  2132     checked_jni_GetLongField,

  2133     checked_jni_GetFloatField,

  2134     checked_jni_GetDoubleField,

  2136     checked_jni_SetObjectField,

  2137     checked_jni_SetBooleanField,

  2138     checked_jni_SetByteField,

  2139     checked_jni_SetCharField,

  2140     checked_jni_SetShortField,

  2141     checked_jni_SetIntField,

  2142     checked_jni_SetLongField,

  2143     checked_jni_SetFloatField,

  2144     checked_jni_SetDoubleField,

  2146     checked_jni_GetStaticMethodID,

  2148     checked_jni_CallStaticObjectMethod,

  2149     checked_jni_CallStaticObjectMethodV,

  2150     checked_jni_CallStaticObjectMethodA,

  2151     checked_jni_CallStaticBooleanMethod,

  2152     checked_jni_CallStaticBooleanMethodV,

  2153     checked_jni_CallStaticBooleanMethodA,

  2154     checked_jni_CallStaticByteMethod,

  2155     checked_jni_CallStaticByteMethodV,

  2156     checked_jni_CallStaticByteMethodA,

  2157     checked_jni_CallStaticCharMethod,

  2158     checked_jni_CallStaticCharMethodV,

  2159     checked_jni_CallStaticCharMethodA,

  2160     checked_jni_CallStaticShortMethod,

  2161     checked_jni_CallStaticShortMethodV,

  2162     checked_jni_CallStaticShortMethodA,

  2163     checked_jni_CallStaticIntMethod,

  2164     checked_jni_CallStaticIntMethodV,

  2165     checked_jni_CallStaticIntMethodA,

  2166     checked_jni_CallStaticLongMethod,

  2167     checked_jni_CallStaticLongMethodV,

  2168     checked_jni_CallStaticLongMethodA,

  2169     checked_jni_CallStaticFloatMethod,

  2170     checked_jni_CallStaticFloatMethodV,

  2171     checked_jni_CallStaticFloatMethodA,

  2172     checked_jni_CallStaticDoubleMethod,

  2173     checked_jni_CallStaticDoubleMethodV,

  2174     checked_jni_CallStaticDoubleMethodA,

  2175     checked_jni_CallStaticVoidMethod,

  2176     checked_jni_CallStaticVoidMethodV,

  2177     checked_jni_CallStaticVoidMethodA,

  2179     checked_jni_GetStaticFieldID,

  2181     checked_jni_GetStaticObjectField,

  2182     checked_jni_GetStaticBooleanField,

  2183     checked_jni_GetStaticByteField,

  2184     checked_jni_GetStaticCharField,

  2185     checked_jni_GetStaticShortField,

  2186     checked_jni_GetStaticIntField,

  2187     checked_jni_GetStaticLongField,

  2188     checked_jni_GetStaticFloatField,

  2189     checked_jni_GetStaticDoubleField,

  2191     checked_jni_SetStaticObjectField,

  2192     checked_jni_SetStaticBooleanField,

  2193     checked_jni_SetStaticByteField,

  2194     checked_jni_SetStaticCharField,

  2195     checked_jni_SetStaticShortField,

  2196     checked_jni_SetStaticIntField,

  2197     checked_jni_SetStaticLongField,

  2198     checked_jni_SetStaticFloatField,

  2199     checked_jni_SetStaticDoubleField,

  2201     checked_jni_NewString,

  2202     checked_jni_GetStringLength,

  2203     checked_jni_GetStringChars,

  2204     checked_jni_ReleaseStringChars,

  2206     checked_jni_NewStringUTF,

  2207     checked_jni_GetStringUTFLength,

  2208     checked_jni_GetStringUTFChars,

  2209     checked_jni_ReleaseStringUTFChars,

  2211     checked_jni_GetArrayLength,

  2213     checked_jni_NewObjectArray,

  2214     checked_jni_GetObjectArrayElement,

  2215     checked_jni_SetObjectArrayElement,

  2217     checked_jni_NewBooleanArray,

  2218     checked_jni_NewByteArray,

  2219     checked_jni_NewCharArray,

  2220     checked_jni_NewShortArray,

  2221     checked_jni_NewIntArray,

  2222     checked_jni_NewLongArray,

  2223     checked_jni_NewFloatArray,

  2224     checked_jni_NewDoubleArray,

  2226     checked_jni_GetBooleanArrayElements,

  2227     checked_jni_GetByteArrayElements,

  2228     checked_jni_GetCharArrayElements,

  2229     checked_jni_GetShortArrayElements,

  2230     checked_jni_GetIntArrayElements,

  2231     checked_jni_GetLongArrayElements,

  2232     checked_jni_GetFloatArrayElements,

  2233     checked_jni_GetDoubleArrayElements,

  2235     checked_jni_ReleaseBooleanArrayElements,

  2236     checked_jni_ReleaseByteArrayElements,

  2237     checked_jni_ReleaseCharArrayElements,

  2238     checked_jni_ReleaseShortArrayElements,

  2239     checked_jni_ReleaseIntArrayElements,

  2240     checked_jni_ReleaseLongArrayElements,

  2241     checked_jni_ReleaseFloatArrayElements,

  2242     checked_jni_ReleaseDoubleArrayElements,

  2244     checked_jni_GetBooleanArrayRegion,

  2245     checked_jni_GetByteArrayRegion,

  2246     checked_jni_GetCharArrayRegion,

  2247     checked_jni_GetShortArrayRegion,

  2248     checked_jni_GetIntArrayRegion,

  2249     checked_jni_GetLongArrayRegion,

  2250     checked_jni_GetFloatArrayRegion,

  2251     checked_jni_GetDoubleArrayRegion,

  2253     checked_jni_SetBooleanArrayRegion,

  2254     checked_jni_SetByteArrayRegion,

  2255     checked_jni_SetCharArrayRegion,

  2256     checked_jni_SetShortArrayRegion,

  2257     checked_jni_SetIntArrayRegion,

  2258     checked_jni_SetLongArrayRegion,

  2259     checked_jni_SetFloatArrayRegion,

  2260     checked_jni_SetDoubleArrayRegion,

  2262     checked_jni_RegisterNatives,

  2263     checked_jni_UnregisterNatives,

  2265     checked_jni_MonitorEnter,

  2266     checked_jni_MonitorExit,

  2268     checked_jni_GetJavaVM,

  2270     checked_jni_GetStringRegion,

  2271     checked_jni_GetStringUTFRegion,

  2273     checked_jni_GetPrimitiveArrayCritical,

  2274     checked_jni_ReleasePrimitiveArrayCritical,

  2276     checked_jni_GetStringCritical,

  2277     checked_jni_ReleaseStringCritical,

  2279     checked_jni_NewWeakGlobalRef,

  2280     checked_jni_DeleteWeakGlobalRef,

  2282     checked_jni_ExceptionCheck,

  2284     checked_jni_NewDirectByteBuffer,

  2285     checked_jni_GetDirectBufferAddress,

  2286     checked_jni_GetDirectBufferCapacity,

  2288     // New 1.6 Features

  2290     checked_jni_GetObjectRefType

  2291 };

  2294 // Returns the function structure

  2295 struct JNINativeInterface_* jni_functions_check() {

  2297   unchecked_jni_NativeInterface = jni_functions_nocheck();

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

  2300   // an addition to the JNINativeInterface_ structure without initializing

  2301   // it in the checked table.

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

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

  2304   assert(*lastPtr != 0,

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

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

  2308   if (PrintJNIResolving) {

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

  2310                   "validate JNI usage");

  2311   }

  2313   return &checked_jni_NativeInterface;

  2314 }

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

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

src/share/vm/prims/jniCheck.cpp