[NativeAOT] Support exporting methods from referenced assemblies in a formal way

src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Publish.targets

@@ -41,7 +41,6 @@
   <Target Name="_ComputeAssembliesToCompileToNative" DependsOnTargets="$(IlcDynamicBuildPropertyDependencies)">
 
     <Warning Condition="Exists($(UserRuntimeConfig))" Text="The published project has a runtimeconfig.template.json that is not supported by PublishAot. Move the configuration to the project file using RuntimeHostConfigurationOption." />
-
     <!-- Fail with descriptive error message for common mistake. -->
     <Error Condition="$([MSBuild]::VersionLessThan('$(NETCoreSdkVersion)', '6.0.0'))" Text=".NET SDK 6+ is required for native compilation." />
     <Error Condition="$([MSBuild]::VersionLessThan('$(TargetFrameworkVersion)', '6.0'))" Text="For native compilation, the project needs to target .NET 6 or higher." />

src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets

@@ -185,6 +185,9 @@ The .NET Foundation licenses this file to you under the MIT license.
       <_IlcConditionallyRootedAssemblies Include="@(ManagedAssemblyToLink)" Condition="%(ManagedAssemblyToLink.TrimMode) == 'copyused'" />
       <_IlcTrimmedAssemblies Include="@(ManagedAssemblyToLink)" Condition="%(ManagedAssemblyToLink.TrimMode) == 'link'" />
       <_IlcNoSingleWarnAssemblies Include="@(ManagedAssemblyToLink)" Condition="%(ManagedAssemblyToLink.TrimmerSingleWarn) == 'false'" />
+
+      <!-- always export unmanaged entry points from System.Private.CoreLib -->
+      <UnmanagedEntryPointsAssembly Include="System.Private.CoreLib" />
     </ItemGroup>
 
     <ItemGroup>
@@ -241,6 +244,7 @@ The .NET Foundation licenses this file to you under the MIT license.
       <IlcArg Include="@(_IlcNoSingleWarnAssemblies->'--nosinglewarnassembly:%(Filename)')" />
       <IlcArg Condition="'$(TrimmerDefaultAction)' == 'copyused' or '$(TrimmerDefaultAction)' == 'copy' or '$(TrimMode)' == 'partial'" Include="--defaultrooting" />
       <IlcArg Include="--resilient" />
+      <IlcArg Include="@(UnmanagedEntryPointsAssembly->'--generateunmanagedentrypoints:%(Identity)')" />
 
       <IlcArg Condition="$(IlcDisableReflection) == 'true'" Include="--feature:System.Reflection.IsReflectionExecutionAvailable=false" />
 

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ExportedMethodsRootProvider.cs → src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/UnmanagedEntryPointsRootProvider.cs

@@ -12,11 +12,11 @@ namespace ILCompiler
     /// <summary>
     /// Computes a set of roots based on managed and unmanaged methods exported from a module.
     /// </summary>
-    public class ExportedMethodsRootProvider : ICompilationRootProvider
+    public class UnmanagedEntryPointsRootProvider : ICompilationRootProvider
     {
         private EcmaModule _module;
 
-        public ExportedMethodsRootProvider(EcmaModule module)
+        public UnmanagedEntryPointsRootProvider(EcmaModule module)
         {
             _module = module;
         }

src/coreclr/tools/aot/ILCompiler.Compiler/ILCompiler.Compiler.csproj

@@ -571,7 +571,7 @@
     <Compile Include="Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64ReadyToRunHelperNode.cs" />
     <Compile Include="Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64ReadyToRunGenericHelperNode.cs" />
     <Compile Include="Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64UnboxingStubNode.cs" />
-    <Compile Include="Compiler\ExportedMethodsRootProvider.cs" />
+    <Compile Include="Compiler\UnmanagedEntryPointsRootProvider.cs" />
     <Compile Include="Compiler\GenericDictionaryLookup.cs" />
     <Compile Include="Compiler\IRootingServiceProvider.cs" />
     <Compile Include="Compiler\JitHelper.cs" />

src/coreclr/tools/aot/ILCompiler/ILCompilerRootCommand.cs

@@ -160,6 +160,8 @@ internal sealed class ILCompilerRootCommand : RootCommand
             new(new[] { "--singlemethodgenericarg" }, "Single method compilation: generic arguments to the method");
         public Option<string> MakeReproPath { get; } =
             new(new[] { "--make-repro-path" }, "Path where to place a repro package");
+        public Option<string[]> UnmanagedEntryPointsAssemblies { get; } =
+            new(new[] { "--generateunmanagedentrypoints" }, Array.Empty<string>, "Generate unmanaged entrypoints for a given assembly");
 
         public OptimizationMode OptimizationMode { get; private set; }
         public ParseResult Result;
@@ -232,6 +234,7 @@ public ILCompilerRootCommand(string[] args) : base(".NET Native IL Compiler")
             AddOption(SingleMethodName);
             AddOption(SingleMethodGenericArgs);
             AddOption(MakeReproPath);
+            AddOption(UnmanagedEntryPointsAssemblies);
 
             this.SetHandler(context =>
             {

src/coreclr/tools/aot/ILCompiler/Program.cs

@@ -181,7 +181,7 @@ public int Run()
                     if (module == typeSystemContext.SystemModule)
                         systemModuleIsInputModule = true;
 
-                    compilationRoots.Add(new ExportedMethodsRootProvider(module));
+                    compilationRoots.Add(new UnmanagedEntryPointsRootProvider(module));
                 }
 
                 bool nativeLib = Get(_command.NativeLib);
@@ -209,8 +209,6 @@ public int Run()
                     if (entrypointModule == null && (!nativeLib || SplitExeInitialization))
                         throw new Exception("No entrypoint module");
 
-                    if (!systemModuleIsInputModule)
-                        compilationRoots.Add(new ExportedMethodsRootProvider((EcmaModule)typeSystemContext.SystemModule));
                     compilationGroup = new SingleFileCompilationModuleGroup();
                 }
 
@@ -238,6 +236,15 @@ public int Run()
                     }
                 }
 
+                foreach (var unmanagedEntryPointsAssembly in Get(_command.UnmanagedEntryPointsAssemblies))
+                {
+                    EcmaModule module = typeSystemContext.GetModuleForSimpleName(unmanagedEntryPointsAssembly);
+                    // Skip adding the system module as a UnmanagedEntryPointsRootProvider if it was already added as an input module
+                    if (module == typeSystemContext.SystemModule && systemModuleIsInputModule)
+                        continue;
+                    compilationRoots.Add(new UnmanagedEntryPointsRootProvider(module));
+                }
+
                 foreach (var rdXmlFilePath in Get(_command.RdXmlFilePaths))
                 {
                     compilationRoots.Add(new RdXmlRootProvider(typeSystemContext, rdXmlFilePath));
@@ -531,7 +538,7 @@ void RunScanner()
                 ExportsFileWriter defFileWriter = new ExportsFileWriter(typeSystemContext, exportsFile);
                 foreach (var compilationRoot in compilationRoots)
                 {
-                    if (compilationRoot is ExportedMethodsRootProvider provider)
+                    if (compilationRoot is UnmanagedEntryPointsRootProvider provider)
                         defFileWriter.AddExportedMethods(provider.ExportedMethods);
                 }
 

src/coreclr/tools/aot/ILCompiler/repro/repro.csproj

@@ -38,6 +38,7 @@
       <ReproResponseLines Include="--feature:System.Linq.Expressions.CanCompileToIL=false" />
       <ReproResponseLines Include="--feature:System.Linq.Expressions.CanEmitObjectArrayDelegate=false" />
       <ReproResponseLines Include="--feature:System.Linq.Expressions.CanCreateArbitraryDelegates=false" />
+      <ReproResponseLines Include="--generateunmanagedentrypoints:System.Private.CoreLib" />
     </ItemGroup>
 
     <WriteLinesToFile File="$(OutputPath)\compile-with-$(LibrariesConfiguration)-libs.rsp"

src/coreclr/tools/aot/Mono.Linker.Tests/TestCasesRunner/ILCompilerDriver.cs

@@ -59,7 +59,7 @@ public ILScanResults Trim (ILCompilerOptions options, ILogWriter logWriter)
 					entrypointModule = module;
 				}
 
-				compilationRoots.Add (new ExportedMethodsRootProvider (module));
+				compilationRoots.Add (new UnmanagedEntryPointsRootProvider (module));
 			}
 
 			compilationRoots.Add (new MainMethodRootProvider (entrypointModule, CreateInitializerList (typeSystemContext, options), generateLibraryAndModuleInitializers: true));

src/tests/nativeaot/GenerateUnmanagedEntryPoints/CMakeLists.txt

@@ -0,0 +1,8 @@
+project (GenerateUnmanagedEntryPoints)
+include_directories(${INC_PLATFORM_DIR})
+
+add_executable (GenerateUnmanagedEntryPointsDriver GenerateUnmanagedEntryPoints.cpp)
+
+if (CLR_CMAKE_TARGET_UNIX)
+    target_link_libraries (GenerateUnmanagedEntryPointsDriver PRIVATE ${CMAKE_DL_LIBS})
+endif()

src/tests/nativeaot/GenerateUnmanagedEntryPoints/GenerateUnmanagedEntryPoints.cpp

@@ -0,0 +1,61 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#ifdef TARGET_WINDOWS
+#include "windows.h"
+#else
+#include "dlfcn.h"
+#endif
+#include "stdio.h"
+#include "string.h"
+
+#ifndef TARGET_WINDOWS
+#define __stdcall
+#endif
+
+// typedef for shared lib exported methods
+typedef void(__stdcall *fptr)();
+
+#ifdef TARGET_WINDOWS
+int __cdecl main()
+#else
+int main(int argc, char* argv[])
+#endif
+{
+#ifdef TARGET_WINDOWS
+    HINSTANCE handle = LoadLibrary("GenerateUnmanagedEntryPoints.dll");
+#elif __APPLE__
+    void *handle = dlopen(strcat(argv[0], ".dylib"), RTLD_LAZY);
+#else
+    void *handle = dlopen(strcat(argv[0], ".so"), RTLD_LAZY);
+#endif
+
+    if (!handle)
+        return 1;
+
+#ifdef TARGET_WINDOWS
+    fptr main_assembly_method = (fptr)GetProcAddress(handle, "SharedLibraryAssemblyMethod");
+    fptr ref1_assembly_method = (fptr)GetProcAddress(handle, "ReferencedAssembly1Method");
+    fptr ref2_assembly_method = (fptr)GetProcAddress(handle, "ReferencedAssembly2Method");
+#else
+    fptr main_assembly_method = (fptr)dlsym(handle, "SharedLibraryAssemblyMethod");
+    fptr ref1_assembly_method = (fptr)dlsym(handle, "ReferencedAssembly1Method");
+    fptr ref2_assembly_method = (fptr)dlsym(handle, "ReferencedAssembly2Method");
+#endif
+
+    // method must be exposed from GenerateUnmanagedEntryPoints assembly
+    if (!main_assembly_method)
+        return 2;
+    main_assembly_method();
+
+    // method must be exposed from ReferencedAssembly1 assembly
+    if (!ref1_assembly_method)
+        return 3;
+    ref1_assembly_method();
+
+    // method must not be exposed from ReferencedAssembly2 assembly
+    if (ref2_assembly_method)
+        return 4;
+
+    return 100;
+}

src/tests/nativeaot/GenerateUnmanagedEntryPoints/GenerateUnmanagedEntryPoints.cs

@@ -0,0 +1,15 @@
+// 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.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace GenerateUnmanagedEntryPoints
+{
+    public class ClassLibrary
+    {
+        [UnmanagedCallersOnly(EntryPoint = "SharedLibraryAssemblyMethod", CallConvs = new Type[] { typeof(CallConvStdcall) })]
+        static void SharedLibraryAssemblyMethod() => Console.WriteLine($"Hello from {nameof(SharedLibraryAssemblyMethod)}");
+    }
+}

src/tests/nativeaot/GenerateUnmanagedEntryPoints/GenerateUnmanagedEntryPoints.csproj

@@ -0,0 +1,36 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Library</OutputType>
+    <CLRTestKind>BuildAndRun</CLRTestKind>
+    <NativeLib>Shared</NativeLib>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <CLRTestBatchPreCommands><![CDATA[
+$(CLRTestBatchPreCommands)
+mkdir native 2>nul
+copy /y GenerateUnmanagedEntryPointsDriver.exe native\GenerateUnmanagedEntryPoints.exe
+]]></CLRTestBatchPreCommands>
+
+    <CLRTestBashPreCommands><![CDATA[
+$(CLRTestBashPreCommands)
+mkdir -p native
+cp GenerateUnmanagedEntryPointsDriver native/GenerateUnmanagedEntryPoints
+]]></CLRTestBashPreCommands>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="GenerateUnmanagedEntryPoints.cs" />
+    <ProjectReference Include="$(MSBuildThisFileDirectory)ReferencedAssembly1\ReferencedAssembly1.csproj" />
+    <ProjectReference Include="$(MSBuildThisFileDirectory)ReferencedAssembly2\ReferencedAssembly2.csproj" />
+  </ItemGroup>
+
+  <!-- Expose additional unmanaged entry points from ReferencedAssembly1 -->
+  <ItemGroup>
+    <UnmanagedEntryPointsAssembly Include="ReferencedAssembly1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <CMakeProjectReference Include="CMakeLists.txt" />
+  </ItemGroup>
+</Project>

src/tests/nativeaot/GenerateUnmanagedEntryPoints/ReferencedAssembly1/ReferencedAssembly1.cs

@@ -0,0 +1,15 @@
+// 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.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace ReferencedAssembly1
+{
+    public class ClassLibrary
+    {
+        [UnmanagedCallersOnly(EntryPoint = "ReferencedAssembly1Method", CallConvs = new Type[] { typeof(CallConvStdcall) })]
+        public static void ReferencedAssembly1Method() => Console.WriteLine($"Hello from {nameof(ReferencedAssembly1Method)}");
+    }
+}

src/tests/nativeaot/GenerateUnmanagedEntryPoints/ReferencedAssembly1/ReferencedAssembly1.csproj

@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <Compile Include="ReferencedAssembly1.cs" />
+  </ItemGroup>
+
+</Project>

src/tests/nativeaot/GenerateUnmanagedEntryPoints/ReferencedAssembly2/ReferencedAssembly2.cs

@@ -0,0 +1,15 @@
+// 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.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace ReferencedAssembly2
+{
+    public class ClassLibrary
+    {
+        [UnmanagedCallersOnly(EntryPoint = "ReferencedAssembly2Method", CallConvs = new Type[] { typeof(CallConvStdcall) })]
+        public static void ReferencedAssembly2Method() => Console.WriteLine($"Hello from {nameof(ReferencedAssembly2Method)}");
+    }
+}

src/tests/nativeaot/GenerateUnmanagedEntryPoints/ReferencedAssembly2/ReferencedAssembly2.csproj

@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <Compile Include="ReferencedAssembly2.cs" />
+  </ItemGroup>
+
+</Project>