Lib: Support v35, v38, v39

Author: SamboyCoding

Cpp2IL.Core/Model/Contexts/HasCustomAttributes.cs

@@ -119,7 +119,7 @@ protected void InitCustomAttributeData()
 
         AttributeTypes = Enumerable.Range(AttributeTypeRange.start, AttributeTypeRange.count)
             .Select(attrIdx => AppContext.Metadata!.attributeTypes![attrIdx]) //Not null because we've checked we're not on v29
-            .Select(typeIdx => AppContext.Binary!.GetType(typeIdx))
+            .Select(typeIdx => AppContext.Binary!.GetType(Il2CppVariableWidthIndex<Il2CppType>.MakeTemporaryForFixedWidthUsage(typeIdx)))
             .ToList();
     }
 
@@ -146,8 +146,8 @@ protected void InitCustomAttributeData()
         var attributeDataRange = AppContext.Metadata.AttributeDataRanges[caIndex];
         var next = AppContext.Metadata.AttributeDataRanges[caIndex + 1];
 
-        var blobStart = AppContext.Metadata.metadataHeader.attributeDataOffset + attributeDataRange.startOffset;
-        var blobEnd = AppContext.Metadata.metadataHeader.attributeDataOffset + next.startOffset;
+        var blobStart = AppContext.Metadata.metadataHeader.attributeData.Offset + attributeDataRange.startOffset;
+        var blobEnd = AppContext.Metadata.metadataHeader.attributeData.Offset + next.startOffset;
         return (blobStart, blobEnd);
     }
 

Cpp2IL.Core/Model/Contexts/ParameterAnalysisContext.cs

@@ -82,7 +82,7 @@ public ParameterAnalysisContext(Il2CppParameterDefinition? definition, int param
 
             if (Attributes.HasFlag(ParameterAttributes.HasDefault))
             {
-                DefaultValue = AppContext.Metadata.GetParameterDefaultValueFromIndex(declaringMethod.Definition!.parameterStart + parameterIndex)!;
+                DefaultValue = AppContext.Metadata.GetParameterDefaultValueFromIndex(declaringMethod.Definition!.parameterStart.Value + parameterIndex)!;
             }
         }
     }

Cpp2IL.Core/Model/CustomAttributes/CustomAttributeArrayParameter.cs

@@ -5,6 +5,7 @@
 using Cpp2IL.Core.Model.Contexts;
 using Cpp2IL.Core.Utils;
 using LibCpp2IL.BinaryStructures;
+using LibCpp2IL.Metadata;
 
 namespace Cpp2IL.Core.Model.CustomAttributes;
 
@@ -45,7 +46,7 @@ public override void ReadFromV29Blob(BinaryReader reader, ApplicationAnalysisCon
             var enumTypeIndex = reader.BaseStream.ReadUnityCompressedInt();
 
             //Save the actual enum type for later.
-            EnumType = context.Binary.GetType(enumTypeIndex);
+            EnumType = context.Binary.GetType(Il2CppVariableWidthIndex<Il2CppType>.MakeTemporaryForFixedWidthUsage(enumTypeIndex)); //DynWidth: enumTypeIndex is already compressed, they didn't make it dynamic
 
             //We read as the primitive underlying type.
             var enumClass = EnumType.AsClass();

Cpp2IL.Core/Model/CustomAttributes/CustomAttributeTypeParameter.cs

@@ -4,6 +4,7 @@
 using Cpp2IL.Core.Utils;
 using LibCpp2IL;
 using LibCpp2IL.BinaryStructures;
+using LibCpp2IL.Metadata;
 
 namespace Cpp2IL.Core.Model.CustomAttributes;
 
@@ -44,7 +45,7 @@ public override void ReadFromV29Blob(BinaryReader reader, ApplicationAnalysisCon
             _type = null;
         else
         {
-            _type = context.Binary.GetType(typeIndex);
+            _type = context.Binary.GetType(Il2CppVariableWidthIndex<Il2CppType>.MakeTemporaryForFixedWidthUsage(typeIndex)); //DynWidth: typeIndex is already compressed, they didn't make it dynamic
         }
         _typeContext = null;
     }

Cpp2IL.Core/Utils/AsmResolver/AsmResolverUtils.cs

@@ -6,6 +6,7 @@
 using AsmResolver.DotNet;
 using AsmResolver.DotNet.Signatures;
 using LibCpp2IL.BinaryStructures;
+using LibCpp2IL.Metadata;
 
 namespace Cpp2IL.Core.Utils.AsmResolver;
 
@@ -14,7 +15,7 @@ public static class AsmResolverUtils
     private static readonly ConcurrentDictionary<string, TypeDefinition?> CachedTypeDefsByName = new();
     private static readonly ConcurrentDictionary<string, TypeSignature?> CachedTypeSignaturesByName = new();
 
-    public static readonly ConcurrentDictionary<long, TypeDefinition> TypeDefsByIndex = new();
+    public static readonly ConcurrentDictionary<Il2CppVariableWidthIndex<Il2CppTypeDefinition>, TypeDefinition> TypeDefsByIndex = new();
 
     internal static void Reset()
     {

Cpp2IL.Core/Utils/V29AttributeUtils.cs

@@ -83,7 +83,7 @@ private static T ResolveMemberFromIndex<T>(Stream stream, MethodAnalysisContext
             memberIndex = -(memberIndex + 1);
 
             //Resolve type
-            var typeDef = context.Metadata.typeDefs[typeIndex];
+            var typeDef = context.Metadata.GetTypeDefinitionFromIndex(Il2CppVariableWidthIndex<Il2CppTypeDefinition>.MakeTemporaryForFixedWidthUsage((int)typeIndex)); //DynWidth: typeIndex is already compressed, they didn't make it dynamic
             var typeContext = context.ResolveContextForType(typeDef) ?? throw new("Unable to find type " + typeDef);
 
             //Get member
@@ -118,7 +118,7 @@ public static BaseCustomAttributeParameter ConstructParameterForType(BinaryReade
         {
             case Il2CppTypeEnum.IL2CPP_TYPE_ENUM:
                 var enumTypeIndex = reader.BaseStream.ReadUnityCompressedInt();
-                var enumType = context.Binary.GetType(enumTypeIndex);
+                var enumType = context.Binary.GetType(Il2CppVariableWidthIndex<Il2CppType>.MakeTemporaryForFixedWidthUsage(enumTypeIndex)); //DynWidth: enumTypeIndex is already compressed, they didn't make it dynamic
                 return new CustomAttributeEnumParameter(enumType, context, owner, kind, index);
             case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
                 return new CustomAttributeArrayParameter(owner, kind, index);

Cpp2IL.Plugin.StrippedCodeRegSupport/StrippedCodeRegSupportPlugin.cs

@@ -38,7 +38,7 @@ private void OnReadFail(Il2CppBinary binary, Il2CppMetadata metadata, ref Il2Cpp
 
         //All we NEED to find is pCodegenModules - the rest of the CodeRegistration struct isn't critical to a successful dump.
         //We can piggyback off BinarySearcher:
-        var searcher = new BinarySearcher(binary, metadata.methodDefs.Length, metadata.typeDefs.Length);
+        var searcher = new BinarySearcher(binary, metadata.methodDefs.Length, metadata.TypeDefinitionCount);
 
         var mscorlibs = searcher.FindAllStrings("mscorlib.dll\0").Select(binary.MapRawAddressToVirtual).ToList();
 

LibCpp2IL/BinarySearcher.cs

@@ -287,9 +287,9 @@ public ulong FindMetadataRegistrationPre24_5()
 
         var bytesToSubtract = sizeOfMr - ptrSize * 4;
 
-        var potentialMetaRegPointers = MapOffsetsToVirt(FindAllBytes(BitConverter.GetBytes(LibCpp2IlMain.TheMetadata!.typeDefs.Length), 1)).ToList();
+        var potentialMetaRegPointers = MapOffsetsToVirt(FindAllBytes(BitConverter.GetBytes(LibCpp2IlMain.TheMetadata!.TypeDefinitionCount), 1)).ToList();
 
-        LibLogger.VerboseNewline($"\t\t\tFound {potentialMetaRegPointers.Count} instances of the number of type defs, {LibCpp2IlMain.TheMetadata.typeDefs.Length}");
+        LibLogger.VerboseNewline($"\t\t\tFound {potentialMetaRegPointers.Count} instances of the number of type defs, {LibCpp2IlMain.TheMetadata.TypeDefinitionCount}");
 
         potentialMetaRegPointers = potentialMetaRegPointers.Select(p => p - bytesToSubtract).ToList();
 
@@ -347,6 +347,7 @@ public ulong FindMetadataRegistrationPost24_5(Il2CppMetadata metadata)
                         if (mrWords[i] == 0)
                         {
                             ok = i >= 14; //Maybe need an investigation here, but metadataUsages can be (always is?) a null ptr on v27
+                            ok |= i == 1; //genericClasses can rarely be null on v39?
                             if (!ok)
                                 LibLogger.VerboseNewline($"\t\t\tRejecting metadata registration 0x{va:X} because the pointer at index {i} is 0.");
                         }
@@ -372,22 +373,22 @@ public ulong FindMetadataRegistrationPost24_5(Il2CppMetadata metadata)
                         // continue;
                     }
 
-                    if (metaReg.typeDefinitionsSizesCount != metadata.typeDefs.Length)
+                    if (metaReg.typeDefinitionsSizesCount != metadata.TypeDefinitionCount)
                     {
-                        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");
+                        LibLogger.VerboseNewline($"\t\t\tRejecting metadata registration 0x{va:X} because it has {metaReg.typeDefinitionsSizesCount} type def sizes, while metadata file defines {metadata.TypeDefinitionCount} type defs");
                         continue;
                     }
 
-                    if (metaReg.numTypes < metadata.typeDefs.Length)
+                    if (metaReg.numTypes < metadata.TypeDefinitionCount)
                     {
-                        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}");
+                        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.TypeDefinitionCount}");
                         continue;
                     }
 
-                    if (metaReg.fieldOffsetsCount != metadata.typeDefs.Length)
+                    if (metaReg.fieldOffsetsCount != metadata.TypeDefinitionCount)
                     {
                         //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 {metadata.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.TypeDefinitionCount} type defs");
                         continue;
                     }
 

LibCpp2IL/BinaryStructures/Il2CppGenericClass.cs

@@ -4,19 +4,26 @@ namespace LibCpp2IL.BinaryStructures;
 
 public class Il2CppGenericClass : ReadableClass
 {
-    public long TypeDefinitionIndex; /* the generic type definition */
+    [Version(Max = 24.5f)] public long TypeDefinitionIndex; /* the generic type definition */
+
+    [Version(Min = 27.0f)] public ulong V27TypePointer;
+    
     public Il2CppGenericContext Context = null!; /* a context that contains the type instantiation doesn't contain any method instantiation */
     public ulong CachedClass; /* if present, the Il2CppClass corresponding to the instantiation.  */
 
     public Il2CppTypeDefinition TypeDefinition => LibCpp2IlMain.MetadataVersion < 27f
-        ? LibCpp2IlMain.TheMetadata!.typeDefs[(int)TypeDefinitionIndex]
+        ? LibCpp2IlMain.TheMetadata!.GetTypeDefinitionFromIndex(Il2CppVariableWidthIndex<Il2CppTypeDefinition>.MakeTemporaryForFixedWidthUsage((int)TypeDefinitionIndex)) //DynWidth: TypeDefinitionIndex removed in v24.5, never dynamic
         : V27BaseType!.AsClass();
 
-    public Il2CppType? V27BaseType => LibCpp2IlMain.MetadataVersion < 27f ? null : LibCpp2IlMain.Binary!.ReadReadableAtVirtualAddress<Il2CppType>((ulong)TypeDefinitionIndex);
+    public Il2CppType? V27BaseType => LibCpp2IlMain.MetadataVersion < 27f ? null : LibCpp2IlMain.Binary!.ReadReadableAtVirtualAddress<Il2CppType>(V27TypePointer);
 
     public override void Read(ClassReadingBinaryReader reader)
     {
-        TypeDefinitionIndex = reader.ReadNInt();
+        if (IsAtLeast(27f))
+            V27TypePointer = reader.ReadNUint();
+        else
+            TypeDefinitionIndex = reader.ReadNInt();
+        
         Context = reader.ReadReadableHereNoLock<Il2CppGenericContext>();
         CachedClass = reader.ReadNUint();
     }

LibCpp2IL/BinaryStructures/Il2CppRGCTXDefinition.cs

@@ -1,3 +1,4 @@
+using LibCpp2IL.Metadata;
 using LibCpp2IL.Reflection;
 
 namespace LibCpp2IL.BinaryStructures;
@@ -13,7 +14,7 @@ public class Il2CppRGCTXDefinition : ReadableClass
 
     public Il2CppMethodSpec? MethodSpec => LibCpp2IlMain.Binary?.GetMethodSpec(MethodIndex);
 
-    public Il2CppTypeReflectionData? Type => LibCpp2ILUtils.GetTypeReflectionData(LibCpp2IlMain.Binary!.GetType(TypeIndex));
+    public Il2CppTypeReflectionData? Type => LibCpp2ILUtils.GetTypeReflectionData(LibCpp2IlMain.Binary!.GetType(Il2CppVariableWidthIndex<Il2CppType>.MakeTemporaryForFixedWidthUsage(TypeIndex)));
 
 
     public class Il2CppRGCTXDefinitionData : ReadableClass