|
0
|
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 }
|
