8295044: Implementation of Foreign Function and Memory API (Second Preview)

Co-authored-by: Jorn Vernee <jvernee@openjdk.org>
Co-authored-by: Per Minborg <pminborg@openjdk.org>
Co-authored-by: Maurizio Cimadamore <mcimadamore@openjdk.org>
Reviewed-by: jvernee, pminborg, psandoz, alanb, sundar

src/java.base/share/classes/java/lang/invoke/MethodHandles.java

@@ -45,8 +45,8 @@ import sun.security.util.SecurityConstants;
 
 import java.lang.constant.ConstantDescs;
 import java.lang.foreign.GroupLayout;
-import java.lang.foreign.MemoryAddress;
 import java.lang.foreign.MemoryLayout;
+import java.lang.foreign.MemorySegment;
 import java.lang.foreign.ValueLayout;
 import java.lang.invoke.LambdaForm.BasicType;
 import java.lang.reflect.Constructor;
@@ -7910,21 +7910,21 @@ assertEquals("boojum", (String) catTrace.invokeExact("boo", "jum"));
      *     access modes {@code get} and {@code set} for {@code long} and
      *     {@code double} on 32-bit platforms.
      * <li>atomic update access modes for {@code int}, {@code long},
-     *     {@code float}, {@code double} or {@link MemoryAddress}.
+     *     {@code float}, {@code double} or {@link MemorySegment}.
      *     (Future major platform releases of the JDK may support additional
      *     types for certain currently unsupported access modes.)
-     * <li>numeric atomic update access modes for {@code int}, {@code long} and {@link MemoryAddress}.
+     * <li>numeric atomic update access modes for {@code int}, {@code long} and {@link MemorySegment}.
      *     (Future major platform releases of the JDK may support additional
      *     numeric types for certain currently unsupported access modes.)
-     * <li>bitwise atomic update access modes for {@code int}, {@code long} and {@link MemoryAddress}.
+     * <li>bitwise atomic update access modes for {@code int}, {@code long} and {@link MemorySegment}.
      *     (Future major platform releases of the JDK may support additional
      *     numeric types for certain currently unsupported access modes.)
      * </ul>
      *
-     * If {@code T} is {@code float}, {@code double} or {@link MemoryAddress} then atomic
+     * If {@code T} is {@code float}, {@code double} or {@link MemorySegment} then atomic
      * update access modes compare values using their bitwise representation
      * (see {@link Float#floatToRawIntBits},
-     * {@link Double#doubleToRawLongBits} and {@link MemoryAddress#toRawLongValue()}, respectively).
+     * {@link Double#doubleToRawLongBits} and {@link MemorySegment#address()}, respectively).
      * <p>
      * Alternatively, a memory access operation is <em>partially aligned</em> if it occurs at a memory address {@code A}
      * which is only compatible with the alignment constraint {@code B}; in such cases, access for anything other than the

src/java.base/share/classes/java/lang/invoke/NativeMethodHandle.java

@@ -52,24 +52,32 @@ import static java.lang.invoke.MethodHandleStatics.newInternalError;
      */
     public static MethodHandle make(NativeEntryPoint nep) {
         MethodType type = nep.type();
-        if (!allTypesPrimitive(type))
-            throw new IllegalArgumentException("Type must only contain primitives: " + type);
+        if (hasIllegalType(type))
+            throw new IllegalArgumentException("Illegal type(s) found: " + type);
 
 
         LambdaForm lform = preparedLambdaForm(type);
         return new NativeMethodHandle(type, lform, nep);
     }
 
-    private static boolean allTypesPrimitive(MethodType type) {
-        if (!type.returnType().isPrimitive())
-            return false;
+    private static boolean hasIllegalType(MethodType type) {
+        if (isIllegalType(type.returnType()))
+            return true;
 
         for (Class<?> pType : type.parameterArray()) {
-            if (!pType.isPrimitive())
-                return false;
+            if (isIllegalType(pType))
+                return true;
         }
 
-        return true;
+        return false;
+    }
+
+    private static boolean isIllegalType(Class<?> pType) {
+        return !(pType == long.class
+              || pType == int.class
+              || pType == float.class
+              || pType == double.class
+              || pType == void.class);
     }
 
     private static final MemberName.Factory IMPL_NAMES = MemberName.getFactory();

src/java.base/share/classes/java/lang/invoke/X-VarHandleByteArrayView.java.template

@@ -34,7 +34,6 @@ import jdk.internal.util.Preconditions;
 import jdk.internal.vm.annotation.ForceInline;
 
 import java.lang.foreign.MemorySegment;
-import java.lang.foreign.MemorySession;
 import java.nio.ByteBuffer;
 import java.nio.ReadOnlyBufferException;
 import java.util.List;