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