Automatic merge of foreign-memaccess+abi into foreign-jextract

Author: duke

src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/Addressable.java

@@ -28,11 +28,11 @@
 /**
  * Represents a type which is <em>addressable</em>. An addressable type is one which can be projected down to
  * a memory address instance (see {@link #address()}). Examples of addressable types are {@link MemorySegment},
- * {@link MemoryAddress}, {@link LibraryLookup.Symbol} and {@link CLinker.VaList}.
+ * {@link MemoryAddress} and {@link CLinker.VaList}.
  *
  * @apiNote In the future, if the Java language permits, {@link Addressable}
  * may become a {@code sealed} interface, which would prohibit subclassing except by
- * explicitly permitted types, such as {@link MemorySegment}, {@link MemoryAddress}, {@link LibraryLookup.Symbol}
+ * explicitly permitted types, such as {@link MemorySegment}, {@link MemoryAddress}
  * and {@link CLinker.VaList}.
  *
  * @implSpec

src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java

@@ -40,23 +40,22 @@
  * A native library lookup. Exposes a lookup operation for searching symbols, see {@link LibraryLookup#lookup(String)}.
  * A given native library remains loaded as long as there is at least one <em>live</em> library lookup instance referring
  * to it.
- * All symbol instances (see {@link LibraryLookup.Symbol}) generated by a given library lookup object contain a strong reference
- * to said lookup object, therefore preventing library unloading; in turn method handle instances obtained from
- * {@link CLinker#downcallHandle(Addressable, MethodType, FunctionDescriptor)}) also maintain a strong reference
- * to the addressable parameter used for their construction. This means that there is always a strong reachability chain
- * from a native method handle to a lookup object (the one that was used to lookup the native library symbol the method handle
- * refers to); this is useful to prevent situations where a native library is unloaded in the middle of a native call.
- * <p><a id = "var-symbols"></a></p>
- * In cases where a client wants to create a memory segment out of a lookup symbol, the client might want to attach the
- * lookup symbol to the newly created segment, so that the symbol will be kept reachable as long as the memory segment
- * is reachable; this can be achieved by creating the segment using the {@link MemoryAddress#asSegmentRestricted(long, ResourceScope)}.
- * restricted segment factory, as follows:
+ * All instances generated by a given library lookup object contain a strong reference to said lookup object,
+ * therefore preventing library unloading. For {@link #lookup(String, MemoryLayout) memory segments} obtained from a library lookup object,
+ * this means that clients can safely dereference memory associated with lookup symbols, as follows:
  * <pre>{@code
-LibraryLookup defaultLookup = LibraryLookup.defaultLookup();
-LibraryLookup.Symbol errno = defaultLookup.lookup("errno");
-MemorySegment errnoSegment = errno.address().asSegmentRestricted(4, ResourceScope.ofShared(errno, Cleaner.create()));
+ * LibraryLookup defaultLookup = LibraryLookup.defaultLookup();
+ * MemorySegment errnoSegment = defaultLookup.lookup("errno", MemoryLayouts.JAVA_INT).get();
+ * int errno = MemoryAccess.getInt(errnoSegment);
  * }</pre>
  * <p>
+ * For {@link #lookup(String) memory addresses} obtained from a library lookup object,
+ * since {@link CLinker#downcallHandle(Addressable, MethodType, FunctionDescriptor) native method handles}
+ * also maintain a strong reference to the addressable parameter used for their construction, there is
+ * always a strong reachability chain from a native method handle to a lookup object (the one that was used to lookup
+ * the native library symbol the method handle refers to). This is useful to prevent situations where a native library
+ * is unloaded in the middle of a native call.
+ * <p>
  * To allow for a library to be unloaded, a client will have to discard any strong references it
  * maintains, directly, or indirectly to a lookup object associated with given library.
  *
@@ -66,39 +65,24 @@
 public interface LibraryLookup {
 
     /**
-     * A symbol retrieved during a library lookup. A lookup symbol has a <em>name</em> and can be projected
-     * into a memory address (see {@link #name()} and {@link #address()}, respectively).
-     *
-     * @apiNote In the future, if the Java language permits, {@link Symbol}
-     * may become a {@code sealed} interface, which would prohibit subclassing except by
-     * explicitly permitted types.
-     *
-     * @implSpec
-     * Implementations of this interface are immutable, thread-safe and <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a>.
+     * Looks up a symbol with given name in this library. The returned memory address maintains a strong reference to this lookup object.
+     * @param name the symbol name.
+     * @return the memory address associated with the library symbol (if any).
      */
-    interface Symbol extends Addressable {
-        /**
-         * The name of this lookup symbol.
-         * @return the name of this lookup symbol.
-         */
-        String name();
-
-        /**
-         * The memory address of this lookup symbol. If the memory associated with this symbol needs to be dereferenced,
-         * clients can obtain a segment from this symbol's address using the {@link MemoryAddress#asSegmentRestricted(long, Runnable, ResourceScope)},
-         * and making sure that the created segment maintains a <a href="LibraryLookup.html#var-symbols">strong reference</a> to this symbol, to prevent library unloading.
-         * @return the memory address of this lookup symbol.
-         */
-        @Override
-        MemoryAddress address();
-    }
+    Optional<MemoryAddress> lookup(String name);
 
     /**
-     * Looks up a symbol with given name in this library. The returned symbol maintains a strong reference to this lookup object.
+     * Looks up a symbol with given name in this library. The returned memory segment has a size that matches that of
+     * the specified layout, and maintains a strong reference to this lookup object. This method can be useful
+     * to lookup global variable symbols in a foreign library.
      * @param name the symbol name.
-     * @return the library symbol (if any).
+     * @param layout the layout to be associated with the library symbol.
+     * @return the memory segment associated with the library symbol (if any).
+     * @throws IllegalArgumentException if the address associated with the lookup symbol do not match the
+     * {@link MemoryLayout#byteAlignment() alignment constraints} in {@code layout}.
      */
-    Optional<Symbol> lookup(String name);
+    @NativeAccess
+    Optional<MemorySegment> lookup(String name, MemoryLayout layout);
 
     /**
      * Obtain a default library lookup object.

src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java

@@ -29,9 +29,13 @@
 
 import java.io.File;
 import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
 import jdk.incubator.foreign.ResourceScope;
 import jdk.internal.loader.NativeLibraries;
 import jdk.internal.loader.NativeLibrary;
+import jdk.internal.reflect.CallerSensitive;
+import jdk.internal.reflect.Reflection;
 
 import java.lang.ref.Reference;
 import java.lang.ref.WeakReference;
@@ -103,29 +107,36 @@ static LibraryLookupImpl lookup(Supplier<NativeLibrary> librarySupplier, String
     //Todo: in principle we could expose a scope accessor, so that users could unload libraries at will
     static class LibraryLookupImpl implements LibraryLookup {
         final NativeLibrary library;
-        final ResourceScope scope;
+        final MemorySegment librarySegment;
 
         LibraryLookupImpl(NativeLibrary library, ResourceScope scope) {
             this.library = library;
-            this.scope = scope;
+            this.librarySegment = MemoryAddress.NULL.asSegmentRestricted(Long.MAX_VALUE, scope);
         }
 
         @Override
-        public Optional<Symbol> lookup(String name) {
+        public Optional<MemoryAddress> lookup(String name) {
             try {
                 Objects.requireNonNull(name);
                 MemoryAddress addr = MemoryAddress.ofLong(library.lookup(name));
-                return Optional.of(new Symbol() { // inner class - retains a link to the scope
-                    @Override
-                    public String name() {
-                        return name;
-                    }
-
-                    @Override
-                    public MemoryAddress address() {
-                        return addr;
-                    }
-                });
+                return Optional.of(librarySegment.asSlice(addr).address());
+            } catch (NoSuchMethodException ex) {
+                return Optional.empty();
+            }
+        }
+
+        @Override
+        @CallerSensitive
+        public Optional<MemorySegment> lookup(String name, MemoryLayout layout) {
+            Reflection.ensureNativeAccess(Reflection.getCallerClass());
+            try {
+                Objects.requireNonNull(name);
+                Objects.requireNonNull(layout);
+                MemoryAddress addr = MemoryAddress.ofLong(library.lookup(name));
+                if (addr.toRawLongValue() % layout.byteAlignment() != 0) {
+                    throw new IllegalArgumentException("Bad layout alignment constraints: " + layout.byteAlignment());
+                }
+                return Optional.of(librarySegment.asSlice(addr, layout.byteSize()));
             } catch (NoSuchMethodException ex) {
                 return Optional.empty();
             }

test/jdk/java/foreign/StdLibTest.java

@@ -192,7 +192,7 @@ static class StdLibHelper {
                 MethodType.methodType(int.class, MemoryAddress.class, VaList.class),
                 FunctionDescriptor.of(C_INT, C_POINTER, C_VA_LIST));
 
-        final static LibraryLookup.Symbol printfAddr = lookup.lookup("printf").get();
+        final static MemoryAddress printfAddr = lookup.lookup("printf").get();
 
         final static FunctionDescriptor printfBase = FunctionDescriptor.of(C_INT, C_POINTER);
 

test/jdk/java/foreign/TestDowncall.java

@@ -36,6 +36,7 @@
 import jdk.incubator.foreign.CLinker;
 import jdk.incubator.foreign.FunctionDescriptor;
 import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayout;
 
 import java.lang.invoke.MethodHandle;
@@ -57,7 +58,7 @@ public class TestDowncall extends CallGeneratorHelper {
     @Test(dataProvider="functions", dataProviderClass=CallGeneratorHelper.class)
     public void testDowncall(int count, String fName, Ret ret, List<ParamType> paramTypes, List<StructFieldType> fields) throws Throwable {
         List<Consumer<Object>> checks = new ArrayList<>();
-        LibraryLookup.Symbol addr = lib.lookup(fName).get();
+        MemoryAddress addr = lib.lookup(fName).get();
         MethodType mt = methodType(ret, paramTypes, fields);
         FunctionDescriptor descriptor = function(ret, paramTypes, fields);
         Object[] args = makeArgs(paramTypes, fields, checks);
@@ -84,7 +85,7 @@ public void testDowncall(int count, String fName, Ret ret, List<ParamType> param
     @Test(dataProvider="functions", dataProviderClass=CallGeneratorHelper.class)
     public void testDowncallNoScope(int count, String fName, Ret ret, List<ParamType> paramTypes, List<StructFieldType> fields) throws Throwable {
         List<Consumer<Object>> checks = new ArrayList<>();
-        LibraryLookup.Symbol addr = lib.lookup(fName).get();
+        MemoryAddress addr = lib.lookup(fName).get();
         MethodType mt = methodType(ret, paramTypes, fields);
         FunctionDescriptor descriptor = function(ret, paramTypes, fields);
         Object[] args = makeArgs(paramTypes, fields, checks);
@@ -107,7 +108,7 @@ public void testDowncallNoScope(int count, String fName, Ret ret, List<ParamType
         }
     }
 
-    Object doCall(LibraryLookup.Symbol addr, SegmentAllocator allocator, MethodType type, FunctionDescriptor descriptor, Object[] args) throws Throwable {
+    Object doCall(MemoryAddress addr, SegmentAllocator allocator, MethodType type, FunctionDescriptor descriptor, Object[] args) throws Throwable {
         MethodHandle mh = abi.downcallHandle(addr, allocator, type, descriptor);
         Object res = mh.invokeWithArguments(args);
         return res;

test/jdk/java/foreign/TestIntrinsics.java

@@ -41,6 +41,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayout;
 import org.testng.annotations.*;
 
@@ -83,7 +84,7 @@ interface AddIdentity {
         }
 
         AddIdentity addIdentity = (name, carrier, layout, arg) -> {
-            LibraryLookup.Symbol ma = lookup.lookup(name).orElseThrow();
+            MemoryAddress ma = lookup.lookup(name).orElseThrow();
             MethodType mt = methodType(carrier, carrier);
             FunctionDescriptor fd = FunctionDescriptor.of(layout, layout);
 
@@ -93,7 +94,7 @@ interface AddIdentity {
         };
 
         { // empty
-            LibraryLookup.Symbol ma = lookup.lookup("empty").orElseThrow();
+            MemoryAddress ma = lookup.lookup("empty").orElseThrow();
             MethodType mt = methodType(void.class);
             FunctionDescriptor fd = FunctionDescriptor.ofVoid();
             tests.add(abi.downcallHandle(ma, mt, fd), null);
@@ -108,7 +109,7 @@ interface AddIdentity {
         addIdentity.add("identity_double", double.class, C_DOUBLE,        10D);
 
         { // identity_va
-            LibraryLookup.Symbol ma = lookup.lookup("identity_va").orElseThrow();
+            MemoryAddress ma = lookup.lookup("identity_va").orElseThrow();
             MethodType mt = methodType(int.class, int.class, double.class, int.class, float.class, long.class);
             FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_INT, asVarArg(C_DOUBLE),
                     asVarArg(C_INT), asVarArg(C_FLOAT), asVarArg(C_LONG_LONG));
@@ -123,7 +124,7 @@ interface AddIdentity {
                     C_SHORT, C_SHORT);
             Object[] args = {1, 10D, 2L, 3F, (byte) 0, (short) 13, 'a'};
             for (int i = 0; i < args.length; i++) {
-                LibraryLookup.Symbol ma = lookup.lookup("invoke_high_arity" + i).orElseThrow();
+                MemoryAddress ma = lookup.lookup("invoke_high_arity" + i).orElseThrow();
                 MethodType mt = baseMT.changeReturnType(baseMT.parameterType(i));
                 FunctionDescriptor fd = baseFD.withReturnLayout(baseFD.argumentLayouts().get(i));
                 Object expected = args[i];

test/jdk/java/foreign/TestLibraryLookup.java

@@ -29,7 +29,11 @@
  */
 
 import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.MemoryAccess;
 import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemoryLayouts;
+import jdk.incubator.foreign.MemorySegment;
 import jdk.internal.foreign.LibrariesHelper;
 import org.testng.annotations.Test;
 
@@ -66,10 +70,9 @@ public void testInvalidLookupPath() {
 
     @Test
     public void testSimpleLookup() throws Throwable {
-        LibraryLookup.Symbol symbol = null;
+        MemoryAddress symbol = null;
         LibraryLookup lookup = LibraryLookup.ofLibrary("LookupTest");
         symbol = lookup.lookup("f").get();
-        assertEquals(symbol.name(), "f");
         assertEquals(LibrariesHelper.numLoadedLibraries(), 1);
         lookup = null;
         symbol = null;
@@ -78,7 +81,7 @@ public void testSimpleLookup() throws Throwable {
 
     @Test
     public void testInvalidSymbolLookup() throws Throwable {
-        LibraryLookup.Symbol symbol = null;
+        MemoryAddress symbol = null;
         LibraryLookup lookup = LibraryLookup.ofLibrary("LookupTest");
         assertTrue(lookup.lookup("nonExistent").isEmpty());
         assertEquals(LibrariesHelper.numLoadedLibraries(), 1);
@@ -87,13 +90,29 @@ public void testInvalidSymbolLookup() throws Throwable {
         waitUnload();
     }
 
+    @Test
+    public void testVariableSymbolLookup() throws Throwable {
+        LibraryLookup lookup = LibraryLookup.ofLibrary("LookupTest");
+        MemorySegment segment = lookup.lookup("c", MemoryLayouts.JAVA_INT).get();
+        assertEquals(MemoryAccess.getInt(segment), 42);
+        lookup = null;
+        segment = null;
+        waitUnload();
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class)
+    public void testBarVariableSymbolLookup() throws Throwable {
+        LibraryLookup lookup = LibraryLookup.ofLibrary("LookupTest");
+        lookup.lookup("c", MemoryLayouts.JAVA_INT.withBitAlignment(1 << 16)).get();
+    }
+
     @Test
     public void testMultiLookupSameLoader() throws Throwable {
-        List<LibraryLookup.Symbol> symbols = new ArrayList<>();
+        List<MemoryAddress> symbols = new ArrayList<>();
         List<LibraryLookup> lookups = new ArrayList<>();
         for (int i = 0 ; i < 5 ; i++) {
             LibraryLookup lookup = LibraryLookup.ofLibrary("LookupTest");
-            LibraryLookup.Symbol symbol = lookup.lookup("f").get();
+            MemoryAddress symbol = lookup.lookup("f").get();
             lookups.add(lookup);
             symbols.add(symbol);
             assertEquals(LibrariesHelper.numLoadedLibraries(), 1);
@@ -151,7 +170,7 @@ public Class<?> loadClass(String name) throws ClassNotFoundException {
 
     static class Holder {
         public static LibraryLookup lookup;
-        public static LibraryLookup.Symbol symbol;
+        public static MemoryAddress symbol;
 
         static {
             try {

test/jdk/java/foreign/TestUpcall.java

@@ -88,7 +88,7 @@ void setup() {
     public void testUpcalls(int count, String fName, Ret ret, List<ParamType> paramTypes, List<StructFieldType> fields) throws Throwable {
         List<Consumer<Object>> returnChecks = new ArrayList<>();
         List<Consumer<Object[]>> argChecks = new ArrayList<>();
-        LibraryLookup.Symbol addr = lib.lookup(fName).get();
+        MemoryAddress addr = lib.lookup(fName).get();
         MethodType mtype = methodType(ret, paramTypes, fields);
         try (NativeScope scope = new NativeScope()) {
             MethodHandle mh = abi.downcallHandle(addr, scope, mtype, function(ret, paramTypes, fields));
@@ -106,7 +106,7 @@ public void testUpcalls(int count, String fName, Ret ret, List<ParamType> paramT
     public void testUpcallsNoScope(int count, String fName, Ret ret, List<ParamType> paramTypes, List<StructFieldType> fields) throws Throwable {
         List<Consumer<Object>> returnChecks = new ArrayList<>();
         List<Consumer<Object[]>> argChecks = new ArrayList<>();
-        LibraryLookup.Symbol addr = lib.lookup(fName).get();
+        MemoryAddress addr = lib.lookup(fName).get();
         MethodType mtype = methodType(ret, paramTypes, fields);
         MethodHandle mh = abi.downcallHandle(addr, SegmentAllocator.ofDefault(), mtype, function(ret, paramTypes, fields));
         Object[] args = makeArgs(ResourceScope.ofDefault(), ret, paramTypes, fields, returnChecks, argChecks);

test/jdk/java/foreign/TestVarArgs.java

@@ -61,7 +61,7 @@ public class TestVarArgs {
     static final VarHandle VH_IntArray = MemoryLayout.ofSequence(C_INT).varHandle(int.class, sequenceElement());
 
     static final CLinker abi = CLinker.getInstance();
-    static final LibraryLookup.Symbol varargsAddr = LibraryLookup.ofLibrary("VarArgs")
+    static final MemoryAddress varargsAddr = LibraryLookup.ofLibrary("VarArgs")
             .lookup("varargs").get();
 
     static final int WRITEBACK_BYTES_PER_ARG = 8;

test/jdk/java/foreign/libLookupTest.c

@@ -29,4 +29,5 @@
  #endif
 
  EXPORT void f() { }
+ EXPORT int c = 42;
 

test/jdk/java/foreign/virtual/TestVirtualCalls.java

@@ -37,6 +37,7 @@
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodType;
 
+import jdk.incubator.foreign.MemoryAddress;
 import org.testng.annotations.*;
 
 import static jdk.incubator.foreign.CLinker.*;
@@ -48,9 +49,9 @@ public class TestVirtualCalls {
     static final LibraryLookup lookup = LibraryLookup.ofLibrary("Virtual");
 
     static final MethodHandle func;
-    static final LibraryLookup.Symbol funcA;
-    static final LibraryLookup.Symbol funcB;
-    static final LibraryLookup.Symbol funcC;
+    static final MemoryAddress funcA;
+    static final MemoryAddress funcB;
+    static final MemoryAddress funcC;
 
     static {
         func = abi.downcallHandle(