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