public static void WriteMethodBody (TextWriter writer, MethodBase method) { foreach (var instruction in method.GetInstructions ()) { writer.Write ('\t'); WriteInstruction (writer, instruction); writer.WriteLine (); } }
public static MatchContext Match(MethodBase method, ILPattern pattern) { IList<Instruction> instructions = method.GetInstructions(); if (instructions.Count == 0) throw new ArgumentException(); var context = new MatchContext(instructions[0]); pattern.Match(context); return context; }
public static MatchContext Match (MethodBase method, ILPattern pattern) { if (method == null) throw new ArgumentNullException("method"); if (pattern == null) throw new ArgumentNullException("pattern"); var instructions = method.GetInstructions(); if (instructions.Count == 0) throw new ArgumentException(); var context = new MatchContext(instructions[0]); pattern.Match(context); return context; }
private void MapInstructions(MethodBase method, MethodDefinition method_definition) { var instructions = method.GetInstructions(); foreach (var instruction in instructions) { var il = method_definition.Body.GetILProcessor(); var op = OpCodeFor(instruction); switch (op.OperandType) { case OperandType.InlineNone: il.Emit(op); break; case OperandType.InlineMethod: il.Emit(op, CreateReference((MethodBase)instruction.Operand, method_definition)); break; case OperandType.InlineField: il.Emit(op, CreateReference((FieldInfo)instruction.Operand, method_definition)); break; case OperandType.InlineType: il.Emit(op, CreateReference((Type)instruction.Operand, method_definition)); break; case OperandType.InlineTok: var member = (MemberInfo)instruction.Operand; if (member is Type) il.Emit(op, CreateTokenReference((Type)instruction.Operand, method_definition)); else if (member is FieldInfo) il.Emit(op, CreateReference((FieldInfo)instruction.Operand, method_definition)); else if (member is MethodBase) il.Emit(op, CreateTokenReference((MethodBase)instruction.Operand, method_definition)); else throw new NotSupportedException(); break; case OperandType.ShortInlineI: if (op.Code == Code.Ldc_I4_S) il.Emit(op, (sbyte)instruction.Operand); else il.Emit(op, (byte)instruction.Operand); break; case OperandType.InlineI: il.Emit(op, (int)instruction.Operand); break; case OperandType.InlineI8: il.Emit(op, (long)instruction.Operand); break; case OperandType.ShortInlineR: il.Emit(op, (float)instruction.Operand); break; case OperandType.InlineR: il.Emit(op, (double)instruction.Operand); break; case OperandType.ShortInlineVar: case OperandType.InlineVar: il.Emit(op, VariableFor(instruction, method_definition)); break; case OperandType.ShortInlineArg: case OperandType.InlineArg: il.Emit(op, ParameterFor(instruction, method_definition)); break; case OperandType.InlineString: il.Emit(op, (string)instruction.Operand); break; case OperandType.ShortInlineBrTarget: case OperandType.InlineBrTarget: il.Emit(op, MC.Cil.Instruction.Create(OpCodes.Nop)); break; case OperandType.InlineSwitch: il.Emit(op, new[] { MC.Cil.Instruction.Create(OpCodes.Nop) }); break; case OperandType.InlineSig: throw new NotSupportedException("InlineSig"); default: throw new NotSupportedException(op.OperandType.ToString()); } } foreach (var instruction in instructions) { var op = OpCodeFor(instruction); switch (op.OperandType) { case OperandType.ShortInlineBrTarget: case OperandType.InlineBrTarget: var br = OffsetToInstruction(instruction.Offset, instructions, method_definition); var target = (MR.Instruction)instruction.Operand; if (target != null) br.Operand = OffsetToInstruction(target.Offset, instructions, method_definition); break; case OperandType.InlineSwitch: var @switch = OffsetToInstruction(instruction.Offset, instructions, method_definition); @switch.Operand = ((MR.Instruction[])instruction.Operand).Select(i => OffsetToInstruction(i.Offset, instructions, method_definition)).ToArray(); break; } } }
private void MapExceptions(MethodBase method, MethodDefinition method_definition) { var body = method.GetMethodBody(); if (body == null) return; var instructions = method.GetInstructions(); foreach (var clause in body.ExceptionHandlingClauses) { var handler = new ExceptionHandler((ExceptionHandlerType)clause.Flags) { TryStart = OffsetToInstruction(clause.TryOffset, instructions, method_definition), TryEnd = OffsetToInstruction(clause.TryOffset + clause.TryLength, instructions, method_definition), HandlerStart = OffsetToInstruction(clause.HandlerOffset, instructions, method_definition), HandlerEnd = OffsetToInstruction(clause.HandlerOffset + clause.HandlerLength, instructions, method_definition) }; switch (handler.HandlerType) { case ExceptionHandlerType.Catch: handler.CatchType = CreateReference(clause.CatchType, method_definition); break; case ExceptionHandlerType.Filter: handler.FilterStart = OffsetToInstruction(clause.FilterOffset, instructions, method_definition); break; } method_definition.Body.ExceptionHandlers.Add(handler); } }