private static string GetTypeName(Il2CppType pType) { string ret; switch (pType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: { var klass = metadata.typeDefs[pType.data.klassIndex]; ret = metadata.GetStringFromIndex(klass.nameIndex); break; } case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { var generic_class = il2cpp.MapVATR <Il2CppGenericClass>(pType.data.generic_class); var pMainDef = metadata.typeDefs[generic_class.typeDefinitionIndex]; ret = metadata.GetStringFromIndex(pMainDef.nameIndex); var typeNames = new List <string>(); var pInst = il2cpp.MapVATR <Il2CppGenericInst>(generic_class.context.class_inst); var pointers = il2cpp.GetPointers(pInst.type_argv, (long)pInst.type_argc); for (uint i = 0; i < pInst.type_argc; ++i) { var pOriType = il2cpp.GetIl2CppType(pointers[i]); typeNames.Add(GetTypeName(pOriType)); } ret += $"<{string.Join(", ", typeNames)}>"; break; } case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: { var arrayType = il2cpp.MapVATR <Il2CppArrayType>(pType.data.array); var type = il2cpp.GetIl2CppType(arrayType.etype); ret = $"{GetTypeName(type)}[{new string(',', arrayType.rank - 1)}]"; break; } case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: { var type = il2cpp.GetIl2CppType(pType.data.type); ret = $"{GetTypeName(type)}[]"; break; } case Il2CppTypeEnum.IL2CPP_TYPE_PTR: { var type = il2cpp.GetIl2CppType(pType.data.type); ret = $"{GetTypeName(type)}*"; break; } default: ret = TypeString[(int)pType.type]; break; } return(ret); }
public Il2CppTypeDefinition GetTypeDefinitionFromIl2CppType(Il2CppType il2CppType) { if (il2Cpp.Version >= 27 && il2Cpp is ElfBase elf && elf.IsDumped) { var offset = il2CppType.data.typeHandle - metadata.Address - metadata.header.typeDefinitionsOffset; var index = offset / (ulong)metadata.SizeOf(typeof(Il2CppTypeDefinition)); return(metadata.typeDefs[index]); }
private bool IsValueType(Il2CppType il2CppType, Il2CppGenericContext context) { switch (il2CppType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: { var typeDef = metadata.typeDefs[il2CppType.data.klassIndex]; if (!typeDef.IsEnum) { return(true); } else { return(false); } } case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class); var typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex]; return(typeDef.IsValueType); } case Il2CppTypeEnum.IL2CPP_TYPE_VAR: { if (context != null) { var genericParameter = metadata.genericParameters[il2CppType.data.genericParameterIndex]; var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(context.class_inst); var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc); var pointer = pointers[genericParameter.num]; var type = il2Cpp.GetIl2CppType(pointer); return(IsValueType(type, null)); } return(false); } case Il2CppTypeEnum.IL2CPP_TYPE_MVAR: { if (context != null) { var genericParameter = metadata.genericParameters[il2CppType.data.genericParameterIndex]; var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(context.method_inst); var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc); var pointer = pointers[genericParameter.num]; var type = il2Cpp.GetIl2CppType(pointer); return(IsValueType(type, null)); } return(false); } default: return(false); } }
private TypeReference GetBlobValueTypeReference(BlobValue blobValue, MemberReference memberReference) { if (blobValue.EnumType != null) { return(GetTypeReference(memberReference, blobValue.EnumType)); } var il2CppType = new Il2CppType(); il2CppType.type = blobValue.il2CppTypeEnum; return(GetTypeReference(memberReference, il2CppType)); }
private string include_path(Il2CppType type) { string output; string type_name = ""; switch (type.type) { case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: { return("cs/array"); } case Il2CppTypeEnum.IL2CPP_TYPE_STRING: { return("cs/string"); } case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { Il2CppTypeDefinition typeDef; Il2CppGenericClass genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(type.data.generic_class); typeDef = executor.GetGenericClassTypeDefinition(genericClass); var @namespace = metadata.GetStringFromIndex(typeDef.namespaceIndex); if (@namespace != "") { type_name += @namespace + "."; } type_name += metadata.GetStringFromIndex(typeDef.nameIndex); var index = type_name.IndexOf("`"); if (index != -1) { type_name = type_name.Substring(0, index); } break; } default: type_name = executor.GetTypeName(type, true, false); break; } type_name = deobfu(type_name); type_name = type_name.Replace(".", "/"); type_name = type_name.Replace("::", "/"); type_name = type_name.Replace("*", ""); output = "au/" + type_name; return(output); }
private void ParseArrayClassStruct(Il2CppType il2CppType, Il2CppGenericContext context) { var structName = GetIl2CppStructName(il2CppType, context); arrayClassPreHeader.Append($"struct {structName}_array;\n"); arrayClassHeader.Append($"struct {structName}_array {{\n" + $"\tIl2CppObject obj;\n" + $"\tIl2CppArrayBounds *bounds;\n" + $"\tuintptr_t max_length;\n" + $"\t{ParseType(il2CppType, context)} m_Items[65535];\n" + $"}};\n"); }
public Il2CppType[] GetGenericInstParamList(Il2CppGenericInst genericInst) { var genericParameterTypes = new Il2CppType[genericInst.type_argc]; var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc); for (int i = 0; i < genericInst.type_argc; i++) { var il2CppType = il2Cpp.GetIl2CppType(pointers[i]); genericParameterTypes[i] = il2CppType; } return(genericParameterTypes); }
public Il2CppGenericParameter GetGenericParameteFromIl2CppType(Il2CppType il2CppType) { if (il2Cpp.Version >= 27 && il2Cpp.IsDumped) { var offset = il2CppType.data.genericParameterHandle - metadata.ImageBase - metadata.header.genericParametersOffset; var index = offset / (ulong)metadata.SizeOf(typeof(Il2CppGenericParameter)); return(metadata.genericParameters[index]); } else { return(metadata.genericParameters[il2CppType.data.genericParameterIndex]); } }
public Il2CppTypeDefinition GetTypeDefinitionFromIl2CppType(Il2CppType il2CppType) { if (il2Cpp.Version >= 27 && il2Cpp.IsDumped) { var offset = il2CppType.data.typeHandle - metadata.ImageBase - metadata.header.typeDefinitionsOffset; var index = offset / (ulong)metadata.SizeOf(typeof(Il2CppTypeDefinition)); return(metadata.typeDefs[index]); } else { return(metadata.typeDefs[il2CppType.data.klassIndex]); } }
private static string get_type_name(Il2CppType pType) { string ret; if (pType.type == Il2CppTypeEnum.IL2CPP_TYPE_CLASS || pType.type == Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE) { Il2CppTypeDefinition klass = metadata.typeDefs[pType.data.klassIndex]; ret = metadata.GetString(klass.nameIndex); } else if (pType.type == Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST) { Il2CppGenericClass generic_class = il2cpp.MapVATR <Il2CppGenericClass>(pType.data.generic_class); Il2CppTypeDefinition pMainDef = metadata.typeDefs[generic_class.typeDefinitionIndex]; ret = metadata.GetString(pMainDef.nameIndex); var typeNames = new List <string>(); Il2CppGenericInst pInst = il2cpp.MapVATR <Il2CppGenericInst>(generic_class.context.class_inst); var pointers = il2cpp.MapVATR <uint>(pInst.type_argv, (int)pInst.type_argc); for (int i = 0; i < pInst.type_argc; ++i) { var pOriType = il2cpp.MapVATR <Il2CppType>(pointers[i]); pOriType.Init(); typeNames.Add(get_type_name(pOriType)); } ret += $"<{string.Join(", ", typeNames)}>"; } else if (pType.type == Il2CppTypeEnum.IL2CPP_TYPE_ARRAY) { Il2CppArrayType arrayType = il2cpp.MapVATR <Il2CppArrayType>(pType.data.array); var type = il2cpp.MapVATR <Il2CppType>(arrayType.etype); type.Init(); ret = $"{get_type_name(type)}[]"; } else if (pType.type == Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY) { var type = il2cpp.MapVATR <Il2CppType>(pType.data.type); type.Init(); ret = $"{get_type_name(type)}[]"; } else { if ((int)pType.type >= szTypeString.Length) { ret = "unknow"; } else { ret = szTypeString[(int)pType.type]; } } return(ret); }
public Il2CppTypeEnum ReadEncodedTypeEnum(BinaryReader reader, out Il2CppType enumType) { enumType = null; var type = (Il2CppTypeEnum)reader.ReadByte(); if (type == Il2CppTypeEnum.IL2CPP_TYPE_ENUM) { var enumTypeIndex = reader.ReadCompressedInt32(); enumType = il2Cpp.types[enumTypeIndex]; var typeDef = GetTypeDefinitionFromIl2CppType(enumType); type = il2Cpp.types[typeDef.elementTypeIndex].type; } return(type); }
public string GetName(Il2CppType il2CppType, string originalName) { if (_typeDefToName.ContainsKey(il2CppType)) { return(_typeDefToName[il2CppType].Split('|')[1]); } Il2CppExecutor executor; if (!_executor.TryGetTarget(out executor)) { throw new InvalidOperationException("Cannot be used with disposed executor!"); } var typeDef = executor.GetTypeDefinitionFromIl2CppType(il2CppType); return(GetName(executor, typeDef, il2CppType, originalName)); }
private string GetNameSpace(Il2CppType il2CppType) { switch (il2CppType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: var typeDef = metadata.typeDefs[il2CppType.data.klassIndex]; var ret = metadata.GetStringFromIndex(typeDef.namespaceIndex); if (ret != string.Empty) { ret += "."; } return(ret); default: return(string.Empty); } }
private Il2CppTypeDefinition GetTypeDefinition(Il2CppType il2CppType) { switch (il2CppType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: return(metadata.typeDefs[il2CppType.data.klassIndex]); case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class); return(metadata.typeDefs[genericClass.typeDefinitionIndex]); case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT: return(null); default: throw new NotSupportedException(); } }
private void ParseParent(Il2CppType il2CppType, out Il2CppTypeDefinition typeDef, out Il2CppGenericContext context) { context = null; switch (il2CppType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: typeDef = metadata.typeDefs[il2CppType.data.klassIndex]; break; case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class); context = genericClass.context; typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex]; break; case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT: typeDef = null; break; default: throw new NotSupportedException(); } }
private TypeReference GetTypeReference(MemberReference memberReference, Il2CppType pType) { var moduleDefinition = memberReference.Module; switch (pType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT: return(moduleDefinition.Import(typeof(Object))); case Il2CppTypeEnum.IL2CPP_TYPE_VOID: return(moduleDefinition.Import(typeof(void))); case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN: return(moduleDefinition.Import(typeof(Boolean))); case Il2CppTypeEnum.IL2CPP_TYPE_CHAR: return(moduleDefinition.Import(typeof(Char))); case Il2CppTypeEnum.IL2CPP_TYPE_I1: return(moduleDefinition.Import(typeof(SByte))); case Il2CppTypeEnum.IL2CPP_TYPE_U1: return(moduleDefinition.Import(typeof(Byte))); case Il2CppTypeEnum.IL2CPP_TYPE_I2: return(moduleDefinition.Import(typeof(Int16))); case Il2CppTypeEnum.IL2CPP_TYPE_U2: return(moduleDefinition.Import(typeof(UInt16))); case Il2CppTypeEnum.IL2CPP_TYPE_I4: return(moduleDefinition.Import(typeof(Int32))); case Il2CppTypeEnum.IL2CPP_TYPE_U4: return(moduleDefinition.Import(typeof(UInt32))); case Il2CppTypeEnum.IL2CPP_TYPE_I: return(moduleDefinition.Import(typeof(IntPtr))); case Il2CppTypeEnum.IL2CPP_TYPE_U: return(moduleDefinition.Import(typeof(UIntPtr))); case Il2CppTypeEnum.IL2CPP_TYPE_I8: return(moduleDefinition.Import(typeof(Int64))); case Il2CppTypeEnum.IL2CPP_TYPE_U8: return(moduleDefinition.Import(typeof(UInt64))); case Il2CppTypeEnum.IL2CPP_TYPE_R4: return(moduleDefinition.Import(typeof(Single))); case Il2CppTypeEnum.IL2CPP_TYPE_R8: return(moduleDefinition.Import(typeof(Double))); case Il2CppTypeEnum.IL2CPP_TYPE_STRING: return(moduleDefinition.Import(typeof(String))); case Il2CppTypeEnum.IL2CPP_TYPE_TYPEDBYREF: return(moduleDefinition.Import(typeof(TypedReference))); case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: { var typeDefinition = typeDefinitionDic[pType.data.klassIndex]; return(moduleDefinition.Import(typeDefinition)); } case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: { var arrayType = il2cpp.MapVATR <Il2CppArrayType>(pType.data.array); var type = il2cpp.GetIl2CppType(arrayType.etype); return(new ArrayType(GetTypeReference(memberReference, type), arrayType.rank)); } case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { var generic_class = il2cpp.MapVATR <Il2CppGenericClass>(pType.data.generic_class); var typeDefinition = typeDefinitionDic[generic_class.typeDefinitionIndex]; var genericInstanceType = new GenericInstanceType(moduleDefinition.Import(typeDefinition)); var pInst = il2cpp.MapVATR <Il2CppGenericInst>(generic_class.context.class_inst); var pointers = il2cpp.GetPointers(pInst.type_argv, (long)pInst.type_argc); foreach (var pointer in pointers) { var pOriType = il2cpp.GetIl2CppType(pointer); genericInstanceType.GenericArguments.Add(GetTypeReference(memberReference, pOriType)); } return(genericInstanceType); } case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: { var type = il2cpp.GetIl2CppType(pType.data.type); return(new ArrayType(GetTypeReference(memberReference, type))); } case Il2CppTypeEnum.IL2CPP_TYPE_VAR: { if (genericParameterDic.TryGetValue(pType, out var genericParameter)) { return(genericParameter); } if (memberReference is MethodDefinition methodDefinition) { var genericName = "T" + (methodDefinition.DeclaringType.GenericParameters.Count + 1); genericParameter = new GenericParameter(genericName, methodDefinition.DeclaringType); methodDefinition.DeclaringType.GenericParameters.Add(genericParameter); genericParameterDic.Add(pType, genericParameter); return(genericParameter); } var typeDefinition = (TypeDefinition)memberReference; var genericName2 = "T" + (typeDefinition.GenericParameters.Count + 1); genericParameter = new GenericParameter(genericName2, typeDefinition); typeDefinition.GenericParameters.Add(genericParameter); genericParameterDic.Add(pType, genericParameter); return(genericParameter); } case Il2CppTypeEnum.IL2CPP_TYPE_MVAR: { if (genericParameterDic.TryGetValue(pType, out var genericParameter)) { return(genericParameter); } var methodDefinition = (MethodDefinition)memberReference; var genericName = "T" + (methodDefinition.GenericParameters.Count + 1); genericParameter = new GenericParameter(genericName, methodDefinition); methodDefinition.GenericParameters.Add(genericParameter); genericParameterDic.Add(pType, genericParameter); return(genericParameter); } case Il2CppTypeEnum.IL2CPP_TYPE_PTR: { var type = il2cpp.GetIl2CppType(pType.data.type); return(new PointerType(GetTypeReference(memberReference, type))); } default: return(moduleDefinition.Import(typeof(Object))); } }
private string GetTypeName(Il2CppType type) { string ret; switch (type.type) { case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: { var typeDef = metadata.typeDefs[type.data.klassIndex]; ret = string.Empty; if (typeDef.declaringTypeIndex != -1) { ret += GetTypeName(il2cpp.types[typeDef.declaringTypeIndex]) + "."; } ret += metadata.GetStringFromIndex(typeDef.nameIndex); break; } case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { var genericClass = il2cpp.MapVATR <Il2CppGenericClass>(type.data.generic_class); var typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex]; ret = metadata.GetStringFromIndex(typeDef.nameIndex); var typeNames = new List <string>(); var genericInst = il2cpp.MapVATR <Il2CppGenericInst>(genericClass.context.class_inst); var pointers = il2cpp.ReadPointers(genericInst.type_argv, genericInst.type_argc); for (uint i = 0; i < genericInst.type_argc; ++i) { var oriType = il2cpp.GetIl2CppType(pointers[i]); typeNames.Add(GetTypeName(oriType)); } ret += $"<{string.Join(", ", typeNames)}>"; break; } case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: { var arrayType = il2cpp.MapVATR <Il2CppArrayType>(type.data.array); var oriType = il2cpp.GetIl2CppType(arrayType.etype); ret = $"{GetTypeName(oriType)}[{new string(',', arrayType.rank - 1)}]"; break; } case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: { var oriType = il2cpp.GetIl2CppType(type.data.type); ret = $"{GetTypeName(oriType)}[]"; break; } case Il2CppTypeEnum.IL2CPP_TYPE_PTR: { var oriType = il2cpp.GetIl2CppType(type.data.type); ret = $"{GetTypeName(oriType)}*"; break; } default: ret = DefineConstants.TypeString[(int)type.type]; break; } return(ret); }
private string GetIl2CppStructName(Il2CppType il2CppType, Il2CppGenericContext context = null) { switch (il2CppType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_VOID: case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN: case Il2CppTypeEnum.IL2CPP_TYPE_CHAR: case Il2CppTypeEnum.IL2CPP_TYPE_I1: case Il2CppTypeEnum.IL2CPP_TYPE_U1: case Il2CppTypeEnum.IL2CPP_TYPE_I2: case Il2CppTypeEnum.IL2CPP_TYPE_U2: case Il2CppTypeEnum.IL2CPP_TYPE_I4: case Il2CppTypeEnum.IL2CPP_TYPE_U4: case Il2CppTypeEnum.IL2CPP_TYPE_I8: case Il2CppTypeEnum.IL2CPP_TYPE_U8: case Il2CppTypeEnum.IL2CPP_TYPE_R4: case Il2CppTypeEnum.IL2CPP_TYPE_R8: case Il2CppTypeEnum.IL2CPP_TYPE_STRING: case Il2CppTypeEnum.IL2CPP_TYPE_TYPEDBYREF: case Il2CppTypeEnum.IL2CPP_TYPE_I: case Il2CppTypeEnum.IL2CPP_TYPE_U: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT: { var typeDef = metadata.typeDefs[il2CppType.data.klassIndex]; return(structNameDic[typeDef]); } case Il2CppTypeEnum.IL2CPP_TYPE_PTR: { var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type); return(GetIl2CppStructName(oriType)); } case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: { var arrayType = il2Cpp.MapVATR <Il2CppArrayType>(il2CppType.data.array); var elementType = il2Cpp.GetIl2CppType(arrayType.etype); var elementStructName = GetIl2CppStructName(elementType, context); var typeStructName = elementStructName + "_array"; if (structNameHashSet.Add(typeStructName)) { ParseArrayClassStruct(elementType, context); } return(typeStructName); } case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: { var elementType = il2Cpp.GetIl2CppType(il2CppType.data.type); var elementStructName = GetIl2CppStructName(elementType, context); var typeStructName = elementStructName + "_array"; if (structNameHashSet.Add(typeStructName)) { ParseArrayClassStruct(elementType, context); } return(typeStructName); } case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { if (!genericClassStructNameDic.TryGetValue(il2CppType.data.generic_class, out var typeStructName)) { var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class); var typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex]; var typeOriName = structNameDic[typeDef]; var typeToReplaceName = FixName(executor.GetTypeDefName(typeDef, true, true)); var typeReplaceName = FixName(executor.GetTypeName(il2CppType, true, false)); typeStructName = typeOriName.Replace(typeToReplaceName, typeReplaceName); genericClassStructNameDic.Add(il2CppType.data.generic_class, typeStructName); if (structNameHashSet.Add(typeStructName)) { genericClassList.Add(il2CppType.data.generic_class); } } return(typeStructName); } case Il2CppTypeEnum.IL2CPP_TYPE_VAR: { if (context != null) { var genericParameter = metadata.genericParameters[il2CppType.data.genericParameterIndex]; var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(context.class_inst); var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc); var pointer = pointers[genericParameter.num]; var type = il2Cpp.GetIl2CppType(pointer); return(GetIl2CppStructName(type)); } return("System_Object"); } case Il2CppTypeEnum.IL2CPP_TYPE_MVAR: { if (context != null) { var genericParameter = metadata.genericParameters[il2CppType.data.genericParameterIndex]; var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(context.method_inst); var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc); var pointer = pointers[genericParameter.num]; var type = il2Cpp.GetIl2CppType(pointer); return(GetIl2CppStructName(type)); } return("System_Object"); } default: throw new NotSupportedException(); } }
public string GetTypeName(Il2CppType il2CppType, bool addNamespace, bool is_nested, bool is_pointer = true) { /* * if (il2CppType.data.klassIndex) * var typeDef = metadata.typeDefs[typeDefIndex]; * var typeName = executor.GetTypeDefName(typeDef, false, true);*/ switch (il2CppType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: { var arrayType = il2Cpp.MapVATR <Il2CppArrayType>(il2CppType.data.array); var elementType = il2Cpp.GetIl2CppType(arrayType.etype); return($"{GetTypeName(elementType, addNamespace, false)}[{new string(',', arrayType.rank - 1)}]"); } case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: { var elementType = il2Cpp.GetIl2CppType(il2CppType.data.type); return($"cs::array<{GetTypeName(elementType, addNamespace, false, false)}>*"); } case Il2CppTypeEnum.IL2CPP_TYPE_PTR: { var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type); return($"{GetTypeName(oriType, addNamespace, false)}*"); } case Il2CppTypeEnum.IL2CPP_TYPE_VAR: case Il2CppTypeEnum.IL2CPP_TYPE_MVAR: { var param = GetGenericParameteFromIl2CppType(il2CppType); return(metadata.GetStringFromIndex(param.nameIndex)); } case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { string str = string.Empty; string str_params = string.Empty; string str_pointer = "*"; if (!is_pointer) { str_pointer = ""; } Il2CppTypeDefinition typeDef; Il2CppGenericClass genericClass = null; if (il2CppType.type == Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST) { genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class); typeDef = GetGenericClassTypeDefinition(genericClass); } else { typeDef = GetTypeDefinitionFromIl2CppType(il2CppType); } if (typeDef.declaringTypeIndex != -1) { // nested str += GetTypeName(il2Cpp.types[typeDef.declaringTypeIndex], addNamespace, true, true); str += "_"; } else if (addNamespace) { var @namespace = metadata.GetStringFromIndex(typeDef.namespaceIndex); if (@namespace != "") { @namespace = @namespace.Replace(".", "::"); str += @namespace + "::"; } } var typeName = metadata.GetStringFromIndex(typeDef.nameIndex); var index = typeName.IndexOf("`"); if (index != -1) { str += typeName.Substring(0, index); } else { str += typeName; } if (is_nested) { return(str); } if (genericClass != null) { var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(genericClass.context.class_inst); str_params += GetGenericInstParams(genericInst); } else if (typeDef.genericContainerIndex >= 0) { var genericContainer = metadata.genericContainers[typeDef.genericContainerIndex]; str_params += GetGenericContainerParams(genericContainer); } if (il2CppType.type == Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE) { str_pointer = ""; } str = str.Replace("<", "_"); str = str.Replace(">", "_"); str = Il2CppDecompiler.deobfu(str); return(str + str_params + str_pointer); } default: return(TypeString[(int)il2CppType.type]); } }
public Il2CppTypeInfo(Il2CppType cppType) { this._cppType = cppType; this._cppTypeEnum = cppType.type; }
public string GetTypeName(Il2CppType il2CppType, bool addNamespace, bool is_nested) { switch (il2CppType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: { var arrayType = il2Cpp.MapVATR <Il2CppArrayType>(il2CppType.data.array); var elementType = il2Cpp.GetIl2CppType(arrayType.etype); return($"{GetTypeName(elementType, addNamespace, false)}[{new string(',', arrayType.rank - 1)}]"); } case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: { var elementType = il2Cpp.GetIl2CppType(il2CppType.data.type); return($"{GetTypeName(elementType, addNamespace, false)}[]"); } case Il2CppTypeEnum.IL2CPP_TYPE_PTR: { var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type); return($"{GetTypeName(oriType, addNamespace, false)}*"); } case Il2CppTypeEnum.IL2CPP_TYPE_VAR: case Il2CppTypeEnum.IL2CPP_TYPE_MVAR: { var param = GetGenericParameteFromIl2CppType(il2CppType); return(metadata.GetStringFromIndex(param.nameIndex)); } case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { string str = string.Empty; Il2CppTypeDefinition typeDef; Il2CppGenericClass genericClass = null; if (il2CppType.type == Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST) { genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class); typeDef = GetGenericClassTypeDefinition(genericClass); } else { typeDef = GetTypeDefinitionFromIl2CppType(il2CppType); } if (typeDef.declaringTypeIndex != -1) { str += GetTypeName(il2Cpp.types[typeDef.declaringTypeIndex], addNamespace, true); str += '.'; } else if (addNamespace) { var @namespace = metadata.GetStringFromIndex(typeDef.namespaceIndex); if (@namespace != "") { str += @namespace + "."; } } var typeName = metadata.GetStringFromIndex(typeDef.nameIndex); var index = typeName.IndexOf("`"); if (index != -1) { str += typeName.Substring(0, index); } else { str += typeName; } if (is_nested) { return(str); } if (genericClass != null) { var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(genericClass.context.class_inst); str += GetGenericInstParams(genericInst); } else if (typeDef.genericContainerIndex >= 0) { var genericContainer = metadata.genericContainers[typeDef.genericContainerIndex]; str += GetGenericContainerParams(genericContainer); } return(str); } default: return(TypeString[(int)il2CppType.type]); } }
private TypeReference GetTypeReferenceWithByRef(MemberReference memberReference, Il2CppType il2CppType) { var typeReference = GetTypeReference(memberReference, il2CppType); if (il2CppType.byref == 1) { return(new ByReferenceType(typeReference)); } else { return(typeReference); } }
private TypeReference GetTypeReference(MemberReference memberReference, Il2CppType il2CppType) { var moduleDefinition = memberReference.Module; switch (il2CppType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT: return(moduleDefinition.ImportReference(typeof(object))); case Il2CppTypeEnum.IL2CPP_TYPE_VOID: return(moduleDefinition.ImportReference(typeof(void))); case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN: return(moduleDefinition.ImportReference(typeof(bool))); case Il2CppTypeEnum.IL2CPP_TYPE_CHAR: return(moduleDefinition.ImportReference(typeof(char))); case Il2CppTypeEnum.IL2CPP_TYPE_I1: return(moduleDefinition.ImportReference(typeof(sbyte))); case Il2CppTypeEnum.IL2CPP_TYPE_U1: return(moduleDefinition.ImportReference(typeof(byte))); case Il2CppTypeEnum.IL2CPP_TYPE_I2: return(moduleDefinition.ImportReference(typeof(short))); case Il2CppTypeEnum.IL2CPP_TYPE_U2: return(moduleDefinition.ImportReference(typeof(ushort))); case Il2CppTypeEnum.IL2CPP_TYPE_I4: return(moduleDefinition.ImportReference(typeof(int))); case Il2CppTypeEnum.IL2CPP_TYPE_U4: return(moduleDefinition.ImportReference(typeof(uint))); case Il2CppTypeEnum.IL2CPP_TYPE_I: return(moduleDefinition.ImportReference(typeof(IntPtr))); case Il2CppTypeEnum.IL2CPP_TYPE_U: return(moduleDefinition.ImportReference(typeof(UIntPtr))); case Il2CppTypeEnum.IL2CPP_TYPE_I8: return(moduleDefinition.ImportReference(typeof(long))); case Il2CppTypeEnum.IL2CPP_TYPE_U8: return(moduleDefinition.ImportReference(typeof(ulong))); case Il2CppTypeEnum.IL2CPP_TYPE_R4: return(moduleDefinition.ImportReference(typeof(float))); case Il2CppTypeEnum.IL2CPP_TYPE_R8: return(moduleDefinition.ImportReference(typeof(double))); case Il2CppTypeEnum.IL2CPP_TYPE_STRING: return(moduleDefinition.ImportReference(typeof(string))); case Il2CppTypeEnum.IL2CPP_TYPE_TYPEDBYREF: return(moduleDefinition.ImportReference(typeof(TypedReference))); case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: { var typeDefinition = typeDefinitionDic[il2CppType.data.klassIndex]; return(moduleDefinition.ImportReference(typeDefinition)); } case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: { var arrayType = il2Cpp.MapVATR <Il2CppArrayType>(il2CppType.data.array); var oriType = il2Cpp.GetIl2CppType(arrayType.etype); return(new ArrayType(GetTypeReference(memberReference, oriType), arrayType.rank)); } case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class); var typeDefinition = typeDefinitionDic[genericClass.typeDefinitionIndex]; var genericInstanceType = new GenericInstanceType(moduleDefinition.ImportReference(typeDefinition)); var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(genericClass.context.class_inst); var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc); foreach (var pointer in pointers) { var oriType = il2Cpp.GetIl2CppType(pointer); genericInstanceType.GenericArguments.Add(GetTypeReference(memberReference, oriType)); } return(genericInstanceType); } case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: { var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type); return(new ArrayType(GetTypeReference(memberReference, oriType))); } case Il2CppTypeEnum.IL2CPP_TYPE_VAR: { if (genericParameterDic.TryGetValue(il2CppType.data.genericParameterIndex, out var genericParameter)) { return(genericParameter); } if (memberReference is MethodDefinition methodDefinition) { return(CreateGenericParameter(il2CppType.data.genericParameterIndex, methodDefinition.DeclaringType)); } var typeDefinition = (TypeDefinition)memberReference; return(CreateGenericParameter(il2CppType.data.genericParameterIndex, typeDefinition)); } case Il2CppTypeEnum.IL2CPP_TYPE_MVAR: { if (genericParameterDic.TryGetValue(il2CppType.data.genericParameterIndex, out var genericParameter)) { return(genericParameter); } var methodDefinition = (MethodDefinition)memberReference; return(CreateGenericParameter(il2CppType.data.genericParameterIndex, methodDefinition)); } case Il2CppTypeEnum.IL2CPP_TYPE_PTR: { var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type); return(new PointerType(GetTypeReference(memberReference, oriType))); } default: throw new ArgumentOutOfRangeException(); } }
private static string GetTypeName(Il2CppType type, bool fullName = false) { string ret; switch (type.type) { case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: { var typeDef = metadata.typeDefs[type.data.klassIndex]; ret = string.Empty; if (fullName) { ret = metadata.GetStringFromIndex(typeDef.namespaceIndex); if (ret != string.Empty) { ret += "."; } } ret += GetTypeName(typeDef); break; } case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { var generic_class = il2cpp.MapVATR <Il2CppGenericClass>(type.data.generic_class); var typeDef = metadata.typeDefs[generic_class.typeDefinitionIndex]; ret = metadata.GetStringFromIndex(typeDef.nameIndex); var genericInst = il2cpp.MapVATR <Il2CppGenericInst>(generic_class.context.class_inst); ret += GetGenericTypeParams(genericInst); break; } case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: { var arrayType = il2cpp.MapVATR <Il2CppArrayType>(type.data.array); var oriType = il2cpp.GetIl2CppType(arrayType.etype); ret = $"{GetTypeName(oriType)}[{new string(',', arrayType.rank - 1)}]"; break; } case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: { var oriType = il2cpp.GetIl2CppType(type.data.type); ret = $"{GetTypeName(oriType)}[]"; break; } case Il2CppTypeEnum.IL2CPP_TYPE_PTR: { var oriType = il2cpp.GetIl2CppType(type.data.type); ret = $"{GetTypeName(oriType)}*"; break; } default: ret = TypeString[(int)type.type]; break; } return(ret); }
private string header_include(Il2CppType type) { string output; string type_name = ""; string namespaze = ""; string template_decl = ""; switch (type.type) { case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: { return("#include <cs/array.hpp>"); } case Il2CppTypeEnum.IL2CPP_TYPE_MVAR: return(""); case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: return($"#include <{include_path(type)}.hpp>"); case Il2CppTypeEnum.IL2CPP_TYPE_STRING: { return("#include <cs/string.hpp>"); } case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { Il2CppTypeDefinition typeDef; Il2CppGenericClass genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(type.data.generic_class); typeDef = executor.GetGenericClassTypeDefinition(genericClass); var @namespace = metadata.GetStringFromIndex(typeDef.namespaceIndex); if (@namespace != "") { type_name += @namespace + "."; } type_name += metadata.GetStringFromIndex(typeDef.nameIndex); var index = type_name.IndexOf("`"); if (index != -1) { type_name = type_name.Substring(0, index); } template_decl = "template <class...> "; //Il2CppExecutor.GetGenericContainerParams(genericContainer, generic_decl) break; } default: { if (type.type > Il2CppTypeEnum.IL2CPP_TYPE_R8) { type_name = executor.GetTypeName(type, true, false); } else { return(""); } break; } } type_name = type_name.Replace(".", "::"); type_name = type_name.Replace("*", ""); var nsindex = type_name.LastIndexOf("::"); if (nsindex > 0) { namespaze = type_name.Substring(0, nsindex); type_name = type_name.Substring(nsindex + 2); output = "namespace " + namespaze + "{ " + template_decl + "struct " + deobfu(type_name) + "; }"; } else { output = "struct " + deobfu(type_name) + ";"; } return(output); }
private string ParseType(Il2CppType il2CppType, Il2CppGenericContext context = null) { switch (il2CppType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_VOID: return("void"); case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN: return("bool"); case Il2CppTypeEnum.IL2CPP_TYPE_CHAR: return("uint16_t"); //Il2CppChar case Il2CppTypeEnum.IL2CPP_TYPE_I1: return("int8_t"); case Il2CppTypeEnum.IL2CPP_TYPE_U1: return("uint8_t"); case Il2CppTypeEnum.IL2CPP_TYPE_I2: return("int16_t"); case Il2CppTypeEnum.IL2CPP_TYPE_U2: return("uint16_t"); case Il2CppTypeEnum.IL2CPP_TYPE_I4: return("int32_t"); case Il2CppTypeEnum.IL2CPP_TYPE_U4: return("uint32_t"); case Il2CppTypeEnum.IL2CPP_TYPE_I8: return("int64_t"); case Il2CppTypeEnum.IL2CPP_TYPE_U8: return("uint64_t"); case Il2CppTypeEnum.IL2CPP_TYPE_R4: return("float"); case Il2CppTypeEnum.IL2CPP_TYPE_R8: return("double"); case Il2CppTypeEnum.IL2CPP_TYPE_STRING: return("System_String_o*"); case Il2CppTypeEnum.IL2CPP_TYPE_PTR: { var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type); return(ParseType(oriType) + "*"); } case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: { var typeDef = metadata.typeDefs[il2CppType.data.klassIndex]; if (typeDef.IsEnum) { return(ParseType(il2Cpp.types[typeDef.elementTypeIndex])); } return(structNameDic[typeDef] + "_o"); } case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: { var typeDef = metadata.typeDefs[il2CppType.data.klassIndex]; return(structNameDic[typeDef] + "_o*"); } case Il2CppTypeEnum.IL2CPP_TYPE_VAR: { if (context != null) { var genericParameter = metadata.genericParameters[il2CppType.data.genericParameterIndex]; var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(context.class_inst); var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc); var pointer = pointers[genericParameter.num]; var type = il2Cpp.GetIl2CppType(pointer); return(ParseType(type)); } return("Il2CppObject*"); } case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: { var arrayType = il2Cpp.MapVATR <Il2CppArrayType>(il2CppType.data.array); var elementType = il2Cpp.GetIl2CppType(arrayType.etype); var elementStructName = GetIl2CppStructName(elementType, context); var typeStructName = elementStructName + "_array"; if (structNameHashSet.Add(typeStructName)) { ParseArrayClassStruct(elementType, context); } return(typeStructName + "*"); } case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class); var typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex]; var typeStructName = genericClassStructNameDic[il2CppType.data.generic_class]; if (structNameHashSet.Add(typeStructName)) { genericClassList.Add(il2CppType.data.generic_class); } if (typeDef.IsValueType) { if (typeDef.IsEnum) { return(ParseType(il2Cpp.types[typeDef.elementTypeIndex])); } return(typeStructName + "_o"); } return(typeStructName + "_o*"); } case Il2CppTypeEnum.IL2CPP_TYPE_TYPEDBYREF: return("Il2CppObject*"); case Il2CppTypeEnum.IL2CPP_TYPE_I: return("intptr_t"); case Il2CppTypeEnum.IL2CPP_TYPE_U: return("uintptr_t"); case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT: return("Il2CppObject*"); case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: { var elementType = il2Cpp.GetIl2CppType(il2CppType.data.type); var elementStructName = GetIl2CppStructName(elementType, context); var typeStructName = elementStructName + "_array"; if (structNameHashSet.Add(typeStructName)) { ParseArrayClassStruct(elementType, context); } return(typeStructName + "*"); } case Il2CppTypeEnum.IL2CPP_TYPE_MVAR: { if (context != null) { var genericParameter = metadata.genericParameters[il2CppType.data.genericParameterIndex]; var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(context.method_inst); var pointers = il2Cpp.MapVATR <ulong>(genericInst.type_argv, genericInst.type_argc); var pointer = pointers[genericParameter.num]; var type = il2Cpp.GetIl2CppType(pointer); return(ParseType(type)); } return("Il2CppObject*"); } default: throw new NotSupportedException(); } }
public string GetTypeName(Il2CppType il2CppType) { string ret; switch (il2CppType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: { var typeDef = metadata.typeDefs[il2CppType.data.klassIndex]; ret = GetTypeDefName(typeDef); break; } case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class); var typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex]; ret = metadata.GetStringFromIndex(typeDef.nameIndex); var genericInst = il2Cpp.MapVATR <Il2CppGenericInst>(genericClass.context.class_inst); ret = ret.Replace($"`{genericInst.type_argc}", ""); ret += GetGenericTypeParams(genericInst); break; } case Il2CppTypeEnum.IL2CPP_TYPE_VAR: case Il2CppTypeEnum.IL2CPP_TYPE_MVAR: { var param = metadata.genericParameters[il2CppType.data.genericParameterIndex]; ret = metadata.GetStringFromIndex(param.nameIndex); break; } case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: { var arrayType = il2Cpp.MapVATR <Il2CppArrayType>(il2CppType.data.array); var oriType = il2Cpp.GetIl2CppType(arrayType.etype); ret = $"{GetTypeName(oriType)}[{new string(',', arrayType.rank - 1)}]"; break; } case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: { var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type); ret = $"{GetTypeName(oriType)}[]"; break; } case Il2CppTypeEnum.IL2CPP_TYPE_PTR: { var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type); ret = $"{GetTypeName(oriType)}*"; break; } default: ret = TypeString[(int)il2CppType.type]; break; } return(ret); }
static void Main(string[] args) { Console.WriteLine("Select Mode: 1. Manual 2.Auto"); var key = Console.ReadKey(true); try { if (key.KeyChar == '2') { metadata = new Metadata(new MemoryStream(File.ReadAllBytes("global-metadata.dat"))); il2cpp = new Il2Cpp(new MemoryStream(File.ReadAllBytes("libil2cpp.so"))); } else if (key.KeyChar == '1') { Console.Write("Input CodeRegistration(R0): "); var codeRegistration = Convert.ToUInt32(Console.ReadLine(), 16); Console.Write("Input MetadataRegistration(R1): "); var metadataRegistration = Convert.ToUInt32(Console.ReadLine(), 16); metadata = new Metadata(new MemoryStream(File.ReadAllBytes("global-metadata.dat"))); il2cpp = new Il2Cpp(new MemoryStream(File.ReadAllBytes("libil2cpp.so")), codeRegistration, metadataRegistration); } else { return; } var writer = new StreamWriter(new FileStream("dump.cs", FileMode.Create)); Console.WriteLine("Dumping..."); //dump_image(); for (int imageIndex = 0; imageIndex < metadata.uiImageCount; imageIndex++) { var imageDef = metadata.imageDefs[imageIndex]; writer.Write($"// Image {imageIndex}: {metadata.GetString(imageDef.nameIndex)} - {imageDef.typeStart}\n"); } for (int idx = 0; idx < metadata.uiNumTypes; ++idx) { //dump_class(i); var typeDef = metadata.typeDefs[idx]; writer.Write($"// Namespace: {metadata.GetString(typeDef.namespaceIndex)}\n"); if ((typeDef.flags & DefineConstants.TYPE_ATTRIBUTE_SERIALIZABLE) != 0) { writer.Write("[Serializable]\n"); } if ((typeDef.flags & DefineConstants.TYPE_ATTRIBUTE_VISIBILITY_MASK) == DefineConstants.TYPE_ATTRIBUTE_PUBLIC) { writer.Write("public "); } if ((typeDef.flags & DefineConstants.TYPE_ATTRIBUTE_ABSTRACT) != 0) { writer.Write("abstract "); } if ((typeDef.flags & DefineConstants.TYPE_ATTRIBUTE_SEALED) != 0) { writer.Write("sealed "); } if ((typeDef.flags & DefineConstants.TYPE_ATTRIBUTE_INTERFACE) != 0) { writer.Write("interface "); } else { writer.Write("class "); } writer.Write($"{metadata.GetString(typeDef.nameIndex)} // TypeDefIndex: {idx}\n{{\n"); writer.Write("\t// Fields\n"); var fieldEnd = typeDef.fieldStart + typeDef.field_count; for (int i = typeDef.fieldStart; i < fieldEnd; ++i) { //dump_field(i, idx, i - typeDef.fieldStart); var pField = metadata.fieldDefs[i]; var pType = il2cpp.GetTypeFromTypeIndex(pField.typeIndex); var pDefault = metadata.GetFieldDefaultFromIndex(i); writer.Write("\t"); if ((pType.attrs & DefineConstants.FIELD_ATTRIBUTE_PRIVATE) == DefineConstants.FIELD_ATTRIBUTE_PRIVATE) { writer.Write("private "); } if ((pType.attrs & DefineConstants.FIELD_ATTRIBUTE_PUBLIC) == DefineConstants.FIELD_ATTRIBUTE_PUBLIC) { writer.Write("public "); } if ((pType.attrs & DefineConstants.FIELD_ATTRIBUTE_STATIC) != 0) { writer.Write("static "); } if ((pType.attrs & DefineConstants.FIELD_ATTRIBUTE_INIT_ONLY) != 0) { writer.Write("readonly "); } writer.Write($"{get_type_name(pType)} {metadata.GetString(pField.nameIndex)}"); if (pDefault != null && pDefault.dataIndex != -1) { var pointer = metadata.GetDefaultValueFromIndex(pDefault.dataIndex); Il2CppType pTypeToUse = il2cpp.GetTypeFromTypeIndex(pDefault.typeIndex); if (pointer > 0) { metadata.Position = pointer; object multi = null; switch (pTypeToUse.type) { case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN: multi = metadata.ReadBoolean(); break; case Il2CppTypeEnum.IL2CPP_TYPE_U1: case Il2CppTypeEnum.IL2CPP_TYPE_I1: multi = metadata.ReadByte(); break; case Il2CppTypeEnum.IL2CPP_TYPE_CHAR: multi = metadata.ReadChar(); break; case Il2CppTypeEnum.IL2CPP_TYPE_U2: multi = metadata.ReadUInt16(); break; case Il2CppTypeEnum.IL2CPP_TYPE_I2: multi = metadata.ReadInt16(); break; case Il2CppTypeEnum.IL2CPP_TYPE_U4: multi = metadata.ReadUInt32(); break; case Il2CppTypeEnum.IL2CPP_TYPE_I4: multi = metadata.ReadInt32(); break; case Il2CppTypeEnum.IL2CPP_TYPE_U8: multi = metadata.ReadUInt64(); break; case Il2CppTypeEnum.IL2CPP_TYPE_I8: multi = metadata.ReadInt64(); break; case Il2CppTypeEnum.IL2CPP_TYPE_R4: multi = metadata.ReadSingle(); break; case Il2CppTypeEnum.IL2CPP_TYPE_R8: multi = metadata.ReadDouble(); break; case Il2CppTypeEnum.IL2CPP_TYPE_STRING: var uiLen = metadata.ReadInt32(); multi = Encoding.UTF8.GetString(metadata.ReadBytes(uiLen)); break; } if (multi is string) { writer.Write($" = \"{multi}\""); } else if (multi != null) { writer.Write($" = {multi}"); } } } writer.Write("; // 0x{0:x}\n", il2cpp.GetFieldOffsetFromIndex(idx, i - typeDef.fieldStart)); } writer.Write("\t// Methods\n"); var methodEnd = typeDef.methodStart + typeDef.method_count; for (int i = typeDef.methodStart; i < methodEnd; ++i) { //dump_method(i); var methodDef = metadata.methodDefs[i]; writer.Write("\t"); Il2CppType pReturnType = il2cpp.GetTypeFromTypeIndex(methodDef.returnType); if ((methodDef.flags & DefineConstants.METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == DefineConstants.METHOD_ATTRIBUTE_PRIVATE) { writer.Write("private "); } if ((methodDef.flags & DefineConstants.METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == DefineConstants.METHOD_ATTRIBUTE_PUBLIC) { writer.Write("public "); } if ((methodDef.flags & DefineConstants.METHOD_ATTRIBUTE_VIRTUAL) != 0) { writer.Write("virtual "); } if ((methodDef.flags & DefineConstants.METHOD_ATTRIBUTE_STATIC) != 0) { writer.Write("static "); } writer.Write($"{get_type_name(pReturnType)} {metadata.GetString(methodDef.nameIndex)}("); for (int j = 0; j < methodDef.parameterCount; ++j) { Il2CppParameterDefinition pParam = metadata.parameterDefs[methodDef.parameterStart + j]; string szParamName = metadata.GetString(pParam.nameIndex); Il2CppType pType = il2cpp.GetTypeFromTypeIndex(pParam.typeIndex); string szTypeName = get_type_name(pType); if ((pType.attrs & DefineConstants.PARAM_ATTRIBUTE_OPTIONAL) != 0) { writer.Write("optional "); } if ((pType.attrs & DefineConstants.PARAM_ATTRIBUTE_OUT) != 0) { writer.Write("out "); } if (j != methodDef.parameterCount - 1) { writer.Write($"{szTypeName} {szParamName}, "); } else { writer.Write($"{szTypeName} {szParamName}"); } } if (methodDef.methodIndex >= 0) { writer.Write("); // {0:x} - {1}\n", il2cpp.pCodeRegistration.methodPointers[methodDef.methodIndex], methodDef.methodIndex); } else { writer.Write("); // 0 - -1\n"); } } writer.Write("}\n"); } writer.Close(); Console.WriteLine("Done !"); } catch (Exception e) { Console.WriteLine(e.Message); } Console.WriteLine("Press any key to exit..."); Console.ReadKey(true); }
private string GetName(Il2CppExecutor executor, Il2CppTypeDefinition typeDef, Il2CppType il2CppType, string originalName) { if (_typeDefToName.ContainsKey(il2CppType)) { return(_typeDefToName[il2CppType].Split('|')[1]); } var uniqueTypeNamePair = $"{typeDef.namespaceIndex}|{originalName}"; int n = 0; while (_uniqueNames.Contains(uniqueTypeNamePair)) { uniqueTypeNamePair = $"{typeDef.namespaceIndex}|_{++n}_{originalName}"; } _uniqueNames.Add(uniqueTypeNamePair); _typeDefToName[il2CppType] = uniqueTypeNamePair; return(uniqueTypeNamePair.Split('|')[1]); }
private string GetIl2CppStructName(Il2CppType il2CppType) { switch (il2CppType.type) { case Il2CppTypeEnum.IL2CPP_TYPE_VOID: case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN: case Il2CppTypeEnum.IL2CPP_TYPE_CHAR: case Il2CppTypeEnum.IL2CPP_TYPE_I1: case Il2CppTypeEnum.IL2CPP_TYPE_U1: case Il2CppTypeEnum.IL2CPP_TYPE_I2: case Il2CppTypeEnum.IL2CPP_TYPE_U2: case Il2CppTypeEnum.IL2CPP_TYPE_I4: case Il2CppTypeEnum.IL2CPP_TYPE_U4: case Il2CppTypeEnum.IL2CPP_TYPE_I8: case Il2CppTypeEnum.IL2CPP_TYPE_U8: case Il2CppTypeEnum.IL2CPP_TYPE_R4: case Il2CppTypeEnum.IL2CPP_TYPE_R8: case Il2CppTypeEnum.IL2CPP_TYPE_STRING: case Il2CppTypeEnum.IL2CPP_TYPE_TYPEDBYREF: case Il2CppTypeEnum.IL2CPP_TYPE_I: case Il2CppTypeEnum.IL2CPP_TYPE_U: case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE: case Il2CppTypeEnum.IL2CPP_TYPE_CLASS: case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT: { var typeDef = metadata.typeDefs[il2CppType.data.klassIndex]; return(structNameDic[typeDef]); } case Il2CppTypeEnum.IL2CPP_TYPE_PTR: { var oriType = il2Cpp.GetIl2CppType(il2CppType.data.type); return(GetIl2CppStructName(oriType)); } case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY: //TODO case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY: //TODO return("Il2CppArray*"); case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST: { if (!genericClassStructNameDic.TryGetValue(il2CppType.data.generic_class, out var typeStructName)) { var genericClass = il2Cpp.MapVATR <Il2CppGenericClass>(il2CppType.data.generic_class); var typeDef = metadata.typeDefs[genericClass.typeDefinitionIndex]; var typeOriName = structNameDic[typeDef]; var typeToReplaceName = FixName(executor.GetTypeDefName(typeDef, true, true)); var typeReplaceName = FixName(executor.GetTypeName(il2CppType, true, false)); typeStructName = typeOriName.Replace(typeToReplaceName, typeReplaceName); genericClassStructNameDic.Add(il2CppType.data.generic_class, typeStructName); if (structNameHashSet.Add(typeStructName)) { genericClassList.Add(il2CppType.data.generic_class); } } return(typeStructName); } default: throw new NotSupportedException(); } }