[mono][wasm] marshal-ilgen is dropped when not required

src/mono/mono/component/marshal-ilgen-stub.c

@@ -9,11 +9,46 @@ marshal_ilgen_available (void)
 	return false;
 }
 
+static void emit_throw_exception (MonoMarshalLightweightCallbacks* lightweight_cb, 
+		MonoMethodBuilder* mb, const char* exc_nspace, const char* exc_name, const char* msg)
+{
+	lightweight_cb->mb_emit_exception (mb, exc_nspace, exc_name, msg);
+}
+
 static int
-stub_emit_marshal_ilgen (EmitMarshalContext *m, int argnum, MonoType *t,
-		MonoMarshalSpec *spec, int conv_arg,	
-		MonoType **conv_arg_type, MarshalAction action, MonoMarshalLightweightCallbacks* lightweight_cb)
+stub_emit_marshal_ilgen (EmitMarshalContext* m, int argnum, MonoType* t,
+		MonoMarshalSpec* spec, int conv_arg,	
+		MonoType** conv_arg_type, MarshalAction action, MonoMarshalLightweightCallbacks* lightweight_cb)
 {
+	if (spec) {
+		g_assert (spec->native != MONO_NATIVE_ASANY);
+		g_assert (spec->native != MONO_NATIVE_CUSTOM);
+	}
+
+	g_assert (!m_type_is_byref(t));
+
+	switch (t->type) {
+	case MONO_TYPE_PTR:
+	case MONO_TYPE_I1:
+	case MONO_TYPE_U1:
+	case MONO_TYPE_I2:
+	case MONO_TYPE_U2:
+	case MONO_TYPE_I4:
+	case MONO_TYPE_U4:
+	case MONO_TYPE_I:
+	case MONO_TYPE_U:
+	case MONO_TYPE_R4:
+	case MONO_TYPE_R8:
+	case MONO_TYPE_I8:
+	case MONO_TYPE_U8:
+	case MONO_TYPE_FNPTR:
+		return lightweight_cb->emit_marshal_scalar (m, argnum, t, spec, conv_arg, conv_arg_type, action);
+	default:
+		emit_throw_exception (lightweight_cb, m->mb, "System", "ApplicationException",
+			g_strdup("Cannot marshal nonblittlable types without marshal-ilgen."));
+		break;
+	}
+
 	return 0;
 }
 

src/mono/mono/metadata/marshal-lightweight.c

@@ -523,7 +523,7 @@ emit_runtime_invoke_body_ilgen (MonoMethodBuilder *mb, const char **param_names,
 	emit_thread_force_interrupt_checkpoint (mb);
 	emit_invoke_call (mb, method, sig, callsig, loc_res, virtual_, need_direct_wrapper);
 
-	mono_mb_emit_ldloc (mb, 0);
+	mono_mb_emit_ldloc (mb, loc_res);
 	mono_mb_emit_byte (mb, CEE_RET);
 }
 

src/mono/wasm/build/WasmApp.Native.targets

@@ -3,9 +3,11 @@
 
   <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.ManagedToNativeGenerator" AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)" />
   <UsingTask TaskName="Microsoft.WebAssembly.Build.Tasks.EmccCompile" AssemblyFile="$(WasmAppBuilderTasksAssemblyPath)" />
+  <UsingTask TaskName="MonoTargetsTasks.MarshalingPInvokeScanner" AssemblyFile="$(MonoTargetsTasksAssemblyPath)" />
 
   <PropertyGroup>
     <_WasmBuildNativeCoreDependsOn>
+      _ScanAssembliesDecideLightweightMarshaler;
       _WasmAotCompileApp;
       _WasmStripAOTAssemblies;
       _PrepareForWasmBuildNative;
@@ -33,7 +35,7 @@
   <ItemGroup Condition="'$(Configuration)' == 'Debug' and '@(_MonoComponent->Count())' == 0">
     <_MonoComponent Include="hot_reload;debugger" />
   </ItemGroup>
-  <ItemGroup>
+  <ItemGroup Condition="'@(MonoLightweightMarshallerIncompatibleAssemblies->Count())' > 0">
     <_MonoComponent Include="marshal-ilgen" />
   </ItemGroup>
 
@@ -680,6 +682,16 @@
     </ItemGroup>
   </Target>
 
+  <Target Name="_ScanAssembliesDecideLightweightMarshaler">
+     <ItemGroup>
+      <AssembliesToScan Include="@(_WasmAssembliesInternal)" />
+    </ItemGroup>
+
+    <MarshalingPInvokeScanner Assemblies ="@(AssembliesToScan)">
+      <Output TaskParameter="IncompatibleAssemblies" ItemName="MonoLightweightMarshallerIncompatibleAssemblies" />
+    </MarshalingPInvokeScanner>
+  </Target>
+
   <!-- '$(ArchiveTests)' != 'true' is to skip on CI for now -->
   <Target Name="_WasmStripAOTAssemblies" Condition="'$(_WasmShouldAOT)' == 'true' and '$(WasmStripAOTAssemblies)' == 'true' and '$(AOTMode)' != 'LLVMOnlyInterp' and '$(ArchiveTests)' != 'true'">
     <PropertyGroup>

src/tasks/MonoTargetsTasks/MarshalingPInvokeScanner/MarshalingPInvokeScanner.cs

@@ -0,0 +1,157 @@
+// 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.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection.Metadata;
+using System.Reflection.Metadata.Ecma335;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using System.Reflection.PortableExecutable;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+
+namespace MonoTargetsTasks
+{
+    public class MarshalingPInvokeScanner : Task
+    {
+        [Required]
+        public string[] Assemblies { get; set; } = Array.Empty<string>();
+
+        [Output]
+        public string[]? IncompatibleAssemblies { get; private set; }
+
+        public override bool Execute()
+        {
+            if (Assemblies is null || Assemblies!.Length == 0)
+            {
+                Log.LogError($"{nameof(MarshalingPInvokeScanner)}.{nameof(Assemblies)} cannot be empty");
+                return false;
+            }
+
+            try
+            {
+                ExecuteInternal();
+                return !Log.HasLoggedErrors;
+            }
+            catch (LogAsErrorException e)
+            {
+                Log.LogError(e.Message);
+                return false;
+            }
+        }
+
+        private void ExecuteInternal()
+        {
+            IncompatibleAssemblies = ScanAssemblies(Assemblies);
+        }
+
+        private string[] ScanAssemblies(string[] assemblies)
+        {
+            HashSet<string> incompatible = new HashSet<string>();
+            MinimalMarshalingTypeCompatibilityProvider mmtcp = new(Log);
+            foreach (string aname in assemblies)
+            {
+                if (IsAssemblyIncompatible(aname, mmtcp))
+                    incompatible.Add(aname);
+            }
+
+            if (mmtcp.IsSecondPassNeeded)
+            {
+                foreach (string aname in assemblies)
+                    ResolveInconclusiveTypes(incompatible, aname, mmtcp);
+            }
+
+            return incompatible.ToArray();
+        }
+
+        private static string GetMethodName(MetadataReader mr, MethodDefinition md) => mr.GetString(md.Name);
+
+        private void ResolveInconclusiveTypes(HashSet<string> incompatible, string assyPath, MinimalMarshalingTypeCompatibilityProvider mmtcp)
+        {
+            string assyName = MetadataReader.GetAssemblyName(assyPath).Name!;
+            HashSet<string> inconclusiveTypes = mmtcp.GetInconclusiveTypesForAssembly(assyName);
+            if(inconclusiveTypes.Count == 0)
+                return;
+
+            using FileStream file = new FileStream(assyPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            using PEReader peReader = new PEReader(file);
+            MetadataReader mdtReader = peReader.GetMetadataReader();
+
+            SignatureDecoder<Compatibility, object> decoder = new(mmtcp, mdtReader, null!);
+
+            foreach (TypeDefinitionHandle typeDefHandle in mdtReader.TypeDefinitions)
+            {
+                TypeDefinition typeDef = mdtReader.GetTypeDefinition(typeDefHandle);
+                string fullTypeName = string.Join(":", mdtReader.GetString(typeDef.Namespace), mdtReader.GetString(typeDef.Name));
+
+                // This is not perfect, but should work right for enums defined in other assemblies,
+                // which is the only case where we use Compatibility.Inconclusive.
+                if (inconclusiveTypes.Contains(fullTypeName) &&
+                    mmtcp.GetTypeFromDefinition(mdtReader, typeDefHandle, 0) != Compatibility.Compatible)
+                {
+                    Log.LogMessage(MessageImportance.Low, string.Format("Type {0} is marshaled and requires marshal-ilgen.", fullTypeName));
+
+                    incompatible.Add("(unknown assembly)");
+                }
+            }
+        }
+
+        private bool IsAssemblyIncompatible(string assyPath, MinimalMarshalingTypeCompatibilityProvider mmtcp)
+        {
+            using FileStream file = new FileStream(assyPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            using PEReader peReader = new PEReader(file);
+            MetadataReader mdtReader = peReader.GetMetadataReader();
+
+            foreach(CustomAttributeHandle attrHandle in mdtReader.CustomAttributes)
+            {
+                CustomAttribute attr = mdtReader.GetCustomAttribute(attrHandle);
+
+                if(attr.Constructor.Kind == HandleKind.MethodDefinition)
+                {
+                    MethodDefinitionHandle mdh = (MethodDefinitionHandle)attr.Constructor;
+                    MethodDefinition md = mdtReader.GetMethodDefinition(mdh);
+                    TypeDefinitionHandle tdh = md.GetDeclaringType();
+                    TypeDefinition td = mdtReader.GetTypeDefinition(tdh);
+
+                    if(mdtReader.GetString(td.Namespace) == "System.Runtime.CompilerServices" &&
+                        mdtReader.GetString(td.Name) == "DisableRuntimeMarshallingAttribute")
+                        return false;
+                }
+            }
+
+            foreach (TypeDefinitionHandle typeDefHandle in mdtReader.TypeDefinitions)
+            {
+                TypeDefinition typeDef = mdtReader.GetTypeDefinition(typeDefHandle);
+                string ns = mdtReader.GetString(typeDef.Namespace);
+                string name = mdtReader.GetString(typeDef.Name);
+
+                foreach(MethodDefinitionHandle mthDefHandle in typeDef.GetMethods())
+                {
+                    MethodDefinition mthDef = mdtReader.GetMethodDefinition(mthDefHandle);
+                    if(!mthDef.Attributes.HasFlag(MethodAttributes.PinvokeImpl))
+                        continue;
+
+                    BlobReader sgnBlobReader = mdtReader.GetBlobReader(mthDef.Signature);
+                    SignatureDecoder<Compatibility, object> decoder = new(mmtcp, mdtReader, null!);
+
+                    MethodSignature<Compatibility> sgn = decoder.DecodeMethodSignature(ref sgnBlobReader);
+                    if(sgn.ReturnType == Compatibility.Incompatible || sgn.ParameterTypes.Any(p => p == Compatibility.Incompatible))
+                    {
+                        Log.LogMessage(MessageImportance.Low, string.Format("Assembly {0} requires marhsal-ilgen for method {1}.{2}:{3} (first pass).",
+                            assyPath, ns, name, mdtReader.GetString(mthDef.Name)));
+
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+}