/// <summary>
/// Gets a <see cref="CorLibTypeSig"/> if <paramref name="namespace"/> and
/// <paramref name="name"/> matches a primitive type.
/// </summary>
/// <param name="self">this</param>
/// <param name="namespace">Namespace</param>
/// <param name="name">Name</param>
/// <param name="defAsm">Definition assembly</param>
/// <returns>A <see cref="CorLibTypeSig"/> or <c>null</c> if it didn't match any primitive type</returns>
public static CorLibTypeSig GetCorLibTypeSig(this ICorLibTypes self, string @namespace, string name, IAssembly defAsm)
{
if (@namespace != "System")
{
return(null);
}
if (defAsm is null || !defAsm.IsCorLib())
{
return(null);
}
return(name switch {
"Void" => self.Void,
"Boolean" => self.Boolean,
"Char" => self.Char,
"SByte" => self.SByte,
"Byte" => self.Byte,
"Int16" => self.Int16,
"UInt16" => self.UInt16,
"Int32" => self.Int32,
"UInt32" => self.UInt32,
"Int64" => self.Int64,
"UInt64" => self.UInt64,
"Single" => self.Single,
"Double" => self.Double,
"String" => self.String,
"TypedReference" => self.TypedReference,
"IntPtr" => self.IntPtr,
"UIntPtr" => self.UIntPtr,
"Object" => self.Object,
_ => null,
});
public void Initialize(DecompilerContext context, ILBlock method)
{
this.labelGlobalRefCount.Clear();
this.labelToBasicBlock.Clear();
this.context = context;
this.corLib = context.CurrentMethod.Module.CorLibTypes;
foreach (var e in method.GetSelfAndChildrenRecursive <ILExpression>(List_ILExpression, e => e.IsBranch()))
{
foreach (var target in e.GetBranchTargets())
{
labelGlobalRefCount[target] = labelGlobalRefCount.GetOrDefault(target) + 1;
}
}
foreach (ILBasicBlock bb in method.GetSelfAndChildrenRecursive <ILBasicBlock>(List_ILBasicBlock))
{
int index = 0;
for (;;)
{
var node = bb.GetNext(ref index);
if (node == null)
{
break;
}
var label = node as ILLabel;
if (label == null)
{
continue;
}
labelToBasicBlock[label] = bb;
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="helper">Token resolver</param>
/// <param name="corLibTypes">ICorLibTypes instance</param>
/// <param name="reader">The signature data</param>
SignatureReader(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, IImageStream reader)
{
this.helper = helper;
this.corLibTypes = corLibTypes;
this.reader = reader;
this.recursionCounter = new RecursionCounter();
}
private TypeSig getRandomTypeSigForField(ICorLibTypes types)
{
switch (random.Next(6))
{
case 0:
return(types.Byte);
case 1:
return(types.Char);
case 2:
return(types.Boolean);
case 3:
return(types.String);
case 4:
return(types.Object);
case 5:
return(types.Int16);
default:
return(types.Byte);
}
}
/// <summary>
/// Reads a <see cref="TypeSig"/> signature
/// </summary>
/// <param name="helper">Token resolver</param>
/// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param>
/// <param name="signature">The signature reader which will be owned by us</param>
/// <param name="gpContext">Generic parameter context</param>
/// <param name="extraData">If there's any extra data after the signature, it's saved
/// here, else this will be <c>null</c></param>
/// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if
/// <paramref name="signature"/> is invalid.</returns>
public static TypeSig ReadTypeSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, IBinaryReader signature, GenericParamContext gpContext, out byte[] extraData)
{
try
{
using (var reader = new SignatureReader(helper, corLibTypes, signature, gpContext))
{
TypeSig ts;
try
{
ts = reader.ReadType();
}
catch (IOException)
{
reader.reader.Position = 0;
ts = null;
}
extraData = reader.GetExtraData();
return(ts);
}
}
catch
{
extraData = null;
return(null);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="helper">Token resolver</param>
/// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param>
/// <param name="reader">The signature data</param>
/// <param name="gpContext">Generic parameter context</param>
SignatureReader(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, IBinaryReader reader, GenericParamContext gpContext)
{
this.helper = helper;
this.corLibTypes = corLibTypes;
this.reader = reader;
this.gpContext = gpContext;
this.recursionCounter = new RecursionCounter();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="readerModule">Reader module</param>
/// <param name="sig">#Blob stream offset of signature</param>
/// <param name="gpContext">Generic parameter context</param>
SignatureReader(ModuleDefMD readerModule, uint sig, GenericParamContext gpContext)
{
helper = readerModule;
corLibTypes = readerModule.CorLibTypes;
reader = readerModule.BlobStream.CreateReader(sig);
this.gpContext = gpContext;
recursionCounter = new RecursionCounter();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
AddZephyrFishBuffID();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes ;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
AddZephyrFishBuffID();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Proj = memRes.GetType("Terraria.Projectile");
WrapMethods();
AddFieldForBHandler();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Proj = memRes.GetType("Terraria.Projectile");
WrapMethods();
AddFieldForBHandler();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Recipe = memRes.GetType("Terraria.Recipe");
AddGroupRecipeField();
WrapMethods();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes ;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Recipe = memRes.GetType("Terraria.Recipe");
AddGroupRecipeField();
WrapMethods();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_WorldFile = memRes.GetType("Terraria.IO.WorldFile");
InjectSaveHook();
InjectLoadHook();
EnlargeFrameImportantArray();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes ;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Item = memRes.GetType("Terraria.Item");
WrapSetDefaults();
AddFieldForBHandler();
AddFieldForSound();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_WorldFile = memRes.GetType("Terraria.IO.WorldFile");
InjectSaveHook();
InjectLoadHook();
EnlargeFrameImportantArray();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes ;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Item = memRes.GetType("Terraria.Item");
WrapSetDefaults();
AddFieldForBHandler();
AddFieldForSound();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Mount = memRes.GetType("Terraria.Mount");
WrapMethods();
AddFieldForBHandler();
Remove_FromFields();
RemoveTypeLimitations();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Mount = memRes.GetType("Terraria.Mount");
WrapMethods();
AddFieldForBHandler();
Remove_FromFields();
RemoveTypeLimitations();
}
/// <summary>
/// Gets a <see cref="CorLibTypeSig"/> if <paramref name="namespace"/> and
/// <paramref name="name"/> matches a primitive type.
/// </summary>
/// <param name="self">this</param>
/// <param name="namespace">Namespace</param>
/// <param name="name">Name</param>
/// <param name="defAsm">Definition assembly</param>
/// <returns>A <see cref="CorLibTypeSig"/> or <c>null</c> if it didn't match any primitive type</returns>
public static CorLibTypeSig GetCorLibTypeSig(this ICorLibTypes self, string @namespace, string name, IAssembly defAsm)
{
if (@namespace != "System")
{
return(null);
}
if (defAsm == null || !defAsm.IsCorLib())
{
return(null);
}
switch (name)
{
case "Void": return(self.Void);
case "Boolean": return(self.Boolean);
case "Char": return(self.Char);
case "SByte": return(self.SByte);
case "Byte": return(self.Byte);
case "Int16": return(self.Int16);
case "UInt16": return(self.UInt16);
case "Int32": return(self.Int32);
case "UInt32": return(self.UInt32);
case "Int64": return(self.Int64);
case "UInt64": return(self.UInt64);
case "Single": return(self.Single);
case "Double": return(self.Double);
case "String": return(self.String);
case "TypedReference": return(self.TypedReference);
case "IntPtr": return(self.IntPtr);
case "UIntPtr": return(self.UIntPtr);
case "Object": return(self.Object);
}
return(null);
}
public SimpleControlFlow(DecompilerContext context, ILBlock method)
{
this.context = context;
this.corLib = context.CurrentMethod.Module.CorLibTypes;
foreach(ILLabel target in method.GetSelfAndChildrenRecursive<ILExpression>(e => e.IsBranch()).SelectMany(e => e.GetBranchTargets())) {
labelGlobalRefCount[target] = labelGlobalRefCount.GetOrDefault(target) + 1;
}
foreach(ILBasicBlock bb in method.GetSelfAndChildrenRecursive<ILBasicBlock>()) {
foreach(ILLabel label in bb.GetChildren().OfType<ILLabel>()) {
labelToBasicBlock[label] = bb;
}
}
}
/// <summary>
/// Reads a <see cref="CallingConventionSig"/> signature
/// </summary>
/// <param name="helper">Token resolver</param>
/// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param>
/// <param name="signature">The signature reader</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="CallingConventionSig"/> instance or <c>null</c> if
/// <paramref name="signature"/> is invalid.</returns>
public static CallingConventionSig ReadSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, DataReader signature, GenericParamContext gpContext)
{
try {
var reader = new SignatureReader(helper, corLibTypes, ref signature, gpContext);
if (reader.reader.Length == 0)
{
return(null);
}
return(reader.ReadSig());
}
catch {
return(null);
}
}
/// <summary>
/// Reads a <see cref="CallingConventionSig"/> signature
/// </summary>
/// <param name="helper">Token resolver</param>
/// <param name="corLibTypes">ICorLibTypes instance</param>
/// <param name="signature">The signature reader which will be owned by us</param>
/// <returns>A new <see cref="CallingConventionSig"/> instance or <c>null</c> if
/// <paramref name="signature"/> is invalid.</returns>
public static CallingConventionSig ReadSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, IImageStream signature)
{
try {
using (var reader = new SignatureReader(helper, corLibTypes, signature)) {
if (reader.reader.Length == 0)
{
return(null);
}
return(reader.ReadSig());
}
}
catch {
return(null);
}
}
/*static bool IsGet2DArrCall(TypeReference arrayType, Instruction i)
* {
* var inner = arrayType.GetElementType();
*
* if (i.OpCode.Code != Code.Call)
* return false;
*
* var mtd = i.Operand as MethodReference;
*
* // for debugging
* //if (mtd == null)
* // return false;
* //if (mtd.Name != "Get")
* // return false;
* //if (mtd.DeclaringType.FullName != arrayType.FullName)
* // return false;
* //if (!mtd.HasThis)
* // return false;
* //if (mtd.ReturnType != inner)
* // return false;
* //if (mtd.Parameters.Count != 2)
* // return false;
* //if (!mtd.Parameters.All(pd => pd.ParameterType == typeSys.Int32))
* // return false;
*
* //return true;
*
* return mtd != null && mtd.Name == "Get" && mtd.DeclaringType.FullName == arrayType.FullName && mtd.ReturnType == inner && !mtd.HasGenericParameters && mtd.Parameters.Count == 2 && mtd.Parameters.All(pd => pd.ParameterType == typeSys.Int32) && mtd.HasThis;
* }*/
/*static void AddExtendedWallTypeField()
* {
* var wallTypeEx = new FieldDefinition("P_wallTypeEx", FieldAttributes.Assembly | FieldAttributes.Static, memRes.ReferenceOf(typeof(ushort[])));
*
* var main_t = memRes.GetType("Terraria.Main");
*
#region add field
* {
* typeDef_Tile.Fields.Add(wallTypeEx);
*
* // initialize in static ctor
* var cb = typeDef_Tile.GetOrCreateStaticCtor().Body;
* var cproc = cb.GetILProcessor();
*
* var finalRet = cb.Instructions.Last();
*
* cproc.InsertBefore(finalRet, Instruction.Create(OpCodes.Ldsfld, main_t.GetField("maxTilesX")));
* cproc.InsertBefore(finalRet, Instruction.Create(OpCodes.Ldsfld, main_t.GetField("maxTilesY")));
* cproc.InsertBefore(finalRet, Instruction.Create(OpCodes.Dup));
* cproc.InsertBefore(finalRet, Instruction.Create(OpCodes.Newarr, wallTypeEx.FieldType));
* cproc.InsertBefore(finalRet, Instruction.Create(OpCodes.Stsfld, wallTypeEx));
* }
#endregion
*
#region add twodimentional getter
* {
* var getWallType = new MethodDefinition("GetWallType", MethodAttributes.Public | MethodAttributes.Static, typeSys.UInt16);
*
* getWallType.Parameters.Add(new ParameterDefinition("x", 0, typeSys.Int32));
* getWallType.Parameters.Add(new ParameterDefinition("y", 0, typeSys.Int32));
*
* var gwproc = getWallType.Body.GetILProcessor();
*
* gwproc.Emit(OpCodes.Ldsfld, wallTypeEx);
*
* // wallTypeEx[y * Main.maxTilesY + x]
* gwproc.Emit(OpCodes.Ldarg_1);
* //gwproc.Emit(OpCodes.Ldsfld, main_t.GetField("maxTilesY"));
* gwproc.Emit(OpCodes.Ldc_I4, LARGEST_WLD_Y);
* gwproc.Emit(OpCodes.Mul);
* gwproc.Emit(OpCodes.Ldarg_0);
* gwproc.Emit(OpCodes.Add);
* gwproc.Emit(OpCodes.Ldelem_Ref);
* gwproc.Emit(OpCodes.Ret);
*
* typeDef_Tile.Methods.Add(getWallType);
*
* // add an overload with a tile argument that ignores the tile, so the stack doesn't get messed up when using injected GetWallType(I) calls.
* {
* var getWallTypeI = new MethodDefinition("GetWallTypeI", MethodAttributes.Assembly | MethodAttributes.Static, typeSys.UInt16);
*
* getWallTypeI.Parameters.Add(new ParameterDefinition("tile", 0, typeSys.Object));
* getWallTypeI.Parameters.Add(new ParameterDefinition("x", 0, typeSys.Int32));
* getWallTypeI.Parameters.Add(new ParameterDefinition("y", 0, typeSys.Int32));
*
* var gwiproc = getWallTypeI.Body.GetILProcessor();
*
* gwiproc.Emit(OpCodes.Ldsfld, wallTypeEx);
*
* // wallTypeEx[y * Main.maxTilesY + x]
* gwiproc.Emit(OpCodes.Ldarg_2);
* //gwiproc.Emit(OpCodes.Ldsfld, main_t.GetField("maxTilesY"));
* gwiproc.Emit(OpCodes.Ldc_I4, LARGEST_WLD_Y);
* gwiproc.Emit(OpCodes.Mul);
* gwiproc.Emit(OpCodes.Ldarg_1);
* gwiproc.Emit(OpCodes.Add);
* gwiproc.Emit(OpCodes.Ldelem_Ref);
* gwiproc.Emit(OpCodes.Ret);
*
* typeDef_Tile.Methods.Add(getWallTypeI);
* }
* }
#endregion
*
#region add twodimentional setter
* {
* var setWallType = new MethodDefinition("SetWallType", MethodAttributes.Public | MethodAttributes.Static, typeSys.Void);
*
* setWallType.Parameters.Add(new ParameterDefinition("x" , 0, typeSys. Int32));
* setWallType.Parameters.Add(new ParameterDefinition("y" , 0, typeSys. Int32));
* setWallType.Parameters.Add(new ParameterDefinition("value", 0, typeSys.UInt16));
*
* var swproc = setWallType.Body.GetILProcessor();
*
* swproc.Emit(OpCodes.Ldsfld, wallTypeEx);
*
* // wallTypeEx[y * Main.maxTilesY + x]
* swproc.Emit(OpCodes.Ldarg_1);
* //swproc.Emit(OpCodes.Ldsfld, main_t.GetField("maxTilesY"));
* swproc.Emit(OpCodes.Ldc_I4, LARGEST_WLD_Y);
* swproc.Emit(OpCodes.Mul);
* swproc.Emit(OpCodes.Ldarg_0);
* swproc.Emit(OpCodes.Add);
* swproc.Emit(OpCodes.Ldarg_2);
* swproc.Emit(OpCodes.Stelem_Ref);
* swproc.Emit(OpCodes.Ret);
*
* typeDef_Tile.Methods.Add(setWallType);
*
* // add an overload with a tile argument that ignores the tile, so the stack doesn't get messed up when using injected SetWallType(I) calls.
* {
* var setWallTypeI = new MethodDefinition("SetWallTypeI", MethodAttributes.Assembly | MethodAttributes.Static, typeSys.Void);
*
* setWallTypeI.Parameters.Add(new ParameterDefinition("tile", 0, typeDef_Tile));
* setWallTypeI.Parameters.Add(new ParameterDefinition("x", 0, typeSys.Int32));
* setWallTypeI.Parameters.Add(new ParameterDefinition("y", 0, typeSys.Int32));
* setWallTypeI.Parameters.Add(new ParameterDefinition("value", 0, typeSys.UInt16));
*
* var swb = setWallTypeI.Body;
*
* var swiproc = swb.GetILProcessor();
*
* swiproc.Emit(OpCodes.Ldsfld, wallTypeEx);
*
* // wallTypeEx[y * Main.maxTilesY + x]
* swiproc.Emit(OpCodes.Ldarg_2);
* //swiproc.Emit(OpCodes.Ldsfld, main_t.GetField("maxTilesY"));
* swiproc.Emit(OpCodes.Ldc_I4, LARGEST_WLD_Y);
* swiproc.Emit(OpCodes.Mul);
* swiproc.Emit(OpCodes.Ldarg_1);
* swiproc.Emit(OpCodes.Add);
* swiproc.Emit(OpCodes.Ldarg_3);
* swiproc.Emit(OpCodes.Stelem_Ref);
* swiproc.Emit(OpCodes.Ret);
*
* typeDef_Tile.Methods.Add(setWallTypeI);
* }
* }
#endregion
* }*/
/*static void ReplaceGetWallTypeCalls()
* {
* var gw = typeDef_Tile.GetMethod("GetWallTypeI"); // using the internal version
*
* var main_t = memRes.GetType("Terraria.Main");
* var main_tile = main_t.GetField("tile");
* var tile_wall = typeDef_Tile.GetField("wall");
*
* foreach (var td in context.PrimaryAssembly.MainModule.Types)
* foreach (var md in td.Methods)
* {
* if (!md.HasBody)
* continue;
*
* var body = md.Body;
* var ins = body.Instructions;
* var proc = body.GetILProcessor();
*
* for (int i = 0; i < ins.Count; i++)
* {
* var n = ins[i];
*
* if (IsGet2DArrCall(main_tile.FieldType, n))
* {
* n = n.Next;
*
* if (n == null)
* continue;
*
* if (n.OpCode.Code == Code.Ldfld && n.Operand == tile_wall)
* {
* var p = ins[i].Previous; // shouldn't be null, tile array + indices are loaded on the IL stack
*
* proc.Remove(p.Next);
* proc.Remove(n);
*
* proc.InsertAfter(p, Instruction.Create(OpCodes.Call, gw));
*
* // rewire branch targets
* foreach (var i_ in ins)
* if (i_ != n && i_ != ins[i] && i_.Operand == ins[i])
* i_.Operand = p.Next;
*
* i--;
* }
* }
* }
* }
* }*/
/*static void ReplaceSetWallTypeCalls()
* {
* var sw = typeDef_Tile.GetMethod("SetWallTypeI"); // using the internal version
*
* var main_t = memRes.GetType("Terraria.Main");
* var main_tile = main_t.GetField("tile");
* var tile_wall = typeDef_Tile.GetField("wall");
*
* foreach (var td in context.PrimaryAssembly.MainModule.Types)
* foreach (var md in td.Methods)
* {
* if (!md.HasBody)
* continue;
*
* var body = md.Body;
* var ins = body.Instructions;
* var proc = body.GetILProcessor();
*
* for (int i = 0; i < ins.Count; i++)
* {
* var n = ins[i];
*
* if (n.OpCode.Code == Code.Stfld && n.Operand == tile_wall)
* {
* var p = ins[i].Previous; // shouldn't be null, tile array + indices are loaded on the IL stack
*
* proc.Remove(n);
*
* proc.InsertAfter(p, Instruction.Create(OpCodes.Call, sw));
*
* // rewire branch targets
* foreach (var i_ in ins)
* if (i_ != n && i_.Operand == n)
* i_.Operand = p.Next;
* }
* }
* }
* }
* static void HideWallField()
* {
* var wall = typeDef_Tile.GetField("wall");
*
* wall.Name = "P_wall";
*
* wall.Attributes = FieldAttributes.Assembly;
* }*/
#endregion
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Tile = memRes.GetType("Terraria.Tile");
ChangeFieldType();
ChangeLocalTypes();
//AddExtendedWallTypeField();
//ReplaceGetWallTypeCalls ();
//ReplaceSetWallTypeCalls ();
//HideWallField();
}
private MethodDef createObfuscatedByMethod(ICorLibTypes types, TypeDefUser typeDef)
{
MethodDefUser mdu = new MethodDefUser("You are fooled!", new MethodSig(CallingConvention.Default, 0, types.String, types.String), MethodAttributes.Public);
mdu.Body = new CilBody(false, new Instruction[] {
OpCodes.Nop.ToInstruction(),
OpCodes.Ldarg_0.ToInstruction(),
OpCodes.Ret.ToInstruction()
}, new ExceptionHandler[0], new Local[0]);
mdu.Parameters[0].CreateParamDef();
mdu.Parameters[0].ParamDef.Name = "wisser_tg";
typeDef.Methods.Add(mdu);
return(mdu);
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes ;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Tile = memRes.GetType("Terraria.Tile");
ChangeFieldType ();
ChangeLocalTypes();
//AddExtendedWallTypeField();
//ReplaceGetWallTypeCalls ();
//ReplaceSetWallTypeCalls ();
//HideWallField();
}
public IntrinsicsAssemblyBuilder(string corlibAssemblyFullName)
{
var corlibRef = new AssemblyRefUser(new AssemblyNameInfo(corlibAssemblyFullName));
module = new ModuleDefUser(Guid.NewGuid().ToString(), Guid.NewGuid(), corlibRef);
module.Kind = ModuleKind.Dll;
var asm = new AssemblyDefUser(Guid.NewGuid().ToString());
asm.Modules.Add(module);
intrinsicsType = new TypeDefUser(ExpressionCompilerConstants.IntrinsicAssemblyNamespace, ExpressionCompilerConstants.IntrinsicAssemblyTypeName, module.CorLibTypes.Object.TypeDefOrRef);
intrinsicsType.Attributes = TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.Class | TypeAttributes.AnsiClass | TypeAttributes.Abstract | TypeAttributes.Sealed;
module.Types.Add(intrinsicsType);
corlibTypes = module.CorLibTypes;
exceptionTypeSig = new ClassSig(corlibTypes.GetTypeRef(nameof(System), nameof(Exception)));
typeTypeSig = new ClassSig(corlibTypes.GetTypeRef(nameof(System), nameof(Type)));
guidTypeSig = new ValueTypeSig(corlibTypes.GetTypeRef(nameof(System), nameof(Guid)));
}
public SimpleControlFlow(DecompilerContext context, ILBlock method)
{
this.context = context;
this.corLib = context.CurrentMethod.Module.CorLibTypes;
foreach (ILLabel target in method.GetSelfAndChildrenRecursive <ILExpression>(e => e.IsBranch()).SelectMany(e => e.GetBranchTargets()))
{
labelGlobalRefCount[target] = labelGlobalRefCount.GetOrDefault(target) + 1;
}
foreach (ILBasicBlock bb in method.GetSelfAndChildrenRecursive <ILBasicBlock>())
{
foreach (ILLabel label in bb.GetChildren().OfType <ILLabel>())
{
labelToBasicBlock[label] = bb;
}
}
}
/// <summary>
/// Reads a <see cref="TypeSig"/> signature
/// </summary>
/// <param name="helper">Token resolver</param>
/// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param>
/// <param name="signature">The signature reader which will be owned by us</param>
/// <param name="gpContext">Generic parameter context</param>
/// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if
/// <paramref name="signature"/> is invalid.</returns>
public static TypeSig ReadTypeSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, IBinaryReader signature, GenericParamContext gpContext)
{
try {
using (var reader = new SignatureReader(helper, corLibTypes, signature, gpContext)) {
TypeSig ts;
try {
ts = reader.ReadType();
}
catch (IOException) {
ts = null;
}
return(ts);
}
}
catch {
return(null);
}
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes ;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_NPC = memRes.GetType("Terraria.NPC" );
WrapMethods();
AddFieldForBHandler();
AddFieldsForAudio();
InsertInitialize();
ReplaceSoundHitCalls();
ReplaceSoundKilledCalls();
InjectBuffEffectsCall();
InitBuffBHandlerArray();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Player = memRes.GetType("Terraria.Player");
WrapMethods();
AddFieldForBHandler();
AddPlaceThingHook();
InsertSaveLoadHooks();
RemoveBuggyPlayerLoading();
RemoveStatCaps();
ReplaceUseSoundCalls();
FixOnEnterWorldBackingFieldName();
InjectMidUpdate();
InitBuffBHandlerArray();
}
/// <summary>
/// Reads a <see cref="TypeSig"/> signature
/// </summary>
/// <param name="helper">Token resolver</param>
/// <param name="corLibTypes">ICorLibTypes instance</param>
/// <param name="signature">The signature reader which will be owned by us</param>
/// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if
/// <paramref name="signature"/> is invalid.</returns>
public static TypeSig ReadTypeSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, IImageStream signature)
{
try {
using (var reader = new SignatureReader(helper, corLibTypes, signature)) {
TypeSig ts;
try {
ts = reader.ReadType();
}
catch (IOException) {
reader.reader.Position = 0;
ts = null;
}
return(ts);
}
}
catch {
return(null);
}
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_NPC = memRes.GetType("Terraria.NPC");
WrapMethods();
AddFieldForBHandler();
AddFieldsForAudio();
InsertInitialize();
ReplaceSoundHitCalls();
ReplaceSoundKilledCalls();
InjectBuffEffectsCall();
InitBuffBHandlerArray();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Player = memRes.GetType("Terraria.Player");
WrapMethods();
AddFieldForBHandler();
AddPlaceThingHook();
InsertSaveLoadHooks();
RemoveBuggyPlayerLoading();
RemoveStatCaps();
ReplaceUseSoundCalls();
FixOnEnterWorldBackingFieldName();
InjectMidUpdate();
InitBuffBHandlerArray();
}
internal static void Patch()
{
context = TerrariaPatcher.context;
memRes = TerrariaPatcher.memRes;
typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes;
typeDef_Main = memRes.GetType("Terraria.Main");
WrapMethods();
RemoveVanillaNpcDrawLimitation();
FixOnEngineLoadField();
RemoveArmourDrawLimitations();
AddPreDrawHook();
AddOnUpdateKeyboardHook();
AddPostScreenClearHook();
//These are causing System.InvalidProgramExceptions so I'm just commenting them out (pls don't remove them)
//AddIsChatAllowedHook();
//AddLocalChatHook();
}
/// <summary>
/// Gets a <see cref="CorLibTypeSig"/> if <paramref name="type"/> matches a primitive type.
/// </summary>
/// <param name="self">this</param>
/// <param name="type">The type</param>
/// <returns>A <see cref="CorLibTypeSig"/> or <c>null</c> if it didn't match any primitive type</returns>
public static CorLibTypeSig GetCorLibTypeSig(this ICorLibTypes self, ITypeDefOrRef type)
{
CorLibTypeSig corLibType;
if (type is TypeDef td &&
td.DeclaringType is null &&
!((corLibType = self.GetCorLibTypeSig(td.Namespace, td.Name, td.DefinitionAssembly)) is null))
{
return(corLibType);
}
if (type is TypeRef tr &&
!(tr.ResolutionScope is TypeRef) &&
!((corLibType = self.GetCorLibTypeSig(tr.Namespace, tr.Name, tr.DefinitionAssembly)) is null))
{
return(corLibType);
}
return(null);
}
public static CorLibTypeSig GetCorLibTypeSig(this ICorLibTypes clt, ElementType t)
{
switch (t)
{
case ElementType.I: return(clt.IntPtr);
case ElementType.U: return(clt.UIntPtr);
case ElementType.I1: return(clt.SByte);
case ElementType.I2: return(clt.Int16);
case ElementType.I4: return(clt.Int32);
case ElementType.I8: return(clt.Int64);
case ElementType.U1: return(clt.Byte);
case ElementType.U2: return(clt.UInt16);
case ElementType.U4: return(clt.UInt32);
case ElementType.U8: return(clt.UInt64);
case ElementType.R4: return(clt.Single);
case ElementType.R8: return(clt.Double);
case ElementType.Char: return(clt.Char);
case ElementType.Void: return(clt.Void);
case ElementType.Object: return(clt.Object);
case ElementType.String: return(clt.String);
case ElementType.Boolean: return(clt.Boolean);
default: throw new CodeBug.Unreachable();
}
}
public void Initialize(DecompilerContext context, ILBlock method)
{
this.labelGlobalRefCount.Clear();
this.labelToBasicBlock.Clear();
this.context = context;
this.corLib = context.CurrentMethod.Module.CorLibTypes;
foreach (var e in method.GetSelfAndChildrenRecursive<ILExpression>(List_ILExpression, e => e.IsBranch())) {
foreach (var target in e.GetBranchTargets())
labelGlobalRefCount[target] = labelGlobalRefCount.GetOrDefault(target) + 1;
}
foreach(ILBasicBlock bb in method.GetSelfAndChildrenRecursive<ILBasicBlock>(List_ILBasicBlock)) {
int index = 0;
for (;;) {
var node = bb.GetNext(ref index);
if (node == null)
break;
var label = node as ILLabel;
if (label == null)
continue;
labelToBasicBlock[label] = bb;
}
}
}
public Il2cppContext(string imagePath)
{
Module = ModuleDefMD.Load(imagePath);
Debug.Assert(Module != null);
// 加载主模块
AssemblyResolver asmRes = new AssemblyResolver();
ModuleContext modCtx = new ModuleContext(asmRes);
asmRes.DefaultModuleContext = modCtx;
asmRes.EnableTypeDefCache = true;
asmRes.FindExactMatch = false;
asmRes.EnableFrameworkRedirect = true;
asmRes.FrameworkRedirectVersion = Module.RuntimeVersion;
Module.Context = modCtx;
Module.Context.AssemblyResolver.AddToCache(Module);
CorLibTypes = Module.CorLibTypes;
CorLibModule = CorLibTypes.Object.TypeRef.Resolve().Module;
RuntimeVersion = Module.RuntimeVersion;
Reset();
}
/// <summary>
/// Gets a <see cref="CorLibTypeSig"/> if <paramref name="type"/> matches a primitive type.
/// </summary>
/// <param name="self">this</param>
/// <param name="type">The type</param>
/// <returns>A <see cref="CorLibTypeSig"/> or <c>null</c> if it didn't match any primitive type</returns>
public static CorLibTypeSig GetCorLibTypeSig(this ICorLibTypes self, ITypeDefOrRef type)
{
CorLibTypeSig corLibType;
TypeDef td;
if ((td = type as TypeDef) != null &&
td.DeclaringType == null &&
(corLibType = self.GetCorLibTypeSig(td.Namespace, td.Name, td.DefinitionAssembly)) != null)
{
return(corLibType);
}
TypeRef tr;
if ((tr = type as TypeRef) != null &&
!(tr.ResolutionScope is TypeRef) &&
(corLibType = self.GetCorLibTypeSig(tr.Namespace, tr.Name, tr.DefinitionAssembly)) != null)
{
return(corLibType);
}
return(null);
}
public IEnumerable <TypeDefUser> Execute(ICorLibTypes types)
{
string current_namespace = "DEFAULT_IF_NOT_EXISTS";
for (int i = 0; i < junksAmount; i++)
{
if (i % 4 == 0)
{
current_namespace = renamer.GetObfuscated(false);
}
TypeDefUser tdu = new TypeDefUser(current_namespace, renamer.GetObfuscated(false));
tdu.Attributes = TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed;
MethodDef md_obf = createObfuscatedByMethod(types, tdu);
for (int fields_i = 0; fields_i < random.Next(junksFieldsA, junksFieldsB); fields_i++)
{
tdu.Fields.Add(new FieldDefUser(renamer.GetObfuscated(false), new FieldSig(getRandomTypeSigForField(types)), fields_i % 3 == 0 ? FieldAttributes.Private : FieldAttributes.Public));
}
for (int methods_i = 0; methods_i < random.Next(junksFieldsA, junksFieldsB); methods_i++)
{
MethodDefUser mdu = new MethodDefUser(renamer.GetObfuscated(false), new MethodSig(CallingConvention.Default, 0, types.String), methods_i % 3 == 0 ? MethodAttributes.Public : MethodAttributes.Private);
mdu.Body = new CilBody(true, new Instruction[] {
OpCodes.Nop.ToInstruction(),
OpCodes.Ldstr.ToInstruction("Obfuscated by Wisser Tg"),
OpCodes.Callvirt.ToInstruction(md_obf),
OpCodes.Ret.ToInstruction()
}, new ExceptionHandler[0], new Local[0]);
tdu.Methods.Add(mdu);
}
yield return(tdu);
}
}
/* needs a better name */
static TypeSig ICast(TypeSig a, TypeSig b, ICorLibTypes ts)
{
if (comp.Equals(a, b))
return a;
if (comp.Equals(a, ts.String))
return a;
if (comp.Equals(b, ts.String))
return b;
if (comp.Equals(a, ts.IntPtr) || comp.Equals(a, ts.UIntPtr))
return a;
if (comp.Equals(b, ts.IntPtr) || comp.Equals(b, ts.UIntPtr))
return b;
if (comp.Equals(a, ts.Double))
return a;
if (comp.Equals(b, ts.Double))
return b;
if (comp.Equals(a, ts.Single))
return a;
if (comp.Equals(b, ts.Single))
return b;
if (comp.Equals(a, ts.Int64) || comp.Equals(a, ts.UInt64))
return a;
if (comp.Equals(b, ts.Int64) || comp.Equals(b, ts.UInt64))
return b;
if (!a.IsByRef || !b.IsByRef)
return ts.Object;
var ad = a.ToTypeDefOrRef().ResolveTypeDefThrow();
var bd = b.ToTypeDefOrRef().ResolveTypeDefThrow();
if ((!ad.IsSequentialLayout || !ad.IsExplicitLayout) && (!bd.IsSequentialLayout || !bd.IsExplicitLayout))
return ts.IntPtr;
// close enough
return ad.PackingSize > bd.PackingSize ? a : b;
}
public PatternMatcher(ICorLibTypes corLib)
{
this.corLib = corLib;
}
public PatternMatcher(DecompilerContext context, ICorLibTypes corLib)
{
this.context = context;
this.corLib = corLib;
}
public void Initialize(ICorLibTypes corLib)
{
this.corLib = corLib;
Reset();
}
public PatternMatcher(ICorLibTypes typeSystem)
{
this.typeSystem = typeSystem;
}
