Mercurial > hg > graal-compiler

comparison src/share/vm/prims/jniCheck.cpp @ 0:a61af66fc99e jdk7-b24

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