private void WriteOpCode(ILOpCode opCode)
{
var opCodeInfo = new OpCodeInfo(opCode, opCode.GetDisplayName());
string index;
switch (opCode)
{
case ILOpCode.Ldarg_0:
case ILOpCode.Ldarg_1:
case ILOpCode.Ldarg_2:
case ILOpCode.Ldarg_3:
output.WriteReference(opCodeInfo, omitSuffix: true);
index = opCodeInfo.Name.Substring(6);
output.WriteLocalReference(index, "param_" + index);
break;
case ILOpCode.Ldloc_0:
case ILOpCode.Ldloc_1:
case ILOpCode.Ldloc_2:
case ILOpCode.Ldloc_3:
case ILOpCode.Stloc_0:
case ILOpCode.Stloc_1:
case ILOpCode.Stloc_2:
case ILOpCode.Stloc_3:
output.WriteReference(opCodeInfo, omitSuffix: true);
index = opCodeInfo.Name.Substring(6);
output.WriteLocalReference(index, "loc_" + index);
break;
default:
output.WriteReference(opCodeInfo);
break;
}
}
public void WriteReference(Disassembler.OpCodeInfo opCode, bool omitSuffix = false)
{
if (omitSuffix)
{
int lastDot = opCode.Name.LastIndexOf('.');
if (lastDot > 0)
{
Write(opCode.Name.Remove(lastDot + 1));
}
}
else
{
Write(opCode.Name);
}
}
public ILStructure(MethodBody body)
: this(ILStructureType.Root, 0, body.CodeSize)
{
// Build the tree of exception structures:
foreach (ExceptionHandler eh in body.ExceptionHandlers)
{
AddNestedStructure(new ILStructure(ILStructureType.Try, eh.TryStart.Offset, eh.TryEnd.Offset, eh));
if (eh.HandlerType == ExceptionHandlerType.Filter)
{
AddNestedStructure(new ILStructure(ILStructureType.Filter, eh.FilterStart.Offset, eh.HandlerStart.Offset, eh));
}
AddNestedStructure(new ILStructure(ILStructureType.Handler, eh.HandlerStart.Offset, eh.HandlerEnd == null ? body.CodeSize : eh.HandlerEnd.Offset, eh));
}
// Very simple loop detection: look for backward branches
List <KeyValuePair <Instruction, Instruction> > allBranches = FindAllBranches(body);
// We go through the branches in reverse so that we find the biggest possible loop boundary first (think loops with "continue;")
for (int i = allBranches.Count - 1; i >= 0; i--)
{
int loopEnd = allBranches[i].Key.GetEndOffset();
int loopStart = allBranches[i].Value.Offset;
if (loopStart < loopEnd)
{
// We found a backward branch. This is a potential loop.
// Check that is has only one entry point:
Instruction entryPoint = null;
// entry point is first instruction in loop if prev inst isn't an unconditional branch
Instruction prev = allBranches[i].Value.Previous;
if (prev != null && !OpCodeInfo.IsUnconditionalBranch(prev.OpCode))
{
entryPoint = allBranches[i].Value;
}
bool multipleEntryPoints = false;
foreach (var pair in allBranches)
{
if (pair.Key.Offset < loopStart || pair.Key.Offset >= loopEnd)
{
if (loopStart <= pair.Value.Offset && pair.Value.Offset < loopEnd)
{
// jump from outside the loop into the loop
if (entryPoint == null)
{
entryPoint = pair.Value;
}
else if (pair.Value != entryPoint)
{
multipleEntryPoints = true;
}
}
}
}
if (!multipleEntryPoints)
{
AddNestedStructure(new ILStructure(ILStructureType.Loop, loopStart, loopEnd, entryPoint));
}
}
}
SortChildren();
}
public IlStructure(MethodBody body, int codesize) : this(IlStructureType.Root, 0, codesize)
{
// Build the tree of exception structures:
for (var i = 0; i < body.ExceptionHandlers.Count; i++)
{
var eh = body.ExceptionHandlers[i];
if (!body.ExceptionHandlers.Take(i).Any(oldEh => oldEh.TryStart == eh.TryStart && oldEh.TryEnd == eh.TryEnd))
{
AddNestedStructure(new IlStructure(IlStructureType.Try, eh.TryStart.Offset, eh.TryEnd.Offset, eh));
}
if (eh.HandlerType == ExceptionHandlerType.Filter)
{
AddNestedStructure(new IlStructure(IlStructureType.Filter, eh.FilterStart.Offset, eh.HandlerStart.Offset, eh));
}
AddNestedStructure(new IlStructure(IlStructureType.Handler, eh.HandlerStart.Offset, eh.HandlerEnd?.Offset ?? codesize, eh));
}
// Very simple loop detection: look for backward branches
var allBranches = FindAllBranches(body);
// We go through the branches in reverse so that we find the biggest possible loop boundary first (think loops with "continue;")
for (var i = allBranches.Count - 1; i >= 0; i--)
{
var loopEnd = allBranches[i].Key.Offset + allBranches[i].Key.GetSize();
var loopStart = allBranches[i].Value.Offset;
if (loopStart >= loopEnd)
{
continue;
}
// We found a backward branch. This is a potential loop.
// Check that is has only one entry point:
Instruction entryPoint = null;
// entry point is first instruction in loop if prev inst isn't an unconditional branch
var prev = allBranches[i].Value.Previous;
if (prev != null && !OpCodeInfo.IsUnconditionalBranch(prev.OpCode))
{
entryPoint = allBranches[i].Value;
}
var multipleEntryPoints = false;
foreach (var pair in allBranches)
{
if (pair.Key.Offset >= loopStart && pair.Key.Offset < loopEnd)
{
continue;
}
if (loopStart > pair.Value.Offset || pair.Value.Offset >= loopEnd)
{
continue;
}
// jump from outside the loop into the loop
if (entryPoint == null)
{
entryPoint = pair.Value;
}
else if (pair.Value != entryPoint)
{
multipleEntryPoints = true;
}
}
if (!multipleEntryPoints)
{
AddNestedStructure(new IlStructure(IlStructureType.Loop, loopStart, loopEnd, entryPoint));
}
}
SortChildren();
}
public void WriteReference(Disassembler.OpCodeInfo opCode)
{
Write(opCode.Name);
}
