Implement NativeLibrary.GetEntryPointModuleHandle

src/coreclr/hosts/corerun/corerun.cpp

@@ -555,16 +555,13 @@ int MAIN(const int argc, const char_t* argv[])
     return exit_code;
 }
 
-#ifdef TARGET_WINDOWS
-// Used by CoreShim to determine running CoreCLR details.
 extern "C" __declspec(dllexport) HRESULT __cdecl GetCurrentClrDetails(void** clrInstance, unsigned int* appDomainId)
 {
     assert(clrInstance != nullptr && appDomainId != nullptr);
     *clrInstance = CurrentClrInstance;
     *appDomainId = CurrentAppDomainId;
     return S_OK;
 }
-#endif // TARGET_WINDOWS
 
 //
 // Self testing for corerun.

src/coreclr/hosts/corerun/corerun.hpp

@@ -48,6 +48,7 @@ namespace pal
 #ifdef TARGET_WINDOWS
 #include <Windows.h>
 
+#define DLL_EXPORT __declspec(dllexport)
 #define MAIN __cdecl wmain
 #define W(str) L ## str
 
@@ -307,6 +308,11 @@ class platform_specific_actions final
 #include <config.h>
 #include <getexepath.h>
 
+#if __GNUC__ >= 4
+#define DLL_EXPORT __attribute__ ((visibility ("default")))
+#else
+#define DLL_EXPORT
+#endif
 #define MAIN main
 #define W(str) str
 #define FAILED(result) (result < 0)
@@ -573,7 +579,7 @@ namespace pal
         pal::ensure_trailing_delimiter(coreclr_path);
         coreclr_path.append(pal::coreclr_lib);
         coreclr_path.append(pal::nativelib_ext);
-        
+
         hMod = (pal::mod_t)dlopen(coreclr_path.c_str(), RTLD_NOW | RTLD_LOCAL);
         if (hMod == nullptr)
         {

src/coreclr/vm/ecalllist.h

@@ -798,6 +798,7 @@ FCFuncStart(gInteropNativeLibraryFuncs)
     QCFuncElement("LoadByName", NativeLibraryNative::LoadByName)
     QCFuncElement("FreeLib", NativeLibraryNative::FreeLib)
     QCFuncElement("GetSymbol", NativeLibraryNative::GetSymbol)
+	QCFuncElement("GetEntryPointModuleHandleInternal", NativeLibraryNative::GetEntryPointModuleHandle)
 FCFuncEnd()
 
 FCFuncStart(gTypeLoadExceptionFuncs)

src/coreclr/vm/nativelibrary.cpp

@@ -181,6 +181,28 @@ namespace
         return hmod;
     }
 
+    // Load the library directly and return the raw system handle
+    NATIVE_LIBRARY_HANDLE GetEntryPointModuleHandleHelper(LoadLibErrorTracker *pErrorTracker )
+    {
+        STANDARD_VM_CONTRACT;
+
+        NATIVE_LIBRARY_HANDLE hmod = NULL;
+
+#ifndef TARGET_UNIX
+        hmod = GetModuleHandleW(NULL);
+
+#else // !TARGET_UNIX
+        hmod = PAL_LoadLibraryDirect(NULL);
+#endif // !TARGET_UNIX
+
+        if (hmod == NULL)
+        {
+            pErrorTracker->TrackErrorCode();
+        }
+
+        return hmod;
+    }
+
     // DllImportSearchPathFlags is a special enumeration, whose values are tied closely with LoadLibrary flags.
     // There is no "default" value DllImportSearchPathFlags. In the absence of DllImportSearchPath attribute,
     // CoreCLR's LoadLibrary implementation uses the following defaults.
@@ -907,3 +929,23 @@ NATIVE_LIBRARY_HANDLE NativeLibrary::LoadLibraryFromMethodDesc(NDirectMethodDesc
 
     RETURN hmod;
 }
+
+NATIVE_LIBRARY_HANDLE NativeLibrary::GetEntryPointModuleHandle()
+{
+    CONTRACT(NATIVE_LIBRARY_HANDLE)
+    {
+        STANDARD_VM_CHECK;
+        POSTCONDITION(RETVAL != NULL);
+    }
+    CONTRACT_END;
+
+    LoadLibErrorTracker errorTracker;
+    NATIVE_LIBRARY_HANDLE hmod = GetEntryPointModuleHandleHelper(&errorTracker);
+    if (hmod == NULL)
+    {
+        StackSString ssLibName(SString::Utf8, "Entry Point Handle");
+        errorTracker.Throw(ssLibName);
+    }
+
+    RETURN hmod;
+}

src/coreclr/vm/nativelibrary.h

@@ -17,6 +17,8 @@ class NativeLibrary
     static INT_PTR GetNativeLibraryExport(NATIVE_LIBRARY_HANDLE handle, LPCWSTR symbolName, BOOL throwOnError);
 
     static NATIVE_LIBRARY_HANDLE LoadLibraryFromMethodDesc(NDirectMethodDesc *pMD);
+
+    static NATIVE_LIBRARY_HANDLE GetEntryPointModuleHandle();
 };
 
 #endif // _NATIVELIBRARY_H_

src/coreclr/vm/nativelibrarynative.cpp

@@ -71,3 +71,18 @@ INT_PTR QCALLTYPE NativeLibraryNative::GetSymbol(INT_PTR handle, LPCWSTR symbolN
     return address;
 }
 
+//static
+INT_PTR QCALLTYPE NativeLibraryNative::GetEntryPointModuleHandle()
+{
+    QCALL_CONTRACT;
+
+    NATIVE_LIBRARY_HANDLE handle = NULL;
+
+    BEGIN_QCALL;
+
+    handle = NativeLibrary::GetEntryPointModuleHandle();
+
+    END_QCALL;
+
+    return reinterpret_cast<INT_PTR>(handle);
+}

src/coreclr/vm/nativelibrarynative.h

@@ -19,7 +19,7 @@ class NativeLibraryNative
                                                BOOL throwOnError);
     static void QCALLTYPE FreeLib(INT_PTR handle);
     static INT_PTR QCALLTYPE GetSymbol(INT_PTR handle, LPCWSTR symbolName, BOOL throwOnError);
-
+    static INT_PTR QCALLTYPE GetEntryPointModuleHandle();
 };
 
 #endif // __NATIVELIBRARYNATIVE_H__

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.ComponentModel;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Threading;
@@ -256,5 +257,24 @@ internal static IntPtr LoadLibraryCallbackStub(string libraryName, Assembly asse
 
             return resolver(libraryName, assembly, hasDllImportSearchPathFlags ? (DllImportSearchPath?)dllImportSearchPathFlags : null);
         }
+
+        [DllImport(RuntimeHelpers.QCall, SetLastError = true)]
+        private static extern IntPtr GetEntryPointModuleHandleInternal();
+
+        /// <summary>
+        /// Get a handle that can be used with <see cref="GetExport" /> or <see cref="TryGetExport" /> to resolve exports from the entry point module.
+        /// </summary>
+        /// <returns> The handle that can be used to resolve exports from the entry point module.</returns>
+        public static IntPtr GetEntryPointModuleHandle()
+        {
+            IntPtr result = GetEntryPointModuleHandleInternal();
+            // I don't know when a failure case can occur here, but checking for it and throwing an exception
+            // if we encounter it.
+            if (result == IntPtr.Zero)
+            {
+                Marshal.ThrowExceptionForHR(Marshal.GetLastPInvokeError());
+            }
+            return result;
+        }
     }
 }

src/libraries/System.Runtime.InteropServices/ref/System.Runtime.InteropServices.cs

@@ -753,6 +753,7 @@ public MarshalDirectiveException(string? message, System.Exception? inner) { }
     public static partial class NativeLibrary
     {
         public static void Free(System.IntPtr handle) { }
+        public static System.IntPtr GetEntryPointModuleHandle() { throw null; }
         public static System.IntPtr GetExport(System.IntPtr handle, string name) { throw null; }
         public static System.IntPtr Load(string libraryPath) { throw null; }
         public static System.IntPtr Load(string libraryName, System.Reflection.Assembly assembly, System.Runtime.InteropServices.DllImportSearchPath? searchPath) { throw null; }

src/mono/mono/metadata/native-library-qcall.c

@@ -16,15 +16,33 @@ enum {
     func_flag_end_of_array = 0x01,
     func_flag_has_signature = 0x02,
     func_flag_unreferenced = 0x04, // Suppress unused fcall check
-    func_flag_qcall = 0x08, // QCall - mscorlib.dll to mscorwks.dll transition implemented as PInvoke
+    func_flag_qcall = 0x08, // QCall - System.Private.CoreLib.dll to native runtime transition implemented as PInvoke
 };
 
+#ifndef DISABLE_QCALLS
+    #define FCFuncStart(name) static const MonoQCallFunc name[] = {
+    #define FCFuncEnd() { func_flag_end_of_array, NULL, NULL }  };
+    #define QCFuncElement(name,impl) { func_flag_qcall, (void*)(impl), name },
+    #define FCClassElement(name, namespace, funcs)
+    #include "mono/metadata/qcall-def.h"
+    #undef FCClassElement
+    #undef QCFuncElement
+    #undef FCFuncEnd
+    #undef FCFuncStart
+#endif
+
 static const MonoQCallDef c_qcalls[] =
 {
 #ifndef DISABLE_QCALLS
+    #define FCFuncStart(name)
+    #define FCFuncEnd()
+    #define QCFuncElement(name,impl)
     #define FCClassElement(name,namespace,funcs) {name, namespace, funcs},
     #include "mono/metadata/qcall-def.h"
     #undef FCClassElement
+    #undef QCFuncElement
+    #undef FCFuncEnd
+    #undef FCFuncStart
 #endif
 };
 

src/mono/mono/metadata/native-library.c

@@ -756,6 +756,21 @@ netcore_check_alc_cache (MonoAssemblyLoadContext *alc, const char *scope)
 	return result;
 }
 
+MonoDl*
+netcore_lookup_self_native_handle()
+{
+	char *error_msg = NULL;
+	if (!internal_module)
+		internal_module = mono_dl_open_self (&error_msg);
+
+	if (!internal_module) {
+		mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT, "DllImport error loading library '__Internal': '%s'.", error_msg);
+		g_free (error_msg);
+	}
+	mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_DLLIMPORT, "Native library found via __Internal.");
+	return internal_module;
+}
+
 static MonoDl *
 netcore_lookup_native_library (MonoAssemblyLoadContext *alc, MonoImage *image, const char *scope, guint32 flags)
 {
@@ -770,18 +785,7 @@ netcore_lookup_native_library (MonoAssemblyLoadContext *alc, MonoImage *image, c
 
 	// We allow a special name to dlopen from the running process namespace, which is not present in CoreCLR
 	if (strcmp (scope, "__Internal") == 0) {
-		if (!internal_module)
-			internal_module = mono_dl_open_self (&error_msg);
-		module = internal_module;
-
-		if (!module) {
-			mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT, "DllImport error loading library '__Internal': '%s'.", error_msg);
-			g_free (error_msg);
-		}
-
-		mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_DLLIMPORT, "Native library found via __Internal: '%s'.", scope);
-
-		return module;
+		return netcore_lookup_self_native_handle();
 	}
 
 	/*

src/mono/mono/metadata/native-library.h

@@ -48,4 +48,6 @@ typedef struct MonoQCallFunc {
 void
 mono_loader_install_pinvoke_override (PInvokeOverrideFn override_fn);
 
+MonoDl*
+netcore_lookup_self_native_handle();
 #endif

src/mono/mono/metadata/qcall-def.h

@@ -12,4 +12,8 @@
  * have to end with a func_flag_end_of_array (0x01) entry.
  **/
 
-FCClassElement("", "", NULL)
+FCFuncStart(gInteropNativeLibraryFuncs)
+	QCFuncElement("GetEntryPointModuleHandleInternal", netcore_lookup_self_native_handle)
+FCFuncEnd()
+
+FCClassElement("NativeLibary", "System.Runtime.InteropServices", gInteropNativeLibraryFuncs)

src/tests/Interop/NativeLibrary/API/NativeLibraryTests.cs

@@ -179,6 +179,11 @@ public static int Main()
             success &= EXPECT(TryGetLibraryExport(handle, "NonNativeSum"), TestResult.ReturnFailure);
 
             NativeLibrary.Free(handle);
+
+            // -----------------------------------------------
+            //         GetLibraryExport Tests
+            // -----------------------------------------------
+            success &= EXPECT(GetEntryPointModuleHandle());
         }
         catch (Exception e)
         {
@@ -365,6 +370,21 @@ static TestResult TryGetLibraryExport(IntPtr handle, string name)
         });
     }
 
+    static TestResult GetEntryPointModuleHandle()
+    {
+        CurrentTest = nameof(GetEntryPointModuleHandle);
+        return Run(() => {
+            IntPtr moduleHandle = NativeLibrary.GetEntryPointModuleHandle();
+            // Get a well-known export name from corerun to validate that we have a valid handle.
+            bool success = NativeLibrary.TryGetExport(moduleHandle, "GetCurrentClrDetails", out IntPtr address);
+            if (!success)
+                return TestResult.ReturnFailure;
+            if (address == IntPtr.Zero)
+                return TestResult.ReturnNull;
+            return TestResult.Success;
+        });
+    }
+
     [DllImport(NativeLibraryToLoad.Name)]
     static extern int RunExportedFunction(IntPtr address, int arg1, int arg2);
 }