12223020379

Committed 08 Dec 2024 03:28PM UTC coverage: 28.172% (-0.2%) from 28.362%

Build # 12223020379

Build Type

push

github

Committed by

web-flow

Commit Message

Wasm name section output format (#388)

Run Details

1265 of 6236 branches covered (20.29%)

Branch coverage included in aggregate %.

2 of 88 new or added lines in 2 files covered. (2.27%)

3385 of 10270 relevant lines covered (32.96%)

124946.92 hits per line

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

0.85

/Cpp2IL.Core/OutputFormats/WasmNameSectionOutputFormat.cs

using System;
using System.IO;
using System.Linq;
using System.Text;
using Cpp2IL.Core.Api;
using Cpp2IL.Core.Logging;
using Cpp2IL.Core.Model.Contexts;
using Cpp2IL.Core.Utils;
using LibCpp2IL;
using LibCpp2IL.Wasm;

namespace Cpp2IL.Core.OutputFormats;

public class WasmNameSectionOutputFormat : Cpp2IlOutputFormat
{
    public override string OutputFormatId => "wasm_name_section";
    public override string OutputFormatName => "Webassembly name section";

    public override void DoOutput(ApplicationAnalysisContext context, string outputRoot)
    {
        // Outputs a binary file matching the standardized "name" WebAssembly custom section.
        // If the game's binary doesn't already have the same type of section (which is practically always),
        // all that's needed to combine the two is a simple `cat main.wasm section.dat > out.wasm`.
        // Using this modified binary in place of the original one provides extra information for debuggers.

        // The spec can be found here: https://webassembly.github.io/spec/core/appendix/custom.html#name-section
        // Some additional subsections have been proposed (already implemented in v8 & spidermonkey), but they don't seem to be helpful as of now.
        // The proposal overview can be found here: https://github.com/WebAssembly/extended-name-section/blob/main/proposals/extended-name-section/Overview.md

        if (context.Binary.GetType() != typeof(WasmFile))
            throw new Exception("This output format only works with WebAssembly files");

        if (!Directory.Exists(outputRoot))
            Directory.CreateDirectory(outputRoot);

        var outputFile = File.Create(Path.Combine(outputRoot, "namesection.dat"));

        var section =
            new MemoryStream(); // This stream is separate from outputFile because we need to know the size of the section before writing it
        section.WriteName("name"); // The section's name (`name`)

        var moduleNameSubsection = new MemoryStream();
        moduleNameSubsection.WriteName("Unity");
        section.WriteSizedData(moduleNameSubsection, 0x0); // Subsection id 0
        moduleNameSubsection.Dispose();

        var paramSuccessCount = 0;
        var paramFailCount = 0;

        var functionData = context.AllTypes.SelectMany(t => t.Methods)
            .Select(method => (method, definition: WasmUtils.TryGetWasmDefinition(method)))
            .Where(v => v.definition is not null)
            .Select(v =>
            {
                var trueParamCount = v.definition!.GetType((WasmFile)LibCpp2IlMain.Binary!).ParamTypes.Length;

                // Also see WasmUtils.BuildSignature
                var parameters = v.method.Parameters.Select(param => param.Name).ToList();

                if (!v.method.IsStatic)
                    parameters.Insert(0, "this");

                if (v.method.ReturnTypeContext is
                    { IsValueType: true, IsPrimitive: true, Definition: null or { Size: > 8 } })
                    parameters.Insert(0, "out");

                parameters.Add("methodInfo"); // Only for some methods...?

                if (trueParamCount != parameters.Count)
                {
                    // Logger.WarnNewline($"Failed param matching for {v.method.FullNameWithSignature}, calculated {parameters.Count} with there actually being {trueParamCount} ({string.Join(" ", parameters)})");
                    parameters.Clear();
                    paramFailCount++;
                }
                else
                {
                    paramSuccessCount++;
                }

                return (
                    Index: v.definition!.FunctionTableIndex,
                    Name: v.method.FullName,
                    Parameters: parameters
                );
            })
            .GroupBy(v => v.Index)
            .OrderBy(grouping => grouping.Key)
            .ToDictionary(
                grouping => grouping.Key,
                grouping => grouping.Select(v => (v.Name, v.Parameters)).ToList()
            );
        
        Logger.InfoNewline(
            $"Estimated parameter naming success rate: {(float)paramSuccessCount / (paramSuccessCount + paramFailCount) * 100:N2}%");

        var functionNameSubsection = new MemoryStream();
        functionNameSubsection.WriteLEB128Unsigned((ulong)functionData.Count); // vector length

        var localNameSubsection = new MemoryStream();
        localNameSubsection.WriteLEB128Unsigned((ulong)functionData.Count); // vector length

        foreach (var (idx, data) in functionData)
        {
            functionNameSubsection.WriteLEB128Unsigned((ulong)idx);
            localNameSubsection.WriteLEB128Unsigned((ulong)idx);

            functionNameSubsection.WriteName(data.Count == 1 ? data[0].Name : $"multiple_{data.Count}_{data[0].Name}");

            localNameSubsection.WriteLEB128Unsigned((ulong)data[0].Parameters.Count); // vector length
            for (var i = 0; i < data[0].Parameters.Count; i++)
            {
                localNameSubsection.WriteLEB128Unsigned((ulong)i);
                // Possible to include type here, but may make names excessively long
                localNameSubsection.WriteName(data.Count == 1
                    ? data[0].Parameters[i]
                    : $"multiple_{data.Count}_{data[0].Parameters[i]}");
            }
        }

        section.WriteSizedData(functionNameSubsection, 0x1); // Subsection id 1
        section.WriteSizedData(localNameSubsection, 0x2); // Subsection id 2

        outputFile.WriteSizedData(section, 0x0); // Section id 0 - custom
    }
}

public static class Extensions
{
    public static void WriteName(this Stream memoryStream, string name)
    {
        var bytes = Encoding.Default.GetBytes(name);
        memoryStream.WriteLEB128Unsigned((ulong)bytes.Length);
        memoryStream.Write(bytes, 0, bytes.Length);
    }

    public static void WriteSizedData(this Stream memoryStream, MemoryStream data, byte? prependByte = null)
    {
        if (prependByte.HasValue)
        {
            memoryStream.WriteByte(prependByte.Value);
        }

        memoryStream.WriteLEB128Unsigned((ulong)data.Length);
        data.WriteTo(memoryStream);
    }
}

1	using System;
2	using System.IO;
3	using System.Linq;
4	using System.Text;
5	using Cpp2IL.Core.Api;
6	using Cpp2IL.Core.Logging;
7	using Cpp2IL.Core.Model.Contexts;
8	using Cpp2IL.Core.Utils;
9	using LibCpp2IL;
10	using LibCpp2IL.Wasm;
11
12	namespace Cpp2IL.Core.OutputFormats;
13
14	public class WasmNameSectionOutputFormat : Cpp2IlOutputFormat
15	{
16	public override string OutputFormatId => "wasm_name_section";	1✔
NEW 17	public override string OutputFormatName => "Webassembly name section";	×
18
19	public override void DoOutput(ApplicationAnalysisContext context, string outputRoot)
20	{
21	// Outputs a binary file matching the standardized "name" WebAssembly custom section.
22	// If the game's binary doesn't already have the same type of section (which is practically always),
23	// all that's needed to combine the two is a simple `cat main.wasm section.dat > out.wasm`.
24	// Using this modified binary in place of the original one provides extra information for debuggers.
25
26	// The spec can be found here: https://webassembly.github.io/spec/core/appendix/custom.html#name-section
27	// Some additional subsections have been proposed (already implemented in v8 & spidermonkey), but they don't seem to be helpful as of now.
28	// The proposal overview can be found here: https://github.com/WebAssembly/extended-name-section/blob/main/proposals/extended-name-section/Overview.md
29
NEW 30	if (context.Binary.GetType() != typeof(WasmFile))	×
NEW 31	throw new Exception("This output format only works with WebAssembly files");	×
32
NEW 33	if (!Directory.Exists(outputRoot))	×
NEW 34	Directory.CreateDirectory(outputRoot);	×
35
NEW 36	var outputFile = File.Create(Path.Combine(outputRoot, "namesection.dat"));	×
37
NEW 38	var section =	×
NEW 39	new MemoryStream(); // This stream is separate from outputFile because we need to know the size of the section before writing it	×
NEW 40	section.WriteName("name"); // The section's name (`name`)	×
41
NEW 42	var moduleNameSubsection = new MemoryStream();	×
NEW 43	moduleNameSubsection.WriteName("Unity");	×
NEW 44	section.WriteSizedData(moduleNameSubsection, 0x0); // Subsection id 0	×
NEW 45	moduleNameSubsection.Dispose();	×
46
NEW 47	var paramSuccessCount = 0;	×
NEW 48	var paramFailCount = 0;	×
49
NEW 50	var functionData = context.AllTypes.SelectMany(t => t.Methods)	×
NEW 51	.Select(method => (method, definition: WasmUtils.TryGetWasmDefinition(method)))	×
NEW 52	.Where(v => v.definition is not null)	×
NEW 53	.Select(v =>	×
NEW 54	{	×
NEW 55	var trueParamCount = v.definition!.GetType((WasmFile)LibCpp2IlMain.Binary!).ParamTypes.Length;	×
NEW 56		×
NEW 57	// Also see WasmUtils.BuildSignature	×
NEW 58	var parameters = v.method.Parameters.Select(param => param.Name).ToList();	×
NEW 59		×
NEW 60	if (!v.method.IsStatic)	×
NEW 61	parameters.Insert(0, "this");	×
NEW 62		×
NEW 63	if (v.method.ReturnTypeContext is	×
NEW 64	{ IsValueType: true, IsPrimitive: true, Definition: null or { Size: > 8 } })	×
NEW 65	parameters.Insert(0, "out");	×
NEW 66		×
NEW 67	parameters.Add("methodInfo"); // Only for some methods...?	×
NEW 68		×
NEW 69	if (trueParamCount != parameters.Count)	×
NEW 70	{	×
NEW 71	// Logger.WarnNewline($"Failed param matching for {v.method.FullNameWithSignature}, calculated {parameters.Count} with there actually being {trueParamCount} ({string.Join(" ", parameters)})");	×
NEW 72	parameters.Clear();	×
NEW 73	paramFailCount++;	×
NEW 74	}	×
NEW 75	else	×
NEW 76	{	×
NEW 77	paramSuccessCount++;	×
NEW 78	}	×
NEW 79		×
NEW 80	return (	×
NEW 81	Index: v.definition!.FunctionTableIndex,	×
NEW 82	Name: v.method.FullName,	×
NEW 83	Parameters: parameters	×
NEW 84	);	×
NEW 85	})	×
NEW 86	.GroupBy(v => v.Index)	×
NEW 87	.OrderBy(grouping => grouping.Key)	×
NEW 88	.ToDictionary(	×
NEW 89	grouping => grouping.Key,	×
NEW 90	grouping => grouping.Select(v => (v.Name, v.Parameters)).ToList()	×
NEW 91	);	×
92
NEW 93	Logger.InfoNewline(	×
NEW 94	$"Estimated parameter naming success rate: {(float)paramSuccessCount / (paramSuccessCount + paramFailCount) * 100:N2}%");	×
95
NEW 96	var functionNameSubsection = new MemoryStream();	×
NEW 97	functionNameSubsection.WriteLEB128Unsigned((ulong)functionData.Count); // vector length	×
98
NEW 99	var localNameSubsection = new MemoryStream();	×
NEW 100	localNameSubsection.WriteLEB128Unsigned((ulong)functionData.Count); // vector length	×
101
NEW 102	foreach (var (idx, data) in functionData)	×
103	{
NEW 104	functionNameSubsection.WriteLEB128Unsigned((ulong)idx);	×
NEW 105	localNameSubsection.WriteLEB128Unsigned((ulong)idx);	×
106
NEW 107	functionNameSubsection.WriteName(data.Count == 1 ? data[0].Name : $"multiple_{data.Count}_{data[0].Name}");	×
108
NEW 109	localNameSubsection.WriteLEB128Unsigned((ulong)data[0].Parameters.Count); // vector length	×
NEW 110	for (var i = 0; i < data[0].Parameters.Count; i++)	×
111	{
NEW 112	localNameSubsection.WriteLEB128Unsigned((ulong)i);	×
113	// Possible to include type here, but may make names excessively long
NEW 114	localNameSubsection.WriteName(data.Count == 1	×
NEW 115	? data[0].Parameters[i]	×
NEW 116	: $"multiple_{data.Count}_{data[0].Parameters[i]}");	×
117	}
118	}
119
NEW 120	section.WriteSizedData(functionNameSubsection, 0x1); // Subsection id 1	×
NEW 121	section.WriteSizedData(localNameSubsection, 0x2); // Subsection id 2	×
122
NEW 123	outputFile.WriteSizedData(section, 0x0); // Section id 0 - custom	×
NEW 124	}	×
125	}
126
127	public static class Extensions
128	{
129	public static void WriteName(this Stream memoryStream, string name)
130	{
NEW 131	var bytes = Encoding.Default.GetBytes(name);	×
NEW 132	memoryStream.WriteLEB128Unsigned((ulong)bytes.Length);	×
NEW 133	memoryStream.Write(bytes, 0, bytes.Length);	×
NEW 134	}	×
135
136	public static void WriteSizedData(this Stream memoryStream, MemoryStream data, byte? prependByte = null)
137	{
NEW 138	if (prependByte.HasValue)	×
139	{
NEW 140	memoryStream.WriteByte(prependByte.Value);	×
141	}
142
NEW 143	memoryStream.WriteLEB128Unsigned((ulong)data.Length);	×
NEW 144	data.WriteTo(memoryStream);	×
NEW 145	}	×
146	}

SamboyCoding / Cpp2IL / 12223020379

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