8317514: Ensure MemorySegment is initialized before touching NativeMemorySegmentImpl

Co-authored-by: Jorn Vernee <[email protected]>
Reviewed-by: jvernee

Author: 2 people

src/java.base/share/classes/java/lang/foreign/MemorySegment.java

@@ -44,9 +44,8 @@
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 import jdk.internal.foreign.AbstractMemorySegmentImpl;
-import jdk.internal.foreign.HeapMemorySegmentImpl;
 import jdk.internal.foreign.MemorySessionImpl;
-import jdk.internal.foreign.NativeMemorySegmentImpl;
+import jdk.internal.foreign.SegmentFactories;
 import jdk.internal.foreign.StringSupport;
 import jdk.internal.foreign.Utils;
 import jdk.internal.javac.Restricted;
@@ -1203,7 +1202,7 @@ static MemorySegment ofBuffer(Buffer buffer) {
      * @return a heap memory segment backed by a byte array.
      */
     static MemorySegment ofArray(byte[] byteArray) {
-        return HeapMemorySegmentImpl.OfByte.fromArray(byteArray);
+        return SegmentFactories.fromArray(byteArray);
     }
 
     /**
@@ -1215,7 +1214,7 @@ static MemorySegment ofArray(byte[] byteArray) {
      * @return a heap memory segment backed by a char array.
      */
     static MemorySegment ofArray(char[] charArray) {
-        return HeapMemorySegmentImpl.OfChar.fromArray(charArray);
+        return SegmentFactories.fromArray(charArray);
     }
 
     /**
@@ -1227,7 +1226,7 @@ static MemorySegment ofArray(char[] charArray) {
      * @return a heap memory segment backed by a short array.
      */
     static MemorySegment ofArray(short[] shortArray) {
-        return HeapMemorySegmentImpl.OfShort.fromArray(shortArray);
+        return SegmentFactories.fromArray(shortArray);
     }
 
     /**
@@ -1239,7 +1238,7 @@ static MemorySegment ofArray(short[] shortArray) {
      * @return a heap memory segment backed by an int array.
      */
     static MemorySegment ofArray(int[] intArray) {
-        return HeapMemorySegmentImpl.OfInt.fromArray(intArray);
+        return SegmentFactories.fromArray(intArray);
     }
 
     /**
@@ -1251,7 +1250,7 @@ static MemorySegment ofArray(int[] intArray) {
      * @return a heap memory segment backed by a float array.
      */
     static MemorySegment ofArray(float[] floatArray) {
-        return HeapMemorySegmentImpl.OfFloat.fromArray(floatArray);
+        return SegmentFactories.fromArray(floatArray);
     }
 
     /**
@@ -1263,7 +1262,7 @@ static MemorySegment ofArray(float[] floatArray) {
      * @return a heap memory segment backed by a long array.
      */
     static MemorySegment ofArray(long[] longArray) {
-        return HeapMemorySegmentImpl.OfLong.fromArray(longArray);
+        return SegmentFactories.fromArray(longArray);
     }
 
     /**
@@ -1275,13 +1274,13 @@ static MemorySegment ofArray(long[] longArray) {
      * @return a heap memory segment backed by a double array.
      */
     static MemorySegment ofArray(double[] doubleArray) {
-        return HeapMemorySegmentImpl.OfDouble.fromArray(doubleArray);
+        return SegmentFactories.fromArray(doubleArray);
     }
 
     /**
-     * A zero-length native segment modelling the {@code NULL} address.
+     * A zero-length native segment modelling the {@code NULL} address. Equivalent to {@code MemorySegment.ofAddress(0L)}.
      */
-    MemorySegment NULL = new NativeMemorySegmentImpl();
+    MemorySegment NULL = MemorySegment.ofAddress(0L);
 
     /**
      * Creates a zero-length native segment from the given {@linkplain #address() address value}.
@@ -1295,7 +1294,7 @@ static MemorySegment ofArray(double[] doubleArray) {
      * @return a zero-length native segment with the given address.
      */
     static MemorySegment ofAddress(long address) {
-        return NativeMemorySegmentImpl.makeNativeSegmentUnchecked(address, 0);
+        return SegmentFactories.makeNativeSegmentUnchecked(address, 0);
     }
 
     /**

src/java.base/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java

@@ -151,9 +151,9 @@ public MemorySegment reinterpretInternal(Class<?> callerClass, long newSize, Sco
         }
         if (!isNative()) throw new UnsupportedOperationException("Not a native segment");
         Runnable action = cleanup != null ?
-                () -> cleanup.accept(NativeMemorySegmentImpl.makeNativeSegmentUnchecked(address(), newSize)) :
+                () -> cleanup.accept(SegmentFactories.makeNativeSegmentUnchecked(address(), newSize)) :
                 null;
-        return NativeMemorySegmentImpl.makeNativeSegmentUnchecked(address(), newSize,
+        return SegmentFactories.makeNativeSegmentUnchecked(address(), newSize,
                 (MemorySessionImpl)scope, action);
     }
 

src/java.base/share/classes/jdk/internal/foreign/ArenaImpl.java

@@ -52,7 +52,7 @@ public void close() {
 
     public MemorySegment allocateNoInit(long byteSize, long byteAlignment) {
         Utils.checkAllocationSizeAndAlign(byteSize, byteAlignment);
-        return NativeMemorySegmentImpl.makeNativeSegmentNoZeroing(byteSize, byteAlignment, session, shouldReserveMemory);
+        return SegmentFactories.allocateSegment(byteSize, byteAlignment, session, shouldReserveMemory);
     }
 
     @Override

src/java.base/share/classes/jdk/internal/foreign/HeapMemorySegmentImpl.java

@@ -26,7 +26,6 @@
 
 package jdk.internal.foreign;
 
-import java.lang.foreign.MemorySegment;
 import java.lang.foreign.ValueLayout;
 import java.nio.ByteBuffer;
 import java.util.Objects;
@@ -48,7 +47,7 @@
  * using sharper types would require use of type-conversions, which in turn would inhibit some C2 optimizations,
  * such as the elimination of store barriers in methods like {@link HeapMemorySegmentImpl#dup(long, long, boolean, MemorySessionImpl)}.
  */
-public abstract sealed class HeapMemorySegmentImpl extends AbstractMemorySegmentImpl {
+abstract sealed class HeapMemorySegmentImpl extends AbstractMemorySegmentImpl {
 
     private static final Unsafe UNSAFE = Unsafe.getUnsafe();
     private static final int BYTE_ARR_BASE = UNSAFE.arrayBaseOffset(byte[].class);
@@ -110,13 +109,6 @@ public byte[] unsafeGetBase() {
             return (byte[])Objects.requireNonNull(base);
         }
 
-        public static MemorySegment fromArray(byte[] arr) {
-            Objects.requireNonNull(arr);
-            long byteSize = (long)arr.length * Unsafe.ARRAY_BYTE_INDEX_SCALE;
-            return new OfByte(Unsafe.ARRAY_BYTE_BASE_OFFSET, arr, byteSize, false,
-                    MemorySessionImpl.heapSession(arr));
-        }
-
         @Override
         public long maxAlignMask() {
             return MAX_ALIGN_1;
@@ -144,13 +136,6 @@ public char[] unsafeGetBase() {
             return (char[])Objects.requireNonNull(base);
         }
 
-        public static MemorySegment fromArray(char[] arr) {
-            Objects.requireNonNull(arr);
-            long byteSize = (long)arr.length * Unsafe.ARRAY_CHAR_INDEX_SCALE;
-            return new OfChar(Unsafe.ARRAY_CHAR_BASE_OFFSET, arr, byteSize, false,
-                    MemorySessionImpl.heapSession(arr));
-        }
-
         @Override
         public long maxAlignMask() {
             return MAX_ALIGN_2;
@@ -178,13 +163,6 @@ public short[] unsafeGetBase() {
             return (short[])Objects.requireNonNull(base);
         }
 
-        public static MemorySegment fromArray(short[] arr) {
-            Objects.requireNonNull(arr);
-            long byteSize = (long)arr.length * Unsafe.ARRAY_SHORT_INDEX_SCALE;
-            return new OfShort(Unsafe.ARRAY_SHORT_BASE_OFFSET, arr, byteSize, false,
-                    MemorySessionImpl.heapSession(arr));
-        }
-
         @Override
         public long maxAlignMask() {
             return MAX_ALIGN_2;
@@ -212,13 +190,6 @@ public int[] unsafeGetBase() {
             return (int[])Objects.requireNonNull(base);
         }
 
-        public static MemorySegment fromArray(int[] arr) {
-            Objects.requireNonNull(arr);
-            long byteSize = (long)arr.length * Unsafe.ARRAY_INT_INDEX_SCALE;
-            return new OfInt(Unsafe.ARRAY_INT_BASE_OFFSET, arr, byteSize, false,
-                    MemorySessionImpl.heapSession(arr));
-        }
-
         @Override
         public long maxAlignMask() {
             return MAX_ALIGN_4;
@@ -246,13 +217,6 @@ public long[] unsafeGetBase() {
             return (long[])Objects.requireNonNull(base);
         }
 
-        public static MemorySegment fromArray(long[] arr) {
-            Objects.requireNonNull(arr);
-            long byteSize = (long)arr.length * Unsafe.ARRAY_LONG_INDEX_SCALE;
-            return new OfLong(Unsafe.ARRAY_LONG_BASE_OFFSET, arr, byteSize, false,
-                    MemorySessionImpl.heapSession(arr));
-        }
-
         @Override
         public long maxAlignMask() {
             return MAX_ALIGN_8;
@@ -280,13 +244,6 @@ public float[] unsafeGetBase() {
             return (float[])Objects.requireNonNull(base);
         }
 
-        public static MemorySegment fromArray(float[] arr) {
-            Objects.requireNonNull(arr);
-            long byteSize = (long)arr.length * Unsafe.ARRAY_FLOAT_INDEX_SCALE;
-            return new OfFloat(Unsafe.ARRAY_FLOAT_BASE_OFFSET, arr, byteSize, false,
-                    MemorySessionImpl.heapSession(arr));
-        }
-
         @Override
         public long maxAlignMask() {
             return MAX_ALIGN_4;
@@ -314,13 +271,6 @@ public double[] unsafeGetBase() {
             return (double[])Objects.requireNonNull(base);
         }
 
-        public static MemorySegment fromArray(double[] arr) {
-            Objects.requireNonNull(arr);
-            long byteSize = (long)arr.length * Unsafe.ARRAY_DOUBLE_INDEX_SCALE;
-            return new OfDouble(Unsafe.ARRAY_DOUBLE_BASE_OFFSET, arr, byteSize, false,
-                    MemorySessionImpl.heapSession(arr));
-        }
-
         @Override
         public long maxAlignMask() {
             return MAX_ALIGN_8;

src/java.base/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java

@@ -35,7 +35,7 @@
  * memory mapped segment, such as the file descriptor associated with the mapping. This information is crucial
  * in order to correctly reconstruct a byte buffer object from the segment (see {@link #makeByteBuffer()}).
  */
-public final class MappedMemorySegmentImpl extends NativeMemorySegmentImpl {
+final class MappedMemorySegmentImpl extends NativeMemorySegmentImpl {
 
     private final UnmapperProxy unmapper;
 

src/java.base/share/classes/jdk/internal/foreign/NativeMemorySegmentImpl.java

@@ -31,20 +31,13 @@
 import java.util.Optional;
 
 import jdk.internal.misc.Unsafe;
-import jdk.internal.misc.VM;
 import jdk.internal.vm.annotation.ForceInline;
 
 /**
  * Implementation for native memory segments. A native memory segment is essentially a wrapper around
  * a native long address.
  */
-public sealed class NativeMemorySegmentImpl extends AbstractMemorySegmentImpl permits MappedMemorySegmentImpl {
-
-    private static final Unsafe UNSAFE = Unsafe.getUnsafe();
-
-    // 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;
+sealed class NativeMemorySegmentImpl extends AbstractMemorySegmentImpl permits MappedMemorySegmentImpl {
 
     final long min;
 
@@ -58,17 +51,6 @@ public sealed class NativeMemorySegmentImpl extends AbstractMemorySegmentImpl pe
                 : min;
     }
 
-    /**
-     * This constructor should only be used when initializing {@link MemorySegment#NULL}. Note: because of the memory
-     * segment class hierarchy, it is possible to end up in a situation where this constructor is called
-     * when the static fields in this class are not yet initialized.
-     */
-    @ForceInline
-    public NativeMemorySegmentImpl() {
-        super(0L, false, new GlobalSession(null));
-        this.min = 0L;
-    }
-
     @Override
     public long address() {
         return min;
@@ -110,72 +92,4 @@ public Object unsafeGetBase() {
     public long maxAlignMask() {
         return 0;
     }
-
-    // factories
-
-    public static MemorySegment makeNativeSegmentNoZeroing(long byteSize, long byteAlignment, MemorySessionImpl sessionImpl,
-                                                  boolean shouldReserve) {
-        sessionImpl.checkValidState();
-        if (VM.isDirectMemoryPageAligned()) {
-            byteAlignment = Math.max(byteAlignment, NIO_ACCESS.pageSize());
-        }
-        long alignedSize = Math.max(1L, byteAlignment > MAX_MALLOC_ALIGN ?
-                byteSize + (byteAlignment - 1) :
-                byteSize);
-
-        if (shouldReserve) {
-            NIO_ACCESS.reserveMemory(alignedSize, byteSize);
-        }
-
-        long buf = allocateMemoryWrapper(alignedSize);
-        long alignedBuf = Utils.alignUp(buf, byteAlignment);
-        AbstractMemorySegmentImpl segment = new NativeMemorySegmentImpl(buf, alignedSize,
-                false, sessionImpl);
-        sessionImpl.addOrCleanupIfFail(new MemorySessionImpl.ResourceList.ResourceCleanup() {
-            @Override
-            public void cleanup() {
-                UNSAFE.freeMemory(buf);
-                if (shouldReserve) {
-                    NIO_ACCESS.unreserveMemory(alignedSize, byteSize);
-                }
-            }
-        });
-        if (alignedSize != byteSize) {
-            long delta = alignedBuf - buf;
-            segment = segment.asSlice(delta, byteSize);
-        }
-        return segment;
-    }
-
-    private static long allocateMemoryWrapper(long size) {
-        try {
-            return UNSAFE.allocateMemory(size);
-        } catch (IllegalArgumentException ex) {
-            throw new OutOfMemoryError();
-        }
-    }
-
-    // Unsafe native segment factories. These are used by the implementation code, to skip the sanity checks
-    // associated with MemorySegment::ofAddress.
-
-    @ForceInline
-    public static MemorySegment makeNativeSegmentUnchecked(long min, long byteSize, MemorySessionImpl sessionImpl, Runnable action) {
-        if (action == null) {
-            sessionImpl.checkValidState();
-        } else {
-            sessionImpl.addCloseAction(action);
-        }
-        return new NativeMemorySegmentImpl(min, byteSize, false, sessionImpl);
-    }
-
-    @ForceInline
-    public static MemorySegment makeNativeSegmentUnchecked(long min, long byteSize, MemorySessionImpl sessionImpl) {
-        sessionImpl.checkValidState();
-        return new NativeMemorySegmentImpl(min, byteSize, false, sessionImpl);
-    }
-
-    @ForceInline
-    public static MemorySegment makeNativeSegmentUnchecked(long min, long byteSize) {
-        return new NativeMemorySegmentImpl(min, byteSize, false, new GlobalSession(null));
-    }
 }