public ImageDebugHeader GetDebugHeader()
{
writer.Dispose();
ImageDebugDirectory imageDebugDirectory = default(ImageDebugDirectory);
imageDebugDirectory.Type = ImageDebugType.EmbeddedPortablePdb;
ImageDebugDirectory directory = imageDebugDirectory;
MemoryStream memoryStream = new MemoryStream();
BinaryStreamWriter binaryStreamWriter = new BinaryStreamWriter(memoryStream);
binaryStreamWriter.WriteByte(77);
binaryStreamWriter.WriteByte(80);
binaryStreamWriter.WriteByte(68);
binaryStreamWriter.WriteByte(66);
binaryStreamWriter.WriteInt32((int)stream.Length);
stream.Position = 0L;
using (DeflateStream destination = new DeflateStream(memoryStream, CompressionMode.Compress, true))
{
stream.CopyTo(destination);
}
directory.SizeOfData = (int)memoryStream.Length;
return(new ImageDebugHeader(new ImageDebugHeaderEntry[2]
{
writer.GetDebugHeader().Entries[0],
new ImageDebugHeaderEntry(directory, memoryStream.ToArray())
}));
}
public ImageDebugHeader GetDebugHeader()
{
writer.Dispose();
var directory = new ImageDebugDirectory {
Type = ImageDebugType.EmbeddedPortablePdb,
MajorVersion = 0x0100,
MinorVersion = 0x0100,
};
var data = new MemoryStream();
var w = new BinaryStreamWriter(data);
w.WriteByte(0x4d);
w.WriteByte(0x50);
w.WriteByte(0x44);
w.WriteByte(0x42);
w.WriteInt32((int)stream.Length);
stream.Position = 0;
using (var compress_stream = new DeflateStream(data, CompressionMode.Compress, leaveOpen: true))
stream.CopyTo(compress_stream);
directory.SizeOfData = (int)data.Length;
return(new ImageDebugHeader(new [] {
writer.GetDebugHeader().Entries[0],
new ImageDebugHeaderEntry(directory, data.ToArray())
}));
}
public CustomMetadataWriter(SymWriter sym_writer)
{
this.sym_writer = sym_writer;
this.stream = new MemoryStream();
this.writer = new BinaryStreamWriter(stream);
writer.WriteByte(version);
writer.WriteByte(0); // count
writer.Align(4);
}
public static void WriteCompressedInteger(this BinaryStreamWriter writer, uint?value)
{
if (value == null)
{
writer.WriteByte(0xFF);
return;
}
if (value <= 0x7F)
{
writer.WriteByte((byte)value);
}
else if (value <= 0x3FFF)
{
writer.WriteByte((byte)(0x80 | (value >> 8)));
writer.WriteByte((byte)value);
}
else
{
writer.WriteByte((byte)(0xC0 | (value >> 24)));
writer.WriteByte((byte)(value >> 16));
writer.WriteByte((byte)(value >> 8));
writer.WriteByte((byte)value);
}
}
public override MetadataStream CreateStream()
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
writer.WriteByte(0);
var processedSignatures = new HashSet <BlobSignature>();
var agenda = new Queue <BlobSignature>(_signatureOffsetMapping.Keys);
while (agenda.Count > 0)
{
var signature = agenda.Dequeue();
if (processedSignatures.Add(signature))
{
writer.WriteCompressedUInt32(signature.GetPhysicalLength());
int count = _signatureOffsetMapping.Count;
signature.Write(_parentBuffer, writer);
// TODO: find more efficient way of adding newly created signatures to the queue.
if (count != _signatureOffsetMapping.Count)
{
foreach (var sig in _signatureOffsetMapping.Keys)
{
agenda.Enqueue(sig);
}
}
}
}
writer.WriteZeroes((int)(FileSegment.Align(_length, 4) - _length));
return(new BlobStream(new MemoryStreamReader(stream.ToArray())));
}
}
private uint AppendString(string value)
{
uint offset = (uint)_rawStream.Length;
AppendRawData(Encoding.UTF8.GetBytes(value));
_writer.WriteByte(0);
return(offset);
}
public override MetadataStream CreateStream()
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
writer.WriteByte(0);
foreach (var value in _stringOffsetMapping.Keys)
{
writer.WriteCompressedUInt32((uint)Encoding.Unicode.GetByteCount(value) + 1);
writer.WriteBytes(Encoding.Unicode.GetBytes(value));
writer.WriteByte(0);
}
return(new UserStringStream(new MemoryStreamReader(stream.ToArray())));
}
}
public override MetadataStream CreateStream()
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
writer.WriteByte(0);
foreach (string value in _stringOffsetMapping.Keys)
{
writer.WriteBytes(Encoding.UTF8.GetBytes(value));
writer.WriteByte(0);
}
writer.WriteZeroes((int)(FileSegment.Align(_length, 4) - _length));
return(new StringStream(new MemoryStreamReader(stream.ToArray())));
}
}
void Write(CustomMetadataType type, Action write)
{
count++;
writer.WriteByte(version);
writer.WriteByte((byte)type);
writer.Align(4);
var length_position = writer.Position;
writer.WriteUInt32(0);
write();
writer.Align(4);
var end = writer.Position;
var length = end - length_position + 4; // header is 4 bytes long
writer.Position = length_position;
writer.WriteInt32(length);
writer.Position = end;
}
public ImageDebugHeader GetDebugHeader()
{
ImageDebugHeader pdbDebugHeader = writer.GetDebugHeader();
var directory = new ImageDebugDirectory {
Type = ImageDebugType.EmbeddedPortablePdb,
MajorVersion = 0x0100,
MinorVersion = 0x0100,
};
var data = new MemoryStream();
var w = new BinaryStreamWriter(data);
w.WriteByte(0x4d);
w.WriteByte(0x50);
w.WriteByte(0x44);
w.WriteByte(0x42);
w.WriteInt32((int)stream.Length);
stream.Position = 0;
using (var compress_stream = new DeflateStream(data, CompressionMode.Compress, leaveOpen: true))
stream.CopyTo(compress_stream);
directory.SizeOfData = (int)data.Length;
var debugHeaderEntries = new ImageDebugHeaderEntry [pdbDebugHeader.Entries.Length + 1];
for (int i = 0; i < pdbDebugHeader.Entries.Length; i++)
{
debugHeaderEntries [i] = pdbDebugHeader.Entries [i];
}
debugHeaderEntries [debugHeaderEntries.Length - 1] = new ImageDebugHeaderEntry(directory, data.ToArray());
return(new ImageDebugHeader(debugHeaderEntries));
}
public void WriteByte()
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
writer.WriteByte(0x80);
writer.WriteSByte(-1);
Assert.Equal(new byte[]
{
0x80,
0xFF
}, stream.ToArray());
}
}
public override MetadataStream CreateStream()
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
writer.WriteByte(0);
foreach (var signature in _signatureOffsetMapping.Keys)
{
writer.WriteCompressedUInt32(signature.GetPhysicalLength(_parentBuffer));
signature.Write(_parentBuffer, writer);
}
writer.WriteZeroes((int)(FileSegment.Align(_length, 4) - _length));
return(new BlobStream(new MemoryStreamReader(stream.ToArray())));
}
}
static void Main(string[] args)
{
var pe = new PEFile();
var originalBytes = Properties.Resources.console_anycpu;
var reader = new BinaryStreamReader(new MemoryStream(originalBytes), new byte[1024]);
pe.ReadFrom(reader);
using (var output = File.Create("console.anycpu.exe"))
{
var writer = new BinaryStreamWriter(output);
pe.WriteTo(writer);
while (reader.Position < originalBytes.Length)
{
writer.WriteByte(reader.ReadByte());
}
}
}
private uint AppendString(string value)
{
uint offset = (uint)_rawStream.Length;
if (value is null)
{
_writer.WriteByte(0);
return(offset);
}
int byteCount = Encoding.Unicode.GetByteCount(value) + 1;
_writer.WriteCompressedUInt32((uint)byteCount);
var rawData = new byte[byteCount];
Encoding.Unicode.GetBytes(value, 0, value.Length, rawData, 0);
rawData[byteCount - 1] = GetTerminatorByte(value);
AppendRawData(rawData);
return(offset);
}
static void WriteOptionalHeader(OptionalHeader optionalHeader, BinaryStreamWriter writer)
{
writer.WriteUInt16((ushort)optionalHeader.PEMagic);
writer.WriteByte(optionalHeader.MajorLinkerVersion);
writer.WriteByte(optionalHeader.MinorLinkerVersion);
writer.WriteUInt32(optionalHeader.SizeOfCode);
writer.WriteUInt32(optionalHeader.SizeOfInitializedData);
writer.WriteUInt32(optionalHeader.SizeOfUninitializedData);
writer.WriteUInt32(optionalHeader.AddressOfEntryPoint);
writer.WriteUInt32(optionalHeader.BaseOfCode);
if (optionalHeader.PEMagic == PEMagic.NT32)
{
writer.WriteUInt32(optionalHeader.BaseOfData);
writer.WriteUInt32(checked ((uint)optionalHeader.ImageBase));
}
else
{
writer.WriteUInt64(optionalHeader.ImageBase);
}
writer.WriteUInt32(optionalHeader.SectionAlignment);
writer.WriteUInt32(optionalHeader.FileAlignment);
writer.WriteUInt16(optionalHeader.MajorOperatingSystemVersion);
writer.WriteUInt16(optionalHeader.MinorOperatingSystemVersion);
writer.WriteUInt16(optionalHeader.MajorImageVersion);
writer.WriteUInt16(optionalHeader.MinorImageVersion);
writer.WriteUInt16(optionalHeader.MajorSubsystemVersion);
writer.WriteUInt16(optionalHeader.MinorSubsystemVersion);
writer.WriteUInt32(optionalHeader.Win32VersionValue);
writer.WriteUInt32(optionalHeader.SizeOfImage);
writer.WriteUInt32(optionalHeader.SizeOfHeaders);
writer.WriteUInt32(optionalHeader.CheckSum);
writer.WriteUInt16((ushort)optionalHeader.Subsystem);
writer.WriteUInt16((ushort)optionalHeader.DllCharacteristics);
if (optionalHeader.PEMagic == PEMagic.NT32)
{
writer.WriteUInt32(checked ((uint)optionalHeader.SizeOfStackReserve));
writer.WriteUInt32(checked ((uint)optionalHeader.SizeOfStackCommit));
writer.WriteUInt32(checked ((uint)optionalHeader.SizeOfHeapReserve));
writer.WriteUInt32(checked ((uint)optionalHeader.SizeOfHeapCommit));
}
else
{
writer.WriteUInt64(optionalHeader.SizeOfStackReserve);
writer.WriteUInt64(optionalHeader.SizeOfStackCommit);
writer.WriteUInt64(optionalHeader.SizeOfHeapReserve);
writer.WriteUInt64(optionalHeader.SizeOfHeapCommit);
}
writer.WriteUInt32(optionalHeader.LoaderFlags);
writer.WriteUInt32(optionalHeader.NumberOfRvaAndSizes);
for (int i = 0; i < optionalHeader.DataDirectories.Length; i++)
{
writer.WriteUInt32(optionalHeader.DataDirectories[i].VirtualAddress);
writer.WriteUInt32(optionalHeader.DataDirectories[i].Size);
}
}
private void DefineCustomMetadata(PdbMethodSymbols pdbSymbols)
{
// Custom PDB metadata
if (pdbSymbols != null)
{
using (var memoryStream = new MemoryStream()) {
var metadata = new BinaryStreamWriter(memoryStream);
metadata.WriteByte(4); // version
metadata.WriteByte((byte)1); // count
metadata.WriteInt16(0); // padding
var metadataStartPosition = metadata.BaseStream.Position;
var customMetadataCount = 0;
if (pdbSymbols.IteratorClass != null)
{
customMetadataCount++;
metadata.WriteByte(4); // version
metadata.WriteByte(4); // forward iterator
metadata.Align(4);
using (new PdbBinaryStreamWriterSizeHelper(metadata)) {
metadata.WriteString(pdbSymbols.IteratorClass);
metadata.WriteInt16(0);
metadata.Align(4);
}
}
if (pdbSymbols.UsingCounts != null)
{
customMetadataCount++;
metadata.WriteByte(4); // version
metadata.WriteByte(0); // using info
metadata.Align(4);
using (new PdbBinaryStreamWriterSizeHelper(metadata)) {
metadata.WriteUInt16((ushort)pdbSymbols.UsingCounts.Count);
foreach (var uc in pdbSymbols.UsingCounts)
{
metadata.WriteUInt16(uc);
}
metadata.Align(4);
}
}
if (pdbSymbols.MethodWhoseUsingInfoAppliesToThisMethod != null)
{
customMetadataCount++;
metadata.WriteByte(4); // version
metadata.WriteByte(1); // forward info
metadata.Align(4);
using (new PdbBinaryStreamWriterSizeHelper(metadata)) {
metadata.WriteUInt32(pdbSymbols.MethodWhoseUsingInfoAppliesToThisMethod.MetadataToken.ToUInt32());
}
}
if (pdbSymbols.IteratorScopes != null)
{
customMetadataCount++;
metadata.WriteByte(4); // version
metadata.WriteByte(3); // iterator scopes
metadata.Align(4);
using (new PdbBinaryStreamWriterSizeHelper(metadata)) {
metadata.WriteInt32(pdbSymbols.IteratorScopes.Count);
foreach (var scope in pdbSymbols.IteratorScopes)
{
metadata.WriteInt32(scope.Start.Offset);
metadata.WriteInt32(scope.End.Offset);
}
}
}
if (metadata.BaseStream.Position != metadataStartPosition)
{
// Update number of entries
metadata.Flush();
metadata.BaseStream.Position = 1;
metadata.WriteByte((byte)customMetadataCount);
metadata.Flush();
writer.DefineCustomMetadata("MD2", memoryStream.ToArray());
}
}
// Save back asyncMethodInfo
if (pdbSymbols.SynchronizationInformation != null)
{
using (var memoryStream = new MemoryStream()) {
var metadata = new BinaryStreamWriter(memoryStream);
metadata.WriteUInt32(pdbSymbols.SynchronizationInformation.KickoffMethod != null ? pdbSymbols.SynchronizationInformation.KickoffMethod.MetadataToken.ToUInt32() : 0);
metadata.WriteUInt32(pdbSymbols.SynchronizationInformation.GeneratedCatchHandlerIlOffset);
metadata.WriteUInt32((uint)pdbSymbols.SynchronizationInformation.SynchronizationPoints.Count);
foreach (var syncPoint in pdbSymbols.SynchronizationInformation.SynchronizationPoints)
{
metadata.WriteUInt32(syncPoint.SynchronizeOffset);
metadata.WriteUInt32(syncPoint.ContinuationMethod != null ? syncPoint.ContinuationMethod.MetadataToken.ToUInt32() : 0);
metadata.WriteUInt32(syncPoint.ContinuationOffset);
}
writer.DefineCustomMetadata("asyncMethodInfo", memoryStream.ToArray());
}
}
}
}
/// <summary>
/// Creates a new blob stream buffer.
/// </summary>
/// <param name="name">The name of the stream.</param>
public BlobStreamBuffer(string name)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
_writer = new BinaryStreamWriter(_rawStream);
_writer.WriteByte(0);
}
