Skip to content

8368933: [lworld] Unsafe.arrayBaseOffset() ambiguous #1684

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 1 commit into from
+64 −55
Closed

8368933: [lworld] Unsafe.arrayBaseOffset() ambiguous #1684

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 4 additions & 4 deletions src/hotspot/share/prims/unsafe.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -903,7 +903,7 @@ static void getBaseAndScale(int& base, int& scale, jclass clazz, TRAPS) {
}
}

UNSAFE_ENTRY(jint, Unsafe_ArrayBaseOffset1(JNIEnv *env, jobject unsafe, jarray array)) {
UNSAFE_ENTRY(jint, Unsafe_ArrayInstanceBaseOffset0(JNIEnv *env, jobject unsafe, jarray array)) {
assert(array != nullptr, "array must not be null");
oop ar = JNIHandles::resolve_non_null(array);
assert(ar->is_array(), "Must be an array");
Expand Down Expand Up @@ -947,7 +947,7 @@ UNSAFE_ENTRY(jint, Unsafe_ArrayIndexScale0(JNIEnv *env, jobject unsafe, jclass c
return field_offset_from_byte_offset(scale) - field_offset_from_byte_offset(0);
} UNSAFE_END

UNSAFE_ENTRY(jint, Unsafe_ArrayIndexScale1(JNIEnv *env, jobject unsafe, jarray array)) {
UNSAFE_ENTRY(jint, Unsafe_ArrayInstanceIndexScale0(JNIEnv *env, jobject unsafe, jarray array)) {
assert(array != nullptr, "array must not be null");
oop ar = JNIHandles::resolve_non_null(array);
assert(ar->is_array(), "Must be an array");
Expand Down Expand Up @@ -1236,9 +1236,9 @@ static JNINativeMethod jdk_internal_misc_Unsafe_methods[] = {
{CC "staticFieldBase0", CC "(" FLD ")" OBJ, FN_PTR(Unsafe_StaticFieldBase0)},
{CC "ensureClassInitialized0", CC "(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized0)},
{CC "arrayBaseOffset0", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset0)},
{CC "arrayBaseOffset1", CC "(" OBJ_ARR ")I", FN_PTR(Unsafe_ArrayBaseOffset1)},
{CC "arrayInstanceBaseOffset0", CC "(" OBJ_ARR ")I", FN_PTR(Unsafe_ArrayInstanceBaseOffset0)},
{CC "arrayIndexScale0", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale0)},
{CC "arrayIndexScale1", CC "(" OBJ_ARR ")I", FN_PTR(Unsafe_ArrayIndexScale1)},
{CC "arrayInstanceIndexScale0", CC "(" OBJ_ARR ")I", FN_PTR(Unsafe_ArrayInstanceIndexScale0)},
{CC "getObjectSize0", CC "(Ljava/lang/Object;)J", FN_PTR(Unsafe_GetObjectSize0)},

{CC "defineClass0", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass0)},
Expand Down
68 changes: 34 additions & 34 deletions src/java.base/share/classes/java/lang/invoke/ArrayVarHandle.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -123,8 +123,8 @@ static Object getVolatile(VarHandle ob, Object oarray, int index) {
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.getFlatValueVolatile(array,
Expand All @@ -142,8 +142,8 @@ static void setVolatile(VarHandle ob, Object oarray, int index, Object value) {
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
UNSAFE.putFlatValueVolatile(array,
Expand All @@ -164,8 +164,8 @@ static Object getOpaque(VarHandle ob, Object oarray, int index) {
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.getFlatValueOpaque(array,
Expand All @@ -183,8 +183,8 @@ static void setOpaque(VarHandle ob, Object oarray, int index, Object value) {
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
UNSAFE.putFlatValueOpaque(array,
Expand All @@ -205,8 +205,8 @@ static Object getAcquire(VarHandle ob, Object oarray, int index) {
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.getFlatValueAcquire(array,
Expand All @@ -224,8 +224,8 @@ static void setRelease(VarHandle ob, Object oarray, int index, Object value) {
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
UNSAFE.putFlatValueRelease(array,
Expand All @@ -246,8 +246,8 @@ static boolean compareAndSet(VarHandle ob, Object oarray, int index, Object expe
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.compareAndSetFlatValue(array,
Expand All @@ -269,8 +269,8 @@ static Object compareAndExchange(VarHandle ob, Object oarray, int index, Object
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.compareAndExchangeFlatValue(array,
Expand All @@ -292,8 +292,8 @@ static Object compareAndExchangeAcquire(VarHandle ob, Object oarray, int index,
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.compareAndExchangeFlatValueAcquire(array,
Expand All @@ -315,8 +315,8 @@ static Object compareAndExchangeRelease(VarHandle ob, Object oarray, int index,
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.compareAndExchangeFlatValueRelease(array,
Expand All @@ -338,8 +338,8 @@ static boolean weakCompareAndSetPlain(VarHandle ob, Object oarray, int index, Ob
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.weakCompareAndSetFlatValuePlain(array,
Expand All @@ -361,8 +361,8 @@ static boolean weakCompareAndSet(VarHandle ob, Object oarray, int index, Object
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.weakCompareAndSetFlatValue(array,
Expand All @@ -384,8 +384,8 @@ static boolean weakCompareAndSetAcquire(VarHandle ob, Object oarray, int index,
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.weakCompareAndSetFlatValueAcquire(array,
Expand All @@ -407,8 +407,8 @@ static boolean weakCompareAndSetRelease(VarHandle ob, Object oarray, int index,
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.weakCompareAndSetFlatValueRelease(array,
Expand All @@ -430,8 +430,8 @@ static Object getAndSet(VarHandle ob, Object oarray, int index, Object value) {
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.getAndSetFlatValue(array,
Expand All @@ -451,8 +451,8 @@ static Object getAndSetAcquire(VarHandle ob, Object oarray, int index, Object va
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.getAndSetFlatValueAcquire(array,
Expand All @@ -472,8 +472,8 @@ static Object getAndSetRelease(VarHandle ob, Object oarray, int index, Object va
if (ValueClass.isFlatArray(oarray)) {
// delegate to flat access primitives
VarHandles.checkAtomicFlatArray(array);
int aoffset = (int) UNSAFE.arrayBaseOffset(array);
int ascale = UNSAFE.arrayIndexScale(array);
int aoffset = (int) UNSAFE.arrayInstanceBaseOffset(array);
int ascale = UNSAFE.arrayInstanceIndexScale(array);
int ashift = 31 - Integer.numberOfLeadingZeros(ascale);
int layout = UNSAFE.arrayLayout(array);
return UNSAFE.getAndSetFlatValueRelease(array,
Expand Down
26 changes: 18 additions & 8 deletions src/java.base/share/classes/jdk/internal/misc/Unsafe.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1421,6 +1421,11 @@ public void notifyStrictStaticAccess(Class<?> c, long staticFieldOffset, boolean
* The return value is in the range of a {@code int}. The return type is
* {@code long} to emphasize that long arithmetic should always be used
* for offset calculations to avoid overflows.
* <p>
* This method doesn't support arrays with an element type that is
* a value class, because this type of array can have multiple layouts.
* For these arrays, {@code arrayInstanceBaseOffset(Object[] array)}
* must be used instead.
*
* @see #getInt(Object, long)
* @see #putInt(Object, long, int)
Expand All @@ -1433,12 +1438,12 @@ public long arrayBaseOffset(Class<?> arrayClass) {
return arrayBaseOffset0(arrayClass);
}

public long arrayBaseOffset(Object[] array) {
public long arrayInstanceBaseOffset(Object[] array) {
if (array == null) {
throw new NullPointerException();
}

return arrayBaseOffset1(array);
return arrayInstanceBaseOffset0(array);
}

/** The value of {@code arrayBaseOffset(boolean[].class)} */
Expand Down Expand Up @@ -1486,6 +1491,11 @@ public long arrayBaseOffset(Object[] array) {
* <p>
* The computation of the actual memory offset should always use {@code
* long} arithmetic to avoid overflows.
* <p>
* This method doesn't support arrays with an element type that is
* a value class, because this type of array can have multiple layouts.
* For these arrays, {@code arrayInstanceIndexScale(Object[] array)}
* must be used instead.
*
* @see #arrayBaseOffset
* @see #getInt(Object, long)
Expand All @@ -1499,12 +1509,12 @@ public int arrayIndexScale(Class<?> arrayClass) {
return arrayIndexScale0(arrayClass);
}

public int arrayIndexScale(Object[] array) {
public int arrayInstanceIndexScale(Object[] array) {
if (array == null) {
throw new NullPointerException();
}

return arrayIndexScale1(array);
return arrayInstanceIndexScale0(array);
}

/**
Expand Down Expand Up @@ -2904,8 +2914,8 @@ private boolean compareAndSetFlatValueAsBytes(Object o, long offset, int layout,
// (see VarHandles::isAtomicFlat).
Object[] expectedArray = newSpecialArray(valueType, 1, layout);
Object xArray = newSpecialArray(valueType, 1, layout);
long base = arrayBaseOffset(expectedArray);
int scale = arrayIndexScale(expectedArray);
long base = arrayInstanceBaseOffset(expectedArray);
int scale = arrayInstanceIndexScale(expectedArray);
putFlatValue(expectedArray, base, layout, valueType, expected);
putFlatValue(xArray, base, layout, valueType, x);
switch (scale) {
Expand Down Expand Up @@ -4434,9 +4444,9 @@ private void putShortParts(Object o, long offset, byte i0, byte i1) {
private native void ensureClassInitialized0(Class<?> c);
private native void notifyStrictStaticAccess0(Class<?> c, long staticFieldOffset, boolean writing);
private native int arrayBaseOffset0(Class<?> arrayClass); // public version returns long to promote correct arithmetic
private native int arrayBaseOffset1(Object[] array);
private native int arrayInstanceBaseOffset0(Object[] array);
private native int arrayIndexScale0(Class<?> arrayClass);
private native int arrayIndexScale1(Object[] array);
private native int arrayInstanceIndexScale0(Object[] array);
private native long getObjectSize0(Object o);
private native int getLoadAverage0(double[] loadavg, int nelems);

Expand Down
8 changes: 4 additions & 4 deletions test/hotspot/jtreg/compiler/valhalla/inlinetypes/TestIntrinsics.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -649,8 +649,8 @@ public void test32_verifier() {
static {
try {
TEST33_ARRAY = (MyValue1[])ValueClass.newNullRestrictedNonAtomicArray(MyValue1.class, 2, MyValue1.DEFAULT);
TEST33_BASE_OFFSET = U.arrayBaseOffset(TEST33_ARRAY);
TEST33_INDEX_SCALE = U.arrayIndexScale(TEST33_ARRAY);
TEST33_BASE_OFFSET = U.arrayInstanceBaseOffset(TEST33_ARRAY);
TEST33_INDEX_SCALE = U.arrayInstanceIndexScale(TEST33_ARRAY);
TEST33_FLATTENED_ARRAY = ValueClass.isFlatArray(TEST33_ARRAY);
TEST33_LAYOUT = U.arrayLayout(TEST33_ARRAY);
} catch (Exception e) {
Expand Down Expand Up @@ -1257,8 +1257,8 @@ public void test63_verifier() {
static {
try {
TEST64_ARRAY = (SmallValue[])ValueClass.newNullRestrictedAtomicArray(SmallValue.class, 2, SmallValue.DEFAULT);
TEST64_BASE_OFFSET = U.arrayBaseOffset(TEST64_ARRAY);
TEST64_INDEX_SCALE = U.arrayIndexScale(TEST64_ARRAY);
TEST64_BASE_OFFSET = U.arrayInstanceBaseOffset(TEST64_ARRAY);
TEST64_INDEX_SCALE = U.arrayInstanceIndexScale(TEST64_ARRAY);
TEST64_FLATTENED_ARRAY = ValueClass.isFlatArray(TEST64_ARRAY);
TEST64_ATOMIC_ARRAY = ValueClass.isAtomicArray(TEST64_ARRAY);
TEST64_LAYOUT = U.arrayLayout(TEST64_ARRAY);
Expand Down
8 changes: 4 additions & 4 deletions test/hotspot/jtreg/runtime/valhalla/inlinetypes/UnsafeTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -301,8 +301,8 @@ public static void testNullableFlatArrays() throws Throwable {
final int ARRAY_LENGTH = 10;
TestValue1[] array = (TestValue1[])ValueClass.newNullableAtomicArray(TestValue1.class, ARRAY_LENGTH);
Asserts.assertTrue(ValueClass.isFlatArray(array));
long baseOffset = U.arrayBaseOffset(array);
int scaleIndex = U.arrayIndexScale(array);
long baseOffset = U.arrayInstanceBaseOffset(array);
int scaleIndex = U.arrayInstanceIndexScale(array);
for (int i = 0; i < ARRAY_LENGTH; i++) {
Asserts.assertNull(U.getValue(array, baseOffset + i * scaleIndex, TestValue1.class));
}
Expand Down Expand Up @@ -356,8 +356,8 @@ public static void testNullableFlatArrays() throws Throwable {
public static void testNullableFlatArrays2() throws Throwable {
final int ARRAY_LENGTH = 10;
TestValue1[] array = (TestValue1[])ValueClass.newNullableAtomicArray(TestValue1.class, ARRAY_LENGTH);
long baseOffset = U.arrayBaseOffset(array);
int scaleIndex = U.arrayIndexScale(array);
long baseOffset = U.arrayInstanceBaseOffset(array);
int scaleIndex = U.arrayInstanceIndexScale(array);
int layoutKind = U.arrayLayout(array);
for (int i = 0; i < ARRAY_LENGTH; i++) {
Asserts.assertNull(U.getFlatValue(array, baseOffset + i * scaleIndex, layoutKind, TestValue1.class));
Expand Down
Loading