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

equal deleted inserted replaced

-:6d26e3a083cb
+:77f29c57ed2e
 #include "memory/allocation.inline.hpp"
 #include "oops/objArrayOop.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "prims/jni.h"
 #include "prims/jvm.h"
+#include "prims/unsafe.hpp"
 #include "runtime/atomic.inline.hpp"
 #include "runtime/globals.hpp"
 #include "runtime/interfaceSupport.hpp"
 #include "runtime/orderAccess.inline.hpp"
 #include "runtime/reflection.hpp"
 #include "utilities/macros.hpp"
 #if INCLUDE_ALL_GCS
 #include "gc/g1/g1SATBCardTableModRefBS.hpp"
 #endif // INCLUDE_ALL_GCS
-/*
+/**
-*      Implementation of class Unsafe
+* Implementation of the jdk.internal.misc.Unsafe class
 */
 #define MAX_OBJECT_SIZE \
 ( arrayOopDesc::header_size(T_DOUBLE) * HeapWordSize \
 + ((julong)max_jint * sizeof(double)) )
 #define UNSAFE_ENTRY(result_type, header) \
-JVM_ENTRY(result_type, header)
+JVM_ENTRY(static result_type, header)
-// Can't use UNSAFE_LEAF because it has the signature of a straight
+#define UNSAFE_LEAF(result_type, header) \
-// call into the runtime (just like JVM_LEAF, funny that) but it's
+JVM_LEAF(static result_type, header)
-// called like a Java Native and thus the wrapper built for it passes
-// arguments like a JNI call.  It expects those arguments to be popped
-// from the stack on Intel like all good JNI args are, and adjusts the
-// stack according.  Since the JVM_LEAF call expects no extra
-// arguments the stack isn't popped in the C code, is pushed by the
-// wrapper and we get sick.
-//#define UNSAFE_LEAF(result_type, header) \
-//  JVM_LEAF(result_type, header)
 #define UNSAFE_END JVM_END
-#define UnsafeWrapper(arg) /*nothing, for the present*/
+static inline void* addr_from_java(jlong addr) {
-inline void* addr_from_java(jlong addr) {
 // This assert fails in a variety of ways on 32-bit systems.
 // It is impossible to predict whether native code that converts
 // pointers to longs will sign-extend or zero-extend the addresses.
 //assert(addr == (uintptr_t)addr, "must not be odd high bits");
 return (void*)(uintptr_t)addr;
 }
-inline jlong addr_to_java(void* p) {
+static inline jlong addr_to_java(void* p) {
 assert(p == (void*)(uintptr_t)p, "must not be odd high bits");
 return (uintptr_t)p;
 }
 // through the Unsafe API are opaque cookies that just happen to be byte
 // offsets.  We represent this state of affairs by passing the cookies
 // through conversion functions when going between the VM and the Unsafe API.
 // The conversion functions just happen to be no-ops at present.
-inline jlong field_offset_to_byte_offset(jlong field_offset) {
+static inline jlong field_offset_to_byte_offset(jlong field_offset) {
 return field_offset;
 }
-inline jlong field_offset_from_byte_offset(jlong byte_offset) {
+static inline jlong field_offset_from_byte_offset(jlong byte_offset) {
 return byte_offset;
 }
-inline jint invocation_key_from_method_slot(jint slot) {
+static inline void* index_oop_from_field_offset_long(oop p, jlong field_offset) {
-return slot;
-}
-inline jint invocation_key_to_method_slot(jint key) {
-return key;
-}
-inline void* index_oop_from_field_offset_long(oop p, jlong field_offset) {
 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;
 }
 jlong p_size = HeapWordSize * (jlong)(p->size());
 assert(byte_offset < p_size, "Unsafe access: offset " INT64_FORMAT " > object's size " INT64_FORMAT, byte_offset, p_size);
 }
 #endif
-if (sizeof(char*) == sizeof(jint))    // (this constant folds!)
+if (sizeof(char*) == sizeof(jint)) {   // (this constant folds!)
 return (address)p + (jint) byte_offset;
-else
+} else {
 return (address)p +        byte_offset;
+}
 }
 // Externally callable versions:
 // (Use these in compiler intrinsics which emulate unsafe primitives.)
 jlong Unsafe_field_offset_to_byte_offset(jlong field_offset) {
 return field_offset;
 }
 jlong Unsafe_field_offset_from_byte_offset(jlong byte_offset) {
 return byte_offset;
-}
-jint Unsafe_invocation_key_from_method_slot(jint slot) {
-return invocation_key_from_method_slot(slot);
-}
-jint Unsafe_invocation_key_to_method_slot(jint key) {
-return invocation_key_to_method_slot(key);
 }
 ///// Data in the Java heap.
 // Get/SetObject must be special-cased, since it works with handles.
 // 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))
+UNSAFE_ENTRY(jobject, Unsafe_GetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) {
-UnsafeWrapper("Unsafe_GetObject");
 oop p = JNIHandles::resolve(obj);
 oop v;
 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);
 }
 jobject ret = JNIHandles::make_local(env, v);
 #if INCLUDE_ALL_GCS
 // 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 (UseG1GC) {
 oop referent = JNIHandles::resolve(ret);
 G1SATBCardTableModRefBS::enqueue(referent);
 }
 }
 #endif // INCLUDE_ALL_GCS
 return ret;
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_SetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h))
+UNSAFE_ENTRY(void, Unsafe_SetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) {
-UnsafeWrapper("Unsafe_SetObject");
 oop x = JNIHandles::resolve(x_h);
 oop p = JNIHandles::resolve(obj);
 if (UseCompressedOops) {
 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_END
-UNSAFE_ENTRY(jobject, Unsafe_GetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset))
+UNSAFE_ENTRY(jobject, Unsafe_GetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) {
-UnsafeWrapper("Unsafe_GetObjectVolatile");
 oop p = JNIHandles::resolve(obj);
 void* addr = index_oop_from_field_offset_long(p, offset);
 volatile oop v;
 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);
 }
 OrderAccess::acquire();
 return JNIHandles::make_local(env, v);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_SetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h))
+UNSAFE_ENTRY(void, Unsafe_SetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) {
-UnsafeWrapper("Unsafe_SetObjectVolatile");
 oop x = JNIHandles::resolve(x_h);
 oop p = JNIHandles::resolve(obj);
 void* addr = index_oop_from_field_offset_long(p, offset);
 OrderAccess::release();
 if (UseCompressedOops) {
 oop_store((narrowOop*)addr, x);
 } else {
 oop_store((oop*)addr, x);
 }
 OrderAccess::fence();
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jobject, Unsafe_GetUncompressedObject(JNIEnv *env, jobject unsafe, jlong addr))
+UNSAFE_ENTRY(jobject, Unsafe_GetUncompressedObject(JNIEnv *env, jobject unsafe, jlong addr)) {
-UnsafeWrapper("Unsafe_GetUncompressedObject");
 oop v = *(oop*) (address) addr;
 return JNIHandles::make_local(env, v);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jclass, Unsafe_GetJavaMirror(JNIEnv *env, jobject unsafe, jlong metaspace_klass))
+UNSAFE_ENTRY(jclass, Unsafe_GetJavaMirror(JNIEnv *env, jobject unsafe, jlong metaspace_klass)) {
-UnsafeWrapper("Unsafe_GetJavaMirror");
 Klass* klass = (Klass*) (address) metaspace_klass;
 return (jclass) JNIHandles::make_local(klass->java_mirror());
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jlong, Unsafe_GetKlassPointer(JNIEnv *env, jobject unsafe, jobject obj))
+UNSAFE_ENTRY(jlong, Unsafe_GetKlassPointer(JNIEnv *env, jobject unsafe, jobject obj)) {
-UnsafeWrapper("Unsafe_GetKlassPointer");
 oop o = JNIHandles::resolve(obj);
 jlong klass = (jlong) (address) o->klass();
 return klass;
-UNSAFE_END
+} UNSAFE_END
 #ifndef SUPPORTS_NATIVE_CX8
 // VM_Version::supports_cx8() is a surrogate for 'supports atomic long memory ops'.
 //
 // 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))
+UNSAFE_ENTRY(jlong, Unsafe_GetLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) {
-UnsafeWrapper("Unsafe_GetLongVolatile");
+if (VM_Version::supports_cx8()) {
-{
+GET_FIELD_VOLATILE(obj, offset, jlong, v);
-if (VM_Version::supports_cx8()) {
+return v;
-GET_FIELD_VOLATILE(obj, offset, jlong, v);
+} else {
-return v;
+Handle p (THREAD, JNIHandles::resolve(obj));
-}
+jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
-else {
+MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
-Handle p (THREAD, JNIHandles::resolve(obj));
+jlong value = Atomic::load(addr);
-jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
+return value;
-MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
+}
-jlong value = Atomic::load(addr);
+} UNSAFE_END
-return value;
-}
+UNSAFE_ENTRY(void, Unsafe_SetLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x)) {
-}
+if (VM_Version::supports_cx8()) {
-UNSAFE_END
+SET_FIELD_VOLATILE(obj, offset, jlong, x);
+} else {
-UNSAFE_ENTRY(void, Unsafe_SetLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x))
+Handle p (THREAD, JNIHandles::resolve(obj));
-UnsafeWrapper("Unsafe_SetLongVolatile");
+jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
-{
+MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
-if (VM_Version::supports_cx8()) {
+Atomic::store(x, addr);
-SET_FIELD_VOLATILE(obj, offset, jlong, x);
+}
-}
+} UNSAFE_END
-else {
-Handle p (THREAD, JNIHandles::resolve(obj));
-jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
-MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
-Atomic::store(x, addr);
-}
-}
-UNSAFE_END
 #endif // not SUPPORTS_NATIVE_CX8
-UNSAFE_ENTRY(jboolean, Unsafe_isBigEndian0(JNIEnv *env, jobject unsafe))
+UNSAFE_LEAF(jboolean, Unsafe_isBigEndian0(JNIEnv *env, jobject unsafe)) {
-UnsafeWrapper("Unsafe_IsBigEndian0");
-{
 #ifdef VM_LITTLE_ENDIAN
 return false;
 #else
 return true;
 #endif
-}
+} UNSAFE_END
-UNSAFE_END
+UNSAFE_LEAF(jint, Unsafe_unalignedAccess0(JNIEnv *env, jobject unsafe)) {
-UNSAFE_ENTRY(jint, Unsafe_unalignedAccess0(JNIEnv *env, jobject unsafe))
+return UseUnalignedAccesses;
-UnsafeWrapper("Unsafe_UnalignedAccess0");
+} UNSAFE_END
-{
-return UseUnalignedAccesses;
+#define DEFINE_GETSETOOP(java_type, Type)        \
-}
-UNSAFE_END
-#define DEFINE_GETSETOOP(jboolean, Boolean) \
 \
-UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean##140(JNIEnv *env, jobject unsafe, jobject obj, jint offset)) \
+UNSAFE_ENTRY(java_type, Unsafe_Get##Type(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) { \
-UnsafeWrapper("Unsafe_Get"#Boolean); \
+GET_FIELD(obj, offset, java_type, v); \
-if (obj == NULL)  THROW_0(vmSymbols::java_lang_NullPointerException()); \
-GET_FIELD(obj, offset, jboolean, v); \
 return v; \
-UNSAFE_END \
+} UNSAFE_END \
 \
-UNSAFE_ENTRY(void, Unsafe_Set##Boolean##140(JNIEnv *env, jobject unsafe, jobject obj, jint offset, jboolean x)) \
+UNSAFE_ENTRY(void, Unsafe_Set##Type(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, java_type x)) { \
-UnsafeWrapper("Unsafe_Set"#Boolean); \
+SET_FIELD(obj, offset, java_type, x); \
-if (obj == NULL)  THROW(vmSymbols::java_lang_NullPointerException()); \
+} UNSAFE_END \
-SET_FIELD(obj, offset, jboolean, x); \
-UNSAFE_END \
-\
-UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) \
-UnsafeWrapper("Unsafe_Get"#Boolean); \
-GET_FIELD(obj, offset, jboolean, v); \
-return v; \
-UNSAFE_END \
-\
-UNSAFE_ENTRY(void, Unsafe_Set##Boolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jboolean x)) \
-UnsafeWrapper("Unsafe_Set"#Boolean); \
-SET_FIELD(obj, offset, jboolean, x); \
-UNSAFE_END \
 \
 // END DEFINE_GETSETOOP.
 DEFINE_GETSETOOP(jboolean, Boolean)
 DEFINE_GETSETOOP(jbyte, Byte)
 DEFINE_GETSETOOP(jfloat, Float);
 DEFINE_GETSETOOP(jdouble, Double);
 #undef DEFINE_GETSETOOP
-#define DEFINE_GETSETOOP_VOLATILE(jboolean, Boolean) \
+#define DEFINE_GETSETOOP_VOLATILE(java_type, Type) \
 \
-UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) \
+UNSAFE_ENTRY(java_type, Unsafe_Get##Type##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) { \
-UnsafeWrapper("Unsafe_Get"#Boolean); \
+GET_FIELD_VOLATILE(obj, offset, java_type, v); \
-GET_FIELD_VOLATILE(obj, offset, jboolean, v); \
 return v; \
-UNSAFE_END \
+} UNSAFE_END \
 \
-UNSAFE_ENTRY(void, Unsafe_Set##Boolean##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jboolean x)) \
+UNSAFE_ENTRY(void, Unsafe_Set##Type##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, java_type x)) { \
-UnsafeWrapper("Unsafe_Set"#Boolean); \
+SET_FIELD_VOLATILE(obj, offset, java_type, x); \
-SET_FIELD_VOLATILE(obj, offset, jboolean, x); \
+} UNSAFE_END \
-UNSAFE_END \
 \
 // END DEFINE_GETSETOOP_VOLATILE.
 DEFINE_GETSETOOP_VOLATILE(jboolean, Boolean)
 DEFINE_GETSETOOP_VOLATILE(jbyte, Byte)
 #undef DEFINE_GETSETOOP_VOLATILE
 // The non-intrinsified versions of setOrdered just use setVolatile
-UNSAFE_ENTRY(void, Unsafe_SetOrderedInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint x))
+UNSAFE_ENTRY(void, Unsafe_SetOrderedInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint x)) {
-UnsafeWrapper("Unsafe_SetOrderedInt");
 SET_FIELD_VOLATILE(obj, offset, jint, x);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_SetOrderedObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h))
+UNSAFE_ENTRY(void, Unsafe_SetOrderedObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) {
-UnsafeWrapper("Unsafe_SetOrderedObject");
 oop x = JNIHandles::resolve(x_h);
 oop p = JNIHandles::resolve(obj);
 void* addr = index_oop_from_field_offset_long(p, offset);
 OrderAccess::release();
 if (UseCompressedOops) {
 oop_store((narrowOop*)addr, x);
 } else {
 oop_store((oop*)addr, x);
 }
 OrderAccess::fence();
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_SetOrderedLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x))
+UNSAFE_ENTRY(void, Unsafe_SetOrderedLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x)) {
-UnsafeWrapper("Unsafe_SetOrderedLong");
 #ifdef SUPPORTS_NATIVE_CX8
 SET_FIELD_VOLATILE(obj, offset, jlong, x);
 #else
 // Keep old code for platforms which may not have atomic long (8 bytes) instructions
-{
+if (VM_Version::supports_cx8()) {
-if (VM_Version::supports_cx8()) {
+SET_FIELD_VOLATILE(obj, offset, jlong, x);
-SET_FIELD_VOLATILE(obj, offset, jlong, x);
+} else {
-}
+Handle p(THREAD, JNIHandles::resolve(obj));
-else {
+jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
-Handle p (THREAD, JNIHandles::resolve(obj));
+MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
-jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
+Atomic::store(x, addr);
-MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
-Atomic::store(x, addr);
-}
 }
 #endif
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_LoadFence(JNIEnv *env, jobject unsafe))
+UNSAFE_LEAF(void, Unsafe_LoadFence(JNIEnv *env, jobject unsafe)) {
-UnsafeWrapper("Unsafe_LoadFence");
 OrderAccess::acquire();
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_StoreFence(JNIEnv *env, jobject unsafe))
+UNSAFE_LEAF(void, Unsafe_StoreFence(JNIEnv *env, jobject unsafe)) {
-UnsafeWrapper("Unsafe_StoreFence");
 OrderAccess::release();
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_FullFence(JNIEnv *env, jobject unsafe))
+UNSAFE_LEAF(void, Unsafe_FullFence(JNIEnv *env, jobject unsafe)) {
-UnsafeWrapper("Unsafe_FullFence");
 OrderAccess::fence();
-UNSAFE_END
+} UNSAFE_END
 ////// Data in the C heap.
 // Note:  These do not throw NullPointerException for bad pointers.
 // They just crash.  Only a oop base pointer can generate a NullPointerException.
 //
 #define DEFINE_GETSETNATIVE(java_type, Type, native_type) \
 \
-UNSAFE_ENTRY(java_type, Unsafe_GetNative##Type(JNIEnv *env, jobject unsafe, jlong addr)) \
+UNSAFE_ENTRY(java_type, Unsafe_GetNative##Type(JNIEnv *env, jobject unsafe, jlong addr)) { \
-UnsafeWrapper("Unsafe_GetNative"#Type); \
 void* p = addr_from_java(addr); \
 JavaThread* t = JavaThread::current(); \
 t->set_doing_unsafe_access(true); \
 java_type x = *(volatile native_type*)p; \
 t->set_doing_unsafe_access(false); \
 return x; \
-UNSAFE_END \
+} UNSAFE_END \
 \
-UNSAFE_ENTRY(void, Unsafe_SetNative##Type(JNIEnv *env, jobject unsafe, jlong addr, java_type x)) \
+UNSAFE_ENTRY(void, Unsafe_SetNative##Type(JNIEnv *env, jobject unsafe, jlong addr, java_type x)) { \
-UnsafeWrapper("Unsafe_SetNative"#Type); \
 JavaThread* t = JavaThread::current(); \
 t->set_doing_unsafe_access(true); \
 void* p = addr_from_java(addr); \
 *(volatile native_type*)p = x; \
 t->set_doing_unsafe_access(false); \
-UNSAFE_END \
+} UNSAFE_END \
 \
 // END DEFINE_GETSETNATIVE.
 DEFINE_GETSETNATIVE(jbyte, Byte, signed char)
 DEFINE_GETSETNATIVE(jshort, Short, signed short);
 DEFINE_GETSETNATIVE(jfloat, Float, float);
 DEFINE_GETSETNATIVE(jdouble, Double, double);
 #undef DEFINE_GETSETNATIVE
-UNSAFE_ENTRY(jlong, Unsafe_GetNativeLong(JNIEnv *env, jobject unsafe, jlong addr))
+UNSAFE_ENTRY(jlong, Unsafe_GetNativeLong(JNIEnv *env, jobject unsafe, jlong addr)) {
-UnsafeWrapper("Unsafe_GetNativeLong");
 JavaThread* t = JavaThread::current();
 // We do it this way to avoid problems with access to heap using 64
 // bit loads, as jlong in heap could be not 64-bit aligned, and on
 // some CPUs (SPARC) it leads to SIGBUS.
 t->set_doing_unsafe_access(true);
 void* p = addr_from_java(addr);
 jlong x;
-if (((intptr_t)p & 7) == 0) {
+if (is_ptr_aligned(p, sizeof(jlong)) == 0) {
 // jlong is aligned, do a volatile access
 x = *(volatile jlong*)p;
 } else {
 jlong_accessor acc;
 acc.words[0] = ((volatile jint*)p)[0];
 acc.words[1] = ((volatile jint*)p)[1];
 x = acc.long_value;
 }
 t->set_doing_unsafe_access(false);
 return x;
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_SetNativeLong(JNIEnv *env, jobject unsafe, jlong addr, jlong x))
+UNSAFE_ENTRY(void, Unsafe_SetNativeLong(JNIEnv *env, jobject unsafe, jlong addr, jlong x)) {
-UnsafeWrapper("Unsafe_SetNativeLong");
 JavaThread* t = JavaThread::current();
 // see comment for Unsafe_GetNativeLong
 t->set_doing_unsafe_access(true);
 void* p = addr_from_java(addr);
-if (((intptr_t)p & 7) == 0) {
+if (is_ptr_aligned(p, sizeof(jlong))) {
 // jlong is aligned, do a volatile access
 *(volatile jlong*)p = x;
 } else {
 jlong_accessor acc;
 acc.long_value = x;
 ((volatile jint*)p)[0] = acc.words[0];
 ((volatile jint*)p)[1] = acc.words[1];
 }
 t->set_doing_unsafe_access(false);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jlong, Unsafe_GetNativeAddress(JNIEnv *env, jobject unsafe, jlong addr))
+UNSAFE_LEAF(jlong, Unsafe_GetNativeAddress(JNIEnv *env, jobject unsafe, jlong addr)) {
-UnsafeWrapper("Unsafe_GetNativeAddress");
 void* p = addr_from_java(addr);
 return addr_to_java(*(void**)p);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_SetNativeAddress(JNIEnv *env, jobject unsafe, jlong addr, jlong x))
+UNSAFE_LEAF(void, Unsafe_SetNativeAddress(JNIEnv *env, jobject unsafe, jlong addr, jlong x)) {
-UnsafeWrapper("Unsafe_SetNativeAddress");
 void* p = addr_from_java(addr);
 *(void**)p = addr_from_java(x);
-UNSAFE_END
+} UNSAFE_END
 ////// Allocation requests
-UNSAFE_ENTRY(jobject, Unsafe_AllocateInstance(JNIEnv *env, jobject unsafe, jclass cls))
+UNSAFE_ENTRY(jobject, Unsafe_AllocateInstance(JNIEnv *env, jobject unsafe, jclass cls)) {
-UnsafeWrapper("Unsafe_AllocateInstance");
+ThreadToNativeFromVM ttnfv(thread);
-{
+return env->AllocObject(cls);
-ThreadToNativeFromVM ttnfv(thread);
+} UNSAFE_END
-return env->AllocObject(cls);
-}
+UNSAFE_ENTRY(jlong, Unsafe_AllocateMemory0(JNIEnv *env, jobject unsafe, jlong size)) {
-UNSAFE_END
-UNSAFE_ENTRY(jlong, Unsafe_AllocateMemory(JNIEnv *env, jobject unsafe, jlong size))
-UnsafeWrapper("Unsafe_AllocateMemory");
 size_t sz = (size_t)size;
-if (sz != (julong)size || size < 0) {
-THROW_0(vmSymbols::java_lang_IllegalArgumentException());
-}
-if (sz == 0) {
-return 0;
-}
 sz = round_to(sz, HeapWordSize);
 void* x = os::malloc(sz, mtInternal);
-if (x == NULL) {
-THROW_0(vmSymbols::java_lang_OutOfMemoryError());
-}
-//Copy::fill_to_words((HeapWord*)x, sz / HeapWordSize);
 return addr_to_java(x);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jlong, Unsafe_ReallocateMemory(JNIEnv *env, jobject unsafe, jlong addr, jlong size))
+UNSAFE_ENTRY(jlong, Unsafe_ReallocateMemory0(JNIEnv *env, jobject unsafe, jlong addr, jlong size)) {
-UnsafeWrapper("Unsafe_ReallocateMemory");
 void* p = addr_from_java(addr);
 size_t sz = (size_t)size;
-if (sz != (julong)size || size < 0) {
-THROW_0(vmSymbols::java_lang_IllegalArgumentException());
-}
-if (sz == 0) {
-os::free(p);
-return 0;
-}
 sz = round_to(sz, HeapWordSize);
-void* x = (p == NULL) ? os::malloc(sz, mtInternal) : os::realloc(p, sz, mtInternal);
-if (x == NULL) {
+void* x = os::realloc(p, sz, mtInternal);
-THROW_0(vmSymbols::java_lang_OutOfMemoryError());
-}
 return addr_to_java(x);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_FreeMemory(JNIEnv *env, jobject unsafe, jlong addr))
+UNSAFE_ENTRY(void, Unsafe_FreeMemory0(JNIEnv *env, jobject unsafe, jlong addr)) {
-UnsafeWrapper("Unsafe_FreeMemory");
 void* p = addr_from_java(addr);
-if (p == NULL) {
-return;
-}
 os::free(p);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_SetMemory(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong size, jbyte value))
+UNSAFE_ENTRY(void, Unsafe_SetMemory0(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong size, jbyte value)) {
-UnsafeWrapper("Unsafe_SetMemory");
 size_t sz = (size_t)size;
-if (sz != (julong)size || size < 0) {
-THROW(vmSymbols::java_lang_IllegalArgumentException());
-}
 oop base = JNIHandles::resolve(obj);
 void* p = index_oop_from_field_offset_long(base, offset);
 Copy::fill_to_memory_atomic(p, sz, value);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_CopyMemory(JNIEnv *env, jobject unsafe, jobject srcObj, jlong srcOffset, jobject dstObj, jlong dstOffset, jlong size))
+UNSAFE_ENTRY(void, Unsafe_CopyMemory0(JNIEnv *env, jobject unsafe, jobject srcObj, jlong srcOffset, jobject dstObj, jlong dstOffset, jlong size)) {
-UnsafeWrapper("Unsafe_CopyMemory");
-if (size == 0) {
-return;
-}
 size_t sz = (size_t)size;
-if (sz != (julong)size || size < 0) {
-THROW(vmSymbols::java_lang_IllegalArgumentException());
-}
 oop srcp = JNIHandles::resolve(srcObj);
 oop dstp = JNIHandles::resolve(dstObj);
-if (dstp != NULL && !dstp->is_typeArray()) {
-// NYI:  This works only for non-oop arrays at present.
-// Generalizing it would be reasonable, but requires card marking.
-// Also, autoboxing a Long from 0L in copyMemory(x,y, 0L,z, n) would be bad.
-THROW(vmSymbols::java_lang_IllegalArgumentException());
-}
 void* src = index_oop_from_field_offset_long(srcp, srcOffset);
 void* dst = index_oop_from_field_offset_long(dstp, dstOffset);
 Copy::conjoint_memory_atomic(src, dst, sz);
-UNSAFE_END
+} UNSAFE_END
 // This function is a leaf since if the source and destination are both in native memory
 // the copy may potentially be very large, and we don't want to disable GC if we can avoid it.
 // If either source or destination (or both) are on the heap, the function will enter VM using
 // JVM_ENTRY_FROM_LEAF
-JVM_LEAF(void, Unsafe_CopySwapMemory0(JNIEnv *env, jobject unsafe, jobject srcObj, jlong srcOffset, jobject dstObj, jlong dstOffset, jlong size, jlong elemSize)) {
+UNSAFE_LEAF(void, Unsafe_CopySwapMemory0(JNIEnv *env, jobject unsafe, jobject srcObj, jlong srcOffset, jobject dstObj, jlong dstOffset, jlong size, jlong elemSize)) {
-UnsafeWrapper("Unsafe_CopySwapMemory0");
 size_t sz = (size_t)size;
 size_t esz = (size_t)elemSize;
 if (srcObj == NULL && dstObj == NULL) {
 // Both src & dst are in native memory
 address dst = (address)index_oop_from_field_offset_long(dstp, dstOffset);
 Copy::conjoint_swap(src, dst, sz, esz);
 } JVM_END
 }
-} JVM_END
+} UNSAFE_END
 ////// Random queries
-// See comment at file start about UNSAFE_LEAF
+UNSAFE_LEAF(jint, Unsafe_AddressSize0(JNIEnv *env, jobject unsafe)) {
-//UNSAFE_LEAF(jint, Unsafe_AddressSize())
-UNSAFE_ENTRY(jint, Unsafe_AddressSize(JNIEnv *env, jobject unsafe))
-UnsafeWrapper("Unsafe_AddressSize");
 return sizeof(void*);
-UNSAFE_END
+} UNSAFE_END
-// See comment at file start about UNSAFE_LEAF
+UNSAFE_LEAF(jint, Unsafe_PageSize()) {
-//UNSAFE_LEAF(jint, Unsafe_PageSize())
-UNSAFE_ENTRY(jint, Unsafe_PageSize(JNIEnv *env, jobject unsafe))
-UnsafeWrapper("Unsafe_PageSize");
 return os::vm_page_size();
-UNSAFE_END
+} UNSAFE_END
-jint find_field_offset(jobject field, int must_be_static, TRAPS) {
+static jint find_field_offset(jobject field, int must_be_static, TRAPS) {
-if (field == NULL) {
+assert(field != NULL, "field must not be NULL");
-THROW_0(vmSymbols::java_lang_NullPointerException());
-}
 oop reflected   = JNIHandles::resolve_non_null(field);
 oop mirror      = java_lang_reflect_Field::clazz(reflected);
-Klass* k      = java_lang_Class::as_Klass(mirror);
+Klass* k        = java_lang_Class::as_Klass(mirror);
 int slot        = java_lang_reflect_Field::slot(reflected);
 int modifiers   = java_lang_reflect_Field::modifiers(reflected);
 if (must_be_static >= 0) {
 int really_is_static = ((modifiers & JVM_ACC_STATIC) != 0);
 int offset = InstanceKlass::cast(k)->field_offset(slot);
 return field_offset_from_byte_offset(offset);
 }
-UNSAFE_ENTRY(jlong, Unsafe_ObjectFieldOffset(JNIEnv *env, jobject unsafe, jobject field))
+UNSAFE_ENTRY(jlong, Unsafe_ObjectFieldOffset0(JNIEnv *env, jobject unsafe, jobject field)) {
-UnsafeWrapper("Unsafe_ObjectFieldOffset");
 return find_field_offset(field, 0, THREAD);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jlong, Unsafe_StaticFieldOffset(JNIEnv *env, jobject unsafe, jobject field))
+UNSAFE_ENTRY(jlong, Unsafe_StaticFieldOffset0(JNIEnv *env, jobject unsafe, jobject field)) {
-UnsafeWrapper("Unsafe_StaticFieldOffset");
 return find_field_offset(field, 1, THREAD);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jobject, Unsafe_StaticFieldBaseFromField(JNIEnv *env, jobject unsafe, jobject field))
+UNSAFE_ENTRY(jobject, Unsafe_StaticFieldBase0(JNIEnv *env, jobject unsafe, jobject field)) {
-UnsafeWrapper("Unsafe_StaticFieldBase");
+assert(field != NULL, "field must not be NULL");
 // Note:  In this VM implementation, a field address is always a short
 // offset from the base of a a klass metaobject.  Thus, the full dynamic
 // range of the return type is never used.  However, some implementations
 // might put the static field inside an array shared by many classes,
 // or even at a fixed address, in which case the address could be quite
 // large.  In that last case, this function would return NULL, since
 // the address would operate alone, without any base pointer.
-if (field == NULL)  THROW_0(vmSymbols::java_lang_NullPointerException());
 oop reflected   = JNIHandles::resolve_non_null(field);
 oop mirror      = java_lang_reflect_Field::clazz(reflected);
 int modifiers   = java_lang_reflect_Field::modifiers(reflected);
 if ((modifiers & JVM_ACC_STATIC) == 0) {
 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
 }
 return JNIHandles::make_local(env, mirror);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_EnsureClassInitialized(JNIEnv *env, jobject unsafe, jobject clazz)) {
+UNSAFE_ENTRY(void, Unsafe_EnsureClassInitialized0(JNIEnv *env, jobject unsafe, jobject clazz)) {
-UnsafeWrapper("Unsafe_EnsureClassInitialized");
+assert(clazz != NULL, "clazz must not be NULL");
-if (clazz == NULL) {
-THROW(vmSymbols::java_lang_NullPointerException());
-}
 oop mirror = JNIHandles::resolve_non_null(clazz);
 Klass* klass = java_lang_Class::as_Klass(mirror);
 if (klass != NULL && klass->should_be_initialized()) {
 InstanceKlass* k = InstanceKlass::cast(klass);
 k->initialize(CHECK);
 }
 }
 UNSAFE_END
-UNSAFE_ENTRY(jboolean, Unsafe_ShouldBeInitialized(JNIEnv *env, jobject unsafe, jobject clazz)) {
+UNSAFE_ENTRY(jboolean, Unsafe_ShouldBeInitialized0(JNIEnv *env, jobject unsafe, jobject clazz)) {
-UnsafeWrapper("Unsafe_ShouldBeInitialized");
+assert(clazz != NULL, "clazz must not be NULL");
-if (clazz == NULL) {
-THROW_(vmSymbols::java_lang_NullPointerException(), false);
-}
 oop mirror = JNIHandles::resolve_non_null(clazz);
 Klass* klass = java_lang_Class::as_Klass(mirror);
 if (klass != NULL && klass->should_be_initialized()) {
 return true;
 }
 return false;
 }
 UNSAFE_END
-static void getBaseAndScale(int& base, int& scale, jclass acls, TRAPS) {
+static void getBaseAndScale(int& base, int& scale, jclass clazz, TRAPS) {
-if (acls == NULL) {
+assert(clazz != NULL, "clazz must not be NULL");
-THROW(vmSymbols::java_lang_NullPointerException());
-}
+oop mirror = JNIHandles::resolve_non_null(clazz);
-oop      mirror = JNIHandles::resolve_non_null(acls);
+Klass* k = java_lang_Class::as_Klass(mirror);
-Klass* k      = java_lang_Class::as_Klass(mirror);
 if (k == NULL || !k->is_array_klass()) {
 THROW(vmSymbols::java_lang_InvalidClassException());
 } else if (k->is_objArray_klass()) {
 base  = arrayOopDesc::base_offset_in_bytes(T_OBJECT);
 scale = heapOopSize;
 } else {
 ShouldNotReachHere();
 }
 }
-UNSAFE_ENTRY(jint, Unsafe_ArrayBaseOffset(JNIEnv *env, jobject unsafe, jclass acls))
+UNSAFE_ENTRY(jint, Unsafe_ArrayBaseOffset0(JNIEnv *env, jobject unsafe, jclass clazz)) {
-UnsafeWrapper("Unsafe_ArrayBaseOffset");
 int base = 0, scale = 0;
-getBaseAndScale(base, scale, acls, CHECK_0);
+getBaseAndScale(base, scale, clazz, CHECK_0);
 return field_offset_from_byte_offset(base);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jint, Unsafe_ArrayIndexScale(JNIEnv *env, jobject unsafe, jclass acls))
+UNSAFE_ENTRY(jint, Unsafe_ArrayIndexScale0(JNIEnv *env, jobject unsafe, jclass clazz)) {
-UnsafeWrapper("Unsafe_ArrayIndexScale");
 int base = 0, scale = 0;
-getBaseAndScale(base, scale, acls, CHECK_0);
+getBaseAndScale(base, scale, clazz, CHECK_0);
 // This VM packs both fields and array elements down to the byte.
 // But watch out:  If this changes, so that array references for
 // a given primitive type (say, T_BOOLEAN) use different memory units
 // than fields, this method MUST return zero for such arrays.
 // For example, the VM used to store sub-word sized fields in full
 // if (scale < wordSize)  return 0;
 // The following allows for a pretty general fieldOffset cookie scheme,
 // but requires it to be linear in byte offset.
 return field_offset_from_byte_offset(scale) - field_offset_from_byte_offset(0);
-UNSAFE_END
+} UNSAFE_END
 static inline void throw_new(JNIEnv *env, const char *ename) {
 char buf[100];
 jio_snprintf(buf, 100, "%s%s", "java/lang/", ename);
 jclass cls = env->FindClass(buf);
 if (env->ExceptionCheck()) {
 env->ExceptionClear();
 tty->print_cr("Unsafe: cannot throw %s because FindClass has failed", buf);
 return;
 }
-char* msg = NULL;
-env->ThrowNew(cls, msg);
+env->ThrowNew(cls, NULL);
 }
 static jclass Unsafe_DefineClass_impl(JNIEnv *env, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd) {
-{
+// Code lifted from JDK 1.3 ClassLoader.c
-// Code lifted from JDK 1.3 ClassLoader.c
+jbyte *body;
-jbyte *body;
+char *utfName = NULL;
-char *utfName;
+jclass result = 0;
-jclass result = 0;
+char buf[128];
-char buf[128];
+assert(data != NULL, "Class bytes must not be NULL");
-if (UsePerfData) {
+assert(length >= 0, "length must not be negative: %d", length);
-ClassLoader::unsafe_defineClassCallCounter()->inc();
+if (UsePerfData) {
+ClassLoader::unsafe_defineClassCallCounter()->inc();
+}
+body = NEW_C_HEAP_ARRAY(jbyte, length, mtInternal);
+if (body == NULL) {
+throw_new(env, "OutOfMemoryError");
+return 0;
+}
+env->GetByteArrayRegion(data, offset, length, body);
+if (env->ExceptionOccurred()) {
+goto free_body;
+}
+if (name != NULL) {
+uint len = env->GetStringUTFLength(name);
+int unicode_len = env->GetStringLength(name);
+if (len >= sizeof(buf)) {
+utfName = NEW_C_HEAP_ARRAY(char, len + 1, mtInternal);
+if (utfName == NULL) {
+throw_new(env, "OutOfMemoryError");
+goto free_body;
+}
+} else {
+utfName = buf;
 }
-if (data == NULL) {
+env->GetStringUTFRegion(name, 0, unicode_len, utfName);
-throw_new(env, "NullPointerException");
-return 0;
+for (uint i = 0; i < len; i++) {
+if (utfName[i] == '.')   utfName[i] = '/';
 }
+}
-/* Work around 4153825. malloc crashes on Solaris when passed a
-* negative size.
+result = JVM_DefineClass(env, utfName, loader, body, length, pd);
-*/
-if (length < 0) {
+if (utfName && utfName != buf) {
-throw_new(env, "ArrayIndexOutOfBoundsException");
+FREE_C_HEAP_ARRAY(char, utfName);
-return 0;
+}
-}
-body = NEW_C_HEAP_ARRAY(jbyte, length, mtInternal);
-if (body == 0) {
-throw_new(env, "OutOfMemoryError");
-return 0;
-}
-env->GetByteArrayRegion(data, offset, length, body);
-if (env->ExceptionOccurred())
-goto free_body;
-if (name != NULL) {
-uint len = env->GetStringUTFLength(name);
-int unicode_len = env->GetStringLength(name);
-if (len >= sizeof(buf)) {
-utfName = NEW_C_HEAP_ARRAY(char, len + 1, mtInternal);
-if (utfName == NULL) {
-throw_new(env, "OutOfMemoryError");
-goto free_body;
-}
-} else {
-utfName = buf;
-}
-env->GetStringUTFRegion(name, 0, unicode_len, utfName);
-//VerifyFixClassname(utfName);
-for (uint i = 0; i < len; i++) {
-if (utfName[i] == '.')   utfName[i] = '/';
-}
-} else {
-utfName = NULL;
-}
-result = JVM_DefineClass(env, utfName, loader, body, length, pd);
-if (utfName && utfName != buf)
-FREE_C_HEAP_ARRAY(char, utfName);
 free_body:
 FREE_C_HEAP_ARRAY(jbyte, body);
 return result;
 }
-}
+UNSAFE_ENTRY(jclass, Unsafe_DefineClass0(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd)) {
-UNSAFE_ENTRY(jclass, Unsafe_DefineClass(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd))
+ThreadToNativeFromVM ttnfv(thread);
-UnsafeWrapper("Unsafe_DefineClass");
-{
+return Unsafe_DefineClass_impl(env, name, data, offset, length, loader, pd);
-ThreadToNativeFromVM ttnfv(thread);
+} UNSAFE_END
-return Unsafe_DefineClass_impl(env, name, data, offset, length, loader, pd);
-}
-UNSAFE_END
 // define a class but do not make it known to the class loader or system dictionary
 // - host_class:  supplies context for linkage, access control, protection domain, and class loader
 // - data:  bytes of a class file, a raw memory address (length gives the number of bytes)
 // type Object instead of String, if the loaded constant is not in fact a String.
 static instanceKlassHandle
 Unsafe_DefineAnonymousClass_impl(JNIEnv *env,
 jclass host_class, jbyteArray data, jobjectArray cp_patches_jh,
-HeapWord* *temp_alloc,
+u1** temp_alloc,
 TRAPS) {
+assert(host_class != NULL, "host_class must not be NULL");
+assert(data != NULL, "data must not be NULL");
 if (UsePerfData) {
 ClassLoader::unsafe_defineClassCallCounter()->inc();
 }
-if (data == NULL) {
-THROW_0(vmSymbols::java_lang_NullPointerException());
-}
 jint length = typeArrayOop(JNIHandles::resolve_non_null(data))->length();
-jint word_length = (length + sizeof(HeapWord)-1) / sizeof(HeapWord);
+assert(length >= 0, "class_bytes_length must not be negative: %d", length);
-HeapWord* body = NEW_C_HEAP_ARRAY(HeapWord, word_length, mtInternal);
-if (body == NULL) {
+int class_bytes_length = (int) length;
+u1* class_bytes = NEW_C_HEAP_ARRAY(u1, length, mtInternal);
+if (class_bytes == NULL) {
 THROW_0(vmSymbols::java_lang_OutOfMemoryError());
 }
 // caller responsible to free it:
-(*temp_alloc) = body;
+*temp_alloc = class_bytes;
-{
+jbyte* array_base = typeArrayOop(JNIHandles::resolve_non_null(data))->byte_at_addr(0);
-jbyte* array_base = typeArrayOop(JNIHandles::resolve_non_null(data))->byte_at_addr(0);
+Copy::conjoint_jbytes(array_base, class_bytes, length);
-Copy::conjoint_words((HeapWord*) array_base, body, word_length);
-}
-u1* class_bytes = (u1*) body;
-int class_bytes_length = (int) length;
-if (class_bytes_length < 0)  class_bytes_length = 0;
-if (class_bytes == NULL
-|| host_class == NULL
-|| length != class_bytes_length)
-THROW_0(vmSymbols::java_lang_IllegalArgumentException());
 objArrayHandle cp_patches_h;
 if (cp_patches_jh != NULL) {
 oop p = JNIHandles::resolve_non_null(cp_patches_jh);
-if (!p->is_objArray())
+assert(p->is_objArray(), "cp_patches must be an object[]");
-THROW_0(vmSymbols::java_lang_IllegalArgumentException());
 cp_patches_h = objArrayHandle(THREAD, (objArrayOop)p);
 }
 const Klass* host_klass = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(host_class));
 assert(host_klass != NULL, "invariant");
 const char* host_source = host_klass->external_name();
 Handle      host_loader(THREAD, host_klass->class_loader());
 Handle      host_domain(THREAD, host_klass->protection_domain());
 GrowableArray<Handle>* cp_patches = NULL;
 if (cp_patches_h.not_null()) {
 int alen = cp_patches_h->length();
 for (int i = alen-1; i >= 0; i--) {
 oop p = cp_patches_h->obj_at(i);
 if (p != NULL) {
 Handle patch(THREAD, p);
-if (cp_patches == NULL)
+if (cp_patches == NULL) {
 cp_patches = new GrowableArray<Handle>(i+1, i+1, Handle());
+}
 cp_patches->at_put(i, patch);
 }
 }
 }
-ClassFileStream st(class_bytes,
+ClassFileStream st(class_bytes, class_bytes_length, host_source, ClassFileStream::verify);
-class_bytes_length,
-host_source,
+Symbol* no_class_name = NULL;
-ClassFileStream::verify);
+Klass* anonk = SystemDictionary::parse_stream(no_class_name,
+host_loader,
-instanceKlassHandle anon_klass;
+host_domain,
-{
+&st,
-Symbol* no_class_name = NULL;
+host_klass,
-Klass* anonk = SystemDictionary::parse_stream(no_class_name,
+cp_patches,
-host_loader,
+CHECK_NULL);
-host_domain,
+if (anonk == NULL) {
-&st,
+return NULL;
-host_klass,
+}
-cp_patches,
-CHECK_NULL);
+return instanceKlassHandle(THREAD, anonk);
-if (anonk == NULL)  return NULL;
+}
-anon_klass = instanceKlassHandle(THREAD, anonk);
-}
+UNSAFE_ENTRY(jclass, Unsafe_DefineAnonymousClass0(JNIEnv *env, jobject unsafe, jclass host_class, jbyteArray data, jobjectArray cp_patches_jh)) {
+ResourceMark rm(THREAD);
-return anon_klass;
-}
-UNSAFE_ENTRY(jclass, Unsafe_DefineAnonymousClass(JNIEnv *env, jobject unsafe, jclass host_class, jbyteArray data, jobjectArray cp_patches_jh))
-{
 instanceKlassHandle anon_klass;
 jobject res_jh = NULL;
+u1* temp_alloc = NULL;
-UnsafeWrapper("Unsafe_DefineAnonymousClass");
-ResourceMark rm(THREAD);
+anon_klass = Unsafe_DefineAnonymousClass_impl(env, host_class, data, cp_patches_jh, &temp_alloc, THREAD);
+if (anon_klass() != NULL) {
-HeapWord* temp_alloc = NULL;
-anon_klass = Unsafe_DefineAnonymousClass_impl(env, host_class, data,
-cp_patches_jh,
-&temp_alloc, THREAD);
-if (anon_klass() != NULL)
 res_jh = JNIHandles::make_local(env, anon_klass->java_mirror());
+}
 // try/finally clause:
 if (temp_alloc != NULL) {
-FREE_C_HEAP_ARRAY(HeapWord, temp_alloc);
+FREE_C_HEAP_ARRAY(u1, temp_alloc);
 }
 // The anonymous class loader data has been artificially been kept alive to
 // this point.   The mirror and any instances of this class have to keep
 // it alive afterwards.
 }
 // let caller initialize it as needed...
 return (jclass) res_jh;
-}
+} UNSAFE_END
-UNSAFE_END
+UNSAFE_ENTRY(void, Unsafe_ThrowException(JNIEnv *env, jobject unsafe, jthrowable thr)) {
-UNSAFE_ENTRY(void, Unsafe_ThrowException(JNIEnv *env, jobject unsafe, jthrowable thr))
+ThreadToNativeFromVM ttnfv(thread);
-UnsafeWrapper("Unsafe_ThrowException");
+env->Throw(thr);
-{
+} UNSAFE_END
-ThreadToNativeFromVM ttnfv(thread);
-env->Throw(thr);
-}
-UNSAFE_END
 // JSR166 ------------------------------------------------------------------
-UNSAFE_ENTRY(jobject, Unsafe_CompareAndExchangeObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h))
+UNSAFE_ENTRY(jobject, Unsafe_CompareAndExchangeObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h)) {
-UnsafeWrapper("Unsafe_CompareAndExchangeObject");
 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);
 oop res = oopDesc::atomic_compare_exchange_oop(x, addr, e, true);
-if (res == e)
+if (res == e) {
 update_barrier_set((void*)addr, x);
+}
 return JNIHandles::make_local(env, res);
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jint, Unsafe_CompareAndExchangeInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
+UNSAFE_ENTRY(jint, Unsafe_CompareAndExchangeInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x)) {
-UnsafeWrapper("Unsafe_CompareAndExchangeInt");
 oop p = JNIHandles::resolve(obj);
 jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
 return (jint)(Atomic::cmpxchg(x, addr, e));
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jlong, Unsafe_CompareAndExchangeLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x))
+UNSAFE_ENTRY(jlong, Unsafe_CompareAndExchangeLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x)) {
-UnsafeWrapper("Unsafe_CompareAndExchangeLong");
 Handle p (THREAD, JNIHandles::resolve(obj));
 jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
 #ifdef SUPPORTS_NATIVE_CX8
 return (jlong)(Atomic::cmpxchg(x, addr, e));
 #else
-if (VM_Version::supports_cx8())
+if (VM_Version::supports_cx8()) {
 return (jlong)(Atomic::cmpxchg(x, addr, e));
-else {
+} else {
 MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
 jlong val = Atomic::load(addr);
-if (val == e)
+if (val == e) {
 Atomic::store(x, addr);
+}
 return val;
 }
 #endif
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h))
+UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h)) {
-UnsafeWrapper("Unsafe_CompareAndSwapObject");
 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);
 oop res = oopDesc::atomic_compare_exchange_oop(x, addr, e, true);
-jboolean success  = (res == e);
+if (res != e) {
-if (success)
+return false;
-update_barrier_set((void*)addr, x);
+}
-return success;
-UNSAFE_END
+update_barrier_set((void*)addr, x);
-UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
+return true;
-UnsafeWrapper("Unsafe_CompareAndSwapInt");
+} UNSAFE_END
+UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(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);
 return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x))
+UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x)) {
-UnsafeWrapper("Unsafe_CompareAndSwapLong");
+Handle p(THREAD, JNIHandles::resolve(obj));
-Handle p (THREAD, JNIHandles::resolve(obj));
+jlong* addr = (jlong*)index_oop_from_field_offset_long(p(), offset);
-jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
 #ifdef SUPPORTS_NATIVE_CX8
 return (jlong)(Atomic::cmpxchg(x, addr, e)) == e;
 #else
-if (VM_Version::supports_cx8())
+if (VM_Version::supports_cx8()) {
 return (jlong)(Atomic::cmpxchg(x, addr, e)) == e;
-else {
+} else {
-jboolean success = false;
 MutexLockerEx mu(UnsafeJlong_lock, Mutex::_no_safepoint_check_flag);
 jlong val = Atomic::load(addr);
-if (val == e) { Atomic::store(x, addr); success = true; }
+if (val != e) {
-return success;
+return false;
+}
+Atomic::store(x, addr);
+return true;
 }
 #endif
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time))
+UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time)) {
-UnsafeWrapper("Unsafe_Park");
 EventThreadPark event;
 HOTSPOT_THREAD_PARK_BEGIN((uintptr_t) thread->parker(), (int) isAbsolute, time);
 JavaThreadParkedState jtps(thread, time != 0);
 thread->parker()->park(isAbsolute != 0, time);
 HOTSPOT_THREAD_PARK_END((uintptr_t) thread->parker());
 if (event.should_commit()) {
 oop obj = thread->current_park_blocker();
 event.set_klass((obj != NULL) ? obj->klass() : NULL);
 event.set_timeout(time);
 event.set_address((obj != NULL) ? (TYPE_ADDRESS) cast_from_oop<uintptr_t>(obj) : 0);
 event.commit();
 }
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(void, Unsafe_Unpark(JNIEnv *env, jobject unsafe, jobject jthread))
+UNSAFE_ENTRY(void, Unsafe_Unpark(JNIEnv *env, jobject unsafe, jobject jthread)) {
-UnsafeWrapper("Unsafe_Unpark");
 Parker* p = NULL;
 if (jthread != NULL) {
 oop java_thread = JNIHandles::resolve_non_null(jthread);
 if (java_thread != NULL) {
 jlong lp = java_lang_Thread::park_event(java_thread);
 if (lp != 0) {
 p = (Parker*)addr_from_java(lp);
 } else {
 // Grab lock if apparently null or using older version of library
 MutexLocker mu(Threads_lock);
 java_thread = JNIHandles::resolve_non_null(jthread);
 if (java_thread != NULL) {
 JavaThread* thr = java_lang_Thread::thread(java_thread);
 if (thr != NULL) {
 p = thr->parker();
 if (p != NULL) { // Bind to Java thread for next time.
 }
 }
 }
 }
 }
 if (p != NULL) {
 HOTSPOT_THREAD_UNPARK((uintptr_t) p);
 p->unpark();
 }
-UNSAFE_END
+} UNSAFE_END
-UNSAFE_ENTRY(jint, Unsafe_Loadavg(JNIEnv *env, jobject unsafe, jdoubleArray loadavg, jint nelem))
+UNSAFE_ENTRY(jint, Unsafe_GetLoadAverage0(JNIEnv *env, jobject unsafe, jdoubleArray loadavg, jint nelem)) {
-UnsafeWrapper("Unsafe_Loadavg");
 const int max_nelem = 3;
 double la[max_nelem];
 jint ret;
 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(loadavg));
 assert(a->is_typeArray(), "must be type array");
-if (nelem < 0 || nelem > max_nelem || a->length() < nelem) {
+ret = os::loadavg(la, nelem);
-ThreadToNativeFromVM ttnfv(thread);
+if (ret == -1) {
-throw_new(env, "ArrayIndexOutOfBoundsException");
 return -1;
 }
-ret = os::loadavg(la, nelem);
-if (ret == -1) return -1;
 // if successful, ret is the number of samples actually retrieved.
 assert(ret >= 0 && ret <= max_nelem, "Unexpected loadavg return value");
 switch(ret) {
 case 3: a->double_at_put(2, (jdouble)la[2]); // fall through
 case 2: a->double_at_put(1, (jdouble)la[1]); // fall through
 case 1: a->double_at_put(0, (jdouble)la[0]); break;
 }
 return ret;
-UNSAFE_END
+} UNSAFE_END
 /// JVM_RegisterUnsafeMethods
 #define ADR "J"
 #define DAC_Args CLS "[B[" OBJ
 #define CC (char*)  /*cast a literal from (const char*)*/
 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
-#define DECLARE_GETPUTOOP(Boolean, Z) \
+#define DECLARE_GETPUTOOP(Type, Desc) \
-{CC "get" #Boolean,      CC "(" OBJ "J)" #Z,       FN_PTR(Unsafe_Get##Boolean)}, \
+{CC "get" #Type,      CC "(" OBJ "J)" #Desc,       FN_PTR(Unsafe_Get##Type)}, \
-{CC "put" #Boolean,      CC "(" OBJ "J" #Z ")V",   FN_PTR(Unsafe_Set##Boolean)}, \
+{CC "put" #Type,      CC "(" OBJ "J" #Desc ")V",   FN_PTR(Unsafe_Set##Type)}, \
-{CC "get" #Boolean "Volatile",      CC "(" OBJ "J)" #Z,       FN_PTR(Unsafe_Get##Boolean##Volatile)}, \
+{CC "get" #Type "Volatile",      CC "(" OBJ "J)" #Desc,       FN_PTR(Unsafe_Get##Type##Volatile)}, \
-{CC "put" #Boolean "Volatile",      CC "(" OBJ "J" #Z ")V",   FN_PTR(Unsafe_Set##Boolean##Volatile)}
+{CC "put" #Type "Volatile",      CC "(" OBJ "J" #Desc ")V",   FN_PTR(Unsafe_Set##Type##Volatile)}
 #define DECLARE_GETPUTNATIVE(Byte, B) \
 {CC "get" #Byte,         CC "(" ADR ")" #B,       FN_PTR(Unsafe_GetNative##Byte)}, \
 {CC "put" #Byte,         CC "(" ADR#B ")V",       FN_PTR(Unsafe_SetNative##Byte)}
+static JNINativeMethod jdk_internal_misc_Unsafe_methods[] = {
-static JNINativeMethod sun_misc_Unsafe_methods[] = {
 {CC "getObject",        CC "(" OBJ "J)" OBJ "",   FN_PTR(Unsafe_GetObject)},
 {CC "putObject",        CC "(" OBJ "J" OBJ ")V",  FN_PTR(Unsafe_SetObject)},
 {CC "getObjectVolatile",CC "(" OBJ "J)" OBJ "",   FN_PTR(Unsafe_GetObjectVolatile)},
 {CC "putObjectVolatile",CC "(" OBJ "J" OBJ ")V",  FN_PTR(Unsafe_SetObjectVolatile)},
 DECLARE_GETPUTNATIVE(Double, D),
 {CC "getAddress",         CC "(" ADR ")" ADR,        FN_PTR(Unsafe_GetNativeAddress)},
 {CC "putAddress",         CC "(" ADR "" ADR ")V",    FN_PTR(Unsafe_SetNativeAddress)},
-{CC "allocateMemory",     CC "(J)" ADR,              FN_PTR(Unsafe_AllocateMemory)},
+{CC "allocateMemory0",    CC "(J)" ADR,              FN_PTR(Unsafe_AllocateMemory0)},
-{CC "reallocateMemory",   CC "(" ADR "J)" ADR,       FN_PTR(Unsafe_ReallocateMemory)},
+{CC "reallocateMemory0",  CC "(" ADR "J)" ADR,       FN_PTR(Unsafe_ReallocateMemory0)},
-{CC "freeMemory",         CC "(" ADR ")V",           FN_PTR(Unsafe_FreeMemory)},
+{CC "freeMemory0",        CC "(" ADR ")V",           FN_PTR(Unsafe_FreeMemory0)},
-{CC "objectFieldOffset",  CC "(" FLD ")J",           FN_PTR(Unsafe_ObjectFieldOffset)},
+{CC "objectFieldOffset0", CC "(" FLD ")J",           FN_PTR(Unsafe_ObjectFieldOffset0)},
-{CC "staticFieldOffset",  CC "(" FLD ")J",           FN_PTR(Unsafe_StaticFieldOffset)},
+{CC "staticFieldOffset0", CC "(" FLD ")J",           FN_PTR(Unsafe_StaticFieldOffset0)},
-{CC "staticFieldBase",    CC "(" FLD ")" OBJ,        FN_PTR(Unsafe_StaticFieldBaseFromField)},
+{CC "staticFieldBase0",   CC "(" FLD ")" OBJ,        FN_PTR(Unsafe_StaticFieldBase0)},
-{CC "ensureClassInitialized",CC "(" CLS ")V",        FN_PTR(Unsafe_EnsureClassInitialized)},
+{CC "ensureClassInitialized0", CC "(" CLS ")V",      FN_PTR(Unsafe_EnsureClassInitialized0)},
-{CC "arrayBaseOffset",    CC "(" CLS ")I",           FN_PTR(Unsafe_ArrayBaseOffset)},
+{CC "arrayBaseOffset0",   CC "(" CLS ")I",           FN_PTR(Unsafe_ArrayBaseOffset0)},
-{CC "arrayIndexScale",    CC "(" CLS ")I",           FN_PTR(Unsafe_ArrayIndexScale)},
+{CC "arrayIndexScale0",   CC "(" CLS ")I",           FN_PTR(Unsafe_ArrayIndexScale0)},
-{CC "addressSize",        CC "()I",                  FN_PTR(Unsafe_AddressSize)},
+{CC "addressSize0",       CC "()I",                  FN_PTR(Unsafe_AddressSize0)},
 {CC "pageSize",           CC "()I",                  FN_PTR(Unsafe_PageSize)},
-{CC "defineClass",        CC "(" DC_Args ")" CLS,    FN_PTR(Unsafe_DefineClass)},
+{CC "defineClass0",       CC "(" DC_Args ")" CLS,    FN_PTR(Unsafe_DefineClass0)},
-{CC "allocateInstance",   CC "(" CLS ")" OBJ,        FN_PTR(Unsafe_AllocateInstance)},
-{CC "throwException",     CC "(" THR ")V",           FN_PTR(Unsafe_ThrowException)},
-{CC "compareAndSwapObject", CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
-{CC "compareAndSwapInt",  CC "(" OBJ "J""I""I"")Z",  FN_PTR(Unsafe_CompareAndSwapInt)},
-{CC "compareAndSwapLong", CC "(" OBJ "J""J""J"")Z",  FN_PTR(Unsafe_CompareAndSwapLong)},
-{CC "putOrderedObject",   CC "(" OBJ "J" OBJ ")V",   FN_PTR(Unsafe_SetOrderedObject)},
-{CC "putOrderedInt",      CC "(" OBJ "JI)V",         FN_PTR(Unsafe_SetOrderedInt)},
-{CC "putOrderedLong",     CC "(" OBJ "JJ)V",         FN_PTR(Unsafe_SetOrderedLong)},
-{CC "park",               CC "(ZJ)V",                FN_PTR(Unsafe_Park)},
-{CC "unpark",             CC "(" OBJ ")V",           FN_PTR(Unsafe_Unpark)},
-{CC "getLoadAverage",     CC "([DI)I",               FN_PTR(Unsafe_Loadavg)},
-{CC "copyMemory",         CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory)},
-{CC "setMemory",          CC "(" OBJ "JJB)V",        FN_PTR(Unsafe_SetMemory)},
-{CC "defineAnonymousClass", CC "(" DAC_Args ")" CLS, FN_PTR(Unsafe_DefineAnonymousClass)},
-{CC "shouldBeInitialized",CC "(" CLS ")Z",           FN_PTR(Unsafe_ShouldBeInitialized)},
-{CC "loadFence",          CC "()V",                  FN_PTR(Unsafe_LoadFence)},
-{CC "storeFence",         CC "()V",                  FN_PTR(Unsafe_StoreFence)},
-{CC "fullFence",          CC "()V",                  FN_PTR(Unsafe_FullFence)},
-};
-static JNINativeMethod jdk_internal_misc_Unsafe_methods[] = {
-{CC "getObject",        CC "(" OBJ "J)" OBJ "",   FN_PTR(Unsafe_GetObject)},
-{CC "putObject",        CC "(" OBJ "J" OBJ ")V",  FN_PTR(Unsafe_SetObject)},
-{CC "getObjectVolatile",CC "(" OBJ "J)" OBJ "",   FN_PTR(Unsafe_GetObjectVolatile)},
-{CC "putObjectVolatile",CC "(" OBJ "J" OBJ ")V",  FN_PTR(Unsafe_SetObjectVolatile)},
-{CC "getUncompressedObject", CC "(" ADR ")" OBJ,  FN_PTR(Unsafe_GetUncompressedObject)},
-{CC "getJavaMirror",         CC "(" ADR ")" CLS,  FN_PTR(Unsafe_GetJavaMirror)},
-{CC "getKlassPointer",       CC "(" OBJ ")" ADR,  FN_PTR(Unsafe_GetKlassPointer)},
-DECLARE_GETPUTOOP(Boolean, Z),
-DECLARE_GETPUTOOP(Byte, B),
-DECLARE_GETPUTOOP(Short, S),
-DECLARE_GETPUTOOP(Char, C),
-DECLARE_GETPUTOOP(Int, I),
-DECLARE_GETPUTOOP(Long, J),
-DECLARE_GETPUTOOP(Float, F),
-DECLARE_GETPUTOOP(Double, D),
-DECLARE_GETPUTNATIVE(Byte, B),
-DECLARE_GETPUTNATIVE(Short, S),
-DECLARE_GETPUTNATIVE(Char, C),
-DECLARE_GETPUTNATIVE(Int, I),
-DECLARE_GETPUTNATIVE(Long, J),
-DECLARE_GETPUTNATIVE(Float, F),
-DECLARE_GETPUTNATIVE(Double, D),
-{CC "getAddress",         CC "(" ADR ")" ADR,        FN_PTR(Unsafe_GetNativeAddress)},
-{CC "putAddress",         CC "(" ADR "" ADR ")V",    FN_PTR(Unsafe_SetNativeAddress)},
-{CC "allocateMemory",     CC "(J)" ADR,              FN_PTR(Unsafe_AllocateMemory)},
-{CC "reallocateMemory",   CC "(" ADR "J)" ADR,       FN_PTR(Unsafe_ReallocateMemory)},
-{CC "freeMemory",         CC "(" ADR ")V",           FN_PTR(Unsafe_FreeMemory)},
-{CC "objectFieldOffset",  CC "(" FLD ")J",           FN_PTR(Unsafe_ObjectFieldOffset)},
-{CC "staticFieldOffset",  CC "(" FLD ")J",           FN_PTR(Unsafe_StaticFieldOffset)},
-{CC "staticFieldBase",    CC "(" FLD ")" OBJ,        FN_PTR(Unsafe_StaticFieldBaseFromField)},
-{CC "ensureClassInitialized",CC "(" CLS ")V",        FN_PTR(Unsafe_EnsureClassInitialized)},
-{CC "arrayBaseOffset",    CC "(" CLS ")I",           FN_PTR(Unsafe_ArrayBaseOffset)},
-{CC "arrayIndexScale",    CC "(" CLS ")I",           FN_PTR(Unsafe_ArrayIndexScale)},
-{CC "addressSize",        CC "()I",                  FN_PTR(Unsafe_AddressSize)},
-{CC "pageSize",           CC "()I",                  FN_PTR(Unsafe_PageSize)},
-{CC "defineClass",        CC "(" DC_Args ")" CLS,    FN_PTR(Unsafe_DefineClass)},
 {CC "allocateInstance",   CC "(" CLS ")" OBJ,        FN_PTR(Unsafe_AllocateInstance)},
 {CC "throwException",     CC "(" THR ")V",           FN_PTR(Unsafe_ThrowException)},
 {CC "compareAndSwapObject", CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
 {CC "compareAndSwapInt",  CC "(" OBJ "J""I""I"")Z",  FN_PTR(Unsafe_CompareAndSwapInt)},
 {CC "compareAndSwapLong", CC "(" OBJ "J""J""J"")Z",  FN_PTR(Unsafe_CompareAndSwapLong)},
 {CC "putOrderedInt",      CC "(" OBJ "JI)V",         FN_PTR(Unsafe_SetOrderedInt)},
 {CC "putOrderedLong",     CC "(" OBJ "JJ)V",         FN_PTR(Unsafe_SetOrderedLong)},
 {CC "park",               CC "(ZJ)V",                FN_PTR(Unsafe_Park)},
 {CC "unpark",             CC "(" OBJ ")V",           FN_PTR(Unsafe_Unpark)},
-{CC "getLoadAverage",     CC "([DI)I",               FN_PTR(Unsafe_Loadavg)},
+{CC "getLoadAverage0",    CC "([DI)I",               FN_PTR(Unsafe_GetLoadAverage0)},
-{CC "copyMemory",         CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory)},
+{CC "copyMemory0",        CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory0)},
 {CC "copySwapMemory0",    CC "(" OBJ "J" OBJ "JJJ)V", FN_PTR(Unsafe_CopySwapMemory0)},
-{CC "setMemory",          CC "(" OBJ "JJB)V",        FN_PTR(Unsafe_SetMemory)},
+{CC "setMemory0",         CC "(" OBJ "JJB)V",        FN_PTR(Unsafe_SetMemory0)},
-{CC "defineAnonymousClass", CC "(" DAC_Args ")" CLS, FN_PTR(Unsafe_DefineAnonymousClass)},
+{CC "defineAnonymousClass0", CC "(" DAC_Args ")" CLS, FN_PTR(Unsafe_DefineAnonymousClass0)},
-{CC "shouldBeInitialized",CC "(" CLS ")Z",           FN_PTR(Unsafe_ShouldBeInitialized)},
+{CC "shouldBeInitialized0", CC "(" CLS ")Z",         FN_PTR(Unsafe_ShouldBeInitialized0)},
 {CC "loadFence",          CC "()V",                  FN_PTR(Unsafe_LoadFence)},
 {CC "storeFence",         CC "()V",                  FN_PTR(Unsafe_StoreFence)},
 {CC "fullFence",          CC "()V",                  FN_PTR(Unsafe_FullFence)},
 #undef DECLARE_GETPUTOOP
 #undef DECLARE_GETPUTNATIVE
-// These two functions are exported, used by NativeLookup.
+// This function is exported, used by NativeLookup.
 // The Unsafe_xxx functions above are called only from the interpreter.
 // The optimizer looks at names and signatures to recognize
 // individual functions.
-JVM_ENTRY(void, JVM_RegisterSunMiscUnsafeMethods(JNIEnv *env, jclass unsafeclass))
+JVM_ENTRY(void, JVM_RegisterJDKInternalMiscUnsafeMethods(JNIEnv *env, jclass unsafeclass)) {
-UnsafeWrapper("JVM_RegisterSunMiscUnsafeMethods");
+ThreadToNativeFromVM ttnfv(thread);
-{
-ThreadToNativeFromVM ttnfv(thread);
+int ok = env->RegisterNatives(unsafeclass, jdk_internal_misc_Unsafe_methods, sizeof(jdk_internal_misc_Unsafe_methods)/sizeof(JNINativeMethod));
+guarantee(ok == 0, "register jdk.internal.misc.Unsafe natives");
-int ok = env->RegisterNatives(unsafeclass, sun_misc_Unsafe_methods, sizeof(sun_misc_Unsafe_methods)/sizeof(JNINativeMethod));
+} JVM_END
-guarantee(ok == 0, "register sun.misc.Unsafe natives");
-}
-JVM_END
-JVM_ENTRY(void, JVM_RegisterJDKInternalMiscUnsafeMethods(JNIEnv *env, jclass unsafeclass))
-UnsafeWrapper("JVM_RegisterJDKInternalMiscUnsafeMethods");
-{
-ThreadToNativeFromVM ttnfv(thread);
-int ok = env->RegisterNatives(unsafeclass, jdk_internal_misc_Unsafe_methods, sizeof(jdk_internal_misc_Unsafe_methods)/sizeof(JNINativeMethod));
-guarantee(ok == 0, "register jdk.internal.misc.Unsafe natives");
-}
-JVM_END

changeset 36551	77f29c57ed2e
parent 36316	7a83de7aabca
child 37184	23e0d47c1f3e
child 36827	53d2d43551d2