17101091060

Committed 20 Aug 2025 02:16PM UTC coverage: 30.421% (-3.9%) from 34.352%

Build # 17101091060

Build Type

Pull #481

github

Committed by

web-flow

Commit Message

Merge 42542dde2 into d5260685f

Pull Request Pull Request #481: Decompiler

Run Details

1804 of 7551 branches covered (23.89%)

Branch coverage included in aggregate %.

102 of 1827 new or added lines in 35 files covered. (5.58%)

40 existing lines in 6 files now uncovered.

4095 of 11840 relevant lines covered (34.59%)

165714.86 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	{
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	×
26	foreach (var assemblyAnalysisContext in appContext.Assemblies)	×
27	{
28	foreach (var m in assemblyAnalysisContext.Types.SelectMany(t => t.Methods))	×
29	{
30	AnalyzeMethod(appContext, m, nativeMethodInfoStack);	×
31	}
32
33	if (Cpp2IlApi.LowMemoryMode)	×
34	GC.Collect();	×
35	}
36
37	if (Cpp2IlApi.LowMemoryMode)	×
38	GC.Collect();	×
39
40	while (nativeMethodInfoStack.Count > 0)	×
41	{
42	(var address, var isVoid) = nativeMethodInfoStack.Pop();	×
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]);	×
48	AnalyzeMethod(appContext, m, nativeMethodInfoStack);	×
49	}
50	}
51	}	×
52
53	private static void AnalyzeMethod(ApplicationAnalysisContext appContext, MethodAnalysisContext m, Stack<(ulong, bool)> nativeMethodInfoStack)
54	{
55	if (m.UnderlyingPointer == 0)	×
56	return;	×
57
58	var convertedIsil = appContext.InstructionSet.GetIsilFromMethod(m);	×
59
60	if (convertedIsil is { Count: 0 })	×
61	{
62	return;	×
63	}
64
65	foreach (var instruction in convertedIsil)	×
66	{
NEW 67	if (instruction.OpCode == OpCode.Call)	×
68	{
69	if (TryGetAddressFromInstruction(instruction, out var address) && !appContext.MethodsByAddress.ContainsKey(address))	×
70	{
71	nativeMethodInfoStack.Push((address, true));	×
72	}
73	}
NEW 74	else if (instruction.OpCode == OpCode.CallVoid)	×
75	{
76	if (TryGetAddressFromInstruction(instruction, out var address) && !appContext.MethodsByAddress.ContainsKey(address))	×
77	{
78	nativeMethodInfoStack.Push((address, m.IsVoid));	×
79	}
80	}
81	}
82	}	×
83
84	private static bool TryGetAddressFromInstruction(Instruction instruction, out ulong address)
85	{
NEW 86	var operand = instruction.Operands[0];	×
87
NEW 88	if (instruction.Operands.Count > 0 && instruction.Operands[0].IsNumeric())	×
89	{
NEW 90	address = (ulong)operand;	×
91	return true;	×
92	}
93
94	address = default;	×
95	return false;	×
96	}
97	}

SamboyCoding / Cpp2IL / 17101091060

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