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