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

6671508: JNI GetPrimitiveArrayCritical should not be callable on object arrays
Summary: Checked JNI now reports error for Get/ReleasePrimitiveArrayCritical on object arrays
Reviewed-by: dholmes, acorn
Contributed-by: david.simms@oracle.com

     1 /*

     2  * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.

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

     4  *

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

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

     7  * published by the Free Software Foundation.

     8  *

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

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

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

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

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

    21  * questions.

    22  *

    23  */

    25 #include "precompiled.hpp"

    26 #include "classfile/systemDictionary.hpp"

    27 #include "classfile/vmSymbols.hpp"

    28 #include "oops/instanceKlass.hpp"

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

    30 #include "oops/symbol.hpp"

    31 #include "prims/jni.h"

    32 #include "prims/jniCheck.hpp"

    33 #include "prims/jvm_misc.hpp"

    34 #include "runtime/fieldDescriptor.hpp"

    35 #include "runtime/handles.hpp"

    36 #include "runtime/interfaceSupport.hpp"

    37 #include "runtime/jfieldIDWorkaround.hpp"

    38 #include "runtime/thread.hpp"

    39 #ifdef TARGET_ARCH_x86

    40 # include "jniTypes_x86.hpp"

    41 #endif

    42 #ifdef TARGET_ARCH_sparc

    43 # include "jniTypes_sparc.hpp"

    44 #endif

    45 #ifdef TARGET_ARCH_zero

    46 # include "jniTypes_zero.hpp"

    47 #endif

    48 #ifdef TARGET_ARCH_arm

    49 # include "jniTypes_arm.hpp"

    50 #endif

    51 #ifdef TARGET_ARCH_ppc

    52 # include "jniTypes_ppc.hpp"

    53 #endif

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

    57 // not in native code.

    59 #define ASSERT_OOPS_ALLOWED                                          \

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

    61            "jniCheck examining oops in bad state.")

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

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

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

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

    68 // NATIVE state.

    70 #define IN_VM(source_code)   {                                         \

    71     {                                                                  \

    72       ThreadInVMfromNative __tiv(thr);                                 \

    73       source_code                                                      \

    74     }                                                                  \

    75   }

    78 /*

    79  * DECLARATIONS

    80  */

    82 static struct JNINativeInterface_ * unchecked_jni_NativeInterface;

    85 /*

    86  * MACRO DEFINITIONS

    87  */

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

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

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

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

    94 // assertions in the wrapper routines might fire

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

    98 #define JNI_ENTRY_CHECKED(result_type, header)                           \

    99 extern "C" {                                                             \

   100   result_type JNICALL header {                                           \

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

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

   103       tty->print_cr(fatal_using_jnienv_in_nonjava);                      \

   104       os::abort(true);                                                   \

   105     }                                                                    \

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

   107     if (env != xenv) {                                                   \

   108       NativeReportJNIFatalError(thr, warn_wrong_jnienv);                 \

   109     }                                                                    \

   110     VM_ENTRY_BASE(result_type, header, thr)

   113 #define UNCHECKED() (unchecked_jni_NativeInterface)

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

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

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

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

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

   120   "Get/ReleasePrimitiveArrayCritical or Get/ReleaseStringCritical";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   144 // When in VM state:

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

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

   147   thr->print_stack();

   148 }

   150 // When in NATIVE state:

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

   152   IN_VM(

   153     ReportJNIFatalError(thr, msg);

   154   )

   155 }

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

   158   IN_VM(

   159     ReportJNIWarning(thr, msg);

   160   )

   161 }

   166 /*

   167  * SUPPORT FUNCTIONS

   168  */

   170 static inline void

   171 functionEnterCritical(JavaThread* thr)

   172 {

   173   if (thr->has_pending_exception()) {

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

   175   }

   176 }

   178 static inline void

   179 functionEnterCriticalExceptionAllowed(JavaThread* thr)

   180 {

   181 }

   183 static inline void

   184 functionEnter(JavaThread* thr)

   185 {

   186   if (thr->in_critical()) {

   187     tty->print_cr(warn_other_function_in_critical);

   188   }

   189   if (thr->has_pending_exception()) {

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

   191   }

   192 }

   194 static inline void

   195 functionEnterExceptionAllowed(JavaThread* thr)

   196 {

   197   if (thr->in_critical()) {

   198     tty->print_cr(warn_other_function_in_critical);

   199   }

   200 }

   202 static inline void

   203 functionExit(JNIEnv *env)

   204 {

   205   /* nothing to do at this time */

   206 }

   208 static inline void

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

   210 {

   211   fieldDescriptor fd;

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

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

   215     ReportJNIFatalError(thr, fatal_should_be_static);

   217   /* validate the class being passed */

   218   ASSERT_OOPS_ALLOWED;

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

   221   /* check for proper subclass hierarchy */

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

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

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

   225     ReportJNIFatalError(thr, fatal_wrong_static_field);

   227   /* check for proper field type */

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

   229     ReportJNIFatalError(thr, fatal_static_field_not_found);

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

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

   232     ReportJNIFatalError(thr, fatal_static_field_mismatch);

   233   }

   234 }

   236 static inline void

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

   238 {

   239   fieldDescriptor fd;

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

   242   if (jfieldIDWorkaround::is_static_jfieldID(fid))

   243     ReportJNIFatalError(thr, fatal_should_be_nonstatic);

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

   246   ASSERT_OOPS_ALLOWED;

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

   248   if (!oopObj) {

   249     ReportJNIFatalError(thr, fatal_null_object);

   250   }

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

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

   254     ReportJNIFatalError(thr, fatal_wrong_field);

   255   }

   257   /* make sure the field exists */

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

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

   260     ReportJNIFatalError(thr, fatal_wrong_field);

   262   /* check for proper field type */

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

   264                                                               false, &fd))

   265     ReportJNIFatalError(thr, fatal_instance_field_not_found);

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

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

   269     ReportJNIFatalError(thr, fatal_instance_field_mismatch);

   270   }

   271 }

   273 static inline void

   274 checkString(JavaThread* thr, jstring js)

   275 {

   276   ASSERT_OOPS_ALLOWED;

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

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

   279     ReportJNIFatalError(thr, fatal_non_string);

   280 }

   282 static inline arrayOop

   283 check_is_array(JavaThread* thr, jarray jArray)

   284 {

   285   ASSERT_OOPS_ALLOWED;

   286   arrayOop aOop;

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

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

   290     ReportJNIFatalError(thr, fatal_non_array);

   291   }

   292   return aOop;

   293 }

   295 static inline arrayOop

   296 check_is_primitive_array(JavaThread* thr, jarray jArray) {

   297   arrayOop aOop = check_is_array(thr, jArray);

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

   300      ReportJNIFatalError(thr, fatal_prim_type_array_expected);

   301   }

   302   return aOop;

   303 }

   305 static inline void

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

   307 {

   308   BasicType array_type;

   309   arrayOop aOop;

   311   aOop = check_is_primitive_array(thr, jArray);

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

   313   if (array_type != elementType) {

   314     ReportJNIFatalError(thr, fatal_element_type_mismatch);

   315   }

   316 }

   318 static inline void

   319 check_is_obj_array(JavaThread* thr, jarray jArray) {

   320   BasicType array_type;

   321   arrayOop aOop;

   323   aOop = check_is_array(thr, jArray);

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

   325   if (array_type != T_OBJECT) {

   326     ReportJNIFatalError(thr, fatal_object_array_expected);

   327   }

   328 }

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

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

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

   333       JNIHandles::is_global_handle(obj) ||

   334       JNIHandles::is_weak_global_handle(obj)) {

   335     ASSERT_OOPS_ALLOWED;

   336     return JNIHandles::resolve_external_guard(obj);

   337   }

   338   ReportJNIFatalError(thr, fatal_bad_ref_to_jni);

   339   return NULL;

   340 }

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

   344   ASSERT_OOPS_ALLOWED;

   345   // do the fast jmethodID check first

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

   347   if (moop == NULL) {

   348     ReportJNIFatalError(thr, fatal_wrong_class_or_method);

   349   }

   350   // jmethodIDs are supposed to be weak handles in the class loader data,

   351   // but that can be expensive so check it last

   352   else if (!Method::is_method_id(method_id)) {

   353     ReportJNIFatalError(thr, fatal_non_weak_method);

   354   }

   355   return moop;

   356 }

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

   360     if (!obj)

   361         return NULL;

   362     ASSERT_OOPS_ALLOWED;

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

   364     if (!oopObj) {

   365       ReportJNIFatalError(thr, fatal_bad_ref_to_jni);

   366     }

   367     return oopObj;

   368 }

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

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

   372 // array descriptors.

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

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

   376   size_t len = strlen(name);

   378   if (len >= 2 &&

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

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

   381     char msg[JVM_MAXPATHLEN];

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

   383     ReportJNIWarning(thr, msg);

   384   }

   385 }

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

   388   ASSERT_OOPS_ALLOWED;

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

   390   if (!mirror) {

   391     ReportJNIFatalError(thr, fatal_received_null_class);

   392   }

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

   395     ReportJNIFatalError(thr, fatal_class_not_a_class);

   396   }

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

   399   // Make allowances for primitive classes ...

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

   401     ReportJNIFatalError(thr, fatal_class_not_a_class);

   402   }

   403   return k;

   404 }

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

   407   ASSERT_OOPS_ALLOWED;

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

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

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

   412     ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);

   413   }

   414 }

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

   417   /* validate the object being passed */

   418   ASSERT_OOPS_ALLOWED;

   419   jniCheck::validate_jmethod_id(thr, method_id);

   420   jniCheck::validate_object(thr, obj);

   421 }

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

   424   /* validate the class being passed */

   425   ASSERT_OOPS_ALLOWED;

   426   jniCheck::validate_jmethod_id(thr, method_id);

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

   428 }

   431 /*

   432  * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE

   433  */

   435 JNI_ENTRY_CHECKED(jclass,

   436   checked_jni_DefineClass(JNIEnv *env,

   437                           const char *name,

   438                           jobject loader,

   439                           const jbyte *buf,

   440                           jsize len))

   441     functionEnter(thr);

   442     IN_VM(

   443       jniCheck::validate_object(thr, loader);

   444     )

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

   446     functionExit(env);

   447     return result;

   448 JNI_END

   450 JNI_ENTRY_CHECKED(jclass,

   451   checked_jni_FindClass(JNIEnv *env,

   452                         const char *name))

   453     functionEnter(thr);

   454     IN_VM(

   455       jniCheck::validate_class_descriptor(thr, name);

   456     )

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

   458     functionExit(env);

   459     return result;

   460 JNI_END

   462 JNI_ENTRY_CHECKED(jmethodID,

   463   checked_jni_FromReflectedMethod(JNIEnv *env,

   464                                   jobject method))

   465     functionEnter(thr);

   466     IN_VM(

   467       jniCheck::validate_object(thr, method);

   468     )

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

   470     functionExit(env);

   471     return result;

   472 JNI_END

   474 JNI_ENTRY_CHECKED(jfieldID,

   475   checked_jni_FromReflectedField(JNIEnv *env,

   476                                  jobject field))

   477     functionEnter(thr);

   478     IN_VM(

   479       jniCheck::validate_object(thr, field);

   480     )

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

   482     functionExit(env);

   483     return result;

   484 JNI_END

   486 JNI_ENTRY_CHECKED(jobject,

   487   checked_jni_ToReflectedMethod(JNIEnv *env,

   488                                 jclass cls,

   489                                 jmethodID methodID,

   490                                 jboolean isStatic))

   491     functionEnter(thr);

   492     IN_VM(

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

   494       jniCheck::validate_jmethod_id(thr, methodID);

   495     )

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

   497                                                     isStatic);

   498     functionExit(env);

   499     return result;

   500 JNI_END

   502 JNI_ENTRY_CHECKED(jclass,

   503   checked_jni_GetSuperclass(JNIEnv *env,

   504                             jclass sub))

   505     functionEnter(thr);

   506     IN_VM(

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

   508     )

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

   510     functionExit(env);

   511     return result;

   512 JNI_END

   514 JNI_ENTRY_CHECKED(jboolean,

   515   checked_jni_IsAssignableFrom(JNIEnv *env,

   516                                jclass sub,

   517                                jclass sup))

   518     functionEnter(thr);

   519     IN_VM(

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

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

   522     )

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

   524     functionExit(env);

   525     return result;

   526 JNI_END

   528 JNI_ENTRY_CHECKED(jobject,

   529   checked_jni_ToReflectedField(JNIEnv *env,

   530                                jclass cls,

   531                                jfieldID fieldID,

   532                                jboolean isStatic))

   533     functionEnter(thr);

   534     IN_VM(

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

   536     )

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

   538                                                    isStatic);

   539     functionExit(env);

   540     return result;

   541 JNI_END

   543 JNI_ENTRY_CHECKED(jint,

   544   checked_jni_Throw(JNIEnv *env,

   545                     jthrowable obj))

   546     functionEnter(thr);

   547     IN_VM(

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

   549       if (oopObj == NULL) {

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

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

   552       } else {

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

   554       }

   555     )

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

   557     functionExit(env);

   558     return result;

   559 JNI_END

   561 JNI_ENTRY_CHECKED(jint,

   562   checked_jni_ThrowNew(JNIEnv *env,

   563                        jclass clazz,

   564                        const char *msg))

   565     functionEnter(thr);

   566     IN_VM(

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

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

   569       jniCheck::validate_throwable_klass(thr, k);

   570     )

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

   572     functionExit(env);

   573     return result;

   574 JNI_END

   576 JNI_ENTRY_CHECKED(jthrowable,

   577   checked_jni_ExceptionOccurred(JNIEnv *env))

   578     functionEnterExceptionAllowed(thr);

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

   580     functionExit(env);

   581     return result;

   582 JNI_END

   584 JNI_ENTRY_CHECKED(void,

   585   checked_jni_ExceptionDescribe(JNIEnv *env))

   586     functionEnterExceptionAllowed(thr);

   587     UNCHECKED()->ExceptionDescribe(env);

   588     functionExit(env);

   589 JNI_END

   591 JNI_ENTRY_CHECKED(void,

   592   checked_jni_ExceptionClear(JNIEnv *env))

   593     functionEnterExceptionAllowed(thr);

   594     UNCHECKED()->ExceptionClear(env);

   595     functionExit(env);

   596 JNI_END

   598 JNI_ENTRY_CHECKED(void,

   599   checked_jni_FatalError(JNIEnv *env,

   600                          const char *msg))

   601     functionEnter(thr);

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

   603     functionExit(env);

   604 JNI_END

   606 JNI_ENTRY_CHECKED(jint,

   607   checked_jni_PushLocalFrame(JNIEnv *env,

   608                              jint capacity))

   609     functionEnterExceptionAllowed(thr);

   610     if (capacity < 0)

   611       NativeReportJNIFatalError(thr, "negative capacity");

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

   613     functionExit(env);

   614     return result;

   615 JNI_END

   617 JNI_ENTRY_CHECKED(jobject,

   618   checked_jni_PopLocalFrame(JNIEnv *env,

   619                             jobject result))

   620     functionEnterExceptionAllowed(thr);

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

   622     functionExit(env);

   623     return res;

   624 JNI_END

   626 JNI_ENTRY_CHECKED(jobject,

   627   checked_jni_NewGlobalRef(JNIEnv *env,

   628                            jobject lobj))

   629     functionEnter(thr);

   630     IN_VM(

   631       if (lobj != NULL) {

   632         jniCheck::validate_handle(thr, lobj);

   633       }

   634     )

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

   636     functionExit(env);

   637     return result;

   638 JNI_END

   640 JNI_ENTRY_CHECKED(void,

   641   checked_jni_DeleteGlobalRef(JNIEnv *env,

   642                               jobject gref))

   643     functionEnterExceptionAllowed(thr);

   644     IN_VM(

   645       jniCheck::validate_object(thr, gref);

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

   647         ReportJNIFatalError(thr,

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

   649       }

   650     )

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

   652     functionExit(env);

   653 JNI_END

   655 JNI_ENTRY_CHECKED(void,

   656   checked_jni_DeleteLocalRef(JNIEnv *env,

   657                              jobject obj))

   658     functionEnterExceptionAllowed(thr);

   659     IN_VM(

   660       jniCheck::validate_object(thr, obj);

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

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

   663         ReportJNIFatalError(thr,

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

   665     )

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

   667     functionExit(env);

   668 JNI_END

   670 JNI_ENTRY_CHECKED(jboolean,

   671   checked_jni_IsSameObject(JNIEnv *env,

   672                            jobject obj1,

   673                            jobject obj2))

   674     functionEnterExceptionAllowed(thr);

   675     IN_VM(

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

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

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

   679        */

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

   681         jniCheck::validate_object(thr, obj1);

   682       }

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

   684         jniCheck::validate_object(thr, obj2);

   685       }

   686     )

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

   688     functionExit(env);

   689     return result;

   690 JNI_END

   692 JNI_ENTRY_CHECKED(jobject,

   693   checked_jni_NewLocalRef(JNIEnv *env,

   694                           jobject ref))

   695     functionEnter(thr);

   696     IN_VM(

   697       if (ref != NULL) {

   698         jniCheck::validate_handle(thr, ref);

   699       }

   700     )

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

   702     functionExit(env);

   703     return result;

   704 JNI_END

   706 JNI_ENTRY_CHECKED(jint,

   707   checked_jni_EnsureLocalCapacity(JNIEnv *env,

   708                                   jint capacity))

   709     functionEnter(thr);

   710     if (capacity < 0) {

   711       NativeReportJNIFatalError(thr, "negative capacity");

   712     }

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

   714     functionExit(env);

   715     return result;

   716 JNI_END

   718 JNI_ENTRY_CHECKED(jobject,

   719   checked_jni_AllocObject(JNIEnv *env,

   720                           jclass clazz))

   721     functionEnter(thr);

   722     IN_VM(

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

   724     )

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

   726     functionExit(env);

   727     return result;

   728 JNI_END

   730 JNI_ENTRY_CHECKED(jobject,

   731   checked_jni_NewObject(JNIEnv *env,

   732                         jclass clazz,

   733                         jmethodID methodID,

   734                         ...))

   735     functionEnter(thr);

   736     va_list args;

   737     IN_VM(

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

   739       jniCheck::validate_jmethod_id(thr, methodID);

   740     )

   741     va_start(args, methodID);

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

   743     va_end(args);

   744     functionExit(env);

   745     return result;

   746 JNI_END

   748 JNI_ENTRY_CHECKED(jobject,

   749   checked_jni_NewObjectV(JNIEnv *env,

   750                          jclass clazz,

   751                          jmethodID methodID,

   752                          va_list args))

   753     functionEnter(thr);

   754     IN_VM(

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

   756       jniCheck::validate_jmethod_id(thr, methodID);

   757     )

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

   759     functionExit(env);

   760     return result;

   761 JNI_END

   763 JNI_ENTRY_CHECKED(jobject,

   764   checked_jni_NewObjectA(JNIEnv *env,

   765                          jclass clazz,

   766                          jmethodID methodID,

   767                          const jvalue *args))

   768     functionEnter(thr);

   769     IN_VM(

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

   771       jniCheck::validate_jmethod_id(thr, methodID);

   772     )

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

   774     functionExit(env);

   775     return result;

   776 JNI_END

   778 JNI_ENTRY_CHECKED(jclass,

   779   checked_jni_GetObjectClass(JNIEnv *env,

   780                              jobject obj))

   781     functionEnter(thr);

   782     IN_VM(

   783       jniCheck::validate_object(thr, obj);

   784     )

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

   786     functionExit(env);

   787     return result;

   788 JNI_END

   790 JNI_ENTRY_CHECKED(jboolean,

   791   checked_jni_IsInstanceOf(JNIEnv *env,

   792                            jobject obj,

   793                            jclass clazz))

   794     functionEnter(thr);

   795     IN_VM(

   796       jniCheck::validate_object(thr, obj);

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

   798     )

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

   800     functionExit(env);

   801     return result;

   802 JNI_END

   804 JNI_ENTRY_CHECKED(jmethodID,

   805   checked_jni_GetMethodID(JNIEnv *env,

   806                           jclass clazz,

   807                           const char *name,

   808                           const char *sig))

   809     functionEnter(thr);

   810     IN_VM(

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

   812     )

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

   814     functionExit(env);

   815     return result;

   816 JNI_END

   818 #define WRAPPER_CallMethod(ResultType, Result) \

   819 JNI_ENTRY_CHECKED(ResultType,  \

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

   821                                    jobject obj, \

   822                                    jmethodID methodID, \

   823                                    ...)) \

   824     functionEnter(thr); \

   825     va_list args; \

   826     IN_VM( \

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

   828     ) \

   829     va_start(args,methodID); \

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

   831                                                           args); \

   832     va_end(args); \

   833     functionExit(env); \

   834     return result; \

   835 JNI_END \

   836 \

   837 JNI_ENTRY_CHECKED(ResultType,  \

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

   839                                     jobject obj, \

   840                                     jmethodID methodID, \

   841                                     va_list args)) \

   842     functionEnter(thr); \

   843     IN_VM(\

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

   845     ) \

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

   847                                                            args); \

   848     functionExit(env); \

   849     return result; \

   850 JNI_END \

   851 \

   852 JNI_ENTRY_CHECKED(ResultType,  \

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

   854                                     jobject obj, \

   855                                     jmethodID methodID, \

   856                                     const jvalue * args)) \

   857     functionEnter(thr); \

   858     IN_VM( \

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

   860     ) \

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

   862                                                            args); \

   863     functionExit(env); \

   864     return result; \

   865 JNI_END

   867 WRAPPER_CallMethod(jobject,Object)

   868 WRAPPER_CallMethod(jboolean,Boolean)

   869 WRAPPER_CallMethod(jbyte,Byte)

   870 WRAPPER_CallMethod(jshort,Short)

   871 WRAPPER_CallMethod(jchar,Char)

   872 WRAPPER_CallMethod(jint,Int)

   873 WRAPPER_CallMethod(jlong,Long)

   874 WRAPPER_CallMethod(jfloat,Float)

   875 WRAPPER_CallMethod(jdouble,Double)

   877 JNI_ENTRY_CHECKED(void,

   878   checked_jni_CallVoidMethod(JNIEnv *env, \

   879                              jobject obj, \

   880                              jmethodID methodID, \

   881                              ...))

   882     functionEnter(thr);

   883     va_list args;

   884     IN_VM(

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

   886     )

   887     va_start(args,methodID);

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

   889     va_end(args);

   890     functionExit(env);

   891 JNI_END

   893 JNI_ENTRY_CHECKED(void,

   894   checked_jni_CallVoidMethodV(JNIEnv *env,

   895                               jobject obj,

   896                               jmethodID methodID,

   897                               va_list args))

   898     functionEnter(thr);

   899     IN_VM(

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

   901     )

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

   903     functionExit(env);

   904 JNI_END

   906 JNI_ENTRY_CHECKED(void,

   907   checked_jni_CallVoidMethodA(JNIEnv *env,

   908                               jobject obj,

   909                               jmethodID methodID,

   910                               const jvalue * args))

   911     functionEnter(thr);

   912     IN_VM(

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

   914     )

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

   916     functionExit(env);

   917 JNI_END

   919 #define WRAPPER_CallNonvirtualMethod(ResultType, Result) \

   920 JNI_ENTRY_CHECKED(ResultType,  \

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

   922                                              jobject obj, \

   923                                              jclass clazz, \

   924                                              jmethodID methodID, \

   925                                              ...)) \

   926     functionEnter(thr); \

   927     va_list args; \

   928     IN_VM( \

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

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

   931     ) \

   932     va_start(args,methodID); \

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

   934                                                                      obj, \

   935                                                                      clazz, \

   936                                                                      methodID,\

   937                                                                      args); \

   938     va_end(args); \

   939     functionExit(env); \

   940     return result; \

   941 JNI_END \

   942 \

   943 JNI_ENTRY_CHECKED(ResultType,  \

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

   945                                               jobject obj, \

   946                                               jclass clazz, \

   947                                               jmethodID methodID, \

   948                                               va_list args)) \

   949     functionEnter(thr); \

   950     IN_VM( \

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

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

   953     ) \

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

   955                                                                      obj, \

   956                                                                      clazz, \

   957                                                                      methodID,\

   958                                                                      args); \

   959     functionExit(env); \

   960     return result; \

   961 JNI_END \

   962 \

   963 JNI_ENTRY_CHECKED(ResultType,  \

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

   965                                               jobject obj, \

   966                                               jclass clazz, \

   967                                               jmethodID methodID, \

   968                                               const jvalue * args)) \

   969     functionEnter(thr); \

   970     IN_VM( \

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

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

   973     ) \

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

   975                                                                      obj, \

   976                                                                      clazz, \

   977                                                                      methodID,\

   978                                                                      args); \

   979     functionExit(env); \

   980     return result; \

   981 JNI_END

   983 WRAPPER_CallNonvirtualMethod(jobject,Object)

   984 WRAPPER_CallNonvirtualMethod(jboolean,Boolean)

   985 WRAPPER_CallNonvirtualMethod(jbyte,Byte)

   986 WRAPPER_CallNonvirtualMethod(jshort,Short)

   987 WRAPPER_CallNonvirtualMethod(jchar,Char)

   988 WRAPPER_CallNonvirtualMethod(jint,Int)

   989 WRAPPER_CallNonvirtualMethod(jlong,Long)

   990 WRAPPER_CallNonvirtualMethod(jfloat,Float)

   991 WRAPPER_CallNonvirtualMethod(jdouble,Double)

   993 JNI_ENTRY_CHECKED(void,

   994   checked_jni_CallNonvirtualVoidMethod(JNIEnv *env,

   995                                        jobject obj,

   996                                        jclass clazz,

   997                                        jmethodID methodID,

   998                                        ...))

   999     functionEnter(thr);

  1000     va_list args;

  1001     IN_VM(

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

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

  1004     )

  1005     va_start(args,methodID);

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

  1007     va_end(args);

  1008     functionExit(env);

  1009 JNI_END

  1011 JNI_ENTRY_CHECKED(void,

  1012   checked_jni_CallNonvirtualVoidMethodV(JNIEnv *env,

  1013                                         jobject obj,

  1014                                         jclass clazz,

  1015                                         jmethodID methodID,

  1016                                         va_list args))

  1017     functionEnter(thr);

  1018     IN_VM(

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

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

  1021     )

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

  1023     functionExit(env);

  1024 JNI_END

  1026 JNI_ENTRY_CHECKED(void,

  1027   checked_jni_CallNonvirtualVoidMethodA(JNIEnv *env,

  1028                                         jobject obj,

  1029                                         jclass clazz,

  1030                                         jmethodID methodID,

  1031                                         const jvalue * args))

  1032     functionEnter(thr);

  1033     IN_VM(

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

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

  1036     )

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

  1038     functionExit(env);

  1039 JNI_END

  1041 JNI_ENTRY_CHECKED(jfieldID,

  1042   checked_jni_GetFieldID(JNIEnv *env,

  1043                          jclass clazz,

  1044                          const char *name,

  1045                          const char *sig))

  1046     functionEnter(thr);

  1047     IN_VM(

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

  1049     )

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

  1051     functionExit(env);

  1052     return result;

  1053 JNI_END

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

  1056 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1058                                  jobject obj, \

  1059                                  jfieldID fieldID)) \

  1060     functionEnter(thr); \

  1061     IN_VM( \

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

  1063     ) \

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

  1065     functionExit(env); \

  1066     return result; \

  1067 JNI_END

  1069 WRAPPER_GetField(jobject,  Object,  T_OBJECT)

  1070 WRAPPER_GetField(jboolean, Boolean, T_BOOLEAN)

  1071 WRAPPER_GetField(jbyte,    Byte,    T_BYTE)

  1072 WRAPPER_GetField(jshort,   Short,   T_SHORT)

  1073 WRAPPER_GetField(jchar,    Char,    T_CHAR)

  1074 WRAPPER_GetField(jint,     Int,     T_INT)

  1075 WRAPPER_GetField(jlong,    Long,    T_LONG)

  1076 WRAPPER_GetField(jfloat,   Float,   T_FLOAT)

  1077 WRAPPER_GetField(jdouble,  Double,  T_DOUBLE)

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

  1080 JNI_ENTRY_CHECKED(void,  \

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

  1082                                  jobject obj, \

  1083                                  jfieldID fieldID, \

  1084                                  ValueType val)) \

  1085     functionEnter(thr); \

  1086     IN_VM( \

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

  1088     ) \

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

  1090     functionExit(env); \

  1091 JNI_END

  1093 WRAPPER_SetField(jobject,  Object,  T_OBJECT)

  1094 WRAPPER_SetField(jboolean, Boolean, T_BOOLEAN)

  1095 WRAPPER_SetField(jbyte,    Byte,    T_BYTE)

  1096 WRAPPER_SetField(jshort,   Short,   T_SHORT)

  1097 WRAPPER_SetField(jchar,    Char,    T_CHAR)

  1098 WRAPPER_SetField(jint,     Int,     T_INT)

  1099 WRAPPER_SetField(jlong,    Long,    T_LONG)

  1100 WRAPPER_SetField(jfloat,   Float,   T_FLOAT)

  1101 WRAPPER_SetField(jdouble,  Double,  T_DOUBLE)

  1104 JNI_ENTRY_CHECKED(jmethodID,

  1105   checked_jni_GetStaticMethodID(JNIEnv *env,

  1106                                 jclass clazz,

  1107                                 const char *name,

  1108                                 const char *sig))

  1109     functionEnter(thr);

  1110     IN_VM(

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

  1112     )

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

  1114     functionExit(env);

  1115     return result;

  1116 JNI_END

  1118 #define WRAPPER_CallStaticMethod(ReturnType,Result) \

  1119 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1121                                          jclass clazz, \

  1122                                          jmethodID methodID, \

  1123                                          ...)) \

  1124     functionEnter(thr); \

  1125     va_list args; \

  1126     IN_VM( \

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

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

  1129     ) \

  1130     va_start(args,methodID); \

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

  1132                                                                  clazz, \

  1133                                                                  methodID, \

  1134                                                                  args); \

  1135     va_end(args); \

  1136     functionExit(env); \

  1137     return result; \

  1138 JNI_END \

  1139 \

  1140 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1142                                           jclass clazz, \

  1143                                           jmethodID methodID,\

  1144                                           va_list args)) \

  1145     functionEnter(thr); \

  1146     IN_VM( \

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

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

  1149     ) \

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

  1151                                                                  clazz, \

  1152                                                                  methodID, \

  1153                                                                  args); \

  1154     functionExit(env); \

  1155     return result; \

  1156 JNI_END \

  1157 \

  1158 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1160                                           jclass clazz, \

  1161                                           jmethodID methodID, \

  1162                                           const jvalue *args)) \

  1163     functionEnter(thr); \

  1164     IN_VM( \

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

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

  1167     ) \

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

  1169                                                                  clazz, \

  1170                                                                  methodID, \

  1171                                                                  args); \

  1172     functionExit(env); \

  1173     return result; \

  1174 JNI_END

  1176 WRAPPER_CallStaticMethod(jobject,Object)

  1177 WRAPPER_CallStaticMethod(jboolean,Boolean)

  1178 WRAPPER_CallStaticMethod(jbyte,Byte)

  1179 WRAPPER_CallStaticMethod(jshort,Short)

  1180 WRAPPER_CallStaticMethod(jchar,Char)

  1181 WRAPPER_CallStaticMethod(jint,Int)

  1182 WRAPPER_CallStaticMethod(jlong,Long)

  1183 WRAPPER_CallStaticMethod(jfloat,Float)

  1184 WRAPPER_CallStaticMethod(jdouble,Double)

  1186 JNI_ENTRY_CHECKED(void,

  1187   checked_jni_CallStaticVoidMethod(JNIEnv *env,

  1188                                    jclass cls,

  1189                                    jmethodID methodID,

  1190                                    ...))

  1191     functionEnter(thr);

  1192     va_list args;

  1193     IN_VM(

  1194       jniCheck::validate_jmethod_id(thr, methodID);

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

  1196     )

  1197     va_start(args,methodID);

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

  1199     va_end(args);

  1200     functionExit(env);

  1201 JNI_END

  1203 JNI_ENTRY_CHECKED(void,

  1204   checked_jni_CallStaticVoidMethodV(JNIEnv *env,

  1205                                     jclass cls,

  1206                                     jmethodID methodID,

  1207                                     va_list args))

  1208     functionEnter(thr);

  1209     IN_VM(

  1210       jniCheck::validate_jmethod_id(thr, methodID);

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

  1212     )

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

  1214     functionExit(env);

  1215 JNI_END

  1217 JNI_ENTRY_CHECKED(void,

  1218   checked_jni_CallStaticVoidMethodA(JNIEnv *env,

  1219                                     jclass cls,

  1220                                     jmethodID methodID,

  1221                                     const jvalue * args))

  1222     functionEnter(thr);

  1223     IN_VM(

  1224       jniCheck::validate_jmethod_id(thr, methodID);

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

  1226     )

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

  1228     functionExit(env);

  1229 JNI_END

  1231 JNI_ENTRY_CHECKED(jfieldID,

  1232   checked_jni_GetStaticFieldID(JNIEnv *env,

  1233                                jclass clazz,

  1234                                const char *name,

  1235                                const char *sig))

  1236     functionEnter(thr);

  1237     IN_VM(

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

  1239     )

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

  1241     functionExit(env);

  1242     return result;

  1243 JNI_END

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

  1246 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1248                                        jclass clazz, \

  1249                                        jfieldID fieldID)) \

  1250     functionEnter(thr); \

  1251     IN_VM( \

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

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

  1254     ) \

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

  1256                                                               clazz, \

  1257                                                               fieldID); \

  1258     functionExit(env); \

  1259     return result; \

  1260 JNI_END

  1262 WRAPPER_GetStaticField(jobject,  Object,  T_OBJECT)

  1263 WRAPPER_GetStaticField(jboolean, Boolean, T_BOOLEAN)

  1264 WRAPPER_GetStaticField(jbyte,    Byte,    T_BYTE)

  1265 WRAPPER_GetStaticField(jshort,   Short,   T_SHORT)

  1266 WRAPPER_GetStaticField(jchar,    Char,    T_CHAR)

  1267 WRAPPER_GetStaticField(jint,     Int,     T_INT)

  1268 WRAPPER_GetStaticField(jlong,    Long,    T_LONG)

  1269 WRAPPER_GetStaticField(jfloat,   Float,   T_FLOAT)

  1270 WRAPPER_GetStaticField(jdouble,  Double,  T_DOUBLE)

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

  1273 JNI_ENTRY_CHECKED(void,  \

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

  1275                                        jclass clazz, \

  1276                                        jfieldID fieldID, \

  1277                                        ValueType value)) \

  1278     functionEnter(thr); \

  1279     IN_VM( \

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

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

  1282     ) \

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

  1284     functionExit(env); \

  1285 JNI_END

  1287 WRAPPER_SetStaticField(jobject,  Object,  T_OBJECT)

  1288 WRAPPER_SetStaticField(jboolean, Boolean, T_BOOLEAN)

  1289 WRAPPER_SetStaticField(jbyte,    Byte,    T_BYTE)

  1290 WRAPPER_SetStaticField(jshort,   Short,   T_SHORT)

  1291 WRAPPER_SetStaticField(jchar,    Char,    T_CHAR)

  1292 WRAPPER_SetStaticField(jint,     Int,     T_INT)

  1293 WRAPPER_SetStaticField(jlong,    Long,    T_LONG)

  1294 WRAPPER_SetStaticField(jfloat,   Float,   T_FLOAT)

  1295 WRAPPER_SetStaticField(jdouble,  Double,  T_DOUBLE)

  1298 JNI_ENTRY_CHECKED(jstring,

  1299   checked_jni_NewString(JNIEnv *env,

  1300                         const jchar *unicode,

  1301                         jsize len))

  1302     functionEnter(thr);

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

  1304     functionExit(env);

  1305     return result;

  1306 JNI_END

  1308 JNI_ENTRY_CHECKED(jsize,

  1309   checked_jni_GetStringLength(JNIEnv *env,

  1310                               jstring str))

  1311     functionEnter(thr);

  1312     IN_VM(

  1313       checkString(thr, str);

  1314     )

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

  1316     functionExit(env);

  1317     return result;

  1318 JNI_END

  1320 // Arbitrary (but well-known) tag

  1321 const jint STRING_TAG = 0x47114711;

  1323 JNI_ENTRY_CHECKED(const jchar *,

  1324   checked_jni_GetStringChars(JNIEnv *env,

  1325                              jstring str,

  1326                              jboolean *isCopy))

  1327     functionEnter(thr);

  1328     IN_VM(

  1329       checkString(thr, str);

  1330     )

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

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

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

  1335     jint* tagLocation = (jint*) AllocateHeap(len * sizeof(jchar) + sizeof(jint), mtInternal);

  1336     *tagLocation = STRING_TAG;

  1337     jchar* newResult = (jchar*) (tagLocation + 1);

  1338     memcpy(newResult, result, len * sizeof(jchar));

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

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

  1341     FreeHeap((char*)result);

  1343     functionExit(env);

  1344     return newResult;

  1345 JNI_END

  1347 JNI_ENTRY_CHECKED(void,

  1348   checked_jni_ReleaseStringChars(JNIEnv *env,

  1349                                  jstring str,

  1350                                  const jchar *chars))

  1351     functionEnterExceptionAllowed(thr);

  1352     IN_VM(

  1353       checkString(thr, str);

  1354     )

  1355     if (chars == NULL) {

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

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

  1358     }

  1359     else {

  1360        jint* tagLocation = ((jint*) chars) - 1;

  1361        if (*tagLocation != STRING_TAG) {

  1362           NativeReportJNIFatalError(thr, "ReleaseStringChars called on something not allocated by GetStringChars");

  1363        }

  1364        UNCHECKED()->ReleaseStringChars(env,str,(const jchar*)tagLocation);

  1365     }

  1366     functionExit(env);

  1367 JNI_END

  1369 JNI_ENTRY_CHECKED(jstring,

  1370   checked_jni_NewStringUTF(JNIEnv *env,

  1371                            const char *utf))

  1372     functionEnter(thr);

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

  1374     functionExit(env);

  1375     return result;

  1376 JNI_END

  1378 JNI_ENTRY_CHECKED(jsize,

  1379   checked_jni_GetStringUTFLength(JNIEnv *env,

  1380                                  jstring str))

  1381     functionEnter(thr);

  1382     IN_VM(

  1383       checkString(thr, str);

  1384     )

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

  1386     functionExit(env);

  1387     return result;

  1388 JNI_END

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

  1391 const jint STRING_UTF_TAG = 0x48124812;

  1393 JNI_ENTRY_CHECKED(const char *,

  1394   checked_jni_GetStringUTFChars(JNIEnv *env,

  1395                                 jstring str,

  1396                                 jboolean *isCopy))

  1397     functionEnter(thr);

  1398     IN_VM(

  1399       checkString(thr, str);

  1400     )

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

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

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

  1405     jint* tagLocation = (jint*) AllocateHeap(len + sizeof(jint), mtInternal);

  1406     *tagLocation = STRING_UTF_TAG;

  1407     char* newResult = (char*) (tagLocation + 1);

  1408     strcpy(newResult, result);

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

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

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

  1413     functionExit(env);

  1414     return newResult;

  1415 JNI_END

  1417 JNI_ENTRY_CHECKED(void,

  1418   checked_jni_ReleaseStringUTFChars(JNIEnv *env,

  1419                                     jstring str,

  1420                                     const char* chars))

  1421     functionEnterExceptionAllowed(thr);

  1422     IN_VM(

  1423       checkString(thr, str);

  1424     )

  1425     if (chars == NULL) {

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

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

  1428     }

  1429     else {

  1430        jint* tagLocation = ((jint*) chars) - 1;

  1431        if (*tagLocation != STRING_UTF_TAG) {

  1432           NativeReportJNIFatalError(thr, "ReleaseStringUTFChars called on something not allocated by GetStringUTFChars");

  1433        }

  1434        UNCHECKED()->ReleaseStringUTFChars(env,str,(const char*)tagLocation);

  1435     }

  1436     functionExit(env);

  1437 JNI_END

  1439 JNI_ENTRY_CHECKED(jsize,

  1440   checked_jni_GetArrayLength(JNIEnv *env,

  1441                              jarray array))

  1442     functionEnter(thr);

  1443     IN_VM(

  1444       check_is_array(thr, array);

  1445     )

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

  1447     functionExit(env);

  1448     return result;

  1449 JNI_END

  1451 JNI_ENTRY_CHECKED(jobjectArray,

  1452   checked_jni_NewObjectArray(JNIEnv *env,

  1453                              jsize len,

  1454                              jclass clazz,

  1455                              jobject init))

  1456     functionEnter(thr);

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

  1458     functionExit(env);

  1459     return result;

  1460 JNI_END

  1462 JNI_ENTRY_CHECKED(jobject,

  1463   checked_jni_GetObjectArrayElement(JNIEnv *env,

  1464                                     jobjectArray array,

  1465                                     jsize index))

  1466     functionEnter(thr);

  1467     IN_VM(

  1468       check_is_obj_array(thr, array);

  1469     )

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

  1471     functionExit(env);

  1472     return result;

  1473 JNI_END

  1475 JNI_ENTRY_CHECKED(void,

  1476   checked_jni_SetObjectArrayElement(JNIEnv *env,

  1477                                     jobjectArray array,

  1478                                     jsize index,

  1479                                     jobject val))

  1480     functionEnter(thr);

  1481     IN_VM(

  1482       check_is_obj_array(thr, array);

  1483     )

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

  1485     functionExit(env);

  1486 JNI_END

  1488 #define WRAPPER_NewScalarArray(Return, Result) \

  1489 JNI_ENTRY_CHECKED(Return, \

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

  1491                                  jsize len)) \

  1492     functionEnter(thr); \

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

  1494     functionExit(env); \

  1495     return (Return) result; \

  1496 JNI_END

  1498 WRAPPER_NewScalarArray(jbooleanArray, Boolean)

  1499 WRAPPER_NewScalarArray(jbyteArray, Byte)

  1500 WRAPPER_NewScalarArray(jshortArray, Short)

  1501 WRAPPER_NewScalarArray(jcharArray, Char)

  1502 WRAPPER_NewScalarArray(jintArray, Int)

  1503 WRAPPER_NewScalarArray(jlongArray, Long)

  1504 WRAPPER_NewScalarArray(jfloatArray, Float)

  1505 WRAPPER_NewScalarArray(jdoubleArray, Double)

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

  1508 JNI_ENTRY_CHECKED(ElementType *,  \

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

  1510                                          ElementType##Array array, \

  1511                                          jboolean *isCopy)) \

  1512     functionEnter(thr); \

  1513     IN_VM( \

  1514       check_primitive_array_type(thr, array, ElementTag); \

  1515     ) \

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

  1517                                                                   array, \

  1518                                                                   isCopy); \

  1519     functionExit(env); \

  1520     return result; \

  1521 JNI_END

  1523 WRAPPER_GetScalarArrayElements(T_BOOLEAN, jboolean, Boolean)

  1524 WRAPPER_GetScalarArrayElements(T_BYTE,    jbyte,    Byte)

  1525 WRAPPER_GetScalarArrayElements(T_SHORT,   jshort,   Short)

  1526 WRAPPER_GetScalarArrayElements(T_CHAR,    jchar,    Char)

  1527 WRAPPER_GetScalarArrayElements(T_INT,     jint,     Int)

  1528 WRAPPER_GetScalarArrayElements(T_LONG,    jlong,    Long)

  1529 WRAPPER_GetScalarArrayElements(T_FLOAT,   jfloat,   Float)

  1530 WRAPPER_GetScalarArrayElements(T_DOUBLE,  jdouble,  Double)

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

  1533 JNI_ENTRY_CHECKED(void,  \

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

  1535                                              ElementType##Array array, \

  1536                                              ElementType *elems, \

  1537                                              jint mode)) \

  1538     functionEnterExceptionAllowed(thr); \

  1539     IN_VM( \

  1540       check_primitive_array_type(thr, array, ElementTag); \

  1541       ASSERT_OOPS_ALLOWED; \

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

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

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

  1545        * subsequent release.

  1546        */ \

  1547     ) \

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

  1549     functionExit(env); \

  1550 JNI_END

  1552 WRAPPER_ReleaseScalarArrayElements(T_BOOLEAN,jboolean, Boolean, bool)

  1553 WRAPPER_ReleaseScalarArrayElements(T_BYTE,   jbyte,    Byte,    byte)

  1554 WRAPPER_ReleaseScalarArrayElements(T_SHORT,  jshort,   Short,   short)

  1555 WRAPPER_ReleaseScalarArrayElements(T_CHAR,   jchar,    Char,    char)

  1556 WRAPPER_ReleaseScalarArrayElements(T_INT,    jint,     Int,     int)

  1557 WRAPPER_ReleaseScalarArrayElements(T_LONG,   jlong,    Long,    long)

  1558 WRAPPER_ReleaseScalarArrayElements(T_FLOAT,  jfloat,   Float,   float)

  1559 WRAPPER_ReleaseScalarArrayElements(T_DOUBLE, jdouble,  Double,  double)

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

  1562 JNI_ENTRY_CHECKED(void,  \

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

  1564                                        ElementType##Array array, \

  1565                                        jsize start, \

  1566                                        jsize len, \

  1567                                        ElementType *buf)) \

  1568     functionEnter(thr); \

  1569     IN_VM( \

  1570       check_primitive_array_type(thr, array, ElementTag); \

  1571     ) \

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

  1573     functionExit(env); \

  1574 JNI_END

  1576 WRAPPER_GetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)

  1577 WRAPPER_GetScalarArrayRegion(T_BYTE,    jbyte,    Byte)

  1578 WRAPPER_GetScalarArrayRegion(T_SHORT,   jshort,   Short)

  1579 WRAPPER_GetScalarArrayRegion(T_CHAR,    jchar,    Char)

  1580 WRAPPER_GetScalarArrayRegion(T_INT,     jint,     Int)

  1581 WRAPPER_GetScalarArrayRegion(T_LONG,    jlong,    Long)

  1582 WRAPPER_GetScalarArrayRegion(T_FLOAT,   jfloat,   Float)

  1583 WRAPPER_GetScalarArrayRegion(T_DOUBLE,  jdouble,  Double)

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

  1586 JNI_ENTRY_CHECKED(void,  \

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

  1588                                        ElementType##Array array, \

  1589                                        jsize start, \

  1590                                        jsize len, \

  1591                                        const ElementType *buf)) \

  1592     functionEnter(thr); \

  1593     IN_VM( \

  1594       check_primitive_array_type(thr, array, ElementTag); \

  1595     ) \

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

  1597     functionExit(env); \

  1598 JNI_END

  1600 WRAPPER_SetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)

  1601 WRAPPER_SetScalarArrayRegion(T_BYTE,    jbyte,    Byte)

  1602 WRAPPER_SetScalarArrayRegion(T_SHORT,   jshort,   Short)

  1603 WRAPPER_SetScalarArrayRegion(T_CHAR,    jchar,    Char)

  1604 WRAPPER_SetScalarArrayRegion(T_INT,     jint,     Int)

  1605 WRAPPER_SetScalarArrayRegion(T_LONG,    jlong,    Long)

  1606 WRAPPER_SetScalarArrayRegion(T_FLOAT,   jfloat,   Float)

  1607 WRAPPER_SetScalarArrayRegion(T_DOUBLE,  jdouble,  Double)

  1609 JNI_ENTRY_CHECKED(jint,

  1610   checked_jni_RegisterNatives(JNIEnv *env,

  1611                               jclass clazz,

  1612                               const JNINativeMethod *methods,

  1613                               jint nMethods))

  1614     functionEnter(thr);

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

  1616     functionExit(env);

  1617     return result;

  1618 JNI_END

  1620 JNI_ENTRY_CHECKED(jint,

  1621   checked_jni_UnregisterNatives(JNIEnv *env,

  1622                                 jclass clazz))

  1623     functionEnter(thr);

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

  1625     functionExit(env);

  1626     return result;

  1627 JNI_END

  1629 JNI_ENTRY_CHECKED(jint,

  1630   checked_jni_MonitorEnter(JNIEnv *env,

  1631                            jobject obj))

  1632     functionEnter(thr);

  1633     IN_VM(

  1634       jniCheck::validate_object(thr, obj);

  1635     )

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

  1637     functionExit(env);

  1638     return result;

  1639 JNI_END

  1641 JNI_ENTRY_CHECKED(jint,

  1642   checked_jni_MonitorExit(JNIEnv *env,

  1643                           jobject obj))

  1644     functionEnterExceptionAllowed(thr);

  1645     IN_VM(

  1646       jniCheck::validate_object(thr, obj);

  1647     )

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

  1649     functionExit(env);

  1650     return result;

  1651 JNI_END

  1653 JNI_ENTRY_CHECKED(jint,

  1654   checked_jni_GetJavaVM(JNIEnv *env,

  1655                         JavaVM **vm))

  1656     functionEnter(thr);

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

  1658     functionExit(env);

  1659     return result;

  1660 JNI_END

  1662 JNI_ENTRY_CHECKED(void,

  1663   checked_jni_GetStringRegion(JNIEnv *env,

  1664                               jstring str,

  1665                               jsize start,

  1666                               jsize len,

  1667                               jchar *buf))

  1668     functionEnter(thr);

  1669     IN_VM(

  1670       checkString(thr, str);

  1671     )

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

  1673     functionExit(env);

  1674 JNI_END

  1676 JNI_ENTRY_CHECKED(void,

  1677   checked_jni_GetStringUTFRegion(JNIEnv *env,

  1678                                  jstring str,

  1679                                  jsize start,

  1680                                  jsize len,

  1681                                  char *buf))

  1682     functionEnter(thr);

  1683     IN_VM(

  1684       checkString(thr, str);

  1685     )

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

  1687     functionExit(env);

  1688 JNI_END

  1690 JNI_ENTRY_CHECKED(void *,

  1691   checked_jni_GetPrimitiveArrayCritical(JNIEnv *env,

  1692                                         jarray array,

  1693                                         jboolean *isCopy))

  1694     functionEnterCritical(thr);

  1695     IN_VM(

  1696       check_is_primitive_array(thr, array);

  1697     )

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

  1699     functionExit(env);

  1700     return result;

  1701 JNI_END

  1703 JNI_ENTRY_CHECKED(void,

  1704   checked_jni_ReleasePrimitiveArrayCritical(JNIEnv *env,

  1705                                             jarray array,

  1706                                             void *carray,

  1707                                             jint mode))

  1708     functionEnterCriticalExceptionAllowed(thr);

  1709     IN_VM(

  1710       check_is_primitive_array(thr, array);

  1711     )

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

  1713      * array parameter as a minor sanity check

  1714      */

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

  1716     functionExit(env);

  1717 JNI_END

  1719 JNI_ENTRY_CHECKED(const jchar*,

  1720   checked_jni_GetStringCritical(JNIEnv *env,

  1721                                 jstring string,

  1722                                 jboolean *isCopy))

  1723     functionEnterCritical(thr);

  1724     IN_VM(

  1725       checkString(thr, string);

  1726     )

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

  1728     functionExit(env);

  1729     return result;

  1730 JNI_END

  1732 JNI_ENTRY_CHECKED(void,

  1733   checked_jni_ReleaseStringCritical(JNIEnv *env,

  1734                                     jstring str,

  1735                                     const jchar *chars))

  1736     functionEnterCriticalExceptionAllowed(thr);

  1737     IN_VM(

  1738       checkString(thr, str);

  1739     )

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

  1741      * string parameter as a minor sanity check

  1742      */

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

  1744     functionExit(env);

  1745 JNI_END

  1747 JNI_ENTRY_CHECKED(jweak,

  1748   checked_jni_NewWeakGlobalRef(JNIEnv *env,

  1749                                jobject obj))

  1750     functionEnter(thr);

  1751     IN_VM(

  1752       if (obj != NULL) {

  1753         jniCheck::validate_handle(thr, obj);

  1754       }

  1755     )

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

  1757     functionExit(env);

  1758     return result;

  1759 JNI_END

  1761 JNI_ENTRY_CHECKED(void,

  1762   checked_jni_DeleteWeakGlobalRef(JNIEnv *env,

  1763                                   jweak ref))

  1764     functionEnterExceptionAllowed(thr);

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

  1766     functionExit(env);

  1767 JNI_END

  1769 JNI_ENTRY_CHECKED(jboolean,

  1770   checked_jni_ExceptionCheck(JNIEnv *env))

  1771     functionEnterExceptionAllowed(thr);

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

  1773     functionExit(env);

  1774     return result;

  1775 JNI_END

  1777 JNI_ENTRY_CHECKED(jobject,

  1778   checked_jni_NewDirectByteBuffer(JNIEnv *env,

  1779                                   void *address,

  1780                                   jlong capacity))

  1781     functionEnter(thr);

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

  1783     functionExit(env);

  1784     return result;

  1785 JNI_END

  1787 JNI_ENTRY_CHECKED(void *,

  1788   checked_jni_GetDirectBufferAddress(JNIEnv *env,

  1789                                      jobject buf))

  1790     functionEnter(thr);

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

  1792     functionExit(env);

  1793     return result;

  1794 JNI_END

  1796 JNI_ENTRY_CHECKED(jlong,

  1797   checked_jni_GetDirectBufferCapacity(JNIEnv *env,

  1798                                       jobject buf))

  1799     functionEnter(thr);

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

  1801     functionExit(env);

  1802     return result;

  1803 JNI_END

  1805 JNI_ENTRY_CHECKED(jobjectRefType,

  1806   checked_jni_GetObjectRefType(JNIEnv *env,

  1807                                jobject obj))

  1808     functionEnter(thr);

  1809     /* validate the object being passed */

  1810     IN_VM(

  1811       jniCheck::validate_object(thr, obj);

  1812     )

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

  1814     functionExit(env);

  1815     return result;

  1816 JNI_END

  1819 JNI_ENTRY_CHECKED(jint,

  1820   checked_jni_GetVersion(JNIEnv *env))

  1821     functionEnter(thr);

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

  1823     functionExit(env);

  1824     return result;

  1825 JNI_END

  1829 /*

  1830  * Structure containing all checked jni functions

  1831  */

  1832 struct JNINativeInterface_  checked_jni_NativeInterface = {

  1833     NULL,

  1834     NULL,

  1835     NULL,

  1837     NULL,

  1839     checked_jni_GetVersion,

  1841     checked_jni_DefineClass,

  1842     checked_jni_FindClass,

  1844     checked_jni_FromReflectedMethod,

  1845     checked_jni_FromReflectedField,

  1847     checked_jni_ToReflectedMethod,

  1849     checked_jni_GetSuperclass,

  1850     checked_jni_IsAssignableFrom,

  1852     checked_jni_ToReflectedField,

  1854     checked_jni_Throw,

  1855     checked_jni_ThrowNew,

  1856     checked_jni_ExceptionOccurred,

  1857     checked_jni_ExceptionDescribe,

  1858     checked_jni_ExceptionClear,

  1859     checked_jni_FatalError,

  1861     checked_jni_PushLocalFrame,

  1862     checked_jni_PopLocalFrame,

  1864     checked_jni_NewGlobalRef,

  1865     checked_jni_DeleteGlobalRef,

  1866     checked_jni_DeleteLocalRef,

  1867     checked_jni_IsSameObject,

  1869     checked_jni_NewLocalRef,

  1870     checked_jni_EnsureLocalCapacity,

  1872     checked_jni_AllocObject,

  1873     checked_jni_NewObject,

  1874     checked_jni_NewObjectV,

  1875     checked_jni_NewObjectA,

  1877     checked_jni_GetObjectClass,

  1878     checked_jni_IsInstanceOf,

  1880     checked_jni_GetMethodID,

  1882     checked_jni_CallObjectMethod,

  1883     checked_jni_CallObjectMethodV,

  1884     checked_jni_CallObjectMethodA,

  1885     checked_jni_CallBooleanMethod,

  1886     checked_jni_CallBooleanMethodV,

  1887     checked_jni_CallBooleanMethodA,

  1888     checked_jni_CallByteMethod,

  1889     checked_jni_CallByteMethodV,

  1890     checked_jni_CallByteMethodA,

  1891     checked_jni_CallCharMethod,

  1892     checked_jni_CallCharMethodV,

  1893     checked_jni_CallCharMethodA,

  1894     checked_jni_CallShortMethod,

  1895     checked_jni_CallShortMethodV,

  1896     checked_jni_CallShortMethodA,

  1897     checked_jni_CallIntMethod,

  1898     checked_jni_CallIntMethodV,

  1899     checked_jni_CallIntMethodA,

  1900     checked_jni_CallLongMethod,

  1901     checked_jni_CallLongMethodV,

  1902     checked_jni_CallLongMethodA,

  1903     checked_jni_CallFloatMethod,

  1904     checked_jni_CallFloatMethodV,

  1905     checked_jni_CallFloatMethodA,

  1906     checked_jni_CallDoubleMethod,

  1907     checked_jni_CallDoubleMethodV,

  1908     checked_jni_CallDoubleMethodA,

  1909     checked_jni_CallVoidMethod,

  1910     checked_jni_CallVoidMethodV,

  1911     checked_jni_CallVoidMethodA,

  1913     checked_jni_CallNonvirtualObjectMethod,

  1914     checked_jni_CallNonvirtualObjectMethodV,

  1915     checked_jni_CallNonvirtualObjectMethodA,

  1916     checked_jni_CallNonvirtualBooleanMethod,

  1917     checked_jni_CallNonvirtualBooleanMethodV,

  1918     checked_jni_CallNonvirtualBooleanMethodA,

  1919     checked_jni_CallNonvirtualByteMethod,

  1920     checked_jni_CallNonvirtualByteMethodV,

  1921     checked_jni_CallNonvirtualByteMethodA,

  1922     checked_jni_CallNonvirtualCharMethod,

  1923     checked_jni_CallNonvirtualCharMethodV,

  1924     checked_jni_CallNonvirtualCharMethodA,

  1925     checked_jni_CallNonvirtualShortMethod,

  1926     checked_jni_CallNonvirtualShortMethodV,

  1927     checked_jni_CallNonvirtualShortMethodA,

  1928     checked_jni_CallNonvirtualIntMethod,

  1929     checked_jni_CallNonvirtualIntMethodV,

  1930     checked_jni_CallNonvirtualIntMethodA,

  1931     checked_jni_CallNonvirtualLongMethod,

  1932     checked_jni_CallNonvirtualLongMethodV,

  1933     checked_jni_CallNonvirtualLongMethodA,

  1934     checked_jni_CallNonvirtualFloatMethod,

  1935     checked_jni_CallNonvirtualFloatMethodV,

  1936     checked_jni_CallNonvirtualFloatMethodA,

  1937     checked_jni_CallNonvirtualDoubleMethod,

  1938     checked_jni_CallNonvirtualDoubleMethodV,

  1939     checked_jni_CallNonvirtualDoubleMethodA,

  1940     checked_jni_CallNonvirtualVoidMethod,

  1941     checked_jni_CallNonvirtualVoidMethodV,

  1942     checked_jni_CallNonvirtualVoidMethodA,

  1944     checked_jni_GetFieldID,

  1946     checked_jni_GetObjectField,

  1947     checked_jni_GetBooleanField,

  1948     checked_jni_GetByteField,

  1949     checked_jni_GetCharField,

  1950     checked_jni_GetShortField,

  1951     checked_jni_GetIntField,

  1952     checked_jni_GetLongField,

  1953     checked_jni_GetFloatField,

  1954     checked_jni_GetDoubleField,

  1956     checked_jni_SetObjectField,

  1957     checked_jni_SetBooleanField,

  1958     checked_jni_SetByteField,

  1959     checked_jni_SetCharField,

  1960     checked_jni_SetShortField,

  1961     checked_jni_SetIntField,

  1962     checked_jni_SetLongField,

  1963     checked_jni_SetFloatField,

  1964     checked_jni_SetDoubleField,

  1966     checked_jni_GetStaticMethodID,

  1968     checked_jni_CallStaticObjectMethod,

  1969     checked_jni_CallStaticObjectMethodV,

  1970     checked_jni_CallStaticObjectMethodA,

  1971     checked_jni_CallStaticBooleanMethod,

  1972     checked_jni_CallStaticBooleanMethodV,

  1973     checked_jni_CallStaticBooleanMethodA,

  1974     checked_jni_CallStaticByteMethod,

  1975     checked_jni_CallStaticByteMethodV,

  1976     checked_jni_CallStaticByteMethodA,

  1977     checked_jni_CallStaticCharMethod,

  1978     checked_jni_CallStaticCharMethodV,

  1979     checked_jni_CallStaticCharMethodA,

  1980     checked_jni_CallStaticShortMethod,

  1981     checked_jni_CallStaticShortMethodV,

  1982     checked_jni_CallStaticShortMethodA,

  1983     checked_jni_CallStaticIntMethod,

  1984     checked_jni_CallStaticIntMethodV,

  1985     checked_jni_CallStaticIntMethodA,

  1986     checked_jni_CallStaticLongMethod,

  1987     checked_jni_CallStaticLongMethodV,

  1988     checked_jni_CallStaticLongMethodA,

  1989     checked_jni_CallStaticFloatMethod,

  1990     checked_jni_CallStaticFloatMethodV,

  1991     checked_jni_CallStaticFloatMethodA,

  1992     checked_jni_CallStaticDoubleMethod,

  1993     checked_jni_CallStaticDoubleMethodV,

  1994     checked_jni_CallStaticDoubleMethodA,

  1995     checked_jni_CallStaticVoidMethod,

  1996     checked_jni_CallStaticVoidMethodV,

  1997     checked_jni_CallStaticVoidMethodA,

  1999     checked_jni_GetStaticFieldID,

  2001     checked_jni_GetStaticObjectField,

  2002     checked_jni_GetStaticBooleanField,

  2003     checked_jni_GetStaticByteField,

  2004     checked_jni_GetStaticCharField,

  2005     checked_jni_GetStaticShortField,

  2006     checked_jni_GetStaticIntField,

  2007     checked_jni_GetStaticLongField,

  2008     checked_jni_GetStaticFloatField,

  2009     checked_jni_GetStaticDoubleField,

  2011     checked_jni_SetStaticObjectField,

  2012     checked_jni_SetStaticBooleanField,

  2013     checked_jni_SetStaticByteField,

  2014     checked_jni_SetStaticCharField,

  2015     checked_jni_SetStaticShortField,

  2016     checked_jni_SetStaticIntField,

  2017     checked_jni_SetStaticLongField,

  2018     checked_jni_SetStaticFloatField,

  2019     checked_jni_SetStaticDoubleField,

  2021     checked_jni_NewString,

  2022     checked_jni_GetStringLength,

  2023     checked_jni_GetStringChars,

  2024     checked_jni_ReleaseStringChars,

  2026     checked_jni_NewStringUTF,

  2027     checked_jni_GetStringUTFLength,

  2028     checked_jni_GetStringUTFChars,

  2029     checked_jni_ReleaseStringUTFChars,

  2031     checked_jni_GetArrayLength,

  2033     checked_jni_NewObjectArray,

  2034     checked_jni_GetObjectArrayElement,

  2035     checked_jni_SetObjectArrayElement,

  2037     checked_jni_NewBooleanArray,

  2038     checked_jni_NewByteArray,

  2039     checked_jni_NewCharArray,

  2040     checked_jni_NewShortArray,

  2041     checked_jni_NewIntArray,

  2042     checked_jni_NewLongArray,

  2043     checked_jni_NewFloatArray,

  2044     checked_jni_NewDoubleArray,

  2046     checked_jni_GetBooleanArrayElements,

  2047     checked_jni_GetByteArrayElements,

  2048     checked_jni_GetCharArrayElements,

  2049     checked_jni_GetShortArrayElements,

  2050     checked_jni_GetIntArrayElements,

  2051     checked_jni_GetLongArrayElements,

  2052     checked_jni_GetFloatArrayElements,

  2053     checked_jni_GetDoubleArrayElements,

  2055     checked_jni_ReleaseBooleanArrayElements,

  2056     checked_jni_ReleaseByteArrayElements,

  2057     checked_jni_ReleaseCharArrayElements,

  2058     checked_jni_ReleaseShortArrayElements,

  2059     checked_jni_ReleaseIntArrayElements,

  2060     checked_jni_ReleaseLongArrayElements,

  2061     checked_jni_ReleaseFloatArrayElements,

  2062     checked_jni_ReleaseDoubleArrayElements,

  2064     checked_jni_GetBooleanArrayRegion,

  2065     checked_jni_GetByteArrayRegion,

  2066     checked_jni_GetCharArrayRegion,

  2067     checked_jni_GetShortArrayRegion,

  2068     checked_jni_GetIntArrayRegion,

  2069     checked_jni_GetLongArrayRegion,

  2070     checked_jni_GetFloatArrayRegion,

  2071     checked_jni_GetDoubleArrayRegion,

  2073     checked_jni_SetBooleanArrayRegion,

  2074     checked_jni_SetByteArrayRegion,

  2075     checked_jni_SetCharArrayRegion,

  2076     checked_jni_SetShortArrayRegion,

  2077     checked_jni_SetIntArrayRegion,

  2078     checked_jni_SetLongArrayRegion,

  2079     checked_jni_SetFloatArrayRegion,

  2080     checked_jni_SetDoubleArrayRegion,

  2082     checked_jni_RegisterNatives,

  2083     checked_jni_UnregisterNatives,

  2085     checked_jni_MonitorEnter,

  2086     checked_jni_MonitorExit,

  2088     checked_jni_GetJavaVM,

  2090     checked_jni_GetStringRegion,

  2091     checked_jni_GetStringUTFRegion,

  2093     checked_jni_GetPrimitiveArrayCritical,

  2094     checked_jni_ReleasePrimitiveArrayCritical,

  2096     checked_jni_GetStringCritical,

  2097     checked_jni_ReleaseStringCritical,

  2099     checked_jni_NewWeakGlobalRef,

  2100     checked_jni_DeleteWeakGlobalRef,

  2102     checked_jni_ExceptionCheck,

  2104     checked_jni_NewDirectByteBuffer,

  2105     checked_jni_GetDirectBufferAddress,

  2106     checked_jni_GetDirectBufferCapacity,

  2108     // New 1.6 Features

  2110     checked_jni_GetObjectRefType

  2111 };

  2114 // Returns the function structure

  2115 struct JNINativeInterface_* jni_functions_check() {

  2117   unchecked_jni_NativeInterface = jni_functions_nocheck();

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

  2120   // an addition to the JNINativeInterface_ structure without initializing

  2121   // it in the checked table.

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

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

  2124   assert(*lastPtr != 0,

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

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

  2128   if (PrintJNIResolving) {

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

  2130                   "validate JNI usage");

  2131   }

  2133   return &checked_jni_NativeInterface;

  2134 }

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

src/share/vm/prims/jniCheck.cpp@39deebbc90b3

src/share/vm/prims/jniCheck.cpp