void ITextOutput.AddDebugSymbols(MethodDebugSymbols methodDebugSymbols)
{
}
public void AddDebugSymbols(MethodDebugSymbols methodDebugSymbols)
{
DebuggerMemberMappings.Add(methodDebugSymbols);
}
public void AddDebugSymbols(MethodDebugSymbols methodDebugSymbols)
{
}
public void Disassemble(MethodBody body, MethodDebugSymbols debugSymbols)
{
// start writing IL code
MethodDefinition method = body.Method;
output.WriteLine("// Method begins at RVA 0x{0:x4}", method.RVA);
output.WriteLine("// Code size {0} (0x{0:x})", body.CodeSize);
output.WriteLine(".maxstack {0}", body.MaxStackSize);
if (method.DeclaringType.Module.Assembly != null && method.DeclaringType.Module.Assembly.EntryPoint == method)
{
output.WriteLine(".entrypoint");
}
if (method.Body.HasVariables)
{
output.Write(".locals ");
if (method.Body.InitLocals)
{
output.Write("init ");
}
output.WriteLine("(");
output.Indent();
foreach (var v in method.Body.Variables)
{
output.WriteDefinition("[" + v.Index + "] ", v);
v.VariableType.WriteTo(output);
if (!string.IsNullOrEmpty(v.Name))
{
output.Write(' ');
output.Write(DisassemblerHelpers.Escape(v.Name));
}
if (v.Index + 1 < method.Body.Variables.Count)
{
output.Write(',');
}
output.WriteLine();
}
output.Unindent();
output.WriteLine(")");
}
output.WriteLine();
if (detectControlStructure && body.Instructions.Count > 0)
{
Instruction inst = body.Instructions[0];
HashSet <int> branchTargets = GetBranchTargets(body.Instructions);
WriteStructureBody(new ILStructure(body), branchTargets, ref inst, debugSymbols, method.Body.CodeSize);
}
else
{
foreach (var inst in method.Body.Instructions)
{
var startLocation = output.Location;
inst.WriteTo(output);
if (debugSymbols != null)
{
// add IL code mappings - used in debugger
debugSymbols.SequencePoints.Add(
new SequencePoint()
{
StartLocation = output.Location,
EndLocation = output.Location,
ILRanges = new ILRange[] { new ILRange(inst.Offset, inst.Next == null ? method.Body.CodeSize : inst.Next.Offset) }
});
}
output.WriteLine();
}
if (method.Body.HasExceptionHandlers)
{
output.WriteLine();
foreach (var eh in method.Body.ExceptionHandlers)
{
eh.WriteTo(output);
output.WriteLine();
}
}
}
}
private void WriteStructureBody(ILStructure s, HashSet <int> branchTargets, ref Instruction inst, MethodDebugSymbols debugSymbols, int codeSize)
{
bool isFirstInstructionInStructure = true;
bool prevInstructionWasBranch = false;
int childIndex = 0;
while (inst != null && inst.Offset < s.EndOffset)
{
int offset = inst.Offset;
if (childIndex < s.Children.Count && s.Children[childIndex].StartOffset <= offset && offset < s.Children[childIndex].EndOffset)
{
ILStructure child = s.Children[childIndex++];
WriteStructureHeader(child);
WriteStructureBody(child, branchTargets, ref inst, debugSymbols, codeSize);
WriteStructureFooter(child);
}
else
{
if (!isFirstInstructionInStructure && (prevInstructionWasBranch || branchTargets.Contains(offset)))
{
output.WriteLine(); // put an empty line after branches, and in front of branch targets
}
var startLocation = output.Location;
inst.WriteTo(output);
// add IL code mappings - used in debugger
if (debugSymbols != null)
{
debugSymbols.SequencePoints.Add(
new SequencePoint()
{
StartLocation = startLocation,
EndLocation = output.Location,
ILRanges = new ILRange[] { new ILRange(inst.Offset, inst.Next == null ? codeSize : inst.Next.Offset) }
});
}
output.WriteLine();
prevInstructionWasBranch = inst.OpCode.FlowControl == FlowControl.Branch ||
inst.OpCode.FlowControl == FlowControl.Cond_Branch ||
inst.OpCode.FlowControl == FlowControl.Return ||
inst.OpCode.FlowControl == FlowControl.Throw;
inst = inst.Next;
}
isFirstInstructionInStructure = false;
}
}
public void AddDebugSymbols(MethodDebugSymbols methodDebugSymbols)
{
_wrapped.AddDebugSymbols(methodDebugSymbols);
}
