private static Boolean Is_Ldarg_C(VirtualOpCode ins, Code code) { // Ldarg_C delegates will reference the arguments field in their Ldfld, which sets them apart from // other very similar delegates return(ins.Matches(ins.ModifyPattern(Pattern_Ldarg_C, Code.Ldc_I4, code)) && ((FieldDef)ins.DelegateMethod.Body.Instructions[2].Operand).MDToken == ins.VType.ArgumentsField.MDToken); }
public static Boolean Is_Cgt_Un(this VirtualOpCode ins) { return(ins.DelegateMethod.Matches(new Code[] { Code.Call, Code.Brtrue_S, Code.Ldc_I4_0, Code.Br_S, Code.Ldc_I4_1, Code.Callvirt, Code.Ldloc_2, Code.Call, Code.Ret }) && ins.DelegateMethod.MatchesIndirect(Pattern_Cgt_Un)); }
public static Boolean Is_Box(this VirtualOpCode ins) { return(ins.Matches(new Code[] { Code.Ldarg_1, Code.Castclass, Code.Callvirt, Code.Stloc_2, Code.Ldarg_0, Code.Ldloc_2, Code.Call, Code.Stloc_0, Code.Ldarg_0, Code.Call })); }
public static Boolean Is_Isinst(this VirtualOpCode ins) { return(ins.DelegateMethod.Matches( Code.Call, Code.Brfalse_S, Code.Ldarg_0, Code.Ldloc_2, Code.Call, Code.Ret, Code.Ldarg_0, Code.Newobj, Code.Call, Code.Ret )); }
protected Instruction ReadOneInstruction_CIL(VirtualOpCode virtualInstruction) { OpCode opcode = virtualInstruction.OpCode.ToOpCode(); Instruction instruction = new Instruction(opcode); instruction.Offset = this.CurrentILOffset; instruction.OpCode = opcode; instruction.Operand = this.ReadOperand(instruction); if (instruction.OpCode.Code == Code.Switch) { var targets = (IList <UInt32>)instruction.Operand; this.CurrentILOffset += (UInt32)(instruction.OpCode.Size + 4 + (4 * targets.Count)); this.CurrentVirtualOffset += (UInt32)(4 + 4 + (4 * targets.Count)); } else { this.CurrentILOffset += (UInt32)instruction.GetSize(); this.CurrentVirtualOffset += (UInt32)virtualInstruction.GetSize(instruction.Operand); } this.CurrentInstructionOffset++; return(instruction); }
public static Boolean Is_Leave(this VirtualOpCode ins) { return(ins.DelegateMethod.MatchesEntire( Code.Ldarg_1, Code.Castclass, Code.Callvirt, Code.Stloc_0, Code.Ldarg_0, Code.Ldnull, Code.Ldloc_0, Code.Call, Code.Ret )); }
public static Boolean Is_Throw(this VirtualOpCode ins) { return(ins.MatchesEntire(new Code[] { Code.Ldarg_0, Code.Call, Code.Stloc_0, Code.Ldloc_0, Code.Callvirt, Code.Call, Code.Ret }) && _Is_Throw(ins, ((MethodDef)ins.DelegateMethod.Body.Instructions[5].Operand))); }
public static Boolean Is_Newobj(this VirtualOpCode ins) { return(ins.Matches(new Code[] { Code.Ldarg_0, Code.Ldloc_2, Code.Ldnull, Code.Ldloc_3, Code.Ldc_I4_0, Code.Call, Code.Stloc_S, Code.Leave_S })); }
private static Boolean Is_Ldarg_C(VirtualOpCode ins, Code code) { // Ldarg_C delegates will reference the arguments field in their Ldfld, which sets them apart from // other very similar delegates return ins.Matches(ins.ModifyPattern(Pattern_Ldarg_C, Code.Ldc_I4, code)) && ((FieldDef)ins.DelegateMethod.Body.Instructions[2].Operand).MDToken == ins.VType.ArgumentsField.MDToken; }
public static Boolean Is_Unbox_Any(this VirtualOpCode ins) { return(ins.DelegateMethod.Matches( Code.Ldloc_2, Code.Callvirt, Code.Stloc_3, Code.Ldloc_3, Code.Ldloc_1, Code.Call, Code.Stloc_S, Code.Ldarg_0, Code.Ldloc_S, Code.Call, Code.Ret )); }
public static Boolean Is_Switch(this VirtualOpCode ins) { return(ins.DelegateMethod.Matches( Code.Blt_S, Code.Ret, Code.Ldloc_3, Code.Ldloc_2, Code.Conv_U, Code.Ldelem, Code.Callvirt, Code.Stloc_S, Code.Ldarg_0, Code.Ldloc_S, Code.Call, Code.Ret )); }
public static Boolean Is_Ldelem_Ref(this VirtualOpCode ins) { // Is exact same as Ldelem_I except for the field reference return(ins.MatchesEntire(new Code[] { Code.Ldarg_0, Code.Ldsfld, Code.Call, Code.Ret }) && _Is_Ldelem(ins) && !ins.Is_Ldelem_I()); }
public static Boolean Is_Stelem_Ref(this VirtualOpCode ins) { return(ins.DelegateMethod.MatchesEntire( Code.Ldarg_0, Code.Ldsfld, Code.Call, Code.Ret ) && ins.DelegateMethod.MatchesIndirect(Pattern_Stelem) && !Is_Stelem_I(ins)); }
public static Boolean Is_Ldelem(this VirtualOpCode ins) { return(ins.MatchesEntire(new Code[] { Code.Ldarg_1, Code.Castclass, Code.Callvirt, Code.Stloc_0, Code.Ldarg_0, Code.Ldloc_0, Code.Call, Code.Stloc_1, Code.Ldarg_0, Code.Ldloc_1, Code.Call, Code.Ret }) && _Is_Ldelem(ins)); }
public static Boolean Is_Shl(this VirtualOpCode ins) { return(ins.MatchesIndirect( new Code[] { Code.Ldloc_S, Code.Ldloc_S, Code.Ldc_I4_S, Code.And, Code.Shl, Code.Stloc_S, Code.Newobj, Code.Stloc_0, Code.Ldloc_0, Code.Ldloc_S, Code.Callvirt, Code.Ldloc_0, Code.Ret } )); }
public static Boolean Is_Conv_R8(this VirtualOpCode ins) { return(ins.DelegateMethod.Matches(Conv_Helper_Pattern( Code.Conv_R8, Code.Stloc_2, Code.Br_S, Code.Ldloc_0, Code.Castclass, Code.Callvirt, Code.Stloc_2 ))); }
private static Boolean _Is_Ldloca(VirtualOpCode ins, String typeName) { TypeDef stackType; return(ins.DelegateMethod.MatchesEntire(Pattern_Ldloca) && (stackType = ins.DelegateMethod.Body.Instructions[1].Operand as TypeDef) != null && StackTypeHelper.GetUnderlyingType(stackType).FullName.Equals(typeName)); }
private static Boolean Is_Stloc_C(VirtualOpCode ins, Code code) { return(ins.MatchesEntire(ins.ModifyPattern(Pattern_Stloc_C, Code.Ldc_I4, code)) && Helpers.FindOpCodePatterns( // Check called method against Pattern_Helper_Stloc_C ((MethodDef)ins.DelegateMethod.Body.Instructions[2].Operand).Body.Instructions, Pattern_Helper_Stloc_C ).Count > 0); }
public static Boolean _Is_Unsupported(VirtualOpCode ins, String name) { String exceptionString = String.Format("{0} is not supported", name); return ins.DelegateMethod.MatchesEntire(new Code[] { Code.Ldstr, Code.Newobj, Code.Throw }) && ((String)ins.DelegateMethod.Body.Instructions[0].Operand) .StartsWith(exceptionString, StringComparison.OrdinalIgnoreCase); }
public static Boolean Is_Ldloc_S(this VirtualOpCode ins) { return(ins.MatchesEntire(Pattern_Ldloc) && ((MethodDef)ins.DelegateMethod.Body.Instructions[7].Operand) .ReturnType.FullName.Equals("System.Byte") && ((FieldDef)ins.DelegateMethod.Body.Instructions[5].Operand) .MDToken == ins.VType.LocalsField.MDToken); }
private static Boolean _Is_Ldelem_T(VirtualOpCode ins, String typeName) { return(ins.MatchesEntire(new Code[] { Code.Ldarg_0, Code.Ldtoken, Code.Call, Code.Call, Code.Ret }) && ((ITypeDefOrRef)ins.DelegateMethod.Body.Instructions[1].Operand) .FullName.Equals(typeName) && _Is_Ldelem(ins)); }
public static Boolean _Is_Ldc(VirtualOpCode ins, OperandType expectedOperandType) { OperandType operandType; return(ins.MatchesEntire(Pattern_Ldc) && ins.TryGetOperandType(out operandType) && operandType == expectedOperandType); }
private static Boolean _Is_Ldelem_T(VirtualOpCode ins, String typeName) { return ins.MatchesEntire(new Code[] { Code.Ldarg_0, Code.Ldtoken, Code.Call, Code.Call, Code.Ret }) && ((ITypeDefOrRef)ins.DelegateMethod.Body.Instructions[1].Operand) .FullName.Equals(typeName) && _Is_Ldelem(ins); }
public static Boolean Is_Starg_S(this VirtualOpCode ins) { var sub = ins.Find(Pattern_Starg); return(sub != null && sub[3].Operand is MethodDef && ((MethodDef)sub[3].Operand).ReturnType.FullName.Equals("System.Byte") && ins.Matches(Pattern_Tail_Starg)); }
public static Boolean Is_Ret(this VirtualOpCode ins) { return(ins.MatchesEntire(new Code[] { Code.Ldarg_0, Code.Call, Code.Ret }) && ((MethodDef)ins.DelegateMethod.Body.Instructions[1].Operand).MatchesEntire(new Code[] { Code.Ldarg_0, Code.Ldc_I4_1, Code.Stfld, Code.Ret })); }
public static Boolean Is_Unbox(this VirtualOpCode ins) { OperandType operandType; return(ins.DelegateMethod.MatchesEntire(Code.Ret) && ins.TryGetOperandType(out operandType) && operandType == OperandType.InlineType); }
public static Boolean Is_Stelem(this VirtualOpCode ins) { return(ins.DelegateMethod.MatchesEntire( Code.Ldarg_1, Code.Castclass, Code.Callvirt, Code.Stloc_0, Code.Ldarg_0, Code.Ldloc_0, Code.Call, Code.Stloc_1, Code.Ldarg_0, Code.Ldloc_1, Code.Call, Code.Ret ) && ins.DelegateMethod.MatchesIndirect(Pattern_Stelem)); }
/// <remarks>Unsure</remarks> public static Boolean Is_Ldarga(this VirtualOpCode ins) { var sub = ins.Find(Pattern_Ldarga); return(sub != null && ((FieldDef)sub[2].Operand).MDToken == ins.VType.ArgumentsField.MDToken && ((MethodDef)sub[4].Operand).ReturnType.FullName.Equals("System.UInt16")); }
public static Boolean Is_Stelem_I(this VirtualOpCode ins) { return(ins.DelegateMethod.MatchesEntire( Code.Ldarg_0, Code.Ldsfld, Code.Call, Code.Ret ) && ins.DelegateMethod.MatchesIndirect(Pattern_Stelem) && ((FieldDef)ins.DelegateMethod.Body.Instructions[1].Operand) .MDToken == ins.VType.GetTypeField("System.IntPtr").MDToken); }
private static Boolean _Is_Conv_I(VirtualOpCode ins, Boolean ovf, IList<Code> helperPattern) { Code[] delegatePattern = (ovf ? new Code[] { Code.Ldarg_0, Code.Ldc_I4_1, Code.Call, Code.Ret } : new Code[] { Code.Ldarg_0, Code.Ldc_I4_0, Code.Call, Code.Ret }); return ins.DelegateMethod.MatchesEntire(delegatePattern) && ins.DelegateMethod.MatchesIndirect(helperPattern); }
public static Boolean Is_Ldlen(this VirtualOpCode ins) { return(ins.MatchesEntire(new Code[] { Code.Ldarg_0, Code.Call, Code.Callvirt, Code.Castclass, Code.Stloc_0, Code.Ldarg_0, Code.Newobj, Code.Stloc_1, Code.Ldloc_1, Code.Ldloc_0, Code.Callvirt, Code.Callvirt, Code.Ldloc_1, Code.Call, Code.Ret }) && ((IMethod)ins.DelegateMethod.Body.Instructions[10].Operand) .FullName.Contains("System.Array::get_Length")); }
public static Boolean Is_Newarr(this VirtualOpCode ins) { var sub = ins.DelegateMethod.Find( Code.Ldloc_S, Code.Ldloc_1, Code.Call, Code.Stloc_S ); return(sub != null && ((IMethod)sub[2].Operand).FullName.Contains("System.Array::CreateInstance")); }
public static Boolean Is_Endfinally(this VirtualOpCode ins) { return(ins.DelegateMethod.MatchesEntire( Code.Ldarg_0, Code.Call, Code.Ret ) && ins.DelegateMethod.MatchesIndirect( Code.Ldarg_0, Code.Ldfld, Code.Callvirt, Code.Ldarg_0, Code.Ldloc_0, Code.Callvirt, Code.Call, Code.Ret )); }
public static Boolean Is_Eaz_Call(this VirtualOpCode ins) { var sub = ins.DelegateMethod.Find(new Code[] { Code.Ldc_I4, Code.And, Code.Ldc_I4_0, Code.Ceq, Code.Ldc_I4_0, Code.Ceq }); return(sub != null && ((Int32)sub[0].Operand) == -2147483648); }
private static Boolean _Is_Ceq_49(VirtualOpCode ins) { return ins.DelegateMethod.Matches( Code.Ldloc_2, Code.Ldloc_1, Code.Ldloc_0, Code.Call, Code.Brtrue_S, Code.Ldc_I4_0, Code.Br_S, Code.Ldc_I4_1 ) && ins.DelegateMethod.MatchesIndirect( Code.Ldloc_1, Code.Callvirt, Code.Call, Code.Ldarg_1, Code.Callvirt, Code.Call, Code.Ceq, Code.Stloc_0, Code.Ldloc_0, Code.Ret ); }
private static Boolean _Is_Ldelem(VirtualOpCode ins) { MethodDef method; IList<Instruction> pattern; var calls = ins.DelegateMethod.Calls().ToArray(); return calls.Length > 0 && (method = calls.Last() as MethodDef) != null && (pattern = method.Find(Pattern_Ldelem)) != null && ((ITypeDefOrRef)pattern[0].Operand).FullName.Contains("System.Array"); }
public static Boolean _Is_Ldind_IC(VirtualOpCode ins, String tokenTypeName) { TypeRef tokenType = null; return ins.DelegateMethod.MatchesEntire( Code.Ldarg_0, Code.Ldtoken, Code.Call, Code.Call, Code.Ret ) && ins.DelegateMethod.MatchesIndirect( Code.Ldarg_0, Code.Call, Code.Stloc_0, Code.Ldarg_0, Code.Ldarg_0, Code.Ldloc_0, Code.Call, Code.Callvirt, Code.Ldarg_1, Code.Call, Code.Call, Code.Ret ) && (tokenType = ins.DelegateMethod.Body.Instructions[1].Operand as TypeRef) != null && tokenType.FullName.Equals(tokenTypeName); }
public static Boolean _Jumps(VirtualOpCode ins) { return ins.DelegateMethod.Calls().Any((called) => { MethodDef method = called as MethodDef; if (method == null) return false; return method.MatchesEntire(new Code[] { Code.Ldarg_0, Code.Ldarg_1, Code.Newobj, Code.Stfld, Code.Ret }) && ((IMethod)method.Body.Instructions[2].Operand).FullName.Contains("System.Nullable"); }); }
private static Boolean _Is_Ceq_50(VirtualOpCode ins) { return ins.DelegateMethod.Matches( Code.Ldloc_2, Code.Ldloc_1, Code.Ldloc_0, Code.Call, Code.Brtrue_S, Code.Ldc_I4_0, Code.Br_S, Code.Ldc_I4_1 ) && ins.DelegateMethod.MatchesIndirect( // Helper changed in 5.0 Code.Ceq, Code.Stloc_0, Code.Br_S, Code.Ldarg_0, Code.Castclass, Code.Stloc_S, Code.Ldarg_1, Code.Castclass, Code.Stloc_S, Code.Ldloc_S, Code.Ldloc_S, Code.Callvirt, Code.Stloc_0, Code.Ldloc_0, Code.Ret ); }
/// <summary> /// Try to identify a virtual instruction. /// </summary> /// <param name="instruction">Virtual instruction</param> /// <param name="code">Detected CIL opcode if successful</param> /// <returns>true if successful, false if not</returns> public virtual Boolean TryIdentify(VirtualOpCode instruction, out Code code) { try { code = this.Identify(instruction); return true; } catch (OriginalOpcodeUnknownException) { code = Code.UNKNOWN2; return false; } }
/// <summary> /// Try to identify a virtual instruction, getting the entire attribute of the detection method. /// </summary> /// <param name="instruction">Virtual instruction</param> /// <param name="attribute">DetectAttribute of detection method if successful</param> /// <returns>true if successful, false if not</returns> public virtual Boolean TryIdentifyFull(VirtualOpCode instruction, out DetectAttribute attribute) { try { attribute = this.IdentifyFull(instruction); return true; } catch (OriginalOpcodeUnknownException) { attribute = null; return false; } }
private static Boolean _Is_Stelem_RC(VirtualOpCode ins, String typeName) { ITypeDefOrRef type = null; var body = ins.DelegateMethod.Body.Instructions; return ins.DelegateMethod.MatchesEntire( Code.Ldarg_0, Code.Ldtoken, Code.Call, Code.Call, Code.Ret ) && ins.DelegateMethod.MatchesIndirect(Pattern_Stelem) && (type = body[1].Operand as ITypeDefOrRef) != null && type.FullName.Equals(typeName); }
/// <summary> /// Identify a virtual instruction, getting the entire attribute of the detection method. /// </summary> /// <param name="instruction">Virtual instruction</param> /// <returns>DetectAttribute of detection method if successful</returns> /// <exception cref="eazdevirt.OriginalOpcodeUnknownException"> /// Thrown if original CIL opcode is unknown. /// </exception> public abstract DetectAttribute IdentifyFull(VirtualOpCode instruction);
private static Boolean _Is_Br_Equality(VirtualOpCode ins) { return ins.DelegateMethod.MatchesIndirect(Pattern_Br_Equality_49) || ins.DelegateMethod.MatchesIndirect(Pattern_Br_Equality_50); }
/// <remarks> /// All Stind_* delegate methods follow this pattern. They have different delegate /// methods, but their delegate methods all just call the same method with no params. /// /// One way to attack this: Devirtualize all as Stind_I, then go back through the /// method afterwards, following the types on the stack. When a Stind_* instruction /// is reached, the value (on top of the stack) is the type being set. /// </remarks> private static Boolean _Is_Stind(VirtualOpCode ins) { return ins.DelegateMethod.MatchesEntire(Code.Ldarg_0, Code.Call, Code.Ret) && ins.DelegateMethod.MatchesIndirect( Code.Ldarg_0, Code.Call, Code.Stloc_0, Code.Ldarg_0, Code.Call, Code.Stloc_1, Code.Ldarg_0, Code.Ldloc_1, Code.Ldloc_0, Code.Call, Code.Ret ); }
private static Boolean _Is_Stelem_IC(VirtualOpCode ins, String typeName) { ITypeDefOrRef type = null; var sub = ins.DelegateMethod.Find( Code.Ldarg_0, Code.Ldtoken, Code.Call, Code.Ldloc_0, Code.Ldloc_1, Code.Ldloc_2, Code.Call, Code.Ret ); return sub != null && (type = sub[1].Operand as ITypeDefOrRef) != null && type.FullName.Equals(typeName); }
protected Instruction ReadOneInstruction_CIL(VirtualOpCode virtualInstruction) { OpCode opcode = virtualInstruction.OpCode.ToOpCode(); Instruction instruction = new Instruction(opcode); instruction.Offset = this.CurrentILOffset; instruction.OpCode = opcode; instruction.Operand = this.ReadOperand(instruction); if (instruction.OpCode.Code == Code.Switch) { var targets = (IList<UInt32>)instruction.Operand; this.CurrentILOffset += (UInt32)(instruction.OpCode.Size + 4 + (4 * targets.Count)); this.CurrentVirtualOffset += (UInt32)(4 + 4 + (4 * targets.Count)); } else { this.CurrentILOffset += (UInt32)instruction.GetSize(); this.CurrentVirtualOffset += (UInt32)virtualInstruction.GetSize(instruction.Operand); } this.CurrentInstructionOffset++; return instruction; }
/// <summary> /// Identify a virtual instruction. /// </summary> /// <param name="instruction">Virtual instruction</param> /// <returns>Detected CIL opcode</returns> /// <exception cref="eazdevirt.OriginalOpcodeUnknownException"> /// Thrown if original CIL opcode is unknown. /// </exception> public abstract Code Identify(VirtualOpCode instruction);
protected Instruction ReadOneInstruction_Special(VirtualOpCode virtualInstruction) { //this.Logger.Verbose(this, "Special Opcode ({0}, delegate MDToken = 0x{1:X8})", // virtualInstruction.SpecialOpCode.ToString(), // virtualInstruction.DelegateMethod.MDToken.Raw //); // Have a method for this? OpCode opcode = null; switch(virtualInstruction.SpecialOpCode) { case SpecialCode.Eaz_Call: opcode = Code.Call.ToOpCode(); // Or Callvirt? break; } if(opcode == null) { throw new Exception(String.Format( "Cannot convert SpecialOpCode to CIL OpCode: {0}", virtualInstruction.SpecialOpCode )); } Object operand = this.ReadSpecialOperand(virtualInstruction); Instruction instruction = new Instruction(opcode); instruction.Offset = this.CurrentILOffset; instruction.OpCode = opcode; instruction.Operand = operand; // this.ReadOperand(instruction); this.CurrentILOffset += (UInt32)instruction.GetSize(); this.CurrentVirtualOffset += (UInt32)virtualInstruction.GetSize(instruction.Operand); this.CurrentInstructionOffset++; return instruction; }
/// <inheritdoc/> public override DetectAttribute IdentifyFull(VirtualOpCode instruction) { foreach (var kvp in _detectors) { if (kvp.Value(instruction)) return (DetectAttribute)kvp.Value.Method.GetCustomAttribute(typeof(DetectAttribute)); } foreach (var kvp in _specialDetectors) { if (kvp.Value(instruction)) return (DetectAttribute)kvp.Value.Method.GetCustomAttribute(typeof(DetectAttribute)); } throw new OriginalOpcodeUnknownException(instruction); }
public static Boolean _Is_Ldc(VirtualOpCode ins, OperandType expectedOperandType) { OperandType operandType; return ins.MatchesEntire(Pattern_Ldc) && ins.TryGetOperandType(out operandType) && operandType == expectedOperandType; }
public static Boolean _Is_Throw(VirtualOpCode ins, MethodDef helper) { var matches = Helpers.FindOpCodePatterns(helper.Body.Instructions, Pattern_Throw); return matches.Count == 1 && matches[0].Length == Pattern_Throw.Length; }
public static Boolean Is_Stind(VirtualOpCode ins) { // Consider all Stind_* instructions as Stind_I (for now?) return _Is_Stind(ins); }
private static Boolean Is_Stloc_C(VirtualOpCode ins, Code code) { return ins.MatchesEntire(ins.ModifyPattern(Pattern_Stloc_C, Code.Ldc_I4, code)) && Helpers.FindOpCodePatterns( // Check called method against Pattern_Helper_Stloc_C ((MethodDef)ins.DelegateMethod.Body.Instructions[2].Operand).Body.Instructions, Pattern_Helper_Stloc_C ).Count > 0; }
private static Boolean _Is_Stloc(VirtualOpCode ins, String indexTypeName) { return ins.MatchesEntire(Pattern_Stloc) && ((MethodDef)ins.DelegateMethod.Body.Instructions[5].Operand) .ReturnType.FullName.Equals(indexTypeName) && Helpers.FindOpCodePatterns( // Check called method against Pattern_Helper_Stloc_C ((MethodDef)ins.DelegateMethod.Body.Instructions[6].Operand).Body.Instructions, Pattern_Helper_Stloc_C ).Count > 0; }
private static Boolean Is_Ldc_I4_C(VirtualOpCode ins, Code code) { return ins.MatchesEntire(ins.ModifyPattern(Pattern_Ldc_I4_C, Code.Ldc_I4, code)); }
/// <summary> /// Read a virtual operand of a special instruction. /// </summary> /// <param name="virtualOpCode">Special virtual opcode</param> /// <returns>Operand object, or null if unsupported operand type</returns> protected Object ReadSpecialOperand(VirtualOpCode virtualOpCode) { switch (virtualOpCode.SpecialOpCode) { case SpecialCode.Eaz_Call: return this.Resolver.ResolveEazCall(this.Reader.ReadInt32()); } return null; }
private static Boolean _Is_Ldloca(VirtualOpCode ins, String typeName) { TypeDef stackType; return ins.DelegateMethod.MatchesEntire(Pattern_Ldloca) && (stackType = ins.DelegateMethod.Body.Instructions[1].Operand as TypeDef) != null && StackTypeHelper.GetUnderlyingType(stackType).FullName.Equals(typeName); }
/// <inheritdoc/> public override Code Identify(VirtualOpCode instruction) { foreach (var kvp in _detectors) { if (kvp.Value(instruction)) return kvp.Key; } throw new OriginalOpcodeUnknownException(instruction); }
private static Boolean Is_Ldloc_C(VirtualOpCode ins, Code code) { return ins.MatchesEntire(ins.ModifyPattern(Pattern_Ldloc_C, Code.Ldc_I4, code)) && ((FieldDef)ins.DelegateMethod.Body.Instructions[2].Operand).MDToken == ins.VType.LocalsField.MDToken; }