public void EmitBlobWithRelocs(byte[] blob, Relocation[] relocs)
{
int nextRelocOffset = -1;
int nextRelocIndex = -1;
if (relocs.Length > 0)
{
nextRelocOffset = relocs[0].Offset;
nextRelocIndex = 0;
}
int i = 0;
while (i < blob.Length)
{
if (i == nextRelocOffset)
{
Relocation reloc = relocs[nextRelocIndex];
int size = EmitSymbolReference(reloc.Target, reloc.Delta, reloc.RelocType);
// Update nextRelocIndex/Offset
if (++nextRelocIndex < relocs.Length)
{
nextRelocOffset = relocs[nextRelocIndex].Offset;
}
i += size;
}
else
{
EmitIntValue(blob[i], 1);
i++;
}
}
}
public void AddRelocAtOffset(ISymbolNode symbol, RelocType relocType, int offset, int delta = 0)
{
Relocation symbolReloc = new Relocation();
symbolReloc.Target = symbol;
symbolReloc.RelocType = relocType;
symbolReloc.Offset = offset;
symbolReloc.Delta = delta;
_relocs.Add(symbolReloc);
}
public void EmitBlobWithRelocs(byte[] blob, Relocation[] relocs)
{
int nextRelocOffset = -1;
int nextRelocIndex = -1;
if (relocs.Length > 0)
{
nextRelocOffset = relocs[0].Offset;
nextRelocIndex = 0;
}
int i = 0;
while (i < blob.Length)
{
if (i == nextRelocOffset)
{
Relocation reloc = relocs[nextRelocIndex];
// Make sure we've gotten the correct size for the reloc
Debug.Assert(reloc.RelocType == RelocType.IMAGE_REL_BASED_DIR64 ||
reloc.RelocType == RelocType.IMAGE_REL_BASED_HIGHLOW);
long delta;
unsafe
{
fixed(void *location = &blob[i])
{
delta = Relocation.ReadValue(reloc.RelocType, location);
}
}
int size = EmitSymbolReference(reloc.Target, (int)delta, reloc.RelocType);
// Update nextRelocIndex/Offset
if (++nextRelocIndex < relocs.Length)
{
nextRelocOffset = relocs[nextRelocIndex].Offset;
}
i += size;
}
else
{
EmitIntValue(blob[i], 1);
i++;
}
}
}
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
{
}
}
}
}
private String GetCodeForReloc(Relocation reloc, DependencyNode node, NodeFactory factory)
{
CppGenerationBuffer relocCode = new CppGenerationBuffer();
if (reloc.Target is CppMethodCodeNode)
{
var method = reloc.Target as CppMethodCodeNode;
relocCode.Append("(void*)&");
relocCode.Append(GetCppMethodDeclarationName(method.Method.OwningType, GetCppMethodName(method.Method)));
}
else if (reloc.Target is EETypeNode && node is EETypeNode)
{
relocCode.Append(GetCppMethodDeclarationName((reloc.Target as EETypeNode).Type, "__getMethodTable"));
relocCode.Append("()");
}
// Node is either an non-emitted type or a generic composition - both are ignored for CPP codegen
else if ((reloc.Target is TypeManagerIndirectionNode || reloc.Target is InterfaceDispatchMapNode || reloc.Target is EETypeOptionalFieldsNode || reloc.Target is GenericCompositionNode) && !(reloc.Target as ObjectNode).ShouldSkipEmittingObjectNode(factory))
{
string mangledTargetName = reloc.Target.GetMangledName();
bool shouldReplaceNamespaceQualifier = reloc.Target is GenericCompositionNode || reloc.Target is EETypeOptionalFieldsNode;
relocCode.Append(shouldReplaceNamespaceQualifier ? mangledTargetName.Replace("::", "_") : mangledTargetName);
relocCode.Append("()");
}
else if (reloc.Target is ObjectAndOffsetSymbolNode &&
(reloc.Target as ObjectAndOffsetSymbolNode).Target is ArrayOfEmbeddedPointersNode<InterfaceDispatchMapNode>)
{
relocCode.Append("dispatchMapModule");
}
else
{
relocCode.Append("NULL");
}
return relocCode.ToString();
}
private String GetCodeForNodeData(List<NodeDataSection> nodeDataSections, Relocation[] relocs, byte[] byteData, DependencyNode node, int offset, NodeFactory factory)
{
CppGenerationBuffer nodeDataDecl = new CppGenerationBuffer();
int relocCounter = 0;
int divisionStartIndex = offset;
nodeDataDecl.Indent();
nodeDataDecl.Indent();
nodeDataDecl.AppendLine();
for (int i = 0; i < nodeDataSections.Count; i++)
{
if (nodeDataSections[i].SectionType == NodeDataSectionType.Relocation)
{
Relocation reloc = relocs[relocCounter];
nodeDataDecl.Append(GetCodeForReloc(reloc, node, factory));
nodeDataDecl.Append(",");
relocCounter++;
}
else
{
AppendFormattedByteArray(nodeDataDecl, byteData, divisionStartIndex, divisionStartIndex + nodeDataSections[i].SectionSize);
nodeDataDecl.Append(",");
}
divisionStartIndex += nodeDataSections[i].SectionSize;
nodeDataDecl.AppendLine();
}
return nodeDataDecl.ToString();
}
public static void EmitObject(string objectFilePath, IEnumerable <DependencyNode> nodes, NodeFactory factory)
{
using (ObjectWriter objectWriter = new ObjectWriter(objectFilePath, factory))
{
string currentSection = "";
// Build file info map.
string[] debugFileInfos = objectWriter.BuildFileInfoMap(nodes);
if (debugFileInfos != null)
{
objectWriter.EmitDebugFileInfo(debugFileInfos.Length, debugFileInfos);
}
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 (currentSection != node.Section)
{
currentSection = node.Section;
objectWriter.SwitchSection(currentSection);
}
objectWriter.EmitAlignment(nodeContents.Alignment);
Relocation[] relocs = nodeContents.Relocs;
int nextRelocOffset = -1;
int nextRelocIndex = -1;
if (relocs != null && relocs.Length > 0)
{
nextRelocOffset = relocs[0].Offset;
nextRelocIndex = 0;
}
// Build symbol definition map.
objectWriter.BuildSymbolDefinitionMap(nodeContents.DefinedSymbols);
// Build debug location map
objectWriter.BuildDebugLocInfoMap(node);
for (int i = 0; i < nodeContents.Data.Length; i++)
{
// Emit symbol definitions if necessary
objectWriter.EmitSymbolDefinition(i);
// Emit debug loc info if needed.
objectWriter.EmitDebugLocInfo(i);
if (i == nextRelocOffset)
{
Relocation reloc = relocs[nextRelocIndex];
ISymbolNode target = reloc.Target;
string targetName = objectWriter.GetSymbolToEmitForTargetPlatform(target.MangledName);
int size = 0;
bool isPCRelative = false;
switch (reloc.RelocType)
{
case RelocType.IMAGE_REL_BASED_DIR64:
size = 8;
break;
case RelocType.IMAGE_REL_BASED_REL32:
size = 4;
isPCRelative = true;
break;
default:
throw new NotImplementedException();
}
// Emit symbol reference
objectWriter.EmitSymbolRef(targetName, size, isPCRelative, reloc.Delta);
// Update nextRelocIndex/Offset
if (++nextRelocIndex < relocs.Length)
{
nextRelocOffset = relocs[nextRelocIndex].Offset;
}
i += size - 1;
continue;
}
objectWriter.EmitIntValue(nodeContents.Data[i], 1);
}
// It is possible to have a symbol just after all of the data.
objectWriter.EmitSymbolDefinition(nodeContents.Data.Length);
// The first definition is the main node name
string nodeName = objectWriter._offsetToDefSymbol[0][0].MangledName;
// Emit frame info for object code.
if (node is INodeWithFrameInfo)
{
FrameInfo[] frameInfos = ((INodeWithFrameInfo)node).FrameInfos;
if (frameInfos != null)
{
foreach (var frameInfo in frameInfos)
{
objectWriter.EmitFrameInfo(nodeName,
frameInfo.StartOffset,
frameInfo.EndOffset,
frameInfo.BlobData.Length,
frameInfo.BlobData);
}
}
}
objectWriter.FlushDebugLocs(nodeName, nodeContents.Data.Length);
objectWriter.SwitchSection(currentSection);
}
}
}
public void AddRelocAtOffset(ISymbolNode symbol, RelocType relocType, int offset, int delta = 0)
{
Relocation symbolReloc = new Relocation();
symbolReloc.Target = symbol;
symbolReloc.RelocType = relocType;
symbolReloc.Offset = offset;
symbolReloc.Delta = delta;
_relocs.Add(symbolReloc);
}
public static void EmitObject(string objectFilePath, IEnumerable <DependencyNode> nodes, NodeFactory factory)
{
using (ObjectWriter objectWriter = new ObjectWriter(objectFilePath, factory))
{
// Build file info map.
string[] debugFileInfos = objectWriter.BuildFileInfoMap(nodes);
if (debugFileInfos != null)
{
objectWriter.EmitDebugFileInfo(debugFileInfos.Length, debugFileInfos);
}
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);
// Ensure section and alignment for the node.
objectWriter.SetSection(node.Section);
objectWriter.EmitAlignment(nodeContents.Alignment);
Relocation[] relocs = nodeContents.Relocs;
int nextRelocOffset = -1;
int nextRelocIndex = -1;
if (relocs != null && relocs.Length > 0)
{
nextRelocOffset = relocs[0].Offset;
nextRelocIndex = 0;
}
// Build symbol definition map.
objectWriter.BuildSymbolDefinitionMap(nodeContents.DefinedSymbols);
// Build CFI map (Unix) or publish unwind blob (Windows).
objectWriter.BuildCFIMap(node);
// Build debug location map
objectWriter.BuildDebugLocInfoMap(node);
for (int i = 0; i < nodeContents.Data.Length; i++)
{
// 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];
ISymbolNode target = reloc.Target;
string targetName = objectWriter.GetSymbolToEmitForTargetPlatform(target.MangledName);
int size = 0;
bool isPCRelative = false;
switch (reloc.RelocType)
{
case RelocType.IMAGE_REL_BASED_DIR64:
size = 8;
break;
case RelocType.IMAGE_REL_BASED_REL32:
size = 4;
isPCRelative = true;
break;
default:
throw new NotImplementedException();
}
// Emit symbol reference
objectWriter.EmitSymbolRef(targetName, size, isPCRelative, reloc.Delta);
// Update nextRelocIndex/Offset
if (++nextRelocIndex < relocs.Length)
{
nextRelocOffset = relocs[nextRelocIndex].Offset;
}
i += size - 1;
continue;
}
objectWriter.EmitIntValue(nodeContents.Data[i], 1);
}
// 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);
objectWriter.FlushDebugLocs(nodeContents.Data.Length);
}
}
}
private String GetCodeForReloc(Relocation reloc, DependencyNode node, NodeFactory factory)
{
CppGenerationBuffer relocCode = new CppGenerationBuffer();
if (reloc.Target is CppMethodCodeNode)
{
var method = reloc.Target as CppMethodCodeNode;
relocCode.Append("(void*)&");
relocCode.Append(GetCppMethodDeclarationName(method.Method.OwningType, GetCppMethodName(method.Method)));
}
else if (reloc.Target is EETypeNode && node is EETypeNode && (reloc.Target as EETypeNode).Marked)
{
relocCode.Append(GetCppMethodDeclarationName((reloc.Target as EETypeNode).Type, "__getMethodTable"));
relocCode.Append("()");
}
// Node is either an non-emitted type or a generic composition - both are ignored for CPP codegen
else if ((reloc.Target is ModuleManagerIndirectionNode || reloc.Target is InterfaceDispatchMapNode || reloc.Target is EETypeOptionalFieldsNode) && !(reloc.Target as ObjectNode).ShouldSkipEmittingObjectNode(factory))
{
relocCode.Append(reloc.Target.MangledName);
relocCode.Append("()");
}
else if (reloc.Target is ObjectAndOffsetSymbolNode && (reloc.Target as ObjectAndOffsetSymbolNode).GetName().Contains("DispatchMap"))
{
relocCode.Append("dispatchMapModule");
}
else
{
relocCode.Append("NULL");
}
return relocCode.ToString();
}
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 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
{
}
}
}
}
private String GetCodeForNodeData(List<NodeDataSection> nodeDataSections, Relocation[] relocs, byte[] byteData, DependencyNode node, int offset)
{
CppGenerationBuffer nodeDataDecl = new CppGenerationBuffer();
int relocCounter = 0;
int divisionStartIndex = offset;
nodeDataDecl.Indent();
nodeDataDecl.AppendLine();
for (int i = 0; i < nodeDataSections.Count; i++)
{
nodeDataDecl.Indent();
if (nodeDataSections[i].SectionType == NodeDataSectionType.Relocation)
{
Relocation reloc = relocs[relocCounter];
if (reloc.Target is CppMethodCodeNode)
{
var method = reloc.Target as CppMethodCodeNode;
nodeDataDecl.Append("(void*)&");
nodeDataDecl.Append(GetCppMethodDeclarationName(method.Method.OwningType, GetCppMethodName(method.Method)));
nodeDataDecl.Append(",");
}
else if (reloc.Target is EETypeNode && node is EETypeNode && _emittedTypes.Contains((reloc.Target as EETypeNode).Type))
{
nodeDataDecl.Append(GetCppMethodDeclarationName((reloc.Target as EETypeNode).Type, "__getMethodTable"));
nodeDataDecl.Append("(),");
}
else
{
// TODO Add support for other relocs
nodeDataDecl.Append("NULL,");
}
relocCounter++;
}
else
{
AppendFormattedByteArray(nodeDataDecl, byteData, divisionStartIndex, divisionStartIndex + nodeDataSections[i].SectionSize);
nodeDataDecl.Append(",");
}
divisionStartIndex += nodeDataSections[i].SectionSize;
nodeDataDecl.AppendLine();
nodeDataDecl.Exdent();
}
return nodeDataDecl.ToString();
}
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, 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 AddRelocAtOffset(ISymbolNode symbol, RelocType relocType, int offset, int delta = 0)
{
Relocation symbolReloc = new Relocation(relocType, offset, symbol, delta);
_relocs.Add(symbolReloc);
}
public void EmitBlobWithRelocs(byte[] blob, Relocation[] relocs)
{
int nextRelocOffset = -1;
int nextRelocIndex = -1;
if (relocs.Length > 0)
{
nextRelocOffset = relocs[0].Offset;
nextRelocIndex = 0;
}
int i = 0;
while (i < blob.Length)
{
if (i == nextRelocOffset)
{
Relocation reloc = relocs[nextRelocIndex];
int size = EmitSymbolReference(reloc.Target, reloc.Delta, reloc.RelocType);
// Update nextRelocIndex/Offset
if (++nextRelocIndex < relocs.Length)
{
nextRelocOffset = relocs[nextRelocIndex].Offset;
}
i += size;
}
else
{
EmitIntValue(blob[i], 1);
i++;
}
}
}
public void AddRelocAtOffset(ISymbolNode symbol, RelocType relocType, int offset, int delta = 0)
{
Relocation symbolReloc = new Relocation(relocType, offset, symbol, delta);
_relocs.Add(symbolReloc);
}
