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  */
  24 
  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.inline.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
  54 
  55 
  56 // Heap objects are allowed to be directly referenced only in VM code,
  57 // not in native code.
  58 
  59 #define ASSERT_OOPS_ALLOWED                                          \
  60     assert(JavaThread::current()->thread_state() == _thread_in_vm,   \
  61            "jniCheck examining oops in bad state.")
  62 
  63 
  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.
  69 
  70 #define IN_VM(source_code)   {                                         \
  71     {                                                                  \
  72       ThreadInVMfromNative __tiv(thr);                                 \
  73       source_code                                                      \
  74     }                                                                  \
  75   }
  76 
  77 
  78 /*
  79  * DECLARATIONS
  80  */
  81 
  82 static struct JNINativeInterface_ * unchecked_jni_NativeInterface;
  83 
  84 
  85 /*
  86  * MACRO DEFINITIONS
  87  */
  88 
  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.
  92 
  93 // Check for thread not attached to VM;  need to catch this before
  94 // assertions in the wrapper routines might fire
  95 
  96 // Check for env being the one value appropriate for this thread.
  97 
  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)
 111 
 112 
 113 #define UNCHECKED() (unchecked_jni_NativeInterface)
 114 
 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";
 142 
 143 
 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 }
 149 
 150 // When in NATIVE state:
 151 static void NativeReportJNIFatalError(JavaThread* thr, const char *msg) {
 152   IN_VM(
 153     ReportJNIFatalError(thr, msg);
 154   )
 155 }
 156 
 157 static void NativeReportJNIWarning(JavaThread* thr, const char *msg) {
 158   IN_VM(
 159     ReportJNIWarning(thr, msg);
 160   )
 161 }
 162 
 163 
 164 
 165 
 166 /*
 167  * SUPPORT FUNCTIONS
 168  */
 169 
 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 }
 177 
 178 static inline void
 179 functionEnterCriticalExceptionAllowed(JavaThread* thr)
 180 {
 181 }
 182 
 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 }
 193 
 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 }
 201 
 202 static inline void
 203 functionExit(JNIEnv *env)
 204 {
 205   /* nothing to do at this time */
 206 }
 207 
 208 static inline void
 209 checkStaticFieldID(JavaThread* thr, jfieldID fid, jclass cls, int ftype)
 210 {
 211   fieldDescriptor fd;
 212 
 213   /* make sure it is a static field */
 214   if (!jfieldIDWorkaround::is_static_jfieldID(fid))
 215     ReportJNIFatalError(thr, fatal_should_be_static);
 216 
 217   /* validate the class being passed */
 218   ASSERT_OOPS_ALLOWED;
 219   Klass* k_oop = jniCheck::validate_class(thr, cls, false);
 220 
 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);
 226 
 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 }
 235 
 236 static inline void
 237 checkInstanceFieldID(JavaThread* thr, jfieldID fid, jobject obj, int ftype)
 238 {
 239   fieldDescriptor fd;
 240 
 241   /* make sure it is an instance field */
 242   if (jfieldIDWorkaround::is_static_jfieldID(fid))
 243     ReportJNIFatalError(thr, fatal_should_be_nonstatic);
 244 
 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();
 252 
 253   if (!jfieldIDWorkaround::is_valid_jfieldID(k_oop, fid)) {
 254     ReportJNIFatalError(thr, fatal_wrong_field);
 255   }
 256 
 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);
 261 
 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);
 266 
 267   if ((fd.field_type() != ftype) &&
 268       !(fd.field_type() == T_ARRAY && ftype == T_OBJECT)) {
 269     ReportJNIFatalError(thr, fatal_instance_field_mismatch);
 270   }
 271 }
 272 
 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 }
 281 
 282 static inline arrayOop
 283 check_is_array(JavaThread* thr, jarray jArray)
 284 {
 285   ASSERT_OOPS_ALLOWED;
 286   arrayOop aOop;
 287 
 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 }
 294 
 295 static inline arrayOop
 296 check_is_primitive_array(JavaThread* thr, jarray jArray) {
 297   arrayOop aOop = check_is_array(thr, jArray);
 298 
 299   if (!aOop->is_typeArray()) {
 300      ReportJNIFatalError(thr, fatal_prim_type_array_expected);
 301   }
 302   return aOop;
 303 }
 304 
 305 static inline void
 306 check_primitive_array_type(JavaThread* thr, jarray jArray, BasicType elementType)
 307 {
 308   BasicType array_type;
 309   arrayOop aOop;
 310 
 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 }
 317 
 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 }
 325 
 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 }
 337 
 338 
 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 }
 353 
 354 
 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 }
 365 
 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
 371 
 372   size_t len = strlen(name);
 373 
 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 }
 382 
 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   }
 389 
 390   if (mirror->klass() != SystemDictionary::Class_klass()) {
 391     ReportJNIFatalError(thr, fatal_class_not_a_class);
 392   }
 393 
 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 }
 401 
 402 void jniCheck::validate_throwable_klass(JavaThread* thr, Klass* klass) {
 403   ASSERT_OOPS_ALLOWED;
 404   assert(klass != NULL, "klass argument must have a value");
 405 
 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 }
 411 
 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 }
 418 
 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 }
 425 
 426 
 427 /*
 428  * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE
 429  */
 430 
 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
 445 
 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
 457 
 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
 469 
 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
 481 
 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
 497 
 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
 509 
 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
 523 
 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
 538 
 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
 556 
 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
 571 
 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
 579 
 580 JNI_ENTRY_CHECKED(void,
 581   checked_jni_ExceptionDescribe(JNIEnv *env))
 582     functionEnterExceptionAllowed(thr);
 583     UNCHECKED()->ExceptionDescribe(env);
 584     functionExit(env);
 585 JNI_END
 586 
 587 JNI_ENTRY_CHECKED(void,
 588   checked_jni_ExceptionClear(JNIEnv *env))
 589     functionEnterExceptionAllowed(thr);
 590     UNCHECKED()->ExceptionClear(env);
 591     functionExit(env);
 592 JNI_END
 593 
 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
 601 
 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
 612 
 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
 621 
 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
 635 
 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
 650 
 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
 665 
 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
 687 
 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
 701 
 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
 713 
 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
 725 
 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
 743 
 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
 758 
 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
 773 
 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
 785 
 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
 799 
 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
 813 
 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
 862 
 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)
 872 
 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
 888 
 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
 901 
 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
 914 
 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
 978 
 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)
 988 
 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
1006 
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
1021 
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
1036 
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
1050 
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
1064 
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)
1074 
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
1088 
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)
1098 
1099 
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
1113 
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
1171 
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)
1181 
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
1198 
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
1212 
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
1226 
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
1240 
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
1257 
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)
1267 
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
1282 
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)
1292 
1293 
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
1303 
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
1315 
1316 // Arbitrary (but well-known) tag
1317 const jint STRING_TAG = 0x47114711;
1318 
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
1343 
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
1365 
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
1374 
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
1386 
1387 // Arbitrary (but well-known) tag - different than GetStringChars
1388 const jint STRING_UTF_TAG = 0x48124812;
1389 
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
1414 
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
1436 
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
1448 
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
1459 
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
1472 
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
1485 
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
1495 
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)
1504 
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
1520 
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)
1529 
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
1549 
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)
1558 
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
1573 
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)
1582 
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
1597 
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)
1606 
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
1617 
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
1626 
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
1638 
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
1650 
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
1659 
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
1673 
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
1687 
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
1700 
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
1716 
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
1729 
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
1744 
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
1758 
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
1766 
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
1774 
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
1784 
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
1793 
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
1802 
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
1815 
1816 
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
1824 
1825 
1826 
1827 /*
1828  * Structure containing all checked jni functions
1829  */
1830 struct JNINativeInterface_  checked_jni_NativeInterface = {
1831     NULL,
1832     NULL,
1833     NULL,
1834 
1835     NULL,
1836 
1837     checked_jni_GetVersion,
1838 
1839     checked_jni_DefineClass,
1840     checked_jni_FindClass,
1841 
1842     checked_jni_FromReflectedMethod,
1843     checked_jni_FromReflectedField,
1844 
1845     checked_jni_ToReflectedMethod,
1846 
1847     checked_jni_GetSuperclass,
1848     checked_jni_IsAssignableFrom,
1849 
1850     checked_jni_ToReflectedField,
1851 
1852     checked_jni_Throw,
1853     checked_jni_ThrowNew,
1854     checked_jni_ExceptionOccurred,
1855     checked_jni_ExceptionDescribe,
1856     checked_jni_ExceptionClear,
1857     checked_jni_FatalError,
1858 
1859     checked_jni_PushLocalFrame,
1860     checked_jni_PopLocalFrame,
1861 
1862     checked_jni_NewGlobalRef,
1863     checked_jni_DeleteGlobalRef,
1864     checked_jni_DeleteLocalRef,
1865     checked_jni_IsSameObject,
1866 
1867     checked_jni_NewLocalRef,
1868     checked_jni_EnsureLocalCapacity,
1869 
1870     checked_jni_AllocObject,
1871     checked_jni_NewObject,
1872     checked_jni_NewObjectV,
1873     checked_jni_NewObjectA,
1874 
1875     checked_jni_GetObjectClass,
1876     checked_jni_IsInstanceOf,
1877 
1878     checked_jni_GetMethodID,
1879 
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,
1910 
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,
1941 
1942     checked_jni_GetFieldID,
1943 
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,
1953 
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,
1963 
1964     checked_jni_GetStaticMethodID,
1965 
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,
1996 
1997     checked_jni_GetStaticFieldID,
1998 
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,
2008 
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,
2018 
2019     checked_jni_NewString,
2020     checked_jni_GetStringLength,
2021     checked_jni_GetStringChars,
2022     checked_jni_ReleaseStringChars,
2023 
2024     checked_jni_NewStringUTF,
2025     checked_jni_GetStringUTFLength,
2026     checked_jni_GetStringUTFChars,
2027     checked_jni_ReleaseStringUTFChars,
2028 
2029     checked_jni_GetArrayLength,
2030 
2031     checked_jni_NewObjectArray,
2032     checked_jni_GetObjectArrayElement,
2033     checked_jni_SetObjectArrayElement,
2034 
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,
2043 
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,
2052 
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,
2061 
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,
2070 
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,
2079 
2080     checked_jni_RegisterNatives,
2081     checked_jni_UnregisterNatives,
2082 
2083     checked_jni_MonitorEnter,
2084     checked_jni_MonitorExit,
2085 
2086     checked_jni_GetJavaVM,
2087 
2088     checked_jni_GetStringRegion,
2089     checked_jni_GetStringUTFRegion,
2090 
2091     checked_jni_GetPrimitiveArrayCritical,
2092     checked_jni_ReleasePrimitiveArrayCritical,
2093 
2094     checked_jni_GetStringCritical,
2095     checked_jni_ReleaseStringCritical,
2096 
2097     checked_jni_NewWeakGlobalRef,
2098     checked_jni_DeleteWeakGlobalRef,
2099 
2100     checked_jni_ExceptionCheck,
2101 
2102     checked_jni_NewDirectByteBuffer,
2103     checked_jni_GetDirectBufferAddress,
2104     checked_jni_GetDirectBufferCapacity,
2105 
2106     // New 1.6 Features
2107 
2108     checked_jni_GetObjectRefType
2109 };
2110 
2111 
2112 // Returns the function structure
2113 struct JNINativeInterface_* jni_functions_check() {
2114 
2115   unchecked_jni_NativeInterface = jni_functions_nocheck();
2116 
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");
2124 
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   }
2130 
2131   return &checked_jni_NativeInterface;
2132 }