public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
builder.RequireInitialPointerAlignment();
builder.AddSymbol(this);
ImmutableArray <DebugDirectoryEntry> entries = _module.PEReader.ReadDebugDirectory();
int numEntries = GetNumDebugDirectoryEntriesInModule();
// First, write the native debug directory entry
{
var entry = (NativeDebugDirectoryEntryNode)factory.DebugDirectoryEntry(_module, -1);
builder.EmitUInt(0 /* Characteristics */);
if (numEntries > 0)
{
builder.EmitUInt(entries[0].Stamp);
builder.EmitUShort(entries[0].MajorVersion);
}
else
{
builder.EmitUInt(0);
builder.EmitUShort(0);
}
// Make sure the "is portable pdb" indicator (MinorVersion == 0x504d) is clear
// for the NGen debug directory entry since this debug directory can be copied
// from an existing entry which could be a portable pdb.
builder.EmitUShort(0 /* MinorVersion */);
builder.EmitInt((int)DebugDirectoryEntryType.CodeView);
builder.EmitInt(entry.Size);
builder.EmitReloc(entry, RelocType.IMAGE_REL_BASED_ADDR32NB);
builder.EmitReloc(entry, RelocType.IMAGE_REL_FILE_ABSOLUTE);
}
// Second, copy existing entries from input module
for (int i = 0; i < numEntries; i++)
{
builder.EmitUInt(0 /* Characteristics */);
builder.EmitUInt(entries[i].Stamp);
builder.EmitUShort(entries[i].MajorVersion);
builder.EmitUShort(entries[i].MinorVersion);
builder.EmitInt((int)entries[i].Type);
builder.EmitInt(entries[i].DataSize);
if (entries[i].DataSize == 0)
{
builder.EmitUInt(0);
builder.EmitUInt(0);
}
else
{
builder.EmitReloc(factory.DebugDirectoryEntry(_module, i), RelocType.IMAGE_REL_BASED_ADDR32NB);
builder.EmitReloc(factory.DebugDirectoryEntry(_module, i), RelocType.IMAGE_REL_FILE_ABSOLUTE);
}
}
Debug.Assert(builder.CountBytes == Size);
return(builder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
builder.RequireInitialPointerAlignment();
builder.AddSymbol(this);
builder.EmitBytes(Encoding.ASCII.GetBytes(_compilerIdentifier));
return(builder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
builder.RequireInitialPointerAlignment();
builder.AddSymbol(this);
builder.EmitBytes(Encoding.UTF8.GetBytes(_ownerExecutableName));
return(builder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
builder.RequireInitialPointerAlignment();
builder.AddSymbol(this);
EmitHeaderPrefix(ref builder);
// Don't bother sorting if we're not emitting the contents
if (!relocsOnly)
{
_items.MergeSort((x, y) => Comparer <int> .Default.Compare((int)x.Id, (int)y.Id));
}
// ReadyToRunHeader.Flags
builder.EmitInt((int)_flags);
// ReadyToRunHeader.NumberOfSections
ObjectDataBuilder.Reservation sectionCountReservation = builder.ReserveInt();
int count = 0;
foreach (var item in _items)
{
// Skip empty entries
if (!relocsOnly && item.Node is ObjectNode on && on.ShouldSkipEmittingObjectNode(factory))
{
continue;
}
// Unmarked nodes are not part of the graph
if (!item.Node.Marked && !(item.Node is ObjectNode))
{
Debug.Assert(item.Node is DelayLoadMethodCallThunkNodeRange);
continue;
}
builder.EmitInt((int)item.Id);
builder.EmitReloc(item.StartSymbol, RelocType.IMAGE_REL_BASED_ADDR32NB);
// The header entry for the runtime functions table should not include the 4 byte 0xffffffff sentinel
// value in the covered range.
int delta = item.Id == ReadyToRunSectionType.RuntimeFunctions ? RuntimeFunctionsTableNode.SentinelSizeAdjustment : 0;
builder.EmitReloc(item.StartSymbol, RelocType.IMAGE_REL_SYMBOL_SIZE, delta);
count++;
}
builder.EmitInt(sectionCountReservation, count);
return(builder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
builder.RequireInitialPointerAlignment();
builder.AddSymbol(this);
// Emit empty entry. This will be filled with data after the output image is emitted
builder.EmitZeros(RSDSSize);
return(builder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
builder.RequireInitialPointerAlignment();
builder.AddSymbol(this);
// Don't bother sorting if we're not emitting the contents
if (!relocsOnly)
{
_items.Sort((x, y) => Comparer <int> .Default.Compare((int)x.Id, (int)y.Id));
}
// ReadyToRunHeader.Magic
builder.EmitInt((int)(ReadyToRunHeaderConstants.Signature));
// ReadyToRunHeader.MajorVersion
builder.EmitShort((short)(ReadyToRunHeaderConstants.CurrentMajorVersion));
builder.EmitShort((short)(ReadyToRunHeaderConstants.CurrentMinorVersion));
// ReadyToRunHeader.Flags
builder.EmitInt(0);
// ReadyToRunHeader.NumberOfSections
ObjectDataBuilder.Reservation sectionCountReservation = builder.ReserveInt();
int count = 0;
foreach (var item in _items)
{
// Skip empty entries
if (!relocsOnly && item.Node.ShouldSkipEmittingObjectNode(factory))
{
continue;
}
builder.EmitInt((int)item.Id);
builder.EmitReloc(item.StartSymbol, RelocType.IMAGE_REL_BASED_ADDR32NB);
if (!relocsOnly)
{
builder.EmitInt(item.Node.GetData(factory).Data.Length);
}
count++;
}
builder.EmitInt(sectionCountReservation, count);
return(builder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
if (relocsOnly)
{
return(new ObjectData(
data: Array.Empty <byte>(),
relocs: Array.Empty <Relocation>(),
alignment: 1,
definedSymbols: new ISymbolDefinitionNode[] { this }));
}
ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
builder.RequireInitialPointerAlignment();
builder.AddSymbol(this);
builder.EmitBytes(GetRvaData(factory.Target.PointerSize));
return(builder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
builder.RequireInitialPointerAlignment();
builder.AddSymbol(this);
EmitHeaderPrefix(ref builder);
// Don't bother sorting if we're not emitting the contents
if (!relocsOnly)
{
_items.MergeSort((x, y) => Comparer <int> .Default.Compare((int)x.Id, (int)y.Id));
}
// ReadyToRunHeader.Flags
builder.EmitInt((int)_flags);
// ReadyToRunHeader.NumberOfSections
ObjectDataBuilder.Reservation sectionCountReservation = builder.ReserveInt();
int count = 0;
foreach (var item in _items)
{
// Skip empty entries
if (!relocsOnly && item.Node.ShouldSkipEmittingObjectNode(factory))
{
continue;
}
builder.EmitInt((int)item.Id);
builder.EmitReloc(item.StartSymbol, RelocType.IMAGE_REL_BASED_ADDR32NB);
builder.EmitReloc(item.StartSymbol, RelocType.IMAGE_REL_SYMBOL_SIZE);
count++;
}
builder.EmitInt(sectionCountReservation, count);
return(builder.ToObjectData());
}
protected override void GetElementDataForNodes(ref ObjectDataBuilder builder, NodeFactory factory, bool relocsOnly)
{
builder.RequireInitialPointerAlignment();
int index = 0;
foreach (ImportSectionNode node in NodesList)
{
if (!relocsOnly && !node.ShouldSkipEmittingTable(factory))
{
node.InitializeOffsetFromBeginningOfArray(builder.CountBytes);
node.InitializeIndexFromBeginningOfArray(index++);
}
node.EncodeData(ref builder, factory, relocsOnly);
if (node is ISymbolDefinitionNode symbolDef)
{
builder.AddSymbol(symbolDef);
}
}
}
public unsafe override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
builder.RequireInitialPointerAlignment();
builder.AddSymbol(this);
BlobReader metadataBlob = new BlobReader(_sourceModule.PEReader.GetMetadata().Pointer, _sourceModule.PEReader.GetMetadata().Length);
var metadataReader = _sourceModule.MetadataReader;
//
// methodDef table
//
int methodDefTableOffset = metadataReader.GetTableMetadataOffset(TableIndex.MethodDef);
builder.EmitBytes(metadataBlob.ReadBytes(methodDefTableOffset));
WriteMethodTableRvas(factory, ref builder, ref metadataBlob);
//
// fieldRva table
//
int fieldRvaTableOffset = metadataReader.GetTableMetadataOffset(TableIndex.FieldRva);
builder.EmitBytes(metadataBlob.ReadBytes(fieldRvaTableOffset - metadataBlob.Offset));
WriteFieldRvas(factory, ref builder, ref metadataBlob);
// Copy the rest of the metadata blob
builder.EmitBytes(metadataBlob.ReadBytes(metadataReader.MetadataLength - metadataBlob.Offset));
Debug.Assert(builder.CountBytes == metadataBlob.Length);
Debug.Assert(builder.CountBytes == metadataBlob.Offset);
Debug.Assert(builder.CountBytes == Size);
return(builder.ToObjectData());
}
public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
{
ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
builder.RequireInitialPointerAlignment();
builder.AddSymbol(this);
BlobReader reader = _module.PEReader.GetEntireImage().GetReader();
reader.Offset = _module.PEReader.PEHeaders.CorHeaderStartOffset;
// Header Size
int headerSize = reader.ReadInt32();
builder.EmitInt(headerSize);
// Runtime major, minor version
builder.EmitUShort(reader.ReadUInt16());
builder.EmitUShort(reader.ReadUInt16());
// Metadata Directory
ReadDirectoryEntry(ref reader);
var metadataBlob = factory.CopiedMetadataBlob(_module);
builder.EmitReloc(metadataBlob, RelocType.IMAGE_REL_BASED_ADDR32NB);
builder.EmitInt(metadataBlob.Size);
// Flags
builder.EmitUInt((uint)(((CorFlags)reader.ReadUInt32() & ~CorFlags.ILOnly) | CorFlags.ILLibrary));
// Entrypoint
builder.EmitInt(reader.ReadInt32());
// Resources Directory
if (ReadDirectoryEntry(ref reader).Size > 0)
{
var managedResources = factory.CopiedManagedResources(_module);
builder.EmitReloc(managedResources, RelocType.IMAGE_REL_BASED_ADDR32NB);
builder.EmitInt(managedResources.Size);
}
else
{
WriteEmptyDirectoryEntry(ref builder);
}
// Strong Name Signature Directory
if (ReadDirectoryEntry(ref reader).Size > 0)
{
var strongNameSignature = factory.CopiedStrongNameSignature(_module);
builder.EmitReloc(strongNameSignature, RelocType.IMAGE_REL_BASED_ADDR32NB);
builder.EmitInt(strongNameSignature.Size);
}
else
{
WriteEmptyDirectoryEntry(ref builder);
}
// Code Manager Table Directory
ReadDirectoryEntry(ref reader);
WriteEmptyDirectoryEntry(ref builder);
// VTable Fixups Directory
ReadDirectoryEntry(ref reader);
WriteEmptyDirectoryEntry(ref builder);
// Export Address Table Jumps Directory
ReadDirectoryEntry(ref reader);
WriteEmptyDirectoryEntry(ref builder);
// Managed Native (ReadyToRun) Header Directory
ReadDirectoryEntry(ref reader);
builder.EmitReloc(factory.Header, RelocType.IMAGE_REL_BASED_ADDR32NB);
builder.EmitReloc(factory.Header, RelocType.IMAGE_REL_SYMBOL_SIZE);
// Did we fully read the header?
Debug.Assert(reader.Offset - headerSize == _module.PEReader.PEHeaders.CorHeaderStartOffset);
Debug.Assert(builder.CountBytes == headerSize);
Debug.Assert(headerSize == Size);
return(builder.ToObjectData());
}