/// <summary>
/// Creates a new tables stream based on a segment in a file.
/// </summary>
/// <param name="name">The name of the stream.</param>
/// <param name="contents">The raw contents of the stream.</param>
/// <param name="referenceResolver">The instance that resolves references to other segments in the file to segments.</param>
public SerializedTableStream(string name, IReadableSegment contents, ISegmentReferenceResolver referenceResolver)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
_contents = contents ?? throw new ArgumentNullException(nameof(contents));
_referenceResolver = referenceResolver ?? throw new ArgumentNullException(nameof(referenceResolver));
var reader = contents.CreateReader();
Reserved = reader.ReadUInt32();
MajorVersion = reader.ReadByte();
MinorVersion = reader.ReadByte();
Flags = (TablesStreamFlags)reader.ReadByte();
Log2LargestRid = reader.ReadByte();
_validMask = reader.ReadUInt64();
_sortedMask = reader.ReadUInt64();
_rowCounts = ReadRowCounts(reader);
if (HasExtraData)
{
ExtraData = reader.ReadUInt32();
}
_headerSize = (uint)(reader.Offset - reader.StartOffset);
_indexSizes = InitializeIndexSizes();
}
private SerializedMetadataTable <TRow> CreateNextTable <TRow>(
TableIndex index,
ref ulong offset,
SerializedMetadataTable <TRow> .ReadRowExtendedDelegate readRow,
ISegmentReferenceResolver referenceResolver)
where TRow : struct, IMetadataRow
{
return(new SerializedMetadataTable <TRow>(
CreateNextRawTableReader(index, ref offset), index, TableLayouts[(int)index], readRow, referenceResolver));
}
/// <summary>
/// Creates a new instance of the <see cref="DefaultDebugDataReader"/> class.
/// </summary>
/// <param name="resolver">The reference resolver to use to read from.</param>
public DefaultDebugDataReader(ISegmentReferenceResolver resolver)
{
_resolver = resolver;
}
/// <summary>
/// Creates a new instance of the <see cref="DefaultMetadataStreamReader"/> class.
/// </summary>
/// <param name="referenceResolver">
/// The object responsible for resolving references to segments in the original PE file.
/// </param>
public DefaultMetadataStreamReader(ISegmentReferenceResolver referenceResolver)
{
_referenceResolver = referenceResolver ?? throw new ArgumentNullException(nameof(referenceResolver));
}
/// <summary>
/// Initializes the PE reader parameters.
/// </summary>
/// <param name="resolver">
/// The object responsible for resolving references within the original PE file.
/// This is usually just the underlying <see cref="PEFile"/> instance.
/// </param>
public PEReadParameters(ISegmentReferenceResolver resolver)
{
ReferenceResolver = resolver;
MetadataStreamReader = new DefaultMetadataStreamReader(resolver);
DebugDataReader = new DefaultDebugDataReader(resolver);
}
/// <summary>
/// Creates a new tables stream based on a byte array.
/// </summary>
/// <param name="name">The name of the stream.</param>
/// <param name="rawData">The raw contents of the stream.</param>
/// <param name="referenceResolver">The instance that resolves references to other segments in the file to segments.</param>
public SerializedTableStream(string name, byte[] rawData, ISegmentReferenceResolver referenceResolver)
: this(name, new DataSegment(rawData), referenceResolver)
{
}
/// <summary>
/// Reads a single method definition row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the method definition table.</param>
/// <param name="referenceResolver">The resolver to use for resolving the virtual address of the method body.</param>
/// <returns>The row.</returns>
public static MethodDefinitionRow FromReader(IBinaryStreamReader reader, TableLayout layout, ISegmentReferenceResolver referenceResolver)
{
return(new MethodDefinitionRow(
referenceResolver.GetReferenceToRva(reader.ReadUInt32()),
(MethodImplAttributes)reader.ReadUInt16(),
(MethodAttributes)reader.ReadUInt16(),
reader.ReadIndex((IndexSize)layout.Columns[3].Size),
reader.ReadIndex((IndexSize)layout.Columns[4].Size),
reader.ReadIndex((IndexSize)layout.Columns[5].Size)));
}
/// <summary>
/// Reads a single field RVA row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the field RVA table.</param>
/// <param name="referenceResolver"></param>
/// <returns>The row.</returns>
public static FieldRvaRow FromReader(IBinaryStreamReader reader, TableLayout layout, ISegmentReferenceResolver referenceResolver)
{
return(new FieldRvaRow(
referenceResolver.GetReferenceToRva(reader.ReadUInt32()),
reader.ReadIndex((IndexSize)layout.Columns[1].Size)));
}
public KoiVmAwareStreamReader(ISegmentReferenceResolver referenceResolver, string koiStreamName, ILogger logger)
{
KoiStreamName = koiStreamName ?? throw new ArgumentNullException(nameof(koiStreamName));
Logger = logger;
_reader = new DefaultMetadataStreamReader(referenceResolver);
}
public KoiVmAwareStreamReader(ISegmentReferenceResolver referenceResolver, ILogger logger)
: this(referenceResolver, "#Koi", logger)
{
}
/// <summary>
/// Reads a metadata table from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="tableIndex">The index of the table.</param>
/// <param name="originalLayout">The layout of the table.</param>
/// <param name="readRow">The method to use for reading each row in the table.</param>
/// <param name="referenceResolver">The instance used to resolve RVAs to segments.</param>
public SerializedMetadataTable(IBinaryStreamReader reader, TableIndex tableIndex, TableLayout originalLayout,
ReadRowExtendedDelegate readRow, ISegmentReferenceResolver referenceResolver)
: this(reader, tableIndex, originalLayout, (r, l) => readRow(r, l, referenceResolver))
{
}
