Split dummydll into 4 separate output formats (#266)

Cpp2IL.Core/Cpp2IlCorePlugin.cs

@@ -41,7 +41,11 @@ public override void OnLoad()
 
         Logger.VerboseNewline("\tRegistering built-in output formats...", "Core Plugin");
 
-        OutputFormatRegistry.Register<AsmResolverDummyDllOutputFormat>();
+        OutputFormatRegistry.Register<AsmResolverDllOutputFormatLegacy>();
+        OutputFormatRegistry.Register<AsmResolverDllOutputFormatDefault>();
+        OutputFormatRegistry.Register<AsmResolverDllOutputFormatEmpty>();
+        OutputFormatRegistry.Register<AsmResolverDllOutputFormatThrowNull>();
+        OutputFormatRegistry.Register<AsmResolverDllOutputFormatIlRecovery>();
         OutputFormatRegistry.Register<DiffableCsOutputFormat>();
         OutputFormatRegistry.Register<IsilDumpOutputFormat>();
         OutputFormatRegistry.Register<WasmMappingOutputFormat>();
@@ -58,4 +62,10 @@ public override void OnLoad()
         var elapsed = DateTime.Now - start;
         Logger.VerboseNewline($"Core plugin loaded in {elapsed.Ticks} ticks ({elapsed.TotalMilliseconds}ms)", "Core Plugin");
     }
+
+    private sealed class AsmResolverDllOutputFormatLegacy : AsmResolverDllOutputFormatDefault
+    {
+        public override string OutputFormatId => "dummydll";
+        public override string OutputFormatName => "DLL output format for backwards compatibility.";
+    }
 }

Cpp2IL.Core/OutputFormats/AsmResolverDllOutputFormatDefault.cs

@@ -0,0 +1,17 @@
+using AsmResolver.DotNet;
+using AssetRipper.CIL;
+using Cpp2IL.Core.Model.Contexts;
+
+namespace Cpp2IL.Core.OutputFormats;
+
+public class AsmResolverDllOutputFormatDefault : AsmResolverDllOutputFormat
+{
+    public override string OutputFormatId => "dll_default";
+
+    public override string OutputFormatName => "DLL files with default method bodies";
+
+    protected override void FillMethodBody(MethodDefinition methodDefinition, MethodAnalysisContext methodContext)
+    {
+        methodDefinition.FillMethodBodyWithStub();
+    }
+}

Cpp2IL.Core/OutputFormats/AsmResolverDllOutputFormatEmpty.cs

@@ -0,0 +1,18 @@
+using AsmResolver.DotNet;
+using Cpp2IL.Core.Model.Contexts;
+using Cpp2IL.Core.Utils.AsmResolver;
+
+namespace Cpp2IL.Core.OutputFormats;
+
+public class AsmResolverDllOutputFormatEmpty : AsmResolverDllOutputFormat
+{
+    public override string OutputFormatId => "dll_empty";
+
+    public override string OutputFormatName => "DLL files with empty method bodies";
+
+    protected override void FillMethodBody(MethodDefinition methodDefinition, MethodAnalysisContext methodContext)
+    {
+        if (methodDefinition.IsManagedMethodWithBody())
+            methodDefinition.CilMethodBody = new(methodDefinition);
+    }
+}

Cpp2IL.Core/OutputFormats/AsmResolverDllOutputFormatIlRecovery.cs

@@ -0,0 +1,24 @@
+using AsmResolver.DotNet;
+using AsmResolver.PE.DotNet.Cil;
+using Cpp2IL.Core.Model.Contexts;
+using Cpp2IL.Core.Utils.AsmResolver;
+
+namespace Cpp2IL.Core.OutputFormats;
+
+public class AsmResolverDllOutputFormatIlRecovery : AsmResolverDllOutputFormat
+{
+    public override string OutputFormatId => "dll_il_recovery";
+
+    public override string OutputFormatName => "DLL files with IL Recovery";
+
+    protected override void FillMethodBody(MethodDefinition methodDefinition, MethodAnalysisContext methodContext)
+    {
+        if (methodDefinition.IsManagedMethodWithBody())
+        {
+            methodDefinition.CilMethodBody = new(methodDefinition);
+            var instructions = methodDefinition.CilMethodBody.Instructions;
+            instructions.Add(CilOpCodes.Ldnull);
+            instructions.Add(CilOpCodes.Throw);
+        }
+    }
+}

Cpp2IL.Core/OutputFormats/AsmResolverDllOutputFormatThrowNull.cs

@@ -0,0 +1,24 @@
+using AsmResolver.DotNet;
+using AsmResolver.PE.DotNet.Cil;
+using Cpp2IL.Core.Model.Contexts;
+using Cpp2IL.Core.Utils.AsmResolver;
+
+namespace Cpp2IL.Core.OutputFormats;
+
+public class AsmResolverDllOutputFormatThrowNull : AsmResolverDllOutputFormat
+{
+    public override string OutputFormatId => "dll_throw_null";
+
+    public override string OutputFormatName => "DLL files with method bodies containing throw null";
+
+    protected override void FillMethodBody(MethodDefinition methodDefinition, MethodAnalysisContext methodContext)
+    {
+        if (methodDefinition.IsManagedMethodWithBody())
+        {
+            methodDefinition.CilMethodBody = new(methodDefinition);
+            var instructions = methodDefinition.CilMethodBody.Instructions;
+            instructions.Add(CilOpCodes.Ldnull);
+            instructions.Add(CilOpCodes.Throw);
+        }
+    }
+}

Cpp2IL.Core/OutputFormats/AsmResolverDummyDllOutputFormat.cs

@@ -18,20 +18,16 @@
 
 namespace Cpp2IL.Core.OutputFormats;
 
-public class AsmResolverDummyDllOutputFormat : Cpp2IlOutputFormat
+public abstract class AsmResolverDllOutputFormat : Cpp2IlOutputFormat
 {
-    public override string OutputFormatId => "dummydll";
-
-    public override string OutputFormatName => "Stub (\"Dummy\") DLL Files";
-
     private AssemblyDefinition? MostRecentCorLib { get; set; }
 
-    public override void DoOutput(ApplicationAnalysisContext context, string outputRoot)
+    public sealed override void DoOutput(ApplicationAnalysisContext context, string outputRoot)
     {
         var ret = BuildAssemblies(context);
 
         var start = DateTime.Now;
-        Logger.Verbose("Generating PE images...", "DummyDllOutput");
+        Logger.Verbose("Generating PE images...", "DllOutput");
 
         if (!Directory.Exists(outputRoot))
             Directory.CreateDirectory(outputRoot);
@@ -42,10 +38,10 @@ public override void DoOutput(ApplicationAnalysisContext context, string outputR
             .Select(a => (image: a.ManifestModule!.ToPEImage(new ManagedPEImageBuilder()), name: a.ManifestModule.Name!))
             .ToList();
 
-        Logger.VerboseNewline($"{(DateTime.Now - start).TotalMilliseconds:F1}ms", "DummyDllOutput");
+        Logger.VerboseNewline($"{(DateTime.Now - start).TotalMilliseconds:F1}ms", "DllOutput");
 
         start = DateTime.Now;
-        Logger.Verbose("Building and writing managed PE files to disk...", "DummyDllOutput");
+        Logger.Verbose("Building and writing managed PE files to disk...", "DllOutput");
 
         //Save them
         var fileBuilder = new ManagedPEFileBuilder();
@@ -55,7 +51,7 @@ public override void DoOutput(ApplicationAnalysisContext context, string outputR
             fileBuilder.CreateFile(image).Write(dllPath);
         }
 
-        Logger.VerboseNewline($"{(DateTime.Now - start).TotalMilliseconds:F1}ms", "DummyDllOutput");
+        Logger.VerboseNewline($"{(DateTime.Now - start).TotalMilliseconds:F1}ms", "DllOutput");
     }
 
     public List<AssemblyDefinition> BuildAssemblies(ApplicationAnalysisContext context)
@@ -72,46 +68,76 @@ public List<AssemblyDefinition> BuildAssemblies(ApplicationAnalysisContext conte
         //Build the stub assemblies
         var start = DateTime.Now;
 #if VERBOSE_LOGGING
-        Logger.Verbose($"Building stub assemblies ({asmCount} assemblies, {typeCount} types)...", "DummyDllOutput");
+        Logger.Verbose($"Building stub assemblies ({asmCount} assemblies, {typeCount} types)...", "DllOutput");
 #else
-        Logger.Verbose($"Building stub assemblies...", "DummyDllOutput");
+        Logger.Verbose($"Building stub assemblies...", "DllOutput");
 #endif
         List<AssemblyDefinition> ret = BuildStubAssemblies(context);
-        Logger.VerboseNewline($"{(DateTime.Now - start).TotalMilliseconds:F1}ms", "DummyDllOutput");
+        Logger.VerboseNewline($"{(DateTime.Now - start).TotalMilliseconds:F1}ms", "DllOutput");
 
         start = DateTime.Now;
-        Logger.Verbose("Configuring inheritance and generics...", "DummyDllOutput");
+        Logger.Verbose("Configuring inheritance and generics...", "DllOutput");
 
         Parallel.ForEach(context.Assemblies, AsmResolverAssemblyPopulator.ConfigureHierarchy);
 
-        Logger.VerboseNewline($"{(DateTime.Now - start).TotalMilliseconds:F1}ms", "DummyDllOutput");
+        Logger.VerboseNewline($"{(DateTime.Now - start).TotalMilliseconds:F1}ms", "DllOutput");
 
         //Populate them
         start = DateTime.Now;
 
 #if VERBOSE_LOGGING
-        Logger.Verbose($"Adding {fieldCount} fields, {methodCount} methods, {propertyCount} properties, and {eventCount} events (in parallel)...", "DummyDllOutput");
+        Logger.Verbose($"Adding {fieldCount} fields, {methodCount} methods, {propertyCount} properties, and {eventCount} events (in parallel)...", "DllOutput");
 #else
-        Logger.Verbose($"Adding fields, methods, properties, and events (in parallel)...", "DummyDllOutput");
+        Logger.Verbose($"Adding fields, methods, properties, and events (in parallel)...", "DllOutput");
 #endif
 
         MiscUtils.ExecuteParallel(context.Assemblies, AsmResolverAssemblyPopulator.CopyDataFromIl2CppToManaged);
-        MiscUtils.ExecuteParallel(context.Assemblies, AsmResolverMethodFiller.FillManagedMethodBodies);
+        MiscUtils.ExecuteParallel(context.Assemblies, FillMethodBodies);
 
-        Logger.VerboseNewline($"{(DateTime.Now - start).TotalMilliseconds:F1}ms", "DummyDllOutput");
+        Logger.VerboseNewline($"{(DateTime.Now - start).TotalMilliseconds:F1}ms", "DllOutput");
 
         //Populate custom attributes
         start = DateTime.Now;
-        Logger.Verbose("Adding custom attributes to all of the above...", "DummyDllOutput");
+        Logger.Verbose("Adding custom attributes to all of the above...", "DllOutput");
         MiscUtils.ExecuteParallel(context.Assemblies, AsmResolverAssemblyPopulator.PopulateCustomAttributes);
 
-        Logger.VerboseNewline($"{(DateTime.Now - start).TotalMilliseconds:F1}ms", "DummyDllOutput");
+        Logger.VerboseNewline($"{(DateTime.Now - start).TotalMilliseconds:F1}ms", "DllOutput");
 
         TypeDefinitionsAsmResolver.Reset();
 
         return ret;
     }
 
+    protected abstract void FillMethodBody(MethodDefinition methodDefinition, MethodAnalysisContext methodContext);
+
+    protected virtual void FillMethodBodies(AssemblyAnalysisContext context)
+    {
+        foreach (var typeContext in context.Types)
+        {
+            if (AsmResolverAssemblyPopulator.IsTypeContextModule(typeContext))
+                continue;
+
+#if !DEBUG
+            try
+#endif
+            {
+                foreach (var methodCtx in typeContext.Methods)
+                {
+                    var managedMethod = methodCtx.GetExtraData<MethodDefinition>("AsmResolverMethod") ?? throw new($"AsmResolver method not found in method analysis context for {typeContext.Definition?.FullName}.{methodCtx.Definition?.Name}");
+
+                    FillMethodBody(managedMethod, methodCtx);
+                }
+            }
+#if !DEBUG
+            catch (System.Exception e)
+            {
+                var managedType = typeContext.GetExtraData<TypeDefinition>("AsmResolverType") ?? throw new($"AsmResolver type not found in type analysis context for {typeContext.Definition?.FullName}");
+                throw new($"Failed to process type {managedType.FullName} (module {managedType.Module?.Name}, declaring type {managedType.DeclaringType?.FullName}) in {context.Definition.AssemblyName.Name}", e);
+            }
+#endif
+        }
+    }
+
     private List<AssemblyDefinition> BuildStubAssemblies(ApplicationAnalysisContext context)
     {
         var assemblyResolver = new Il2CppAssemblyResolver();