[WIP] Update entry assembly

src/coreclr/hosts/corerun/corerun.cpp

@@ -433,6 +433,7 @@ static int run(const configuration& config)
             argv_utf8.get(),
             entry_assembly_utf8.c_str(),
             (uint32_t*)&exit_code);
+
         if (FAILED(result))
         {
             pal::fprintf(stderr, W("BEGIN: coreclr_execute_assembly failed - Error: 0x%08x\n"), result);

src/coreclr/vm/assembly.cpp

@@ -1381,7 +1381,7 @@ void RunManagedStartup()
     managedStartup.Call(args);
 }
 
-INT32 Assembly::ExecuteMainMethod(PTRARRAYREF *stringArgs, BOOL waitForOtherThreads)
+void Assembly::ExecuteMainMethodPre(BOOL waitForOtherThreads)
 {
     CONTRACTL
     {
@@ -1397,9 +1397,6 @@ INT32 Assembly::ExecuteMainMethod(PTRARRAYREF *stringArgs, BOOL waitForOtherThre
     // reset the error code for std C
     errno=0;
 
-    HRESULT hr = S_OK;
-    INT32   iRetVal = 0;
-
     Thread *pThread = GetThread();
     MethodDesc *pMeth;
     {
@@ -1446,6 +1443,74 @@ INT32 Assembly::ExecuteMainMethod(PTRARRAYREF *stringArgs, BOOL waitForOtherThre
 
             RunManagedStartup();
 
+            Thread::CleanUpForManagedThreadInNative(pThread);
+        }
+    }
+
+    //RunMainPost is supposed to be called on the main thread of an EXE,
+    //after that thread has finished doing useful work.  It contains logic
+    //to decide when the process should get torn down.  So, don't call it from
+    // AppDomain.ExecuteAssembly()
+    if (pMeth) {
+        if (waitForOtherThreads)
+            RunMainPost();
+    }
+    else {
+        StackSString displayName;
+        GetDisplayName(displayName);
+        COMPlusThrowHR(COR_E_MISSINGMETHOD, IDS_EE_FAILED_TO_FIND_MAIN, displayName);
+    }
+
+}
+
+INT32 Assembly::ExecuteMainMethod(PTRARRAYREF *stringArgs, BOOL waitForOtherThreads)
+{
+    CONTRACTL
+    {
+        INSTANCE_CHECK;
+        THROWS;
+        GC_TRIGGERS;
+        MODE_ANY;
+        ENTRY_POINT;
+        INJECT_FAULT(COMPlusThrowOM());
+    }
+    CONTRACTL_END;
+
+    // reset the error code for std C
+    errno=0;
+
+    HRESULT hr = S_OK;
+    INT32   iRetVal = 0;
+
+    Thread *pThread = GetThread();
+    MethodDesc *pMeth;
+    {
+        // This thread looks like it wandered in -- but actually we rely on it to keep the process alive.
+        pThread->SetBackground(FALSE);
+
+        GCX_COOP();
+
+        pMeth = GetEntryPoint();
+
+        if (pMeth) {
+            {
+#ifdef FEATURE_COMINTEROP
+                GCX_PREEMP();
+
+                Thread::ApartmentState state = Thread::AS_Unknown;
+                state = SystemDomain::GetEntryPointThreadAptState(pMeth->GetMDImport(), pMeth->GetMemberDef());
+                SystemDomain::SetThreadAptState(state);
+#endif // FEATURE_COMINTEROP
+            }
+
+            RunMainPre();
+
+            // Perform additional managed thread initialization.
+            // This would is normally done in the runtime when a managed
+            // thread is started, but is done here instead since the
+            // Main thread wasn't started by the runtime.
+            Thread::InitializationForManagedThreadInNative(pThread);
+
             hr = RunMain(pMeth, 1, &iRetVal, stringArgs);
 
             Thread::CleanUpForManagedThreadInNative(pThread);

src/coreclr/vm/assembly.hpp

@@ -251,6 +251,7 @@ class Assembly
 
     //****************************************************************************************
     //
+    void ExecuteMainMethodPre(BOOL waitForOtherThreads);
     INT32 ExecuteMainMethod(PTRARRAYREF *stringArgs, BOOL waitForOtherThreads);
 
     //****************************************************************************************

src/coreclr/vm/assemblynative.cpp

@@ -1170,6 +1170,19 @@ extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnS
     END_QCALL;
 }
 
+extern "C" void QCALLTYPE AssemblyNative_UpdateEntryAssembly(QCall::AssemblyHandle assemblyHandle)
+{
+    QCALL_CONTRACT;
+
+    BEGIN_QCALL;
+
+    Assembly* pAssembly = assemblyHandle->GetAssembly();
+    PTR_AppDomain pCurDomain = GetAppDomain();
+    pCurDomain->SetRootAssembly(pAssembly);
+
+    END_QCALL;
+}
+
 extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString)
 {
     QCALL_CONTRACT;

src/coreclr/vm/assemblynative.hpp

@@ -42,6 +42,8 @@ extern "C" uint32_t QCALLTYPE AssemblyNative_GetAssemblyCount();
 
 extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly);
 
+extern "C" void QCALLTYPE AssemblyNative_UpdateEntryAssembly(QCall::AssemblyHandle assemblyHandle);
+
 
 extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly);
 

src/coreclr/vm/corhost.cpp

@@ -337,7 +337,10 @@ HRESULT CorHost2::ExecuteAssembly(DWORD dwAppDomainId,
         if(CLRConfig::GetConfigValue(CLRConfig::INTERNAL_Corhost_Swallow_Uncaught_Exceptions))
         {
             EX_TRY
-                DWORD retval = pAssembly->ExecuteMainMethod(&arguments, TRUE /* waitForOtherThreads */);
+                pAssembly->ExecuteMainMethodPre(TRUE /* waitForOtherThreads */);
+                AppDomain *curDomain = SystemDomain::GetCurrentDomain();
+                Assembly *curEntryAssembly = curDomain->GetRootAssembly();
+                DWORD retval = curEntryAssembly->ExecuteMainMethod(&arguments, TRUE /* waitForOtherThreads */);
                 if (pReturnValue)
                 {
                     *pReturnValue = retval;
@@ -346,7 +349,10 @@ HRESULT CorHost2::ExecuteAssembly(DWORD dwAppDomainId,
         }
         else
         {
-            DWORD retval = pAssembly->ExecuteMainMethod(&arguments, TRUE /* waitForOtherThreads */);
+            pAssembly->ExecuteMainMethodPre(TRUE /* waitForOtherThreads */);
+            AppDomain *curDomain = SystemDomain::GetCurrentDomain();
+            Assembly *curEntryAssembly = curDomain->GetRootAssembly();
+            DWORD retval = curEntryAssembly->ExecuteMainMethod(&arguments, TRUE /* waitForOtherThreads */);
             if (pReturnValue)
             {
                 *pReturnValue = retval;

src/mono/sample/HelloWorld_2/HelloWorld_2.csproj

@@ -0,0 +1,61 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>$(NetCoreAppCurrent)</TargetFramework>
+    <!-- always set SelfContained when running to use Mono on desktop -->
+    <SelfContained>true</SelfContained>
+  </PropertyGroup>
+
+  <UsingTask TaskName="MonoAOTCompiler"
+             AssemblyFile="$(MonoAOTCompilerTasksAssemblyPath)" />
+
+  <Target Name="AOTCompileApp" Condition="'$(RunAOTCompilation)' == 'true'" AfterTargets="CopyFilesToPublishDirectory">
+    <PropertyGroup>
+      <_AotOutputType>Library</_AotOutputType>
+      <_AotLibraryFormat>Dylib</_AotLibraryFormat>
+      <UseAotDataFile>false</UseAotDataFile>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <AotInputAssemblies Include="$(PublishDir)\*.dll" />
+    </ItemGroup>
+
+    <MonoAOTCompiler
+      CompilerBinaryPath="@(MonoAotCrossCompiler->WithMetadataValue('RuntimeIdentifier','$(TargetOS)-$(TargetArchitecture.ToLowerInvariant())'))"
+      OutputType="$(_AotOutputType)"
+      LibraryFormat="$(_AotLibraryFormat)"
+      Assemblies="@(AotInputAssemblies)"
+      OutputDir="$(PublishDir)"
+      CollectTrimmingEligibleMethods="$(StripILCode)"
+      TrimmingEligibleMethodsOutputDirectory="$(TrimmingEligibleMethodsOutputDirectory)"
+      IntermediateOutputPath="$(IntermediateOutputPath)"
+      UseAotDataFile="$(UseAotDataFile)"
+      MibcProfilePath="$(MibcProfilePath)"
+      UseLLVM="$(MonoEnableLLVM)"
+      LLVMPath="$(MonoAotCrossDir)">
+      <Output TaskParameter="CompiledAssemblies" ItemName="BundleAssemblies" />
+    </MonoAOTCompiler>
+  </Target>
+
+  <UsingTask TaskName="ILStrip"
+             AssemblyFile="$(MonoTargetsTasksAssemblyPath)" />
+
+  <Target Name="StripILCode" Condition="'$(StripILCode)' == 'true'" AfterTargets="AOTCompileApp">
+    <PropertyGroup>
+      <TrimIndividualMethods>true</TrimIndividualMethods>
+    </PropertyGroup>
+
+    <ILStrip
+      TrimIndividualMethods="$(TrimIndividualMethods)"
+      Assemblies="@(BundleAssemblies)">
+      <Output TaskParameter="TrimmedAssemblies" ItemName="TrimmedAssemblies" />
+    </ILStrip>
+
+    <Copy
+        SourceFiles="@(TrimmedAssemblies->Metadata('TrimmedAssemblyFileName'))"
+        DestinationFiles="@(TrimmedAssemblies)"
+        OverwriteReadOnlyFiles="true"
+    />
+    <Delete Files="@(TrimmedAssemblies->Metadata('TrimmedAssemblyFileName'))" />
+  </Target>
+</Project>

src/mono/sample/HelloWorld_2/Makefile

@@ -0,0 +1,34 @@
+TOP=../../../../
+DOTNET:=$(TOP)dotnet.sh
+DOTNET_Q_ARGS=--nologo -v:q -consoleloggerparameters:NoSummary
+
+MONO_CONFIG?=Debug
+MONO_ARCH?=$(shell . $(TOP)eng/common/native/init-os-and-arch.sh && echo $${arch})
+TARGET_OS?=$(shell . $(TOP)eng/common/native/init-os-and-arch.sh && echo $${os})
+AOT?=false
+USE_LLVM?=false
+StripILCode?=false
+TrimmingEligibleMethodsOutputDirectory?= #<path-to-a-writable-directory>
+
+#MIBC_PROFILE_PATH=<path-to-mibc-for-sample>
+
+MONO_ENV_OPTIONS ?=
+
+publish:
+	$(DOTNET) publish \
+	-c $(MONO_CONFIG) \
+	-r $(TARGET_OS)-$(MONO_ARCH) \
+	/p:RunAOTCompilation=$(AOT) \
+	/p:MonoEnableLLVM=$(USE_LLVM) \
+	/p:StripILCode=$(StripILCode) \
+	/p:TrimmingEligibleMethodsOutputDirectory=$(TrimmingEligibleMethodsOutputDirectory) \
+	'/p:MibcProfilePath="$(MIBC_PROFILE_PATH)"' \
+	/bl
+
+run: publish
+	DOTNET_DebugWriteToStdErr=1 \
+	MONO_ENV_OPTIONS="$(MONO_ENV_OPTIONS)" \
+	$(TOP)artifacts/bin/HelloWorld_2/$(MONO_ARCH)/$(MONO_CONFIG)/$(TARGET_OS)-$(MONO_ARCH)/publish/HelloWorld_2
+
+clean:
+	rm -rf $(TOP)artifacts/bin/HelloWorld_2/

src/mono/sample/HelloWorld_2/Program.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;
+
+namespace HelloWorld_2
+{
+    internal class Program
+    {
+        private static void Main(string[] args)
+        {
+            Console.WriteLine($"Hello World 2");
+        }
+    }
+}