30164692193

Committed 25 Jul 2026 03:58PM UTC coverage: 37.493% (-0.08%) from 37.57%

Build # 30164692193

Build Type

push

github

Committed by

SamboyCoding

Commit Message

Core: Fix dll_il_recovery being completely broken

Coverage Stats

2875 of 8614 branches covered (33.38%)

Branch coverage included in aggregate %.

5 of 9 new or added lines in 3 files covered. (55.56%)

6 existing lines in 3 files now uncovered.

5271 of 13113 relevant lines covered (40.2%)

168584.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.84

/Cpp2IL.Core/OutputFormats/AsmResolverDllOutputFormatIlRecovery.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using AsmResolver.DotNet;
using AsmResolver.DotNet.Signatures;
using AsmResolver.PE.DotNet.Cil;
using AssetRipper.CIL;
using Cpp2IL.Core.Extensions;
using Cpp2IL.Core.Graphs;
using Cpp2IL.Core.Logging;
using Cpp2IL.Core.Model.Contexts;
using Cpp2IL.Core.Utils;

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)
    {
        var module = methodDefinition.DeclaringModule!;
        var moduleName = module.Name!.ToString();
        var shouldSkip = moduleName.StartsWith("UnityEngine.") || moduleName.StartsWith("Unity.") ||
                         moduleName.StartsWith("System.") || moduleName == "System" ||
                         moduleName.StartsWith("mscorlib");
        var importer = new ReferenceImporter(module);

        if (!methodDefinition.IsManagedMethodWithBody())
            return;

        methodDefinition.CilMethodBody = new();
        var instructions = methodDefinition.CilMethodBody.Instructions;

        if (shouldSkip)
        {
            methodDefinition.ReplaceMethodBodyWithMinimalImplementation();
            return;
        }

        try
        {
            TotalMethodCount++;

            methodContext.Analyze();

            if (methodContext.ConvertedIsil.Count == 0)
                methodDefinition.ReplaceMethodBodyWithMinimalImplementation();
            else
                IlGenerator.GenerateIl(methodContext, methodDefinition);

            //WriteControlFlowGraph(methodContext, Path.Combine(Environment.CurrentDirectory, "Cpp2IL", "bin", "Debug", "net9.0", "cpp2il_out", "cfg"));

            SuccessfulMethodCount++;
        }
        catch (Exception e)
        {
            // Known analysis limitations (DecompilerException) get a one-line warning; anything
            // else is an unexpected bug and keeps its (collapsed) stack trace.
            var detail = e is DecompilerException ? e.Message : e.ToCollapsedString();

            if (e is DecompilerException)
                Logger.WarnNewline($"Skipping {methodContext.FullName}: {e.Message}");
            else
                Logger.ErrorNewline($"Decompiling {methodContext.FullName} failed: {detail}");
            
            methodDefinition.CilMethodBody = new();
            instructions = methodDefinition.CilMethodBody.Instructions;

            var factory = module.CorLibTypeFactory;
            var exceptionCtor = factory.CorLibScope
                .CreateTypeReference("System", "Exception")
                .CreateMemberReference(".ctor", MethodSignature.CreateInstance(factory.Void, [factory.String]))
                .ImportWith(importer);

            instructions.Add(CilOpCodes.Ldstr, detail);
            instructions.Add(CilOpCodes.Newobj, exceptionCtor);
            instructions.Add(CilOpCodes.Throw);
        }

        methodContext.ReleaseAnalysisData();
    }

    public static void WriteControlFlowGraph(MethodAnalysisContext method, string outputPath)
    {
        var graph = method.ControlFlowGraph;

        var sb = new StringBuilder();
        var edges = new List<(int, int)>();

        sb.AppendLine("digraph ControlFlowGraph {");
        sb.AppendLine("    \"label\"=\"Control flow graph\"");

        // no instructions
        graph ??= new ISILControlFlowGraph([]);

        var methodText = $@"{CsFileUtils.GetKeyWordsForMethod(method)} {method.FullNameWithSignature}
parameter locals: {string.Join(", ", method.ParameterLocals)}
parameter operands: {string.Join(", ", method.ParameterOperands)}";

        foreach (var block in graph.Blocks)
        {
            if (block == graph.EntryBlock || block == graph.ExitBlock)
            {
                var isEntry = block == graph.EntryBlock;
                sb.AppendLine($"""
                                       {block.ID} [
                                               "color"="{(isEntry ? "green" : "red")}"
                                               "label"="{(isEntry ? $"Entry ({block.ID})\n{methodText}" : $"Exit ({block.ID})")}"
                                       ]
                               """);
            }
            else
            {
                sb.AppendLine($"""
                                       {block.ID} [
                                               "shape"="box"
                                               "label"="{block.ToString().EscapeString().Replace("\\r", "")}"
                                       ]
                               """);
            }

            edges.AddRange(block.Successors.Select(b => (block.ID, b.ID)));
        }

        foreach (var edge in edges)
            sb.AppendLine($"    {edge.Item1} -> {edge.Item2}");

        sb.AppendLine("}");

        var type = method.DeclaringType!;
        var assemblyName = MiscUtils.CleanPathElement(type.DeclaringAssembly.CleanAssemblyName);
        var typePath = Path.Combine(type.FullName.Split('.').Select(MiscUtils.CleanPathElement).ToArray());
        var directoryPath = Path.Combine(outputPath, assemblyName, typePath);

        var methodName = MiscUtils.CleanPathElement(method.Name + "_" + string.Join("_",
            method.Parameters.Select(p => MiscUtils.CleanPathElement(p.ParameterType.Name))));
        var path = Path.Combine(directoryPath, methodName) + ".dot";

        if (path.Length > 260)
        {
            path = path[..250];
            path += ".dot";
        }

        var directory = Path.GetDirectoryName(path)!;
        if (!Directory.Exists(directory))
            Directory.CreateDirectory(directory);

        File.WriteAllText(path, sb.ToString());
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.IO;
4	using System.Linq;
5	using System.Text;
6	using AsmResolver.DotNet;
7	using AsmResolver.DotNet.Signatures;
8	using AsmResolver.PE.DotNet.Cil;
9	using AssetRipper.CIL;
10	using Cpp2IL.Core.Extensions;
11	using Cpp2IL.Core.Graphs;
12	using Cpp2IL.Core.Logging;
13	using Cpp2IL.Core.Model.Contexts;
14	using Cpp2IL.Core.Utils;
15
16	namespace Cpp2IL.Core.OutputFormats;
17
18	public class AsmResolverDllOutputFormatIlRecovery : AsmResolverDllOutputFormat
19	{
20	public override string OutputFormatId => "dll_il_recovery";	1✔
21
22	public override string OutputFormatName => "DLL files with IL Recovery";	×
23
24	protected override void FillMethodBody(MethodDefinition methodDefinition, MethodAnalysisContext methodContext)
25	{
26	var module = methodDefinition.DeclaringModule!;	×
27	var moduleName = module.Name!.ToString();	×
28	var shouldSkip = moduleName.StartsWith("UnityEngine.") \|\| moduleName.StartsWith("Unity.") \|\|	×
29	moduleName.StartsWith("System.") \|\| moduleName == "System" \|\|	×
30	moduleName.StartsWith("mscorlib");	×
31	var importer = new ReferenceImporter(module);	×
32
33	if (!methodDefinition.IsManagedMethodWithBody())	×
34	return;	×
35
36	methodDefinition.CilMethodBody = new();	×
37	var instructions = methodDefinition.CilMethodBody.Instructions;	×
38
39	if (shouldSkip)	×
40	{
41	methodDefinition.ReplaceMethodBodyWithMinimalImplementation();	×
42	return;	×
43	}
44
45	try
46	{
47	TotalMethodCount++;	×
48
49	methodContext.Analyze();	×
50
51	if (methodContext.ConvertedIsil.Count == 0)	×
52	methodDefinition.ReplaceMethodBodyWithMinimalImplementation();	×
53	else
54	IlGenerator.GenerateIl(methodContext, methodDefinition);	×
55
56	//WriteControlFlowGraph(methodContext, Path.Combine(Environment.CurrentDirectory, "Cpp2IL", "bin", "Debug", "net9.0", "cpp2il_out", "cfg"));
57
58	SuccessfulMethodCount++;	×
59	}	×
60	catch (Exception e)	×
61	{
62	// Known analysis limitations (DecompilerException) get a one-line warning; anything
63	// else is an unexpected bug and keeps its (collapsed) stack trace.
64	var detail = e is DecompilerException ? e.Message : e.ToCollapsedString();	×
65
66	if (e is DecompilerException)	×
67	Logger.WarnNewline($"Skipping {methodContext.FullName}: {e.Message}");	×
68	else
69	Logger.ErrorNewline($"Decompiling {methodContext.FullName} failed: {detail}");	×
70
NEW 71	methodDefinition.CilMethodBody = new();	×
NEW 72	instructions = methodDefinition.CilMethodBody.Instructions;	×
73
UNCOV 74	var factory = module.CorLibTypeFactory;	×
75	var exceptionCtor = factory.CorLibScope	×
76	.CreateTypeReference("System", "Exception")	×
77	.CreateMemberReference(".ctor", MethodSignature.CreateInstance(factory.Void, [factory.String]))	×
78	.ImportWith(importer);	×
79
80	instructions.Add(CilOpCodes.Ldstr, detail);	×
81	instructions.Add(CilOpCodes.Newobj, exceptionCtor);	×
82	instructions.Add(CilOpCodes.Throw);	×
83	}	×
84
85	methodContext.ReleaseAnalysisData();	×
86	}	×
87
88	public static void WriteControlFlowGraph(MethodAnalysisContext method, string outputPath)
89	{
90	var graph = method.ControlFlowGraph;	×
91
92	var sb = new StringBuilder();	×
93	var edges = new List<(int, int)>();	×
94
95	sb.AppendLine("digraph ControlFlowGraph {");	×
96	sb.AppendLine(" \"label\"=\"Control flow graph\"");	×
97
98	// no instructions
99	graph ??= new ISILControlFlowGraph([]);	×
100
101	var methodText = $@"{CsFileUtils.GetKeyWordsForMethod(method)} {method.FullNameWithSignature}	×
102	parameter locals: {string.Join(", ", method.ParameterLocals)}	×
103	parameter operands: {string.Join(", ", method.ParameterOperands)}";	×
104
105	foreach (var block in graph.Blocks)	×
106	{
107	if (block == graph.EntryBlock \|\| block == graph.ExitBlock)	×
108	{
109	var isEntry = block == graph.EntryBlock;	×
110	sb.AppendLine($"""	×
111	{block.ID} [	×
112	"color"="{(isEntry ? "green" : "red")}"	×
113	"label"="{(isEntry ? $"Entry ({block.ID})\n{methodText}" : $"Exit ({block.ID})")}"	×
114	]	×
115	""");	×
116	}
117	else
118	{
119	sb.AppendLine($"""	×
120	{block.ID} [	×
121	"shape"="box"	×
122	"label"="{block.ToString().EscapeString().Replace("\\r", "")}"	×
123	]	×
124	""");	×
125	}
126
127	edges.AddRange(block.Successors.Select(b => (block.ID, b.ID)));	×
128	}
129
130	foreach (var edge in edges)	×
131	sb.AppendLine($" {edge.Item1} -> {edge.Item2}");	×
132
133	sb.AppendLine("}");	×
134
135	var type = method.DeclaringType!;	×
136	var assemblyName = MiscUtils.CleanPathElement(type.DeclaringAssembly.CleanAssemblyName);	×
137	var typePath = Path.Combine(type.FullName.Split('.').Select(MiscUtils.CleanPathElement).ToArray());	×
138	var directoryPath = Path.Combine(outputPath, assemblyName, typePath);	×
139
140	var methodName = MiscUtils.CleanPathElement(method.Name + "_" + string.Join("_",	×
141	method.Parameters.Select(p => MiscUtils.CleanPathElement(p.ParameterType.Name))));	×
142	var path = Path.Combine(directoryPath, methodName) + ".dot";	×
143
144	if (path.Length > 260)	×
145	{
146	path = path[..250];	×
147	path += ".dot";	×
148	}
149
150	var directory = Path.GetDirectoryName(path)!;	×
151	if (!Directory.Exists(directory))	×
152	Directory.CreateDirectory(directory);	×
153
154	File.WriteAllText(path, sb.ToString());	×
155	}	×
156	}

SamboyCoding / Cpp2IL / 30164692193

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous