From 5fc9b5787dc4d7f00d2c59288bc8d840fdf5b495 Mon Sep 17 00:00:00 2001 From: Maurizio Cimadamore Date: Mon, 22 May 2023 14:57:00 +0000 Subject: [PATCH] 8308276: Change layout API to work with bytes, not bits Reviewed-by: psandoz, pminborg --- .../java/lang/foreign/AddressLayout.java | 4 +- .../java/lang/foreign/GroupLayout.java | 4 +- .../java/lang/foreign/MemoryLayout.java | 150 ++++-------------- .../java/lang/foreign/MemorySegment.java | 6 +- .../java/lang/foreign/PaddingLayout.java | 3 +- .../java/lang/foreign/SequenceLayout.java | 4 +- .../java/lang/foreign/StructLayout.java | 2 +- .../java/lang/foreign/UnionLayout.java | 2 +- .../java/lang/foreign/ValueLayout.java | 68 ++++---- .../java/lang/invoke/MethodHandles.java | 2 +- .../classes/jdk/internal/foreign/CABI.java | 4 +- .../jdk/internal/foreign/LayoutPath.java | 17 +- .../foreign/NativeMemorySegmentImpl.java | 4 +- .../classes/jdk/internal/foreign/Utils.java | 16 +- .../internal/foreign/abi/AbstractLinker.java | 14 +- .../jdk/internal/foreign/abi/SharedUtils.java | 1 - .../foreign/abi/aarch64/TypeClass.java | 6 +- .../foreign/abi/fallback/FFIType.java | 6 +- .../foreign/abi/riscv64/linux/TypeClass.java | 2 +- .../foreign/layout/AbstractGroupLayout.java | 17 +- .../foreign/layout/AbstractLayout.java | 30 ++-- .../foreign/layout/MemoryLayoutUtil.java | 8 +- .../foreign/layout/PaddingLayoutImpl.java | 22 +-- .../foreign/layout/SequenceLayoutImpl.java | 22 +-- .../foreign/layout/StructLayoutImpl.java | 16 +- .../foreign/layout/UnionLayoutImpl.java | 14 +- .../internal/foreign/layout/ValueLayouts.java | 127 +++++++-------- .../jdk/incubator/vector/ByteVector.java | 4 +- .../jdk/incubator/vector/DoubleVector.java | 4 +- .../jdk/incubator/vector/FloatVector.java | 4 +- .../jdk/incubator/vector/IntVector.java | 4 +- .../jdk/incubator/vector/LongVector.java | 4 +- .../jdk/incubator/vector/ShortVector.java | 4 +- .../incubator/vector/X-Vector.java.template | 4 +- .../MemoryLayoutTypeRetentionTest.java | 47 +++--- test/jdk/java/foreign/NativeTestHelper.java | 12 +- test/jdk/java/foreign/StdLibTest.java | 2 +- test/jdk/java/foreign/TestArrayCopy.java | 6 +- test/jdk/java/foreign/TestByteBuffer.java | 22 +-- .../java/foreign/TestFunctionDescriptor.java | 12 +- test/jdk/java/foreign/TestHeapAlignment.java | 22 +-- test/jdk/java/foreign/TestIllegalLink.java | 42 ++--- test/jdk/java/foreign/TestLayoutPaths.java | 121 +++----------- test/jdk/java/foreign/TestLayouts.java | 114 ++++++------- test/jdk/java/foreign/TestLinker.java | 8 +- test/jdk/java/foreign/TestMemoryAccess.java | 6 +- .../foreign/TestMemoryAccessInstance.java | 2 +- .../jdk/java/foreign/TestMemoryAlignment.java | 38 +++-- test/jdk/java/foreign/TestNulls.java | 2 +- .../java/foreign/TestSegmentAllocators.java | 9 +- test/jdk/java/foreign/TestSegmentCopy.java | 4 +- test/jdk/java/foreign/TestSpliterator.java | 2 +- .../jdk/java/foreign/TestUpcallHighArity.java | 2 +- .../java/foreign/TestUpcallStructScope.java | 2 +- test/jdk/java/foreign/TestValueLayouts.java | 56 ++++--- .../foreign/TestVarHandleCombinators.java | 14 +- .../callarranger/TestLayoutEquality.java | 6 +- .../TestLinuxAArch64CallArranger.java | 2 +- .../callarranger/TestRISCV64CallArranger.java | 4 +- .../callarranger/TestSysVCallArranger.java | 2 +- test/jdk/java/foreign/nested/TestNested.java | 24 +-- .../AttachCurrentThread/ImplicitAttach.java | 4 +- .../vector/Byte128VectorLoadStoreTests.java | 2 +- .../vector/Byte256VectorLoadStoreTests.java | 2 +- .../vector/Byte512VectorLoadStoreTests.java | 2 +- .../vector/Byte64VectorLoadStoreTests.java | 2 +- .../vector/ByteMaxVectorLoadStoreTests.java | 2 +- .../vector/Double128VectorLoadStoreTests.java | 2 +- .../vector/Double256VectorLoadStoreTests.java | 2 +- .../vector/Double512VectorLoadStoreTests.java | 2 +- .../vector/Double64VectorLoadStoreTests.java | 2 +- .../vector/DoubleMaxVectorLoadStoreTests.java | 2 +- .../vector/Float128VectorLoadStoreTests.java | 2 +- .../vector/Float256VectorLoadStoreTests.java | 2 +- .../vector/Float512VectorLoadStoreTests.java | 2 +- .../vector/Float64VectorLoadStoreTests.java | 2 +- .../vector/FloatMaxVectorLoadStoreTests.java | 2 +- .../vector/Int128VectorLoadStoreTests.java | 2 +- .../vector/Int256VectorLoadStoreTests.java | 2 +- .../vector/Int512VectorLoadStoreTests.java | 2 +- .../vector/Int64VectorLoadStoreTests.java | 2 +- .../vector/IntMaxVectorLoadStoreTests.java | 2 +- .../vector/Long128VectorLoadStoreTests.java | 2 +- .../vector/Long256VectorLoadStoreTests.java | 2 +- .../vector/Long512VectorLoadStoreTests.java | 2 +- .../vector/Long64VectorLoadStoreTests.java | 2 +- .../vector/LongMaxVectorLoadStoreTests.java | 2 +- .../vector/Short128VectorLoadStoreTests.java | 2 +- .../vector/Short256VectorLoadStoreTests.java | 2 +- .../vector/Short512VectorLoadStoreTests.java | 2 +- .../vector/Short64VectorLoadStoreTests.java | 2 +- .../vector/ShortMaxVectorLoadStoreTests.java | 2 +- .../templates/X-LoadStoreTest.java.template | 2 +- 93 files changed, 527 insertions(+), 721 deletions(-) diff --git a/src/java.base/share/classes/java/lang/foreign/AddressLayout.java b/src/java.base/share/classes/java/lang/foreign/AddressLayout.java index fc98f558133..9819cc84cc9 100644 --- a/src/java.base/share/classes/java/lang/foreign/AddressLayout.java +++ b/src/java.base/share/classes/java/lang/foreign/AddressLayout.java @@ -38,7 +38,7 @@ import java.util.Optional; /** * A value layout used to model the address of some region of memory. The carrier associated with an address layout is * {@code MemorySegment.class}. The size and alignment of an address layout are platform dependent - * (e.g. on a 64-bit platform, the size and alignment of an address layout are set to 64 bits). + * (e.g. on a 64-bit platform, the size and alignment of an address layout are set to 8 bytes). *

* An address layout may optionally feature a {@linkplain #targetLayout() target layout}. An address layout with * target layout {@code T} can be used to model the address of a region of memory whose layout is {@code T}. @@ -74,7 +74,7 @@ public sealed interface AddressLayout extends ValueLayout permits ValueLayouts.O * {@inheritDoc} */ @Override - AddressLayout withBitAlignment(long bitAlignment); + AddressLayout withByteAlignment(long byteAlignment); /** * {@inheritDoc} diff --git a/src/java.base/share/classes/java/lang/foreign/GroupLayout.java b/src/java.base/share/classes/java/lang/foreign/GroupLayout.java index 872f4923992..20f6f29fd30 100644 --- a/src/java.base/share/classes/java/lang/foreign/GroupLayout.java +++ b/src/java.base/share/classes/java/lang/foreign/GroupLayout.java @@ -68,9 +68,9 @@ public sealed interface GroupLayout extends MemoryLayout permits StructLayout, U /** * {@inheritDoc} * @throws IllegalArgumentException {@inheritDoc} - * @throws IllegalArgumentException if {@code bitAlignment} is less than {@code M}, where {@code M} is the maximum alignment + * @throws IllegalArgumentException if {@code byteAlignment} is less than {@code M}, where {@code M} is the maximum alignment * constraint in any of the member layouts associated with this group layout. */ @Override - GroupLayout withBitAlignment(long bitAlignment); + GroupLayout withByteAlignment(long byteAlignment); } diff --git a/src/java.base/share/classes/java/lang/foreign/MemoryLayout.java b/src/java.base/share/classes/java/lang/foreign/MemoryLayout.java index 44a620ea3c9..0734d3678da 100644 --- a/src/java.base/share/classes/java/lang/foreign/MemoryLayout.java +++ b/src/java.base/share/classes/java/lang/foreign/MemoryLayout.java @@ -75,7 +75,7 @@ import jdk.internal.javac.PreviewFeature; * SequenceLayout taggedValues = MemoryLayout.sequenceLayout(5, * MemoryLayout.structLayout( * ValueLayout.JAVA_BYTE.withName("kind"), - * MemoryLayout.paddingLayout(24), + * MemoryLayout.paddingLayout(3), * ValueLayout.JAVA_INT.withName("value") * ) * ).withName("TaggedValues"); @@ -84,7 +84,7 @@ import jdk.internal.javac.PreviewFeature; *

Size, alignment and byte order

* * All layouts have a size; layout size for value and padding layouts is always explicitly denoted; this means that a layout description - * always has the same size in bits, regardless of the platform in which it is used. For derived layouts, the size is computed + * always has the same size in bytes, regardless of the platform in which it is used. For derived layouts, the size is computed * as follows: * - * A layout's natural alignment can be overridden if needed (see {@link MemoryLayout#withBitAlignment(long)}), which can be useful to describe + * A layout's natural alignment can be overridden if needed (see {@link MemoryLayout#withByteAlignment(long)}), which can be useful to describe * hyper-aligned layouts. *

* All value layouts have an explicit byte order (see {@link java.nio.ByteOrder}) which is set when the layout is created. @@ -115,17 +115,17 @@ import jdk.internal.javac.PreviewFeature; * at a layout nested within the root layout - this is the layout selected by the layout path. * Layout paths are typically expressed as a sequence of one or more {@link PathElement} instances. *

- * Layout paths are for example useful in order to obtain {@linkplain MemoryLayout#bitOffset(PathElement...) offsets} of + * Layout paths are for example useful in order to obtain {@linkplain MemoryLayout#byteOffset(PathElement...) offsets} of * arbitrarily nested layouts inside another layout, to quickly obtain a {@linkplain #varHandle(PathElement...) memory access handle} * corresponding to the selected layout, or to {@linkplain #select(PathElement...) select} an arbitrarily nested layout inside * another layout. *

* Such layout paths can be constructed programmatically using the methods in this class. * For instance, given the {@code taggedValues} layout instance constructed as above, we can obtain the offset, - * in bits, of the member layout named value in the first sequence element, as follows: + * in bytes, of the member layout named value in the first sequence element, as follows: * {@snippet lang=java : - * long valueOffset = taggedValues.bitOffset(PathElement.sequenceElement(0), - * PathElement.groupElement("value")); // yields 32 + * long valueOffset = taggedValues.byteOffset(PathElement.sequenceElement(0), + * PathElement.groupElement("value")); // yields 4 * } * * Similarly, we can select the member layout named {@code value}, as follows: @@ -151,7 +151,7 @@ import jdk.internal.javac.PreviewFeature; * access coordinate. * *

A layout path with free dimensions can also be used to create an offset-computing method handle, using the - * {@link #bitOffset(PathElement...)} or {@link #byteOffsetHandle(PathElement...)} method. Again, free dimensions are + * {@link #byteOffset(PathElement...)} or {@link #byteOffsetHandle(PathElement...)} method. Again, free dimensions are * translated into {@code long} parameters of the created method handle. The method handle can be used to compute the * offsets of elements of a sequence at different indices, by supplying these indices when invoking the method handle. * For instance: @@ -172,14 +172,8 @@ import jdk.internal.javac.PreviewFeature; @PreviewFeature(feature=PreviewFeature.Feature.FOREIGN) public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, PaddingLayout, ValueLayout { - /** - * {@return the layout size, in bits} - */ - long bitSize(); - /** * {@return the layout size, in bytes} - * @throws UnsupportedOperationException if {@code bitSize()} is not a multiple of 8. */ long byteSize(); @@ -210,24 +204,6 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin */ MemoryLayout withoutName(); - /** - * Returns the alignment constraint associated with this layout, expressed in bits. Layout alignment defines a power - * of two {@code A} which is the bit-wise alignment of the layout. If {@code A <= 8} then {@code A/8} is the number of - * bytes that must be aligned for any pointer that correctly points to this layout. Thus: - * - *

- * - * If no explicit alignment constraint was set on this layout (see {@link #withBitAlignment(long)}), - * then this method returns the natural alignment constraint (in bits) associated with this layout. - * - * @return the layout alignment constraint, in bits. - */ - long bitAlignment(); - /** * Returns the alignment constraint associated with this layout, expressed in bytes. Layout alignment defines a power * of two {@code A} which is the byte-wise alignment of the layout, where {@code A} is the number of bytes that must be aligned @@ -239,76 +215,24 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin *
  • {@code A=64} is the most strict alignment required by the x86/SV ABI (for AVX-512 data).
    • * * - * If no explicit alignment constraint was set on this layout (see {@link #withBitAlignment(long)}), + * If no explicit alignment constraint was set on this layout (see {@link #withByteAlignment(long)}), * then this method returns the natural alignment constraint (in bytes) associated with this layout. * * @return the layout alignment constraint, in bytes. - * @throws UnsupportedOperationException if {@code bitAlignment()} is not a multiple of 8. */ long byteAlignment(); + /** * Returns a memory layout of the same type with the same size and name as this layout, - * but with the specified alignment constraint (in bits). + * but with the specified alignment constraint (in bytes). * - * @param bitAlignment the layout alignment constraint, expressed in bits. + * @param byteAlignment the layout alignment constraint, expressed in bytes. * @return a memory layout with the given alignment constraint. - * @throws IllegalArgumentException if {@code bitAlignment} is not a power of two, or if it's less than 8. + * @throws IllegalArgumentException if {@code byteAlignment} is not a power of two, or if it's less than 1. */ - MemoryLayout withBitAlignment(long bitAlignment); + MemoryLayout withByteAlignment(long byteAlignment); - /** - * Computes the offset, in bits, of the layout selected by the given layout path, where the path is considered rooted in this - * layout. - * - * @param elements the layout path elements. - * @return The offset, in bits, of the layout selected by the layout path in {@code elements}. - * @throws IllegalArgumentException if the layout path does not select any layout nested in this layout, or if the - * layout path contains one or more path elements that select multiple sequence element indices - * (see {@link PathElement#sequenceElement()} and {@link PathElement#sequenceElement(long, long)}). - * @throws IllegalArgumentException if the layout path contains one or more dereference path elements - * (see {@link PathElement#dereferenceElement()}). - * @throws NullPointerException if either {@code elements == null}, or if any of the elements - * in {@code elements} is {@code null}. - */ - default long bitOffset(PathElement... elements) { - return computePathOp(LayoutPath.rootPath(this), LayoutPath::offset, - EnumSet.of(PathKind.SEQUENCE_ELEMENT, PathKind.SEQUENCE_RANGE, PathKind.DEREF_ELEMENT), elements); - } - - /** - * Creates a method handle that can be used to compute the offset, in bits, of the layout selected - * by the given layout path, where the path is considered rooted in this layout. - * - *

    The returned method handle has a return type of {@code long}, and features as many {@code long} - * parameter types as there are free dimensions in the provided layout path (see {@link PathElement#sequenceElement()}), - * where the order of the parameters corresponds to the order of the path elements. - * The returned method handle can be used to compute a layout offset similar to {@link #bitOffset(PathElement...)}, - * but where some sequence indices are specified only when invoking the method handle. - * - *

    The final offset returned by the method handle is computed as follows: - * - * 

    {@code
-     * offset = c_1 + c_2 + ... + c_m + (x_1 * s_1) + (x_2 * s_2) + ... + (x_n * s_n)
-     * }
    - * - * where {@code x_1}, {@code x_2}, ... {@code x_n} are dynamic values provided as {@code long} - * arguments, whereas {@code c_1}, {@code c_2}, ... {@code c_m} are static offset constants - * and {@code s_0}, {@code s_1}, ... {@code s_n} are static stride constants which are derived from - * the layout path. - * - * @param elements the layout path elements. - * @return a method handle that can be used to compute the bit offset of the layout element - * specified by the given layout path elements, when supplied with the missing sequence element indices. - * @throws IllegalArgumentException if the layout path contains one or more path elements that select - * multiple sequence element indices (see {@link PathElement#sequenceElement(long, long)}). - * @throws IllegalArgumentException if the layout path contains one or more dereference path elements - * (see {@link PathElement#dereferenceElement()}). - */ - default MethodHandle bitOffsetHandle(PathElement... elements) { - return computePathOp(LayoutPath.rootPath(this), LayoutPath::offsetHandle, - EnumSet.of(PathKind.SEQUENCE_RANGE, PathKind.DEREF_ELEMENT), elements); - } /** * Computes the offset, in bytes, of the layout selected by the given layout path, where the path is considered rooted in this @@ -321,12 +245,12 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin * (see {@link PathElement#sequenceElement()} and {@link PathElement#sequenceElement(long, long)}). * @throws IllegalArgumentException if the layout path contains one or more dereference path elements * (see {@link PathElement#dereferenceElement()}). - * @throws UnsupportedOperationException if {@code bitOffset(elements)} is not a multiple of 8. * @throws NullPointerException if either {@code elements == null}, or if any of the elements * in {@code elements} is {@code null}. */ default long byteOffset(PathElement... elements) { - return Utils.bitsToBytes(bitOffset(elements)); + return computePathOp(LayoutPath.rootPath(this), LayoutPath::offset, + EnumSet.of(PathKind.SEQUENCE_ELEMENT, PathKind.SEQUENCE_RANGE, PathKind.DEREF_ELEMENT), elements); } /** @@ -342,8 +266,7 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin *

    The final offset returned by the method handle is computed as follows: * * 

    {@code
-     * bitOffset = c_1 + c_2 + ... + c_m + (x_1 * s_1) + (x_2 * s_2) + ... + (x_n * s_n)
-     * offset = bitOffset / 8
+     * byteOffset = c_1 + c_2 + ... + c_m + (x_1 * s_1) + (x_2 * s_2) + ... + (x_n * s_n)
      * }
    * * where {@code x_1}, {@code x_2}, ... {@code x_n} are dynamic values provided as {@code long} @@ -351,9 +274,6 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin * and {@code s_0}, {@code s_1}, ... {@code s_n} are static stride constants which are derived from * the layout path. * - *

    The method handle will throw an {@link UnsupportedOperationException} if the computed - * offset in bits is not a multiple of 8. - * * @param elements the layout path elements. * @return a method handle that can be used to compute the byte offset of the layout element * specified by the given layout path elements, when supplied with the missing sequence element indices. @@ -363,9 +283,8 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin * (see {@link PathElement#dereferenceElement()}). */ default MethodHandle byteOffsetHandle(PathElement... elements) { - MethodHandle mh = bitOffsetHandle(elements); - mh = MethodHandles.filterReturnValue(mh, Utils.BITS_TO_BYTES); - return mh; + return computePathOp(LayoutPath.rootPath(this), LayoutPath::offsetHandle, + EnumSet.of(PathKind.SEQUENCE_RANGE, PathKind.DEREF_ELEMENT), elements); } /** @@ -448,8 +367,7 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin *

    The offset of the returned segment is computed as follows: * * 

    {@code
-     * bitOffset = c_1 + c_2 + ... + c_m + (x_1 * s_1) + (x_2 * s_2) + ... + (x_n * s_n)
-     * offset = bitOffset / 8
+     * byteOffset = c_1 + c_2 + ... + c_m + (x_1 * s_1) + (x_2 * s_2) + ... + (x_n * s_n)
      * }
    * * where {@code x_1}, {@code x_2}, ... {@code x_n} are dynamic values provided as {@code long} @@ -465,12 +383,8 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin * where {@code segment} is the segment to be sliced, and where {@code layout} is the layout selected by the given * layout path, as per {@link MemoryLayout#select(PathElement...)}. * - *

    The method handle will throw an {@link UnsupportedOperationException} if the computed - * offset in bits is not a multiple of 8. - * * @param elements the layout path elements. * @return a method handle which can be used to create a slice of the selected layout element, given a segment. - * @throws UnsupportedOperationException if the size of the selected layout in bits is not a multiple of 8. * @throws IllegalArgumentException if the layout path contains one or more dereference path elements * (see {@link PathElement#dereferenceElement()}). */ @@ -687,14 +601,14 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin String toString(); /** - * Creates a padding layout with the given bitSize and a bit-alignment of eight. + * Creates a padding layout with the given byte size and a byte-alignment of one. * - * @param bitSize the padding size in bits. + * @param byteSize the padding size (expressed in bytes). * @return the new selector layout. - * @throws IllegalArgumentException if {@code bitSize <= 0} or {@code bitSize % 8 != 0} + * @throws IllegalArgumentException if {@code byteSize <= 0}. */ - static PaddingLayout paddingLayout(long bitSize) { - return PaddingLayoutImpl.of(MemoryLayoutUtil.requireBitSizeValid(bitSize, false)); + static PaddingLayout paddingLayout(long byteSize) { + return PaddingLayoutImpl.of(MemoryLayoutUtil.requireByteSizeValid(byteSize, false)); } /** @@ -704,7 +618,7 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin * @param elementLayout the sequence element layout. * @return the new sequence layout with the given element layout and size. * @throws IllegalArgumentException if {@code elementCount } is negative. - * @throws IllegalArgumentException if {@code elementLayout.bitSize() % elementLayout.bitAlignment() != 0}. + * @throws IllegalArgumentException if {@code elementLayout.byteSize() % elementLayout.byteAlignment() != 0}. */ static SequenceLayout sequenceLayout(long elementCount, MemoryLayout elementLayout) { MemoryLayoutUtil.requireNonNegative(elementCount); @@ -720,16 +634,16 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin * * This is equivalent to the following code: * {@snippet lang = java: - * sequenceLayout(Long.MAX_VALUE / elementLayout.bitSize(), elementLayout); + * sequenceLayout(Long.MAX_VALUE / elementLayout.byteSize(), elementLayout); * } * * @param elementLayout the sequence element layout. * @return a new sequence layout with the given element layout and maximum element count. - * @throws IllegalArgumentException if {@code elementLayout.bitSize() % elementLayout.bitAlignment() != 0}. + * @throws IllegalArgumentException if {@code elementLayout.byteSize() % elementLayout.byteAlignment() != 0}. */ static SequenceLayout sequenceLayout(MemoryLayout elementLayout) { Objects.requireNonNull(elementLayout); - return sequenceLayout(Long.MAX_VALUE / elementLayout.bitSize(), elementLayout); + return sequenceLayout(Long.MAX_VALUE / elementLayout.byteSize(), elementLayout); } /** @@ -737,7 +651,7 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin * * @param elements The member layouts of the struct layout. * @return a struct layout with the given member layouts. - * @throws IllegalArgumentException if the sum of the {@linkplain #bitSize() bit sizes} of the member layouts + * @throws IllegalArgumentException if the sum of the {@linkplain #byteSize() byte sizes} of the member layouts * overflows. * @throws IllegalArgumentException if a member layout in {@code elements} occurs at an offset (relative to the start * of the struct layout) which is not compatible with its alignment constraint. @@ -752,14 +666,14 @@ public sealed interface MemoryLayout permits SequenceLayout, GroupLayout, Paddin * To avoid the exception, clients can either insert additional padding layout elements: * * {@snippet lang = java: - * structLayout(JAVA_SHORT, MemoryLayout.ofPadding(16), JAVA_INT) + * structLayout(JAVA_SHORT, MemoryLayout.ofPadding(2), JAVA_INT) * } * * Or, alternatively, they can use a member layout which features a smaller alignment constraint. This will result * in a packed struct layout: * * {@snippet lang = java: - * structLayout(JAVA_SHORT, JAVA_INT.withBitAlignment(16)) + * structLayout(JAVA_SHORT, JAVA_INT.withByteAlignment(2)) * } */ static StructLayout structLayout(MemoryLayout... elements) { diff --git a/src/java.base/share/classes/java/lang/foreign/MemorySegment.java b/src/java.base/share/classes/java/lang/foreign/MemorySegment.java index d4e706fafdf..7efc8ef8da0 100644 --- a/src/java.base/share/classes/java/lang/foreign/MemorySegment.java +++ b/src/java.base/share/classes/java/lang/foreign/MemorySegment.java @@ -379,7 +379,7 @@ import jdk.internal.vm.annotation.ForceInline; * to read a pointer from some memory segment. This can be done via the * {@linkplain MemorySegment#get(AddressLayout, long)} access method. This method accepts an * {@linkplain AddressLayout address layout} (e.g. {@link ValueLayout#ADDRESS}), the layout of the pointer - * to be read. For instance on a 64-bit platform, the size of an address layout is 64 bits. The access operation + * to be read. For instance on a 64-bit platform, the size of an address layout is 8 bytes. The access operation * also accepts an offset, expressed in bytes, which indicates the position (relative to the start of the memory segment) * at which the pointer is stored. The access operation returns a zero-length native memory segment, backed by a region * of memory whose starting address is the 64-bit value read at the specified offset. @@ -470,7 +470,7 @@ public sealed interface MemorySegment permits AbstractMemorySegmentImpl { * @return the element spliterator for this segment * @throws IllegalArgumentException if {@code elementLayout.byteSize() == 0}. * @throws IllegalArgumentException if {@code byteSize() % elementLayout.byteSize() != 0}. - * @throws IllegalArgumentException if {@code elementLayout.bitSize() % elementLayout.bitAlignment() != 0}. + * @throws IllegalArgumentException if {@code elementLayout.byteSize() % elementLayout.byteAlignment() != 0}. * @throws IllegalArgumentException if this segment is incompatible * with the alignment constraint in the provided layout. */ @@ -487,7 +487,7 @@ public sealed interface MemorySegment permits AbstractMemorySegmentImpl { * @return a sequential {@code Stream} over disjoint slices in this segment. * @throws IllegalArgumentException if {@code elementLayout.byteSize() == 0}. * @throws IllegalArgumentException if {@code byteSize() % elementLayout.byteSize() != 0}. - * @throws IllegalArgumentException if {@code elementLayout.bitSize() % elementLayout.bitAlignment() != 0}. + * @throws IllegalArgumentException if {@code elementLayout.byteSize() % elementLayout.byteAlignment() != 0}. * @throws IllegalArgumentException if this segment is incompatible * with the alignment constraint in the provided layout. */ diff --git a/src/java.base/share/classes/java/lang/foreign/PaddingLayout.java b/src/java.base/share/classes/java/lang/foreign/PaddingLayout.java index a09689c874c..cd0cd44ed30 100644 --- a/src/java.base/share/classes/java/lang/foreign/PaddingLayout.java +++ b/src/java.base/share/classes/java/lang/foreign/PaddingLayout.java @@ -56,6 +56,5 @@ public sealed interface PaddingLayout extends MemoryLayout permits PaddingLayout * {@inheritDoc} * @throws IllegalArgumentException {@inheritDoc} */ - @Override - PaddingLayout withBitAlignment(long bitAlignment); + PaddingLayout withByteAlignment(long byteAlignment); } diff --git a/src/java.base/share/classes/java/lang/foreign/SequenceLayout.java b/src/java.base/share/classes/java/lang/foreign/SequenceLayout.java index 3d0a01631f8..95bde61f0bd 100644 --- a/src/java.base/share/classes/java/lang/foreign/SequenceLayout.java +++ b/src/java.base/share/classes/java/lang/foreign/SequenceLayout.java @@ -143,7 +143,7 @@ public sealed interface SequenceLayout extends MemoryLayout permits SequenceLayo /** * {@inheritDoc} * @throws IllegalArgumentException {@inheritDoc} - * @throws IllegalArgumentException if {@code bitAlignment < elementLayout().bitAlignment()}. + * @throws IllegalArgumentException if {@code byteAlignment < elementLayout().byteAlignment()}. */ - SequenceLayout withBitAlignment(long bitAlignment); + SequenceLayout withByteAlignment(long byteAlignment); } diff --git a/src/java.base/share/classes/java/lang/foreign/StructLayout.java b/src/java.base/share/classes/java/lang/foreign/StructLayout.java index ad314ae3b36..57ddc00caee 100644 --- a/src/java.base/share/classes/java/lang/foreign/StructLayout.java +++ b/src/java.base/share/classes/java/lang/foreign/StructLayout.java @@ -56,5 +56,5 @@ public sealed interface StructLayout extends GroupLayout permits StructLayoutImp * @throws IllegalArgumentException {@inheritDoc} */ @Override - StructLayout withBitAlignment(long bitAlignment); + StructLayout withByteAlignment(long byteAlignment); } diff --git a/src/java.base/share/classes/java/lang/foreign/UnionLayout.java b/src/java.base/share/classes/java/lang/foreign/UnionLayout.java index fa322f3cc74..f13d9274df1 100644 --- a/src/java.base/share/classes/java/lang/foreign/UnionLayout.java +++ b/src/java.base/share/classes/java/lang/foreign/UnionLayout.java @@ -56,5 +56,5 @@ public sealed interface UnionLayout extends GroupLayout permits UnionLayoutImpl * @throws IllegalArgumentException {@inheritDoc} */ @Override - UnionLayout withBitAlignment(long bitAlignment); + UnionLayout withByteAlignment(long byteAlignment); } 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 2095391af9b..61ddd50e0a1 100644 --- a/src/java.base/share/classes/java/lang/foreign/ValueLayout.java +++ b/src/java.base/share/classes/java/lang/foreign/ValueLayout.java @@ -37,7 +37,7 @@ import jdk.internal.javac.PreviewFeature; * integral values (either signed or unsigned), floating-point values and * address values. *

    - * Each value layout has a size, an alignment (in bits), + * Each value layout has a size, an alignment (both expressed in bytes), * a {@linkplain ByteOrder byte order}, and a carrier, that is, the Java type that should be used when * {@linkplain MemorySegment#get(OfInt, long) accessing} a region of memory using the value layout. *

    @@ -129,7 +129,7 @@ public sealed interface ValueLayout extends MemoryLayout permits * featuring {@code shape.length + 1} * {@code long} coordinates. * @throws IllegalArgumentException if {@code shape[i] < 0}, for at least one index {@code i}. - * @throws UnsupportedOperationException if {@code bitAlignment() > bitSize()}. + * @throws UnsupportedOperationException if {@code byteAlignment() > byteSize()}. * @see MethodHandles#memorySegmentViewVarHandle * @see MemoryLayout#varHandle(PathElement...) * @see SequenceLayout @@ -152,7 +152,7 @@ public sealed interface ValueLayout extends MemoryLayout permits * @throws IllegalArgumentException {@inheritDoc} */ @Override - ValueLayout withBitAlignment(long bitAlignment); + ValueLayout withByteAlignment(long byteAlignment); /** * A value layout whose carrier is {@code boolean.class}. @@ -180,7 +180,7 @@ public sealed interface ValueLayout extends MemoryLayout permits * @throws IllegalArgumentException {@inheritDoc} */ @Override - OfBoolean withBitAlignment(long bitAlignment); + OfBoolean withByteAlignment(long byteAlignment); /** * {@inheritDoc} @@ -216,7 +216,7 @@ public sealed interface ValueLayout extends MemoryLayout permits * @throws IllegalArgumentException {@inheritDoc} */ @Override - OfByte withBitAlignment(long bitAlignment); + OfByte withByteAlignment(long byteAlignment); /** * {@inheritDoc} @@ -253,7 +253,7 @@ public sealed interface ValueLayout extends MemoryLayout permits * @throws IllegalArgumentException {@inheritDoc} */ @Override - OfChar withBitAlignment(long bitAlignment); + OfChar withByteAlignment(long byteAlignment); /** * {@inheritDoc} @@ -290,7 +290,7 @@ public sealed interface ValueLayout extends MemoryLayout permits * @throws IllegalArgumentException {@inheritDoc} */ @Override - OfShort withBitAlignment(long bitAlignment); + OfShort withByteAlignment(long byteAlignment); /** * {@inheritDoc} @@ -327,7 +327,7 @@ public sealed interface ValueLayout extends MemoryLayout permits * @throws IllegalArgumentException {@inheritDoc} */ @Override - OfInt withBitAlignment(long bitAlignment); + OfInt withByteAlignment(long byteAlignment); /** * {@inheritDoc} @@ -363,7 +363,7 @@ public sealed interface ValueLayout extends MemoryLayout permits * {@inheritDoc} */ @Override - OfFloat withBitAlignment(long bitAlignment); + OfFloat withByteAlignment(long byteAlignment); /** * {@inheritDoc} @@ -400,7 +400,7 @@ public sealed interface ValueLayout extends MemoryLayout permits * @throws IllegalArgumentException {@inheritDoc} */ @Override - OfLong withBitAlignment(long bitAlignment); + OfLong withByteAlignment(long byteAlignment); /** * {@inheritDoc} @@ -437,7 +437,7 @@ public sealed interface ValueLayout extends MemoryLayout permits * @throws IllegalArgumentException {@inheritDoc} */ @Override - OfDouble withBitAlignment(long bitAlignment); + OfDouble withByteAlignment(long byteAlignment); /** * {@inheritDoc} @@ -449,56 +449,56 @@ public sealed interface ValueLayout extends MemoryLayout permits /** * A value layout constant whose size is the same as that of a machine address ({@code size_t}), - * bit alignment set to {@code sizeof(size_t) * 8}, byte order set to {@link ByteOrder#nativeOrder()}. + * byte alignment set to {@code sizeof(size_t)}, byte order set to {@link ByteOrder#nativeOrder()}. */ AddressLayout ADDRESS = ValueLayouts.OfAddressImpl.of(ByteOrder.nativeOrder()); /** * A value layout constant whose size is the same as that of a Java {@code byte}, - * bit alignment set to 8, and byte order set to {@link ByteOrder#nativeOrder()}. + * byte alignment set to 1, and byte order set to {@link ByteOrder#nativeOrder()}. */ OfByte JAVA_BYTE = ValueLayouts.OfByteImpl.of(ByteOrder.nativeOrder()); /** * A value layout constant whose size is the same as that of a Java {@code boolean}, - * bit alignment set to 8, and byte order set to {@link ByteOrder#nativeOrder()}. + * byte alignment set to 1, and byte order set to {@link ByteOrder#nativeOrder()}. */ OfBoolean JAVA_BOOLEAN = ValueLayouts.OfBooleanImpl.of(ByteOrder.nativeOrder()); /** * A value layout constant whose size is the same as that of a Java {@code char}, - * bit alignment set to 16, and byte order set to {@link ByteOrder#nativeOrder()}. + * byte alignment set to 2, and byte order set to {@link ByteOrder#nativeOrder()}. */ OfChar JAVA_CHAR = ValueLayouts.OfCharImpl.of(ByteOrder.nativeOrder()); /** * A value layout constant whose size is the same as that of a Java {@code short}, - * bit alignment set to 16, and byte order set to {@link ByteOrder#nativeOrder()}. + * byte alignment set to 2, and byte order set to {@link ByteOrder#nativeOrder()}. */ OfShort JAVA_SHORT = ValueLayouts.OfShortImpl.of(ByteOrder.nativeOrder()); /** * A value layout constant whose size is the same as that of a Java {@code int}, - * bit alignment set to 32, and byte order set to {@link ByteOrder#nativeOrder()}. + * byte alignment set to 4, and byte order set to {@link ByteOrder#nativeOrder()}. */ OfInt JAVA_INT = ValueLayouts.OfIntImpl.of(ByteOrder.nativeOrder()); /** * A value layout constant whose size is the same as that of a Java {@code long}, - * (platform-dependent) bit alignment set to {@code ADDRESS.bitSize()}, + * (platform-dependent) byte alignment set to {@code ADDRESS.byteSize()}, * and byte order set to {@link ByteOrder#nativeOrder()}. */ OfLong JAVA_LONG = ValueLayouts.OfLongImpl.of(ByteOrder.nativeOrder()); /** * A value layout constant whose size is the same as that of a Java {@code float}, - * bit alignment set to 32, and byte order set to {@link ByteOrder#nativeOrder()}. + * byte alignment set to 4, and byte order set to {@link ByteOrder#nativeOrder()}. */ OfFloat JAVA_FLOAT = ValueLayouts.OfFloatImpl.of(ByteOrder.nativeOrder()); /** * A value layout constant whose size is the same as that of a Java {@code double}, - * (platform-dependent) bit alignment set to {@code ADDRESS.bitSize()}, + * (platform-dependent) byte alignment set to {@code ADDRESS.byteSize()}, * and byte order set to {@link ByteOrder#nativeOrder()}. */ OfDouble JAVA_DOUBLE = ValueLayouts.OfDoubleImpl.of(ByteOrder.nativeOrder()); @@ -508,83 +508,83 @@ public sealed interface ValueLayout extends MemoryLayout permits * and byte order set to {@link ByteOrder#nativeOrder()}. * Equivalent to the following code: * {@snippet lang=java : - * ADDRESS.withBitAlignment(8); + * ADDRESS.withByteAlignment(1); * } * @apiNote Care should be taken when using unaligned value layouts as they may induce * performance and portability issues. */ - AddressLayout ADDRESS_UNALIGNED = ADDRESS.withBitAlignment(8); + AddressLayout ADDRESS_UNALIGNED = ADDRESS.withByteAlignment(1); /** * An unaligned value layout constant whose size is the same as that of a Java {@code char} * and byte order set to {@link ByteOrder#nativeOrder()}. * Equivalent to the following code: * {@snippet lang=java : - * JAVA_CHAR.withBitAlignment(8); + * JAVA_CHAR.withByteAlignment(1); * } * @apiNote Care should be taken when using unaligned value layouts as they may induce * performance and portability issues. */ - OfChar JAVA_CHAR_UNALIGNED = JAVA_CHAR.withBitAlignment(8); + OfChar JAVA_CHAR_UNALIGNED = JAVA_CHAR.withByteAlignment(1); /** * An unaligned value layout constant whose size is the same as that of a Java {@code short} * and byte order set to {@link ByteOrder#nativeOrder()}. * Equivalent to the following code: * {@snippet lang=java : - * JAVA_SHORT.withBitAlignment(8); + * JAVA_SHORT.withByteAlignment(1); * } * @apiNote Care should be taken when using unaligned value layouts as they may induce * performance and portability issues. */ - OfShort JAVA_SHORT_UNALIGNED = JAVA_SHORT.withBitAlignment(8); + OfShort JAVA_SHORT_UNALIGNED = JAVA_SHORT.withByteAlignment(1); /** * An unaligned value layout constant whose size is the same as that of a Java {@code int} * and byte order set to {@link ByteOrder#nativeOrder()}. * Equivalent to the following code: * {@snippet lang=java : - * JAVA_INT.withBitAlignment(8); + * JAVA_INT.withByteAlignment(1); * } * @apiNote Care should be taken when using unaligned value layouts as they may induce * performance and portability issues. */ - OfInt JAVA_INT_UNALIGNED = JAVA_INT.withBitAlignment(8); + OfInt JAVA_INT_UNALIGNED = JAVA_INT.withByteAlignment(1); /** * An unaligned value layout constant whose size is the same as that of a Java {@code long} * and byte order set to {@link ByteOrder#nativeOrder()}. * Equivalent to the following code: * {@snippet lang=java : - * JAVA_LONG.withBitAlignment(8); + * JAVA_LONG.withByteAlignment(1); * } * @apiNote Care should be taken when using unaligned value layouts as they may induce * performance and portability issues. */ - OfLong JAVA_LONG_UNALIGNED = JAVA_LONG.withBitAlignment(8); + OfLong JAVA_LONG_UNALIGNED = JAVA_LONG.withByteAlignment(1); /** * An unaligned value layout constant whose size is the same as that of a Java {@code float} * and byte order set to {@link ByteOrder#nativeOrder()}. * Equivalent to the following code: * {@snippet lang=java : - * JAVA_FLOAT.withBitAlignment(8); + * JAVA_FLOAT.withByteAlignment(1); * } * @apiNote Care should be taken when using unaligned value layouts as they may induce * performance and portability issues. */ - OfFloat JAVA_FLOAT_UNALIGNED = JAVA_FLOAT.withBitAlignment(8); + OfFloat JAVA_FLOAT_UNALIGNED = JAVA_FLOAT.withByteAlignment(1); /** * An unaligned value layout constant whose size is the same as that of a Java {@code double} * and byte order set to {@link ByteOrder#nativeOrder()}. * Equivalent to the following code: * {@snippet lang=java : - * JAVA_DOUBLE.withBitAlignment(8); + * JAVA_DOUBLE.withByteAlignment(1); * } * @apiNote Care should be taken when using unaligned value layouts as they may induce * performance and portability issues. */ - OfDouble JAVA_DOUBLE_UNALIGNED = JAVA_DOUBLE.withBitAlignment(8); + OfDouble JAVA_DOUBLE_UNALIGNED = JAVA_DOUBLE.withByteAlignment(1); } diff --git a/src/java.base/share/classes/java/lang/invoke/MethodHandles.java b/src/java.base/share/classes/java/lang/invoke/MethodHandles.java index de243c72d40..e3dcaac8922 100644 --- a/src/java.base/share/classes/java/lang/invoke/MethodHandles.java +++ b/src/java.base/share/classes/java/lang/invoke/MethodHandles.java @@ -7964,7 +7964,7 @@ assertEquals("boojum", (String) catTrace.invokeExact("boo", "jum")); *

    As an example, consider the memory layout expressed by a {@link GroupLayout} instance constructed as follows: * {@snippet lang="java" : * GroupLayout seq = java.lang.foreign.MemoryLayout.structLayout( - * MemoryLayout.paddingLayout(32), + * MemoryLayout.paddingLayout(4), * ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN).withName("value") * ); * } diff --git a/src/java.base/share/classes/jdk/internal/foreign/CABI.java b/src/java.base/share/classes/jdk/internal/foreign/CABI.java index afec17e92c0..52ef0f68216 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/CABI.java +++ b/src/java.base/share/classes/jdk/internal/foreign/CABI.java @@ -54,10 +54,10 @@ public enum CABI { if (ForeignLinkerSupport.isSupported()) { // figure out the ABI based on the platform String arch = StaticProperty.osArch(); - long addressSize = ADDRESS.bitSize(); + long addressSize = ADDRESS.byteSize(); // might be running in a 32-bit VM on a 64-bit platform. // addressSize will be correctly 32 - if ((arch.equals("amd64") || arch.equals("x86_64")) && addressSize == 64) { + if ((arch.equals("amd64") || arch.equals("x86_64")) && addressSize == 8) { if (OperatingSystem.isWindows()) { return WIN_64; } else { diff --git a/src/java.base/share/classes/jdk/internal/foreign/LayoutPath.java b/src/java.base/share/classes/jdk/internal/foreign/LayoutPath.java index 936b4813847..b893a759d56 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/LayoutPath.java +++ b/src/java.base/share/classes/jdk/internal/foreign/LayoutPath.java @@ -97,7 +97,7 @@ public class LayoutPath { check(SequenceLayout.class, "attempting to select a sequence element from a non-sequence layout"); SequenceLayout seq = (SequenceLayout)layout; MemoryLayout elem = seq.elementLayout(); - return LayoutPath.nestedPath(elem, offset, addStride(elem.bitSize()), addBound(seq.elementCount()), derefAdapters, this); + return LayoutPath.nestedPath(elem, offset, addStride(elem.byteSize()), addBound(seq.elementCount()), derefAdapters, this); } public LayoutPath sequenceElement(long start, long step) { @@ -105,7 +105,7 @@ public class LayoutPath { SequenceLayout seq = (SequenceLayout)layout; checkSequenceBounds(seq, start); MemoryLayout elem = seq.elementLayout(); - long elemSize = elem.bitSize(); + long elemSize = elem.byteSize(); long nelems = step > 0 ? seq.elementCount() - start : start + 1; @@ -118,7 +118,7 @@ public class LayoutPath { check(SequenceLayout.class, "attempting to select a sequence element from a non-sequence layout"); SequenceLayout seq = (SequenceLayout)layout; checkSequenceBounds(seq, index); - long elemSize = seq.elementLayout().bitSize(); + long elemSize = seq.elementLayout().byteSize(); long elemOffset = elemSize * index; return LayoutPath.nestedPath(seq.elementLayout(), offset + elemOffset, strides, bounds, derefAdapters,this); } @@ -135,7 +135,7 @@ public class LayoutPath { elem = l; break; } else if (g instanceof StructLayout) { - offset += l.bitSize(); + offset += l.byteSize(); } } if (elem == null) { @@ -156,7 +156,7 @@ public class LayoutPath { } elem = g.memberLayouts().get(i); if (g instanceof StructLayout && i < index) { - offset += elem.bitSize(); + offset += elem.byteSize(); } } return LayoutPath.nestedPath(elem, this.offset + offset, strides, bounds, derefAdapters, this); @@ -196,14 +196,14 @@ public class LayoutPath { VarHandle handle = Utils.makeSegmentViewVarHandle(valueLayout); for (int i = strides.length - 1; i >= 0; i--) { MethodHandle collector = MethodHandles.insertArguments(MH_ADD_SCALED_OFFSET, 2, - Utils.bitsToBytes(strides[i]), + strides[i], bounds[i]); // (J, ...) -> J to (J, J, ...) -> J // i.e. new coord is prefixed. Last coord will correspond to innermost layout handle = MethodHandles.collectCoordinates(handle, 1, collector); } handle = MethodHandles.insertCoordinates(handle, 1, - Utils.bitsToBytes(offset)); + offset); if (adapt) { for (int i = derefAdapters.length; i > 0; i--) { @@ -232,8 +232,7 @@ public class LayoutPath { } public MethodHandle sliceHandle() { - MethodHandle offsetHandle = offsetHandle(); // bit offset - offsetHandle = MethodHandles.filterReturnValue(offsetHandle, Utils.BITS_TO_BYTES); // byte offset + MethodHandle offsetHandle = offsetHandle(); // byte offset MethodHandle sliceHandle = MH_SLICE; // (MS, long, long) -> MS sliceHandle = MethodHandles.insertArguments(sliceHandle, 2, layout.byteSize()); // (MS, long) -> MS diff --git a/src/java.base/share/classes/jdk/internal/foreign/NativeMemorySegmentImpl.java b/src/java.base/share/classes/jdk/internal/foreign/NativeMemorySegmentImpl.java index 0738b81202a..28d038e39b3 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/NativeMemorySegmentImpl.java +++ b/src/java.base/share/classes/jdk/internal/foreign/NativeMemorySegmentImpl.java @@ -43,8 +43,8 @@ public sealed class NativeMemorySegmentImpl extends AbstractMemorySegmentImpl pe private static final Unsafe UNSAFE = Unsafe.getUnsafe(); - // The maximum alignment supported by malloc - typically 16 on - // 64-bit platforms and 8 on 32-bit platforms. + // The maximum alignment supported by malloc - typically 16 bytes on + // 64-bit platforms and 8 bytes on 32-bit platforms. private static final long MAX_MALLOC_ALIGN = Unsafe.ADDRESS_SIZE == 4 ? 8 : 16; private static final boolean SKIP_ZERO_MEMORY = GetBooleanAction.privilegedGetProperty("jdk.internal.foreign.skipZeroMemory"); diff --git a/src/java.base/share/classes/jdk/internal/foreign/Utils.java b/src/java.base/share/classes/jdk/internal/foreign/Utils.java index 6638a095265..5289cab3f22 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/Utils.java +++ b/src/java.base/share/classes/jdk/internal/foreign/Utils.java @@ -63,7 +63,6 @@ public final class Utils { private static final MethodHandle BOOL_TO_BYTE; private static final MethodHandle ADDRESS_TO_LONG; private static final MethodHandle LONG_TO_ADDRESS; - public static final MethodHandle BITS_TO_BYTES; static { try { @@ -76,8 +75,6 @@ public final class Utils { MethodType.methodType(long.class, MemorySegment.class)); LONG_TO_ADDRESS = lookup.findStatic(Utils.class, "longToAddress", MethodType.methodType(MemorySegment.class, long.class, long.class, long.class)); - BITS_TO_BYTES = lookup.findStatic(Utils.class, "bitsToBytes", - MethodType.methodType(long.class, long.class)); } catch (Throwable ex) { throw new ExceptionInInitializerError(ex); } @@ -92,11 +89,6 @@ public final class Utils { return ms.asSlice(alignUp(offset, alignment) - offset); } - public static long bitsToBytes(long bits) { - assert Utils.isAligned(bits, 8); - return bits / Byte.SIZE; - } - public static VarHandle makeSegmentViewVarHandle(ValueLayout layout) { final class VarHandleCache { private static final Map HANDLE_MAP = new ConcurrentHashMap<>(); @@ -177,7 +169,7 @@ public final class Utils { public static void checkElementAlignment(ValueLayout layout, String msg) { // Fast-path: if both size and alignment are powers of two, we can just // check if one is greater than the other. - assert isPowerOfTwo(layout.bitSize()); + assert isPowerOfTwo(layout.byteSize()); if (layout.byteAlignment() > layout.byteSize()) { throw new IllegalArgumentException(msg); } @@ -236,14 +228,14 @@ public final class Utils { List layouts = new ArrayList<>(); long align = 0; for (MemoryLayout l : elements) { - long padding = computePadding(offset, l.bitAlignment()); + long padding = computePadding(offset, l.byteAlignment()); if (padding != 0) { layouts.add(MemoryLayout.paddingLayout(padding)); offset += padding; } layouts.add(l); - align = Math.max(align, l.bitAlignment()); - offset += l.bitSize(); + align = Math.max(align, l.byteAlignment()); + offset += l.byteSize(); } long padding = computePadding(offset, align); if (padding != 0) { diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/AbstractLinker.java b/src/java.base/share/classes/jdk/internal/foreign/abi/AbstractLinker.java index 1c6ee128c2b..d386287fed8 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/abi/AbstractLinker.java +++ b/src/java.base/share/classes/jdk/internal/foreign/abi/AbstractLinker.java @@ -160,7 +160,7 @@ public abstract sealed class AbstractLinker implements Linker permits LinuxAArch checkMemberOffset(sl, member, lastUnpaddedOffset, offset); checkLayoutRecursive(member); - offset += member.bitSize(); + offset += member.byteSize(); if (!(member instanceof PaddingLayout)) { lastUnpaddedOffset = offset; } @@ -171,7 +171,7 @@ public abstract sealed class AbstractLinker implements Linker permits LinuxAArch for (MemoryLayout member : ul.memberLayouts()) { checkLayoutRecursive(member); if (!(member instanceof PaddingLayout)) { - maxUnpaddedLayout = Long.max(maxUnpaddedLayout, member.bitSize()); + maxUnpaddedLayout = Long.max(maxUnpaddedLayout, member.byteSize()); } } checkGroupSize(ul, maxUnpaddedLayout); @@ -182,10 +182,10 @@ public abstract sealed class AbstractLinker implements Linker permits LinuxAArch // check for trailing padding private static void checkGroupSize(GroupLayout gl, long maxUnpaddedOffset) { - long expectedSize = Utils.alignUp(maxUnpaddedOffset, gl.bitAlignment()); - if (gl.bitSize() != expectedSize) { + long expectedSize = Utils.alignUp(maxUnpaddedOffset, gl.byteAlignment()); + if (gl.byteSize() != expectedSize) { throw new IllegalArgumentException("Layout '" + gl + "' has unexpected size: " - + gl.bitSize() + " != " + expectedSize); + + gl.byteSize() + " != " + expectedSize); } } @@ -193,7 +193,7 @@ public abstract sealed class AbstractLinker implements Linker permits LinuxAArch // the previous layout private static void checkMemberOffset(StructLayout parent, MemoryLayout memberLayout, long lastUnpaddedOffset, long offset) { - long expectedOffset = Utils.alignUp(lastUnpaddedOffset, memberLayout.bitAlignment()); + long expectedOffset = Utils.alignUp(lastUnpaddedOffset, memberLayout.byteAlignment()); if (expectedOffset != offset) { throw new IllegalArgumentException("Member layout '" + memberLayout + "', of '" + parent + "'" + " found at unexpected offset: " + offset + " != " + expectedOffset); @@ -202,7 +202,7 @@ public abstract sealed class AbstractLinker implements Linker permits LinuxAArch private static void checkHasNaturalAlignment(MemoryLayout layout) { if (!((AbstractLayout) layout).hasNaturalAlignment()) { - throw new IllegalArgumentException("Layout bit alignment must be natural alignment: " + layout); + throw new IllegalArgumentException("Layout alignment must be natural alignment: " + layout); } } diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/SharedUtils.java b/src/java.base/share/classes/jdk/internal/foreign/abi/SharedUtils.java index fc800e073ad..1de4572cc51 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/abi/SharedUtils.java +++ b/src/java.base/share/classes/jdk/internal/foreign/abi/SharedUtils.java @@ -79,7 +79,6 @@ public final class SharedUtils { public static final MethodHandle MH_CHECK_SYMBOL; public static final AddressLayout C_POINTER = ADDRESS - .withBitAlignment(64) .withTargetLayout(MemoryLayout.sequenceLayout(JAVA_BYTE)); public static final Arena DUMMY_ARENA = new Arena() { diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/TypeClass.java b/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/TypeClass.java index 57025b37b01..4c655de4b20 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/TypeClass.java +++ b/src/java.base/share/classes/jdk/internal/foreign/abi/aarch64/TypeClass.java @@ -58,7 +58,7 @@ public enum TypeClass { } static boolean isRegisterAggregate(MemoryLayout type) { - return type.bitSize() <= MAX_AGGREGATE_REGS_SIZE * 64; + return type.byteSize() <= MAX_AGGREGATE_REGS_SIZE * 8; } static List scalarLayouts(GroupLayout gl) { @@ -106,8 +106,8 @@ public enum TypeClass { return false; TypeClass argClass = classifyValueType((ValueLayout) elem); - if (elem.bitSize() != baseType.bitSize() || - elem.bitAlignment() != baseType.bitAlignment() || + if (elem.byteSize() != baseType.byteSize() || + elem.byteAlignment() != baseType.byteAlignment() || baseArgClass != argClass) { return false; } diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/fallback/FFIType.java b/src/java.base/share/classes/jdk/internal/foreign/abi/fallback/FFIType.java index b8e41f763c8..465a17d2298 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/abi/fallback/FFIType.java +++ b/src/java.base/share/classes/jdk/internal/foreign/abi/fallback/FFIType.java @@ -58,9 +58,9 @@ import static java.lang.foreign.ValueLayout.JAVA_SHORT; * } ffi_type; */ class FFIType { - private static final ValueLayout SIZE_T = switch ((int) ADDRESS.bitSize()) { - case 64 -> JAVA_LONG; - case 32 -> JAVA_INT; + private static final ValueLayout SIZE_T = switch ((int) ADDRESS.byteSize()) { + case 8 -> JAVA_LONG; + case 4 -> JAVA_INT; default -> throw new IllegalStateException("Address size not supported: " + ADDRESS.byteSize()); }; private static final ValueLayout UNSIGNED_SHORT = JAVA_SHORT; diff --git a/src/java.base/share/classes/jdk/internal/foreign/abi/riscv64/linux/TypeClass.java b/src/java.base/share/classes/jdk/internal/foreign/abi/riscv64/linux/TypeClass.java index 11656f0c76d..368a7571beb 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/abi/riscv64/linux/TypeClass.java +++ b/src/java.base/share/classes/jdk/internal/foreign/abi/riscv64/linux/TypeClass.java @@ -181,7 +181,7 @@ public enum TypeClass { } private static boolean isRegisterAggregate(MemoryLayout type) { - return type.bitSize() <= MAX_AGGREGATE_REGS_SIZE * 64; + return type.byteSize() <= MAX_AGGREGATE_REGS_SIZE * 8; } private static TypeClass classifyStructType(GroupLayout layout) { diff --git a/src/java.base/share/classes/jdk/internal/foreign/layout/AbstractGroupLayout.java b/src/java.base/share/classes/jdk/internal/foreign/layout/AbstractGroupLayout.java index 2aa5e8812ee..84b879aef07 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/layout/AbstractGroupLayout.java +++ b/src/java.base/share/classes/jdk/internal/foreign/layout/AbstractGroupLayout.java @@ -29,7 +29,6 @@ import java.lang.foreign.MemoryLayout; import java.util.List; import java.util.Objects; import java.util.Optional; -import java.util.function.LongBinaryOperator; import java.util.stream.Collectors; /** @@ -49,13 +48,13 @@ public sealed abstract class AbstractGroupLayout elements; - final long minBitAlignment; + final long minByteAlignment; - AbstractGroupLayout(Kind kind, List elements, long bitSize, long bitAlignment, long minBitAlignment, Optional name) { - super(bitSize, bitAlignment, name); // Subclassing creates toctou problems here + AbstractGroupLayout(Kind kind, List elements, long byteSize, long byteAlignment, long minByteAlignment, Optional name) { + super(byteSize, byteAlignment, name); // Subclassing creates toctou problems here this.kind = kind; this.elements = List.copyOf(elements); - this.minBitAlignment = minBitAlignment; + this.minByteAlignment = minByteAlignment; } /** @@ -82,11 +81,11 @@ public sealed abstract class AbstractGroupLayout & Memory private final long byteAlignment; private final Optional name; - AbstractLayout(long bitSize, long bitAlignment, Optional name) { - this.byteSize = MemoryLayoutUtil.requireBitSizeValid(bitSize, true) / 8; - this.byteAlignment = requirePowerOfTwoAndGreaterOrEqualToEight(bitAlignment) / 8; + AbstractLayout(long byteSize, long byteAlignment, Optional name) { + this.byteSize = MemoryLayoutUtil.requireByteSizeValid(byteSize, true); + this.byteAlignment = requirePowerOfTwoAndGreaterOrEqualToOne(byteAlignment); this.name = Objects.requireNonNull(name); } public final L withName(String name) { - return dup(bitAlignment(), Optional.of(name)); + return dup(byteAlignment(), Optional.of(name)); } public final L withoutName() { - return dup(bitAlignment(), Optional.empty()); + return dup(byteAlignment(), Optional.empty()); } public final Optional name() { return name; } - public L withBitAlignment(long bitAlignment) { - return dup(bitAlignment, name); - } - - public final long bitAlignment() { - return byteAlignment * 8; + public L withByteAlignment(long byteAlignment) { + return dup(byteAlignment, name); } public final long byteAlignment() { @@ -77,10 +73,6 @@ public abstract sealed class AbstractLayout & Memory return byteSize; } - public final long bitSize() { - return byteSize * 8; - } - public boolean hasNaturalAlignment() { return byteSize == byteAlignment; } @@ -127,21 +119,21 @@ public abstract sealed class AbstractLayout & Memory @Override public abstract String toString(); - abstract L dup(long bitAlignment, Optional name); + abstract L dup(long byteAlignment, Optional name); String decorateLayoutString(String s) { if (name().isPresent()) { s = String.format("%s(%s)", s, name().get()); } if (!hasNaturalAlignment()) { - s = bitAlignment() + "%" + s; + s = byteAlignment() + "%" + s; } return s; } - private static long requirePowerOfTwoAndGreaterOrEqualToEight(long value) { + private static long requirePowerOfTwoAndGreaterOrEqualToOne(long value) { if (!Utils.isPowerOfTwo(value) || // value must be a power of two - value < 8) { // value must be greater or equal to 8 + value < 1) { // value must be greater or equal to 1 throw new IllegalArgumentException("Invalid alignment: " + value); } return value; diff --git a/src/java.base/share/classes/jdk/internal/foreign/layout/MemoryLayoutUtil.java b/src/java.base/share/classes/jdk/internal/foreign/layout/MemoryLayoutUtil.java index ec093278cf1..dce06141028 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/layout/MemoryLayoutUtil.java +++ b/src/java.base/share/classes/jdk/internal/foreign/layout/MemoryLayoutUtil.java @@ -37,11 +37,11 @@ public final class MemoryLayoutUtil { return value; } - public static long requireBitSizeValid(long bitSize, boolean allowZero) { - if ((bitSize == 0 && !allowZero) || bitSize < 0 || bitSize % 8 != 0) { - throw new IllegalArgumentException("Invalid bitSize: " + bitSize); + public static long requireByteSizeValid(long byteSize, boolean allowZero) { + if ((byteSize == 0 && !allowZero) || byteSize < 0) { + throw new IllegalArgumentException("Invalid byte size: " + byteSize); } - return bitSize; + return byteSize; } } \ No newline at end of file diff --git a/src/java.base/share/classes/jdk/internal/foreign/layout/PaddingLayoutImpl.java b/src/java.base/share/classes/jdk/internal/foreign/layout/PaddingLayoutImpl.java index 2e82e19dfa1..63973e1cf3e 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/layout/PaddingLayoutImpl.java +++ b/src/java.base/share/classes/jdk/internal/foreign/layout/PaddingLayoutImpl.java @@ -31,17 +31,17 @@ import java.util.Optional; public final class PaddingLayoutImpl extends AbstractLayout implements PaddingLayout { - private PaddingLayoutImpl(long bitSize) { - this(bitSize, 8, Optional.empty()); + private PaddingLayoutImpl(long byteSize) { + this(byteSize, 1, Optional.empty()); } - private PaddingLayoutImpl(long bitSize, long bitAlignment, Optional name) { - super(bitSize, bitAlignment, name); + private PaddingLayoutImpl(long byteSize, long byteAlignment, Optional name) { + super(byteSize, byteAlignment, name); } @Override public String toString() { - return decorateLayoutString("x" + bitSize()); + return decorateLayoutString("x" + byteSize()); } @Override @@ -49,17 +49,17 @@ public final class PaddingLayoutImpl extends AbstractLayout i return this == other || other instanceof PaddingLayoutImpl otherPadding && super.equals(other) && - bitSize() == otherPadding.bitSize(); + byteSize() == otherPadding.byteSize(); } @Override public int hashCode() { - return Objects.hash(super.hashCode(), bitSize()); + return Objects.hash(super.hashCode(), byteSize()); } @Override - PaddingLayoutImpl dup(long bitAlignment, Optional name) { - return new PaddingLayoutImpl(bitSize(), bitAlignment, name); + PaddingLayoutImpl dup(long byteAlignment, Optional name) { + return new PaddingLayoutImpl(byteSize(), byteAlignment, name); } @Override @@ -67,8 +67,8 @@ public final class PaddingLayoutImpl extends AbstractLayout i return true; } - public static PaddingLayout of(long bitSize) { - return new PaddingLayoutImpl(bitSize); + public static PaddingLayout of(long byteSize) { + return new PaddingLayoutImpl(byteSize); } } diff --git a/src/java.base/share/classes/jdk/internal/foreign/layout/SequenceLayoutImpl.java b/src/java.base/share/classes/jdk/internal/foreign/layout/SequenceLayoutImpl.java index 00fc77c6047..12aa063153b 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/layout/SequenceLayoutImpl.java +++ b/src/java.base/share/classes/jdk/internal/foreign/layout/SequenceLayoutImpl.java @@ -36,11 +36,11 @@ public final class SequenceLayoutImpl extends AbstractLayout private final MemoryLayout elementLayout; private SequenceLayoutImpl(long elemCount, MemoryLayout elementLayout) { - this(elemCount, elementLayout, elementLayout.bitAlignment(), Optional.empty()); + this(elemCount, elementLayout, elementLayout.byteAlignment(), Optional.empty()); } - private SequenceLayoutImpl(long elemCount, MemoryLayout elementLayout, long bitAlignment, Optional name) { - super(Math.multiplyExact(elemCount, elementLayout.bitSize()), bitAlignment, name); + private SequenceLayoutImpl(long elemCount, MemoryLayout elementLayout, long byteAlignment, Optional name) { + super(Math.multiplyExact(elemCount, elementLayout.byteSize()), byteAlignment, name); this.elemCount = elemCount; this.elementLayout = elementLayout; } @@ -68,7 +68,7 @@ public final class SequenceLayoutImpl extends AbstractLayout * @throws IllegalArgumentException if {@code elementCount < 0}. */ public SequenceLayout withElementCount(long elementCount) { - return new SequenceLayoutImpl(elementCount, elementLayout, bitAlignment(), name()); + return new SequenceLayoutImpl(elementCount, elementLayout, byteAlignment(), name()); } /** @@ -176,7 +176,7 @@ public final class SequenceLayoutImpl extends AbstractLayout @Override public String toString() { - boolean max = (Long.MAX_VALUE / elementLayout.bitSize()) == elemCount; + boolean max = (Long.MAX_VALUE / elementLayout.byteSize()) == elemCount; return decorateLayoutString(String.format("[%s:%s]", max ? "*" : elemCount, elementLayout)); } @@ -196,21 +196,21 @@ public final class SequenceLayoutImpl extends AbstractLayout } @Override - SequenceLayoutImpl dup(long bitAlignment, Optional name) { - return new SequenceLayoutImpl(elementCount(), elementLayout, bitAlignment, name); + SequenceLayoutImpl dup(long byteAlignment, Optional name) { + return new SequenceLayoutImpl(elementCount(), elementLayout, byteAlignment, name); } @Override - public SequenceLayoutImpl withBitAlignment(long bitAlignment) { - if (bitAlignment < elementLayout.bitAlignment()) { + public SequenceLayoutImpl withByteAlignment(long byteAlignment) { + if (byteAlignment < elementLayout.byteAlignment()) { throw new IllegalArgumentException("Invalid alignment constraint"); } - return super.withBitAlignment(bitAlignment); + return super.withByteAlignment(byteAlignment); } @Override public boolean hasNaturalAlignment() { - return bitAlignment() == elementLayout.bitAlignment(); + return byteAlignment() == elementLayout.byteAlignment(); } public static SequenceLayout of(long elementCount, MemoryLayout elementLayout) { diff --git a/src/java.base/share/classes/jdk/internal/foreign/layout/StructLayoutImpl.java b/src/java.base/share/classes/jdk/internal/foreign/layout/StructLayoutImpl.java index a286f79a02f..9da6594e00f 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/layout/StructLayoutImpl.java +++ b/src/java.base/share/classes/jdk/internal/foreign/layout/StructLayoutImpl.java @@ -32,24 +32,24 @@ import java.util.Optional; public final class StructLayoutImpl extends AbstractGroupLayout implements StructLayout { - private StructLayoutImpl(List elements, long bitSize, long bitAlignment, long minBitAlignment, Optional name) { - super(Kind.STRUCT, elements, bitSize, bitAlignment, minBitAlignment, name); + private StructLayoutImpl(List elements, long byteSize, long byteAlignment, long minByteAlignment, Optional name) { + super(Kind.STRUCT, elements, byteSize, byteAlignment, minByteAlignment, name); } @Override - StructLayoutImpl dup(long bitAlignment, Optional name) { - return new StructLayoutImpl(memberLayouts(), bitSize(), bitAlignment, minBitAlignment, name); + StructLayoutImpl dup(long byteAlignment, Optional name) { + return new StructLayoutImpl(memberLayouts(), byteSize(), byteAlignment, minByteAlignment, name); } public static StructLayout of(List elements) { long size = 0; - long align = 8; + long align = 1; for (MemoryLayout elem : elements) { - if (size % elem.bitAlignment() != 0) { + if (size % elem.byteAlignment() != 0) { throw new IllegalArgumentException("Invalid alignment constraint for member layout: " + elem); } - size = Math.addExact(size, elem.bitSize()); - align = Math.max(align, elem.bitAlignment()); + size = Math.addExact(size, elem.byteSize()); + align = Math.max(align, elem.byteAlignment()); } return new StructLayoutImpl(elements, size, align, align, Optional.empty()); } diff --git a/src/java.base/share/classes/jdk/internal/foreign/layout/UnionLayoutImpl.java b/src/java.base/share/classes/jdk/internal/foreign/layout/UnionLayoutImpl.java index 64b960028a8..544ca838b18 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/layout/UnionLayoutImpl.java +++ b/src/java.base/share/classes/jdk/internal/foreign/layout/UnionLayoutImpl.java @@ -32,21 +32,21 @@ import java.util.Optional; public final class UnionLayoutImpl extends AbstractGroupLayout implements UnionLayout { - private UnionLayoutImpl(List elements, long bitSize, long bitAlignment, long minBitAlignment, Optional name) { - super(Kind.UNION, elements, bitSize, bitAlignment, minBitAlignment, name); + private UnionLayoutImpl(List elements, long byteSize, long byteAlignment, long minByteAlignment, Optional name) { + super(Kind.UNION, elements, byteSize, byteAlignment, minByteAlignment, name); } @Override - UnionLayoutImpl dup(long bitAlignment, Optional name) { - return new UnionLayoutImpl(memberLayouts(), bitSize(), bitAlignment, minBitAlignment, name); + UnionLayoutImpl dup(long byteAlignment, Optional name) { + return new UnionLayoutImpl(memberLayouts(), byteSize(), byteAlignment, minByteAlignment, name); } public static UnionLayout of(List elements) { long size = 0; - long align = 8; + long align = 1; for (MemoryLayout elem : elements) { - size = Math.max(size, elem.bitSize()); - align = Math.max(align, elem.bitAlignment()); + size = Math.max(size, elem.byteSize()); + align = Math.max(align, elem.byteAlignment()); } return new UnionLayoutImpl(elements, size, align, align, Optional.empty()); } diff --git a/src/java.base/share/classes/jdk/internal/foreign/layout/ValueLayouts.java b/src/java.base/share/classes/jdk/internal/foreign/layout/ValueLayouts.java index 796ce70ff47..57016f548c4 100644 --- a/src/java.base/share/classes/jdk/internal/foreign/layout/ValueLayouts.java +++ b/src/java.base/share/classes/jdk/internal/foreign/layout/ValueLayouts.java @@ -46,7 +46,7 @@ import java.util.Optional; /** * A value layout. A value layout is used to model the memory layout associated with values of basic data types, such as integral types - * (either signed or unsigned) and floating-point types. Each value layout has a size, an alignment (in bits), + * (either signed or unsigned) and floating-point types. Each value layout has a size, an alignment (expressed in bytes), * a {@linkplain ByteOrder byte order}, and a carrier, that is, the Java type that should be used when * {@linkplain MemorySegment#get(ValueLayout.OfInt, long) accessing} a memory region using the value layout. *

    @@ -64,18 +64,18 @@ public final class ValueLayouts { abstract sealed static class AbstractValueLayout & ValueLayout> extends AbstractLayout { - static final int ADDRESS_SIZE_BITS = Unsafe.ADDRESS_SIZE * 8; + static final int ADDRESS_SIZE_BYTES = Unsafe.ADDRESS_SIZE; private final Class carrier; private final ByteOrder order; @Stable private VarHandle handle; - AbstractValueLayout(Class carrier, ByteOrder order, long bitSize, long bitAlignment, Optional name) { - super(bitSize, bitAlignment, name); + AbstractValueLayout(Class carrier, ByteOrder order, long byteSize, long byteAlignment, Optional name) { + super(byteSize, byteAlignment, name); this.carrier = carrier; this.order = order; - assertCarrierSize(carrier, bitSize); + assertCarrierSize(carrier, byteSize); } /** @@ -94,7 +94,7 @@ public final class ValueLayouts { */ public final V withOrder(ByteOrder order) { Objects.requireNonNull(order); - return dup(order, bitAlignment(), name()); + return dup(order, byteAlignment(), name()); } @Override @@ -103,7 +103,7 @@ public final class ValueLayouts { if (order == ByteOrder.LITTLE_ENDIAN) { descriptor = Character.toLowerCase(descriptor); } - return decorateLayoutString(String.format("%s%d", descriptor, bitSize())); + return decorateLayoutString(String.format("%s%d", descriptor, byteSize())); } @Override @@ -143,20 +143,21 @@ public final class ValueLayouts { } @Override - final V dup(long bitAlignment, Optional name) { - return dup(order(), bitAlignment, name); + final V dup(long byteAlignment, Optional name) { + return dup(order(), byteAlignment, name); } - abstract V dup(ByteOrder order, long bitAlignment, Optional name); + abstract V dup(ByteOrder order, long byteAlignment, Optional name); - static void assertCarrierSize(Class carrier, long bitSize) { + static void assertCarrierSize(Class carrier, long byteSize) { assert isValidCarrier(carrier); assert carrier != MemorySegment.class - // MemorySegment bitSize must always equal ADDRESS_SIZE_BITS - || bitSize == ADDRESS_SIZE_BITS; + // MemorySegment byteSize must always equal ADDRESS_SIZE_BYTES + || byteSize == ADDRESS_SIZE_BYTES; assert !carrier.isPrimitive() || - // Primitive class bitSize must always correspond - bitSize == (carrier == boolean.class ? 8 : Wrapper.forPrimitiveType(carrier).bitWidth()); + // Primitive class byteSize must always correspond + byteSize == (carrier == boolean.class ? 1 : + Utils.byteWidthOfPrimitive(carrier)); } static boolean isValidCarrier(Class carrier) { @@ -189,129 +190,129 @@ public final class ValueLayouts { public static final class OfBooleanImpl extends AbstractValueLayout implements ValueLayout.OfBoolean { - private OfBooleanImpl(ByteOrder order, long bitAlignment, Optional name) { - super(boolean.class, order, Byte.SIZE, bitAlignment, name); + private OfBooleanImpl(ByteOrder order, long byteAlignment, Optional name) { + super(boolean.class, order, Byte.BYTES, byteAlignment, name); } @Override - OfBooleanImpl dup(ByteOrder order, long bitAlignment, Optional name) { - return new OfBooleanImpl(order, bitAlignment, name); + OfBooleanImpl dup(ByteOrder order, long byteAlignment, Optional name) { + return new OfBooleanImpl(order, byteAlignment, name); } public static OfBoolean of(ByteOrder order) { - return new OfBooleanImpl(order, Byte.SIZE, Optional.empty()); + return new OfBooleanImpl(order, Byte.BYTES, Optional.empty()); } } public static final class OfByteImpl extends AbstractValueLayout implements ValueLayout.OfByte { - private OfByteImpl(ByteOrder order, long bitAlignment, Optional name) { - super(byte.class, order, Byte.SIZE, bitAlignment, name); + private OfByteImpl(ByteOrder order, long byteAlignment, Optional name) { + super(byte.class, order, Byte.BYTES, byteAlignment, name); } @Override - OfByteImpl dup(ByteOrder order, long bitAlignment, Optional name) { - return new OfByteImpl(order, bitAlignment, name); + OfByteImpl dup(ByteOrder order, long byteAlignment, Optional name) { + return new OfByteImpl(order, byteAlignment, name); } public static OfByte of(ByteOrder order) { - return new OfByteImpl(order, Byte.SIZE, Optional.empty()); + return new OfByteImpl(order, Byte.BYTES, Optional.empty()); } } public static final class OfCharImpl extends AbstractValueLayout implements ValueLayout.OfChar { - private OfCharImpl(ByteOrder order, long bitAlignment, Optional name) { - super(char.class, order, Character.SIZE, bitAlignment, name); + private OfCharImpl(ByteOrder order, long byteAlignment, Optional name) { + super(char.class, order, Character.BYTES, byteAlignment, name); } @Override - OfCharImpl dup(ByteOrder order, long bitAlignment, Optional name) { - return new OfCharImpl(order, bitAlignment, name); + OfCharImpl dup(ByteOrder order, long byteAlignment, Optional name) { + return new OfCharImpl(order, byteAlignment, name); } public static OfChar of(ByteOrder order) { - return new OfCharImpl(order, Character.SIZE, Optional.empty()); + return new OfCharImpl(order, Character.BYTES, Optional.empty()); } } public static final class OfShortImpl extends AbstractValueLayout implements ValueLayout.OfShort { - private OfShortImpl(ByteOrder order, long bitAlignment, Optional name) { - super(short.class, order, Short.SIZE, bitAlignment, name); + private OfShortImpl(ByteOrder order, long byteAlignment, Optional name) { + super(short.class, order, Short.BYTES, byteAlignment, name); } @Override - OfShortImpl dup(ByteOrder order, long bitAlignment, Optional name) { - return new OfShortImpl(order, bitAlignment, name); + OfShortImpl dup(ByteOrder order, long byteAlignment, Optional name) { + return new OfShortImpl(order, byteAlignment, name); } public static OfShort of(ByteOrder order) { - return new OfShortImpl(order, Short.SIZE, Optional.empty()); + return new OfShortImpl(order, Short.BYTES, Optional.empty()); } } public static final class OfIntImpl extends AbstractValueLayout implements ValueLayout.OfInt { - private OfIntImpl(ByteOrder order, long bitAlignment, Optional name) { - super(int.class, order, Integer.SIZE, bitAlignment, name); + private OfIntImpl(ByteOrder order, long byteAlignment, Optional name) { + super(int.class, order, Integer.BYTES, byteAlignment, name); } @Override - OfIntImpl dup(ByteOrder order, long bitAlignment, Optional name) { - return new OfIntImpl(order, bitAlignment, name); + OfIntImpl dup(ByteOrder order, long byteAlignment, Optional name) { + return new OfIntImpl(order, byteAlignment, name); } public static OfInt of(ByteOrder order) { - return new OfIntImpl(order, Integer.SIZE, Optional.empty()); + return new OfIntImpl(order, Integer.BYTES, Optional.empty()); } } public static final class OfFloatImpl extends AbstractValueLayout implements ValueLayout.OfFloat { - private OfFloatImpl(ByteOrder order, long bitAlignment, Optional name) { - super(float.class, order, Float.SIZE, bitAlignment, name); + private OfFloatImpl(ByteOrder order, long byteAlignment, Optional name) { + super(float.class, order, Float.BYTES, byteAlignment, name); } @Override - OfFloatImpl dup(ByteOrder order, long bitAlignment, Optional name) { - return new OfFloatImpl(order, bitAlignment, name); + OfFloatImpl dup(ByteOrder order, long byteAlignment, Optional name) { + return new OfFloatImpl(order, byteAlignment, name); } public static OfFloat of(ByteOrder order) { - return new OfFloatImpl(order, Float.SIZE, Optional.empty()); + return new OfFloatImpl(order, Float.BYTES, Optional.empty()); } } public static final class OfLongImpl extends AbstractValueLayout implements ValueLayout.OfLong { - private OfLongImpl(ByteOrder order, long bitAlignment, Optional name) { - super(long.class, order, Long.SIZE, bitAlignment, name); + private OfLongImpl(ByteOrder order, long byteAlignment, Optional name) { + super(long.class, order, Long.BYTES, byteAlignment, name); } @Override - OfLongImpl dup(ByteOrder order, long bitAlignment, Optional name) { - return new OfLongImpl(order, bitAlignment, name); + OfLongImpl dup(ByteOrder order, long byteAlignment, Optional name) { + return new OfLongImpl(order, byteAlignment, name); } public static OfLong of(ByteOrder order) { - return new OfLongImpl(order, ADDRESS_SIZE_BITS, Optional.empty()); + return new OfLongImpl(order, ADDRESS_SIZE_BYTES, Optional.empty()); } } public static final class OfDoubleImpl extends AbstractValueLayout implements ValueLayout.OfDouble { - private OfDoubleImpl(ByteOrder order, long bitAlignment, Optional name) { - super(double.class, order, Double.SIZE, bitAlignment, name); + private OfDoubleImpl(ByteOrder order, long byteAlignment, Optional name) { + super(double.class, order, Double.BYTES, byteAlignment, name); } @Override - OfDoubleImpl dup(ByteOrder order, long bitAlignment, Optional name) { - return new OfDoubleImpl(order, bitAlignment, name); + OfDoubleImpl dup(ByteOrder order, long byteAlignment, Optional name) { + return new OfDoubleImpl(order, byteAlignment, name); } public static OfDouble of(ByteOrder order) { - return new OfDoubleImpl(order, ADDRESS_SIZE_BITS, Optional.empty()); + return new OfDoubleImpl(order, ADDRESS_SIZE_BYTES, Optional.empty()); } } @@ -320,14 +321,14 @@ public final class ValueLayouts { private final MemoryLayout targetLayout; - private OfAddressImpl(ByteOrder order, long bitSize, long bitAlignment, MemoryLayout targetLayout, Optional name) { - super(MemorySegment.class, order, bitSize, bitAlignment, name); + private OfAddressImpl(ByteOrder order, long byteSize, long byteAlignment, MemoryLayout targetLayout, Optional name) { + super(MemorySegment.class, order, byteSize, byteAlignment, name); this.targetLayout = targetLayout; } @Override - OfAddressImpl dup(ByteOrder order, long bitAlignment, Optional name) { - return new OfAddressImpl(order, bitSize(), bitAlignment,targetLayout, name); + OfAddressImpl dup(ByteOrder order, long byteAlignment, Optional name) { + return new OfAddressImpl(order, byteSize(), byteAlignment,targetLayout, name); } @Override @@ -346,12 +347,12 @@ public final class ValueLayouts { public AddressLayout withTargetLayout(MemoryLayout layout) { Reflection.ensureNativeAccess(Reflection.getCallerClass(), AddressLayout.class, "withTargetLayout"); Objects.requireNonNull(layout); - return new OfAddressImpl(order(), bitSize(), bitAlignment(), layout, name()); + return new OfAddressImpl(order(), byteSize(), byteAlignment(), layout, name()); } @Override public AddressLayout withoutTargetLayout() { - return new OfAddressImpl(order(), bitSize(), bitAlignment(), null, name()); + return new OfAddressImpl(order(), byteSize(), byteAlignment(), null, name()); } @Override @@ -360,7 +361,7 @@ public final class ValueLayouts { } public static AddressLayout of(ByteOrder order) { - return new OfAddressImpl(order, ADDRESS_SIZE_BITS, ADDRESS_SIZE_BITS, null, Optional.empty()); + return new OfAddressImpl(order, ADDRESS_SIZE_BYTES, ADDRESS_SIZE_BYTES, null, Optional.empty()); } @Override @@ -369,7 +370,7 @@ public final class ValueLayouts { if (order() == ByteOrder.LITTLE_ENDIAN) { descriptor = Character.toLowerCase(descriptor); } - String str = decorateLayoutString(String.format("%s%d", descriptor, bitSize())); + String str = decorateLayoutString(String.format("%s%d", descriptor, byteSize())); if (targetLayout != null) { str += ":" + targetLayout; } diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java index 87a70e8c28e..aa1768d37ef 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ByteVector.java @@ -57,7 +57,7 @@ public abstract class ByteVector extends AbstractVector { static final int FORBID_OPCODE_KIND = VO_ONLYFP; - static final ValueLayout.OfByte ELEMENT_LAYOUT = ValueLayout.JAVA_BYTE.withBitAlignment(8); + static final ValueLayout.OfByte ELEMENT_LAYOUT = ValueLayout.JAVA_BYTE.withByteAlignment(1); @ForceInline static int opCode(Operator op) { @@ -3302,7 +3302,7 @@ public abstract class ByteVector extends AbstractVector { * byte[] ar = new byte[species.length()]; * for (int n = 0; n < ar.length; n++) { * if (m.laneIsSet(n)) { - * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_BYTE.withBitAlignment(8), n); + * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_BYTE.withByteAlignment(1), n); * } * } * ByteVector r = ByteVector.fromArray(species, ar, 0); diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java index 1f4c0a49d45..99c34e0c770 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/DoubleVector.java @@ -57,7 +57,7 @@ public abstract class DoubleVector extends AbstractVector { static final int FORBID_OPCODE_KIND = VO_NOFP; - static final ValueLayout.OfDouble ELEMENT_LAYOUT = ValueLayout.JAVA_DOUBLE.withBitAlignment(8); + static final ValueLayout.OfDouble ELEMENT_LAYOUT = ValueLayout.JAVA_DOUBLE.withByteAlignment(1); @ForceInline static int opCode(Operator op) { @@ -2985,7 +2985,7 @@ public abstract class DoubleVector extends AbstractVector { * double[] ar = new double[species.length()]; * for (int n = 0; n < ar.length; n++) { * if (m.laneIsSet(n)) { - * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_DOUBLE.withBitAlignment(8), n); + * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_DOUBLE.withByteAlignment(1), n); * } * } * DoubleVector r = DoubleVector.fromArray(species, ar, 0); diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java index e86523870ad..9e2fb5e7479 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatVector.java @@ -57,7 +57,7 @@ public abstract class FloatVector extends AbstractVector { static final int FORBID_OPCODE_KIND = VO_NOFP; - static final ValueLayout.OfFloat ELEMENT_LAYOUT = ValueLayout.JAVA_FLOAT.withBitAlignment(8); + static final ValueLayout.OfFloat ELEMENT_LAYOUT = ValueLayout.JAVA_FLOAT.withByteAlignment(1); @ForceInline static int opCode(Operator op) { @@ -2991,7 +2991,7 @@ public abstract class FloatVector extends AbstractVector { * float[] ar = new float[species.length()]; * for (int n = 0; n < ar.length; n++) { * if (m.laneIsSet(n)) { - * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_FLOAT.withBitAlignment(8), n); + * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_FLOAT.withByteAlignment(1), n); * } * } * FloatVector r = FloatVector.fromArray(species, ar, 0); diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java index a6faa907387..5df7db83d37 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/IntVector.java @@ -57,7 +57,7 @@ public abstract class IntVector extends AbstractVector { static final int FORBID_OPCODE_KIND = VO_ONLYFP; - static final ValueLayout.OfInt ELEMENT_LAYOUT = ValueLayout.JAVA_INT.withBitAlignment(8); + static final ValueLayout.OfInt ELEMENT_LAYOUT = ValueLayout.JAVA_INT.withByteAlignment(1); @ForceInline static int opCode(Operator op) { @@ -3147,7 +3147,7 @@ public abstract class IntVector extends AbstractVector { * int[] ar = new int[species.length()]; * for (int n = 0; n < ar.length; n++) { * if (m.laneIsSet(n)) { - * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_INT.withBitAlignment(8), n); + * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_INT.withByteAlignment(1), n); * } * } * IntVector r = IntVector.fromArray(species, ar, 0); diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java index bbaa8fdb799..b86225cd9f4 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java @@ -57,7 +57,7 @@ public abstract class LongVector extends AbstractVector { static final int FORBID_OPCODE_KIND = VO_ONLYFP; - static final ValueLayout.OfLong ELEMENT_LAYOUT = ValueLayout.JAVA_LONG.withBitAlignment(8); + static final ValueLayout.OfLong ELEMENT_LAYOUT = ValueLayout.JAVA_LONG.withByteAlignment(1); @ForceInline static int opCode(Operator op) { @@ -3026,7 +3026,7 @@ public abstract class LongVector extends AbstractVector { * long[] ar = new long[species.length()]; * for (int n = 0; n < ar.length; n++) { * if (m.laneIsSet(n)) { - * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_LONG.withBitAlignment(8), n); + * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_LONG.withByteAlignment(1), n); * } * } * LongVector r = LongVector.fromArray(species, ar, 0); diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java index 8b08f766588..02f44a7b49c 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/ShortVector.java @@ -57,7 +57,7 @@ public abstract class ShortVector extends AbstractVector { static final int FORBID_OPCODE_KIND = VO_ONLYFP; - static final ValueLayout.OfShort ELEMENT_LAYOUT = ValueLayout.JAVA_SHORT.withBitAlignment(8); + static final ValueLayout.OfShort ELEMENT_LAYOUT = ValueLayout.JAVA_SHORT.withByteAlignment(1); @ForceInline static int opCode(Operator op) { @@ -3296,7 +3296,7 @@ public abstract class ShortVector extends AbstractVector { * short[] ar = new short[species.length()]; * for (int n = 0; n < ar.length; n++) { * if (m.laneIsSet(n)) { - * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_SHORT.withBitAlignment(8), n); + * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_SHORT.withByteAlignment(1), n); * } * } * ShortVector r = ShortVector.fromArray(species, ar, 0); diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-Vector.java.template b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-Vector.java.template index af7ff88f489..dc705580028 100644 --- a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-Vector.java.template +++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/X-Vector.java.template @@ -61,7 +61,7 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { static final int FORBID_OPCODE_KIND = VO_ONLYFP; #end[FP] - static final ValueLayout.Of$Type$ ELEMENT_LAYOUT = ValueLayout.JAVA_$TYPE$.withBitAlignment(8); + static final ValueLayout.Of$Type$ ELEMENT_LAYOUT = ValueLayout.JAVA_$TYPE$.withByteAlignment(1); @ForceInline static int opCode(Operator op) { @@ -4098,7 +4098,7 @@ public abstract class $abstractvectortype$ extends AbstractVector<$Boxtype$> { * $type$[] ar = new $type$[species.length()]; * for (int n = 0; n < ar.length; n++) { * if (m.laneIsSet(n)) { - * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_$TYPE$.withBitAlignment(8), n); + * ar[n] = slice.getAtIndex(ValuaLayout.JAVA_$TYPE$.withByteAlignment(1), n); * } * } * $abstractvectortype$ r = $abstractvectortype$.fromArray(species, ar, 0); diff --git a/test/jdk/java/foreign/MemoryLayoutTypeRetentionTest.java b/test/jdk/java/foreign/MemoryLayoutTypeRetentionTest.java index 35c655af3eb..70e0aa1f6eb 100644 --- a/test/jdk/java/foreign/MemoryLayoutTypeRetentionTest.java +++ b/test/jdk/java/foreign/MemoryLayoutTypeRetentionTest.java @@ -41,7 +41,7 @@ public class MemoryLayoutTypeRetentionTest { // withName() et al. should return the same type as the original object. private static final String NAME = "a"; - private static final long BIT_ALIGNMENT = Byte.SIZE; + private static final long BYTE_ALIGNMENT = Byte.BYTES; private static final ByteOrder BYTE_ORDER = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN; @@ -49,7 +49,7 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testOfBoolean() { OfBoolean v = JAVA_BOOLEAN - .withBitAlignment(BIT_ALIGNMENT) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME) .withOrder(BYTE_ORDER); @@ -59,7 +59,7 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testOfByte() { OfByte v = JAVA_BYTE - .withBitAlignment(BIT_ALIGNMENT) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME) .withOrder(BYTE_ORDER); @@ -69,7 +69,7 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testOfShort() { OfShort v = JAVA_SHORT - .withBitAlignment(BIT_ALIGNMENT) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME) .withOrder(BYTE_ORDER); @@ -79,7 +79,7 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testOfInt() { OfInt v = JAVA_INT - .withBitAlignment(BIT_ALIGNMENT) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME) .withOrder(BYTE_ORDER); @@ -89,7 +89,7 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testOfChar() { OfChar v = JAVA_CHAR - .withBitAlignment(BIT_ALIGNMENT) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME) .withOrder(BYTE_ORDER); @@ -99,7 +99,7 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testOfLong() { OfLong v = JAVA_LONG - .withBitAlignment(BIT_ALIGNMENT) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME) .withOrder(BYTE_ORDER); @@ -109,7 +109,7 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testOfFloat() { OfFloat v = JAVA_FLOAT - .withBitAlignment(BIT_ALIGNMENT) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME) .withOrder(BYTE_ORDER); @@ -119,7 +119,7 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testOfDouble() { OfDouble v = JAVA_DOUBLE - .withBitAlignment(BIT_ALIGNMENT) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME) .withOrder(BYTE_ORDER); @@ -129,7 +129,7 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testValueLayout() { ValueLayout v = ((ValueLayout) JAVA_INT) - .withBitAlignment(BIT_ALIGNMENT) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME) .withOrder(BYTE_ORDER); @@ -139,7 +139,7 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testAddressLayout() { AddressLayout v = ADDRESS - .withBitAlignment(BIT_ALIGNMENT) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME) .withoutTargetLayout() @@ -156,8 +156,8 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testPaddingLayout() { - PaddingLayout v = MemoryLayout.paddingLayout(8) - .withBitAlignment(BIT_ALIGNMENT) + PaddingLayout v = MemoryLayout.paddingLayout(1) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME); check(v); @@ -166,9 +166,9 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testGroupLayout() { GroupLayout v = MemoryLayout.structLayout( - JAVA_INT.withBitAlignment(BIT_ALIGNMENT), - JAVA_LONG.withBitAlignment(BIT_ALIGNMENT)) - .withBitAlignment(BIT_ALIGNMENT) + JAVA_INT.withByteAlignment(BYTE_ALIGNMENT), + JAVA_LONG.withByteAlignment(BYTE_ALIGNMENT)) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME); check(v); @@ -177,9 +177,9 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testStructLayout() { StructLayout v = MemoryLayout.structLayout( - JAVA_INT.withBitAlignment(BIT_ALIGNMENT), - JAVA_LONG.withBitAlignment(BIT_ALIGNMENT)) - .withBitAlignment(BIT_ALIGNMENT) + JAVA_INT.withByteAlignment(BYTE_ALIGNMENT), + JAVA_LONG.withByteAlignment(BYTE_ALIGNMENT)) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME); check(v); @@ -188,9 +188,9 @@ public class MemoryLayoutTypeRetentionTest { @Test public void testUnionLayout() { UnionLayout v = MemoryLayout.unionLayout( - JAVA_INT.withBitAlignment(BIT_ALIGNMENT), - JAVA_LONG.withBitAlignment(BIT_ALIGNMENT)) - .withBitAlignment(BIT_ALIGNMENT) + JAVA_INT.withByteAlignment(BYTE_ALIGNMENT), + JAVA_LONG.withByteAlignment(BYTE_ALIGNMENT)) + .withByteAlignment(BYTE_ALIGNMENT) .withoutName() .withName(NAME); check(v); @@ -206,8 +206,7 @@ public class MemoryLayoutTypeRetentionTest { assertEquals(v.name().orElseThrow(), NAME); assertTrue(v.withoutName().name().isEmpty()); - assertEquals(v.bitAlignment(), BIT_ALIGNMENT); - assertEquals(v.byteSize() * 8, v.bitSize()); + assertEquals(v.byteAlignment(), BYTE_ALIGNMENT); } } diff --git a/test/jdk/java/foreign/NativeTestHelper.java b/test/jdk/java/foreign/NativeTestHelper.java index 0d18097efcf..0ea7dfe89f2 100644 --- a/test/jdk/java/foreign/NativeTestHelper.java +++ b/test/jdk/java/foreign/NativeTestHelper.java @@ -100,28 +100,28 @@ public class NativeTestHelper { /** * The layout for the {@code short} C type */ - public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT.withBitAlignment(16); + public static final ValueLayout.OfShort C_SHORT = ValueLayout.JAVA_SHORT; /** * The layout for the {@code int} C type */ - public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT.withBitAlignment(32); + public static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT; /** * The layout for the {@code long long} C type. */ - public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG.withBitAlignment(64); + public static final ValueLayout.OfLong C_LONG_LONG = ValueLayout.JAVA_LONG; /** * The layout for the {@code float} C type */ - public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT.withBitAlignment(32); + public static final ValueLayout.OfFloat C_FLOAT = ValueLayout.JAVA_FLOAT; /** * The layout for the {@code double} C type */ - public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE.withBitAlignment(64); + public static final ValueLayout.OfDouble C_DOUBLE = ValueLayout.JAVA_DOUBLE; /** * The {@code T*} native type. */ - public static final AddressLayout C_POINTER = ValueLayout.ADDRESS.withBitAlignment(64) + public static final AddressLayout C_POINTER = ValueLayout.ADDRESS .withTargetLayout(MemoryLayout.sequenceLayout(C_CHAR)); public static final Linker LINKER = Linker.nativeLinker(); diff --git a/test/jdk/java/foreign/StdLibTest.java b/test/jdk/java/foreign/StdLibTest.java index d443a97a915..86136f605b1 100644 --- a/test/jdk/java/foreign/StdLibTest.java +++ b/test/jdk/java/foreign/StdLibTest.java @@ -233,7 +233,7 @@ public class StdLibTest extends NativeTestHelper { C_INT.withName("wday"), C_INT.withName("yday"), C_BOOL.withName("isdst"), - MemoryLayout.paddingLayout(24) + MemoryLayout.paddingLayout(3) ); Tm(MemorySegment addr) { diff --git a/test/jdk/java/foreign/TestArrayCopy.java b/test/jdk/java/foreign/TestArrayCopy.java index fd6b5b8a2cd..2a2b740cd91 100644 --- a/test/jdk/java/foreign/TestArrayCopy.java +++ b/test/jdk/java/foreign/TestArrayCopy.java @@ -254,13 +254,13 @@ public class TestArrayCopy { @Test(expectedExceptions = IllegalArgumentException.class) public void testHyperAlignedSrc() { MemorySegment segment = MemorySegment.ofArray(new byte[] {1, 2, 3, 4}); - MemorySegment.copy(new byte[] { 1, 2, 3, 4 }, 0, segment, JAVA_BYTE.withBitAlignment(16), 0, 4); + MemorySegment.copy(new byte[] { 1, 2, 3, 4 }, 0, segment, JAVA_BYTE.withByteAlignment(2), 0, 4); } @Test(expectedExceptions = IllegalArgumentException.class) public void testHyperAlignedDst() { MemorySegment segment = MemorySegment.ofArray(new byte[] {1, 2, 3, 4}); - MemorySegment.copy(segment, JAVA_BYTE.withBitAlignment(16), 0, new byte[] { 1, 2, 3, 4 }, 0, 4); + MemorySegment.copy(segment, JAVA_BYTE.withByteAlignment(2), 0, new byte[] { 1, 2, 3, 4 }, 0, 4); } /***** Utilities *****/ @@ -328,7 +328,7 @@ public class TestArrayCopy { @SuppressWarnings("unchecked") public CopyHelper(L elementLayout, Class carrier) { - this.elementLayout = (L)elementLayout.withBitAlignment(8); + this.elementLayout = (L)elementLayout.withByteAlignment(1); this.carrier = carrier; } diff --git a/test/jdk/java/foreign/TestByteBuffer.java b/test/jdk/java/foreign/TestByteBuffer.java index fdd7e60f95a..e3aba287272 100644 --- a/test/jdk/java/foreign/TestByteBuffer.java +++ b/test/jdk/java/foreign/TestByteBuffer.java @@ -77,13 +77,7 @@ import org.testng.SkipException; import org.testng.annotations.*; import sun.nio.ch.DirectBuffer; -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.foreign.ValueLayout.*; import static org.testng.Assert.*; public class TestByteBuffer { @@ -102,12 +96,12 @@ 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 final ValueLayout.OfChar BB_CHAR = JAVA_CHAR_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN); + static final ValueLayout.OfShort BB_SHORT = JAVA_SHORT_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN); + static final ValueLayout.OfInt BB_INT = JAVA_INT_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN); + static final ValueLayout.OfLong BB_LONG = JAVA_LONG_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN); + static final ValueLayout.OfFloat BB_FLOAT = JAVA_FLOAT_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN); + static final ValueLayout.OfDouble BB_DOUBLE = JAVA_DOUBLE_UNALIGNED.withOrder(ByteOrder.BIG_ENDIAN); static SequenceLayout tuples = MemoryLayout.sequenceLayout(500, MemoryLayout.structLayout( @@ -385,7 +379,7 @@ public class TestByteBuffer { } static void checkByteArrayAlignment(MemoryLayout layout) { - if (layout.bitSize() > 32 + if (layout.byteSize() > 4 && System.getProperty("sun.arch.data.model").equals("32")) { throw new SkipException("avoid unaligned access on 32-bit system"); } diff --git a/test/jdk/java/foreign/TestFunctionDescriptor.java b/test/jdk/java/foreign/TestFunctionDescriptor.java index 8482181230d..54b212df472 100644 --- a/test/jdk/java/foreign/TestFunctionDescriptor.java +++ b/test/jdk/java/foreign/TestFunctionDescriptor.java @@ -125,7 +125,7 @@ public class TestFunctionDescriptor extends NativeTestHelper { C_INT, MemoryLayout.structLayout(C_INT, C_INT), MemoryLayout.sequenceLayout(3, C_INT), - MemoryLayout.paddingLayout(32)); + MemoryLayout.paddingLayout(4)); fd.toMethodType(); // should throw } @@ -143,27 +143,27 @@ public class TestFunctionDescriptor extends NativeTestHelper { @Test(expectedExceptions = IllegalArgumentException.class) public void testBadPaddingInVoidFunction() { - FunctionDescriptor.ofVoid(MemoryLayout.paddingLayout(8)); + FunctionDescriptor.ofVoid(MemoryLayout.paddingLayout(1)); } @Test(expectedExceptions = IllegalArgumentException.class) public void testBadPaddingInNonVoidFunction() { - FunctionDescriptor.of(MemoryLayout.paddingLayout(8)); + FunctionDescriptor.of(MemoryLayout.paddingLayout(1)); } @Test(expectedExceptions = IllegalArgumentException.class) public void testBadPaddingInAppendArgLayouts() { - FunctionDescriptor.ofVoid().appendArgumentLayouts(MemoryLayout.paddingLayout(8)); + FunctionDescriptor.ofVoid().appendArgumentLayouts(MemoryLayout.paddingLayout(1)); } @Test(expectedExceptions = IllegalArgumentException.class) public void testBadPaddingInInsertArgLayouts() { - FunctionDescriptor.ofVoid().insertArgumentLayouts(0, MemoryLayout.paddingLayout(8)); + FunctionDescriptor.ofVoid().insertArgumentLayouts(0, MemoryLayout.paddingLayout(1)); } @Test(expectedExceptions = IllegalArgumentException.class) public void testBadPaddingInChangeRetLayout() { - FunctionDescriptor.ofVoid().changeReturnLayout(MemoryLayout.paddingLayout(8)); + FunctionDescriptor.ofVoid().changeReturnLayout(MemoryLayout.paddingLayout(1)); } } diff --git a/test/jdk/java/foreign/TestHeapAlignment.java b/test/jdk/java/foreign/TestHeapAlignment.java index d51b47ae94a..abe22fb5923 100644 --- a/test/jdk/java/foreign/TestHeapAlignment.java +++ b/test/jdk/java/foreign/TestHeapAlignment.java @@ -85,14 +85,6 @@ public class TestHeapAlignment { } } - static final ValueLayout.OfChar JAVA_CHAR_ALIGNED = ValueLayout.JAVA_CHAR.withBitAlignment(16); - static final ValueLayout.OfShort JAVA_SHORT_ALIGNED = ValueLayout.JAVA_SHORT.withBitAlignment(16); - static final ValueLayout.OfInt JAVA_INT_ALIGNED = ValueLayout.JAVA_INT.withBitAlignment(32); - static final ValueLayout.OfFloat JAVA_FLOAT_ALIGNED = ValueLayout.JAVA_FLOAT.withBitAlignment(32); - static final ValueLayout.OfLong JAVA_LONG_ALIGNED = ValueLayout.JAVA_LONG.withBitAlignment(64); - static final ValueLayout.OfDouble JAVA_DOUBLE_ALIGNED = ValueLayout.JAVA_DOUBLE.withBitAlignment(64); - static final AddressLayout ADDRESS_ALIGNED = ValueLayout.ADDRESS.withBitAlignment(ValueLayout.ADDRESS.bitSize()); - enum SegmentAndAlignment { HEAP_BYTE(MemorySegment.ofArray(new byte[8]), 1), HEAP_SHORT(MemorySegment.ofArray(new short[4]), 2), @@ -118,13 +110,13 @@ public class TestHeapAlignment { for (SegmentAndAlignment testCase : SegmentAndAlignment.values()) { layouts.add(new Object[] { testCase.segment, testCase.align, (byte) 42, new byte[]{42}, ValueLayout.JAVA_BYTE, (Function)MemorySegment::ofArray }); layouts.add(new Object[] { testCase.segment, testCase.align, true, null, ValueLayout.JAVA_BOOLEAN, null }); - layouts.add(new Object[] { testCase.segment, testCase.align, (char) 42, new char[]{42}, JAVA_CHAR_ALIGNED, (Function)MemorySegment::ofArray }); - layouts.add(new Object[] { testCase.segment, testCase.align, (short) 42, new short[]{42}, JAVA_SHORT_ALIGNED, (Function)MemorySegment::ofArray }); - layouts.add(new Object[] { testCase.segment, testCase.align, 42, new int[]{42}, JAVA_INT_ALIGNED, (Function)MemorySegment::ofArray }); - layouts.add(new Object[] { testCase.segment, testCase.align, 42f, new float[]{42}, JAVA_FLOAT_ALIGNED, (Function)MemorySegment::ofArray }); - layouts.add(new Object[] { testCase.segment, testCase.align, 42L, new long[]{42}, JAVA_LONG_ALIGNED, (Function)MemorySegment::ofArray }); - layouts.add(new Object[] { testCase.segment, testCase.align, 42d, new double[]{42}, JAVA_DOUBLE_ALIGNED, (Function)MemorySegment::ofArray }); - layouts.add(new Object[] { testCase.segment, testCase.align, MemorySegment.ofAddress(42), null, ADDRESS_ALIGNED, null }); + layouts.add(new Object[] { testCase.segment, testCase.align, (char) 42, new char[]{42}, ValueLayout.JAVA_CHAR, (Function)MemorySegment::ofArray }); + layouts.add(new Object[] { testCase.segment, testCase.align, (short) 42, new short[]{42}, ValueLayout.JAVA_SHORT, (Function)MemorySegment::ofArray }); + layouts.add(new Object[] { testCase.segment, testCase.align, 42, new int[]{42}, ValueLayout.JAVA_INT, (Function)MemorySegment::ofArray }); + layouts.add(new Object[] { testCase.segment, testCase.align, 42f, new float[]{42}, ValueLayout.JAVA_FLOAT, (Function)MemorySegment::ofArray }); + layouts.add(new Object[] { testCase.segment, testCase.align, 42L, new long[]{42}, ValueLayout.JAVA_LONG, (Function)MemorySegment::ofArray }); + layouts.add(new Object[] { testCase.segment, testCase.align, 42d, new double[]{42}, ValueLayout.JAVA_DOUBLE, (Function)MemorySegment::ofArray }); + layouts.add(new Object[] { testCase.segment, testCase.align, MemorySegment.ofAddress(42), null, ValueLayout.ADDRESS, null }); } return layouts.toArray(new Object[0][]); } diff --git a/test/jdk/java/foreign/TestIllegalLink.java b/test/jdk/java/foreign/TestIllegalLink.java index f076789b579..ebaf3ab221d 100644 --- a/test/jdk/java/foreign/TestIllegalLink.java +++ b/test/jdk/java/foreign/TestIllegalLink.java @@ -111,52 +111,52 @@ public class TestIllegalLink extends NativeTestHelper { List cases = new ArrayList<>(Arrays.asList(new Object[][]{ { FunctionDescriptor.of(MemoryLayout.sequenceLayout(2, C_INT)), - "Unsupported layout: [2:i32]" + "Unsupported layout: [2:i4]" }, { FunctionDescriptor.ofVoid(MemoryLayout.sequenceLayout(2, C_INT)), - "Unsupported layout: [2:i32]" + "Unsupported layout: [2:i4]" }, { - FunctionDescriptor.ofVoid(C_INT.withBitAlignment(16)), - "Layout bit alignment must be natural alignment" + FunctionDescriptor.ofVoid(C_INT.withByteAlignment(2)), + "Layout alignment must be natural alignment" }, { - FunctionDescriptor.ofVoid(C_POINTER.withBitAlignment(16)), - "Layout bit alignment must be natural alignment" + FunctionDescriptor.ofVoid(C_POINTER.withByteAlignment(2)), + "Layout alignment must be natural alignment" }, { - FunctionDescriptor.ofVoid(ValueLayout.JAVA_CHAR.withBitAlignment(32)), - "Layout bit alignment must be natural alignment" + FunctionDescriptor.ofVoid(ValueLayout.JAVA_CHAR.withByteAlignment(4)), + "Layout alignment must be natural alignment" }, { FunctionDescriptor.ofVoid(MemoryLayout.structLayout( - C_CHAR.withName("x").withBitAlignment(8), - C_SHORT.withName("y").withBitAlignment(8), - C_INT.withName("z").withBitAlignment(8) - ).withBitAlignment(8)), - "Layout bit alignment must be natural alignment" + C_CHAR.withName("x").withByteAlignment(1), + C_SHORT.withName("y").withByteAlignment(1), + C_INT.withName("z").withByteAlignment(1) + ).withByteAlignment(1)), + "Layout alignment must be natural alignment" }, { FunctionDescriptor.ofVoid(MemoryLayout.structLayout( MemoryLayout.structLayout( - C_CHAR.withName("x").withBitAlignment(8), - C_SHORT.withName("y").withBitAlignment(8), - C_INT.withName("z").withBitAlignment(8) + C_CHAR.withName("x").withByteAlignment(1), + C_SHORT.withName("y").withByteAlignment(1), + C_INT.withName("z").withByteAlignment(1) ))), - "Layout bit alignment must be natural alignment" + "Layout alignment must be natural alignment" }, { FunctionDescriptor.ofVoid(MemoryLayout.structLayout( MemoryLayout.sequenceLayout( - C_INT.withBitAlignment(8) + C_INT.withByteAlignment(1) ))), - "Layout bit alignment must be natural alignment" + "Layout alignment must be natural alignment" }, { FunctionDescriptor.ofVoid(MemoryLayout.structLayout( ValueLayout.JAVA_INT, - MemoryLayout.paddingLayout(32), // no excess padding + MemoryLayout.paddingLayout(4), // no excess padding ValueLayout.JAVA_INT)), "unexpected offset" }, @@ -181,7 +181,7 @@ public class TestIllegalLink extends NativeTestHelper { { FunctionDescriptor.ofVoid(MemoryLayout.structLayout( ValueLayout.JAVA_INT, - MemoryLayout.paddingLayout(32))), // too much trailing padding + MemoryLayout.paddingLayout(4))), // too much trailing padding "has unexpected size" }, })); diff --git a/test/jdk/java/foreign/TestLayoutPaths.java b/test/jdk/java/foreign/TestLayoutPaths.java index 45692e8d4f0..bfa1cedb3fa 100644 --- a/test/jdk/java/foreign/TestLayoutPaths.java +++ b/test/jdk/java/foreign/TestLayoutPaths.java @@ -46,48 +46,24 @@ import static org.testng.Assert.*; public class TestLayoutPaths { - @Test(expectedExceptions = IllegalArgumentException.class) - public void testBadBitSelectFromSeq() { - SequenceLayout seq = MemoryLayout.sequenceLayout(5, JAVA_INT); - seq.bitOffset(groupElement("foo")); - } - @Test(expectedExceptions = IllegalArgumentException.class) public void testBadByteSelectFromSeq() { SequenceLayout seq = MemoryLayout.sequenceLayout(5, JAVA_INT); seq.byteOffset(groupElement("foo")); } - @Test(expectedExceptions = IllegalArgumentException.class) - public void testBadBitSelectFromStruct() { - GroupLayout g = MemoryLayout.structLayout(JAVA_INT); - g.bitOffset(sequenceElement()); - } - @Test(expectedExceptions = IllegalArgumentException.class) public void testBadByteSelectFromStruct() { GroupLayout g = MemoryLayout.structLayout(JAVA_INT); g.byteOffset(sequenceElement()); } - @Test(expectedExceptions = IllegalArgumentException.class) - public void testBadBitSelectFromValue() { - SequenceLayout seq = MemoryLayout.sequenceLayout(5, JAVA_INT); - seq.bitOffset(sequenceElement(), sequenceElement()); - } - @Test(expectedExceptions = IllegalArgumentException.class) public void testBadByteSelectFromValue() { SequenceLayout seq = MemoryLayout.sequenceLayout(5, JAVA_INT); seq.byteOffset(sequenceElement(), sequenceElement()); } - @Test(expectedExceptions = IllegalArgumentException.class) - public void testUnknownBitStructField() { - GroupLayout g = MemoryLayout.structLayout(JAVA_INT); - g.bitOffset(groupElement("foo")); - } - @Test(expectedExceptions = IllegalArgumentException.class) public void testUnknownByteStructField() { GroupLayout g = MemoryLayout.structLayout(JAVA_INT); @@ -106,12 +82,6 @@ public class TestLayoutPaths { g.byteOffset(groupElement(-1)); } - @Test(expectedExceptions = IllegalArgumentException.class) - public void testBitOutOfBoundsSeqIndex() { - SequenceLayout seq = MemoryLayout.sequenceLayout(5, JAVA_INT); - seq.bitOffset(sequenceElement(6)); - } - @Test(expectedExceptions = IllegalArgumentException.class) public void testByteOutOfBoundsSeqIndex() { SequenceLayout seq = MemoryLayout.sequenceLayout(5, JAVA_INT); @@ -123,12 +93,6 @@ public class TestLayoutPaths { sequenceElement(-2); } - @Test(expectedExceptions = IllegalArgumentException.class) - public void testBitNegativeSeqIndex() { - SequenceLayout seq = MemoryLayout.sequenceLayout(5, JAVA_INT); - seq.bitOffset(sequenceElement(-2)); - } - @Test(expectedExceptions = IllegalArgumentException.class) public void testByteNegativeSeqIndex() { SequenceLayout seq = MemoryLayout.sequenceLayout(5, JAVA_INT); @@ -138,7 +102,7 @@ public class TestLayoutPaths { @Test(expectedExceptions = IllegalArgumentException.class) public void testOutOfBoundsSeqRange() { SequenceLayout seq = MemoryLayout.sequenceLayout(5, JAVA_INT); - seq.bitOffset(sequenceElement(6, 2)); + seq.byteOffset(sequenceElement(6, 2)); } @Test(expectedExceptions = IllegalArgumentException.class) @@ -146,12 +110,6 @@ public class TestLayoutPaths { sequenceElement(-2, 2); } - @Test(expectedExceptions = IllegalArgumentException.class) - public void testBitNegativeSeqRange() { - SequenceLayout seq = MemoryLayout.sequenceLayout(5, JAVA_INT); - seq.bitOffset(sequenceElement(-2, 2)); - } - @Test(expectedExceptions = IllegalArgumentException.class) public void testByteNegativeSeqRange() { SequenceLayout seq = MemoryLayout.sequenceLayout(5, JAVA_INT); @@ -164,12 +122,6 @@ public class TestLayoutPaths { seq.varHandle(sequenceElement()); } - @Test(expectedExceptions = IllegalArgumentException.class) - public void testBitOffsetHandleBadRange() { - SequenceLayout seq = MemoryLayout.sequenceLayout(5, MemoryLayout.structLayout(JAVA_INT)); - seq.bitOffsetHandle(sequenceElement(0, 1)); // ranges not accepted - } - @Test(expectedExceptions = IllegalArgumentException.class) public void testByteOffsetHandleBadRange() { SequenceLayout seq = MemoryLayout.sequenceLayout(5, MemoryLayout.structLayout(JAVA_INT)); @@ -181,12 +133,6 @@ public class TestLayoutPaths { SequenceLayout seq = MemoryLayout.sequenceLayout(10, JAVA_INT); // bad path elements for (PathElement e : List.of( sequenceElement(), sequenceElement(0, 2) )) { - try { - seq.bitOffset(e); - fail(); - } catch (IllegalArgumentException ex) { - assertTrue(true); - } try { seq.byteOffset(e); fail(); @@ -211,12 +157,12 @@ public class TestLayoutPaths { @Test(dataProvider = "groupSelectors") public void testStructPaths(IntFunction groupSelector) { - long[] offsets = { 0, 8, 24, 56 }; + long[] offsets = { 0, 1, 3, 7 }; GroupLayout g = MemoryLayout.structLayout( ValueLayout.JAVA_BYTE.withName("0"), - ValueLayout.JAVA_CHAR.withBitAlignment(8).withName("1"), - ValueLayout.JAVA_FLOAT.withBitAlignment(8).withName("2"), - ValueLayout.JAVA_LONG.withBitAlignment(8).withName("3") + ValueLayout.JAVA_CHAR_UNALIGNED.withName("1"), + ValueLayout.JAVA_FLOAT_UNALIGNED.withName("2"), + ValueLayout.JAVA_LONG_UNALIGNED.withName("3") ); // test select @@ -229,10 +175,8 @@ public class TestLayoutPaths { // test offset for (int i = 0 ; i < 4 ; i++) { - long bitOffset = g.bitOffset(groupSelector.apply(i)); - assertEquals(offsets[i], bitOffset); long byteOffset = g.byteOffset(groupSelector.apply(i)); - assertEquals((offsets[i]) >>> 3, byteOffset); + assertEquals(offsets[i], byteOffset); } } @@ -256,10 +200,8 @@ public class TestLayoutPaths { // test offset for (int i = 0 ; i < 4 ; i++) { - long bitOffset = g.bitOffset(groupSelector.apply(i)); - assertEquals(offsets[i], bitOffset); long byteOffset = g.byteOffset(groupSelector.apply(i)); - assertEquals((offsets[i]) >>> 3, byteOffset); + assertEquals(offsets[i], byteOffset); } } @@ -273,7 +215,7 @@ public class TestLayoutPaths { @Test public void testSequencePaths() { - long[] offsets = { 0, 8, 16, 24 }; + long[] offsets = { 0, 1, 2, 3 }; SequenceLayout g = MemoryLayout.sequenceLayout(4, ValueLayout.JAVA_BYTE); // test select @@ -284,26 +226,18 @@ public class TestLayoutPaths { // test offset for (int i = 0 ; i < 4 ; i++) { - long bitOffset = g.bitOffset(sequenceElement(i)); - assertEquals(offsets[i], bitOffset); long byteOffset = g.byteOffset(sequenceElement(i)); - assertEquals((offsets[i]) >>> 3, byteOffset); + assertEquals(offsets[i], byteOffset); } } @Test(dataProvider = "testLayouts") public void testOffsetHandle(MemoryLayout layout, PathElement[] pathElements, long[] indexes, - long expectedBitOffset) throws Throwable { - MethodHandle bitOffsetHandle = layout.bitOffsetHandle(pathElements); - bitOffsetHandle = bitOffsetHandle.asSpreader(long[].class, indexes.length); - long actualBitOffset = (long) bitOffsetHandle.invokeExact(indexes); - assertEquals(actualBitOffset, expectedBitOffset); - if (expectedBitOffset % 8 == 0) { - MethodHandle byteOffsetHandle = layout.byteOffsetHandle(pathElements); - byteOffsetHandle = byteOffsetHandle.asSpreader(long[].class, indexes.length); - long actualByteOffset = (long) byteOffsetHandle.invokeExact(indexes); - assertEquals(actualByteOffset, expectedBitOffset / 8); - } + long expectedByteOffset) throws Throwable { + MethodHandle byteOffsetHandle = layout.byteOffsetHandle(pathElements); + byteOffsetHandle = byteOffsetHandle.asSpreader(long[].class, indexes.length); + long actualByteOffset = (long) byteOffsetHandle.invokeExact(indexes); + assertEquals(actualByteOffset, expectedByteOffset); } @DataProvider @@ -314,25 +248,25 @@ public class TestLayoutPaths { MemoryLayout.sequenceLayout(10, JAVA_INT), new PathElement[] { sequenceElement() }, new long[] { 4 }, - JAVA_INT.bitSize() * 4 + JAVA_INT.byteSize() * 4 }); testCases.add(new Object[] { MemoryLayout.sequenceLayout(10, MemoryLayout.structLayout(JAVA_INT, JAVA_INT.withName("y"))), new PathElement[] { sequenceElement(), groupElement("y") }, new long[] { 4 }, - (JAVA_INT.bitSize() * 2) * 4 + JAVA_INT.bitSize() + (JAVA_INT.byteSize() * 2) * 4 + JAVA_INT.byteSize() }); testCases.add(new Object[] { - MemoryLayout.sequenceLayout(10, MemoryLayout.structLayout(MemoryLayout.paddingLayout(32), JAVA_INT.withName("y"))), + MemoryLayout.sequenceLayout(10, MemoryLayout.structLayout(MemoryLayout.paddingLayout(4), JAVA_INT.withName("y"))), new PathElement[] { sequenceElement(), groupElement("y") }, new long[] { 4 }, - (JAVA_INT.bitSize() + 32) * 4 + 32 + (JAVA_INT.byteSize() + 4) * 4 + 4 }); testCases.add(new Object[] { MemoryLayout.sequenceLayout(10, JAVA_INT), new PathElement[] { sequenceElement() }, new long[] { 4 }, - JAVA_INT.bitSize() * 4 + JAVA_INT.byteSize() * 4 }); testCases.add(new Object[] { MemoryLayout.structLayout( @@ -340,7 +274,7 @@ public class TestLayoutPaths { ), new PathElement[] { groupElement("data"), sequenceElement() }, new long[] { 4 }, - JAVA_INT.bitSize() * 4 + JAVA_INT.byteSize() * 4 }); MemoryLayout complexLayout = MemoryLayout.structLayout( @@ -358,25 +292,25 @@ public class TestLayoutPaths { complexLayout, new PathElement[] { groupElement("data"), sequenceElement(), sequenceElement(), groupElement("x") }, new long[] { 0, 1 }, - (JAVA_INT.bitSize() * 2) + (JAVA_INT.byteSize() * 2) }); testCases.add(new Object[] { complexLayout, new PathElement[] { groupElement("data"), sequenceElement(), sequenceElement(), groupElement("x") }, new long[] { 1, 0 }, - (JAVA_INT.bitSize() * 2) * 10 + (JAVA_INT.byteSize() * 2) * 10 }); testCases.add(new Object[] { complexLayout, new PathElement[] { groupElement("data"), sequenceElement(), sequenceElement(), groupElement("y") }, new long[] { 0, 1 }, - (JAVA_INT.bitSize() * 2) + JAVA_INT.bitSize() + (JAVA_INT.byteSize() * 2) + JAVA_INT.byteSize() }); testCases.add(new Object[] { complexLayout, new PathElement[] { groupElement("data"), sequenceElement(), sequenceElement(), groupElement("y") }, new long[] { 1, 0 }, - (JAVA_INT.bitSize() * 2) * 10 + JAVA_INT.bitSize() + (JAVA_INT.byteSize() * 2) * 10 + JAVA_INT.byteSize() }); return testCases.toArray(Object[][]::new); @@ -384,10 +318,7 @@ public class TestLayoutPaths { @Test(dataProvider = "testLayouts") public void testSliceHandle(MemoryLayout layout, PathElement[] pathElements, long[] indexes, - long expectedBitOffset) throws Throwable { - if (expectedBitOffset % 8 != 0) - throw new SkipException("Offset not a multiple of 8"); - + long expectedByteOffset) throws Throwable { MemoryLayout selected = layout.select(pathElements); MethodHandle sliceHandle = layout.sliceHandle(pathElements); sliceHandle = sliceHandle.asSpreader(long[].class, indexes.length); @@ -395,7 +326,7 @@ public class TestLayoutPaths { try (Arena arena = Arena.ofConfined()) { MemorySegment segment = arena.allocate(layout); MemorySegment slice = (MemorySegment) sliceHandle.invokeExact(segment, indexes); - assertEquals(slice.address() - segment.address(), expectedBitOffset / 8); + assertEquals(slice.address() - segment.address(), expectedByteOffset); assertEquals(slice.byteSize(), selected.byteSize()); } } diff --git a/test/jdk/java/foreign/TestLayouts.java b/test/jdk/java/foreign/TestLayouts.java index a746c9a02b7..ebb7bcf0585 100644 --- a/test/jdk/java/foreign/TestLayouts.java +++ b/test/jdk/java/foreign/TestLayouts.java @@ -45,14 +45,14 @@ public class TestLayouts { @Test(dataProvider = "badAlignments", expectedExceptions = IllegalArgumentException.class) public void testBadLayoutAlignment(MemoryLayout layout, long alignment) { - layout.withBitAlignment(alignment); + layout.withByteAlignment(alignment); } @Test(dataProvider = "basicLayoutsAndAddressAndGroups") public void testEqualities(MemoryLayout layout) { // Use another Type - MemoryLayout differentType = MemoryLayout.paddingLayout(8); + MemoryLayout differentType = MemoryLayout.paddingLayout(1); assertFalse(layout.equals(differentType)); // Use another name @@ -60,7 +60,7 @@ public class TestLayouts { assertFalse(layout.equals(differentName)); // Use another alignment - MemoryLayout differentAlignment = layout.withBitAlignment(layout.bitAlignment() * 2); + MemoryLayout differentAlignment = layout.withByteAlignment(layout.byteAlignment() * 2); assertFalse(layout.equals(differentAlignment)); // Swap endian @@ -78,7 +78,7 @@ public class TestLayouts { assertFalse(layout.equals(MemoryLayout.sequenceLayout(13, JAVA_LONG))); - MemoryLayout other = layout.withBitAlignment(128).withBitAlignment(layout.bitAlignment()); + MemoryLayout other = layout.withByteAlignment(16).withByteAlignment(layout.byteAlignment()); assertTrue(layout.equals(other)); } @@ -124,37 +124,37 @@ public class TestLayouts { @Test(dataProvider = "basicLayoutsAndAddressAndGroups", expectedExceptions = IllegalArgumentException.class) public void testGroupIllegalAlignmentNotPowerOfTwo(MemoryLayout layout) { - layout.withBitAlignment(3); + layout.withByteAlignment(9); } @Test(dataProvider = "basicLayoutsAndAddressAndGroups", expectedExceptions = IllegalArgumentException.class) - public void testGroupIllegalAlignmentNotGreaterOrEqualTo8(MemoryLayout layout) { - layout.withBitAlignment(4); + public void testGroupIllegalAlignmentNotGreaterOrEqualTo1(MemoryLayout layout) { + layout.withByteAlignment(0); } @Test public void testEqualsPadding() { - PaddingLayout paddingLayout = MemoryLayout.paddingLayout(16); + PaddingLayout paddingLayout = MemoryLayout.paddingLayout(2); testEqualities(paddingLayout); - PaddingLayout paddingLayout2 = MemoryLayout.paddingLayout(32); + PaddingLayout paddingLayout2 = MemoryLayout.paddingLayout(4); assertNotEquals(paddingLayout, paddingLayout2); } @Test public void testEmptyGroup() { MemoryLayout struct = MemoryLayout.structLayout(); - assertEquals(struct.bitSize(), 0); - assertEquals(struct.bitAlignment(), 8); + assertEquals(struct.byteSize(), 0); + assertEquals(struct.byteAlignment(), 1); MemoryLayout union = MemoryLayout.unionLayout(); - assertEquals(union.bitSize(), 0); - assertEquals(union.bitAlignment(), 8); + assertEquals(union.byteSize(), 0); + assertEquals(union.byteAlignment(), 1); } @Test public void testStructSizeAndAlign() { MemoryLayout struct = MemoryLayout.structLayout( - MemoryLayout.paddingLayout(8), + MemoryLayout.paddingLayout(1), ValueLayout.JAVA_BYTE, ValueLayout.JAVA_CHAR, ValueLayout.JAVA_INT, @@ -166,21 +166,21 @@ public class TestLayouts { @Test(dataProvider="basicLayouts") public void testPaddingNoAlign(MemoryLayout layout) { - assertEquals(MemoryLayout.paddingLayout(layout.bitSize()).bitAlignment(), 8); + assertEquals(MemoryLayout.paddingLayout(layout.byteSize()).byteAlignment(), 1); } @Test(dataProvider="basicLayouts") public void testStructPaddingAndAlign(MemoryLayout layout) { MemoryLayout struct = MemoryLayout.structLayout( - layout, MemoryLayout.paddingLayout(128 - layout.bitSize())); - assertEquals(struct.bitAlignment(), layout.bitAlignment()); + layout, MemoryLayout.paddingLayout(16 - layout.byteSize())); + assertEquals(struct.byteAlignment(), layout.byteAlignment()); } @Test(dataProvider="basicLayouts") public void testUnionPaddingAndAlign(MemoryLayout layout) { MemoryLayout struct = MemoryLayout.unionLayout( - layout, MemoryLayout.paddingLayout(128 - layout.bitSize())); - assertEquals(struct.bitAlignment(), layout.bitAlignment()); + layout, MemoryLayout.paddingLayout(16 - layout.byteSize())); + assertEquals(struct.byteAlignment(), layout.byteAlignment()); } @Test @@ -204,7 +204,7 @@ public class TestLayouts { @Test(dataProvider = "basicLayouts") public void testSequenceInferredCount(MemoryLayout layout) { assertEquals(MemoryLayout.sequenceLayout(layout), - MemoryLayout.sequenceLayout(Long.MAX_VALUE / layout.bitSize(), layout)); + MemoryLayout.sequenceLayout(Long.MAX_VALUE / layout.byteSize(), layout)); } public void testSequenceNegativeElementCount() { @@ -233,23 +233,23 @@ public class TestLayouts { @Test public void testPadding() { - var padding = MemoryLayout.paddingLayout(8); + var padding = MemoryLayout.paddingLayout(1); assertEquals(padding.byteAlignment(), 1); } @Test public void testPaddingInStruct() { - var padding = MemoryLayout.paddingLayout(8); + var padding = MemoryLayout.paddingLayout(1); var struct = MemoryLayout.structLayout(padding); assertEquals(struct.byteAlignment(), 1); } @Test - public void testPaddingIllegalBitSize() { - for (long bitSize : List.of(-8L, -1L, 0L, 1L, 7L)) { + public void testPaddingIllegalByteSize() { + for (long byteSize : List.of(-1L, 0L)) { try { - MemoryLayout.paddingLayout(bitSize); - fail("bitSize cannot be " + bitSize); + MemoryLayout.paddingLayout(byteSize); + fail("byte size cannot be " + byteSize); } catch (IllegalArgumentException ignore) { // Happy path } @@ -259,9 +259,9 @@ public class TestLayouts { @Test public void testStructToString() { StructLayout padding = MemoryLayout.structLayout(JAVA_INT).withName("struct"); - assertEquals(padding.toString(), "[i32](struct)"); - var toStringUnaligned = padding.withBitAlignment(64).toString(); - assertEquals(toStringUnaligned, "64%[i32](struct)"); + assertEquals(padding.toString(), "[i4](struct)"); + var toStringUnaligned = padding.withByteAlignment(8).toString(); + assertEquals(toStringUnaligned, "8%[i4](struct)"); } @Test(dataProvider = "layoutKinds") @@ -270,36 +270,36 @@ public class TestLayouts { } @Test(dataProvider="layoutsAndAlignments") - public void testAlignmentString(MemoryLayout layout, long bitAlign) { - long[] alignments = { 8, 16, 32, 64, 128 }; + public void testAlignmentString(MemoryLayout layout, long byteAlign) { + long[] alignments = { 1, 2, 4, 8, 16 }; for (long a : alignments) { - if (layout.bitAlignment() == bitAlign) { + if (layout.byteAlignment() == byteAlign) { assertFalse(layout.toString().contains("%")); - if (a >= layout.bitAlignment()) { - assertEquals(layout.withBitAlignment(a).toString().contains("%"), a != bitAlign); + if (a >= layout.byteAlignment()) { + assertEquals(layout.withByteAlignment(a).toString().contains("%"), a != byteAlign); } } } } @Test(dataProvider="layoutsAndAlignments") - public void testBadBitAlignment(MemoryLayout layout, long bitAlign) { - long[] alignments = { 8, 16, 32, 64, 128 }; + public void testBadByteAlignment(MemoryLayout layout, long byteAlign) { + long[] alignments = { 1, 2, 4, 8, 16 }; for (long a : alignments) { - if (a < bitAlign && !(layout instanceof ValueLayout)) { - assertThrows(IllegalArgumentException.class, () -> layout.withBitAlignment(a)); + if (a < byteAlign && !(layout instanceof ValueLayout)) { + assertThrows(IllegalArgumentException.class, () -> layout.withByteAlignment(a)); } } } @Test(dataProvider="layoutsAndAlignments", expectedExceptions = IllegalArgumentException.class) - public void testBadSequenceElementAlignmentTooBig(MemoryLayout layout, long bitAlign) { - layout = layout.withBitAlignment(layout.bitSize() * 2); // hyper-align + public void testBadSequenceElementAlignmentTooBig(MemoryLayout layout, long byteAlign) { + layout = layout.withByteAlignment(layout.byteSize() * 2); // hyper-align MemoryLayout.sequenceLayout(layout); } @Test(dataProvider="layoutsAndAlignments") - public void testBadSequenceElementSizeNotMultipleOfAlignment(MemoryLayout layout, long bitAlign) { + public void testBadSequenceElementSizeNotMultipleOfAlignment(MemoryLayout layout, long byteAlign) { boolean shouldFail = layout.byteSize() % layout.byteAlignment() != 0; try { MemoryLayout.sequenceLayout(layout); @@ -310,7 +310,7 @@ public class TestLayouts { } @Test(dataProvider="layoutsAndAlignments") - public void testBadSpliteratorElementSizeNotMultipleOfAlignment(MemoryLayout layout, long bitAlign) { + public void testBadSpliteratorElementSizeNotMultipleOfAlignment(MemoryLayout layout, long byteAlign) { boolean shouldFail = layout.byteSize() % layout.byteAlignment() != 0; try (Arena arena = Arena.ofConfined()) { MemorySegment segment = arena.allocate(layout); @@ -322,7 +322,7 @@ public class TestLayouts { } @Test(dataProvider="layoutsAndAlignments") - public void testBadElementsElementSizeNotMultipleOfAlignment(MemoryLayout layout, long bitAlign) { + public void testBadElementsElementSizeNotMultipleOfAlignment(MemoryLayout layout, long byteAlign) { boolean shouldFail = layout.byteSize() % layout.byteAlignment() != 0; try (Arena arena = Arena.ofConfined()) { MemorySegment segment = arena.allocate(layout); @@ -334,8 +334,8 @@ public class TestLayouts { } @Test(dataProvider="layoutsAndAlignments", expectedExceptions = IllegalArgumentException.class) - public void testBadStruct(MemoryLayout layout, long bitAlign) { - layout = layout.withBitAlignment(layout.bitSize() * 2); // hyper-align + public void testBadStruct(MemoryLayout layout, long byteAlign) { + layout = layout.withByteAlignment(layout.byteSize() * 2); // hyper-align MemoryLayout.structLayout(layout, layout); } @@ -351,8 +351,8 @@ public class TestLayouts { LayoutKind[] layoutKinds = LayoutKind.values(); Object[][] values = new Object[layoutKinds.length * 2][2]; for (int i = 0; i < layoutKinds.length ; i++) { - values[i * 2] = new Object[] { layoutKinds[i].layout, 3 }; // smaller than 8 - values[(i * 2) + 1] = new Object[] { layoutKinds[i].layout, 18 }; // not a power of 2 + values[i * 2] = new Object[] { layoutKinds[i].layout, 0 }; // smaller than 1 + values[(i * 2) + 1] = new Object[] { layoutKinds[i].layout, 5 }; // not a power of 2 } return values; } @@ -368,7 +368,7 @@ public class TestLayouts { VALUE_LE(size -> valueLayoutForSize((int)size).withOrder(ByteOrder.LITTLE_ENDIAN)), VALUE_BE(size -> valueLayoutForSize((int)size).withOrder(ByteOrder.BIG_ENDIAN)), PADDING(MemoryLayout::paddingLayout), - SEQUENCE(size -> MemoryLayout.sequenceLayout(size, MemoryLayout.paddingLayout(8))); + SEQUENCE(size -> MemoryLayout.sequenceLayout(size, MemoryLayout.paddingLayout(1))); private final LongFunction factory; @@ -393,10 +393,10 @@ public class TestLayouts { enum LayoutKind { VALUE(ValueLayout.JAVA_BYTE), - PADDING(MemoryLayout.paddingLayout(8)), - SEQUENCE(MemoryLayout.sequenceLayout(1, MemoryLayout.paddingLayout(8))), - STRUCT(MemoryLayout.structLayout(MemoryLayout.paddingLayout(8), MemoryLayout.paddingLayout(8))), - UNION(MemoryLayout.unionLayout(MemoryLayout.paddingLayout(8), MemoryLayout.paddingLayout(8))); + PADDING(MemoryLayout.paddingLayout(1)), + SEQUENCE(MemoryLayout.sequenceLayout(1, MemoryLayout.paddingLayout(1))), + STRUCT(MemoryLayout.structLayout(MemoryLayout.paddingLayout(1), MemoryLayout.paddingLayout(1))), + UNION(MemoryLayout.unionLayout(MemoryLayout.paddingLayout(1), MemoryLayout.paddingLayout(1))); final MemoryLayout layout; @@ -432,24 +432,24 @@ public class TestLayouts { int i = 0; //add basic layouts for (MemoryLayout l : basicLayoutsNoLongDouble) { - layoutsAndAlignments.add(new Object[] { l, l.bitAlignment() }); + layoutsAndAlignments.add(new Object[] { l, l.byteAlignment() }); } //add basic layouts wrapped in a sequence with given size for (MemoryLayout l : basicLayoutsNoLongDouble) { - layoutsAndAlignments.add(new Object[] { MemoryLayout.sequenceLayout(4, l), l.bitAlignment() }); + layoutsAndAlignments.add(new Object[] { MemoryLayout.sequenceLayout(4, l), l.byteAlignment() }); } //add basic layouts wrapped in a struct for (MemoryLayout l1 : basicLayoutsNoLongDouble) { for (MemoryLayout l2 : basicLayoutsNoLongDouble) { if (l1.byteSize() % l2.byteAlignment() != 0) continue; // second element is not aligned, skip - long align = Math.max(l1.bitAlignment(), l2.bitAlignment()); + long align = Math.max(l1.byteAlignment(), l2.byteAlignment()); layoutsAndAlignments.add(new Object[]{MemoryLayout.structLayout(l1, l2), align}); } } //add basic layouts wrapped in a union for (MemoryLayout l1 : basicLayoutsNoLongDouble) { for (MemoryLayout l2 : basicLayoutsNoLongDouble) { - long align = Math.max(l1.bitAlignment(), l2.bitAlignment()); + long align = Math.max(l1.byteAlignment(), l2.byteAlignment()); layoutsAndAlignments.add(new Object[]{MemoryLayout.unionLayout(l1, l2), align}); } } @@ -484,7 +484,7 @@ public class TestLayouts { return Stream.of( MemoryLayout.sequenceLayout(10, JAVA_INT), MemoryLayout.sequenceLayout(JAVA_INT), - MemoryLayout.structLayout(JAVA_INT, MemoryLayout.paddingLayout(32), JAVA_LONG), + MemoryLayout.structLayout(JAVA_INT, MemoryLayout.paddingLayout(4), JAVA_LONG), MemoryLayout.unionLayout(JAVA_LONG, JAVA_DOUBLE) ); } diff --git a/test/jdk/java/foreign/TestLinker.java b/test/jdk/java/foreign/TestLinker.java index 77657e4b1d9..b040b4bacdd 100644 --- a/test/jdk/java/foreign/TestLinker.java +++ b/test/jdk/java/foreign/TestLinker.java @@ -89,10 +89,10 @@ public class TestLinker extends NativeTestHelper { FunctionDescriptor.ofVoid(structLayout(C_INT).withName("x")) }, { FunctionDescriptor.ofVoid(structLayout(C_INT)), FunctionDescriptor.ofVoid(structLayout(C_INT.withName("x"))) }, - { FunctionDescriptor.ofVoid(structLayout(C_INT, paddingLayout(32), C_LONG_LONG)), - FunctionDescriptor.ofVoid(structLayout(C_INT, paddingLayout(32), C_LONG_LONG.withName("x"))) }, - { FunctionDescriptor.ofVoid(structLayout(C_INT, paddingLayout(32), C_LONG_LONG)), - FunctionDescriptor.ofVoid(structLayout(C_INT, paddingLayout(32).withName("x"), C_LONG_LONG)) }, + { FunctionDescriptor.ofVoid(structLayout(C_INT, paddingLayout(4), C_LONG_LONG)), + FunctionDescriptor.ofVoid(structLayout(C_INT, paddingLayout(4), C_LONG_LONG.withName("x"))) }, + { FunctionDescriptor.ofVoid(structLayout(C_INT, paddingLayout(4), C_LONG_LONG)), + FunctionDescriptor.ofVoid(structLayout(C_INT, paddingLayout(4).withName("x"), C_LONG_LONG)) }, { FunctionDescriptor.ofVoid(structLayout(sequenceLayout(1, C_INT))), FunctionDescriptor.ofVoid(structLayout(sequenceLayout(1, C_INT).withName("x"))) }, { FunctionDescriptor.ofVoid(structLayout(sequenceLayout(1, C_INT))), diff --git a/test/jdk/java/foreign/TestMemoryAccess.java b/test/jdk/java/foreign/TestMemoryAccess.java index f4e0a5be5ff..135f96476f3 100644 --- a/test/jdk/java/foreign/TestMemoryAccess.java +++ b/test/jdk/java/foreign/TestMemoryAccess.java @@ -50,7 +50,7 @@ public class TestMemoryAccess { @Test(dataProvider = "elements") public void testPaddedAccessByName(Function viewFactory, MemoryLayout elemLayout, Checker checker) { - GroupLayout layout = MemoryLayout.structLayout(MemoryLayout.paddingLayout(elemLayout.bitSize()), elemLayout.withName("elem")); + GroupLayout layout = MemoryLayout.structLayout(MemoryLayout.paddingLayout(elemLayout.byteSize()), elemLayout.withName("elem")); testAccessInternal(viewFactory, layout, layout.varHandle(PathElement.groupElement("elem")), checker); } @@ -74,7 +74,7 @@ public class TestMemoryAccess { @Test(dataProvider = "arrayElements") public void testPaddedArrayAccessByName(Function viewFactory, MemoryLayout elemLayout, ArrayChecker checker) { - SequenceLayout seq = MemoryLayout.sequenceLayout(10, MemoryLayout.structLayout(MemoryLayout.paddingLayout(elemLayout.bitSize()), elemLayout.withName("elem"))); + SequenceLayout seq = MemoryLayout.sequenceLayout(10, MemoryLayout.structLayout(MemoryLayout.paddingLayout(elemLayout.byteSize()), elemLayout.withName("elem"))); testArrayAccessInternal(viewFactory, seq, seq.varHandle(MemoryLayout.PathElement.sequenceElement(), MemoryLayout.PathElement.groupElement("elem")), checker); } @@ -168,7 +168,7 @@ public class TestMemoryAccess { @Test(dataProvider = "matrixElements") public void testPaddedMatrixAccessByName(Function viewFactory, MemoryLayout elemLayout, MatrixChecker checker) { SequenceLayout seq = MemoryLayout.sequenceLayout(20, - MemoryLayout.sequenceLayout(10, MemoryLayout.structLayout(MemoryLayout.paddingLayout(elemLayout.bitSize()), elemLayout.withName("elem")))); + MemoryLayout.sequenceLayout(10, MemoryLayout.structLayout(MemoryLayout.paddingLayout(elemLayout.byteSize()), elemLayout.withName("elem")))); testMatrixAccessInternal(viewFactory, seq, seq.varHandle( PathElement.sequenceElement(), PathElement.sequenceElement(), PathElement.groupElement("elem")), diff --git a/test/jdk/java/foreign/TestMemoryAccessInstance.java b/test/jdk/java/foreign/TestMemoryAccessInstance.java index d644a5ad904..c8e1fda6da1 100644 --- a/test/jdk/java/foreign/TestMemoryAccessInstance.java +++ b/test/jdk/java/foreign/TestMemoryAccessInstance.java @@ -95,7 +95,7 @@ public class TestMemoryAccessInstance { try (Arena arena = Arena.ofConfined()) { MemorySegment segment = arena.allocate(64, 1); T t = transform.apply(segment); - L alignedLayout = (L)layout.withBitAlignment(layout.byteSize() * 8 * 2); + L alignedLayout = (L)layout.withByteAlignment(layout.byteSize() * 2); try { segmentSetter.set(t, alignedLayout, 0, value); fail(); diff --git a/test/jdk/java/foreign/TestMemoryAlignment.java b/test/jdk/java/foreign/TestMemoryAlignment.java index db39b1d0432..43623b392a7 100644 --- a/test/jdk/java/foreign/TestMemoryAlignment.java +++ b/test/jdk/java/foreign/TestMemoryAlignment.java @@ -41,11 +41,10 @@ public class TestMemoryAlignment { @Test(dataProvider = "alignments") public void testAlignedAccess(long align) { ValueLayout layout = ValueLayout.JAVA_INT - .withBitAlignment(32) .withOrder(ByteOrder.BIG_ENDIAN); - assertEquals(layout.bitAlignment(), 32); - ValueLayout aligned = layout.withBitAlignment(align); - assertEquals(aligned.bitAlignment(), align); //unreasonable alignment here, to make sure access throws + assertEquals(layout.byteAlignment(), 4); + ValueLayout aligned = layout.withByteAlignment(align); + assertEquals(aligned.byteAlignment(), align); //unreasonable alignment here, to make sure access throws VarHandle vh = aligned.varHandle(); try (Arena arena = Arena.ofConfined()) { MemorySegment segment = arena.allocate(aligned);; @@ -58,13 +57,12 @@ public class TestMemoryAlignment { @Test(dataProvider = "alignments") public void testUnalignedAccess(long align) { ValueLayout layout = ValueLayout.JAVA_INT - .withBitAlignment(32) .withOrder(ByteOrder.BIG_ENDIAN); - assertEquals(layout.bitAlignment(), 32); - ValueLayout aligned = layout.withBitAlignment(align); + assertEquals(layout.byteAlignment(), 4); + ValueLayout aligned = layout.withByteAlignment(align); try (Arena arena = Arena.ofConfined()) { - MemoryLayout alignedGroup = MemoryLayout.structLayout(MemoryLayout.paddingLayout(8), aligned); - assertEquals(alignedGroup.bitAlignment(), align); + MemoryLayout alignedGroup = MemoryLayout.structLayout(MemoryLayout.paddingLayout(1), aligned); + assertEquals(alignedGroup.byteAlignment(), align); VarHandle vh = aligned.varHandle(); MemorySegment segment = arena.allocate(alignedGroup);; vh.set(segment.asSlice(1L), -42); @@ -77,20 +75,20 @@ public class TestMemoryAlignment { @Test(dataProvider = "alignments") public void testUnalignedPath(long align) { MemoryLayout layout = ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN); - MemoryLayout aligned = layout.withBitAlignment(align).withName("value"); + MemoryLayout aligned = layout.withByteAlignment(align).withName("value"); try { - GroupLayout alignedGroup = MemoryLayout.structLayout(MemoryLayout.paddingLayout(8), aligned); + GroupLayout alignedGroup = MemoryLayout.structLayout(MemoryLayout.paddingLayout(1), aligned); alignedGroup.varHandle(PathElement.groupElement("value")); - assertEquals(align, 8); //this is the only case where path is aligned + assertEquals(align, 1); //this is the only case where path is aligned } catch (IllegalArgumentException ex) { - assertNotEquals(align, 8); //if align != 8, path is always unaligned + assertNotEquals(align, 1); //if align != 8, path is always unaligned } } @Test(dataProvider = "alignments") public void testUnalignedSequence(long align) { try { - SequenceLayout layout = MemoryLayout.sequenceLayout(5, ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN).withBitAlignment(align)); + SequenceLayout layout = MemoryLayout.sequenceLayout(5, ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN).withByteAlignment(align)); VarHandle vh = layout.varHandle(PathElement.sequenceElement()); try (Arena arena = Arena.ofConfined()) { MemorySegment segment = arena.allocate(layout);; @@ -99,7 +97,7 @@ public class TestMemoryAlignment { } } } catch (IllegalArgumentException ex) { - assertTrue(align > 32); //if align > 32, access is always unaligned (for some elements) + assertTrue(align > 4); //if align > 4, access is always unaligned (for some elements) } } @@ -109,10 +107,10 @@ public class TestMemoryAlignment { ValueLayout vShort = ValueLayout.JAVA_SHORT.withOrder(ByteOrder.BIG_ENDIAN); ValueLayout vInt = ValueLayout.JAVA_INT.withOrder(ByteOrder.BIG_ENDIAN); //mimic pragma pack(1) - GroupLayout g = MemoryLayout.structLayout(vChar.withBitAlignment(8).withName("a"), - vShort.withBitAlignment(8).withName("b"), - vInt.withBitAlignment(8).withName("c")); - assertEquals(g.bitAlignment(), 8); + GroupLayout g = MemoryLayout.structLayout(vChar.withByteAlignment(1).withName("a"), + vShort.withByteAlignment(1).withName("b"), + vInt.withByteAlignment(1).withName("c")); + assertEquals(g.byteAlignment(), 1); VarHandle vh_c = g.varHandle(PathElement.groupElement("a")); VarHandle vh_s = g.varHandle(PathElement.groupElement("b")); VarHandle vh_i = g.varHandle(PathElement.groupElement("c")); @@ -129,7 +127,7 @@ public class TestMemoryAlignment { @DataProvider(name = "alignments") public Object[][] createAlignments() { - return LongStream.range(3, 32) + return LongStream.range(1, 20) .mapToObj(v -> new Object[] { 1L << v }) .toArray(Object[][]::new); } diff --git a/test/jdk/java/foreign/TestNulls.java b/test/jdk/java/foreign/TestNulls.java index 45a5c825c46..d3582a0e04b 100644 --- a/test/jdk/java/foreign/TestNulls.java +++ b/test/jdk/java/foreign/TestNulls.java @@ -161,7 +161,7 @@ public class TestNulls { addDefaultMapping(ValueLayout.OfFloat.class, ValueLayout.JAVA_FLOAT); addDefaultMapping(ValueLayout.OfLong.class, JAVA_LONG); addDefaultMapping(ValueLayout.OfDouble.class, ValueLayout.JAVA_DOUBLE); - addDefaultMapping(PaddingLayout.class, MemoryLayout.paddingLayout(32)); + addDefaultMapping(PaddingLayout.class, MemoryLayout.paddingLayout(4)); addDefaultMapping(GroupLayout.class, MemoryLayout.structLayout(ValueLayout.JAVA_INT)); addDefaultMapping(StructLayout.class, MemoryLayout.structLayout(ValueLayout.JAVA_INT)); addDefaultMapping(UnionLayout.class, MemoryLayout.unionLayout(ValueLayout.JAVA_INT)); diff --git a/test/jdk/java/foreign/TestSegmentAllocators.java b/test/jdk/java/foreign/TestSegmentAllocators.java index 2d8fad428fb..c52c7756245 100644 --- a/test/jdk/java/foreign/TestSegmentAllocators.java +++ b/test/jdk/java/foreign/TestSegmentAllocators.java @@ -56,17 +56,16 @@ import static org.testng.Assert.*; public class TestSegmentAllocators { final static int ELEMS = 128; - final static Class ADDRESS_CARRIER = ValueLayout.ADDRESS.bitSize() == 64 ? long.class : int.class; @Test(dataProvider = "scalarAllocations") @SuppressWarnings("unchecked") public void testAllocation(Z value, AllocationFactory allocationFactory, L layout, AllocationFunction allocationFunction, Function handleFactory) { - layout = (L)layout.withBitAlignment(layout.bitSize()); + layout = (L)layout.withByteAlignment(layout.byteSize()); L[] layouts = (L[])new ValueLayout[] { layout, - layout.withBitAlignment(layout.bitAlignment() * 2), - layout.withBitAlignment(layout.bitAlignment() * 4), - layout.withBitAlignment(layout.bitAlignment() * 8) + layout.withByteAlignment(layout.byteAlignment() * 2), + layout.withByteAlignment(layout.byteAlignment() * 4), + layout.withByteAlignment(layout.byteAlignment() * 8) }; for (L alignedLayout : layouts) { List addressList = new ArrayList<>(); diff --git a/test/jdk/java/foreign/TestSegmentCopy.java b/test/jdk/java/foreign/TestSegmentCopy.java index c430d0cb110..504e81d5528 100644 --- a/test/jdk/java/foreign/TestSegmentCopy.java +++ b/test/jdk/java/foreign/TestSegmentCopy.java @@ -108,13 +108,13 @@ public class TestSegmentCopy { @Test(expectedExceptions = IllegalArgumentException.class) public void testHyperAlignedSrc() { MemorySegment segment = MemorySegment.ofArray(new byte[] {1, 2, 3, 4}); - MemorySegment.copy(segment, 0, segment, JAVA_BYTE.withBitAlignment(16), 0, 4); + MemorySegment.copy(segment, 0, segment, JAVA_BYTE.withByteAlignment(2), 0, 4); } @Test(expectedExceptions = IllegalArgumentException.class) public void testHyperAlignedDst() { MemorySegment segment = MemorySegment.ofArray(new byte[] {1, 2, 3, 4}); - MemorySegment.copy(segment, JAVA_BYTE.withBitAlignment(16), 0, segment, 0, 4); + MemorySegment.copy(segment, JAVA_BYTE.withByteAlignment(2), 0, segment, 0, 4); } enum Type { diff --git a/test/jdk/java/foreign/TestSpliterator.java b/test/jdk/java/foreign/TestSpliterator.java index 5cbe29f52dd..02df427cea2 100644 --- a/test/jdk/java/foreign/TestSpliterator.java +++ b/test/jdk/java/foreign/TestSpliterator.java @@ -156,7 +156,7 @@ public class TestSpliterator { MemorySegment segment = scope.allocate(8, 1); // compute an alignment constraint (in bytes) which exceed that of the native segment long bigByteAlign = Long.lowestOneBit(segment.address()) << 1; - segment.elements(MemoryLayout.sequenceLayout(2, ValueLayout.JAVA_INT.withBitAlignment(bigByteAlign * 8))); + segment.elements(MemoryLayout.sequenceLayout(2, ValueLayout.JAVA_INT.withByteAlignment(bigByteAlign))); } static long sumSingle(long acc, MemorySegment segment) { diff --git a/test/jdk/java/foreign/TestUpcallHighArity.java b/test/jdk/java/foreign/TestUpcallHighArity.java index fc33d92cf82..f5f76923bb9 100644 --- a/test/jdk/java/foreign/TestUpcallHighArity.java +++ b/test/jdk/java/foreign/TestUpcallHighArity.java @@ -55,7 +55,7 @@ public class TestUpcallHighArity extends CallGeneratorHelper { C_POINTER.withName("p0"), C_DOUBLE.withName("p1"), C_INT.withName("p2"), - MemoryLayout.paddingLayout(32) + MemoryLayout.paddingLayout(4) ); static { diff --git a/test/jdk/java/foreign/TestUpcallStructScope.java b/test/jdk/java/foreign/TestUpcallStructScope.java index 07e1a2593aa..72344c4438b 100644 --- a/test/jdk/java/foreign/TestUpcallStructScope.java +++ b/test/jdk/java/foreign/TestUpcallStructScope.java @@ -59,7 +59,7 @@ public class TestUpcallStructScope extends NativeTestHelper { C_POINTER.withName("p0"), C_DOUBLE.withName("p1"), C_INT.withName("p2"), - MemoryLayout.paddingLayout(32) + MemoryLayout.paddingLayout(4) ); static { diff --git a/test/jdk/java/foreign/TestValueLayouts.java b/test/jdk/java/foreign/TestValueLayouts.java index c0802a7018e..b39a025fd5f 100644 --- a/test/jdk/java/foreign/TestValueLayouts.java +++ b/test/jdk/java/foreign/TestValueLayouts.java @@ -41,114 +41,112 @@ public class TestValueLayouts { @Test public void testByte() { - testAligned(JAVA_BYTE, byte.class, Byte.SIZE); + testAligned(JAVA_BYTE, byte.class, Byte.BYTES); } @Test public void testBoolean() { - testAligned(JAVA_BOOLEAN, boolean.class, Byte.SIZE); + testAligned(JAVA_BOOLEAN, boolean.class, Byte.BYTES); } @Test public void testShort() { - testAligned(JAVA_SHORT, short.class, Short.SIZE); + testAligned(JAVA_SHORT, short.class, Short.BYTES); } @Test public void testShortUnaligned() { - testUnaligned(JAVA_SHORT_UNALIGNED, short.class, Short.SIZE); + testUnaligned(JAVA_SHORT_UNALIGNED, short.class, Short.BYTES); } @Test public void testInt() { - testAligned(JAVA_INT, int.class, Integer.SIZE); + testAligned(JAVA_INT, int.class, Integer.BYTES); } @Test public void testIntUnaligned() { - testUnaligned(JAVA_INT_UNALIGNED, int.class, Integer.SIZE); + testUnaligned(JAVA_INT_UNALIGNED, int.class, Integer.BYTES); } @Test public void testLong() { - testAligned(JAVA_LONG, long.class, Long.SIZE, ADDRESS.bitSize()); + testAligned(JAVA_LONG, long.class, Long.BYTES, ADDRESS.byteSize()); } @Test public void testLongUnaligned() { - testUnaligned(JAVA_LONG_UNALIGNED, long.class, Long.SIZE); + testUnaligned(JAVA_LONG_UNALIGNED, long.class, Long.BYTES); } @Test public void testFloat() { - testAligned(JAVA_FLOAT, float.class, Float.SIZE); + testAligned(JAVA_FLOAT, float.class, Float.BYTES); } @Test public void testFloatUnaligned() { - testUnaligned(JAVA_FLOAT_UNALIGNED, float.class, Float.SIZE); + testUnaligned(JAVA_FLOAT_UNALIGNED, float.class, Float.BYTES); } @Test public void testDouble() { - testAligned(JAVA_DOUBLE, double.class, Double.SIZE, ADDRESS.bitSize()); + testAligned(JAVA_DOUBLE, double.class, Double.BYTES, ADDRESS.byteSize()); } @Test public void testDoubleUnaligned() { - testUnaligned(JAVA_DOUBLE_UNALIGNED, double.class, Double.SIZE); + testUnaligned(JAVA_DOUBLE_UNALIGNED, double.class, Double.BYTES); } @Test public void testChar() { - testAligned(JAVA_CHAR, char.class, Character.SIZE); + testAligned(JAVA_CHAR, char.class, Character.BYTES); } @Test public void testCharUnaligned() { - testUnaligned(JAVA_CHAR_UNALIGNED, char.class, Character.SIZE); + testUnaligned(JAVA_CHAR_UNALIGNED, char.class, Character.BYTES); } @Test public void testAddress() { - testAligned(ADDRESS, MemorySegment.class, Unsafe.ADDRESS_SIZE * 8L); + testAligned(ADDRESS, MemorySegment.class, Unsafe.ADDRESS_SIZE); } @Test public void testAddressUnaligned() { - testUnaligned(ADDRESS_UNALIGNED, MemorySegment.class, Unsafe.ADDRESS_SIZE * 8L); + testUnaligned(ADDRESS_UNALIGNED, MemorySegment.class, Unsafe.ADDRESS_SIZE); } void testAligned(ValueLayout layout, Class carrier, - long bitSize) { - test(layout, carrier, bitSize, bitSize); + long byteSize) { + test(layout, carrier, byteSize, byteSize); } void testAligned(ValueLayout layout, Class carrier, - long bitSize, - long bitAlignment) { - test(layout, carrier, bitSize, bitAlignment); + long byteSize, + long byteAlignment) { + test(layout, carrier, byteSize, byteAlignment); } void testUnaligned(ValueLayout layout, Class carrier, - long bitSize) { - test(layout, carrier, bitSize, Byte.SIZE); + long byteSize) { + test(layout, carrier, byteSize, Byte.BYTES); } void test(ValueLayout layout, Class carrier, - long bitSize, - long bitAlignment) { + long byteSize, + long byteAlignment) { assertEquals(layout.carrier(), carrier); - assertEquals(layout.bitSize(), bitSize); + assertEquals(layout.byteSize(), byteSize); assertEquals(layout.order(), ByteOrder.nativeOrder()); - assertEquals(layout.bitAlignment(), bitAlignment); + assertEquals(layout.byteAlignment(), byteAlignment); assertTrue(layout.name().isEmpty()); - assertEquals(layout.byteSize(), layout.bitSize() / 8); - assertEquals(layout.byteAlignment(), layout.bitAlignment() / 8); } diff --git a/test/jdk/java/foreign/TestVarHandleCombinators.java b/test/jdk/java/foreign/TestVarHandleCombinators.java index cf748865d7e..d7c2cb700df 100644 --- a/test/jdk/java/foreign/TestVarHandleCombinators.java +++ b/test/jdk/java/foreign/TestVarHandleCombinators.java @@ -53,7 +53,7 @@ public class TestVarHandleCombinators { @Test(expectedExceptions = IllegalArgumentException.class) public void testUnalignedElement() { - VarHandle vh = MethodHandles.memorySegmentViewVarHandle(ValueLayout.JAVA_BYTE.withBitAlignment(32)); + VarHandle vh = MethodHandles.memorySegmentViewVarHandle(ValueLayout.JAVA_BYTE.withByteAlignment(4)); MemorySegment segment = MemorySegment.ofArray(new byte[4]); vh.get(segment, 2L); //should throw //FIXME: the VH only checks the alignment of the segment, which is fine if the VH is derived from layouts, @@ -63,7 +63,7 @@ public class TestVarHandleCombinators { @Test public void testAlign() { - VarHandle vh = MethodHandles.memorySegmentViewVarHandle(ValueLayout.JAVA_BYTE.withBitAlignment(16)); + VarHandle vh = MethodHandles.memorySegmentViewVarHandle(ValueLayout.JAVA_BYTE.withByteAlignment(2)); Arena scope = Arena.ofAuto(); MemorySegment segment = scope.allocate(1L, 2); @@ -73,8 +73,8 @@ public class TestVarHandleCombinators { @Test public void testByteOrderLE() { - VarHandle vh = MethodHandles.memorySegmentViewVarHandle(ValueLayout.JAVA_SHORT - .withOrder(ByteOrder.LITTLE_ENDIAN).withBitAlignment(8)); + VarHandle vh = MethodHandles.memorySegmentViewVarHandle(ValueLayout.JAVA_SHORT_UNALIGNED + .withOrder(ByteOrder.LITTLE_ENDIAN)); byte[] arr = new byte[2]; MemorySegment segment = MemorySegment.ofArray(arr); vh.set(segment, 0L, (short) 0xFF); @@ -84,8 +84,8 @@ public class TestVarHandleCombinators { @Test public void testByteOrderBE() { - VarHandle vh = MethodHandles.memorySegmentViewVarHandle(ValueLayout.JAVA_SHORT - .withOrder(ByteOrder.BIG_ENDIAN).withBitAlignment(8)); + VarHandle vh = MethodHandles.memorySegmentViewVarHandle(ValueLayout.JAVA_SHORT_UNALIGNED + .withOrder(ByteOrder.BIG_ENDIAN)); byte[] arr = new byte[2]; MemorySegment segment = MemorySegment.ofArray(arr); vh.set(segment, 0L, (short) 0xFF); @@ -100,7 +100,7 @@ public class TestVarHandleCombinators { //[10 : [5 : [x32 i32]]] - VarHandle vh = MethodHandles.memorySegmentViewVarHandle(ValueLayout.JAVA_INT.withBitAlignment(32)); + VarHandle vh = MethodHandles.memorySegmentViewVarHandle(ValueLayout.JAVA_INT); int count = 0; try (Arena arena = Arena.ofConfined()) { MemorySegment segment = arena.allocate(inner_size * outer_size * 8, 4); diff --git a/test/jdk/java/foreign/callarranger/TestLayoutEquality.java b/test/jdk/java/foreign/callarranger/TestLayoutEquality.java index 68127010c89..2da5c0f6105 100644 --- a/test/jdk/java/foreign/callarranger/TestLayoutEquality.java +++ b/test/jdk/java/foreign/callarranger/TestLayoutEquality.java @@ -50,14 +50,14 @@ public class TestLayoutEquality { @Test(dataProvider = "layoutConstants") public void testReconstructedEquality(ValueLayout layout) { ValueLayout newLayout = ValueLayouts.valueLayout(layout.carrier(), layout.order()); - newLayout = newLayout.withBitAlignment(layout.bitAlignment()); + newLayout = newLayout.withByteAlignment(layout.byteAlignment()); if (layout instanceof AddressLayout addressLayout && addressLayout.targetLayout().isPresent()) { newLayout = ((AddressLayout)newLayout).withTargetLayout(addressLayout.targetLayout().get()); } // properties should be equal - assertEquals(newLayout.bitSize(), layout.bitSize()); - assertEquals(newLayout.bitAlignment(), layout.bitAlignment()); + assertEquals(newLayout.byteSize(), layout.byteSize()); + assertEquals(newLayout.byteAlignment(), layout.byteAlignment()); assertEquals(newLayout.name(), layout.name()); // layouts should be equals diff --git a/test/jdk/java/foreign/callarranger/TestLinuxAArch64CallArranger.java b/test/jdk/java/foreign/callarranger/TestLinuxAArch64CallArranger.java index 8a81e0f416b..78fe1292089 100644 --- a/test/jdk/java/foreign/callarranger/TestLinuxAArch64CallArranger.java +++ b/test/jdk/java/foreign/callarranger/TestLinuxAArch64CallArranger.java @@ -187,7 +187,7 @@ public class TestLinuxAArch64CallArranger extends CallArrangerTestBase { bufferLoad(8, long.class), vmStore(r1, long.class), }}, // struct s { float a; /* padding */ double b }; - { MemoryLayout.structLayout(C_FLOAT, MemoryLayout.paddingLayout(32), C_DOUBLE), + { MemoryLayout.structLayout(C_FLOAT, MemoryLayout.paddingLayout(4), C_DOUBLE), new Binding[] { dup(), // s.a diff --git a/test/jdk/java/foreign/callarranger/TestRISCV64CallArranger.java b/test/jdk/java/foreign/callarranger/TestRISCV64CallArranger.java index 40c5d8a12bc..338288985fa 100644 --- a/test/jdk/java/foreign/callarranger/TestRISCV64CallArranger.java +++ b/test/jdk/java/foreign/callarranger/TestRISCV64CallArranger.java @@ -205,7 +205,7 @@ public class TestRISCV64CallArranger extends CallArrangerTestBase { } }, // struct s { float a; /* padding */ double b }; - { MemoryLayout.structLayout(C_FLOAT, MemoryLayout.paddingLayout(32), C_DOUBLE), + { MemoryLayout.structLayout(C_FLOAT, MemoryLayout.paddingLayout(4), C_DOUBLE), new Binding[]{ dup(), // s.a @@ -257,7 +257,7 @@ public class TestRISCV64CallArranger extends CallArrangerTestBase { @Test public void testStructFA2() { - MemoryLayout fa = MemoryLayout.structLayout(C_FLOAT, MemoryLayout.paddingLayout(32), C_DOUBLE); + MemoryLayout fa = MemoryLayout.structLayout(C_FLOAT, MemoryLayout.paddingLayout(4), C_DOUBLE); MethodType mt = MethodType.methodType(MemorySegment.class, float.class, int.class, MemorySegment.class); FunctionDescriptor fd = FunctionDescriptor.of(fa, C_FLOAT, C_INT, fa); diff --git a/test/jdk/java/foreign/callarranger/TestSysVCallArranger.java b/test/jdk/java/foreign/callarranger/TestSysVCallArranger.java index 4fa579b47d3..1405feb04a4 100644 --- a/test/jdk/java/foreign/callarranger/TestSysVCallArranger.java +++ b/test/jdk/java/foreign/callarranger/TestSysVCallArranger.java @@ -118,7 +118,7 @@ public class TestSysVCallArranger extends CallArrangerTestBase { public void testNestedUnion() { MemoryLayout POINT = MemoryLayout.structLayout( C_INT, - MemoryLayout.paddingLayout(32), + MemoryLayout.paddingLayout(4), MemoryLayout.unionLayout( MemoryLayout.structLayout(C_INT, C_INT), C_LONG diff --git a/test/jdk/java/foreign/nested/TestNested.java b/test/jdk/java/foreign/nested/TestNested.java index 317b7112025..d1124cc54b0 100644 --- a/test/jdk/java/foreign/nested/TestNested.java +++ b/test/jdk/java/foreign/nested/TestNested.java @@ -88,14 +88,14 @@ public class TestNested extends NativeTestHelper { C_LONG_LONG.withName("f1"), C_DOUBLE.withName("f2"), C_INT.withName("f3"), - MemoryLayout.paddingLayout(32) + MemoryLayout.paddingLayout(4) ).withName("S1"); static final UnionLayout U1 = MemoryLayout.unionLayout( C_SHORT.withName("f0"), C_LONG_LONG.withName("f1"), C_SHORT.withName("f2"), MemoryLayout.sequenceLayout(4, MemoryLayout.sequenceLayout(3, C_CHAR)).withName("f3"), - MemoryLayout.paddingLayout(128) + MemoryLayout.paddingLayout(16) ).withName("U1"); static final UnionLayout U17 = MemoryLayout.unionLayout( C_CHAR.withName("f0"), @@ -107,7 +107,7 @@ public class TestNested extends NativeTestHelper { U17.withName("f0"), MemoryLayout.sequenceLayout(4, C_LONG_LONG).withName("f1"), C_SHORT.withName("f2"), - MemoryLayout.paddingLayout(48) + MemoryLayout.paddingLayout(6) ).withName("S2"); static final StructLayout S3 = MemoryLayout.structLayout( C_FLOAT.withName("f0"), @@ -117,12 +117,12 @@ public class TestNested extends NativeTestHelper { ).withName("S3"); static final StructLayout S4 = MemoryLayout.structLayout( MemoryLayout.sequenceLayout(2, C_SHORT).withName("f0"), - MemoryLayout.paddingLayout(32), + MemoryLayout.paddingLayout(4), S1.withName("f1") ).withName("S4"); static final StructLayout S5 = MemoryLayout.structLayout( C_FLOAT.withName("f0"), - MemoryLayout.paddingLayout(32), + MemoryLayout.paddingLayout(4), C_POINTER.withName("f1"), S4.withName("f2") ).withName("S5"); @@ -139,7 +139,7 @@ public class TestNested extends NativeTestHelper { C_DOUBLE.withName("f0"), C_SHORT.withName("f1"), C_SHORT.withName("f2"), - MemoryLayout.paddingLayout(32), + MemoryLayout.paddingLayout(4), C_LONG_LONG.withName("f3") ).withName("S7"); static final UnionLayout U3 = MemoryLayout.unionLayout( @@ -169,16 +169,16 @@ public class TestNested extends NativeTestHelper { static final StructLayout S8 = MemoryLayout.structLayout( MemoryLayout.sequenceLayout(3, C_DOUBLE).withName("f0"), U7.withName("f1"), - MemoryLayout.paddingLayout(48), + MemoryLayout.paddingLayout(6), C_POINTER.withName("f2"), C_POINTER.withName("f3") ).withName("S8"); static final StructLayout S9 = MemoryLayout.structLayout( C_CHAR.withName("f0"), - MemoryLayout.paddingLayout(56), + MemoryLayout.paddingLayout(7), MemoryLayout.sequenceLayout(2, C_DOUBLE).withName("f1"), C_CHAR.withName("f2"), - MemoryLayout.paddingLayout(56), + MemoryLayout.paddingLayout(7), S8.withName("f3") ).withName("S9"); static final UnionLayout U8 = MemoryLayout.unionLayout( @@ -207,7 +207,7 @@ public class TestNested extends NativeTestHelper { static final StructLayout S11 = MemoryLayout.structLayout( C_SHORT.withName("f0"), C_CHAR.withName("f1"), - MemoryLayout.paddingLayout(8) + MemoryLayout.paddingLayout(1) ).withName("S11"); static final UnionLayout U12 = MemoryLayout.unionLayout( C_FLOAT.withName("f0"), @@ -237,10 +237,10 @@ public class TestNested extends NativeTestHelper { static final StructLayout S13 = MemoryLayout.structLayout( C_INT.withName("f0"), C_CHAR.withName("f1"), - MemoryLayout.paddingLayout(24), + MemoryLayout.paddingLayout(3), C_POINTER.withName("f2"), C_CHAR.withName("f3"), - MemoryLayout.paddingLayout(56) + MemoryLayout.paddingLayout(7) ).withName("S13"); static final StructLayout S14 = MemoryLayout.structLayout( C_LONG_LONG.withName("f0") diff --git a/test/jdk/java/lang/Thread/jni/AttachCurrentThread/ImplicitAttach.java b/test/jdk/java/lang/Thread/jni/AttachCurrentThread/ImplicitAttach.java index df975dba184..914f0f6004c 100644 --- a/test/jdk/java/lang/Thread/jni/AttachCurrentThread/ImplicitAttach.java +++ b/test/jdk/java/lang/Thread/jni/AttachCurrentThread/ImplicitAttach.java @@ -31,8 +31,8 @@ import java.util.concurrent.CountDownLatch; * Test native threads attaching implicitly to the VM by means of an upcall. */ public class ImplicitAttach { - private static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT.withBitAlignment(32); - private static final AddressLayout C_POINTER = ValueLayout.ADDRESS.withBitAlignment(64); + private static final ValueLayout.OfInt C_INT = ValueLayout.JAVA_INT; + private static final AddressLayout C_POINTER = ValueLayout.ADDRESS; private static volatile CountDownLatch latch; diff --git a/test/jdk/jdk/incubator/vector/Byte128VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Byte128VectorLoadStoreTests.java index 1b1cb9cbf51..6718c37e34f 100644 --- a/test/jdk/jdk/incubator/vector/Byte128VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Byte128VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Byte128VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfByte ELEMENT_LAYOUT = ValueLayout.JAVA_BYTE.withBitAlignment(8); + static final ValueLayout.OfByte ELEMENT_LAYOUT = ValueLayout.JAVA_BYTE.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 128); diff --git a/test/jdk/jdk/incubator/vector/Byte256VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Byte256VectorLoadStoreTests.java index cc6d863e4d5..63a5c012894 100644 --- a/test/jdk/jdk/incubator/vector/Byte256VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Byte256VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Byte256VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfByte ELEMENT_LAYOUT = ValueLayout.JAVA_BYTE.withBitAlignment(8); + static final ValueLayout.OfByte ELEMENT_LAYOUT = ValueLayout.JAVA_BYTE.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 256); diff --git a/test/jdk/jdk/incubator/vector/Byte512VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Byte512VectorLoadStoreTests.java index dd2ed1960e9..fabb77f3a97 100644 --- a/test/jdk/jdk/incubator/vector/Byte512VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Byte512VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Byte512VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfByte ELEMENT_LAYOUT = ValueLayout.JAVA_BYTE.withBitAlignment(8); + static final ValueLayout.OfByte ELEMENT_LAYOUT = ValueLayout.JAVA_BYTE.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 512); diff --git a/test/jdk/jdk/incubator/vector/Byte64VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Byte64VectorLoadStoreTests.java index 7fbff2fc2c8..eef32604590 100644 --- a/test/jdk/jdk/incubator/vector/Byte64VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Byte64VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Byte64VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfByte ELEMENT_LAYOUT = ValueLayout.JAVA_BYTE.withBitAlignment(8); + static final ValueLayout.OfByte ELEMENT_LAYOUT = ValueLayout.JAVA_BYTE.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 64); diff --git a/test/jdk/jdk/incubator/vector/ByteMaxVectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/ByteMaxVectorLoadStoreTests.java index ae5be9e8aac..8a51dd67cff 100644 --- a/test/jdk/jdk/incubator/vector/ByteMaxVectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/ByteMaxVectorLoadStoreTests.java @@ -56,7 +56,7 @@ public class ByteMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfByte ELEMENT_LAYOUT = ValueLayout.JAVA_BYTE.withBitAlignment(8); + static final ValueLayout.OfByte ELEMENT_LAYOUT = ValueLayout.JAVA_BYTE.withByteAlignment(1); static VectorShape getMaxBit() { return VectorShape.S_Max_BIT; diff --git a/test/jdk/jdk/incubator/vector/Double128VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Double128VectorLoadStoreTests.java index 0cc14e2ad22..005f3b2496c 100644 --- a/test/jdk/jdk/incubator/vector/Double128VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Double128VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Double128VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfDouble ELEMENT_LAYOUT = ValueLayout.JAVA_DOUBLE.withBitAlignment(8); + static final ValueLayout.OfDouble ELEMENT_LAYOUT = ValueLayout.JAVA_DOUBLE.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 128); diff --git a/test/jdk/jdk/incubator/vector/Double256VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Double256VectorLoadStoreTests.java index 58e5f4f6f3a..53133964152 100644 --- a/test/jdk/jdk/incubator/vector/Double256VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Double256VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Double256VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfDouble ELEMENT_LAYOUT = ValueLayout.JAVA_DOUBLE.withBitAlignment(8); + static final ValueLayout.OfDouble ELEMENT_LAYOUT = ValueLayout.JAVA_DOUBLE.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 256); diff --git a/test/jdk/jdk/incubator/vector/Double512VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Double512VectorLoadStoreTests.java index 1ebe1389d9c..084d700a304 100644 --- a/test/jdk/jdk/incubator/vector/Double512VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Double512VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Double512VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfDouble ELEMENT_LAYOUT = ValueLayout.JAVA_DOUBLE.withBitAlignment(8); + static final ValueLayout.OfDouble ELEMENT_LAYOUT = ValueLayout.JAVA_DOUBLE.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 512); diff --git a/test/jdk/jdk/incubator/vector/Double64VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Double64VectorLoadStoreTests.java index 4fb167a19c4..d18a69c5175 100644 --- a/test/jdk/jdk/incubator/vector/Double64VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Double64VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Double64VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfDouble ELEMENT_LAYOUT = ValueLayout.JAVA_DOUBLE.withBitAlignment(8); + static final ValueLayout.OfDouble ELEMENT_LAYOUT = ValueLayout.JAVA_DOUBLE.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 64); diff --git a/test/jdk/jdk/incubator/vector/DoubleMaxVectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/DoubleMaxVectorLoadStoreTests.java index 78bec977fda..c6440367576 100644 --- a/test/jdk/jdk/incubator/vector/DoubleMaxVectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/DoubleMaxVectorLoadStoreTests.java @@ -56,7 +56,7 @@ public class DoubleMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfDouble ELEMENT_LAYOUT = ValueLayout.JAVA_DOUBLE.withBitAlignment(8); + static final ValueLayout.OfDouble ELEMENT_LAYOUT = ValueLayout.JAVA_DOUBLE.withByteAlignment(1); static VectorShape getMaxBit() { return VectorShape.S_Max_BIT; diff --git a/test/jdk/jdk/incubator/vector/Float128VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Float128VectorLoadStoreTests.java index c411dd1024b..cd5e0ec09d7 100644 --- a/test/jdk/jdk/incubator/vector/Float128VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Float128VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Float128VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfFloat ELEMENT_LAYOUT = ValueLayout.JAVA_FLOAT.withBitAlignment(8); + static final ValueLayout.OfFloat ELEMENT_LAYOUT = ValueLayout.JAVA_FLOAT.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 128); diff --git a/test/jdk/jdk/incubator/vector/Float256VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Float256VectorLoadStoreTests.java index 6d339ad7a38..1620b045de2 100644 --- a/test/jdk/jdk/incubator/vector/Float256VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Float256VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Float256VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfFloat ELEMENT_LAYOUT = ValueLayout.JAVA_FLOAT.withBitAlignment(8); + static final ValueLayout.OfFloat ELEMENT_LAYOUT = ValueLayout.JAVA_FLOAT.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 256); diff --git a/test/jdk/jdk/incubator/vector/Float512VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Float512VectorLoadStoreTests.java index 427494c9725..be1b009be67 100644 --- a/test/jdk/jdk/incubator/vector/Float512VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Float512VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Float512VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfFloat ELEMENT_LAYOUT = ValueLayout.JAVA_FLOAT.withBitAlignment(8); + static final ValueLayout.OfFloat ELEMENT_LAYOUT = ValueLayout.JAVA_FLOAT.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 512); diff --git a/test/jdk/jdk/incubator/vector/Float64VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Float64VectorLoadStoreTests.java index bf932f80355..9f2a5fedba9 100644 --- a/test/jdk/jdk/incubator/vector/Float64VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Float64VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Float64VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfFloat ELEMENT_LAYOUT = ValueLayout.JAVA_FLOAT.withBitAlignment(8); + static final ValueLayout.OfFloat ELEMENT_LAYOUT = ValueLayout.JAVA_FLOAT.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 64); diff --git a/test/jdk/jdk/incubator/vector/FloatMaxVectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/FloatMaxVectorLoadStoreTests.java index 550374dc454..0d9b2fa0bd4 100644 --- a/test/jdk/jdk/incubator/vector/FloatMaxVectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/FloatMaxVectorLoadStoreTests.java @@ -56,7 +56,7 @@ public class FloatMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfFloat ELEMENT_LAYOUT = ValueLayout.JAVA_FLOAT.withBitAlignment(8); + static final ValueLayout.OfFloat ELEMENT_LAYOUT = ValueLayout.JAVA_FLOAT.withByteAlignment(1); static VectorShape getMaxBit() { return VectorShape.S_Max_BIT; diff --git a/test/jdk/jdk/incubator/vector/Int128VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Int128VectorLoadStoreTests.java index 04f1f7d6e66..0de06ca4ec4 100644 --- a/test/jdk/jdk/incubator/vector/Int128VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Int128VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Int128VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfInt ELEMENT_LAYOUT = ValueLayout.JAVA_INT.withBitAlignment(8); + static final ValueLayout.OfInt ELEMENT_LAYOUT = ValueLayout.JAVA_INT.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 128); diff --git a/test/jdk/jdk/incubator/vector/Int256VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Int256VectorLoadStoreTests.java index a7b503a95f5..8b9cfb876a8 100644 --- a/test/jdk/jdk/incubator/vector/Int256VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Int256VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Int256VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfInt ELEMENT_LAYOUT = ValueLayout.JAVA_INT.withBitAlignment(8); + static final ValueLayout.OfInt ELEMENT_LAYOUT = ValueLayout.JAVA_INT.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 256); diff --git a/test/jdk/jdk/incubator/vector/Int512VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Int512VectorLoadStoreTests.java index 2843eaa9ea8..96957ec4903 100644 --- a/test/jdk/jdk/incubator/vector/Int512VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Int512VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Int512VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfInt ELEMENT_LAYOUT = ValueLayout.JAVA_INT.withBitAlignment(8); + static final ValueLayout.OfInt ELEMENT_LAYOUT = ValueLayout.JAVA_INT.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 512); diff --git a/test/jdk/jdk/incubator/vector/Int64VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Int64VectorLoadStoreTests.java index cd2c72ba977..e82c714654b 100644 --- a/test/jdk/jdk/incubator/vector/Int64VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Int64VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Int64VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfInt ELEMENT_LAYOUT = ValueLayout.JAVA_INT.withBitAlignment(8); + static final ValueLayout.OfInt ELEMENT_LAYOUT = ValueLayout.JAVA_INT.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 64); diff --git a/test/jdk/jdk/incubator/vector/IntMaxVectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/IntMaxVectorLoadStoreTests.java index 7138431a948..96f8aa9e38a 100644 --- a/test/jdk/jdk/incubator/vector/IntMaxVectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/IntMaxVectorLoadStoreTests.java @@ -56,7 +56,7 @@ public class IntMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfInt ELEMENT_LAYOUT = ValueLayout.JAVA_INT.withBitAlignment(8); + static final ValueLayout.OfInt ELEMENT_LAYOUT = ValueLayout.JAVA_INT.withByteAlignment(1); static VectorShape getMaxBit() { return VectorShape.S_Max_BIT; diff --git a/test/jdk/jdk/incubator/vector/Long128VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Long128VectorLoadStoreTests.java index 33dc4dcff24..85662ab0e88 100644 --- a/test/jdk/jdk/incubator/vector/Long128VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Long128VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Long128VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfLong ELEMENT_LAYOUT = ValueLayout.JAVA_LONG.withBitAlignment(8); + static final ValueLayout.OfLong ELEMENT_LAYOUT = ValueLayout.JAVA_LONG.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 128); diff --git a/test/jdk/jdk/incubator/vector/Long256VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Long256VectorLoadStoreTests.java index ce940c38dba..c502c19d67d 100644 --- a/test/jdk/jdk/incubator/vector/Long256VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Long256VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Long256VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfLong ELEMENT_LAYOUT = ValueLayout.JAVA_LONG.withBitAlignment(8); + static final ValueLayout.OfLong ELEMENT_LAYOUT = ValueLayout.JAVA_LONG.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 256); diff --git a/test/jdk/jdk/incubator/vector/Long512VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Long512VectorLoadStoreTests.java index 662b8e542a0..9485e1d2c06 100644 --- a/test/jdk/jdk/incubator/vector/Long512VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Long512VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Long512VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfLong ELEMENT_LAYOUT = ValueLayout.JAVA_LONG.withBitAlignment(8); + static final ValueLayout.OfLong ELEMENT_LAYOUT = ValueLayout.JAVA_LONG.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 512); diff --git a/test/jdk/jdk/incubator/vector/Long64VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Long64VectorLoadStoreTests.java index 74bfe78b1f8..145f8e18718 100644 --- a/test/jdk/jdk/incubator/vector/Long64VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Long64VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Long64VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfLong ELEMENT_LAYOUT = ValueLayout.JAVA_LONG.withBitAlignment(8); + static final ValueLayout.OfLong ELEMENT_LAYOUT = ValueLayout.JAVA_LONG.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 64); diff --git a/test/jdk/jdk/incubator/vector/LongMaxVectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/LongMaxVectorLoadStoreTests.java index 580b7c34b4f..ec0170c8779 100644 --- a/test/jdk/jdk/incubator/vector/LongMaxVectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/LongMaxVectorLoadStoreTests.java @@ -56,7 +56,7 @@ public class LongMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfLong ELEMENT_LAYOUT = ValueLayout.JAVA_LONG.withBitAlignment(8); + static final ValueLayout.OfLong ELEMENT_LAYOUT = ValueLayout.JAVA_LONG.withByteAlignment(1); static VectorShape getMaxBit() { return VectorShape.S_Max_BIT; diff --git a/test/jdk/jdk/incubator/vector/Short128VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Short128VectorLoadStoreTests.java index 5c90c6c5f9d..f404ee49139 100644 --- a/test/jdk/jdk/incubator/vector/Short128VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Short128VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Short128VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfShort ELEMENT_LAYOUT = ValueLayout.JAVA_SHORT.withBitAlignment(8); + static final ValueLayout.OfShort ELEMENT_LAYOUT = ValueLayout.JAVA_SHORT.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 128); diff --git a/test/jdk/jdk/incubator/vector/Short256VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Short256VectorLoadStoreTests.java index 6e0cb97469d..e6ba0a2f6b0 100644 --- a/test/jdk/jdk/incubator/vector/Short256VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Short256VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Short256VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfShort ELEMENT_LAYOUT = ValueLayout.JAVA_SHORT.withBitAlignment(8); + static final ValueLayout.OfShort ELEMENT_LAYOUT = ValueLayout.JAVA_SHORT.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 256); diff --git a/test/jdk/jdk/incubator/vector/Short512VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Short512VectorLoadStoreTests.java index 1635cab3538..b4c2a899c4e 100644 --- a/test/jdk/jdk/incubator/vector/Short512VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Short512VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Short512VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfShort ELEMENT_LAYOUT = ValueLayout.JAVA_SHORT.withBitAlignment(8); + static final ValueLayout.OfShort ELEMENT_LAYOUT = ValueLayout.JAVA_SHORT.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 512); diff --git a/test/jdk/jdk/incubator/vector/Short64VectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/Short64VectorLoadStoreTests.java index 48dd41e599e..229e41248d6 100644 --- a/test/jdk/jdk/incubator/vector/Short64VectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/Short64VectorLoadStoreTests.java @@ -54,7 +54,7 @@ public class Short64VectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfShort ELEMENT_LAYOUT = ValueLayout.JAVA_SHORT.withBitAlignment(8); + static final ValueLayout.OfShort ELEMENT_LAYOUT = ValueLayout.JAVA_SHORT.withByteAlignment(1); static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 64); diff --git a/test/jdk/jdk/incubator/vector/ShortMaxVectorLoadStoreTests.java b/test/jdk/jdk/incubator/vector/ShortMaxVectorLoadStoreTests.java index 6f5b7e69dbb..4f5ab531c75 100644 --- a/test/jdk/jdk/incubator/vector/ShortMaxVectorLoadStoreTests.java +++ b/test/jdk/jdk/incubator/vector/ShortMaxVectorLoadStoreTests.java @@ -56,7 +56,7 @@ public class ShortMaxVectorLoadStoreTests extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.OfShort ELEMENT_LAYOUT = ValueLayout.JAVA_SHORT.withBitAlignment(8); + static final ValueLayout.OfShort ELEMENT_LAYOUT = ValueLayout.JAVA_SHORT.withByteAlignment(1); static VectorShape getMaxBit() { return VectorShape.S_Max_BIT; diff --git a/test/jdk/jdk/incubator/vector/templates/X-LoadStoreTest.java.template b/test/jdk/jdk/incubator/vector/templates/X-LoadStoreTest.java.template index a9d46118cbc..bac451ae026 100644 --- a/test/jdk/jdk/incubator/vector/templates/X-LoadStoreTest.java.template +++ b/test/jdk/jdk/incubator/vector/templates/X-LoadStoreTest.java.template @@ -67,7 +67,7 @@ public class $vectorteststype$ extends AbstractVectorLoadStoreTest { static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); - static final ValueLayout.Of$Type$ ELEMENT_LAYOUT = ValueLayout.JAVA_$TYPE$.withBitAlignment(8); + static final ValueLayout.Of$Type$ ELEMENT_LAYOUT = ValueLayout.JAVA_$TYPE$.withByteAlignment(1); #if[MaxBit] static VectorShape getMaxBit() {