public XmlDumper(R2RReader r2r, TextWriter writer, bool raw, bool header, bool disasm, IntPtr disassembler, bool unwind, bool gc, bool sectionContents)
{
_r2r = r2r;
_writer = writer;
_xmlDocument = new XmlDocument();
_raw = raw;
_header = header;
_disasm = disasm;
_disassembler = disassembler;
_unwind = unwind;
_gc = gc;
_sectionContents = sectionContents;
}
/// <summary>
/// Returns the runtime function with id matching <param>rtfQuery</param>
/// </summary>
/// <param name="r2r">Contains all extracted info about the ReadyToRun image</param>
/// <param name="rtfQuery">The name or value to search for</param>
public RuntimeFunction FindRuntimeFunction(R2RReader r2r, int rtfQuery)
{
foreach (R2RMethod m in r2r.R2RMethods)
{
foreach (RuntimeFunction rtf in m.RuntimeFunctions)
{
if (rtf.Id == rtfQuery || (rtf.StartAddress >= rtfQuery && rtf.StartAddress + rtf.Size < rtfQuery))
{
return(rtf);
}
}
}
return(null);
}
/// <summary>
/// Read the EH clause from a given file offset in the PE image.
/// </summary>
/// <param name="reader">R2R image reader<param>
/// <param name="offset">Offset of the EH clause in the image</param>
public EHClause(R2RReader reader, int offset)
{
Flags = (CorExceptionFlag)BitConverter.ToUInt32(reader.Image, offset + 0 * sizeof(uint));
TryOffset = BitConverter.ToUInt32(reader.Image, offset + 1 * sizeof(uint));
TryEnd = BitConverter.ToUInt32(reader.Image, offset + 2 * sizeof(uint));
HandlerOffset = BitConverter.ToUInt32(reader.Image, offset + 3 * sizeof(uint));
HandlerEnd = BitConverter.ToUInt32(reader.Image, offset + 4 * sizeof(uint));
ClassTokenOrFilterOffset = BitConverter.ToUInt32(reader.Image, offset + 5 * sizeof(uint));
if ((Flags & CorExceptionFlag.COR_ILEXCEPTION_CLAUSE_KIND_MASK) == CorExceptionFlag.COR_ILEXCEPTION_CLAUSE_NONE)
{
ClassName = MetadataNameFormatter.FormatHandle(reader.MetadataReader, MetadataTokens.Handle((int)ClassTokenOrFilterOffset));
}
}
/// <summary>
/// Extracts the method signature from the metadata by rid
/// </summary>
public R2RMethod(int index, MetadataReader mdReader, uint rid, int entryPointId, GenericElementTypes[] instanceArgs, uint[] tok, FixupCell[] fixups)
{
Index = index;
Token = _mdtMethodDef | rid;
Rid = rid;
EntryPointRuntimeFunctionId = entryPointId;
_mdReader = mdReader;
RuntimeFunctions = new List <RuntimeFunction>();
// get the method signature from the MethodDefhandle
MethodDefinitionHandle methodDefHandle = MetadataTokens.MethodDefinitionHandle((int)rid);
_methodDef = mdReader.GetMethodDefinition(methodDefHandle);
Name = mdReader.GetString(_methodDef.Name);
BlobReader signatureReader = mdReader.GetBlobReader(_methodDef.Signature);
TypeDefinitionHandle declaringTypeHandle = _methodDef.GetDeclaringType();
DeclaringType = R2RReader.GetTypeDefFullName(mdReader, declaringTypeHandle);
SignatureHeader signatureHeader = signatureReader.ReadSignatureHeader();
IsGeneric = signatureHeader.IsGeneric;
GenericParameterHandleCollection genericParams = _methodDef.GetGenericParameters();
_genericParamInstanceMap = new Dictionary <string, string>();
int argCount = signatureReader.ReadCompressedInteger();
if (IsGeneric)
{
argCount = signatureReader.ReadCompressedInteger();
}
Fixups = fixups;
DisassemblingTypeProvider provider = new DisassemblingTypeProvider();
if (IsGeneric && instanceArgs != null && tok != null)
{
InitGenericInstances(genericParams, instanceArgs, tok);
}
DisassemblingGenericContext genericContext = new DisassemblingGenericContext(new string[0], _genericParamInstanceMap.Values.ToArray());
Signature = _methodDef.DecodeSignature(provider, genericContext);
SignatureString = GetSignature();
}
/// <summary>
/// Dumps one R2RSection
/// </summary>
private void DumpSection(R2RReader r2r, R2RSection section)
{
WriteSubDivider();
_writer.WriteLine(section.ToString());
if (_raw)
{
DumpBytes(r2r, section.RelativeVirtualAddress, (uint)section.Size);
_writer.WriteLine();
}
if (_sectionContents)
{
DumpSectionContents(r2r, section);
_writer.WriteLine();
}
}
// <summary>
/// For each query in the list of queries, search for all sections by the name or value of the ReadyToRunSectionType enum
/// </summary>
/// <param name="r2r">Contains all the extracted info about the ReadyToRun image</param>
/// <param name="queries">The names/values to search for</param>
private void QuerySection(R2RReader r2r, IReadOnlyList <string> queries)
{
if (queries.Count > 0)
{
_dumper.WriteDivider("R2R Section");
}
foreach (string q in queries)
{
IList <R2RSection> res = FindSection(r2r, q);
XmlNode queryNode = _dumper.DumpQueryCount(q, "Sections", res.Count);
foreach (R2RSection section in res)
{
_dumper.DumpSection(section, queryNode);
}
}
}
// <summary>
/// For each query in the list of queries, search for all methods matching the query by name, signature or id
/// </summary>
/// <param name="r2r">Contains all the extracted info about the ReadyToRun image</param>
/// <param name="title">The title to print, "R2R Methods by Query" or "R2R Methods by Keyword"</param>
/// <param name="queries">The keywords/ids to search for</param>
/// <param name="exact">Specifies whether to look for methods with names/signatures/ids matching the method exactly or partially</param>
private void QueryMethod(R2RReader r2r, string title, IReadOnlyList <string> queries, bool exact)
{
if (queries.Count > 0)
{
_dumper.WriteDivider(title);
}
foreach (string q in queries)
{
IList <R2RMethod> res = FindMethod(r2r, q, exact);
XmlNode queryNode = _dumper.DumpQueryCount(q, "Methods", res.Count);
foreach (R2RMethod method in res)
{
_dumper.DumpMethod(method, queryNode);
}
}
}
/// <summary>
/// Dumps the R2RHeader and all the sections in the header
/// </summary>
private void DumpHeader(R2RReader r2r, bool dumpSections)
{
_writer.WriteLine(r2r.R2RHeader.ToString());
if (_raw)
{
DumpBytes(r2r, r2r.R2RHeader.RelativeVirtualAddress, (uint)r2r.R2RHeader.Size);
}
if (dumpSections)
{
WriteDivider("R2R Sections");
foreach (R2RSection section in r2r.R2RHeader.Sections.Values)
{
DumpSection(r2r, section);
}
}
}
private int Run(string[] args)
{
ArgumentSyntax syntax = ParseCommandLine(args);
if (_help)
{
_writer.WriteLine(syntax.GetHelpText());
return(0);
}
if (_inputFilenames.Count == 0)
{
throw new ArgumentException("Input filename must be specified (--in <file>)");
}
// open output stream
if (_outputFilename != null)
{
_writer = File.CreateText(_outputFilename);
}
else
{
_writer = Console.Out;
}
try
{
foreach (string filename in _inputFilenames)
{
R2RReader r2r = new R2RReader(filename);
Dump(r2r);
}
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.ToString());
return(1);
}
finally
{
// close output stream
_writer.Close();
}
return(0);
}
/// <summary>
/// Dumps one runtime function.
/// </summary>
private void DumpRuntimeFunction(R2RReader r2r, RuntimeFunction rtf)
{
if (_disasm)
{
_writer.WriteLine($"Id: {rtf.Id}");
CoreDisTools.DumpCodeBlock(_disassembler, rtf.StartAddress, r2r.GetOffset(rtf.StartAddress), r2r.Image, rtf.Size);
}
else
{
_writer.Write($"{rtf}");
}
if (_raw)
{
DumpBytes(r2r, rtf.StartAddress, (uint)rtf.Size);
}
_writer.WriteLine();
}
// <summary>
/// For each query in the list of queries, search for all methods matching the query by name, signature or id
/// </summary>
/// <param name="r2r">Contains all the extracted info about the ReadyToRun image</param>
/// <param name="title">The title to print, "R2R Methods by Query" or "R2R Methods by Keyword"</param>
/// <param name="queries">The keywords/ids to search for</param>
/// <param name="exact">Specifies whether to look for methods with names/signatures/ids matching the method exactly or partially</param>
private void QueryMethod(R2RReader r2r, string title, IReadOnlyList <string> queries, bool exact)
{
if (queries.Count > 0)
{
WriteDivider(title);
}
foreach (string q in queries)
{
IList <R2RMethod> res = FindMethod(r2r, q, exact);
_writer.WriteLine(res.Count + " result(s) for \"" + q + "\"");
_writer.WriteLine();
foreach (R2RMethod method in res)
{
DumpMethod(r2r, method);
}
}
}
// <summary>
/// For each query in the list of queries, search for all sections by the name or value of the ReadyToRunSectionType enum
/// </summary>
/// <param name="r2r">Contains all the extracted info about the ReadyToRun image</param>
/// <param name="queries">The names/values to search for</param>
private void QuerySection(R2RReader r2r, IReadOnlyList <string> queries)
{
if (queries.Count > 0)
{
WriteDivider("R2R Section");
}
foreach (string q in queries)
{
IList <R2RSection> res = FindSection(r2r, q);
_writer.WriteLine(res.Count + " result(s) for \"" + q + "\"");
_writer.WriteLine();
foreach (R2RSection section in res)
{
DumpSection(r2r, section);
}
}
}
/// <summary>
/// Outputs specified headers, sections, methods or runtime functions for one ReadyToRun image
/// </summary>
/// <param name="r2r">The structure containing the info of the ReadyToRun image</param>
public void Dump(R2RReader r2r)
{
_writer.WriteLine($"Filename: {r2r.Filename}");
_writer.WriteLine($"Machine: {r2r.Machine}");
_writer.WriteLine($"ImageBase: 0x{r2r.ImageBase:X8}");
_writer.WriteLine();
if (_queries.Count == 0 && _keywords.Count == 0 && _runtimeFunctions.Count == 0 && _sections.Count == 0) //dump all sections and methods
{
WriteDivider("R2R Header");
DumpHeader(r2r, true);
if (!_header)
{
WriteDivider("R2R Methods");
_writer.WriteLine($"{r2r.R2RMethods.Count} methods");
_writer.WriteLine();
foreach (R2RMethod method in r2r.R2RMethods)
{
DumpMethod(r2r, method);
}
}
}
else //dump queried sections/methods/runtimeFunctions
{
if (_header)
{
DumpHeader(r2r, false);
}
QuerySection(r2r, _sections);
QueryRuntimeFunction(r2r, _runtimeFunctions);
QueryMethod(r2r, "R2R Methods by Query", _queries, true);
QueryMethod(r2r, "R2R Methods by Keyword", _keywords, false);
}
if (_types)
{
DumpAvailableTypes(r2r);
}
_writer.WriteLine("=============================================================");
_writer.WriteLine();
}
// <summary>
/// For each query in the list of queries, search for a runtime function by id.
/// The method containing the runtime function gets outputted, along with the single runtime function that was searched
/// </summary>
/// <param name="r2r">Contains all the extracted info about the ReadyToRun image</param>
/// <param name="queries">The ids to search for</param>
private void QueryRuntimeFunction(R2RReader r2r, IReadOnlyList <int> queries)
{
if (queries.Count > 0)
{
WriteDivider("Runtime Functions");
}
foreach (int q in queries)
{
RuntimeFunction rtf = FindRuntimeFunction(r2r, q);
if (rtf == null)
{
WriteWarning("Unable to find by id " + q);
continue;
}
_writer.WriteLine(rtf.Method.SignatureString);
DumpRuntimeFunction(r2r, rtf);
}
}
// <summary>
/// For each query in the list of queries, search for a runtime function by id.
/// The method containing the runtime function gets outputted, along with the single runtime function that was searched
/// </summary>
/// <param name="r2r">Contains all the extracted info about the ReadyToRun image</param>
/// <param name="queries">The ids to search for</param>
private void QueryRuntimeFunction(R2RReader r2r, IReadOnlyList <int> queries)
{
if (queries.Count > 0)
{
_dumper.WriteDivider("Runtime Functions");
}
foreach (int q in queries)
{
RuntimeFunction rtf = FindRuntimeFunction(r2r, q);
if (rtf == null)
{
WriteWarning("Unable to find by id " + q);
continue;
}
XmlNode queryNode = _dumper.DumpQueryCount(q.ToString(), "Runtime Function", 1);
_dumper.DumpRuntimeFunction(rtf, queryNode);
}
}
// <summary>
/// For each query in the list of queries, dump a runtime function by id.
/// The method containing the runtime function gets outputted, along with the single runtime function that was searched
/// </summary>
/// <param name="r2r">Contains all the extracted info about the ReadyToRun image</param>
/// <param name="queries">The ids to search for</param>
private void QueryRuntimeFunction(R2RReader r2r, IEnumerable <string> queries)
{
if (queries.Any())
{
_dumper.WriteDivider("Runtime Functions");
}
foreach (string q in queries)
{
RuntimeFunction rtf = FindRuntimeFunction(r2r, ArgStringToInt(q));
if (rtf == null)
{
WriteWarning("Unable to find by id " + q);
continue;
}
XmlNode queryNode = _dumper.DumpQueryCount(q.ToString(), "Runtime Function", 1);
_dumper.DumpRuntimeFunction(rtf, queryNode);
}
}
public static TransitionBlock FromReader(R2RReader reader)
{
switch (reader.Architecture)
{
case Architecture.X86:
return(X86TransitionBlock.Instance);
case Architecture.X64:
return(reader.OS == OperatingSystem.Windows ? X64WindowsTransitionBlock.Instance : X64UnixTransitionBlock.Instance);
case Architecture.Arm:
return(ArmTransitionBlock.Instance);
case Architecture.Arm64:
return(Arm64TransitionBlock.Instance);
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Dumps one R2RMethod.
/// </summary>
private void DumpMethod(R2RReader r2r, R2RMethod method)
{
WriteSubDivider();
_writer.WriteLine(method.ToString());
if (_gc)
{
_writer.WriteLine("GcInfo:");
_writer.Write(method.GcInfo);
if (_raw)
{
DumpBytes(r2r, method.GcInfo.Offset, (uint)method.GcInfo.Size);
}
}
_writer.WriteLine();
foreach (RuntimeFunction runtimeFunction in method.RuntimeFunctions)
{
DumpRuntimeFunction(r2r, runtimeFunction);
}
}
public R2RImportSection(
int index,
R2RReader reader,
int rva,
int size,
CorCompileImportFlags flags,
byte type,
byte entrySize,
int signatureRVA,
List <ImportSectionEntry> entries,
int auxDataRVA,
int auxDataOffset,
Machine machine,
ushort majorVersion)
{
Index = index;
SectionRVA = rva;
SectionSize = size;
Flags = flags;
Type = (CorCompileImportType)type;
EntrySize = entrySize;
SignatureRVA = signatureRVA;
Entries = entries;
AuxiliaryDataRVA = auxDataRVA;
AuxiliaryDataSize = 0;
if (AuxiliaryDataRVA != 0)
{
int startOffset = auxDataOffset + BitConverter.ToInt32(reader.Image, auxDataOffset);
for (int i = 0; i < Entries.Count; i++)
{
GCRefMapDecoder decoder = new GCRefMapDecoder(reader, startOffset);
Entries[i].GCRefMap = decoder.ReadMap();
startOffset = decoder.GetOffset();
}
AuxiliaryDataSize = startOffset - auxDataOffset;
}
}
public static int Main(string[] args)
{
try
{
if (args.Length < 1)
{
throw new System.ArgumentException("File name must be passed as argument");
}
R2RReader r2r = new R2RReader(args[0]);
if (r2r.IsR2R)
{
Console.WriteLine($"Filename: {r2r.Filename}");
Console.WriteLine($"Machine: {r2r.Machine}");
Console.WriteLine($"ImageBase: 0x{r2r.ImageBase:X8}");
Console.WriteLine("============== R2R Header ==============");
Console.WriteLine(r2r.R2RHeader.ToString());
foreach (KeyValuePair <R2RSection.SectionType, R2RSection> section in r2r.R2RHeader.Sections)
{
Console.WriteLine("------------------\n");
Console.WriteLine(section.Value.ToString());
}
Console.WriteLine("============== Native Code ==============");
foreach (R2RMethod method in r2r.R2RMethods)
{
Console.WriteLine(method.ToString());
Console.WriteLine("------------------\n");
}
}
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.ToString());
return(1);
}
return(0);
}
/// <summary>
/// Outputs specified headers, sections, methods or runtime functions for one ReadyToRun image
/// </summary>
/// <param name="r2r">The structure containing the info of the ReadyToRun image</param>
public void Dump(R2RReader r2r)
{
_dumper.Begin();
if (_queries.Count == 0 && _keywords.Count == 0 && _runtimeFunctions.Count == 0 && _sections.Count == 0) //dump all sections and methods if no queries specified
{
if (_options.Header || !_options.EntryPoints)
{
_dumper.WriteDivider("R2R Header");
_dumper.DumpHeader(true);
}
if (_options.EntryPoints)
{
_dumper.DumpEntryPoints();
}
if (!_options.Header && !_options.EntryPoints)
{
_dumper.DumpAllMethods();
}
}
else //dump queried sections, methods and runtimeFunctions
{
if (_options.Header)
{
_dumper.DumpHeader(false);
}
QuerySection(r2r, _sections);
QueryRuntimeFunction(r2r, _runtimeFunctions);
QueryMethod(r2r, "R2R Methods by Query", _queries, true);
QueryMethod(r2r, "R2R Methods by Keyword", _keywords, false);
}
_dumper.End();
}
/// <summary>
/// Dumps one runtime function.
/// </summary>
private void DumpRuntimeFunction(R2RReader r2r, RuntimeFunction rtf)
{
_writer.Write($"{rtf}");
if (_disasm)
{
_writer.Write(CoreDisTools.GetCodeBlock(_disassembler, rtf, r2r.GetOffset(rtf.StartAddress), r2r.Image));
}
if (_raw)
{
_writer.WriteLine("Raw Bytes:");
DumpBytes(r2r, rtf.StartAddress, (uint)rtf.Size);
}
if (_unwind)
{
_writer.WriteLine("UnwindInfo:");
_writer.Write(rtf.UnwindInfo);
if (_raw)
{
DumpBytes(r2r, rtf.UnwindRVA, (uint)rtf.UnwindInfo.Size);
}
}
_writer.WriteLine();
}
/// <summary>
/// Initializes the fields of the R2RHeader
/// </summary>
/// <param name="image">PE image</param>
/// <param name="rva">Relative virtual address of the ReadyToRun header</param>
/// <param name="curOffset">Index in the image byte array to the start of the ReadyToRun header</param>
/// <exception cref="BadImageFormatException">The signature must be 0x00525452</exception>
public R2RHeader(byte[] image, int rva, int curOffset)
{
RelativeVirtualAddress = rva;
int startOffset = curOffset;
byte[] signature = new byte[sizeof(uint)];
Array.Copy(image, curOffset, signature, 0, sizeof(uint));
SignatureString = System.Text.Encoding.UTF8.GetString(signature);
Signature = R2RReader.ReadUInt32(image, ref curOffset);
if (Signature != READYTORUN_SIGNATURE)
{
throw new System.BadImageFormatException("Incorrect R2R header signature");
}
MajorVersion = R2RReader.ReadUInt16(image, ref curOffset);
MinorVersion = R2RReader.ReadUInt16(image, ref curOffset);
Flags = R2RReader.ReadUInt32(image, ref curOffset);
int nSections = R2RReader.ReadInt32(image, ref curOffset);
Sections = new Dictionary <R2RSection.SectionType, R2RSection>();
for (int i = 0; i < nSections; i++)
{
int type = R2RReader.ReadInt32(image, ref curOffset);
var sectionType = (R2RSection.SectionType)type;
if (!Enum.IsDefined(typeof(R2RSection.SectionType), type))
{
R2RDump.OutputWarning("Invalid ReadyToRun section type");
}
Sections[sectionType] = new R2RSection(sectionType,
R2RReader.ReadInt32(image, ref curOffset),
R2RReader.ReadInt32(image, ref curOffset));
}
Size = curOffset - startOffset;
}
public XmlDumper(bool ignoreSensitive, R2RReader r2r, TextWriter writer, Disassembler disassembler, DumpOptions options)
: base(r2r, writer, disassembler, options)
{
_ignoreSensitive = ignoreSensitive;
XmlDocument = new XmlDocument();
_ignoredProperties = new XmlAttributeOverrides();
XmlAttributes attrs = new XmlAttributes();
attrs.XmlIgnore = _ignoreSensitive;
_ignoredProperties.Add(typeof(R2RHeader), "RelativeVirtualAddress", attrs);
_ignoredProperties.Add(typeof(R2RHeader), "Size", attrs);
_ignoredProperties.Add(typeof(R2RImportSection), "SectionRVA", attrs);
_ignoredProperties.Add(typeof(R2RImportSection), "SectionSize", attrs);
_ignoredProperties.Add(typeof(R2RImportSection), "EntrySize", attrs);
_ignoredProperties.Add(typeof(R2RImportSection), "SignatureRVA", attrs);
_ignoredProperties.Add(typeof(R2RImportSection), "AuxiliaryDataRVA", attrs);
_ignoredProperties.Add(typeof(R2RImportSection.ImportSectionEntry), "SignatureSample", attrs);
_ignoredProperties.Add(typeof(R2RImportSection.ImportSectionEntry), "SignatureRVA", attrs);
_ignoredProperties.Add(typeof(RuntimeFunction), "StartAddress", attrs);
_ignoredProperties.Add(typeof(RuntimeFunction), "UnwindRVA", attrs);
_ignoredProperties.Add(typeof(R2RSection), "RelativeVirtualAddress", attrs);
_ignoredProperties.Add(typeof(R2RSection), "Size", attrs);
}
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);
}
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);
}
/// <summary>
/// Extracts the method signature from the metadata by rid
/// </summary>
public R2RMethod(
int index,
R2RReader r2rReader,
EntityHandle methodHandle,
int entryPointId,
string owningType,
string constrainedType,
string[] instanceArgs,
FixupCell[] fixups)
{
Index = index;
MethodHandle = methodHandle;
EntryPointRuntimeFunctionId = entryPointId;
R2RReader = r2rReader;
RuntimeFunctions = new List <RuntimeFunction>();
EntityHandle owningTypeHandle;
GenericParameterHandleCollection genericParams = default(GenericParameterHandleCollection);
DisassemblingGenericContext genericContext = new DisassemblingGenericContext(typeParameters: Array.Empty <string>(), methodParameters: instanceArgs);
DisassemblingTypeProvider typeProvider = new DisassemblingTypeProvider();
// get the method signature from the method handle
switch (MethodHandle.Kind)
{
case HandleKind.MethodDefinition:
{
MethodDefinition methodDef = R2RReader.MetadataReader.GetMethodDefinition((MethodDefinitionHandle)MethodHandle);
Name = R2RReader.MetadataReader.GetString(methodDef.Name);
Signature = methodDef.DecodeSignature <string, DisassemblingGenericContext>(typeProvider, genericContext);
owningTypeHandle = methodDef.GetDeclaringType();
genericParams = methodDef.GetGenericParameters();
}
break;
case HandleKind.MemberReference:
{
MemberReference memberRef = R2RReader.MetadataReader.GetMemberReference((MemberReferenceHandle)MethodHandle);
Name = R2RReader.MetadataReader.GetString(memberRef.Name);
Signature = memberRef.DecodeMethodSignature <string, DisassemblingGenericContext>(typeProvider, genericContext);
owningTypeHandle = memberRef.Parent;
}
break;
default:
throw new NotImplementedException();
}
if (owningType != null)
{
DeclaringType = owningType;
}
else
{
DeclaringType = MetadataNameFormatter.FormatHandle(R2RReader.MetadataReader, owningTypeHandle);
}
Fixups = fixups;
StringBuilder sb = new StringBuilder();
sb.Append(Signature.ReturnType);
sb.Append(" ");
sb.Append(DeclaringType);
sb.Append(".");
sb.Append(Name);
if (Signature.GenericParameterCount != 0)
{
sb.Append("<");
for (int i = 0; i < Signature.GenericParameterCount; i++)
{
if (i > 0)
{
sb.Append(", ");
}
if (instanceArgs != null && instanceArgs.Length > i)
{
sb.Append(instanceArgs[i]);
}
else
{
sb.Append("!");
sb.Append(i);
}
}
sb.Append(">");
}
sb.Append("(");
for (int i = 0; i < Signature.ParameterTypes.Length; i++)
{
if (i > 0)
{
sb.Append(", ");
}
sb.AppendFormat($"{Signature.ParameterTypes[i]}");
}
sb.Append(")");
SignatureString = sb.ToString();
}
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(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);
}
public TextDumper(R2RReader r2r, TextWriter writer, Disassembler disassembler, DumpOptions options)
: base(r2r, writer, disassembler, options)
{
}
