private static async Task <int> Execute(string assemblyPath, string namespaceFilter)
{
var disassembler = new DisassemblerSession();
var disassembly = await disassembler.LoadAsync(assemblyPath);
var types = disassembly.Types;
if (!string.IsNullOrEmpty(namespaceFilter))
{
var ns = disassembly.Namespaces.FirstOrDefault(n =>
{
var candidateName = n.Name ?? "<Default>";
return(candidateName.Equals(namespaceFilter, StringComparison.OrdinalIgnoreCase));
});
if (ns == null)
{
return(Error($"namespace does not exist: {namespaceFilter}"));
}
types = ns.Types;
}
foreach (var type in types)
{
Console.WriteLine($"* {type.FullName}");
}
return(0);
}
private static async Task <int> Execute(string assemblyPath, string typeName, string memberName)
{
var console = new IndentingWriter(Console.Out);
var disassembler = new DisassemblerSession();
var disassembly = await disassembler.LoadAsync(assemblyPath);
var type = disassembly.FindType(typeName);
if (type == null)
{
return(Error($"could not find type: {typeName}"));
}
var member = type.Members.FirstOrDefault(t => t.Name.Equals(memberName));
if (member == null)
{
return(Error($"could not find member: {memberName} in type {typeName}"));
}
if (member.MemberType == MemberType.Method)
{
var method = (MethodDefinition)member.Definition;
CILDisassembler.DisassembleMethod(method, console);
}
else
{
return(Error($"Member type not supported: {member.MemberType}"));
}
return(0);
}
private static async Task <int> Execute(string assemblyPath)
{
var disassembler = new DisassemblerSession();
var disassembly = await disassembler.LoadAsync(assemblyPath);
foreach (var ns in disassembly.Namespaces)
{
Console.WriteLine($"* {ns.Name ?? "<Default>"}");
}
return(0);
}
private static async Task <int> Execute(string assemblyPath, string typeName)
{
var disassembler = new DisassemblerSession();
var disassembly = await disassembler.LoadAsync(assemblyPath);
var type = disassembly.FindType(typeName);
if (type == null)
{
return(Error($"could not find type: {typeName}"));
}
foreach (var member in type.Members)
{
Console.WriteLine($"* [{member.MemberType}] {member.Name}");
}
return(0);
}
private static async Task <int> Execute(string assemblyPath, string typeName, string memberName, string outFile, string format)
{
var disassembler = new DisassemblerSession();
var disassembly = await disassembler.LoadAsync(assemblyPath);
var type = disassembly.FindType(typeName);
if (type == null)
{
return(Error($"could not find type: {typeName}"));
}
var member = type.Members.FirstOrDefault(t => t.Name.Equals(memberName));
if (member == null)
{
return(Error($"could not find member: {memberName} in type {typeName}"));
}
ControlFlowGraph graph = null;
if (member.MemberType == MemberType.Method)
{
graph = ControlFlowGraphBuilder.Build(((MethodDefinition)member.Definition).Body);
}
else
{
return(Error($"Member type not supported: {member.MemberType}"));
}
if (!string.IsNullOrEmpty(outFile))
{
format = string.IsNullOrEmpty(format) ? "dot" : format;
if (!Formats.TryGetValue(format, out var handler))
{
return(Error($"Unknown format: {format}"));
}
await handler(graph, outFile);
}
else
{
Console.WriteLine($"Control flow graph for {typeName}.{memberName}");
foreach (var node in graph.Nodes)
{
Console.WriteLine();
Console.WriteLine(node.ToString());
}
// Write Exception handlers
foreach (var handler in graph.ExceptionHandlers)
{
Console.WriteLine();
Console.WriteLine(" .try {");
Console.WriteLine($" IL_{handler.TryStart.Offset:X4} -> IL_{handler.TryEnd.Offset:X4}");
Console.WriteLine(" }");
Console.WriteLine($" {FormatHandlerType(handler)} {{");
if (handler.HandlerType == ExceptionHandlerType.Filter)
{
Console.WriteLine($" IL_{handler.FilterStart.Offset:X4} -> IL_{handler.HandlerStart.Offset:X4}");
Console.WriteLine(" }");
Console.WriteLine(" .catch {");
}
Console.WriteLine($" IL_{handler.HandlerStart.Offset:X4} -> IL_{handler.HandlerEnd.Offset:X4}");
Console.WriteLine(" }");
}
}
Console.WriteLine();
return(0);
}
private static async Task <int> Execute(string assemblyPath, string typeName, string memberName)
{
var disassembler = new DisassemblerSession();
var disassembly = await disassembler.LoadAsync(assemblyPath);
var type = disassembly.FindType(typeName);
if (type == null)
{
return(Error($"could not find type: {typeName}"));
}
var member = type.Members.FirstOrDefault(t => t.Name.Equals(memberName));
if (member == null)
{
return(Error($"could not find member: {memberName} in type {typeName}"));
}
ControlFlowGraph graph = null;
MethodDefinition method = null;
if (member.MemberType == MemberType.Method)
{
method = (MethodDefinition)member.Definition;
graph = ControlFlowGraphBuilder.Build(method.Body);
}
else
{
return(Error($"Member type not supported: {member.MemberType}"));
}
var syntax = SyntaxGraphBuilder.Create(graph, method);
var arguments = string.Join(", ", method.Parameters.Select(p => $"{p.ParameterType.FullName} {p.Name}"));
Console.WriteLine($"Syntax analysis for {typeName}.{memberName}({arguments})");
if (method.Body.Variables.Any())
{
Console.WriteLine();
foreach (var local in method.Body.Variables)
{
Console.WriteLine($" .local {local.VariableType.FullName} _{local.Index}");
}
}
foreach (var node in syntax.Nodes)
{
Console.WriteLine();
Console.WriteLine($" {node.DisplayName} : {{");
foreach (var statement in node.Statements)
{
Console.WriteLine($" {statement}");
}
Console.WriteLine($" }}{FormatLinks(node)}");
}
Console.WriteLine();
return(0);
}
