/// <summary>
/// Constructor
/// </summary>
/// <param name="module">Module that will own the method body</param>
/// <param name="obj">This can be one of several supported types: the delegate instance
/// created by DynamicMethod.CreateDelegate(), a DynamicMethod instance, a RTDynamicMethod
/// instance or a DynamicResolver instance.</param>
/// <param name="gpContext">Generic parameter context</param>
public DynamicMethodBodyReader(ModuleDef module, object obj, GenericParamContext gpContext)
{
this.module = module;
this.importer = new Importer(module, ImporterOptions.TryToUseDefs, gpContext);
this.gpContext = gpContext;
this.methodName = null;
if (obj == null)
throw new ArgumentNullException("obj");
var del = obj as Delegate;
if (del != null) {
obj = del.Method;
if (obj == null)
throw new Exception("Delegate.Method == null");
}
if (obj.GetType().ToString() == "System.Reflection.Emit.DynamicMethod+RTDynamicMethod") {
obj = rtdmOwnerFieldInfo.Read(obj) as DynamicMethod;
if (obj == null)
throw new Exception("RTDynamicMethod.m_owner is null or invalid");
}
if (obj is DynamicMethod) {
methodName = ((DynamicMethod)obj).Name;
obj = dmResolverFieldInfo.Read(obj);
if (obj == null)
throw new Exception("No resolver found");
}
if (obj.GetType().ToString() != "System.Reflection.Emit.DynamicResolver")
throw new Exception("Couldn't find DynamicResolver");
var code = rslvCodeFieldInfo.Read(obj) as byte[];
if (code == null)
throw new Exception("No code");
codeSize = code.Length;
var delMethod = rslvMethodFieldInfo.Read(obj) as SR.MethodBase;
if (delMethod == null)
throw new Exception("No method");
maxStack = (int)rslvMaxStackFieldInfo.Read(obj);
var scope = rslvDynamicScopeFieldInfo.Read(obj);
if (scope == null)
throw new Exception("No scope");
var tokensList = scopeTokensFieldInfo.Read(scope) as System.Collections.IList;
if (tokensList == null)
throw new Exception("No tokens");
tokens = new List<object>(tokensList.Count);
for (int i = 0; i < tokensList.Count; i++)
tokens.Add(tokensList[i]);
ehInfos = (IList<object>)rslvExceptionsFieldInfo.Read(obj);
ehHeader = rslvExceptionHeaderFieldInfo.Read(obj) as byte[];
UpdateLocals(rslvLocalsFieldInfo.Read(obj) as byte[]);
this.reader = MemoryImageStream.Create(code);
this.method = CreateMethodDef(delMethod);
this.parameters = this.method.Parameters;
}
/// <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>
/// 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)
{
}
/// <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 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)));
}
PortablePdbCustomDebugInfoReader(ModuleDef module, TypeDef typeOpt, CilBody bodyOpt, GenericParamContext gpContext, ref DataReader reader)
{
this.module = module;
this.typeOpt = typeOpt;
this.bodyOpt = bodyOpt;
this.gpContext = gpContext;
this.reader = reader;
}
/// <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 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);
}
static Instruction compare_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext)
{
int type = reader.ReadByte();
Instruction instr = new Instruction();
switch (type)
{
case 0: instr.OpCode = OpCodes.Br; break;
case 1: instr.OpCode = OpCodes.Brtrue; break;
case 2: instr.OpCode = OpCodes.Brfalse; break;
case 3: instr.OpCode = OpCodes.Beq; break;
case 4: instr.OpCode = OpCodes.Bge; break;
case 5: instr.OpCode = OpCodes.Bgt; break;
case 6: instr.OpCode = OpCodes.Ble; break;
case 7: instr.OpCode = OpCodes.Blt; break;
case 8: instr.OpCode = OpCodes.Bne_Un; break;
case 9: instr.OpCode = OpCodes.Bge_Un; break;
case 10: instr.OpCode = OpCodes.Bgt_Un; break;
case 11: instr.OpCode = OpCodes.Ble_Un; break;
case 12: instr.OpCode = OpCodes.Blt_Un; break;
case 13: instr.OpCode = OpCodes.Ceq; break;
case 14: instr.OpCode = OpCodes.Cgt; break;
case 15: instr.OpCode = OpCodes.Clt; break;
case 16: instr.OpCode = OpCodes.Cgt_Un; break;
case 17: instr.OpCode = OpCodes.Clt_Un; break;
default: throw new ApplicationException("Invalid opcode");
}
if (type < 13)
{
instr.Operand = new TargetDisplOperand(reader.ReadInt32());
}
return(instr);
}
static Instruction cast_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext)
{
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(), gpContext);
return(instr);
}
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");
}
}
protected override void InitializeCustomAttributes()
{
readerModule.InitCustomAttributes(this, ref customAttributes, GenericParamContext.Create(ownerType));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="module">Module that will own the method body</param>
/// <param name="obj">This can be one of several supported types: the delegate instance
/// created by DynamicMethod.CreateDelegate(), a DynamicMethod instance, a RTDynamicMethod
/// instance or a DynamicResolver instance.</param>
/// <param name="gpContext">Generic parameter context</param>
public SuperDynamicReader(ModuleDef module, object obj, GenericParamContext gpContext)
{
this.module = module;
this.importer = new Importer(module, ImporterOptions.TryToUseDefs, gpContext);
this.gpContext = gpContext;
if (obj == null)
{
throw new ArgumentNullException("obj");
}
var del = obj as Delegate;
if (del != null)
{
obj = del.Method;
if (obj == null)
{
throw new Exception("Delegate.Method == null");
}
}
if (obj.GetType().ToString() == "System.Reflection.Emit.DynamicMethod+RTDynamicMethod")
{
obj = rtdmOwnerFieldInfo.Read(obj) as DynamicMethod;
if (obj == null)
{
throw new Exception("RTDynamicMethod.m_owner is null or invalid");
}
}
if (obj is DynamicMethod)
{
object obj2 = obj;
obj = dmResolverFieldInfo.Read(obj);
if (obj == null)
{
// could be compiled from dynamic info instead of raw shit
obj = obj2;
obj = methodDynamicInfo.Read(obj);
if (obj == null)
{
throw new Exception("No resolver found");
}
SecondOption(obj);
return;
}
}
if (obj.GetType().ToString() != "System.Reflection.Emit.DynamicResolver")
{
throw new Exception("Couldn't find DynamicResolver");
}
var code = rslvCodeFieldInfo.Read(obj) as byte[];
if (code == null)
{
throw new Exception("No code");
}
codeSize = code.Length;
var delMethod = rslvMethodFieldInfo.Read(obj) as SR.MethodBase;
if (delMethod == null)
{
throw new Exception("No method");
}
maxStack = (int)rslvMaxStackFieldInfo.Read(obj);
var scope = rslvDynamicScopeFieldInfo.Read(obj);
if (scope == null)
{
throw new Exception("No scope");
}
var tokensList = scopeTokensFieldInfo.Read(scope) as System.Collections.IList;
if (tokensList == null)
{
throw new Exception("No tokens");
}
tokens = new List <object>(tokensList.Count);
for (int i = 0; i < tokensList.Count; i++)
{
tokens.Add(tokensList[i]);
}
ehInfos = (IList <object>)rslvExceptionsFieldInfo.Read(obj);
ehHeader = rslvExceptionHeaderFieldInfo.Read(obj) as byte[];
UpdateLocals(rslvLocalsFieldInfo.Read(obj) as byte[]);
this.reader = MemoryImageStream.Create(code);
this.method = CreateMethodDef(delMethod);
this.parameters = this.method.Parameters;
}
ITypeDefOrRef ISignatureReaderHelper.ResolveTypeDefOrRef(uint codedToken, GenericParamContext gpContext)
{
uint token;
if (!CodedToken.TypeDefOrRef.Decode(codedToken, out token))
return null;
uint rid = MDToken.ToRID(token);
switch (MDToken.ToTable(token)) {
case Table.TypeDef:
case Table.TypeRef:
case Table.TypeSpec:
return ImportType(rid);
}
return null;
}
/// <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 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>
/// 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);
}
static Instruction endfinally_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext)
{
return(OpCodes.Endfinally.ToInstruction());
}
static Instruction stobj_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext)
{
return(new Instruction(OpCodes.Stobj, null));
}
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");
}
}
static Instruction throw_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext)
{
return(OpCodes.Throw.ToInstruction());
}
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="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 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 ldtoken_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext)
{
return(new Instruction(OpCodes.Ldtoken, resolver.ResolveToken(reader.ReadUInt32(), gpContext)));
}
/// <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 leave_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext)
{
int displacement = reader.ReadInt32();
return(new Instruction(OpCodes.Leave, new TargetDisplOperand(displacement)));
}
/// <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 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>
/// 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 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="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 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");
}
}
/// <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 ret_read(BinaryReader reader, IInstructionOperandResolver resolver, GenericParamContext gpContext)
{
reader.ReadInt32(); // token of current method
return(OpCodes.Ret.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>
/// <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 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);
}
