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

Initial load
http://hg.openjdk.java.net/jdk8u/jdk8u/hotspot/
changeset: 6782:28b50d07f6f8
tag: jdk8u25-b17

     1 /*

     2  * Copyright (c) 2001, 2014, 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("%s", 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("%s", 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("%s", 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   arrayOop aOop = check_is_array(thr, jArray);

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

   322     ReportJNIFatalError(thr, fatal_object_array_expected);

   323   }

   324 }

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

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

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

   329       JNIHandles::is_global_handle(obj) ||

   330       JNIHandles::is_weak_global_handle(obj)) {

   331     ASSERT_OOPS_ALLOWED;

   332     return JNIHandles::resolve_external_guard(obj);

   333   }

   334   ReportJNIFatalError(thr, fatal_bad_ref_to_jni);

   335   return NULL;

   336 }

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

   340   ASSERT_OOPS_ALLOWED;

   341   // do the fast jmethodID check first

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

   343   if (moop == NULL) {

   344     ReportJNIFatalError(thr, fatal_wrong_class_or_method);

   345   }

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

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

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

   349     ReportJNIFatalError(thr, fatal_non_weak_method);

   350   }

   351   return moop;

   352 }

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

   356     if (!obj)

   357         return NULL;

   358     ASSERT_OOPS_ALLOWED;

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

   360     if (!oopObj) {

   361       ReportJNIFatalError(thr, fatal_bad_ref_to_jni);

   362     }

   363     return oopObj;

   364 }

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

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

   368 // array descriptors.

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

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

   372   size_t len = strlen(name);

   374   if (len >= 2 &&

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

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

   377     char msg[JVM_MAXPATHLEN];

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

   379     ReportJNIWarning(thr, msg);

   380   }

   381 }

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

   384   ASSERT_OOPS_ALLOWED;

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

   386   if (!mirror) {

   387     ReportJNIFatalError(thr, fatal_received_null_class);

   388   }

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

   391     ReportJNIFatalError(thr, fatal_class_not_a_class);

   392   }

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

   395   // Make allowances for primitive classes ...

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

   397     ReportJNIFatalError(thr, fatal_class_not_a_class);

   398   }

   399   return k;

   400 }

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

   403   ASSERT_OOPS_ALLOWED;

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

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

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

   408     ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);

   409   }

   410 }

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

   413   /* validate the object being passed */

   414   ASSERT_OOPS_ALLOWED;

   415   jniCheck::validate_jmethod_id(thr, method_id);

   416   jniCheck::validate_object(thr, obj);

   417 }

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

   420   /* validate the class being passed */

   421   ASSERT_OOPS_ALLOWED;

   422   jniCheck::validate_jmethod_id(thr, method_id);

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

   424 }

   427 /*

   428  * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE

   429  */

   431 JNI_ENTRY_CHECKED(jclass,

   432   checked_jni_DefineClass(JNIEnv *env,

   433                           const char *name,

   434                           jobject loader,

   435                           const jbyte *buf,

   436                           jsize len))

   437     functionEnter(thr);

   438     IN_VM(

   439       jniCheck::validate_object(thr, loader);

   440     )

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

   442     functionExit(env);

   443     return result;

   444 JNI_END

   446 JNI_ENTRY_CHECKED(jclass,

   447   checked_jni_FindClass(JNIEnv *env,

   448                         const char *name))

   449     functionEnter(thr);

   450     IN_VM(

   451       jniCheck::validate_class_descriptor(thr, name);

   452     )

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

   454     functionExit(env);

   455     return result;

   456 JNI_END

   458 JNI_ENTRY_CHECKED(jmethodID,

   459   checked_jni_FromReflectedMethod(JNIEnv *env,

   460                                   jobject method))

   461     functionEnter(thr);

   462     IN_VM(

   463       jniCheck::validate_object(thr, method);

   464     )

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

   466     functionExit(env);

   467     return result;

   468 JNI_END

   470 JNI_ENTRY_CHECKED(jfieldID,

   471   checked_jni_FromReflectedField(JNIEnv *env,

   472                                  jobject field))

   473     functionEnter(thr);

   474     IN_VM(

   475       jniCheck::validate_object(thr, field);

   476     )

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

   478     functionExit(env);

   479     return result;

   480 JNI_END

   482 JNI_ENTRY_CHECKED(jobject,

   483   checked_jni_ToReflectedMethod(JNIEnv *env,

   484                                 jclass cls,

   485                                 jmethodID methodID,

   486                                 jboolean isStatic))

   487     functionEnter(thr);

   488     IN_VM(

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

   490       jniCheck::validate_jmethod_id(thr, methodID);

   491     )

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

   493                                                     isStatic);

   494     functionExit(env);

   495     return result;

   496 JNI_END

   498 JNI_ENTRY_CHECKED(jclass,

   499   checked_jni_GetSuperclass(JNIEnv *env,

   500                             jclass sub))

   501     functionEnter(thr);

   502     IN_VM(

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

   504     )

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

   506     functionExit(env);

   507     return result;

   508 JNI_END

   510 JNI_ENTRY_CHECKED(jboolean,

   511   checked_jni_IsAssignableFrom(JNIEnv *env,

   512                                jclass sub,

   513                                jclass sup))

   514     functionEnter(thr);

   515     IN_VM(

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

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

   518     )

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

   520     functionExit(env);

   521     return result;

   522 JNI_END

   524 JNI_ENTRY_CHECKED(jobject,

   525   checked_jni_ToReflectedField(JNIEnv *env,

   526                                jclass cls,

   527                                jfieldID fieldID,

   528                                jboolean isStatic))

   529     functionEnter(thr);

   530     IN_VM(

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

   532     )

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

   534                                                    isStatic);

   535     functionExit(env);

   536     return result;

   537 JNI_END

   539 JNI_ENTRY_CHECKED(jint,

   540   checked_jni_Throw(JNIEnv *env,

   541                     jthrowable obj))

   542     functionEnter(thr);

   543     IN_VM(

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

   545       if (oopObj == NULL) {

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

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

   548       } else {

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

   550       }

   551     )

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

   553     functionExit(env);

   554     return result;

   555 JNI_END

   557 JNI_ENTRY_CHECKED(jint,

   558   checked_jni_ThrowNew(JNIEnv *env,

   559                        jclass clazz,

   560                        const char *msg))

   561     functionEnter(thr);

   562     IN_VM(

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

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

   565       jniCheck::validate_throwable_klass(thr, k);

   566     )

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

   568     functionExit(env);

   569     return result;

   570 JNI_END

   572 JNI_ENTRY_CHECKED(jthrowable,

   573   checked_jni_ExceptionOccurred(JNIEnv *env))

   574     functionEnterExceptionAllowed(thr);

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

   576     functionExit(env);

   577     return result;

   578 JNI_END

   580 JNI_ENTRY_CHECKED(void,

   581   checked_jni_ExceptionDescribe(JNIEnv *env))

   582     functionEnterExceptionAllowed(thr);

   583     UNCHECKED()->ExceptionDescribe(env);

   584     functionExit(env);

   585 JNI_END

   587 JNI_ENTRY_CHECKED(void,

   588   checked_jni_ExceptionClear(JNIEnv *env))

   589     functionEnterExceptionAllowed(thr);

   590     UNCHECKED()->ExceptionClear(env);

   591     functionExit(env);

   592 JNI_END

   594 JNI_ENTRY_CHECKED(void,

   595   checked_jni_FatalError(JNIEnv *env,

   596                          const char *msg))

   597     functionEnter(thr);

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

   599     functionExit(env);

   600 JNI_END

   602 JNI_ENTRY_CHECKED(jint,

   603   checked_jni_PushLocalFrame(JNIEnv *env,

   604                              jint capacity))

   605     functionEnterExceptionAllowed(thr);

   606     if (capacity < 0)

   607       NativeReportJNIFatalError(thr, "negative capacity");

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

   609     functionExit(env);

   610     return result;

   611 JNI_END

   613 JNI_ENTRY_CHECKED(jobject,

   614   checked_jni_PopLocalFrame(JNIEnv *env,

   615                             jobject result))

   616     functionEnterExceptionAllowed(thr);

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

   618     functionExit(env);

   619     return res;

   620 JNI_END

   622 JNI_ENTRY_CHECKED(jobject,

   623   checked_jni_NewGlobalRef(JNIEnv *env,

   624                            jobject lobj))

   625     functionEnter(thr);

   626     IN_VM(

   627       if (lobj != NULL) {

   628         jniCheck::validate_handle(thr, lobj);

   629       }

   630     )

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

   632     functionExit(env);

   633     return result;

   634 JNI_END

   636 JNI_ENTRY_CHECKED(void,

   637   checked_jni_DeleteGlobalRef(JNIEnv *env,

   638                               jobject gref))

   639     functionEnterExceptionAllowed(thr);

   640     IN_VM(

   641       jniCheck::validate_object(thr, gref);

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

   643         ReportJNIFatalError(thr,

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

   645       }

   646     )

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

   648     functionExit(env);

   649 JNI_END

   651 JNI_ENTRY_CHECKED(void,

   652   checked_jni_DeleteLocalRef(JNIEnv *env,

   653                              jobject obj))

   654     functionEnterExceptionAllowed(thr);

   655     IN_VM(

   656       jniCheck::validate_object(thr, obj);

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

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

   659         ReportJNIFatalError(thr,

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

   661     )

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

   663     functionExit(env);

   664 JNI_END

   666 JNI_ENTRY_CHECKED(jboolean,

   667   checked_jni_IsSameObject(JNIEnv *env,

   668                            jobject obj1,

   669                            jobject obj2))

   670     functionEnterExceptionAllowed(thr);

   671     IN_VM(

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

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

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

   675        */

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

   677         jniCheck::validate_object(thr, obj1);

   678       }

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

   680         jniCheck::validate_object(thr, obj2);

   681       }

   682     )

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

   684     functionExit(env);

   685     return result;

   686 JNI_END

   688 JNI_ENTRY_CHECKED(jobject,

   689   checked_jni_NewLocalRef(JNIEnv *env,

   690                           jobject ref))

   691     functionEnter(thr);

   692     IN_VM(

   693       if (ref != NULL) {

   694         jniCheck::validate_handle(thr, ref);

   695       }

   696     )

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

   698     functionExit(env);

   699     return result;

   700 JNI_END

   702 JNI_ENTRY_CHECKED(jint,

   703   checked_jni_EnsureLocalCapacity(JNIEnv *env,

   704                                   jint capacity))

   705     functionEnter(thr);

   706     if (capacity < 0) {

   707       NativeReportJNIFatalError(thr, "negative capacity");

   708     }

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

   710     functionExit(env);

   711     return result;

   712 JNI_END

   714 JNI_ENTRY_CHECKED(jobject,

   715   checked_jni_AllocObject(JNIEnv *env,

   716                           jclass clazz))

   717     functionEnter(thr);

   718     IN_VM(

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

   720     )

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

   722     functionExit(env);

   723     return result;

   724 JNI_END

   726 JNI_ENTRY_CHECKED(jobject,

   727   checked_jni_NewObject(JNIEnv *env,

   728                         jclass clazz,

   729                         jmethodID methodID,

   730                         ...))

   731     functionEnter(thr);

   732     va_list args;

   733     IN_VM(

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

   735       jniCheck::validate_jmethod_id(thr, methodID);

   736     )

   737     va_start(args, methodID);

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

   739     va_end(args);

   740     functionExit(env);

   741     return result;

   742 JNI_END

   744 JNI_ENTRY_CHECKED(jobject,

   745   checked_jni_NewObjectV(JNIEnv *env,

   746                          jclass clazz,

   747                          jmethodID methodID,

   748                          va_list args))

   749     functionEnter(thr);

   750     IN_VM(

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

   752       jniCheck::validate_jmethod_id(thr, methodID);

   753     )

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

   755     functionExit(env);

   756     return result;

   757 JNI_END

   759 JNI_ENTRY_CHECKED(jobject,

   760   checked_jni_NewObjectA(JNIEnv *env,

   761                          jclass clazz,

   762                          jmethodID methodID,

   763                          const jvalue *args))

   764     functionEnter(thr);

   765     IN_VM(

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

   767       jniCheck::validate_jmethod_id(thr, methodID);

   768     )

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

   770     functionExit(env);

   771     return result;

   772 JNI_END

   774 JNI_ENTRY_CHECKED(jclass,

   775   checked_jni_GetObjectClass(JNIEnv *env,

   776                              jobject obj))

   777     functionEnter(thr);

   778     IN_VM(

   779       jniCheck::validate_object(thr, obj);

   780     )

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

   782     functionExit(env);

   783     return result;

   784 JNI_END

   786 JNI_ENTRY_CHECKED(jboolean,

   787   checked_jni_IsInstanceOf(JNIEnv *env,

   788                            jobject obj,

   789                            jclass clazz))

   790     functionEnter(thr);

   791     IN_VM(

   792       jniCheck::validate_object(thr, obj);

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

   794     )

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

   796     functionExit(env);

   797     return result;

   798 JNI_END

   800 JNI_ENTRY_CHECKED(jmethodID,

   801   checked_jni_GetMethodID(JNIEnv *env,

   802                           jclass clazz,

   803                           const char *name,

   804                           const char *sig))

   805     functionEnter(thr);

   806     IN_VM(

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

   808     )

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

   810     functionExit(env);

   811     return result;

   812 JNI_END

   814 #define WRAPPER_CallMethod(ResultType, Result) \

   815 JNI_ENTRY_CHECKED(ResultType,  \

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

   817                                    jobject obj, \

   818                                    jmethodID methodID, \

   819                                    ...)) \

   820     functionEnter(thr); \

   821     va_list args; \

   822     IN_VM( \

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

   824     ) \

   825     va_start(args,methodID); \

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

   827                                                           args); \

   828     va_end(args); \

   829     functionExit(env); \

   830     return result; \

   831 JNI_END \

   832 \

   833 JNI_ENTRY_CHECKED(ResultType,  \

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

   835                                     jobject obj, \

   836                                     jmethodID methodID, \

   837                                     va_list args)) \

   838     functionEnter(thr); \

   839     IN_VM(\

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

   841     ) \

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

   843                                                            args); \

   844     functionExit(env); \

   845     return result; \

   846 JNI_END \

   847 \

   848 JNI_ENTRY_CHECKED(ResultType,  \

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

   850                                     jobject obj, \

   851                                     jmethodID methodID, \

   852                                     const jvalue * args)) \

   853     functionEnter(thr); \

   854     IN_VM( \

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

   856     ) \

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

   858                                                            args); \

   859     functionExit(env); \

   860     return result; \

   861 JNI_END

   863 WRAPPER_CallMethod(jobject,Object)

   864 WRAPPER_CallMethod(jboolean,Boolean)

   865 WRAPPER_CallMethod(jbyte,Byte)

   866 WRAPPER_CallMethod(jshort,Short)

   867 WRAPPER_CallMethod(jchar,Char)

   868 WRAPPER_CallMethod(jint,Int)

   869 WRAPPER_CallMethod(jlong,Long)

   870 WRAPPER_CallMethod(jfloat,Float)

   871 WRAPPER_CallMethod(jdouble,Double)

   873 JNI_ENTRY_CHECKED(void,

   874   checked_jni_CallVoidMethod(JNIEnv *env, \

   875                              jobject obj, \

   876                              jmethodID methodID, \

   877                              ...))

   878     functionEnter(thr);

   879     va_list args;

   880     IN_VM(

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

   882     )

   883     va_start(args,methodID);

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

   885     va_end(args);

   886     functionExit(env);

   887 JNI_END

   889 JNI_ENTRY_CHECKED(void,

   890   checked_jni_CallVoidMethodV(JNIEnv *env,

   891                               jobject obj,

   892                               jmethodID methodID,

   893                               va_list args))

   894     functionEnter(thr);

   895     IN_VM(

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

   897     )

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

   899     functionExit(env);

   900 JNI_END

   902 JNI_ENTRY_CHECKED(void,

   903   checked_jni_CallVoidMethodA(JNIEnv *env,

   904                               jobject obj,

   905                               jmethodID methodID,

   906                               const jvalue * args))

   907     functionEnter(thr);

   908     IN_VM(

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

   910     )

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

   912     functionExit(env);

   913 JNI_END

   915 #define WRAPPER_CallNonvirtualMethod(ResultType, Result) \

   916 JNI_ENTRY_CHECKED(ResultType,  \

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

   918                                              jobject obj, \

   919                                              jclass clazz, \

   920                                              jmethodID methodID, \

   921                                              ...)) \

   922     functionEnter(thr); \

   923     va_list args; \

   924     IN_VM( \

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

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

   927     ) \

   928     va_start(args,methodID); \

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

   930                                                                      obj, \

   931                                                                      clazz, \

   932                                                                      methodID,\

   933                                                                      args); \

   934     va_end(args); \

   935     functionExit(env); \

   936     return result; \

   937 JNI_END \

   938 \

   939 JNI_ENTRY_CHECKED(ResultType,  \

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

   941                                               jobject obj, \

   942                                               jclass clazz, \

   943                                               jmethodID methodID, \

   944                                               va_list args)) \

   945     functionEnter(thr); \

   946     IN_VM( \

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

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

   949     ) \

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

   951                                                                      obj, \

   952                                                                      clazz, \

   953                                                                      methodID,\

   954                                                                      args); \

   955     functionExit(env); \

   956     return result; \

   957 JNI_END \

   958 \

   959 JNI_ENTRY_CHECKED(ResultType,  \

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

   961                                               jobject obj, \

   962                                               jclass clazz, \

   963                                               jmethodID methodID, \

   964                                               const jvalue * args)) \

   965     functionEnter(thr); \

   966     IN_VM( \

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

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

   969     ) \

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

   971                                                                      obj, \

   972                                                                      clazz, \

   973                                                                      methodID,\

   974                                                                      args); \

   975     functionExit(env); \

   976     return result; \

   977 JNI_END

   979 WRAPPER_CallNonvirtualMethod(jobject,Object)

   980 WRAPPER_CallNonvirtualMethod(jboolean,Boolean)

   981 WRAPPER_CallNonvirtualMethod(jbyte,Byte)

   982 WRAPPER_CallNonvirtualMethod(jshort,Short)

   983 WRAPPER_CallNonvirtualMethod(jchar,Char)

   984 WRAPPER_CallNonvirtualMethod(jint,Int)

   985 WRAPPER_CallNonvirtualMethod(jlong,Long)

   986 WRAPPER_CallNonvirtualMethod(jfloat,Float)

   987 WRAPPER_CallNonvirtualMethod(jdouble,Double)

   989 JNI_ENTRY_CHECKED(void,

   990   checked_jni_CallNonvirtualVoidMethod(JNIEnv *env,

   991                                        jobject obj,

   992                                        jclass clazz,

   993                                        jmethodID methodID,

   994                                        ...))

   995     functionEnter(thr);

   996     va_list args;

   997     IN_VM(

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

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

  1000     )

  1001     va_start(args,methodID);

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

  1003     va_end(args);

  1004     functionExit(env);

  1005 JNI_END

  1007 JNI_ENTRY_CHECKED(void,

  1008   checked_jni_CallNonvirtualVoidMethodV(JNIEnv *env,

  1009                                         jobject obj,

  1010                                         jclass clazz,

  1011                                         jmethodID methodID,

  1012                                         va_list args))

  1013     functionEnter(thr);

  1014     IN_VM(

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

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

  1017     )

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

  1019     functionExit(env);

  1020 JNI_END

  1022 JNI_ENTRY_CHECKED(void,

  1023   checked_jni_CallNonvirtualVoidMethodA(JNIEnv *env,

  1024                                         jobject obj,

  1025                                         jclass clazz,

  1026                                         jmethodID methodID,

  1027                                         const jvalue * args))

  1028     functionEnter(thr);

  1029     IN_VM(

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

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

  1032     )

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

  1034     functionExit(env);

  1035 JNI_END

  1037 JNI_ENTRY_CHECKED(jfieldID,

  1038   checked_jni_GetFieldID(JNIEnv *env,

  1039                          jclass clazz,

  1040                          const char *name,

  1041                          const char *sig))

  1042     functionEnter(thr);

  1043     IN_VM(

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

  1045     )

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

  1047     functionExit(env);

  1048     return result;

  1049 JNI_END

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

  1052 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1054                                  jobject obj, \

  1055                                  jfieldID fieldID)) \

  1056     functionEnter(thr); \

  1057     IN_VM( \

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

  1059     ) \

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

  1061     functionExit(env); \

  1062     return result; \

  1063 JNI_END

  1065 WRAPPER_GetField(jobject,  Object,  T_OBJECT)

  1066 WRAPPER_GetField(jboolean, Boolean, T_BOOLEAN)

  1067 WRAPPER_GetField(jbyte,    Byte,    T_BYTE)

  1068 WRAPPER_GetField(jshort,   Short,   T_SHORT)

  1069 WRAPPER_GetField(jchar,    Char,    T_CHAR)

  1070 WRAPPER_GetField(jint,     Int,     T_INT)

  1071 WRAPPER_GetField(jlong,    Long,    T_LONG)

  1072 WRAPPER_GetField(jfloat,   Float,   T_FLOAT)

  1073 WRAPPER_GetField(jdouble,  Double,  T_DOUBLE)

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

  1076 JNI_ENTRY_CHECKED(void,  \

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

  1078                                  jobject obj, \

  1079                                  jfieldID fieldID, \

  1080                                  ValueType val)) \

  1081     functionEnter(thr); \

  1082     IN_VM( \

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

  1084     ) \

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

  1086     functionExit(env); \

  1087 JNI_END

  1089 WRAPPER_SetField(jobject,  Object,  T_OBJECT)

  1090 WRAPPER_SetField(jboolean, Boolean, T_BOOLEAN)

  1091 WRAPPER_SetField(jbyte,    Byte,    T_BYTE)

  1092 WRAPPER_SetField(jshort,   Short,   T_SHORT)

  1093 WRAPPER_SetField(jchar,    Char,    T_CHAR)

  1094 WRAPPER_SetField(jint,     Int,     T_INT)

  1095 WRAPPER_SetField(jlong,    Long,    T_LONG)

  1096 WRAPPER_SetField(jfloat,   Float,   T_FLOAT)

  1097 WRAPPER_SetField(jdouble,  Double,  T_DOUBLE)

  1100 JNI_ENTRY_CHECKED(jmethodID,

  1101   checked_jni_GetStaticMethodID(JNIEnv *env,

  1102                                 jclass clazz,

  1103                                 const char *name,

  1104                                 const char *sig))

  1105     functionEnter(thr);

  1106     IN_VM(

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

  1108     )

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

  1110     functionExit(env);

  1111     return result;

  1112 JNI_END

  1114 #define WRAPPER_CallStaticMethod(ReturnType,Result) \

  1115 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1117                                          jclass clazz, \

  1118                                          jmethodID methodID, \

  1119                                          ...)) \

  1120     functionEnter(thr); \

  1121     va_list args; \

  1122     IN_VM( \

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

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

  1125     ) \

  1126     va_start(args,methodID); \

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

  1128                                                                  clazz, \

  1129                                                                  methodID, \

  1130                                                                  args); \

  1131     va_end(args); \

  1132     functionExit(env); \

  1133     return result; \

  1134 JNI_END \

  1135 \

  1136 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1138                                           jclass clazz, \

  1139                                           jmethodID methodID,\

  1140                                           va_list args)) \

  1141     functionEnter(thr); \

  1142     IN_VM( \

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

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

  1145     ) \

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

  1147                                                                  clazz, \

  1148                                                                  methodID, \

  1149                                                                  args); \

  1150     functionExit(env); \

  1151     return result; \

  1152 JNI_END \

  1153 \

  1154 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1156                                           jclass clazz, \

  1157                                           jmethodID methodID, \

  1158                                           const jvalue *args)) \

  1159     functionEnter(thr); \

  1160     IN_VM( \

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

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

  1163     ) \

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

  1165                                                                  clazz, \

  1166                                                                  methodID, \

  1167                                                                  args); \

  1168     functionExit(env); \

  1169     return result; \

  1170 JNI_END

  1172 WRAPPER_CallStaticMethod(jobject,Object)

  1173 WRAPPER_CallStaticMethod(jboolean,Boolean)

  1174 WRAPPER_CallStaticMethod(jbyte,Byte)

  1175 WRAPPER_CallStaticMethod(jshort,Short)

  1176 WRAPPER_CallStaticMethod(jchar,Char)

  1177 WRAPPER_CallStaticMethod(jint,Int)

  1178 WRAPPER_CallStaticMethod(jlong,Long)

  1179 WRAPPER_CallStaticMethod(jfloat,Float)

  1180 WRAPPER_CallStaticMethod(jdouble,Double)

  1182 JNI_ENTRY_CHECKED(void,

  1183   checked_jni_CallStaticVoidMethod(JNIEnv *env,

  1184                                    jclass cls,

  1185                                    jmethodID methodID,

  1186                                    ...))

  1187     functionEnter(thr);

  1188     va_list args;

  1189     IN_VM(

  1190       jniCheck::validate_jmethod_id(thr, methodID);

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

  1192     )

  1193     va_start(args,methodID);

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

  1195     va_end(args);

  1196     functionExit(env);

  1197 JNI_END

  1199 JNI_ENTRY_CHECKED(void,

  1200   checked_jni_CallStaticVoidMethodV(JNIEnv *env,

  1201                                     jclass cls,

  1202                                     jmethodID methodID,

  1203                                     va_list args))

  1204     functionEnter(thr);

  1205     IN_VM(

  1206       jniCheck::validate_jmethod_id(thr, methodID);

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

  1208     )

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

  1210     functionExit(env);

  1211 JNI_END

  1213 JNI_ENTRY_CHECKED(void,

  1214   checked_jni_CallStaticVoidMethodA(JNIEnv *env,

  1215                                     jclass cls,

  1216                                     jmethodID methodID,

  1217                                     const jvalue * args))

  1218     functionEnter(thr);

  1219     IN_VM(

  1220       jniCheck::validate_jmethod_id(thr, methodID);

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

  1222     )

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

  1224     functionExit(env);

  1225 JNI_END

  1227 JNI_ENTRY_CHECKED(jfieldID,

  1228   checked_jni_GetStaticFieldID(JNIEnv *env,

  1229                                jclass clazz,

  1230                                const char *name,

  1231                                const char *sig))

  1232     functionEnter(thr);

  1233     IN_VM(

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

  1235     )

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

  1237     functionExit(env);

  1238     return result;

  1239 JNI_END

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

  1242 JNI_ENTRY_CHECKED(ReturnType,  \

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

  1244                                        jclass clazz, \

  1245                                        jfieldID fieldID)) \

  1246     functionEnter(thr); \

  1247     IN_VM( \

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

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

  1250     ) \

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

  1252                                                               clazz, \

  1253                                                               fieldID); \

  1254     functionExit(env); \

  1255     return result; \

  1256 JNI_END

  1258 WRAPPER_GetStaticField(jobject,  Object,  T_OBJECT)

  1259 WRAPPER_GetStaticField(jboolean, Boolean, T_BOOLEAN)

  1260 WRAPPER_GetStaticField(jbyte,    Byte,    T_BYTE)

  1261 WRAPPER_GetStaticField(jshort,   Short,   T_SHORT)

  1262 WRAPPER_GetStaticField(jchar,    Char,    T_CHAR)

  1263 WRAPPER_GetStaticField(jint,     Int,     T_INT)

  1264 WRAPPER_GetStaticField(jlong,    Long,    T_LONG)

  1265 WRAPPER_GetStaticField(jfloat,   Float,   T_FLOAT)

  1266 WRAPPER_GetStaticField(jdouble,  Double,  T_DOUBLE)

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

  1269 JNI_ENTRY_CHECKED(void,  \

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

  1271                                        jclass clazz, \

  1272                                        jfieldID fieldID, \

  1273                                        ValueType value)) \

  1274     functionEnter(thr); \

  1275     IN_VM( \

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

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

  1278     ) \

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

  1280     functionExit(env); \

  1281 JNI_END

  1283 WRAPPER_SetStaticField(jobject,  Object,  T_OBJECT)

  1284 WRAPPER_SetStaticField(jboolean, Boolean, T_BOOLEAN)

  1285 WRAPPER_SetStaticField(jbyte,    Byte,    T_BYTE)

  1286 WRAPPER_SetStaticField(jshort,   Short,   T_SHORT)

  1287 WRAPPER_SetStaticField(jchar,    Char,    T_CHAR)

  1288 WRAPPER_SetStaticField(jint,     Int,     T_INT)

  1289 WRAPPER_SetStaticField(jlong,    Long,    T_LONG)

  1290 WRAPPER_SetStaticField(jfloat,   Float,   T_FLOAT)

  1291 WRAPPER_SetStaticField(jdouble,  Double,  T_DOUBLE)

  1294 JNI_ENTRY_CHECKED(jstring,

  1295   checked_jni_NewString(JNIEnv *env,

  1296                         const jchar *unicode,

  1297                         jsize len))

  1298     functionEnter(thr);

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

  1300     functionExit(env);

  1301     return result;

  1302 JNI_END

  1304 JNI_ENTRY_CHECKED(jsize,

  1305   checked_jni_GetStringLength(JNIEnv *env,

  1306                               jstring str))

  1307     functionEnter(thr);

  1308     IN_VM(

  1309       checkString(thr, str);

  1310     )

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

  1312     functionExit(env);

  1313     return result;

  1314 JNI_END

  1316 // Arbitrary (but well-known) tag

  1317 const jint STRING_TAG = 0x47114711;

  1319 JNI_ENTRY_CHECKED(const jchar *,

  1320   checked_jni_GetStringChars(JNIEnv *env,

  1321                              jstring str,

  1322                              jboolean *isCopy))

  1323     functionEnter(thr);

  1324     IN_VM(

  1325       checkString(thr, str);

  1326     )

  1327     jchar* newResult = NULL;

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

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

  1330     if (result != NULL) {

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

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

  1333       *tagLocation = STRING_TAG;

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

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

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

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

  1338       FreeHeap((char*)result);

  1339     }

  1340     functionExit(env);

  1341     return newResult;

  1342 JNI_END

  1344 JNI_ENTRY_CHECKED(void,

  1345   checked_jni_ReleaseStringChars(JNIEnv *env,

  1346                                  jstring str,

  1347                                  const jchar *chars))

  1348     functionEnterExceptionAllowed(thr);

  1349     IN_VM(

  1350       checkString(thr, str);

  1351     )

  1352     if (chars == NULL) {

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

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

  1355     }

  1356     else {

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

  1358        if (*tagLocation != STRING_TAG) {

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

  1360        }

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

  1362     }

  1363     functionExit(env);

  1364 JNI_END

  1366 JNI_ENTRY_CHECKED(jstring,

  1367   checked_jni_NewStringUTF(JNIEnv *env,

  1368                            const char *utf))

  1369     functionEnter(thr);

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

  1371     functionExit(env);

  1372     return result;

  1373 JNI_END

  1375 JNI_ENTRY_CHECKED(jsize,

  1376   checked_jni_GetStringUTFLength(JNIEnv *env,

  1377                                  jstring str))

  1378     functionEnter(thr);

  1379     IN_VM(

  1380       checkString(thr, str);

  1381     )

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

  1383     functionExit(env);

  1384     return result;

  1385 JNI_END

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

  1388 const jint STRING_UTF_TAG = 0x48124812;

  1390 JNI_ENTRY_CHECKED(const char *,

  1391   checked_jni_GetStringUTFChars(JNIEnv *env,

  1392                                 jstring str,

  1393                                 jboolean *isCopy))

  1394     functionEnter(thr);

  1395     IN_VM(

  1396       checkString(thr, str);

  1397     )

  1398     char* newResult = NULL;

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

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

  1401     if (result != NULL) {

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

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

  1404       *tagLocation = STRING_UTF_TAG;

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

  1406       strcpy(newResult, result);

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

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

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

  1410     }

  1411     functionExit(env);

  1412     return newResult;

  1413 JNI_END

  1415 JNI_ENTRY_CHECKED(void,

  1416   checked_jni_ReleaseStringUTFChars(JNIEnv *env,

  1417                                     jstring str,

  1418                                     const char* chars))

  1419     functionEnterExceptionAllowed(thr);

  1420     IN_VM(

  1421       checkString(thr, str);

  1422     )

  1423     if (chars == NULL) {

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

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

  1426     }

  1427     else {

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

  1429        if (*tagLocation != STRING_UTF_TAG) {

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

  1431        }

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

  1433     }

  1434     functionExit(env);

  1435 JNI_END

  1437 JNI_ENTRY_CHECKED(jsize,

  1438   checked_jni_GetArrayLength(JNIEnv *env,

  1439                              jarray array))

  1440     functionEnter(thr);

  1441     IN_VM(

  1442       check_is_array(thr, array);

  1443     )

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

  1445     functionExit(env);

  1446     return result;

  1447 JNI_END

  1449 JNI_ENTRY_CHECKED(jobjectArray,

  1450   checked_jni_NewObjectArray(JNIEnv *env,

  1451                              jsize len,

  1452                              jclass clazz,

  1453                              jobject init))

  1454     functionEnter(thr);

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

  1456     functionExit(env);

  1457     return result;

  1458 JNI_END

  1460 JNI_ENTRY_CHECKED(jobject,

  1461   checked_jni_GetObjectArrayElement(JNIEnv *env,

  1462                                     jobjectArray array,

  1463                                     jsize index))

  1464     functionEnter(thr);

  1465     IN_VM(

  1466       check_is_obj_array(thr, array);

  1467     )

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

  1469     functionExit(env);

  1470     return result;

  1471 JNI_END

  1473 JNI_ENTRY_CHECKED(void,

  1474   checked_jni_SetObjectArrayElement(JNIEnv *env,

  1475                                     jobjectArray array,

  1476                                     jsize index,

  1477                                     jobject val))

  1478     functionEnter(thr);

  1479     IN_VM(

  1480       check_is_obj_array(thr, array);

  1481     )

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

  1483     functionExit(env);

  1484 JNI_END

  1486 #define WRAPPER_NewScalarArray(Return, Result) \

  1487 JNI_ENTRY_CHECKED(Return, \

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

  1489                                  jsize len)) \

  1490     functionEnter(thr); \

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

  1492     functionExit(env); \

  1493     return (Return) result; \

  1494 JNI_END

  1496 WRAPPER_NewScalarArray(jbooleanArray, Boolean)

  1497 WRAPPER_NewScalarArray(jbyteArray, Byte)

  1498 WRAPPER_NewScalarArray(jshortArray, Short)

  1499 WRAPPER_NewScalarArray(jcharArray, Char)

  1500 WRAPPER_NewScalarArray(jintArray, Int)

  1501 WRAPPER_NewScalarArray(jlongArray, Long)

  1502 WRAPPER_NewScalarArray(jfloatArray, Float)

  1503 WRAPPER_NewScalarArray(jdoubleArray, Double)

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

  1506 JNI_ENTRY_CHECKED(ElementType *,  \

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

  1508                                          ElementType##Array array, \

  1509                                          jboolean *isCopy)) \

  1510     functionEnter(thr); \

  1511     IN_VM( \

  1512       check_primitive_array_type(thr, array, ElementTag); \

  1513     ) \

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

  1515                                                                   array, \

  1516                                                                   isCopy); \

  1517     functionExit(env); \

  1518     return result; \

  1519 JNI_END

  1521 WRAPPER_GetScalarArrayElements(T_BOOLEAN, jboolean, Boolean)

  1522 WRAPPER_GetScalarArrayElements(T_BYTE,    jbyte,    Byte)

  1523 WRAPPER_GetScalarArrayElements(T_SHORT,   jshort,   Short)

  1524 WRAPPER_GetScalarArrayElements(T_CHAR,    jchar,    Char)

  1525 WRAPPER_GetScalarArrayElements(T_INT,     jint,     Int)

  1526 WRAPPER_GetScalarArrayElements(T_LONG,    jlong,    Long)

  1527 WRAPPER_GetScalarArrayElements(T_FLOAT,   jfloat,   Float)

  1528 WRAPPER_GetScalarArrayElements(T_DOUBLE,  jdouble,  Double)

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

  1531 JNI_ENTRY_CHECKED(void,  \

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

  1533                                              ElementType##Array array, \

  1534                                              ElementType *elems, \

  1535                                              jint mode)) \

  1536     functionEnterExceptionAllowed(thr); \

  1537     IN_VM( \

  1538       check_primitive_array_type(thr, array, ElementTag); \

  1539       ASSERT_OOPS_ALLOWED; \

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

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

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

  1543        * subsequent release.

  1544        */ \

  1545     ) \

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

  1547     functionExit(env); \

  1548 JNI_END

  1550 WRAPPER_ReleaseScalarArrayElements(T_BOOLEAN,jboolean, Boolean, bool)

  1551 WRAPPER_ReleaseScalarArrayElements(T_BYTE,   jbyte,    Byte,    byte)

  1552 WRAPPER_ReleaseScalarArrayElements(T_SHORT,  jshort,   Short,   short)

  1553 WRAPPER_ReleaseScalarArrayElements(T_CHAR,   jchar,    Char,    char)

  1554 WRAPPER_ReleaseScalarArrayElements(T_INT,    jint,     Int,     int)

  1555 WRAPPER_ReleaseScalarArrayElements(T_LONG,   jlong,    Long,    long)

  1556 WRAPPER_ReleaseScalarArrayElements(T_FLOAT,  jfloat,   Float,   float)

  1557 WRAPPER_ReleaseScalarArrayElements(T_DOUBLE, jdouble,  Double,  double)

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

  1560 JNI_ENTRY_CHECKED(void,  \

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

  1562                                        ElementType##Array array, \

  1563                                        jsize start, \

  1564                                        jsize len, \

  1565                                        ElementType *buf)) \

  1566     functionEnter(thr); \

  1567     IN_VM( \

  1568       check_primitive_array_type(thr, array, ElementTag); \

  1569     ) \

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

  1571     functionExit(env); \

  1572 JNI_END

  1574 WRAPPER_GetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)

  1575 WRAPPER_GetScalarArrayRegion(T_BYTE,    jbyte,    Byte)

  1576 WRAPPER_GetScalarArrayRegion(T_SHORT,   jshort,   Short)

  1577 WRAPPER_GetScalarArrayRegion(T_CHAR,    jchar,    Char)

  1578 WRAPPER_GetScalarArrayRegion(T_INT,     jint,     Int)

  1579 WRAPPER_GetScalarArrayRegion(T_LONG,    jlong,    Long)

  1580 WRAPPER_GetScalarArrayRegion(T_FLOAT,   jfloat,   Float)

  1581 WRAPPER_GetScalarArrayRegion(T_DOUBLE,  jdouble,  Double)

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

  1584 JNI_ENTRY_CHECKED(void,  \

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

  1586                                        ElementType##Array array, \

  1587                                        jsize start, \

  1588                                        jsize len, \

  1589                                        const ElementType *buf)) \

  1590     functionEnter(thr); \

  1591     IN_VM( \

  1592       check_primitive_array_type(thr, array, ElementTag); \

  1593     ) \

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

  1595     functionExit(env); \

  1596 JNI_END

  1598 WRAPPER_SetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)

  1599 WRAPPER_SetScalarArrayRegion(T_BYTE,    jbyte,    Byte)

  1600 WRAPPER_SetScalarArrayRegion(T_SHORT,   jshort,   Short)

  1601 WRAPPER_SetScalarArrayRegion(T_CHAR,    jchar,    Char)

  1602 WRAPPER_SetScalarArrayRegion(T_INT,     jint,     Int)

  1603 WRAPPER_SetScalarArrayRegion(T_LONG,    jlong,    Long)

  1604 WRAPPER_SetScalarArrayRegion(T_FLOAT,   jfloat,   Float)

  1605 WRAPPER_SetScalarArrayRegion(T_DOUBLE,  jdouble,  Double)

  1607 JNI_ENTRY_CHECKED(jint,

  1608   checked_jni_RegisterNatives(JNIEnv *env,

  1609                               jclass clazz,

  1610                               const JNINativeMethod *methods,

  1611                               jint nMethods))

  1612     functionEnter(thr);

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

  1614     functionExit(env);

  1615     return result;

  1616 JNI_END

  1618 JNI_ENTRY_CHECKED(jint,

  1619   checked_jni_UnregisterNatives(JNIEnv *env,

  1620                                 jclass clazz))

  1621     functionEnter(thr);

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

  1623     functionExit(env);

  1624     return result;

  1625 JNI_END

  1627 JNI_ENTRY_CHECKED(jint,

  1628   checked_jni_MonitorEnter(JNIEnv *env,

  1629                            jobject obj))

  1630     functionEnter(thr);

  1631     IN_VM(

  1632       jniCheck::validate_object(thr, obj);

  1633     )

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

  1635     functionExit(env);

  1636     return result;

  1637 JNI_END

  1639 JNI_ENTRY_CHECKED(jint,

  1640   checked_jni_MonitorExit(JNIEnv *env,

  1641                           jobject obj))

  1642     functionEnterExceptionAllowed(thr);

  1643     IN_VM(

  1644       jniCheck::validate_object(thr, obj);

  1645     )

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

  1647     functionExit(env);

  1648     return result;

  1649 JNI_END

  1651 JNI_ENTRY_CHECKED(jint,

  1652   checked_jni_GetJavaVM(JNIEnv *env,

  1653                         JavaVM **vm))

  1654     functionEnter(thr);

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

  1656     functionExit(env);

  1657     return result;

  1658 JNI_END

  1660 JNI_ENTRY_CHECKED(void,

  1661   checked_jni_GetStringRegion(JNIEnv *env,

  1662                               jstring str,

  1663                               jsize start,

  1664                               jsize len,

  1665                               jchar *buf))

  1666     functionEnter(thr);

  1667     IN_VM(

  1668       checkString(thr, str);

  1669     )

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

  1671     functionExit(env);

  1672 JNI_END

  1674 JNI_ENTRY_CHECKED(void,

  1675   checked_jni_GetStringUTFRegion(JNIEnv *env,

  1676                                  jstring str,

  1677                                  jsize start,

  1678                                  jsize len,

  1679                                  char *buf))

  1680     functionEnter(thr);

  1681     IN_VM(

  1682       checkString(thr, str);

  1683     )

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

  1685     functionExit(env);

  1686 JNI_END

  1688 JNI_ENTRY_CHECKED(void *,

  1689   checked_jni_GetPrimitiveArrayCritical(JNIEnv *env,

  1690                                         jarray array,

  1691                                         jboolean *isCopy))

  1692     functionEnterCritical(thr);

  1693     IN_VM(

  1694       check_is_primitive_array(thr, array);

  1695     )

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

  1697     functionExit(env);

  1698     return result;

  1699 JNI_END

  1701 JNI_ENTRY_CHECKED(void,

  1702   checked_jni_ReleasePrimitiveArrayCritical(JNIEnv *env,

  1703                                             jarray array,

  1704                                             void *carray,

  1705                                             jint mode))

  1706     functionEnterCriticalExceptionAllowed(thr);

  1707     IN_VM(

  1708       check_is_primitive_array(thr, array);

  1709     )

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

  1711      * array parameter as a minor sanity check

  1712      */

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

  1714     functionExit(env);

  1715 JNI_END

  1717 JNI_ENTRY_CHECKED(const jchar*,

  1718   checked_jni_GetStringCritical(JNIEnv *env,

  1719                                 jstring string,

  1720                                 jboolean *isCopy))

  1721     functionEnterCritical(thr);

  1722     IN_VM(

  1723       checkString(thr, string);

  1724     )

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

  1726     functionExit(env);

  1727     return result;

  1728 JNI_END

  1730 JNI_ENTRY_CHECKED(void,

  1731   checked_jni_ReleaseStringCritical(JNIEnv *env,

  1732                                     jstring str,

  1733                                     const jchar *chars))

  1734     functionEnterCriticalExceptionAllowed(thr);

  1735     IN_VM(

  1736       checkString(thr, str);

  1737     )

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

  1739      * string parameter as a minor sanity check

  1740      */

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

  1742     functionExit(env);

  1743 JNI_END

  1745 JNI_ENTRY_CHECKED(jweak,

  1746   checked_jni_NewWeakGlobalRef(JNIEnv *env,

  1747                                jobject obj))

  1748     functionEnter(thr);

  1749     IN_VM(

  1750       if (obj != NULL) {

  1751         jniCheck::validate_handle(thr, obj);

  1752       }

  1753     )

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

  1755     functionExit(env);

  1756     return result;

  1757 JNI_END

  1759 JNI_ENTRY_CHECKED(void,

  1760   checked_jni_DeleteWeakGlobalRef(JNIEnv *env,

  1761                                   jweak ref))

  1762     functionEnterExceptionAllowed(thr);

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

  1764     functionExit(env);

  1765 JNI_END

  1767 JNI_ENTRY_CHECKED(jboolean,

  1768   checked_jni_ExceptionCheck(JNIEnv *env))

  1769     functionEnterExceptionAllowed(thr);

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

  1771     functionExit(env);

  1772     return result;

  1773 JNI_END

  1775 JNI_ENTRY_CHECKED(jobject,

  1776   checked_jni_NewDirectByteBuffer(JNIEnv *env,

  1777                                   void *address,

  1778                                   jlong capacity))

  1779     functionEnter(thr);

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

  1781     functionExit(env);

  1782     return result;

  1783 JNI_END

  1785 JNI_ENTRY_CHECKED(void *,

  1786   checked_jni_GetDirectBufferAddress(JNIEnv *env,

  1787                                      jobject buf))

  1788     functionEnter(thr);

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

  1790     functionExit(env);

  1791     return result;

  1792 JNI_END

  1794 JNI_ENTRY_CHECKED(jlong,

  1795   checked_jni_GetDirectBufferCapacity(JNIEnv *env,

  1796                                       jobject buf))

  1797     functionEnter(thr);

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

  1799     functionExit(env);

  1800     return result;

  1801 JNI_END

  1803 JNI_ENTRY_CHECKED(jobjectRefType,

  1804   checked_jni_GetObjectRefType(JNIEnv *env,

  1805                                jobject obj))

  1806     functionEnter(thr);

  1807     /* validate the object being passed */

  1808     IN_VM(

  1809       jniCheck::validate_object(thr, obj);

  1810     )

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

  1812     functionExit(env);

  1813     return result;

  1814 JNI_END

  1817 JNI_ENTRY_CHECKED(jint,

  1818   checked_jni_GetVersion(JNIEnv *env))

  1819     functionEnter(thr);

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

  1821     functionExit(env);

  1822     return result;

  1823 JNI_END

  1827 /*

  1828  * Structure containing all checked jni functions

  1829  */

  1830 struct JNINativeInterface_  checked_jni_NativeInterface = {

  1831     NULL,

  1832     NULL,

  1833     NULL,

  1835     NULL,

  1837     checked_jni_GetVersion,

  1839     checked_jni_DefineClass,

  1840     checked_jni_FindClass,

  1842     checked_jni_FromReflectedMethod,

  1843     checked_jni_FromReflectedField,

  1845     checked_jni_ToReflectedMethod,

  1847     checked_jni_GetSuperclass,

  1848     checked_jni_IsAssignableFrom,

  1850     checked_jni_ToReflectedField,

  1852     checked_jni_Throw,

  1853     checked_jni_ThrowNew,

  1854     checked_jni_ExceptionOccurred,

  1855     checked_jni_ExceptionDescribe,

  1856     checked_jni_ExceptionClear,

  1857     checked_jni_FatalError,

  1859     checked_jni_PushLocalFrame,

  1860     checked_jni_PopLocalFrame,

  1862     checked_jni_NewGlobalRef,

  1863     checked_jni_DeleteGlobalRef,

  1864     checked_jni_DeleteLocalRef,

  1865     checked_jni_IsSameObject,

  1867     checked_jni_NewLocalRef,

  1868     checked_jni_EnsureLocalCapacity,

  1870     checked_jni_AllocObject,

  1871     checked_jni_NewObject,

  1872     checked_jni_NewObjectV,

  1873     checked_jni_NewObjectA,

  1875     checked_jni_GetObjectClass,

  1876     checked_jni_IsInstanceOf,

  1878     checked_jni_GetMethodID,

  1880     checked_jni_CallObjectMethod,

  1881     checked_jni_CallObjectMethodV,

  1882     checked_jni_CallObjectMethodA,

  1883     checked_jni_CallBooleanMethod,

  1884     checked_jni_CallBooleanMethodV,

  1885     checked_jni_CallBooleanMethodA,

  1886     checked_jni_CallByteMethod,

  1887     checked_jni_CallByteMethodV,

  1888     checked_jni_CallByteMethodA,

  1889     checked_jni_CallCharMethod,

  1890     checked_jni_CallCharMethodV,

  1891     checked_jni_CallCharMethodA,

  1892     checked_jni_CallShortMethod,

  1893     checked_jni_CallShortMethodV,

  1894     checked_jni_CallShortMethodA,

  1895     checked_jni_CallIntMethod,

  1896     checked_jni_CallIntMethodV,

  1897     checked_jni_CallIntMethodA,

  1898     checked_jni_CallLongMethod,

  1899     checked_jni_CallLongMethodV,

  1900     checked_jni_CallLongMethodA,

  1901     checked_jni_CallFloatMethod,

  1902     checked_jni_CallFloatMethodV,

  1903     checked_jni_CallFloatMethodA,

  1904     checked_jni_CallDoubleMethod,

  1905     checked_jni_CallDoubleMethodV,

  1906     checked_jni_CallDoubleMethodA,

  1907     checked_jni_CallVoidMethod,

  1908     checked_jni_CallVoidMethodV,

  1909     checked_jni_CallVoidMethodA,

  1911     checked_jni_CallNonvirtualObjectMethod,

  1912     checked_jni_CallNonvirtualObjectMethodV,

  1913     checked_jni_CallNonvirtualObjectMethodA,

  1914     checked_jni_CallNonvirtualBooleanMethod,

  1915     checked_jni_CallNonvirtualBooleanMethodV,

  1916     checked_jni_CallNonvirtualBooleanMethodA,

  1917     checked_jni_CallNonvirtualByteMethod,

  1918     checked_jni_CallNonvirtualByteMethodV,

  1919     checked_jni_CallNonvirtualByteMethodA,

  1920     checked_jni_CallNonvirtualCharMethod,

  1921     checked_jni_CallNonvirtualCharMethodV,

  1922     checked_jni_CallNonvirtualCharMethodA,

  1923     checked_jni_CallNonvirtualShortMethod,

  1924     checked_jni_CallNonvirtualShortMethodV,

  1925     checked_jni_CallNonvirtualShortMethodA,

  1926     checked_jni_CallNonvirtualIntMethod,

  1927     checked_jni_CallNonvirtualIntMethodV,

  1928     checked_jni_CallNonvirtualIntMethodA,

  1929     checked_jni_CallNonvirtualLongMethod,

  1930     checked_jni_CallNonvirtualLongMethodV,

  1931     checked_jni_CallNonvirtualLongMethodA,

  1932     checked_jni_CallNonvirtualFloatMethod,

  1933     checked_jni_CallNonvirtualFloatMethodV,

  1934     checked_jni_CallNonvirtualFloatMethodA,

  1935     checked_jni_CallNonvirtualDoubleMethod,

  1936     checked_jni_CallNonvirtualDoubleMethodV,

  1937     checked_jni_CallNonvirtualDoubleMethodA,

  1938     checked_jni_CallNonvirtualVoidMethod,

  1939     checked_jni_CallNonvirtualVoidMethodV,

  1940     checked_jni_CallNonvirtualVoidMethodA,

  1942     checked_jni_GetFieldID,

  1944     checked_jni_GetObjectField,

  1945     checked_jni_GetBooleanField,

  1946     checked_jni_GetByteField,

  1947     checked_jni_GetCharField,

  1948     checked_jni_GetShortField,

  1949     checked_jni_GetIntField,

  1950     checked_jni_GetLongField,

  1951     checked_jni_GetFloatField,

  1952     checked_jni_GetDoubleField,

  1954     checked_jni_SetObjectField,

  1955     checked_jni_SetBooleanField,

  1956     checked_jni_SetByteField,

  1957     checked_jni_SetCharField,

  1958     checked_jni_SetShortField,

  1959     checked_jni_SetIntField,

  1960     checked_jni_SetLongField,

  1961     checked_jni_SetFloatField,

  1962     checked_jni_SetDoubleField,

  1964     checked_jni_GetStaticMethodID,

  1966     checked_jni_CallStaticObjectMethod,

  1967     checked_jni_CallStaticObjectMethodV,

  1968     checked_jni_CallStaticObjectMethodA,

  1969     checked_jni_CallStaticBooleanMethod,

  1970     checked_jni_CallStaticBooleanMethodV,

  1971     checked_jni_CallStaticBooleanMethodA,

  1972     checked_jni_CallStaticByteMethod,

  1973     checked_jni_CallStaticByteMethodV,

  1974     checked_jni_CallStaticByteMethodA,

  1975     checked_jni_CallStaticCharMethod,

  1976     checked_jni_CallStaticCharMethodV,

  1977     checked_jni_CallStaticCharMethodA,

  1978     checked_jni_CallStaticShortMethod,

  1979     checked_jni_CallStaticShortMethodV,

  1980     checked_jni_CallStaticShortMethodA,

  1981     checked_jni_CallStaticIntMethod,

  1982     checked_jni_CallStaticIntMethodV,

  1983     checked_jni_CallStaticIntMethodA,

  1984     checked_jni_CallStaticLongMethod,

  1985     checked_jni_CallStaticLongMethodV,

  1986     checked_jni_CallStaticLongMethodA,

  1987     checked_jni_CallStaticFloatMethod,

  1988     checked_jni_CallStaticFloatMethodV,

  1989     checked_jni_CallStaticFloatMethodA,

  1990     checked_jni_CallStaticDoubleMethod,

  1991     checked_jni_CallStaticDoubleMethodV,

  1992     checked_jni_CallStaticDoubleMethodA,

  1993     checked_jni_CallStaticVoidMethod,

  1994     checked_jni_CallStaticVoidMethodV,

  1995     checked_jni_CallStaticVoidMethodA,

  1997     checked_jni_GetStaticFieldID,

  1999     checked_jni_GetStaticObjectField,

  2000     checked_jni_GetStaticBooleanField,

  2001     checked_jni_GetStaticByteField,

  2002     checked_jni_GetStaticCharField,

  2003     checked_jni_GetStaticShortField,

  2004     checked_jni_GetStaticIntField,

  2005     checked_jni_GetStaticLongField,

  2006     checked_jni_GetStaticFloatField,

  2007     checked_jni_GetStaticDoubleField,

  2009     checked_jni_SetStaticObjectField,

  2010     checked_jni_SetStaticBooleanField,

  2011     checked_jni_SetStaticByteField,

  2012     checked_jni_SetStaticCharField,

  2013     checked_jni_SetStaticShortField,

  2014     checked_jni_SetStaticIntField,

  2015     checked_jni_SetStaticLongField,

  2016     checked_jni_SetStaticFloatField,

  2017     checked_jni_SetStaticDoubleField,

  2019     checked_jni_NewString,

  2020     checked_jni_GetStringLength,

  2021     checked_jni_GetStringChars,

  2022     checked_jni_ReleaseStringChars,

  2024     checked_jni_NewStringUTF,

  2025     checked_jni_GetStringUTFLength,

  2026     checked_jni_GetStringUTFChars,

  2027     checked_jni_ReleaseStringUTFChars,

  2029     checked_jni_GetArrayLength,

  2031     checked_jni_NewObjectArray,

  2032     checked_jni_GetObjectArrayElement,

  2033     checked_jni_SetObjectArrayElement,

  2035     checked_jni_NewBooleanArray,

  2036     checked_jni_NewByteArray,

  2037     checked_jni_NewCharArray,

  2038     checked_jni_NewShortArray,

  2039     checked_jni_NewIntArray,

  2040     checked_jni_NewLongArray,

  2041     checked_jni_NewFloatArray,

  2042     checked_jni_NewDoubleArray,

  2044     checked_jni_GetBooleanArrayElements,

  2045     checked_jni_GetByteArrayElements,

  2046     checked_jni_GetCharArrayElements,

  2047     checked_jni_GetShortArrayElements,

  2048     checked_jni_GetIntArrayElements,

  2049     checked_jni_GetLongArrayElements,

  2050     checked_jni_GetFloatArrayElements,

  2051     checked_jni_GetDoubleArrayElements,

  2053     checked_jni_ReleaseBooleanArrayElements,

  2054     checked_jni_ReleaseByteArrayElements,

  2055     checked_jni_ReleaseCharArrayElements,

  2056     checked_jni_ReleaseShortArrayElements,

  2057     checked_jni_ReleaseIntArrayElements,

  2058     checked_jni_ReleaseLongArrayElements,

  2059     checked_jni_ReleaseFloatArrayElements,

  2060     checked_jni_ReleaseDoubleArrayElements,

  2062     checked_jni_GetBooleanArrayRegion,

  2063     checked_jni_GetByteArrayRegion,

  2064     checked_jni_GetCharArrayRegion,

  2065     checked_jni_GetShortArrayRegion,

  2066     checked_jni_GetIntArrayRegion,

  2067     checked_jni_GetLongArrayRegion,

  2068     checked_jni_GetFloatArrayRegion,

  2069     checked_jni_GetDoubleArrayRegion,

  2071     checked_jni_SetBooleanArrayRegion,

  2072     checked_jni_SetByteArrayRegion,

  2073     checked_jni_SetCharArrayRegion,

  2074     checked_jni_SetShortArrayRegion,

  2075     checked_jni_SetIntArrayRegion,

  2076     checked_jni_SetLongArrayRegion,

  2077     checked_jni_SetFloatArrayRegion,

  2078     checked_jni_SetDoubleArrayRegion,

  2080     checked_jni_RegisterNatives,

  2081     checked_jni_UnregisterNatives,

  2083     checked_jni_MonitorEnter,

  2084     checked_jni_MonitorExit,

  2086     checked_jni_GetJavaVM,

  2088     checked_jni_GetStringRegion,

  2089     checked_jni_GetStringUTFRegion,

  2091     checked_jni_GetPrimitiveArrayCritical,

  2092     checked_jni_ReleasePrimitiveArrayCritical,

  2094     checked_jni_GetStringCritical,

  2095     checked_jni_ReleaseStringCritical,

  2097     checked_jni_NewWeakGlobalRef,

  2098     checked_jni_DeleteWeakGlobalRef,

  2100     checked_jni_ExceptionCheck,

  2102     checked_jni_NewDirectByteBuffer,

  2103     checked_jni_GetDirectBufferAddress,

  2104     checked_jni_GetDirectBufferCapacity,

  2106     // New 1.6 Features

  2108     checked_jni_GetObjectRefType

  2109 };

  2112 // Returns the function structure

  2113 struct JNINativeInterface_* jni_functions_check() {

  2115   unchecked_jni_NativeInterface = jni_functions_nocheck();

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

  2118   // an addition to the JNINativeInterface_ structure without initializing

  2119   // it in the checked table.

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

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

  2122   assert(*lastPtr != 0,

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

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

  2126   if (PrintJNIResolving) {

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

  2128                   "validate JNI usage");

  2129   }

  2131   return &checked_jni_NativeInterface;

  2132 }

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

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

src/share/vm/prims/jniCheck.cpp