Fixed Initialization Issues with native Mono and Il2Cpp games on Linux

Author: HerpDerpinstine

MelonLoader.Bootstrap/MelonLoader.Bootstrap.csproj

@@ -64,7 +64,6 @@
 
     <ItemGroup>
         <Compile Include="$(SolutionDir)/MelonLoader/LoaderConfig.cs" />
-        <Compile Include="..\MelonLoader\NativeUtils\NativeHooks.cs" Link="NativeHooks.cs" />
     </ItemGroup>
 
     <ItemGroup Condition="'$(RuntimeIdentifier.StartsWith(`osx-`))' == 'true'">

MelonLoader.Bootstrap/ModuleSymbolRedirect.cs

@@ -30,6 +30,7 @@ internal static void Attach()
                 ("dlsym", detourPtr)
             ]);
 #endif
+
 #if WINDOWS
             PltHook.InstallHooks
             ([
@@ -40,59 +41,58 @@ internal static void Attach()
             MelonDebug.Log("Symbol Redirect Attached!");
         }
 
-        internal static nint GetSymbol(nint handle, string symbolName)
-            => GetSymbol(handle, Marshal.StringToHGlobalAnsi(symbolName));
-        internal static nint GetSymbol(nint handle, nint symbolName)
+        internal static nint GetSymbol(nint handle, string? symbol)
         {
             if ((handle == nint.Zero)
-                || (symbolName == nint.Zero))
+                || string.IsNullOrEmpty(symbol))
                 return nint.Zero;
 
+            // Herp: Using Prebuilt Interop classes for this caused weird crashing issues when attempting to marshal string to span
+            // This works around the issue by manually importing the appropriate original export into a delegate and then calling original using that instead
 #if WINDOWS
-            return GetProcAddress(handle, symbolName);
+            return WindowsNative.GetProcAddress(handle, symbol);
 #elif LINUX || OSX
-            return dlsym(handle, symbolName);
+            return LibcNative.Dlsym(handle, symbol);
 #else
             return nint.Zero;
 #endif
         }
+        internal static nint GetSymbol(nint handle, nint symbol)
+        {
+            if ((handle == nint.Zero) 
+                || (symbol == nint.Zero))
+                return nint.Zero;
+
+            return GetSymbol(handle, Marshal.PtrToStringAnsi(symbol));
+        }
 
         private static nint SymbolDetour(nint handle, nint symbol)
         {
-            nint originalSymbolAddress = GetSymbol(handle, symbol);
-
             string? symbolName = Marshal.PtrToStringAnsi(symbol);
             if (string.IsNullOrEmpty(symbolName)
                 || string.IsNullOrWhiteSpace(symbolName))
-                return originalSymbolAddress;
+                return nint.Zero;
+
+            nint originalSymbolAddress = GetSymbol(handle, symbolName);
+            if (originalSymbolAddress == nint.Zero)
+                return nint.Zero;
 
-            //MelonDebug.Log($"Looking for Symbol {symbolName}");
+            MelonDebug.Log($"Looking for Symbol {symbolName}");
             if (!MonoHandler.SymbolRedirects.TryGetValue(symbolName, out var redirect)
                 && !Il2CppHandler.SymbolRedirects.TryGetValue(symbolName, out redirect))
                 return originalSymbolAddress;
 
             if (!_runtimeInitialised)
             {
-                _runtimeInitialised = true;
-                MelonDebug.Log("Initializing Runtime");
+                MelonDebug.Log("Init");
                 redirect.InitMethod(handle);
                 if (!LoaderConfig.Current.Loader.CapturePlayerLogs)
                     ConsoleHandler.ResetHandles();
             }
+            _runtimeInitialised = true;
 
             MelonDebug.Log($"Redirecting {symbolName}");
             return redirect.detourPtr;
         }
-
-#if WINDOWS
-        [DllImport("kernel32")]
-        private static extern nint GetProcAddress(nint handle, nint symbol);
-#elif LINUX
-        [DllImport("libdl.so.2")]
-        private static extern IntPtr dlsym(nint handle, nint symbol);
-#elif OSX
-        [DllImport("libSystem.B.dylib")]
-        private static extern IntPtr dlsym(nint handle, nint symbol);
-#endif
     }
-}
+}

MelonLoader.Bootstrap/RuntimeHandlers/Il2Cpp/Dotnet.cs

@@ -81,7 +81,7 @@ public static bool InitializeForRuntimeConfig(string runtimeConfigPath, out nint
 
         if (status != 0)
         {
-            context = 0;
+            context = status;
             return false;
         }
 

MelonLoader.Bootstrap/RuntimeHandlers/Il2Cpp/Il2CppHandler.cs

@@ -111,10 +111,9 @@ private static void InitializeManaged()
 
     internal static nint InvokeDetour(nint method, nint obj, nint args, nint exc)
     {
-        if (invokeStarted)
-            return il2cpp.RuntimeInvoke(method, obj, args, exc);
-
         var result = il2cpp.RuntimeInvoke(method, obj, args, exc);
+        if (invokeStarted)
+            return result;
 
         var name = il2cpp.GetMethodName(method);
         if (name == null || !name.Contains("Internal_ActiveSceneChanged"))
@@ -133,16 +132,6 @@ private static void Start()
         startFunc?.Invoke();
     }
 
-    private static unsafe void NativeHookAttachImpl(nint* target, nint detour)
-    {
-        *target = Dobby.HookAttach(*target, detour);
-    }
-
-    private static unsafe void NativeHookDetachImpl(nint* target, nint detour)
-    {
-        Dobby.HookDetach(*target);
-    }
-
     // Requires the bootstrap handle to be passed first
     private delegate void InitializeFn(ref nint startFunc);
-}
+}

MelonLoader/Core.cs

@@ -145,14 +145,12 @@ internal static int Initialize()
             Fixes.Il2CppInterop.Il2CppInteropExceptionLog.Install();
 
 #if OSX
-            Fixes.Il2CppInterop.Il2CppInteropMacFix.Install();
             Fixes.Dotnet.NativeLibraryFix.Install();
 #endif
 
             Fixes.Il2CppInterop.Il2CppInteropFixes.Install();
+            Fixes.Il2CppInterop.Il2CppInteropInjectorHelpersSetupFix.Install();
             Fixes.Il2CppInterop.Il2CppInteropGetFieldDefaultValueFix.Install();
-            Fixes.Il2CppInterop.Il2CppInteropGenericMethodGetMethodFix.Install();
-
             Fixes.Il2CppInterop.Il2CppICallInjector.Install();
 
 #endif
@@ -211,8 +209,8 @@ internal static bool Start()
             if (!SupportModule.Setup())
                 return false;
 
-            //MelonDebug.Msg("Invoking AddUnityDebugLog");
-            //AddUnityDebugLog();
+            MelonDebug.Msg("Invoking AddUnityDebugLog");
+            AddUnityDebugLog();
 
 #if NET6_0_OR_GREATER
             RegisterTypeInIl2Cpp.SetReady();

MelonLoader/Fixes/Il2CppInterop/Il2CppInteropGenericMethodGetMethodFix.cs

@@ -0,0 +1,129 @@
+#if NET6_0_OR_GREATER
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Reflection.Emit;
+using HarmonyLib;
+using Il2CppInterop.Runtime.Injection;
+using MelonLoader.InternalUtils;
+
+namespace MelonLoader.Fixes.Il2CppInterop
+{
+    // Herp: This fixes an XRef issue with Il2CppInterop's GenericMethod::GetMethod Hook on some Unity Builds
+    // Unity 2020.3.x
+    // Unity 6000.x.x+
+    internal static class Il2CppInteropInjectorHelpersSetupFix
+    {
+        private static Type _injectorType;
+        private static MethodInfo _setupMethod;
+        private static MethodInfo _setupPatch;
+        
+        internal static void Install()
+        {
+            try
+            {
+                Type thisType = typeof(Il2CppInteropInjectorHelpersSetupFix);
+                
+                _injectorType = typeof(ClassInjector).Assembly.GetType("Il2CppInterop.Runtime.Injection.InjectorHelpers", false);
+                if (_injectorType == null)
+                    throw new Exception($"Failed to get InjectorHelpers");
+
+                _setupMethod = _injectorType.GetMethod("Setup", BindingFlags.NonPublic | BindingFlags.Static);
+                if (_setupMethod == null)
+                    throw new Exception("Failed to get InjectorHelpers.Setup");
+
+                _setupPatch = thisType.GetMethod(nameof(Setup_Transpiler), BindingFlags.NonPublic | BindingFlags.Static);
+                MelonDebug.Msg($"Patching Il2CppInterop InjectorHelpers.Setup...");
+                Core.HarmonyInstance.Patch(_setupMethod,
+                    null,
+                    null,
+                    new HarmonyMethod(_setupPatch));
+            }
+            catch (Exception e)
+            {
+                MelonLogger.Error(e);
+            }
+        }
+        
+        private static bool ShouldUseNewHook()
+        {
+            if (UnityInformationHandler.EngineVersion.Major >= 6000)
+                return true;
+
+            if ((UnityInformationHandler.EngineVersion.Major == 2020)
+                && (UnityInformationHandler.EngineVersion.Minor == 3)
+                && (UnityInformationHandler.EngineVersion.Build >= 48))
+                return true;
+
+            if ((UnityInformationHandler.EngineVersion.Major == 2022)
+                && (UnityInformationHandler.EngineVersion.Minor == 3)
+                && (UnityInformationHandler.EngineVersion.Build >= 62))
+                return true;
+
+            return false;
+        }
+
+        private static IEnumerable<CodeInstruction> Setup_Transpiler(IEnumerable<CodeInstruction> instructions)
+        {
+#if OSX
+            // This hook isn't reliable on macOS due to potential inlining by the player's compiler resulting in il2cppinterop
+            // thinking it found the right function, but it actually found one that takes a pointer which it would then incorrectly hook
+            // resulting in a crash. While it can hinder class injection functionality, it isn't needed for the game to boot,
+            // and it didn't prevent UnityExplorer to function
+            instructions = RemoveHookCall("GetTypeInfoFromTypeDefinitionIndexHook", instructions);
+#endif
+            
+            if (!ShouldUseNewHook())
+                return instructions;
+            
+            instructions = ReplaceGenericMethodGetMethodHook(instructions);
+            
+#if LINUX
+            instructions = RemoveHookCall("GetFieldDefaultValueHook", instructions);
+#endif
+
+            return instructions;
+        }
+        
+        private static IEnumerable<CodeInstruction> ReplaceGenericMethodGetMethodHook(IEnumerable<CodeInstruction> instructions)
+        {
+            var codeMatcher = new CodeMatcher(instructions);
+            codeMatcher.MatchStartForward([
+                new(i => i.LoadsField(AccessTools.Field(_injectorType, "GenericMethodGetMethodHook")))
+            ]).Operand = AccessTools.Field(_injectorType, "GenericMethodGetMethodHook_Unity6");
+            return codeMatcher.InstructionEnumeration();
+        }
+        
+        private static IEnumerable<CodeInstruction> RemoveHookCall(string hookFieldName, IEnumerable<CodeInstruction> instructions)
+        {
+            var field = AccessTools.Field(_injectorType, hookFieldName);
+
+            var matcher = new CodeMatcher(instructions);
+
+            matcher.MatchStartForward(
+                new CodeMatch(i => i.LoadsField(field))
+            );
+
+            if (!matcher.IsValid)
+                return instructions;
+
+            // Capture labels from the first instruction being removed
+            var labels = matcher.Instruction.labels;
+
+            // Move to next instruction AFTER the removed block
+            matcher.Advance(2);
+
+            // Reattach labels so branches still work
+            matcher.Instruction.labels.AddRange(labels);
+
+            // Go back and remove the original instructions
+            matcher.Advance(-2);
+            matcher.RemoveInstructions(2);
+
+            return matcher.InstructionEnumeration();
+        }
+    }
+}
+
+#endif