private Disassembler(MethodBase method, ILStyler styler)
{
this._module = method.DeclaringType.Module;
this._styler = styler;
if (method.GetMethodBody() != null)
{
this._il = method.GetMethodBody().GetILAsByteArray();
}
}
/// <summary>
/// MethodBodyReader constructor
/// </summary>
/// <param name="mi">
/// The System.Reflection defined MethodInfo
/// </param>
public MethodBodyReader(MethodInfo mi)
{
this.mi = mi;
if (mi.GetMethodBody() != null)
{
il = mi.GetMethodBody().GetILAsByteArray();
ConstructInstructions(mi.Module);
}
}
// Token: 0x06002E89 RID: 11913
// RVA: 0x0012E9C4 File Offset: 0x0012CBC4
public Class776(MethodBase methodBase_1)
{
this.methodBase_0 = methodBase_1;
byte[] array = (methodBase_1.GetMethodBody() != null) ? methodBase_1.GetMethodBody().GetILAsByteArray() : null;
if (array != null)
{
this.byte_0 = array;
this.method_3(methodBase_1.Module);
}
}
public MSIL_MethodResolver(System.Reflection.MethodBase Method) : base(Method.DeclaringType.Module)
{
System.Reflection.MethodBody body = Method.GetMethodBody();
if (Method.GetMethodBody() != null)
{
foreach (System.Reflection.LocalVariableInfo localsBody in body.LocalVariables)
{
System.Reflection.LocalVariableInfo _WAR_local = localsBody;
_locals.Add(_WAR_local.LocalIndex, _WAR_local);
}
}
}
/*
public ILReader(MethodBase enclosingMethod)
{
this.m_enclosingMethod = enclosingMethod;
MethodBody methodBody = m_enclosingMethod.GetMethodBody();
this.m_byteArray = (methodBody == null) ? new Byte[0] : methodBody.GetILAsByteArray();
this.m_position = 0;
}
*/
public ILReader2(MethodBase enclosingMethod)
{
this.m_enclosingMethod = enclosingMethod;
MethodBody methodBody = m_enclosingMethod.GetMethodBody();
this.m_byteArray = (methodBody == null) ? new Byte[0] : methodBody.GetILAsByteArray();
this.m_position = 0;
}
public ExceptionDetails(Exception ex, MethodBase info)
{
var methodBody = info.GetMethodBody();
Exception = ex;
MethodName = info.Name;
MethodBody = methodBody != null ? methodBody.ToString() : "undefined";
}
MethodBodyReader (MethodBase method)
{
this.method = method;
this.body = method.GetMethodBody ();
if (this.body == null)
throw new ArgumentException ("Method has no body");
var bytes = body.GetILAsByteArray ();
if (bytes == null)
throw new ArgumentException ("Can not get the body of the method");
if (!(method is ConstructorInfo))
method_arguments = method.GetGenericArguments ();
if (method.DeclaringType != null)
type_arguments = method.DeclaringType.GetGenericArguments ();
if (!method.IsStatic)
this_parameter = new ThisParameter(method.DeclaringType);
this.parameters = method.GetParameters ();
this.locals = body.LocalVariables;
this.module = method.Module;
this.il = new ByteBuffer (bytes);
this.instructions = new List<Instruction> ((bytes.Length + 1) / 2);
}
public NaiveMethodNameExtractor(Delegate @delegate)
{
delegateMethod = @delegate.Method;
body = delegateMethod.GetMethodBody();
Debug.Assert(body != null);
module = delegateMethod.Module;
stream = new MemoryStream(body.GetILAsByteArray());
Read();
}
/// <summary>
/// Disassemble the bytecode of the specified method or constructor
/// </summary>
/// <param name="MethodBase">The method to disassemble</param>
/// <param name="Resolver">A resolver class used while disassembling the code.
/// Every token resolution and local variable resolution will be made with this resolver</param>
/// <returns>The list of intruction contained in the method</returns>
static public List <Instruction> ReadMethod(System.Reflection.MethodBase MethodBase, Resolver Resolver)
{
System.Reflection.MethodBody methodBody = MethodBase.GetMethodBody();
if (methodBody == null)
{
return(new List <Instruction>());
}
return(ReadMethod(methodBody.GetILAsByteArray(), Resolver));
}
protected override void DoInitStackAnalysis(MethodBase aMethod)
{
base.DoInitStackAnalysis(aMethod);
switch (OpCode)
{
case Code.Ldloc:
var xBody = aMethod.GetMethodBody();
if (xBody != null)
{
StackPushTypes[0] = xBody.LocalVariables[Value].LocalType;
if (StackPushTypes[0].IsEnum)
{
StackPushTypes[0] = StackPushTypes[0].GetEnumUnderlyingType();
}
}
return;
case Code.Ldloca:
StackPushTypes[0] = typeof(void*);
return;
case Code.Ldarga:
StackPushTypes[0] = typeof (void*);
return;
case Code.Ldarg:
var xArgIndexCorrection = 0;
if (!aMethod.IsStatic)
{
if (Value == 0)
{
StackPushTypes[0] = aMethod.DeclaringType;
if (StackPushTypes[0].IsEnum)
{
StackPushTypes[0] = StackPushTypes[0].GetEnumUnderlyingType();
}
else
{
if (StackPushTypes[0].IsValueType)
{
StackPushTypes[0] = typeof (void*);
}
}
return;
}
xArgIndexCorrection = -1;
}
var xParams = aMethod.GetParameters();
StackPushTypes[0] = xParams[Value + xArgIndexCorrection].ParameterType;
if (StackPushTypes[0].IsEnum)
{
StackPushTypes[0] = StackPushTypes[0].GetEnumUnderlyingType();
}
return;
default:
break;
}
}
public void OnExit(MethodBase method)
{
Console.WriteLine("OnExit");
var mi = (MethodInfo) method;
var p = method.GetParameters();
var b = method.GetMethodBody();
var st = new StackTrace();
StackFrame sf = st.GetFrame(1); //previous method call
}
/// <summary>
/// Get intermediate language of passed method.
/// </summary>
/// <param name="methodInfo"> The method info. </param>
/// <returns> The intermediate language as a byte array. </returns>
/// <exception cref="ArgumentException">Thrown if methodBody is null.</exception>
private static IEnumerable<byte> GetIntermediateLanguageFromMethodInfoBase(MethodBase methodInfo)
{
var methodBody = methodInfo.GetMethodBody();
if (methodBody == null)
{
throw new ArgumentException("Method Body is null");
}
return methodBody.GetILAsByteArray();
}
static internal byte[] GetBodyAsByteArray(this MethodBase method)
{
method.Prepare();
if (method is DynamicMethod)
{
return((method as DynamicMethod).GetILGenerator().GetILAsByteArray());
}
var _body = method.GetMethodBody();
return(_body == null ? null : _body.GetILAsByteArray());
}
public MethodData(MethodBase method)
{
Token = method.MetadataToken;
MethodBody body = method.GetMethodBody();
if (body != null)
SignatureToken = body.LocalSignatureMetadataToken;
Name = method.DeclaringType.FullName + "::" + method.Name;
}
/// <summary>
/// MethodBodyReader constructor
/// </summary>
/// <param name="method">The method to read the body from.</param>
/// <param name="language">Code language to use for text representations of code.</param>
public MethodBodyReader(MethodBase method, ILanguageInfo language)
{
try
{
this.method = method;
this.language = language ?? new DefaultLanguageInfo();
MethodBody body = method.GetMethodBody();
if (body != null)
{
il = body.GetILAsByteArray();
ConstructInstructions(method.Module);
}
}
catch (Exception ex)
{
throw new InvalidOperationException(String.Format("Failed to read the body of {0}'s {1}.", method.DeclaringType, method), ex);
}
}
/// <summary>
/// Gets the il instructions.
/// </summary>
/// <param name="This">This MethodBase.</param>
/// <returns>A list of instructions.</returns>
public static ILInstruction[] GetInstructions(this MethodBase This)
{
Contract.Requires(This != null);
var body = This.GetMethodBody();
if (body == null)
{
return(null);
}
// make sure opcodes are loaded
_CheckOpcodeInit();
var module = This.Module;
var il = body.GetILAsByteArray();
var position = 0;
var result = new List <ILInstruction>();
while (position < il.Length)
{
var instruction = new ILInstruction();
// get the operation code of the current instruction
OpCode code;
ushort value = il[position++];
if (value != 0xfe)
{
code = _SINGLE_BYTE_OP_CODES[value];
}
else
{
value = il[position++];
code = _MULTI_BYTE_OP_CODES[value];
value = (ushort)(value | 0xfe00);
}
instruction.Code = code;
instruction.Offset = position - 1;
// get the operand of the current operation
position = _ReadOperand(This, code, position, il, module, instruction);
result.Add(instruction);
}
return(result.ToArray());
}
static StackObject *GetMethodBody_35(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Reflection.MethodBase instance_of_this_method = (System.Reflection.MethodBase) typeof(System.Reflection.MethodBase).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.GetMethodBody();
object obj_result_of_this_method = result_of_this_method;
if (obj_result_of_this_method is CrossBindingAdaptorType)
{
return(ILIntepreter.PushObject(__ret, __mStack, ((CrossBindingAdaptorType)obj_result_of_this_method).ILInstance));
}
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
private MethodBodyReader(MethodBase method)
{
_method = method;
_body = method.GetMethodBody();
if (_body == null)
throw new ArgumentException("Method has no body");
var iLAsByteArray = _body.GetILAsByteArray();
if (iLAsByteArray == null)
throw new ArgumentException("Can not get the body of the method");
if (!(method is ConstructorInfo))
_methodArguments = method.GetGenericArguments();
if (method.DeclaringType != null)
_typeArguments = method.DeclaringType.GetGenericArguments();
_parameters = method.GetParameters();
_locals = _body.LocalVariables;
_module = method.Module;
_il = new ByteBuffer(iLAsByteArray);
}
void CopyMethodBody(MethodBase Base, ILGenerator Gen)
{
MethodBody Body = Base.GetMethodBody();
CopyLocals(Gen, Body);
byte[] Bytes = Body.GetILAsByteArray();
var ExceptionTrinkets = new List<int>();
var LabelTargets = new Dictionary<int, Label>();
var LabelOrigins = new Dictionary<int, Label[]>();
MineExTrinkets(Body, ExceptionTrinkets);
// There's a reason we mine these labels. First of all, we need to get the switchmaps. Because
// there is no way to bang a number of bytes in the IL, we mine the targets of a switch operation
// and save them to be marked when we walk through the method again to copy the opcodes. Secondly,
// the microsoft C# compiler sometimes uses the leave.s opcode instead of the leave opcode at the
// end of a try block. This is all fine, but System.Reflection.Emit forces a leave opcode on the
// IL when we call BeginCatchBlock() and friends, offering no way to use the leave.s opcode instead.
// The simple result is that we are left with putting the leave instruction with its 4-byte
// argument in the IL against our will. This screws over all branch targets with an offset of +3
// bytes. Consequently, we have to mine *all* branch targets and re-mark them to prevent segfaults
// and the like in the runtime. This overhead could all have been avoided, had SRE given us just
// a tiny bit more of control over the IL that was to be emitted.
MineLabels(Bytes, Gen, LabelOrigins, LabelTargets);
for(int i = 0; i < Bytes.Length; i++)
{
CopyTryCatch(Gen, i, Body, ExceptionTrinkets);
CopyLabels(Gen, i, LabelTargets);
CopyOpcode(Bytes, ref i, Gen, Base.Module, ExceptionTrinkets, LabelOrigins);
}
// If we do not throw this exception, SRE will do it, but with much less debugging information.
foreach(int i in LabelTargets.Keys)
throw new Exception("Unmarked label destined for RVA "+i.ToString("X"));
}
public DisassembledMethod Disassemble(MethodBase method)
{
Contract.Requires(method != null);
Contract.Requires(CanDisassemble(method));
var methodBody = method.GetMethodBody();
if (methodBody == null)
{
throw new NotSupportedException(method.DeclaringType +" {" + method.ToString() + "} "+ method.GetMethodImplementationFlags() );
}
Contract.Assert(methodBody!=null);
// ReSharper disable PossibleNullReferenceException
var ilBytes = methodBody.GetILAsByteArray();
// ReSharper restore PossibleNullReferenceException
Type returnType = method is MethodInfo
? (method as MethodInfo).ReturnType
: typeof (void);
var handlingClauses = methodBody.ExceptionHandlingClauses;
Type[] genericParameters = null;
if (method.IsGenericMethod)
{
genericParameters = method.GetGenericArguments();
}
return new DisassembledMethod(
ilBytes,
Scan(ilBytes, handlingClauses),
new ModuleMetadataResolver(method.Module),
handlingClauses,
methodBody.LocalVariables,
returnType,
method.GetParameters(),
method.IsGenericMethodDefinition ,
genericParameters );
}
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);
}
}
private void MapVariables(MethodBase method, MethodDefinition method_definition)
{
var body = method.GetMethodBody();
if (body == null)
return;
foreach (var variable in body.LocalVariables)
{
var variable_type = CreateReference(variable.LocalType, method_definition);
method_definition.Body.Variables.Add(new VariableDefinition(variable.IsPinned ? new PinnedType(variable_type) : variable_type));
}
method_definition.Body.InitLocals = body.InitLocals;
}
private void DumpMethod(MethodBase mb, BinaryWriter sw)
{
MethodBody mbd = mb.GetMethodBody();
if (mbd == null)
return;
SetOffset(sw, mb.MetadataToken);
WriteHeader(mbd, sw);
WriteILCode(mbd, sw);
WriteSEH(mbd, sw);
}
private static IEnumerable<Instruction> readIL(MethodBase method, Type genericContext)
{
MethodBody body = method.GetMethodBody();
if (body == null)
yield break;
int offset = 0;
byte[] il = body.GetILAsByteArray();
while (offset < il.Length)
{
int startOffset = offset;
byte opCodeByte = il[offset];
short opCodeValue = opCodeByte;
offset++;
// If it's an extended opcode then grab the second byte. The 0xFE prefix codes aren't marked as prefix operators though.
if (opCodeValue == 0xFE || _opCodeList[opCodeValue].OpCodeType == OpCodeType.Prefix)
{
opCodeValue = (short) ((opCodeValue << 8) + il[offset]);
offset++;
}
OpCode code = _opCodeList[opCodeValue];
object operand = null;
switch (code.OperandType)
{
case OperandType.ShortInlineBrTarget:
case OperandType.ShortInlineI:
case OperandType.ShortInlineVar:
operand = il[offset];
offset++;
break;
case OperandType.InlineI:
case OperandType.InlineBrTarget:
operand = BitConverter.ToInt32(il, offset);
offset += 4;
break;
case OperandType.ShortInlineR: operand = BitConverter.ToSingle(il, offset); offset += 4; break;
case OperandType.InlineVar: operand = BitConverter.ToInt16(il, offset); offset += 2; break;
case OperandType.InlineI8: operand = BitConverter.ToInt64(il, offset); offset += 8; break;
case OperandType.InlineR: operand = BitConverter.ToDouble(il, offset); offset += 8; break;
case OperandType.InlineField: operand = method.Module.ResolveField(BitConverter.ToInt32(il, offset), genericContext.GetGenericArguments(), method is ConstructorInfo ? Type.EmptyTypes : method.GetGenericArguments()); offset += 4; break;
case OperandType.InlineMethod: operand = method.Module.ResolveMethod(BitConverter.ToInt32(il, offset), genericContext.GetGenericArguments(), method is ConstructorInfo ? Type.EmptyTypes : method.GetGenericArguments()); offset += 4; break;
case OperandType.InlineSig: operand = method.Module.ResolveSignature(BitConverter.ToInt32(il, offset)); offset += 4; break;
case OperandType.InlineString: operand = method.Module.ResolveString(BitConverter.ToInt32(il, offset)); offset += 4; break;
case OperandType.InlineType: operand = method.Module.ResolveType(BitConverter.ToInt32(il, offset), genericContext.GetGenericArguments(), method is ConstructorInfo ? Type.EmptyTypes : method.GetGenericArguments()); offset += 4; break;
case OperandType.InlineSwitch:
long num = BitConverter.ToInt32(il, offset);
offset += 4;
var ints = new int[num];
for (int i = 0; i < num; i++)
{
ints[i] = BitConverter.ToInt32(il, offset);
offset += 4;
}
operand = ints;
break;
case OperandType.InlineTok:
operand = method.Module.ResolveMember(BitConverter.ToInt32(il, offset), genericContext.GetGenericArguments(), method is ConstructorInfo ? Type.EmptyTypes : method.GetGenericArguments()); offset += 4; break;
}
yield return new Instruction(startOffset, code, operand);
}
}
static int GetILSize (MethodBase mi)
{
MethodBody body = mi.GetMethodBody ();
if (body != null)
return body.GetILAsByteArray ().Length;
return 0;
}
protected List<EcmaCil.IL.BaseInstruction> ScanMethodBody_DoIt(MethodBase aMethod, EcmaCil.MethodMeta aMethodMeta, IDictionary<int, int> aILOffsetToInstructionIndex, IDictionary<int, int> aInstructionIndexToILOffset)
{
var xResult = new List<EcmaCil.IL.BaseInstruction>(aILOffsetToInstructionIndex.Count);
var xBody = aMethod.GetMethodBody();
// Cache for use in field and method resolution
Type[] xTypeGenArgs = null;
Type[] xMethodGenArgs = null;
if (aMethod.DeclaringType.IsGenericType)
{
xTypeGenArgs = aMethod.DeclaringType.GetGenericArguments();
}
if (aMethod.IsGenericMethod)
{
xMethodGenArgs = aMethod.GetGenericArguments();
}
// Some methods return no body. Not sure why.. have to investigate
// They arent abstracts or icalls...
// MtW: how about externs (pinvoke, etc)
if (xBody == null)
{
return null;
}
var xIL = xBody.GetILAsByteArray();
int xPos = 0;
var xInstructionIndex = 0;
var xInitSecondStage = new List<Action>(aILOffsetToInstructionIndex.Count);
while (xPos < xIL.Length)
{
ExceptionHandlingClause xCurrentHandler = null;
#region Determine current handler
// todo: add support for nested handlers using a stack or so..
foreach (ExceptionHandlingClause xHandler in xBody.ExceptionHandlingClauses)
{
if (xHandler.TryOffset > 0)
{
if (xHandler.TryOffset <= xPos && (xHandler.TryLength + xHandler.TryOffset + 1) > xPos) // + 1 because index should be less than the try
{
if (xCurrentHandler == null)
{
xCurrentHandler = xHandler;
continue;
}
else if (xHandler.TryOffset > xCurrentHandler.TryOffset && (xHandler.TryLength + xHandler.TryOffset) < (xCurrentHandler.TryLength + xCurrentHandler.TryOffset))
{
// only replace if the current found handler is narrower
xCurrentHandler = xHandler;
continue;
}
}
}
if (xHandler.HandlerOffset > 0)
{
if (xHandler.HandlerOffset <= xPos && (xHandler.HandlerOffset + xHandler.HandlerLength + 1) > xPos)
{
if (xCurrentHandler == null)
{
xCurrentHandler = xHandler;
continue;
}
else if (xHandler.HandlerOffset > xCurrentHandler.HandlerOffset && (xHandler.HandlerOffset + xHandler.HandlerLength) < (xCurrentHandler.HandlerOffset + xCurrentHandler.HandlerLength))
{
// only replace if the current found handler is narrower
xCurrentHandler = xHandler;
continue;
}
}
}
if ((xHandler.Flags & ExceptionHandlingClauseOptions.Filter) > 0)
{
if (xHandler.FilterOffset > 0)
{
if (xHandler.FilterOffset <= xPos)
{
if (xCurrentHandler == null)
{
xCurrentHandler = xHandler;
continue;
}
else if (xHandler.FilterOffset > xCurrentHandler.FilterOffset)
{
// only replace if the current found handler is narrower
xCurrentHandler = xHandler;
continue;
}
}
}
}
}
#endregion
OpCodeEnum xOpCodeVal;
OpCode xOpCode;
int xOpPos = xPos;
if (xIL[xPos] == 0xFE)
{
xOpCodeVal = (OpCodeEnum)(0xFE00 | xIL[xPos + 1]);
xOpCode = mOpCodesHi[xIL[xPos + 1]];
xPos = xPos + 2;
}
else
{
xOpCodeVal = (OpCodeEnum)xIL[xPos];
xOpCode = mOpCodesLo[xIL[xPos]];
xPos++;
}
EcmaCil.IL.BaseInstruction xILOpCode = null;
Cil.InstructionBranch xBranch;
Console.WriteLine(xOpCode.ToString() + " " + xOpCode.OperandType);
#region switch(xOpCode.OperandType)
switch (xOpCode.OperandType)
{
// No operand.
case OperandType.InlineNone:
{
#region Inline none options
// These shortcut translation regions expand shortcut ops into full ops
// This elminates the amount of code required in the assemblers
// by allowing them to ignore the shortcuts
switch (xOpCodeVal)
{
case OpCodeEnum.Ldarg_0:
xILOpCode = new Cil.InstructionArgument(EcmaCil.IL.InstructionKindEnum.Ldarg, xInstructionIndex, aMethodMeta.Parameters[0]);
break;
case OpCodeEnum.Ldarg_1:
xILOpCode = new Cil.InstructionArgument(EcmaCil.IL.InstructionKindEnum.Ldarg, xInstructionIndex, aMethodMeta.Parameters[1]);
break;
case OpCodeEnum.Ldarg_2:
xILOpCode = new Cil.InstructionArgument(EcmaCil.IL.InstructionKindEnum.Ldarg, xInstructionIndex, aMethodMeta.Parameters[2]);
break;
case OpCodeEnum.Ldarg_3:
xILOpCode = new Cil.InstructionArgument(EcmaCil.IL.InstructionKindEnum.Ldarg, xInstructionIndex, aMethodMeta.Parameters[3]);
break;
case OpCodeEnum.Ldc_I4_0:
xILOpCode = new Cil.InstructionInt32(EcmaCil.IL.InstructionKindEnum.Ldc_I4, xInstructionIndex, 0);
break;
case OpCodeEnum.Ldc_I4_1:
xILOpCode = new Cil.InstructionInt32(EcmaCil.IL.InstructionKindEnum.Ldc_I4, xInstructionIndex, 1);
break;
case OpCodeEnum.Ldc_I4_2:
xILOpCode = new Cil.InstructionInt32(EcmaCil.IL.InstructionKindEnum.Ldc_I4, xInstructionIndex, 2);
break;
case OpCodeEnum.Ldc_I4_3:
xILOpCode = new Cil.InstructionInt32(EcmaCil.IL.InstructionKindEnum.Ldc_I4, xInstructionIndex, 3);
break;
case OpCodeEnum.Ldc_I4_4:
xILOpCode = new Cil.InstructionInt32(EcmaCil.IL.InstructionKindEnum.Ldc_I4, xInstructionIndex, 4);
break;
case OpCodeEnum.Ldc_I4_5:
xILOpCode = new Cil.InstructionInt32(EcmaCil.IL.InstructionKindEnum.Ldc_I4, xInstructionIndex, 5);
break;
case OpCodeEnum.Ldc_I4_6:
xILOpCode = new Cil.InstructionInt32(EcmaCil.IL.InstructionKindEnum.Ldc_I4, xInstructionIndex, 6);
break;
case OpCodeEnum.Ldc_I4_7:
xILOpCode = new Cil.InstructionInt32(EcmaCil.IL.InstructionKindEnum.Ldc_I4, xInstructionIndex, 7);
break;
case OpCodeEnum.Ldc_I4_8:
xILOpCode = new Cil.InstructionInt32(EcmaCil.IL.InstructionKindEnum.Ldc_I4, xInstructionIndex, 8);
break;
case OpCodeEnum.Ldc_I4_M1:
xILOpCode = new Cil.InstructionInt32(EcmaCil.IL.InstructionKindEnum.Ldc_I4, xInstructionIndex, -1);
break;
case OpCodeEnum.Ldloc_0:
xILOpCode = new Cil.InstructionLocal(EcmaCil.IL.InstructionKindEnum.Ldloc, xInstructionIndex, aMethodMeta.Body.LocalVariables[0]);
break;
case OpCodeEnum.Ldloc_1:
xILOpCode = new Cil.InstructionLocal(EcmaCil.IL.InstructionKindEnum.Ldloc, xInstructionIndex, aMethodMeta.Body.LocalVariables[1]);
break;
case OpCodeEnum.Ldloc_2:
xILOpCode = new Cil.InstructionLocal(EcmaCil.IL.InstructionKindEnum.Ldloc, xInstructionIndex, aMethodMeta.Body.LocalVariables[2]);
break;
case OpCodeEnum.Ldloc_3:
xILOpCode = new Cil.InstructionLocal(EcmaCil.IL.InstructionKindEnum.Ldloc, xInstructionIndex, aMethodMeta.Body.LocalVariables[3]);
break;
case OpCodeEnum.Stloc_0:
xILOpCode = new Cil.InstructionLocal(EcmaCil.IL.InstructionKindEnum.Stloc, xInstructionIndex, aMethodMeta.Body.LocalVariables[0]);
break;
case OpCodeEnum.Stloc_1:
xILOpCode = new Cil.InstructionLocal(EcmaCil.IL.InstructionKindEnum.Stloc, xInstructionIndex, aMethodMeta.Body.LocalVariables[1]);
break;
case OpCodeEnum.Stloc_2:
xILOpCode = new Cil.InstructionLocal(EcmaCil.IL.InstructionKindEnum.Stloc, xInstructionIndex, aMethodMeta.Body.LocalVariables[2]);
break;
case OpCodeEnum.Stloc_3:
xILOpCode = new Cil.InstructionLocal(EcmaCil.IL.InstructionKindEnum.Stloc, xInstructionIndex, aMethodMeta.Body.LocalVariables[3]);
break;
default:
xILOpCode = new Cil.InstructionNone((EcmaCil.IL.InstructionKindEnum)xOpCodeVal, xInstructionIndex);
break;
}
#endregion
break;
}
case OperandType.ShortInlineBrTarget:
{
#region Inline branch
// By calculating target, we assume all branches are within a method
// So far at least wtih csc, its true. We check it with CheckBranch
// just in case.
int xTarget = xPos + 1 + (sbyte)xIL[xPos];
CheckBranch(xTarget, xIL.Length);
switch (xOpCodeVal)
{
case OpCodeEnum.Beq_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Beq, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Bge_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Bge, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Bge_Un_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Bge_Un, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Bgt_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Bgt, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Bgt_Un_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Bgt_Un, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Ble_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Ble, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Ble_Un_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Ble_Un, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Blt_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Blt, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Blt_Un_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Blt_Un, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Bne_Un_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Bne_Un, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Br_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Br, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Brfalse_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Brfalse, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Brtrue_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Brtrue, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
case OpCodeEnum.Leave_S:
xBranch = new Cil.InstructionBranch(EcmaCil.IL.InstructionKindEnum.Leave, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
default:
xBranch = new Cil.InstructionBranch((EcmaCil.IL.InstructionKindEnum)xOpCodeVal, xInstructionIndex);
xILOpCode = xBranch;
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
break;
}
xPos = xPos + 1;
break;
#endregion
}
case OperandType.InlineBrTarget:
{
int xTarget = xPos + 4 + (Int32)ReadInt32(xIL, xPos);
CheckBranch(xTarget, xIL.Length);
xILOpCode = xBranch = new Cil.InstructionBranch((EcmaCil.IL.InstructionKindEnum)xOpCodeVal, xInstructionIndex);
xInitSecondStage.Add(delegate
{
xBranch.Target = xResult[aILOffsetToInstructionIndex[xTarget]];
});
xPos = xPos + 4;
break;
}
case OperandType.ShortInlineI:
switch (xOpCodeVal)
{
case OpCodeEnum.Ldc_I4_S:
xILOpCode = new Cil.InstructionInt32(EcmaCil.IL.InstructionKindEnum.Ldc_I4, xInstructionIndex, xIL[xPos]);
break;
default:
xILOpCode = new Cil.InstructionInt32((EcmaCil.IL.InstructionKindEnum)xOpCodeVal, xInstructionIndex, xIL[xPos]);
break;
}
xPos = xPos + 1;
break;
case OperandType.InlineI:
xILOpCode = new Cil.InstructionInt32((Cil.InstructionKindEnum)xOpCodeVal, xInstructionIndex, ReadInt32(xIL, xPos));
xPos = xPos + 4;
break;
case OperandType.InlineI8:
xILOpCode = new Cil.InstructionInt64((Cil.InstructionKindEnum)xOpCodeVal, xInstructionIndex, ReadInt64(xIL, xPos));
xPos = xPos + 8;
break;
case OperandType.ShortInlineR:
// this is not correct:
//xILOpCode = new Cil.InstructionSingle(
//xILOpCode = new ILOpCodes.OpSingle(xOpCodeVal, xOpPos, xPos + 4, BitConverter.ToSingle(xIL, xPos), xCurrentHandler);
//xPos = xPos + 4;
//break;
throw new NotImplementedException();
case OperandType.InlineR:
// this is not correct
//xILOpCode = new ILOpCodes.OpDouble(xOpCodeVal, xOpPos, xPos + 8, BitConverter.ToDouble(xIL, xPos), xCurrentHandler);
//xPos = xPos + 8;
//break;
throw new NotImplementedException();
// The operand is a 32-bit metadata token.
case OperandType.InlineField:
throw new NotImplementedException();
//{
// var xValue = aMethod.Module.ResolveField((int)ReadInt32(xIL, xPos), xTypeGenArgs, xMethodGenArgs);
// xILOpCode = new ILOpCodes.OpField(xOpCodeVal, xOpPos, xPos + 4, xValue, xCurrentHandler);
// xPos = xPos + 4;
// break;
//}
// The operand is a 32-bit metadata token.
case OperandType.InlineMethod:
var xTargetMethod = EnqueueMethod(aMethod.DeclaringType.Module.ResolveMethod(ReadInt32(xIL, xPos)), aMethod, "Method Call");
xILOpCode = new Cil.InstructionMethod((Cil.InstructionKindEnum)xOpCodeVal, xInstructionIndex, xTargetMethod);
xPos = xPos + 4;
break;
//{
// var xValue = aMethod.Module.ResolveMethod((int)ReadInt32(xIL, xPos), xTypeGenArgs, xMethodGenArgs);
// xILOpCode = new ILOpCodes.OpMethod(xOpCodeVal, xOpPos, xPos + 4, xValue, xCurrentHandler);
// xPos = xPos + 4;
// break;
//}
// 32-bit metadata signature token.
case OperandType.InlineSig:
throw new NotImplementedException();
case OperandType.InlineString:
xILOpCode = new Cil.InstructionString(Cil.InstructionKindEnum.Ldstr, xInstructionIndex, aMethod.Module.ResolveString(ReadInt32(xIL, xPos)));
xPos = xPos + 4;
break;
case OperandType.InlineSwitch:
throw new NotImplementedException();
//{
// int xCount = (int)ReadInt32(xIL, xPos);
// xPos = xPos + 4;
// int xNextOpPos = xPos + xCount * 4;
// int[] xBranchLocations = new int[xCount];
// for (int i = 0; i < xCount; i++)
// {
// xBranchLocations[i] = xNextOpPos + (int)ReadInt32(xIL, xPos + i * 4);
// CheckBranch(xBranchLocations[i], xIL.Length);
// }
// xILOpCode = new ILOpCodes.OpSwitch(xOpCodeVal, xOpPos, xPos, xBranchLocations, xCurrentHandler);
// xPos = xNextOpPos;
// break;
//}
// The operand is a FieldRef, MethodRef, or TypeRef token.
case OperandType.InlineTok:
throw new NotImplementedException();
//xILOpCode = new ILOpCodes.OpToken(xOpCodeVal, xOpPos, xPos + 4, ReadInt32(xIL, xPos), aMethod.Module, xTypeGenArgs, xMethodGenArgs, xCurrentHandler);
// xPos = xPos + 4;
// break;
// 32-bit metadata token.
case OperandType.InlineType:
throw new NotImplementedException();
//{
// var xValue = aMethod.Module.ResolveType((int)ReadInt32(xIL, xPos), xTypeGenArgs, xMethodGenArgs);
// xILOpCode = new ILOpCodes.OpType(xOpCodeVal, xOpPos, xPos + 4, xValue, xCurrentHandler);
// xPos = xPos + 4;
// break;
//}
case OperandType.ShortInlineVar:
switch (xOpCodeVal)
{
case OpCodeEnum.Ldloc_S:
xILOpCode = new Cil.InstructionLocal(Cil.InstructionKindEnum.Ldloc, xInstructionIndex, aMethodMeta.Body.LocalVariables[xIL[xPos]]);
break;
case OpCodeEnum.Ldloca_S:
xILOpCode = new Cil.InstructionLocal(Cil.InstructionKindEnum.Ldloca, xInstructionIndex, aMethodMeta.Body.LocalVariables[xIL[xPos]]);
break;
case OpCodeEnum.Ldarg_S:
xILOpCode = new Cil.InstructionArgument(Cil.InstructionKindEnum.Ldarg, xInstructionIndex, aMethodMeta.Parameters[xIL[xPos]]);
break;
case OpCodeEnum.Ldarga_S:
xILOpCode = new Cil.InstructionArgument(Cil.InstructionKindEnum.Ldarga, xInstructionIndex, aMethodMeta.Parameters[xIL[xPos]]);
break;
case OpCodeEnum.Starg_S:
xILOpCode = new Cil.InstructionArgument(Cil.InstructionKindEnum.Starg, xInstructionIndex, aMethodMeta.Parameters[xIL[xPos]]);
break;
case OpCodeEnum.Stloc_S:
xILOpCode = new Cil.InstructionLocal(Cil.InstructionKindEnum.Stloc, xInstructionIndex, aMethodMeta.Body.LocalVariables[xIL[xPos]]);
break;
default:
throw new NotImplementedException();
//xILOpCode = new ILOpCodes.OpVar(xOpCodeVal, xOpPos, xPos + 1, xIL[xPos], xCurrentHandler);
//break;
}
xPos = xPos + 1;
break;
case OperandType.InlineVar:
//xILOpCode = new ILOpCodes.OpVar(xOpCodeVal, xOpPos, xPos + 2, ReadUInt16(xIL, xPos), xCurrentHandler);
//xPos = xPos + 2;
throw new NotImplementedException();
break;
default:
throw new Exception("Unknown OperandType");
}
#endregion switch(xOpCode.OperandType)
xResult.Add(xILOpCode);
xInstructionIndex++;
}
foreach (var xAction in xInitSecondStage)
{
xAction();
}
return xResult;
}
static int GetILSize (MethodBase mi)
{
#if NET_2_0
MethodBody body = mi.GetMethodBody ();
if (body != null)
return body.GetILAsByteArray ().Length;
#endif
return 0;
}
public static IEnumerable<ILInstruction> GetInstructions(MethodBase methodBase)
{
MethodBody methodBody = methodBase.GetMethodBody();
byte[] bytes;
if (methodBody != null)
{
bytes = methodBody.GetILAsByteArray();
}
else
{
bytes = new byte[] { };
}
int offset = 0;
while (offset < bytes.Length)
{
ILInstruction instruction = new ILInstruction();
instruction.Offset = offset;
short code = (short)bytes[offset++];
if (code == 0xfe)
{
code = (short)(bytes[offset++] | 0xfe00);
}
instruction.OpCode = ILOpCodeTranslator.GetOpCode(code);
switch (instruction.OpCode.OperandType)
{
case OperandType.InlineBrTarget:
offset += 4;
break;
case OperandType.InlineField:
offset += 4;
break;
case OperandType.InlineI:
offset += 4;
break;
case OperandType.InlineI8:
offset += 8;
break;
case OperandType.InlineMethod:
int metaDataToken = bytes.GetInt32(offset);
Type[] genericMethodArguments = null;
if (methodBase.IsGenericMethod == true)
{
genericMethodArguments = methodBase.GetGenericArguments();
}
instruction.Data = methodBase.Module.ResolveMethod(metaDataToken, methodBase.DeclaringType.GetGenericArguments(), genericMethodArguments);
offset += 4;
break;
case OperandType.InlineNone:
break;
case OperandType.InlineR:
offset += 8;
break;
case OperandType.InlineSig:
offset += 4;
break;
case OperandType.InlineString:
offset += 4;
break;
case OperandType.InlineSwitch:
int count = bytes.GetInt32(offset) + 1;
offset += 4 * count;
break;
case OperandType.InlineTok:
offset += 4;
break;
case OperandType.InlineType:
offset += 4;
break;
case OperandType.InlineVar:
offset += 2;
break;
case OperandType.ShortInlineBrTarget:
offset += 1;
break;
case OperandType.ShortInlineI:
offset += 1;
break;
case OperandType.ShortInlineR:
offset += 4;
break;
case OperandType.ShortInlineVar:
offset += 1;
break;
default:
throw new NotImplementedException();
}
yield return instruction;
}
}
public override MethodBody GetMethodBody()
{
return(MethodBase.GetMethodBody(this.mhandle));
}
public MethodDetail(RootDetail parent, MethodBase mi)
: base(parent, mi)
{
CodeStringBuilder csb = new CodeStringBuilder(AppendMode.Text);
csb.AppendMethodName(mi);
_name = csb.ToString();
_visibility = VisibilityUtil.GetVisibilityFor(mi);
_category = "method";
MethodBody body = null;
try
{
body = mi.GetMethodBody();
}
catch (VerificationException)
{
// "Operation could destabilize the runtime" on .NET 3.0 WPF PresentationCore.dll
}
if (body != null)
{
_body = GenericUtility.GetILAsHashedText(mi);
}
csb = new CodeStringBuilder();
AppendAttributesDeclaration(csb);
MethodInfo bi = null;
if (mi is MethodInfo)
{
bi = ((MethodInfo)mi).GetBaseDefinition();
}
csb.Mode = AppendMode.Html;
csb.AppendVisibility(_visibility);
csb.AppendText(" ");
csb.Mode = AppendMode.Both;
if (mi.IsAbstract)
{
if (!mi.DeclaringType.IsInterface)
{
csb.AppendKeyword("abstract ");
}
}
else if (mi.IsVirtual && !mi.IsFinal)
{
if (!object.ReferenceEquals(mi, bi))
{
csb.AppendKeyword("override ");
}
else
{
csb.AppendKeyword("virtual ");
}
}
else if (mi.IsStatic)
{
csb.AppendKeyword("static ");
}
if (mi is MethodInfo)
{
csb.AppendParameter(((MethodInfo)mi).ReturnParameter);
}
csb.AppendText(" ");
csb.AppendText(_name);
csb.AppendText("(");
CodeStringBuilder csbParameters = new CodeStringBuilder(AppendMode.Text);
foreach (ParameterInfo pi in mi.GetParameters())
{
csb.AppendParameter(pi);
csb.AppendText(", ");
csbParameters.AppendParameterType(pi);
csbParameters.AppendText(", ");
_parameterCount++;
}
if (mi.GetParameters().Length > 0)
{
csb.RemoveCharsFromEnd(2);
csbParameters.RemoveCharsFromEnd(2);
}
csb.AppendText(")");
if (mi is MethodInfo)
{
csb.AppendGenericRestrictions(mi);
}
_declaration = csb.ToString();
_declarationHtml = csb.ToHtmlString();
_parameterTypesList = csbParameters.ToString();
}
private static bool ShouldMapBody(MethodBase method, MethodDefinition method_definition)
{
return method_definition.HasBody && method.GetMethodBody() != null;
}
MSILHandler(System.Reflection.MethodBase method)
{
_module = method.DeclaringType.Module;
_il = method.GetMethodBody().GetILAsByteArray();
}
public ILReader(MethodBase InputMethod, FieldInfo[] FieldsInModule, MethodBase[] MethodsInModule, Assembly currentAssm)
{
workingAssm = currentAssm;
MethodOpcodes = new ArrayList();
InputMeth = InputMethod;
ExceptionHandlers = new ArrayList();
if (InputMethod == null)
{
Console.WriteLine("Error, input method is not specified, can not continue");
return;
}
methodBody = InputMethod.GetMethodBody();
curModule = InputMethod.DeclaringType.Module;
pos = 0;
pos1 = 0;
IL = methodBody.GetILAsByteArray();
IList<ExceptionHandlingClause> ehClauses = methodBody.ExceptionHandlingClauses;
foreach( ExceptionHandlingClause ehclause in ehClauses )
{
ExceptionHandlers.Add(new ExceptionInstruction(ehclause.TryOffset,ExceptionHandler.Try,null));
switch (ehclause.Flags)
{
//case 0:
case ExceptionHandlingClauseOptions.Clause:
ExceptionHandlers.Add(new ExceptionInstruction(ehclause.HandlerOffset,ExceptionHandler.Catch,ehclause.CatchType));
ExceptionHandlers.Add(new ExceptionInstruction(ehclause.HandlerOffset+ehclause.HandlerLength,ExceptionHandler.EndException,null));
break;
//case 1:
case ExceptionHandlingClauseOptions.Filter:
ExceptionHandlers.Add(new ExceptionInstruction(ehclause.FilterOffset,ExceptionHandler.Filter,null));
ExceptionHandlers.Add(new ExceptionInstruction(ehclause.HandlerOffset,ExceptionHandler.EndFilter,null));
ExceptionHandlers.Add(new ExceptionInstruction(ehclause.HandlerOffset+ehclause.HandlerLength,ExceptionHandler.EndException,null));
break;
//case 2:
case ExceptionHandlingClauseOptions.Finally:
ExceptionHandlers.Add(new ExceptionInstruction(ehclause.HandlerOffset,ExceptionHandler.Finally,null));
ExceptionHandlers.Add(new ExceptionInstruction(ehclause.HandlerOffset+ehclause.HandlerLength,ExceptionHandler.EndException,null));
break;
//case 4:
case ExceptionHandlingClauseOptions.Fault:
ExceptionHandlers.Add(new ExceptionInstruction(ehclause.HandlerOffset,ExceptionHandler.Fault,null));
ExceptionHandlers.Add(new ExceptionInstruction(ehclause.HandlerOffset+ehclause.HandlerLength,ExceptionHandler.EndException,null));
break;
}
}
// populate opcode
Opcode Op = GetOpcode();
while (Op.Name != "") // This cycles through all the Opcodes
{
if (Op.Name != "stfld")
MethodOpcodes.Add(Op);
Op = GetOpcode();
}
// sort the stfld opcodes and output
// this will make the opcode invalid for run.
// but out purpose is simply compare the assemblies.
StfldList.Sort(new StringCompare());
foreach (object i in StfldList)
{
Opcode temp = new Opcode("stfld", i);
MakeLabel(temp, false);
MethodOpcodes.Add(temp);
}
}
public ILToken[] GetTokens(MethodBase method) {
this.method = method;
il = method.GetMethodBody().GetILAsByteArray();
ILToken[] ret = new ILToken[il.Length];
position = 0;
this.Module = method.Module;
while (position < il.Length) {
var opCode = byteCodes[il[position]];
var p = this.position;
if (opCode == OpCodes.Prefix1) {
opCode = shortCodes[512 + (short)((il[position] << 8) + il[position + 1])];
++position;
}
ret[p] = new ILToken(position, opCode.Size, opCode);
++this.position;
p = this.position;
if ((OpCodeValue)opCode.Value == OpCodeValue.Switch) {
var count = this.EatUInt32();
ret[p] = new ILToken(p, 4, count);
for (int i = 0; i < count; ++i) {
p = this.position;
ret[p] = new ILToken(p, 4, this.EatInt32());
}
} else
switch (opCode.OperandType) {
case OperandType.InlineBrTarget: ret[p] = new ILToken(p, 4, this.EatInt32()); break;
case OperandType.InlineField: ret[p] = new ILToken(p, 4, parseInlineField()); break;
case OperandType.InlineI: ret[p] = new ILToken(p, 4, this.EatInt32()); break;
//case OperandType.InlineI8:
// break;
case OperandType.InlineMethod: ret[p] = new ILToken(p, 4, parseInlineMethod()); break;
case OperandType.InlineNone: break;
//case OperandType.InlinePhi:
// break;
case OperandType.InlineR: ret[p] = new ILToken(p, 8, this.EatFloat64()); break;
//case OperandType.InlineSig:
// break;
case OperandType.InlineString: ret[p] = new ILToken(p, 4, parseInlineString()); break;
//case OperandType.InlineTok: ret[p] = new ILToken(p, 4, parseInlineTok()); break;
case OperandType.InlineType: ret[p] = new ILToken(p, 4, parseInlineType()); break;
//case OperandType.InlineVar:
case OperandType.ShortInlineBrTarget: ret[p] = new ILToken(p, 1, (sbyte)this.il[this.position++]); break;
case OperandType.ShortInlineI: ret[p] = new ILToken(p, 1, (sbyte)this.il[this.position++]); break;
case OperandType.ShortInlineR: ret[p] = new ILToken(p, 4, this.EatFloat32()); break;
case OperandType.ShortInlineVar: ret[p] = new ILToken(p, 1, this.il[this.position++]); break;
case OperandType.InlineSwitch: ret[p] = new ILToken(p, 4, this.EatInt32()); break;
default:
ThrowHelper.Method.Throw(this.method, this.position, "Not supported OperandType.{0}.", opCode.OperandType.ToString());
break;
}
}
return ret;
}
MethodBodyReader(MethodBase method)
{
this.method = method;
this.body = method.GetMethodBody();
if (this.body == null)
throw new ArgumentException();
var bytes = body.GetILAsByteArray();
if (bytes == null)
throw new ArgumentException();
if (!(method is ConstructorInfo))
method_arguments = method.GetGenericArguments();
if (method.DeclaringType != null)
type_arguments = method.DeclaringType.GetGenericArguments();
this.parameters = method.GetParameters();
this.locals = body.LocalVariables;
this.module = method.Module;
this.il = new ByteBuffer(bytes);
}
public static IList<Instruction> GetInstructions(MethodBase method)
{
var mb = method.GetMethodBody();
if (mb == null)
{
return new List<Instruction>();
}
var reader = new MethodBodyReader(method, mb);
reader.ReadInstructions();
return reader.instructions;
}
/// <summary>
/// Gets the IL byte array of the method.
/// </summary>
/// <param name="mb"></param>
/// <returns></returns>
public static byte[] GetMethodBody(MethodBase mb)
{
var emptyArray = new byte[0];
if (mb == null)
return emptyArray;
var body = mb.GetMethodBody();
return body == null ? emptyArray : body.GetILAsByteArray();
}
