1 /*
2 * Copyright (c) 2000, 2023, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/classFileStream.hpp"
27 #include "classfile/classLoader.hpp"
28 #include "classfile/classLoadInfo.hpp"
29 #include "classfile/javaClasses.inline.hpp"
30 #include "classfile/systemDictionary.hpp"
31 #include "classfile/vmSymbols.hpp"
32 #include "jfr/jfrEvents.hpp"
33 #include "jni.h"
34 #include "jvm.h"
35 #include "memory/allocation.inline.hpp"
36 #include "memory/resourceArea.hpp"
37 #include "logging/log.hpp"
38 #include "logging/logStream.hpp"
39 #include "oops/access.inline.hpp"
40 #include "oops/fieldStreams.inline.hpp"
41 #include "oops/flatArrayKlass.hpp"
42 #include "oops/flatArrayOop.inline.hpp"
43 #include "oops/inlineKlass.inline.hpp"
44 #include "oops/instanceKlass.inline.hpp"
45 #include "oops/klass.inline.hpp"
46 #include "oops/objArrayOop.inline.hpp"
47 #include "oops/oop.inline.hpp"
48 #include "oops/typeArrayOop.inline.hpp"
49 #include "prims/jvmtiExport.hpp"
50 #include "prims/unsafe.hpp"
51 #include "runtime/fieldDescriptor.inline.hpp"
52 #include "runtime/globals.hpp"
53 #include "runtime/handles.inline.hpp"
54 #include "runtime/interfaceSupport.inline.hpp"
55 #include "runtime/javaThread.inline.hpp"
56 #include "runtime/jniHandles.inline.hpp"
57 #include "runtime/orderAccess.hpp"
58 #include "runtime/reflection.hpp"
59 #include "runtime/sharedRuntime.hpp"
60 #include "runtime/stubRoutines.hpp"
61 #include "runtime/threadSMR.hpp"
62 #include "runtime/vmOperations.hpp"
63 #include "runtime/vm_version.hpp"
64 #include "services/threadService.hpp"
65 #include "utilities/align.hpp"
66 #include "utilities/copy.hpp"
67 #include "utilities/dtrace.hpp"
68 #include "utilities/macros.hpp"
69
70 /**
71 * Implementation of the jdk.internal.misc.Unsafe class
72 */
73
74
75 #define MAX_OBJECT_SIZE \
76 ( arrayOopDesc::header_size(T_DOUBLE) * HeapWordSize \
77 + ((julong)max_jint * sizeof(double)) )
78
79 #define UNSAFE_ENTRY(result_type, header) \
80 JVM_ENTRY(static result_type, header)
81
82 #define UNSAFE_LEAF(result_type, header) \
83 JVM_LEAF(static result_type, header)
84
85 // Note that scoped accesses (cf. scopedMemoryAccess.cpp) can install
86 // an async handshake on the entry to an Unsafe method. When that happens,
87 // it is expected that we are not allowed to touch the underlying memory
88 // that might have gotten unmapped. Therefore, we check at the entry
89 // to unsafe functions, if we have such async exception conditions,
90 // and return immediately if that is the case.
91 //
92 // We can't have safepoints in this code.
93 // It would be problematic if an async exception handshake were installed later on
94 // during another safepoint in the function, but before the memory access happens,
95 // as the memory will be freed after the handshake is installed. We must notice
96 // the installed handshake and return early before doing the memory access to prevent
97 // accesses to freed memory.
98 //
99 // Note also that we MUST do a scoped memory access in the VM (or Java) thread
100 // state. Since we rely on a handshake to check for threads that are accessing
101 // scoped memory, and we need the handshaking thread to wait until we get to a
102 // safepoint, in order to make sure we are not in the middle of accessing memory
103 // that is about to be freed. (i.e. there can be no UNSAFE_LEAF_SCOPED)
104 #define UNSAFE_ENTRY_SCOPED(result_type, header) \
105 JVM_ENTRY(static result_type, header) \
106 if (thread->has_async_exception_condition()) {return (result_type)0;}
107
108 #define UNSAFE_END JVM_END
109
110
111 static inline void* addr_from_java(jlong addr) {
112 // This assert fails in a variety of ways on 32-bit systems.
113 // It is impossible to predict whether native code that converts
114 // pointers to longs will sign-extend or zero-extend the addresses.
115 //assert(addr == (uintptr_t)addr, "must not be odd high bits");
116 return (void*)(uintptr_t)addr;
117 }
118
119 static inline jlong addr_to_java(void* p) {
120 assert(p == (void*)(uintptr_t)p, "must not be odd high bits");
121 return (uintptr_t)p;
122 }
123
124
125 // Note: The VM's obj_field and related accessors use byte-scaled
126 // ("unscaled") offsets, just as the unsafe methods do.
127
128 // However, the method Unsafe.fieldOffset explicitly declines to
129 // guarantee this. The field offset values manipulated by the Java user
130 // through the Unsafe API are opaque cookies that just happen to be byte
131 // offsets. We represent this state of affairs by passing the cookies
132 // through conversion functions when going between the VM and the Unsafe API.
133 // The conversion functions just happen to be no-ops at present.
134
135 static inline jlong field_offset_to_byte_offset(jlong field_offset) {
136 return field_offset;
137 }
138
139 static inline int field_offset_from_byte_offset(int byte_offset) {
140 return byte_offset;
141 }
142
143 static inline void assert_field_offset_sane(oop p, jlong field_offset) {
144 #ifdef ASSERT
145 jlong byte_offset = field_offset_to_byte_offset(field_offset);
146
147 if (p != nullptr) {
148 assert(byte_offset >= 0 && byte_offset <= (jlong)MAX_OBJECT_SIZE, "sane offset");
149 if (byte_offset == (jint)byte_offset) {
150 void* ptr_plus_disp = cast_from_oop<address>(p) + byte_offset;
151 assert(p->field_addr<void>((jint)byte_offset) == ptr_plus_disp,
152 "raw [ptr+disp] must be consistent with oop::field_addr");
153 }
154 jlong p_size = HeapWordSize * (jlong)(p->size());
155 assert(byte_offset < p_size, "Unsafe access: offset " INT64_FORMAT " > object's size " INT64_FORMAT, (int64_t)byte_offset, (int64_t)p_size);
156 }
157 #endif
158 }
159
160 static inline void* index_oop_from_field_offset_long(oop p, jlong field_offset) {
161 assert_field_offset_sane(p, field_offset);
162 jlong byte_offset = field_offset_to_byte_offset(field_offset);
163
164 if (sizeof(char*) == sizeof(jint)) { // (this constant folds!)
165 return cast_from_oop<address>(p) + (jint) byte_offset;
166 } else {
167 return cast_from_oop<address>(p) + byte_offset;
168 }
169 }
170
171 // Externally callable versions:
172 // (Use these in compiler intrinsics which emulate unsafe primitives.)
173 jlong Unsafe_field_offset_to_byte_offset(jlong field_offset) {
174 return field_offset;
175 }
176 jlong Unsafe_field_offset_from_byte_offset(jlong byte_offset) {
177 return byte_offset;
178 }
179
180 ///// Data read/writes on the Java heap and in native (off-heap) memory
181
182 /**
183 * Helper class to wrap memory accesses in JavaThread::doing_unsafe_access()
184 */
185 class GuardUnsafeAccess {
186 JavaThread* _thread;
187
188 public:
189 GuardUnsafeAccess(JavaThread* thread) : _thread(thread) {
190 // native/off-heap access which may raise SIGBUS if accessing
191 // memory mapped file data in a region of the file which has
192 // been truncated and is now invalid.
193 _thread->set_doing_unsafe_access(true);
194 }
195
196 ~GuardUnsafeAccess() {
197 _thread->set_doing_unsafe_access(false);
198 }
199 };
200
201 /**
202 * Helper class for accessing memory.
203 *
204 * Normalizes values and wraps accesses in
205 * JavaThread::doing_unsafe_access() if needed.
206 */
207 template <typename T>
208 class MemoryAccess : StackObj {
209 JavaThread* _thread;
210 oop _obj;
211 ptrdiff_t _offset;
212
213 // Resolves and returns the address of the memory access.
214 // This raw memory access may fault, so we make sure it happens within the
215 // guarded scope by making the access volatile at least. Since the store
216 // of Thread::set_doing_unsafe_access() is also volatile, these accesses
217 // can not be reordered by the compiler. Therefore, if the access triggers
218 // a fault, we will know that Thread::doing_unsafe_access() returns true.
219 volatile T* addr() {
220 void* addr = index_oop_from_field_offset_long(_obj, _offset);
221 return static_cast<volatile T*>(addr);
222 }
223
224 template <typename U>
225 U normalize_for_write(U x) {
226 return x;
227 }
228
229 jboolean normalize_for_write(jboolean x) {
230 return x & 1;
231 }
232
233 template <typename U>
234 U normalize_for_read(U x) {
235 return x;
236 }
237
238 jboolean normalize_for_read(jboolean x) {
239 return x != 0;
240 }
241
242 public:
243 MemoryAccess(JavaThread* thread, jobject obj, jlong offset)
244 : _thread(thread), _obj(JNIHandles::resolve(obj)), _offset((ptrdiff_t)offset) {
245 assert_field_offset_sane(_obj, offset);
246 }
247
248 T get() {
249 GuardUnsafeAccess guard(_thread);
250 return normalize_for_read(*addr());
251 }
252
253 void put(T x) {
254 GuardUnsafeAccess guard(_thread);
255 assert(_obj == nullptr || !_obj->is_inline_type() || _obj->mark().is_larval_state(), "must be an object instance or a larval inline type");
256 *addr() = normalize_for_write(x);
257 }
258
259 T get_volatile() {
260 GuardUnsafeAccess guard(_thread);
261 volatile T ret = RawAccess<MO_SEQ_CST>::load(addr());
262 return normalize_for_read(ret);
263 }
264
265 void put_volatile(T x) {
266 GuardUnsafeAccess guard(_thread);
267 RawAccess<MO_SEQ_CST>::store(addr(), normalize_for_write(x));
268 }
269 };
270
271 #ifdef ASSERT
272 /*
273 * Get the field descriptor of the field of the given object at the given offset.
274 */
275 static bool get_field_descriptor(oop p, jlong offset, fieldDescriptor* fd) {
276 bool found = false;
277 Klass* k = p->klass();
278 if (k->is_instance_klass()) {
279 InstanceKlass* ik = InstanceKlass::cast(k);
280 found = ik->find_field_from_offset((int)offset, false, fd);
281 if (!found && ik->is_mirror_instance_klass()) {
282 Klass* k2 = java_lang_Class::as_Klass(p);
283 if (k2->is_instance_klass()) {
284 ik = InstanceKlass::cast(k2);
285 found = ik->find_field_from_offset((int)offset, true, fd);
286 }
287 }
288 }
289 return found;
290 }
291 #endif // ASSERT
292
293 static void assert_and_log_unsafe_value_access(oop p, jlong offset, InlineKlass* vk) {
294 Klass* k = p->klass();
295 #ifdef ASSERT
296 if (k->is_instance_klass()) {
297 assert_field_offset_sane(p, offset);
298 fieldDescriptor fd;
299 bool found = get_field_descriptor(p, offset, &fd);
300 if (found) {
301 assert(found, "value field not found");
302 assert(fd.is_flat(), "field not flat");
303 } else {
304 if (log_is_enabled(Trace, valuetypes)) {
305 log_trace(valuetypes)("not a field in %s at offset " UINT64_FORMAT_X,
306 p->klass()->external_name(), (uint64_t)offset);
307 }
308 }
309 } else if (k->is_flatArray_klass()) {
310 FlatArrayKlass* vak = FlatArrayKlass::cast(k);
311 int index = (offset - vak->array_header_in_bytes()) / vak->element_byte_size();
312 address dest = (address)((flatArrayOop)p)->value_at_addr(index, vak->layout_helper());
313 assert(dest == (cast_from_oop<address>(p) + offset), "invalid offset");
314 } else {
315 ShouldNotReachHere();
316 }
317 #endif // ASSERT
318 if (log_is_enabled(Trace, valuetypes)) {
319 if (k->is_flatArray_klass()) {
320 FlatArrayKlass* vak = FlatArrayKlass::cast(k);
321 int index = (offset - vak->array_header_in_bytes()) / vak->element_byte_size();
322 address dest = (address)((flatArrayOop)p)->value_at_addr(index, vak->layout_helper());
323 log_trace(valuetypes)("%s array type %s index %d element size %d offset " UINT64_FORMAT_X " at " INTPTR_FORMAT,
324 p->klass()->external_name(), vak->external_name(),
325 index, vak->element_byte_size(), (uint64_t)offset, p2i(dest));
326 } else {
327 log_trace(valuetypes)("%s field type %s at offset " UINT64_FORMAT_X,
328 p->klass()->external_name(), vk->external_name(), (uint64_t)offset);
329 }
330 }
331 }
332
333 // These functions allow a null base pointer with an arbitrary address.
334 // But if the base pointer is non-null, the offset should make some sense.
335 // That is, it should be in the range [0, MAX_OBJECT_SIZE].
336 UNSAFE_ENTRY(jobject, Unsafe_GetReference(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) {
337 oop p = JNIHandles::resolve(obj);
338 assert_field_offset_sane(p, offset);
339 oop v = HeapAccess<ON_UNKNOWN_OOP_REF>::oop_load_at(p, offset);
340 return JNIHandles::make_local(THREAD, v);
341 } UNSAFE_END
342
343 UNSAFE_ENTRY(void, Unsafe_PutReference(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) {
344 oop x = JNIHandles::resolve(x_h);
345 oop p = JNIHandles::resolve(obj);
346 assert_field_offset_sane(p, offset);
347 assert(!p->is_inline_type() || p->mark().is_larval_state(), "must be an object instance or a larval inline type");
348 HeapAccess<ON_UNKNOWN_OOP_REF>::oop_store_at(p, offset, x);
349 } UNSAFE_END
350
351 UNSAFE_ENTRY(jlong, Unsafe_ValueHeaderSize(JNIEnv *env, jobject unsafe, jclass c)) {
352 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(c));
353 InlineKlass* vk = InlineKlass::cast(k);
354 return vk->first_field_offset();
355 } UNSAFE_END
356
357 UNSAFE_ENTRY(jboolean, Unsafe_IsFlatField(JNIEnv *env, jobject unsafe, jobject o)) {
358 oop f = JNIHandles::resolve_non_null(o);
359 Klass* k = java_lang_Class::as_Klass(java_lang_reflect_Field::clazz(f));
360 int slot = java_lang_reflect_Field::slot(f);
361 return InstanceKlass::cast(k)->field_is_flat(slot);
362 } UNSAFE_END
363
364 UNSAFE_ENTRY(jboolean, Unsafe_HasNullMarker(JNIEnv *env, jobject unsage, jobject o)) {
365 oop f = JNIHandles::resolve_non_null(o);
366 Klass* k = java_lang_Class::as_Klass(java_lang_reflect_Field::clazz(f));
367 int slot = java_lang_reflect_Field::slot(f);
368 return InstanceKlass::cast(k)->field_has_null_marker(slot);
369 } UNSAFE_END
370
371 UNSAFE_ENTRY(jint, Unsafe_NullMarkerOffset(JNIEnv *env, jobject unsage, jobject o)) {
372 oop f = JNIHandles::resolve_non_null(o);
373 Klass* k = java_lang_Class::as_Klass(java_lang_reflect_Field::clazz(f));
374 int slot = java_lang_reflect_Field::slot(f);
375 return InstanceKlass::cast(k)->null_marker_offsets_array()->at(slot);
376 } UNSAFE_END
377
378 UNSAFE_ENTRY(jboolean, Unsafe_IsFlatArray(JNIEnv *env, jobject unsafe, jclass c)) {
379 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(c));
380 return k->is_flatArray_klass();
381 } UNSAFE_END
382
383 UNSAFE_ENTRY(jobject, Unsafe_UninitializedDefaultValue(JNIEnv *env, jobject unsafe, jclass vc)) {
384 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(vc));
385 InlineKlass* vk = InlineKlass::cast(k);
386 oop v = vk->default_value();
387 return JNIHandles::make_local(THREAD, v);
388 } UNSAFE_END
389
390 UNSAFE_ENTRY(jobject, Unsafe_GetValue(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jclass vc)) {
391 oop base = JNIHandles::resolve(obj);
392 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(vc));
393 InlineKlass* vk = InlineKlass::cast(k);
394 assert_and_log_unsafe_value_access(base, offset, vk);
395 Handle base_h(THREAD, base);
396 oop v = vk->read_flat_field(base_h(), offset, CHECK_NULL);
397 return JNIHandles::make_local(THREAD, v);
398 } UNSAFE_END
399
400 UNSAFE_ENTRY(void, Unsafe_PutValue(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jclass vc, jobject value)) {
401 oop base = JNIHandles::resolve(obj);
402 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(vc));
403 InlineKlass* vk = InlineKlass::cast(k);
404 assert(!base->is_inline_type() || base->mark().is_larval_state(), "must be an object instance or a larval inline type");
405 assert_and_log_unsafe_value_access(base, offset, vk);
406 oop v = JNIHandles::resolve(value);
407 vk->write_flat_field(base, offset, v, CHECK);
408 } UNSAFE_END
409
410 UNSAFE_ENTRY(jobject, Unsafe_MakePrivateBuffer(JNIEnv *env, jobject unsafe, jobject value)) {
411 oop v = JNIHandles::resolve_non_null(value);
412 assert(v->is_inline_type(), "must be an inline type instance");
413 Handle vh(THREAD, v);
414 InlineKlass* vk = InlineKlass::cast(v->klass());
415 instanceOop new_value = vk->allocate_instance_buffer(CHECK_NULL);
416 vk->inline_copy_oop_to_new_oop(vh(), new_value);
417 markWord mark = new_value->mark();
418 new_value->set_mark(mark.enter_larval_state());
419 return JNIHandles::make_local(THREAD, new_value);
420 } UNSAFE_END
421
422 UNSAFE_ENTRY(jobject, Unsafe_FinishPrivateBuffer(JNIEnv *env, jobject unsafe, jobject value)) {
423 oop v = JNIHandles::resolve(value);
424 assert(v->mark().is_larval_state(), "must be a larval value");
425 markWord mark = v->mark();
426 v->set_mark(mark.exit_larval_state());
427 return JNIHandles::make_local(THREAD, v);
428 } UNSAFE_END
429
430 UNSAFE_ENTRY(jobject, Unsafe_GetReferenceVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) {
431 oop p = JNIHandles::resolve(obj);
432 assert_field_offset_sane(p, offset);
433 oop v = HeapAccess<MO_SEQ_CST | ON_UNKNOWN_OOP_REF>::oop_load_at(p, offset);
434 return JNIHandles::make_local(THREAD, v);
435 } UNSAFE_END
436
437 UNSAFE_ENTRY(void, Unsafe_PutReferenceVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) {
438 oop x = JNIHandles::resolve(x_h);
439 oop p = JNIHandles::resolve(obj);
440 assert_field_offset_sane(p, offset);
441 HeapAccess<MO_SEQ_CST | ON_UNKNOWN_OOP_REF>::oop_store_at(p, offset, x);
442 } UNSAFE_END
443
444 UNSAFE_ENTRY(jobject, Unsafe_GetUncompressedObject(JNIEnv *env, jobject unsafe, jlong addr)) {
445 oop v = *(oop*) (address) addr;
446 return JNIHandles::make_local(THREAD, v);
447 } UNSAFE_END
448
449 #define DEFINE_GETSETOOP(java_type, Type) \
450 \
451 UNSAFE_ENTRY_SCOPED(java_type, Unsafe_Get##Type(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) { \
452 return MemoryAccess<java_type>(thread, obj, offset).get(); \
453 } UNSAFE_END \
454 \
455 UNSAFE_ENTRY_SCOPED(void, Unsafe_Put##Type(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, java_type x)) { \
456 MemoryAccess<java_type>(thread, obj, offset).put(x); \
457 } UNSAFE_END \
458 \
459 // END DEFINE_GETSETOOP.
460
461 DEFINE_GETSETOOP(jboolean, Boolean)
462 DEFINE_GETSETOOP(jbyte, Byte)
463 DEFINE_GETSETOOP(jshort, Short);
464 DEFINE_GETSETOOP(jchar, Char);
465 DEFINE_GETSETOOP(jint, Int);
466 DEFINE_GETSETOOP(jlong, Long);
467 DEFINE_GETSETOOP(jfloat, Float);
468 DEFINE_GETSETOOP(jdouble, Double);
469
470 #undef DEFINE_GETSETOOP
471
472 #define DEFINE_GETSETOOP_VOLATILE(java_type, Type) \
473 \
474 UNSAFE_ENTRY_SCOPED(java_type, Unsafe_Get##Type##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) { \
475 return MemoryAccess<java_type>(thread, obj, offset).get_volatile(); \
476 } UNSAFE_END \
477 \
478 UNSAFE_ENTRY_SCOPED(void, Unsafe_Put##Type##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, java_type x)) { \
479 MemoryAccess<java_type>(thread, obj, offset).put_volatile(x); \
480 } UNSAFE_END \
481 \
482 // END DEFINE_GETSETOOP_VOLATILE.
483
484 DEFINE_GETSETOOP_VOLATILE(jboolean, Boolean)
485 DEFINE_GETSETOOP_VOLATILE(jbyte, Byte)
486 DEFINE_GETSETOOP_VOLATILE(jshort, Short);
487 DEFINE_GETSETOOP_VOLATILE(jchar, Char);
488 DEFINE_GETSETOOP_VOLATILE(jint, Int);
489 DEFINE_GETSETOOP_VOLATILE(jlong, Long);
490 DEFINE_GETSETOOP_VOLATILE(jfloat, Float);
491 DEFINE_GETSETOOP_VOLATILE(jdouble, Double);
492
493 #undef DEFINE_GETSETOOP_VOLATILE
494
495 UNSAFE_LEAF(void, Unsafe_FullFence(JNIEnv *env, jobject unsafe)) {
496 OrderAccess::fence();
497 } UNSAFE_END
498
499 ////// Allocation requests
500
501 UNSAFE_ENTRY(jobject, Unsafe_AllocateInstance(JNIEnv *env, jobject unsafe, jclass cls)) {
502 JvmtiVMObjectAllocEventCollector oam;
503 instanceOop i = InstanceKlass::allocate_instance(JNIHandles::resolve_non_null(cls), CHECK_NULL);
504 return JNIHandles::make_local(THREAD, i);
505 } UNSAFE_END
506
507 UNSAFE_LEAF(jlong, Unsafe_AllocateMemory0(JNIEnv *env, jobject unsafe, jlong size)) {
508 size_t sz = (size_t)size;
509
510 assert(is_aligned(sz, HeapWordSize), "sz not aligned");
511
512 void* x = os::malloc(sz, mtOther);
513
514 return addr_to_java(x);
515 } UNSAFE_END
516
517 UNSAFE_LEAF(jlong, Unsafe_ReallocateMemory0(JNIEnv *env, jobject unsafe, jlong addr, jlong size)) {
518 void* p = addr_from_java(addr);
519 size_t sz = (size_t)size;
520
521 assert(is_aligned(sz, HeapWordSize), "sz not aligned");
522
523 void* x = os::realloc(p, sz, mtOther);
524
525 return addr_to_java(x);
526 } UNSAFE_END
527
528 UNSAFE_LEAF(void, Unsafe_FreeMemory0(JNIEnv *env, jobject unsafe, jlong addr)) {
529 void* p = addr_from_java(addr);
530
531 os::free(p);
532 } UNSAFE_END
533
534 UNSAFE_ENTRY_SCOPED(void, Unsafe_SetMemory0(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong size, jbyte value)) {
535 size_t sz = (size_t)size;
536
537 oop base = JNIHandles::resolve(obj);
538 void* p = index_oop_from_field_offset_long(base, offset);
539
540 {
541 GuardUnsafeAccess guard(thread);
542 Copy::fill_to_memory_atomic(p, sz, value);
543 }
544 } UNSAFE_END
545
546 UNSAFE_ENTRY_SCOPED(void, Unsafe_CopyMemory0(JNIEnv *env, jobject unsafe, jobject srcObj, jlong srcOffset, jobject dstObj, jlong dstOffset, jlong size)) {
547 size_t sz = (size_t)size;
548
549 oop srcp = JNIHandles::resolve(srcObj);
550 oop dstp = JNIHandles::resolve(dstObj);
551
552 void* src = index_oop_from_field_offset_long(srcp, srcOffset);
553 void* dst = index_oop_from_field_offset_long(dstp, dstOffset);
554 {
555 GuardUnsafeAccess guard(thread);
556 if (StubRoutines::unsafe_arraycopy() != nullptr) {
557 MACOS_AARCH64_ONLY(ThreadWXEnable wx(WXExec, thread));
558 StubRoutines::UnsafeArrayCopy_stub()(src, dst, sz);
559 } else {
560 Copy::conjoint_memory_atomic(src, dst, sz);
561 }
562 }
563 } UNSAFE_END
564
565 UNSAFE_ENTRY_SCOPED(void, Unsafe_CopySwapMemory0(JNIEnv *env, jobject unsafe, jobject srcObj, jlong srcOffset, jobject dstObj, jlong dstOffset, jlong size, jlong elemSize)) {
566 size_t sz = (size_t)size;
567 size_t esz = (size_t)elemSize;
568
569 oop srcp = JNIHandles::resolve(srcObj);
570 oop dstp = JNIHandles::resolve(dstObj);
571
572 address src = (address)index_oop_from_field_offset_long(srcp, srcOffset);
573 address dst = (address)index_oop_from_field_offset_long(dstp, dstOffset);
574
575 {
576 GuardUnsafeAccess guard(thread);
577 Copy::conjoint_swap(src, dst, sz, esz);
578 }
579 } UNSAFE_END
580
581 UNSAFE_LEAF (void, Unsafe_WriteBack0(JNIEnv *env, jobject unsafe, jlong line)) {
582 assert(VM_Version::supports_data_cache_line_flush(), "should not get here");
583 #ifdef ASSERT
584 if (TraceMemoryWriteback) {
585 tty->print_cr("Unsafe: writeback 0x%p", addr_from_java(line));
586 }
587 #endif
588
589 MACOS_AARCH64_ONLY(ThreadWXEnable wx(WXExec, Thread::current()));
590 assert(StubRoutines::data_cache_writeback() != nullptr, "sanity");
591 (StubRoutines::DataCacheWriteback_stub())(addr_from_java(line));
592 } UNSAFE_END
593
594 static void doWriteBackSync0(bool is_pre)
595 {
596 MACOS_AARCH64_ONLY(ThreadWXEnable wx(WXExec, Thread::current()));
597 assert(StubRoutines::data_cache_writeback_sync() != nullptr, "sanity");
598 (StubRoutines::DataCacheWritebackSync_stub())(is_pre);
599 }
600
601 UNSAFE_LEAF (void, Unsafe_WriteBackPreSync0(JNIEnv *env, jobject unsafe)) {
602 assert(VM_Version::supports_data_cache_line_flush(), "should not get here");
603 #ifdef ASSERT
604 if (TraceMemoryWriteback) {
605 tty->print_cr("Unsafe: writeback pre-sync");
606 }
607 #endif
608
609 doWriteBackSync0(true);
610 } UNSAFE_END
611
612 UNSAFE_LEAF (void, Unsafe_WriteBackPostSync0(JNIEnv *env, jobject unsafe)) {
613 assert(VM_Version::supports_data_cache_line_flush(), "should not get here");
614 #ifdef ASSERT
615 if (TraceMemoryWriteback) {
616 tty->print_cr("Unsafe: writeback pre-sync");
617 }
618 #endif
619
620 doWriteBackSync0(false);
621 } UNSAFE_END
622
623 ////// Random queries
624
625 static jlong find_field_offset(jclass clazz, jstring name, TRAPS) {
626 assert(clazz != nullptr, "clazz must not be null");
627 assert(name != nullptr, "name must not be null");
628
629 ResourceMark rm(THREAD);
630 char *utf_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name));
631
632 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
633
634 jint offset = -1;
635 for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
636 Symbol *name = fs.name();
637 if (name->equals(utf_name)) {
638 offset = fs.offset();
639 break;
640 }
641 }
642 if (offset < 0) {
643 THROW_0(vmSymbols::java_lang_InternalError());
644 }
645 return field_offset_from_byte_offset(offset);
646 }
647
648 static jlong find_field_offset(jobject field, int must_be_static, TRAPS) {
649 assert(field != nullptr, "field must not be null");
650
651 oop reflected = JNIHandles::resolve_non_null(field);
652 oop mirror = java_lang_reflect_Field::clazz(reflected);
653 Klass* k = java_lang_Class::as_Klass(mirror);
654 int slot = java_lang_reflect_Field::slot(reflected);
655 int modifiers = java_lang_reflect_Field::modifiers(reflected);
656
657 if (must_be_static >= 0) {
658 int really_is_static = ((modifiers & JVM_ACC_STATIC) != 0);
659 if (must_be_static != really_is_static) {
660 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
661 }
662 }
663
664 int offset = InstanceKlass::cast(k)->field_offset(slot);
665 return field_offset_from_byte_offset(offset);
666 }
667
668 UNSAFE_ENTRY(jlong, Unsafe_ObjectFieldOffset0(JNIEnv *env, jobject unsafe, jobject field)) {
669 return find_field_offset(field, 0, THREAD);
670 } UNSAFE_END
671
672 UNSAFE_ENTRY(jlong, Unsafe_ObjectFieldOffset1(JNIEnv *env, jobject unsafe, jclass c, jstring name)) {
673 return find_field_offset(c, name, THREAD);
674 } UNSAFE_END
675
676 UNSAFE_ENTRY(jlong, Unsafe_StaticFieldOffset0(JNIEnv *env, jobject unsafe, jobject field)) {
677 return find_field_offset(field, 1, THREAD);
678 } UNSAFE_END
679
680 UNSAFE_ENTRY(jobject, Unsafe_StaticFieldBase0(JNIEnv *env, jobject unsafe, jobject field)) {
681 assert(field != nullptr, "field must not be null");
682
683 // Note: In this VM implementation, a field address is always a short
684 // offset from the base of a klass metaobject. Thus, the full dynamic
685 // range of the return type is never used. However, some implementations
686 // might put the static field inside an array shared by many classes,
687 // or even at a fixed address, in which case the address could be quite
688 // large. In that last case, this function would return null, since
689 // the address would operate alone, without any base pointer.
690
691 oop reflected = JNIHandles::resolve_non_null(field);
692 oop mirror = java_lang_reflect_Field::clazz(reflected);
693 int modifiers = java_lang_reflect_Field::modifiers(reflected);
694
695 if ((modifiers & JVM_ACC_STATIC) == 0) {
696 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
697 }
698
699 return JNIHandles::make_local(THREAD, mirror);
700 } UNSAFE_END
701
702 UNSAFE_ENTRY(void, Unsafe_EnsureClassInitialized0(JNIEnv *env, jobject unsafe, jobject clazz)) {
703 assert(clazz != nullptr, "clazz must not be null");
704
705 oop mirror = JNIHandles::resolve_non_null(clazz);
706
707 Klass* klass = java_lang_Class::as_Klass(mirror);
708 if (klass != nullptr && klass->should_be_initialized()) {
709 InstanceKlass* k = InstanceKlass::cast(klass);
710 k->initialize(CHECK);
711 }
712 }
713 UNSAFE_END
714
715 UNSAFE_ENTRY(jboolean, Unsafe_ShouldBeInitialized0(JNIEnv *env, jobject unsafe, jobject clazz)) {
716 assert(clazz != nullptr, "clazz must not be null");
717
718 oop mirror = JNIHandles::resolve_non_null(clazz);
719 Klass* klass = java_lang_Class::as_Klass(mirror);
720
721 if (klass != nullptr && klass->should_be_initialized()) {
722 return true;
723 }
724
725 return false;
726 }
727 UNSAFE_END
728
729 static void getBaseAndScale(int& base, int& scale, jclass clazz, TRAPS) {
730 assert(clazz != nullptr, "clazz must not be null");
731
732 oop mirror = JNIHandles::resolve_non_null(clazz);
733 Klass* k = java_lang_Class::as_Klass(mirror);
734
735 if (k == nullptr || !k->is_array_klass()) {
736 THROW(vmSymbols::java_lang_InvalidClassException());
737 } else if (k->is_objArray_klass()) {
738 base = arrayOopDesc::base_offset_in_bytes(T_OBJECT);
739 scale = heapOopSize;
740 } else if (k->is_typeArray_klass()) {
741 TypeArrayKlass* tak = TypeArrayKlass::cast(k);
742 base = tak->array_header_in_bytes();
743 assert(base == arrayOopDesc::base_offset_in_bytes(tak->element_type()), "array_header_size semantics ok");
744 scale = (1 << tak->log2_element_size());
745 } else if (k->is_flatArray_klass()) {
746 FlatArrayKlass* vak = FlatArrayKlass::cast(k);
747 InlineKlass* vklass = vak->element_klass();
748 base = vak->array_header_in_bytes();
749 scale = vak->element_byte_size();
750 } else {
751 ShouldNotReachHere();
752 }
753 }
754
755 UNSAFE_ENTRY(jint, Unsafe_ArrayBaseOffset0(JNIEnv *env, jobject unsafe, jclass clazz)) {
756 int base = 0, scale = 0;
757 getBaseAndScale(base, scale, clazz, CHECK_0);
758
759 return field_offset_from_byte_offset(base);
760 } UNSAFE_END
761
762
763 UNSAFE_ENTRY(jint, Unsafe_ArrayIndexScale0(JNIEnv *env, jobject unsafe, jclass clazz)) {
764 int base = 0, scale = 0;
765 getBaseAndScale(base, scale, clazz, CHECK_0);
766
767 // This VM packs both fields and array elements down to the byte.
768 // But watch out: If this changes, so that array references for
769 // a given primitive type (say, T_BOOLEAN) use different memory units
770 // than fields, this method MUST return zero for such arrays.
771 // For example, the VM used to store sub-word sized fields in full
772 // words in the object layout, so that accessors like getByte(Object,int)
773 // did not really do what one might expect for arrays. Therefore,
774 // this function used to report a zero scale factor, so that the user
775 // would know not to attempt to access sub-word array elements.
776 // // Code for unpacked fields:
777 // if (scale < wordSize) return 0;
778
779 // The following allows for a pretty general fieldOffset cookie scheme,
780 // but requires it to be linear in byte offset.
781 return field_offset_from_byte_offset(scale) - field_offset_from_byte_offset(0);
782 } UNSAFE_END
783
784
785 UNSAFE_ENTRY(jlong, Unsafe_GetObjectSize0(JNIEnv* env, jobject o, jobject obj))
786 oop p = JNIHandles::resolve(obj);
787 return p->size() * HeapWordSize;
788 UNSAFE_END
789
790
791 static inline void throw_new(JNIEnv *env, const char *ename) {
792 jclass cls = env->FindClass(ename);
793 if (env->ExceptionCheck()) {
794 env->ExceptionClear();
795 tty->print_cr("Unsafe: cannot throw %s because FindClass has failed", ename);
796 return;
797 }
798
799 env->ThrowNew(cls, nullptr);
800 }
801
802 static jclass Unsafe_DefineClass_impl(JNIEnv *env, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd) {
803 // Code lifted from JDK 1.3 ClassLoader.c
804
805 jbyte *body;
806 char *utfName = nullptr;
807 jclass result = 0;
808 char buf[128];
809
810 assert(data != nullptr, "Class bytes must not be null");
811 assert(length >= 0, "length must not be negative: %d", length);
812
813 if (UsePerfData) {
814 ClassLoader::unsafe_defineClassCallCounter()->inc();
815 }
816
817 body = NEW_C_HEAP_ARRAY_RETURN_NULL(jbyte, length, mtInternal);
818 if (body == nullptr) {
819 throw_new(env, "java/lang/OutOfMemoryError");
820 return 0;
821 }
822
823 env->GetByteArrayRegion(data, offset, length, body);
824 if (env->ExceptionOccurred()) {
825 goto free_body;
826 }
827
828 if (name != nullptr) {
829 uint len = env->GetStringUTFLength(name);
830 int unicode_len = env->GetStringLength(name);
831
832 if (len >= sizeof(buf)) {
833 utfName = NEW_C_HEAP_ARRAY_RETURN_NULL(char, len + 1, mtInternal);
834 if (utfName == nullptr) {
835 throw_new(env, "java/lang/OutOfMemoryError");
836 goto free_body;
837 }
838 } else {
839 utfName = buf;
840 }
841
842 env->GetStringUTFRegion(name, 0, unicode_len, utfName);
843
844 for (uint i = 0; i < len; i++) {
845 if (utfName[i] == '.') utfName[i] = '/';
846 }
847 }
848
849 result = JVM_DefineClass(env, utfName, loader, body, length, pd);
850
851 if (utfName && utfName != buf) {
852 FREE_C_HEAP_ARRAY(char, utfName);
853 }
854
855 free_body:
856 FREE_C_HEAP_ARRAY(jbyte, body);
857 return result;
858 }
859
860
861 UNSAFE_ENTRY(jclass, Unsafe_DefineClass0(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd)) {
862 ThreadToNativeFromVM ttnfv(thread);
863
864 return Unsafe_DefineClass_impl(env, name, data, offset, length, loader, pd);
865 } UNSAFE_END
866
867
868 UNSAFE_ENTRY(void, Unsafe_ThrowException(JNIEnv *env, jobject unsafe, jthrowable thr)) {
869 ThreadToNativeFromVM ttnfv(thread);
870 env->Throw(thr);
871 } UNSAFE_END
872
873 // JSR166 ------------------------------------------------------------------
874
875 UNSAFE_ENTRY(jobject, Unsafe_CompareAndExchangeReference(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h)) {
876 oop x = JNIHandles::resolve(x_h);
877 oop e = JNIHandles::resolve(e_h);
878 oop p = JNIHandles::resolve(obj);
879 assert_field_offset_sane(p, offset);
880 oop res = HeapAccess<ON_UNKNOWN_OOP_REF>::oop_atomic_cmpxchg_at(p, (ptrdiff_t)offset, e, x);
881 return JNIHandles::make_local(THREAD, res);
882 } UNSAFE_END
883
884 UNSAFE_ENTRY_SCOPED(jint, Unsafe_CompareAndExchangeInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x)) {
885 oop p = JNIHandles::resolve(obj);
886 volatile jint* addr = (volatile jint*)index_oop_from_field_offset_long(p, offset);
887 return Atomic::cmpxchg(addr, e, x);
888 } UNSAFE_END
889
890 UNSAFE_ENTRY_SCOPED(jlong, Unsafe_CompareAndExchangeLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x)) {
891 oop p = JNIHandles::resolve(obj);
892 volatile jlong* addr = (volatile jlong*)index_oop_from_field_offset_long(p, offset);
893 return Atomic::cmpxchg(addr, e, x);
894 } UNSAFE_END
895
896 UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSetReference(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h)) {
897 oop x = JNIHandles::resolve(x_h);
898 oop e = JNIHandles::resolve(e_h);
899 oop p = JNIHandles::resolve(obj);
900 assert_field_offset_sane(p, offset);
901 oop ret = HeapAccess<ON_UNKNOWN_OOP_REF>::oop_atomic_cmpxchg_at(p, (ptrdiff_t)offset, e, x);
902 return ret == e;
903 } UNSAFE_END
904
905 UNSAFE_ENTRY_SCOPED(jboolean, Unsafe_CompareAndSetInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x)) {
906 oop p = JNIHandles::resolve(obj);
907 volatile jint* addr = (volatile jint*)index_oop_from_field_offset_long(p, offset);
908 return Atomic::cmpxchg(addr, e, x) == e;
909 } UNSAFE_END
910
911 UNSAFE_ENTRY_SCOPED(jboolean, Unsafe_CompareAndSetLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x)) {
912 oop p = JNIHandles::resolve(obj);
913 volatile jlong* addr = (volatile jlong*)index_oop_from_field_offset_long(p, offset);
914 return Atomic::cmpxchg(addr, e, x) == e;
915 } UNSAFE_END
916
917 static void post_thread_park_event(EventThreadPark* event, const oop obj, jlong timeout_nanos, jlong until_epoch_millis) {
918 assert(event != nullptr, "invariant");
919 event->set_parkedClass((obj != nullptr) ? obj->klass() : nullptr);
920 event->set_timeout(timeout_nanos);
921 event->set_until(until_epoch_millis);
922 event->set_address((obj != nullptr) ? (u8)cast_from_oop<uintptr_t>(obj) : 0);
923 event->commit();
924 }
925
926 UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time)) {
927 HOTSPOT_THREAD_PARK_BEGIN((uintptr_t) thread->parker(), (int) isAbsolute, time);
928 EventThreadPark event;
929
930 JavaThreadParkedState jtps(thread, time != 0);
931 thread->parker()->park(isAbsolute != 0, time);
932 if (event.should_commit()) {
933 const oop obj = thread->current_park_blocker();
934 if (time == 0) {
935 post_thread_park_event(&event, obj, min_jlong, min_jlong);
936 } else {
937 if (isAbsolute != 0) {
938 post_thread_park_event(&event, obj, min_jlong, time);
939 } else {
940 post_thread_park_event(&event, obj, time, min_jlong);
941 }
942 }
943 }
944 HOTSPOT_THREAD_PARK_END((uintptr_t) thread->parker());
945 } UNSAFE_END
946
947 UNSAFE_ENTRY(void, Unsafe_Unpark(JNIEnv *env, jobject unsafe, jobject jthread)) {
948 if (jthread != nullptr) {
949 oop thread_oop = JNIHandles::resolve_non_null(jthread);
950 // Get the JavaThread* stored in the java.lang.Thread object _before_
951 // the embedded ThreadsListHandle is constructed so we know if the
952 // early life stage of the JavaThread* is protected. We use acquire
953 // here to ensure that if we see a non-nullptr value, then we also
954 // see the main ThreadsList updates from the JavaThread* being added.
955 FastThreadsListHandle ftlh(thread_oop, java_lang_Thread::thread_acquire(thread_oop));
956 JavaThread* thr = ftlh.protected_java_thread();
957 if (thr != nullptr) {
958 // The still live JavaThread* is protected by the FastThreadsListHandle
959 // so it is safe to access.
960 Parker* p = thr->parker();
961 HOTSPOT_THREAD_UNPARK((uintptr_t) p);
962 p->unpark();
963 }
964 } // FastThreadsListHandle is destroyed here.
965 } UNSAFE_END
966
967 UNSAFE_ENTRY(jint, Unsafe_GetLoadAverage0(JNIEnv *env, jobject unsafe, jdoubleArray loadavg, jint nelem)) {
968 const int max_nelem = 3;
969 double la[max_nelem];
970 jint ret;
971
972 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(loadavg));
973 assert(a->is_typeArray(), "must be type array");
974
975 ret = os::loadavg(la, nelem);
976 if (ret == -1) {
977 return -1;
978 }
979
980 // if successful, ret is the number of samples actually retrieved.
981 assert(ret >= 0 && ret <= max_nelem, "Unexpected loadavg return value");
982 switch(ret) {
983 case 3: a->double_at_put(2, (jdouble)la[2]); // fall through
984 case 2: a->double_at_put(1, (jdouble)la[1]); // fall through
985 case 1: a->double_at_put(0, (jdouble)la[0]); break;
986 }
987
988 return ret;
989 } UNSAFE_END
990
991
992 /// JVM_RegisterUnsafeMethods
993
994 #define ADR "J"
995
996 #define LANG "Ljava/lang/"
997
998 #define OBJ LANG "Object;"
999 #define CLS LANG "Class;"
1000 #define FLD LANG "reflect/Field;"
1001 #define THR LANG "Throwable;"
1002
1003 #define DC_Args LANG "String;[BII" LANG "ClassLoader;" "Ljava/security/ProtectionDomain;"
1004 #define DAC_Args CLS "[B[" OBJ
1005
1006 #define CC (char*) /*cast a literal from (const char*)*/
1007 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
1008
1009 #define DECLARE_GETPUTOOP(Type, Desc) \
1010 {CC "get" #Type, CC "(" OBJ "J)" #Desc, FN_PTR(Unsafe_Get##Type)}, \
1011 {CC "put" #Type, CC "(" OBJ "J" #Desc ")V", FN_PTR(Unsafe_Put##Type)}, \
1012 {CC "get" #Type "Volatile", CC "(" OBJ "J)" #Desc, FN_PTR(Unsafe_Get##Type##Volatile)}, \
1013 {CC "put" #Type "Volatile", CC "(" OBJ "J" #Desc ")V", FN_PTR(Unsafe_Put##Type##Volatile)}
1014
1015
1016 static JNINativeMethod jdk_internal_misc_Unsafe_methods[] = {
1017 {CC "getReference", CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetReference)},
1018 {CC "putReference", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_PutReference)},
1019 {CC "getReferenceVolatile", CC "(" OBJ "J)" OBJ, FN_PTR(Unsafe_GetReferenceVolatile)},
1020 {CC "putReferenceVolatile", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_PutReferenceVolatile)},
1021
1022 {CC "isFlatArray", CC "(" CLS ")Z", FN_PTR(Unsafe_IsFlatArray)},
1023 {CC "isFlatField0", CC "(" OBJ ")Z", FN_PTR(Unsafe_IsFlatField)},
1024 {CC "hasNullMarker0" , CC "(" OBJ ")Z", FN_PTR(Unsafe_HasNullMarker)},
1025 {CC "nullMarkerOffset0", CC "(" OBJ ")I", FN_PTR(Unsafe_NullMarkerOffset)},
1026 {CC "getValue", CC "(" OBJ "J" CLS ")" OBJ, FN_PTR(Unsafe_GetValue)},
1027 {CC "putValue", CC "(" OBJ "J" CLS OBJ ")V", FN_PTR(Unsafe_PutValue)},
1028 {CC "uninitializedDefaultValue", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_UninitializedDefaultValue)},
1029 {CC "makePrivateBuffer", CC "(" OBJ ")" OBJ, FN_PTR(Unsafe_MakePrivateBuffer)},
1030 {CC "finishPrivateBuffer", CC "(" OBJ ")" OBJ, FN_PTR(Unsafe_FinishPrivateBuffer)},
1031 {CC "valueHeaderSize", CC "(" CLS ")J", FN_PTR(Unsafe_ValueHeaderSize)},
1032
1033 {CC "getUncompressedObject", CC "(" ADR ")" OBJ, FN_PTR(Unsafe_GetUncompressedObject)},
1034
1035 DECLARE_GETPUTOOP(Boolean, Z),
1036 DECLARE_GETPUTOOP(Byte, B),
1037 DECLARE_GETPUTOOP(Short, S),
1038 DECLARE_GETPUTOOP(Char, C),
1039 DECLARE_GETPUTOOP(Int, I),
1040 DECLARE_GETPUTOOP(Long, J),
1041 DECLARE_GETPUTOOP(Float, F),
1042 DECLARE_GETPUTOOP(Double, D),
1043
1044 {CC "allocateMemory0", CC "(J)" ADR, FN_PTR(Unsafe_AllocateMemory0)},
1045 {CC "reallocateMemory0", CC "(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory0)},
1046 {CC "freeMemory0", CC "(" ADR ")V", FN_PTR(Unsafe_FreeMemory0)},
1047
1048 {CC "objectFieldOffset0", CC "(" FLD ")J", FN_PTR(Unsafe_ObjectFieldOffset0)},
1049 {CC "objectFieldOffset1", CC "(" CLS LANG "String;)J", FN_PTR(Unsafe_ObjectFieldOffset1)},
1050 {CC "staticFieldOffset0", CC "(" FLD ")J", FN_PTR(Unsafe_StaticFieldOffset0)},
1051 {CC "staticFieldBase0", CC "(" FLD ")" OBJ, FN_PTR(Unsafe_StaticFieldBase0)},
1052 {CC "ensureClassInitialized0", CC "(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized0)},
1053 {CC "arrayBaseOffset0", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset0)},
1054 {CC "arrayIndexScale0", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale0)},
1055 {CC "getObjectSize0", CC "(Ljava/lang/Object;)J", FN_PTR(Unsafe_GetObjectSize0)},
1056
1057 {CC "defineClass0", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass0)},
1058 {CC "allocateInstance", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)},
1059 {CC "throwException", CC "(" THR ")V", FN_PTR(Unsafe_ThrowException)},
1060 {CC "compareAndSetReference",CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSetReference)},
1061 {CC "compareAndSetInt", CC "(" OBJ "J""I""I"")Z", FN_PTR(Unsafe_CompareAndSetInt)},
1062 {CC "compareAndSetLong", CC "(" OBJ "J""J""J"")Z", FN_PTR(Unsafe_CompareAndSetLong)},
1063 {CC "compareAndExchangeReference", CC "(" OBJ "J" OBJ "" OBJ ")" OBJ, FN_PTR(Unsafe_CompareAndExchangeReference)},
1064 {CC "compareAndExchangeInt", CC "(" OBJ "J""I""I"")I", FN_PTR(Unsafe_CompareAndExchangeInt)},
1065 {CC "compareAndExchangeLong", CC "(" OBJ "J""J""J"")J", FN_PTR(Unsafe_CompareAndExchangeLong)},
1066
1067 {CC "park", CC "(ZJ)V", FN_PTR(Unsafe_Park)},
1068 {CC "unpark", CC "(" OBJ ")V", FN_PTR(Unsafe_Unpark)},
1069
1070 {CC "getLoadAverage0", CC "([DI)I", FN_PTR(Unsafe_GetLoadAverage0)},
1071
1072 {CC "copyMemory0", CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory0)},
1073 {CC "copySwapMemory0", CC "(" OBJ "J" OBJ "JJJ)V", FN_PTR(Unsafe_CopySwapMemory0)},
1074 {CC "writeback0", CC "(" "J" ")V", FN_PTR(Unsafe_WriteBack0)},
1075 {CC "writebackPreSync0", CC "()V", FN_PTR(Unsafe_WriteBackPreSync0)},
1076 {CC "writebackPostSync0", CC "()V", FN_PTR(Unsafe_WriteBackPostSync0)},
1077 {CC "setMemory0", CC "(" OBJ "JJB)V", FN_PTR(Unsafe_SetMemory0)},
1078
1079 {CC "shouldBeInitialized0", CC "(" CLS ")Z", FN_PTR(Unsafe_ShouldBeInitialized0)},
1080
1081 {CC "fullFence", CC "()V", FN_PTR(Unsafe_FullFence)},
1082 };
1083
1084 #undef CC
1085 #undef FN_PTR
1086
1087 #undef ADR
1088 #undef LANG
1089 #undef OBJ
1090 #undef CLS
1091 #undef FLD
1092 #undef THR
1093 #undef DC_Args
1094 #undef DAC_Args
1095
1096 #undef DECLARE_GETPUTOOP
1097
1098
1099 // This function is exported, used by NativeLookup.
1100 // The Unsafe_xxx functions above are called only from the interpreter.
1101 // The optimizer looks at names and signatures to recognize
1102 // individual functions.
1103
1104 JVM_ENTRY(void, JVM_RegisterJDKInternalMiscUnsafeMethods(JNIEnv *env, jclass unsafeclass)) {
1105 ThreadToNativeFromVM ttnfv(thread);
1106
1107 int ok = env->RegisterNatives(unsafeclass, jdk_internal_misc_Unsafe_methods, sizeof(jdk_internal_misc_Unsafe_methods)/sizeof(JNINativeMethod));
1108 guarantee(ok == 0, "register jdk.internal.misc.Unsafe natives");
1109 } JVM_END