< prev index next >

src/hotspot/share/prims/unsafe.cpp

Print this page

  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 "classfile/classFileStream.hpp"
  26 #include "classfile/classLoader.hpp"
  27 #include "classfile/classLoadInfo.hpp"
  28 #include "classfile/javaClasses.inline.hpp"
  29 #include "classfile/systemDictionary.hpp"
  30 #include "classfile/vmSymbols.hpp"
  31 #include "jfr/jfrEvents.hpp"
  32 #include "jni.h"
  33 #include "jvm.h"
  34 #include "memory/allocation.inline.hpp"
  35 #include "memory/resourceArea.hpp"


  36 #include "oops/access.inline.hpp"
  37 #include "oops/fieldStreams.inline.hpp"



  38 #include "oops/instanceKlass.inline.hpp"
  39 #include "oops/klass.inline.hpp"
  40 #include "oops/objArrayOop.inline.hpp"
  41 #include "oops/oop.inline.hpp"
  42 #include "oops/typeArrayOop.inline.hpp"
  43 #include "prims/jvmtiExport.hpp"
  44 #include "prims/unsafe.hpp"

  45 #include "runtime/globals.hpp"
  46 #include "runtime/handles.inline.hpp"
  47 #include "runtime/interfaceSupport.inline.hpp"
  48 #include "runtime/javaThread.inline.hpp"
  49 #include "runtime/jniHandles.inline.hpp"
  50 #include "runtime/orderAccess.hpp"
  51 #include "runtime/reflection.hpp"
  52 #include "runtime/sharedRuntime.hpp"
  53 #include "runtime/stubRoutines.hpp"
  54 #include "runtime/threadSMR.hpp"
  55 #include "runtime/vmOperations.hpp"
  56 #include "runtime/vm_version.hpp"
  57 #include "sanitizers/ub.hpp"
  58 #include "services/threadService.hpp"
  59 #include "utilities/align.hpp"
  60 #include "utilities/copy.hpp"
  61 #include "utilities/dtrace.hpp"
  62 #include "utilities/macros.hpp"
  63 
  64 /**

 151   }
 152 #endif
 153 }
 154 
 155 static inline void* index_oop_from_field_offset_long(oop p, jlong field_offset) {
 156   assert_field_offset_sane(p, field_offset);
 157   uintptr_t base_address = cast_from_oop<uintptr_t>(p);
 158   uintptr_t byte_offset  = (uintptr_t)field_offset_to_byte_offset(field_offset);
 159   return (void*)(base_address + byte_offset);
 160 }
 161 
 162 // Externally callable versions:
 163 // (Use these in compiler intrinsics which emulate unsafe primitives.)
 164 jlong Unsafe_field_offset_to_byte_offset(jlong field_offset) {
 165   return field_offset;
 166 }
 167 jlong Unsafe_field_offset_from_byte_offset(jlong byte_offset) {
 168   return byte_offset;
 169 }
 170 
 171 
 172 ///// Data read/writes on the Java heap and in native (off-heap) memory
 173 
 174 /**
 175  * Helper class to wrap memory accesses in JavaThread::doing_unsafe_access()
 176  */
 177 class GuardUnsafeAccess {
 178   JavaThread* _thread;
 179 
 180 public:
 181   GuardUnsafeAccess(JavaThread* thread) : _thread(thread) {
 182     // native/off-heap access which may raise SIGBUS if accessing
 183     // memory mapped file data in a region of the file which has
 184     // been truncated and is now invalid.
 185     _thread->set_doing_unsafe_access(true);
 186   }
 187 
 188   ~GuardUnsafeAccess() {
 189     _thread->set_doing_unsafe_access(false);
 190   }
 191 };

 230   jboolean normalize_for_read(jboolean x) {
 231     return x != 0;
 232   }
 233 
 234 public:
 235   MemoryAccess(JavaThread* thread, jobject obj, jlong offset)
 236     : _thread(thread), _obj(JNIHandles::resolve(obj)), _offset((ptrdiff_t)offset) {
 237     assert_field_offset_sane(_obj, offset);
 238   }
 239 
 240   T get() {
 241     GuardUnsafeAccess guard(_thread);
 242     return normalize_for_read(*addr());
 243   }
 244 
 245   // we use this method at some places for writing to 0 e.g. to cause a crash;
 246   // ubsan does not know that this is the desired behavior
 247   ATTRIBUTE_NO_UBSAN
 248   void put(T x) {
 249     GuardUnsafeAccess guard(_thread);

 250     *addr() = normalize_for_write(x);
 251   }
 252 
 253 
 254   T get_volatile() {
 255     GuardUnsafeAccess guard(_thread);
 256     volatile T ret = RawAccess<MO_SEQ_CST>::load(addr());
 257     return normalize_for_read(ret);
 258   }
 259 
 260   void put_volatile(T x) {
 261     GuardUnsafeAccess guard(_thread);
 262     RawAccess<MO_SEQ_CST>::store(addr(), normalize_for_write(x));
 263   }
 264 };
 265 






























































 266 // These functions allow a null base pointer with an arbitrary address.
 267 // But if the base pointer is non-null, the offset should make some sense.
 268 // That is, it should be in the range [0, MAX_OBJECT_SIZE].
 269 UNSAFE_ENTRY(jobject, Unsafe_GetReference(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) {
 270   oop p = JNIHandles::resolve(obj);
 271   assert_field_offset_sane(p, offset);
 272   oop v = HeapAccess<ON_UNKNOWN_OOP_REF>::oop_load_at(p, offset);
 273   return JNIHandles::make_local(THREAD, v);
 274 } UNSAFE_END
 275 
 276 UNSAFE_ENTRY(void, Unsafe_PutReference(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) {
 277   oop x = JNIHandles::resolve(x_h);
 278   oop p = JNIHandles::resolve(obj);
 279   assert_field_offset_sane(p, offset);

 280   HeapAccess<ON_UNKNOWN_OOP_REF>::oop_store_at(p, offset, x);
 281 } UNSAFE_END
 282 



































































































































































 283 UNSAFE_ENTRY(jobject, Unsafe_GetReferenceVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) {
 284   oop p = JNIHandles::resolve(obj);
 285   assert_field_offset_sane(p, offset);
 286   oop v = HeapAccess<MO_SEQ_CST | ON_UNKNOWN_OOP_REF>::oop_load_at(p, offset);
 287   return JNIHandles::make_local(THREAD, v);
 288 } UNSAFE_END
 289 
 290 UNSAFE_ENTRY(void, Unsafe_PutReferenceVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) {
 291   oop x = JNIHandles::resolve(x_h);
 292   oop p = JNIHandles::resolve(obj);
 293   assert_field_offset_sane(p, offset);
 294   HeapAccess<MO_SEQ_CST | ON_UNKNOWN_OOP_REF>::oop_store_at(p, offset, x);
 295 } UNSAFE_END
 296 
 297 UNSAFE_ENTRY(jobject, Unsafe_GetUncompressedObject(JNIEnv *env, jobject unsafe, jlong addr)) {
 298   oop v = *(oop*) (address) addr;
 299   return JNIHandles::make_local(THREAD, v);
 300 } UNSAFE_END
 301 
 302 #define DEFINE_GETSETOOP(java_type, Type) \

 583   return false;
 584 }
 585 UNSAFE_END
 586 
 587 static void getBaseAndScale(int& base, int& scale, jclass clazz, TRAPS) {
 588   assert(clazz != nullptr, "clazz must not be null");
 589 
 590   oop mirror = JNIHandles::resolve_non_null(clazz);
 591   Klass* k = java_lang_Class::as_Klass(mirror);
 592 
 593   if (k == nullptr || !k->is_array_klass()) {
 594     THROW(vmSymbols::java_lang_InvalidClassException());
 595   } else if (k->is_objArray_klass()) {
 596     base  = arrayOopDesc::base_offset_in_bytes(T_OBJECT);
 597     scale = heapOopSize;
 598   } else if (k->is_typeArray_klass()) {
 599     TypeArrayKlass* tak = TypeArrayKlass::cast(k);
 600     base  = tak->array_header_in_bytes();
 601     assert(base == arrayOopDesc::base_offset_in_bytes(tak->element_type()), "array_header_size semantics ok");
 602     scale = (1 << tak->log2_element_size());





 603   } else {
 604     ShouldNotReachHere();
 605   }
 606 }
 607 
 608 UNSAFE_ENTRY(jint, Unsafe_ArrayBaseOffset0(JNIEnv *env, jobject unsafe, jclass clazz)) {
 609   int base = 0, scale = 0;
 610   getBaseAndScale(base, scale, clazz, CHECK_0);
 611 
 612   return field_offset_from_byte_offset(base);
 613 } UNSAFE_END
 614 
 615 
 616 UNSAFE_ENTRY(jint, Unsafe_ArrayIndexScale0(JNIEnv *env, jobject unsafe, jclass clazz)) {
 617   int base = 0, scale = 0;
 618   getBaseAndScale(base, scale, clazz, CHECK_0);
 619 
 620   // This VM packs both fields and array elements down to the byte.
 621   // But watch out:  If this changes, so that array references for
 622   // a given primitive type (say, T_BOOLEAN) use different memory units
 623   // than fields, this method MUST return zero for such arrays.
 624   // For example, the VM used to store sub-word sized fields in full
 625   // words in the object layout, so that accessors like getByte(Object,int)
 626   // did not really do what one might expect for arrays.  Therefore,
 627   // this function used to report a zero scale factor, so that the user
 628   // would know not to attempt to access sub-word array elements.
 629   // // Code for unpacked fields:
 630   // if (scale < wordSize)  return 0;
 631 
 632   // The following allows for a pretty general fieldOffset cookie scheme,
 633   // but requires it to be linear in byte offset.
 634   return field_offset_from_byte_offset(scale) - field_offset_from_byte_offset(0);
 635 } UNSAFE_END
 636 
 637 






 638 static inline void throw_new(JNIEnv *env, const char *ename) {
 639   jclass cls = env->FindClass(ename);
 640   if (env->ExceptionCheck()) {
 641     env->ExceptionClear();
 642     tty->print_cr("Unsafe: cannot throw %s because FindClass has failed", ename);
 643     return;
 644   }
 645 
 646   env->ThrowNew(cls, nullptr);
 647 }
 648 
 649 static jclass Unsafe_DefineClass_impl(JNIEnv *env, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd) {
 650   // Code lifted from JDK 1.3 ClassLoader.c
 651 
 652   jbyte *body;
 653   char *utfName = nullptr;
 654   jclass result = nullptr;
 655   char buf[128];
 656 
 657   assert(data != nullptr, "Class bytes must not be null");

 837 
 838 
 839 /// JVM_RegisterUnsafeMethods
 840 
 841 #define ADR "J"
 842 
 843 #define LANG "Ljava/lang/"
 844 
 845 #define OBJ LANG "Object;"
 846 #define CLS LANG "Class;"
 847 #define FLD LANG "reflect/Field;"
 848 #define THR LANG "Throwable;"
 849 
 850 #define DC_Args  LANG "String;[BII" LANG "ClassLoader;" "Ljava/security/ProtectionDomain;"
 851 #define DAC_Args CLS "[B[" OBJ
 852 
 853 #define CC (char*)  /*cast a literal from (const char*)*/
 854 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
 855 
 856 #define DECLARE_GETPUTOOP(Type, Desc) \
 857     {CC "get" #Type,      CC "(" OBJ "J)" #Desc,       FN_PTR(Unsafe_Get##Type)}, \
 858     {CC "put" #Type,      CC "(" OBJ "J" #Desc ")V",   FN_PTR(Unsafe_Put##Type)}, \
 859     {CC "get" #Type "Volatile",      CC "(" OBJ "J)" #Desc,       FN_PTR(Unsafe_Get##Type##Volatile)}, \
 860     {CC "put" #Type "Volatile",      CC "(" OBJ "J" #Desc ")V",   FN_PTR(Unsafe_Put##Type##Volatile)}
 861 
 862 
 863 static JNINativeMethod jdk_internal_misc_Unsafe_methods[] = {
 864     {CC "getReference",         CC "(" OBJ "J)" OBJ "",   FN_PTR(Unsafe_GetReference)},
 865     {CC "putReference",         CC "(" OBJ "J" OBJ ")V",  FN_PTR(Unsafe_PutReference)},
 866     {CC "getReferenceVolatile", CC "(" OBJ "J)" OBJ,      FN_PTR(Unsafe_GetReferenceVolatile)},
 867     {CC "putReferenceVolatile", CC "(" OBJ "J" OBJ ")V",  FN_PTR(Unsafe_PutReferenceVolatile)},
 868 















 869     {CC "getUncompressedObject", CC "(" ADR ")" OBJ,  FN_PTR(Unsafe_GetUncompressedObject)},
 870 
 871     DECLARE_GETPUTOOP(Boolean, Z),
 872     DECLARE_GETPUTOOP(Byte, B),
 873     DECLARE_GETPUTOOP(Short, S),
 874     DECLARE_GETPUTOOP(Char, C),
 875     DECLARE_GETPUTOOP(Int, I),
 876     DECLARE_GETPUTOOP(Long, J),
 877     DECLARE_GETPUTOOP(Float, F),
 878     DECLARE_GETPUTOOP(Double, D),
 879 
 880     {CC "allocateMemory0",    CC "(J)" ADR,              FN_PTR(Unsafe_AllocateMemory0)},
 881     {CC "reallocateMemory0",  CC "(" ADR "J)" ADR,       FN_PTR(Unsafe_ReallocateMemory0)},
 882     {CC "freeMemory0",        CC "(" ADR ")V",           FN_PTR(Unsafe_FreeMemory0)},
 883 
 884     {CC "objectFieldOffset0", CC "(" FLD ")J",           FN_PTR(Unsafe_ObjectFieldOffset0)},
 885     {CC "objectFieldOffset1", CC "(" CLS LANG "String;)J", FN_PTR(Unsafe_ObjectFieldOffset1)},
 886     {CC "staticFieldOffset0", CC "(" FLD ")J",           FN_PTR(Unsafe_StaticFieldOffset0)},
 887     {CC "staticFieldBase0",   CC "(" FLD ")" OBJ,        FN_PTR(Unsafe_StaticFieldBase0)},
 888     {CC "ensureClassInitialized0", CC "(" CLS ")V",      FN_PTR(Unsafe_EnsureClassInitialized0)},
 889     {CC "arrayBaseOffset0",   CC "(" CLS ")I",           FN_PTR(Unsafe_ArrayBaseOffset0)},
 890     {CC "arrayIndexScale0",   CC "(" CLS ")I",           FN_PTR(Unsafe_ArrayIndexScale0)},

 891 
 892     {CC "defineClass0",       CC "(" DC_Args ")" CLS,    FN_PTR(Unsafe_DefineClass0)},
 893     {CC "allocateInstance",   CC "(" CLS ")" OBJ,        FN_PTR(Unsafe_AllocateInstance)},
 894     {CC "throwException",     CC "(" THR ")V",           FN_PTR(Unsafe_ThrowException)},
 895     {CC "compareAndSetReference",CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSetReference)},
 896     {CC "compareAndSetInt",   CC "(" OBJ "J""I""I"")Z",  FN_PTR(Unsafe_CompareAndSetInt)},
 897     {CC "compareAndSetLong",  CC "(" OBJ "J""J""J"")Z",  FN_PTR(Unsafe_CompareAndSetLong)},
 898     {CC "compareAndExchangeReference", CC "(" OBJ "J" OBJ "" OBJ ")" OBJ, FN_PTR(Unsafe_CompareAndExchangeReference)},
 899     {CC "compareAndExchangeInt",  CC "(" OBJ "J""I""I"")I", FN_PTR(Unsafe_CompareAndExchangeInt)},
 900     {CC "compareAndExchangeLong", CC "(" OBJ "J""J""J"")J", FN_PTR(Unsafe_CompareAndExchangeLong)},
 901 
 902     {CC "park",               CC "(ZJ)V",                FN_PTR(Unsafe_Park)},
 903     {CC "unpark",             CC "(" OBJ ")V",           FN_PTR(Unsafe_Unpark)},
 904 
 905     {CC "getLoadAverage0",    CC "([DI)I",               FN_PTR(Unsafe_GetLoadAverage0)},
 906 
 907     {CC "copyMemory0",        CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory0)},
 908     {CC "copySwapMemory0",    CC "(" OBJ "J" OBJ "JJJ)V", FN_PTR(Unsafe_CopySwapMemory0)},
 909     {CC "writeback0",         CC "(" "J" ")V",           FN_PTR(Unsafe_WriteBack0)},
 910     {CC "writebackPreSync0",  CC "()V",                  FN_PTR(Unsafe_WriteBackPreSync0)},

  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 "classfile/classFileStream.hpp"
  26 #include "classfile/classLoader.hpp"
  27 #include "classfile/classLoadInfo.hpp"
  28 #include "classfile/javaClasses.inline.hpp"
  29 #include "classfile/systemDictionary.hpp"
  30 #include "classfile/vmSymbols.hpp"
  31 #include "jfr/jfrEvents.hpp"
  32 #include "jni.h"
  33 #include "jvm.h"
  34 #include "memory/allocation.inline.hpp"
  35 #include "memory/resourceArea.hpp"
  36 #include "logging/log.hpp"
  37 #include "logging/logStream.hpp"
  38 #include "oops/access.inline.hpp"
  39 #include "oops/fieldStreams.inline.hpp"
  40 #include "oops/flatArrayKlass.hpp"
  41 #include "oops/flatArrayOop.inline.hpp"
  42 #include "oops/inlineKlass.inline.hpp"
  43 #include "oops/instanceKlass.inline.hpp"
  44 #include "oops/klass.inline.hpp"
  45 #include "oops/objArrayOop.inline.hpp"
  46 #include "oops/oop.inline.hpp"
  47 #include "oops/typeArrayOop.inline.hpp"
  48 #include "prims/jvmtiExport.hpp"
  49 #include "prims/unsafe.hpp"
  50 #include "runtime/fieldDescriptor.inline.hpp"
  51 #include "runtime/globals.hpp"
  52 #include "runtime/handles.inline.hpp"
  53 #include "runtime/interfaceSupport.inline.hpp"
  54 #include "runtime/javaThread.inline.hpp"
  55 #include "runtime/jniHandles.inline.hpp"
  56 #include "runtime/orderAccess.hpp"
  57 #include "runtime/reflection.hpp"
  58 #include "runtime/sharedRuntime.hpp"
  59 #include "runtime/stubRoutines.hpp"
  60 #include "runtime/threadSMR.hpp"
  61 #include "runtime/vmOperations.hpp"
  62 #include "runtime/vm_version.hpp"
  63 #include "sanitizers/ub.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 /**

 157   }
 158 #endif
 159 }
 160 
 161 static inline void* index_oop_from_field_offset_long(oop p, jlong field_offset) {
 162   assert_field_offset_sane(p, field_offset);
 163   uintptr_t base_address = cast_from_oop<uintptr_t>(p);
 164   uintptr_t byte_offset  = (uintptr_t)field_offset_to_byte_offset(field_offset);
 165   return (void*)(base_address + byte_offset);
 166 }
 167 
 168 // Externally callable versions:
 169 // (Use these in compiler intrinsics which emulate unsafe primitives.)
 170 jlong Unsafe_field_offset_to_byte_offset(jlong field_offset) {
 171   return field_offset;
 172 }
 173 jlong Unsafe_field_offset_from_byte_offset(jlong byte_offset) {
 174   return byte_offset;
 175 }
 176 

 177 ///// Data read/writes on the Java heap and in native (off-heap) memory
 178 
 179 /**
 180  * Helper class to wrap memory accesses in JavaThread::doing_unsafe_access()
 181  */
 182 class GuardUnsafeAccess {
 183   JavaThread* _thread;
 184 
 185 public:
 186   GuardUnsafeAccess(JavaThread* thread) : _thread(thread) {
 187     // native/off-heap access which may raise SIGBUS if accessing
 188     // memory mapped file data in a region of the file which has
 189     // been truncated and is now invalid.
 190     _thread->set_doing_unsafe_access(true);
 191   }
 192 
 193   ~GuardUnsafeAccess() {
 194     _thread->set_doing_unsafe_access(false);
 195   }
 196 };

 235   jboolean normalize_for_read(jboolean x) {
 236     return x != 0;
 237   }
 238 
 239 public:
 240   MemoryAccess(JavaThread* thread, jobject obj, jlong offset)
 241     : _thread(thread), _obj(JNIHandles::resolve(obj)), _offset((ptrdiff_t)offset) {
 242     assert_field_offset_sane(_obj, offset);
 243   }
 244 
 245   T get() {
 246     GuardUnsafeAccess guard(_thread);
 247     return normalize_for_read(*addr());
 248   }
 249 
 250   // we use this method at some places for writing to 0 e.g. to cause a crash;
 251   // ubsan does not know that this is the desired behavior
 252   ATTRIBUTE_NO_UBSAN
 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->payload_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 unsafe, 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 unsafe, 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_offset(slot);
 376 } UNSAFE_END
 377 
 378 UNSAFE_ENTRY(jint, Unsafe_ArrayLayout(JNIEnv *env, jobject unsafe, jclass c)) {
 379   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(c));
 380   if (!k->is_flatArray_klass()) {
 381     return (jint)LayoutKind::REFERENCE;
 382   } else {
 383     return (jint)FlatArrayKlass::cast(k)->layout_kind();
 384   }
 385 } UNSAFE_END
 386 
 387 UNSAFE_ENTRY(jint, Unsafe_FieldLayout(JNIEnv *env, jobject unsafe, jobject field)) {
 388   assert(field != nullptr, "field must not be null");
 389 
 390   oop reflected   = JNIHandles::resolve_non_null(field);
 391   oop mirror      = java_lang_reflect_Field::clazz(reflected);
 392   Klass* k        = java_lang_Class::as_Klass(mirror);
 393   int slot        = java_lang_reflect_Field::slot(reflected);
 394   int modifiers   = java_lang_reflect_Field::modifiers(reflected);
 395 
 396   if ((modifiers & JVM_ACC_STATIC) != 0) {
 397     return (jint)LayoutKind::REFERENCE; // static fields are never flat
 398   } else {
 399     InstanceKlass* ik = InstanceKlass::cast(k);
 400     if (ik->field_is_flat(slot)) {
 401       return (jint)ik->inline_layout_info(slot).kind();
 402     } else {
 403       return (jint)LayoutKind::REFERENCE;
 404     }
 405   }
 406 } UNSAFE_END
 407 
 408 UNSAFE_ENTRY(jboolean, Unsafe_IsFlatArray(JNIEnv *env, jobject unsafe, jclass c)) {
 409   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(c));
 410   return k->is_flatArray_klass();
 411 } UNSAFE_END
 412 
 413 UNSAFE_ENTRY(jobject, Unsafe_UninitializedDefaultValue(JNIEnv *env, jobject unsafe, jclass vc)) {
 414   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(vc));
 415   InlineKlass* vk = InlineKlass::cast(k);
 416   oop v = vk->default_value();
 417   return JNIHandles::make_local(THREAD, v);
 418 } UNSAFE_END
 419 
 420 UNSAFE_ENTRY(jobject, Unsafe_GetValue(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jclass vc)) {
 421   oop base = JNIHandles::resolve(obj);
 422   if (base == nullptr) {
 423     THROW_NULL(vmSymbols::java_lang_NullPointerException());
 424   }
 425   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(vc));
 426   InlineKlass* vk = InlineKlass::cast(k);
 427   assert_and_log_unsafe_value_access(base, offset, vk);
 428   LayoutKind lk = LayoutKind::UNKNOWN;
 429   if (base->is_array()) {
 430     FlatArrayKlass* fak = FlatArrayKlass::cast(base->klass());
 431     lk = fak->layout_kind();
 432   } else {
 433     fieldDescriptor fd;
 434     InstanceKlass::cast(base->klass())->find_field_from_offset(offset, false, &fd);
 435     lk = fd.field_holder()->inline_layout_info(fd.index()).kind();
 436   }
 437   Handle base_h(THREAD, base);
 438   oop v = vk->read_payload_from_addr(base_h(), offset, lk, CHECK_NULL);
 439   return JNIHandles::make_local(THREAD, v);
 440 } UNSAFE_END
 441 
 442 UNSAFE_ENTRY(jobject, Unsafe_GetFlatValue(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint layoutKind, jclass vc)) {
 443   assert(layoutKind != (int)LayoutKind::REFERENCE, "This method handles only flat layouts");
 444   oop base = JNIHandles::resolve(obj);
 445   if (base == nullptr) {
 446     THROW_NULL(vmSymbols::java_lang_NullPointerException());
 447   }
 448   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(vc));
 449   InlineKlass* vk = InlineKlass::cast(k);
 450   assert_and_log_unsafe_value_access(base, offset, vk);
 451   LayoutKind lk = (LayoutKind)layoutKind;
 452   Handle base_h(THREAD, base);
 453   oop v = vk->read_payload_from_addr(base_h(), offset, lk, CHECK_NULL);
 454   return JNIHandles::make_local(THREAD, v);
 455 } UNSAFE_END
 456 
 457 UNSAFE_ENTRY(void, Unsafe_PutValue(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jclass vc, jobject value)) {
 458   oop base = JNIHandles::resolve(obj);
 459   if (base == nullptr) {
 460     THROW(vmSymbols::java_lang_NullPointerException());
 461   }
 462   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(vc));
 463   InlineKlass* vk = InlineKlass::cast(k);
 464   assert(!base->is_inline_type() || base->mark().is_larval_state(), "must be an object instance or a larval inline type");
 465   assert_and_log_unsafe_value_access(base, offset, vk);
 466   LayoutKind lk = LayoutKind::UNKNOWN;
 467   if (base->is_array()) {
 468     FlatArrayKlass* fak = FlatArrayKlass::cast(base->klass());
 469     lk = fak->layout_kind();
 470   } else {
 471     fieldDescriptor fd;
 472     InstanceKlass::cast(base->klass())->find_field_from_offset(offset, false, &fd);
 473     lk = fd.field_holder()->inline_layout_info(fd.index()).kind();
 474   }
 475   oop v = JNIHandles::resolve(value);
 476   vk->write_value_to_addr(v, ((char*)(oopDesc*)base) + offset, lk, true, CHECK);
 477 } UNSAFE_END
 478 
 479 UNSAFE_ENTRY(void, Unsafe_PutFlatValue(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint layoutKind, jclass vc, jobject value)) {
 480   assert(layoutKind != (int)LayoutKind::REFERENCE, "This method handles only flat layouts");
 481   oop base = JNIHandles::resolve(obj);
 482   if (base == nullptr) {
 483     THROW(vmSymbols::java_lang_NullPointerException());
 484   }
 485   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(vc));
 486   InlineKlass* vk = InlineKlass::cast(k);
 487   assert(!base->is_inline_type() || base->mark().is_larval_state(), "must be an object instance or a larval inline type");
 488   assert_and_log_unsafe_value_access(base, offset, vk);
 489   LayoutKind lk = (LayoutKind)layoutKind;
 490   oop v = JNIHandles::resolve(value);
 491   vk->write_value_to_addr(v, ((char*)(oopDesc*)base) + offset, lk, true, CHECK);
 492 } UNSAFE_END
 493 
 494 UNSAFE_ENTRY(jobject, Unsafe_MakePrivateBuffer(JNIEnv *env, jobject unsafe, jobject value)) {
 495   oop v = JNIHandles::resolve_non_null(value);
 496   assert(v->is_inline_type(), "must be an inline type instance");
 497   Handle vh(THREAD, v);
 498   InlineKlass* vk = InlineKlass::cast(v->klass());
 499   instanceOop new_value = vk->allocate_instance_buffer(CHECK_NULL);
 500   vk->copy_payload_to_addr(vk->payload_addr(vh()), vk->payload_addr(new_value), LayoutKind::BUFFERED, false);
 501   markWord mark = new_value->mark();
 502   new_value->set_mark(mark.enter_larval_state());
 503   return JNIHandles::make_local(THREAD, new_value);
 504 } UNSAFE_END
 505 
 506 UNSAFE_ENTRY(jobject, Unsafe_FinishPrivateBuffer(JNIEnv *env, jobject unsafe, jobject value)) {
 507   oop v = JNIHandles::resolve(value);
 508   assert(v->mark().is_larval_state(), "must be a larval value");
 509   markWord mark = v->mark();
 510   v->set_mark(mark.exit_larval_state());
 511   return JNIHandles::make_local(THREAD, v);
 512 } UNSAFE_END
 513 
 514 UNSAFE_ENTRY(jobject, Unsafe_GetReferenceVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) {
 515   oop p = JNIHandles::resolve(obj);
 516   assert_field_offset_sane(p, offset);
 517   oop v = HeapAccess<MO_SEQ_CST | ON_UNKNOWN_OOP_REF>::oop_load_at(p, offset);
 518   return JNIHandles::make_local(THREAD, v);
 519 } UNSAFE_END
 520 
 521 UNSAFE_ENTRY(void, Unsafe_PutReferenceVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h)) {
 522   oop x = JNIHandles::resolve(x_h);
 523   oop p = JNIHandles::resolve(obj);
 524   assert_field_offset_sane(p, offset);
 525   HeapAccess<MO_SEQ_CST | ON_UNKNOWN_OOP_REF>::oop_store_at(p, offset, x);
 526 } UNSAFE_END
 527 
 528 UNSAFE_ENTRY(jobject, Unsafe_GetUncompressedObject(JNIEnv *env, jobject unsafe, jlong addr)) {
 529   oop v = *(oop*) (address) addr;
 530   return JNIHandles::make_local(THREAD, v);
 531 } UNSAFE_END
 532 
 533 #define DEFINE_GETSETOOP(java_type, Type) \

 814   return false;
 815 }
 816 UNSAFE_END
 817 
 818 static void getBaseAndScale(int& base, int& scale, jclass clazz, TRAPS) {
 819   assert(clazz != nullptr, "clazz must not be null");
 820 
 821   oop mirror = JNIHandles::resolve_non_null(clazz);
 822   Klass* k = java_lang_Class::as_Klass(mirror);
 823 
 824   if (k == nullptr || !k->is_array_klass()) {
 825     THROW(vmSymbols::java_lang_InvalidClassException());
 826   } else if (k->is_objArray_klass()) {
 827     base  = arrayOopDesc::base_offset_in_bytes(T_OBJECT);
 828     scale = heapOopSize;
 829   } else if (k->is_typeArray_klass()) {
 830     TypeArrayKlass* tak = TypeArrayKlass::cast(k);
 831     base  = tak->array_header_in_bytes();
 832     assert(base == arrayOopDesc::base_offset_in_bytes(tak->element_type()), "array_header_size semantics ok");
 833     scale = (1 << tak->log2_element_size());
 834   } else if (k->is_flatArray_klass()) {
 835     FlatArrayKlass* vak = FlatArrayKlass::cast(k);
 836     InlineKlass* vklass = vak->element_klass();
 837     base = vak->array_header_in_bytes();
 838     scale = vak->element_byte_size();
 839   } else {
 840     ShouldNotReachHere();
 841   }
 842 }
 843 
 844 UNSAFE_ENTRY(jint, Unsafe_ArrayBaseOffset0(JNIEnv *env, jobject unsafe, jclass clazz)) {
 845   int base = 0, scale = 0;
 846   getBaseAndScale(base, scale, clazz, CHECK_0);
 847 
 848   return field_offset_from_byte_offset(base);
 849 } UNSAFE_END
 850 
 851 
 852 UNSAFE_ENTRY(jint, Unsafe_ArrayIndexScale0(JNIEnv *env, jobject unsafe, jclass clazz)) {
 853   int base = 0, scale = 0;
 854   getBaseAndScale(base, scale, clazz, CHECK_0);
 855 
 856   // This VM packs both fields and array elements down to the byte.
 857   // But watch out:  If this changes, so that array references for
 858   // a given primitive type (say, T_BOOLEAN) use different memory units
 859   // than fields, this method MUST return zero for such arrays.
 860   // For example, the VM used to store sub-word sized fields in full
 861   // words in the object layout, so that accessors like getByte(Object,int)
 862   // did not really do what one might expect for arrays.  Therefore,
 863   // this function used to report a zero scale factor, so that the user
 864   // would know not to attempt to access sub-word array elements.
 865   // // Code for unpacked fields:
 866   // if (scale < wordSize)  return 0;
 867 
 868   // The following allows for a pretty general fieldOffset cookie scheme,
 869   // but requires it to be linear in byte offset.
 870   return field_offset_from_byte_offset(scale) - field_offset_from_byte_offset(0);
 871 } UNSAFE_END
 872 
 873 
 874 UNSAFE_ENTRY(jlong, Unsafe_GetObjectSize0(JNIEnv* env, jobject o, jobject obj))
 875   oop p = JNIHandles::resolve(obj);
 876   return p->size() * HeapWordSize;
 877 UNSAFE_END
 878 
 879 
 880 static inline void throw_new(JNIEnv *env, const char *ename) {
 881   jclass cls = env->FindClass(ename);
 882   if (env->ExceptionCheck()) {
 883     env->ExceptionClear();
 884     tty->print_cr("Unsafe: cannot throw %s because FindClass has failed", ename);
 885     return;
 886   }
 887 
 888   env->ThrowNew(cls, nullptr);
 889 }
 890 
 891 static jclass Unsafe_DefineClass_impl(JNIEnv *env, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd) {
 892   // Code lifted from JDK 1.3 ClassLoader.c
 893 
 894   jbyte *body;
 895   char *utfName = nullptr;
 896   jclass result = nullptr;
 897   char buf[128];
 898 
 899   assert(data != nullptr, "Class bytes must not be null");

1079 
1080 
1081 /// JVM_RegisterUnsafeMethods
1082 
1083 #define ADR "J"
1084 
1085 #define LANG "Ljava/lang/"
1086 
1087 #define OBJ LANG "Object;"
1088 #define CLS LANG "Class;"
1089 #define FLD LANG "reflect/Field;"
1090 #define THR LANG "Throwable;"
1091 
1092 #define DC_Args  LANG "String;[BII" LANG "ClassLoader;" "Ljava/security/ProtectionDomain;"
1093 #define DAC_Args CLS "[B[" OBJ
1094 
1095 #define CC (char*)  /*cast a literal from (const char*)*/
1096 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
1097 
1098 #define DECLARE_GETPUTOOP(Type, Desc) \
1099     {CC "get"  #Type,      CC "(" OBJ "J)" #Desc,                 FN_PTR(Unsafe_Get##Type)}, \
1100     {CC "put"  #Type,      CC "(" OBJ "J" #Desc ")V",             FN_PTR(Unsafe_Put##Type)}, \
1101     {CC "get"  #Type "Volatile",      CC "(" OBJ "J)" #Desc,      FN_PTR(Unsafe_Get##Type##Volatile)}, \
1102     {CC "put"  #Type "Volatile",      CC "(" OBJ "J" #Desc ")V",  FN_PTR(Unsafe_Put##Type##Volatile)}
1103 
1104 
1105 static JNINativeMethod jdk_internal_misc_Unsafe_methods[] = {
1106     {CC "getReference",         CC "(" OBJ "J)" OBJ "",   FN_PTR(Unsafe_GetReference)},
1107     {CC "putReference",         CC "(" OBJ "J" OBJ ")V",  FN_PTR(Unsafe_PutReference)},
1108     {CC "getReferenceVolatile", CC "(" OBJ "J)" OBJ,      FN_PTR(Unsafe_GetReferenceVolatile)},
1109     {CC "putReferenceVolatile", CC "(" OBJ "J" OBJ ")V",  FN_PTR(Unsafe_PutReferenceVolatile)},
1110 
1111     {CC "isFlatArray",          CC "(" CLS ")Z",          FN_PTR(Unsafe_IsFlatArray)},
1112     {CC "isFlatField0",         CC "(" OBJ ")Z",          FN_PTR(Unsafe_IsFlatField)},
1113     {CC "hasNullMarker0",       CC "(" OBJ ")Z",          FN_PTR(Unsafe_HasNullMarker)},
1114     {CC "nullMarkerOffset0",    CC "(" OBJ ")I",          FN_PTR(Unsafe_NullMarkerOffset)},
1115     {CC "arrayLayout0",         CC "(" OBJ ")I",          FN_PTR(Unsafe_ArrayLayout)},
1116     {CC "fieldLayout0",         CC "(" OBJ ")I",          FN_PTR(Unsafe_FieldLayout)},
1117     {CC "getValue",             CC "(" OBJ "J" CLS ")" OBJ, FN_PTR(Unsafe_GetValue)},
1118     {CC "getFlatValue",         CC "(" OBJ "JI" CLS ")" OBJ, FN_PTR(Unsafe_GetFlatValue)},
1119     {CC "putValue",             CC "(" OBJ "J" CLS OBJ ")V", FN_PTR(Unsafe_PutValue)},
1120     {CC "putFlatValue",         CC "(" OBJ "JI" CLS OBJ ")V", FN_PTR(Unsafe_PutFlatValue)},
1121     {CC "uninitializedDefaultValue", CC "(" CLS ")" OBJ,  FN_PTR(Unsafe_UninitializedDefaultValue)},
1122     {CC "makePrivateBuffer",     CC "(" OBJ ")" OBJ,      FN_PTR(Unsafe_MakePrivateBuffer)},
1123     {CC "finishPrivateBuffer",   CC "(" OBJ ")" OBJ,      FN_PTR(Unsafe_FinishPrivateBuffer)},
1124     {CC "valueHeaderSize",       CC "(" CLS ")J",         FN_PTR(Unsafe_ValueHeaderSize)},
1125 
1126     {CC "getUncompressedObject", CC "(" ADR ")" OBJ,  FN_PTR(Unsafe_GetUncompressedObject)},
1127 
1128     DECLARE_GETPUTOOP(Boolean, Z),
1129     DECLARE_GETPUTOOP(Byte, B),
1130     DECLARE_GETPUTOOP(Short, S),
1131     DECLARE_GETPUTOOP(Char, C),
1132     DECLARE_GETPUTOOP(Int, I),
1133     DECLARE_GETPUTOOP(Long, J),
1134     DECLARE_GETPUTOOP(Float, F),
1135     DECLARE_GETPUTOOP(Double, D),
1136 
1137     {CC "allocateMemory0",    CC "(J)" ADR,              FN_PTR(Unsafe_AllocateMemory0)},
1138     {CC "reallocateMemory0",  CC "(" ADR "J)" ADR,       FN_PTR(Unsafe_ReallocateMemory0)},
1139     {CC "freeMemory0",        CC "(" ADR ")V",           FN_PTR(Unsafe_FreeMemory0)},
1140 
1141     {CC "objectFieldOffset0", CC "(" FLD ")J",           FN_PTR(Unsafe_ObjectFieldOffset0)},
1142     {CC "objectFieldOffset1", CC "(" CLS LANG "String;)J", FN_PTR(Unsafe_ObjectFieldOffset1)},
1143     {CC "staticFieldOffset0", CC "(" FLD ")J",           FN_PTR(Unsafe_StaticFieldOffset0)},
1144     {CC "staticFieldBase0",   CC "(" FLD ")" OBJ,        FN_PTR(Unsafe_StaticFieldBase0)},
1145     {CC "ensureClassInitialized0", CC "(" CLS ")V",      FN_PTR(Unsafe_EnsureClassInitialized0)},
1146     {CC "arrayBaseOffset0",   CC "(" CLS ")I",           FN_PTR(Unsafe_ArrayBaseOffset0)},
1147     {CC "arrayIndexScale0",   CC "(" CLS ")I",           FN_PTR(Unsafe_ArrayIndexScale0)},
1148     {CC "getObjectSize0",     CC "(Ljava/lang/Object;)J", FN_PTR(Unsafe_GetObjectSize0)},
1149 
1150     {CC "defineClass0",       CC "(" DC_Args ")" CLS,    FN_PTR(Unsafe_DefineClass0)},
1151     {CC "allocateInstance",   CC "(" CLS ")" OBJ,        FN_PTR(Unsafe_AllocateInstance)},
1152     {CC "throwException",     CC "(" THR ")V",           FN_PTR(Unsafe_ThrowException)},
1153     {CC "compareAndSetReference",CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSetReference)},
1154     {CC "compareAndSetInt",   CC "(" OBJ "J""I""I"")Z",  FN_PTR(Unsafe_CompareAndSetInt)},
1155     {CC "compareAndSetLong",  CC "(" OBJ "J""J""J"")Z",  FN_PTR(Unsafe_CompareAndSetLong)},
1156     {CC "compareAndExchangeReference", CC "(" OBJ "J" OBJ "" OBJ ")" OBJ, FN_PTR(Unsafe_CompareAndExchangeReference)},
1157     {CC "compareAndExchangeInt",  CC "(" OBJ "J""I""I"")I", FN_PTR(Unsafe_CompareAndExchangeInt)},
1158     {CC "compareAndExchangeLong", CC "(" OBJ "J""J""J"")J", FN_PTR(Unsafe_CompareAndExchangeLong)},
1159 
1160     {CC "park",               CC "(ZJ)V",                FN_PTR(Unsafe_Park)},
1161     {CC "unpark",             CC "(" OBJ ")V",           FN_PTR(Unsafe_Unpark)},
1162 
1163     {CC "getLoadAverage0",    CC "([DI)I",               FN_PTR(Unsafe_GetLoadAverage0)},
1164 
1165     {CC "copyMemory0",        CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory0)},
1166     {CC "copySwapMemory0",    CC "(" OBJ "J" OBJ "JJJ)V", FN_PTR(Unsafe_CopySwapMemory0)},
1167     {CC "writeback0",         CC "(" "J" ")V",           FN_PTR(Unsafe_WriteBack0)},
1168     {CC "writebackPreSync0",  CC "()V",                  FN_PTR(Unsafe_WriteBackPreSync0)},
< prev index next >