diff --git a/src/java.base/share/classes/java/lang/foreign/ValueLayout.java b/src/java.base/share/classes/java/lang/foreign/ValueLayout.java
index 73111ac2ef3..923706d8e71 100644
--- a/src/java.base/share/classes/java/lang/foreign/ValueLayout.java
+++ b/src/java.base/share/classes/java/lang/foreign/ValueLayout.java
@@ -543,13 +543,15 @@ public OfAddress withOrder(ByteOrder order) {
/**
* A value layout constant whose size is the same as that of a machine address ({@code size_t}),
- * bit alignment set to 8, and byte order set to {@link ByteOrder#nativeOrder()}.
+ * bit alignment set to {@code sizeof(size_t) * 8}, and byte order set to {@link ByteOrder#nativeOrder()}.
* Equivalent to the following code:
* {@snippet lang=java :
- * MemoryLayout.valueLayout(MemoryAddress.class, ByteOrder.nativeOrder()).withBitAlignment(8);
+ * MemoryLayout.valueLayout(MemoryAddress.class, ByteOrder.nativeOrder())
+ * .withBitAlignment(<address size>);
* }
*/
- public static final OfAddress ADDRESS = new OfAddress(ByteOrder.nativeOrder()).withBitAlignment(8);
+ public static final OfAddress ADDRESS = new OfAddress(ByteOrder.nativeOrder())
+ .withBitAlignment(ValueLayout.ADDRESS_SIZE_BITS);
/**
* A value layout constant whose size is the same as that of a Java {@code byte},
@@ -573,62 +575,62 @@ public OfAddress withOrder(ByteOrder order) {
/**
* A value layout constant whose size is the same as that of a Java {@code char},
- * bit alignment set to 8, and byte order set to {@link ByteOrder#nativeOrder()}.
+ * bit alignment set to 16, and byte order set to {@link ByteOrder#nativeOrder()}.
* Equivalent to the following code:
* {@snippet lang=java :
- * MemoryLayout.valueLayout(char.class, ByteOrder.nativeOrder()).withBitAlignment(8);
+ * MemoryLayout.valueLayout(char.class, ByteOrder.nativeOrder()).withBitAlignment(16);
* }
*/
- public static final OfChar JAVA_CHAR = new OfChar(ByteOrder.nativeOrder()).withBitAlignment(8);
+ public static final OfChar JAVA_CHAR = new OfChar(ByteOrder.nativeOrder()).withBitAlignment(16);
/**
* A value layout constant whose size is the same as that of a Java {@code short},
- * bit alignment set to 8, and byte order set to {@link ByteOrder#nativeOrder()}.
+ * bit alignment set to 16, and byte order set to {@link ByteOrder#nativeOrder()}.
* Equivalent to the following code:
* {@snippet lang=java :
- * MemoryLayout.valueLayout(short.class, ByteOrder.nativeOrder()).withBitAlignment(8);
+ * MemoryLayout.valueLayout(short.class, ByteOrder.nativeOrder()).withBitAlignment(16);
* }
*/
- public static final OfShort JAVA_SHORT = new OfShort(ByteOrder.nativeOrder()).withBitAlignment(8);
+ public static final OfShort JAVA_SHORT = new OfShort(ByteOrder.nativeOrder()).withBitAlignment(16);
/**
* A value layout constant whose size is the same as that of a Java {@code int},
- * bit alignment set to 8, and byte order set to {@link ByteOrder#nativeOrder()}.
+ * bit alignment set to 32, and byte order set to {@link ByteOrder#nativeOrder()}.
* Equivalent to the following code:
* {@snippet lang=java :
- * MemoryLayout.valueLayout(int.class, ByteOrder.nativeOrder()).withBitAlignment(8);
+ * MemoryLayout.valueLayout(int.class, ByteOrder.nativeOrder()).withBitAlignment(32);
* }
*/
- public static final OfInt JAVA_INT = new OfInt(ByteOrder.nativeOrder()).withBitAlignment(8);
+ public static final OfInt JAVA_INT = new OfInt(ByteOrder.nativeOrder()).withBitAlignment(32);
/**
* A value layout constant whose size is the same as that of a Java {@code long},
- * bit alignment set to 8, and byte order set to {@link ByteOrder#nativeOrder()}.
+ * bit alignment set to 64, and byte order set to {@link ByteOrder#nativeOrder()}.
* Equivalent to the following code:
* {@snippet lang=java :
- * MemoryLayout.valueLayout(long.class, ByteOrder.nativeOrder()).withBitAlignment(8);
+ * MemoryLayout.valueLayout(long.class, ByteOrder.nativeOrder()).withBitAlignment(64);
* }
*/
public static final OfLong JAVA_LONG = new OfLong(ByteOrder.nativeOrder())
- .withBitAlignment(8);
+ .withBitAlignment(64);
/**
* A value layout constant whose size is the same as that of a Java {@code float},
- * bit alignment set to 8, and byte order set to {@link ByteOrder#nativeOrder()}.
+ * bit alignment set to 32, and byte order set to {@link ByteOrder#nativeOrder()}.
* Equivalent to the following code:
* {@snippet lang=java :
- * MemoryLayout.valueLayout(float.class, ByteOrder.nativeOrder()).withBitAlignment(8);
+ * MemoryLayout.valueLayout(float.class, ByteOrder.nativeOrder()).withBitAlignment(32);
* }
*/
- public static final OfFloat JAVA_FLOAT = new OfFloat(ByteOrder.nativeOrder()).withBitAlignment(8);
+ public static final OfFloat JAVA_FLOAT = new OfFloat(ByteOrder.nativeOrder()).withBitAlignment(32);
/**
* A value layout constant whose size is the same as that of a Java {@code double},
- * bit alignment set to 8, and byte order set to {@link ByteOrder#nativeOrder()}.
+ * bit alignment set to 64, and byte order set to {@link ByteOrder#nativeOrder()}.
* Equivalent to the following code:
* {@snippet lang=java :
- * MemoryLayout.valueLayout(double.class, ByteOrder.nativeOrder()).withBitAlignment(8);
+ * MemoryLayout.valueLayout(double.class, ByteOrder.nativeOrder()).withBitAlignment(64);
* }
*/
- public static final OfDouble JAVA_DOUBLE = new OfDouble(ByteOrder.nativeOrder()).withBitAlignment(8);
+ public static final OfDouble JAVA_DOUBLE = new OfDouble(ByteOrder.nativeOrder()).withBitAlignment(64);
}
diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/BindingSpecializer.java b/src/java.base/share/classes/jdk/internal/foreign/abi/BindingSpecializer.java
index 73611a2c57f..82f37260092 100644
--- a/src/java.base/share/classes/jdk/internal/foreign/abi/BindingSpecializer.java
+++ b/src/java.base/share/classes/jdk/internal/foreign/abi/BindingSpecializer.java
@@ -62,6 +62,15 @@
import java.util.List;
import java.util.function.BiPredicate;
+import static java.lang.foreign.ValueLayout.ADDRESS;
+import static java.lang.foreign.ValueLayout.JAVA_BOOLEAN;
+import static java.lang.foreign.ValueLayout.JAVA_BYTE;
+import static java.lang.foreign.ValueLayout.JAVA_CHAR;
+import static java.lang.foreign.ValueLayout.JAVA_DOUBLE;
+import static java.lang.foreign.ValueLayout.JAVA_FLOAT;
+import static java.lang.foreign.ValueLayout.JAVA_INT;
+import static java.lang.foreign.ValueLayout.JAVA_LONG;
+import static java.lang.foreign.ValueLayout.JAVA_SHORT;
import static java.lang.invoke.MethodType.methodType;
import static jdk.internal.org.objectweb.asm.Opcodes.*;
@@ -698,29 +707,29 @@ private void emitAllocateCall(long size, long alignment) {
private Class<?> emitLoadLayoutConstant(Class<?> type) {
Class<?> valueLayoutType = valueLayoutTypeFor(type);
String valueLayoutConstantName = valueLayoutConstantFor(type);
- emitGetStatic(ValueLayout.class, valueLayoutConstantName, valueLayoutType.descriptorString());
+ emitGetStatic(BindingSpecializer.class, valueLayoutConstantName, valueLayoutType.descriptorString());
return valueLayoutType;
}
private static String valueLayoutConstantFor(Class<?> type) {
if (type == boolean.class) {
- return "JAVA_BOOLEAN";
+ return "JAVA_BOOLEAN_UNALIGNED";
} else if (type == byte.class) {
- return "JAVA_BYTE";
+ return "JAVA_BYTE_UNALIGNED";
} else if (type == short.class) {
- return "JAVA_SHORT";
+ return "JAVA_SHORT_UNALIGNED";
} else if (type == char.class) {
- return "JAVA_CHAR";
+ return "JAVA_CHAR_UNALIGNED";
} else if (type == int.class) {
- return "JAVA_INT";
+ return "JAVA_INT_UNALIGNED";
} else if (type == long.class) {
- return "JAVA_LONG";
+ return "JAVA_LONG_UNALIGNED";
} else if (type == float.class) {
- return "JAVA_FLOAT";
+ return "JAVA_FLOAT_UNALIGNED";
} else if (type == double.class) {
- return "JAVA_DOUBLE";
+ return "JAVA_DOUBLE_UNALIGNED";
} else if (type == MemoryAddress.class) {
- return "ADDRESS";
+ return "ADDRESS_UNALIGNED";
} else {
throw new IllegalStateException("Unknown type: " + type);
}
@@ -946,4 +955,15 @@ static BasicType of(Class<?> cls) {
}
}
}
+
+ // unaligned constants
+ public final static ValueLayout.OfBoolean JAVA_BOOLEAN_UNALIGNED = JAVA_BOOLEAN;
+ public final static ValueLayout.OfByte JAVA_BYTE_UNALIGNED = JAVA_BYTE;
+ public final static ValueLayout.OfShort JAVA_SHORT_UNALIGNED = JAVA_SHORT.withBitAlignment(8);
+ public final static ValueLayout.OfChar JAVA_CHAR_UNALIGNED = JAVA_CHAR.withBitAlignment(8);
+ public final static ValueLayout.OfInt JAVA_INT_UNALIGNED = JAVA_INT.withBitAlignment(8);
+ public final static ValueLayout.OfLong JAVA_LONG_UNALIGNED = JAVA_LONG.withBitAlignment(8);
+ public final static ValueLayout.OfFloat JAVA_FLOAT_UNALIGNED = JAVA_FLOAT.withBitAlignment(8);
+ public final static ValueLayout.OfDouble JAVA_DOUBLE_UNALIGNED = JAVA_DOUBLE.withBitAlignment(8);
+ public final static ValueLayout.OfAddress ADDRESS_UNALIGNED = ADDRESS.withBitAlignment(8);
}
diff --git a/test/jdk/java/foreign/TestArrayCopy.java b/test/jdk/java/foreign/TestArrayCopy.java
index 0ae4edd41b5..fd6b5b8a2cd 100644
--- a/test/jdk/java/foreign/TestArrayCopy.java
+++ b/test/jdk/java/foreign/TestArrayCopy.java
@@ -326,8 +326,9 @@ abstract static class CopyHelper<X, L extends ValueLayout> {
final L elementLayout;
final Class<?> carrier;
+ @SuppressWarnings("unchecked")
public CopyHelper(L elementLayout, Class<X> carrier) {
- this.elementLayout = elementLayout;
+ this.elementLayout = (L)elementLayout.withBitAlignment(8);
this.carrier = carrier;
}
diff --git a/test/jdk/java/foreign/TestByteBuffer.java b/test/jdk/java/foreign/TestByteBuffer.java
index 15f3c6c337f..548a244728e 100644
--- a/test/jdk/java/foreign/TestByteBuffer.java
+++ b/test/jdk/java/foreign/TestByteBuffer.java
@@ -37,6 +37,7 @@
import java.io.File;
import java.io.IOException;
+import java.lang.foreign.ValueLayout;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
@@ -107,39 +108,26 @@ public class TestByteBuffer {
}
}
+ static final ValueLayout.OfChar BB_CHAR = JAVA_CHAR.withOrder(ByteOrder.BIG_ENDIAN).withBitAlignment(8);
+ static final ValueLayout.OfShort BB_SHORT = JAVA_SHORT.withOrder(ByteOrder.BIG_ENDIAN).withBitAlignment(8);
+ static final ValueLayout.OfInt BB_INT = JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN).withBitAlignment(8);
+ static final ValueLayout.OfLong BB_LONG = JAVA_LONG.withOrder(ByteOrder.BIG_ENDIAN).withBitAlignment(8);
+ static final ValueLayout.OfFloat BB_FLOAT = JAVA_FLOAT.withOrder(ByteOrder.BIG_ENDIAN).withBitAlignment(8);
+ static final ValueLayout.OfDouble BB_DOUBLE = JAVA_DOUBLE.withOrder(ByteOrder.BIG_ENDIAN).withBitAlignment(8);
+
static SequenceLayout tuples = MemoryLayout.sequenceLayout(500,
MemoryLayout.structLayout(
- JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN).withName("index"),
- JAVA_FLOAT.withOrder(ByteOrder.BIG_ENDIAN).withName("value")
+ BB_INT.withName("index"),
+ BB_FLOAT.withName("value")
));
- static SequenceLayout bytes = MemoryLayout.sequenceLayout(100,
- JAVA_BYTE
- );
-
- static SequenceLayout chars = MemoryLayout.sequenceLayout(100,
- JAVA_CHAR.withOrder(ByteOrder.BIG_ENDIAN)
- );
-
- static SequenceLayout shorts = MemoryLayout.sequenceLayout(100,
- JAVA_SHORT.withOrder(ByteOrder.BIG_ENDIAN)
- );
-
- static SequenceLayout ints = MemoryLayout.sequenceLayout(100,
- JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN)
- );
-
- static SequenceLayout floats = MemoryLayout.sequenceLayout(100,
- JAVA_FLOAT.withOrder(ByteOrder.BIG_ENDIAN)
- );
-
- static SequenceLayout longs = MemoryLayout.sequenceLayout(100,
- JAVA_LONG.withOrder(ByteOrder.BIG_ENDIAN)
- );
-
- static SequenceLayout doubles = MemoryLayout.sequenceLayout(100,
- JAVA_DOUBLE.withOrder(ByteOrder.BIG_ENDIAN)
- );
+ static SequenceLayout bytes = MemoryLayout.sequenceLayout(100, JAVA_BYTE);
+ static SequenceLayout chars = MemoryLayout.sequenceLayout(100, BB_CHAR);
+ static SequenceLayout shorts = MemoryLayout.sequenceLayout(100, BB_SHORT);
+ static SequenceLayout ints = MemoryLayout.sequenceLayout(100, BB_INT);
+ static SequenceLayout floats = MemoryLayout.sequenceLayout(100, BB_FLOAT);
+ static SequenceLayout longs = MemoryLayout.sequenceLayout(100, BB_LONG);
+ static SequenceLayout doubles = MemoryLayout.sequenceLayout(100, BB_DOUBLE);
static VarHandle indexHandle = tuples.varHandle(PathElement.sequenceElement(), PathElement.groupElement("index"));
static VarHandle valueHandle = tuples.varHandle(PathElement.sequenceElement(), PathElement.groupElement("value"));
@@ -840,32 +828,32 @@ public Object[][] resizeOps() {
Consumer<MemorySegment> byteInitializer =
(base) -> initBytes(base, bytes, (addr, pos) -> addr.set(JAVA_BYTE, pos, (byte)(long)pos));
Consumer<MemorySegment> charInitializer =
- (base) -> initBytes(base, chars, (addr, pos) -> addr.setAtIndex(JAVA_CHAR.withOrder(ByteOrder.BIG_ENDIAN), pos, (char)(long)pos));
+ (base) -> initBytes(base, chars, (addr, pos) -> addr.setAtIndex(BB_CHAR, pos, (char)(long)pos));
Consumer<MemorySegment> shortInitializer =
- (base) -> initBytes(base, shorts, (addr, pos) -> addr.setAtIndex(JAVA_SHORT.withOrder(ByteOrder.BIG_ENDIAN), pos, (short)(long)pos));
+ (base) -> initBytes(base, shorts, (addr, pos) -> addr.setAtIndex(BB_SHORT, pos, (short)(long)pos));
Consumer<MemorySegment> intInitializer =
- (base) -> initBytes(base, ints, (addr, pos) -> addr.setAtIndex(JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN), pos, (int)(long)pos));
+ (base) -> initBytes(base, ints, (addr, pos) -> addr.setAtIndex(BB_INT, pos, (int)(long)pos));
Consumer<MemorySegment> floatInitializer =
- (base) -> initBytes(base, floats, (addr, pos) -> addr.setAtIndex(JAVA_FLOAT.withOrder(ByteOrder.BIG_ENDIAN), pos, (float)(long)pos));
+ (base) -> initBytes(base, floats, (addr, pos) -> addr.setAtIndex(BB_FLOAT, pos, (float)(long)pos));
Consumer<MemorySegment> longInitializer =
- (base) -> initBytes(base, longs, (addr, pos) -> addr.setAtIndex(JAVA_LONG.withOrder(ByteOrder.BIG_ENDIAN), pos, (long)pos));
+ (base) -> initBytes(base, longs, (addr, pos) -> addr.setAtIndex(BB_LONG, pos, (long)pos));
Consumer<MemorySegment> doubleInitializer =
- (base) -> initBytes(base, doubles, (addr, pos) -> addr.setAtIndex(JAVA_DOUBLE.withOrder(ByteOrder.BIG_ENDIAN), pos, (double)(long)pos));
+ (base) -> initBytes(base, doubles, (addr, pos) -> addr.setAtIndex(BB_DOUBLE, pos, (double)(long)pos));
Consumer<MemorySegment> byteChecker =
(base) -> checkBytes(base, bytes, Function.identity(), (addr, pos) -> addr.get(JAVA_BYTE, pos), ByteBuffer::get);
Consumer<MemorySegment> charChecker =
- (base) -> checkBytes(base, chars, ByteBuffer::asCharBuffer, (addr, pos) -> addr.getAtIndex(JAVA_CHAR.withOrder(ByteOrder.BIG_ENDIAN), pos), CharBuffer::get);
+ (base) -> checkBytes(base, chars, ByteBuffer::asCharBuffer, (addr, pos) -> addr.getAtIndex(BB_CHAR, pos), CharBuffer::get);
Consumer<MemorySegment> shortChecker =
- (base) -> checkBytes(base, shorts, ByteBuffer::asShortBuffer, (addr, pos) -> addr.getAtIndex(JAVA_SHORT.withOrder(ByteOrder.BIG_ENDIAN), pos), ShortBuffer::get);
+ (base) -> checkBytes(base, shorts, ByteBuffer::asShortBuffer, (addr, pos) -> addr.getAtIndex(BB_SHORT, pos), ShortBuffer::get);
Consumer<MemorySegment> intChecker =
- (base) -> checkBytes(base, ints, ByteBuffer::asIntBuffer, (addr, pos) -> addr.getAtIndex(JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN), pos), IntBuffer::get);
+ (base) -> checkBytes(base, ints, ByteBuffer::asIntBuffer, (addr, pos) -> addr.getAtIndex(BB_INT, pos), IntBuffer::get);
Consumer<MemorySegment> floatChecker =
- (base) -> checkBytes(base, floats, ByteBuffer::asFloatBuffer, (addr, pos) -> addr.getAtIndex(JAVA_FLOAT.withOrder(ByteOrder.BIG_ENDIAN), pos), FloatBuffer::get);
+ (base) -> checkBytes(base, floats, ByteBuffer::asFloatBuffer, (addr, pos) -> addr.getAtIndex(BB_FLOAT, pos), FloatBuffer::get);
Consumer<MemorySegment> longChecker =
- (base) -> checkBytes(base, longs, ByteBuffer::asLongBuffer, (addr, pos) -> addr.getAtIndex(JAVA_LONG.withOrder(ByteOrder.BIG_ENDIAN), pos), LongBuffer::get);
+ (base) -> checkBytes(base, longs, ByteBuffer::asLongBuffer, (addr, pos) -> addr.getAtIndex(BB_LONG, pos), LongBuffer::get);
Consumer<MemorySegment> doubleChecker =
- (base) -> checkBytes(base, doubles, ByteBuffer::asDoubleBuffer, (addr, pos) -> addr.getAtIndex(JAVA_DOUBLE.withOrder(ByteOrder.BIG_ENDIAN), pos), DoubleBuffer::get);
+ (base) -> checkBytes(base, doubles, ByteBuffer::asDoubleBuffer, (addr, pos) -> addr.getAtIndex(BB_DOUBLE, pos), DoubleBuffer::get);
return new Object[][]{
{byteChecker, byteInitializer, bytes},
diff --git a/test/jdk/java/foreign/TestMemoryAccessInstance.java b/test/jdk/java/foreign/TestMemoryAccessInstance.java
index 4a0e5c04868..c75aeb45978 100644
--- a/test/jdk/java/foreign/TestMemoryAccessInstance.java
+++ b/test/jdk/java/foreign/TestMemoryAccessInstance.java
@@ -81,13 +81,13 @@ interface BufferSetter<X> {
void test() {
try (MemorySession session = MemorySession.openConfined()) {
- MemorySegment segment = MemorySegment.allocateNative(64, session);
+ MemorySegment segment = MemorySegment.allocateNative(128, session);
ByteBuffer buffer = segment.asByteBuffer();
T t = transform.apply(segment);
- segmentSetter.set(t, layout, 4, value);
- assertEquals(bufferGetter.get(buffer, 4), value);
- bufferSetter.set(buffer, 4, value);
- assertEquals(value, segmentGetter.get(t, layout, 4));
+ segmentSetter.set(t, layout, 8, value);
+ assertEquals(bufferGetter.get(buffer, 8), value);
+ bufferSetter.set(buffer, 8, value);
+ assertEquals(value, segmentGetter.get(t, layout, 8));
}
}
diff --git a/test/jdk/java/foreign/TestMemoryDereference.java b/test/jdk/java/foreign/TestMemoryDereference.java
index 6502aba09ff..d6d5af5f949 100644
--- a/test/jdk/java/foreign/TestMemoryDereference.java
+++ b/test/jdk/java/foreign/TestMemoryDereference.java
@@ -98,6 +98,14 @@ <Z> Accessor<Z> of(Z value,
}
}
+ // unaligned constants
+ public final static ValueLayout.OfShort JAVA_SHORT_UNALIGNED = JAVA_SHORT.withBitAlignment(8);
+ public final static ValueLayout.OfChar JAVA_CHAR_UNALIGNED = JAVA_CHAR.withBitAlignment(8);
+ public final static ValueLayout.OfInt JAVA_INT_UNALIGNED = JAVA_INT.withBitAlignment(8);
+ public final static ValueLayout.OfFloat JAVA_FLOAT_UNALIGNED = JAVA_FLOAT.withBitAlignment(8);
+ public final static ValueLayout.OfDouble JAVA_DOUBLE_UNALIGNED = JAVA_DOUBLE.withBitAlignment(8);
+ public final static ValueLayout.OfAddress ADDRESS_UNALIGNED = ADDRESS.withBitAlignment(8);
+
@Test(dataProvider = "accessors")
public void testMemoryAccess(String testName, Accessor<?> accessor) {
accessor.test();
@@ -123,90 +131,90 @@ static Object[][] accessors() {
},
// char, offset
{"char/offset", new Accessor<>((char) 42,
- s -> s.get(JAVA_CHAR, 8), (s, x) -> s.set(JAVA_CHAR, 8, x),
+ s -> s.get(JAVA_CHAR_UNALIGNED, 8), (s, x) -> s.set(JAVA_CHAR_UNALIGNED, 8, x),
(bb) -> bb.order(NE).getChar(8), (bb, v) -> bb.order(NE).putChar(8, v))
},
{"char/offset/LE", new Accessor<>((char) 42,
- s -> s.get(JAVA_CHAR.withOrder(ByteOrder.LITTLE_ENDIAN), 8),
- (s, x) -> s.set(JAVA_CHAR.withOrder(ByteOrder.LITTLE_ENDIAN), 8, x),
+ s -> s.get(JAVA_CHAR_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN), 8),
+ (s, x) -> s.set(JAVA_CHAR_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN), 8, x),
(bb) -> bb.order(LE).getChar(8), (bb, v) -> bb.order(LE).putChar(8, v))
},
{"char/offset/BE", new Accessor<>((char) 42,
- s -> s.get(JAVA_CHAR.withOrder(ByteOrder.BIG_ENDIAN), 8),
- (s, x) -> s.set(JAVA_CHAR.withOrder(ByteOrder.BIG_ENDIAN), 8, x),
+ s -> s.get(JAVA_CHAR_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN), 8),
+ (s, x) -> s.set(JAVA_CHAR_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN), 8, x),
(bb) -> bb.order(BE).getChar(8), (bb, v) -> bb.order(BE).putChar(8, v))
},
// short, offset
{"short/offset", new Accessor<>((short) 42,
- s -> s.get(JAVA_SHORT, 8), (s, x) -> s.set(JAVA_SHORT, 8, x),
+ s -> s.get(JAVA_SHORT_UNALIGNED, 8), (s, x) -> s.set(JAVA_SHORT_UNALIGNED, 8, x),
(bb) -> bb.order(NE).getShort(8), (bb, v) -> bb.order(NE).putShort(8, v))
},
{"short/offset/LE", new Accessor<>((short) 42,
- s -> s.get(JAVA_SHORT.withOrder(ByteOrder.LITTLE_ENDIAN), 8),
- (s, x) -> s.set(JAVA_SHORT.withOrder(ByteOrder.LITTLE_ENDIAN), 8, x),
+ s -> s.get(JAVA_SHORT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN), 8),
+ (s, x) -> s.set(JAVA_SHORT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN), 8, x),
(bb) -> bb.order(LE).getShort(8), (bb, v) -> bb.order(LE).putShort(8, v))
},
{"short/offset/BE", new Accessor<>((short) 42,
- s -> s.get(JAVA_SHORT.withOrder(ByteOrder.BIG_ENDIAN), 8),
- (s, x) -> s.set(JAVA_SHORT.withOrder(ByteOrder.BIG_ENDIAN), 8, x),
+ s -> s.get(JAVA_SHORT_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN), 8),
+ (s, x) -> s.set(JAVA_SHORT_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN), 8, x),
(bb) -> bb.order(BE).getShort(8), (bb, v) -> bb.order(BE).putShort(8, v))
},
// int, offset
{"int/offset", new Accessor<>(42,
- s -> s.get(JAVA_INT, 8), (s, x) -> s.set(JAVA_INT, 8, x),
+ s -> s.get(JAVA_INT_UNALIGNED, 8), (s, x) -> s.set(JAVA_INT_UNALIGNED, 8, x),
(bb) -> bb.order(NE).getInt(8), (bb, v) -> bb.order(NE).putInt(8, v))
},
{"int/offset/LE", new Accessor<>(42,
- s -> s.get(JAVA_INT.withOrder(ByteOrder.LITTLE_ENDIAN), 8),
- (s, x) -> s.set(JAVA_INT.withOrder(ByteOrder.LITTLE_ENDIAN), 8, x),
+ s -> s.get(JAVA_INT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN), 8),
+ (s, x) -> s.set(JAVA_INT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN), 8, x),
(bb) -> bb.order(LE).getInt(8), (bb, v) -> bb.order(LE).putInt(8, v))
},
{"int/offset/BE", new Accessor<>(42,
- s -> s.get(JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN), 8),
- (s, x) -> s.set(JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN), 8, x),
+ s -> s.get(JAVA_INT_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN), 8),
+ (s, x) -> s.set(JAVA_INT_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN), 8, x),
(bb) -> bb.order(BE).getInt(8), (bb, v) -> bb.order(BE).putInt(8, v))
},
// float, offset
{"float/offset", new Accessor<>(42f,
- s -> s.get(JAVA_FLOAT, 8), (s, x) -> s.set(JAVA_FLOAT, 8, x),
+ s -> s.get(JAVA_FLOAT_UNALIGNED, 8), (s, x) -> s.set(JAVA_FLOAT_UNALIGNED, 8, x),
(bb) -> bb.order(NE).getFloat(8), (bb, v) -> bb.order(NE).putFloat(8, v))
},
{"float/offset/LE", new Accessor<>(42f,
- s -> s.get(ValueLayout.JAVA_FLOAT.withOrder(ByteOrder.LITTLE_ENDIAN), 8),
- (s, x) -> s.set(ValueLayout.JAVA_FLOAT.withOrder(ByteOrder.LITTLE_ENDIAN), 8, x),
+ s -> s.get(JAVA_FLOAT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN), 8),
+ (s, x) -> s.set(JAVA_FLOAT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN), 8, x),
(bb) -> bb.order(LE).getFloat(8), (bb, v) -> bb.order(LE).putFloat(8, v))
},
{"float/offset/BE", new Accessor<>(42f,
- s -> s.get(ValueLayout.JAVA_FLOAT.withOrder(ByteOrder.BIG_ENDIAN), 8),
- (s, x) -> s.set(ValueLayout.JAVA_FLOAT.withOrder(ByteOrder.BIG_ENDIAN), 8, x),
+ s -> s.get(JAVA_FLOAT_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN), 8),
+ (s, x) -> s.set(JAVA_FLOAT_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN), 8, x),
(bb) -> bb.order(BE).getFloat(8), (bb, v) -> bb.order(BE).putFloat(8, v))
},
// double, offset
{"double/offset", new Accessor<>(42d,
- s -> s.get(JAVA_DOUBLE, 8), (s, x) -> s.set(JAVA_DOUBLE, 8, x),
+ s -> s.get(JAVA_DOUBLE_UNALIGNED, 8), (s, x) -> s.set(JAVA_DOUBLE_UNALIGNED, 8, x),
(bb) -> bb.order(NE).getDouble(8), (bb, v) -> bb.order(NE).putDouble(8, v))
},
{"double/offset/LE", new Accessor<>(42d,
- s -> s.get(ValueLayout.JAVA_DOUBLE.withOrder(ByteOrder.LITTLE_ENDIAN), 8),
- (s, x) -> s.set(ValueLayout.JAVA_DOUBLE.withOrder(ByteOrder.LITTLE_ENDIAN), 8, x),
+ s -> s.get(JAVA_DOUBLE_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN), 8),
+ (s, x) -> s.set(JAVA_DOUBLE_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN), 8, x),
(bb) -> bb.order(LE).getDouble(8), (bb, v) -> bb.order(LE).putDouble(8, v))
},
{"double/offset/BE", new Accessor<>(42d,
- s -> s.get(ValueLayout.JAVA_DOUBLE.withOrder(ByteOrder.BIG_ENDIAN), 8),
- (s, x) -> s.set(ValueLayout.JAVA_DOUBLE.withOrder(ByteOrder.BIG_ENDIAN), 8, x),
+ s -> s.get(JAVA_DOUBLE_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN), 8),
+ (s, x) -> s.set(JAVA_DOUBLE_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN), 8, x),
(bb) -> bb.order(BE).getDouble(8), (bb, v) -> bb.order(BE).putDouble(8, v))
},
{ "address/offset", new Accessor<>(MemoryAddress.ofLong(42),
- s -> s.get(ADDRESS, 8), (s, x) -> s.set(ADDRESS, 8, x),
+ s -> s.get(ADDRESS_UNALIGNED, 8), (s, x) -> s.set(ADDRESS_UNALIGNED, 8, x),
(bb) -> {
ByteBuffer nb = bb.order(NE);
- long addr = ValueLayout.ADDRESS.byteSize() == 8 ?
+ long addr = ADDRESS_UNALIGNED.byteSize() == 8 ?
nb.getLong(8) : nb.getInt(8);
return MemoryAddress.ofLong(addr);
},
(bb, v) -> {
ByteBuffer nb = bb.order(NE);
- if (ValueLayout.ADDRESS.byteSize() == 8) {
+ if (ADDRESS_UNALIGNED.byteSize() == 8) {
nb.putLong(8, v.toRawLongValue());
} else {
nb.putInt(8, (int)v.toRawLongValue());
diff --git a/test/jdk/java/foreign/TestSegmentCopy.java b/test/jdk/java/foreign/TestSegmentCopy.java
index 4d5efa2005d..aa8d70ca061 100644
--- a/test/jdk/java/foreign/TestSegmentCopy.java
+++ b/test/jdk/java/foreign/TestSegmentCopy.java
@@ -99,19 +99,19 @@ enum Type {
// Byte
BYTE(byte.class, JAVA_BYTE, i -> (byte)i),
//LE
- SHORT_LE(short.class, ValueLayout.JAVA_SHORT.withOrder(ByteOrder.LITTLE_ENDIAN), i -> (short)i),
- CHAR_LE(char.class, ValueLayout.JAVA_CHAR.withOrder(ByteOrder.LITTLE_ENDIAN), i -> (char)i),
- INT_LE(int.class, ValueLayout.JAVA_INT.withOrder(ByteOrder.LITTLE_ENDIAN), i -> i),
- FLOAT_LE(float.class, ValueLayout.JAVA_FLOAT.withOrder(ByteOrder.LITTLE_ENDIAN), i -> (float)i),
- LONG_LE(long.class, ValueLayout.JAVA_LONG.withOrder(ByteOrder.LITTLE_ENDIAN), i -> (long)i),
- DOUBLE_LE(double.class, ValueLayout.JAVA_DOUBLE.withOrder(ByteOrder.LITTLE_ENDIAN), i -> (double)i),
+ SHORT_LE(short.class, ValueLayout.JAVA_SHORT.withBitAlignment(8).withOrder(ByteOrder.LITTLE_ENDIAN), i -> (short)i),
+ CHAR_LE(char.class, ValueLayout.JAVA_CHAR.withBitAlignment(8).withOrder(ByteOrder.LITTLE_ENDIAN), i -> (char)i),
+ INT_LE(int.class, ValueLayout.JAVA_INT.withBitAlignment(8).withOrder(ByteOrder.LITTLE_ENDIAN), i -> i),
+ FLOAT_LE(float.class, ValueLayout.JAVA_FLOAT.withBitAlignment(8).withOrder(ByteOrder.LITTLE_ENDIAN), i -> (float)i),
+ LONG_LE(long.class, ValueLayout.JAVA_LONG.withBitAlignment(8).withOrder(ByteOrder.LITTLE_ENDIAN), i -> (long)i),
+ DOUBLE_LE(double.class, ValueLayout.JAVA_DOUBLE.withBitAlignment(8).withOrder(ByteOrder.LITTLE_ENDIAN), i -> (double)i),
//BE
- SHORT_BE(short.class, ValueLayout.JAVA_SHORT.withOrder(ByteOrder.BIG_ENDIAN), i -> (short)i),
- CHAR_BE(char.class, ValueLayout.JAVA_CHAR.withOrder(ByteOrder.BIG_ENDIAN), i -> (char)i),
- INT_BE(int.class, ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN), i -> i),
- FLOAT_BE(float.class, ValueLayout.JAVA_FLOAT.withOrder(ByteOrder.BIG_ENDIAN), i -> (float)i),
- LONG_BE(long.class, ValueLayout.JAVA_LONG.withOrder(ByteOrder.BIG_ENDIAN), i -> (long)i),
- DOUBLE_BE(double.class, ValueLayout.JAVA_DOUBLE.withOrder(ByteOrder.BIG_ENDIAN), i -> (double)i);
+ SHORT_BE(short.class, ValueLayout.JAVA_SHORT.withBitAlignment(8).withOrder(ByteOrder.BIG_ENDIAN), i -> (short)i),
+ CHAR_BE(char.class, ValueLayout.JAVA_CHAR.withBitAlignment(8).withOrder(ByteOrder.BIG_ENDIAN), i -> (char)i),
+ INT_BE(int.class, ValueLayout.JAVA_INT.withBitAlignment(8).withOrder(ByteOrder.BIG_ENDIAN), i -> i),
+ FLOAT_BE(float.class, ValueLayout.JAVA_FLOAT.withBitAlignment(8).withOrder(ByteOrder.BIG_ENDIAN), i -> (float)i),
+ LONG_BE(long.class, ValueLayout.JAVA_LONG.withBitAlignment(8).withOrder(ByteOrder.BIG_ENDIAN), i -> (long)i),
+ DOUBLE_BE(double.class, ValueLayout.JAVA_DOUBLE.withBitAlignment(8).withOrder(ByteOrder.BIG_ENDIAN), i -> (double)i);
final ValueLayout layout;
final IntFunction<Object> valueConverter;
diff --git a/test/jdk/java/foreign/TestVarHandleCombinators.java b/test/jdk/java/foreign/TestVarHandleCombinators.java
index 07af719863e..4c044c29e7c 100644
--- a/test/jdk/java/foreign/TestVarHandleCombinators.java
+++ b/test/jdk/java/foreign/TestVarHandleCombinators.java
@@ -72,7 +72,8 @@ public void testAlign() {
@Test
public void testByteOrderLE() {
- VarHandle vh = MethodHandles.memoryAccessVarHandle(ValueLayout.JAVA_SHORT.withOrder(ByteOrder.LITTLE_ENDIAN));
+ VarHandle vh = MethodHandles.memoryAccessVarHandle(ValueLayout.JAVA_SHORT
+ .withOrder(ByteOrder.LITTLE_ENDIAN).withBitAlignment(8));
byte[] arr = new byte[2];
MemorySegment segment = MemorySegment.ofArray(arr);
vh.set(segment, 0L, (short) 0xFF);
@@ -82,7 +83,8 @@ public void testByteOrderLE() {
@Test
public void testByteOrderBE() {
- VarHandle vh = MethodHandles.memoryAccessVarHandle(ValueLayout.JAVA_SHORT.withOrder(ByteOrder.BIG_ENDIAN));
+ VarHandle vh = MethodHandles.memoryAccessVarHandle(ValueLayout.JAVA_SHORT
+ .withOrder(ByteOrder.BIG_ENDIAN).withBitAlignment(8));
byte[] arr = new byte[2];
MemorySegment segment = MemorySegment.ofArray(arr);
vh.set(segment, 0L, (short) 0xFF);
diff --git a/test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SegmentTestDataProvider.java b/test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SegmentTestDataProvider.java
index 287c346b8ad..b0e638a1814 100644
--- a/test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SegmentTestDataProvider.java
+++ b/test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SegmentTestDataProvider.java
@@ -107,7 +107,7 @@ static boolean compareSegmentsFloat(Collection<MemorySegment> segments1, Collect
static Consumer<MemorySegment> segmentCopier(Consumer<MemorySegment> input) {
return segment -> {
- MemorySegment dest = MemorySegment.ofArray(new byte[(int)segment.byteSize()]);
+ MemorySegment dest = MemorySegment.ofArray(new long[(int)segment.byteSize() / 8]);
dest.copyFrom(segment);
input.accept(dest);
};