27098183143

Committed 07 Jun 2026 04:25PM UTC coverage: 33.682% (-1.4%) from 35.035%

Build # 27098183143

Build Type

push

github

Committed by

SamboyCoding

Commit Message

Decompiler: add SSA dead-code elimination

Coverage Stats

2122 of 7666 branches covered (27.68%)

Branch coverage included in aggregate %.

36 of 45 new or added lines in 2 files covered. (80.0%)

884 existing lines in 14 files now uncovered.

4571 of 12205 relevant lines covered (37.45%)

246086.91 hits per line

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

1.28

/Cpp2IL.Core/ProcessingLayers/NativeMethodDetectionProcessingLayer.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Cpp2IL.Core.Api;
using Cpp2IL.Core.Extensions;
using Cpp2IL.Core.ISIL;
using Cpp2IL.Core.Model.Contexts;

namespace Cpp2IL.Core.ProcessingLayers;

public class NativeMethodDetectionProcessingLayer : Cpp2IlProcessingLayer
{
    public override string Name => "Native Method Detection";

    public override string Id => "nativemethoddetector";

    public override void Process(ApplicationAnalysisContext appContext, Action<int, int>? progressCallback = null)
    {
        var nativeMethodInfoStack = new Stack<(ulong, bool)>();
        var cppNativeMethodsType = appContext.AssembliesByName["mscorlib"].InjectType(
            "Cpp2ILInjected",
            "CppNativeMethods",
            null,
            TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Abstract | TypeAttributes.Sealed); //public static class
        foreach (var assemblyAnalysisContext in appContext.Assemblies)
        {
            foreach (var m in assemblyAnalysisContext.Types.SelectMany(t => t.Methods))
            {
                AnalyzeMethod(appContext, m, nativeMethodInfoStack);
            }

            if (Cpp2IlApi.LowMemoryMode)
                GC.Collect();
        }

        if (Cpp2IlApi.LowMemoryMode)
            GC.Collect();

        while (nativeMethodInfoStack.Count > 0)
        {
            (var address, var isVoid) = nativeMethodInfoStack.Pop();
            if (!appContext.MethodsByAddress.ContainsKey(address))
            {
                var m = new NativeMethodAnalysisContext(cppNativeMethodsType, address, isVoid);
                cppNativeMethodsType.Methods.Add(m);
                appContext.MethodsByAddress.Add(address, [m]);
                AnalyzeMethod(appContext, m, nativeMethodInfoStack);
            }
        }
    }

    private static void AnalyzeMethod(ApplicationAnalysisContext appContext, MethodAnalysisContext m, Stack<(ulong, bool)> nativeMethodInfoStack)
    {
        if (m.UnderlyingPointer == 0)
            return;

        var convertedIsil = appContext.InstructionSet.GetIsilFromMethod(m);

        if (convertedIsil is { Count: 0 })
        {
            return;
        }

        foreach (var instruction in convertedIsil)
        {
            if (instruction.OpCode == OpCode.Call)
            {
                if (TryGetAddressFromInstruction(instruction, out var address) && !appContext.MethodsByAddress.ContainsKey(address))
                {
                    nativeMethodInfoStack.Push((address, true));
                }
            }
            else if (instruction.OpCode == OpCode.CallVoid)
            {
                if (TryGetAddressFromInstruction(instruction, out var address) && !appContext.MethodsByAddress.ContainsKey(address))
                {
                    nativeMethodInfoStack.Push((address, m.IsVoid));
                }
            }
        }
    }

    private static bool TryGetAddressFromInstruction(Instruction instruction, out ulong address)
    {
        var operand = instruction.Operands[0];

        if (instruction.Operands.Count > 0 && instruction.Operands[0].IsNumeric())
        {
            address = (ulong)operand;
            return true;
        }

        address = default;
        return false;
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4	using System.Reflection;
5	using Cpp2IL.Core.Api;
6	using Cpp2IL.Core.Extensions;
7	using Cpp2IL.Core.ISIL;
8	using Cpp2IL.Core.Model.Contexts;
9
10	namespace Cpp2IL.Core.ProcessingLayers;
11
12	public class NativeMethodDetectionProcessingLayer : Cpp2IlProcessingLayer
13	{
UNCOV 14	public override string Name => "Native Method Detection";	×
15
16	public override string Id => "nativemethoddetector";	1✔
17
18	public override void Process(ApplicationAnalysisContext appContext, Action<int, int>? progressCallback = null)
19	{
20	var nativeMethodInfoStack = new Stack<(ulong, bool)>();	×
21	var cppNativeMethodsType = appContext.AssembliesByName["mscorlib"].InjectType(	×
22	"Cpp2ILInjected",	×
23	"CppNativeMethods",	×
24	null,	×
25	TypeAttributes.Public \| TypeAttributes.Class \| TypeAttributes.Abstract \| TypeAttributes.Sealed); //public static class	×
UNCOV 26	foreach (var assemblyAnalysisContext in appContext.Assemblies)	×
27	{
UNCOV 28	foreach (var m in assemblyAnalysisContext.Types.SelectMany(t => t.Methods))	×
29	{
UNCOV 30	AnalyzeMethod(appContext, m, nativeMethodInfoStack);	×
31	}
32
33	if (Cpp2IlApi.LowMemoryMode)	×
UNCOV 34	GC.Collect();	×
35	}
36
37	if (Cpp2IlApi.LowMemoryMode)	×
UNCOV 38	GC.Collect();	×
39
UNCOV 40	while (nativeMethodInfoStack.Count > 0)	×
41	{
42	(var address, var isVoid) = nativeMethodInfoStack.Pop();	×
UNCOV 43	if (!appContext.MethodsByAddress.ContainsKey(address))	×
44	{
45	var m = new NativeMethodAnalysisContext(cppNativeMethodsType, address, isVoid);	×
46	cppNativeMethodsType.Methods.Add(m);	×
47	appContext.MethodsByAddress.Add(address, [m]);	×
UNCOV 48	AnalyzeMethod(appContext, m, nativeMethodInfoStack);	×
49	}
50	}
UNCOV 51	}	×
52
53	private static void AnalyzeMethod(ApplicationAnalysisContext appContext, MethodAnalysisContext m, Stack<(ulong, bool)> nativeMethodInfoStack)
54	{
55	if (m.UnderlyingPointer == 0)	×
UNCOV 56	return;	×
57
UNCOV 58	var convertedIsil = appContext.InstructionSet.GetIsilFromMethod(m);	×
59
UNCOV 60	if (convertedIsil is { Count: 0 })	×
61	{
UNCOV 62	return;	×
63	}
64
UNCOV 65	foreach (var instruction in convertedIsil)	×
66	{
UNCOV 67	if (instruction.OpCode == OpCode.Call)	×
68	{
UNCOV 69	if (TryGetAddressFromInstruction(instruction, out var address) && !appContext.MethodsByAddress.ContainsKey(address))	×
70	{
UNCOV 71	nativeMethodInfoStack.Push((address, true));	×
72	}
73	}
UNCOV 74	else if (instruction.OpCode == OpCode.CallVoid)	×
75	{
UNCOV 76	if (TryGetAddressFromInstruction(instruction, out var address) && !appContext.MethodsByAddress.ContainsKey(address))	×
77	{
UNCOV 78	nativeMethodInfoStack.Push((address, m.IsVoid));	×
79	}
80	}
81	}
UNCOV 82	}	×
83
84	private static bool TryGetAddressFromInstruction(Instruction instruction, out ulong address)
85	{
UNCOV 86	var operand = instruction.Operands[0];	×
87
88	if (instruction.Operands.Count > 0 && instruction.Operands[0].IsNumeric())	×
89	{
UNCOV 90	address = (ulong)operand;	×
91	return true;	×
92	}
93
UNCOV 94	address = default;	×
UNCOV 95	return false;	×
96	}
97	}

SamboyCoding / Cpp2IL / 27098183143

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