Mercurial > hg > truffle
annotate src/share/vm/prims/unsafe.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 | 47e3110c47e8 |
| children | 7848fc12602b |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17810
diff
changeset
|
2 * Copyright (c) 2000, 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:
1324
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1324
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:
1324
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/vmSymbols.hpp" | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7425
diff
changeset
|
27 #include "utilities/macros.hpp" |
|
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7425
diff
changeset
|
28 #if INCLUDE_ALL_GCS |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
29 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp" |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7425
diff
changeset
|
30 #endif // INCLUDE_ALL_GCS |
| 1972 | 31 #include "memory/allocation.inline.hpp" |
| 32 #include "prims/jni.h" | |
| 33 #include "prims/jvm.h" | |
| 34 #include "runtime/globals.hpp" | |
| 35 #include "runtime/interfaceSupport.hpp" | |
|
20198
c49dcaf78a65
8042737: Introduce umbrella header prefetch.inline.hpp
goetz
parents:
20197
diff
changeset
|
36 #include "runtime/prefetch.inline.hpp" |
|
20197
ce8f6bb717c9
8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents:
17937
diff
changeset
|
37 #include "runtime/orderAccess.inline.hpp" |
| 1972 | 38 #include "runtime/reflection.hpp" |
| 39 #include "runtime/synchronizer.hpp" | |
| 40 #include "services/threadService.hpp" | |
| 10405 | 41 #include "trace/tracing.hpp" |
| 1972 | 42 #include "utilities/copy.hpp" |
| 43 #include "utilities/dtrace.hpp" | |
| 44 | |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17810
diff
changeset
|
45 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17810
diff
changeset
|
46 |
| 0 | 47 /* |
| 48 * Implementation of class sun.misc.Unsafe | |
| 49 */ | |
| 50 | |
| 4006 | 51 #ifndef USDT2 |
|
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
845
diff
changeset
|
52 HS_DTRACE_PROBE_DECL3(hotspot, thread__park__begin, uintptr_t, int, long long); |
|
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
845
diff
changeset
|
53 HS_DTRACE_PROBE_DECL1(hotspot, thread__park__end, uintptr_t); |
|
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
845
diff
changeset
|
54 HS_DTRACE_PROBE_DECL1(hotspot, thread__unpark, uintptr_t); |
| 4006 | 55 #endif /* !USDT2 */ |
|
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
845
diff
changeset
|
56 |
| 0 | 57 #define MAX_OBJECT_SIZE \ |
| 58 ( arrayOopDesc::header_size(T_DOUBLE) * HeapWordSize \ | |
| 59 + ((julong)max_jint * sizeof(double)) ) | |
| 60 | |
| 61 | |
| 62 #define UNSAFE_ENTRY(result_type, header) \ | |
| 63 JVM_ENTRY(result_type, header) | |
| 64 | |
| 65 // Can't use UNSAFE_LEAF because it has the signature of a straight | |
| 66 // call into the runtime (just like JVM_LEAF, funny that) but it's | |
| 67 // called like a Java Native and thus the wrapper built for it passes | |
| 68 // arguments like a JNI call. It expects those arguments to be popped | |
| 69 // from the stack on Intel like all good JNI args are, and adjusts the | |
| 70 // stack according. Since the JVM_LEAF call expects no extra | |
| 71 // arguments the stack isn't popped in the C code, is pushed by the | |
| 72 // wrapper and we get sick. | |
| 73 //#define UNSAFE_LEAF(result_type, header) \ | |
| 74 // JVM_LEAF(result_type, header) | |
| 75 | |
| 76 #define UNSAFE_END JVM_END | |
| 77 | |
| 78 #define UnsafeWrapper(arg) /*nothing, for the present*/ | |
| 79 | |
| 80 | |
| 81 inline void* addr_from_java(jlong addr) { | |
| 82 // This assert fails in a variety of ways on 32-bit systems. | |
| 83 // It is impossible to predict whether native code that converts | |
| 84 // pointers to longs will sign-extend or zero-extend the addresses. | |
| 85 //assert(addr == (uintptr_t)addr, "must not be odd high bits"); | |
| 86 return (void*)(uintptr_t)addr; | |
| 87 } | |
| 88 | |
| 89 inline jlong addr_to_java(void* p) { | |
| 90 assert(p == (void*)(uintptr_t)p, "must not be odd high bits"); | |
| 91 return (uintptr_t)p; | |
| 92 } | |
| 93 | |
| 94 | |
| 95 // Note: The VM's obj_field and related accessors use byte-scaled | |
| 96 // ("unscaled") offsets, just as the unsafe methods do. | |
| 97 | |
| 98 // However, the method Unsafe.fieldOffset explicitly declines to | |
| 99 // guarantee this. The field offset values manipulated by the Java user | |
| 100 // through the Unsafe API are opaque cookies that just happen to be byte | |
| 101 // offsets. We represent this state of affairs by passing the cookies | |
| 102 // through conversion functions when going between the VM and the Unsafe API. | |
| 103 // The conversion functions just happen to be no-ops at present. | |
| 104 | |
| 105 inline jlong field_offset_to_byte_offset(jlong field_offset) { | |
| 106 return field_offset; | |
| 107 } | |
| 108 | |
| 109 inline jlong field_offset_from_byte_offset(jlong byte_offset) { | |
| 110 return byte_offset; | |
| 111 } | |
| 112 | |
| 113 inline jint invocation_key_from_method_slot(jint slot) { | |
| 114 return slot; | |
| 115 } | |
| 116 | |
| 117 inline jint invocation_key_to_method_slot(jint key) { | |
| 118 return key; | |
| 119 } | |
| 120 | |
| 121 inline void* index_oop_from_field_offset_long(oop p, jlong field_offset) { | |
| 122 jlong byte_offset = field_offset_to_byte_offset(field_offset); | |
| 123 #ifdef ASSERT | |
| 124 if (p != NULL) { | |
| 125 assert(byte_offset >= 0 && byte_offset <= (jlong)MAX_OBJECT_SIZE, "sane offset"); | |
| 126 if (byte_offset == (jint)byte_offset) { | |
| 127 void* ptr_plus_disp = (address)p + byte_offset; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
128 assert((void*)p->obj_field_addr<oop>((jint)byte_offset) == ptr_plus_disp, |
| 0 | 129 "raw [ptr+disp] must be consistent with oop::field_base"); |
| 130 } | |
|
6889
e81a8af10cd9
8001071: Add simple range check into VM implemenation of Unsafe access methods
kvn
parents:
6831
diff
changeset
|
131 jlong p_size = HeapWordSize * (jlong)(p->size()); |
|
e81a8af10cd9
8001071: Add simple range check into VM implemenation of Unsafe access methods
kvn
parents:
6831
diff
changeset
|
132 assert(byte_offset < p_size, err_msg("Unsafe access: offset " INT64_FORMAT " > object's size " INT64_FORMAT, byte_offset, p_size)); |
| 0 | 133 } |
| 134 #endif | |
| 135 if (sizeof(char*) == sizeof(jint)) // (this constant folds!) | |
| 136 return (address)p + (jint) byte_offset; | |
| 137 else | |
| 138 return (address)p + byte_offset; | |
| 139 } | |
| 140 | |
| 141 // Externally callable versions: | |
| 142 // (Use these in compiler intrinsics which emulate unsafe primitives.) | |
| 143 jlong Unsafe_field_offset_to_byte_offset(jlong field_offset) { | |
| 144 return field_offset; | |
| 145 } | |
| 146 jlong Unsafe_field_offset_from_byte_offset(jlong byte_offset) { | |
| 147 return byte_offset; | |
| 148 } | |
| 149 jint Unsafe_invocation_key_from_method_slot(jint slot) { | |
| 150 return invocation_key_from_method_slot(slot); | |
| 151 } | |
| 152 jint Unsafe_invocation_key_to_method_slot(jint key) { | |
| 153 return invocation_key_to_method_slot(key); | |
| 154 } | |
| 155 | |
| 156 | |
| 157 ///// Data in the Java heap. | |
| 158 | |
| 159 #define GET_FIELD(obj, offset, type_name, v) \ | |
| 160 oop p = JNIHandles::resolve(obj); \ | |
| 161 type_name v = *(type_name*)index_oop_from_field_offset_long(p, offset) | |
| 162 | |
| 163 #define SET_FIELD(obj, offset, type_name, x) \ | |
| 164 oop p = JNIHandles::resolve(obj); \ | |
| 165 *(type_name*)index_oop_from_field_offset_long(p, offset) = x | |
| 166 | |
| 167 #define GET_FIELD_VOLATILE(obj, offset, type_name, v) \ | |
| 168 oop p = JNIHandles::resolve(obj); \ | |
|
17794
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
12316
diff
changeset
|
169 if (support_IRIW_for_not_multiple_copy_atomic_cpu) { \ |
|
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
12316
diff
changeset
|
170 OrderAccess::fence(); \ |
|
3514ee402842
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
12316
diff
changeset
|
171 } \ |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
172 volatile type_name v = OrderAccess::load_acquire((volatile type_name*)index_oop_from_field_offset_long(p, offset)); |
| 0 | 173 |
| 174 #define SET_FIELD_VOLATILE(obj, offset, type_name, x) \ | |
| 175 oop p = JNIHandles::resolve(obj); \ | |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
176 OrderAccess::release_store_fence((volatile type_name*)index_oop_from_field_offset_long(p, offset), x); |
| 0 | 177 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
178 // Macros for oops that check UseCompressedOops |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
179 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
180 #define GET_OOP_FIELD(obj, offset, v) \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
181 oop p = JNIHandles::resolve(obj); \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
182 oop v; \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
183 if (UseCompressedOops) { \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
184 narrowOop n = *(narrowOop*)index_oop_from_field_offset_long(p, offset); \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
185 v = oopDesc::decode_heap_oop(n); \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
186 } else { \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
187 v = *(oop*)index_oop_from_field_offset_long(p, offset); \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
188 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
189 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
190 |
| 0 | 191 // Get/SetObject must be special-cased, since it works with handles. |
| 192 | |
| 193 // The xxx140 variants for backward compatibility do not allow a full-width offset. | |
| 194 UNSAFE_ENTRY(jobject, Unsafe_GetObject140(JNIEnv *env, jobject unsafe, jobject obj, jint offset)) | |
| 195 UnsafeWrapper("Unsafe_GetObject"); | |
| 196 if (obj == NULL) THROW_0(vmSymbols::java_lang_NullPointerException()); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
197 GET_OOP_FIELD(obj, offset, v) |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
198 jobject ret = JNIHandles::make_local(env, v); |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7425
diff
changeset
|
199 #if INCLUDE_ALL_GCS |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
200 // We could be accessing the referent field in a reference |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
201 // object. If G1 is enabled then we need to register a non-null |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
202 // referent with the SATB barrier. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
203 if (UseG1GC) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
204 bool needs_barrier = false; |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
205 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
206 if (ret != NULL) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
207 if (offset == java_lang_ref_Reference::referent_offset) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
208 oop o = JNIHandles::resolve_non_null(obj); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
209 Klass* k = o->klass(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
210 if (InstanceKlass::cast(k)->reference_type() != REF_NONE) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
211 assert(InstanceKlass::cast(k)->is_subclass_of(SystemDictionary::Reference_klass()), "sanity"); |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
212 needs_barrier = true; |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
213 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
214 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
215 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
216 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
217 if (needs_barrier) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
218 oop referent = JNIHandles::resolve(ret); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
219 G1SATBCardTableModRefBS::enqueue(referent); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
220 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
221 } |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7425
diff
changeset
|
222 #endif // INCLUDE_ALL_GCS |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
223 return ret; |
| 0 | 224 UNSAFE_END |
| 225 | |
| 226 UNSAFE_ENTRY(void, Unsafe_SetObject140(JNIEnv *env, jobject unsafe, jobject obj, jint offset, jobject x_h)) | |
| 227 UnsafeWrapper("Unsafe_SetObject"); | |
| 228 if (obj == NULL) THROW(vmSymbols::java_lang_NullPointerException()); | |
| 229 oop x = JNIHandles::resolve(x_h); | |
| 230 //SET_FIELD(obj, offset, oop, x); | |
| 231 oop p = JNIHandles::resolve(obj); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
232 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
233 if (x != NULL) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
234 // If there is a heap base pointer, we are obliged to emit a store barrier. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
235 oop_store((narrowOop*)index_oop_from_field_offset_long(p, offset), x); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
236 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
237 narrowOop n = oopDesc::encode_heap_oop_not_null(x); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
238 *(narrowOop*)index_oop_from_field_offset_long(p, offset) = n; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
239 } |
| 0 | 240 } else { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
241 if (x != NULL) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
242 // If there is a heap base pointer, we are obliged to emit a store barrier. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
243 oop_store((oop*)index_oop_from_field_offset_long(p, offset), x); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
244 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
245 *(oop*)index_oop_from_field_offset_long(p, offset) = x; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
246 } |
| 0 | 247 } |
| 248 UNSAFE_END | |
| 249 | |
| 250 // The normal variants allow a null base pointer with an arbitrary address. | |
| 251 // But if the base pointer is non-null, the offset should make some sense. | |
| 252 // That is, it should be in the range [0, MAX_OBJECT_SIZE]. | |
| 253 UNSAFE_ENTRY(jobject, Unsafe_GetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) | |
| 254 UnsafeWrapper("Unsafe_GetObject"); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
255 GET_OOP_FIELD(obj, offset, v) |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
256 jobject ret = JNIHandles::make_local(env, v); |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7425
diff
changeset
|
257 #if INCLUDE_ALL_GCS |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
258 // We could be accessing the referent field in a reference |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
259 // object. If G1 is enabled then we need to register non-null |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
260 // referent with the SATB barrier. |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
261 if (UseG1GC) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
262 bool needs_barrier = false; |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
263 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
264 if (ret != NULL) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
265 if (offset == java_lang_ref_Reference::referent_offset && obj != NULL) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
266 oop o = JNIHandles::resolve(obj); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
267 Klass* k = o->klass(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
268 if (InstanceKlass::cast(k)->reference_type() != REF_NONE) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
269 assert(InstanceKlass::cast(k)->is_subclass_of(SystemDictionary::Reference_klass()), "sanity"); |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
270 needs_barrier = true; |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
271 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
272 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
273 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
274 |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
275 if (needs_barrier) { |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
276 oop referent = JNIHandles::resolve(ret); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
277 G1SATBCardTableModRefBS::enqueue(referent); |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
278 } |
|
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
279 } |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7425
diff
changeset
|
280 #endif // INCLUDE_ALL_GCS |
|
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2376
diff
changeset
|
281 return ret; |
| 0 | 282 UNSAFE_END |
| 283 | |
| 284 UNSAFE_ENTRY(void, Unsafe_SetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) | |
| 285 UnsafeWrapper("Unsafe_SetObject"); | |
| 286 oop x = JNIHandles::resolve(x_h); | |
| 287 oop p = JNIHandles::resolve(obj); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
288 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
289 oop_store((narrowOop*)index_oop_from_field_offset_long(p, offset), x); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
290 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
291 oop_store((oop*)index_oop_from_field_offset_long(p, offset), x); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
292 } |
| 0 | 293 UNSAFE_END |
| 294 | |
| 295 UNSAFE_ENTRY(jobject, Unsafe_GetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) | |
| 296 UnsafeWrapper("Unsafe_GetObjectVolatile"); | |
|
6224
56c4f88474b3
7087357: JSR 292: remove obsolete code after 7085860
twisti
parents:
4043
diff
changeset
|
297 oop p = JNIHandles::resolve(obj); |
|
56c4f88474b3
7087357: JSR 292: remove obsolete code after 7085860
twisti
parents:
4043
diff
changeset
|
298 void* addr = index_oop_from_field_offset_long(p, offset); |
|
56c4f88474b3
7087357: JSR 292: remove obsolete code after 7085860
twisti
parents:
4043
diff
changeset
|
299 volatile oop v; |
|
56c4f88474b3
7087357: JSR 292: remove obsolete code after 7085860
twisti
parents:
4043
diff
changeset
|
300 if (UseCompressedOops) { |
|
56c4f88474b3
7087357: JSR 292: remove obsolete code after 7085860
twisti
parents:
4043
diff
changeset
|
301 volatile narrowOop n = *(volatile narrowOop*) addr; |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
10405
diff
changeset
|
302 (void)const_cast<oop&>(v = oopDesc::decode_heap_oop(n)); |
|
6224
56c4f88474b3
7087357: JSR 292: remove obsolete code after 7085860
twisti
parents:
4043
diff
changeset
|
303 } else { |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
10405
diff
changeset
|
304 (void)const_cast<oop&>(v = *(volatile oop*) addr); |
|
6224
56c4f88474b3
7087357: JSR 292: remove obsolete code after 7085860
twisti
parents:
4043
diff
changeset
|
305 } |
|
56c4f88474b3
7087357: JSR 292: remove obsolete code after 7085860
twisti
parents:
4043
diff
changeset
|
306 OrderAccess::acquire(); |
| 0 | 307 return JNIHandles::make_local(env, v); |
| 308 UNSAFE_END | |
| 309 | |
| 310 UNSAFE_ENTRY(void, Unsafe_SetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) | |
| 311 UnsafeWrapper("Unsafe_SetObjectVolatile"); | |
| 312 oop x = JNIHandles::resolve(x_h); | |
| 313 oop p = JNIHandles::resolve(obj); | |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
314 void* addr = index_oop_from_field_offset_long(p, offset); |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
315 OrderAccess::release(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
316 if (UseCompressedOops) { |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
317 oop_store((narrowOop*)addr, x); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
318 } else { |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
319 oop_store((oop*)addr, x); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
320 } |
| 0 | 321 OrderAccess::fence(); |
| 322 UNSAFE_END | |
| 323 | |
| 10235 | 324 #ifndef SUPPORTS_NATIVE_CX8 |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
325 // Keep old code for platforms which may not have atomic jlong (8 bytes) instructions |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
326 |
| 0 | 327 // Volatile long versions must use locks if !VM_Version::supports_cx8(). |
| 328 // support_cx8 is a surrogate for 'supports atomic long memory ops'. | |
| 329 | |
| 330 UNSAFE_ENTRY(jlong, Unsafe_GetLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) | |
| 331 UnsafeWrapper("Unsafe_GetLongVolatile"); | |
| 332 { | |
| 333 if (VM_Version::supports_cx8()) { | |
| 334 GET_FIELD_VOLATILE(obj, offset, jlong, v); | |
| 335 return v; | |
| 336 } | |
| 337 else { | |
| 338 Handle p (THREAD, JNIHandles::resolve(obj)); | |
| 339 jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset)); | |
| 340 ObjectLocker ol(p, THREAD); | |
| 341 jlong value = *addr; | |
| 342 return value; | |
| 343 } | |
| 344 } | |
| 345 UNSAFE_END | |
| 346 | |
| 347 UNSAFE_ENTRY(void, Unsafe_SetLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x)) | |
| 348 UnsafeWrapper("Unsafe_SetLongVolatile"); | |
| 349 { | |
| 350 if (VM_Version::supports_cx8()) { | |
| 351 SET_FIELD_VOLATILE(obj, offset, jlong, x); | |
| 352 } | |
| 353 else { | |
| 354 Handle p (THREAD, JNIHandles::resolve(obj)); | |
| 355 jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset)); | |
| 356 ObjectLocker ol(p, THREAD); | |
| 357 *addr = x; | |
| 358 } | |
| 359 } | |
| 360 UNSAFE_END | |
| 361 | |
| 10235 | 362 #endif // not SUPPORTS_NATIVE_CX8 |
| 0 | 363 |
| 364 #define DEFINE_GETSETOOP(jboolean, Boolean) \ | |
| 365 \ | |
| 366 UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean##140(JNIEnv *env, jobject unsafe, jobject obj, jint offset)) \ | |
| 367 UnsafeWrapper("Unsafe_Get"#Boolean); \ | |
| 368 if (obj == NULL) THROW_0(vmSymbols::java_lang_NullPointerException()); \ | |
| 369 GET_FIELD(obj, offset, jboolean, v); \ | |
| 370 return v; \ | |
| 371 UNSAFE_END \ | |
| 372 \ | |
| 373 UNSAFE_ENTRY(void, Unsafe_Set##Boolean##140(JNIEnv *env, jobject unsafe, jobject obj, jint offset, jboolean x)) \ | |
| 374 UnsafeWrapper("Unsafe_Set"#Boolean); \ | |
| 375 if (obj == NULL) THROW(vmSymbols::java_lang_NullPointerException()); \ | |
| 376 SET_FIELD(obj, offset, jboolean, x); \ | |
| 377 UNSAFE_END \ | |
| 378 \ | |
| 379 UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) \ | |
| 380 UnsafeWrapper("Unsafe_Get"#Boolean); \ | |
| 381 GET_FIELD(obj, offset, jboolean, v); \ | |
| 382 return v; \ | |
| 383 UNSAFE_END \ | |
| 384 \ | |
| 385 UNSAFE_ENTRY(void, Unsafe_Set##Boolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jboolean x)) \ | |
| 386 UnsafeWrapper("Unsafe_Set"#Boolean); \ | |
| 387 SET_FIELD(obj, offset, jboolean, x); \ | |
| 388 UNSAFE_END \ | |
| 389 \ | |
| 390 // END DEFINE_GETSETOOP. | |
| 391 | |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
392 DEFINE_GETSETOOP(jboolean, Boolean) |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
393 DEFINE_GETSETOOP(jbyte, Byte) |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
394 DEFINE_GETSETOOP(jshort, Short); |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
395 DEFINE_GETSETOOP(jchar, Char); |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
396 DEFINE_GETSETOOP(jint, Int); |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
397 DEFINE_GETSETOOP(jlong, Long); |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
398 DEFINE_GETSETOOP(jfloat, Float); |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
399 DEFINE_GETSETOOP(jdouble, Double); |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
400 |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
401 #undef DEFINE_GETSETOOP |
| 0 | 402 |
| 403 #define DEFINE_GETSETOOP_VOLATILE(jboolean, Boolean) \ | |
| 404 \ | |
| 405 UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) \ | |
| 406 UnsafeWrapper("Unsafe_Get"#Boolean); \ | |
| 407 GET_FIELD_VOLATILE(obj, offset, jboolean, v); \ | |
| 408 return v; \ | |
| 409 UNSAFE_END \ | |
| 410 \ | |
| 411 UNSAFE_ENTRY(void, Unsafe_Set##Boolean##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jboolean x)) \ | |
| 412 UnsafeWrapper("Unsafe_Set"#Boolean); \ | |
| 413 SET_FIELD_VOLATILE(obj, offset, jboolean, x); \ | |
| 414 UNSAFE_END \ | |
| 415 \ | |
| 416 // END DEFINE_GETSETOOP_VOLATILE. | |
| 417 | |
| 418 DEFINE_GETSETOOP_VOLATILE(jboolean, Boolean) | |
| 419 DEFINE_GETSETOOP_VOLATILE(jbyte, Byte) | |
| 420 DEFINE_GETSETOOP_VOLATILE(jshort, Short); | |
| 421 DEFINE_GETSETOOP_VOLATILE(jchar, Char); | |
| 422 DEFINE_GETSETOOP_VOLATILE(jint, Int); | |
| 423 DEFINE_GETSETOOP_VOLATILE(jfloat, Float); | |
| 424 DEFINE_GETSETOOP_VOLATILE(jdouble, Double); | |
| 425 | |
| 10235 | 426 #ifdef SUPPORTS_NATIVE_CX8 |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
427 DEFINE_GETSETOOP_VOLATILE(jlong, Long); |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
428 #endif |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
429 |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
430 #undef DEFINE_GETSETOOP_VOLATILE |
| 0 | 431 |
| 432 // The non-intrinsified versions of setOrdered just use setVolatile | |
| 433 | |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
434 UNSAFE_ENTRY(void, Unsafe_SetOrderedInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint x)) |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
435 UnsafeWrapper("Unsafe_SetOrderedInt"); |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
436 SET_FIELD_VOLATILE(obj, offset, jint, x); |
| 0 | 437 UNSAFE_END |
| 438 | |
| 439 UNSAFE_ENTRY(void, Unsafe_SetOrderedObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) | |
| 440 UnsafeWrapper("Unsafe_SetOrderedObject"); | |
| 441 oop x = JNIHandles::resolve(x_h); | |
| 442 oop p = JNIHandles::resolve(obj); | |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
443 void* addr = index_oop_from_field_offset_long(p, offset); |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
444 OrderAccess::release(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
445 if (UseCompressedOops) { |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
446 oop_store((narrowOop*)addr, x); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
447 } else { |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
448 oop_store((oop*)addr, x); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
449 } |
| 0 | 450 OrderAccess::fence(); |
| 451 UNSAFE_END | |
| 452 | |
| 453 UNSAFE_ENTRY(void, Unsafe_SetOrderedLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x)) | |
| 454 UnsafeWrapper("Unsafe_SetOrderedLong"); | |
| 10235 | 455 #ifdef SUPPORTS_NATIVE_CX8 |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
456 SET_FIELD_VOLATILE(obj, offset, jlong, x); |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
457 #else |
|
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
458 // Keep old code for platforms which may not have atomic long (8 bytes) instructions |
| 0 | 459 { |
| 460 if (VM_Version::supports_cx8()) { | |
| 461 SET_FIELD_VOLATILE(obj, offset, jlong, x); | |
| 462 } | |
| 463 else { | |
| 464 Handle p (THREAD, JNIHandles::resolve(obj)); | |
| 465 jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset)); | |
| 466 ObjectLocker ol(p, THREAD); | |
| 467 *addr = x; | |
| 468 } | |
| 469 } | |
|
2114
4fc084dac61e
7009756: volatile variables could be broken throw reflection API
kvn
parents:
1972
diff
changeset
|
470 #endif |
| 0 | 471 UNSAFE_END |
| 472 | |
| 7425 | 473 UNSAFE_ENTRY(void, Unsafe_LoadFence(JNIEnv *env, jobject unsafe)) |
| 474 UnsafeWrapper("Unsafe_LoadFence"); | |
| 475 OrderAccess::acquire(); | |
| 476 UNSAFE_END | |
| 477 | |
| 478 UNSAFE_ENTRY(void, Unsafe_StoreFence(JNIEnv *env, jobject unsafe)) | |
| 479 UnsafeWrapper("Unsafe_StoreFence"); | |
| 480 OrderAccess::release(); | |
| 481 UNSAFE_END | |
| 482 | |
| 483 UNSAFE_ENTRY(void, Unsafe_FullFence(JNIEnv *env, jobject unsafe)) | |
| 484 UnsafeWrapper("Unsafe_FullFence"); | |
| 485 OrderAccess::fence(); | |
| 486 UNSAFE_END | |
| 487 | |
| 0 | 488 ////// Data in the C heap. |
| 489 | |
| 490 // Note: These do not throw NullPointerException for bad pointers. | |
| 491 // They just crash. Only a oop base pointer can generate a NullPointerException. | |
| 492 // | |
| 493 #define DEFINE_GETSETNATIVE(java_type, Type, native_type) \ | |
| 494 \ | |
| 495 UNSAFE_ENTRY(java_type, Unsafe_GetNative##Type(JNIEnv *env, jobject unsafe, jlong addr)) \ | |
| 496 UnsafeWrapper("Unsafe_GetNative"#Type); \ | |
| 497 void* p = addr_from_java(addr); \ | |
| 498 JavaThread* t = JavaThread::current(); \ | |
| 499 t->set_doing_unsafe_access(true); \ | |
| 500 java_type x = *(volatile native_type*)p; \ | |
| 501 t->set_doing_unsafe_access(false); \ | |
| 502 return x; \ | |
| 503 UNSAFE_END \ | |
| 504 \ | |
| 505 UNSAFE_ENTRY(void, Unsafe_SetNative##Type(JNIEnv *env, jobject unsafe, jlong addr, java_type x)) \ | |
| 506 UnsafeWrapper("Unsafe_SetNative"#Type); \ | |
| 507 JavaThread* t = JavaThread::current(); \ | |
| 508 t->set_doing_unsafe_access(true); \ | |
| 509 void* p = addr_from_java(addr); \ | |
| 510 *(volatile native_type*)p = x; \ | |
| 511 t->set_doing_unsafe_access(false); \ | |
| 512 UNSAFE_END \ | |
| 513 \ | |
| 514 // END DEFINE_GETSETNATIVE. | |
| 515 | |
| 516 DEFINE_GETSETNATIVE(jbyte, Byte, signed char) | |
| 517 DEFINE_GETSETNATIVE(jshort, Short, signed short); | |
| 518 DEFINE_GETSETNATIVE(jchar, Char, unsigned short); | |
| 519 DEFINE_GETSETNATIVE(jint, Int, jint); | |
| 520 // no long -- handled specially | |
| 521 DEFINE_GETSETNATIVE(jfloat, Float, float); | |
| 522 DEFINE_GETSETNATIVE(jdouble, Double, double); | |
| 523 | |
| 524 #undef DEFINE_GETSETNATIVE | |
| 525 | |
| 526 UNSAFE_ENTRY(jlong, Unsafe_GetNativeLong(JNIEnv *env, jobject unsafe, jlong addr)) | |
| 527 UnsafeWrapper("Unsafe_GetNativeLong"); | |
| 528 JavaThread* t = JavaThread::current(); | |
| 529 // We do it this way to avoid problems with access to heap using 64 | |
| 530 // bit loads, as jlong in heap could be not 64-bit aligned, and on | |
| 531 // some CPUs (SPARC) it leads to SIGBUS. | |
| 532 t->set_doing_unsafe_access(true); | |
| 533 void* p = addr_from_java(addr); | |
| 534 jlong x; | |
| 535 if (((intptr_t)p & 7) == 0) { | |
| 536 // jlong is aligned, do a volatile access | |
| 537 x = *(volatile jlong*)p; | |
| 538 } else { | |
| 539 jlong_accessor acc; | |
| 540 acc.words[0] = ((volatile jint*)p)[0]; | |
| 541 acc.words[1] = ((volatile jint*)p)[1]; | |
| 542 x = acc.long_value; | |
| 543 } | |
| 544 t->set_doing_unsafe_access(false); | |
| 545 return x; | |
| 546 UNSAFE_END | |
| 547 | |
| 548 UNSAFE_ENTRY(void, Unsafe_SetNativeLong(JNIEnv *env, jobject unsafe, jlong addr, jlong x)) | |
| 549 UnsafeWrapper("Unsafe_SetNativeLong"); | |
| 550 JavaThread* t = JavaThread::current(); | |
| 551 // see comment for Unsafe_GetNativeLong | |
| 552 t->set_doing_unsafe_access(true); | |
| 553 void* p = addr_from_java(addr); | |
| 554 if (((intptr_t)p & 7) == 0) { | |
| 555 // jlong is aligned, do a volatile access | |
| 556 *(volatile jlong*)p = x; | |
| 557 } else { | |
| 558 jlong_accessor acc; | |
| 559 acc.long_value = x; | |
| 560 ((volatile jint*)p)[0] = acc.words[0]; | |
| 561 ((volatile jint*)p)[1] = acc.words[1]; | |
| 562 } | |
| 563 t->set_doing_unsafe_access(false); | |
| 564 UNSAFE_END | |
| 565 | |
| 566 | |
| 567 UNSAFE_ENTRY(jlong, Unsafe_GetNativeAddress(JNIEnv *env, jobject unsafe, jlong addr)) | |
| 568 UnsafeWrapper("Unsafe_GetNativeAddress"); | |
| 569 void* p = addr_from_java(addr); | |
| 570 return addr_to_java(*(void**)p); | |
| 571 UNSAFE_END | |
| 572 | |
| 573 UNSAFE_ENTRY(void, Unsafe_SetNativeAddress(JNIEnv *env, jobject unsafe, jlong addr, jlong x)) | |
| 574 UnsafeWrapper("Unsafe_SetNativeAddress"); | |
| 575 void* p = addr_from_java(addr); | |
| 576 *(void**)p = addr_from_java(x); | |
| 577 UNSAFE_END | |
| 578 | |
| 579 | |
| 580 ////// Allocation requests | |
| 581 | |
| 582 UNSAFE_ENTRY(jobject, Unsafe_AllocateInstance(JNIEnv *env, jobject unsafe, jclass cls)) | |
| 583 UnsafeWrapper("Unsafe_AllocateInstance"); | |
| 584 { | |
| 585 ThreadToNativeFromVM ttnfv(thread); | |
| 586 return env->AllocObject(cls); | |
| 587 } | |
| 588 UNSAFE_END | |
| 589 | |
| 590 UNSAFE_ENTRY(jlong, Unsafe_AllocateMemory(JNIEnv *env, jobject unsafe, jlong size)) | |
| 591 UnsafeWrapper("Unsafe_AllocateMemory"); | |
| 592 size_t sz = (size_t)size; | |
| 593 if (sz != (julong)size || size < 0) { | |
| 594 THROW_0(vmSymbols::java_lang_IllegalArgumentException()); | |
| 595 } | |
| 596 if (sz == 0) { | |
| 597 return 0; | |
| 598 } | |
| 599 sz = round_to(sz, HeapWordSize); | |
| 6197 | 600 void* x = os::malloc(sz, mtInternal); |
| 0 | 601 if (x == NULL) { |
| 602 THROW_0(vmSymbols::java_lang_OutOfMemoryError()); | |
| 603 } | |
| 604 //Copy::fill_to_words((HeapWord*)x, sz / HeapWordSize); | |
| 605 return addr_to_java(x); | |
| 606 UNSAFE_END | |
| 607 | |
| 608 UNSAFE_ENTRY(jlong, Unsafe_ReallocateMemory(JNIEnv *env, jobject unsafe, jlong addr, jlong size)) | |
| 609 UnsafeWrapper("Unsafe_ReallocateMemory"); | |
| 610 void* p = addr_from_java(addr); | |
| 611 size_t sz = (size_t)size; | |
| 612 if (sz != (julong)size || size < 0) { | |
| 613 THROW_0(vmSymbols::java_lang_IllegalArgumentException()); | |
| 614 } | |
| 615 if (sz == 0) { | |
| 616 os::free(p); | |
| 617 return 0; | |
| 618 } | |
| 619 sz = round_to(sz, HeapWordSize); | |
| 6197 | 620 void* x = (p == NULL) ? os::malloc(sz, mtInternal) : os::realloc(p, sz, mtInternal); |
| 0 | 621 if (x == NULL) { |
| 622 THROW_0(vmSymbols::java_lang_OutOfMemoryError()); | |
| 623 } | |
| 624 return addr_to_java(x); | |
| 625 UNSAFE_END | |
| 626 | |
| 627 UNSAFE_ENTRY(void, Unsafe_FreeMemory(JNIEnv *env, jobject unsafe, jlong addr)) | |
| 628 UnsafeWrapper("Unsafe_FreeMemory"); | |
| 629 void* p = addr_from_java(addr); | |
| 630 if (p == NULL) { | |
| 631 return; | |
| 632 } | |
| 633 os::free(p); | |
| 634 UNSAFE_END | |
| 635 | |
| 636 UNSAFE_ENTRY(void, Unsafe_SetMemory(JNIEnv *env, jobject unsafe, jlong addr, jlong size, jbyte value)) | |
| 637 UnsafeWrapper("Unsafe_SetMemory"); | |
| 638 size_t sz = (size_t)size; | |
| 639 if (sz != (julong)size || size < 0) { | |
| 640 THROW(vmSymbols::java_lang_IllegalArgumentException()); | |
| 641 } | |
| 642 char* p = (char*) addr_from_java(addr); | |
| 643 Copy::fill_to_memory_atomic(p, sz, value); | |
| 644 UNSAFE_END | |
| 645 | |
| 646 UNSAFE_ENTRY(void, Unsafe_SetMemory2(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong size, jbyte value)) | |
| 647 UnsafeWrapper("Unsafe_SetMemory"); | |
| 648 size_t sz = (size_t)size; | |
| 649 if (sz != (julong)size || size < 0) { | |
| 650 THROW(vmSymbols::java_lang_IllegalArgumentException()); | |
| 651 } | |
| 652 oop base = JNIHandles::resolve(obj); | |
| 653 void* p = index_oop_from_field_offset_long(base, offset); | |
| 654 Copy::fill_to_memory_atomic(p, sz, value); | |
| 655 UNSAFE_END | |
| 656 | |
| 657 UNSAFE_ENTRY(void, Unsafe_CopyMemory(JNIEnv *env, jobject unsafe, jlong srcAddr, jlong dstAddr, jlong size)) | |
| 658 UnsafeWrapper("Unsafe_CopyMemory"); | |
| 659 if (size == 0) { | |
| 660 return; | |
| 661 } | |
| 662 size_t sz = (size_t)size; | |
| 663 if (sz != (julong)size || size < 0) { | |
| 664 THROW(vmSymbols::java_lang_IllegalArgumentException()); | |
| 665 } | |
| 666 void* src = addr_from_java(srcAddr); | |
| 667 void* dst = addr_from_java(dstAddr); | |
| 668 Copy::conjoint_memory_atomic(src, dst, sz); | |
| 669 UNSAFE_END | |
| 670 | |
| 671 UNSAFE_ENTRY(void, Unsafe_CopyMemory2(JNIEnv *env, jobject unsafe, jobject srcObj, jlong srcOffset, jobject dstObj, jlong dstOffset, jlong size)) | |
| 672 UnsafeWrapper("Unsafe_CopyMemory"); | |
| 673 if (size == 0) { | |
| 674 return; | |
| 675 } | |
| 676 size_t sz = (size_t)size; | |
| 677 if (sz != (julong)size || size < 0) { | |
| 678 THROW(vmSymbols::java_lang_IllegalArgumentException()); | |
| 679 } | |
| 680 oop srcp = JNIHandles::resolve(srcObj); | |
| 681 oop dstp = JNIHandles::resolve(dstObj); | |
| 682 if (dstp != NULL && !dstp->is_typeArray()) { | |
| 683 // NYI: This works only for non-oop arrays at present. | |
| 684 // Generalizing it would be reasonable, but requires card marking. | |
| 685 // Also, autoboxing a Long from 0L in copyMemory(x,y, 0L,z, n) would be bad. | |
| 686 THROW(vmSymbols::java_lang_IllegalArgumentException()); | |
| 687 } | |
| 688 void* src = index_oop_from_field_offset_long(srcp, srcOffset); | |
| 689 void* dst = index_oop_from_field_offset_long(dstp, dstOffset); | |
| 690 Copy::conjoint_memory_atomic(src, dst, sz); | |
| 691 UNSAFE_END | |
| 692 | |
| 693 | |
| 694 ////// Random queries | |
| 695 | |
| 696 // See comment at file start about UNSAFE_LEAF | |
| 697 //UNSAFE_LEAF(jint, Unsafe_AddressSize()) | |
| 698 UNSAFE_ENTRY(jint, Unsafe_AddressSize(JNIEnv *env, jobject unsafe)) | |
| 699 UnsafeWrapper("Unsafe_AddressSize"); | |
| 700 return sizeof(void*); | |
| 701 UNSAFE_END | |
| 702 | |
| 703 // See comment at file start about UNSAFE_LEAF | |
| 704 //UNSAFE_LEAF(jint, Unsafe_PageSize()) | |
| 705 UNSAFE_ENTRY(jint, Unsafe_PageSize(JNIEnv *env, jobject unsafe)) | |
| 706 UnsafeWrapper("Unsafe_PageSize"); | |
| 707 return os::vm_page_size(); | |
| 708 UNSAFE_END | |
| 709 | |
| 710 jint find_field_offset(jobject field, int must_be_static, TRAPS) { | |
| 711 if (field == NULL) { | |
| 712 THROW_0(vmSymbols::java_lang_NullPointerException()); | |
| 713 } | |
| 714 | |
| 715 oop reflected = JNIHandles::resolve_non_null(field); | |
| 716 oop mirror = java_lang_reflect_Field::clazz(reflected); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
717 Klass* k = java_lang_Class::as_Klass(mirror); |
| 0 | 718 int slot = java_lang_reflect_Field::slot(reflected); |
| 719 int modifiers = java_lang_reflect_Field::modifiers(reflected); | |
| 720 | |
| 721 if (must_be_static >= 0) { | |
| 722 int really_is_static = ((modifiers & JVM_ACC_STATIC) != 0); | |
| 723 if (must_be_static != really_is_static) { | |
| 724 THROW_0(vmSymbols::java_lang_IllegalArgumentException()); | |
| 725 } | |
| 726 } | |
| 727 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
728 int offset = InstanceKlass::cast(k)->field_offset(slot); |
| 0 | 729 return field_offset_from_byte_offset(offset); |
| 730 } | |
| 731 | |
| 732 UNSAFE_ENTRY(jlong, Unsafe_ObjectFieldOffset(JNIEnv *env, jobject unsafe, jobject field)) | |
| 733 UnsafeWrapper("Unsafe_ObjectFieldOffset"); | |
| 734 return find_field_offset(field, 0, THREAD); | |
| 735 UNSAFE_END | |
| 736 | |
| 737 UNSAFE_ENTRY(jlong, Unsafe_StaticFieldOffset(JNIEnv *env, jobject unsafe, jobject field)) | |
| 738 UnsafeWrapper("Unsafe_StaticFieldOffset"); | |
| 739 return find_field_offset(field, 1, THREAD); | |
| 740 UNSAFE_END | |
| 741 | |
| 742 UNSAFE_ENTRY(jobject, Unsafe_StaticFieldBaseFromField(JNIEnv *env, jobject unsafe, jobject field)) | |
| 743 UnsafeWrapper("Unsafe_StaticFieldBase"); | |
| 744 // Note: In this VM implementation, a field address is always a short | |
| 745 // offset from the base of a a klass metaobject. Thus, the full dynamic | |
| 746 // range of the return type is never used. However, some implementations | |
| 747 // might put the static field inside an array shared by many classes, | |
| 748 // or even at a fixed address, in which case the address could be quite | |
| 749 // large. In that last case, this function would return NULL, since | |
| 750 // the address would operate alone, without any base pointer. | |
| 751 | |
| 752 if (field == NULL) THROW_0(vmSymbols::java_lang_NullPointerException()); | |
| 753 | |
| 754 oop reflected = JNIHandles::resolve_non_null(field); | |
| 755 oop mirror = java_lang_reflect_Field::clazz(reflected); | |
| 756 int modifiers = java_lang_reflect_Field::modifiers(reflected); | |
| 757 | |
| 758 if ((modifiers & JVM_ACC_STATIC) == 0) { | |
| 759 THROW_0(vmSymbols::java_lang_IllegalArgumentException()); | |
| 760 } | |
| 761 | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2316
diff
changeset
|
762 return JNIHandles::make_local(env, mirror); |
| 0 | 763 UNSAFE_END |
| 764 | |
| 765 //@deprecated | |
| 766 UNSAFE_ENTRY(jint, Unsafe_FieldOffset(JNIEnv *env, jobject unsafe, jobject field)) | |
| 767 UnsafeWrapper("Unsafe_FieldOffset"); | |
| 768 // tries (but fails) to be polymorphic between static and non-static: | |
| 769 jlong offset = find_field_offset(field, -1, THREAD); | |
| 770 guarantee(offset == (jint)offset, "offset fits in 32 bits"); | |
| 771 return (jint)offset; | |
| 772 UNSAFE_END | |
| 773 | |
| 774 //@deprecated | |
| 775 UNSAFE_ENTRY(jobject, Unsafe_StaticFieldBaseFromClass(JNIEnv *env, jobject unsafe, jobject clazz)) | |
| 776 UnsafeWrapper("Unsafe_StaticFieldBase"); | |
| 777 if (clazz == NULL) { | |
| 778 THROW_0(vmSymbols::java_lang_NullPointerException()); | |
| 779 } | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2316
diff
changeset
|
780 return JNIHandles::make_local(env, JNIHandles::resolve_non_null(clazz)); |
| 0 | 781 UNSAFE_END |
| 782 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
783 UNSAFE_ENTRY(void, Unsafe_EnsureClassInitialized(JNIEnv *env, jobject unsafe, jobject clazz)) { |
| 0 | 784 UnsafeWrapper("Unsafe_EnsureClassInitialized"); |
| 785 if (clazz == NULL) { | |
| 786 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 787 } | |
| 788 oop mirror = JNIHandles::resolve_non_null(clazz); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
789 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
790 Klass* klass = java_lang_Class::as_Klass(mirror); |
| 6983 | 791 if (klass != NULL && klass->should_be_initialized()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
792 InstanceKlass* k = InstanceKlass::cast(klass); |
| 0 | 793 k->initialize(CHECK); |
| 794 } | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
795 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
796 UNSAFE_END |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
797 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
798 UNSAFE_ENTRY(jboolean, Unsafe_ShouldBeInitialized(JNIEnv *env, jobject unsafe, jobject clazz)) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
799 UnsafeWrapper("Unsafe_ShouldBeInitialized"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
800 if (clazz == NULL) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
801 THROW_(vmSymbols::java_lang_NullPointerException(), false); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
802 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
803 oop mirror = JNIHandles::resolve_non_null(clazz); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
804 Klass* klass = java_lang_Class::as_Klass(mirror); |
| 6983 | 805 if (klass != NULL && klass->should_be_initialized()) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
806 return true; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
807 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
808 return false; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
809 } |
| 0 | 810 UNSAFE_END |
| 811 | |
| 812 static void getBaseAndScale(int& base, int& scale, jclass acls, TRAPS) { | |
| 813 if (acls == NULL) { | |
| 814 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 815 } | |
| 816 oop mirror = JNIHandles::resolve_non_null(acls); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
817 Klass* k = java_lang_Class::as_Klass(mirror); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
818 if (k == NULL || !k->oop_is_array()) { |
| 0 | 819 THROW(vmSymbols::java_lang_InvalidClassException()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
820 } else if (k->oop_is_objArray()) { |
| 0 | 821 base = arrayOopDesc::base_offset_in_bytes(T_OBJECT); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
822 scale = heapOopSize; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
823 } else if (k->oop_is_typeArray()) { |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6725
diff
changeset
|
824 TypeArrayKlass* tak = TypeArrayKlass::cast(k); |
| 0 | 825 base = tak->array_header_in_bytes(); |
| 826 assert(base == arrayOopDesc::base_offset_in_bytes(tak->element_type()), "array_header_size semantics ok"); | |
| 827 scale = (1 << tak->log2_element_size()); | |
| 828 } else { | |
| 829 ShouldNotReachHere(); | |
| 830 } | |
| 831 } | |
| 832 | |
| 833 UNSAFE_ENTRY(jint, Unsafe_ArrayBaseOffset(JNIEnv *env, jobject unsafe, jclass acls)) | |
| 834 UnsafeWrapper("Unsafe_ArrayBaseOffset"); | |
| 835 int base, scale; | |
| 836 getBaseAndScale(base, scale, acls, CHECK_0); | |
| 837 return field_offset_from_byte_offset(base); | |
| 838 UNSAFE_END | |
| 839 | |
| 840 | |
| 841 UNSAFE_ENTRY(jint, Unsafe_ArrayIndexScale(JNIEnv *env, jobject unsafe, jclass acls)) | |
| 842 UnsafeWrapper("Unsafe_ArrayIndexScale"); | |
| 843 int base, scale; | |
| 844 getBaseAndScale(base, scale, acls, CHECK_0); | |
| 845 // This VM packs both fields and array elements down to the byte. | |
| 846 // But watch out: If this changes, so that array references for | |
| 847 // a given primitive type (say, T_BOOLEAN) use different memory units | |
| 848 // than fields, this method MUST return zero for such arrays. | |
| 849 // For example, the VM used to store sub-word sized fields in full | |
| 850 // words in the object layout, so that accessors like getByte(Object,int) | |
| 851 // did not really do what one might expect for arrays. Therefore, | |
| 852 // this function used to report a zero scale factor, so that the user | |
| 853 // would know not to attempt to access sub-word array elements. | |
| 854 // // Code for unpacked fields: | |
| 855 // if (scale < wordSize) return 0; | |
| 856 | |
| 857 // The following allows for a pretty general fieldOffset cookie scheme, | |
| 858 // but requires it to be linear in byte offset. | |
| 859 return field_offset_from_byte_offset(scale) - field_offset_from_byte_offset(0); | |
| 860 UNSAFE_END | |
| 861 | |
| 862 | |
| 863 static inline void throw_new(JNIEnv *env, const char *ename) { | |
| 864 char buf[100]; | |
| 865 strcpy(buf, "java/lang/"); | |
| 866 strcat(buf, ename); | |
| 867 jclass cls = env->FindClass(buf); | |
|
17704
56cd09c4a5c9
8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents:
12316
diff
changeset
|
868 if (env->ExceptionCheck()) { |
|
56cd09c4a5c9
8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents:
12316
diff
changeset
|
869 env->ExceptionClear(); |
|
56cd09c4a5c9
8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents:
12316
diff
changeset
|
870 tty->print_cr("Unsafe: cannot throw %s because FindClass has failed", buf); |
|
56cd09c4a5c9
8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents:
12316
diff
changeset
|
871 return; |
|
56cd09c4a5c9
8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents:
12316
diff
changeset
|
872 } |
| 0 | 873 char* msg = NULL; |
| 874 env->ThrowNew(cls, msg); | |
| 875 } | |
| 876 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
877 static jclass Unsafe_DefineClass_impl(JNIEnv *env, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd) { |
| 0 | 878 { |
| 879 // Code lifted from JDK 1.3 ClassLoader.c | |
| 880 | |
| 881 jbyte *body; | |
| 882 char *utfName; | |
| 883 jclass result = 0; | |
| 884 char buf[128]; | |
| 885 | |
| 886 if (UsePerfData) { | |
| 887 ClassLoader::unsafe_defineClassCallCounter()->inc(); | |
| 888 } | |
| 889 | |
| 890 if (data == NULL) { | |
| 891 throw_new(env, "NullPointerException"); | |
| 892 return 0; | |
| 893 } | |
| 894 | |
| 895 /* Work around 4153825. malloc crashes on Solaris when passed a | |
| 896 * negative size. | |
| 897 */ | |
| 898 if (length < 0) { | |
| 899 throw_new(env, "ArrayIndexOutOfBoundsException"); | |
| 900 return 0; | |
| 901 } | |
| 902 | |
| 6197 | 903 body = NEW_C_HEAP_ARRAY(jbyte, length, mtInternal); |
| 0 | 904 |
| 905 if (body == 0) { | |
| 906 throw_new(env, "OutOfMemoryError"); | |
| 907 return 0; | |
| 908 } | |
| 909 | |
| 910 env->GetByteArrayRegion(data, offset, length, body); | |
| 911 | |
| 912 if (env->ExceptionOccurred()) | |
| 913 goto free_body; | |
| 914 | |
| 915 if (name != NULL) { | |
| 916 uint len = env->GetStringUTFLength(name); | |
| 917 int unicode_len = env->GetStringLength(name); | |
| 918 if (len >= sizeof(buf)) { | |
| 6197 | 919 utfName = NEW_C_HEAP_ARRAY(char, len + 1, mtInternal); |
| 0 | 920 if (utfName == NULL) { |
| 921 throw_new(env, "OutOfMemoryError"); | |
| 922 goto free_body; | |
| 923 } | |
| 924 } else { | |
| 925 utfName = buf; | |
| 926 } | |
| 927 env->GetStringUTFRegion(name, 0, unicode_len, utfName); | |
| 928 //VerifyFixClassname(utfName); | |
| 929 for (uint i = 0; i < len; i++) { | |
| 930 if (utfName[i] == '.') utfName[i] = '/'; | |
| 931 } | |
| 932 } else { | |
| 933 utfName = NULL; | |
| 934 } | |
| 935 | |
| 936 result = JVM_DefineClass(env, utfName, loader, body, length, pd); | |
| 937 | |
| 938 if (utfName && utfName != buf) | |
| 6197 | 939 FREE_C_HEAP_ARRAY(char, utfName, mtInternal); |
| 0 | 940 |
| 941 free_body: | |
| 6197 | 942 FREE_C_HEAP_ARRAY(jbyte, body, mtInternal); |
| 0 | 943 return result; |
| 944 } | |
| 945 } | |
| 946 | |
| 947 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
948 UNSAFE_ENTRY(jclass, Unsafe_DefineClass(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd)) |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
949 UnsafeWrapper("Unsafe_DefineClass"); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
950 { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
951 ThreadToNativeFromVM ttnfv(thread); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
952 return Unsafe_DefineClass_impl(env, name, data, offset, length, loader, pd); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
953 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
954 UNSAFE_END |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
955 |
|
20415
47e3110c47e8
6642881: Improve performance of Class.getClassLoader()
coleenp
parents:
20198
diff
changeset
|
956 static jobject get_class_loader(JNIEnv* env, jclass cls) { |
|
47e3110c47e8
6642881: Improve performance of Class.getClassLoader()
coleenp
parents:
20198
diff
changeset
|
957 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { |
|
47e3110c47e8
6642881: Improve performance of Class.getClassLoader()
coleenp
parents:
20198
diff
changeset
|
958 return NULL; |
|
47e3110c47e8
6642881: Improve performance of Class.getClassLoader()
coleenp
parents:
20198
diff
changeset
|
959 } |
|
47e3110c47e8
6642881: Improve performance of Class.getClassLoader()
coleenp
parents:
20198
diff
changeset
|
960 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); |
|
47e3110c47e8
6642881: Improve performance of Class.getClassLoader()
coleenp
parents:
20198
diff
changeset
|
961 oop loader = k->class_loader(); |
|
47e3110c47e8
6642881: Improve performance of Class.getClassLoader()
coleenp
parents:
20198
diff
changeset
|
962 return JNIHandles::make_local(env, loader); |
|
47e3110c47e8
6642881: Improve performance of Class.getClassLoader()
coleenp
parents:
20198
diff
changeset
|
963 } |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
964 |
| 0 | 965 UNSAFE_ENTRY(jclass, Unsafe_DefineClass0(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length)) |
| 966 UnsafeWrapper("Unsafe_DefineClass"); | |
| 967 { | |
| 968 ThreadToNativeFromVM ttnfv(thread); | |
| 969 | |
| 970 int depthFromDefineClass0 = 1; | |
| 971 jclass caller = JVM_GetCallerClass(env, depthFromDefineClass0); | |
|
20415
47e3110c47e8
6642881: Improve performance of Class.getClassLoader()
coleenp
parents:
20198
diff
changeset
|
972 jobject loader = (caller == NULL) ? NULL : get_class_loader(env, caller); |
| 0 | 973 jobject pd = (caller == NULL) ? NULL : JVM_GetProtectionDomain(env, caller); |
| 974 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
975 return Unsafe_DefineClass_impl(env, name, data, offset, length, loader, pd); |
| 0 | 976 } |
| 977 UNSAFE_END | |
| 978 | |
| 979 | |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
980 #define DAC_Args CLS"[B["OBJ |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
981 // define a class but do not make it known to the class loader or system dictionary |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
982 // - host_class: supplies context for linkage, access control, protection domain, and class loader |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
983 // - data: bytes of a class file, a raw memory address (length gives the number of bytes) |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
984 // - cp_patches: where non-null entries exist, they replace corresponding CP entries in data |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
985 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
986 // When you load an anonymous class U, it works as if you changed its name just before loading, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
987 // to a name that you will never use again. Since the name is lost, no other class can directly |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
988 // link to any member of U. Just after U is loaded, the only way to use it is reflectively, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
989 // through java.lang.Class methods like Class.newInstance. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
990 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
991 // Access checks for linkage sites within U continue to follow the same rules as for named classes. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
992 // The package of an anonymous class is given by the package qualifier on the name under which it was loaded. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
993 // An anonymous class also has special privileges to access any member of its host class. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
994 // This is the main reason why this loading operation is unsafe. The purpose of this is to |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
995 // allow language implementations to simulate "open classes"; a host class in effect gets |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
996 // new code when an anonymous class is loaded alongside it. A less convenient but more |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
997 // standard way to do this is with reflection, which can also be set to ignore access |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
998 // restrictions. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
999 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1000 // Access into an anonymous class is possible only through reflection. Therefore, there |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1001 // are no special access rules for calling into an anonymous class. The relaxed access |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1002 // rule for the host class is applied in the opposite direction: A host class reflectively |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1003 // access one of its anonymous classes. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1004 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1005 // If you load the same bytecodes twice, you get two different classes. You can reload |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1006 // the same bytecodes with or without varying CP patches. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1007 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1008 // By using the CP patching array, you can have a new anonymous class U2 refer to an older one U1. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1009 // The bytecodes for U2 should refer to U1 by a symbolic name (doesn't matter what the name is). |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1010 // The CONSTANT_Class entry for that name can be patched to refer directly to U1. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1011 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1012 // This allows, for example, U2 to use U1 as a superclass or super-interface, or as |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1013 // an outer class (so that U2 is an anonymous inner class of anonymous U1). |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1014 // It is not possible for a named class, or an older anonymous class, to refer by |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1015 // name (via its CP) to a newer anonymous class. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1016 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1017 // CP patching may also be used to modify (i.e., hack) the names of methods, classes, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1018 // or type descriptors used in the loaded anonymous class. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1019 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1020 // Finally, CP patching may be used to introduce "live" objects into the constant pool, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1021 // instead of "dead" strings. A compiled statement like println((Object)"hello") can |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1022 // be changed to println(greeting), where greeting is an arbitrary object created before |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1023 // the anonymous class is loaded. This is useful in dynamic languages, in which |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1024 // various kinds of metaobjects must be introduced as constants into bytecode. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1025 // Note the cast (Object), which tells the verifier to expect an arbitrary object, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1026 // not just a literal string. For such ldc instructions, the verifier uses the |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1027 // type Object instead of String, if the loaded constant is not in fact a String. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1028 |
|
7185
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1029 static instanceKlassHandle |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1030 Unsafe_DefineAnonymousClass_impl(JNIEnv *env, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1031 jclass host_class, jbyteArray data, jobjectArray cp_patches_jh, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1032 HeapWord* *temp_alloc, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1033 TRAPS) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1034 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1035 if (UsePerfData) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1036 ClassLoader::unsafe_defineClassCallCounter()->inc(); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1037 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1038 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1039 if (data == NULL) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1040 THROW_0(vmSymbols::java_lang_NullPointerException()); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1041 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1042 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1043 jint length = typeArrayOop(JNIHandles::resolve_non_null(data))->length(); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1044 jint word_length = (length + sizeof(HeapWord)-1) / sizeof(HeapWord); |
| 6197 | 1045 HeapWord* body = NEW_C_HEAP_ARRAY(HeapWord, word_length, mtInternal); |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1046 if (body == NULL) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1047 THROW_0(vmSymbols::java_lang_OutOfMemoryError()); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1048 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1049 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1050 // caller responsible to free it: |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1051 (*temp_alloc) = body; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1052 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1053 { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1054 jbyte* array_base = typeArrayOop(JNIHandles::resolve_non_null(data))->byte_at_addr(0); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1055 Copy::conjoint_words((HeapWord*) array_base, body, word_length); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1056 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1057 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1058 u1* class_bytes = (u1*) body; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1059 int class_bytes_length = (int) length; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1060 if (class_bytes_length < 0) class_bytes_length = 0; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1061 if (class_bytes == NULL |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1062 || host_class == NULL |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1063 || length != class_bytes_length) |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1064 THROW_0(vmSymbols::java_lang_IllegalArgumentException()); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1065 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1066 objArrayHandle cp_patches_h; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1067 if (cp_patches_jh != NULL) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1068 oop p = JNIHandles::resolve_non_null(cp_patches_jh); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1069 if (!p->is_objArray()) |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1070 THROW_0(vmSymbols::java_lang_IllegalArgumentException()); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1071 cp_patches_h = objArrayHandle(THREAD, (objArrayOop)p); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1072 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1073 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1074 KlassHandle host_klass(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(host_class))); |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1075 const char* host_source = host_klass->external_name(); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1076 Handle host_loader(THREAD, host_klass->class_loader()); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1077 Handle host_domain(THREAD, host_klass->protection_domain()); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1078 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1079 GrowableArray<Handle>* cp_patches = NULL; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1080 if (cp_patches_h.not_null()) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1081 int alen = cp_patches_h->length(); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1082 for (int i = alen-1; i >= 0; i--) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1083 oop p = cp_patches_h->obj_at(i); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1084 if (p != NULL) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1085 Handle patch(THREAD, p); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1086 if (cp_patches == NULL) |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1087 cp_patches = new GrowableArray<Handle>(i+1, i+1, Handle()); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1088 cp_patches->at_put(i, patch); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1089 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1090 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1091 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1092 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1093 ClassFileStream st(class_bytes, class_bytes_length, (char*) host_source); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1094 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1095 instanceKlassHandle anon_klass; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1096 { |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2114
diff
changeset
|
1097 Symbol* no_class_name = NULL; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1098 Klass* anonk = SystemDictionary::parse_stream(no_class_name, |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1099 host_loader, host_domain, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1100 &st, host_klass, cp_patches, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1101 CHECK_NULL); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1102 if (anonk == NULL) return NULL; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1103 anon_klass = instanceKlassHandle(THREAD, anonk); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1104 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1105 |
|
7185
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1106 return anon_klass; |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1107 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1108 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1109 UNSAFE_ENTRY(jclass, Unsafe_DefineAnonymousClass(JNIEnv *env, jobject unsafe, jclass host_class, jbyteArray data, jobjectArray cp_patches_jh)) |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1110 { |
|
7185
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1111 instanceKlassHandle anon_klass; |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1112 jobject res_jh = NULL; |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1113 |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1114 UnsafeWrapper("Unsafe_DefineAnonymousClass"); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1115 ResourceMark rm(THREAD); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1116 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1117 HeapWord* temp_alloc = NULL; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1118 |
|
7185
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1119 anon_klass = Unsafe_DefineAnonymousClass_impl(env, host_class, data, |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1120 cp_patches_jh, |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1121 &temp_alloc, THREAD); |
|
7185
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1122 if (anon_klass() != NULL) |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1123 res_jh = JNIHandles::make_local(env, anon_klass->java_mirror()); |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1124 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1125 // try/finally clause: |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1126 if (temp_alloc != NULL) { |
| 6197 | 1127 FREE_C_HEAP_ARRAY(HeapWord, temp_alloc, mtInternal); |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1128 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1129 |
|
7185
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1130 // The anonymous class loader data has been artificially been kept alive to |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1131 // this point. The mirror and any instances of this class have to keep |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1132 // it alive afterwards. |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1133 if (anon_klass() != NULL) { |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1134 anon_klass->class_loader_data()->set_keep_alive(false); |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1135 } |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1136 |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1137 // let caller initialize it as needed... |
|
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
6983
diff
changeset
|
1138 |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1139 return (jclass) res_jh; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1140 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1141 UNSAFE_END |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1142 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1143 |
| 0 | 1144 |
| 1145 UNSAFE_ENTRY(void, Unsafe_MonitorEnter(JNIEnv *env, jobject unsafe, jobject jobj)) | |
| 1146 UnsafeWrapper("Unsafe_MonitorEnter"); | |
| 1147 { | |
| 1148 if (jobj == NULL) { | |
| 1149 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 1150 } | |
| 1151 Handle obj(thread, JNIHandles::resolve_non_null(jobj)); | |
| 1152 ObjectSynchronizer::jni_enter(obj, CHECK); | |
| 1153 } | |
| 1154 UNSAFE_END | |
| 1155 | |
| 1156 | |
| 1157 UNSAFE_ENTRY(jboolean, Unsafe_TryMonitorEnter(JNIEnv *env, jobject unsafe, jobject jobj)) | |
| 1158 UnsafeWrapper("Unsafe_TryMonitorEnter"); | |
| 1159 { | |
| 1160 if (jobj == NULL) { | |
| 1161 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_FALSE); | |
| 1162 } | |
| 1163 Handle obj(thread, JNIHandles::resolve_non_null(jobj)); | |
| 1164 bool res = ObjectSynchronizer::jni_try_enter(obj, CHECK_0); | |
| 1165 return (res ? JNI_TRUE : JNI_FALSE); | |
| 1166 } | |
| 1167 UNSAFE_END | |
| 1168 | |
| 1169 | |
| 1170 UNSAFE_ENTRY(void, Unsafe_MonitorExit(JNIEnv *env, jobject unsafe, jobject jobj)) | |
| 1171 UnsafeWrapper("Unsafe_MonitorExit"); | |
| 1172 { | |
| 1173 if (jobj == NULL) { | |
| 1174 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 1175 } | |
| 1176 Handle obj(THREAD, JNIHandles::resolve_non_null(jobj)); | |
| 1177 ObjectSynchronizer::jni_exit(obj(), CHECK); | |
| 1178 } | |
| 1179 UNSAFE_END | |
| 1180 | |
| 1181 | |
| 1182 UNSAFE_ENTRY(void, Unsafe_ThrowException(JNIEnv *env, jobject unsafe, jthrowable thr)) | |
| 1183 UnsafeWrapper("Unsafe_ThrowException"); | |
| 1184 { | |
| 1185 ThreadToNativeFromVM ttnfv(thread); | |
| 1186 env->Throw(thr); | |
| 1187 } | |
| 1188 UNSAFE_END | |
| 1189 | |
| 1190 // JSR166 ------------------------------------------------------------------ | |
| 1191 | |
| 1192 UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h)) | |
| 1193 UnsafeWrapper("Unsafe_CompareAndSwapObject"); | |
| 1194 oop x = JNIHandles::resolve(x_h); | |
| 1195 oop e = JNIHandles::resolve(e_h); | |
| 1196 oop p = JNIHandles::resolve(obj); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1197 HeapWord* addr = (HeapWord *)index_oop_from_field_offset_long(p, offset); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1198 oop res = oopDesc::atomic_compare_exchange_oop(x, addr, e, true); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1199 jboolean success = (res == e); |
| 0 | 1200 if (success) |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1201 update_barrier_set((void*)addr, x); |
| 0 | 1202 return success; |
| 1203 UNSAFE_END | |
| 1204 | |
| 1205 UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x)) | |
| 1206 UnsafeWrapper("Unsafe_CompareAndSwapInt"); | |
| 1207 oop p = JNIHandles::resolve(obj); | |
| 1208 jint* addr = (jint *) index_oop_from_field_offset_long(p, offset); | |
| 1209 return (jint)(Atomic::cmpxchg(x, addr, e)) == e; | |
| 1210 UNSAFE_END | |
| 1211 | |
| 1212 UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x)) | |
| 1213 UnsafeWrapper("Unsafe_CompareAndSwapLong"); | |
| 1214 Handle p (THREAD, JNIHandles::resolve(obj)); | |
| 1215 jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset)); | |
| 1216 if (VM_Version::supports_cx8()) | |
| 1217 return (jlong)(Atomic::cmpxchg(x, addr, e)) == e; | |
| 1218 else { | |
| 1219 jboolean success = false; | |
| 1220 ObjectLocker ol(p, THREAD); | |
| 1221 if (*addr == e) { *addr = x; success = true; } | |
| 1222 return success; | |
| 1223 } | |
| 1224 UNSAFE_END | |
| 1225 | |
| 1226 UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time)) | |
| 1227 UnsafeWrapper("Unsafe_Park"); | |
| 10405 | 1228 EventThreadPark event; |
| 4006 | 1229 #ifndef USDT2 |
|
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
845
diff
changeset
|
1230 HS_DTRACE_PROBE3(hotspot, thread__park__begin, thread->parker(), (int) isAbsolute, time); |
| 4006 | 1231 #else /* USDT2 */ |
| 1232 HOTSPOT_THREAD_PARK_BEGIN( | |
| 1233 (uintptr_t) thread->parker(), (int) isAbsolute, time); | |
| 1234 #endif /* USDT2 */ | |
| 0 | 1235 JavaThreadParkedState jtps(thread, time != 0); |
| 1236 thread->parker()->park(isAbsolute != 0, time); | |
| 4006 | 1237 #ifndef USDT2 |
|
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
845
diff
changeset
|
1238 HS_DTRACE_PROBE1(hotspot, thread__park__end, thread->parker()); |
| 4006 | 1239 #else /* USDT2 */ |
| 1240 HOTSPOT_THREAD_PARK_END( | |
| 1241 (uintptr_t) thread->parker()); | |
| 1242 #endif /* USDT2 */ | |
| 10405 | 1243 if (event.should_commit()) { |
| 1244 oop obj = thread->current_park_blocker(); | |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
10405
diff
changeset
|
1245 event.set_klass((obj != NULL) ? obj->klass() : NULL); |
| 10405 | 1246 event.set_timeout(time); |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
10405
diff
changeset
|
1247 event.set_address((obj != NULL) ? (TYPE_ADDRESS) cast_from_oop<uintptr_t>(obj) : 0); |
| 10405 | 1248 event.commit(); |
| 1249 } | |
| 0 | 1250 UNSAFE_END |
| 1251 | |
| 1252 UNSAFE_ENTRY(void, Unsafe_Unpark(JNIEnv *env, jobject unsafe, jobject jthread)) | |
| 1253 UnsafeWrapper("Unsafe_Unpark"); | |
| 1254 Parker* p = NULL; | |
| 1255 if (jthread != NULL) { | |
| 1256 oop java_thread = JNIHandles::resolve_non_null(jthread); | |
| 1257 if (java_thread != NULL) { | |
| 1258 jlong lp = java_lang_Thread::park_event(java_thread); | |
| 1259 if (lp != 0) { | |
| 1260 // This cast is OK even though the jlong might have been read | |
| 1261 // non-atomically on 32bit systems, since there, one word will | |
| 1262 // always be zero anyway and the value set is always the same | |
| 1263 p = (Parker*)addr_from_java(lp); | |
| 1264 } else { | |
| 1265 // Grab lock if apparently null or using older version of library | |
| 1266 MutexLocker mu(Threads_lock); | |
| 1267 java_thread = JNIHandles::resolve_non_null(jthread); | |
| 1268 if (java_thread != NULL) { | |
| 1269 JavaThread* thr = java_lang_Thread::thread(java_thread); | |
| 1270 if (thr != NULL) { | |
| 1271 p = thr->parker(); | |
| 1272 if (p != NULL) { // Bind to Java thread for next time. | |
| 1273 java_lang_Thread::set_park_event(java_thread, addr_to_java(p)); | |
| 1274 } | |
| 1275 } | |
| 1276 } | |
| 1277 } | |
| 1278 } | |
| 1279 } | |
| 1280 if (p != NULL) { | |
| 4006 | 1281 #ifndef USDT2 |
|
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
845
diff
changeset
|
1282 HS_DTRACE_PROBE1(hotspot, thread__unpark, p); |
| 4006 | 1283 #else /* USDT2 */ |
| 1284 HOTSPOT_THREAD_UNPARK( | |
| 1285 (uintptr_t) p); | |
| 1286 #endif /* USDT2 */ | |
| 0 | 1287 p->unpark(); |
| 1288 } | |
| 1289 UNSAFE_END | |
| 1290 | |
| 1291 UNSAFE_ENTRY(jint, Unsafe_Loadavg(JNIEnv *env, jobject unsafe, jdoubleArray loadavg, jint nelem)) | |
| 1292 UnsafeWrapper("Unsafe_Loadavg"); | |
| 1293 const int max_nelem = 3; | |
| 1294 double la[max_nelem]; | |
| 1295 jint ret; | |
| 1296 | |
| 1297 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(loadavg)); | |
| 1298 assert(a->is_typeArray(), "must be type array"); | |
| 1299 | |
| 1300 if (nelem < 0 || nelem > max_nelem || a->length() < nelem) { | |
| 1301 ThreadToNativeFromVM ttnfv(thread); | |
| 1302 throw_new(env, "ArrayIndexOutOfBoundsException"); | |
| 1303 return -1; | |
| 1304 } | |
| 1305 | |
| 1306 ret = os::loadavg(la, nelem); | |
| 1307 if (ret == -1) return -1; | |
| 1308 | |
| 1309 // if successful, ret is the number of samples actually retrieved. | |
| 1310 assert(ret >= 0 && ret <= max_nelem, "Unexpected loadavg return value"); | |
| 1311 switch(ret) { | |
| 1312 case 3: a->double_at_put(2, (jdouble)la[2]); // fall through | |
| 1313 case 2: a->double_at_put(1, (jdouble)la[1]); // fall through | |
| 1314 case 1: a->double_at_put(0, (jdouble)la[0]); break; | |
| 1315 } | |
| 1316 return ret; | |
| 1317 UNSAFE_END | |
| 1318 | |
| 1319 UNSAFE_ENTRY(void, Unsafe_PrefetchRead(JNIEnv* env, jclass ignored, jobject obj, jlong offset)) | |
| 1320 UnsafeWrapper("Unsafe_PrefetchRead"); | |
| 1321 oop p = JNIHandles::resolve(obj); | |
| 1322 void* addr = index_oop_from_field_offset_long(p, 0); | |
| 1323 Prefetch::read(addr, (intx)offset); | |
| 1324 UNSAFE_END | |
| 1325 | |
| 1326 UNSAFE_ENTRY(void, Unsafe_PrefetchWrite(JNIEnv* env, jclass ignored, jobject obj, jlong offset)) | |
| 1327 UnsafeWrapper("Unsafe_PrefetchWrite"); | |
| 1328 oop p = JNIHandles::resolve(obj); | |
| 1329 void* addr = index_oop_from_field_offset_long(p, 0); | |
| 1330 Prefetch::write(addr, (intx)offset); | |
| 1331 UNSAFE_END | |
| 1332 | |
| 1333 | |
| 1334 /// JVM_RegisterUnsafeMethods | |
| 1335 | |
| 1336 #define ADR "J" | |
| 1337 | |
| 1338 #define LANG "Ljava/lang/" | |
| 1339 | |
| 1340 #define OBJ LANG"Object;" | |
| 1341 #define CLS LANG"Class;" | |
| 1342 #define CTR LANG"reflect/Constructor;" | |
| 1343 #define FLD LANG"reflect/Field;" | |
| 1344 #define MTH LANG"reflect/Method;" | |
| 1345 #define THR LANG"Throwable;" | |
| 1346 | |
| 1347 #define DC0_Args LANG"String;[BII" | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1348 #define DC_Args DC0_Args LANG"ClassLoader;" "Ljava/security/ProtectionDomain;" |
| 0 | 1349 |
| 1350 #define CC (char*) /*cast a literal from (const char*)*/ | |
| 1351 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f) | |
| 1352 | |
| 1353 // define deprecated accessors for compabitility with 1.4.0 | |
| 1354 #define DECLARE_GETSETOOP_140(Boolean, Z) \ | |
| 1355 {CC"get"#Boolean, CC"("OBJ"I)"#Z, FN_PTR(Unsafe_Get##Boolean##140)}, \ | |
| 1356 {CC"put"#Boolean, CC"("OBJ"I"#Z")V", FN_PTR(Unsafe_Set##Boolean##140)} | |
| 1357 | |
| 1358 // Note: In 1.4.1, getObject and kin take both int and long offsets. | |
| 1359 #define DECLARE_GETSETOOP_141(Boolean, Z) \ | |
| 1360 {CC"get"#Boolean, CC"("OBJ"J)"#Z, FN_PTR(Unsafe_Get##Boolean)}, \ | |
| 1361 {CC"put"#Boolean, CC"("OBJ"J"#Z")V", FN_PTR(Unsafe_Set##Boolean)} | |
| 1362 | |
| 1363 // Note: In 1.5.0, there are volatile versions too | |
| 1364 #define DECLARE_GETSETOOP(Boolean, Z) \ | |
| 1365 {CC"get"#Boolean, CC"("OBJ"J)"#Z, FN_PTR(Unsafe_Get##Boolean)}, \ | |
| 1366 {CC"put"#Boolean, CC"("OBJ"J"#Z")V", FN_PTR(Unsafe_Set##Boolean)}, \ | |
| 1367 {CC"get"#Boolean"Volatile", CC"("OBJ"J)"#Z, FN_PTR(Unsafe_Get##Boolean##Volatile)}, \ | |
| 1368 {CC"put"#Boolean"Volatile", CC"("OBJ"J"#Z")V", FN_PTR(Unsafe_Set##Boolean##Volatile)} | |
| 1369 | |
| 1370 | |
| 1371 #define DECLARE_GETSETNATIVE(Byte, B) \ | |
| 1372 {CC"get"#Byte, CC"("ADR")"#B, FN_PTR(Unsafe_GetNative##Byte)}, \ | |
| 1373 {CC"put"#Byte, CC"("ADR#B")V", FN_PTR(Unsafe_SetNative##Byte)} | |
| 1374 | |
| 1375 | |
| 1376 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1377 // These are the methods for 1.4.0 |
| 0 | 1378 static JNINativeMethod methods_140[] = { |
| 1379 {CC"getObject", CC"("OBJ"I)"OBJ"", FN_PTR(Unsafe_GetObject140)}, | |
| 1380 {CC"putObject", CC"("OBJ"I"OBJ")V", FN_PTR(Unsafe_SetObject140)}, | |
| 1381 | |
| 1382 DECLARE_GETSETOOP_140(Boolean, Z), | |
| 1383 DECLARE_GETSETOOP_140(Byte, B), | |
| 1384 DECLARE_GETSETOOP_140(Short, S), | |
| 1385 DECLARE_GETSETOOP_140(Char, C), | |
| 1386 DECLARE_GETSETOOP_140(Int, I), | |
| 1387 DECLARE_GETSETOOP_140(Long, J), | |
| 1388 DECLARE_GETSETOOP_140(Float, F), | |
| 1389 DECLARE_GETSETOOP_140(Double, D), | |
| 1390 | |
| 1391 DECLARE_GETSETNATIVE(Byte, B), | |
| 1392 DECLARE_GETSETNATIVE(Short, S), | |
| 1393 DECLARE_GETSETNATIVE(Char, C), | |
| 1394 DECLARE_GETSETNATIVE(Int, I), | |
| 1395 DECLARE_GETSETNATIVE(Long, J), | |
| 1396 DECLARE_GETSETNATIVE(Float, F), | |
| 1397 DECLARE_GETSETNATIVE(Double, D), | |
| 1398 | |
| 1399 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | |
| 1400 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | |
| 1401 | |
| 1402 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | |
| 1403 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | |
| 1404 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | |
| 1405 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1406 {CC"fieldOffset", CC"("FLD")I", FN_PTR(Unsafe_FieldOffset)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1407 {CC"staticFieldBase", CC"("CLS")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromClass)}, |
| 0 | 1408 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, |
| 1409 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | |
| 1410 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | |
| 1411 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | |
| 1412 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | |
| 1413 | |
| 1414 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1415 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, |
| 0 | 1416 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, |
| 1417 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | |
| 1418 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | |
| 1419 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)} | |
| 1420 }; | |
| 1421 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1422 // These are the methods prior to the JSR 166 changes in 1.5.0 |
| 0 | 1423 static JNINativeMethod methods_141[] = { |
| 1424 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, | |
| 1425 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, | |
| 1426 | |
| 1427 DECLARE_GETSETOOP_141(Boolean, Z), | |
| 1428 DECLARE_GETSETOOP_141(Byte, B), | |
| 1429 DECLARE_GETSETOOP_141(Short, S), | |
| 1430 DECLARE_GETSETOOP_141(Char, C), | |
| 1431 DECLARE_GETSETOOP_141(Int, I), | |
| 1432 DECLARE_GETSETOOP_141(Long, J), | |
| 1433 DECLARE_GETSETOOP_141(Float, F), | |
| 1434 DECLARE_GETSETOOP_141(Double, D), | |
| 1435 | |
| 1436 DECLARE_GETSETNATIVE(Byte, B), | |
| 1437 DECLARE_GETSETNATIVE(Short, S), | |
| 1438 DECLARE_GETSETNATIVE(Char, C), | |
| 1439 DECLARE_GETSETNATIVE(Int, I), | |
| 1440 DECLARE_GETSETNATIVE(Long, J), | |
| 1441 DECLARE_GETSETNATIVE(Float, F), | |
| 1442 DECLARE_GETSETNATIVE(Double, D), | |
| 1443 | |
| 1444 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | |
| 1445 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | |
| 1446 | |
| 1447 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | |
| 1448 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | |
| 1449 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | |
| 1450 | |
| 1451 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | |
| 1452 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, | |
| 1453 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | |
| 1454 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | |
| 1455 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | |
| 1456 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | |
| 1457 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | |
| 1458 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | |
| 1459 | |
| 1460 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1461 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, |
| 0 | 1462 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, |
| 1463 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | |
| 1464 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | |
| 1465 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)} | |
| 1466 | |
| 1467 }; | |
| 1468 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1469 // These are the methods prior to the JSR 166 changes in 1.6.0 |
| 0 | 1470 static JNINativeMethod methods_15[] = { |
| 1471 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, | |
| 1472 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, | |
| 1473 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)}, | |
| 1474 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)}, | |
| 1475 | |
| 1476 | |
| 1477 DECLARE_GETSETOOP(Boolean, Z), | |
| 1478 DECLARE_GETSETOOP(Byte, B), | |
| 1479 DECLARE_GETSETOOP(Short, S), | |
| 1480 DECLARE_GETSETOOP(Char, C), | |
| 1481 DECLARE_GETSETOOP(Int, I), | |
| 1482 DECLARE_GETSETOOP(Long, J), | |
| 1483 DECLARE_GETSETOOP(Float, F), | |
| 1484 DECLARE_GETSETOOP(Double, D), | |
| 1485 | |
| 1486 DECLARE_GETSETNATIVE(Byte, B), | |
| 1487 DECLARE_GETSETNATIVE(Short, S), | |
| 1488 DECLARE_GETSETNATIVE(Char, C), | |
| 1489 DECLARE_GETSETNATIVE(Int, I), | |
| 1490 DECLARE_GETSETNATIVE(Long, J), | |
| 1491 DECLARE_GETSETNATIVE(Float, F), | |
| 1492 DECLARE_GETSETNATIVE(Double, D), | |
| 1493 | |
| 1494 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | |
| 1495 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | |
| 1496 | |
| 1497 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | |
| 1498 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | |
| 1499 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | |
| 1500 | |
| 1501 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | |
| 1502 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, | |
| 1503 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | |
| 1504 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | |
| 1505 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | |
| 1506 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | |
| 1507 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | |
| 1508 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | |
| 1509 | |
| 1510 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1511 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, |
| 0 | 1512 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, |
| 1513 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | |
| 1514 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | |
| 1515 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}, | |
| 1516 {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, | |
| 1517 {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, | |
| 1518 {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, | |
| 1519 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)}, | |
| 1520 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)} | |
| 1521 | |
| 1522 }; | |
| 1523 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1524 // These are the methods for 1.6.0 and 1.7.0 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1525 static JNINativeMethod methods_16[] = { |
| 0 | 1526 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, |
| 1527 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, | |
| 1528 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)}, | |
| 1529 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)}, | |
| 1530 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1531 DECLARE_GETSETOOP(Boolean, Z), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1532 DECLARE_GETSETOOP(Byte, B), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1533 DECLARE_GETSETOOP(Short, S), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1534 DECLARE_GETSETOOP(Char, C), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1535 DECLARE_GETSETOOP(Int, I), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1536 DECLARE_GETSETOOP(Long, J), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1537 DECLARE_GETSETOOP(Float, F), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1538 DECLARE_GETSETOOP(Double, D), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1539 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1540 DECLARE_GETSETNATIVE(Byte, B), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1541 DECLARE_GETSETNATIVE(Short, S), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1542 DECLARE_GETSETNATIVE(Char, C), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1543 DECLARE_GETSETNATIVE(Int, I), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1544 DECLARE_GETSETNATIVE(Long, J), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1545 DECLARE_GETSETNATIVE(Float, F), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1546 DECLARE_GETSETNATIVE(Double, D), |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1547 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1548 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1549 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1550 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1551 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1552 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1553 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1554 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1555 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1556 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1557 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1558 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1559 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1560 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1561 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1562 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1563 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1564 {CC"defineClass", CC"("DC0_Args")"CLS, FN_PTR(Unsafe_DefineClass0)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1565 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1566 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1567 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1568 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1569 {CC"tryMonitorEnter", CC"("OBJ")Z", FN_PTR(Unsafe_TryMonitorEnter)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1570 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1571 {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1572 {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1573 {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1574 {CC"putOrderedObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetOrderedObject)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1575 {CC"putOrderedInt", CC"("OBJ"JI)V", FN_PTR(Unsafe_SetOrderedInt)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1576 {CC"putOrderedLong", CC"("OBJ"JJ)V", FN_PTR(Unsafe_SetOrderedLong)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1577 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1578 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)} |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1579 }; |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1580 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1581 // These are the methods for 1.8.0 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1582 static JNINativeMethod methods_18[] = { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1583 {CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1584 {CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1585 {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1586 {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)}, |
| 0 | 1587 |
| 1588 DECLARE_GETSETOOP(Boolean, Z), | |
| 1589 DECLARE_GETSETOOP(Byte, B), | |
| 1590 DECLARE_GETSETOOP(Short, S), | |
| 1591 DECLARE_GETSETOOP(Char, C), | |
| 1592 DECLARE_GETSETOOP(Int, I), | |
| 1593 DECLARE_GETSETOOP(Long, J), | |
| 1594 DECLARE_GETSETOOP(Float, F), | |
| 1595 DECLARE_GETSETOOP(Double, D), | |
| 1596 | |
| 1597 DECLARE_GETSETNATIVE(Byte, B), | |
| 1598 DECLARE_GETSETNATIVE(Short, S), | |
| 1599 DECLARE_GETSETNATIVE(Char, C), | |
| 1600 DECLARE_GETSETNATIVE(Int, I), | |
| 1601 DECLARE_GETSETNATIVE(Long, J), | |
| 1602 DECLARE_GETSETNATIVE(Float, F), | |
| 1603 DECLARE_GETSETNATIVE(Double, D), | |
| 1604 | |
| 1605 {CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, | |
| 1606 {CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, | |
| 1607 | |
| 1608 {CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, | |
| 1609 {CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, | |
| 1610 {CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, | |
| 1611 | |
| 1612 {CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, | |
| 1613 {CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, | |
| 1614 {CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, | |
| 1615 {CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, | |
| 1616 {CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, | |
| 1617 {CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, | |
| 1618 {CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, | |
| 1619 {CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, | |
| 1620 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1621 {CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, |
| 0 | 1622 {CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, |
| 1623 {CC"monitorEnter", CC"("OBJ")V", FN_PTR(Unsafe_MonitorEnter)}, | |
| 1624 {CC"monitorExit", CC"("OBJ")V", FN_PTR(Unsafe_MonitorExit)}, | |
| 1625 {CC"tryMonitorEnter", CC"("OBJ")Z", FN_PTR(Unsafe_TryMonitorEnter)}, | |
| 1626 {CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}, | |
| 1627 {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, | |
| 1628 {CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, | |
| 1629 {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, | |
| 1630 {CC"putOrderedObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetOrderedObject)}, | |
| 1631 {CC"putOrderedInt", CC"("OBJ"JI)V", FN_PTR(Unsafe_SetOrderedInt)}, | |
| 1632 {CC"putOrderedLong", CC"("OBJ"JJ)V", FN_PTR(Unsafe_SetOrderedLong)}, | |
| 1633 {CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)}, | |
| 1634 {CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)} | |
| 1635 }; | |
| 1636 | |
| 1637 JNINativeMethod loadavg_method[] = { | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1638 {CC"getLoadAverage", CC"([DI)I", FN_PTR(Unsafe_Loadavg)} |
| 0 | 1639 }; |
| 1640 | |
| 1641 JNINativeMethod prefetch_methods[] = { | |
| 1642 {CC"prefetchRead", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)}, | |
| 1643 {CC"prefetchWrite", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)}, | |
| 1644 {CC"prefetchReadStatic", CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchRead)}, | |
| 1645 {CC"prefetchWriteStatic",CC"("OBJ"J)V", FN_PTR(Unsafe_PrefetchWrite)} | |
| 1646 }; | |
| 1647 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1648 JNINativeMethod memcopy_methods_17[] = { |
| 0 | 1649 {CC"copyMemory", CC"("OBJ"J"OBJ"JJ)V", FN_PTR(Unsafe_CopyMemory2)}, |
| 1650 {CC"setMemory", CC"("OBJ"JJB)V", FN_PTR(Unsafe_SetMemory2)} | |
| 1651 }; | |
| 1652 | |
| 1653 JNINativeMethod memcopy_methods_15[] = { | |
| 1654 {CC"setMemory", CC"("ADR"JB)V", FN_PTR(Unsafe_SetMemory)}, | |
| 1655 {CC"copyMemory", CC"("ADR ADR"J)V", FN_PTR(Unsafe_CopyMemory)} | |
| 1656 }; | |
| 1657 | |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1658 JNINativeMethod anonk_methods[] = { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1659 {CC"defineAnonymousClass", CC"("DAC_Args")"CLS, FN_PTR(Unsafe_DefineAnonymousClass)}, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
356
diff
changeset
|
1660 }; |
| 0 | 1661 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
1662 JNINativeMethod lform_methods[] = { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
1663 {CC"shouldBeInitialized",CC"("CLS")Z", FN_PTR(Unsafe_ShouldBeInitialized)}, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
1664 }; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
1665 |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1666 JNINativeMethod fence_methods[] = { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1667 {CC"loadFence", CC"()V", FN_PTR(Unsafe_LoadFence)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1668 {CC"storeFence", CC"()V", FN_PTR(Unsafe_StoreFence)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1669 {CC"fullFence", CC"()V", FN_PTR(Unsafe_FullFence)}, |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1670 }; |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1671 |
| 0 | 1672 #undef CC |
| 1673 #undef FN_PTR | |
| 1674 | |
| 1675 #undef ADR | |
| 1676 #undef LANG | |
| 1677 #undef OBJ | |
| 1678 #undef CLS | |
| 1679 #undef CTR | |
| 1680 #undef FLD | |
| 1681 #undef MTH | |
| 1682 #undef THR | |
| 1683 #undef DC0_Args | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1684 #undef DC_Args |
| 0 | 1685 |
| 1686 #undef DECLARE_GETSETOOP | |
| 1687 #undef DECLARE_GETSETNATIVE | |
| 1688 | |
| 1689 | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1690 /** |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1691 * Helper method to register native methods. |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1692 */ |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1693 static bool register_natives(const char* message, JNIEnv* env, jclass clazz, const JNINativeMethod* methods, jint nMethods) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1694 int status = env->RegisterNatives(clazz, methods, nMethods); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1695 if (status < 0 || env->ExceptionOccurred()) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1696 if (PrintMiscellaneous && (Verbose || WizardMode)) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1697 tty->print_cr("Unsafe: failed registering %s", message); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1698 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1699 env->ExceptionClear(); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1700 return false; |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1701 } else { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1702 if (PrintMiscellaneous && (Verbose || WizardMode)) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1703 tty->print_cr("Unsafe: successfully registered %s", message); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1704 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1705 return true; |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1706 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1707 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1708 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1709 |
| 0 | 1710 // This one function is exported, used by NativeLookup. |
| 1711 // The Unsafe_xxx functions above are called only from the interpreter. | |
| 1712 // The optimizer looks at names and signatures to recognize | |
| 1713 // individual functions. | |
| 1714 | |
| 1715 JVM_ENTRY(void, JVM_RegisterUnsafeMethods(JNIEnv *env, jclass unsafecls)) | |
| 1716 UnsafeWrapper("JVM_RegisterUnsafeMethods"); | |
| 1717 { | |
| 1718 ThreadToNativeFromVM ttnfv(thread); | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1719 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1720 // Unsafe methods |
| 0 | 1721 { |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1722 bool success = false; |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1723 // We need to register the 1.6 methods first because the 1.8 methods would register fine on 1.7 and 1.6 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1724 if (!success) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1725 success = register_natives("1.6 methods", env, unsafecls, methods_16, sizeof(methods_16)/sizeof(JNINativeMethod)); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1726 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1727 if (!success) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1728 success = register_natives("1.8 methods", env, unsafecls, methods_18, sizeof(methods_18)/sizeof(JNINativeMethod)); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1729 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1730 if (!success) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1731 success = register_natives("1.5 methods", env, unsafecls, methods_15, sizeof(methods_15)/sizeof(JNINativeMethod)); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1732 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1733 if (!success) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1734 success = register_natives("1.4.1 methods", env, unsafecls, methods_141, sizeof(methods_141)/sizeof(JNINativeMethod)); |
| 0 | 1735 } |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1736 if (!success) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1737 success = register_natives("1.4.0 methods", env, unsafecls, methods_140, sizeof(methods_140)/sizeof(JNINativeMethod)); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1738 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1739 guarantee(success, "register unsafe natives"); |
| 0 | 1740 } |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1741 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1742 // Unsafe.getLoadAverage |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1743 register_natives("1.6 loadavg method", env, unsafecls, loadavg_method, sizeof(loadavg_method)/sizeof(JNINativeMethod)); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1744 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1745 // Prefetch methods |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1746 register_natives("1.6 prefetch methods", env, unsafecls, prefetch_methods, sizeof(prefetch_methods)/sizeof(JNINativeMethod)); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1747 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1748 // Memory copy methods |
| 0 | 1749 { |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1750 bool success = false; |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1751 if (!success) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1752 success = register_natives("1.7 memory copy methods", env, unsafecls, memcopy_methods_17, sizeof(memcopy_methods_17)/sizeof(JNINativeMethod)); |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1753 } |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1754 if (!success) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1755 success = register_natives("1.5 memory copy methods", env, unsafecls, memcopy_methods_15, sizeof(memcopy_methods_15)/sizeof(JNINativeMethod)); |
| 0 | 1756 } |
| 1757 } | |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1758 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1759 // Unsafe.defineAnonymousClass |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2376
diff
changeset
|
1760 if (EnableInvokeDynamic) { |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1761 register_natives("1.7 define anonymous class method", env, unsafecls, anonk_methods, sizeof(anonk_methods)/sizeof(JNINativeMethod)); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6226
diff
changeset
|
1762 } |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1763 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1764 // Unsafe.shouldBeInitialized |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1765 if (EnableInvokeDynamic) { |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1766 register_natives("1.7 LambdaForm support", env, unsafecls, lform_methods, sizeof(lform_methods)/sizeof(JNINativeMethod)); |
| 0 | 1767 } |
|
8866
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1768 |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1769 // Fence methods |
|
16885e702c88
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
8001
diff
changeset
|
1770 register_natives("1.8 fence methods", env, unsafecls, fence_methods, sizeof(fence_methods)/sizeof(JNINativeMethod)); |
| 0 | 1771 } |
| 1772 JVM_END |