/// <summary>
/// Dump the subset of methods common to both sides of the diff to the given dumper.
/// </summary>
/// <param name="dumper">Output dumper to use</param>
/// <param name="signatureFilter">Set of common signatures of methods to dump</param>
private void DumpCommonMethods(Dumper dumper, int moduleIndex, Dictionary <string, MethodPair> signatureFilter)
{
IEnumerable <ReadyToRunMethod> filteredMethods = TryGetMethods(dumper.Reader, moduleIndex)
.Where(method => signatureFilter.ContainsKey(method.SignatureString))
.OrderBy(method => method.SignatureString);
foreach (ReadyToRunMethod method in filteredMethods)
{
dumper.DumpMethod(method);
}
}
/// <summary>
/// Dump the subset of methods common to both sides of the diff to the given dumper.
/// </summary>
/// <param name="dumper">Output dumper to use</param>
/// <param name="signatureFilter">Set of common signatures of methods to dump</param>
private void DumpCommonMethods(Dumper dumper, HashSet <string> signatureFilter)
{
IEnumerable <ReadyToRunMethod> filteredMethods = dumper
.Reader
.Methods
.Where(method => signatureFilter.Contains(method.SignatureString))
.OrderBy(method => method.SignatureString);
foreach (ReadyToRunMethod method in filteredMethods)
{
dumper.DumpMethod(method);
}
}
/// <summary>
/// Dump the subset of methods common to both sides of the diff to the given dumper.
/// </summary>
/// <param name="dumper">Output dumper to use</param>
/// <param name="signatureFilter">Set of common signatures of methods to dump</param>
private void DumpCommonMethods(Dumper dumper, ReadyToRunSection section, Dictionary <string, MethodPair> signatureFilter)
{
if (!TryGetMethods(dumper.Reader, section, out IReadOnlyList <ReadyToRunMethod> sectionMethods))
{
IEnumerable <ReadyToRunMethod> filteredMethods = sectionMethods
.Where(method => signatureFilter.ContainsKey(method.SignatureString))
.OrderBy(method => method.SignatureString);
foreach (ReadyToRunMethod method in filteredMethods)
{
dumper.DumpMethod(method);
}
}
}
private int Run(string[] args)
{
ArgumentSyntax syntax = ParseCommandLine(args);
// open output stream
if (_outputFilename != null)
{
_writer = File.CreateText(_outputFilename);
}
else
{
_writer = Console.Out;
}
if (_help)
{
_writer.WriteLine(syntax.GetHelpText());
return(0);
}
if (_inputFilenames.Count == 0)
{
throw new ArgumentException("Input filename must be specified (--in <file>)");
}
try
{
foreach (string filename in _inputFilenames)
{
R2RReader r2r = new R2RReader(filename);
if (_disasm)
{
_disassembler = CoreDisTools.GetDisasm(r2r.Machine);
}
if (_xml)
{
_dumper = new XmlDumper(r2r, _writer, _raw, _header, _disasm, _disassembler, _unwind, _gc, _sectionContents);
}
else
{
_dumper = new TextDumper(r2r, _writer, _raw, _header, _disasm, _disassembler, _unwind, _gc, _sectionContents);
}
Dump(r2r);
if (_disasm)
{
CoreDisTools.FinishDisasm(_disassembler);
}
}
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.ToString());
return(1);
}
finally
{
// close output stream
_writer.Close();
}
return(0);
}
/// <summary>
/// Store the left and right file and output writer.
/// </summary>
/// <param name="leftDumper">Dumper to use for the left diff output</param>
/// <param name="rightDumper">Dumper to use for the right diff output</param>
/// <param name="writer">Writer to use for output common to left / right side</param>
public R2RDiff(Dumper leftDumper, Dumper rightDumper, TextWriter writer)
{
_leftDumper = leftDumper;
_rightDumper = rightDumper;
_writer = writer;
}
private int Run(string[] args)
{
ArgumentSyntax syntax = ParseCommandLine(args);
// open output stream
if (_outputFilename != null)
{
_writer = File.CreateText(_outputFilename);
}
else
{
_writer = Console.Out;
}
if (_help)
{
_writer.WriteLine(syntax.GetHelpText());
return(0);
}
Disassembler disassembler = null;
try
{
if (_inputFilenames.Count == 0)
{
throw new ArgumentException("Input filename must be specified (--in <file>)");
}
if (_diff && _inputFilenames.Count < 2)
{
throw new ArgumentException("Need at least 2 input files in diff mode");
}
R2RReader previousReader = null;
foreach (string filename in _inputFilenames)
{
// parse the ReadyToRun image
R2RReader r2r = new R2RReader(filename);
if (_disasm)
{
if (r2r.InputArchitectureSupported() && r2r.DisassemblerArchitectureSupported())
{
disassembler = new Disassembler(r2r.Image, r2r.Machine);
}
else
{
throw new ArgumentException($"The architecture of input file {filename} ({r2r.Machine.ToString()}) or the architecture of the disassembler tools ({System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture.ToString()}) is not supported.");
}
}
if (_xml)
{
_dumper = new XmlDumper(_ignoreSensitive, r2r, _writer, _raw, _header, _disasm, disassembler, _unwind, _gc, _sectionContents);
}
else
{
_dumper = new TextDumper(r2r, _writer, _raw, _header, _disasm, disassembler, _unwind, _gc, _sectionContents);
}
if (!_diff)
{
// output the ReadyToRun info
Dump(r2r);
}
else if (previousReader != null)
{
new R2RDiff(previousReader, r2r, _writer).Run();
}
previousReader = r2r;
}
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.ToString());
if (e is ArgumentException)
{
Console.WriteLine();
Console.WriteLine(syntax.GetHelpText());
}
if (_xml)
{
XmlDocument document = new XmlDocument();
XmlNode node = document.CreateNode("element", "Error", "");
node.InnerText = e.Message;
document.AppendChild(node);
if (_writer != null)
{
document.Save(_writer);
}
}
return(1);
}
finally
{
if (disassembler != null)
{
disassembler.Dispose();
}
// close output stream
_writer.Close();
}
return(0);
}
private int Run()
{
Disassembler disassembler = null;
try
{
if (_options.In == null || _options.In.Length == 0)
{
throw new ArgumentException("Input filename must be specified (--in <file>)");
}
if (_options.Diff && _options.In.Length < 2)
{
throw new ArgumentException("Need at least 2 input files in diff mode");
}
if (_options.Naked && _options.Raw)
{
throw new ArgumentException("The option '--naked' is incompatible with '--raw'");
}
Dumper previousDumper = null;
foreach (FileInfo filename in _options.In)
{
// parse the ReadyToRun image
ReadyToRunReader r2r = new ReadyToRunReader(_options, filename.FullName);
if (_options.Disasm)
{
if (r2r.InputArchitectureSupported() && r2r.DisassemblerArchitectureSupported())
{
disassembler = new Disassembler(r2r, _options);
}
else
{
throw new ArgumentException($"The architecture of input file {filename} ({r2r.Machine.ToString()}) or the architecture of the disassembler tools ({System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture.ToString()}) is not supported.");
}
}
if (!_options.Diff)
{
// output the ReadyToRun info
_dumper = new TextDumper(r2r, _writer, disassembler, _options);
Dump(r2r);
}
else
{
string perFileOutput = filename.FullName + ".common-methods.r2r";
_dumper = new TextDumper(r2r, new StreamWriter(perFileOutput, append: false, _encoding), disassembler, _options);
if (previousDumper != null)
{
new R2RDiff(previousDumper, _dumper, _writer).Run();
}
previousDumper?.Writer?.Flush();
previousDumper = _dumper;
}
}
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.ToString());
if (e is ArgumentException)
{
Console.WriteLine();
}
return(1);
}
finally
{
if (disassembler != null)
{
disassembler.Dispose();
}
// flush output stream
_dumper?.Writer?.Flush();
_writer?.Flush();
}
return(0);
}
private int Run(string[] args)
{
ArgumentSyntax syntax = ParseCommandLine(args);
// open output stream
if (_outputFilename != null)
{
_writer = File.CreateText(_outputFilename);
}
else
{
_writer = Console.Out;
}
if (_help)
{
_writer.WriteLine(syntax.GetHelpText());
return(0);
}
try
{
if (_inputFilenames.Count == 0)
{
throw new ArgumentException("Input filename must be specified (--in <file>)");
}
foreach (string filename in _inputFilenames)
{
R2RReader r2r = new R2RReader(filename);
if (_disasm)
{
_disassembler = CoreDisTools.GetDisasm(r2r.Machine);
}
if (_xml)
{
_dumper = new XmlDumper(_ignoreSensitive, r2r, _writer, _raw, _header, _disasm, _disassembler, _unwind, _gc, _sectionContents);
}
else
{
_dumper = new TextDumper(r2r, _writer, _raw, _header, _disasm, _disassembler, _unwind, _gc, _sectionContents);
}
Dump(r2r);
if (_disasm)
{
CoreDisTools.FinishDisasm(_disassembler);
}
}
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.ToString());
if (e is ArgumentException)
{
Console.WriteLine();
Console.WriteLine(syntax.GetHelpText());
}
if (_xml)
{
XmlDocument document = new XmlDocument();
XmlNode node = document.CreateNode("element", "Error", "");
node.InnerText = e.Message;
document.AppendChild(node);
if (_writer != null)
{
document.Save(_writer);
}
}
return(1);
}
finally
{
// close output stream
_writer.Close();
}
return(0);
}
private int Run()
{
Disassembler disassembler = null;
try
{
if (_options.In == null || _options.In.Length == 0)
{
throw new ArgumentException("Input filename must be specified (--in <file>)");
}
if (_options.Diff && _options.In.Length < 2)
{
throw new ArgumentException("Need at least 2 input files in diff mode");
}
if (_options.Naked && _options.Raw)
{
throw new ArgumentException("The option '--naked' is incompatible with '--raw'");
}
R2RReader previousReader = null;
foreach (FileInfo filename in _options.In)
{
// parse the ReadyToRun image
R2RReader r2r = new R2RReader(_options, filename.FullName);
if (_options.Disasm)
{
if (r2r.InputArchitectureSupported() && r2r.DisassemblerArchitectureSupported())
{
disassembler = new Disassembler(r2r, _options);
}
else
{
throw new ArgumentException($"The architecture of input file {filename} ({r2r.Machine.ToString()}) or the architecture of the disassembler tools ({System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture.ToString()}) is not supported.");
}
}
if (_options.Xml)
{
_dumper = new XmlDumper(_options.IgnoreSensitive, r2r, _writer, disassembler, _options);
}
else
{
_dumper = new TextDumper(r2r, _writer, disassembler, _options);
}
if (!_options.Diff)
{
// output the ReadyToRun info
Dump(r2r);
}
else if (previousReader != null)
{
new R2RDiff(previousReader, r2r, _writer).Run();
}
previousReader = r2r;
}
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.ToString());
if (e is ArgumentException)
{
Console.WriteLine();
}
if (_options.Xml)
{
XmlDocument document = new XmlDocument();
XmlNode node = document.CreateNode("element", "Error", "");
node.InnerText = e.Message;
document.AppendChild(node);
if (_writer != null)
{
document.Save(_writer);
}
}
return(1);
}
finally
{
if (disassembler != null)
{
disassembler.Dispose();
}
// close output stream
_writer.Close();
}
return(0);
}
private int Run(string[] args)
{
ArgumentSyntax syntax = ParseCommandLine(args);
// open output stream
if (_outputFilename != null)
{
_writer = File.CreateText(_outputFilename);
}
else
{
_writer = Console.Out;
}
if (_help)
{
_writer.WriteLine(syntax.GetHelpText());
return(0);
}
Disassembler disassembler = null;
try
{
if (_inputFilenames.Count == 0)
{
throw new ArgumentException("Input filename must be specified (--in <file>)");
}
if (_diff && _inputFilenames.Count < 2)
{
throw new ArgumentException("Need at least 2 input files in diff mode");
}
R2RReader previousReader = null;
foreach (string filename in _inputFilenames)
{
// parse the ReadyToRun image
R2RReader r2r = new R2RReader(filename);
if (_disasm)
{
// TODO: Fix R2RDump issue where an x64 R2R image cannot be dissassembled with the x86 CoreDisTools
// For the short term, we want to error out with a decent message explaining the unexpected error
// Issue #19564: https://github.com/dotnet/coreclr/issues/19564
if (r2r.InputArchitectureMatchesDisassemblerArchitecture())
{
disassembler = new Disassembler(r2r.Image, r2r.Machine);
}
else
{
throw new ArgumentException($"The architecture of input file {filename} is {r2r.Machine.ToString()} and does not match the architecture of the disassembler tools {System.Runtime.InteropServices.RuntimeInformation.ProcessArchitecture.ToString()}");
}
}
if (_xml)
{
_dumper = new XmlDumper(_ignoreSensitive, r2r, _writer, _raw, _header, _disasm, disassembler, _unwind, _gc, _sectionContents);
}
else
{
_dumper = new TextDumper(r2r, _writer, _raw, _header, _disasm, disassembler, _unwind, _gc, _sectionContents);
}
if (!_diff)
{
// output the ReadyToRun info
Dump(r2r);
}
else if (previousReader != null)
{
new R2RDiff(previousReader, r2r, _writer).Run();
}
previousReader = r2r;
}
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.ToString());
if (e is ArgumentException)
{
Console.WriteLine();
Console.WriteLine(syntax.GetHelpText());
}
if (_xml)
{
XmlDocument document = new XmlDocument();
XmlNode node = document.CreateNode("element", "Error", "");
node.InnerText = e.Message;
document.AppendChild(node);
if (_writer != null)
{
document.Save(_writer);
}
}
return(1);
}
finally
{
if (disassembler != null)
{
disassembler.Dispose();
}
// close output stream
_writer.Close();
}
return(0);
}