[wasm] Implement initial support for WasmImportLinkage to the AppBuilders (#94615)

* Implement initial support for WasmImportLinkage to the AppBuilders

* Mangle WasmLinkage imports by namespace and handle special modules

* Don't mangle the symbolic entry point

* Add very basic support for wasm exports using UnmanagedCallersOnly

* Escape potential escape characters in string literals

* Make the C codegen more readable

* Add temporary sample for testing

* Simplify workaround for UnmanagedCallersOnly

* Remove weak attribute that slipped in

* Rename some of the helpers

* Use multiline interpolation

* Improve output formatting and comments

* review feedback

Author: lewing

src/mono/sample/wasi/native/Makefile

@@ -0,0 +1,15 @@
+TOP=../../../../..
+
+include ../wasi.mk
+
+ifneq ($(AOT),)
+override MSBUILD_ARGS+=/p:RunAOTCompilation=true
+endif
+
+ifneq ($(V),)
+DOTNET_MONO_LOG_LEVEL=--setenv=MONO_LOG_LEVEL=debug
+endif
+
+PROJECT_NAME=Wasi.Console.Sample.csproj
+
+run: run-console

src/mono/sample/wasi/native/Program.cs

@@ -0,0 +1,31 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Runtime.InteropServices;
+
+public unsafe class Test
+{
+    [UnmanagedCallersOnly(EntryPoint = "ManagedFunc")]
+    public static int MyExport(int number)
+    {
+        // called from MyImport aka UnmanagedFunc
+        Console.WriteLine($"MyExport({number}) -> 42");
+        return 42;
+    }
+
+    [DllImport("*", EntryPoint = "UnmanagedFunc")]
+    public static extern void MyImport(); // calls ManagedFunc aka MyExport
+
+    public unsafe static int Main(string[] args)
+    {
+        Console.WriteLine($"main: {args.Length}");
+        // workaround to force the interpreter to initialize wasm_native_to_interp_ftndesc for MyExport
+        if (args.Length > 10000) {
+            ((IntPtr)(delegate* unmanaged<int,int>)&MyExport).ToString();
+        }
+
+        MyImport();
+        return 0;
+    }
+}

src/mono/sample/wasi/native/Wasi.Native.Sample.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>$(NetCoreAppCurrent)</TargetFramework>
+    <RuntimeIdentifier>wasi-wasm</RuntimeIdentifier>
+    
+    <TargetOs>wasi</TargetOs>
+    <WasmBuildNative>true</WasmBuildNative>
+    <WasmNativeStrip>false</WasmNativeStrip>
+    <IsBrowserWasmProject>false</IsBrowserWasmProject>
+    <WasmSingleFileBundle>true</WasmSingleFileBundle>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <NativeFileReference Include="local.c" />
+  </ItemGroup>
+  <Target Name="RunSample" DependsOnTargets="RunSampleWithWasmtime" />
+</Project>

src/mono/sample/wasi/native/local.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+int ManagedFunc(int number);
+
+void UnmanagedFunc()
+{
+    int ret = 0;
+    printf("UnmanagedFunc calling ManagedFunc\n");
+    ret = ManagedFunc(123);
+    printf("ManagedFunc returned %d\n", ret);
+}

src/tasks/WasmAppBuilder/PInvokeCollector.cs

@@ -15,17 +15,19 @@
 internal sealed class PInvoke : IEquatable<PInvoke>
 #pragma warning restore CA1067
 {
-    public PInvoke(string entryPoint, string module, MethodInfo method)
+    public PInvoke(string entryPoint, string module, MethodInfo method, bool wasmLinkage)
     {
         EntryPoint = entryPoint;
         Module = module;
         Method = method;
+        WasmLinkage = wasmLinkage;
     }
 
     public string EntryPoint;
     public string Module;
     public MethodInfo Method;
     public bool Skip;
+    public bool WasmLinkage;
 
     public bool Equals(PInvoke? other)
         => other != null &&
@@ -100,9 +102,10 @@ void CollectPInvokesForMethod(MethodInfo method)
             if ((method.Attributes & MethodAttributes.PinvokeImpl) != 0)
             {
                 var dllimport = method.CustomAttributes.First(attr => attr.AttributeType.Name == "DllImportAttribute");
+                var wasmLinkage = method.CustomAttributes.Any(attr => attr.AttributeType.Name == "WasmImportLinkageAttribute");
                 var module = (string)dllimport.ConstructorArguments[0].Value!;
                 var entrypoint = (string)dllimport.NamedArguments.First(arg => arg.MemberName == "EntryPoint").TypedValue.Value!;
-                pinvokes.Add(new PInvoke(entrypoint, module, method));
+                pinvokes.Add(new PInvoke(entrypoint, module, method, wasmLinkage));
 
                 string? signature = SignatureMapper.MethodToSignature(method);
                 if (signature == null)
@@ -241,8 +244,23 @@ internal sealed class PInvokeCallback
     public PInvokeCallback(MethodInfo method)
     {
         Method = method;
+        foreach (var attr in method.CustomAttributes)
+        {
+            if (attr.AttributeType.Name == "UnmanagedCallersOnlyAttribute")
+            {
+                foreach(var arg in attr.NamedArguments)
+                {
+                    if (arg.MemberName == "EntryPoint")
+                    {
+                        EntryPoint = arg.TypedValue.Value!.ToString();
+                        return;
+                    }
+                }
+            }
+        }
     }
 
+    public string? EntryPoint;
     public MethodInfo Method;
     public string? EntryName;
 }