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) { }