15052305799

Committed 15 May 2025 06:18PM UTC coverage: 34.043% (+0.005%) from 34.038%

Build # 15052305799

Build Type

push

github

Committed by

SamboyCoding

Commit Message

Remove AttributeAttribute::Name

Run Details

1774 of 6622 branches covered (26.79%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

2 existing lines in 1 file now uncovered.

4155 of 10794 relevant lines covered (38.49%)

188319.93 hits per line

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

0.64

/Cpp2IL.Core/ProcessingLayers/AttributeInjectorProcessingLayer.cs

using System;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using Cpp2IL.Core.Api;
using Cpp2IL.Core.Model.Contexts;
using Cpp2IL.Core.Model.CustomAttributes;
using Cpp2IL.Core.Utils;
using LibCpp2IL;

namespace Cpp2IL.Core.ProcessingLayers;

public class AttributeInjectorProcessingLayer : Cpp2IlProcessingLayer
{
    public override string Name => "Attribute Injector";
    public override string Id => "attributeinjector";

    private static bool _useEzDiffMode;

    public override void Process(ApplicationAnalysisContext appContext, Action<int, int>? progressCallback = null)
    {
        //EZ diff mode removes token attributes and method address/rva fields to make diffing using e.g. git easier
        _useEzDiffMode = appContext.GetExtraData<string>("attr-injector-use-ez-diff") != null;

        InjectAttributeAttribute(appContext);

        if (!_useEzDiffMode)
            InjectTokenAttribute(appContext);

        InjectAddressAttribute(appContext);
        InjectFieldOffsetAttribute(appContext);
    }

    private static void InjectFieldOffsetAttribute(ApplicationAnalysisContext appContext)
    {
        var fieldOffsetAttributes = appContext.InjectTypeIntoAllAssemblies("Cpp2ILInjected", "FieldOffsetAttribute", appContext.SystemTypes.SystemAttributeType);

        var offsetFields = fieldOffsetAttributes.InjectFieldToAllAssemblies("Offset", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);

        var fieldOffsetConstructors = fieldOffsetAttributes.InjectConstructor(false);

        foreach (var assemblyAnalysisContext in appContext.Assemblies)
        {
            var offsetField = offsetFields[assemblyAnalysisContext];

            var fieldOffsetConstructor = fieldOffsetConstructors[assemblyAnalysisContext];

            foreach (var f in assemblyAnalysisContext.Types.SelectMany(t => t.Fields))
            {
                if (f.CustomAttributes == null || f.BackingData == null || f.IsStatic)
                    continue;

                var newAttribute = new AnalyzedCustomAttribute(fieldOffsetConstructor);

                //This loop is not done parallel because f.Offset has heavy lock contention
                newAttribute.Fields.Add(new(offsetField, new CustomAttributePrimitiveParameter($"0x{f.Offset:X}", newAttribute, CustomAttributeParameterKind.Field, 0)));
                f.CustomAttributes.Add(newAttribute);
            }
        }
    }

    private static void InjectAddressAttribute(ApplicationAnalysisContext appContext)
    {
        var addressAttributes = appContext.InjectTypeIntoAllAssemblies("Cpp2ILInjected", "AddressAttribute", appContext.SystemTypes.SystemAttributeType);

        var rvaFields = addressAttributes.InjectFieldToAllAssemblies("RVA", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);
        var offsetFields = addressAttributes.InjectFieldToAllAssemblies("Offset", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);
        var lengthFields = addressAttributes.InjectFieldToAllAssemblies("Length", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);

        var addressConstructors = addressAttributes.InjectConstructor(false);

        foreach (var assemblyAnalysisContext in appContext.Assemblies)
        {
            var rvaField = rvaFields[assemblyAnalysisContext];
            var offsetField = offsetFields[assemblyAnalysisContext];
            var lengthField = lengthFields[assemblyAnalysisContext];

            var addressConstructor = addressConstructors[assemblyAnalysisContext];

            foreach (var m in assemblyAnalysisContext.Types.SelectMany(t => t.Methods))
            {
                if (m.CustomAttributes == null || m.UnderlyingPointer == 0)
                    continue;

                var newAttribute = new AnalyzedCustomAttribute(addressConstructor);

                if (!_useEzDiffMode)
                {
                    newAttribute.Fields.Add(new(rvaField, new CustomAttributePrimitiveParameter($"0x{m.Rva:X}", newAttribute, CustomAttributeParameterKind.Field, 0)));
                    if (appContext.Binary.TryMapVirtualAddressToRaw(m.UnderlyingPointer, out var offset))
                        newAttribute.Fields.Add(new(offsetField, new CustomAttributePrimitiveParameter($"0x{offset:X}", newAttribute, CustomAttributeParameterKind.Field, 1)));
                }

                newAttribute.Fields.Add(new(lengthField, new CustomAttributePrimitiveParameter($"0x{m.RawBytes.Length:X}", newAttribute, CustomAttributeParameterKind.Field, newAttribute.Fields.Count)));
                m.CustomAttributes.Add(newAttribute);
            }
        }
    }

    private static void InjectTokenAttribute(ApplicationAnalysisContext appContext)
    {
        var tokenAttributes = appContext.InjectTypeIntoAllAssemblies("Cpp2ILInjected", "TokenAttribute", appContext.SystemTypes.SystemAttributeType);

        var tokenFields = tokenAttributes.InjectFieldToAllAssemblies("Token", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);

        var tokenConstructors = tokenAttributes.InjectConstructor(false);

        foreach (var assemblyAnalysisContext in appContext.Assemblies)
        {
            var tokenField = tokenFields[assemblyAnalysisContext];

            var tokenConstructor = tokenConstructors[assemblyAnalysisContext];

            var toProcess = assemblyAnalysisContext.Types.SelectMany(ctx => ctx.Methods.Cast<HasCustomAttributes>()
                    .Concat(ctx.Fields)
                    .Concat(ctx.Events)
                    .Concat(ctx.Properties)
                    .Append(ctx))
                .Append(assemblyAnalysisContext);

            Parallel.ForEach(toProcess, context =>
            {
                if (context.CustomAttributes == null || context.Token == 0)
                    return;

                var newAttribute = new AnalyzedCustomAttribute(tokenConstructor);
                newAttribute.Fields.Add(new(tokenField, new CustomAttributePrimitiveParameter($"0x{context.Token:X}", newAttribute, CustomAttributeParameterKind.Field, 0)));
                context.CustomAttributes.Add(newAttribute);
            });
        }
    }

    private static void InjectAttributeAttribute(ApplicationAnalysisContext appContext)
    {
        if (appContext.MetadataVersion >= 29f)
        {
            //All attributes should be fully serializable anyway, as they're stored in metadata
            //However, we still need to read them all
            var toAnalyze = appContext.Assemblies.SelectMany(ctx => ctx.Types)
                .SelectMany(ctx => ctx.Methods
                    .SelectMany(m => m.Parameters.Cast<HasCustomAttributes>().Append(m))
                    .Concat(ctx.Fields)
                    .Concat(ctx.Events)
                    .Concat(ctx.Properties)
                    .Append(ctx));

            foreach (var hasCustomAttributes in toAnalyze)
                hasCustomAttributes.AnalyzeCustomAttributeData();

            // MiscUtils.ExecuteParallel(toAnalyze, ctx => ctx.AnalyzeCustomAttributeData());
            return;
        }

        var attributeAttributes = appContext.InjectTypeIntoAllAssemblies("Cpp2ILInjected", "AttributeAttribute", appContext.SystemTypes.SystemAttributeType);

        var attributeTypeFields = attributeAttributes.InjectFieldToAllAssemblies("Type", appContext.SystemTypes.SystemTypeType, FieldAttributes.Public);
        var attributeRvaFields = attributeAttributes.InjectFieldToAllAssemblies("RVA", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);
        var attributeOffsetFields = attributeAttributes.InjectFieldToAllAssemblies("Offset", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);

        var attributeConstructors = attributeAttributes.InjectConstructor(false);

        foreach (var assemblyAnalysisContext in appContext.Assemblies)
        {
            var typeField = attributeTypeFields[assemblyAnalysisContext];
            var rvaField = attributeRvaFields[assemblyAnalysisContext];
            var offsetField = attributeOffsetFields[assemblyAnalysisContext];

            var attributeConstructor = attributeConstructors[assemblyAnalysisContext];

            var toProcess = assemblyAnalysisContext.Types
                .SelectMany(ctx => ctx.Methods.SelectMany(m => m.Parameters.Cast<HasCustomAttributes>().Append(m))
                    .Concat(ctx.Fields)
                    .Concat(ctx.Events)
                    .Concat(ctx.Properties)
                    .Append(ctx))
                .Append(assemblyAnalysisContext);

            MiscUtils.ExecuteParallel(toProcess, c => ProcessCustomAttributesForContext(c, typeField, rvaField, offsetField, attributeConstructor));
        }
    }

    private static void ProcessCustomAttributesForContext(HasCustomAttributes context, FieldAnalysisContext typeField, FieldAnalysisContext rvaField, FieldAnalysisContext offsetField, MethodAnalysisContext ctor)
    {
        if (_useEzDiffMode)
            context.CustomAttributes = [];
        else
        {
            context.AnalyzeCustomAttributeData(false);

            if (context.CustomAttributes == null)
                return;
        }

        for (var index = 0; index < context.CustomAttributes.Count; index++)
        {
            var attribute = context.CustomAttributes[index];

            if (attribute.IsSuitableForEmission)
                //Attribute has all required parameters, so we don't need an injected one
                continue;

            //Create replacement attribute
            var replacementAttribute = new AnalyzedCustomAttribute(ctor);

            //Get ptr, and from it, rva and offset
            var generatorPtr = context.CaCacheGeneratorAnalysis!.UnderlyingPointer;
            var generatorRva = context.AppContext.Binary.GetRva(generatorPtr);
            if (!context.AppContext.Binary.TryMapVirtualAddressToRaw(generatorPtr, out var offsetInBinary))
                offsetInBinary = 0;

            //Add the 3 fields to the replacement attribute
            replacementAttribute.Fields.Add(new(typeField, new CustomAttributeTypeParameter(attribute.Constructor.DeclaringType, replacementAttribute, CustomAttributeParameterKind.Field, 0)));
            replacementAttribute.Fields.Add(new(rvaField, new CustomAttributePrimitiveParameter($"0x{generatorRva:X}", replacementAttribute, CustomAttributeParameterKind.Field, 1)));
            replacementAttribute.Fields.Add(new(offsetField, new CustomAttributePrimitiveParameter($"0x{offsetInBinary:X}", replacementAttribute, CustomAttributeParameterKind.Field, 2)));

            //Replace the original attribute with the replacement attribute
            context.CustomAttributes[index] = replacementAttribute;
        }
    }
}

1	using System;
2	using System.Diagnostics;
3	using System.Linq;
4	using System.Reflection;
5	using System.Threading.Tasks;
6	using Cpp2IL.Core.Api;
7	using Cpp2IL.Core.Model.Contexts;
8	using Cpp2IL.Core.Model.CustomAttributes;
9	using Cpp2IL.Core.Utils;
10	using LibCpp2IL;
11
12	namespace Cpp2IL.Core.ProcessingLayers;
13
14	public class AttributeInjectorProcessingLayer : Cpp2IlProcessingLayer
15	{
16	public override string Name => "Attribute Injector";	×
17	public override string Id => "attributeinjector";	1✔
18
19	private static bool _useEzDiffMode;
20
21	public override void Process(ApplicationAnalysisContext appContext, Action<int, int>? progressCallback = null)
22	{
23	//EZ diff mode removes token attributes and method address/rva fields to make diffing using e.g. git easier
24	_useEzDiffMode = appContext.GetExtraData<string>("attr-injector-use-ez-diff") != null;	×
25
26	InjectAttributeAttribute(appContext);	×
27
28	if (!_useEzDiffMode)	×
29	InjectTokenAttribute(appContext);	×
30
31	InjectAddressAttribute(appContext);	×
32	InjectFieldOffsetAttribute(appContext);	×
33	}	×
34
35	private static void InjectFieldOffsetAttribute(ApplicationAnalysisContext appContext)
36	{
37	var fieldOffsetAttributes = appContext.InjectTypeIntoAllAssemblies("Cpp2ILInjected", "FieldOffsetAttribute", appContext.SystemTypes.SystemAttributeType);	×
38
39	var offsetFields = fieldOffsetAttributes.InjectFieldToAllAssemblies("Offset", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);	×
40
41	var fieldOffsetConstructors = fieldOffsetAttributes.InjectConstructor(false);	×
42
43	foreach (var assemblyAnalysisContext in appContext.Assemblies)	×
44	{
45	var offsetField = offsetFields[assemblyAnalysisContext];	×
46
47	var fieldOffsetConstructor = fieldOffsetConstructors[assemblyAnalysisContext];	×
48
49	foreach (var f in assemblyAnalysisContext.Types.SelectMany(t => t.Fields))	×
50	{
51	if (f.CustomAttributes == null \|\| f.BackingData == null \|\| f.IsStatic)	×
52	continue;
53
54	var newAttribute = new AnalyzedCustomAttribute(fieldOffsetConstructor);	×
55
56	//This loop is not done parallel because f.Offset has heavy lock contention
57	newAttribute.Fields.Add(new(offsetField, new CustomAttributePrimitiveParameter($"0x{f.Offset:X}", newAttribute, CustomAttributeParameterKind.Field, 0)));	×
58	f.CustomAttributes.Add(newAttribute);	×
59	}
60	}
61	}	×
62
63	private static void InjectAddressAttribute(ApplicationAnalysisContext appContext)
64	{
65	var addressAttributes = appContext.InjectTypeIntoAllAssemblies("Cpp2ILInjected", "AddressAttribute", appContext.SystemTypes.SystemAttributeType);	×
66
67	var rvaFields = addressAttributes.InjectFieldToAllAssemblies("RVA", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);	×
68	var offsetFields = addressAttributes.InjectFieldToAllAssemblies("Offset", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);	×
69	var lengthFields = addressAttributes.InjectFieldToAllAssemblies("Length", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);	×
70
71	var addressConstructors = addressAttributes.InjectConstructor(false);	×
72
73	foreach (var assemblyAnalysisContext in appContext.Assemblies)	×
74	{
75	var rvaField = rvaFields[assemblyAnalysisContext];	×
76	var offsetField = offsetFields[assemblyAnalysisContext];	×
77	var lengthField = lengthFields[assemblyAnalysisContext];	×
78
79	var addressConstructor = addressConstructors[assemblyAnalysisContext];	×
80
81	foreach (var m in assemblyAnalysisContext.Types.SelectMany(t => t.Methods))	×
82	{
83	if (m.CustomAttributes == null \|\| m.UnderlyingPointer == 0)	×
84	continue;
85
86	var newAttribute = new AnalyzedCustomAttribute(addressConstructor);	×
87
88	if (!_useEzDiffMode)	×
89	{
90	newAttribute.Fields.Add(new(rvaField, new CustomAttributePrimitiveParameter($"0x{m.Rva:X}", newAttribute, CustomAttributeParameterKind.Field, 0)));	×
91	if (appContext.Binary.TryMapVirtualAddressToRaw(m.UnderlyingPointer, out var offset))	×
92	newAttribute.Fields.Add(new(offsetField, new CustomAttributePrimitiveParameter($"0x{offset:X}", newAttribute, CustomAttributeParameterKind.Field, 1)));	×
93	}
94
95	newAttribute.Fields.Add(new(lengthField, new CustomAttributePrimitiveParameter($"0x{m.RawBytes.Length:X}", newAttribute, CustomAttributeParameterKind.Field, newAttribute.Fields.Count)));	×
96	m.CustomAttributes.Add(newAttribute);	×
97	}
98	}
99	}	×
100
101	private static void InjectTokenAttribute(ApplicationAnalysisContext appContext)
102	{
103	var tokenAttributes = appContext.InjectTypeIntoAllAssemblies("Cpp2ILInjected", "TokenAttribute", appContext.SystemTypes.SystemAttributeType);	×
104
105	var tokenFields = tokenAttributes.InjectFieldToAllAssemblies("Token", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);	×
106
107	var tokenConstructors = tokenAttributes.InjectConstructor(false);	×
108
109	foreach (var assemblyAnalysisContext in appContext.Assemblies)	×
110	{
111	var tokenField = tokenFields[assemblyAnalysisContext];	×
112
113	var tokenConstructor = tokenConstructors[assemblyAnalysisContext];	×
114
115	var toProcess = assemblyAnalysisContext.Types.SelectMany(ctx => ctx.Methods.Cast<HasCustomAttributes>()	×
116	.Concat(ctx.Fields)	×
117	.Concat(ctx.Events)	×
118	.Concat(ctx.Properties)	×
119	.Append(ctx))	×
120	.Append(assemblyAnalysisContext);	×
121
122	Parallel.ForEach(toProcess, context =>	×
123	{	×
124	if (context.CustomAttributes == null \|\| context.Token == 0)	×
125	return;	×
126		×
127	var newAttribute = new AnalyzedCustomAttribute(tokenConstructor);	×
128	newAttribute.Fields.Add(new(tokenField, new CustomAttributePrimitiveParameter($"0x{context.Token:X}", newAttribute, CustomAttributeParameterKind.Field, 0)));	×
129	context.CustomAttributes.Add(newAttribute);	×
130	});	×
131	}
132	}	×
133
134	private static void InjectAttributeAttribute(ApplicationAnalysisContext appContext)
135	{
136	if (appContext.MetadataVersion >= 29f)	×
137	{
138	//All attributes should be fully serializable anyway, as they're stored in metadata
139	//However, we still need to read them all
140	var toAnalyze = appContext.Assemblies.SelectMany(ctx => ctx.Types)	×
141	.SelectMany(ctx => ctx.Methods	×
142	.SelectMany(m => m.Parameters.Cast<HasCustomAttributes>().Append(m))	×
143	.Concat(ctx.Fields)	×
144	.Concat(ctx.Events)	×
145	.Concat(ctx.Properties)	×
146	.Append(ctx));	×
147
148	foreach (var hasCustomAttributes in toAnalyze)	×
149	hasCustomAttributes.AnalyzeCustomAttributeData();	×
150
151	// MiscUtils.ExecuteParallel(toAnalyze, ctx => ctx.AnalyzeCustomAttributeData());
152	return;	×
153	}
154
155	var attributeAttributes = appContext.InjectTypeIntoAllAssemblies("Cpp2ILInjected", "AttributeAttribute", appContext.SystemTypes.SystemAttributeType);	×
156
157	var attributeTypeFields = attributeAttributes.InjectFieldToAllAssemblies("Type", appContext.SystemTypes.SystemTypeType, FieldAttributes.Public);	×
158	var attributeRvaFields = attributeAttributes.InjectFieldToAllAssemblies("RVA", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);	×
159	var attributeOffsetFields = attributeAttributes.InjectFieldToAllAssemblies("Offset", appContext.SystemTypes.SystemStringType, FieldAttributes.Public);	×
160
161	var attributeConstructors = attributeAttributes.InjectConstructor(false);	×
162
163	foreach (var assemblyAnalysisContext in appContext.Assemblies)	×
164	{
UNCOV 165	var typeField = attributeTypeFields[assemblyAnalysisContext];	×
UNCOV 166	var rvaField = attributeRvaFields[assemblyAnalysisContext];	×
167	var offsetField = attributeOffsetFields[assemblyAnalysisContext];	×
168
169	var attributeConstructor = attributeConstructors[assemblyAnalysisContext];	×
170
171	var toProcess = assemblyAnalysisContext.Types	×
172	.SelectMany(ctx => ctx.Methods.SelectMany(m => m.Parameters.Cast<HasCustomAttributes>().Append(m))	×
173	.Concat(ctx.Fields)	×
174	.Concat(ctx.Events)	×
175	.Concat(ctx.Properties)	×
176	.Append(ctx))	×
177	.Append(assemblyAnalysisContext);	×
178
NEW 179	MiscUtils.ExecuteParallel(toProcess, c => ProcessCustomAttributesForContext(c, typeField, rvaField, offsetField, attributeConstructor));	×
180	}
181	}	×
182
183	private static void ProcessCustomAttributesForContext(HasCustomAttributes context, FieldAnalysisContext typeField, FieldAnalysisContext rvaField, FieldAnalysisContext offsetField, MethodAnalysisContext ctor)
184	{
185	if (_useEzDiffMode)	×
186	context.CustomAttributes = [];	×
187	else
188	{
189	context.AnalyzeCustomAttributeData(false);	×
190
191	if (context.CustomAttributes == null)	×
192	return;	×
193	}
194
195	for (var index = 0; index < context.CustomAttributes.Count; index++)	×
196	{
197	var attribute = context.CustomAttributes[index];	×
198
199	if (attribute.IsSuitableForEmission)	×
200	//Attribute has all required parameters, so we don't need an injected one
201	continue;
202
203	//Create replacement attribute
204	var replacementAttribute = new AnalyzedCustomAttribute(ctor);	×
205
206	//Get ptr, and from it, rva and offset
207	var generatorPtr = context.CaCacheGeneratorAnalysis!.UnderlyingPointer;	×
208	var generatorRva = context.AppContext.Binary.GetRva(generatorPtr);	×
209	if (!context.AppContext.Binary.TryMapVirtualAddressToRaw(generatorPtr, out var offsetInBinary))	×
210	offsetInBinary = 0;	×
211
212	//Add the 3 fields to the replacement attribute
213	replacementAttribute.Fields.Add(new(typeField, new CustomAttributeTypeParameter(attribute.Constructor.DeclaringType, replacementAttribute, CustomAttributeParameterKind.Field, 0)));	×
214	replacementAttribute.Fields.Add(new(rvaField, new CustomAttributePrimitiveParameter($"0x{generatorRva:X}", replacementAttribute, CustomAttributeParameterKind.Field, 1)));	×
215	replacementAttribute.Fields.Add(new(offsetField, new CustomAttributePrimitiveParameter($"0x{offsetInBinary:X}", replacementAttribute, CustomAttributeParameterKind.Field, 2)));	×
216
217	//Replace the original attribute with the replacement attribute
218	context.CustomAttributes[index] = replacementAttribute;	×
219	}
220	}	×
221	}

SamboyCoding / Cpp2IL / 15052305799

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