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)
+extern "C" DLL_EXPORT 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,17 +308,25 @@ 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 CDECL
 #define MAIN main
 #define W(str) str
-#define FAILED(result) (result < 0)
-
+#define S_OK 0
+#define FAILED(result) (result < S_OK)
 #if !HAVE_DIRENT_D_TYPE
 #define DT_UNKNOWN 0
 #define DT_DIR 4
 #define DT_REG 8
 #define DT_LNK 10
 #endif
 
+typedef int HRESULT;
+
 namespace pal
 {
     using char_t = char;
@@ -573,7 +582,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/nativelibrarynative.cpp

@@ -70,4 +70,3 @@ INT_PTR QCALLTYPE NativeLibraryNative::GetSymbol(INT_PTR handle, LPCWSTR symbolN
 
     return address;
 }
-

src/coreclr/vm/nativelibrarynative.h

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

src/libraries/Common/src/Interop/Unix/System.Native/Interop.Dl.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.InteropServices;
+using Microsoft.Win32.SafeHandles;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetDefaultSearchOrderPseudoHandle", SetLastError = true)]
+        internal static extern IntPtr GetDefaultSearchOrderPseudoHandle();
+    }
+}

src/libraries/Native/Unix/System.Native/CMakeLists.txt

@@ -11,6 +11,7 @@ endif ()
 include_directories("${CLR_SRC_NATIVE_DIR}/common")
 
 set(NATIVE_SOURCES
+    pal_dl.c
     pal_errno.c
     pal_interfaceaddresses.c
     pal_io.c

src/libraries/Native/Unix/System.Native/entrypoints.c

@@ -7,6 +7,7 @@
 #include "pal_autoreleasepool.h"
 #include "pal_console.h"
 #include "pal_datetime.h"
+#include "pal_dl.h"
 #include "pal_errno.h"
 #include "pal_interfaceaddresses.h"
 #include "pal_io.h"
@@ -257,6 +258,7 @@ static const Entry s_sysNative[] =
     DllImportEntry(SystemNative_SetPosixSignalHandler)
     DllImportEntry(SystemNative_GetPlatformSignalNumber)
     DllImportEntry(SystemNative_GetGroups)
+    DllImportEntry(SystemNative_GetDefaultSearchOrderPseudoHandle)
 };
 
 EXTERN_C const void* SystemResolveDllImport(const char* name);

src/libraries/Native/Unix/System.Native/pal_dl.c

@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include "pal_dl.h"
+#include "dlfcn.h"
+#include <stdlib.h>
+
+#ifdef TARGET_ANDROID
+void* SystemNative_GetDefaultSearchOrderPseudoHandle(void)
+{
+    return (void*)RTLD_DEFAULT;
+}
+#else
+static void* g_defaultSearchOrderPseudoHandle = NULL;
+void* SystemNative_GetDefaultSearchOrderPseudoHandle(void)
+{
+    if (g_defaultSearchOrderPseudoHandle == NULL)
+    {
+        g_defaultSearchOrderPseudoHandle = dlopen(NULL, RTLD_LAZY);
+    }
+    return g_defaultSearchOrderPseudoHandle;
+}
+#endif

src/libraries/Native/Unix/System.Native/pal_dl.h

@@ -0,0 +1,8 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma once
+
+#include "pal_compiler.h"
+
+PALEXPORT void* SystemNative_GetDefaultSearchOrderPseudoHandle(void);

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -1792,6 +1792,9 @@
     <Compile Include="$(CommonPath)Interop\Windows\User32\Interop.USEROBJECTFLAGS.cs">
       <Link>Common\Interop\Windows\User32\Interop.USEROBJECTFLAGS.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetModuleHandle.cs">
+      <Link>Common\Interop\Windows\Kernel32\Interop.GetModuleHandle.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)System\IO\FileSystem.Attributes.Windows.cs">
       <Link>Common\System\IO\FileSystem.Attributes.Windows.cs</Link>
     </Compile>
@@ -1934,6 +1937,9 @@
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.CopyFile.cs">
       <Link>Common\Interop\Unix\System.Native\Interop.CopyFile.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Dl.cs">
+      <Link>Common\Interop\Unix\System.Native\Interop.Dl.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ErrNo.cs">
       <Link>Common\Interop\Unix\System.Native\Interop.ErrNo.cs</Link>
     </Compile>
@@ -2326,4 +2332,4 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IUnaryNegationOperators.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IUnaryPlusOperators.cs" />
   </ItemGroup>
-</Project>
+</Project>

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

@@ -256,5 +256,26 @@ internal static IntPtr LoadLibraryCallbackStub(string libraryName, Assembly asse
 
             return resolver(libraryName, assembly, hasDllImportSearchPathFlags ? (DllImportSearchPath?)dllImportSearchPathFlags : null);
         }
+
+        /// <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 = IntPtr.Zero;
+#if TARGET_WINDOWS
+            result = Interop.Kernel32.GetModuleHandle(null);
+#else
+            result = Interop.Sys.GetDefaultSearchOrderPseudoHandle();
+#endif
+            // 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.GetHRForLastWin32Error());
+            }
+            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,19 +16,40 @@ 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
+    { NULL, NULL, NULL }
 };
 
-const int c_nECClasses = sizeof (c_qcalls) / sizeof (c_qcalls[0]);
+// Number of actual entries in c_qcalls.
+// Subtract one to ignore the all-NULL entry at the end.
+const int c_nECClasses = (sizeof (c_qcalls) / sizeof (c_qcalls[0])) - 1;
 
 static gboolean is_end_of_array (MonoQCallFunc *func) { return !!((int)func->flags & func_flag_end_of_array); }
 static gboolean has_signature (MonoQCallFunc *func) { return !!((int)func->flags & func_flag_has_signature); }

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

@@ -756,6 +756,21 @@ netcore_check_alc_cache (MonoAssemblyLoadContext *alc, const char *scope)
 	return result;
 }
 
+static 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/qcall-def.h

@@ -8,8 +8,13 @@
  *  where symbol_name is an array of MonoQCallFunc.
  *
  * FCClassElements have to be sorted by name then namespace, 
- * but that the functions in each one can be in any order, but 
- * have to end with a func_flag_end_of_array (0x01) entry.
+ * but the functions in each one can be in any order, 
+ * specified by the QCFuncElement macro as follows:
+ *      FCFuncStart(class_symbol_name)
+ *            QCFuncElement(method_name, symbol_name)
+ *      FCFuncEnd()
+ * where class_symbol_name is the symbol for the corresponding
+ * class specified in FCClassElement, method_name is the name of the
+ * method on the managed side, and symbol_name is the name
+ * of the implementing method on the native side.
  **/
-
-FCClassElement("", "", NULL)

src/tests/Interop/NativeLibrary/API/NativeLibraryTests.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;
+using System.Diagnostics;
 using System.IO;
 using System.Reflection;
 using System.Runtime.InteropServices;
@@ -179,6 +180,27 @@ public static int Main()
             success &= EXPECT(TryGetLibraryExport(handle, "NonNativeSum"), TestResult.ReturnFailure);
 
             NativeLibrary.Free(handle);
+
+            // -----------------------------------------------
+            //         GetEntryPointModuleHandle Tests
+            // -----------------------------------------------
+
+            // Mobile test runs aren't hosted by corerun, so we don't have a well-known export to test here
+            if (IsHostedByCoreRun())
+            {
+                // Export from CoreRun host
+                success &= EXPECT(GetSymbolFromEntryPointModuleHandle("GetCurrentClrDetails"));
+                success &= EXPECT(GetSymbolFromEntryPointModuleHandle("NonExistentCoreRunExport"), TestResult.ReturnFailure);
+            }
+
+            handle = NativeLibrary.Load(libName);
+
+            // On non-Windows, the returned handle can load any global symbol,
+            // so try loading a symbol from the native test library.
+            success &= EXPECT(GetSymbolFromEntryPointModuleHandle(TestLibrary.Utilities.IsX86 ? "_NativeSum@8" : "NativeSum"), OperatingSystem.IsWindows() ? TestResult.ReturnFailure : TestResult.Success);
+            success &= EXPECT(GetSymbolFromEntryPointModuleHandle("NonNativeSum"), TestResult.ReturnFailure);
+
+            NativeLibrary.Free(handle);
         }
         catch (Exception e)
         {
@@ -192,6 +214,11 @@ public static int Main()
         return (success) ? 100 : -100;
     }
 
+    static bool IsHostedByCoreRun()
+    {
+        return Process.GetCurrentProcess().MainModule.ModuleName is "corerun" or "corerun.exe";
+    }
+
     static bool EXPECT(TestResult actualValue, TestResult expectedValue = TestResult.Success)
     {
         if (actualValue == expectedValue)
@@ -365,6 +392,20 @@ static TestResult TryGetLibraryExport(IntPtr handle, string name)
         });
     }
 
+    static TestResult GetSymbolFromEntryPointModuleHandle(string symbolToLoadFromHandle)
+    {
+        CurrentTest = nameof(GetSymbolFromEntryPointModuleHandle);
+        return Run(() => {
+            IntPtr moduleHandle = NativeLibrary.GetEntryPointModuleHandle();
+            bool success = NativeLibrary.TryGetExport(moduleHandle, symbolToLoadFromHandle, 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);
 }