1 /*
2 * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
643 if (size == 0) {
644 return;
645 }
646 size_t sz = (size_t)size;
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
664 ////// Random queries
665
666 // See comment at file start about UNSAFE_LEAF
667 //UNSAFE_LEAF(jint, Unsafe_AddressSize())
668 UNSAFE_ENTRY(jint, Unsafe_AddressSize(JNIEnv *env, jobject unsafe))
669 UnsafeWrapper("Unsafe_AddressSize");
670 return sizeof(void*);
671 UNSAFE_END
672
673 // See comment at file start about UNSAFE_LEAF
674 //UNSAFE_LEAF(jint, Unsafe_PageSize())
675 UNSAFE_ENTRY(jint, Unsafe_PageSize(JNIEnv *env, jobject unsafe))
676 UnsafeWrapper("Unsafe_PageSize");
677 return os::vm_page_size();
678 UNSAFE_END
679
680 jint find_field_offset(jobject field, int must_be_static, TRAPS) {
681 if (field == NULL) {
682 THROW_0(vmSymbols::java_lang_NullPointerException());
1346 {CC "arrayBaseOffset", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)},
1347 {CC "arrayIndexScale", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)},
1348 {CC "addressSize", CC "()I", FN_PTR(Unsafe_AddressSize)},
1349 {CC "pageSize", CC "()I", FN_PTR(Unsafe_PageSize)},
1350
1351 {CC "defineClass", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)},
1352 {CC "allocateInstance", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)},
1353 {CC "throwException", CC "(" THR ")V", FN_PTR(Unsafe_ThrowException)},
1354 {CC "compareAndSwapObject", CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
1355 {CC "compareAndSwapInt", CC "(" OBJ "J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
1356 {CC "compareAndSwapLong", CC "(" OBJ "J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
1357 {CC "putOrderedObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetOrderedObject)},
1358 {CC "putOrderedInt", CC "(" OBJ "JI)V", FN_PTR(Unsafe_SetOrderedInt)},
1359 {CC "putOrderedLong", CC "(" OBJ "JJ)V", FN_PTR(Unsafe_SetOrderedLong)},
1360 {CC "park", CC "(ZJ)V", FN_PTR(Unsafe_Park)},
1361 {CC "unpark", CC "(" OBJ ")V", FN_PTR(Unsafe_Unpark)},
1362
1363 {CC "getLoadAverage", CC "([DI)I", FN_PTR(Unsafe_Loadavg)},
1364
1365 {CC "copyMemory", CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory)},
1366 {CC "setMemory", CC "(" OBJ "JJB)V", FN_PTR(Unsafe_SetMemory)},
1367
1368 {CC "defineAnonymousClass", CC "(" DAC_Args ")" CLS, FN_PTR(Unsafe_DefineAnonymousClass)},
1369
1370 {CC "shouldBeInitialized",CC "(" CLS ")Z", FN_PTR(Unsafe_ShouldBeInitialized)},
1371
1372 {CC "loadFence", CC "()V", FN_PTR(Unsafe_LoadFence)},
1373 {CC "storeFence", CC "()V", FN_PTR(Unsafe_StoreFence)},
1374 {CC "fullFence", CC "()V", FN_PTR(Unsafe_FullFence)},
1375
1376 {CC "isBigEndian0", CC "()Z", FN_PTR(Unsafe_isBigEndian0)},
1377 {CC "unalignedAccess0", CC "()Z", FN_PTR(Unsafe_unalignedAccess0)}
1378 };
1379
1380 #undef CC
1381 #undef FN_PTR
1382
1383 #undef ADR
1384 #undef LANG
1385 #undef OBJ
|
1 /*
2 * Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
643 if (size == 0) {
644 return;
645 }
646 size_t sz = (size_t)size;
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
|