Merge branch 'master' of https://github.com/Perfare/Il2CppDumper

Perfare · Perfare · commit d0eeb82c81db · 2021-12-06T07:34:09.000+08:00
diff --git a/Il2CppDumper/Il2CppDumper.csproj b/Il2CppDumper/Il2CppDumper.csproj
@@ -25,6 +25,9 @@
     <None Update="ghidra.py">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Update="ghidra_wasm.py">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Update="ghidra_with_struct.py">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
diff --git a/Il2CppDumper/Outputs/ScriptJson.cs b/Il2CppDumper/Outputs/ScriptJson.cs
@@ -21,6 +21,7 @@ public class ScriptMethod
         public ulong Address;
         public string Name;
         public string Signature;
+        public string TypeSignature;
     }
 
     public class ScriptString
diff --git a/Il2CppDumper/Outputs/StructGenerator.cs b/Il2CppDumper/Outputs/StructGenerator.cs
@@ -89,6 +89,7 @@ public void WriteScript(string outputDir)
                         var methodPointer = il2Cpp.GetMethodPointer(imageName, methodDef);
                         if (methodPointer > 0)
                         {
+                            var methodTypeSignature = new List<Il2CppTypeEnum>();
                             var scriptMethod = new ScriptMethod();
                             json.ScriptMethod.Add(scriptMethod);
                             scriptMethod.Address = il2Cpp.GetRVA(methodPointer);
@@ -101,15 +102,18 @@ public void WriteScript(string outputDir)
                             {
                                 returnType += "*";
                             }
+                            methodTypeSignature.Add(methodReturnType.byref == 1 ? Il2CppTypeEnum.IL2CPP_TYPE_PTR : methodReturnType.type);
                             var signature = $"{returnType} {FixName(methodFullName)} (";
                             var parameterStrs = new List<string>();
                             if ((methodDef.flags & METHOD_ATTRIBUTE_STATIC) == 0)
                             {
                                 var thisType = ParseType(il2Cpp.types[typeDef.byvalTypeIndex]);
+                                methodTypeSignature.Add(il2Cpp.types[typeDef.byvalTypeIndex].type);
                                 parameterStrs.Add($"{thisType} __this");
                             }
                             else if (il2Cpp.Version <= 24)
                             {
+                                methodTypeSignature.Add(Il2CppTypeEnum.IL2CPP_TYPE_PTR);
                                 parameterStrs.Add($"Il2CppObject* __this");
                             }
                             for (var j = 0; j < methodDef.parameterCount; j++)
@@ -122,12 +126,15 @@ public void WriteScript(string outputDir)
                                 {
                                     parameterCType += "*";
                                 }
+                                methodTypeSignature.Add(parameterType.byref == 1 ? Il2CppTypeEnum.IL2CPP_TYPE_PTR : parameterType.type);
                                 parameterStrs.Add($"{parameterCType} {FixName(parameterName)}");
                             }
+                            methodTypeSignature.Add(Il2CppTypeEnum.IL2CPP_TYPE_PTR);
                             parameterStrs.Add("const MethodInfo* method");
                             signature += string.Join(", ", parameterStrs);
                             signature += ");";
                             scriptMethod.Signature = signature;
+                            scriptMethod.TypeSignature = GetMethodTypeSignature(methodTypeSignature);
                         }
                         //泛型实例函数
                         if (il2Cpp.methodDefinitionMethodSpecs.TryGetValue(i, out var methodSpecs))
@@ -137,6 +144,7 @@ public void WriteScript(string outputDir)
                                 var genericMethodPointer = il2Cpp.methodSpecGenericMethodPointers[methodSpec];
                                 if (genericMethodPointer > 0)
                                 {
+                                    var methodTypeSignature = new List<Il2CppTypeEnum>();
                                     var scriptMethod = new ScriptMethod();
                                     json.ScriptMethod.Add(scriptMethod);
                                     scriptMethod.Address = il2Cpp.GetRVA(genericMethodPointer);
@@ -158,6 +166,7 @@ public void WriteScript(string outputDir)
                                     {
                                         returnType += "*";
                                     }
+                                    methodTypeSignature.Add(methodReturnType.byref == 1 ? Il2CppTypeEnum.IL2CPP_TYPE_PTR : methodReturnType.type);
                                     var signature = $"{returnType} {FixName(methodFullName)} (";
                                     var parameterStrs = new List<string>();
                                     if ((methodDef.flags & METHOD_ATTRIBUTE_STATIC) == 0)
@@ -172,21 +181,25 @@ public void WriteScript(string outputDir)
                                             if (nameGenericClassDic.TryGetValue(typeStructName, out var il2CppType))
                                             {
                                                 thisType = ParseType(il2CppType);
+                                                methodTypeSignature.Add(il2CppType.type);
                                             }
                                             else
                                             {
                                                 //没有单独的泛型实例类
                                                 thisType = ParseType(il2Cpp.types[typeDef.byvalTypeIndex]);
+                                                methodTypeSignature.Add(il2Cpp.types[typeDef.byvalTypeIndex].type);
                                             }
                                         }
                                         else
                                         {
                                             thisType = ParseType(il2Cpp.types[typeDef.byvalTypeIndex]);
+                                            methodTypeSignature.Add(il2Cpp.types[typeDef.byvalTypeIndex].type);
                                         }
                                         parameterStrs.Add($"{thisType} __this");
                                     }
                                     else if (il2Cpp.Version <= 24)
                                     {
+                                        methodTypeSignature.Add(Il2CppTypeEnum.IL2CPP_TYPE_PTR);
                                         parameterStrs.Add($"Il2CppObject* __this");
                                     }
                                     for (var j = 0; j < methodDef.parameterCount; j++)
@@ -199,12 +212,15 @@ public void WriteScript(string outputDir)
                                         {
                                             parameterCType += "*";
                                         }
+                                        methodTypeSignature.Add(parameterType.byref == 1 ? Il2CppTypeEnum.IL2CPP_TYPE_PTR : parameterType.type);
                                         parameterStrs.Add($"{parameterCType} {FixName(parameterName)}");
                                     }
+                                    methodTypeSignature.Add(Il2CppTypeEnum.IL2CPP_TYPE_PTR);
                                     parameterStrs.Add($"const {methodInfoName}* method");
                                     signature += string.Join(", ", parameterStrs);
                                     signature += ");";
                                     scriptMethod.Signature = signature;
+                                    scriptMethod.TypeSignature = GetMethodTypeSignature(methodTypeSignature);
                                 }
                             }
                         }
@@ -644,6 +660,57 @@ private string ParseType(Il2CppType il2CppType, Il2CppGenericContext context = n
                     throw new NotSupportedException();
             }
         }
+        public string GetMethodTypeSignature(List<Il2CppTypeEnum> types)
+        {
+            string signature = string.Empty;
+            foreach (Il2CppTypeEnum type in types)
+            {
+                switch (type)
+                {
+                    case Il2CppTypeEnum.IL2CPP_TYPE_VOID:
+                        signature += "v";
+                        break;
+                    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:
+                        signature += "i";
+                        break;
+                    case Il2CppTypeEnum.IL2CPP_TYPE_I8:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_U8:
+                        signature += "j";
+                        break;
+                    case Il2CppTypeEnum.IL2CPP_TYPE_R4:
+                        signature += "f";
+                        break;
+                    case Il2CppTypeEnum.IL2CPP_TYPE_R8:
+                        signature += "d";
+                        break;
+                    case Il2CppTypeEnum.IL2CPP_TYPE_STRING:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_PTR:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_VAR:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_TYPEDBYREF:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_I:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_U:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:
+                    case Il2CppTypeEnum.IL2CPP_TYPE_MVAR:
+                        signature += "i";
+                        break;
+                    default:
+                        throw new NotSupportedException();
+                }
+            }
+            return signature;
+        }
 
         private void AddStruct(Il2CppTypeDefinition typeDef)
         {
diff --git a/Il2CppDumper/ghidra_wasm.py b/Il2CppDumper/ghidra_wasm.py
@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+import json
+
+from wasm import WasmLoader
+from wasm.analysis import WasmAnalysis
+from ghidra.util.task import ConsoleTaskMonitor
+
+monitor = ConsoleTaskMonitor()
+WasmLoader.loadElementsToTable(currentProgram, WasmAnalysis.getState(currentProgram).module, 0, 0, 0, monitor)
+
+runScript("analyze_dyncalls.py")
+
+processFields = [
+	"ScriptMethod",
+	"ScriptString",
+	"ScriptMetadata",
+	"ScriptMetadataMethod",
+	"Addresses",
+]
+
+functionManager = currentProgram.getFunctionManager()
+progspace = currentProgram.addressFactory.getAddressSpace("ram")
+USER_DEFINED = ghidra.program.model.symbol.SourceType.USER_DEFINED
+
+def get_addr(addr):
+	return progspace.getAddress(addr)
+
+def set_name(addr, name):
+	name = name.replace(' ', '-')
+	createLabel(addr, name, True, USER_DEFINED)
+
+def make_function(start):
+	func = getFunctionAt(start)
+	if func is None:
+		createFunction(start, None)
+
+f = askFile("script.json from Il2cppdumper", "Open")
+data = json.loads(open(f.absolutePath, 'rb').read().decode('utf-8'))
+
+
+if "ScriptMethod" in data and "ScriptMethod" in processFields:
+	scriptMethods = data["ScriptMethod"]
+	dynCallNamespace =  currentProgram.symbolTable.getNamespace("dynCall", None)
+	monitor.initialize(len(scriptMethods))
+	monitor.setMessage("Methods")
+	for scriptMethod in scriptMethods:
+		offset = scriptMethod["Address"]
+		sig = scriptMethod["TypeSignature"]
+		symbolName = "func_%s_%d" % (sig, offset)
+		symbol = currentProgram.symbolTable.getSymbol(symbolName, dynCallNamespace)
+		if symbol:
+			addr = symbol.address
+			name = scriptMethod["Name"].encode("utf-8")
+			set_name(addr, name)
+		else:
+			print "Warning at %s:" % scriptMethod["Name"]
+			print "Symbol %s not found!" % symbolName
+		monitor.incrementProgress(1)
+
+if "ScriptString" in data and "ScriptString" in processFields:
+	index = 1
+	scriptStrings = data["ScriptString"]
+	monitor.initialize(len(scriptStrings))
+	monitor.setMessage("Strings")
+	for scriptString in scriptStrings:
+		addr = get_addr(scriptString["Address"])
+		value = scriptString["Value"].encode("utf-8")
+		name = "StringLiteral_" + str(index)
+		createLabel(addr, name, True, USER_DEFINED)
+		setEOLComment(addr, value)
+		index += 1
+		monitor.incrementProgress(1)
+
+if "ScriptMetadata" in data and "ScriptMetadata" in processFields:
+	scriptMetadatas = data["ScriptMetadata"]
+	monitor.initialize(len(scriptMetadatas))
+	monitor.setMessage("Metadata")
+	for scriptMetadata in scriptMetadatas:
+		addr = get_addr(scriptMetadata["Address"])
+		name = scriptMetadata["Name"].encode("utf-8")
+		set_name(addr, name)
+		setEOLComment(addr, name)
+		monitor.incrementProgress(1)
+
+if "ScriptMetadataMethod" in data and "ScriptMetadataMethod" in processFields:
+	scriptMetadataMethods = data["ScriptMetadataMethod"]
+	monitor.initialize(len(scriptMetadataMethods))
+	monitor.setMessage("Metadata Methods")
+	for scriptMetadataMethod in scriptMetadataMethods:
+		addr = get_addr(scriptMetadataMethod["Address"])
+		name = scriptMetadataMethod["Name"].encode("utf-8")
+		methodAddr = get_addr(scriptMetadataMethod["MethodAddress"])
+		set_name(addr, name)
+		setEOLComment(addr, name)
+		monitor.incrementProgress(1)
+
+if "Addresses" in data and "Addresses" in processFields:
+	pass
+
+print 'Script finished!'
diff --git a/README.md b/README.md
@@ -54,6 +54,10 @@ structure information header file
 
 For Ghidra
 
+#### ghidra_wasm.py
+
+For Ghidra, work with [ghidra-wasm-plugin](https://github.com/nneonneo/ghidra-wasm-plugin)
+
 #### script.json
 
 For ida.py and ghidra.py
diff --git a/README.zh-CN.md b/README.zh-CN.md
@@ -52,6 +52,10 @@ Il2CppDumper.exe <executable-file> <global-metadata> <output-directory>
 
 用于Ghidra
 
+#### ghidra_wasm.py
+
+用于Ghidra, 和[ghidra-wasm-plugin](https://github.com/nneonneo/ghidra-wasm-plugin)一起工作
+
 #### script.json
 
 用于IDA和Ghidra脚本

Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@ public class ScriptMethod`
`21`	`21`	`public ulong Address;`
`22`	`22`	`public string Name;`
`23`	`23`	`public string Signature;`
	`24`	`+ public string TypeSignature;`
`24`	`25`	`}`
`25`	`26`
`26`	`27`	`public class ScriptString`
Original file line number	Diff line number	Diff line change
`@@ -89,6 +89,7 @@ public void WriteScript(string outputDir)`
`89`	`89`	`var methodPointer = il2Cpp.GetMethodPointer(imageName, methodDef);`
`90`	`90`	`if (methodPointer > 0)`
`91`	`91`	`{`
	`92`	`+ var methodTypeSignature = new List<Il2CppTypeEnum>();`
`92`	`93`	`var scriptMethod = new ScriptMethod();`
`93`	`94`	`json.ScriptMethod.Add(scriptMethod);`
`94`	`95`	`scriptMethod.Address = il2Cpp.GetRVA(methodPointer);`
`@@ -101,15 +102,18 @@ public void WriteScript(string outputDir)`
`101`	`102`	`{`
`102`	`103`	`returnType += "*";`
`103`	`104`	`}`
	`105`	`+ methodTypeSignature.Add(methodReturnType.byref == 1 ? Il2CppTypeEnum.IL2CPP_TYPE_PTR : methodReturnType.type);`
`104`	`106`	`var signature = $"{returnType} {FixName(methodFullName)} (";`
`105`	`107`	`var parameterStrs = new List<string>();`
`106`	`108`	`if ((methodDef.flags & METHOD_ATTRIBUTE_STATIC) == 0)`
`107`	`109`	`{`
`108`	`110`	`var thisType = ParseType(il2Cpp.types[typeDef.byvalTypeIndex]);`
	`111`	`+ methodTypeSignature.Add(il2Cpp.types[typeDef.byvalTypeIndex].type);`
`109`	`112`	`parameterStrs.Add($"{thisType} __this");`
`110`	`113`	`}`
`111`	`114`	`else if (il2Cpp.Version <= 24)`
`112`	`115`	`{`
	`116`	`+ methodTypeSignature.Add(Il2CppTypeEnum.IL2CPP_TYPE_PTR);`
`113`	`117`	`parameterStrs.Add($"Il2CppObject* __this");`
`114`	`118`	`}`
`115`	`119`	`for (var j = 0; j < methodDef.parameterCount; j++)`
`@@ -122,12 +126,15 @@ public void WriteScript(string outputDir)`
`122`	`126`	`{`
`123`	`127`	`parameterCType += "*";`
`124`	`128`	`}`
	`129`	`+ methodTypeSignature.Add(parameterType.byref == 1 ? Il2CppTypeEnum.IL2CPP_TYPE_PTR : parameterType.type);`
`125`	`130`	`parameterStrs.Add($"{parameterCType} {FixName(parameterName)}");`
`126`	`131`	`}`
	`132`	`+ methodTypeSignature.Add(Il2CppTypeEnum.IL2CPP_TYPE_PTR);`
`127`	`133`	`parameterStrs.Add("const MethodInfo* method");`
`128`	`134`	`signature += string.Join(", ", parameterStrs);`
`129`	`135`	`signature += ");";`
`130`	`136`	`scriptMethod.Signature = signature;`
	`137`	`+ scriptMethod.TypeSignature = GetMethodTypeSignature(methodTypeSignature);`
`131`	`138`	`}`
`132`	`139`	`//泛型实例函数`
`133`	`140`	`if (il2Cpp.methodDefinitionMethodSpecs.TryGetValue(i, out var methodSpecs))`
`@@ -137,6 +144,7 @@ public void WriteScript(string outputDir)`
`137`	`144`	`var genericMethodPointer = il2Cpp.methodSpecGenericMethodPointers[methodSpec];`
`138`	`145`	`if (genericMethodPointer > 0)`
`139`	`146`	`{`
	`147`	`+ var methodTypeSignature = new List<Il2CppTypeEnum>();`
`140`	`148`	`var scriptMethod = new ScriptMethod();`
`141`	`149`	`json.ScriptMethod.Add(scriptMethod);`
`142`	`150`	`scriptMethod.Address = il2Cpp.GetRVA(genericMethodPointer);`
`@@ -158,6 +166,7 @@ public void WriteScript(string outputDir)`
`158`	`166`	`{`
`159`	`167`	`returnType += "*";`
`160`	`168`	`}`
	`169`	`+ methodTypeSignature.Add(methodReturnType.byref == 1 ? Il2CppTypeEnum.IL2CPP_TYPE_PTR : methodReturnType.type);`
`161`	`170`	`var signature = $"{returnType} {FixName(methodFullName)} (";`
`162`	`171`	`var parameterStrs = new List<string>();`
`163`	`172`	`if ((methodDef.flags & METHOD_ATTRIBUTE_STATIC) == 0)`
`@@ -172,21 +181,25 @@ public void WriteScript(string outputDir)`
`172`	`181`	`if (nameGenericClassDic.TryGetValue(typeStructName, out var il2CppType))`
`173`	`182`	`{`
`174`	`183`	`thisType = ParseType(il2CppType);`
	`184`	`+ methodTypeSignature.Add(il2CppType.type);`
`175`	`185`	`}`
`176`	`186`	`else`
`177`	`187`	`{`
`178`	`188`	`//没有单独的泛型实例类`
`179`	`189`	`thisType = ParseType(il2Cpp.types[typeDef.byvalTypeIndex]);`
	`190`	`+ methodTypeSignature.Add(il2Cpp.types[typeDef.byvalTypeIndex].type);`
`180`	`191`	`}`
`181`	`192`	`}`
`182`	`193`	`else`
`183`	`194`	`{`
`184`	`195`	`thisType = ParseType(il2Cpp.types[typeDef.byvalTypeIndex]);`
	`196`	`+ methodTypeSignature.Add(il2Cpp.types[typeDef.byvalTypeIndex].type);`
`185`	`197`	`}`
`186`	`198`	`parameterStrs.Add($"{thisType} __this");`
`187`	`199`	`}`
`188`	`200`	`else if (il2Cpp.Version <= 24)`
`189`	`201`	`{`
	`202`	`+ methodTypeSignature.Add(Il2CppTypeEnum.IL2CPP_TYPE_PTR);`
`190`	`203`	`parameterStrs.Add($"Il2CppObject* __this");`
`191`	`204`	`}`
`192`	`205`	`for (var j = 0; j < methodDef.parameterCount; j++)`
`@@ -199,12 +212,15 @@ public void WriteScript(string outputDir)`
`199`	`212`	`{`
`200`	`213`	`parameterCType += "*";`
`201`	`214`	`}`
	`215`	`+ methodTypeSignature.Add(parameterType.byref == 1 ? Il2CppTypeEnum.IL2CPP_TYPE_PTR : parameterType.type);`
`202`	`216`	`parameterStrs.Add($"{parameterCType} {FixName(parameterName)}");`
`203`	`217`	`}`
	`218`	`+ methodTypeSignature.Add(Il2CppTypeEnum.IL2CPP_TYPE_PTR);`
`204`	`219`	`parameterStrs.Add($"const {methodInfoName}* method");`
`205`	`220`	`signature += string.Join(", ", parameterStrs);`
`206`	`221`	`signature += ");";`
`207`	`222`	`scriptMethod.Signature = signature;`
	`223`	`+ scriptMethod.TypeSignature = GetMethodTypeSignature(methodTypeSignature);`
`208`	`224`	`}`
`209`	`225`	`}`
`210`	`226`	`}`
`@@ -644,6 +660,57 @@ private string ParseType(Il2CppType il2CppType, Il2CppGenericContext context = n`
`644`	`660`	`throw new NotSupportedException();`
`645`	`661`	`}`
`646`	`662`	`}`
	`663`	`+ public string GetMethodTypeSignature(List<Il2CppTypeEnum> types)`
	`664`	`+ {`
	`665`	`+ string signature = string.Empty;`
	`666`	`+ foreach (Il2CppTypeEnum type in types)`
	`667`	`+ {`
	`668`	`+ switch (type)`
	`669`	`+ {`
	`670`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_VOID:`
	`671`	`+ signature += "v";`
	`672`	`+ break;`
	`673`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_BOOLEAN:`
	`674`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_CHAR:`
	`675`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_I1:`
	`676`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_U1:`
	`677`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_I2:`
	`678`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_U2:`
	`679`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_I4:`
	`680`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_U4:`
	`681`	`+ signature += "i";`
	`682`	`+ break;`
	`683`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_I8:`
	`684`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_U8:`
	`685`	`+ signature += "j";`
	`686`	`+ break;`
	`687`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_R4:`
	`688`	`+ signature += "f";`
	`689`	`+ break;`
	`690`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_R8:`
	`691`	`+ signature += "d";`
	`692`	`+ break;`
	`693`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_STRING:`
	`694`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_PTR:`
	`695`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_VALUETYPE:`
	`696`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_CLASS:`
	`697`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_VAR:`
	`698`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_ARRAY:`
	`699`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST:`
	`700`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_TYPEDBYREF:`
	`701`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_I:`
	`702`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_U:`
	`703`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_OBJECT:`
	`704`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_SZARRAY:`
	`705`	`+ case Il2CppTypeEnum.IL2CPP_TYPE_MVAR:`
	`706`	`+ signature += "i";`
	`707`	`+ break;`
	`708`	`+ default:`
	`709`	`+ throw new NotSupportedException();`
	`710`	`+ }`
	`711`	`+ }`
	`712`	`+ return signature;`
	`713`	`+ }`
`647`	`714`
`648`	`715`	`private void AddStruct(Il2CppTypeDefinition typeDef)`
`649`	`716`	`{`