Call Analysis Processing Layer (#164)

Author: ds5678

Cpp2IL.Core/CorePlugin/AttributeAnalysisProcessingLayer.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using Cpp2IL.Core.Api;
 using Cpp2IL.Core.Model.Contexts;
@@ -7,7 +7,7 @@ namespace Cpp2IL.Core.CorePlugin;
 
 public class AttributeAnalysisProcessingLayer : Cpp2IlProcessingLayer
 {
-    public override string Name => "CustomAttribute Analyser";
+    public override string Name => "CustomAttribute Analyzer";
     public override string Id => "attributeanalyzer";
 
     public override void Process(ApplicationAnalysisContext appContext, Action<int, int>? progressCallback = null)
@@ -38,4 +38,4 @@ private void AnalyzeAndRaise(HasCustomAttributes toAnalyze, ref int count, int t
         count++;
         progressCallback?.Invoke(count, total);
     }
-}
+}

Cpp2IL.Core/CorePlugin/CallAnalysisProcessingLayer.cs

@@ -47,10 +47,11 @@ public override void OnLoad()
 
         ProcessingLayerRegistry.Register<AttributeAnalysisProcessingLayer>();
         ProcessingLayerRegistry.Register<AttributeInjectorProcessingLayer>();
+        ProcessingLayerRegistry.Register<CallAnalysisProcessingLayer>();
         ProcessingLayerRegistry.Register<StableRenamingProcessingLayer>();
         ProcessingLayerRegistry.Register<DeobfuscationMapProcessingLayer>();
 
         var elapsed = DateTime.Now - start;
         Logger.VerboseNewline($"Core plugin loaded in {elapsed.Ticks} ticks ({elapsed.TotalMilliseconds}ms)", "Core Plugin");
     }
-}
+}

Cpp2IL.Core/CorePlugin/Cpp2IlCorePlugin.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Cpp2IL.Core.Logging;
@@ -51,6 +51,13 @@ public abstract class BaseKeyFunctionAddresses
 
         private ApplicationAnalysisContext _appContext = null!; //Always initialized before used
 
+        private readonly HashSet<ulong> resolvedAddresses = new();
+
+        public bool IsKeyFunctionAddress(ulong address)
+        {
+            return address != 0 && resolvedAddresses.Contains(address);
+        }
+
         private void FindExport(string name, out ulong ptr)
         {
             Logger.Verbose($"\tLooking for Exported {name} function...");
@@ -105,6 +112,7 @@ public void Find(ApplicationAnalysisContext applicationAnalysisContext)
             AttemptInstructionAnalysisToFillGaps();
 
             FindThunks();
+            InitializeResolvedAddresses();
         }
 
         protected void TryGetInitMetadataFromException()
@@ -283,5 +291,45 @@ private void FindThunks()
         protected virtual void Init(ApplicationAnalysisContext context)
         {
         }
+
+        private void InitializeResolvedAddresses()
+        {
+            resolvedAddresses.Clear();
+            resolvedAddresses.Add(il2cpp_codegen_initialize_method);
+            resolvedAddresses.Add(il2cpp_codegen_initialize_runtime_metadata);
+            resolvedAddresses.Add(il2cpp_vm_metadatacache_initializemethodmetadata);
+            resolvedAddresses.Add(il2cpp_runtime_class_init_export);
+            resolvedAddresses.Add(il2cpp_runtime_class_init_actual);
+            resolvedAddresses.Add(il2cpp_object_new);
+            resolvedAddresses.Add(il2cpp_vm_object_new);
+            resolvedAddresses.Add(il2cpp_codegen_object_new);
+            resolvedAddresses.Add(il2cpp_array_new_specific);
+            resolvedAddresses.Add(il2cpp_vm_array_new_specific);
+            resolvedAddresses.Add(SzArrayNew);
+            resolvedAddresses.Add(il2cpp_type_get_object);
+            resolvedAddresses.Add(il2cpp_vm_reflection_get_type_object);
+            resolvedAddresses.Add(il2cpp_resolve_icall);
+            resolvedAddresses.Add(InternalCalls_Resolve);
+
+            resolvedAddresses.Add(il2cpp_string_new);
+            resolvedAddresses.Add(il2cpp_vm_string_new);
+            resolvedAddresses.Add(il2cpp_string_new_wrapper);
+            resolvedAddresses.Add(il2cpp_vm_string_newWrapper);
+            resolvedAddresses.Add(il2cpp_codegen_string_new_wrapper);
+
+            resolvedAddresses.Add(il2cpp_value_box);
+            resolvedAddresses.Add(il2cpp_vm_object_box);
+
+            resolvedAddresses.Add(il2cpp_object_unbox);
+            resolvedAddresses.Add(il2cpp_vm_object_unbox);
+
+            resolvedAddresses.Add(il2cpp_raise_exception);
+            resolvedAddresses.Add(il2cpp_vm_exception_raise);
+            resolvedAddresses.Add(il2cpp_codegen_raise_exception);
+
+            resolvedAddresses.Add(il2cpp_vm_object_is_inst);
+
+            resolvedAddresses.Add(AddrPInvokeLookup);
+        }
     }
-}
+}

Cpp2IL.Core/Il2CppApiFunctions/BaseKeyFunctionAddresses.cs

@@ -12,6 +12,11 @@ public class CustomAttributeTypeParameter : BaseCustomAttributeParameter
 {
     public Il2CppType? Type;
 
+    public CustomAttributeTypeParameter(Il2CppType? type, AnalyzedCustomAttribute owner, CustomAttributeParameterKind kind, int index) : base(owner, kind, index)
+    {
+        Type = type;
+    }
+
     public CustomAttributeTypeParameter(AnalyzedCustomAttribute owner, CustomAttributeParameterKind kind, int index) : base(owner, kind, index)
     {
     }

Cpp2IL.Core/Model/CustomAttributes/CustomAttributeTypeParameter.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
@@ -284,6 +284,14 @@ public static bool BitsAreEqual(this BitArray first, BitArray second)
             return !areDifferent;
         }
 
+        public static void ExecuteSerial<T>(IEnumerable<T> enumerable, Action<T> what)
+        {
+            foreach (var item in enumerable)
+            {
+                what(item);
+            }
+        }
+
         public static void ExecuteParallel<T>(IEnumerable<T> enumerable, Action<T> what)
         {
             bool F2(T t)

Cpp2IL.Core/Utils/MiscUtils.cs

@@ -36,6 +36,11 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Cpp2IL.Plugin.BuildReport",
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Cpp2IL.Plugin.OrbisPkg", "Cpp2IL.Plugin.OrbisPkg\Cpp2IL.Plugin.OrbisPkg.csproj", "{A621899A-564D-4CD0-97AC-097EBABA5ACD}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Docs", "Docs", "{51C7C919-3561-4630-827C-7FF8173AF665}"
+	ProjectSection(SolutionItems) = preProject
+		docs\CallAnalyzer.md = docs\CallAnalyzer.md
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -86,6 +91,9 @@ Global
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{51C7C919-3561-4630-827C-7FF8173AF665} = {46226B08-22BA-455E-8B99-F496E90EDCBC}
+	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {E9A45B2C-AAEF-4D66-ADD6-7DD234DA3F39}
 	EndGlobalSection

Cpp2IL.sln

@@ -1,4 +1,4 @@
-using System.Collections.Concurrent;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
@@ -185,6 +185,8 @@ public static int GetPropertyIndexFromProperty(Il2CppPropertyDefinition property
 
             switch (fullName)
             {
+                case "System.Int32":
+                    return PrimitiveTypeCache[Il2CppTypeEnum.IL2CPP_TYPE_I4];
                 case "System.String":
                     return PrimitiveTypeCache[Il2CppTypeEnum.IL2CPP_TYPE_STRING];
                 case "System.Void":
@@ -207,4 +209,4 @@ public static int GetPropertyIndexFromProperty(Il2CppPropertyDefinition property
             return null;
         }
     }
-}
+}

LibCpp2IL/Reflection/LibCpp2IlReflection.cs

@@ -0,0 +1,88 @@
+# Call Analyzer
+
+This processing layer analyzes method instructions for calls to other methods and emits attributes based on that.
+
+For this processor, 8 new attributes are injected:
+```cs
+using System;
+namespace Cpp2ILInjected.CallAnalysis;
+
+/// <summary>
+/// This method's instructions have been deduplicated by the compiler, and it shares its address with other methods.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+public sealed class DeduplicatedMethodAttribute : Attribute
+{
+}
+
+/// <summary>
+/// A problem was encountered while analyzing this method's instructions.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+public sealed class CallAnalysisFailedAttribute : Attribute
+{
+}
+
+/// <summary>
+/// This method has no instructions to analyze and is not abstract nor an interface declaration.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+public sealed class CallAnalysisNotSupportedAttribute : Attribute
+{
+}
+
+/// <summary>
+/// This method is called from the method specified.
+/// </summary>
+/// <remarks>
+/// This attribute is not emitted if there are a large amount of callers.
+/// </remarks>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+public sealed class CalledByAttribute : Attribute
+{
+	public Type Type;
+
+	public string Member;
+}
+
+/// <summary>
+/// This method calls the method specified.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+public sealed class CallsAttribute : Attribute
+{
+	public Type Type;
+
+	public string Member;
+}
+
+/// <summary>
+/// The number of direct calls to this method.
+/// </summary>
+/// <remarks>
+/// This attribute is similar in form and function to the one generated by <see href="https://github.com/knah/Il2CppAssemblyUnhollower">Unhollower</see>.
+/// </remarks>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+public sealed class CallerCountAttribute : Attribute
+{
+	public int Count;
+}
+
+/// <summary>
+/// This method calls at least one deduplicated method.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+public sealed class CallsDeduplicatedMethodsAttribute : Attribute
+{
+	public int Count;
+}
+
+/// <summary>
+/// This method calls at least one unknown method.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+public sealed class CallsUnknownMethodsAttribute : Attribute
+{
+	public int Count;
+}
+```