private static int WriteCodeViewData(BlobBuilder builder, string pdbPath, Guid pdbGuid)
{
int start = builder.Count;
builder.WriteByte((byte)'R');
builder.WriteByte((byte)'S');
builder.WriteByte((byte)'D');
builder.WriteByte((byte)'S');
// PDB id:
builder.WriteGuid(pdbGuid);
// age
builder.WriteUInt32(1);
// UTF-8 encoded zero-terminated path to PDB
int pathStart = builder.Count;
builder.WriteUTF8(pdbPath, allowUnpairedSurrogates: true);
builder.WriteByte(0);
return builder.Count - start;
}
internal static void WriteCompressedInteger(BlobBuilder writer, uint value)
{
unchecked
{
if (value <= SingleByteCompressedIntegerMaxValue)
{
writer.WriteByte((byte)value);
}
else if (value <= TwoByteCompressedIntegerMaxValue)
{
writer.WriteUInt16BE((ushort)(0x8000 | value));
}
else if (value <= MaxCompressedIntegerValue)
{
writer.WriteUInt32BE(0xc0000000 | value);
}
else
{
Throw.ValueArgumentOutOfRange();
}
}
}
internal static void WriteConstant(BlobBuilder writer, object value)
{
if (value == null)
{
// The encoding of Type for the nullref value for FieldInit is ELEMENT_TYPE_CLASS with a Value of a 32-bit.
writer.WriteUInt32(0);
return;
}
var type = value.GetType();
if (type.GetTypeInfo().IsEnum)
{
type = Enum.GetUnderlyingType(type);
}
if (type == typeof(bool))
{
writer.WriteBoolean((bool)value);
}
else if (type == typeof(int))
{
writer.WriteInt32((int)value);
}
else if (type == typeof(string))
{
writer.WriteUTF16((string)value);
}
else if (type == typeof(byte))
{
writer.WriteByte((byte)value);
}
else if (type == typeof(char))
{
writer.WriteUInt16((char)value);
}
else if (type == typeof(double))
{
writer.WriteDouble((double)value);
}
else if (type == typeof(short))
{
writer.WriteInt16((short)value);
}
else if (type == typeof(long))
{
writer.WriteInt64((long)value);
}
else if (type == typeof(sbyte))
{
writer.WriteSByte((sbyte)value);
}
else if (type == typeof(float))
{
writer.WriteSingle((float)value);
}
else if (type == typeof(ushort))
{
writer.WriteUInt16((ushort)value);
}
else if (type == typeof(uint))
{
writer.WriteUInt32((uint)value);
}
else if (type == typeof(ulong))
{
writer.WriteUInt64((ulong)value);
}
else
{
throw new ArgumentException(SR.Format(SR.InvalidConstantValueOfType, type));
}
}
internal static void WriteCompressedSignedInteger(BlobBuilder writer, int value)
{
unchecked
{
const int b6 = (1 << 6) - 1;
const int b13 = (1 << 13) - 1;
const int b28 = (1 << 28) - 1;
// 0xffffffff for negative value
// 0x00000000 for non-negative
int signMask = value >> 31;
if ((value & ~b6) == (signMask & ~b6))
{
int n = ((value & b6) << 1) | (signMask & 1);
writer.WriteByte((byte)n);
}
else if ((value & ~b13) == (signMask & ~b13))
{
int n = ((value & b13) << 1) | (signMask & 1);
writer.WriteUInt16BE((ushort)(0x8000 | n));
}
else if ((value & ~b28) == (signMask & ~b28))
{
int n = ((value & b28) << 1) | (signMask & 1);
writer.WriteUInt32BE(0xc0000000 | (uint)n);
}
else
{
Throw.ValueArgumentOutOfRange();
}
}
}
private static void SerializeStreamHeader(ref int offsetFromStartOfMetadata, int alignedStreamSize, string streamName, BlobBuilder writer)
{
// 4 for the first uint (offset), 4 for the second uint (padded size), length of stream name + 1 for null terminator (then padded)
int sizeOfStreamHeader = MetadataSizes.GetMetadataStreamHeaderSize(streamName);
writer.WriteInt32(offsetFromStartOfMetadata);
writer.WriteInt32(alignedStreamSize);
foreach (char ch in streamName)
{
writer.WriteByte((byte)ch);
}
// After offset, size, and stream name, write 0-bytes until we reach our padded size.
for (uint i = 8 + (uint)streamName.Length; i < sizeOfStreamHeader; i++)
{
writer.WriteByte(0);
}
offsetFromStartOfMetadata += alignedStreamSize;
}
private void SerializeMetadataHeader(BlobBuilder writer)
{
int startOffset = writer.Position;
// signature
writer.WriteUInt32(0x424A5342);
// major version
writer.WriteUInt16(1);
// minor version
writer.WriteUInt16(1);
// reserved
writer.WriteUInt32(0);
// metadata version length
writer.WriteUInt32(MetadataSizes.MetadataVersionPaddedLength);
int n = Math.Min(MetadataSizes.MetadataVersionPaddedLength, _metadataVersion.Length);
for (int i = 0; i < n; i++)
{
writer.WriteByte((byte)_metadataVersion[i]);
}
for (int i = n; i < MetadataSizes.MetadataVersionPaddedLength; i++)
{
writer.WriteByte(0);
}
// reserved
writer.WriteUInt16(0);
// number of streams
writer.WriteUInt16((ushort)(5 + (_sizes.IsMinimalDelta ? 1 : 0) + (_sizes.IsStandaloneDebugMetadata ? 1 : 0)));
// stream headers
int offsetFromStartOfMetadata = _sizes.MetadataHeaderSize;
// emit the #Pdb stream first so that only a single page has to be read in order to find out PDB ID
if (_sizes.IsStandaloneDebugMetadata)
{
SerializeStreamHeader(ref offsetFromStartOfMetadata, _sizes.StandalonePdbStreamSize, "#Pdb", writer);
}
// Spec: Some compilers store metadata in a #- stream, which holds an uncompressed, or non-optimized, representation of metadata tables;
// this includes extra metadata -Ptr tables. Such PE files do not form part of ECMA-335 standard.
//
// Note: EnC delta is stored as uncompressed metadata stream.
SerializeStreamHeader(ref offsetFromStartOfMetadata, _sizes.MetadataTableStreamSize, (_sizes.IsMetadataTableStreamCompressed ? "#~" : "#-"), writer);
SerializeStreamHeader(ref offsetFromStartOfMetadata, _sizes.GetAlignedHeapSize(HeapIndex.String), "#Strings", writer);
SerializeStreamHeader(ref offsetFromStartOfMetadata, _sizes.GetAlignedHeapSize(HeapIndex.UserString), "#US", writer);
SerializeStreamHeader(ref offsetFromStartOfMetadata, _sizes.GetAlignedHeapSize(HeapIndex.Guid), "#GUID", writer);
SerializeStreamHeader(ref offsetFromStartOfMetadata, _sizes.GetAlignedHeapSize(HeapIndex.Blob), "#Blob", writer);
if (_sizes.IsMinimalDelta)
{
SerializeStreamHeader(ref offsetFromStartOfMetadata, 0, "#JTD", writer);
}
int endOffset = writer.Position;
Debug.Assert(endOffset - startOffset == _sizes.MetadataHeaderSize);
}
internal void SerializeLocalSlots(BlobBuilder writer)
{
int syntaxOffsetBaseline = -1;
foreach (LocalSlotDebugInfo localSlot in this.LocalSlots)
{
if (localSlot.Id.SyntaxOffset < syntaxOffsetBaseline)
{
syntaxOffsetBaseline = localSlot.Id.SyntaxOffset;
}
}
if (syntaxOffsetBaseline != -1)
{
writer.WriteByte(SyntaxOffsetBaseline);
writer.WriteCompressedInteger(-syntaxOffsetBaseline);
}
foreach (LocalSlotDebugInfo localSlot in this.LocalSlots)
{
SynthesizedLocalKind kind = localSlot.SynthesizedKind;
Debug.Assert(kind <= SynthesizedLocalKind.MaxValidValueForLocalVariableSerializedToDebugInformation);
if (!kind.IsLongLived())
{
writer.WriteByte(0);
continue;
}
byte b = (byte)(kind + 1);
Debug.Assert((b & (1 << 7)) == 0);
bool hasOrdinal = localSlot.Id.Ordinal > 0;
if (hasOrdinal)
{
b |= 1 << 7;
}
writer.WriteByte(b);
writer.WriteCompressedInteger(localSlot.Id.SyntaxOffset - syntaxOffsetBaseline);
if (hasOrdinal)
{
writer.WriteCompressedInteger(localSlot.Id.Ordinal);
}
}
}
private void WritePEHeader(BlobBuilder builder, PEDirectoriesBuilder directories, ImmutableArray<SerializedSection> sections)
{
builder.WriteUInt16((ushort)(Header.Is32Bit ? PEMagic.PE32 : PEMagic.PE32Plus));
builder.WriteByte(Header.MajorLinkerVersion);
builder.WriteByte(Header.MinorLinkerVersion);
// SizeOfCode:
builder.WriteUInt32((uint)SumRawDataSizes(sections, SectionCharacteristics.ContainsCode));
// SizeOfInitializedData:
builder.WriteUInt32((uint)SumRawDataSizes(sections, SectionCharacteristics.ContainsInitializedData));
// SizeOfUninitializedData:
builder.WriteUInt32((uint)SumRawDataSizes(sections, SectionCharacteristics.ContainsUninitializedData));
// AddressOfEntryPoint:
builder.WriteUInt32((uint)directories.AddressOfEntryPoint);
// BaseOfCode:
int codeSectionIndex = IndexOfSection(sections, SectionCharacteristics.ContainsCode);
builder.WriteUInt32((uint)(codeSectionIndex != -1 ? sections[codeSectionIndex].RelativeVirtualAddress : 0));
if (Header.Is32Bit)
{
// BaseOfData:
int dataSectionIndex = IndexOfSection(sections, SectionCharacteristics.ContainsInitializedData);
builder.WriteUInt32((uint)(dataSectionIndex != -1 ? sections[dataSectionIndex].RelativeVirtualAddress : 0));
builder.WriteUInt32((uint)Header.ImageBase);
}
else
{
builder.WriteUInt64(Header.ImageBase);
}
// NT additional fields:
builder.WriteUInt32((uint)Header.SectionAlignment);
builder.WriteUInt32((uint)Header.FileAlignment);
builder.WriteUInt16(Header.MajorOperatingSystemVersion);
builder.WriteUInt16(Header.MinorOperatingSystemVersion);
builder.WriteUInt16(Header.MajorImageVersion);
builder.WriteUInt16(Header.MinorImageVersion);
builder.WriteUInt16(Header.MajorSubsystemVersion);
builder.WriteUInt16(Header.MinorSubsystemVersion);
// Win32VersionValue (reserved, should be 0)
builder.WriteUInt32(0);
// SizeOfImage:
var lastSection = sections[sections.Length - 1];
builder.WriteUInt32((uint)BitArithmetic.Align(lastSection.RelativeVirtualAddress + lastSection.VirtualSize, Header.SectionAlignment));
// SizeOfHeaders:
builder.WriteUInt32((uint)BitArithmetic.Align(Header.ComputeSizeOfPeHeaders(sections.Length), Header.FileAlignment));
// Checksum:
// Shall be zero for strong name signing.
builder.WriteUInt32(0);
builder.WriteUInt16((ushort)Header.Subsystem);
builder.WriteUInt16((ushort)Header.DllCharacteristics);
if (Header.Is32Bit)
{
builder.WriteUInt32((uint)Header.SizeOfStackReserve);
builder.WriteUInt32((uint)Header.SizeOfStackCommit);
builder.WriteUInt32((uint)Header.SizeOfHeapReserve);
builder.WriteUInt32((uint)Header.SizeOfHeapCommit);
}
else
{
builder.WriteUInt64(Header.SizeOfStackReserve);
builder.WriteUInt64(Header.SizeOfStackCommit);
builder.WriteUInt64(Header.SizeOfHeapReserve);
builder.WriteUInt64(Header.SizeOfHeapCommit);
}
// LoaderFlags
builder.WriteUInt32(0);
// The number of data-directory entries in the remainder of the header.
builder.WriteUInt32(16);
// directory entries:
builder.WriteUInt32((uint)directories.ExportTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.ExportTable.Size);
builder.WriteUInt32((uint)directories.ImportTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.ImportTable.Size);
builder.WriteUInt32((uint)directories.ResourceTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.ResourceTable.Size);
builder.WriteUInt32((uint)directories.ExceptionTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.ExceptionTable.Size);
// Authenticode CertificateTable directory. Shall be zero before the PE is signed.
builder.WriteUInt32(0);
builder.WriteUInt32(0);
builder.WriteUInt32((uint)directories.BaseRelocationTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.BaseRelocationTable.Size);
builder.WriteUInt32((uint)directories.DebugTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.DebugTable.Size);
builder.WriteUInt32((uint)directories.CopyrightTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.CopyrightTable.Size);
builder.WriteUInt32((uint)directories.GlobalPointerTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.GlobalPointerTable.Size);
builder.WriteUInt32((uint)directories.ThreadLocalStorageTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.ThreadLocalStorageTable.Size);
builder.WriteUInt32((uint)directories.LoadConfigTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.LoadConfigTable.Size);
builder.WriteUInt32((uint)directories.BoundImportTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.BoundImportTable.Size);
builder.WriteUInt32((uint)directories.ImportAddressTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.ImportAddressTable.Size);
builder.WriteUInt32((uint)directories.DelayImportTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.DelayImportTable.Size);
builder.WriteUInt32((uint)directories.CorHeaderTable.RelativeVirtualAddress);
builder.WriteUInt32((uint)directories.CorHeaderTable.Size);
// Reserved, should be 0
builder.WriteUInt64(0);
}
private void SerializeConstantTable(BlobBuilder writer, MetadataSizes metadataSizes)
{
// Note: we can sort the table at this point since no other table can reference its rows via RowId or CodedIndex (which would need updating otherwise).
var ordered = _constantTableNeedsSorting ? (IEnumerable<ConstantRow>)_constantTable.OrderBy((x, y) => (int)x.Parent - (int)y.Parent) : _constantTable;
foreach (ConstantRow constant in ordered)
{
writer.WriteByte(constant.Type);
writer.WriteByte(0);
writer.WriteReference(constant.Parent, metadataSizes.HasConstantCodedIndexSize);
writer.WriteReference((uint)GetHeapOffset(constant.Value), metadataSizes.BlobIndexSize);
}
}
private static void WriteNameTable(BlobBuilder builder)
{
int start = builder.Count;
foreach (char ch in CorEntryPointDll)
{
builder.WriteByte((byte)ch);
}
builder.WriteByte(0);
builder.WriteUInt16(0);
Debug.Assert(builder.Count - start == SizeOfNameTable);
}
private void WriteImportTable(BlobBuilder builder, int importTableRva, int importAddressTableRva)
{
int start = builder.Count;
int ilRVA = importTableRva + 40;
int hintRva = ilRVA + (Is32Bit ? 12 : 16);
int nameRva = hintRva + 12 + 2;
// Import table
builder.WriteUInt32((uint)ilRVA); // 4
builder.WriteUInt32(0); // 8
builder.WriteUInt32(0); // 12
builder.WriteUInt32((uint)nameRva); // 16
builder.WriteUInt32((uint)importAddressTableRva); // 20
builder.WriteBytes(0, 20); // 40
// Import Lookup table
if (Is32Bit)
{
builder.WriteUInt32((uint)hintRva); // 44
builder.WriteUInt32(0); // 48
builder.WriteUInt32(0); // 52
}
else
{
builder.WriteUInt64((uint)hintRva); // 48
builder.WriteUInt64(0); // 56
}
// Hint table
builder.WriteUInt16(0); // Hint 54|58
foreach (char ch in CorEntryPointName)
{
builder.WriteByte((byte)ch); // 65|69
}
builder.WriteByte(0); // 66|70
Debug.Assert(builder.Count - start == SizeOfImportTable);
}
internal static void WriteConstant(BlobBuilder writer, object value)
{
if (value == null)
{
// The encoding of Type for the nullref value for FieldInit is ELEMENT_TYPE_CLASS with a Value of a 32-bit.
writer.WriteUInt32(0);
return;
}
var type = value.GetType();
if (type.GetTypeInfo().IsEnum)
{
type = Enum.GetUnderlyingType(type);
}
if (type == typeof(bool))
{
writer.WriteBoolean((bool)value);
}
else if (type == typeof(int))
{
writer.WriteInt32((int)value);
}
else if (type == typeof(string))
{
writer.WriteUTF16((string)value);
}
else if (type == typeof(byte))
{
writer.WriteByte((byte)value);
}
else if (type == typeof(char))
{
writer.WriteUInt16((char)value);
}
else if (type == typeof(double))
{
writer.WriteDouble((double)value);
}
else if (type == typeof(short))
{
writer.WriteInt16((short)value);
}
else if (type == typeof(long))
{
writer.WriteInt64((long)value);
}
else if (type == typeof(sbyte))
{
writer.WriteSByte((sbyte)value);
}
else if (type == typeof(float))
{
writer.WriteSingle((float)value);
}
else if (type == typeof(ushort))
{
writer.WriteUInt16((ushort)value);
}
else if (type == typeof(uint))
{
writer.WriteUInt32((uint)value);
}
else if (type == typeof(ulong))
{
writer.WriteUInt64((ulong)value);
}
else
{
throw new ArgumentException(SR.Format(SR.InvalidConstantValueOfType, type));
}
}
private static void WriteOpCode(BlobBuilder writer, ILOpCode code)
{
var size = code.Size();
if (size == 1)
{
writer.WriteByte((byte)code);
}
else
{
// IL opcodes that occupy two bytes are written to
// the byte stream with the high-order byte first,
// in contrast to the little-endian format of the
// numeric arguments and tokens.
Debug.Assert(size == 2);
writer.WriteByte((byte)((ushort)code >> 8));
writer.WriteByte((byte)((ushort)code & 0xff));
}
}
public void TryOpenAssociatedPortablePdb_DuplicateEntries_Embedded()
{
var pdbBuilder1 = new BlobBuilder();
pdbBuilder1.WriteBytes(PortablePdbs.DocumentsPdb);
var pdbBuilder2 = new BlobBuilder();
pdbBuilder2.WriteByte(1);
var id = new BlobContentId(Guid.Parse("18091B06-32BB-46C2-9C3B-7C9389A2F6C6"), 0x12345678);
var ddBuilder = new DebugDirectoryBuilder();
ddBuilder.AddCodeViewEntry(@"/a/b/a.pdb", id, portablePdbVersion: 0x0100);
ddBuilder.AddReproducibleEntry();
ddBuilder.AddEmbeddedPortablePdbEntry(pdbBuilder1, portablePdbVersion: 0x0100);
ddBuilder.AddEmbeddedPortablePdbEntry(pdbBuilder2, portablePdbVersion: 0x0100);
var peStream = new MemoryStream(TestBuilders.BuildPEWithDebugDirectory(ddBuilder));
using (var reader = new PEReader(peStream))
{
string pathQueried = null;
Func<string, Stream> streamProvider = p =>
{
Assert.Null(pathQueried);
pathQueried = p;
return null;
};
MetadataReaderProvider pdbProvider;
string pdbPath;
Assert.True(reader.TryOpenAssociatedPortablePdb(Path.Combine("pedir", "file.exe"), streamProvider, out pdbProvider, out pdbPath));
Assert.Equal(PathUtilities.CombinePathWithRelativePath("pedir", "a.pdb"), pathQueried);
Assert.Null(pdbPath);
Assert.Equal(13, pdbProvider.GetMetadataReader().Documents.Count);
}
}
private static void WriteSectionHeader(BlobBuilder builder, SerializedSection serializedSection)
{
if (serializedSection.VirtualSize == 0)
{
return;
}
for (int j = 0, m = serializedSection.Name.Length; j < 8; j++)
{
if (j < m)
{
builder.WriteByte((byte)serializedSection.Name[j]);
}
else
{
builder.WriteByte(0);
}
}
builder.WriteUInt32((uint)serializedSection.VirtualSize);
builder.WriteUInt32((uint)serializedSection.RelativeVirtualAddress);
builder.WriteUInt32((uint)serializedSection.SizeOfRawData);
builder.WriteUInt32((uint)serializedSection.PointerToRawData);
// PointerToRelocations (TODO: not supported):
builder.WriteUInt32(0);
// PointerToLinenumbers (TODO: not supported):
builder.WriteUInt32(0);
// NumberOfRelocations (TODO: not supported):
builder.WriteUInt16(0);
// NumberOfLinenumbers (TODO: not supported):
builder.WriteUInt16(0);
builder.WriteUInt32((uint)serializedSection.Characteristics);
}
private void SerializeTablesHeader(BlobBuilder writer, MetadataSizes metadataSizes)
{
int startPosition = writer.Position;
HeapSizeFlag heapSizes = 0;
if (metadataSizes.StringIndexSize > 2)
{
heapSizes |= HeapSizeFlag.StringHeapLarge;
}
if (metadataSizes.GuidIndexSize > 2)
{
heapSizes |= HeapSizeFlag.GuidHeapLarge;
}
if (metadataSizes.BlobIndexSize > 2)
{
heapSizes |= HeapSizeFlag.BlobHeapLarge;
}
if (metadataSizes.IsMinimalDelta)
{
heapSizes |= (HeapSizeFlag.EnCDeltas | HeapSizeFlag.DeletedMarks);
}
ulong sortedDebugTables = metadataSizes.PresentTablesMask & MetadataSizes.SortedDebugTables;
// Consider filtering out type system tables that are not present:
ulong sortedTables = sortedDebugTables | (metadataSizes.IsStandaloneDebugMetadata ? 0UL : 0x16003301fa00);
writer.WriteUInt32(0); // reserved
writer.WriteByte(MetadataFormatMajorVersion);
writer.WriteByte(MetadataFormatMinorVersion);
writer.WriteByte((byte)heapSizes);
writer.WriteByte(1); // reserved
writer.WriteUInt64(metadataSizes.PresentTablesMask);
writer.WriteUInt64(sortedTables);
MetadataWriterUtilities.SerializeRowCounts(writer, metadataSizes.RowCounts);
int endPosition = writer.Position;
Debug.Assert(metadataSizes.CalculateTableStreamHeaderSize() == endPosition - startPosition);
}
private readonly static byte[] zeroStamp = new byte[4]; // four bytes of zero
/// <summary>
/// Write the entire "Debug Directory (Image Only)" along with data that it points to.
/// </summary>
internal void WriteDebugTable(BlobBuilder builder, PESectionLocation textSectionLocation, ContentId nativePdbContentId, ContentId portablePdbContentId)
{
Debug.Assert(builder.Count == 0);
int tableSize = ImageDebugDirectoryBaseSize;
Debug.Assert(tableSize != 0);
Debug.Assert(nativePdbContentId.IsDefault || portablePdbContentId.IsDefault);
Debug.Assert(!EmitPdb || (nativePdbContentId.IsDefault ^ portablePdbContentId.IsDefault));
int dataSize = ComputeSizeOfDebugDirectoryData();
if (EmitPdb)
{
const int IMAGE_DEBUG_TYPE_CODEVIEW = 2; // from PE spec
uint dataOffset = (uint)(ComputeOffsetToDebugTable() + tableSize);
WriteDebugTableEntry(builder,
stamp: nativePdbContentId.Stamp ?? portablePdbContentId.Stamp,
version: portablePdbContentId.IsDefault ? (uint)0 : ('P' << 24 | 'M' << 16 | 0x01 << 8 | 0x00),
debugType: IMAGE_DEBUG_TYPE_CODEVIEW,
sizeOfData: (uint)dataSize,
addressOfRawData: (uint)textSectionLocation.RelativeVirtualAddress + dataOffset, // RVA of the data
pointerToRawData: (uint)textSectionLocation.PointerToRawData + dataOffset); // position of the data in the PE stream
}
if (IsDeterministic)
{
const int IMAGE_DEBUG_TYPE_NO_TIMESTAMP = 16; // from PE spec
WriteDebugTableEntry(builder,
stamp: zeroStamp,
version: 0,
debugType: IMAGE_DEBUG_TYPE_NO_TIMESTAMP,
sizeOfData: 0,
addressOfRawData: 0,
pointerToRawData: 0);
}
// We should now have written all and precisely the data we said we'd write for the table entries.
Debug.Assert(builder.Count == tableSize);
// ====================
// The following is additional data beyond the debug directory at the offset `dataOffset`
// pointed to by the ImageDebugTypeCodeView entry.
if (EmitPdb)
{
builder.WriteByte((byte)'R');
builder.WriteByte((byte)'S');
builder.WriteByte((byte)'D');
builder.WriteByte((byte)'S');
// PDB id:
builder.WriteBytes(nativePdbContentId.Guid ?? portablePdbContentId.Guid);
// age
builder.WriteUInt32(1); // TODO: allow specify for native PDBs
// UTF-8 encoded zero-terminated path to PDB
int pathStart = builder.Count;
builder.WriteUTF8(PdbPathOpt, allowUnpairedSurrogates: true);
builder.WriteByte(0);
// padding:
builder.WriteBytes(0, Math.Max(0, MinPdbPath - (builder.Count - pathStart)));
}
// We should now have written all and precisely the data we said we'd write for the table and its data.
Debug.Assert(builder.Count == tableSize + dataSize);
}
internal void SerializeMetadataTables(
BlobBuilder writer,
MetadataSizes metadataSizes,
int methodBodyStreamRva,
int mappedFieldDataStreamRva)
{
int startPosition = writer.Position;
this.SerializeTablesHeader(writer, metadataSizes);
if (metadataSizes.IsPresent(TableIndex.Module))
{
SerializeModuleTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.TypeRef))
{
this.SerializeTypeRefTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.TypeDef))
{
this.SerializeTypeDefTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.Field))
{
this.SerializeFieldTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.MethodDef))
{
this.SerializeMethodDefTable(writer, metadataSizes, methodBodyStreamRva);
}
if (metadataSizes.IsPresent(TableIndex.Param))
{
this.SerializeParamTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.InterfaceImpl))
{
this.SerializeInterfaceImplTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.MemberRef))
{
this.SerializeMemberRefTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.Constant))
{
this.SerializeConstantTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.CustomAttribute))
{
this.SerializeCustomAttributeTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.FieldMarshal))
{
this.SerializeFieldMarshalTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.DeclSecurity))
{
this.SerializeDeclSecurityTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.ClassLayout))
{
this.SerializeClassLayoutTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.FieldLayout))
{
this.SerializeFieldLayoutTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.StandAloneSig))
{
this.SerializeStandAloneSigTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.EventMap))
{
this.SerializeEventMapTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.Event))
{
this.SerializeEventTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.PropertyMap))
{
this.SerializePropertyMapTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.Property))
{
this.SerializePropertyTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.MethodSemantics))
{
this.SerializeMethodSemanticsTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.MethodImpl))
{
this.SerializeMethodImplTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.ModuleRef))
{
this.SerializeModuleRefTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.TypeSpec))
{
this.SerializeTypeSpecTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.ImplMap))
{
this.SerializeImplMapTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.FieldRva))
{
this.SerializeFieldRvaTable(writer, metadataSizes, mappedFieldDataStreamRva);
}
if (metadataSizes.IsPresent(TableIndex.EncLog))
{
this.SerializeEncLogTable(writer);
}
if (metadataSizes.IsPresent(TableIndex.EncMap))
{
this.SerializeEncMapTable(writer);
}
if (metadataSizes.IsPresent(TableIndex.Assembly))
{
this.SerializeAssemblyTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.AssemblyRef))
{
this.SerializeAssemblyRefTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.File))
{
this.SerializeFileTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.ExportedType))
{
this.SerializeExportedTypeTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.ManifestResource))
{
this.SerializeManifestResourceTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.NestedClass))
{
this.SerializeNestedClassTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.GenericParam))
{
this.SerializeGenericParamTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.MethodSpec))
{
this.SerializeMethodSpecTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.GenericParamConstraint))
{
this.SerializeGenericParamConstraintTable(writer, metadataSizes);
}
// debug tables
if (metadataSizes.IsPresent(TableIndex.Document))
{
this.SerializeDocumentTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.MethodDebugInformation))
{
this.SerializeMethodDebugInformationTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.LocalScope))
{
this.SerializeLocalScopeTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.LocalVariable))
{
this.SerializeLocalVariableTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.LocalConstant))
{
this.SerializeLocalConstantTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.ImportScope))
{
this.SerializeImportScopeTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.StateMachineMethod))
{
this.SerializeStateMachineMethodTable(writer, metadataSizes);
}
if (metadataSizes.IsPresent(TableIndex.CustomDebugInformation))
{
this.SerializeCustomDebugInformationTable(writer, metadataSizes);
}
writer.WriteByte(0);
writer.Align(4);
int endPosition = writer.Position;
Debug.Assert(metadataSizes.MetadataTableStreamSize == endPosition - startPosition);
}
private void WriteRuntimeStartupStub(BlobBuilder sectionBuilder, int importAddressTableRva, ulong baseAddress)
{
// entry point code, consisting of a jump indirect to _CorXXXMain
if (Is32Bit)
{
// Write zeros (nops) to pad the entry point code so that the target address is aligned on a 4 byte boundary.
// Note that the section is aligned to FileAlignment, which is at least 512, so we can align relatively to the start of the section.
sectionBuilder.Align(4);
sectionBuilder.WriteUInt16(0);
sectionBuilder.WriteByte(0xff);
sectionBuilder.WriteByte(0x25); //4
sectionBuilder.WriteUInt32((uint)importAddressTableRva + (uint)baseAddress); //8
}
else
{
// Write zeros (nops) to pad the entry point code so that the target address is aligned on a 8 byte boundary.
// Note that the section is aligned to FileAlignment, which is at least 512, so we can align relatively to the start of the section.
sectionBuilder.Align(8);
sectionBuilder.WriteUInt32(0);
sectionBuilder.WriteUInt16(0);
sectionBuilder.WriteByte(0xff);
sectionBuilder.WriteByte(0x25); //8
sectionBuilder.WriteUInt64((ulong)importAddressTableRva + baseAddress); //16
}
}
