jdk-sandbox: comparison src/hotspot/share/prims/unsafe.cpp

equal deleted inserted replaced

-:55c43e677ded
+:fb0275c320a0
 #include "jvm.h"
 #include "classfile/classFileStream.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "memory/allocation.inline.hpp"
 #include "memory/resourceArea.hpp"
+#include "oops/access.inline.hpp"
 #include "oops/fieldStreams.hpp"
 #include "oops/objArrayOop.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "prims/unsafe.hpp"
 #include "runtime/atomic.hpp"
 #include "trace/tracing.hpp"
 #include "utilities/align.hpp"
 #include "utilities/copy.hpp"
 #include "utilities/dtrace.hpp"
 #include "utilities/macros.hpp"
-#if INCLUDE_ALL_GCS
-#include "gc/g1/g1SATBCardTableModRefBS.hpp"
-#endif // INCLUDE_ALL_GCS
 /**
 * Implementation of the jdk.internal.misc.Unsafe class
 */
 static inline jlong field_offset_from_byte_offset(jlong byte_offset) {
 return byte_offset;
 }
-static inline void* index_oop_from_field_offset_long(oop p, jlong field_offset) {
+static inline void assert_field_offset_sane(oop p, jlong field_offset) {
+#ifdef ASSERT
 jlong byte_offset = field_offset_to_byte_offset(field_offset);
-#ifdef ASSERT
 if (p != NULL) {
 assert(byte_offset >= 0 && byte_offset <= (jlong)MAX_OBJECT_SIZE, "sane offset");
 if (byte_offset == (jint)byte_offset) {
 void* ptr_plus_disp = (address)p + byte_offset;
 assert((void*)p->obj_field_addr<oop>((jint)byte_offset) == ptr_plus_disp,
 }
 jlong p_size = HeapWordSize * (jlong)(p->size());
 assert(byte_offset < p_size, "Unsafe access: offset " INT64_FORMAT " > object's size " INT64_FORMAT, (int64_t)byte_offset, (int64_t)p_size);
 }
 #endif
+}
+static inline void* index_oop_from_field_offset_long(oop p, jlong field_offset) {
+assert_field_offset_sane(p, field_offset);
+jlong byte_offset = field_offset_to_byte_offset(field_offset);
 if (sizeof(char*) == sizeof(jint)) {   // (this constant folds!)
 return (address)p + (jint) byte_offset;
 } else {
 return (address)p +        byte_offset;
 * Normalizes values and wraps accesses in
 * JavaThread::doing_unsafe_access() if needed.
 */
 class MemoryAccess : StackObj {
 JavaThread* _thread;
-jobject _obj;
+oop _obj;
-jlong _offset;
+ptrdiff_t _offset;
 // Resolves and returns the address of the memory access
 void* addr() {
-return index_oop_from_field_offset_long(JNIHandles::resolve(_obj), _offset);
+return index_oop_from_field_offset_long(_obj, _offset);
 }
 template <typename T>
 T normalize_for_write(T x) {
 return x;
 /**
 * Helper class to wrap memory accesses in JavaThread::doing_unsafe_access()
 */
 class GuardUnsafeAccess {
 JavaThread* _thread;
-bool _active;
 public:
-GuardUnsafeAccess(JavaThread* thread, jobject _obj) : _thread(thread) {
+GuardUnsafeAccess(JavaThread* thread) : _thread(thread) {
-if (JNIHandles::resolve(_obj) == NULL) {
+// native/off-heap access which may raise SIGBUS if accessing
-// native/off-heap access which may raise SIGBUS if accessing
+// memory mapped file data in a region of the file which has
-// memory mapped file data in a region of the file which has
+// been truncated and is now invalid
-// been truncated and is now invalid
+_thread->set_doing_unsafe_access(true);
-_thread->set_doing_unsafe_access(true);
-_active = true;
-} else {
-_active = false;
-}
 }
 ~GuardUnsafeAccess() {
-if (_active) {
+_thread->set_doing_unsafe_access(false);
-_thread->set_doing_unsafe_access(false);
-}
 }
 };
 public:
 MemoryAccess(JavaThread* thread, jobject obj, jlong offset)
-: _thread(thread), _obj(obj), _offset(offset) {
+: _thread(thread), _obj(JNIHandles::resolve(obj)), _offset((ptrdiff_t)offset) {
+assert_field_offset_sane(_obj, offset);
 }
 template <typename T>
 T get() {
-GuardUnsafeAccess guard(_thread, _obj);
+if (oopDesc::is_null(_obj)) {
+GuardUnsafeAccess guard(_thread);
-T* p = (T*)addr();
+T ret = RawAccess<>::load((T*)addr());
+return normalize_for_read(ret);
-T x = normalize_for_read(*p);
+} else {
+T ret = HeapAccess<>::load_at(_obj, _offset);
-return x;
+return normalize_for_read(ret);
+}
 }
 template <typename T>
 void put(T x) {
-GuardUnsafeAccess guard(_thread, _obj);
+if (oopDesc::is_null(_obj)) {
+GuardUnsafeAccess guard(_thread);
-T* p = (T*)addr();
+RawAccess<>::store((T*)addr(), normalize_for_write(x));
+} else {
-*p = normalize_for_write(x);
+HeapAccess<>::store_at(_obj, _offset, normalize_for_write(x));
+}
 }
 template <typename T>
 T get_volatile() {
-GuardUnsafeAccess guard(_thread, _obj);
+if (oopDesc::is_null(_obj)) {
+GuardUnsafeAccess guard(_thread);
-T* p = (T*)addr();
+volatile T ret = RawAccess<MO_SEQ_CST>::load((volatile T*)addr());
+return normalize_for_read(ret);
-if (support_IRIW_for_not_multiple_copy_atomic_cpu) {
+} else {
-OrderAccess::fence();
+T ret = HeapAccess<MO_SEQ_CST>::load_at(_obj, _offset);
-}
+return normalize_for_read(ret);
+}
-T x = OrderAccess::load_acquire((volatile T*)p);
-return normalize_for_read(x);
 }
 template <typename T>
 void put_volatile(T x) {
-GuardUnsafeAccess guard(_thread, _obj);
+if (oopDesc::is_null(_obj)) {
+GuardUnsafeAccess guard(_thread);
-T* p = (T*)addr();
+RawAccess<MO_SEQ_CST>::store((volatile T*)addr(), normalize_for_write(x));
+} else {
-OrderAccess::release_store_fence((volatile T*)p, normalize_for_write(x));
+HeapAccess<MO_SEQ_CST>::store_at(_obj, _offset, normalize_for_write(x));
 }
+}
-#ifndef SUPPORTS_NATIVE_CX8
-jlong get_jlong_locked() {
-GuardUnsafeAccess guard(_thread, _obj);
-MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
-jlong* p = (jlong*)addr();
-jlong x = Atomic::load(p);
-return x;
-}
-void put_jlong_locked(jlong x) {
-GuardUnsafeAccess guard(_thread, _obj);
-MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
-jlong* p = (jlong*)addr();
-Atomic::store(normalize_for_write(x),  p);
-}
-#endif
 };
-// Get/PutObject must be special-cased, since it works with handles.
-// We could be accessing the referent field in a reference
-// object. If G1 is enabled then we need to register non-null
-// referent with the SATB barrier.
-#if INCLUDE_ALL_GCS
-static bool is_java_lang_ref_Reference_access(oop o, jlong offset) {
-if (offset == java_lang_ref_Reference::referent_offset && o != NULL) {
-Klass* k = o->klass();
-if (InstanceKlass::cast(k)->reference_type() != REF_NONE) {
-assert(InstanceKlass::cast(k)->is_subclass_of(SystemDictionary::Reference_klass()), "sanity");
-return true;
-}
-}
-return false;
-}
-#endif
-static void ensure_satb_referent_alive(oop o, jlong offset, oop v) {
-#if INCLUDE_ALL_GCS
-if (UseG1GC && v != NULL && is_java_lang_ref_Reference_access(o, offset)) {
-G1SATBCardTableModRefBS::enqueue(v);
-}
-#endif
-}
 // These functions allow a null base pointer with an arbitrary address.
 // But if the base pointer is non-null, the offset should make some sense.
 // That is, it should be in the range [0, MAX_OBJECT_SIZE].
 UNSAFE_ENTRY(jobject, Unsafe_GetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) {
 oop p = JNIHandles::resolve(obj);
-oop v;
+assert_field_offset_sane(p, offset);
+oop v = HeapAccess<ON_UNKNOWN_OOP_REF>::oop_load_at(p, offset);
-if (UseCompressedOops) {
-narrowOop n = *(narrowOop*)index_oop_from_field_offset_long(p, offset);
-v = oopDesc::decode_heap_oop(n);
-} else {
-v = *(oop*)index_oop_from_field_offset_long(p, offset);
-}
-ensure_satb_referent_alive(p, offset, v);
 return JNIHandles::make_local(env, v);
 } UNSAFE_END
 UNSAFE_ENTRY(void, Unsafe_PutObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) {
 oop x = JNIHandles::resolve(x_h);
 oop p = JNIHandles::resolve(obj);
+assert_field_offset_sane(p, offset);
-if (UseCompressedOops) {
+HeapAccess<ON_UNKNOWN_OOP_REF>::oop_store_at(p, offset, x);
-oop_store((narrowOop*)index_oop_from_field_offset_long(p, offset), x);
-} else {
-oop_store((oop*)index_oop_from_field_offset_long(p, offset), x);
-}
 } UNSAFE_END
 UNSAFE_ENTRY(jobject, Unsafe_GetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) {
 oop p = JNIHandles::resolve(obj);
-void* addr = index_oop_from_field_offset_long(p, offset);
+assert_field_offset_sane(p, offset);
+oop v = HeapAccess<MO_SEQ_CST | ON_UNKNOWN_OOP_REF>::oop_load_at(p, offset);
-volatile oop v;
-if (support_IRIW_for_not_multiple_copy_atomic_cpu) {
-OrderAccess::fence();
-}
-if (UseCompressedOops) {
-volatile narrowOop n = *(volatile narrowOop*) addr;
-(void)const_cast<oop&>(v = oopDesc::decode_heap_oop(n));
-} else {
-(void)const_cast<oop&>(v = *(volatile oop*) addr);
-}
-ensure_satb_referent_alive(p, offset, v);
-OrderAccess::acquire();
 return JNIHandles::make_local(env, v);
 } UNSAFE_END
 UNSAFE_ENTRY(void, Unsafe_PutObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) {
 oop x = JNIHandles::resolve(x_h);
 oop p = JNIHandles::resolve(obj);
-void* addr = index_oop_from_field_offset_long(p, offset);
+assert_field_offset_sane(p, offset);
-OrderAccess::release();
+HeapAccess<MO_SEQ_CST | ON_UNKNOWN_OOP_REF>::oop_store_at(p, offset, x);
-if (UseCompressedOops) {
-oop_store((narrowOop*)addr, x);
-} else {
-oop_store((oop*)addr, x);
-}
-OrderAccess::fence();
 } UNSAFE_END
 UNSAFE_ENTRY(jobject, Unsafe_GetUncompressedObject(JNIEnv *env, jobject unsafe, jlong addr)) {
 oop v = *(oop*) (address) addr;
 return JNIHandles::make_local(env, v);
 } UNSAFE_END
-#ifndef SUPPORTS_NATIVE_CX8
-// VM_Version::supports_cx8() is a surrogate for 'supports atomic long memory ops'.
-//
-// On platforms which do not support atomic compare-and-swap of jlong (8 byte)
-// values we have to use a lock-based scheme to enforce atomicity. This has to be
-// applied to all Unsafe operations that set the value of a jlong field. Even so
-// the compareAndSetLong operation will not be atomic with respect to direct stores
-// to the field from Java code. It is important therefore that any Java code that
-// utilizes these Unsafe jlong operations does not perform direct stores. To permit
-// direct loads of the field from Java code we must also use Atomic::store within the
-// locked regions. And for good measure, in case there are direct stores, we also
-// employ Atomic::load within those regions. Note that the field in question must be
-// volatile and so must have atomic load/store accesses applied at the Java level.
-//
-// The locking scheme could utilize a range of strategies for controlling the locking
-// granularity: from a lock per-field through to a single global lock. The latter is
-// the simplest and is used for the current implementation. Note that the Java object
-// that contains the field, can not, in general, be used for locking. To do so can lead
-// to deadlocks as we may introduce locking into what appears to the Java code to be a
-// lock-free path.
-//
-// As all the locked-regions are very short and themselves non-blocking we can treat
-// them as leaf routines and elide safepoint checks (ie we don't perform any thread
-// state transitions even when blocking for the lock). Note that if we do choose to
-// add safepoint checks and thread state transitions, we must ensure that we calculate
-// the address of the field _after_ we have acquired the lock, else the object may have
-// been moved by the GC
-UNSAFE_ENTRY(jlong, Unsafe_GetLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) {
-if (VM_Version::supports_cx8()) {
-return MemoryAccess(thread, obj, offset).get_volatile<jlong>();
-} else {
-return MemoryAccess(thread, obj, offset).get_jlong_locked();
-}
-} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_PutLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x)) {
-if (VM_Version::supports_cx8()) {
-MemoryAccess(thread, obj, offset).put_volatile<jlong>(x);
-} else {
-MemoryAccess(thread, obj, offset).put_jlong_locked(x);
-}
-} UNSAFE_END
-#endif // not SUPPORTS_NATIVE_CX8
 UNSAFE_LEAF(jboolean, Unsafe_isBigEndian0(JNIEnv *env, jobject unsafe)) {
 #ifdef VM_LITTLE_ENDIAN
 return false;
 #else
 DEFINE_GETSETOOP_VOLATILE(jboolean, Boolean)
 DEFINE_GETSETOOP_VOLATILE(jbyte, Byte)
 DEFINE_GETSETOOP_VOLATILE(jshort, Short);
 DEFINE_GETSETOOP_VOLATILE(jchar, Char);
 DEFINE_GETSETOOP_VOLATILE(jint, Int);
+DEFINE_GETSETOOP_VOLATILE(jlong, Long);
 DEFINE_GETSETOOP_VOLATILE(jfloat, Float);
 DEFINE_GETSETOOP_VOLATILE(jdouble, Double);
-#ifdef SUPPORTS_NATIVE_CX8
-DEFINE_GETSETOOP_VOLATILE(jlong, Long);
-#endif
 #undef DEFINE_GETSETOOP_VOLATILE
 UNSAFE_LEAF(void, Unsafe_LoadFence(JNIEnv *env, jobject unsafe)) {
 OrderAccess::acquire();
 UNSAFE_ENTRY(jobject, Unsafe_CompareAndExchangeObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h)) {
 oop x = JNIHandles::resolve(x_h);
 oop e = JNIHandles::resolve(e_h);
 oop p = JNIHandles::resolve(obj);
-HeapWord* addr = (HeapWord *)index_oop_from_field_offset_long(p, offset);
+assert_field_offset_sane(p, offset);
-oop res = oopDesc::atomic_compare_exchange_oop(x, addr, e, true);
+oop res = HeapAccess<ON_UNKNOWN_OOP_REF>::oop_atomic_cmpxchg_at(x, p, (ptrdiff_t)offset, e);
-if (res == e) {
-update_barrier_set((void*)addr, x);
-}
 return JNIHandles::make_local(env, res);
 } UNSAFE_END
 UNSAFE_ENTRY(jint, Unsafe_CompareAndExchangeInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x)) {
 oop p = JNIHandles::resolve(obj);
-jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
+if (oopDesc::is_null(p)) {
+volatile jint* addr = (volatile jint*)index_oop_from_field_offset_long(p, offset);
-return (jint)(Atomic::cmpxchg(x, addr, e));
+return RawAccess<>::atomic_cmpxchg(x, addr, e);
+} else {
+assert_field_offset_sane(p, offset);
+return HeapAccess<>::atomic_cmpxchg_at(x, p, (ptrdiff_t)offset, e);
+}
 } UNSAFE_END
 UNSAFE_ENTRY(jlong, Unsafe_CompareAndExchangeLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x)) {
-Handle p(THREAD, JNIHandles::resolve(obj));
+oop p = JNIHandles::resolve(obj);
-jlong* addr = (jlong*)index_oop_from_field_offset_long(p(), offset);
+if (oopDesc::is_null(p)) {
+volatile jlong* addr = (volatile jlong*)index_oop_from_field_offset_long(p, offset);
-#ifdef SUPPORTS_NATIVE_CX8
+return RawAccess<>::atomic_cmpxchg(x, addr, e);
-return (jlong)(Atomic::cmpxchg(x, addr, e));
-#else
-if (VM_Version::supports_cx8()) {
-return (jlong)(Atomic::cmpxchg(x, addr, e));
 } else {
-MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
+assert_field_offset_sane(p, offset);
+return HeapAccess<>::atomic_cmpxchg_at(x, p, (ptrdiff_t)offset, e);
-jlong val = Atomic::load(addr);
+}
-if (val == e) {
-Atomic::store(x, addr);
-}
-return val;
-}
-#endif
 } UNSAFE_END
 UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h)) {
 oop x = JNIHandles::resolve(x_h);
 oop e = JNIHandles::resolve(e_h);
 oop p = JNIHandles::resolve(obj);
-HeapWord* addr = (HeapWord *)index_oop_from_field_offset_long(p, offset);
+assert_field_offset_sane(p, offset);
-oop res = oopDesc::atomic_compare_exchange_oop(x, addr, e, true);
+oop ret = HeapAccess<ON_UNKNOWN_OOP_REF>::oop_atomic_cmpxchg_at(x, p, (ptrdiff_t)offset, e);
-if (res != e) {
+return ret == e;
-return false;
-}
-update_barrier_set((void*)addr, x);
-return true;
 } UNSAFE_END
 UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSetInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x)) {
 oop p = JNIHandles::resolve(obj);
-jint* addr = (jint *)index_oop_from_field_offset_long(p, offset);
+if (oopDesc::is_null(p)) {
+volatile jint* addr = (volatile jint*)index_oop_from_field_offset_long(p, offset);
-return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
+return RawAccess<>::atomic_cmpxchg(x, addr, e) == e;
+} else {
+assert_field_offset_sane(p, offset);
+return HeapAccess<>::atomic_cmpxchg_at(x, p, (ptrdiff_t)offset, e) == e;
+}
 } UNSAFE_END
 UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSetLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x)) {
-Handle p(THREAD, JNIHandles::resolve(obj));
+oop p = JNIHandles::resolve(obj);
-jlong* addr = (jlong*)index_oop_from_field_offset_long(p(), offset);
+if (oopDesc::is_null(p)) {
+volatile jlong* addr = (volatile jlong*)index_oop_from_field_offset_long(p, offset);
-#ifdef SUPPORTS_NATIVE_CX8
+return RawAccess<>::atomic_cmpxchg(x, addr, e) == e;
-return (jlong)(Atomic::cmpxchg(x, addr, e)) == e;
-#else
-if (VM_Version::supports_cx8()) {
-return (jlong)(Atomic::cmpxchg(x, addr, e)) == e;
 } else {
-MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
+assert_field_offset_sane(p, offset);
+return HeapAccess<>::atomic_cmpxchg_at(x, p, (ptrdiff_t)offset, e) == e;
-jlong val = Atomic::load(addr);
+}
-if (val != e) {
-return false;
-}
-Atomic::store(x, addr);
-return true;
-}
-#endif
 } UNSAFE_END
 UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time)) {
 EventThreadPark event;
 HOTSPOT_THREAD_PARK_BEGIN((uintptr_t) thread->parker(), (int) isAbsolute, time);

changeset 47998	fb0275c320a0
parent 47765	b7c7428eaab9
child 48105	8d15b1369c7a