static void ParseMethod(MethodDefinition method, IILVisitor visitor)
{
var context = CreateContext(method, visitor);
var code = context.Code;
var flags = code.ReadByte();
switch (flags & 0x3)
{
case 0x2: // tiny
int code_size = flags >> 2;
ParseCode(code_size, context);
break;
case 0x3: // fat
code.Advance(-1);
ParseFatMethod(context);
break;
default:
throw new NotSupportedException();
}
code.MoveBackTo(context.Position);
}
public static void Parse (MethodDefinition method, IILVisitor visitor)
{
if (method == null)
throw new ArgumentNullException ("method");
if (visitor == null)
throw new ArgumentNullException ("visitor");
if (!method.HasBody || !method.HasImage)
throw new ArgumentException ();
var context = CreateContext (method, visitor);
var code = context.Code;
code.MoveTo (method.RVA);
var flags = code.ReadByte ();
switch (flags & 0x3) {
case 0x2: // tiny
int code_size = flags >> 2;
ParseCode (code_size, context);
break;
case 0x3: // fat
code.position--;
ParseFatMethod (context);
break;
default:
throw new NotSupportedException ();
}
}
public static ForwardAnalysis <AbstractState, EdgeData> Make <Source, Dest, Context> (
IILDecoder <APC, Source, Dest, Context, EdgeData> decoder,
IAnalysis <APC, AbstractState, IILVisitor <APC, Source, Dest, AbstractState, AbstractState>, EdgeData> analysis)
where Context : IMethodContextProvider
{
IILVisitor <APC, Source, Dest, AbstractState, AbstractState> visitor = analysis.GetVisitor();
var forwardAnalysisSolver = new ForwardAnalysis <AbstractState, EdgeData> (
decoder.ContextProvider.MethodContext.CFG,
(pc, state) => decoder.ForwardDecode <AbstractState, AbstractState, IILVisitor <APC, Source, Dest, AbstractState, AbstractState> > (pc, visitor, state),
analysis.Join,
analysis.ImmutableVersion,
analysis.MutableVersion,
analysis.EdgeConversion,
decoder.EdgeData,
(pc, state) => {
if (!decoder.IsUnreachable(pc))
{
return(analysis.IsBottom(pc, state));
}
return(true);
},
analysis.Dump
);
analysis.SaveFixPointInfo(forwardAnalysisSolver);
return(forwardAnalysisSolver);
}
public static void Parse(MethodDefinition method, IILVisitor visitor)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
if (visitor == null)
{
throw new ArgumentNullException("visitor");
}
if (!method.HasBody || !method.HasImage)
{
throw new ArgumentException();
}
ILParser.ParseContext parseContext = ILParser.CreateContext(method, visitor);
CodeReader code = parseContext.Code;
code.MoveTo(method.RVA);
byte num = code.ReadByte();
int num1 = num & 3;
if (num1 == 2)
{
ILParser.ParseCode(num >> 2, parseContext);
return;
}
if (num1 != 3)
{
throw new NotSupportedException();
}
code.position--;
ILParser.ParseFatMethod(parseContext);
}
static ParseContext CreateContext (MethodDefinition method, IILVisitor visitor)
{
var code = method.Module.Read (method, (_, reader) => new CodeReader (reader.image.MetadataSection, reader));
return new ParseContext {
Code = code,
Metadata = code.reader,
Visitor = visitor,
};
}
static ParseContext CreateContext(MethodDefinition method, IILVisitor visitor)
{
var code = method.Module.Read(method, (_, reader) => new CodeReader(reader.image.MetadataSection, reader));
return(new ParseContext {
Code = code,
Metadata = code.reader,
Visitor = visitor,
});
}
private static ILParser.ParseContext CreateContext(MethodDefinition method, IILVisitor visitor)
{
CodeReader codeReader = method.Module.Read <MethodDefinition, CodeReader>(method, (MethodDefinition _, MetadataReader reader) => new CodeReader(reader.image.MetadataSection, reader));
return(new ILParser.ParseContext()
{
Code = codeReader,
Metadata = codeReader.reader,
Visitor = visitor
});
}
static ParseContext CreateContext(MethodDefinition method, IILVisitor visitor)
{
var code = method.Module.Read(method, (_, reader) => reader.code);
var position = code.MoveTo(method);
return(new ParseContext {
Code = code,
Position = position,
Metadata = code.reader,
Visitor = visitor,
});
}
public static void Parse(MethodDefinition method, IILVisitor visitor)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
if (visitor == null)
{
throw new ArgumentNullException("visitor");
}
if (!method.HasBody || !method.HasImage)
{
throw new ArgumentException();
}
method.Module.Read(method, (m, _) => {
ParseMethod(m, visitor);
return(true);
});
}
public static void Parse(MethodDefinition method, IILVisitor visitor)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
if (visitor == null)
{
throw new ArgumentNullException("visitor");
}
if (!method.HasBody || !method.HasImage)
{
throw new ArgumentException();
}
var context = CreateContext(method, visitor);
var code = context.Code;
code.MoveTo(method.RVA);
var flags = code.ReadByte();
switch (flags & 0x3)
{
case 0x2: // tiny
int code_size = flags >> 2;
ParseCode(code_size, context);
break;
case 0x3: // fat
code.position--;
ParseFatMethod(context);
break;
default:
throw new NotSupportedException();
}
}
static ParseContext CreateContext(MethodDefinition method, IILVisitor visitor)
{
var code = method.Module.Read (method, (_, reader) => reader.code);
code.MoveTo (method);
return new ParseContext {
Code = code,
Metadata = code.reader,
Visitor = visitor,
};
}
private static void ParseCode(int code_size, ILParser.ParseContext context)
{
CodeReader code = context.Code;
MetadataReader metadata = context.Metadata;
IILVisitor visitor = context.Visitor;
int codeSize = code.position + code_size;
while (code.position < codeSize)
{
byte num = code.ReadByte();
OpCode opCode = (num != 254 ? OpCodes.OneByteOpCode[num] : OpCodes.TwoBytesOpCode[code.ReadByte()]);
switch (opCode.OperandType)
{
case OperandType.InlineBrTarget:
{
visitor.OnInlineBranch(opCode, code.ReadInt32());
continue;
}
case OperandType.InlineField:
case OperandType.InlineMethod:
case OperandType.InlineTok:
case OperandType.InlineType:
{
IMetadataTokenProvider metadataTokenProvider = metadata.LookupToken(code.ReadToken());
Mono.Cecil.TokenType tokenType = metadataTokenProvider.MetadataToken.TokenType;
if (tokenType > Mono.Cecil.TokenType.Field)
{
if (tokenType > Mono.Cecil.TokenType.MemberRef)
{
if (tokenType == Mono.Cecil.TokenType.TypeSpec)
{
goto Label0;
}
if (tokenType != Mono.Cecil.TokenType.MethodSpec)
{
continue;
}
}
else if (tokenType != Mono.Cecil.TokenType.Method)
{
if (tokenType == Mono.Cecil.TokenType.MemberRef)
{
FieldReference fieldReference = metadataTokenProvider as FieldReference;
if (fieldReference == null)
{
MethodReference methodReference = metadataTokenProvider as MethodReference;
if (methodReference == null)
{
throw new InvalidOperationException();
}
visitor.OnInlineMethod(opCode, methodReference);
continue;
}
else
{
visitor.OnInlineField(opCode, fieldReference);
continue;
}
}
else
{
continue;
}
}
visitor.OnInlineMethod(opCode, (MethodReference)metadataTokenProvider);
continue;
}
else if (tokenType != Mono.Cecil.TokenType.TypeRef && tokenType != Mono.Cecil.TokenType.TypeDef)
{
if (tokenType == Mono.Cecil.TokenType.Field)
{
visitor.OnInlineField(opCode, (FieldReference)metadataTokenProvider);
continue;
}
else
{
continue;
}
}
Label0:
visitor.OnInlineType(opCode, (TypeReference)metadataTokenProvider);
continue;
}
case OperandType.InlineI:
{
visitor.OnInlineInt32(opCode, code.ReadInt32());
continue;
}
case OperandType.InlineI8:
{
visitor.OnInlineInt64(opCode, code.ReadInt64());
continue;
}
case OperandType.InlineNone:
{
visitor.OnInlineNone(opCode);
continue;
}
case OperandType.InlineR:
{
visitor.OnInlineDouble(opCode, code.ReadDouble());
continue;
}
case OperandType.InlineSig:
{
visitor.OnInlineSignature(opCode, code.GetCallSite(code.ReadToken()));
continue;
}
case OperandType.InlineString:
{
visitor.OnInlineString(opCode, code.GetString(code.ReadToken()));
continue;
}
case OperandType.InlineSwitch:
{
int num1 = code.ReadInt32();
int[] numArray = new int[num1];
for (int i = 0; i < num1; i++)
{
numArray[i] = code.ReadInt32();
}
visitor.OnInlineSwitch(opCode, numArray);
continue;
}
case OperandType.InlineVar:
{
visitor.OnInlineVariable(opCode, ILParser.GetVariable(context, code.ReadInt16()));
continue;
}
case OperandType.InlineArg:
{
visitor.OnInlineArgument(opCode, code.GetParameter(code.ReadInt16()));
continue;
}
case OperandType.ShortInlineBrTarget:
{
visitor.OnInlineBranch(opCode, code.ReadSByte());
continue;
}
case OperandType.ShortInlineI:
{
if (opCode != OpCodes.Ldc_I4_S)
{
visitor.OnInlineByte(opCode, code.ReadByte());
continue;
}
else
{
visitor.OnInlineSByte(opCode, code.ReadSByte());
continue;
}
}
case OperandType.ShortInlineR:
{
visitor.OnInlineSingle(opCode, code.ReadSingle());
continue;
}
case OperandType.ShortInlineVar:
{
visitor.OnInlineVariable(opCode, ILParser.GetVariable(context, (int)code.ReadByte()));
continue;
}
case OperandType.ShortInlineArg:
{
visitor.OnInlineArgument(opCode, code.GetParameter((int)code.ReadByte()));
continue;
}
default:
{
continue;
}
}
}
}
