jniCheck.cpp revision 2073:b92c45f2bc75
1139804Simp/* 226156Sse * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved. 326156Sse * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 426156Sse * 526156Sse * This code is free software; you can redistribute it and/or modify it 626156Sse * under the terms of the GNU General Public License version 2 only, as 726156Sse * published by the Free Software Foundation. 826156Sse * 926156Sse * This code is distributed in the hope that it will be useful, but WITHOUT 1026156Sse * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 1126156Sse * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1226156Sse * version 2 for more details (a copy is included in the LICENSE file that 1326156Sse * accompanied this code). 1426156Sse * 1526156Sse * You should have received a copy of the GNU General Public License version 1626156Sse * 2 along with this work; if not, write to the Free Software Foundation, 1726156Sse * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 1826156Sse * 1926156Sse * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 2026156Sse * or visit www.oracle.com if you need additional information or have any 2126156Sse * questions. 2226156Sse * 2326156Sse */ 2426156Sse 2526156Sse#include "precompiled.hpp" 2626156Sse#include "classfile/systemDictionary.hpp" 27116182Sobrien#include "classfile/vmSymbols.hpp" 28116182Sobrien#include "oops/instanceKlass.hpp" 2936887Sdfr#include "oops/oop.inline.hpp" 30121482Sjhb#include "oops/symbol.hpp" 31121482Sjhb#include "prims/jni.h" 3241059Speter#include "prims/jniCheck.hpp" 3365822Sjhb#include "prims/jvm_misc.hpp" 34110860Salfred#include "runtime/fieldDescriptor.hpp" 3565822Sjhb#include "runtime/handles.hpp" 3641059Speter#include "runtime/interfaceSupport.hpp" 3766698Sjhb#include "runtime/jfieldIDWorkaround.hpp" 3866698Sjhb#include "runtime/thread.hpp" 3966698Sjhb#ifdef TARGET_ARCH_x86 4066698Sjhb# include "jniTypes_x86.hpp" 41130128Sbde#endif 4274914Sjhb#ifdef TARGET_ARCH_sparc 4326156Sse# include "jniTypes_sparc.hpp" 4467365Sjhb#endif 4566698Sjhb#ifdef TARGET_ARCH_zero 4672759Sjhb# include "jniTypes_zero.hpp" 4772237Sjhb#endif 48139451Sjhb#ifdef TARGET_ARCH_arm 4977582Stmm# include "jniTypes_arm.hpp" 5066698Sjhb#endif 5166698Sjhb#ifdef TARGET_ARCH_ppc 5266698Sjhb# include "jniTypes_ppc.hpp" 5366698Sjhb#endif 5467551Sjhb 5572237Sjhb 56121482Sjhb// Heap objects are allowed to be directly referenced only in VM code, 57121482Sjhb// not in native code. 58121482Sjhb 59121482Sjhb#define ASSERT_OOPS_ALLOWED \ 6026156Sse assert(JavaThread::current()->thread_state() == _thread_in_vm, \ 61151658Sjhb "jniCheck examining oops in bad state.") 62151658Sjhb 63151658Sjhb 64151658Sjhb// Execute the given block of source code with the thread in VM state. 65151658Sjhb// To do this, transition from the NATIVE state to the VM state, execute 66151658Sjhb// the code, and transtition back. The ThreadInVMfromNative constructor 67151658Sjhb// performs the transition to VM state, its destructor restores the 68151658Sjhb// NATIVE state. 6972759Sjhb 7072759Sjhb#define IN_VM(source_code) { \ 71151658Sjhb { \ 72151658Sjhb ThreadInVMfromNative __tiv(thr); \ 73151658Sjhb source_code \ 74151658Sjhb } \ 75151658Sjhb } 76151658Sjhb 77151658Sjhb 78151658Sjhb/* 79151658Sjhb * DECLARATIONS 80151658Sjhb */ 81128339Sbde 82128339Sbdestatic struct JNINativeInterface_ * unchecked_jni_NativeInterface; 83173004Sjulian 8438244Sbde 8572237Sjhb/* 8672237Sjhb * MACRO DEFINITIONS 87168850Snjl */ 88128331Sjhb 89128331Sjhb// All JNI checked functions here use JNI_ENTRY_CHECKED() instead of the 90128331Sjhb// QUICK_ENTRY or LEAF variants found in jni.cpp. This allows handles 91128339Sbde// to be created if a fatal error should occur. 92151658Sjhb 93151658Sjhb// Check for thread not attached to VM; need to catch this before 94128331Sjhb// assertions in the wrapper routines might fire 95151658Sjhb 96169320Spiso// Check for env being the one value appropriate for this thread. 97169320Spiso 98169320Spiso#define JNI_ENTRY_CHECKED(result_type, header) \ 99169320Spisoextern "C" { \ 100151658Sjhb result_type JNICALL header { \ 101169320Spiso JavaThread* thr = (JavaThread*)ThreadLocalStorage::get_thread_slow();\ 102151658Sjhb if (thr == NULL || !thr->is_Java_thread()) { \ 103169320Spiso tty->print_cr(fatal_using_jnienv_in_nonjava); \ 104169320Spiso os::abort(true); \ 105169320Spiso } \ 106169320Spiso JNIEnv* xenv = thr->jni_environment(); \ 107169320Spiso if (env != xenv) { \ 108169320Spiso NativeReportJNIFatalError(thr, warn_wrong_jnienv); \ 109128339Sbde } \ 110151658Sjhb __ENTRY(result_type, header, thr) 111128339Sbde 112128339Sbde 113165124Sjhb#define UNCHECKED() (unchecked_jni_NativeInterface) 11472237Sjhb 115151658Sjhbstatic const char * warn_wrong_jnienv = "Using JNIEnv in the wrong thread"; 11665822Sjhbstatic const char * warn_bad_class_descriptor = "JNI FindClass received a bad class descriptor \"%s\". A correct class descriptor " \ 11772237Sjhb "has no leading \"L\" or trailing \";\". Incorrect descriptors will not be accepted in future releases."; 11865822Sjhbstatic const char * fatal_using_jnienv_in_nonjava = "FATAL ERROR in native method: Using JNIEnv in non-Java thread"; 11972237Sjhbstatic const char * warn_other_function_in_critical = "Warning: Calling other JNI functions in the scope of " \ 12078365Speter "Get/ReleasePrimitiveArrayCritical or Get/ReleaseStringCritical"; 12165822Sjhbstatic const char * fatal_bad_ref_to_jni = "Bad global or local ref passed to JNI"; 12272237Sjhbstatic const char * fatal_received_null_class = "JNI received a null class"; 12365822Sjhbstatic const char * fatal_class_not_a_class = "JNI received a class argument that is not a class"; 12465822Sjhbstatic const char * fatal_class_not_a_throwable_class = "JNI Throw or ThrowNew received a class argument that is not a Throwable or Throwable subclass"; 12565822Sjhbstatic const char * fatal_wrong_class_or_method = "Wrong object class or methodID passed to JNI call"; 12665822Sjhbstatic const char * fatal_non_weak_method = "non-weak methodID passed to JNI call"; 12765822Sjhbstatic const char * fatal_unknown_array_object = "Unknown array object passed to JNI array operations"; 12865822Sjhbstatic const char * fatal_object_array_expected = "Object array expected but not received for JNI array operation"; 12965822Sjhbstatic const char * fatal_non_array = "Non-array passed to JNI array operations"; 13065822Sjhbstatic const char * fatal_element_type_mismatch = "Array element type mismatch in JNI"; 13165822Sjhbstatic const char * fatal_should_be_static = "Non-static field ID passed to JNI"; 13265822Sjhbstatic const char * fatal_wrong_static_field = "Wrong static field ID passed to JNI"; 13365822Sjhbstatic const char * fatal_static_field_not_found = "Static field not found in JNI get/set field operations"; 13465822Sjhbstatic const char * fatal_static_field_mismatch = "Field type (static) mismatch in JNI get/set field operations"; 13565822Sjhbstatic const char * fatal_should_be_nonstatic = "Static field ID passed to JNI"; 13665822Sjhbstatic const char * fatal_null_object = "Null object passed to JNI"; 13765822Sjhbstatic const char * fatal_wrong_field = "Wrong field ID passed to JNI"; 13878365Speterstatic const char * fatal_instance_field_not_found = "Instance field not found in JNI get/set field operations"; 13978365Speterstatic const char * fatal_instance_field_mismatch = "Field type (instance) mismatch in JNI get/set field operations"; 14078365Speterstatic const char * fatal_non_string = "JNI string operation received a non-string"; 14172237Sjhb 14272237Sjhb 14372237Sjhb// When in VM state: 14465822Sjhbstatic void ReportJNIWarning(JavaThread* thr, const char *msg) { 14565822Sjhb tty->print_cr("WARNING in native method: %s", msg); 14665822Sjhb thr->print_stack(); 14765822Sjhb} 14872237Sjhb 149151658Sjhb// When in NATIVE state: 15065822Sjhbstatic void NativeReportJNIFatalError(JavaThread* thr, const char *msg) { 15165822Sjhb IN_VM( 15265822Sjhb ReportJNIFatalError(thr, msg); 15365822Sjhb ) 15465822Sjhb} 15572237Sjhb 156151658Sjhbstatic void NativeReportJNIWarning(JavaThread* thr, const char *msg) { 15772237Sjhb IN_VM( 15872237Sjhb ReportJNIWarning(thr, msg); 159151658Sjhb ) 16072237Sjhb} 161151658Sjhb 16283366Sjulian 163151658Sjhb 16467551Sjhb 165151658Sjhb/* 166151658Sjhb * SUPPORT FUNCTIONS 16772237Sjhb */ 168151658Sjhb 169151658Sjhbstatic inline void 170151658SjhbfunctionEnterCritical(JavaThread* thr) 171151658Sjhb{ 172151658Sjhb if (thr->has_pending_exception()) { 173105354Srobert NativeReportJNIWarning(thr, "JNI call made with exception pending"); 174151658Sjhb } 175173004Sjulian} 176170307Sjeff 177151658Sjhbstatic inline void 178170307SjefffunctionEnterCriticalExceptionAllowed(JavaThread* thr) 179151658Sjhb{ 180151658Sjhb} 181151658Sjhb 182151658Sjhbstatic inline void 183151658SjhbfunctionEnter(JavaThread* thr) 184151658Sjhb{ 185151658Sjhb if (thr->in_critical()) { 186151658Sjhb tty->print_cr(warn_other_function_in_critical); 187151658Sjhb } 188151658Sjhb if (thr->has_pending_exception()) { 189151658Sjhb NativeReportJNIWarning(thr, "JNI call made with exception pending"); 190151658Sjhb } 191151658Sjhb} 192151658Sjhb 193151658Sjhbstatic inline void 194151658SjhbfunctionEnterExceptionAllowed(JavaThread* thr) 195137267Sjhb{ 196151658Sjhb if (thr->in_critical()) { 197151658Sjhb tty->print_cr(warn_other_function_in_critical); 198151658Sjhb } 199151658Sjhb} 200151658Sjhb 201151658Sjhbstatic inline void 202151658SjhbfunctionExit(JNIEnv *env) 203151658Sjhb{ 204151658Sjhb /* nothing to do at this time */ 205137267Sjhb} 206137267Sjhb 207137267Sjhbstatic inline void 208151658SjhbcheckStaticFieldID(JavaThread* thr, jfieldID fid, jclass cls, int ftype) 209137267Sjhb{ 210151658Sjhb fieldDescriptor fd; 211151658Sjhb 212151658Sjhb /* make sure it is a static field */ 213151658Sjhb if (!jfieldIDWorkaround::is_static_jfieldID(fid)) 214151658Sjhb ReportJNIFatalError(thr, fatal_should_be_static); 215151658Sjhb 216151658Sjhb /* validate the class being passed */ 217137267Sjhb ASSERT_OOPS_ALLOWED; 218151658Sjhb klassOop k_oop = jniCheck::validate_class(thr, cls, false); 219151658Sjhb 220151658Sjhb /* check for proper subclass hierarchy */ 221151658Sjhb JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fid); 222151658Sjhb klassOop f_oop = id->holder(); 223151658Sjhb if (!instanceKlass::cast(k_oop)->is_subtype_of(f_oop)) 224151658Sjhb ReportJNIFatalError(thr, fatal_wrong_static_field); 225151658Sjhb 226151658Sjhb /* check for proper field type */ 22772237Sjhb if (!instanceKlass::cast(f_oop)->find_local_field_from_offset( 228151658Sjhb id->offset(), true, &fd)) 22972237Sjhb ReportJNIFatalError(thr, fatal_static_field_not_found); 230151658Sjhb if ((fd.field_type() != ftype) && 231151658Sjhb !(fd.field_type() == T_ARRAY && ftype == T_OBJECT)) { 232151658Sjhb ReportJNIFatalError(thr, fatal_static_field_mismatch); 233151658Sjhb } 234151658Sjhb} 235151658Sjhb 236151658Sjhbstatic inline void 237151658SjhbcheckInstanceFieldID(JavaThread* thr, jfieldID fid, jobject obj, int ftype) 23872237Sjhb{ 23972237Sjhb fieldDescriptor fd; 240169320Spiso 24172237Sjhb /* make sure it is an instance field */ 242151658Sjhb if (jfieldIDWorkaround::is_static_jfieldID(fid)) 243151658Sjhb ReportJNIFatalError(thr, fatal_should_be_nonstatic); 24466698Sjhb 245151658Sjhb /* validate the object being passed and then get its class */ 24672237Sjhb ASSERT_OOPS_ALLOWED; 24772237Sjhb oop oopObj = jniCheck::validate_object(thr, obj); 248151658Sjhb if (!oopObj) { 249151658Sjhb ReportJNIFatalError(thr, fatal_null_object); 25072759Sjhb } 251151658Sjhb klassOop k_oop = oopObj->klass(); 252151658Sjhb 253151658Sjhb if (!jfieldIDWorkaround::is_valid_jfieldID(k_oop, fid)) { 254151658Sjhb ReportJNIFatalError(thr, fatal_wrong_field); 255151658Sjhb } 256151658Sjhb 25772759Sjhb /* make sure the field exists */ 25872237Sjhb int offset = jfieldIDWorkaround::from_instance_jfieldID(k_oop, fid); 259151658Sjhb if (!instanceKlass::cast(k_oop)->contains_field_offset(offset)) 26072237Sjhb ReportJNIFatalError(thr, fatal_wrong_field); 261151658Sjhb 262151658Sjhb /* check for proper field type */ 263151658Sjhb if (!instanceKlass::cast(k_oop)->find_field_from_offset(offset, 264151658Sjhb false, &fd)) 265151658Sjhb ReportJNIFatalError(thr, fatal_instance_field_not_found); 266151658Sjhb 267151658Sjhb if ((fd.field_type() != ftype) && 268151658Sjhb !(fd.field_type() == T_ARRAY && ftype == T_OBJECT)) { 269151658Sjhb ReportJNIFatalError(thr, fatal_instance_field_mismatch); 270169320Spiso } 271169320Spiso} 272169320Spiso 273169320Spisostatic inline void 274169320SpisocheckString(JavaThread* thr, jstring js) 275169320Spiso{ 276169320Spiso ASSERT_OOPS_ALLOWED; 277169320Spiso oop s = jniCheck::validate_object(thr, js); 27872237Sjhb if (!s || !java_lang_String::is_instance(s)) 279169320Spiso ReportJNIFatalError(thr, fatal_non_string); 280169320Spiso} 281169320Spiso 282169320Spisostatic inline void 283169320SpisocheckArray(JavaThread* thr, jarray jArray, int elementType) 284169320Spiso{ 285169320Spiso ASSERT_OOPS_ALLOWED; 286169320Spiso arrayOop aOop; 287169320Spiso 288169320Spiso aOop = (arrayOop)jniCheck::validate_object(thr, jArray); 289169320Spiso if (aOop == NULL || !aOop->is_array()) 290169320Spiso ReportJNIFatalError(thr, fatal_non_array); 291169320Spiso 292169320Spiso if (elementType != -1) { 293169320Spiso if (aOop->is_typeArray()) { 294169320Spiso BasicType array_type = typeArrayKlass::cast(aOop->klass())->element_type(); 295169320Spiso if (array_type != elementType) 296169320Spiso ReportJNIFatalError(thr, fatal_element_type_mismatch); 297169320Spiso } else if (aOop->is_objArray()) { 298169320Spiso if ( T_OBJECT != elementType) 299169320Spiso ReportJNIFatalError(thr, fatal_object_array_expected); 300169320Spiso } else { 301169320Spiso ReportJNIFatalError(thr, fatal_unknown_array_object); 302169320Spiso } 303169320Spiso } 304169320Spiso} 305151658Sjhb 306151658Sjhb 307151658Sjhboop jniCheck::validate_handle(JavaThread* thr, jobject obj) { 308151658Sjhb if (JNIHandles::is_frame_handle(thr, obj) || 309151658Sjhb JNIHandles::is_local_handle(thr, obj) || 310151658Sjhb JNIHandles::is_global_handle(obj) || 311151658Sjhb JNIHandles::is_weak_global_handle(obj)) { 312151658Sjhb ASSERT_OOPS_ALLOWED; 313151658Sjhb return JNIHandles::resolve_external_guard(obj); 314151658Sjhb } 315151658Sjhb ReportJNIFatalError(thr, fatal_bad_ref_to_jni); 316151658Sjhb return NULL; 317157728Sjhb} 318157728Sjhb 319157728Sjhb 320157728SjhbmethodOop jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) { 321157728Sjhb ASSERT_OOPS_ALLOWED; 322157728Sjhb // do the fast jmethodID check first 323151658Sjhb methodOop moop = JNIHandles::checked_resolve_jmethod_id(method_id); 324151658Sjhb if (moop == NULL) { 325151658Sjhb ReportJNIFatalError(thr, fatal_wrong_class_or_method); 326151658Sjhb } 327151658Sjhb // jmethodIDs are supposed to be weak global handles, but that 328151658Sjhb // can be expensive so check it last 329169320Spiso else if (!JNIHandles::is_weak_global_handle((jobject) method_id)) { 330151658Sjhb ReportJNIFatalError(thr, fatal_non_weak_method); 331151658Sjhb } 332151658Sjhb return moop; 333151658Sjhb} 334151658Sjhb 335151658Sjhb 336151658Sjhboop jniCheck::validate_object(JavaThread* thr, jobject obj) { 337151658Sjhb if (!obj) 338151658Sjhb return NULL; 339173004Sjulian ASSERT_OOPS_ALLOWED; 340173004Sjulian oop oopObj = jniCheck::validate_handle(thr, obj); 341173004Sjulian if (!oopObj) { 342151658Sjhb ReportJNIFatalError(thr, fatal_bad_ref_to_jni); 343172836Sjulian } 344170307Sjeff return oopObj; 345164936Sjulian} 346103216Sjulian 347170307Sjeff// Warn if a class descriptor is in decorated form; class descriptors 348151658Sjhb// passed to JNI findClass should not be decorated unless they are 349151658Sjhb// array descriptors. 350151658Sjhbvoid jniCheck::validate_class_descriptor(JavaThread* thr, const char* name) { 351151658Sjhb if (name == NULL) return; // implementation accepts NULL so just return 35272237Sjhb 353169320Spiso size_t len = strlen(name); 354169320Spiso 355169320Spiso if (len >= 2 && 356169320Spiso name[0] == JVM_SIGNATURE_CLASS && // 'L' 357169320Spiso name[len-1] == JVM_SIGNATURE_ENDCLASS ) { // ';' 358169320Spiso char msg[JVM_MAXPATHLEN]; 359169320Spiso jio_snprintf(msg, JVM_MAXPATHLEN, warn_bad_class_descriptor, name); 36072237Sjhb ReportJNIWarning(thr, msg); 361169320Spiso } 362169320Spiso} 363173004Sjulian 364173004SjulianklassOop jniCheck::validate_class(JavaThread* thr, jclass clazz, bool allow_primitive) { 365173004Sjulian ASSERT_OOPS_ALLOWED; 366169320Spiso oop mirror = jniCheck::validate_handle(thr, clazz); 367172836Sjulian if (!mirror) { 368170307Sjeff ReportJNIFatalError(thr, fatal_received_null_class); 369169320Spiso } 370169320Spiso 371170307Sjeff if (mirror->klass() != SystemDictionary::Class_klass()) { 372169320Spiso ReportJNIFatalError(thr, fatal_class_not_a_class); 373169320Spiso } 374169320Spiso 375169320Spiso klassOop k = java_lang_Class::as_klassOop(mirror); 376169320Spiso // Make allowances for primitive classes ... 377169320Spiso if (!(k != NULL || allow_primitive && java_lang_Class::is_primitive(mirror))) { 378169320Spiso ReportJNIFatalError(thr, fatal_class_not_a_class); 379151658Sjhb } 380151658Sjhb return k; 38172237Sjhb} 38283366Sjulian 38372237Sjhbvoid jniCheck::validate_throwable_klass(JavaThread* thr, klassOop klass) { 384157784Sscottl ASSERT_OOPS_ALLOWED; 385151658Sjhb assert(klass != NULL, "klass argument must have a value"); 386170307Sjeff 38776771Sjhb if (!Klass::cast(klass)->oop_is_instance() || 388103216Sjulian !instanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) { 389103216Sjulian ReportJNIFatalError(thr, fatal_class_not_a_throwable_class); 390166188Sjeff } 39172237Sjhb} 392170307Sjeff 39372237Sjhbvoid jniCheck::validate_call_object(JavaThread* thr, jobject obj, jmethodID method_id) { 39472237Sjhb /* validate the object being passed */ 395169320Spiso ASSERT_OOPS_ALLOWED; 39672237Sjhb jniCheck::validate_jmethod_id(thr, method_id); 397151658Sjhb jniCheck::validate_object(thr, obj); 398166901Spiso} 399166901Spiso 40072237Sjhbvoid jniCheck::validate_call_class(JavaThread* thr, jclass clazz, jmethodID method_id) { 401151658Sjhb /* validate the class being passed */ 402151658Sjhb ASSERT_OOPS_ALLOWED; 40372237Sjhb jniCheck::validate_jmethod_id(thr, method_id); 404166901Spiso jniCheck::validate_class(thr, clazz, false); 40572237Sjhb} 40672237Sjhb 407151658Sjhb 408151658Sjhb/* 409166901Spiso * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE 41072237Sjhb */ 41172237Sjhb 41272237SjhbJNI_ENTRY_CHECKED(jclass, 413151658Sjhb checked_jni_DefineClass(JNIEnv *env, 41472237Sjhb const char *name, 415166901Spiso jobject loader, 41672237Sjhb const jbyte *buf, 41772237Sjhb jsize len)) 41872237Sjhb functionEnter(thr); 41972237Sjhb IN_VM( 42072237Sjhb jniCheck::validate_object(thr, loader); 42172237Sjhb ) 422151658Sjhb jclass result = UNCHECKED()->DefineClass(env, name, loader, buf, len); 423151658Sjhb functionExit(env); 424151658Sjhb return result; 425151658SjhbJNI_END 426151658Sjhb 427151658SjhbJNI_ENTRY_CHECKED(jclass, 428151658Sjhb checked_jni_FindClass(JNIEnv *env, 429151658Sjhb const char *name)) 430151658Sjhb functionEnter(thr); 431122002Sjhb IN_VM( 43272237Sjhb jniCheck::validate_class_descriptor(thr, name); 433151658Sjhb ) 434151658Sjhb jclass result = UNCHECKED()->FindClass(env, name); 435151658Sjhb functionExit(env); 436151658Sjhb return result; 437151658SjhbJNI_END 43872237Sjhb 439151658SjhbJNI_ENTRY_CHECKED(jmethodID, 44072237Sjhb checked_jni_FromReflectedMethod(JNIEnv *env, 44172237Sjhb jobject method)) 442151658Sjhb functionEnter(thr); 44372237Sjhb IN_VM( 444151658Sjhb jniCheck::validate_object(thr, method); 445166901Spiso ) 446151658Sjhb jmethodID result = UNCHECKED()->FromReflectedMethod(env, method); 447157815Sjhb functionExit(env); 448151658Sjhb return result; 449151658SjhbJNI_END 450151658Sjhb 451151658SjhbJNI_ENTRY_CHECKED(jfieldID, 452151658Sjhb checked_jni_FromReflectedField(JNIEnv *env, 453151658Sjhb jobject field)) 454151658Sjhb functionEnter(thr); 455151658Sjhb IN_VM( 456151658Sjhb jniCheck::validate_object(thr, field); 457151658Sjhb ) 458151658Sjhb jfieldID result = UNCHECKED()->FromReflectedField(env, field); 459151658Sjhb functionExit(env); 460151658Sjhb return result; 461151658SjhbJNI_END 462151658Sjhb 463151658SjhbJNI_ENTRY_CHECKED(jobject, 46472237Sjhb checked_jni_ToReflectedMethod(JNIEnv *env, 46572237Sjhb jclass cls, 46672237Sjhb jmethodID methodID, 46772237Sjhb jboolean isStatic)) 468169320Spiso functionEnter(thr); 469169320Spiso IN_VM( 470169320Spiso jniCheck::validate_class(thr, cls, false); 471169320Spiso jniCheck::validate_jmethod_id(thr, methodID); 472169320Spiso ) 473169320Spiso jobject result = UNCHECKED()->ToReflectedMethod(env, cls, methodID, 474169320Spiso isStatic); 475169320Spiso functionExit(env); 47672237Sjhb return result; 477169320SpisoJNI_END 478169320Spiso 479169320SpisoJNI_ENTRY_CHECKED(jclass, 480169320Spiso checked_jni_GetSuperclass(JNIEnv *env, 481169320Spiso jclass sub)) 482169320Spiso functionEnter(thr); 483169320Spiso IN_VM( 484169320Spiso jniCheck::validate_class(thr, sub, true); 485169320Spiso ) 486169320Spiso jclass result = UNCHECKED()->GetSuperclass(env, sub); 487169320Spiso functionExit(env); 488169320Spiso return result; 489169320SpisoJNI_END 490169320Spiso 491169320SpisoJNI_ENTRY_CHECKED(jboolean, 492169320Spiso checked_jni_IsAssignableFrom(JNIEnv *env, 493169320Spiso jclass sub, 494169320Spiso jclass sup)) 495169320Spiso functionEnter(thr); 496169320Spiso IN_VM( 497169320Spiso jniCheck::validate_class(thr, sub, true); 498169320Spiso jniCheck::validate_class(thr, sup, true); 499169320Spiso ) 500169320Spiso jboolean result = UNCHECKED()->IsAssignableFrom(env, sub, sup); 501169320Spiso functionExit(env); 502169320Spiso return result; 503169320SpisoJNI_END 504169320Spiso 505169320SpisoJNI_ENTRY_CHECKED(jobject, 506169320Spiso checked_jni_ToReflectedField(JNIEnv *env, 507169320Spiso jclass cls, 508169320Spiso jfieldID fieldID, 509169320Spiso jboolean isStatic)) 510169320Spiso functionEnter(thr); 511169320Spiso IN_VM( 512169320Spiso jniCheck::validate_class(thr, cls, false); 513169320Spiso ) 514169320Spiso jobject result = UNCHECKED()->ToReflectedField(env, cls, fieldID, 515169320Spiso isStatic); 516169320Spiso functionExit(env); 517169320Spiso return result; 518169320SpisoJNI_END 519169320Spiso 520169320SpisoJNI_ENTRY_CHECKED(jint, 521169320Spiso checked_jni_Throw(JNIEnv *env, 522169320Spiso jthrowable obj)) 523169320Spiso functionEnter(thr); 524169320Spiso IN_VM( 525169320Spiso oop oopObj = jniCheck::validate_object(thr, obj); 526169320Spiso if (oopObj == NULL) { 527169320Spiso // Unchecked Throw tolerates a NULL obj, so just warn 528169320Spiso ReportJNIWarning(thr, "JNI Throw called with NULL throwable"); 529169320Spiso } else { 530169320Spiso jniCheck::validate_throwable_klass(thr, oopObj->klass()); 531169320Spiso } 532169320Spiso ) 533169320Spiso jint result = UNCHECKED()->Throw(env, obj); 534169320Spiso functionExit(env); 535169320Spiso return result; 536169320SpisoJNI_END 537169320Spiso 538169320SpisoJNI_ENTRY_CHECKED(jint, 539169320Spiso checked_jni_ThrowNew(JNIEnv *env, 540169320Spiso jclass clazz, 541169320Spiso const char *msg)) 542169320Spiso functionEnter(thr); 543169320Spiso IN_VM( 544169320Spiso klassOop k = jniCheck::validate_class(thr, clazz, false); 545169320Spiso assert(k != NULL, "validate_class shouldn't return NULL klassOop"); 546169320Spiso jniCheck::validate_throwable_klass(thr, k); 547169320Spiso ) 548169320Spiso jint result = UNCHECKED()->ThrowNew(env, clazz, msg); 549169320Spiso functionExit(env); 550169320Spiso return result; 551169320SpisoJNI_END 552165125Sjhb 553165125SjhbJNI_ENTRY_CHECKED(jthrowable, 554165125Sjhb checked_jni_ExceptionOccurred(JNIEnv *env)) 555165125Sjhb functionEnterExceptionAllowed(thr); 556165125Sjhb jthrowable result = UNCHECKED()->ExceptionOccurred(env); 557165125Sjhb functionExit(env); 558165125Sjhb return result; 559165125SjhbJNI_END 560165125Sjhb 561165125SjhbJNI_ENTRY_CHECKED(void, 562165125Sjhb checked_jni_ExceptionDescribe(JNIEnv *env)) 563165125Sjhb functionEnterExceptionAllowed(thr); 564165125Sjhb UNCHECKED()->ExceptionDescribe(env); 565165125Sjhb functionExit(env); 566165125SjhbJNI_END 567165125Sjhb 568165125SjhbJNI_ENTRY_CHECKED(void, 569165125Sjhb checked_jni_ExceptionClear(JNIEnv *env)) 570165125Sjhb functionEnterExceptionAllowed(thr); 571165125Sjhb UNCHECKED()->ExceptionClear(env); 572169320Spiso functionExit(env); 57372237SjhbJNI_END 574151658Sjhb 57572237SjhbJNI_ENTRY_CHECKED(void, 576151658Sjhb checked_jni_FatalError(JNIEnv *env, 577151658Sjhb const char *msg)) 57872237Sjhb functionEnter(thr); 579151658Sjhb UNCHECKED()->FatalError(env, msg); 58072237Sjhb functionExit(env); 581151658SjhbJNI_END 582151658Sjhb 583151658SjhbJNI_ENTRY_CHECKED(jint, 58472237Sjhb checked_jni_PushLocalFrame(JNIEnv *env, 58572759Sjhb jint capacity)) 58672237Sjhb functionEnterExceptionAllowed(thr); 587151658Sjhb if (capacity < 0) 588151658Sjhb NativeReportJNIFatalError(thr, "negative capacity"); 589151658Sjhb jint result = UNCHECKED()->PushLocalFrame(env, capacity); 590165124Sjhb functionExit(env); 591151658Sjhb return result; 59287593SobrienJNI_END 593151658Sjhb 59472237SjhbJNI_ENTRY_CHECKED(jobject, 595151658Sjhb checked_jni_PopLocalFrame(JNIEnv *env, 59672759Sjhb jobject result)) 59772759Sjhb functionEnterExceptionAllowed(thr); 598151658Sjhb jobject res = UNCHECKED()->PopLocalFrame(env, result); 599151658Sjhb functionExit(env); 600151658Sjhb return res; 60172759SjhbJNI_END 60272237Sjhb 60372839SjhbJNI_ENTRY_CHECKED(jobject, 604151658Sjhb checked_jni_NewGlobalRef(JNIEnv *env, 605151658Sjhb jobject lobj)) 606151658Sjhb functionEnter(thr); 607151658Sjhb IN_VM( 608151658Sjhb if (lobj != NULL) { 609151658Sjhb jniCheck::validate_handle(thr, lobj); 610151658Sjhb } 611151658Sjhb ) 612151658Sjhb jobject result = UNCHECKED()->NewGlobalRef(env,lobj); 613151658Sjhb functionExit(env); 614151658Sjhb return result; 615151658SjhbJNI_END 61672839Sjhb 61772839SjhbJNI_ENTRY_CHECKED(void, 618124505Struckman checked_jni_DeleteGlobalRef(JNIEnv *env, 619124505Struckman jobject gref)) 620124505Struckman functionEnterExceptionAllowed(thr); 621124505Struckman IN_VM( 62272839Sjhb jniCheck::validate_object(thr, gref); 623170307Sjeff if (gref && !JNIHandles::is_global_handle(gref)) { 624151658Sjhb ReportJNIFatalError(thr, 62572839Sjhb "Invalid global JNI handle passed to DeleteGlobalRef"); 62672839Sjhb } 62772839Sjhb ) 62872839Sjhb UNCHECKED()->DeleteGlobalRef(env,gref); 62972839Sjhb functionExit(env); 63072839SjhbJNI_END 63172839Sjhb 632151658SjhbJNI_ENTRY_CHECKED(void, 633151658Sjhb checked_jni_DeleteLocalRef(JNIEnv *env, 634151658Sjhb jobject obj)) 635170307Sjeff functionEnterExceptionAllowed(thr); 636151658Sjhb IN_VM( 637157815Sjhb jniCheck::validate_object(thr, obj); 638151658Sjhb if (obj && !(JNIHandles::is_local_handle(thr, obj) || 639151658Sjhb JNIHandles::is_frame_handle(thr, obj))) 640151658Sjhb ReportJNIFatalError(thr, 641151658Sjhb "Invalid local JNI handle passed to DeleteLocalRef"); 642151658Sjhb ) 643151658Sjhb UNCHECKED()->DeleteLocalRef(env, obj); 644151658Sjhb functionExit(env); 645151658SjhbJNI_END 646151658Sjhb 647151658SjhbJNI_ENTRY_CHECKED(jboolean, 648151658Sjhb checked_jni_IsSameObject(JNIEnv *env, 649151658Sjhb jobject obj1, 650151658Sjhb jobject obj2)) 651151658Sjhb functionEnterExceptionAllowed(thr); 652151658Sjhb IN_VM( 653151658Sjhb /* This JNI function can be used to compare weak global references 654151658Sjhb * to NULL objects. If the handles are valid, but contain NULL, 655151658Sjhb * then don't attempt to validate the object. 656151658Sjhb */ 657151658Sjhb if (obj1 != NULL && jniCheck::validate_handle(thr, obj1) != NULL) { 65876771Sjhb jniCheck::validate_object(thr, obj1); 65972237Sjhb } 66072237Sjhb if (obj2 != NULL && jniCheck::validate_handle(thr, obj2) != NULL) { 66172237Sjhb jniCheck::validate_object(thr, obj2); 66272237Sjhb } 663151658Sjhb ) 66472759Sjhb jboolean result = UNCHECKED()->IsSameObject(env,obj1,obj2); 665151658Sjhb functionExit(env); 666151658Sjhb return result; 66783366SjulianJNI_END 668101176Sjulian 66972759SjhbJNI_ENTRY_CHECKED(jobject, 67072759Sjhb checked_jni_NewLocalRef(JNIEnv *env, 67172759Sjhb jobject ref)) 67272759Sjhb functionEnter(thr); 67372759Sjhb IN_VM( 674151658Sjhb if (ref != NULL) { 675151658Sjhb jniCheck::validate_handle(thr, ref); 67672759Sjhb } 67772759Sjhb ) 678101176Sjulian jobject result = UNCHECKED()->NewLocalRef(env, ref); 679151658Sjhb functionExit(env); 680151658Sjhb return result; 681133191SrwatsonJNI_END 682151658Sjhb 68372759SjhbJNI_ENTRY_CHECKED(jint, 68472759Sjhb checked_jni_EnsureLocalCapacity(JNIEnv *env, 68572759Sjhb jint capacity)) 68672759Sjhb functionEnter(thr); 687151658Sjhb if (capacity < 0) { 688133191Srwatson NativeReportJNIFatalError(thr, "negative capacity"); 689173004Sjulian } 690151658Sjhb jint result = UNCHECKED()->EnsureLocalCapacity(env, capacity); 691151658Sjhb functionExit(env); 69272759Sjhb return result; 69372759SjhbJNI_END 69472759Sjhb 69572759SjhbJNI_ENTRY_CHECKED(jobject, 696151658Sjhb checked_jni_AllocObject(JNIEnv *env, 69772759Sjhb jclass clazz)) 69872759Sjhb functionEnter(thr); 69972759Sjhb IN_VM( 700170307Sjeff jniCheck::validate_class(thr, clazz, false); 701170307Sjeff ) 70272759Sjhb jobject result = UNCHECKED()->AllocObject(env,clazz); 703151658Sjhb functionExit(env); 704170307Sjeff return result; 705103216SjulianJNI_END 706151658Sjhb 707173004SjulianJNI_ENTRY_CHECKED(jobject, 708103216Sjulian checked_jni_NewObject(JNIEnv *env, 709166188Sjeff jclass clazz, 71072759Sjhb jmethodID methodID, 711151658Sjhb ...)) 712173004Sjulian functionEnter(thr); 71372759Sjhb va_list args; 714170307Sjeff IN_VM( 71572759Sjhb jniCheck::validate_class(thr, clazz, false); 71672759Sjhb jniCheck::validate_jmethod_id(thr, methodID); 71772759Sjhb ) 718169320Spiso va_start(args, methodID); 719169320Spiso jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args); 720169320Spiso va_end(args); 721169320Spiso functionExit(env); 722169320Spiso return result; 723169320SpisoJNI_END 724169320Spiso 725169320SpisoJNI_ENTRY_CHECKED(jobject, 726169320Spiso checked_jni_NewObjectV(JNIEnv *env, 727169320Spiso jclass clazz, 728169320Spiso jmethodID methodID, 729169320Spiso va_list args)) 730169320Spiso functionEnter(thr); 73172759Sjhb IN_VM( 732169320Spiso jniCheck::validate_class(thr, clazz, false); 733169320Spiso jniCheck::validate_jmethod_id(thr, methodID); 734169320Spiso ) 735169320Spiso jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args); 736169320Spiso functionExit(env); 737169320Spiso return result; 738169320SpisoJNI_END 739169320Spiso 740169320SpisoJNI_ENTRY_CHECKED(jobject, 741169320Spiso checked_jni_NewObjectA(JNIEnv *env, 742169320Spiso jclass clazz, 743169320Spiso jmethodID methodID, 744169320Spiso const jvalue *args)) 745169320Spiso functionEnter(thr); 746169320Spiso IN_VM( 747169320Spiso jniCheck::validate_class(thr, clazz, false); 748169320Spiso jniCheck::validate_jmethod_id(thr, methodID); 749169320Spiso ) 750169320Spiso jobject result = UNCHECKED()->NewObjectA(env,clazz,methodID,args); 751169320Spiso functionExit(env); 752169320Spiso return result; 753169320SpisoJNI_END 754169320Spiso 755169320SpisoJNI_ENTRY_CHECKED(jclass, 756169320Spiso checked_jni_GetObjectClass(JNIEnv *env, 757169320Spiso jobject obj)) 758169320Spiso functionEnter(thr); 759169320Spiso IN_VM( 760169320Spiso jniCheck::validate_object(thr, obj); 761169320Spiso ) 762169320Spiso jclass result = UNCHECKED()->GetObjectClass(env,obj); 763169320Spiso functionExit(env); 764169320Spiso return result; 765169320SpisoJNI_END 766169320Spiso 767169320SpisoJNI_ENTRY_CHECKED(jboolean, 768169320Spiso checked_jni_IsInstanceOf(JNIEnv *env, 769169320Spiso jobject obj, 770169320Spiso jclass clazz)) 771169320Spiso functionEnter(thr); 772170307Sjeff IN_VM( 773169320Spiso jniCheck::validate_object(thr, obj); 774169320Spiso jniCheck::validate_class(thr, clazz, true); 775169320Spiso ) 776169320Spiso jboolean result = UNCHECKED()->IsInstanceOf(env,obj,clazz); 777169320Spiso functionExit(env); 778169320Spiso return result; 779169320SpisoJNI_END 780169320Spiso 781169320SpisoJNI_ENTRY_CHECKED(jmethodID, 782169320Spiso checked_jni_GetMethodID(JNIEnv *env, 783169320Spiso jclass clazz, 784170307Sjeff const char *name, 785169320Spiso const char *sig)) 786169320Spiso functionEnter(thr); 787169320Spiso IN_VM( 788169320Spiso jniCheck::validate_class(thr, clazz, false); 789169320Spiso ) 790169320Spiso jmethodID result = UNCHECKED()->GetMethodID(env,clazz,name,sig); 791169320Spiso functionExit(env); 792169320Spiso return result; 793169320SpisoJNI_END 794169320Spiso 795169320Spiso#define WRAPPER_CallMethod(ResultType, Result) \ 796169320SpisoJNI_ENTRY_CHECKED(ResultType, \ 797169320Spiso checked_jni_Call##Result##Method(JNIEnv *env, \ 798169320Spiso jobject obj, \ 799169320Spiso jmethodID methodID, \ 800169320Spiso ...)) \ 801169320Spiso functionEnter(thr); \ 802169320Spiso va_list args; \ 803169320Spiso IN_VM( \ 804169320Spiso jniCheck::validate_call_object(thr, obj, methodID); \ 805169320Spiso ) \ 806169320Spiso va_start(args,methodID); \ 807169320Spiso ResultType result =UNCHECKED()->Call##Result##MethodV(env, obj, methodID, \ 808169320Spiso args); \ 809169320Spiso va_end(args); \ 810169320Spiso functionExit(env); \ 811169320Spiso return result; \ 812169320SpisoJNI_END \ 813169320Spiso\ 814169320SpisoJNI_ENTRY_CHECKED(ResultType, \ 815169320Spiso checked_jni_Call##Result##MethodV(JNIEnv *env, \ 816169320Spiso jobject obj, \ 817169320Spiso jmethodID methodID, \ 818169320Spiso va_list args)) \ 819169320Spiso functionEnter(thr); \ 820169320Spiso IN_VM(\ 821169320Spiso jniCheck::validate_call_object(thr, obj, methodID); \ 822169320Spiso ) \ 823169320Spiso ResultType result = UNCHECKED()->Call##Result##MethodV(env, obj, methodID,\ 824169320Spiso args); \ 825169320Spiso functionExit(env); \ 826169320Spiso return result; \ 827169320SpisoJNI_END \ 828169320Spiso\ 829169320SpisoJNI_ENTRY_CHECKED(ResultType, \ 830169320Spiso checked_jni_Call##Result##MethodA(JNIEnv *env, \ 831169320Spiso jobject obj, \ 832169320Spiso jmethodID methodID, \ 833169320Spiso const jvalue * args)) \ 834169320Spiso functionEnter(thr); \ 835169320Spiso IN_VM( \ 836169320Spiso jniCheck::validate_call_object(thr, obj, methodID); \ 837169320Spiso ) \ 838169320Spiso ResultType result = UNCHECKED()->Call##Result##MethodA(env, obj, methodID,\ 839169320Spiso args); \ 840169320Spiso functionExit(env); \ 841169320Spiso return result; \ 842169320SpisoJNI_END 843173004Sjulian 844169320SpisoWRAPPER_CallMethod(jobject,Object) 845169320SpisoWRAPPER_CallMethod(jboolean,Boolean) 846169320SpisoWRAPPER_CallMethod(jbyte,Byte) 847169320SpisoWRAPPER_CallMethod(jshort,Short) 848169320SpisoWRAPPER_CallMethod(jchar,Char) 849169320SpisoWRAPPER_CallMethod(jint,Int) 850169320SpisoWRAPPER_CallMethod(jlong,Long) 851169320SpisoWRAPPER_CallMethod(jfloat,Float) 852169320SpisoWRAPPER_CallMethod(jdouble,Double) 853169320Spiso 854170307SjeffJNI_ENTRY_CHECKED(void, 855170307Sjeff checked_jni_CallVoidMethod(JNIEnv *env, \ 856169320Spiso jobject obj, \ 857169320Spiso jmethodID methodID, \ 858170307Sjeff ...)) 859169320Spiso functionEnter(thr); 860169320Spiso va_list args; 861173004Sjulian IN_VM( 862169320Spiso jniCheck::validate_call_object(thr, obj, methodID); 863169320Spiso ) 864169320Spiso va_start(args,methodID); 865169320Spiso UNCHECKED()->CallVoidMethodV(env,obj,methodID,args); 866173004Sjulian va_end(args); 867169320Spiso functionExit(env); 868170307SjeffJNI_END 869169320Spiso 870169320SpisoJNI_ENTRY_CHECKED(void, 871169320Spiso checked_jni_CallVoidMethodV(JNIEnv *env, 872169320Spiso jobject obj, 873169320Spiso jmethodID methodID, 874151699Sjhb va_list args)) 875151699Sjhb functionEnter(thr); 876151699Sjhb IN_VM( 877151699Sjhb jniCheck::validate_call_object(thr, obj, methodID); 87872759Sjhb ) 879151658Sjhb UNCHECKED()->CallVoidMethodV(env,obj,methodID,args); 88072237Sjhb functionExit(env); 88172237SjhbJNI_END 882151658Sjhb 88372237SjhbJNI_ENTRY_CHECKED(void, 88466698Sjhb checked_jni_CallVoidMethodA(JNIEnv *env, 885169320Spiso jobject obj, 88672759Sjhb jmethodID methodID, 88772759Sjhb const jvalue * args)) 888151658Sjhb functionEnter(thr); 88966698Sjhb IN_VM( 890151658Sjhb jniCheck::validate_call_object(thr, obj, methodID); 891151658Sjhb ) 892151658Sjhb UNCHECKED()->CallVoidMethodA(env,obj,methodID,args); 89372759Sjhb functionExit(env); 894169320SpisoJNI_END 895169320Spiso 896169320Spiso#define WRAPPER_CallNonvirtualMethod(ResultType, Result) \ 897169320SpisoJNI_ENTRY_CHECKED(ResultType, \ 898169320Spiso checked_jni_CallNonvirtual##Result##Method(JNIEnv *env, \ 899169320Spiso jobject obj, \ 900169320Spiso jclass clazz, \ 90167551Sjhb jmethodID methodID, \ 90272237Sjhb ...)) \ 903151658Sjhb functionEnter(thr); \ 904151658Sjhb va_list args; \ 90566698Sjhb IN_VM( \ 906166901Spiso jniCheck::validate_call_object(thr, obj, methodID); \ 90772376Sjake jniCheck::validate_call_class(thr, clazz, methodID); \ 908134791Sjulian ) \ 90966698Sjhb va_start(args,methodID); \ 91066698Sjhb ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \ 91166698Sjhb obj, \ 912151658Sjhb clazz, \ 91366698Sjhb methodID,\ 91467551Sjhb args); \ 91572237Sjhb va_end(args); \ 91666698Sjhb functionExit(env); \ 917151658Sjhb return result; \ 918151658SjhbJNI_END \ 91972759Sjhb\ 92066698SjhbJNI_ENTRY_CHECKED(ResultType, \ 921151658Sjhb checked_jni_CallNonvirtual##Result##MethodV(JNIEnv *env, \ 922151658Sjhb jobject obj, \ 923151658Sjhb jclass clazz, \ 92467551Sjhb jmethodID methodID, \ 92572759Sjhb va_list args)) \ 92672759Sjhb functionEnter(thr); \ 92772759Sjhb IN_VM( \ 92867551Sjhb jniCheck::validate_call_object(thr, obj, methodID); \ 92972237Sjhb jniCheck::validate_call_class(thr, clazz, methodID); \ 930163474Sbde ) \ 93172237Sjhb ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \ 932170291Sattilio obj, \ 933169320Spiso clazz, \ 934169320Spiso methodID,\ 935169320Spiso args); \ 936151658Sjhb functionExit(env); \ 937169320Spiso return result; \ 93872759SjhbJNI_END \ 93966698Sjhb\ 94066698SjhbJNI_ENTRY_CHECKED(ResultType, \ 94166698Sjhb checked_jni_CallNonvirtual##Result##MethodA(JNIEnv *env, \ 942151699Sjhb jobject obj, \ 943151699Sjhb jclass clazz, \ 944151699Sjhb jmethodID methodID, \ 945151699Sjhb const jvalue * args)) \ 946151699Sjhb functionEnter(thr); \ 947151699Sjhb IN_VM( \ 948151699Sjhb jniCheck::validate_call_object(thr, obj, methodID); \ 949151699Sjhb jniCheck::validate_call_class(thr, clazz, methodID); \ 950151699Sjhb ) \ 951151699Sjhb ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodA(env, \ 952151699Sjhb obj, \ 953151699Sjhb clazz, \ 954151699Sjhb methodID,\ 955169320Spiso args); \ 956151658Sjhb functionExit(env); \ 957169320Spiso return result; \ 958169320SpisoJNI_END 959169320Spiso 960169320SpisoWRAPPER_CallNonvirtualMethod(jobject,Object) 961169320SpisoWRAPPER_CallNonvirtualMethod(jboolean,Boolean) 962169320SpisoWRAPPER_CallNonvirtualMethod(jbyte,Byte) 963169320SpisoWRAPPER_CallNonvirtualMethod(jshort,Short) 964169320SpisoWRAPPER_CallNonvirtualMethod(jchar,Char) 965169320SpisoWRAPPER_CallNonvirtualMethod(jint,Int) 966169320SpisoWRAPPER_CallNonvirtualMethod(jlong,Long) 967169320SpisoWRAPPER_CallNonvirtualMethod(jfloat,Float) 968169320SpisoWRAPPER_CallNonvirtualMethod(jdouble,Double) 969169320Spiso 970169320SpisoJNI_ENTRY_CHECKED(void, 971169320Spiso checked_jni_CallNonvirtualVoidMethod(JNIEnv *env, 972169320Spiso jobject obj, 973169320Spiso jclass clazz, 974169320Spiso jmethodID methodID, 975169320Spiso ...)) 976169320Spiso functionEnter(thr); 977169320Spiso va_list args; 978169320Spiso IN_VM( 979169320Spiso jniCheck::validate_call_object(thr, obj, methodID); 980169320Spiso jniCheck::validate_call_class(thr, clazz, methodID); 981169320Spiso ) 982169320Spiso va_start(args,methodID); 983169320Spiso UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args); 984169320Spiso va_end(args); 985169320Spiso functionExit(env); 986169320SpisoJNI_END 987169320Spiso 988169320SpisoJNI_ENTRY_CHECKED(void, 989151658Sjhb checked_jni_CallNonvirtualVoidMethodV(JNIEnv *env, 990151658Sjhb jobject obj, 991151658Sjhb jclass clazz, 992151658Sjhb jmethodID methodID, 993151658Sjhb va_list args)) 994151658Sjhb functionEnter(thr); 995151658Sjhb IN_VM( 996151658Sjhb jniCheck::validate_call_object(thr, obj, methodID); 997151658Sjhb jniCheck::validate_call_class(thr, clazz, methodID); 998151658Sjhb ) 999151658Sjhb UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args); 1000151658Sjhb functionExit(env); 1001151658SjhbJNI_END 1002151658Sjhb 1003151658SjhbJNI_ENTRY_CHECKED(void, 1004151658Sjhb checked_jni_CallNonvirtualVoidMethodA(JNIEnv *env, 1005151658Sjhb jobject obj, 1006151658Sjhb jclass clazz, 1007151658Sjhb jmethodID methodID, 1008151658Sjhb const jvalue * args)) 1009151658Sjhb functionEnter(thr); 1010151658Sjhb IN_VM( 1011167080Spiso jniCheck::validate_call_object(thr, obj, methodID); 1012167080Spiso jniCheck::validate_call_class(thr, clazz, methodID); 1013167080Spiso ) 1014167080Spiso UNCHECKED()->CallNonvirtualVoidMethodA(env,obj,clazz,methodID,args); 1015151658Sjhb functionExit(env); 1016151658SjhbJNI_END 1017151658Sjhb 1018151658SjhbJNI_ENTRY_CHECKED(jfieldID, 1019151658Sjhb checked_jni_GetFieldID(JNIEnv *env, 1020151658Sjhb jclass clazz, 1021151658Sjhb const char *name, 1022151658Sjhb const char *sig)) 1023151658Sjhb functionEnter(thr); 1024151658Sjhb IN_VM( 1025151658Sjhb jniCheck::validate_class(thr, clazz, false); 1026151658Sjhb ) 1027151658Sjhb jfieldID result = UNCHECKED()->GetFieldID(env,clazz,name,sig); 1028151658Sjhb functionExit(env); 1029169320Spiso return result; 1030169320SpisoJNI_END 1031151658Sjhb 1032151658Sjhb#define WRAPPER_GetField(ReturnType,Result,FieldType) \ 1033151658SjhbJNI_ENTRY_CHECKED(ReturnType, \ 1034151658Sjhb checked_jni_Get##Result##Field(JNIEnv *env, \ 1035151658Sjhb jobject obj, \ 1036151658Sjhb jfieldID fieldID)) \ 1037151658Sjhb functionEnter(thr); \ 1038151658Sjhb IN_VM( \ 1039151658Sjhb checkInstanceFieldID(thr, fieldID, obj, FieldType); \ 1040151658Sjhb ) \ 1041151658Sjhb ReturnType result = UNCHECKED()->Get##Result##Field(env,obj,fieldID); \ 1042151658Sjhb functionExit(env); \ 1043151658Sjhb return result; \ 1044151658SjhbJNI_END 1045151658Sjhb 1046151658SjhbWRAPPER_GetField(jobject, Object, T_OBJECT) 1047151658SjhbWRAPPER_GetField(jboolean, Boolean, T_BOOLEAN) 1048151658SjhbWRAPPER_GetField(jbyte, Byte, T_BYTE) 1049151658SjhbWRAPPER_GetField(jshort, Short, T_SHORT) 1050151658SjhbWRAPPER_GetField(jchar, Char, T_CHAR) 1051167173SjhbWRAPPER_GetField(jint, Int, T_INT) 1052167173SjhbWRAPPER_GetField(jlong, Long, T_LONG) 1053168850SnjlWRAPPER_GetField(jfloat, Float, T_FLOAT) 1054168850SnjlWRAPPER_GetField(jdouble, Double, T_DOUBLE) 1055151658Sjhb 1056168850Snjl#define WRAPPER_SetField(ValueType,Result,FieldType) \ 1057151658SjhbJNI_ENTRY_CHECKED(void, \ 1058151658Sjhb checked_jni_Set##Result##Field(JNIEnv *env, \ 1059167173Sjhb jobject obj, \ 1060151658Sjhb jfieldID fieldID, \ 1061151658Sjhb ValueType val)) \ 1062151658Sjhb functionEnter(thr); \ 1063151658Sjhb IN_VM( \ 1064151658Sjhb checkInstanceFieldID(thr, fieldID, obj, FieldType); \ 1065151658Sjhb ) \ 1066151658Sjhb UNCHECKED()->Set##Result##Field(env,obj,fieldID,val); \ 1067151658Sjhb functionExit(env); \ 1068151658SjhbJNI_END 1069151658Sjhb 1070151658SjhbWRAPPER_SetField(jobject, Object, T_OBJECT) 1071169320SpisoWRAPPER_SetField(jboolean, Boolean, T_BOOLEAN) 107266698SjhbWRAPPER_SetField(jbyte, Byte, T_BYTE) 107372237SjhbWRAPPER_SetField(jshort, Short, T_SHORT) 107466698SjhbWRAPPER_SetField(jchar, Char, T_CHAR) 1075104094SphkWRAPPER_SetField(jint, Int, T_INT) 107672237SjhbWRAPPER_SetField(jlong, Long, T_LONG) 107766698SjhbWRAPPER_SetField(jfloat, Float, T_FLOAT) 1078151658SjhbWRAPPER_SetField(jdouble, Double, T_DOUBLE) 1079151658Sjhb 108083366Sjulian 108172237SjhbJNI_ENTRY_CHECKED(jmethodID, 1082151658Sjhb checked_jni_GetStaticMethodID(JNIEnv *env, 108383366Sjulian jclass clazz, 108483366Sjulian const char *name, 1085151658Sjhb const char *sig)) 1086151658Sjhb functionEnter(thr); 108787593Sobrien IN_VM( 1088151658Sjhb jniCheck::validate_class(thr, clazz, false); 1089151658Sjhb ) 109066698Sjhb jmethodID result = UNCHECKED()->GetStaticMethodID(env,clazz,name,sig); 109167551Sjhb functionExit(env); 109267551Sjhb return result; 109367551SjhbJNI_END 109467551Sjhb 109566698Sjhb#define WRAPPER_CallStaticMethod(ReturnType,Result) \ 109672237SjhbJNI_ENTRY_CHECKED(ReturnType, \ 109772237Sjhb checked_jni_CallStatic##Result##Method(JNIEnv *env, \ 109872237Sjhb jclass clazz, \ 109972237Sjhb jmethodID methodID, \ 1100151658Sjhb ...)) \ 1101173004Sjulian functionEnter(thr); \ 110272237Sjhb va_list args; \ 1103173004Sjulian IN_VM( \ 110472237Sjhb jniCheck::validate_jmethod_id(thr, methodID); \ 110572237Sjhb jniCheck::validate_class(thr, clazz, false); \ 1106151658Sjhb ) \ 1107151658Sjhb va_start(args,methodID); \ 1108151658Sjhb ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \ 1109151658Sjhb clazz, \ 1110151658Sjhb methodID, \ 111172237Sjhb args); \ 111267551Sjhb va_end(args); \ 1113151658Sjhb functionExit(env); \ 1114151658Sjhb return result; \ 1115151658SjhbJNI_END \ 1116151658Sjhb\ 111767551SjhbJNI_ENTRY_CHECKED(ReturnType, \ 111872237Sjhb checked_jni_CallStatic##Result##MethodV(JNIEnv *env, \ 1119151658Sjhb jclass clazz, \ 112066698Sjhb jmethodID methodID,\ 1121128331Sjhb va_list args)) \ 1122128331Sjhb functionEnter(thr); \ 112367551Sjhb IN_VM( \ 112466698Sjhb jniCheck::validate_jmethod_id(thr, methodID); \ 112566698Sjhb jniCheck::validate_class(thr, clazz, false); \ 112667551Sjhb ) \ 112766698Sjhb ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \ 112866698Sjhb clazz, \ 1129170307Sjeff methodID, \ 1130151658Sjhb args); \ 1131128331Sjhb functionExit(env); \ 1132151658Sjhb return result; \ 1133131473SjhbJNI_END \ 113466698Sjhb\ 1135170307SjeffJNI_ENTRY_CHECKED(ReturnType, \ 113666698Sjhb checked_jni_CallStatic##Result##MethodA(JNIEnv *env, \ 113766698Sjhb jclass clazz, \ 1138169320Spiso jmethodID methodID, \ 1139169320Spiso const jvalue *args)) \ 1140169320Spiso functionEnter(thr); \ 1141169320Spiso IN_VM( \ 1142169320Spiso jniCheck::validate_jmethod_id(thr, methodID); \ 1143169320Spiso jniCheck::validate_class(thr, clazz, false); \ 1144169320Spiso ) \ 1145169320Spiso ReturnType result = UNCHECKED()->CallStatic##Result##MethodA(env, \ 1146169320Spiso clazz, \ 1147169320Spiso methodID, \ 1148169320Spiso args); \ 1149169320Spiso functionExit(env); \ 1150169320Spiso return result; \ 115166698SjhbJNI_END 1152169320Spiso 1153169320SpisoWRAPPER_CallStaticMethod(jobject,Object) 1154169320SpisoWRAPPER_CallStaticMethod(jboolean,Boolean) 1155169320SpisoWRAPPER_CallStaticMethod(jbyte,Byte) 1156169320SpisoWRAPPER_CallStaticMethod(jshort,Short) 1157169320SpisoWRAPPER_CallStaticMethod(jchar,Char) 1158169320SpisoWRAPPER_CallStaticMethod(jint,Int) 1159169320SpisoWRAPPER_CallStaticMethod(jlong,Long) 1160169320SpisoWRAPPER_CallStaticMethod(jfloat,Float) 1161169320SpisoWRAPPER_CallStaticMethod(jdouble,Double) 1162169320Spiso 1163169320SpisoJNI_ENTRY_CHECKED(void, 1164169320Spiso checked_jni_CallStaticVoidMethod(JNIEnv *env, 1165169320Spiso jclass cls, 1166169320Spiso jmethodID methodID, 1167169320Spiso ...)) 1168169320Spiso functionEnter(thr); 1169169320Spiso va_list args; 1170169320Spiso IN_VM( 1171169320Spiso jniCheck::validate_jmethod_id(thr, methodID); 1172173004Sjulian jniCheck::validate_class(thr, cls, false); 1173169320Spiso ) 1174173004Sjulian va_start(args,methodID); 1175169320Spiso UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args); 1176169320Spiso va_end(args); 1177169320Spiso functionExit(env); 1178169320SpisoJNI_END 1179169320Spiso 1180169320SpisoJNI_ENTRY_CHECKED(void, 1181169320Spiso checked_jni_CallStaticVoidMethodV(JNIEnv *env, 1182169320Spiso jclass cls, 1183169320Spiso jmethodID methodID, 1184169320Spiso va_list args)) 1185169320Spiso functionEnter(thr); 1186169320Spiso IN_VM( 1187169320Spiso jniCheck::validate_jmethod_id(thr, methodID); 1188169320Spiso jniCheck::validate_class(thr, cls, false); 1189169320Spiso ) 1190169320Spiso UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args); 1191169320Spiso functionExit(env); 1192169320SpisoJNI_END 1193169320Spiso 1194169320SpisoJNI_ENTRY_CHECKED(void, 1195169320Spiso checked_jni_CallStaticVoidMethodA(JNIEnv *env, 1196169320Spiso jclass cls, 1197169320Spiso jmethodID methodID, 1198169320Spiso const jvalue * args)) 1199169320Spiso functionEnter(thr); 1200169320Spiso IN_VM( 1201169320Spiso jniCheck::validate_jmethod_id(thr, methodID); 1202169320Spiso jniCheck::validate_class(thr, cls, false); 1203170307Sjeff ) 1204169320Spiso UNCHECKED()->CallStaticVoidMethodA(env,cls,methodID,args); 1205169320Spiso functionExit(env); 1206169320SpisoJNI_END 1207169320Spiso 1208169320SpisoJNI_ENTRY_CHECKED(jfieldID, 1209170307Sjeff checked_jni_GetStaticFieldID(JNIEnv *env, 1210169320Spiso jclass clazz, 1211169320Spiso const char *name, 1212169320Spiso const char *sig)) 1213169320Spiso functionEnter(thr); 1214169320Spiso IN_VM( 1215169320Spiso jniCheck::validate_class(thr, clazz, false); 1216169320Spiso ) 1217169320Spiso jfieldID result = UNCHECKED()->GetStaticFieldID(env,clazz,name,sig); 1218169320Spiso functionExit(env); 1219169320Spiso return result; 1220169320SpisoJNI_END 1221169320Spiso 1222169320Spiso#define WRAPPER_GetStaticField(ReturnType,Result,FieldType) \ 1223169320SpisoJNI_ENTRY_CHECKED(ReturnType, \ 1224169320Spiso checked_jni_GetStatic##Result##Field(JNIEnv *env, \ 1225169320Spiso jclass clazz, \ 1226169320Spiso jfieldID fieldID)) \ 1227169320Spiso functionEnter(thr); \ 1228169320Spiso IN_VM( \ 1229169320Spiso jniCheck::validate_class(thr, clazz, false); \ 1230169320Spiso checkStaticFieldID(thr, fieldID, clazz, FieldType); \ 1231169320Spiso ) \ 1232169320Spiso ReturnType result = UNCHECKED()->GetStatic##Result##Field(env, \ 1233169320Spiso clazz, \ 1234169320Spiso fieldID); \ 1235169320Spiso functionExit(env); \ 1236169320Spiso return result; \ 1237169320SpisoJNI_END 1238169320Spiso 1239169320SpisoWRAPPER_GetStaticField(jobject, Object, T_OBJECT) 1240169320SpisoWRAPPER_GetStaticField(jboolean, Boolean, T_BOOLEAN) 1241169320SpisoWRAPPER_GetStaticField(jbyte, Byte, T_BYTE) 1242169320SpisoWRAPPER_GetStaticField(jshort, Short, T_SHORT) 1243169320SpisoWRAPPER_GetStaticField(jchar, Char, T_CHAR) 1244169320SpisoWRAPPER_GetStaticField(jint, Int, T_INT) 1245169320SpisoWRAPPER_GetStaticField(jlong, Long, T_LONG) 1246169320SpisoWRAPPER_GetStaticField(jfloat, Float, T_FLOAT) 1247169320SpisoWRAPPER_GetStaticField(jdouble, Double, T_DOUBLE) 1248169320Spiso 1249169320Spiso#define WRAPPER_SetStaticField(ValueType,Result,FieldType) \ 1250169320SpisoJNI_ENTRY_CHECKED(void, \ 1251169320Spiso checked_jni_SetStatic##Result##Field(JNIEnv *env, \ 1252169320Spiso jclass clazz, \ 1253169320Spiso jfieldID fieldID, \ 1254169320Spiso ValueType value)) \ 1255169320Spiso functionEnter(thr); \ 1256169320Spiso IN_VM( \ 1257169320Spiso jniCheck::validate_class(thr, clazz, false); \ 1258169320Spiso checkStaticFieldID(thr, fieldID, clazz, FieldType); \ 1259169320Spiso ) \ 1260169320Spiso UNCHECKED()->SetStatic##Result##Field(env,clazz,fieldID,value); \ 1261169320Spiso functionExit(env); \ 1262169320SpisoJNI_END 1263169320Spiso 1264169320SpisoWRAPPER_SetStaticField(jobject, Object, T_OBJECT) 1265169320SpisoWRAPPER_SetStaticField(jboolean, Boolean, T_BOOLEAN) 1266169320SpisoWRAPPER_SetStaticField(jbyte, Byte, T_BYTE) 1267169320SpisoWRAPPER_SetStaticField(jshort, Short, T_SHORT) 1268169320SpisoWRAPPER_SetStaticField(jchar, Char, T_CHAR) 1269169320SpisoWRAPPER_SetStaticField(jint, Int, T_INT) 1270169320SpisoWRAPPER_SetStaticField(jlong, Long, T_LONG) 1271169320SpisoWRAPPER_SetStaticField(jfloat, Float, T_FLOAT) 1272169320SpisoWRAPPER_SetStaticField(jdouble, Double, T_DOUBLE) 1273169320Spiso 1274169320Spiso 1275169320SpisoJNI_ENTRY_CHECKED(jstring, 1276169320Spiso checked_jni_NewString(JNIEnv *env, 1277169320Spiso const jchar *unicode, 1278169320Spiso jsize len)) 1279169320Spiso functionEnter(thr); 1280169320Spiso jstring result = UNCHECKED()->NewString(env,unicode,len); 1281169320Spiso functionExit(env); 1282169320Spiso return result; 1283169320SpisoJNI_END 1284169320Spiso 1285169320SpisoJNI_ENTRY_CHECKED(jsize, 1286169320Spiso checked_jni_GetStringLength(JNIEnv *env, 1287169320Spiso jstring str)) 1288169320Spiso functionEnter(thr); 1289169320Spiso IN_VM( 1290169320Spiso checkString(thr, str); 1291169320Spiso ) 1292169320Spiso jsize result = UNCHECKED()->GetStringLength(env,str); 1293169320Spiso functionExit(env); 1294169320Spiso return result; 1295169320SpisoJNI_END 1296169320Spiso 1297169320Spiso// Arbitrary (but well-known) tag 1298169320Spisoconst jint STRING_TAG = 0x47114711; 1299169320Spiso 1300169320SpisoJNI_ENTRY_CHECKED(const jchar *, 1301169320Spiso checked_jni_GetStringChars(JNIEnv *env, 1302169320Spiso jstring str, 1303169320Spiso jboolean *isCopy)) 1304169320Spiso functionEnter(thr); 1305169320Spiso IN_VM( 1306169320Spiso checkString(thr, str); 1307169320Spiso ) 1308169320Spiso const jchar *result = UNCHECKED()->GetStringChars(env,str,isCopy); 1309169320Spiso assert (isCopy == NULL || *isCopy == JNI_TRUE, "GetStringChars didn't return a copy as expected"); 1310169320Spiso 1311169320Spiso size_t len = UNCHECKED()->GetStringLength(env,str) + 1; // + 1 for NULL termination 1312169320Spiso jint* tagLocation = (jint*) AllocateHeap(len * sizeof(jchar) + sizeof(jint), "checked_jni_GetStringChars"); 1313169320Spiso *tagLocation = STRING_TAG; 1314169320Spiso jchar* newResult = (jchar*) (tagLocation + 1); 1315169320Spiso memcpy(newResult, result, len * sizeof(jchar)); 1316169320Spiso // Avoiding call to UNCHECKED()->ReleaseStringChars() since that will fire unexpected dtrace probes 1317169320Spiso // Note that the dtrace arguments for the allocated memory will not match up with this solution. 1318169320Spiso FreeHeap((char*)result); 1319169320Spiso 1320169320Spiso functionExit(env); 1321169320Spiso return newResult; 1322169320SpisoJNI_END 1323169320Spiso 1324169320SpisoJNI_ENTRY_CHECKED(void, 1325169320Spiso checked_jni_ReleaseStringChars(JNIEnv *env, 1326169320Spiso jstring str, 1327169320Spiso const jchar *chars)) 1328169320Spiso functionEnterExceptionAllowed(thr); 1329169320Spiso IN_VM( 1330169320Spiso checkString(thr, str); 1331169320Spiso ) 1332169320Spiso if (chars == NULL) { 1333169320Spiso // still do the unchecked call to allow dtrace probes 1334169320Spiso UNCHECKED()->ReleaseStringChars(env,str,chars); 1335169320Spiso } 1336169320Spiso else { 1337169320Spiso jint* tagLocation = ((jint*) chars) - 1; 1338169320Spiso if (*tagLocation != STRING_TAG) { 1339169320Spiso NativeReportJNIFatalError(thr, "ReleaseStringChars called on something not allocated by GetStringChars"); 1340169320Spiso } 1341169320Spiso UNCHECKED()->ReleaseStringChars(env,str,(const jchar*)tagLocation); 1342169320Spiso } 1343169320Spiso functionExit(env); 1344169320SpisoJNI_END 1345121482Sjhb 134672237SjhbJNI_ENTRY_CHECKED(jstring, 1347121482Sjhb checked_jni_NewStringUTF(JNIEnv *env, 1348121482Sjhb const char *utf)) 1349121482Sjhb functionEnter(thr); 1350151658Sjhb jstring result = UNCHECKED()->NewStringUTF(env,utf); 1351121482Sjhb functionExit(env); 1352121482Sjhb return result; 1353121482SjhbJNI_END 1354121482Sjhb 1355121482SjhbJNI_ENTRY_CHECKED(jsize, 1356121482Sjhb checked_jni_GetStringUTFLength(JNIEnv *env, 1357121482Sjhb jstring str)) 1358121482Sjhb functionEnter(thr); 1359121482Sjhb IN_VM( 1360121482Sjhb checkString(thr, str); 1361121482Sjhb ) 1362121482Sjhb jsize result = UNCHECKED()->GetStringUTFLength(env,str); 1363121482Sjhb functionExit(env); 1364121482Sjhb return result; 1365121482SjhbJNI_END 1366121482Sjhb 1367121482Sjhb// Arbitrary (but well-known) tag - different than GetStringChars 1368121482Sjhbconst jint STRING_UTF_TAG = 0x48124812; 1369121482Sjhb 1370121482SjhbJNI_ENTRY_CHECKED(const char *, 1371121482Sjhb checked_jni_GetStringUTFChars(JNIEnv *env, 1372121482Sjhb jstring str, 1373121482Sjhb jboolean *isCopy)) 1374121482Sjhb functionEnter(thr); 1375121482Sjhb IN_VM( 1376121482Sjhb checkString(thr, str); 1377121482Sjhb ) 1378121482Sjhb const char *result = UNCHECKED()->GetStringUTFChars(env,str,isCopy); 1379121482Sjhb assert (isCopy == NULL || *isCopy == JNI_TRUE, "GetStringUTFChars didn't return a copy as expected"); 1380121482Sjhb 1381121482Sjhb size_t len = strlen(result) + 1; // + 1 for NULL termination 1382121482Sjhb jint* tagLocation = (jint*) AllocateHeap(len + sizeof(jint), "checked_jni_GetStringUTFChars"); 1383121482Sjhb *tagLocation = STRING_UTF_TAG; 1384121482Sjhb char* newResult = (char*) (tagLocation + 1); 1385121482Sjhb strcpy(newResult, result); 1386121482Sjhb // Avoiding call to UNCHECKED()->ReleaseStringUTFChars() since that will fire unexpected dtrace probes 1387121482Sjhb // Note that the dtrace arguments for the allocated memory will not match up with this solution. 1388121482Sjhb FreeHeap((char*)result); 1389121482Sjhb 1390166901Spiso functionExit(env); 1391121482Sjhb return newResult; 1392121482SjhbJNI_END 1393121482Sjhb 1394121482SjhbJNI_ENTRY_CHECKED(void, 1395121482Sjhb checked_jni_ReleaseStringUTFChars(JNIEnv *env, 1396121482Sjhb jstring str, 1397121482Sjhb const char* chars)) 1398121482Sjhb functionEnterExceptionAllowed(thr); 1399121482Sjhb IN_VM( 1400121482Sjhb checkString(thr, str); 1401121482Sjhb ) 1402121482Sjhb if (chars == NULL) { 1403121482Sjhb // still do the unchecked call to allow dtrace probes 1404121482Sjhb UNCHECKED()->ReleaseStringUTFChars(env,str,chars); 1405121482Sjhb } 1406121482Sjhb else { 1407121482Sjhb jint* tagLocation = ((jint*) chars) - 1; 1408121482Sjhb if (*tagLocation != STRING_UTF_TAG) { 1409121482Sjhb NativeReportJNIFatalError(thr, "ReleaseStringUTFChars called on something not allocated by GetStringUTFChars"); 1410121482Sjhb } 1411121482Sjhb UNCHECKED()->ReleaseStringUTFChars(env,str,(const char*)tagLocation); 1412121482Sjhb } 1413121482Sjhb functionExit(env); 1414121482SjhbJNI_END 1415121482Sjhb 1416121482SjhbJNI_ENTRY_CHECKED(jsize, 1417121482Sjhb checked_jni_GetArrayLength(JNIEnv *env, 1418121482Sjhb jarray array)) 1419121482Sjhb functionEnter(thr); 1420121482Sjhb IN_VM( 1421121482Sjhb checkArray(thr, array, -1); 1422121482Sjhb ) 1423121482Sjhb jsize result = UNCHECKED()->GetArrayLength(env,array); 1424121482Sjhb functionExit(env); 1425121482Sjhb return result; 1426121482SjhbJNI_END 1427121482Sjhb 1428121482SjhbJNI_ENTRY_CHECKED(jobjectArray, 1429151658Sjhb checked_jni_NewObjectArray(JNIEnv *env, 1430121482Sjhb jsize len, 1431121482Sjhb jclass clazz, 1432151658Sjhb jobject init)) 1433121482Sjhb functionEnter(thr); 1434151658Sjhb jobjectArray result = UNCHECKED()->NewObjectArray(env,len,clazz,init); 1435151658Sjhb functionExit(env); 1436121482Sjhb return result; 1437121482SjhbJNI_END 1438151658Sjhb 1439151658SjhbJNI_ENTRY_CHECKED(jobject, 1440151658Sjhb checked_jni_GetObjectArrayElement(JNIEnv *env, 1441151658Sjhb jobjectArray array, 1442151658Sjhb jsize index)) 1443151658Sjhb functionEnter(thr); 1444151658Sjhb IN_VM( 1445151658Sjhb checkArray(thr, array, T_OBJECT); 1446121482Sjhb ) 1447121482Sjhb jobject result = UNCHECKED()->GetObjectArrayElement(env,array,index); 1448151658Sjhb functionExit(env); 1449121482Sjhb return result; 1450121482SjhbJNI_END 1451121482Sjhb 1452151658SjhbJNI_ENTRY_CHECKED(void, 1453121482Sjhb checked_jni_SetObjectArrayElement(JNIEnv *env, 1454121482Sjhb jobjectArray array, 1455121482Sjhb jsize index, 1456121482Sjhb jobject val)) 1457121482Sjhb functionEnter(thr); 1458151658Sjhb IN_VM( 1459121482Sjhb checkArray(thr, array, T_OBJECT); 1460121482Sjhb ) 1461151658Sjhb UNCHECKED()->SetObjectArrayElement(env,array,index,val); 1462121482Sjhb functionExit(env); 1463121482SjhbJNI_END 1464151658Sjhb 1465121482Sjhb#define WRAPPER_NewScalarArray(Return, Result) \ 1466121482SjhbJNI_ENTRY_CHECKED(Return, \ 1467121482Sjhb checked_jni_New##Result##Array(JNIEnv *env, \ 1468121482Sjhb jsize len)) \ 1469121482Sjhb functionEnter(thr); \ 1470121482Sjhb Return result = UNCHECKED()->New##Result##Array(env,len); \ 1471121482Sjhb functionExit(env); \ 1472121482Sjhb return (Return) result; \ 1473121482SjhbJNI_END 1474151658Sjhb 1475121482SjhbWRAPPER_NewScalarArray(jbooleanArray, Boolean) 1476121482SjhbWRAPPER_NewScalarArray(jbyteArray, Byte) 1477151658SjhbWRAPPER_NewScalarArray(jshortArray, Short) 1478151658SjhbWRAPPER_NewScalarArray(jcharArray, Char) 1479151658SjhbWRAPPER_NewScalarArray(jintArray, Int) 1480151658SjhbWRAPPER_NewScalarArray(jlongArray, Long) 1481151658SjhbWRAPPER_NewScalarArray(jfloatArray, Float) 1482151658SjhbWRAPPER_NewScalarArray(jdoubleArray, Double) 1483151658Sjhb 1484160312Sjhb#define WRAPPER_GetScalarArrayElements(ElementTag,ElementType,Result) \ 1485151658SjhbJNI_ENTRY_CHECKED(ElementType *, \ 1486151658Sjhb checked_jni_Get##Result##ArrayElements(JNIEnv *env, \ 1487151658Sjhb ElementType##Array array, \ 1488151658Sjhb jboolean *isCopy)) \ 1489151658Sjhb functionEnter(thr); \ 1490151658Sjhb IN_VM( \ 1491151658Sjhb checkArray(thr, array, ElementTag); \ 1492160312Sjhb ) \ 1493160312Sjhb ElementType *result = UNCHECKED()->Get##Result##ArrayElements(env, \ 1494151658Sjhb array, \ 1495151658Sjhb isCopy); \ 1496121482Sjhb functionExit(env); \ 1497121482Sjhb return result; \ 1498121482SjhbJNI_END 149967551Sjhb 150066698SjhbWRAPPER_GetScalarArrayElements(T_BOOLEAN, jboolean, Boolean) 150167551SjhbWRAPPER_GetScalarArrayElements(T_BYTE, jbyte, Byte) 150272237SjhbWRAPPER_GetScalarArrayElements(T_SHORT, jshort, Short) 150367551SjhbWRAPPER_GetScalarArrayElements(T_CHAR, jchar, Char) 1504113613SjhbWRAPPER_GetScalarArrayElements(T_INT, jint, Int) 150572237SjhbWRAPPER_GetScalarArrayElements(T_LONG, jlong, Long) 1506151658SjhbWRAPPER_GetScalarArrayElements(T_FLOAT, jfloat, Float) 150772237SjhbWRAPPER_GetScalarArrayElements(T_DOUBLE, jdouble, Double) 1508117128Sscottl 150972237Sjhb#define WRAPPER_ReleaseScalarArrayElements(ElementTag,ElementType,Result,Tag) \ 151072759SjhbJNI_ENTRY_CHECKED(void, \ 1511151658Sjhb checked_jni_Release##Result##ArrayElements(JNIEnv *env, \ 1512113613Sjhb ElementType##Array array, \ 1513113613Sjhb ElementType *elems, \ 1514113613Sjhb jint mode)) \ 151566698Sjhb functionEnterExceptionAllowed(thr); \ 151672237Sjhb IN_VM( \ 151766698Sjhb checkArray(thr, array, ElementTag); \ 1518151658Sjhb ASSERT_OOPS_ALLOWED; \ 151977582Stmm typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \ 152077582Stmm /* cannot check validity of copy, unless every request is logged by 152177582Stmm * checking code. Implementation of this check is deferred until a 152277582Stmm * subsequent release. 152377582Stmm */ \ 152477582Stmm ) \ 152577582Stmm UNCHECKED()->Release##Result##ArrayElements(env,array,elems,mode); \ 152677582Stmm functionExit(env); \ 152777582StmmJNI_END 152877582Stmm 152977582StmmWRAPPER_ReleaseScalarArrayElements(T_BOOLEAN,jboolean, Boolean, bool) 1530151658SjhbWRAPPER_ReleaseScalarArrayElements(T_BYTE, jbyte, Byte, byte) 153177582StmmWRAPPER_ReleaseScalarArrayElements(T_SHORT, jshort, Short, short) 153277582StmmWRAPPER_ReleaseScalarArrayElements(T_CHAR, jchar, Char, char) 153377582StmmWRAPPER_ReleaseScalarArrayElements(T_INT, jint, Int, int) 153477582StmmWRAPPER_ReleaseScalarArrayElements(T_LONG, jlong, Long, long) 153577582StmmWRAPPER_ReleaseScalarArrayElements(T_FLOAT, jfloat, Float, float) 153677582StmmWRAPPER_ReleaseScalarArrayElements(T_DOUBLE, jdouble, Double, double) 153777582Stmm 153877582Stmm#define WRAPPER_GetScalarArrayRegion(ElementTag,ElementType,Result) \ 153977582StmmJNI_ENTRY_CHECKED(void, \ 1540151658Sjhb checked_jni_Get##Result##ArrayRegion(JNIEnv *env, \ 154177582Stmm ElementType##Array array, \ 154277582Stmm jsize start, \ 154377582Stmm jsize len, \ 154477582Stmm ElementType *buf)) \ 154577582Stmm functionEnter(thr); \ 1546121482Sjhb IN_VM( \ 1547121482Sjhb checkArray(thr, array, ElementTag); \ 1548121482Sjhb ) \ 1549121482Sjhb UNCHECKED()->Get##Result##ArrayRegion(env,array,start,len,buf); \ 1550121482Sjhb functionExit(env); \ 1551121482SjhbJNI_END 1552121482Sjhb 1553121482SjhbWRAPPER_GetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean) 1554121482SjhbWRAPPER_GetScalarArrayRegion(T_BYTE, jbyte, Byte) 1555121482SjhbWRAPPER_GetScalarArrayRegion(T_SHORT, jshort, Short) 1556121482SjhbWRAPPER_GetScalarArrayRegion(T_CHAR, jchar, Char) 1557160312SjhbWRAPPER_GetScalarArrayRegion(T_INT, jint, Int) 1558121482SjhbWRAPPER_GetScalarArrayRegion(T_LONG, jlong, Long) 1559121482SjhbWRAPPER_GetScalarArrayRegion(T_FLOAT, jfloat, Float) 1560121482SjhbWRAPPER_GetScalarArrayRegion(T_DOUBLE, jdouble, Double) 1561121482Sjhb 1562121482Sjhb#define WRAPPER_SetScalarArrayRegion(ElementTag,ElementType,Result) \ 1563121482SjhbJNI_ENTRY_CHECKED(void, \ 1564121482Sjhb checked_jni_Set##Result##ArrayRegion(JNIEnv *env, \ 1565121482Sjhb ElementType##Array array, \ 1566 jsize start, \ 1567 jsize len, \ 1568 const ElementType *buf)) \ 1569 functionEnter(thr); \ 1570 IN_VM( \ 1571 checkArray(thr, array, ElementTag); \ 1572 ) \ 1573 UNCHECKED()->Set##Result##ArrayRegion(env,array,start,len,buf); \ 1574 functionExit(env); \ 1575JNI_END 1576 1577WRAPPER_SetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean) 1578WRAPPER_SetScalarArrayRegion(T_BYTE, jbyte, Byte) 1579WRAPPER_SetScalarArrayRegion(T_SHORT, jshort, Short) 1580WRAPPER_SetScalarArrayRegion(T_CHAR, jchar, Char) 1581WRAPPER_SetScalarArrayRegion(T_INT, jint, Int) 1582WRAPPER_SetScalarArrayRegion(T_LONG, jlong, Long) 1583WRAPPER_SetScalarArrayRegion(T_FLOAT, jfloat, Float) 1584WRAPPER_SetScalarArrayRegion(T_DOUBLE, jdouble, Double) 1585 1586JNI_ENTRY_CHECKED(jint, 1587 checked_jni_RegisterNatives(JNIEnv *env, 1588 jclass clazz, 1589 const JNINativeMethod *methods, 1590 jint nMethods)) 1591 functionEnter(thr); 1592 jint result = UNCHECKED()->RegisterNatives(env,clazz,methods,nMethods); 1593 functionExit(env); 1594 return result; 1595JNI_END 1596 1597JNI_ENTRY_CHECKED(jint, 1598 checked_jni_UnregisterNatives(JNIEnv *env, 1599 jclass clazz)) 1600 functionEnter(thr); 1601 jint result = UNCHECKED()->UnregisterNatives(env,clazz); 1602 functionExit(env); 1603 return result; 1604JNI_END 1605 1606JNI_ENTRY_CHECKED(jint, 1607 checked_jni_MonitorEnter(JNIEnv *env, 1608 jobject obj)) 1609 functionEnter(thr); 1610 IN_VM( 1611 jniCheck::validate_object(thr, obj); 1612 ) 1613 jint result = UNCHECKED()->MonitorEnter(env,obj); 1614 functionExit(env); 1615 return result; 1616JNI_END 1617 1618JNI_ENTRY_CHECKED(jint, 1619 checked_jni_MonitorExit(JNIEnv *env, 1620 jobject obj)) 1621 functionEnterExceptionAllowed(thr); 1622 IN_VM( 1623 jniCheck::validate_object(thr, obj); 1624 ) 1625 jint result = UNCHECKED()->MonitorExit(env,obj); 1626 functionExit(env); 1627 return result; 1628JNI_END 1629 1630JNI_ENTRY_CHECKED(jint, 1631 checked_jni_GetJavaVM(JNIEnv *env, 1632 JavaVM **vm)) 1633 functionEnter(thr); 1634 jint result = UNCHECKED()->GetJavaVM(env,vm); 1635 functionExit(env); 1636 return result; 1637JNI_END 1638 1639JNI_ENTRY_CHECKED(void, 1640 checked_jni_GetStringRegion(JNIEnv *env, 1641 jstring str, 1642 jsize start, 1643 jsize len, 1644 jchar *buf)) 1645 functionEnter(thr); 1646 IN_VM( 1647 checkString(thr, str); 1648 ) 1649 UNCHECKED()->GetStringRegion(env, str, start, len, buf); 1650 functionExit(env); 1651JNI_END 1652 1653JNI_ENTRY_CHECKED(void, 1654 checked_jni_GetStringUTFRegion(JNIEnv *env, 1655 jstring str, 1656 jsize start, 1657 jsize len, 1658 char *buf)) 1659 functionEnter(thr); 1660 IN_VM( 1661 checkString(thr, str); 1662 ) 1663 UNCHECKED()->GetStringUTFRegion(env, str, start, len, buf); 1664 functionExit(env); 1665JNI_END 1666 1667JNI_ENTRY_CHECKED(void *, 1668 checked_jni_GetPrimitiveArrayCritical(JNIEnv *env, 1669 jarray array, 1670 jboolean *isCopy)) 1671 functionEnterCritical(thr); 1672 IN_VM( 1673 checkArray(thr, array, -1); 1674 ) 1675 void *result = UNCHECKED()->GetPrimitiveArrayCritical(env, array, isCopy); 1676 functionExit(env); 1677 return result; 1678JNI_END 1679 1680JNI_ENTRY_CHECKED(void, 1681 checked_jni_ReleasePrimitiveArrayCritical(JNIEnv *env, 1682 jarray array, 1683 void *carray, 1684 jint mode)) 1685 functionEnterCriticalExceptionAllowed(thr); 1686 IN_VM( 1687 checkArray(thr, array, -1); 1688 ) 1689 /* The Hotspot JNI code does not use the parameters, so just check the 1690 * array parameter as a minor sanity check 1691 */ 1692 UNCHECKED()->ReleasePrimitiveArrayCritical(env, array, carray, mode); 1693 functionExit(env); 1694JNI_END 1695 1696JNI_ENTRY_CHECKED(const jchar*, 1697 checked_jni_GetStringCritical(JNIEnv *env, 1698 jstring string, 1699 jboolean *isCopy)) 1700 functionEnterCritical(thr); 1701 IN_VM( 1702 checkString(thr, string); 1703 ) 1704 const jchar *result = UNCHECKED()->GetStringCritical(env, string, isCopy); 1705 functionExit(env); 1706 return result; 1707JNI_END 1708 1709JNI_ENTRY_CHECKED(void, 1710 checked_jni_ReleaseStringCritical(JNIEnv *env, 1711 jstring str, 1712 const jchar *chars)) 1713 functionEnterCriticalExceptionAllowed(thr); 1714 IN_VM( 1715 checkString(thr, str); 1716 ) 1717 /* The Hotspot JNI code does not use the parameters, so just check the 1718 * string parameter as a minor sanity check 1719 */ 1720 UNCHECKED()->ReleaseStringCritical(env, str, chars); 1721 functionExit(env); 1722JNI_END 1723 1724JNI_ENTRY_CHECKED(jweak, 1725 checked_jni_NewWeakGlobalRef(JNIEnv *env, 1726 jobject obj)) 1727 functionEnter(thr); 1728 IN_VM( 1729 if (obj != NULL) { 1730 jniCheck::validate_handle(thr, obj); 1731 } 1732 ) 1733 jweak result = UNCHECKED()->NewWeakGlobalRef(env, obj); 1734 functionExit(env); 1735 return result; 1736JNI_END 1737 1738JNI_ENTRY_CHECKED(void, 1739 checked_jni_DeleteWeakGlobalRef(JNIEnv *env, 1740 jweak ref)) 1741 functionEnterExceptionAllowed(thr); 1742 UNCHECKED()->DeleteWeakGlobalRef(env, ref); 1743 functionExit(env); 1744JNI_END 1745 1746JNI_ENTRY_CHECKED(jboolean, 1747 checked_jni_ExceptionCheck(JNIEnv *env)) 1748 functionEnterExceptionAllowed(thr); 1749 jboolean result = UNCHECKED()->ExceptionCheck(env); 1750 functionExit(env); 1751 return result; 1752JNI_END 1753 1754JNI_ENTRY_CHECKED(jobject, 1755 checked_jni_NewDirectByteBuffer(JNIEnv *env, 1756 void *address, 1757 jlong capacity)) 1758 functionEnter(thr); 1759 jobject result = UNCHECKED()->NewDirectByteBuffer(env, address, capacity); 1760 functionExit(env); 1761 return result; 1762JNI_END 1763 1764JNI_ENTRY_CHECKED(void *, 1765 checked_jni_GetDirectBufferAddress(JNIEnv *env, 1766 jobject buf)) 1767 functionEnter(thr); 1768 void* result = UNCHECKED()->GetDirectBufferAddress(env, buf); 1769 functionExit(env); 1770 return result; 1771JNI_END 1772 1773JNI_ENTRY_CHECKED(jlong, 1774 checked_jni_GetDirectBufferCapacity(JNIEnv *env, 1775 jobject buf)) 1776 functionEnter(thr); 1777 jlong result = UNCHECKED()->GetDirectBufferCapacity(env, buf); 1778 functionExit(env); 1779 return result; 1780JNI_END 1781 1782JNI_ENTRY_CHECKED(jobjectRefType, 1783 checked_jni_GetObjectRefType(JNIEnv *env, 1784 jobject obj)) 1785 functionEnter(thr); 1786 /* validate the object being passed */ 1787 IN_VM( 1788 jniCheck::validate_object(thr, obj); 1789 ) 1790 jobjectRefType result = UNCHECKED()->GetObjectRefType(env, obj); 1791 functionExit(env); 1792 return result; 1793JNI_END 1794 1795 1796JNI_ENTRY_CHECKED(jint, 1797 checked_jni_GetVersion(JNIEnv *env)) 1798 functionEnter(thr); 1799 jint result = UNCHECKED()->GetVersion(env); 1800 functionExit(env); 1801 return result; 1802JNI_END 1803 1804 1805 1806/* 1807 * Structure containing all checked jni functions 1808 */ 1809struct JNINativeInterface_ checked_jni_NativeInterface = { 1810 NULL, 1811 NULL, 1812 NULL, 1813 1814 NULL, 1815 1816 checked_jni_GetVersion, 1817 1818 checked_jni_DefineClass, 1819 checked_jni_FindClass, 1820 1821 checked_jni_FromReflectedMethod, 1822 checked_jni_FromReflectedField, 1823 1824 checked_jni_ToReflectedMethod, 1825 1826 checked_jni_GetSuperclass, 1827 checked_jni_IsAssignableFrom, 1828 1829 checked_jni_ToReflectedField, 1830 1831 checked_jni_Throw, 1832 checked_jni_ThrowNew, 1833 checked_jni_ExceptionOccurred, 1834 checked_jni_ExceptionDescribe, 1835 checked_jni_ExceptionClear, 1836 checked_jni_FatalError, 1837 1838 checked_jni_PushLocalFrame, 1839 checked_jni_PopLocalFrame, 1840 1841 checked_jni_NewGlobalRef, 1842 checked_jni_DeleteGlobalRef, 1843 checked_jni_DeleteLocalRef, 1844 checked_jni_IsSameObject, 1845 1846 checked_jni_NewLocalRef, 1847 checked_jni_EnsureLocalCapacity, 1848 1849 checked_jni_AllocObject, 1850 checked_jni_NewObject, 1851 checked_jni_NewObjectV, 1852 checked_jni_NewObjectA, 1853 1854 checked_jni_GetObjectClass, 1855 checked_jni_IsInstanceOf, 1856 1857 checked_jni_GetMethodID, 1858 1859 checked_jni_CallObjectMethod, 1860 checked_jni_CallObjectMethodV, 1861 checked_jni_CallObjectMethodA, 1862 checked_jni_CallBooleanMethod, 1863 checked_jni_CallBooleanMethodV, 1864 checked_jni_CallBooleanMethodA, 1865 checked_jni_CallByteMethod, 1866 checked_jni_CallByteMethodV, 1867 checked_jni_CallByteMethodA, 1868 checked_jni_CallCharMethod, 1869 checked_jni_CallCharMethodV, 1870 checked_jni_CallCharMethodA, 1871 checked_jni_CallShortMethod, 1872 checked_jni_CallShortMethodV, 1873 checked_jni_CallShortMethodA, 1874 checked_jni_CallIntMethod, 1875 checked_jni_CallIntMethodV, 1876 checked_jni_CallIntMethodA, 1877 checked_jni_CallLongMethod, 1878 checked_jni_CallLongMethodV, 1879 checked_jni_CallLongMethodA, 1880 checked_jni_CallFloatMethod, 1881 checked_jni_CallFloatMethodV, 1882 checked_jni_CallFloatMethodA, 1883 checked_jni_CallDoubleMethod, 1884 checked_jni_CallDoubleMethodV, 1885 checked_jni_CallDoubleMethodA, 1886 checked_jni_CallVoidMethod, 1887 checked_jni_CallVoidMethodV, 1888 checked_jni_CallVoidMethodA, 1889 1890 checked_jni_CallNonvirtualObjectMethod, 1891 checked_jni_CallNonvirtualObjectMethodV, 1892 checked_jni_CallNonvirtualObjectMethodA, 1893 checked_jni_CallNonvirtualBooleanMethod, 1894 checked_jni_CallNonvirtualBooleanMethodV, 1895 checked_jni_CallNonvirtualBooleanMethodA, 1896 checked_jni_CallNonvirtualByteMethod, 1897 checked_jni_CallNonvirtualByteMethodV, 1898 checked_jni_CallNonvirtualByteMethodA, 1899 checked_jni_CallNonvirtualCharMethod, 1900 checked_jni_CallNonvirtualCharMethodV, 1901 checked_jni_CallNonvirtualCharMethodA, 1902 checked_jni_CallNonvirtualShortMethod, 1903 checked_jni_CallNonvirtualShortMethodV, 1904 checked_jni_CallNonvirtualShortMethodA, 1905 checked_jni_CallNonvirtualIntMethod, 1906 checked_jni_CallNonvirtualIntMethodV, 1907 checked_jni_CallNonvirtualIntMethodA, 1908 checked_jni_CallNonvirtualLongMethod, 1909 checked_jni_CallNonvirtualLongMethodV, 1910 checked_jni_CallNonvirtualLongMethodA, 1911 checked_jni_CallNonvirtualFloatMethod, 1912 checked_jni_CallNonvirtualFloatMethodV, 1913 checked_jni_CallNonvirtualFloatMethodA, 1914 checked_jni_CallNonvirtualDoubleMethod, 1915 checked_jni_CallNonvirtualDoubleMethodV, 1916 checked_jni_CallNonvirtualDoubleMethodA, 1917 checked_jni_CallNonvirtualVoidMethod, 1918 checked_jni_CallNonvirtualVoidMethodV, 1919 checked_jni_CallNonvirtualVoidMethodA, 1920 1921 checked_jni_GetFieldID, 1922 1923 checked_jni_GetObjectField, 1924 checked_jni_GetBooleanField, 1925 checked_jni_GetByteField, 1926 checked_jni_GetCharField, 1927 checked_jni_GetShortField, 1928 checked_jni_GetIntField, 1929 checked_jni_GetLongField, 1930 checked_jni_GetFloatField, 1931 checked_jni_GetDoubleField, 1932 1933 checked_jni_SetObjectField, 1934 checked_jni_SetBooleanField, 1935 checked_jni_SetByteField, 1936 checked_jni_SetCharField, 1937 checked_jni_SetShortField, 1938 checked_jni_SetIntField, 1939 checked_jni_SetLongField, 1940 checked_jni_SetFloatField, 1941 checked_jni_SetDoubleField, 1942 1943 checked_jni_GetStaticMethodID, 1944 1945 checked_jni_CallStaticObjectMethod, 1946 checked_jni_CallStaticObjectMethodV, 1947 checked_jni_CallStaticObjectMethodA, 1948 checked_jni_CallStaticBooleanMethod, 1949 checked_jni_CallStaticBooleanMethodV, 1950 checked_jni_CallStaticBooleanMethodA, 1951 checked_jni_CallStaticByteMethod, 1952 checked_jni_CallStaticByteMethodV, 1953 checked_jni_CallStaticByteMethodA, 1954 checked_jni_CallStaticCharMethod, 1955 checked_jni_CallStaticCharMethodV, 1956 checked_jni_CallStaticCharMethodA, 1957 checked_jni_CallStaticShortMethod, 1958 checked_jni_CallStaticShortMethodV, 1959 checked_jni_CallStaticShortMethodA, 1960 checked_jni_CallStaticIntMethod, 1961 checked_jni_CallStaticIntMethodV, 1962 checked_jni_CallStaticIntMethodA, 1963 checked_jni_CallStaticLongMethod, 1964 checked_jni_CallStaticLongMethodV, 1965 checked_jni_CallStaticLongMethodA, 1966 checked_jni_CallStaticFloatMethod, 1967 checked_jni_CallStaticFloatMethodV, 1968 checked_jni_CallStaticFloatMethodA, 1969 checked_jni_CallStaticDoubleMethod, 1970 checked_jni_CallStaticDoubleMethodV, 1971 checked_jni_CallStaticDoubleMethodA, 1972 checked_jni_CallStaticVoidMethod, 1973 checked_jni_CallStaticVoidMethodV, 1974 checked_jni_CallStaticVoidMethodA, 1975 1976 checked_jni_GetStaticFieldID, 1977 1978 checked_jni_GetStaticObjectField, 1979 checked_jni_GetStaticBooleanField, 1980 checked_jni_GetStaticByteField, 1981 checked_jni_GetStaticCharField, 1982 checked_jni_GetStaticShortField, 1983 checked_jni_GetStaticIntField, 1984 checked_jni_GetStaticLongField, 1985 checked_jni_GetStaticFloatField, 1986 checked_jni_GetStaticDoubleField, 1987 1988 checked_jni_SetStaticObjectField, 1989 checked_jni_SetStaticBooleanField, 1990 checked_jni_SetStaticByteField, 1991 checked_jni_SetStaticCharField, 1992 checked_jni_SetStaticShortField, 1993 checked_jni_SetStaticIntField, 1994 checked_jni_SetStaticLongField, 1995 checked_jni_SetStaticFloatField, 1996 checked_jni_SetStaticDoubleField, 1997 1998 checked_jni_NewString, 1999 checked_jni_GetStringLength, 2000 checked_jni_GetStringChars, 2001 checked_jni_ReleaseStringChars, 2002 2003 checked_jni_NewStringUTF, 2004 checked_jni_GetStringUTFLength, 2005 checked_jni_GetStringUTFChars, 2006 checked_jni_ReleaseStringUTFChars, 2007 2008 checked_jni_GetArrayLength, 2009 2010 checked_jni_NewObjectArray, 2011 checked_jni_GetObjectArrayElement, 2012 checked_jni_SetObjectArrayElement, 2013 2014 checked_jni_NewBooleanArray, 2015 checked_jni_NewByteArray, 2016 checked_jni_NewCharArray, 2017 checked_jni_NewShortArray, 2018 checked_jni_NewIntArray, 2019 checked_jni_NewLongArray, 2020 checked_jni_NewFloatArray, 2021 checked_jni_NewDoubleArray, 2022 2023 checked_jni_GetBooleanArrayElements, 2024 checked_jni_GetByteArrayElements, 2025 checked_jni_GetCharArrayElements, 2026 checked_jni_GetShortArrayElements, 2027 checked_jni_GetIntArrayElements, 2028 checked_jni_GetLongArrayElements, 2029 checked_jni_GetFloatArrayElements, 2030 checked_jni_GetDoubleArrayElements, 2031 2032 checked_jni_ReleaseBooleanArrayElements, 2033 checked_jni_ReleaseByteArrayElements, 2034 checked_jni_ReleaseCharArrayElements, 2035 checked_jni_ReleaseShortArrayElements, 2036 checked_jni_ReleaseIntArrayElements, 2037 checked_jni_ReleaseLongArrayElements, 2038 checked_jni_ReleaseFloatArrayElements, 2039 checked_jni_ReleaseDoubleArrayElements, 2040 2041 checked_jni_GetBooleanArrayRegion, 2042 checked_jni_GetByteArrayRegion, 2043 checked_jni_GetCharArrayRegion, 2044 checked_jni_GetShortArrayRegion, 2045 checked_jni_GetIntArrayRegion, 2046 checked_jni_GetLongArrayRegion, 2047 checked_jni_GetFloatArrayRegion, 2048 checked_jni_GetDoubleArrayRegion, 2049 2050 checked_jni_SetBooleanArrayRegion, 2051 checked_jni_SetByteArrayRegion, 2052 checked_jni_SetCharArrayRegion, 2053 checked_jni_SetShortArrayRegion, 2054 checked_jni_SetIntArrayRegion, 2055 checked_jni_SetLongArrayRegion, 2056 checked_jni_SetFloatArrayRegion, 2057 checked_jni_SetDoubleArrayRegion, 2058 2059 checked_jni_RegisterNatives, 2060 checked_jni_UnregisterNatives, 2061 2062 checked_jni_MonitorEnter, 2063 checked_jni_MonitorExit, 2064 2065 checked_jni_GetJavaVM, 2066 2067 checked_jni_GetStringRegion, 2068 checked_jni_GetStringUTFRegion, 2069 2070 checked_jni_GetPrimitiveArrayCritical, 2071 checked_jni_ReleasePrimitiveArrayCritical, 2072 2073 checked_jni_GetStringCritical, 2074 checked_jni_ReleaseStringCritical, 2075 2076 checked_jni_NewWeakGlobalRef, 2077 checked_jni_DeleteWeakGlobalRef, 2078 2079 checked_jni_ExceptionCheck, 2080 2081 checked_jni_NewDirectByteBuffer, 2082 checked_jni_GetDirectBufferAddress, 2083 checked_jni_GetDirectBufferCapacity, 2084 2085 // New 1.6 Features 2086 2087 checked_jni_GetObjectRefType 2088}; 2089 2090 2091// Returns the function structure 2092struct JNINativeInterface_* jni_functions_check() { 2093 2094 unchecked_jni_NativeInterface = jni_functions_nocheck(); 2095 2096 // make sure the last pointer in the checked table is not null, indicating 2097 // an addition to the JNINativeInterface_ structure without initializing 2098 // it in the checked table. 2099 debug_only(int *lastPtr = (int *)((char *)&checked_jni_NativeInterface + \ 2100 sizeof(*unchecked_jni_NativeInterface) - sizeof(char *));) 2101 assert(*lastPtr != 0, 2102 "Mismatched JNINativeInterface tables, check for new entries"); 2103 2104 // with -verbose:jni this message will print 2105 if (PrintJNIResolving) { 2106 tty->print_cr("Checked JNI functions are being used to " \ 2107 "validate JNI usage"); 2108 } 2109 2110 return &checked_jni_NativeInterface; 2111} 2112