diff --git a/src/java.base/share/classes/java/lang/foreign/AbstractLayout.java b/src/java.base/share/classes/java/lang/foreign/AbstractLayout.java
index 37240800292..49139755c19 100644
--- a/src/java.base/share/classes/java/lang/foreign/AbstractLayout.java
+++ b/src/java.base/share/classes/java/lang/foreign/AbstractLayout.java
@@ -33,22 +33,22 @@
 
 abstract non-sealed class AbstractLayout implements MemoryLayout {
 
-    private final long size;
-    final long alignment;
+    private final long bitSize;
+    final long bitAlignment;
     private final Optional<String> name;
     @Stable
-    long cachedSize;
+    long byteSize;
 
-    AbstractLayout(long size, long alignment, Optional<String> name) {
-        this.size = size;
-        this.alignment = alignment;
+    AbstractLayout(long bitSize, long bitAlignment, Optional<String> name) {
+        this.bitSize = bitSize;
+        this.bitAlignment = bitAlignment;
         this.name = name;
     }
 
     @Override
     public AbstractLayout withName(String name) {
         Objects.requireNonNull(name);
-        return dup(alignment, Optional.of(name));
+        return dup(bitAlignment, Optional.of(name));
     }
 
     @Override
@@ -56,12 +56,12 @@ public final Optional<String> name() {
         return name;
     }
 
-    abstract AbstractLayout dup(long alignment, Optional<String> name);
+    abstract AbstractLayout dup(long bitAlignment, Optional<String> name);
 
     @Override
-    public AbstractLayout withBitAlignment(long alignmentBits) {
-        checkAlignment(alignmentBits);
-        return dup(alignmentBits, name);
+    public AbstractLayout withBitAlignment(long bitAlignment) {
+        checkAlignment(bitAlignment);
+        return dup(bitAlignment, name);
     }
 
     void checkAlignment(long alignmentBitCount) {
@@ -83,22 +83,22 @@ static void checkSize(long size, boolean includeZero) {
 
     @Override
     public final long bitAlignment() {
-        return alignment;
+        return bitAlignment;
     }
 
     @Override
     @ForceInline
     public long byteSize() {
-        if (cachedSize == 0) {
-            cachedSize = Utils.bitsToBytesOrThrow(bitSize(),
+        if (byteSize == 0) {
+            byteSize = Utils.bitsToBytesOrThrow(bitSize(),
                     () -> new UnsupportedOperationException("Cannot compute byte size; bit size is not a multiple of 8"));
         }
-        return cachedSize;
+        return byteSize;
     }
 
     @Override
     public long bitSize() {
-        return size;
+        return bitSize;
     }
 
     String decorateLayoutString(String s) {
@@ -106,13 +106,13 @@ String decorateLayoutString(String s) {
             s = String.format("%s(%s)", s, name().get());
         }
         if (!hasNaturalAlignment()) {
-            s = alignment + "%" + s;
+            s = bitAlignment + "%" + s;
         }
         return s;
     }
 
     boolean hasNaturalAlignment() {
-        return size == alignment;
+        return bitSize == bitAlignment;
     }
 
     @Override
@@ -128,7 +128,7 @@ public boolean isPadding() {
      */
     @Override
     public int hashCode() {
-        return Objects.hash(name, size, alignment);
+        return Objects.hash(name, bitSize, bitAlignment);
     }
 
     /**
@@ -156,8 +156,8 @@ public boolean equals(Object other) {
 
         return other instanceof AbstractLayout otherLayout &&
                 name.equals(otherLayout.name) &&
-                size == otherLayout.size &&
-                alignment == otherLayout.alignment;
+                bitSize == otherLayout.bitSize &&
+                bitAlignment == otherLayout.bitAlignment;
     }
 
     /**
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 d012735ba9f..54f34ebfb00 100644
--- a/src/java.base/share/classes/java/lang/foreign/GroupLayout.java
+++ b/src/java.base/share/classes/java/lang/foreign/GroupLayout.java
@@ -89,8 +89,8 @@ long alignof(List<MemoryLayout> elems) {
         this(kind, elements, kind.alignof(elements), Optional.empty());
     }
 
-    GroupLayout(Kind kind, List<MemoryLayout> elements, long alignment, Optional<String> name) {
-        super(kind.sizeof(elements), alignment, name);
+    GroupLayout(Kind kind, List<MemoryLayout> elements, long bitAlignment, Optional<String> name) {
+        super(kind.sizeof(elements), bitAlignment, name);
         this.kind = kind;
         this.elements = elements;
     }
@@ -157,13 +157,13 @@ public int hashCode() {
     }
 
     @Override
-    GroupLayout dup(long alignment, Optional<String> name) {
-        return new GroupLayout(kind, elements, alignment, name);
+    GroupLayout dup(long bitAlignment, Optional<String> name) {
+        return new GroupLayout(kind, elements, bitAlignment, name);
     }
 
     @Override
     boolean hasNaturalAlignment() {
-        return alignment == kind.alignof(elements);
+        return bitAlignment == kind.alignof(elements);
     }
 
     //hack: the declarations below are to make javadoc happy; we could have used generics in AbstractLayout
@@ -181,7 +181,7 @@ public GroupLayout withName(String name) {
      * {@inheritDoc}
      */
     @Override
-    public GroupLayout withBitAlignment(long alignmentBits) {
-        return (GroupLayout)super.withBitAlignment(alignmentBits);
+    public GroupLayout withBitAlignment(long bitAlignment) {
+        return (GroupLayout)super.withBitAlignment(bitAlignment);
     }
 }
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 0a21c804ad1..5b4ec600782 100644
--- a/src/java.base/share/classes/java/lang/foreign/PaddingLayout.java
+++ b/src/java.base/share/classes/java/lang/foreign/PaddingLayout.java
@@ -37,12 +37,12 @@
  */
 /* package-private */ final class PaddingLayout extends AbstractLayout implements MemoryLayout {
 
-    PaddingLayout(long size) {
-        this(size, 1, Optional.empty());
+    PaddingLayout(long bitSize) {
+        this(bitSize, 1, Optional.empty());
     }
 
-    PaddingLayout(long size, long alignment, Optional<String> name) {
-        super(size, alignment, name);
+    PaddingLayout(long bitSize, long bitAlignment, Optional<String> name) {
+        super(bitSize, bitAlignment, name);
     }
 
     @Override
@@ -70,8 +70,8 @@ public int hashCode() {
     }
 
     @Override
-    PaddingLayout dup(long alignment, Optional<String> name) {
-        return new PaddingLayout(bitSize(), alignment, name);
+    PaddingLayout dup(long bitAlignment, Optional<String> name) {
+        return new PaddingLayout(bitSize(), bitAlignment, name);
     }
 
     @Override
@@ -94,7 +94,7 @@ public PaddingLayout withName(String name) {
      * {@inheritDoc}
      */
     @Override
-    public PaddingLayout withBitAlignment(long alignmentBits) {
-        return (PaddingLayout)super.withBitAlignment(alignmentBits);
+    public PaddingLayout withBitAlignment(long bitAlignment) {
+        return (PaddingLayout)super.withBitAlignment(bitAlignment);
     }
 }
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 d25ba35ead1..b423a14f5bc 100644
--- a/src/java.base/share/classes/java/lang/foreign/SequenceLayout.java
+++ b/src/java.base/share/classes/java/lang/foreign/SequenceLayout.java
@@ -64,8 +64,8 @@ public final class SequenceLayout extends AbstractLayout implements MemoryLayout
         this(elemCount, elementLayout, elementLayout.bitAlignment(), Optional.empty());
     }
 
-    SequenceLayout(long elemCount, MemoryLayout elementLayout, long alignment, Optional<String> name) {
-        super(Math.multiplyExact(elemCount, elementLayout.bitSize()), alignment, name);
+    SequenceLayout(long elemCount, MemoryLayout elementLayout, long bitAlignment, Optional<String> name) {
+        super(Math.multiplyExact(elemCount, elementLayout.bitSize()), bitAlignment, name);
         this.elemCount = elemCount;
         this.elementLayout = elementLayout;
     }
@@ -93,7 +93,7 @@ public long elementCount() {
      */
     public SequenceLayout withElementCount(long elementCount) {
         AbstractLayout.checkSize(elementCount, true);
-        return new SequenceLayout(elementCount, elementLayout, alignment, name());
+        return new SequenceLayout(elementCount, elementLayout, bitAlignment, name());
     }
 
     /**
@@ -222,13 +222,13 @@ public int hashCode() {
     }
 
     @Override
-    SequenceLayout dup(long alignment, Optional<String> name) {
-        return new SequenceLayout(elementCount(), elementLayout, alignment, name);
+    SequenceLayout dup(long bitAlignment, Optional<String> name) {
+        return new SequenceLayout(elementCount(), elementLayout, bitAlignment, name);
     }
 
     @Override
     boolean hasNaturalAlignment() {
-        return alignment == elementLayout.bitAlignment();
+        return bitAlignment == elementLayout.bitAlignment();
     }
 
     //hack: the declarations below are to make javadoc happy; we could have used generics in AbstractLayout
@@ -246,7 +246,7 @@ public SequenceLayout withName(String name) {
      * {@inheritDoc}
      */
     @Override
-    public SequenceLayout withBitAlignment(long alignmentBits) {
-        return (SequenceLayout)super.withBitAlignment(alignmentBits);
+    public SequenceLayout withBitAlignment(long bitAlignment) {
+        return (SequenceLayout)super.withBitAlignment(bitAlignment);
     }
 }
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 94391949c65..cb7fe546a4d 100644
--- a/src/java.base/share/classes/java/lang/foreign/ValueLayout.java
+++ b/src/java.base/share/classes/java/lang/foreign/ValueLayout.java
@@ -66,15 +66,15 @@ public sealed class ValueLayout extends AbstractLayout implements MemoryLayout {
 
     private static final int ADDRESS_SIZE_BITS = Unsafe.ADDRESS_SIZE * 8;
 
-    ValueLayout(Class<?> carrier, ByteOrder order, long size) {
-        this(carrier, order, size, size, Optional.empty());
+    ValueLayout(Class<?> carrier, ByteOrder order, long bitSize) {
+        this(carrier, order, bitSize, bitSize, Optional.empty());
     }
 
-    ValueLayout(Class<?> carrier, ByteOrder order, long size, long alignment, Optional<String> name) {
-        super(size, alignment, name);
+    ValueLayout(Class<?> carrier, ByteOrder order, long bitSize, long bitAlignment, Optional<String> name) {
+        super(bitSize, bitAlignment, name);
         this.carrier = carrier;
         this.order = order;
-        checkCarrierSize(carrier, size);
+        checkCarrierSize(carrier, bitSize);
     }
 
     /**
@@ -92,7 +92,7 @@ public ByteOrder order() {
      * @return a value layout with the given byte order.
      */
     public ValueLayout withOrder(ByteOrder order) {
-        return new ValueLayout(carrier, Objects.requireNonNull(order), bitSize(), alignment, name());
+        return new ValueLayout(carrier, Objects.requireNonNull(order), bitSize(), bitAlignment, name());
     }
 
     /**
@@ -211,8 +211,8 @@ public int hashCode() {
     }
 
     @Override
-    ValueLayout dup(long alignment, Optional<String> name) {
-        return new ValueLayout(carrier, order, bitSize(), alignment, name());
+    ValueLayout dup(long bitAlignment, Optional<String> name) {
+        return new ValueLayout(carrier, order, bitSize(), bitAlignment, name());
     }
 
     //hack: the declarations below are to make javadoc happy; we could have used generics in AbstractLayout
@@ -230,8 +230,8 @@ public ValueLayout withName(String name) {
      * {@inheritDoc}
      */
     @Override
-    public ValueLayout withBitAlignment(long alignmentBits) {
-        return (ValueLayout)super.withBitAlignment(alignmentBits);
+    public ValueLayout withBitAlignment(long bitAlignment) {
+        return (ValueLayout)super.withBitAlignment(bitAlignment);
     }
 
     static void checkCarrierSize(Class<?> carrier, long size) {
@@ -284,13 +284,13 @@ public static final class OfBoolean extends ValueLayout {
             super(boolean.class, order, 8);
         }
 
-        OfBoolean(ByteOrder order, long alignment, Optional<String> name) {
-            super(boolean.class, order, 8, alignment, name);
+        OfBoolean(ByteOrder order, long bitAlignment, Optional<String> name) {
+            super(boolean.class, order, 8, bitAlignment, name);
         }
 
         @Override
-        OfBoolean dup(long alignment, Optional<String> name) {
-            return new OfBoolean(order(), alignment, name);
+        OfBoolean dup(long bitAlignment, Optional<String> name) {
+            return new OfBoolean(order(), bitAlignment, name);
         }
 
         @Override
@@ -299,14 +299,14 @@ public OfBoolean withName(String name) {
         }
 
         @Override
-        public OfBoolean withBitAlignment(long alignmentBits) {
-            return (OfBoolean)super.withBitAlignment(alignmentBits);
+        public OfBoolean withBitAlignment(long bitAlignment) {
+            return (OfBoolean)super.withBitAlignment(bitAlignment);
         }
 
         @Override
         public OfBoolean withOrder(ByteOrder order) {
             Objects.requireNonNull(order);
-            return new OfBoolean(order, alignment, name());
+            return new OfBoolean(order, bitAlignment, name());
         }
     }
 
@@ -321,13 +321,13 @@ public static final class OfByte extends ValueLayout {
             super(byte.class, order, 8);
         }
 
-        OfByte(ByteOrder order, long alignment, Optional<String> name) {
-            super(byte.class, order, 8, alignment, name);
+        OfByte(ByteOrder order, long bitAlignment, Optional<String> name) {
+            super(byte.class, order, 8, bitAlignment, name);
         }
 
         @Override
-        OfByte dup(long alignment, Optional<String> name) {
-            return new OfByte(order(), alignment, name);
+        OfByte dup(long bitAlignment, Optional<String> name) {
+            return new OfByte(order(), bitAlignment, name);
         }
 
         @Override
@@ -336,14 +336,14 @@ public OfByte withName(String name) {
         }
 
         @Override
-        public OfByte withBitAlignment(long alignmentBits) {
-            return (OfByte)super.withBitAlignment(alignmentBits);
+        public OfByte withBitAlignment(long bitAlignment) {
+            return (OfByte)super.withBitAlignment(bitAlignment);
         }
 
         @Override
         public OfByte withOrder(ByteOrder order) {
             Objects.requireNonNull(order);
-            return new OfByte(order, alignment, name());
+            return new OfByte(order, bitAlignment, name());
         }
     }
 
@@ -358,13 +358,13 @@ public static final class OfChar extends ValueLayout {
             super(char.class, order, 16);
         }
 
-        OfChar(ByteOrder order, long alignment, Optional<String> name) {
-            super(char.class, order, 16, alignment, name);
+        OfChar(ByteOrder order, long bitAlignment, Optional<String> name) {
+            super(char.class, order, 16, bitAlignment, name);
         }
 
         @Override
-        OfChar dup(long alignment, Optional<String> name) {
-            return new OfChar(order(), alignment, name);
+        OfChar dup(long bitAlignment, Optional<String> name) {
+            return new OfChar(order(), bitAlignment, name);
         }
 
         @Override
@@ -373,14 +373,14 @@ public OfChar withName(String name) {
         }
 
         @Override
-        public OfChar withBitAlignment(long alignmentBits) {
-            return (OfChar)super.withBitAlignment(alignmentBits);
+        public OfChar withBitAlignment(long bitAlignment) {
+            return (OfChar)super.withBitAlignment(bitAlignment);
         }
 
         @Override
         public OfChar withOrder(ByteOrder order) {
             Objects.requireNonNull(order);
-            return new OfChar(order, alignment, name());
+            return new OfChar(order, bitAlignment, name());
         }
     }
 
@@ -395,13 +395,13 @@ public static final class OfShort extends ValueLayout {
             super(short.class, order, 16);
         }
 
-        OfShort(ByteOrder order, long alignment, Optional<String> name) {
-            super(short.class, order, 16, alignment, name);
+        OfShort(ByteOrder order, long bitAlignment, Optional<String> name) {
+            super(short.class, order, 16, bitAlignment, name);
         }
 
         @Override
-        OfShort dup(long alignment, Optional<String> name) {
-            return new OfShort(order(), alignment, name);
+        OfShort dup(long bitAlignment, Optional<String> name) {
+            return new OfShort(order(), bitAlignment, name);
         }
 
         @Override
@@ -410,14 +410,14 @@ public OfShort withName(String name) {
         }
 
         @Override
-        public OfShort withBitAlignment(long alignmentBits) {
-            return (OfShort)super.withBitAlignment(alignmentBits);
+        public OfShort withBitAlignment(long bitAlignment) {
+            return (OfShort)super.withBitAlignment(bitAlignment);
         }
 
         @Override
         public OfShort withOrder(ByteOrder order) {
             Objects.requireNonNull(order);
-            return new OfShort(order, alignment, name());
+            return new OfShort(order, bitAlignment, name());
         }
     }
 
@@ -432,13 +432,13 @@ public static final class OfInt extends ValueLayout {
             super(int.class, order, 32);
         }
 
-        OfInt(ByteOrder order, long alignment, Optional<String> name) {
-            super(int.class, order, 32, alignment, name);
+        OfInt(ByteOrder order, long bitAlignment, Optional<String> name) {
+            super(int.class, order, 32, bitAlignment, name);
         }
 
         @Override
-        OfInt dup(long alignment, Optional<String> name) {
-            return new OfInt(order(), alignment, name);
+        OfInt dup(long bitAlignment, Optional<String> name) {
+            return new OfInt(order(), bitAlignment, name);
         }
 
         @Override
@@ -447,14 +447,14 @@ public OfInt withName(String name) {
         }
 
         @Override
-        public OfInt withBitAlignment(long alignmentBits) {
-            return (OfInt)super.withBitAlignment(alignmentBits);
+        public OfInt withBitAlignment(long bitAlignment) {
+            return (OfInt)super.withBitAlignment(bitAlignment);
         }
 
         @Override
         public OfInt withOrder(ByteOrder order) {
             Objects.requireNonNull(order);
-            return new OfInt(order, alignment, name());
+            return new OfInt(order, bitAlignment, name());
         }
     }
 
@@ -469,13 +469,13 @@ public static final class OfFloat extends ValueLayout {
             super(float.class, order, 32);
         }
 
-        OfFloat(ByteOrder order, long alignment, Optional<String> name) {
-            super(float.class, order, 32, alignment, name);
+        OfFloat(ByteOrder order, long bitAlignment, Optional<String> name) {
+            super(float.class, order, 32, bitAlignment, name);
         }
 
         @Override
-        OfFloat dup(long alignment, Optional<String> name) {
-            return new OfFloat(order(), alignment, name);
+        OfFloat dup(long bitAlignment, Optional<String> name) {
+            return new OfFloat(order(), bitAlignment, name);
         }
 
         @Override
@@ -484,14 +484,14 @@ public OfFloat withName(String name) {
         }
 
         @Override
-        public OfFloat withBitAlignment(long alignmentBits) {
-            return (OfFloat)super.withBitAlignment(alignmentBits);
+        public OfFloat withBitAlignment(long bitAlignment) {
+            return (OfFloat)super.withBitAlignment(bitAlignment);
         }
 
         @Override
         public OfFloat withOrder(ByteOrder order) {
             Objects.requireNonNull(order);
-            return new OfFloat(order, alignment, name());
+            return new OfFloat(order, bitAlignment, name());
         }
     }
 
@@ -506,13 +506,13 @@ public static final class OfLong extends ValueLayout {
             super(long.class, order, 64);
         }
 
-        OfLong(ByteOrder order, long alignment, Optional<String> name) {
-            super(long.class, order, 64, alignment, name);
+        OfLong(ByteOrder order, long bitAlignment, Optional<String> name) {
+            super(long.class, order, 64, bitAlignment, name);
         }
 
         @Override
-        OfLong dup(long alignment, Optional<String> name) {
-            return new OfLong(order(), alignment, name);
+        OfLong dup(long bitAlignment, Optional<String> name) {
+            return new OfLong(order(), bitAlignment, name);
         }
 
         @Override
@@ -521,14 +521,14 @@ public OfLong withName(String name) {
         }
 
         @Override
-        public OfLong withBitAlignment(long alignmentBits) {
-            return (OfLong)super.withBitAlignment(alignmentBits);
+        public OfLong withBitAlignment(long bitAlignment) {
+            return (OfLong)super.withBitAlignment(bitAlignment);
         }
 
         @Override
         public OfLong withOrder(ByteOrder order) {
             Objects.requireNonNull(order);
-            return new OfLong(order, alignment, name());
+            return new OfLong(order, bitAlignment, name());
         }
     }
 
@@ -543,13 +543,13 @@ public static final class OfDouble extends ValueLayout {
             super(double.class, order, 64);
         }
 
-        OfDouble(ByteOrder order, long alignment, Optional<String> name) {
-            super(double.class, order, 64, alignment, name);
+        OfDouble(ByteOrder order, long bitAlignment, Optional<String> name) {
+            super(double.class, order, 64, bitAlignment, name);
         }
 
         @Override
-        OfDouble dup(long alignment, Optional<String> name) {
-            return new OfDouble(order(), alignment, name);
+        OfDouble dup(long bitAlignment, Optional<String> name) {
+            return new OfDouble(order(), bitAlignment, name);
         }
 
         @Override
@@ -558,14 +558,14 @@ public OfDouble withName(String name) {
         }
 
         @Override
-        public OfDouble withBitAlignment(long alignmentBits) {
-            return (OfDouble)super.withBitAlignment(alignmentBits);
+        public OfDouble withBitAlignment(long bitAlignment) {
+            return (OfDouble)super.withBitAlignment(bitAlignment);
         }
 
         @Override
         public OfDouble withOrder(ByteOrder order) {
             Objects.requireNonNull(order);
-            return new OfDouble(order, alignment, name());
+            return new OfDouble(order, bitAlignment, name());
         }
     }
 
@@ -584,14 +584,14 @@ public static final class OfAddress extends ValueLayout {
             this.isUnbounded = false; // safe
         }
 
-        OfAddress(ByteOrder order, long size, long alignment, boolean isUnbounded, Optional<String> name) {
-            super(MemorySegment.class, order, size, alignment, name);
+        OfAddress(ByteOrder order, long bitSize, long bitAlignment, boolean isUnbounded, Optional<String> name) {
+            super(MemorySegment.class, order, bitSize, bitAlignment, name);
             this.isUnbounded = isUnbounded;
         }
 
         @Override
-        OfAddress dup(long alignment, Optional<String> name) {
-            return new OfAddress(order(), bitSize(), alignment, isUnbounded, name);
+        OfAddress dup(long bitAlignment, Optional<String> name) {
+            return new OfAddress(order(), bitSize(), bitAlignment, isUnbounded, name);
         }
 
         @Override
@@ -600,14 +600,14 @@ public OfAddress withName(String name) {
         }
 
         @Override
-        public OfAddress withBitAlignment(long alignmentBits) {
-            return (OfAddress)super.withBitAlignment(alignmentBits);
+        public OfAddress withBitAlignment(long bitAlignment) {
+            return (OfAddress)super.withBitAlignment(bitAlignment);
         }
 
         @Override
         public OfAddress withOrder(ByteOrder order) {
             Objects.requireNonNull(order);
-            return new OfAddress(order, bitSize(), alignment, isUnbounded, name());
+            return new OfAddress(order, bitSize(), bitAlignment, isUnbounded, name());
         }
 
         @Override
@@ -638,7 +638,7 @@ public int hashCode() {
         @CallerSensitive
         public OfAddress asUnbounded() {
             Reflection.ensureNativeAccess(Reflection.getCallerClass(), ValueLayout.OfAddress.class, "asUnbounded");
-            return new OfAddress(order(), bitSize(), alignment, true, name());
+            return new OfAddress(order(), bitSize(), bitAlignment, true, name());
         }
 
         /**