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