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