647 if (sz != (julong)size || size < 0) {
648 THROW(vmSymbols::java_lang_IllegalArgumentException());
649 }
650 oop srcp = JNIHandles::resolve(srcObj);
651 oop dstp = JNIHandles::resolve(dstObj);
652 if (dstp != NULL && !dstp->is_typeArray()) {
653 // NYI: This works only for non-oop arrays at present.
654 // Generalizing it would be reasonable, but requires card marking.
655 // Also, autoboxing a Long from 0L in copyMemory(x,y, 0L,z, n) would be bad.
656 THROW(vmSymbols::java_lang_IllegalArgumentException());
657 }
658 void* src = index_oop_from_field_offset_long(srcp, srcOffset);
659 void* dst = index_oop_from_field_offset_long(dstp, dstOffset);
660 Copy::conjoint_memory_atomic(src, dst, sz);
661 UNSAFE_END
662
663 // This function is a leaf since if the source and destination are both in native memory
664 // the copy may potentially be very large, and we don't want to disable GC if we can avoid it.
665 // If either source or destination (or both) are on the heap, the function will enter VM using
666 // JVM_ENTRY_FROM_LEAF
667 JVM_LEAF(void, Unsafe_CopySwapMemory(JNIEnv *env, jobject unsafe, jobject srcObj, jlong srcOffset, jobject dstObj, jlong dstOffset, jlong size, jlong elemSize))
668 UnsafeWrapper("Unsafe_CopySwapMemory");
669 if (size == 0) {
670 return;
671 }
672
673 size_t sz = (size_t)size;
674 if (sz != (julong)size || size < 0) {
675 JVM_ENTRY_FROM_LEAF(env, void, Unsafe_CopySwapMemory) {
676 THROW(vmSymbols::java_lang_IllegalArgumentException());
677 } JVM_END
678 }
679
680 size_t esz = (size_t)elemSize;
681 if (esz != 2 && esz != 4 && esz != 8) {
682 JVM_ENTRY_FROM_LEAF(env, void, Unsafe_CopySwapMemory) {
683 THROW(vmSymbols::java_lang_IllegalArgumentException());
684 } JVM_END
685 }
686
687 if (!is_size_aligned(sz, esz)) {
688 JVM_ENTRY_FROM_LEAF(env, void, Unsafe_CopySwapMemory) {
689 THROW(vmSymbols::java_lang_IllegalArgumentException());
690 } JVM_END
691 }
692
693 if (srcObj == NULL && dstObj == NULL) {
694 // Both src & dst are in native memory
695 address src = (address)srcOffset;
696 address dst = (address)dstOffset;
697
698 if (src == NULL || dst == NULL) {
699 JVM_ENTRY_FROM_LEAF(env, void, Unsafe_CopySwapMemory) {
700 THROW(vmSymbols::java_lang_NullPointerException());
701 } JVM_END
702 }
703
704 Copy::conjoint_swap(src, dst, sz, esz);
705 } else {
706 // At least one of src/dst are on heap, transition to VM to access raw pointers
707
708 JVM_ENTRY_FROM_LEAF(env, void, Unsafe_CopySwapMemory) {
709 oop srcp = JNIHandles::resolve(srcObj);
710 oop dstp = JNIHandles::resolve(dstObj);
711
712 if (dstp != NULL && !dstp->is_typeArray()) {
713 // NYI: This works only for non-oop arrays at present.
714 // Generalizing it would be reasonable, but requires card marking.
715 // Also, autoboxing a Long from 0L in copyMemory(x,y, 0L,z, n) would be bad.
716 THROW(vmSymbols::java_lang_IllegalArgumentException());
717 }
718
719 address src = (address)index_oop_from_field_offset_long(srcp, srcOffset);
720 address dst = (address)index_oop_from_field_offset_long(dstp, dstOffset);
721
722 Copy::conjoint_swap(src, dst, sz, esz);
723 } JVM_END
724 }
725 JVM_END
726
727
728 ////// Random queries
729
730 // See comment at file start about UNSAFE_LEAF
731 //UNSAFE_LEAF(jint, Unsafe_AddressSize())
732 UNSAFE_ENTRY(jint, Unsafe_AddressSize(JNIEnv *env, jobject unsafe))
733 UnsafeWrapper("Unsafe_AddressSize");
734 return sizeof(void*);
735 UNSAFE_END
736
737 // See comment at file start about UNSAFE_LEAF
738 //UNSAFE_LEAF(jint, Unsafe_PageSize())
739 UNSAFE_ENTRY(jint, Unsafe_PageSize(JNIEnv *env, jobject unsafe))
740 UnsafeWrapper("Unsafe_PageSize");
741 return os::vm_page_size();
742 UNSAFE_END
743
744 jint find_field_offset(jobject field, int must_be_static, TRAPS) {
745 if (field == NULL) {
746 THROW_0(vmSymbols::java_lang_NullPointerException());
1410 {CC "arrayBaseOffset", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1411 {CC "arrayIndexScale", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)},
1412 {CC "addressSize", CC "()I", FN_PTR(Unsafe_AddressSize)},
1413 {CC "pageSize", CC "()I", FN_PTR(Unsafe_PageSize)},
1414
1415 {CC "defineClass", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)},
1416 {CC "allocateInstance", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)},
1417 {CC "throwException", CC "(" THR ")V", FN_PTR(Unsafe_ThrowException)},
1418 {CC "compareAndSwapObject", CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
1419 {CC "compareAndSwapInt", CC "(" OBJ "J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
1420 {CC "compareAndSwapLong", CC "(" OBJ "J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
1421 {CC "putOrderedObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetOrderedObject)},
1422 {CC "putOrderedInt", CC "(" OBJ "JI)V", FN_PTR(Unsafe_SetOrderedInt)},
1423 {CC "putOrderedLong", CC "(" OBJ "JJ)V", FN_PTR(Unsafe_SetOrderedLong)},
1424 {CC "park", CC "(ZJ)V", FN_PTR(Unsafe_Park)},
1425 {CC "unpark", CC "(" OBJ ")V", FN_PTR(Unsafe_Unpark)},
1426
1427 {CC "getLoadAverage", CC "([DI)I", FN_PTR(Unsafe_Loadavg)},
1428
1429 {CC "copyMemory", CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory)},
1430 {CC "copySwapMemory", CC "(" OBJ "J" OBJ "JJJ)V", FN_PTR(Unsafe_CopySwapMemory)},
1431 {CC "setMemory", CC "(" OBJ "JJB)V", FN_PTR(Unsafe_SetMemory)},
1432
1433 {CC "defineAnonymousClass", CC "(" DAC_Args ")" CLS, FN_PTR(Unsafe_DefineAnonymousClass)},
1434
1435 {CC "shouldBeInitialized",CC "(" CLS ")Z", FN_PTR(Unsafe_ShouldBeInitialized)},
1436
1437 {CC "loadFence", CC "()V", FN_PTR(Unsafe_LoadFence)},
1438 {CC "storeFence", CC "()V", FN_PTR(Unsafe_StoreFence)},
1439 {CC "fullFence", CC "()V", FN_PTR(Unsafe_FullFence)},
1440
1441 {CC "isBigEndian0", CC "()Z", FN_PTR(Unsafe_isBigEndian0)},
1442 {CC "unalignedAccess0", CC "()Z", FN_PTR(Unsafe_unalignedAccess0)}
1443 };
1444
1445 #undef CC
1446 #undef FN_PTR
1447
1448 #undef ADR
1449 #undef LANG
1450 #undef OBJ
|
647 if (sz != (julong)size || size < 0) {
648 THROW(vmSymbols::java_lang_IllegalArgumentException());
649 }
650 oop srcp = JNIHandles::resolve(srcObj);
651 oop dstp = JNIHandles::resolve(dstObj);
652 if (dstp != NULL && !dstp->is_typeArray()) {
653 // NYI: This works only for non-oop arrays at present.
654 // Generalizing it would be reasonable, but requires card marking.
655 // Also, autoboxing a Long from 0L in copyMemory(x,y, 0L,z, n) would be bad.
656 THROW(vmSymbols::java_lang_IllegalArgumentException());
657 }
658 void* src = index_oop_from_field_offset_long(srcp, srcOffset);
659 void* dst = index_oop_from_field_offset_long(dstp, dstOffset);
660 Copy::conjoint_memory_atomic(src, dst, sz);
661 UNSAFE_END
662
663 // This function is a leaf since if the source and destination are both in native memory
664 // the copy may potentially be very large, and we don't want to disable GC if we can avoid it.
665 // If either source or destination (or both) are on the heap, the function will enter VM using
666 // JVM_ENTRY_FROM_LEAF
667 JVM_LEAF(void, Unsafe_CopySwapMemory0(JNIEnv *env, jobject unsafe, jobject srcObj, jlong srcOffset, jobject dstObj, jlong dstOffset, jlong size, jlong elemSize)) {
668 UnsafeWrapper("Unsafe_CopySwapMemory0");
669
670 size_t sz = (size_t)size;
671 size_t esz = (size_t)elemSize;
672
673 if (srcObj == NULL && dstObj == NULL) {
674 // Both src & dst are in native memory
675 address src = (address)srcOffset;
676 address dst = (address)dstOffset;
677
678 Copy::conjoint_swap(src, dst, sz, esz);
679 } else {
680 // At least one of src/dst are on heap, transition to VM to access raw pointers
681
682 JVM_ENTRY_FROM_LEAF(env, void, Unsafe_CopySwapMemory0) {
683 oop srcp = JNIHandles::resolve(srcObj);
684 oop dstp = JNIHandles::resolve(dstObj);
685
686 address src = (address)index_oop_from_field_offset_long(srcp, srcOffset);
687 address dst = (address)index_oop_from_field_offset_long(dstp, dstOffset);
688
689 Copy::conjoint_swap(src, dst, sz, esz);
690 } JVM_END
691 }
692 } JVM_END
693
694 ////// Random queries
695
696 // See comment at file start about UNSAFE_LEAF
697 //UNSAFE_LEAF(jint, Unsafe_AddressSize())
698 UNSAFE_ENTRY(jint, Unsafe_AddressSize(JNIEnv *env, jobject unsafe))
699 UnsafeWrapper("Unsafe_AddressSize");
700 return sizeof(void*);
701 UNSAFE_END
702
703 // See comment at file start about UNSAFE_LEAF
704 //UNSAFE_LEAF(jint, Unsafe_PageSize())
705 UNSAFE_ENTRY(jint, Unsafe_PageSize(JNIEnv *env, jobject unsafe))
706 UnsafeWrapper("Unsafe_PageSize");
707 return os::vm_page_size();
708 UNSAFE_END
709
710 jint find_field_offset(jobject field, int must_be_static, TRAPS) {
711 if (field == NULL) {
712 THROW_0(vmSymbols::java_lang_NullPointerException());
1376 {CC "arrayBaseOffset", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1377 {CC "arrayIndexScale", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)},
1378 {CC "addressSize", CC "()I", FN_PTR(Unsafe_AddressSize)},
1379 {CC "pageSize", CC "()I", FN_PTR(Unsafe_PageSize)},
1380
1381 {CC "defineClass", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)},
1382 {CC "allocateInstance", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)},
1383 {CC "throwException", CC "(" THR ")V", FN_PTR(Unsafe_ThrowException)},
1384 {CC "compareAndSwapObject", CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
1385 {CC "compareAndSwapInt", CC "(" OBJ "J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
1386 {CC "compareAndSwapLong", CC "(" OBJ "J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
1387 {CC "putOrderedObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetOrderedObject)},
1388 {CC "putOrderedInt", CC "(" OBJ "JI)V", FN_PTR(Unsafe_SetOrderedInt)},
1389 {CC "putOrderedLong", CC "(" OBJ "JJ)V", FN_PTR(Unsafe_SetOrderedLong)},
1390 {CC "park", CC "(ZJ)V", FN_PTR(Unsafe_Park)},
1391 {CC "unpark", CC "(" OBJ ")V", FN_PTR(Unsafe_Unpark)},
1392
1393 {CC "getLoadAverage", CC "([DI)I", FN_PTR(Unsafe_Loadavg)},
1394
1395 {CC "copyMemory", CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory)},
1396 {CC "copySwapMemory0", CC "(" OBJ "J" OBJ "JJJ)V", FN_PTR(Unsafe_CopySwapMemory0)},
1397 {CC "setMemory", CC "(" OBJ "JJB)V", FN_PTR(Unsafe_SetMemory)},
1398
1399 {CC "defineAnonymousClass", CC "(" DAC_Args ")" CLS, FN_PTR(Unsafe_DefineAnonymousClass)},
1400
1401 {CC "shouldBeInitialized",CC "(" CLS ")Z", FN_PTR(Unsafe_ShouldBeInitialized)},
1402
1403 {CC "loadFence", CC "()V", FN_PTR(Unsafe_LoadFence)},
1404 {CC "storeFence", CC "()V", FN_PTR(Unsafe_StoreFence)},
1405 {CC "fullFence", CC "()V", FN_PTR(Unsafe_FullFence)},
1406
1407 {CC "isBigEndian0", CC "()Z", FN_PTR(Unsafe_isBigEndian0)},
1408 {CC "unalignedAccess0", CC "()Z", FN_PTR(Unsafe_unalignedAccess0)}
1409 };
1410
1411 #undef CC
1412 #undef FN_PTR
1413
1414 #undef ADR
1415 #undef LANG
1416 #undef OBJ
|