Factor out some usage of static state

Author: SamboyCoding

Cpp2IL.Core/Cpp2IlApi.cs

@@ -107,7 +107,7 @@ private static void OnLibInitialized()
 
  var start = DateTime.Now;
  Logger.InfoNewline("Creating application model...");
- CurrentAppContext = new(LibCpp2IlMain.Binary, LibCpp2IlMain.TheMetadata!, LibCpp2IlMain.MetadataVersion);
+ CurrentAppContext = new(LibCpp2IlMain.Binary, LibCpp2IlMain.TheMetadata!);
  Logger.InfoNewline($"Application model created in {(DateTime.Now - start).TotalMilliseconds}ms");
  }
 

Cpp2IL.Core/Model/Contexts/ApplicationAnalysisContext.cs

@@ -28,7 +28,7 @@ public class ApplicationAnalysisContext : ContextWithDataStorage
  /// <summary>
  /// The version of the IL2CPP metadata file this application was loaded from.
  /// </summary>
- public readonly float MetadataVersion;
+ public float MetadataVersion => Metadata.MetadataVersion;
 
  /// <summary>
  /// The instruction set helper class associated with the instruction set that this application was compiled with.
@@ -70,11 +70,10 @@ public class ApplicationAnalysisContext : ContextWithDataStorage
  /// </summary>
  public bool HasFinishedInitializing { get; private set; }
 
- public ApplicationAnalysisContext(Il2CppBinary binary, Il2CppMetadata metadata, float metadataVersion)
+ public ApplicationAnalysisContext(Il2CppBinary binary, Il2CppMetadata metadata)
  {
  Binary = binary;
  Metadata = metadata;
- MetadataVersion = metadataVersion;
 
  try
  {

Cpp2IL.Core/Model/Contexts/HasCustomAttributes.cs

@@ -98,8 +98,8 @@ protected void InitCustomAttributeData()
  }
 
  AttributeTypes = Enumerable.Range(AttributeTypeRange.start, AttributeTypeRange.count)
- .Select(attrIdx => LibCpp2IlMain.TheMetadata!.attributeTypes[attrIdx])
- .Select(typeIdx => LibCpp2IlMain.Binary!.GetType(typeIdx))
+ .Select(attrIdx => AppContext.Metadata!.attributeTypes![attrIdx]) //Not null because we've checked we're not on v29
+ .Select(typeIdx => AppContext.Binary!.GetType(typeIdx))
  .ToList();
 
  ulong generatorPtr;

Cpp2IL.Core/ProcessingLayers/AttributeInjectorProcessingLayer.cs

@@ -133,7 +133,7 @@ private static void InjectTokenAttribute(ApplicationAnalysisContext appContext)
 
  private static void InjectAttributeAttribute(ApplicationAnalysisContext appContext)
  {
- if (LibCpp2IlMain.MetadataVersion >= 29f)
+ 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

Cpp2IL.Core/Utils/AsmResolver/AsmResolverUtils.cs

@@ -112,7 +112,7 @@ public static TypeSignature GetTypeSignatureFromIl2CppType(ModuleDefinition modu
 
  //Get base type
  TypeDefsByIndex.TryGetValue(genericClass.TypeDefinitionIndex, out var typeDefinition);
- if (LibCpp2IlMain.MetadataVersion >= 27f)
+ if (Cpp2IlApi.CurrentAppContext!.MetadataVersion >= 27f) //TODO: we should pass in the app context to this method
  {
  //V27 - type indexes are pointers now.
  var type = LibCpp2IlMain.Binary!.ReadReadableAtVirtualAddress<Il2CppType>((ulong)genericClass.TypeDefinitionIndex);
@@ -121,15 +121,6 @@ public static TypeSignature GetTypeSignatureFromIl2CppType(ModuleDefinition modu
 
  var genericInstanceType = new GenericInstanceTypeSignature(typeDefinition!, typeDefinition!.IsValueType);
 
- //If the generic type is declared in a type with generic params, we have to fill all its parent's params with dummy values.
- // if (typeDefinition.DeclaringType?.GenericParameters?.Count is {} declTypeGpCount)
- // {
- // for (var i = 0; i < declTypeGpCount; i++)
- // {
- // genericInstanceType.TypeArguments.Add(TypeDefinitionsAsmResolver.Object.ToTypeSignature());
- // }
- // }
-
  //Get generic arguments
  var genericArgumentTypes = genericClass.Context.ClassInst.Types;
 

Cpp2IL.Core/Utils/MiscUtils.cs

@@ -170,8 +170,8 @@ internal static byte[] RawBytes(IConvertible original) =>
 
  private static void InitFunctionStarts()
  {
- _allKnownFunctionStarts = LibCpp2IlMain.TheMetadata!.methodDefs.Select(m => m.MethodPointer)
- .Concat(LibCpp2IlMain.Binary!.ConcreteGenericImplementationsByAddress.Keys)
+ _allKnownFunctionStarts = Cpp2IlApi.CurrentAppContext!.Metadata.methodDefs.Select(m => m.MethodPointer)
+ .Concat(Cpp2IlApi.CurrentAppContext.Binary.ConcreteGenericImplementationsByAddress.Keys)
  .Concat(SharedState.AttributeGeneratorStarts)
  .ToList();
 
@@ -264,10 +264,10 @@ public static string AnalyzeStackTracePointers(ulong[] pointers)
  {
  // var pointers = new ulong[] {0x52e6ba0, 0x52ad3a0, 0x11b09714, 0x40a990c, 0xd172c68, 0xa2c0514, 0x35ea45c, 0x1fc43208};
 
- var methodsSortedByPointer = LibCpp2IlMain.TheMetadata!.methodDefs.ToList();
+ var methodsSortedByPointer = Cpp2IlApi.CurrentAppContext!.Metadata.methodDefs.ToList();
  methodsSortedByPointer.SortByExtractedKey(m => m.MethodPointer);
 
- var genericMethodsSortedByPointer = LibCpp2IlMain.Binary!.ConcreteGenericImplementationsByAddress.ToList();
+ var genericMethodsSortedByPointer = Cpp2IlApi.CurrentAppContext.Binary.ConcreteGenericImplementationsByAddress.ToList();
  genericMethodsSortedByPointer.SortByExtractedKey(m => m.Key);
 
  var stack = pointers.Select(p =>

Cpp2IL.Plugin.StrippedCodeRegSupport/StrippedCodeRegSupportPlugin.cs

@@ -30,7 +30,7 @@ private void OnReadFail(Il2CppBinary binary, Il2CppMetadata metadata, ref Il2Cpp
  //We don't have a CodeRegistration, so we need to try and find one.
  Logger.InfoNewline("Received read failure for CodeRegistration, implying it may have been stripped. Attempting to work around...");
 
- if (LibCpp2IlMain.MetadataVersion < MinSupportedMetadataVersion)
+ if (metadata.MetadataVersion < MinSupportedMetadataVersion)
  {
  Logger.ErrorNewline($"This game's metadata version is too old to support this plugin (it needs to be at least Metadata {MinSupportedMetadataVersion:F1}, i.e. Unity 2020.2 or newer).");
  return;

LibCpp2IL/BinarySearcher.cs

@@ -6,6 +6,7 @@
 using System.Text;
 using LibCpp2IL.BinaryStructures;
 using LibCpp2IL.Logging;
+using LibCpp2IL.Metadata;
 using LibCpp2IL.NintendoSwitch;
 using LibCpp2IL.Wasm;
 
@@ -124,7 +125,7 @@ public ulong FindCodeRegistrationPre2019()
  }
 
  [SuppressMessage("ReSharper", "PossibleMultipleEnumeration")]
- internal ulong FindCodeRegistrationPost2019()
+ internal ulong FindCodeRegistrationPost2019(Il2CppMetadata metadata)
  {
  //Works only on >=24.2
  var mscorlibs = FindAllStrings("mscorlib.dll\0").Select(idx => binary.MapRawAddressToVirtual(idx)).ToList();
@@ -148,7 +149,7 @@ internal ulong FindCodeRegistrationPost2019()
  var ptrSize = (binary.is32Bit ? 4u : 8u);
 
  List<ulong>? pCodegenModules = null;
- if (LibCpp2IlMain.MetadataVersion < 27f)
+ if (metadata.MetadataVersion < 27f)
  {
  //Pre-v27, mscorlib is the first codegen module, so *MscorlibCodegenEntryInCodegenModulesList == g_CodegenModules, so we can just find a pointer to this.
  if (pMscorlibCodegenEntryInCodegenModulesList.Count == 1)
@@ -209,7 +210,7 @@ internal ulong FindCodeRegistrationPost2019()
 
  //We have pCodegenModules which *should* be x-reffed in the last pointer of Il2CppCodeRegistration.
  //So, subtract the size of one pointer from that...
- var bytesToGoBack = (ulong)Il2CppCodeRegistration.GetStructSize(binary.is32Bit, LibCpp2IlMain.MetadataVersion) - ptrSize;
+ var bytesToGoBack = (ulong)Il2CppCodeRegistration.GetStructSize(binary.is32Bit, metadata.MetadataVersion) - ptrSize;
 
  LibLogger.VerboseNewline($"\t\t\tpCodegenModules is the second-to-last field of the codereg struct. Therefore on this version and architecture, we need to subtract {bytesToGoBack} bytes from its address to get pCodeReg");
 
@@ -308,7 +309,7 @@ public ulong FindMetadataRegistrationPre24_5()
  return 0;
  }
 
- public ulong FindMetadataRegistrationPost24_5()
+ public ulong FindMetadataRegistrationPost24_5(Il2CppMetadata metadata)
  {
  var ptrSize = binary.is32Bit ? 4ul : 8ul;
  var sizeOfMr = (uint)Il2CppMetadataRegistration.GetStructSize(binary.is32Bit);
@@ -364,29 +365,29 @@ public ulong FindMetadataRegistrationPost24_5()
  if (ok)
  {
  var metaReg = binary.ReadReadableAtVirtualAddress<Il2CppMetadataRegistration>(va);
- if (LibCpp2IlMain.MetadataVersion >= 27f && (metaReg.metadataUsagesCount != 0 || metaReg.metadataUsages != 0))
+ if (metadata.MetadataVersion >= 27f && (metaReg.metadataUsagesCount != 0 || metaReg.metadataUsages != 0))
  {
  //Too many metadata usages - should be 0 on v27
  LibLogger.VerboseNewline($"\t\t\tWarning: metadata registration 0x{va:X} has {metaReg.metadataUsagesCount} metadata usages at a pointer of 0x{metaReg.metadataUsages:X}. We're on v27, these should be 0.");
  // continue;
  }
 
- if (metaReg.typeDefinitionsSizesCount != LibCpp2IlMain.TheMetadata!.typeDefs.Length)
+ if (metaReg.typeDefinitionsSizesCount != metadata.typeDefs.Length)
  {
- LibLogger.VerboseNewline($"\t\t\tRejecting metadata registration 0x{va:X} because it has {metaReg.typeDefinitionsSizesCount} type def sizes, while metadata file defines {LibCpp2IlMain.TheMetadata!.typeDefs.Length} type defs");
+ LibLogger.VerboseNewline($"\t\t\tRejecting metadata registration 0x{va:X} because it has {metaReg.typeDefinitionsSizesCount} type def sizes, while metadata file defines {metadata.typeDefs.Length} type defs");
  continue;
  }
 
- if (metaReg.numTypes < LibCpp2IlMain.TheMetadata!.typeDefs.Length)
+ if (metaReg.numTypes < metadata.typeDefs.Length)
  {
- LibLogger.VerboseNewline($"\t\t\tRejecting metadata registration 0x{va:X} because it has {metaReg.numTypes} types, which is less than metadata-file-defined type def count of {LibCpp2IlMain.TheMetadata!.typeDefs.Length}");
+ LibLogger.VerboseNewline($"\t\t\tRejecting metadata registration 0x{va:X} because it has {metaReg.numTypes} types, which is less than metadata-file-defined type def count of {metadata.typeDefs.Length}");
  continue;
  }
 
- if (metaReg.fieldOffsetsCount != LibCpp2IlMain.TheMetadata!.typeDefs.Length)
+ if (metaReg.fieldOffsetsCount != metadata.typeDefs.Length)
  {
  //If we see any cases of failing to find meta reg and this line is in verbose log, maybe the assumption (num field offsets == num type defs) is wrong.
- LibLogger.VerboseNewline($"\t\t\tRejecting metadata registration 0x{va:X} because it has {metaReg.fieldOffsetsCount} field offsets, while metadata file defines {LibCpp2IlMain.TheMetadata!.typeDefs.Length} type defs");
+ LibLogger.VerboseNewline($"\t\t\tRejecting metadata registration 0x{va:X} because it has {metaReg.fieldOffsetsCount} field offsets, while metadata file defines {metadata.typeDefs.Length} type defs");
  continue;
  }
 

LibCpp2IL/Elf/ElfFile.cs

@@ -4,6 +4,7 @@
 using System.IO;
 using System.Linq;
 using LibCpp2IL.Logging;
+using LibCpp2IL.Metadata;
 using LibCpp2IL.PE;
 
 namespace LibCpp2IL.Elf;
@@ -470,7 +471,7 @@ private void ProcessInitializers()
  _initializerPointers = initArray.Select(a => MapVirtualAddressToRaw(a)).ToList();
  }
 
- public override (ulong pCodeRegistration, ulong pMetadataRegistration) FindCodeAndMetadataReg(int methodCount, int typeDefinitionsCount)
+ public override (ulong pCodeRegistration, ulong pMetadataRegistration) FindCodeAndMetadataReg(Il2CppMetadata metadata)
  {
  //Let's just try and be cheap here and find them in the symbol table.
 
@@ -492,21 +493,21 @@ public override (ulong pCodeRegistration, ulong pMetadataRegistration) FindCodeA
  LibLogger.VerboseNewline("Didn't find them, scanning binary...");
 
  //Well, that didn't work. Look for the specific initializer function which calls into Il2CppCodegenRegistration.
- if (InstructionSetId == DefaultInstructionSets.ARM_V7 && LibCpp2IlMain.MetadataVersion < 24.2f)
+ if (InstructionSetId == DefaultInstructionSets.ARM_V7 && metadata.MetadataVersion < 24.2f)
  {
  var ret = FindCodeAndMetadataRegArm32();
  if (ret != (0, 0))
  return ret;
  }
 
- if (InstructionSetId == DefaultInstructionSets.ARM_V8 && LibCpp2IlMain.MetadataVersion < 24.2f)
+ if (InstructionSetId == DefaultInstructionSets.ARM_V8 && metadata.MetadataVersion < 24.2f)
  {
  var ret = FindCodeAndMetadataRegArm64();
  if (ret != (0, 0))
  return ret;
  }
 
- return FindCodeAndMetadataRegDefaultBehavior(methodCount, typeDefinitionsCount);
+ return FindCodeAndMetadataRegDefaultBehavior(metadata);
  }
 
  private (ulong codeReg, ulong metaReg) FindCodeAndMetadataRegArm32()
@@ -662,17 +663,20 @@ public override (ulong pCodeRegistration, ulong pMetadataRegistration) FindCodeA
  return (0, 0);
  }
 
- private (ulong codeReg, ulong metaReg) FindCodeAndMetadataRegDefaultBehavior(int methodCount, int typeDefinitionsCount)
+ private (ulong codeReg, ulong metaReg) FindCodeAndMetadataRegDefaultBehavior(Il2CppMetadata metadata)
  {
+ var methodCount = metadata.methodDefs.Count(x => x.methodIndex >= 0);
+ var typeDefinitionsCount = metadata.typeDefs.Length;
+ 
  LibLogger.VerboseNewline("Searching for il2cpp structures in an ELF binary using non-arch-specific method...");
  var searcher = new BinarySearcher(this, methodCount, typeDefinitionsCount);
 
  LibLogger.VerboseNewline("\tLooking for code reg (this might take a while)...");
- var codeReg = LibCpp2IlMain.MetadataVersion >= 24.2f ? searcher.FindCodeRegistrationPost2019() : searcher.FindCodeRegistrationPre2019();
+ var codeReg = metadata.MetadataVersion >= 24.2f ? searcher.FindCodeRegistrationPost2019(metadata) : searcher.FindCodeRegistrationPre2019();
  LibLogger.VerboseNewline($"\tGot code reg 0x{codeReg:X}");
 
- LibLogger.VerboseNewline($"\tLooking for meta reg ({(LibCpp2IlMain.MetadataVersion >= 27f ? "post-27" : "pre-27")})...");
- var metaReg = LibCpp2IlMain.MetadataVersion >= 27f ? searcher.FindMetadataRegistrationPost24_5() : searcher.FindMetadataRegistrationPre24_5();
+ LibLogger.VerboseNewline($"\tLooking for meta reg ({(metadata.MetadataVersion >= 27f ? "post-27" : "pre-27")})...");
+ var metaReg = metadata.MetadataVersion >= 27f ? searcher.FindMetadataRegistrationPost24_5(metadata) : searcher.FindMetadataRegistrationPre24_5();
  LibLogger.VerboseNewline($"\tGot meta reg 0x{metaReg:x}");
 
  return (codeReg, metaReg);

LibCpp2IL/Il2CppBinary.cs

@@ -62,7 +62,7 @@ public abstract class Il2CppBinary(MemoryStream input) : ClassReadingBinaryReade
 
  public int InBinaryMetadataSize { get; private set; }
 
- public void Init(ulong pCodeRegistration, ulong pMetadataRegistration)
+ public void Init(ulong pCodeRegistration, ulong pMetadataRegistration, Il2CppMetadata metadata)
  {
  var cr = pCodeRegistration > 0 ? ReadReadableAtVirtualAddress<Il2CppCodeRegistration>(pCodeRegistration) : null;
  var mr = pMetadataRegistration > 0 ? ReadReadableAtVirtualAddress<Il2CppMetadataRegistration>(pMetadataRegistration) : null;
@@ -112,7 +112,7 @@ public void Init(ulong pCodeRegistration, ulong pMetadataRegistration)
 
  InBinaryMetadataSize += GetNumBytesReadSinceLastCallAndClear();
 
- if (LibCpp2IlMain.MetadataVersion < 27)
+ if (metadata.MetadataVersion < 27)
  {
  LibLogger.Verbose("\tReading custom attribute generators...");
  start = DateTime.Now;
@@ -161,7 +161,7 @@ public void Init(ulong pCodeRegistration, ulong pMetadataRegistration)
 
  InBinaryMetadataSize += GetNumBytesReadSinceLastCallAndClear();
 
- if (LibCpp2IlMain.MetadataVersion >= 24.2f)
+ if (metadata.MetadataVersion >= 24.2f)
  {
  LibLogger.VerboseNewline("\tReading code gen modules...");
  start = DateTime.Now;
@@ -472,25 +472,28 @@ public virtual bool TryGetExportedFunctionName(ulong addr, [NotNullWhen(true)] o
 
  public abstract ulong GetVirtualAddressOfPrimaryExecutableSection();
 
- public virtual (ulong pCodeRegistration, ulong pMetadataRegistration) FindCodeAndMetadataReg(int methodCount, int typeDefinitionsCount)
+ public virtual (ulong pCodeRegistration, ulong pMetadataRegistration) FindCodeAndMetadataReg(Il2CppMetadata metadata)
  {
  LibLogger.VerboseNewline("\tAttempting to locate code and metadata registration functions...");
 
+ var methodCount = metadata.methodDefs.Count(x => x.methodIndex >= 0);
+ var typeDefinitionsCount = metadata.typeDefs.Length;
+
  var plusSearch = new BinarySearcher(this, methodCount, typeDefinitionsCount);
 
  LibLogger.VerboseNewline("\t\t-Searching for MetadataReg...");
 
- var pMetadataRegistration = LibCpp2IlMain.MetadataVersion < 24.5f
+ var pMetadataRegistration = metadata.MetadataVersion < 24.5f
  ? plusSearch.FindMetadataRegistrationPre24_5()
- : plusSearch.FindMetadataRegistrationPost24_5();
+ : plusSearch.FindMetadataRegistrationPost24_5(metadata);
 
  LibLogger.VerboseNewline("\t\t-Searching for CodeReg...");
 
  ulong pCodeRegistration;
- if (LibCpp2IlMain.MetadataVersion >= 24.2f)
+ if (metadata.MetadataVersion >= 24.2f)
  {
  LibLogger.VerboseNewline("\t\t\tUsing mscorlib full-disassembly approach to get codereg, this may take a while...");
- pCodeRegistration = plusSearch.FindCodeRegistrationPost2019();
+ pCodeRegistration = plusSearch.FindCodeRegistrationPost2019(metadata);
  }
  else
  pCodeRegistration = plusSearch.FindCodeRegistrationPre2019();