public BlobNode(Utf8String name, ObjectNodeSection section, byte[] data, int alignment)
{
_name = name;
_section = section;
_data = data;
_alignment = alignment;
}
private bool ShouldShareSymbol(ObjectNode node)
{
// Foldable sections are always COMDATs
ObjectNodeSection section = node.Section;
if (section == ObjectNodeSection.FoldableManagedCodeUnixContentSection ||
section == ObjectNodeSection.FoldableManagedCodeWindowsContentSection ||
section == ObjectNodeSection.FoldableReadOnlyDataSection)
{
return(true);
}
if (_isSingleFileCompilation)
{
return(false);
}
if (_targetPlatform.OperatingSystem == TargetOS.OSX)
{
return(false);
}
if (!(node is ISymbolNode))
{
return(false);
}
// These intentionally clash with one another, but are merged with linker directives so should not be Comdat folded
if (node is ModulesSectionNode)
{
return(false);
}
return(true);
}
public BlobNode(Utf8String name, ObjectNodeSection section, byte[] data, int alignment)
{
_name = name;
_section = section;
_data = data;
_alignment = alignment;
}
/// <summary>
/// Builds a set of CustomSectionAttributes flags from an ObjectNodeSection.
/// </summary>
private CustomSectionAttributes GetCustomSectionAttributes(ObjectNodeSection section)
{
CustomSectionAttributes attributes = 0;
switch (section.Type)
{
case SectionType.Executable:
attributes |= CustomSectionAttributes.Executable;
break;
case SectionType.ReadOnly:
attributes |= CustomSectionAttributes.ReadOnly;
break;
case SectionType.Writeable:
attributes |= CustomSectionAttributes.Writeable;
break;
}
switch (section.Attributes)
{
case SectionAttributes.MachOInitFuncPointers:
attributes |= CustomSectionAttributes.MachOInitFuncPointers;
break;
}
return(attributes);
}
public void SetSection(ObjectNodeSection section)
{
if (!section.IsStandardSection && !_customSectionNames.Contains(section.Name))
{
CreateCustomSection(section);
}
_currentSectionName = section.Name;
SwitchSection(_nativeObjectWriter, section.Name);
}
public void SetSection(ObjectNodeSection section)
{
if (!section.IsStandardSection && !_customSectionNames.Contains(section.Name))
{
CreateCustomSection(section);
}
_currentSectionName = section.Name;
SwitchSection(_nativeObjectWriter, section.Name);
}
public void SetCodeSectionAttribute(ObjectNodeSection section)
{
if (!section.IsStandardSection)
{
SetCodeSectionAttribute(_nativeObjectWriter, section.Name, GetCustomSectionAttributes(section), section.ComdatName);
}
else
{
SetCodeSectionAttribute(_nativeObjectWriter, section.Name);
}
}
private ObjectNodeSection GetSharedSection(ObjectNodeSection section, string key)
{
string standardSectionPrefix = "";
if (section.IsStandardSection)
{
standardSectionPrefix = ".";
}
return(new ObjectNodeSection(standardSectionPrefix + section.Name, section.Type, key));
}
public void SetSection(ObjectNodeSection section)
{
if (!section.IsStandardSection)
{
SwitchSection(_nativeObjectWriter, section.Name, GetCustomSectionAttributes(section), section.ComdatName);
}
else
{
SwitchSection(_nativeObjectWriter, section.Name);
}
_currentSection = section;
}
/// <summary>
/// Emit a single ObjectData into the proper section of the output R2R PE executable.
/// </summary>
/// <param name="data">ObjectData blob to emit</param>
/// <param name="name">Textual representation of the ObjecData blob in the map file</param>
/// <param name="section">Section to emit the blob into</param>
/// <param name="mapFile">Map file output stream</param>
private void EmitObjectData(ObjectData data, int nodeIndex, string name, ObjectNodeSection section, TextWriter mapFile)
{
int targetSectionIndex;
switch (section.Type)
{
case SectionType.Executable:
targetSectionIndex = _textSectionIndex;
break;
case SectionType.Writeable:
targetSectionIndex = _dataSectionIndex;
break;
case SectionType.ReadOnly:
targetSectionIndex = _rdataSectionIndex;
break;
default:
throw new NotImplementedException();
}
#if DEBUG
for (int symbolIndex = 0; symbolIndex < data.DefinedSymbols.Length; symbolIndex++)
{
ISymbolNode definedSymbol = data.DefinedSymbols[symbolIndex];
NodeInfo alreadyWrittenSymbol;
string symbolName = definedSymbol.GetMangledName(_nodeFactory.NameMangler);
if (_previouslyWrittenNodeNames.TryGetValue(symbolName, out alreadyWrittenSymbol))
{
Console.WriteLine($@"Duplicate symbol - 1st occurrence: [{alreadyWrittenSymbol.NodeIndex}:{alreadyWrittenSymbol.SymbolIndex}], {alreadyWrittenSymbol.Node.GetMangledName(_nodeFactory.NameMangler)}");
Console.WriteLine($@"Duplicate symbol - 2nd occurrence: [{nodeIndex}:{symbolIndex}], {definedSymbol.GetMangledName(_nodeFactory.NameMangler)}");
Debug.Fail("Duplicate node name emitted to file",
$"Symbol {definedSymbol.GetMangledName(_nodeFactory.NameMangler)} has already been written to the output object file {_objectFilePath} with symbol {alreadyWrittenSymbol}");
}
_previouslyWrittenNodeNames.Add(symbolName, new NodeInfo(definedSymbol, nodeIndex, symbolIndex));
}
#endif
_sectionBuilder.AddObjectData(data, targetSectionIndex, name, mapFile);
}
/// <summary>
/// Builds a set of CustomSectionAttributes flags from an ObjectNodeSection.
/// </summary>
private CustomSectionAttributes GetCustomSectionAttributes(ObjectNodeSection section)
{
CustomSectionAttributes attributes = 0;
switch (section.Type)
{
case SectionType.Executable:
attributes |= CustomSectionAttributes.Executable;
break;
case SectionType.ReadOnly:
attributes |= CustomSectionAttributes.ReadOnly;
break;
case SectionType.Writeable:
attributes |= CustomSectionAttributes.Writeable;
break;
}
switch (section.Attributes)
{
case SectionAttributes.MachOInitFuncPointers:
attributes |= CustomSectionAttributes.MachOInitFuncPointers;
break;
}
return attributes;
}
public static void EmitObject(string objectFilePath, IEnumerable <DependencyNode> nodes, NodeFactory factory, WebAssemblyCodegenCompilation compilation, IObjectDumper dumper)
{
WebAssemblyObjectWriter objectWriter = new WebAssemblyObjectWriter(objectFilePath, factory, compilation);
bool succeeded = false;
try
{
//ObjectNodeSection managedCodeSection = null;
var listOfOffsets = new List <int>();
foreach (DependencyNode depNode in nodes)
{
ObjectNode node = depNode as ObjectNode;
if (node == null)
{
continue;
}
if (node.ShouldSkipEmittingObjectNode(factory))
{
continue;
}
objectWriter.StartObjectNode(node);
ObjectData nodeContents = node.GetData(factory);
if (dumper != null)
{
dumper.DumpObjectNode(factory.NameMangler, node, nodeContents);
}
#if DEBUG
foreach (ISymbolNode definedSymbol in nodeContents.DefinedSymbols)
{
try
{
_previouslyWrittenNodeNames.Add(definedSymbol.GetMangledName(factory.NameMangler), definedSymbol);
}
catch (ArgumentException)
{
ISymbolNode alreadyWrittenSymbol = _previouslyWrittenNodeNames[definedSymbol.GetMangledName(factory.NameMangler)];
Debug.Fail("Duplicate node name emitted to file",
$"Symbol {definedSymbol.GetMangledName(factory.NameMangler)} has already been written to the output object file {objectFilePath} with symbol {alreadyWrittenSymbol}");
}
}
#endif
ObjectNodeSection section = node.Section;
if (objectWriter.ShouldShareSymbol(node))
{
section = objectWriter.GetSharedSection(section, ((ISymbolNode)node).GetMangledName(factory.NameMangler));
}
// Ensure section and alignment for the node.
objectWriter.SetSection(section);
objectWriter.EmitAlignment(nodeContents.Alignment);
objectWriter.ResetByteRunInterruptionOffsets(nodeContents.Relocs);
// Build symbol definition map.
objectWriter.BuildSymbolDefinitionMap(node, nodeContents.DefinedSymbols);
Relocation[] relocs = nodeContents.Relocs;
int nextRelocOffset = -1;
int nextRelocIndex = -1;
if (relocs.Length > 0)
{
nextRelocOffset = relocs[0].Offset;
nextRelocIndex = 0;
}
int i = 0;
listOfOffsets.Clear();
listOfOffsets.AddRange(objectWriter._byteInterruptionOffsets);
int offsetIndex = 0;
while (i < nodeContents.Data.Length)
{
// Emit symbol definitions if necessary
objectWriter.EmitSymbolDefinition(i);
if (i == nextRelocOffset)
{
Relocation reloc = relocs[nextRelocIndex];
long delta;
unsafe
{
fixed(void *location = &nodeContents.Data[i])
{
delta = Relocation.ReadValue(reloc.RelocType, location);
}
}
int size = objectWriter.EmitSymbolReference(reloc.Target, (int)delta, reloc.RelocType);
/*
* WebAssembly has no thumb
* // Emit a copy of original Thumb2 instruction that came from RyuJIT
* if (reloc.RelocType == RelocType.IMAGE_REL_BASED_THUMB_MOV32 ||
* reloc.RelocType == RelocType.IMAGE_REL_BASED_THUMB_BRANCH24)
* {
* unsafe
* {
* fixed (void* location = &nodeContents.Data[i])
* {
* objectWriter.EmitBytes((IntPtr)location, size);
* }
* }
* }*/
// Update nextRelocIndex/Offset
if (++nextRelocIndex < relocs.Length)
{
nextRelocOffset = relocs[nextRelocIndex].Offset;
}
else
{
// This is the last reloc. Set the next reloc offset to -1 in case the last reloc has a zero size,
// which means the reloc does not have vacant bytes corresponding to in the data buffer. E.g,
// IMAGE_REL_THUMB_BRANCH24 is a kind of 24-bit reloc whose bits scatte over the instruction that
// references it. We do not vacate extra bytes in the data buffer for this kind of reloc.
nextRelocOffset = -1;
}
i += size;
}
else
{
while (offsetIndex < listOfOffsets.Count && listOfOffsets[offsetIndex] <= i)
{
offsetIndex++;
}
int nextOffset = offsetIndex == listOfOffsets.Count ? nodeContents.Data.Length : listOfOffsets[offsetIndex];
unsafe
{
// Todo: Use Span<T> instead once it's available to us in this repo
fixed(byte *pContents = &nodeContents.Data[i])
{
objectWriter.EmitBytes((IntPtr)(pContents), nextOffset - i);
i += nextOffset - i;
}
}
}
}
Debug.Assert(i == nodeContents.Data.Length);
// It is possible to have a symbol just after all of the data.
objectWriter.EmitSymbolDefinition(nodeContents.Data.Length);
objectWriter.DoneObjectNode();
}
succeeded = true;
}
finally
{
objectWriter.Dispose();
if (!succeeded)
{
// If there was an exception while generating the OBJ file, make sure we don't leave the unfinished
// object file around.
try
{
File.Delete(objectFilePath);
}
catch
{
}
}
}
}
public void SetCodeSectionAttribute(ObjectNodeSection section)
{
//throw new NotImplementedException(); // This function isn't complete
}
public void SetSection(ObjectNodeSection section)
{
_currentSection = section;
}
public void BuildCFIMap(NodeFactory factory, ObjectNode node)
{
_offsetToCfis.Clear();
_offsetToCfiStart.Clear();
_offsetToCfiEnd.Clear();
_frameOpened = false;
INodeWithCodeInfo nodeWithCodeInfo = node as INodeWithCodeInfo;
if (nodeWithCodeInfo == null)
{
return;
}
FrameInfo[] frameInfos = nodeWithCodeInfo.FrameInfos;
if (frameInfos == null)
{
return;
}
ObjectNode.ObjectData ehInfo = nodeWithCodeInfo.EHInfo;
int i = 0;
foreach (var frameInfo in frameInfos)
{
int start = frameInfo.StartOffset;
int end = frameInfo.EndOffset;
int len = frameInfo.BlobData.Length;
byte[] blob = frameInfo.BlobData;
if (_targetPlatform.OperatingSystem == TargetOS.Windows)
{
string blobSymbolName = "_unwind" + (i++).ToStringInvariant() + _currentNodeName;
ObjectNodeSection section = ObjectNodeSection.XDataSection;
if (node.ShouldShareNodeAcrossModules(factory) && factory.Target.OperatingSystem == TargetOS.Windows)
{
section = section.GetSharedSection(blobSymbolName);
CreateCustomSection(section);
}
SwitchSection(_nativeObjectWriter, section.Name);
EmitAlignment(4);
EmitSymbolDef(blobSymbolName);
if (ehInfo != null)
{
blob[blob.Length - 1] |= 0x04; // Flag to indicate that EHClauses follows
}
EmitBlob(blob);
if (ehInfo != null)
{
Debug.Assert(ehInfo.Alignment == 1);
Debug.Assert(ehInfo.DefinedSymbols.Length == 0);
EmitBlobWithRelocs(ehInfo.Data, ehInfo.Relocs);
ehInfo = null;
}
// TODO: Currently we get linker errors if we emit frame info for shared types.
// This needs follow-up investigation.
if (!node.ShouldShareNodeAcrossModules(factory))
{
// For window, just emit the frame blob (UNWIND_INFO) as a whole.
EmitWinFrameInfo(start, end, len, blobSymbolName);
}
EnsureCurrentSection();
}
else
{
// For Unix, we build CFI blob map for each offset.
Debug.Assert(len % CfiCodeSize == 0);
// Record start/end of frames which shouldn't be overlapped.
_offsetToCfiStart.Add(start);
_offsetToCfiEnd.Add(end);
for (int j = 0; j < len; j += CfiCodeSize)
{
// The first byte of CFI_CODE is offset from the range the frame covers.
// Compute code offset from the root method.
int codeOffset = blob[j] + start;
List <byte[]> cfis;
if (!_offsetToCfis.TryGetValue(codeOffset, out cfis))
{
cfis = new List <byte[]>();
_offsetToCfis.Add(codeOffset, cfis);
}
byte[] cfi = new byte[CfiCodeSize];
Array.Copy(blob, j, cfi, 0, CfiCodeSize);
cfis.Add(cfi);
}
}
}
}
public void BuildCFIMap(NodeFactory factory, ObjectNode node)
{
_offsetToCfis.Clear();
_offsetToCfiStart.Clear();
_offsetToCfiEnd.Clear();
_offsetToCfiLsdaBlobName.Clear();
_frameOpened = false;
INodeWithCodeInfo nodeWithCodeInfo = node as INodeWithCodeInfo;
if (nodeWithCodeInfo == null)
{
return;
}
FrameInfo[] frameInfos = nodeWithCodeInfo.FrameInfos;
if (frameInfos == null)
{
return;
}
byte[] gcInfo = nodeWithCodeInfo.GCInfo;
ObjectData ehInfo = nodeWithCodeInfo.EHInfo;
for (int i = 0; i < frameInfos.Length; i++)
{
FrameInfo frameInfo = frameInfos[i];
int start = frameInfo.StartOffset;
int end = frameInfo.EndOffset;
int len = frameInfo.BlobData.Length;
byte[] blob = frameInfo.BlobData;
ObjectNodeSection lsdaSection = LsdaSection;
if (ShouldShareSymbol(node))
{
lsdaSection = lsdaSection.GetSharedSection(((ISymbolNode)node).GetMangledName(_nodeFactory.NameMangler));
}
SwitchSection(_nativeObjectWriter, lsdaSection.Name, GetCustomSectionAttributes(lsdaSection), lsdaSection.ComdatName);
_sb.Clear().Append("_lsda").Append(i.ToStringInvariant()).Append(_currentNodeZeroTerminatedName);
byte[] blobSymbolName = _sb.ToUtf8String().UnderlyingArray;
EmitSymbolDef(blobSymbolName);
FrameInfoFlags flags = frameInfo.Flags;
if (ehInfo != null)
{
flags |= FrameInfoFlags.HasEHInfo;
}
EmitIntValue((byte)flags, 1);
if (i != 0)
{
EmitSymbolRef(_sb.Clear().Append("_lsda0").Append(_currentNodeZeroTerminatedName), RelocType.IMAGE_REL_BASED_REL32, 4);
// emit relative offset from the main function
EmitIntValue((ulong)(start - frameInfos[0].StartOffset), 4);
}
if (ehInfo != null)
{
EmitSymbolRef(_sb.Clear().Append("_ehInfo").Append(_currentNodeZeroTerminatedName), RelocType.IMAGE_REL_BASED_REL32, 4);
}
if (gcInfo != null)
{
EmitBlob(gcInfo);
gcInfo = null;
}
if (ehInfo != null)
{
// TODO: Place EHInfo into different section for better locality
Debug.Assert(ehInfo.Alignment == 1);
Debug.Assert(ehInfo.DefinedSymbols.Length == 0);
EmitSymbolDef(_sb /* ehInfo */);
EmitBlobWithRelocs(ehInfo.Data, ehInfo.Relocs);
ehInfo = null;
}
// For Unix, we build CFI blob map for each offset.
Debug.Assert(len % CfiCodeSize == 0);
// Record start/end of frames which shouldn't be overlapped.
_offsetToCfiStart.Add(start);
_offsetToCfiEnd.Add(end);
_offsetToCfiLsdaBlobName.Add(start, blobSymbolName);
for (int j = 0; j < len; j += CfiCodeSize)
{
// The first byte of CFI_CODE is offset from the range the frame covers.
// Compute code offset from the root method.
int codeOffset = blob[j] + start;
List <byte[]> cfis;
if (!_offsetToCfis.TryGetValue(codeOffset, out cfis))
{
cfis = new List <byte[]>();
_offsetToCfis.Add(codeOffset, cfis);
}
byte[] cfi = new byte[CfiCodeSize];
Array.Copy(blob, j, cfi, 0, CfiCodeSize);
cfis.Add(cfi);
}
}
EnsureCurrentSection();
}
public SettableReadOnlyDataBlob(Utf8String name, ObjectNodeSection section)
{
_name = name;
_section = section;
}
public static void EmitObject(string objectFilePath, IEnumerable <DependencyNode> nodes, NodeFactory factory, IObjectDumper dumper)
{
ObjectWriter objectWriter = new ObjectWriter(objectFilePath, factory);
bool succeeded = false;
try
{
ObjectNodeSection managedCodeSection;
if (factory.Target.OperatingSystem == TargetOS.Windows)
{
managedCodeSection = ObjectNodeSection.ManagedCodeWindowsContentSection;
}
else
{
managedCodeSection = ObjectNodeSection.ManagedCodeUnixContentSection;
// TODO 2916: managed code section has to be created here, switch is not necessary.
objectWriter.SetSection(ObjectNodeSection.ManagedCodeUnixContentSection);
objectWriter.SetSection(LsdaSection);
}
objectWriter.SetCodeSectionAttribute(managedCodeSection);
// Build file info map.
objectWriter.BuildFileInfoMap(nodes);
var listOfOffsets = new List <int>();
foreach (DependencyNode depNode in nodes)
{
ObjectNode node = depNode as ObjectNode;
if (node == null)
{
continue;
}
if (node.ShouldSkipEmittingObjectNode(factory))
{
continue;
}
ObjectData nodeContents = node.GetData(factory);
if (dumper != null)
{
dumper.DumpObjectNode(factory.NameMangler, node, nodeContents);
}
#if DEBUG
foreach (ISymbolNode definedSymbol in nodeContents.DefinedSymbols)
{
try
{
_previouslyWrittenNodeNames.Add(definedSymbol.GetMangledName(factory.NameMangler), definedSymbol);
}
catch (ArgumentException)
{
ISymbolNode alreadyWrittenSymbol = _previouslyWrittenNodeNames[definedSymbol.GetMangledName(factory.NameMangler)];
Debug.Fail("Duplicate node name emitted to file",
$"Symbol {definedSymbol.GetMangledName(factory.NameMangler)} has already been written to the output object file {objectFilePath} with symbol {alreadyWrittenSymbol}");
}
}
#endif
ObjectNodeSection section = node.Section;
if (objectWriter.ShouldShareSymbol(node))
{
section = objectWriter.GetSharedSection(section, ((ISymbolNode)node).GetMangledName(factory.NameMangler));
}
// Ensure section and alignment for the node.
objectWriter.SetSection(section);
objectWriter.EmitAlignment(nodeContents.Alignment);
objectWriter.ResetByteRunInterruptionOffsets(nodeContents.Relocs);
// Build symbol definition map.
objectWriter.BuildSymbolDefinitionMap(node, nodeContents.DefinedSymbols);
// The DWARF CFI unwind is implemented for AMD64 & ARM32 only.
TargetArchitecture tarch = factory.Target.Architecture;
if (!factory.Target.IsWindows &&
(tarch == TargetArchitecture.X64 || tarch == TargetArchitecture.ARM))
{
objectWriter.BuildCFIMap(factory, node);
}
// Build debug location map
objectWriter.BuildDebugLocInfoMap(node);
Relocation[] relocs = nodeContents.Relocs;
int nextRelocOffset = -1;
int nextRelocIndex = -1;
if (relocs.Length > 0)
{
nextRelocOffset = relocs[0].Offset;
nextRelocIndex = 0;
}
int i = 0;
listOfOffsets.Clear();
listOfOffsets.AddRange(objectWriter._byteInterruptionOffsets);
int offsetIndex = 0;
while (i < nodeContents.Data.Length)
{
// Emit symbol definitions if necessary
objectWriter.EmitSymbolDefinition(i);
// Emit CFI codes for the given offset.
objectWriter.EmitCFICodes(i);
// Emit debug loc info if needed.
objectWriter.EmitDebugLocInfo(i);
if (i == nextRelocOffset)
{
Relocation reloc = relocs[nextRelocIndex];
long delta;
unsafe
{
fixed(void *location = &nodeContents.Data[i])
{
delta = Relocation.ReadValue(reloc.RelocType, location);
}
}
int size = objectWriter.EmitSymbolReference(reloc.Target, (int)delta, reloc.RelocType);
// Emit a copy of original Thumb2 instruction that came from RyuJIT
if (reloc.RelocType == RelocType.IMAGE_REL_BASED_THUMB_MOV32 ||
reloc.RelocType == RelocType.IMAGE_REL_BASED_THUMB_BRANCH24)
{
unsafe
{
fixed(void *location = &nodeContents.Data[i])
{
objectWriter.EmitBytes((IntPtr)location, size);
}
}
}
// Update nextRelocIndex/Offset
if (++nextRelocIndex < relocs.Length)
{
nextRelocOffset = relocs[nextRelocIndex].Offset;
}
else
{
// This is the last reloc. Set the next reloc offset to -1 in case the last reloc has a zero size,
// which means the reloc does not have vacant bytes corresponding to in the data buffer. E.g,
// IMAGE_REL_THUMB_BRANCH24 is a kind of 24-bit reloc whose bits scatte over the instruction that
// references it. We do not vacate extra bytes in the data buffer for this kind of reloc.
nextRelocOffset = -1;
}
i += size;
}
else
{
while (offsetIndex < listOfOffsets.Count && listOfOffsets[offsetIndex] <= i)
{
offsetIndex++;
}
int nextOffset = offsetIndex == listOfOffsets.Count ? nodeContents.Data.Length : listOfOffsets[offsetIndex];
unsafe
{
// Todo: Use Span<T> instead once it's available to us in this repo
fixed(byte *pContents = &nodeContents.Data[i])
{
objectWriter.EmitBytes((IntPtr)(pContents), nextOffset - i);
i += nextOffset - i;
}
}
}
}
Debug.Assert(i == nodeContents.Data.Length);
// It is possible to have a symbol just after all of the data.
objectWriter.EmitSymbolDefinition(nodeContents.Data.Length);
// Publish Windows unwind info.
if (factory.Target.IsWindows)
{
objectWriter.PublishUnwindInfo(node);
}
// Emit the last CFI to close the frame.
objectWriter.EmitCFICodes(nodeContents.Data.Length);
if (objectWriter.HasFunctionDebugInfo())
{
objectWriter.EmitDebugVarInfo(node);
objectWriter.EmitDebugEHClauseInfo(node);
objectWriter.EmitDebugFunctionInfo(node, nodeContents.Data.Length);
}
}
objectWriter.EmitDebugModuleInfo();
succeeded = true;
}
finally
{
objectWriter.Dispose();
if (!succeeded)
{
// If there was an exception while generating the OBJ file, make sure we don't leave the unfinished
// object file around.
try
{
File.Delete(objectFilePath);
}
catch
{
}
}
}
}
public static void EmitObject(string objectFilePath, IEnumerable <DependencyNode> nodes, NodeFactory factory)
{
ObjectWriter objectWriter = new ObjectWriter(objectFilePath, factory);
bool succeeded = false;
try
{
if (factory.Target.OperatingSystem == TargetOS.Windows)
{
objectWriter.CreateCustomSection(MethodCodeNode.WindowsContentSection);
// Emit sentinels for managed code section.
ObjectNodeSection codeStartSection = factory.CompilationModuleGroup.IsSingleFileCompilation ?
MethodCodeNode.StartSection :
MethodCodeNode.StartSection.GetSharedSection("__managedcode_a");
objectWriter.SetSection(codeStartSection);
objectWriter.EmitSymbolDef(new Utf8StringBuilder().Append("__managedcode_a"));
objectWriter.EmitIntValue(0, 1);
ObjectNodeSection codeEndSection = factory.CompilationModuleGroup.IsSingleFileCompilation ?
MethodCodeNode.EndSection :
MethodCodeNode.EndSection.GetSharedSection("__managedcode_z");
objectWriter.SetSection(codeEndSection);
objectWriter.EmitSymbolDef(new Utf8StringBuilder().Append("__managedcode_z"));
objectWriter.EmitIntValue(0, 1);
}
else
{
objectWriter.CreateCustomSection(MethodCodeNode.UnixContentSection);
objectWriter.CreateCustomSection(LsdaSection);
}
// Build file info map.
objectWriter.BuildFileInfoMap(nodes);
foreach (DependencyNode depNode in nodes)
{
ObjectNode node = depNode as ObjectNode;
if (node == null)
{
continue;
}
if (node.ShouldSkipEmittingObjectNode(factory))
{
continue;
}
ObjectNode.ObjectData nodeContents = node.GetData(factory);
#if DEBUG
foreach (ISymbolNode definedSymbol in nodeContents.DefinedSymbols)
{
Debug.Assert(_previouslyWrittenNodeNames.Add(definedSymbol.GetMangledName()), "Duplicate node name emitted to file",
$"Symbol {definedSymbol.GetMangledName()} has already been written to the output object file {objectFilePath}");
}
#endif
ObjectNodeSection section = node.Section;
if (objectWriter.ShouldShareSymbol(node))
{
section = section.GetSharedSection(((ISymbolNode)node).GetMangledName());
}
// Ensure section and alignment for the node.
objectWriter.SetSection(section);
objectWriter.EmitAlignment(nodeContents.Alignment);
// Build symbol definition map.
objectWriter.BuildSymbolDefinitionMap(node, nodeContents.DefinedSymbols);
// Build CFI map (Unix) or publish unwind blob (Windows).
objectWriter.BuildCFIMap(factory, node);
// Build debug location map
objectWriter.BuildDebugLocInfoMap(node);
Relocation[] relocs = nodeContents.Relocs;
int nextRelocOffset = -1;
int nextRelocIndex = -1;
if (relocs.Length > 0)
{
nextRelocOffset = relocs[0].Offset;
nextRelocIndex = 0;
}
int i = 0;
while (i < nodeContents.Data.Length)
{
// Emit symbol definitions if necessary
objectWriter.EmitSymbolDefinition(i);
// Emit CFI codes for the given offset.
objectWriter.EmitCFICodes(i);
// Emit debug loc info if needed.
objectWriter.EmitDebugLocInfo(i);
if (i == nextRelocOffset)
{
Relocation reloc = relocs[nextRelocIndex];
long delta;
unsafe
{
fixed(void *location = &nodeContents.Data[i])
{
delta = Relocation.ReadValue(reloc.RelocType, location);
}
}
int size = objectWriter.EmitSymbolReference(reloc.Target, (int)delta, reloc.RelocType);
// Update nextRelocIndex/Offset
if (++nextRelocIndex < relocs.Length)
{
nextRelocOffset = relocs[nextRelocIndex].Offset;
}
i += size;
}
else
{
objectWriter.EmitIntValue(nodeContents.Data[i], 1);
i++;
}
}
// It is possible to have a symbol just after all of the data.
objectWriter.EmitSymbolDefinition(nodeContents.Data.Length);
// Emit the last CFI to close the frame.
objectWriter.EmitCFICodes(nodeContents.Data.Length);
if (objectWriter.HasFunctionDebugInfo())
{
// Build debug local var info
objectWriter.EmitDebugVarInfo(node);
objectWriter.EmitDebugFunctionInfo(nodeContents.Data.Length);
}
}
objectWriter.EmitDebugModuleInfo();
succeeded = true;
}
finally
{
objectWriter.Dispose();
if (!succeeded)
{
// If there was an exception while generating the OBJ file, make sure we don't leave the unfinished
// object file around.
try
{
File.Delete(objectFilePath);
}
catch
{
}
}
}
}
public static void EmitObject(string objectFilePath, IEnumerable <DependencyNode> nodes, NodeFactory factory)
{
using (ObjectWriter objectWriter = new ObjectWriter(objectFilePath, factory))
{
// TODO: Exception handling on Unix
if (factory.Target.IsWindows)
{
objectWriter.CreateCustomSection(MethodCodeNode.ContentSection);
// Emit sentinels for managed code section.
ObjectNodeSection codeStartSection = factory.CompilationModuleGroup.IsSingleFileCompilation ? MethodCodeNode.StartSection : MethodCodeNode.StartSection.GetSharedSection("__managedcode_a");
objectWriter.SetSection(codeStartSection);
objectWriter.EmitSymbolDef("__managedcode_a");
objectWriter.EmitIntValue(0, 1);
ObjectNodeSection codeEndSection = factory.CompilationModuleGroup.IsSingleFileCompilation ? MethodCodeNode.EndSection : MethodCodeNode.EndSection.GetSharedSection("__managedcode_z");
objectWriter.SetSection(codeEndSection);
objectWriter.EmitSymbolDef("__managedcode_z");
objectWriter.EmitIntValue(0, 1);
}
// Build file info map.
objectWriter.BuildFileInfoMap(nodes);
foreach (DependencyNode depNode in nodes)
{
ObjectNode node = depNode as ObjectNode;
if (node == null)
{
continue;
}
if (node.ShouldSkipEmittingObjectNode(factory))
{
continue;
}
#if DEBUG
Debug.Assert(_previouslyWrittenNodeNames.Add(node.GetName()), "Duplicate node name emitted to file", "Node {0} has already been written to the output object file {1}", node.GetName(), objectFilePath);
#endif
ObjectNode.ObjectData nodeContents = node.GetData(factory);
ObjectNodeSection section = node.Section;
if (node.ShouldShareNodeAcrossModules(factory) && factory.Target.OperatingSystem == TargetOS.Windows)
{
Debug.Assert(node is ISymbolNode);
section = section.GetSharedSection(((ISymbolNode)node).MangledName);
}
// Ensure section and alignment for the node.
objectWriter.SetSection(section);
objectWriter.EmitAlignment(nodeContents.Alignment);
// Build symbol definition map.
objectWriter.BuildSymbolDefinitionMap(node, nodeContents.DefinedSymbols);
// Build CFI map (Unix) or publish unwind blob (Windows).
objectWriter.BuildCFIMap(factory, node);
// Build debug location map
objectWriter.BuildDebugLocInfoMap(node);
Relocation[] relocs = nodeContents.Relocs;
int nextRelocOffset = -1;
int nextRelocIndex = -1;
if (relocs.Length > 0)
{
nextRelocOffset = relocs[0].Offset;
nextRelocIndex = 0;
}
int i = 0;
while (i < nodeContents.Data.Length)
{
// Emit symbol definitions if necessary
objectWriter.EmitSymbolDefinition(i);
// Emit CFI codes for the given offset.
objectWriter.EmitCFICodes(i);
// Emit debug loc info if needed.
objectWriter.EmitDebugLocInfo(i);
if (i == nextRelocOffset)
{
Relocation reloc = relocs[nextRelocIndex];
int size = objectWriter.EmitSymbolReference(reloc.Target, reloc.Delta, reloc.RelocType);
// Update nextRelocIndex/Offset
if (++nextRelocIndex < relocs.Length)
{
nextRelocOffset = relocs[nextRelocIndex].Offset;
}
i += size;
}
else
{
objectWriter.EmitIntValue(nodeContents.Data[i], 1);
i++;
}
}
// It is possible to have a symbol just after all of the data.
objectWriter.EmitSymbolDefinition(nodeContents.Data.Length);
// Emit the last CFI to close the frame.
objectWriter.EmitCFICodes(nodeContents.Data.Length);
if (objectWriter.HasFunctionDebugInfo())
{
// Build debug local var info
objectWriter.EmitDebugVarInfo(node);
objectWriter.EmitDebugFunctionInfo(nodeContents.Data.Length);
}
}
objectWriter.EmitDebugModuleInfo();
}
}
public void CreateCustomSection(ObjectNodeSection section)
{
CreateCustomSection(_nativeObjectWriter, section.Name, GetCustomSectionAttributes(section), section.ComdatName);
_customSectionNames.Add(section.Name);
}
public static void EmitObject(string objectFilePath, IEnumerable <DependencyNode> nodes, NodeFactory factory, IObjectDumper dumper)
{
ObjectWriter objectWriter = new ObjectWriter(objectFilePath, factory);
bool succeeded = false;
try
{
ObjectNodeSection managedCodeSection;
if (factory.Target.OperatingSystem == TargetOS.Windows)
{
managedCodeSection = MethodCodeNode.WindowsContentSection;
// Emit sentinels for managed code section.
ObjectNodeSection codeStartSection = factory.CompilationModuleGroup.IsSingleFileCompilation ?
MethodCodeNode.StartSection :
MethodCodeNode.StartSection.GetSharedSection("__managedcode_a");
objectWriter.SetSection(codeStartSection);
objectWriter.EmitSymbolDef(new Utf8StringBuilder().Append("__managedcode_a"));
objectWriter.EmitIntValue(0, 1);
ObjectNodeSection codeEndSection = factory.CompilationModuleGroup.IsSingleFileCompilation ?
MethodCodeNode.EndSection :
MethodCodeNode.EndSection.GetSharedSection("__managedcode_z");
objectWriter.SetSection(codeEndSection);
objectWriter.EmitSymbolDef(new Utf8StringBuilder().Append("__managedcode_z"));
objectWriter.EmitIntValue(1, 1);
}
else
{
managedCodeSection = MethodCodeNode.UnixContentSection;
// TODO 2916: managed code section has to be created here, switch is not necessary.
objectWriter.SetSection(MethodCodeNode.UnixContentSection);
objectWriter.SetSection(LsdaSection);
}
objectWriter.SetCodeSectionAttribute(managedCodeSection);
// Build file info map.
objectWriter.BuildFileInfoMap(nodes);
foreach (DependencyNode depNode in nodes)
{
ObjectNode node = depNode as ObjectNode;
if (node == null)
{
continue;
}
if (node.ShouldSkipEmittingObjectNode(factory))
{
continue;
}
ObjectData nodeContents = node.GetData(factory);
if (dumper != null)
{
dumper.DumpObjectNode(factory.NameMangler, node, nodeContents);
}
#if DEBUG
foreach (ISymbolNode definedSymbol in nodeContents.DefinedSymbols)
{
try
{
_previouslyWrittenNodeNames.Add(definedSymbol.GetMangledName(factory.NameMangler), definedSymbol);
}
catch (ArgumentException)
{
ISymbolNode alreadyWrittenSymbol = _previouslyWrittenNodeNames[definedSymbol.GetMangledName(factory.NameMangler)];
Debug.Assert(false, "Duplicate node name emitted to file",
$"Symbol {definedSymbol.GetMangledName(factory.NameMangler)} has already been written to the output object file {objectFilePath} with symbol {alreadyWrittenSymbol}");
}
}
#endif
ObjectNodeSection section = node.Section;
if (objectWriter.ShouldShareSymbol(node))
{
section = section.GetSharedSection(((ISymbolNode)node).GetMangledName(factory.NameMangler));
}
// Ensure section and alignment for the node.
objectWriter.SetSection(section);
objectWriter.EmitAlignment(nodeContents.Alignment);
// Build symbol definition map.
objectWriter.BuildSymbolDefinitionMap(node, nodeContents.DefinedSymbols);
if (!factory.Target.IsWindows)
{
objectWriter.BuildCFIMap(factory, node);
}
// Build debug location map
objectWriter.BuildDebugLocInfoMap(node);
Relocation[] relocs = nodeContents.Relocs;
int nextRelocOffset = -1;
int nextRelocIndex = -1;
if (relocs.Length > 0)
{
nextRelocOffset = relocs[0].Offset;
nextRelocIndex = 0;
}
int i = 0;
while (i < nodeContents.Data.Length)
{
// Emit symbol definitions if necessary
objectWriter.EmitSymbolDefinition(i);
// Emit CFI codes for the given offset.
objectWriter.EmitCFICodes(i);
// Emit debug loc info if needed.
objectWriter.EmitDebugLocInfo(i);
if (i == nextRelocOffset)
{
Relocation reloc = relocs[nextRelocIndex];
long delta;
unsafe
{
fixed(void *location = &nodeContents.Data[i])
{
delta = Relocation.ReadValue(reloc.RelocType, location);
}
}
int size = objectWriter.EmitSymbolReference(reloc.Target, (int)delta, reloc.RelocType);
// Update nextRelocIndex/Offset
if (++nextRelocIndex < relocs.Length)
{
nextRelocOffset = relocs[nextRelocIndex].Offset;
}
else
{
// This is the last reloc. Set the next reloc offset to -1 in case the last reloc has a zero size,
// which means the reloc does not have vacant bytes corresponding to in the data buffer. E.g,
// IMAGE_REL_THUMB_BRANCH24 is a kind of 24-bit reloc whose bits scatte over the instruction that
// references it. We do not vacate extra bytes in the data buffer for this kind of reloc.
nextRelocOffset = -1;
}
i += size;
}
else
{
objectWriter.EmitIntValue(nodeContents.Data[i], 1);
i++;
}
}
// It is possible to have a symbol just after all of the data.
objectWriter.EmitSymbolDefinition(nodeContents.Data.Length);
// Publish Windows unwind info.
if (factory.Target.IsWindows)
{
objectWriter.PublishUnwindInfo(node);
}
// Emit the last CFI to close the frame.
objectWriter.EmitCFICodes(nodeContents.Data.Length);
if (objectWriter.HasFunctionDebugInfo())
{
// Build debug local var info
objectWriter.EmitDebugVarInfo(node);
objectWriter.EmitDebugFunctionInfo(nodeContents.Data.Length);
}
}
objectWriter.EmitDebugModuleInfo();
succeeded = true;
}
finally
{
objectWriter.Dispose();
if (!succeeded)
{
// If there was an exception while generating the OBJ file, make sure we don't leave the unfinished
// object file around.
try
{
File.Delete(objectFilePath);
}
catch
{
}
}
}
}
public void PublishUnwindInfo(ObjectNode node)
{
INodeWithCodeInfo nodeWithCodeInfo = node as INodeWithCodeInfo;
if (nodeWithCodeInfo == null)
{
return;
}
FrameInfo[] frameInfos = nodeWithCodeInfo.FrameInfos;
if (frameInfos == null)
{
return;
}
byte[] gcInfo = nodeWithCodeInfo.GCInfo;
ObjectData ehInfo = nodeWithCodeInfo.EHInfo;
for (int i = 0; i < frameInfos.Length; i++)
{
FrameInfo frameInfo = frameInfos[i];
int start = frameInfo.StartOffset;
int end = frameInfo.EndOffset;
int len = frameInfo.BlobData.Length;
byte[] blob = frameInfo.BlobData;
_sb.Clear().Append(_nodeFactory.NameMangler.CompilationUnitPrefix).Append("_unwind").Append(i.ToStringInvariant());
ObjectNodeSection section = ObjectNodeSection.XDataSection;
SwitchSection(_nativeObjectWriter, section.Name);
byte[] blobSymbolName = _sb.Append(_currentNodeZeroTerminatedName).ToUtf8String().UnderlyingArray;
EmitAlignment(4);
EmitSymbolDef(blobSymbolName);
FrameInfoFlags flags = frameInfo.Flags;
if (ehInfo != null)
{
flags |= FrameInfoFlags.HasEHInfo;
}
EmitBlob(blob);
EmitIntValue((byte)flags, 1);
if (ehInfo != null)
{
EmitSymbolRef(_sb.Clear().Append(_nodeFactory.NameMangler.CompilationUnitPrefix).Append("_ehInfo").Append(_currentNodeZeroTerminatedName), RelocType.IMAGE_REL_BASED_ABSOLUTE);
}
if (gcInfo != null)
{
EmitBlob(gcInfo);
gcInfo = null;
}
if (ehInfo != null)
{
// TODO: Place EHInfo into different section for better locality
Debug.Assert(ehInfo.Alignment == 1);
Debug.Assert(ehInfo.DefinedSymbols.Length == 0);
EmitSymbolDef(_sb /* ehInfo */);
EmitBlobWithRelocs(ehInfo.Data, ehInfo.Relocs);
ehInfo = null;
}
// For window, just emit the frame blob (UNWIND_INFO) as a whole.
EmitWinFrameInfo(start, end, len, blobSymbolName);
EnsureCurrentSection();
}
}
public void CreateCustomSection(ObjectNodeSection section)
{
CreateCustomSection(_nativeObjectWriter, section.Name, GetCustomSectionAttributes(section), section.ComdatName);
_customSectionNames.Add(section.Name);
}
/// <summary>
/// Emit a single ObjectData into the proper section of the output R2R PE executable.
/// </summary>
/// <param name="r2rPeBuilder">R2R PE builder to output object data to</param>
/// <param name="data">ObjectData blob to emit</param>
/// <param name="nodeIndex">Logical index of the emitted node for diagnostic purposes</param>
/// <param name="name">Textual representation of the ObjecData blob in the map file</param>
/// <param name="section">Section to emit the blob into</param>
private void EmitObjectData(R2RPEBuilder r2rPeBuilder, ObjectData data, int nodeIndex, string name, ObjectNodeSection section)
{
#if DEBUG
for (int symbolIndex = 0; symbolIndex < data.DefinedSymbols.Length; symbolIndex++)
{
ISymbolNode definedSymbol = data.DefinedSymbols[symbolIndex];
NodeInfo alreadyWrittenSymbol;
string symbolName = definedSymbol.GetMangledName(_nodeFactory.NameMangler);
if (_previouslyWrittenNodeNames.TryGetValue(symbolName, out alreadyWrittenSymbol))
{
Console.WriteLine($@"Duplicate symbol - 1st occurrence: [{alreadyWrittenSymbol.NodeIndex}:{alreadyWrittenSymbol.SymbolIndex}], {alreadyWrittenSymbol.Node.GetMangledName(_nodeFactory.NameMangler)}");
Console.WriteLine($@"Duplicate symbol - 2nd occurrence: [{nodeIndex}:{symbolIndex}], {definedSymbol.GetMangledName(_nodeFactory.NameMangler)}");
Debug.Fail("Duplicate node name emitted to file",
$"Symbol {definedSymbol.GetMangledName(_nodeFactory.NameMangler)} has already been written to the output object file {_objectFilePath} with symbol {alreadyWrittenSymbol}");
}
_previouslyWrittenNodeNames.Add(symbolName, new NodeInfo(definedSymbol, nodeIndex, symbolIndex));
}
#endif
r2rPeBuilder.AddObjectData(data, section, name, _outputInfoBuilder);
}
public void BuildCFIMap(NodeFactory factory, ObjectNode node)
{
_offsetToCfis.Clear();
_offsetToCfiStart.Clear();
_offsetToCfiEnd.Clear();
_offsetToCfiLsdaBlobName.Clear();
_frameOpened = false;
INodeWithCodeInfo nodeWithCodeInfo = node as INodeWithCodeInfo;
if (nodeWithCodeInfo == null)
{
return;
}
FrameInfo[] frameInfos = nodeWithCodeInfo.FrameInfos;
if (frameInfos == null)
{
return;
}
byte[] gcInfo = nodeWithCodeInfo.GCInfo;
ObjectNode.ObjectData ehInfo = nodeWithCodeInfo.EHInfo;
string mainEhInfoSymbolName = null;
for (int i = 0; i < frameInfos.Length; i++)
{
FrameInfo frameInfo = frameInfos[i];
int start = frameInfo.StartOffset;
int end = frameInfo.EndOffset;
int len = frameInfo.BlobData.Length;
byte[] blob = frameInfo.BlobData;
if (_targetPlatform.OperatingSystem == TargetOS.Windows)
{
string blobSymbolName = "_unwind" + i.ToStringInvariant() + _currentNodeName;
ObjectNodeSection section = ObjectNodeSection.XDataSection;
if (node.ShouldShareNodeAcrossModules(factory) && factory.Target.OperatingSystem == TargetOS.Windows)
{
section = section.GetSharedSection(blobSymbolName);
CreateCustomSection(section);
}
SwitchSection(_nativeObjectWriter, section.Name);
EmitAlignment(4);
EmitSymbolDef(blobSymbolName);
FrameInfoFlags flags = frameInfo.Flags;
if (ehInfo != null)
{
flags |= FrameInfoFlags.HasEHInfo;
}
EmitBlob(blob);
EmitIntValue((byte)flags, 1);
if (ehInfo != null)
{
mainEhInfoSymbolName = "_ehInfo" + _currentNodeName;
EmitSymbolRef(mainEhInfoSymbolName, RelocType.IMAGE_REL_BASED_ABSOLUTE);
}
if (gcInfo != null)
{
EmitBlob(gcInfo);
gcInfo = null;
}
if (ehInfo != null)
{
// TODO: Place EHInfo into different section for better locality
Debug.Assert(ehInfo.Alignment == 1);
Debug.Assert(ehInfo.DefinedSymbols.Length == 0);
EmitSymbolDef(mainEhInfoSymbolName);
EmitBlobWithRelocs(ehInfo.Data, ehInfo.Relocs);
ehInfo = null;
}
// TODO: Currently we get linker errors if we emit frame info for shared types.
// This needs follow-up investigation.
if (!node.ShouldShareNodeAcrossModules(factory))
{
// For window, just emit the frame blob (UNWIND_INFO) as a whole.
EmitWinFrameInfo(start, end, len, blobSymbolName);
}
}
else
{
string blobSymbolName = "_lsda" + i.ToStringInvariant() + _currentNodeName;
SwitchSection(_nativeObjectWriter, LsdaSection.Name);
EmitSymbolDef(blobSymbolName);
FrameInfoFlags flags = frameInfo.Flags;
if (ehInfo != null)
{
flags |= FrameInfoFlags.HasEHInfo;
}
EmitIntValue((byte)flags, 1);
if (i != 0)
{
EmitSymbolRef("_lsda0" + _currentNodeName, RelocType.IMAGE_REL_BASED_REL32, 4);
// emit relative offset from the main function
EmitIntValue((ulong)(start - frameInfos[0].StartOffset), 4);
}
if (ehInfo != null)
{
mainEhInfoSymbolName = "_ehInfo" + _currentNodeName;
EmitSymbolRef(mainEhInfoSymbolName, RelocType.IMAGE_REL_BASED_REL32, 4);
}
if (gcInfo != null)
{
EmitBlob(gcInfo);
gcInfo = null;
}
if (ehInfo != null)
{
// TODO: Place EHInfo into different section for better locality
Debug.Assert(ehInfo.Alignment == 1);
Debug.Assert(ehInfo.DefinedSymbols.Length == 0);
EmitSymbolDef(mainEhInfoSymbolName);
EmitBlobWithRelocs(ehInfo.Data, ehInfo.Relocs);
ehInfo = null;
}
// For Unix, we build CFI blob map for each offset.
Debug.Assert(len % CfiCodeSize == 0);
// Record start/end of frames which shouldn't be overlapped.
_offsetToCfiStart.Add(start);
_offsetToCfiEnd.Add(end);
_offsetToCfiLsdaBlobName.Add(start, blobSymbolName);
for (int j = 0; j < len; j += CfiCodeSize)
{
// The first byte of CFI_CODE is offset from the range the frame covers.
// Compute code offset from the root method.
int codeOffset = blob[j] + start;
List <byte[]> cfis;
if (!_offsetToCfis.TryGetValue(codeOffset, out cfis))
{
cfis = new List <byte[]>();
_offsetToCfis.Add(codeOffset, cfis);
}
byte[] cfi = new byte[CfiCodeSize];
Array.Copy(blob, j, cfi, 0, CfiCodeSize);
cfis.Add(cfi);
}
}
EnsureCurrentSection();
}
}
