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