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