Add support for arrays to Panama NFI backend

Author: otethal

truffle/CHANGELOG.md

@@ -6,6 +6,7 @@ This changelog summarizes major changes between Truffle versions relevant to lan
 * GR-65048: Introduced `InternalResource.OS.UNSUPPORTED` and `InternalResource.CPUArchitecture.UNSUPPORTED` to represent unsupported platforms. Execution on unsupported platforms must be explicitly enabled using the system property `-Dpolyglot.engine.allowUnsupportedPlatform=true`. If this property is not set, calls to `OS.getCurrent()` or `CPUArchitecture.getCurrent()` will throw an `IllegalStateException` when running on an unsupported platform. `InternalResource` implementations should handle the unsupported platform and describe possible steps in the error message on how to proceed.
 * GR-66839: Deprecate `Location#isFinal()` as it always returns false.
 * GR-67702: Specialization DSL: For nodes annotated with `@GenerateInline`, inlining warnings emitted for `@Cached` expressions are now suppressed if the inlined node is explicitly annotated with `@GenerateInline(false)`. This avoids unnecessary warnings if inlining for a node was explicitly disabled.
+* GR-66310: Added support for passing arrays of primitive types to native code through the Truffle NFI Panama backend.
 
 ## Version 25.0
 * GR-31495 Added ability to specify language and instrument specific options using `Source.Builder.option(String, String)`. Languages may describe available source options by implementing `TruffleLanguage.getSourceOptionDescriptors()` and `TruffleInstrument.getSourceOptionDescriptors()` respectively.

truffle/docs/NFI.md

@@ -194,7 +194,7 @@ Depending on the configuration of components you are running, available backends
 ### Panama backend
 
 The Panama backend uses the Foreign Function and Memory APIs introduced by [project Panama](https://openjdk.org/projects/panama/). 
-This backend only supports a subset of all the types. Specifically, it does not support `STRING`, `OBJECT`, `ENV`, `FP80` or array types.
+This backend only supports a subset of all the types. Specifically, it does not support `STRING`, `OBJECT`, `ENV`, or `FP80`.
 Although less feature-complete, the backend is typically more performant.
 It is available starting from JDK 22.
 

truffle/src/com.oracle.truffle.nfi.backend.panama.jdk22/src/com/oracle/truffle/nfi/backend/panama/ArgumentNode.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -40,9 +40,15 @@
  */
 package com.oracle.truffle.nfi.backend.panama;
 
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+import java.lang.reflect.Array;
+
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Bind;
 import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
@@ -51,17 +57,14 @@
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.profiles.InlinedBranchProfile;
 
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-
 abstract class ArgumentNode extends Node {
     final PanamaType type;
 
     ArgumentNode(PanamaType type) {
         this.type = type;
     }
 
-    abstract Object execute(Object value) throws UnsupportedTypeException;
+    abstract Object execute(Arena arena, Object value) throws UnsupportedTypeException;
 
     abstract static class ToVOIDNode extends ArgumentNode {
 
@@ -70,7 +73,7 @@ abstract static class ToVOIDNode extends ArgumentNode {
         }
 
         @Specialization
-        Object doConvert(@SuppressWarnings("unused") Object value) {
+        Object doConvert(@SuppressWarnings("unused") Arena arena, @SuppressWarnings("unused") Object value) {
             return null;
         }
     }
@@ -82,7 +85,7 @@ abstract static class ToINT8Node extends ArgumentNode {
         }
 
         @Specialization(limit = "3")
-        byte doConvert(Object value,
+        byte doConvert(@SuppressWarnings("unused") Arena arena, Object value,
                         @CachedLibrary("value") InteropLibrary interop) throws UnsupportedTypeException {
             try {
                 return interop.asByte(value);
@@ -99,7 +102,7 @@ abstract static class ToINT16Node extends ArgumentNode {
         }
 
         @Specialization(limit = "3")
-        short doConvert(Object value,
+        short doConvert(@SuppressWarnings("unused") Arena arena, Object value,
                         @CachedLibrary("value") InteropLibrary interop) throws UnsupportedTypeException {
             try {
                 return interop.asShort(value);
@@ -116,7 +119,7 @@ abstract static class ToINT32Node extends ArgumentNode {
         }
 
         @Specialization(limit = "3")
-        int doConvert(Object value,
+        int doConvert(@SuppressWarnings("unused") Arena arena, Object value,
                         @CachedLibrary("value") InteropLibrary interop) throws UnsupportedTypeException {
             try {
                 return interop.asInt(value);
@@ -133,7 +136,7 @@ abstract static class ToINT64Node extends ArgumentNode {
         }
 
         @Specialization(limit = "3")
-        long doConvert(Object value,
+        long doConvert(@SuppressWarnings("unused") Arena arena, Object value,
                         @CachedLibrary("value") InteropLibrary interop) throws UnsupportedTypeException {
             try {
                 return interop.asLong(value);
@@ -145,24 +148,26 @@ long doConvert(Object value,
 
     abstract static class ToPointerNode extends ArgumentNode {
 
+        abstract long executeLong(Arena arena, Object value) throws UnsupportedTypeException;
+
         ToPointerNode(PanamaType type) {
             super(type);
         }
 
         @Specialization(limit = "3", guards = "interop.isPointer(arg)", rewriteOn = UnsupportedMessageException.class)
-        long putPointer(Object arg,
+        long putPointer(@SuppressWarnings("unused") Arena arena, Object arg,
                         @CachedLibrary("arg") InteropLibrary interop) throws UnsupportedMessageException {
             return interop.asPointer(arg);
         }
 
         @Specialization(limit = "3", guards = {"!interop.isPointer(arg)", "interop.isNull(arg)"})
-        long putNull(@SuppressWarnings("unused") Object arg,
+        long putNull(@SuppressWarnings("unused") Arena arena, @SuppressWarnings("unused") Object arg,
                         @SuppressWarnings("unused") @CachedLibrary("arg") InteropLibrary interop) {
             return NativePointer.NULL.asPointer();
         }
 
         @Specialization(limit = "3", replaces = {"putPointer", "putNull"})
-        static long putGeneric(Object arg,
+        static long putGeneric(@SuppressWarnings("unused") Arena arena, Object arg,
                         @Bind Node node,
                         @CachedLibrary("arg") InteropLibrary interop,
                         @Cached InlinedBranchProfile exception) throws UnsupportedTypeException {
@@ -199,7 +204,7 @@ abstract static class ToFLOATNode extends ArgumentNode {
         }
 
         @Specialization(limit = "3")
-        float doConvert(Object value,
+        float doConvert(@SuppressWarnings("unused") Arena arena, Object value,
                         @CachedLibrary("value") InteropLibrary interop) throws UnsupportedTypeException {
             try {
                 return interop.asFloat(value);
@@ -216,7 +221,7 @@ abstract static class ToDOUBLENode extends ArgumentNode {
         }
 
         @Specialization(limit = "3")
-        double doConvert(Object value,
+        double doConvert(@SuppressWarnings("unused") Arena arena, Object value,
                         @CachedLibrary("value") InteropLibrary interop) throws UnsupportedTypeException {
             try {
                 return interop.asDouble(value);
@@ -233,11 +238,10 @@ abstract static class ToSTRINGNode extends ArgumentNode {
         }
 
         @Specialization(limit = "3")
-        Object doConvert(Object value,
+        Object doConvert(@SuppressWarnings("unused") Arena arena, Object value,
                         @CachedLibrary("value") InteropLibrary interop) throws UnsupportedTypeException {
-            PanamaNFIContext ctx = PanamaNFIContext.get(this);
             try {
-                return allocateFrom(ctx.getContextArena(), interop.asString(value));
+                return allocateFrom(arena, interop.asString(value));
             } catch (UnsupportedMessageException ex) {
                 throw UnsupportedTypeException.create(new Object[]{value});
             }
@@ -248,4 +252,54 @@ private static MemorySegment allocateFrom(Arena arena, String str) {
             return arena.allocateFrom(str);
         }
     }
+
+    abstract static class ToArrayNode extends ArgumentNode {
+
+        @Child GetArrayElementLayoutNode getArrayElementLayoutNode;
+
+        ToArrayNode(PanamaType type) {
+            super(type);
+            getArrayElementLayoutNode = GetArrayElementLayoutNode.create(type.type);
+        }
+
+        final boolean isHostObject(Object value) {
+            return PanamaNFIContext.get(this).env.isHostObject(value);
+        }
+
+        final Object asHostObject(Object value) {
+            return PanamaNFIContext.get(this).env.asHostObject(value);
+        }
+
+        @Specialization(guards = {"isHostObject(value)", "elementLayout != null"})
+        MemorySegment doHostObject(Arena arena, @SuppressWarnings("unused") Object value,
+                        @Bind("asHostObject(value)") Object hostObject,
+                        @Bind("getArrayElementLayoutNode.execute(hostObject)") ValueLayout elementLayout) {
+            return doCopy(arena, hostObject, elementLayout);
+        }
+
+        @Specialization(guards = {"!isHostObject(value)", "elementLayout != null"})
+        MemorySegment doArray(Arena arena, Object value,
+                        @Bind("getArrayElementLayoutNode.execute(value)") ValueLayout elementLayout) {
+            return doCopy(arena, value, elementLayout);
+        }
+
+        @Fallback
+        MemorySegment doInteropObject(@SuppressWarnings("unused") Arena arena, Object value,
+                        @Cached(parameters = "type") ToPointerNode toPointer) throws UnsupportedTypeException {
+            return wrapPointer(toPointer.executeLong(arena, value));
+        }
+
+        @TruffleBoundary(allowInlining = true)
+        private static MemorySegment doCopy(Arena arena, Object array, ValueLayout elementLayout) {
+            int arrayLength = Array.getLength(array);
+            MemorySegment dst = arena.allocate(elementLayout, arrayLength);
+            MemorySegment.copy(array, 0, dst, elementLayout, 0, arrayLength);
+            return dst;
+        }
+
+        @TruffleBoundary(allowInlining = true)
+        private static MemorySegment wrapPointer(long ptr) {
+            return MemorySegment.ofAddress(ptr);
+        }
+    }
 }

truffle/src/com.oracle.truffle.nfi.backend.panama.jdk22/src/com/oracle/truffle/nfi/backend/panama/FunctionExecuteNode.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -40,6 +40,7 @@
  */
 package com.oracle.truffle.nfi.backend.panama;
 
+import java.lang.foreign.Arena;
 import java.lang.foreign.MemorySegment;
 import java.lang.ref.Reference;
 
@@ -57,7 +58,6 @@
 import com.oracle.truffle.api.nodes.IndirectCallNode;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.RootNode;
-
 import com.oracle.truffle.nfi.backend.panama.PanamaSignature.CachedSignatureInfo;
 
 @GenerateUncached
@@ -106,17 +106,34 @@ static Object genericExecute(long receiver, PanamaSignature signature, Object[]
 
     abstract static class SignatureExecuteNode extends RootNode {
 
+        private static final PostCallArgumentNode[] EMPTY_POST_CALL_NODE_ARRAY = new PostCallArgumentNode[0];
+
         final CachedSignatureInfo signatureInfo;
         @Children ArgumentNode[] argNodes;
+        @Children PostCallArgumentNode[] postCallArgNodes;
+        final boolean needsArena;
 
         SignatureExecuteNode(PanamaNFILanguage language, CachedSignatureInfo signatureInfo) {
             super(language);
             this.signatureInfo = signatureInfo;
 
             PanamaType[] argTypes = signatureInfo.getArgTypes();
             this.argNodes = new ArgumentNode[argTypes.length];
+            boolean postCall = false;
+            boolean arenaNeeded = false;
             for (int i = 0; i < argTypes.length; i++) {
                 argNodes[i] = argTypes[i].createArgumentNode();
+                postCall |= argTypes[i].needsPostCallProcessing();
+                arenaNeeded |= argTypes[i].needsArena();
+            }
+            this.needsArena = arenaNeeded;
+            if (postCall) {
+                this.postCallArgNodes = new PostCallArgumentNode[argNodes.length];
+                for (int i = 0; i < argNodes.length; i++) {
+                    postCallArgNodes[i] = argTypes[i].createPostCallArgumentNode();
+                }
+            } else {
+                this.postCallArgNodes = EMPTY_POST_CALL_NODE_ARRAY;
             }
         }
 
@@ -146,18 +163,32 @@ public Object doGeneric(VirtualFrame frame) {
                 throw silenceException(RuntimeException.class, ArityException.create(argNodes.length, argNodes.length, args.length));
             }
 
+            Object[] convertedArgs = postCallArgNodes == null ? args : new Object[args.length];
+            Arena arena = needsArena ? Arena.ofConfined() : null;
             try {
-                PanamaType[] types = signatureInfo.getArgTypes();
-                assert argNodes.length == types.length;
+                try {
+                    PanamaType[] types = signatureInfo.getArgTypes();
+                    assert argNodes.length == types.length;
+
+                    for (int i = 0; i < argNodes.length; i++) {
+                        convertedArgs[i] = argNodes[i].execute(arena, args[i]);
+                    }
+                } catch (UnsupportedTypeException ex) {
+                    throw silenceException(RuntimeException.class, ex);
+                }
 
-                for (int i = 0; i < argNodes.length; i++) {
-                    args[i] = argNodes[i].execute(args[i]);
+                Object result = signatureInfo.execute(signature, convertedArgs, address, this);
+                for (int i = 0; i < postCallArgNodes.length; i++) {
+                    if (postCallArgNodes[i] != null) {
+                        postCallArgNodes[i].execute(args[i], convertedArgs[i]);
+                    }
+                }
+                return result;
+            } finally {
+                if (needsArena) {
+                    arena.close();
                 }
-            } catch (UnsupportedTypeException ex) {
-                throw silenceException(RuntimeException.class, ex);
             }
-
-            return signatureInfo.execute(signature, args, address, this);
         }
 
         @SuppressWarnings({"unchecked", "unused"})