/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="code"/> is not /// a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="code">All code</param> /// <param name="exceptions">Exceptions or <c>null</c> if all exception handlers are in /// <paramref name="code"/></param> /// <param name="parameters">Method parameters</param> /// <param name="flags">Method header flags, eg. 2 if tiny method</param> /// <param name="maxStack">Max stack</param> /// <param name="codeSize">Code size</param> /// <param name="localVarSigTok">Local variable signature token or 0 if none</param> /// <param name="gpContext">Generic parameter context</param> /// <param name="context">The module context</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, byte[] code, byte[] exceptions, IList <Parameter> parameters, ushort flags, ushort maxStack, uint codeSize, uint localVarSigTok, GenericParamContext gpContext, ModuleContext context) { var codeReader = ByteArrayDataReaderFactory.CreateReader(code); var ehReader = exceptions is null ? (DataReader?)null : ByteArrayDataReaderFactory.CreateReader(exceptions); var mbReader = new MethodBodyReader(opResolver, codeReader, ehReader, parameters, gpContext, context); mbReader.SetHeader(flags, maxStack, codeSize, localVarSigTok); if (!mbReader.Read()) { return(new CilBody()); } return(mbReader.CreateCilBody()); }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="code"/> is not /// a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="code">All code</param> /// <param name="exceptions">Exceptions or <c>null</c> if all exception handlers are in /// <paramref name="code"/></param> /// <param name="parameters">Method parameters</param> /// <param name="flags">Method header flags, eg. 2 if tiny method</param> /// <param name="maxStack">Max stack</param> /// <param name="codeSize">Code size</param> /// <param name="localVarSigTok">Local variable signature token or 0 if none</param> /// <param name="gpContext">Generic parameter context</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, byte[] code, byte[] exceptions, IList <Parameter> parameters, ushort flags, ushort maxStack, uint codeSize, uint localVarSigTok, GenericParamContext gpContext) { var codeReader = MemoryImageStream.Create(code); var ehReader = exceptions == null ? null : MemoryImageStream.Create(exceptions); var mbReader = new MethodBodyReader(opResolver, codeReader, ehReader, parameters, gpContext); mbReader.SetHeader(flags, maxStack, codeSize, localVarSigTok); if (!mbReader.Read()) { return(new CilBody()); } return(mbReader.CreateCilBody()); }
static Instruction cast_read(BinaryReader reader, IInstructionOperandResolver resolver) { var instr = new Instruction(); switch (reader.ReadByte()) { case 0: instr.OpCode = OpCodes.Castclass; break; case 1: instr.OpCode = OpCodes.Isinst; break; default: throw new ApplicationException("Invalid opcode"); } instr.Operand = resolver.ResolveToken(reader.ReadUInt32()); return(instr); }
static Instruction box_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { var instr = new Instruction(); switch (reader.ReadByte()) { case 0: instr.OpCode = OpCodes.Box; break; case 1: instr.OpCode = OpCodes.Unbox_Any; break; default: throw new ApplicationException("Invalid opcode"); } instr.Operand = resolver.ResolveToken(reader.ReadUInt32(), gpContext); return(instr); }
static Instruction ldfld_read(BinaryReader reader, IInstructionOperandResolver resolver) { byte b = reader.ReadByte(); var field = resolver.ResolveToken(reader.ReadUInt32()) as IField; switch (b) { case 0: return(new Instruction(null, new FieldInstructionOperand(OpCodes.Ldsfld, OpCodes.Ldfld, field))); case 1: return(new Instruction(null, new FieldInstructionOperand(OpCodes.Ldsflda, OpCodes.Ldflda, field))); case 2: return(new Instruction(null, new FieldInstructionOperand(OpCodes.Stsfld, OpCodes.Stfld, field))); default: throw new ApplicationException("Invalid opcode"); } }
static Instruction ldc_read(BinaryReader reader, IInstructionOperandResolver resolver) { switch ((ElementType)reader.ReadByte()) { case ElementType.I4: return(Instruction.CreateLdcI4(reader.ReadInt32())); case ElementType.I8: return(OpCodes.Ldc_I8.ToInstruction(reader.ReadInt64())); case ElementType.R4: return(OpCodes.Ldc_R4.ToInstruction(reader.ReadSingle())); case ElementType.R8: return(OpCodes.Ldc_R8.ToInstruction(reader.ReadDouble())); case ElementType.Object: return(OpCodes.Ldnull.ToInstruction()); default: throw new ApplicationException("Invalid opcode"); } }
static Instruction ldloca_read(BinaryReader reader, IInstructionOperandResolver resolver) { Instruction instr = new Instruction(); if (reader.ReadBoolean()) { instr.OpCode = OpCodes.Ldarga; instr.Operand = new ArgOperand(reader.ReadUInt16()); } else { instr.OpCode = OpCodes.Ldloca; instr.Operand = new LocalOperand(reader.ReadUInt16()); } return(instr); }
static Instruction ldftn_read(BinaryReader reader, IInstructionOperandResolver resolver) { byte code = reader.ReadByte(); uint token = reader.ReadUInt32(); switch (code) { case 0: return(new Instruction(OpCodes.Ldftn, resolver.ResolveToken(token))); case 1: reader.ReadInt32(); // token of newobj .ctor return(new Instruction(OpCodes.Ldvirtftn, resolver.ResolveToken(token))); default: throw new ApplicationException("Invalid opcode"); } }
static Instruction arithmetic_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { switch (reader.ReadByte()) { case 0: return OpCodes.Add.ToInstruction(); case 1: return OpCodes.Add_Ovf.ToInstruction(); case 2: return OpCodes.Add_Ovf_Un.ToInstruction(); case 3: return OpCodes.Sub.ToInstruction(); case 4: return OpCodes.Sub_Ovf.ToInstruction(); case 5: return OpCodes.Sub_Ovf_Un.ToInstruction(); case 6: return OpCodes.Mul.ToInstruction(); case 7: return OpCodes.Mul_Ovf.ToInstruction(); case 8: return OpCodes.Mul_Ovf_Un.ToInstruction(); case 9: return OpCodes.Div.ToInstruction(); case 10: return OpCodes.Div_Un.ToInstruction(); case 11: return OpCodes.Rem.ToInstruction(); case 12: return OpCodes.Rem_Un.ToInstruction(); default: throw new ApplicationException("Invalid opcode"); } }
static Instruction logical_read(BinaryReader reader, IInstructionOperandResolver resolver) { switch (reader.ReadByte()) { case 0: return(OpCodes.And.ToInstruction()); case 1: return(OpCodes.Or.ToInstruction()); case 2: return(OpCodes.Xor.ToInstruction()); case 3: return(OpCodes.Shl.ToInstruction()); case 4: return(OpCodes.Shr.ToInstruction()); case 5: return(OpCodes.Shr_Un.ToInstruction()); default: throw new ApplicationException("Invalid opcode"); } }
static Instruction ldloc_read(BinaryReader reader, IInstructionOperandResolver resolver) { bool isLdarg = reader.ReadBoolean(); ushort index = reader.ReadUInt16(); var instr = new Instruction(); if (isLdarg) { instr.OpCode = OpCodes.Ldarg; instr.Operand = new ArgOperand(index); } else { instr.OpCode = OpCodes.Ldloc; instr.Operand = new LocalOperand(index); } return(instr); }
static Instruction stloc_read(BinaryReader reader, IInstructionOperandResolver resolver) { bool isStarg = reader.ReadBoolean(); ushort index = reader.ReadUInt16(); var instr = new Instruction(); if (isStarg) { instr.OpCode = OpCodes.Starg; instr.Operand = new ArgOperand(index); } else { instr.OpCode = OpCodes.Stloc; instr.Operand = new LocalOperand(index); reader.ReadInt32(); // ElementType of local } return(instr); }
/// <summary> /// Constructor /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="codeReader">A reader positioned at the start of a .NET method body</param> /// <param name="ehReader">Exception handler reader or <c>null</c> if exceptions aren't /// present or if <paramref name="codeReader"/> contains the exception handlers</param> /// <param name="parameters">Method parameters</param> public MethodBodyReader(IInstructionOperandResolver opResolver, IBinaryReader codeReader, IBinaryReader ehReader, IList <Parameter> parameters) : base(codeReader, parameters) { this.opResolver = opResolver; this.exceptionsReader = ehReader; }
static Instruction neg_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { switch (reader.ReadByte()) { case 0: return OpCodes.Neg.ToInstruction(); case 1: return OpCodes.Not.ToInstruction(); default: throw new ApplicationException("Invalid opcode"); } }
static Instruction switch_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { int numTargets = reader.ReadInt32(); int[] targetDispls = new int[numTargets]; for (int i = 0; i < targetDispls.Length; i++) targetDispls[i] = reader.ReadInt32(); return new Instruction(OpCodes.Switch, new SwitchTargetDisplOperand(targetDispls)); }
static Instruction stloc_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { bool isStarg = reader.ReadBoolean(); ushort index = reader.ReadUInt16(); var instr = new Instruction(); if (isStarg) { instr.OpCode = OpCodes.Starg; instr.Operand = new ArgOperand(index); } else { instr.OpCode = OpCodes.Stloc; instr.Operand = new LocalOperand(index); reader.ReadInt32(); // ElementType of local } return instr; }
/// <summary> /// Constructor /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="codeReader">A reader positioned at the start of a .NET method body</param> /// <param name="ehReader">Exception handler reader or <c>null</c> if exceptions aren't /// present or if <paramref name="codeReader"/> contains the exception handlers</param> /// <param name="parameters">Method parameters</param> public MethodBodyReader(IInstructionOperandResolver opResolver, IBinaryReader codeReader, IBinaryReader ehReader, IList<Parameter> parameters) : this(opResolver, codeReader, ehReader, parameters, new GenericParamContext()) { }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="code"/> is not /// a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="code">All code</param> /// <param name="exceptions">Exceptions or <c>null</c> if all exception handlers are in /// <paramref name="code"/></param> /// <param name="parameters">Method parameters</param> /// <param name="flags">Method header flags, eg. 2 if tiny method</param> /// <param name="maxStack">Max stack</param> /// <param name="codeSize">Code size</param> /// <param name="localVarSigTok">Local variable signature token or 0 if none</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, byte[] code, byte[] exceptions, IList<Parameter> parameters, ushort flags, ushort maxStack, uint codeSize, uint localVarSigTok) { return CreateCilBody(opResolver, code, exceptions, parameters, flags, maxStack, codeSize, localVarSigTok, new GenericParamContext()); }
/// <summary> /// Constructor /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="method">Use parameters from this method</param> /// <param name="gpContext">Generic parameter context</param> public MethodBodyReader(IInstructionOperandResolver opResolver, DataReader reader, MethodDef method, GenericParamContext gpContext) : this(opResolver, reader, null, method.Parameters, gpContext) { }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="codeReader"/> doesn't /// point to the start of a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="codeReader">A reader positioned at the start of a .NET method body</param> /// <param name="ehReader">Exception handler reader or <c>null</c> if exceptions aren't /// present or if <paramref name="codeReader"/> contains the exception handlers</param> /// <param name="parameters">Method parameters</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, DataReader codeReader, DataReader?ehReader, IList <Parameter> parameters) => CreateCilBody(opResolver, codeReader, ehReader, parameters, new GenericParamContext());
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="code"/> is not /// a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="code">All code</param> /// <param name="exceptions">Exceptions or <c>null</c> if all exception handlers are in /// <paramref name="code"/></param> /// <param name="parameters">Method parameters</param> /// <param name="gpContext">Generic parameter context</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, byte[] code, byte[] exceptions, IList <Parameter> parameters, GenericParamContext gpContext) => CreateCilBody(opResolver, ByteArrayDataReaderFactory.CreateReader(code), exceptions is null ? (DataReader?)null : ByteArrayDataReaderFactory.CreateReader(exceptions), parameters, gpContext);
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="reader"/> doesn't /// point to the start of a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="method">Use parameters from this method</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, IBinaryReader reader, MethodDef method) { return(CreateCilBody(opResolver, reader, method.Parameters)); }
public OpCodeHandlerInfoReader(IInstructionOperandResolver resolver, GenericParamContext gpContext) { this.resolver = resolver; this.gpContext = gpContext; readHandlers = new Dictionary <HandlerTypeCode, Func <BinaryReader, Instruction> > { { HandlerTypeCode.Add, Handler_Add }, { HandlerTypeCode.Add_Ovf, Handler_Add_Ovf }, { HandlerTypeCode.Add_Ovf_Un, Handler_Add_Ovf_Un }, { HandlerTypeCode.And, Handler_And }, { HandlerTypeCode.Beq, Handler_Beq }, { HandlerTypeCode.Bge, Handler_Bge }, { HandlerTypeCode.Bge_Un, Handler_Bge_Un }, { HandlerTypeCode.Bgt, Handler_Bgt }, { HandlerTypeCode.Bgt_Un, Handler_Bgt_Un }, { HandlerTypeCode.Ble, Handler_Ble }, { HandlerTypeCode.Ble_Un, Handler_Ble_Un }, { HandlerTypeCode.Blt, Handler_Blt }, { HandlerTypeCode.Blt_Un, Handler_Blt_Un }, { HandlerTypeCode.Bne_Un, Handler_Bne_Un }, { HandlerTypeCode.Box, Handler_Box }, { HandlerTypeCode.Br, Handler_Br }, { HandlerTypeCode.Brfalse, Handler_Brfalse }, { HandlerTypeCode.Brtrue, Handler_Brtrue }, { HandlerTypeCode.Call, Handler_Call }, { HandlerTypeCode.Callvirt, Handler_Callvirt }, { HandlerTypeCode.Castclass, Handler_Castclass }, { HandlerTypeCode.Ceq, Handler_Ceq }, { HandlerTypeCode.Cgt, Handler_Cgt }, { HandlerTypeCode.Cgt_Un, Handler_Cgt_Un }, { HandlerTypeCode.Clt, Handler_Clt }, { HandlerTypeCode.Clt_Un, Handler_Clt_Un }, { HandlerTypeCode.Conv, Handler_Conv }, { HandlerTypeCode.Div, Handler_Div }, { HandlerTypeCode.Div_Un, Handler_Div_Un }, { HandlerTypeCode.Dup, Handler_Dup }, { HandlerTypeCode.Endfinally, Handler_Endfinally }, { HandlerTypeCode.Initobj, Handler_Initobj }, { HandlerTypeCode.Isinst, Handler_Isinst }, { HandlerTypeCode.Ldarg, Handler_Ldarg }, { HandlerTypeCode.Ldarga, Handler_Ldarga }, { HandlerTypeCode.Ldc, Handler_Ldc }, { HandlerTypeCode.Ldelem, Handler_Ldelem }, { HandlerTypeCode.Ldelema, Handler_Ldelema }, { HandlerTypeCode.Ldfld_Ldsfld, Handler_Ldfld_Ldsfld }, { HandlerTypeCode.Ldflda_Ldsflda, Handler_Ldflda_Ldsflda }, { HandlerTypeCode.Ldftn, Handler_Ldftn }, { HandlerTypeCode.Ldlen, Handler_Ldlen }, { HandlerTypeCode.Ldloc, Handler_Ldloc }, { HandlerTypeCode.Ldloca, Handler_Ldloca }, { HandlerTypeCode.Ldobj, Handler_Ldobj }, { HandlerTypeCode.Ldstr, Handler_Ldstr }, { HandlerTypeCode.Ldtoken, Handler_Ldtoken }, { HandlerTypeCode.Ldvirtftn, Handler_Ldvirtftn }, { HandlerTypeCode.Leave, Handler_Leave }, { HandlerTypeCode.Mul, Handler_Mul }, { HandlerTypeCode.Mul_Ovf, Handler_Mul_Ovf }, { HandlerTypeCode.Mul_Ovf_Un, Handler_Mul_Ovf_Un }, { HandlerTypeCode.Neg, Handler_Neg }, { HandlerTypeCode.Newarr, Handler_Newarr }, { HandlerTypeCode.Newobj, Handler_Newobj }, { HandlerTypeCode.Nop, Handler_Nop }, { HandlerTypeCode.Not, Handler_Not }, { HandlerTypeCode.Or, Handler_Or }, { HandlerTypeCode.Pop, Handler_Pop }, { HandlerTypeCode.Rem, Handler_Rem }, { HandlerTypeCode.Rem_Un, Handler_Rem_Un }, { HandlerTypeCode.Ret, Handler_Ret }, { HandlerTypeCode.Rethrow, Handler_Rethrow }, { HandlerTypeCode.Shl, Handler_Shl }, { HandlerTypeCode.Shr, Handler_Shr }, { HandlerTypeCode.Shr_Un, Handler_Shr_Un }, { HandlerTypeCode.Starg, Handler_Starg }, { HandlerTypeCode.Stelem, Handler_Stelem }, { HandlerTypeCode.Stfld_Stsfld, Handler_Stfld_Stsfld }, { HandlerTypeCode.Stloc, Handler_Stloc }, { HandlerTypeCode.Stobj, Handler_Stobj }, { HandlerTypeCode.Sub, Handler_Sub }, { HandlerTypeCode.Sub_Ovf, Handler_Sub_Ovf }, { HandlerTypeCode.Sub_Ovf_Un, Handler_Sub_Ovf_Un }, { HandlerTypeCode.Switch, Handler_Switch }, { HandlerTypeCode.Throw, Handler_Throw }, { HandlerTypeCode.Unbox_Any, Handler_Unbox_Any }, { HandlerTypeCode.Xor, Handler_Xor }, }; }
/// <summary> /// Constructor /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="parameters">Method parameters</param> public MethodBodyReader(IInstructionOperandResolver opResolver, DataReader reader, IList <Parameter> parameters) : this(opResolver, reader, null, parameters, new GenericParamContext()) { }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="codeReader"/> doesn't /// point to the start of a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="codeReader">A reader positioned at the start of a .NET method body</param> /// <param name="ehReader">Exception handler reader or <c>null</c> if exceptions aren't /// present or if <paramref name="codeReader"/> contains the exception handlers</param> /// <param name="parameters">Method parameters</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, IBinaryReader codeReader, IBinaryReader ehReader, IList<Parameter> parameters) { return CreateCilBody(opResolver, codeReader, ehReader, parameters, new GenericParamContext()); }
/// <summary> /// Constructor /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="codeReader">A reader positioned at the start of a .NET method body</param> /// <param name="ehReader">Exception handler reader or <c>null</c> if exceptions aren't /// present or if <paramref name="codeReader"/> contains the exception handlers</param> /// <param name="parameters">Method parameters</param> /// <param name="gpContext">Generic parameter context</param> public MethodBodyReader(IInstructionOperandResolver opResolver, DataReader codeReader, DataReader?ehReader, IList <Parameter> parameters, GenericParamContext gpContext) : this(opResolver, codeReader, ehReader, parameters, gpContext, null) { }
/// <summary> /// Constructor /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="method">Use parameters from this method</param> public MethodBodyReader(IInstructionOperandResolver opResolver, IBinaryReader reader, MethodDef method) : this(opResolver, reader, null, method.Parameters, new GenericParamContext()) { }
static Instruction newarr_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { return new Instruction(OpCodes.Newarr, resolver.ResolveToken(reader.ReadUInt32(), gpContext)); }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="reader"/> doesn't /// point to the start of a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="method">Use parameters from this method</param> /// <param name="gpContext">Generic parameter context</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, IBinaryReader reader, MethodDef method, GenericParamContext gpContext) { return CreateCilBody(opResolver, reader, null, method.Parameters, gpContext); }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="code"/> is not /// a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="code">All code</param> /// <param name="exceptions">Exceptions or <c>null</c> if all exception handlers are in /// <paramref name="code"/></param> /// <param name="parameters">Method parameters</param> /// <param name="gpContext">Generic parameter context</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, byte[] code, byte[] exceptions, IList <Parameter> parameters, GenericParamContext gpContext) { return(CreateCilBody(opResolver, MemoryImageStream.Create(code), exceptions == null ? null : MemoryImageStream.Create(exceptions), parameters, gpContext)); }
static Instruction ret_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { reader.ReadInt32(); // token of current method return OpCodes.Ret.ToInstruction(); }
static Instruction stobj_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { return new Instruction(OpCodes.Stobj, null); }
/// <summary> /// Constructor /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="codeReader">A reader positioned at the start of a .NET method body</param> /// <param name="ehReader">Exception handler reader or <c>null</c> if exceptions aren't /// present or if <paramref name="codeReader"/> contains the exception handlers</param> /// <param name="parameters">Method parameters</param> public MethodBodyReader(IInstructionOperandResolver opResolver, IBinaryReader codeReader, IBinaryReader ehReader, IList <Parameter> parameters) : this(opResolver, codeReader, ehReader, parameters, new GenericParamContext()) { }
static Instruction throw_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { return OpCodes.Throw.ToInstruction(); }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="reader"/> doesn't /// point to the start of a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="method">Use parameters from this method</param> /// <param name="gpContext">Generic parameter context</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, IBinaryReader reader, MethodDef method, GenericParamContext gpContext) { return(CreateCilBody(opResolver, reader, null, method.Parameters, gpContext)); }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="reader"/> doesn't /// point to the start of a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="method">Use parameters from this method</param> /// <param name="gpContext">Generic parameter context</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, DataReader reader, MethodDef method, GenericParamContext gpContext) => CreateCilBody(opResolver, reader, null, method.Parameters, gpContext);
/// <summary> /// Constructor /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="parameters">Method parameters</param> public MethodBodyReader(IInstructionOperandResolver opResolver, IBinaryReader reader, IList <Parameter> parameters) : this(opResolver, reader, null, parameters) { }
static Instruction box_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { var instr = new Instruction(); switch (reader.ReadByte()) { case 0: instr.OpCode = OpCodes.Box; break; case 1: instr.OpCode = OpCodes.Unbox_Any; break; default: throw new ApplicationException("Invalid opcode"); } instr.Operand = resolver.ResolveToken(reader.ReadUInt32(), gpContext); return instr; }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="reader"/> doesn't /// point to the start of a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="parameters">Method parameters</param> /// <param name="gpContext">Generic parameter context</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, DataReader reader, IList <Parameter> parameters, GenericParamContext gpContext) => CreateCilBody(opResolver, reader, null, parameters, gpContext);
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="code"/> is not /// a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="code">All code</param> /// <param name="exceptions">Exceptions or <c>null</c> if all exception handlers are in /// <paramref name="code"/></param> /// <param name="parameters">Method parameters</param> /// <param name="flags">Method header flags, eg. 2 if tiny method</param> /// <param name="maxStack">Max stack</param> /// <param name="codeSize">Code size</param> /// <param name="localVarSigTok">Local variable signature token or 0 if none</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, byte[] code, byte[] exceptions, IList <Parameter> parameters, ushort flags, ushort maxStack, uint codeSize, uint localVarSigTok) { return(CreateCilBody(opResolver, code, exceptions, parameters, flags, maxStack, codeSize, localVarSigTok, new GenericParamContext())); }
static Instruction convert_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { byte type = reader.ReadByte(); bool second = reader.ReadBoolean(); bool third = reader.ReadBoolean(); Instruction instr = null; foreach (var info in instructionInfos1) { if (type != info.Type || info.Second != second || info.Third != third) continue; instr = new Instruction(info.OpCode); break; } if (instr == null) throw new ApplicationException("Invalid opcode"); return instr; }
/// <summary> /// Constructor /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="parameters">Method parameters</param> /// <param name="gpContext">Generic parameter context</param> public MethodBodyReader(IInstructionOperandResolver opResolver, IBinaryReader reader, IList <Parameter> parameters, GenericParamContext gpContext) : this(opResolver, reader, null, parameters, gpContext) { }
static Instruction ldelem_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { Instruction instr = null; bool first = reader.ReadBoolean(); bool second = reader.ReadBoolean(); int value = reader.ReadInt32(); foreach (var info in instructionInfos2) { if (info.First != first || info.Second != second) continue; if (second && value != info.Value) continue; if (second) instr = new Instruction(info.OpCode); else instr = new Instruction(info.OpCode, resolver.ResolveToken((uint)value, gpContext)); break; } if (instr == null) throw new ApplicationException("Invalid opcode"); return instr; }
/// <summary> /// Resolves a token /// </summary> /// <param name="self">An <see cref="IInstructionOperandResolver"/> object</param> /// <param name="token">The metadata token</param> /// <returns>A <see cref="IMDTokenProvider"/> or <c>null</c> if <paramref name="token"/> is invalid</returns> public static IMDTokenProvider ResolveToken(this IInstructionOperandResolver self, uint token) { return(self.ResolveToken(token, new GenericParamContext())); }
static Instruction endfinally_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { return OpCodes.Endfinally.ToInstruction(); }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="reader"/> doesn't /// point to the start of a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="parameters">Method parameters</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, IBinaryReader reader, IList <Parameter> parameters) { return(CreateCilBody(opResolver, reader, null, parameters, new GenericParamContext())); }
static Instruction ldfld_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { byte b = reader.ReadByte(); var field = resolver.ResolveToken(reader.ReadUInt32(), gpContext) as IField; switch (b) { case 0: return new Instruction(null, new FieldInstructionOperand(OpCodes.Ldsfld, OpCodes.Ldfld, field)); case 1: return new Instruction(null, new FieldInstructionOperand(OpCodes.Ldsflda, OpCodes.Ldflda, field)); case 2: return new Instruction(null, new FieldInstructionOperand(OpCodes.Stsfld, OpCodes.Stfld, field)); default: throw new ApplicationException("Invalid opcode"); } }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="code"/> is not /// a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="code">All code</param> /// <param name="exceptions">Exceptions or <c>null</c> if all exception handlers are in /// <paramref name="code"/></param> /// <param name="parameters">Method parameters</param> /// <param name="gpContext">Generic parameter context</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, byte[] code, byte[] exceptions, IList<Parameter> parameters, GenericParamContext gpContext) { return CreateCilBody(opResolver, MemoryImageStream.Create(code), exceptions == null ? null : MemoryImageStream.Create(exceptions), parameters, gpContext); }
static Instruction ldloca_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { Instruction instr = new Instruction(); if (reader.ReadBoolean()) { instr.OpCode = OpCodes.Ldarga; instr.Operand = new ArgOperand(reader.ReadUInt16()); } else { instr.OpCode = OpCodes.Ldloca; instr.Operand = new LocalOperand(reader.ReadUInt16()); } return instr; }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="codeReader"/> doesn't /// point to the start of a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="codeReader">A reader positioned at the start of a .NET method body</param> /// <param name="ehReader">Exception handler reader or <c>null</c> if exceptions aren't /// present or if <paramref name="codeReader"/> contains the exception handlers</param> /// <param name="parameters">Method parameters</param> /// <param name="gpContext">Generic parameter context</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, IBinaryReader codeReader, IBinaryReader ehReader, IList<Parameter> parameters, GenericParamContext gpContext) { var mbReader = new MethodBodyReader(opResolver, codeReader, ehReader, parameters, gpContext); if (!mbReader.Read()) return new CilBody(); return mbReader.CreateCilBody(); }
static Instruction ldstr_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { return OpCodes.Ldstr.ToInstruction(reader.ReadString()); }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="code"/> is not /// a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="code">All code</param> /// <param name="exceptions">Exceptions or <c>null</c> if all exception handlers are in /// <paramref name="code"/></param> /// <param name="parameters">Method parameters</param> /// <param name="flags">Method header flags, eg. 2 if tiny method</param> /// <param name="maxStack">Max stack</param> /// <param name="codeSize">Code size</param> /// <param name="localVarSigTok">Local variable signature token or 0 if none</param> /// <param name="gpContext">Generic parameter context</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, byte[] code, byte[] exceptions, IList<Parameter> parameters, ushort flags, ushort maxStack, uint codeSize, uint localVarSigTok, GenericParamContext gpContext) { var codeReader = MemoryImageStream.Create(code); var ehReader = exceptions == null ? null : MemoryImageStream.Create(exceptions); var mbReader = new MethodBodyReader(opResolver, codeReader, ehReader, parameters, gpContext); mbReader.SetHeader(flags, maxStack, codeSize, localVarSigTok); if (!mbReader.Read()) return new CilBody(); return mbReader.CreateCilBody(); }
static Instruction leave_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { int displacement = reader.ReadInt32(); return new Instruction(OpCodes.Leave, new TargetDisplOperand(displacement)); }
/// <summary> /// Constructor /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="parameters">Method parameters</param> /// <param name="gpContext">Generic parameter context</param> public MethodBodyReader(IInstructionOperandResolver opResolver, IBinaryReader reader, IList<Parameter> parameters, GenericParamContext gpContext) : this(opResolver, reader, null, parameters, gpContext) { }
static Instruction ldc_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { switch ((ElementType)reader.ReadByte()) { case ElementType.I4: return Instruction.CreateLdcI4(reader.ReadInt32()); case ElementType.I8: return OpCodes.Ldc_I8.ToInstruction(reader.ReadInt64()); case ElementType.R4: return OpCodes.Ldc_R4.ToInstruction(reader.ReadSingle()); case ElementType.R8: return OpCodes.Ldc_R8.ToInstruction(reader.ReadDouble()); case ElementType.Object: return OpCodes.Ldnull.ToInstruction(); default: throw new ApplicationException("Invalid opcode"); } }
/// <summary> /// Constructor /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="codeReader">A reader positioned at the start of a .NET method body</param> /// <param name="ehReader">Exception handler reader or <c>null</c> if exceptions aren't /// present or if <paramref name="codeReader"/> contains the exception handlers</param> /// <param name="parameters">Method parameters</param> /// <param name="gpContext">Generic parameter context</param> public MethodBodyReader(IInstructionOperandResolver opResolver, IBinaryReader codeReader, IBinaryReader ehReader, IList<Parameter> parameters, GenericParamContext gpContext) : base(codeReader, parameters) { this.opResolver = opResolver; this.exceptionsReader = ehReader; this.gpContext = gpContext; }
static Instruction ldftn_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { byte code = reader.ReadByte(); uint token = reader.ReadUInt32(); switch (code) { case 0: return new Instruction(OpCodes.Ldftn, resolver.ResolveToken(token, gpContext)); case 1: reader.ReadInt32(); // token of newobj .ctor return new Instruction(OpCodes.Ldvirtftn, resolver.ResolveToken(token, gpContext)); default: throw new ApplicationException("Invalid opcode"); } }
/// <summary> /// Creates a CIL method body or returns an empty one if <paramref name="reader"/> doesn't /// point to the start of a valid CIL method body. /// </summary> /// <param name="opResolver">The operand resolver</param> /// <param name="reader">A reader positioned at the start of a .NET method body</param> /// <param name="parameters">Method parameters</param> /// <param name="gpContext">Generic parameter context</param> public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, IBinaryReader reader, IList<Parameter> parameters, GenericParamContext gpContext) { return CreateCilBody(opResolver, reader, null, parameters, gpContext); }
static Instruction logical_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext) { switch (reader.ReadByte()) { case 0: return OpCodes.And.ToInstruction(); case 1: return OpCodes.Or.ToInstruction(); case 2: return OpCodes.Xor.ToInstruction(); case 3: return OpCodes.Shl.ToInstruction(); case 4: return OpCodes.Shr.ToInstruction(); case 5: return OpCodes.Shr_Un.ToInstruction(); default: throw new ApplicationException("Invalid opcode"); } }