Implement wasm function interop call adapter for argument and return value handling.

Fixes a compilation error in WasmFunctionInstance.execute due to WasmLanguage not being PE-constant when accessing the multi-value result stack.

Author: woess

wasm/src/org.graalvm.wasm/src/org/graalvm/wasm/Linker.java

@@ -469,7 +469,8 @@ void resolveFunctionImport(WasmContext context, WasmInstance instance, WasmFunct
     }
 
     void resolveFunctionExport(WasmModule module, int functionIndex, String exportedFunctionName) {
-        final ImportDescriptor importDescriptor = module.symbolTable().function(functionIndex).importDescriptor();
+        final WasmFunction function = module.symbolTable().function(functionIndex);
+        final ImportDescriptor importDescriptor = function.importDescriptor();
         final Sym[] dependencies = (importDescriptor != null) ? new Sym[]{new ImportFunctionSym(module.name(), importDescriptor, functionIndex)} : ResolutionDag.NO_DEPENDENCIES;
         resolutionDag.resolveLater(new ExportFunctionSym(module.name(), exportedFunctionName), dependencies, NO_RESOLVE_ACTION);
     }

wasm/src/org.graalvm.wasm/src/org/graalvm/wasm/SymbolTable.java

@@ -86,9 +86,9 @@ public abstract class SymbolTable {
     private static final int NO_EQUIVALENCE_CLASS = 0;
     static final int FIRST_EQUIVALENCE_CLASS = NO_EQUIVALENCE_CLASS + 1;
 
-    public static class FunctionType {
-        private final byte[] paramTypes;
-        private final byte[] resultTypes;
+    public static final class FunctionType {
+        @CompilationFinal(dimensions = 1) private final byte[] paramTypes;
+        @CompilationFinal(dimensions = 1) private final byte[] resultTypes;
         private final int hashCode;
 
         FunctionType(byte[] paramTypes, byte[] resultTypes) {
@@ -112,10 +112,9 @@ public int hashCode() {
 
         @Override
         public boolean equals(Object object) {
-            if (!(object instanceof FunctionType)) {
+            if (!(object instanceof FunctionType that)) {
                 return false;
             }
-            FunctionType that = (FunctionType) object;
             if (this.paramTypes.length != that.paramTypes.length) {
                 return false;
             }
@@ -146,7 +145,7 @@ public String toString() {
             for (int i = 0; i < resultTypes.length; i++) {
                 resultNames[i] = WasmType.toString(resultTypes[i]);
             }
-            return Arrays.toString(paramNames) + " -> " + Arrays.toString(resultNames);
+            return "(" + String.join(" ", paramNames) + ")->(" + String.join(" ", resultNames) + ")";
         }
     }
 

wasm/src/org.graalvm.wasm/src/org/graalvm/wasm/WasmFunction.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 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
@@ -128,6 +128,14 @@ public String importedFunctionName() {
         return isImported() ? importDescriptor.memberName() : null;
     }
 
+    public String exportedFunctionName() {
+        return symbolTable.exportedFunctionName(index);
+    }
+
+    public boolean isExported() {
+        return exportedFunctionName() != null;
+    }
+
     public int typeIndex() {
         return typeIndex;
     }

wasm/src/org.graalvm.wasm/src/org/graalvm/wasm/WasmFunctionInstance.java

@@ -42,25 +42,22 @@
 
 import java.util.Objects;
 
-import org.graalvm.wasm.api.InteropArray;
-import org.graalvm.wasm.api.Vector128;
-import org.graalvm.wasm.exception.Failure;
-import org.graalvm.wasm.exception.WasmException;
+import org.graalvm.wasm.nodes.WasmCallNode;
 import org.graalvm.wasm.nodes.WasmIndirectCallNode;
 
 import com.oracle.truffle.api.CallTarget;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.TruffleContext;
 import com.oracle.truffle.api.dsl.Cached;
-import com.oracle.truffle.api.interop.ArityException;
+import com.oracle.truffle.api.dsl.ImportStatic;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.interop.TruffleObject;
-import com.oracle.truffle.api.interop.UnsupportedTypeException;
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.library.ExportLibrary;
 import com.oracle.truffle.api.library.ExportMessage;
 
+@ImportStatic(WasmCallNode.class)
 @ExportLibrary(InteropLibrary.class)
 public final class WasmFunctionInstance extends EmbedderDataHolder implements TruffleObject {
 
@@ -69,7 +66,15 @@ public final class WasmFunctionInstance extends EmbedderDataHolder implements Tr
     private final WasmFunction function;
     private final CallTarget target;
     private final TruffleContext truffleContext;
+    /**
+     * Stores the imported function object for {@link org.graalvm.wasm.api.ExecuteHostFunctionNode}.
+     * Initialized during linking.
+     */
     private Object importedFunction;
+    /**
+     * Interop call adapter for exported functions, converting parameter and result values.
+     */
+    private final CallTarget interopCallAdapter;
 
     /**
      * Represents a call target that is a WebAssembly function or an imported function.
@@ -84,6 +89,7 @@ public WasmFunctionInstance(WasmContext context, WasmInstance moduleInstance, Wa
         this.function = Objects.requireNonNull(function, "function must be non-null");
         this.target = Objects.requireNonNull(target, "Call target must be non-null");
         this.truffleContext = context.environment().getContext();
+        this.interopCallAdapter = context.language().interopCallAdapterFor(function.type());
         assert ((RootCallTarget) target).getRootNode().getLanguage(WasmLanguage.class) == context.language();
     }
 
@@ -137,102 +143,15 @@ boolean isExecutable() {
     @ExportMessage
     Object execute(Object[] arguments,
                     @CachedLibrary("this") InteropLibrary self,
-                    @Cached WasmIndirectCallNode callNode) throws ArityException, UnsupportedTypeException {
+                    @Cached WasmIndirectCallNode callNode) {
         TruffleContext c = getTruffleContext();
         Object prev = c.enter(self);
         try {
-            Object result = callNode.execute(target, WasmArguments.create(moduleInstance, validateArguments(arguments)));
-
-            // For external calls of a WebAssembly function we have to materialize the multi-value
-            // stack.
-            // At this point the multi-value stack has already been populated, therefore, we don't
-            // have to check the size of the multi-value stack.
-            if (result == WasmConstant.MULTI_VALUE) {
-                WasmLanguage language = context.language();
-                assert language == WasmLanguage.get(null);
-                return multiValueStackAsArray(language);
-            }
-            return result;
+            CallTarget callAdapter = Objects.requireNonNull(this.interopCallAdapter);
+            return callNode.execute(callAdapter, WasmArguments.create(this, arguments));
+            // throws ArityException, UnsupportedTypeException
         } finally {
             c.leave(self, prev);
         }
     }
-
-    private Object[] validateArguments(Object[] arguments) throws ArityException, UnsupportedTypeException {
-        if (function == null) {
-            return arguments;
-        }
-        final int paramCount = function.paramCount();
-        if (arguments.length != paramCount) {
-            throw ArityException.create(paramCount, paramCount, arguments.length);
-        }
-        for (int i = 0; i < paramCount; i++) {
-            byte paramType = function.paramTypeAt(i);
-            Object value = arguments[i];
-            switch (paramType) {
-                case WasmType.I32_TYPE -> {
-                    if (value instanceof Integer) {
-                        continue;
-                    }
-                }
-                case WasmType.I64_TYPE -> {
-                    if (value instanceof Long) {
-                        continue;
-                    }
-                }
-                case WasmType.F32_TYPE -> {
-                    if (value instanceof Float) {
-                        continue;
-                    }
-                }
-                case WasmType.F64_TYPE -> {
-                    if (value instanceof Double) {
-                        continue;
-                    }
-                }
-                case WasmType.V128_TYPE -> {
-                    if (value instanceof Vector128) {
-                        continue;
-                    }
-                }
-                case WasmType.FUNCREF_TYPE -> {
-                    if (value instanceof WasmFunctionInstance || value == WasmConstant.NULL) {
-                        continue;
-                    }
-                }
-                case WasmType.EXTERNREF_TYPE -> {
-                    continue;
-                }
-                default -> throw WasmException.create(Failure.UNKNOWN_TYPE);
-            }
-            throw UnsupportedTypeException.create(arguments);
-        }
-        return arguments;
-    }
-
-    private Object multiValueStackAsArray(WasmLanguage language) {
-        final var multiValueStack = language.multiValueStack();
-        final long[] primitiveMultiValueStack = multiValueStack.primitiveStack();
-        final Object[] objectMultiValueStack = multiValueStack.objectStack();
-        final int resultCount = function.resultCount();
-        assert primitiveMultiValueStack.length >= resultCount;
-        assert objectMultiValueStack.length >= resultCount;
-        final Object[] values = new Object[resultCount];
-        for (int i = 0; i < resultCount; i++) {
-            byte resultType = function.resultTypeAt(i);
-            values[i] = switch (resultType) {
-                case WasmType.I32_TYPE -> (int) primitiveMultiValueStack[i];
-                case WasmType.I64_TYPE -> primitiveMultiValueStack[i];
-                case WasmType.F32_TYPE -> Float.intBitsToFloat((int) primitiveMultiValueStack[i]);
-                case WasmType.F64_TYPE -> Double.longBitsToDouble(primitiveMultiValueStack[i]);
-                case WasmType.V128_TYPE, WasmType.FUNCREF_TYPE, WasmType.EXTERNREF_TYPE -> {
-                    Object obj = objectMultiValueStack[i];
-                    objectMultiValueStack[i] = null;
-                    yield obj;
-                }
-                default -> throw WasmException.create(Failure.UNSPECIFIED_INTERNAL);
-            };
-        }
-        return InteropArray.create(values);
-    }
 }

wasm/src/org.graalvm.wasm/src/org/graalvm/wasm/WasmLanguage.java

@@ -48,6 +48,7 @@
 import org.graalvm.options.OptionDescriptors;
 import org.graalvm.options.OptionValues;
 import org.graalvm.polyglot.SandboxPolicy;
+import org.graalvm.wasm.api.InteropCallAdapterNode;
 import org.graalvm.wasm.api.JsConstants;
 import org.graalvm.wasm.api.WebAssembly;
 import org.graalvm.wasm.exception.WasmJsApiException;
@@ -56,6 +57,7 @@
 import org.graalvm.wasm.predefined.BuiltinModule;
 
 import com.oracle.truffle.api.CallTarget;
+import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.ContextThreadLocal;
 import com.oracle.truffle.api.RootCallTarget;
@@ -96,8 +98,10 @@ public final class WasmLanguage extends TruffleLanguage<WasmContext> {
 
     private final Map<SymbolTable.FunctionType, Integer> equivalenceClasses = new ConcurrentHashMap<>();
     private int nextEquivalenceClass = SymbolTable.FIRST_EQUIVALENCE_CLASS;
+    private final Map<SymbolTable.FunctionType, CallTarget> interopCallAdapters = new ConcurrentHashMap<>();
 
     public int equivalenceClassFor(SymbolTable.FunctionType type) {
+        CompilerAsserts.neverPartOfCompilation();
         Integer equivalenceClass = equivalenceClasses.get(type);
         if (equivalenceClass == null) {
             synchronized (this) {
@@ -112,6 +116,20 @@ public int equivalenceClassFor(SymbolTable.FunctionType type) {
         return equivalenceClass;
     }
 
+    /**
+     * Gets or creates the interop call adapter for a function type. Always returns the same call
+     * target for any particular type.
+     */
+    public CallTarget interopCallAdapterFor(SymbolTable.FunctionType type) {
+        CompilerAsserts.neverPartOfCompilation();
+        CallTarget callAdapter = interopCallAdapters.get(type);
+        if (callAdapter == null) {
+            callAdapter = interopCallAdapters.computeIfAbsent(type,
+                            k -> new InteropCallAdapterNode(this, k).getCallTarget());
+        }
+        return callAdapter;
+    }
+
     @Override
     protected WasmContext createContext(Env env) {
         WasmContext context = new WasmContext(env, this);
@@ -249,6 +267,11 @@ protected boolean areOptionsCompatible(OptionValues firstOptions, OptionValues n
         }
     }
 
+    @SuppressWarnings("unchecked")
+    public static <E extends Throwable> RuntimeException rethrow(Throwable ex) throws E {
+        throw (E) ex;
+    }
+
     public MultiValueStack multiValueStack() {
         return multiValueStackThreadLocal.get();
     }