Thu, 12 Oct 2017 21:27:07 +0800
merge
1 /*
2 * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 /*
26 * This file has been modified by Loongson Technology in 2015. These
27 * modifications are Copyright (c) 2015 Loongson Technology, and are made
28 * available on the same license terms set forth above.
29 */
31 #include "precompiled.hpp"
32 #include "classfile/systemDictionary.hpp"
33 #include "classfile/vmSymbols.hpp"
34 #include "memory/guardedMemory.hpp"
35 #include "oops/instanceKlass.hpp"
36 #include "oops/oop.inline.hpp"
37 #include "oops/symbol.hpp"
38 #include "prims/jni.h"
39 #include "prims/jniCheck.hpp"
40 #include "prims/jvm_misc.hpp"
41 #include "runtime/fieldDescriptor.hpp"
42 #include "runtime/handles.hpp"
43 #include "runtime/interfaceSupport.hpp"
44 #include "runtime/jfieldIDWorkaround.hpp"
45 #include "runtime/thread.inline.hpp"
46 #ifdef TARGET_ARCH_x86
47 # include "jniTypes_x86.hpp"
48 #endif
49 #ifdef TARGET_ARCH_sparc
50 # include "jniTypes_sparc.hpp"
51 #endif
52 #ifdef TARGET_ARCH_zero
53 # include "jniTypes_zero.hpp"
54 #endif
55 #ifdef TARGET_ARCH_arm
56 # include "jniTypes_arm.hpp"
57 #endif
58 #ifdef TARGET_ARCH_ppc
59 # include "jniTypes_ppc.hpp"
60 #endif
61 #ifdef TARGET_ARCH_mips
62 # include "jniTypes_mips.hpp"
63 #endif
66 // Heap objects are allowed to be directly referenced only in VM code,
67 // not in native code.
69 #define ASSERT_OOPS_ALLOWED \
70 assert(JavaThread::current()->thread_state() == _thread_in_vm, \
71 "jniCheck examining oops in bad state.")
74 // Execute the given block of source code with the thread in VM state.
75 // To do this, transition from the NATIVE state to the VM state, execute
76 // the code, and transtition back. The ThreadInVMfromNative constructor
77 // performs the transition to VM state, its destructor restores the
78 // NATIVE state.
80 #define IN_VM(source_code) { \
81 { \
82 ThreadInVMfromNative __tiv(thr); \
83 source_code \
84 } \
85 }
88 /*
89 * DECLARATIONS
90 */
92 static struct JNINativeInterface_ * unchecked_jni_NativeInterface;
95 /*
96 * MACRO DEFINITIONS
97 */
99 // All JNI checked functions here use JNI_ENTRY_CHECKED() instead of the
100 // QUICK_ENTRY or LEAF variants found in jni.cpp. This allows handles
101 // to be created if a fatal error should occur.
103 // Check for thread not attached to VM; need to catch this before
104 // assertions in the wrapper routines might fire
106 // Check for env being the one value appropriate for this thread.
108 #define JNI_ENTRY_CHECKED(result_type, header) \
109 extern "C" { \
110 result_type JNICALL header { \
111 JavaThread* thr = (JavaThread*)ThreadLocalStorage::get_thread_slow();\
112 if (thr == NULL || !thr->is_Java_thread()) { \
113 tty->print_cr("%s", fatal_using_jnienv_in_nonjava); \
114 os::abort(true); \
115 } \
116 JNIEnv* xenv = thr->jni_environment(); \
117 if (env != xenv) { \
118 NativeReportJNIFatalError(thr, warn_wrong_jnienv); \
119 } \
120 VM_ENTRY_BASE(result_type, header, thr)
123 #define UNCHECKED() (unchecked_jni_NativeInterface)
125 static const char * warn_wrong_jnienv = "Using JNIEnv in the wrong thread";
126 static const char * warn_bad_class_descriptor = "JNI FindClass received a bad class descriptor \"%s\". A correct class descriptor " \
127 "has no leading \"L\" or trailing \";\". Incorrect descriptors will not be accepted in future releases.";
128 static const char * fatal_using_jnienv_in_nonjava = "FATAL ERROR in native method: Using JNIEnv in non-Java thread";
129 static const char * warn_other_function_in_critical = "Warning: Calling other JNI functions in the scope of " \
130 "Get/ReleasePrimitiveArrayCritical or Get/ReleaseStringCritical";
131 static const char * fatal_bad_ref_to_jni = "Bad global or local ref passed to JNI";
132 static const char * fatal_received_null_class = "JNI received a null class";
133 static const char * fatal_class_not_a_class = "JNI received a class argument that is not a class";
134 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";
135 static const char * fatal_wrong_class_or_method = "Wrong object class or methodID passed to JNI call";
136 static const char * fatal_non_weak_method = "non-weak methodID passed to JNI call";
137 static const char * fatal_unknown_array_object = "Unknown array object passed to JNI array operations";
138 static const char * fatal_object_array_expected = "Object array expected but not received for JNI array operation";
139 static const char * fatal_prim_type_array_expected = "Primitive type array expected but not received for JNI array operation";
140 static const char * fatal_non_array = "Non-array passed to JNI array operations";
141 static const char * fatal_element_type_mismatch = "Array element type mismatch in JNI";
142 static const char * fatal_should_be_static = "Non-static field ID passed to JNI";
143 static const char * fatal_wrong_static_field = "Wrong static field ID passed to JNI";
144 static const char * fatal_static_field_not_found = "Static field not found in JNI get/set field operations";
145 static const char * fatal_static_field_mismatch = "Field type (static) mismatch in JNI get/set field operations";
146 static const char * fatal_should_be_nonstatic = "Static field ID passed to JNI";
147 static const char * fatal_null_object = "Null object passed to JNI";
148 static const char * fatal_wrong_field = "Wrong field ID passed to JNI";
149 static const char * fatal_instance_field_not_found = "Instance field not found in JNI get/set field operations";
150 static const char * fatal_instance_field_mismatch = "Field type (instance) mismatch in JNI get/set field operations";
151 static const char * fatal_non_string = "JNI string operation received a non-string";
154 // When in VM state:
155 static void ReportJNIWarning(JavaThread* thr, const char *msg) {
156 tty->print_cr("WARNING in native method: %s", msg);
157 thr->print_stack();
158 }
160 // When in NATIVE state:
161 static void NativeReportJNIFatalError(JavaThread* thr, const char *msg) {
162 IN_VM(
163 ReportJNIFatalError(thr, msg);
164 )
165 }
167 static void NativeReportJNIWarning(JavaThread* thr, const char *msg) {
168 IN_VM(
169 ReportJNIWarning(thr, msg);
170 )
171 }
176 /*
177 * SUPPORT FUNCTIONS
178 */
180 static inline void
181 functionEnterCritical(JavaThread* thr)
182 {
183 if (thr->has_pending_exception()) {
184 NativeReportJNIWarning(thr, "JNI call made with exception pending");
185 }
186 }
188 static inline void
189 functionEnterCriticalExceptionAllowed(JavaThread* thr)
190 {
191 }
193 static inline void
194 functionEnter(JavaThread* thr)
195 {
196 if (thr->in_critical()) {
197 tty->print_cr("%s", warn_other_function_in_critical);
198 }
199 if (thr->has_pending_exception()) {
200 NativeReportJNIWarning(thr, "JNI call made with exception pending");
201 }
202 }
204 static inline void
205 functionEnterExceptionAllowed(JavaThread* thr)
206 {
207 if (thr->in_critical()) {
208 tty->print_cr("%s", warn_other_function_in_critical);
209 }
210 }
212 static inline void
213 functionExit(JNIEnv *env)
214 {
215 /* nothing to do at this time */
216 }
218 static inline void
219 checkStaticFieldID(JavaThread* thr, jfieldID fid, jclass cls, int ftype)
220 {
221 fieldDescriptor fd;
223 /* make sure it is a static field */
224 if (!jfieldIDWorkaround::is_static_jfieldID(fid))
225 ReportJNIFatalError(thr, fatal_should_be_static);
227 /* validate the class being passed */
228 ASSERT_OOPS_ALLOWED;
229 Klass* k_oop = jniCheck::validate_class(thr, cls, false);
231 /* check for proper subclass hierarchy */
232 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fid);
233 Klass* f_oop = id->holder();
234 if (!InstanceKlass::cast(k_oop)->is_subtype_of(f_oop))
235 ReportJNIFatalError(thr, fatal_wrong_static_field);
237 /* check for proper field type */
238 if (!id->find_local_field(&fd))
239 ReportJNIFatalError(thr, fatal_static_field_not_found);
240 if ((fd.field_type() != ftype) &&
241 !(fd.field_type() == T_ARRAY && ftype == T_OBJECT)) {
242 ReportJNIFatalError(thr, fatal_static_field_mismatch);
243 }
244 }
246 static inline void
247 checkInstanceFieldID(JavaThread* thr, jfieldID fid, jobject obj, int ftype)
248 {
249 fieldDescriptor fd;
251 /* make sure it is an instance field */
252 if (jfieldIDWorkaround::is_static_jfieldID(fid))
253 ReportJNIFatalError(thr, fatal_should_be_nonstatic);
255 /* validate the object being passed and then get its class */
256 ASSERT_OOPS_ALLOWED;
257 oop oopObj = jniCheck::validate_object(thr, obj);
258 if (!oopObj) {
259 ReportJNIFatalError(thr, fatal_null_object);
260 }
261 Klass* k_oop = oopObj->klass();
263 if (!jfieldIDWorkaround::is_valid_jfieldID(k_oop, fid)) {
264 ReportJNIFatalError(thr, fatal_wrong_field);
265 }
267 /* make sure the field exists */
268 int offset = jfieldIDWorkaround::from_instance_jfieldID(k_oop, fid);
269 if (!InstanceKlass::cast(k_oop)->contains_field_offset(offset))
270 ReportJNIFatalError(thr, fatal_wrong_field);
272 /* check for proper field type */
273 if (!InstanceKlass::cast(k_oop)->find_field_from_offset(offset,
274 false, &fd))
275 ReportJNIFatalError(thr, fatal_instance_field_not_found);
277 if ((fd.field_type() != ftype) &&
278 !(fd.field_type() == T_ARRAY && ftype == T_OBJECT)) {
279 ReportJNIFatalError(thr, fatal_instance_field_mismatch);
280 }
281 }
283 static inline void
284 checkString(JavaThread* thr, jstring js)
285 {
286 ASSERT_OOPS_ALLOWED;
287 oop s = jniCheck::validate_object(thr, js);
288 if (!s || !java_lang_String::is_instance(s))
289 ReportJNIFatalError(thr, fatal_non_string);
290 }
292 static inline arrayOop
293 check_is_array(JavaThread* thr, jarray jArray)
294 {
295 ASSERT_OOPS_ALLOWED;
296 arrayOop aOop;
298 aOop = (arrayOop)jniCheck::validate_object(thr, jArray);
299 if (aOop == NULL || !aOop->is_array()) {
300 ReportJNIFatalError(thr, fatal_non_array);
301 }
302 return aOop;
303 }
305 static inline arrayOop
306 check_is_primitive_array(JavaThread* thr, jarray jArray) {
307 arrayOop aOop = check_is_array(thr, jArray);
309 if (!aOop->is_typeArray()) {
310 ReportJNIFatalError(thr, fatal_prim_type_array_expected);
311 }
312 return aOop;
313 }
315 static inline void
316 check_primitive_array_type(JavaThread* thr, jarray jArray, BasicType elementType)
317 {
318 BasicType array_type;
319 arrayOop aOop;
321 aOop = check_is_primitive_array(thr, jArray);
322 array_type = TypeArrayKlass::cast(aOop->klass())->element_type();
323 if (array_type != elementType) {
324 ReportJNIFatalError(thr, fatal_element_type_mismatch);
325 }
326 }
328 static inline void
329 check_is_obj_array(JavaThread* thr, jarray jArray) {
330 arrayOop aOop = check_is_array(thr, jArray);
331 if (!aOop->is_objArray()) {
332 ReportJNIFatalError(thr, fatal_object_array_expected);
333 }
334 }
336 /*
337 * Copy and wrap array elements for bounds checking.
338 * Remember the original elements (GuardedMemory::get_tag())
339 */
340 static void* check_jni_wrap_copy_array(JavaThread* thr, jarray array,
341 void* orig_elements) {
342 void* result;
343 IN_VM(
344 oop a = JNIHandles::resolve_non_null(array);
345 size_t len = arrayOop(a)->length() <<
346 TypeArrayKlass::cast(a->klass())->log2_element_size();
347 result = GuardedMemory::wrap_copy(orig_elements, len, orig_elements);
348 )
349 return result;
350 }
352 static void* check_wrapped_array(JavaThread* thr, const char* fn_name,
353 void* obj, void* carray, size_t* rsz) {
354 if (carray == NULL) {
355 tty->print_cr("%s: elements vector NULL" PTR_FORMAT, fn_name, p2i(obj));
356 NativeReportJNIFatalError(thr, "Elements vector NULL");
357 }
358 GuardedMemory guarded(carray);
359 void* orig_result = guarded.get_tag();
360 if (!guarded.verify_guards()) {
361 tty->print_cr("ReleasePrimitiveArrayCritical: release array failed bounds "
362 "check, incorrect pointer returned ? array: " PTR_FORMAT " carray: "
363 PTR_FORMAT, p2i(obj), p2i(carray));
364 guarded.print_on(tty);
365 NativeReportJNIFatalError(thr, "ReleasePrimitiveArrayCritical: "
366 "failed bounds check");
367 }
368 if (orig_result == NULL) {
369 tty->print_cr("ReleasePrimitiveArrayCritical: unrecognized elements. array: "
370 PTR_FORMAT " carray: " PTR_FORMAT, p2i(obj), p2i(carray));
371 guarded.print_on(tty);
372 NativeReportJNIFatalError(thr, "ReleasePrimitiveArrayCritical: "
373 "unrecognized elements");
374 }
375 if (rsz != NULL) {
376 *rsz = guarded.get_user_size();
377 }
378 return orig_result;
379 }
381 static void* check_wrapped_array_release(JavaThread* thr, const char* fn_name,
382 void* obj, void* carray, jint mode) {
383 size_t sz;
384 void* orig_result = check_wrapped_array(thr, fn_name, obj, carray, &sz);
385 switch (mode) {
386 case 0:
387 memcpy(orig_result, carray, sz);
388 GuardedMemory::free_copy(carray);
389 break;
390 case JNI_COMMIT:
391 memcpy(orig_result, carray, sz);
392 break;
393 case JNI_ABORT:
394 GuardedMemory::free_copy(carray);
395 break;
396 default:
397 tty->print_cr("%s: Unrecognized mode %i releasing array "
398 PTR_FORMAT " elements " PTR_FORMAT, fn_name, mode, p2i(obj), p2i(carray));
399 NativeReportJNIFatalError(thr, "Unrecognized array release mode");
400 }
401 return orig_result;
402 }
404 oop jniCheck::validate_handle(JavaThread* thr, jobject obj) {
405 if (JNIHandles::is_frame_handle(thr, obj) ||
406 JNIHandles::is_local_handle(thr, obj) ||
407 JNIHandles::is_global_handle(obj) ||
408 JNIHandles::is_weak_global_handle(obj)) {
409 ASSERT_OOPS_ALLOWED;
410 return JNIHandles::resolve_external_guard(obj);
411 }
412 ReportJNIFatalError(thr, fatal_bad_ref_to_jni);
413 return NULL;
414 }
417 Method* jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) {
418 ASSERT_OOPS_ALLOWED;
419 // do the fast jmethodID check first
420 Method* moop = Method::checked_resolve_jmethod_id(method_id);
421 if (moop == NULL) {
422 ReportJNIFatalError(thr, fatal_wrong_class_or_method);
423 }
424 // jmethodIDs are supposed to be weak handles in the class loader data,
425 // but that can be expensive so check it last
426 else if (!Method::is_method_id(method_id)) {
427 ReportJNIFatalError(thr, fatal_non_weak_method);
428 }
429 return moop;
430 }
433 oop jniCheck::validate_object(JavaThread* thr, jobject obj) {
434 if (!obj)
435 return NULL;
436 ASSERT_OOPS_ALLOWED;
437 oop oopObj = jniCheck::validate_handle(thr, obj);
438 if (!oopObj) {
439 ReportJNIFatalError(thr, fatal_bad_ref_to_jni);
440 }
441 return oopObj;
442 }
444 // Warn if a class descriptor is in decorated form; class descriptors
445 // passed to JNI findClass should not be decorated unless they are
446 // array descriptors.
447 void jniCheck::validate_class_descriptor(JavaThread* thr, const char* name) {
448 if (name == NULL) return; // implementation accepts NULL so just return
450 size_t len = strlen(name);
452 if (len >= 2 &&
453 name[0] == JVM_SIGNATURE_CLASS && // 'L'
454 name[len-1] == JVM_SIGNATURE_ENDCLASS ) { // ';'
455 char msg[JVM_MAXPATHLEN];
456 jio_snprintf(msg, JVM_MAXPATHLEN, warn_bad_class_descriptor, name);
457 ReportJNIWarning(thr, msg);
458 }
459 }
461 Klass* jniCheck::validate_class(JavaThread* thr, jclass clazz, bool allow_primitive) {
462 ASSERT_OOPS_ALLOWED;
463 oop mirror = jniCheck::validate_handle(thr, clazz);
464 if (!mirror) {
465 ReportJNIFatalError(thr, fatal_received_null_class);
466 }
468 if (mirror->klass() != SystemDictionary::Class_klass()) {
469 ReportJNIFatalError(thr, fatal_class_not_a_class);
470 }
472 Klass* k = java_lang_Class::as_Klass(mirror);
473 // Make allowances for primitive classes ...
474 if (!(k != NULL || allow_primitive && java_lang_Class::is_primitive(mirror))) {
475 ReportJNIFatalError(thr, fatal_class_not_a_class);
476 }
477 return k;
478 }
480 void jniCheck::validate_throwable_klass(JavaThread* thr, Klass* klass) {
481 ASSERT_OOPS_ALLOWED;
482 assert(klass != NULL, "klass argument must have a value");
484 if (!klass->oop_is_instance() ||
485 !InstanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) {
486 ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);
487 }
488 }
490 void jniCheck::validate_call_object(JavaThread* thr, jobject obj, jmethodID method_id) {
491 /* validate the object being passed */
492 ASSERT_OOPS_ALLOWED;
493 jniCheck::validate_jmethod_id(thr, method_id);
494 jniCheck::validate_object(thr, obj);
495 }
497 void jniCheck::validate_call_class(JavaThread* thr, jclass clazz, jmethodID method_id) {
498 /* validate the class being passed */
499 ASSERT_OOPS_ALLOWED;
500 jniCheck::validate_jmethod_id(thr, method_id);
501 jniCheck::validate_class(thr, clazz, false);
502 }
505 /*
506 * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE
507 */
509 JNI_ENTRY_CHECKED(jclass,
510 checked_jni_DefineClass(JNIEnv *env,
511 const char *name,
512 jobject loader,
513 const jbyte *buf,
514 jsize len))
515 functionEnter(thr);
516 IN_VM(
517 jniCheck::validate_object(thr, loader);
518 )
519 jclass result = UNCHECKED()->DefineClass(env, name, loader, buf, len);
520 functionExit(env);
521 return result;
522 JNI_END
524 JNI_ENTRY_CHECKED(jclass,
525 checked_jni_FindClass(JNIEnv *env,
526 const char *name))
527 functionEnter(thr);
528 IN_VM(
529 jniCheck::validate_class_descriptor(thr, name);
530 )
531 jclass result = UNCHECKED()->FindClass(env, name);
532 functionExit(env);
533 return result;
534 JNI_END
536 JNI_ENTRY_CHECKED(jmethodID,
537 checked_jni_FromReflectedMethod(JNIEnv *env,
538 jobject method))
539 functionEnter(thr);
540 IN_VM(
541 jniCheck::validate_object(thr, method);
542 )
543 jmethodID result = UNCHECKED()->FromReflectedMethod(env, method);
544 functionExit(env);
545 return result;
546 JNI_END
548 JNI_ENTRY_CHECKED(jfieldID,
549 checked_jni_FromReflectedField(JNIEnv *env,
550 jobject field))
551 functionEnter(thr);
552 IN_VM(
553 jniCheck::validate_object(thr, field);
554 )
555 jfieldID result = UNCHECKED()->FromReflectedField(env, field);
556 functionExit(env);
557 return result;
558 JNI_END
560 JNI_ENTRY_CHECKED(jobject,
561 checked_jni_ToReflectedMethod(JNIEnv *env,
562 jclass cls,
563 jmethodID methodID,
564 jboolean isStatic))
565 functionEnter(thr);
566 IN_VM(
567 jniCheck::validate_class(thr, cls, false);
568 jniCheck::validate_jmethod_id(thr, methodID);
569 )
570 jobject result = UNCHECKED()->ToReflectedMethod(env, cls, methodID,
571 isStatic);
572 functionExit(env);
573 return result;
574 JNI_END
576 JNI_ENTRY_CHECKED(jclass,
577 checked_jni_GetSuperclass(JNIEnv *env,
578 jclass sub))
579 functionEnter(thr);
580 IN_VM(
581 jniCheck::validate_class(thr, sub, true);
582 )
583 jclass result = UNCHECKED()->GetSuperclass(env, sub);
584 functionExit(env);
585 return result;
586 JNI_END
588 JNI_ENTRY_CHECKED(jboolean,
589 checked_jni_IsAssignableFrom(JNIEnv *env,
590 jclass sub,
591 jclass sup))
592 functionEnter(thr);
593 IN_VM(
594 jniCheck::validate_class(thr, sub, true);
595 jniCheck::validate_class(thr, sup, true);
596 )
597 jboolean result = UNCHECKED()->IsAssignableFrom(env, sub, sup);
598 functionExit(env);
599 return result;
600 JNI_END
602 JNI_ENTRY_CHECKED(jobject,
603 checked_jni_ToReflectedField(JNIEnv *env,
604 jclass cls,
605 jfieldID fieldID,
606 jboolean isStatic))
607 functionEnter(thr);
608 IN_VM(
609 jniCheck::validate_class(thr, cls, false);
610 )
611 jobject result = UNCHECKED()->ToReflectedField(env, cls, fieldID,
612 isStatic);
613 functionExit(env);
614 return result;
615 JNI_END
617 JNI_ENTRY_CHECKED(jint,
618 checked_jni_Throw(JNIEnv *env,
619 jthrowable obj))
620 functionEnter(thr);
621 IN_VM(
622 oop oopObj = jniCheck::validate_object(thr, obj);
623 if (oopObj == NULL) {
624 // Unchecked Throw tolerates a NULL obj, so just warn
625 ReportJNIWarning(thr, "JNI Throw called with NULL throwable");
626 } else {
627 jniCheck::validate_throwable_klass(thr, oopObj->klass());
628 }
629 )
630 jint result = UNCHECKED()->Throw(env, obj);
631 functionExit(env);
632 return result;
633 JNI_END
635 JNI_ENTRY_CHECKED(jint,
636 checked_jni_ThrowNew(JNIEnv *env,
637 jclass clazz,
638 const char *msg))
639 functionEnter(thr);
640 IN_VM(
641 Klass* k = jniCheck::validate_class(thr, clazz, false);
642 assert(k != NULL, "validate_class shouldn't return NULL Klass*");
643 jniCheck::validate_throwable_klass(thr, k);
644 )
645 jint result = UNCHECKED()->ThrowNew(env, clazz, msg);
646 functionExit(env);
647 return result;
648 JNI_END
650 JNI_ENTRY_CHECKED(jthrowable,
651 checked_jni_ExceptionOccurred(JNIEnv *env))
652 functionEnterExceptionAllowed(thr);
653 jthrowable result = UNCHECKED()->ExceptionOccurred(env);
654 functionExit(env);
655 return result;
656 JNI_END
658 JNI_ENTRY_CHECKED(void,
659 checked_jni_ExceptionDescribe(JNIEnv *env))
660 functionEnterExceptionAllowed(thr);
661 UNCHECKED()->ExceptionDescribe(env);
662 functionExit(env);
663 JNI_END
665 JNI_ENTRY_CHECKED(void,
666 checked_jni_ExceptionClear(JNIEnv *env))
667 functionEnterExceptionAllowed(thr);
668 UNCHECKED()->ExceptionClear(env);
669 functionExit(env);
670 JNI_END
672 JNI_ENTRY_CHECKED(void,
673 checked_jni_FatalError(JNIEnv *env,
674 const char *msg))
675 functionEnter(thr);
676 UNCHECKED()->FatalError(env, msg);
677 functionExit(env);
678 JNI_END
680 JNI_ENTRY_CHECKED(jint,
681 checked_jni_PushLocalFrame(JNIEnv *env,
682 jint capacity))
683 functionEnterExceptionAllowed(thr);
684 if (capacity < 0)
685 NativeReportJNIFatalError(thr, "negative capacity");
686 jint result = UNCHECKED()->PushLocalFrame(env, capacity);
687 functionExit(env);
688 return result;
689 JNI_END
691 JNI_ENTRY_CHECKED(jobject,
692 checked_jni_PopLocalFrame(JNIEnv *env,
693 jobject result))
694 functionEnterExceptionAllowed(thr);
695 jobject res = UNCHECKED()->PopLocalFrame(env, result);
696 functionExit(env);
697 return res;
698 JNI_END
700 JNI_ENTRY_CHECKED(jobject,
701 checked_jni_NewGlobalRef(JNIEnv *env,
702 jobject lobj))
703 functionEnter(thr);
704 IN_VM(
705 if (lobj != NULL) {
706 jniCheck::validate_handle(thr, lobj);
707 }
708 )
709 jobject result = UNCHECKED()->NewGlobalRef(env,lobj);
710 functionExit(env);
711 return result;
712 JNI_END
714 JNI_ENTRY_CHECKED(void,
715 checked_jni_DeleteGlobalRef(JNIEnv *env,
716 jobject gref))
717 functionEnterExceptionAllowed(thr);
718 IN_VM(
719 jniCheck::validate_object(thr, gref);
720 if (gref && !JNIHandles::is_global_handle(gref)) {
721 ReportJNIFatalError(thr,
722 "Invalid global JNI handle passed to DeleteGlobalRef");
723 }
724 )
725 UNCHECKED()->DeleteGlobalRef(env,gref);
726 functionExit(env);
727 JNI_END
729 JNI_ENTRY_CHECKED(void,
730 checked_jni_DeleteLocalRef(JNIEnv *env,
731 jobject obj))
732 functionEnterExceptionAllowed(thr);
733 IN_VM(
734 jniCheck::validate_object(thr, obj);
735 if (obj && !(JNIHandles::is_local_handle(thr, obj) ||
736 JNIHandles::is_frame_handle(thr, obj)))
737 ReportJNIFatalError(thr,
738 "Invalid local JNI handle passed to DeleteLocalRef");
739 )
740 UNCHECKED()->DeleteLocalRef(env, obj);
741 functionExit(env);
742 JNI_END
744 JNI_ENTRY_CHECKED(jboolean,
745 checked_jni_IsSameObject(JNIEnv *env,
746 jobject obj1,
747 jobject obj2))
748 functionEnterExceptionAllowed(thr);
749 IN_VM(
750 /* This JNI function can be used to compare weak global references
751 * to NULL objects. If the handles are valid, but contain NULL,
752 * then don't attempt to validate the object.
753 */
754 if (obj1 != NULL && jniCheck::validate_handle(thr, obj1) != NULL) {
755 jniCheck::validate_object(thr, obj1);
756 }
757 if (obj2 != NULL && jniCheck::validate_handle(thr, obj2) != NULL) {
758 jniCheck::validate_object(thr, obj2);
759 }
760 )
761 jboolean result = UNCHECKED()->IsSameObject(env,obj1,obj2);
762 functionExit(env);
763 return result;
764 JNI_END
766 JNI_ENTRY_CHECKED(jobject,
767 checked_jni_NewLocalRef(JNIEnv *env,
768 jobject ref))
769 functionEnter(thr);
770 IN_VM(
771 if (ref != NULL) {
772 jniCheck::validate_handle(thr, ref);
773 }
774 )
775 jobject result = UNCHECKED()->NewLocalRef(env, ref);
776 functionExit(env);
777 return result;
778 JNI_END
780 JNI_ENTRY_CHECKED(jint,
781 checked_jni_EnsureLocalCapacity(JNIEnv *env,
782 jint capacity))
783 functionEnter(thr);
784 if (capacity < 0) {
785 NativeReportJNIFatalError(thr, "negative capacity");
786 }
787 jint result = UNCHECKED()->EnsureLocalCapacity(env, capacity);
788 functionExit(env);
789 return result;
790 JNI_END
792 JNI_ENTRY_CHECKED(jobject,
793 checked_jni_AllocObject(JNIEnv *env,
794 jclass clazz))
795 functionEnter(thr);
796 IN_VM(
797 jniCheck::validate_class(thr, clazz, false);
798 )
799 jobject result = UNCHECKED()->AllocObject(env,clazz);
800 functionExit(env);
801 return result;
802 JNI_END
804 JNI_ENTRY_CHECKED(jobject,
805 checked_jni_NewObject(JNIEnv *env,
806 jclass clazz,
807 jmethodID methodID,
808 ...))
809 functionEnter(thr);
810 va_list args;
811 IN_VM(
812 jniCheck::validate_class(thr, clazz, false);
813 jniCheck::validate_jmethod_id(thr, methodID);
814 )
815 va_start(args, methodID);
816 jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
817 va_end(args);
818 functionExit(env);
819 return result;
820 JNI_END
822 JNI_ENTRY_CHECKED(jobject,
823 checked_jni_NewObjectV(JNIEnv *env,
824 jclass clazz,
825 jmethodID methodID,
826 va_list args))
827 functionEnter(thr);
828 IN_VM(
829 jniCheck::validate_class(thr, clazz, false);
830 jniCheck::validate_jmethod_id(thr, methodID);
831 )
832 jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
833 functionExit(env);
834 return result;
835 JNI_END
837 JNI_ENTRY_CHECKED(jobject,
838 checked_jni_NewObjectA(JNIEnv *env,
839 jclass clazz,
840 jmethodID methodID,
841 const jvalue *args))
842 functionEnter(thr);
843 IN_VM(
844 jniCheck::validate_class(thr, clazz, false);
845 jniCheck::validate_jmethod_id(thr, methodID);
846 )
847 jobject result = UNCHECKED()->NewObjectA(env,clazz,methodID,args);
848 functionExit(env);
849 return result;
850 JNI_END
852 JNI_ENTRY_CHECKED(jclass,
853 checked_jni_GetObjectClass(JNIEnv *env,
854 jobject obj))
855 functionEnter(thr);
856 IN_VM(
857 jniCheck::validate_object(thr, obj);
858 )
859 jclass result = UNCHECKED()->GetObjectClass(env,obj);
860 functionExit(env);
861 return result;
862 JNI_END
864 JNI_ENTRY_CHECKED(jboolean,
865 checked_jni_IsInstanceOf(JNIEnv *env,
866 jobject obj,
867 jclass clazz))
868 functionEnter(thr);
869 IN_VM(
870 jniCheck::validate_object(thr, obj);
871 jniCheck::validate_class(thr, clazz, true);
872 )
873 jboolean result = UNCHECKED()->IsInstanceOf(env,obj,clazz);
874 functionExit(env);
875 return result;
876 JNI_END
878 JNI_ENTRY_CHECKED(jmethodID,
879 checked_jni_GetMethodID(JNIEnv *env,
880 jclass clazz,
881 const char *name,
882 const char *sig))
883 functionEnter(thr);
884 IN_VM(
885 jniCheck::validate_class(thr, clazz, false);
886 )
887 jmethodID result = UNCHECKED()->GetMethodID(env,clazz,name,sig);
888 functionExit(env);
889 return result;
890 JNI_END
892 #define WRAPPER_CallMethod(ResultType, Result) \
893 JNI_ENTRY_CHECKED(ResultType, \
894 checked_jni_Call##Result##Method(JNIEnv *env, \
895 jobject obj, \
896 jmethodID methodID, \
897 ...)) \
898 functionEnter(thr); \
899 va_list args; \
900 IN_VM( \
901 jniCheck::validate_call_object(thr, obj, methodID); \
902 ) \
903 va_start(args,methodID); \
904 ResultType result =UNCHECKED()->Call##Result##MethodV(env, obj, methodID, \
905 args); \
906 va_end(args); \
907 functionExit(env); \
908 return result; \
909 JNI_END \
910 \
911 JNI_ENTRY_CHECKED(ResultType, \
912 checked_jni_Call##Result##MethodV(JNIEnv *env, \
913 jobject obj, \
914 jmethodID methodID, \
915 va_list args)) \
916 functionEnter(thr); \
917 IN_VM(\
918 jniCheck::validate_call_object(thr, obj, methodID); \
919 ) \
920 ResultType result = UNCHECKED()->Call##Result##MethodV(env, obj, methodID,\
921 args); \
922 functionExit(env); \
923 return result; \
924 JNI_END \
925 \
926 JNI_ENTRY_CHECKED(ResultType, \
927 checked_jni_Call##Result##MethodA(JNIEnv *env, \
928 jobject obj, \
929 jmethodID methodID, \
930 const jvalue * args)) \
931 functionEnter(thr); \
932 IN_VM( \
933 jniCheck::validate_call_object(thr, obj, methodID); \
934 ) \
935 ResultType result = UNCHECKED()->Call##Result##MethodA(env, obj, methodID,\
936 args); \
937 functionExit(env); \
938 return result; \
939 JNI_END
941 WRAPPER_CallMethod(jobject,Object)
942 WRAPPER_CallMethod(jboolean,Boolean)
943 WRAPPER_CallMethod(jbyte,Byte)
944 WRAPPER_CallMethod(jshort,Short)
945 WRAPPER_CallMethod(jchar,Char)
946 WRAPPER_CallMethod(jint,Int)
947 WRAPPER_CallMethod(jlong,Long)
948 WRAPPER_CallMethod(jfloat,Float)
949 WRAPPER_CallMethod(jdouble,Double)
951 JNI_ENTRY_CHECKED(void,
952 checked_jni_CallVoidMethod(JNIEnv *env, \
953 jobject obj, \
954 jmethodID methodID, \
955 ...))
956 functionEnter(thr);
957 va_list args;
958 IN_VM(
959 jniCheck::validate_call_object(thr, obj, methodID);
960 )
961 va_start(args,methodID);
962 UNCHECKED()->CallVoidMethodV(env,obj,methodID,args);
963 va_end(args);
964 functionExit(env);
965 JNI_END
967 JNI_ENTRY_CHECKED(void,
968 checked_jni_CallVoidMethodV(JNIEnv *env,
969 jobject obj,
970 jmethodID methodID,
971 va_list args))
972 functionEnter(thr);
973 IN_VM(
974 jniCheck::validate_call_object(thr, obj, methodID);
975 )
976 UNCHECKED()->CallVoidMethodV(env,obj,methodID,args);
977 functionExit(env);
978 JNI_END
980 JNI_ENTRY_CHECKED(void,
981 checked_jni_CallVoidMethodA(JNIEnv *env,
982 jobject obj,
983 jmethodID methodID,
984 const jvalue * args))
985 functionEnter(thr);
986 IN_VM(
987 jniCheck::validate_call_object(thr, obj, methodID);
988 )
989 UNCHECKED()->CallVoidMethodA(env,obj,methodID,args);
990 functionExit(env);
991 JNI_END
993 #define WRAPPER_CallNonvirtualMethod(ResultType, Result) \
994 JNI_ENTRY_CHECKED(ResultType, \
995 checked_jni_CallNonvirtual##Result##Method(JNIEnv *env, \
996 jobject obj, \
997 jclass clazz, \
998 jmethodID methodID, \
999 ...)) \
1000 functionEnter(thr); \
1001 va_list args; \
1002 IN_VM( \
1003 jniCheck::validate_call_object(thr, obj, methodID); \
1004 jniCheck::validate_call_class(thr, clazz, methodID); \
1005 ) \
1006 va_start(args,methodID); \
1007 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
1008 obj, \
1009 clazz, \
1010 methodID,\
1011 args); \
1012 va_end(args); \
1013 functionExit(env); \
1014 return result; \
1015 JNI_END \
1016 \
1017 JNI_ENTRY_CHECKED(ResultType, \
1018 checked_jni_CallNonvirtual##Result##MethodV(JNIEnv *env, \
1019 jobject obj, \
1020 jclass clazz, \
1021 jmethodID methodID, \
1022 va_list args)) \
1023 functionEnter(thr); \
1024 IN_VM( \
1025 jniCheck::validate_call_object(thr, obj, methodID); \
1026 jniCheck::validate_call_class(thr, clazz, methodID); \
1027 ) \
1028 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
1029 obj, \
1030 clazz, \
1031 methodID,\
1032 args); \
1033 functionExit(env); \
1034 return result; \
1035 JNI_END \
1036 \
1037 JNI_ENTRY_CHECKED(ResultType, \
1038 checked_jni_CallNonvirtual##Result##MethodA(JNIEnv *env, \
1039 jobject obj, \
1040 jclass clazz, \
1041 jmethodID methodID, \
1042 const jvalue * args)) \
1043 functionEnter(thr); \
1044 IN_VM( \
1045 jniCheck::validate_call_object(thr, obj, methodID); \
1046 jniCheck::validate_call_class(thr, clazz, methodID); \
1047 ) \
1048 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodA(env, \
1049 obj, \
1050 clazz, \
1051 methodID,\
1052 args); \
1053 functionExit(env); \
1054 return result; \
1055 JNI_END
1057 WRAPPER_CallNonvirtualMethod(jobject,Object)
1058 WRAPPER_CallNonvirtualMethod(jboolean,Boolean)
1059 WRAPPER_CallNonvirtualMethod(jbyte,Byte)
1060 WRAPPER_CallNonvirtualMethod(jshort,Short)
1061 WRAPPER_CallNonvirtualMethod(jchar,Char)
1062 WRAPPER_CallNonvirtualMethod(jint,Int)
1063 WRAPPER_CallNonvirtualMethod(jlong,Long)
1064 WRAPPER_CallNonvirtualMethod(jfloat,Float)
1065 WRAPPER_CallNonvirtualMethod(jdouble,Double)
1067 JNI_ENTRY_CHECKED(void,
1068 checked_jni_CallNonvirtualVoidMethod(JNIEnv *env,
1069 jobject obj,
1070 jclass clazz,
1071 jmethodID methodID,
1072 ...))
1073 functionEnter(thr);
1074 va_list args;
1075 IN_VM(
1076 jniCheck::validate_call_object(thr, obj, methodID);
1077 jniCheck::validate_call_class(thr, clazz, methodID);
1078 )
1079 va_start(args,methodID);
1080 UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
1081 va_end(args);
1082 functionExit(env);
1083 JNI_END
1085 JNI_ENTRY_CHECKED(void,
1086 checked_jni_CallNonvirtualVoidMethodV(JNIEnv *env,
1087 jobject obj,
1088 jclass clazz,
1089 jmethodID methodID,
1090 va_list args))
1091 functionEnter(thr);
1092 IN_VM(
1093 jniCheck::validate_call_object(thr, obj, methodID);
1094 jniCheck::validate_call_class(thr, clazz, methodID);
1095 )
1096 UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
1097 functionExit(env);
1098 JNI_END
1100 JNI_ENTRY_CHECKED(void,
1101 checked_jni_CallNonvirtualVoidMethodA(JNIEnv *env,
1102 jobject obj,
1103 jclass clazz,
1104 jmethodID methodID,
1105 const jvalue * args))
1106 functionEnter(thr);
1107 IN_VM(
1108 jniCheck::validate_call_object(thr, obj, methodID);
1109 jniCheck::validate_call_class(thr, clazz, methodID);
1110 )
1111 UNCHECKED()->CallNonvirtualVoidMethodA(env,obj,clazz,methodID,args);
1112 functionExit(env);
1113 JNI_END
1115 JNI_ENTRY_CHECKED(jfieldID,
1116 checked_jni_GetFieldID(JNIEnv *env,
1117 jclass clazz,
1118 const char *name,
1119 const char *sig))
1120 functionEnter(thr);
1121 IN_VM(
1122 jniCheck::validate_class(thr, clazz, false);
1123 )
1124 jfieldID result = UNCHECKED()->GetFieldID(env,clazz,name,sig);
1125 functionExit(env);
1126 return result;
1127 JNI_END
1129 #define WRAPPER_GetField(ReturnType,Result,FieldType) \
1130 JNI_ENTRY_CHECKED(ReturnType, \
1131 checked_jni_Get##Result##Field(JNIEnv *env, \
1132 jobject obj, \
1133 jfieldID fieldID)) \
1134 functionEnter(thr); \
1135 IN_VM( \
1136 checkInstanceFieldID(thr, fieldID, obj, FieldType); \
1137 ) \
1138 ReturnType result = UNCHECKED()->Get##Result##Field(env,obj,fieldID); \
1139 functionExit(env); \
1140 return result; \
1141 JNI_END
1143 WRAPPER_GetField(jobject, Object, T_OBJECT)
1144 WRAPPER_GetField(jboolean, Boolean, T_BOOLEAN)
1145 WRAPPER_GetField(jbyte, Byte, T_BYTE)
1146 WRAPPER_GetField(jshort, Short, T_SHORT)
1147 WRAPPER_GetField(jchar, Char, T_CHAR)
1148 WRAPPER_GetField(jint, Int, T_INT)
1149 WRAPPER_GetField(jlong, Long, T_LONG)
1150 WRAPPER_GetField(jfloat, Float, T_FLOAT)
1151 WRAPPER_GetField(jdouble, Double, T_DOUBLE)
1153 #define WRAPPER_SetField(ValueType,Result,FieldType) \
1154 JNI_ENTRY_CHECKED(void, \
1155 checked_jni_Set##Result##Field(JNIEnv *env, \
1156 jobject obj, \
1157 jfieldID fieldID, \
1158 ValueType val)) \
1159 functionEnter(thr); \
1160 IN_VM( \
1161 checkInstanceFieldID(thr, fieldID, obj, FieldType); \
1162 ) \
1163 UNCHECKED()->Set##Result##Field(env,obj,fieldID,val); \
1164 functionExit(env); \
1165 JNI_END
1167 WRAPPER_SetField(jobject, Object, T_OBJECT)
1168 WRAPPER_SetField(jboolean, Boolean, T_BOOLEAN)
1169 WRAPPER_SetField(jbyte, Byte, T_BYTE)
1170 WRAPPER_SetField(jshort, Short, T_SHORT)
1171 WRAPPER_SetField(jchar, Char, T_CHAR)
1172 WRAPPER_SetField(jint, Int, T_INT)
1173 WRAPPER_SetField(jlong, Long, T_LONG)
1174 WRAPPER_SetField(jfloat, Float, T_FLOAT)
1175 WRAPPER_SetField(jdouble, Double, T_DOUBLE)
1178 JNI_ENTRY_CHECKED(jmethodID,
1179 checked_jni_GetStaticMethodID(JNIEnv *env,
1180 jclass clazz,
1181 const char *name,
1182 const char *sig))
1183 functionEnter(thr);
1184 IN_VM(
1185 jniCheck::validate_class(thr, clazz, false);
1186 )
1187 jmethodID result = UNCHECKED()->GetStaticMethodID(env,clazz,name,sig);
1188 functionExit(env);
1189 return result;
1190 JNI_END
1192 #define WRAPPER_CallStaticMethod(ReturnType,Result) \
1193 JNI_ENTRY_CHECKED(ReturnType, \
1194 checked_jni_CallStatic##Result##Method(JNIEnv *env, \
1195 jclass clazz, \
1196 jmethodID methodID, \
1197 ...)) \
1198 functionEnter(thr); \
1199 va_list args; \
1200 IN_VM( \
1201 jniCheck::validate_jmethod_id(thr, methodID); \
1202 jniCheck::validate_class(thr, clazz, false); \
1203 ) \
1204 va_start(args,methodID); \
1205 ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
1206 clazz, \
1207 methodID, \
1208 args); \
1209 va_end(args); \
1210 functionExit(env); \
1211 return result; \
1212 JNI_END \
1213 \
1214 JNI_ENTRY_CHECKED(ReturnType, \
1215 checked_jni_CallStatic##Result##MethodV(JNIEnv *env, \
1216 jclass clazz, \
1217 jmethodID methodID,\
1218 va_list args)) \
1219 functionEnter(thr); \
1220 IN_VM( \
1221 jniCheck::validate_jmethod_id(thr, methodID); \
1222 jniCheck::validate_class(thr, clazz, false); \
1223 ) \
1224 ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
1225 clazz, \
1226 methodID, \
1227 args); \
1228 functionExit(env); \
1229 return result; \
1230 JNI_END \
1231 \
1232 JNI_ENTRY_CHECKED(ReturnType, \
1233 checked_jni_CallStatic##Result##MethodA(JNIEnv *env, \
1234 jclass clazz, \
1235 jmethodID methodID, \
1236 const jvalue *args)) \
1237 functionEnter(thr); \
1238 IN_VM( \
1239 jniCheck::validate_jmethod_id(thr, methodID); \
1240 jniCheck::validate_class(thr, clazz, false); \
1241 ) \
1242 ReturnType result = UNCHECKED()->CallStatic##Result##MethodA(env, \
1243 clazz, \
1244 methodID, \
1245 args); \
1246 functionExit(env); \
1247 return result; \
1248 JNI_END
1250 WRAPPER_CallStaticMethod(jobject,Object)
1251 WRAPPER_CallStaticMethod(jboolean,Boolean)
1252 WRAPPER_CallStaticMethod(jbyte,Byte)
1253 WRAPPER_CallStaticMethod(jshort,Short)
1254 WRAPPER_CallStaticMethod(jchar,Char)
1255 WRAPPER_CallStaticMethod(jint,Int)
1256 WRAPPER_CallStaticMethod(jlong,Long)
1257 WRAPPER_CallStaticMethod(jfloat,Float)
1258 WRAPPER_CallStaticMethod(jdouble,Double)
1260 JNI_ENTRY_CHECKED(void,
1261 checked_jni_CallStaticVoidMethod(JNIEnv *env,
1262 jclass cls,
1263 jmethodID methodID,
1264 ...))
1265 functionEnter(thr);
1266 va_list args;
1267 IN_VM(
1268 jniCheck::validate_jmethod_id(thr, methodID);
1269 jniCheck::validate_class(thr, cls, false);
1270 )
1271 va_start(args,methodID);
1272 UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
1273 va_end(args);
1274 functionExit(env);
1275 JNI_END
1277 JNI_ENTRY_CHECKED(void,
1278 checked_jni_CallStaticVoidMethodV(JNIEnv *env,
1279 jclass cls,
1280 jmethodID methodID,
1281 va_list args))
1282 functionEnter(thr);
1283 IN_VM(
1284 jniCheck::validate_jmethod_id(thr, methodID);
1285 jniCheck::validate_class(thr, cls, false);
1286 )
1287 UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
1288 functionExit(env);
1289 JNI_END
1291 JNI_ENTRY_CHECKED(void,
1292 checked_jni_CallStaticVoidMethodA(JNIEnv *env,
1293 jclass cls,
1294 jmethodID methodID,
1295 const jvalue * args))
1296 functionEnter(thr);
1297 IN_VM(
1298 jniCheck::validate_jmethod_id(thr, methodID);
1299 jniCheck::validate_class(thr, cls, false);
1300 )
1301 UNCHECKED()->CallStaticVoidMethodA(env,cls,methodID,args);
1302 functionExit(env);
1303 JNI_END
1305 JNI_ENTRY_CHECKED(jfieldID,
1306 checked_jni_GetStaticFieldID(JNIEnv *env,
1307 jclass clazz,
1308 const char *name,
1309 const char *sig))
1310 functionEnter(thr);
1311 IN_VM(
1312 jniCheck::validate_class(thr, clazz, false);
1313 )
1314 jfieldID result = UNCHECKED()->GetStaticFieldID(env,clazz,name,sig);
1315 functionExit(env);
1316 return result;
1317 JNI_END
1319 #define WRAPPER_GetStaticField(ReturnType,Result,FieldType) \
1320 JNI_ENTRY_CHECKED(ReturnType, \
1321 checked_jni_GetStatic##Result##Field(JNIEnv *env, \
1322 jclass clazz, \
1323 jfieldID fieldID)) \
1324 functionEnter(thr); \
1325 IN_VM( \
1326 jniCheck::validate_class(thr, clazz, false); \
1327 checkStaticFieldID(thr, fieldID, clazz, FieldType); \
1328 ) \
1329 ReturnType result = UNCHECKED()->GetStatic##Result##Field(env, \
1330 clazz, \
1331 fieldID); \
1332 functionExit(env); \
1333 return result; \
1334 JNI_END
1336 WRAPPER_GetStaticField(jobject, Object, T_OBJECT)
1337 WRAPPER_GetStaticField(jboolean, Boolean, T_BOOLEAN)
1338 WRAPPER_GetStaticField(jbyte, Byte, T_BYTE)
1339 WRAPPER_GetStaticField(jshort, Short, T_SHORT)
1340 WRAPPER_GetStaticField(jchar, Char, T_CHAR)
1341 WRAPPER_GetStaticField(jint, Int, T_INT)
1342 WRAPPER_GetStaticField(jlong, Long, T_LONG)
1343 WRAPPER_GetStaticField(jfloat, Float, T_FLOAT)
1344 WRAPPER_GetStaticField(jdouble, Double, T_DOUBLE)
1346 #define WRAPPER_SetStaticField(ValueType,Result,FieldType) \
1347 JNI_ENTRY_CHECKED(void, \
1348 checked_jni_SetStatic##Result##Field(JNIEnv *env, \
1349 jclass clazz, \
1350 jfieldID fieldID, \
1351 ValueType value)) \
1352 functionEnter(thr); \
1353 IN_VM( \
1354 jniCheck::validate_class(thr, clazz, false); \
1355 checkStaticFieldID(thr, fieldID, clazz, FieldType); \
1356 ) \
1357 UNCHECKED()->SetStatic##Result##Field(env,clazz,fieldID,value); \
1358 functionExit(env); \
1359 JNI_END
1361 WRAPPER_SetStaticField(jobject, Object, T_OBJECT)
1362 WRAPPER_SetStaticField(jboolean, Boolean, T_BOOLEAN)
1363 WRAPPER_SetStaticField(jbyte, Byte, T_BYTE)
1364 WRAPPER_SetStaticField(jshort, Short, T_SHORT)
1365 WRAPPER_SetStaticField(jchar, Char, T_CHAR)
1366 WRAPPER_SetStaticField(jint, Int, T_INT)
1367 WRAPPER_SetStaticField(jlong, Long, T_LONG)
1368 WRAPPER_SetStaticField(jfloat, Float, T_FLOAT)
1369 WRAPPER_SetStaticField(jdouble, Double, T_DOUBLE)
1372 JNI_ENTRY_CHECKED(jstring,
1373 checked_jni_NewString(JNIEnv *env,
1374 const jchar *unicode,
1375 jsize len))
1376 functionEnter(thr);
1377 jstring result = UNCHECKED()->NewString(env,unicode,len);
1378 functionExit(env);
1379 return result;
1380 JNI_END
1382 JNI_ENTRY_CHECKED(jsize,
1383 checked_jni_GetStringLength(JNIEnv *env,
1384 jstring str))
1385 functionEnter(thr);
1386 IN_VM(
1387 checkString(thr, str);
1388 )
1389 jsize result = UNCHECKED()->GetStringLength(env,str);
1390 functionExit(env);
1391 return result;
1392 JNI_END
1394 // Arbitrary (but well-known) tag
1395 const void* STRING_TAG = (void*)0x47114711;
1397 JNI_ENTRY_CHECKED(const jchar *,
1398 checked_jni_GetStringChars(JNIEnv *env,
1399 jstring str,
1400 jboolean *isCopy))
1401 functionEnter(thr);
1402 IN_VM(
1403 checkString(thr, str);
1404 )
1405 jchar* new_result = NULL;
1406 const jchar *result = UNCHECKED()->GetStringChars(env,str,isCopy);
1407 assert (isCopy == NULL || *isCopy == JNI_TRUE, "GetStringChars didn't return a copy as expected");
1408 if (result != NULL) {
1409 size_t len = UNCHECKED()->GetStringLength(env,str) + 1; // + 1 for NULL termination
1410 len *= sizeof(jchar);
1411 new_result = (jchar*) GuardedMemory::wrap_copy(result, len, STRING_TAG);
1412 if (new_result == NULL) {
1413 vm_exit_out_of_memory(len, OOM_MALLOC_ERROR, "checked_jni_GetStringChars");
1414 }
1415 // Avoiding call to UNCHECKED()->ReleaseStringChars() since that will fire unexpected dtrace probes
1416 // Note that the dtrace arguments for the allocated memory will not match up with this solution.
1417 FreeHeap((char*)result);
1418 }
1419 functionExit(env);
1420 return new_result;
1421 JNI_END
1423 JNI_ENTRY_CHECKED(void,
1424 checked_jni_ReleaseStringChars(JNIEnv *env,
1425 jstring str,
1426 const jchar *chars))
1427 functionEnterExceptionAllowed(thr);
1428 IN_VM(
1429 checkString(thr, str);
1430 )
1431 if (chars == NULL) {
1432 // still do the unchecked call to allow dtrace probes
1433 UNCHECKED()->ReleaseStringChars(env,str,chars);
1434 }
1435 else {
1436 GuardedMemory guarded((void*)chars);
1437 if (!guarded.verify_guards()) {
1438 tty->print_cr("ReleaseStringChars: release chars failed bounds check. "
1439 "string: " PTR_FORMAT " chars: " PTR_FORMAT, p2i(str), p2i(chars));
1440 guarded.print_on(tty);
1441 NativeReportJNIFatalError(thr, "ReleaseStringChars: "
1442 "release chars failed bounds check.");
1443 }
1444 if (guarded.get_tag() != STRING_TAG) {
1445 tty->print_cr("ReleaseStringChars: called on something not allocated "
1446 "by GetStringChars. string: " PTR_FORMAT " chars: " PTR_FORMAT,
1447 p2i(str), p2i(chars));
1448 NativeReportJNIFatalError(thr, "ReleaseStringChars called on something "
1449 "not allocated by GetStringChars");
1450 }
1451 UNCHECKED()->ReleaseStringChars(env, str,
1452 (const jchar*) guarded.release_for_freeing());
1453 }
1454 functionExit(env);
1455 JNI_END
1457 JNI_ENTRY_CHECKED(jstring,
1458 checked_jni_NewStringUTF(JNIEnv *env,
1459 const char *utf))
1460 functionEnter(thr);
1461 jstring result = UNCHECKED()->NewStringUTF(env,utf);
1462 functionExit(env);
1463 return result;
1464 JNI_END
1466 JNI_ENTRY_CHECKED(jsize,
1467 checked_jni_GetStringUTFLength(JNIEnv *env,
1468 jstring str))
1469 functionEnter(thr);
1470 IN_VM(
1471 checkString(thr, str);
1472 )
1473 jsize result = UNCHECKED()->GetStringUTFLength(env,str);
1474 functionExit(env);
1475 return result;
1476 JNI_END
1478 // Arbitrary (but well-known) tag - different than GetStringChars
1479 const void* STRING_UTF_TAG = (void*) 0x48124812;
1481 JNI_ENTRY_CHECKED(const char *,
1482 checked_jni_GetStringUTFChars(JNIEnv *env,
1483 jstring str,
1484 jboolean *isCopy))
1485 functionEnter(thr);
1486 IN_VM(
1487 checkString(thr, str);
1488 )
1489 char* new_result = NULL;
1490 const char *result = UNCHECKED()->GetStringUTFChars(env,str,isCopy);
1491 assert (isCopy == NULL || *isCopy == JNI_TRUE, "GetStringUTFChars didn't return a copy as expected");
1492 if (result != NULL) {
1493 size_t len = strlen(result) + 1; // + 1 for NULL termination
1494 new_result = (char*) GuardedMemory::wrap_copy(result, len, STRING_UTF_TAG);
1495 if (new_result == NULL) {
1496 vm_exit_out_of_memory(len, OOM_MALLOC_ERROR, "checked_jni_GetStringUTFChars");
1497 }
1498 // Avoiding call to UNCHECKED()->ReleaseStringUTFChars() since that will fire unexpected dtrace probes
1499 // Note that the dtrace arguments for the allocated memory will not match up with this solution.
1500 FreeHeap((char*)result, mtInternal);
1501 }
1502 functionExit(env);
1503 return new_result;
1504 JNI_END
1506 JNI_ENTRY_CHECKED(void,
1507 checked_jni_ReleaseStringUTFChars(JNIEnv *env,
1508 jstring str,
1509 const char* chars))
1510 functionEnterExceptionAllowed(thr);
1511 IN_VM(
1512 checkString(thr, str);
1513 )
1514 if (chars == NULL) {
1515 // still do the unchecked call to allow dtrace probes
1516 UNCHECKED()->ReleaseStringUTFChars(env,str,chars);
1517 }
1518 else {
1519 GuardedMemory guarded((void*)chars);
1520 if (!guarded.verify_guards()) {
1521 tty->print_cr("ReleaseStringUTFChars: release chars failed bounds check. "
1522 "string: " PTR_FORMAT " chars: " PTR_FORMAT, p2i(str), p2i(chars));
1523 guarded.print_on(tty);
1524 NativeReportJNIFatalError(thr, "ReleaseStringUTFChars: "
1525 "release chars failed bounds check.");
1526 }
1527 if (guarded.get_tag() != STRING_UTF_TAG) {
1528 tty->print_cr("ReleaseStringUTFChars: called on something not "
1529 "allocated by GetStringUTFChars. string: " PTR_FORMAT " chars: "
1530 PTR_FORMAT, p2i(str), p2i(chars));
1531 NativeReportJNIFatalError(thr, "ReleaseStringUTFChars "
1532 "called on something not allocated by GetStringUTFChars");
1533 }
1534 UNCHECKED()->ReleaseStringUTFChars(env, str,
1535 (const char*) guarded.release_for_freeing());
1536 }
1537 functionExit(env);
1538 JNI_END
1540 JNI_ENTRY_CHECKED(jsize,
1541 checked_jni_GetArrayLength(JNIEnv *env,
1542 jarray array))
1543 functionEnter(thr);
1544 IN_VM(
1545 check_is_array(thr, array);
1546 )
1547 jsize result = UNCHECKED()->GetArrayLength(env,array);
1548 functionExit(env);
1549 return result;
1550 JNI_END
1552 JNI_ENTRY_CHECKED(jobjectArray,
1553 checked_jni_NewObjectArray(JNIEnv *env,
1554 jsize len,
1555 jclass clazz,
1556 jobject init))
1557 functionEnter(thr);
1558 jobjectArray result = UNCHECKED()->NewObjectArray(env,len,clazz,init);
1559 functionExit(env);
1560 return result;
1561 JNI_END
1563 JNI_ENTRY_CHECKED(jobject,
1564 checked_jni_GetObjectArrayElement(JNIEnv *env,
1565 jobjectArray array,
1566 jsize index))
1567 functionEnter(thr);
1568 IN_VM(
1569 check_is_obj_array(thr, array);
1570 )
1571 jobject result = UNCHECKED()->GetObjectArrayElement(env,array,index);
1572 functionExit(env);
1573 return result;
1574 JNI_END
1576 JNI_ENTRY_CHECKED(void,
1577 checked_jni_SetObjectArrayElement(JNIEnv *env,
1578 jobjectArray array,
1579 jsize index,
1580 jobject val))
1581 functionEnter(thr);
1582 IN_VM(
1583 check_is_obj_array(thr, array);
1584 )
1585 UNCHECKED()->SetObjectArrayElement(env,array,index,val);
1586 functionExit(env);
1587 JNI_END
1589 #define WRAPPER_NewScalarArray(Return, Result) \
1590 JNI_ENTRY_CHECKED(Return, \
1591 checked_jni_New##Result##Array(JNIEnv *env, \
1592 jsize len)) \
1593 functionEnter(thr); \
1594 Return result = UNCHECKED()->New##Result##Array(env,len); \
1595 functionExit(env); \
1596 return (Return) result; \
1597 JNI_END
1599 WRAPPER_NewScalarArray(jbooleanArray, Boolean)
1600 WRAPPER_NewScalarArray(jbyteArray, Byte)
1601 WRAPPER_NewScalarArray(jshortArray, Short)
1602 WRAPPER_NewScalarArray(jcharArray, Char)
1603 WRAPPER_NewScalarArray(jintArray, Int)
1604 WRAPPER_NewScalarArray(jlongArray, Long)
1605 WRAPPER_NewScalarArray(jfloatArray, Float)
1606 WRAPPER_NewScalarArray(jdoubleArray, Double)
1608 #define WRAPPER_GetScalarArrayElements(ElementTag,ElementType,Result) \
1609 JNI_ENTRY_CHECKED(ElementType *, \
1610 checked_jni_Get##Result##ArrayElements(JNIEnv *env, \
1611 ElementType##Array array, \
1612 jboolean *isCopy)) \
1613 functionEnter(thr); \
1614 IN_VM( \
1615 check_primitive_array_type(thr, array, ElementTag); \
1616 ) \
1617 ElementType *result = UNCHECKED()->Get##Result##ArrayElements(env, \
1618 array, \
1619 isCopy); \
1620 if (result != NULL) { \
1621 result = (ElementType *) check_jni_wrap_copy_array(thr, array, result); \
1622 } \
1623 functionExit(env); \
1624 return result; \
1625 JNI_END
1627 WRAPPER_GetScalarArrayElements(T_BOOLEAN, jboolean, Boolean)
1628 WRAPPER_GetScalarArrayElements(T_BYTE, jbyte, Byte)
1629 WRAPPER_GetScalarArrayElements(T_SHORT, jshort, Short)
1630 WRAPPER_GetScalarArrayElements(T_CHAR, jchar, Char)
1631 WRAPPER_GetScalarArrayElements(T_INT, jint, Int)
1632 WRAPPER_GetScalarArrayElements(T_LONG, jlong, Long)
1633 WRAPPER_GetScalarArrayElements(T_FLOAT, jfloat, Float)
1634 WRAPPER_GetScalarArrayElements(T_DOUBLE, jdouble, Double)
1636 #define WRAPPER_ReleaseScalarArrayElements(ElementTag,ElementType,Result,Tag) \
1637 JNI_ENTRY_CHECKED(void, \
1638 checked_jni_Release##Result##ArrayElements(JNIEnv *env, \
1639 ElementType##Array array, \
1640 ElementType *elems, \
1641 jint mode)) \
1642 functionEnterExceptionAllowed(thr); \
1643 IN_VM( \
1644 check_primitive_array_type(thr, array, ElementTag); \
1645 ASSERT_OOPS_ALLOWED; \
1646 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
1647 ) \
1648 ElementType* orig_result = (ElementType *) check_wrapped_array_release( \
1649 thr, "checked_jni_Release"#Result"ArrayElements", array, elems, mode); \
1650 UNCHECKED()->Release##Result##ArrayElements(env, array, orig_result, mode); \
1651 functionExit(env); \
1652 JNI_END
1654 WRAPPER_ReleaseScalarArrayElements(T_BOOLEAN,jboolean, Boolean, bool)
1655 WRAPPER_ReleaseScalarArrayElements(T_BYTE, jbyte, Byte, byte)
1656 WRAPPER_ReleaseScalarArrayElements(T_SHORT, jshort, Short, short)
1657 WRAPPER_ReleaseScalarArrayElements(T_CHAR, jchar, Char, char)
1658 WRAPPER_ReleaseScalarArrayElements(T_INT, jint, Int, int)
1659 WRAPPER_ReleaseScalarArrayElements(T_LONG, jlong, Long, long)
1660 WRAPPER_ReleaseScalarArrayElements(T_FLOAT, jfloat, Float, float)
1661 WRAPPER_ReleaseScalarArrayElements(T_DOUBLE, jdouble, Double, double)
1663 #define WRAPPER_GetScalarArrayRegion(ElementTag,ElementType,Result) \
1664 JNI_ENTRY_CHECKED(void, \
1665 checked_jni_Get##Result##ArrayRegion(JNIEnv *env, \
1666 ElementType##Array array, \
1667 jsize start, \
1668 jsize len, \
1669 ElementType *buf)) \
1670 functionEnter(thr); \
1671 IN_VM( \
1672 check_primitive_array_type(thr, array, ElementTag); \
1673 ) \
1674 UNCHECKED()->Get##Result##ArrayRegion(env,array,start,len,buf); \
1675 functionExit(env); \
1676 JNI_END
1678 WRAPPER_GetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)
1679 WRAPPER_GetScalarArrayRegion(T_BYTE, jbyte, Byte)
1680 WRAPPER_GetScalarArrayRegion(T_SHORT, jshort, Short)
1681 WRAPPER_GetScalarArrayRegion(T_CHAR, jchar, Char)
1682 WRAPPER_GetScalarArrayRegion(T_INT, jint, Int)
1683 WRAPPER_GetScalarArrayRegion(T_LONG, jlong, Long)
1684 WRAPPER_GetScalarArrayRegion(T_FLOAT, jfloat, Float)
1685 WRAPPER_GetScalarArrayRegion(T_DOUBLE, jdouble, Double)
1687 #define WRAPPER_SetScalarArrayRegion(ElementTag,ElementType,Result) \
1688 JNI_ENTRY_CHECKED(void, \
1689 checked_jni_Set##Result##ArrayRegion(JNIEnv *env, \
1690 ElementType##Array array, \
1691 jsize start, \
1692 jsize len, \
1693 const ElementType *buf)) \
1694 functionEnter(thr); \
1695 IN_VM( \
1696 check_primitive_array_type(thr, array, ElementTag); \
1697 ) \
1698 UNCHECKED()->Set##Result##ArrayRegion(env,array,start,len,buf); \
1699 functionExit(env); \
1700 JNI_END
1702 WRAPPER_SetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)
1703 WRAPPER_SetScalarArrayRegion(T_BYTE, jbyte, Byte)
1704 WRAPPER_SetScalarArrayRegion(T_SHORT, jshort, Short)
1705 WRAPPER_SetScalarArrayRegion(T_CHAR, jchar, Char)
1706 WRAPPER_SetScalarArrayRegion(T_INT, jint, Int)
1707 WRAPPER_SetScalarArrayRegion(T_LONG, jlong, Long)
1708 WRAPPER_SetScalarArrayRegion(T_FLOAT, jfloat, Float)
1709 WRAPPER_SetScalarArrayRegion(T_DOUBLE, jdouble, Double)
1711 JNI_ENTRY_CHECKED(jint,
1712 checked_jni_RegisterNatives(JNIEnv *env,
1713 jclass clazz,
1714 const JNINativeMethod *methods,
1715 jint nMethods))
1716 functionEnter(thr);
1717 jint result = UNCHECKED()->RegisterNatives(env,clazz,methods,nMethods);
1718 functionExit(env);
1719 return result;
1720 JNI_END
1722 JNI_ENTRY_CHECKED(jint,
1723 checked_jni_UnregisterNatives(JNIEnv *env,
1724 jclass clazz))
1725 functionEnter(thr);
1726 jint result = UNCHECKED()->UnregisterNatives(env,clazz);
1727 functionExit(env);
1728 return result;
1729 JNI_END
1731 JNI_ENTRY_CHECKED(jint,
1732 checked_jni_MonitorEnter(JNIEnv *env,
1733 jobject obj))
1734 functionEnter(thr);
1735 IN_VM(
1736 jniCheck::validate_object(thr, obj);
1737 )
1738 jint result = UNCHECKED()->MonitorEnter(env,obj);
1739 functionExit(env);
1740 return result;
1741 JNI_END
1743 JNI_ENTRY_CHECKED(jint,
1744 checked_jni_MonitorExit(JNIEnv *env,
1745 jobject obj))
1746 functionEnterExceptionAllowed(thr);
1747 IN_VM(
1748 jniCheck::validate_object(thr, obj);
1749 )
1750 jint result = UNCHECKED()->MonitorExit(env,obj);
1751 functionExit(env);
1752 return result;
1753 JNI_END
1755 JNI_ENTRY_CHECKED(jint,
1756 checked_jni_GetJavaVM(JNIEnv *env,
1757 JavaVM **vm))
1758 functionEnter(thr);
1759 jint result = UNCHECKED()->GetJavaVM(env,vm);
1760 functionExit(env);
1761 return result;
1762 JNI_END
1764 JNI_ENTRY_CHECKED(void,
1765 checked_jni_GetStringRegion(JNIEnv *env,
1766 jstring str,
1767 jsize start,
1768 jsize len,
1769 jchar *buf))
1770 functionEnter(thr);
1771 IN_VM(
1772 checkString(thr, str);
1773 )
1774 UNCHECKED()->GetStringRegion(env, str, start, len, buf);
1775 functionExit(env);
1776 JNI_END
1778 JNI_ENTRY_CHECKED(void,
1779 checked_jni_GetStringUTFRegion(JNIEnv *env,
1780 jstring str,
1781 jsize start,
1782 jsize len,
1783 char *buf))
1784 functionEnter(thr);
1785 IN_VM(
1786 checkString(thr, str);
1787 )
1788 UNCHECKED()->GetStringUTFRegion(env, str, start, len, buf);
1789 functionExit(env);
1790 JNI_END
1792 JNI_ENTRY_CHECKED(void *,
1793 checked_jni_GetPrimitiveArrayCritical(JNIEnv *env,
1794 jarray array,
1795 jboolean *isCopy))
1796 functionEnterCritical(thr);
1797 IN_VM(
1798 check_is_primitive_array(thr, array);
1799 )
1800 void *result = UNCHECKED()->GetPrimitiveArrayCritical(env, array, isCopy);
1801 if (result != NULL) {
1802 result = check_jni_wrap_copy_array(thr, array, result);
1803 }
1804 functionExit(env);
1805 return result;
1806 JNI_END
1808 JNI_ENTRY_CHECKED(void,
1809 checked_jni_ReleasePrimitiveArrayCritical(JNIEnv *env,
1810 jarray array,
1811 void *carray,
1812 jint mode))
1813 functionEnterCriticalExceptionAllowed(thr);
1814 IN_VM(
1815 check_is_primitive_array(thr, array);
1816 )
1817 // Check the element array...
1818 void* orig_result = check_wrapped_array_release(thr, "ReleasePrimitiveArrayCritical", array, carray, mode);
1819 UNCHECKED()->ReleasePrimitiveArrayCritical(env, array, orig_result, mode);
1820 functionExit(env);
1821 JNI_END
1823 JNI_ENTRY_CHECKED(const jchar*,
1824 checked_jni_GetStringCritical(JNIEnv *env,
1825 jstring string,
1826 jboolean *isCopy))
1827 functionEnterCritical(thr);
1828 IN_VM(
1829 checkString(thr, string);
1830 )
1831 const jchar *result = UNCHECKED()->GetStringCritical(env, string, isCopy);
1832 functionExit(env);
1833 return result;
1834 JNI_END
1836 JNI_ENTRY_CHECKED(void,
1837 checked_jni_ReleaseStringCritical(JNIEnv *env,
1838 jstring str,
1839 const jchar *chars))
1840 functionEnterCriticalExceptionAllowed(thr);
1841 IN_VM(
1842 checkString(thr, str);
1843 )
1844 /* The Hotspot JNI code does not use the parameters, so just check the
1845 * string parameter as a minor sanity check
1846 */
1847 UNCHECKED()->ReleaseStringCritical(env, str, chars);
1848 functionExit(env);
1849 JNI_END
1851 JNI_ENTRY_CHECKED(jweak,
1852 checked_jni_NewWeakGlobalRef(JNIEnv *env,
1853 jobject obj))
1854 functionEnter(thr);
1855 IN_VM(
1856 if (obj != NULL) {
1857 jniCheck::validate_handle(thr, obj);
1858 }
1859 )
1860 jweak result = UNCHECKED()->NewWeakGlobalRef(env, obj);
1861 functionExit(env);
1862 return result;
1863 JNI_END
1865 JNI_ENTRY_CHECKED(void,
1866 checked_jni_DeleteWeakGlobalRef(JNIEnv *env,
1867 jweak ref))
1868 functionEnterExceptionAllowed(thr);
1869 UNCHECKED()->DeleteWeakGlobalRef(env, ref);
1870 functionExit(env);
1871 JNI_END
1873 JNI_ENTRY_CHECKED(jboolean,
1874 checked_jni_ExceptionCheck(JNIEnv *env))
1875 functionEnterExceptionAllowed(thr);
1876 jboolean result = UNCHECKED()->ExceptionCheck(env);
1877 functionExit(env);
1878 return result;
1879 JNI_END
1881 JNI_ENTRY_CHECKED(jobject,
1882 checked_jni_NewDirectByteBuffer(JNIEnv *env,
1883 void *address,
1884 jlong capacity))
1885 functionEnter(thr);
1886 jobject result = UNCHECKED()->NewDirectByteBuffer(env, address, capacity);
1887 functionExit(env);
1888 return result;
1889 JNI_END
1891 JNI_ENTRY_CHECKED(void *,
1892 checked_jni_GetDirectBufferAddress(JNIEnv *env,
1893 jobject buf))
1894 functionEnter(thr);
1895 void* result = UNCHECKED()->GetDirectBufferAddress(env, buf);
1896 functionExit(env);
1897 return result;
1898 JNI_END
1900 JNI_ENTRY_CHECKED(jlong,
1901 checked_jni_GetDirectBufferCapacity(JNIEnv *env,
1902 jobject buf))
1903 functionEnter(thr);
1904 jlong result = UNCHECKED()->GetDirectBufferCapacity(env, buf);
1905 functionExit(env);
1906 return result;
1907 JNI_END
1909 JNI_ENTRY_CHECKED(jobjectRefType,
1910 checked_jni_GetObjectRefType(JNIEnv *env,
1911 jobject obj))
1912 functionEnter(thr);
1913 /* validate the object being passed */
1914 IN_VM(
1915 jniCheck::validate_object(thr, obj);
1916 )
1917 jobjectRefType result = UNCHECKED()->GetObjectRefType(env, obj);
1918 functionExit(env);
1919 return result;
1920 JNI_END
1923 JNI_ENTRY_CHECKED(jint,
1924 checked_jni_GetVersion(JNIEnv *env))
1925 functionEnter(thr);
1926 jint result = UNCHECKED()->GetVersion(env);
1927 functionExit(env);
1928 return result;
1929 JNI_END
1933 /*
1934 * Structure containing all checked jni functions
1935 */
1936 struct JNINativeInterface_ checked_jni_NativeInterface = {
1937 NULL,
1938 NULL,
1939 NULL,
1941 NULL,
1943 checked_jni_GetVersion,
1945 checked_jni_DefineClass,
1946 checked_jni_FindClass,
1948 checked_jni_FromReflectedMethod,
1949 checked_jni_FromReflectedField,
1951 checked_jni_ToReflectedMethod,
1953 checked_jni_GetSuperclass,
1954 checked_jni_IsAssignableFrom,
1956 checked_jni_ToReflectedField,
1958 checked_jni_Throw,
1959 checked_jni_ThrowNew,
1960 checked_jni_ExceptionOccurred,
1961 checked_jni_ExceptionDescribe,
1962 checked_jni_ExceptionClear,
1963 checked_jni_FatalError,
1965 checked_jni_PushLocalFrame,
1966 checked_jni_PopLocalFrame,
1968 checked_jni_NewGlobalRef,
1969 checked_jni_DeleteGlobalRef,
1970 checked_jni_DeleteLocalRef,
1971 checked_jni_IsSameObject,
1973 checked_jni_NewLocalRef,
1974 checked_jni_EnsureLocalCapacity,
1976 checked_jni_AllocObject,
1977 checked_jni_NewObject,
1978 checked_jni_NewObjectV,
1979 checked_jni_NewObjectA,
1981 checked_jni_GetObjectClass,
1982 checked_jni_IsInstanceOf,
1984 checked_jni_GetMethodID,
1986 checked_jni_CallObjectMethod,
1987 checked_jni_CallObjectMethodV,
1988 checked_jni_CallObjectMethodA,
1989 checked_jni_CallBooleanMethod,
1990 checked_jni_CallBooleanMethodV,
1991 checked_jni_CallBooleanMethodA,
1992 checked_jni_CallByteMethod,
1993 checked_jni_CallByteMethodV,
1994 checked_jni_CallByteMethodA,
1995 checked_jni_CallCharMethod,
1996 checked_jni_CallCharMethodV,
1997 checked_jni_CallCharMethodA,
1998 checked_jni_CallShortMethod,
1999 checked_jni_CallShortMethodV,
2000 checked_jni_CallShortMethodA,
2001 checked_jni_CallIntMethod,
2002 checked_jni_CallIntMethodV,
2003 checked_jni_CallIntMethodA,
2004 checked_jni_CallLongMethod,
2005 checked_jni_CallLongMethodV,
2006 checked_jni_CallLongMethodA,
2007 checked_jni_CallFloatMethod,
2008 checked_jni_CallFloatMethodV,
2009 checked_jni_CallFloatMethodA,
2010 checked_jni_CallDoubleMethod,
2011 checked_jni_CallDoubleMethodV,
2012 checked_jni_CallDoubleMethodA,
2013 checked_jni_CallVoidMethod,
2014 checked_jni_CallVoidMethodV,
2015 checked_jni_CallVoidMethodA,
2017 checked_jni_CallNonvirtualObjectMethod,
2018 checked_jni_CallNonvirtualObjectMethodV,
2019 checked_jni_CallNonvirtualObjectMethodA,
2020 checked_jni_CallNonvirtualBooleanMethod,
2021 checked_jni_CallNonvirtualBooleanMethodV,
2022 checked_jni_CallNonvirtualBooleanMethodA,
2023 checked_jni_CallNonvirtualByteMethod,
2024 checked_jni_CallNonvirtualByteMethodV,
2025 checked_jni_CallNonvirtualByteMethodA,
2026 checked_jni_CallNonvirtualCharMethod,
2027 checked_jni_CallNonvirtualCharMethodV,
2028 checked_jni_CallNonvirtualCharMethodA,
2029 checked_jni_CallNonvirtualShortMethod,
2030 checked_jni_CallNonvirtualShortMethodV,
2031 checked_jni_CallNonvirtualShortMethodA,
2032 checked_jni_CallNonvirtualIntMethod,
2033 checked_jni_CallNonvirtualIntMethodV,
2034 checked_jni_CallNonvirtualIntMethodA,
2035 checked_jni_CallNonvirtualLongMethod,
2036 checked_jni_CallNonvirtualLongMethodV,
2037 checked_jni_CallNonvirtualLongMethodA,
2038 checked_jni_CallNonvirtualFloatMethod,
2039 checked_jni_CallNonvirtualFloatMethodV,
2040 checked_jni_CallNonvirtualFloatMethodA,
2041 checked_jni_CallNonvirtualDoubleMethod,
2042 checked_jni_CallNonvirtualDoubleMethodV,
2043 checked_jni_CallNonvirtualDoubleMethodA,
2044 checked_jni_CallNonvirtualVoidMethod,
2045 checked_jni_CallNonvirtualVoidMethodV,
2046 checked_jni_CallNonvirtualVoidMethodA,
2048 checked_jni_GetFieldID,
2050 checked_jni_GetObjectField,
2051 checked_jni_GetBooleanField,
2052 checked_jni_GetByteField,
2053 checked_jni_GetCharField,
2054 checked_jni_GetShortField,
2055 checked_jni_GetIntField,
2056 checked_jni_GetLongField,
2057 checked_jni_GetFloatField,
2058 checked_jni_GetDoubleField,
2060 checked_jni_SetObjectField,
2061 checked_jni_SetBooleanField,
2062 checked_jni_SetByteField,
2063 checked_jni_SetCharField,
2064 checked_jni_SetShortField,
2065 checked_jni_SetIntField,
2066 checked_jni_SetLongField,
2067 checked_jni_SetFloatField,
2068 checked_jni_SetDoubleField,
2070 checked_jni_GetStaticMethodID,
2072 checked_jni_CallStaticObjectMethod,
2073 checked_jni_CallStaticObjectMethodV,
2074 checked_jni_CallStaticObjectMethodA,
2075 checked_jni_CallStaticBooleanMethod,
2076 checked_jni_CallStaticBooleanMethodV,
2077 checked_jni_CallStaticBooleanMethodA,
2078 checked_jni_CallStaticByteMethod,
2079 checked_jni_CallStaticByteMethodV,
2080 checked_jni_CallStaticByteMethodA,
2081 checked_jni_CallStaticCharMethod,
2082 checked_jni_CallStaticCharMethodV,
2083 checked_jni_CallStaticCharMethodA,
2084 checked_jni_CallStaticShortMethod,
2085 checked_jni_CallStaticShortMethodV,
2086 checked_jni_CallStaticShortMethodA,
2087 checked_jni_CallStaticIntMethod,
2088 checked_jni_CallStaticIntMethodV,
2089 checked_jni_CallStaticIntMethodA,
2090 checked_jni_CallStaticLongMethod,
2091 checked_jni_CallStaticLongMethodV,
2092 checked_jni_CallStaticLongMethodA,
2093 checked_jni_CallStaticFloatMethod,
2094 checked_jni_CallStaticFloatMethodV,
2095 checked_jni_CallStaticFloatMethodA,
2096 checked_jni_CallStaticDoubleMethod,
2097 checked_jni_CallStaticDoubleMethodV,
2098 checked_jni_CallStaticDoubleMethodA,
2099 checked_jni_CallStaticVoidMethod,
2100 checked_jni_CallStaticVoidMethodV,
2101 checked_jni_CallStaticVoidMethodA,
2103 checked_jni_GetStaticFieldID,
2105 checked_jni_GetStaticObjectField,
2106 checked_jni_GetStaticBooleanField,
2107 checked_jni_GetStaticByteField,
2108 checked_jni_GetStaticCharField,
2109 checked_jni_GetStaticShortField,
2110 checked_jni_GetStaticIntField,
2111 checked_jni_GetStaticLongField,
2112 checked_jni_GetStaticFloatField,
2113 checked_jni_GetStaticDoubleField,
2115 checked_jni_SetStaticObjectField,
2116 checked_jni_SetStaticBooleanField,
2117 checked_jni_SetStaticByteField,
2118 checked_jni_SetStaticCharField,
2119 checked_jni_SetStaticShortField,
2120 checked_jni_SetStaticIntField,
2121 checked_jni_SetStaticLongField,
2122 checked_jni_SetStaticFloatField,
2123 checked_jni_SetStaticDoubleField,
2125 checked_jni_NewString,
2126 checked_jni_GetStringLength,
2127 checked_jni_GetStringChars,
2128 checked_jni_ReleaseStringChars,
2130 checked_jni_NewStringUTF,
2131 checked_jni_GetStringUTFLength,
2132 checked_jni_GetStringUTFChars,
2133 checked_jni_ReleaseStringUTFChars,
2135 checked_jni_GetArrayLength,
2137 checked_jni_NewObjectArray,
2138 checked_jni_GetObjectArrayElement,
2139 checked_jni_SetObjectArrayElement,
2141 checked_jni_NewBooleanArray,
2142 checked_jni_NewByteArray,
2143 checked_jni_NewCharArray,
2144 checked_jni_NewShortArray,
2145 checked_jni_NewIntArray,
2146 checked_jni_NewLongArray,
2147 checked_jni_NewFloatArray,
2148 checked_jni_NewDoubleArray,
2150 checked_jni_GetBooleanArrayElements,
2151 checked_jni_GetByteArrayElements,
2152 checked_jni_GetCharArrayElements,
2153 checked_jni_GetShortArrayElements,
2154 checked_jni_GetIntArrayElements,
2155 checked_jni_GetLongArrayElements,
2156 checked_jni_GetFloatArrayElements,
2157 checked_jni_GetDoubleArrayElements,
2159 checked_jni_ReleaseBooleanArrayElements,
2160 checked_jni_ReleaseByteArrayElements,
2161 checked_jni_ReleaseCharArrayElements,
2162 checked_jni_ReleaseShortArrayElements,
2163 checked_jni_ReleaseIntArrayElements,
2164 checked_jni_ReleaseLongArrayElements,
2165 checked_jni_ReleaseFloatArrayElements,
2166 checked_jni_ReleaseDoubleArrayElements,
2168 checked_jni_GetBooleanArrayRegion,
2169 checked_jni_GetByteArrayRegion,
2170 checked_jni_GetCharArrayRegion,
2171 checked_jni_GetShortArrayRegion,
2172 checked_jni_GetIntArrayRegion,
2173 checked_jni_GetLongArrayRegion,
2174 checked_jni_GetFloatArrayRegion,
2175 checked_jni_GetDoubleArrayRegion,
2177 checked_jni_SetBooleanArrayRegion,
2178 checked_jni_SetByteArrayRegion,
2179 checked_jni_SetCharArrayRegion,
2180 checked_jni_SetShortArrayRegion,
2181 checked_jni_SetIntArrayRegion,
2182 checked_jni_SetLongArrayRegion,
2183 checked_jni_SetFloatArrayRegion,
2184 checked_jni_SetDoubleArrayRegion,
2186 checked_jni_RegisterNatives,
2187 checked_jni_UnregisterNatives,
2189 checked_jni_MonitorEnter,
2190 checked_jni_MonitorExit,
2192 checked_jni_GetJavaVM,
2194 checked_jni_GetStringRegion,
2195 checked_jni_GetStringUTFRegion,
2197 checked_jni_GetPrimitiveArrayCritical,
2198 checked_jni_ReleasePrimitiveArrayCritical,
2200 checked_jni_GetStringCritical,
2201 checked_jni_ReleaseStringCritical,
2203 checked_jni_NewWeakGlobalRef,
2204 checked_jni_DeleteWeakGlobalRef,
2206 checked_jni_ExceptionCheck,
2208 checked_jni_NewDirectByteBuffer,
2209 checked_jni_GetDirectBufferAddress,
2210 checked_jni_GetDirectBufferCapacity,
2212 // New 1.6 Features
2214 checked_jni_GetObjectRefType
2215 };
2218 // Returns the function structure
2219 struct JNINativeInterface_* jni_functions_check() {
2221 unchecked_jni_NativeInterface = jni_functions_nocheck();
2223 // make sure the last pointer in the checked table is not null, indicating
2224 // an addition to the JNINativeInterface_ structure without initializing
2225 // it in the checked table.
2226 debug_only(int *lastPtr = (int *)((char *)&checked_jni_NativeInterface + \
2227 sizeof(*unchecked_jni_NativeInterface) - sizeof(char *));)
2228 assert(*lastPtr != 0,
2229 "Mismatched JNINativeInterface tables, check for new entries");
2231 // with -verbose:jni this message will print
2232 if (PrintJNIResolving) {
2233 tty->print_cr("Checked JNI functions are being used to " \
2234 "validate JNI usage");
2235 }
2237 return &checked_jni_NativeInterface;
2238 }