public override void Compile(string outputFile)
{
_dependencyGraph.ComputeMarkedNodes();
var nodes = _dependencyGraph.MarkedNodeList;
nodes = _fileLayoutOptimizer.ApplyProfilerGuidedMethodSort(nodes);
using (PerfEventSource.StartStopEvents.EmittingEvents())
{
NodeFactory.SetMarkingComplete();
ReadyToRunObjectWriter.EmitObject(outputFile, componentModule: null, nodes, NodeFactory, _generateMapFile, _customPESectionAlignment);
CompilationModuleGroup moduleGroup = _nodeFactory.CompilationModuleGroup;
if (moduleGroup.IsCompositeBuildMode)
{
// In composite mode with standalone MSIL we rewrite all input MSIL assemblies to the
// output folder, adding a formal R2R header to them with forwarding information to
// the composite executable.
string outputDirectory = Path.GetDirectoryName(outputFile);
string ownerExecutableName = Path.GetFileName(outputFile);
foreach (string inputFile in _inputFiles)
{
string relativeMsilPath = Path.GetRelativePath(_compositeRootPath, inputFile);
if (relativeMsilPath == inputFile || relativeMsilPath.StartsWith(s_folderUpPrefix, StringComparison.Ordinal))
{
// Input file not under the composite root, emit to root output folder
relativeMsilPath = Path.GetFileName(inputFile);
}
string standaloneMsilOutputFile = Path.Combine(outputDirectory, relativeMsilPath);
RewriteComponentFile(inputFile: inputFile, outputFile: standaloneMsilOutputFile, ownerExecutableName: ownerExecutableName);
}
}
}
}
private void RewriteComponentFile(string inputFile, string outputFile, string ownerExecutableName)
{
EcmaModule inputModule = NodeFactory.TypeSystemContext.GetModuleFromPath(inputFile);
Directory.CreateDirectory(Path.GetDirectoryName(outputFile));
CopiedCorHeaderNode copiedCorHeader = new CopiedCorHeaderNode(inputModule);
DebugDirectoryNode debugDirectory = new DebugDirectoryNode(inputModule, outputFile);
NodeFactory componentFactory = new NodeFactory(
_nodeFactory.TypeSystemContext,
_nodeFactory.CompilationModuleGroup,
_nodeFactory.NameMangler,
copiedCorHeader,
debugDirectory,
win32Resources: new Win32Resources.ResourceData(inputModule),
Internal.ReadyToRunConstants.ReadyToRunFlags.READYTORUN_FLAG_Component |
Internal.ReadyToRunConstants.ReadyToRunFlags.READYTORUN_FLAG_NonSharedPInvokeStubs);
IComparer <DependencyNodeCore <NodeFactory> > comparer = new SortableDependencyNode.ObjectNodeComparer(new CompilerComparer());
DependencyAnalyzerBase <NodeFactory> componentGraph = new DependencyAnalyzer <NoLogStrategy <NodeFactory>, NodeFactory>(componentFactory, comparer);
componentGraph.AddRoot(componentFactory.Header, "Component module R2R header");
OwnerCompositeExecutableNode ownerExecutableNode = new OwnerCompositeExecutableNode(_nodeFactory.Target, ownerExecutableName);
componentGraph.AddRoot(ownerExecutableNode, "Owner composite executable name");
componentGraph.AddRoot(copiedCorHeader, "Copied COR header");
componentGraph.AddRoot(debugDirectory, "Debug directory");
if (componentFactory.Win32ResourcesNode != null)
{
componentGraph.AddRoot(componentFactory.Win32ResourcesNode, "Win32 resources");
}
componentGraph.ComputeMarkedNodes();
componentFactory.Header.Add(Internal.Runtime.ReadyToRunSectionType.OwnerCompositeExecutable, ownerExecutableNode, ownerExecutableNode);
ReadyToRunObjectWriter.EmitObject(outputFile, componentModule: inputModule, componentGraph.MarkedNodeList, componentFactory, generateMapFile: false, customPESectionAlignment: null);
}
public override void Compile(string outputFile)
{
_dependencyGraph.ComputeMarkedNodes();
var nodes = _dependencyGraph.MarkedNodeList;
using (PerfEventSource.StartStopEvents.EmittingEvents())
{
NodeFactory.SetMarkingComplete();
ReadyToRunObjectWriter.EmitObject(outputFile, componentModule: null, nodes, NodeFactory, _generateMapFile);
CompilationModuleGroup moduleGroup = _nodeFactory.CompilationModuleGroup;
if (moduleGroup.IsCompositeBuildMode)
{
// In composite mode with standalone MSIL we rewrite all input MSIL assemblies to the
// output folder, adding a format R2R header to them with forwarding information to
// the composite executable.
string outputDirectory = Path.GetDirectoryName(outputFile);
string ownerExecutableName = Path.GetFileName(outputFile);
foreach (string inputFile in _inputFiles)
{
string standaloneMsilOutputFile = Path.Combine(outputDirectory, Path.GetFileName(inputFile));
RewriteComponentFile(inputFile: inputFile, outputFile: standaloneMsilOutputFile, ownerExecutableName: ownerExecutableName);
}
}
}
}
protected override void CompileInternal(string outputFile, ObjectDumper dumper)
{
using (FileStream inputFile = File.OpenRead(_inputFilePath))
{
PEReader inputPeReader = new PEReader(inputFile);
_dependencyGraph.ComputeMarkedNodes();
var nodes = _dependencyGraph.MarkedNodeList;
NodeFactory.SetMarkingComplete();
ReadyToRunObjectWriter.EmitObject(inputPeReader, outputFile, nodes, NodeFactory);
}
}
public override void Compile(string outputFile)
{
using (FileStream inputFile = File.OpenRead(_inputFilePath))
{
PEReader inputPeReader = new PEReader(inputFile);
_dependencyGraph.ComputeMarkedNodes();
var nodes = _dependencyGraph.MarkedNodeList;
PerfEventSource.Log.EmittingStart();
NodeFactory.SetMarkingComplete();
ReadyToRunObjectWriter.EmitObject(inputPeReader, outputFile, nodes, NodeFactory);
PerfEventSource.Log.EmittingStop();
}
}
private void RewriteComponentFile(string inputFile, string outputFile, string ownerExecutableName)
{
EcmaModule inputModule = NodeFactory.TypeSystemContext.GetModuleFromPath(inputFile);
Directory.CreateDirectory(Path.GetDirectoryName(outputFile));
ReadyToRunFlags flags =
ReadyToRunFlags.READYTORUN_FLAG_Component |
ReadyToRunFlags.READYTORUN_FLAG_NonSharedPInvokeStubs;
if (inputModule.IsPlatformNeutral)
{
flags |= ReadyToRunFlags.READYTORUN_FLAG_PlatformNeutralSource;
}
flags |= _nodeFactory.CompilationModuleGroup.GetReadyToRunFlags() & ReadyToRunFlags.READYTORUN_FLAG_MultiModuleVersionBubble;
CopiedCorHeaderNode copiedCorHeader = new CopiedCorHeaderNode(inputModule);
// Re-written components shouldn't have any additional diagnostic information - only information about the forwards.
// Even with all of this, we might be modifying the image in a silly manner - adding a directory when if didn't have one.
DebugDirectoryNode debugDirectory = new DebugDirectoryNode(inputModule, outputFile, shouldAddNiPdb: false, shouldGeneratePerfmap: false);
NodeFactory componentFactory = new NodeFactory(
_nodeFactory.TypeSystemContext,
_nodeFactory.CompilationModuleGroup,
null,
_nodeFactory.NameMangler,
copiedCorHeader,
debugDirectory,
win32Resources: new Win32Resources.ResourceData(inputModule),
flags,
_nodeFactory.OptimizationFlags,
_nodeFactory.ImageBase);
IComparer <DependencyNodeCore <NodeFactory> > comparer = new SortableDependencyNode.ObjectNodeComparer(CompilerComparer.Instance);
DependencyAnalyzerBase <NodeFactory> componentGraph = new DependencyAnalyzer <NoLogStrategy <NodeFactory>, NodeFactory>(componentFactory, comparer);
componentGraph.AddRoot(componentFactory.Header, "Component module R2R header");
OwnerCompositeExecutableNode ownerExecutableNode = new OwnerCompositeExecutableNode(_nodeFactory.Target, ownerExecutableName);
componentGraph.AddRoot(ownerExecutableNode, "Owner composite executable name");
componentGraph.AddRoot(copiedCorHeader, "Copied COR header");
componentGraph.AddRoot(debugDirectory, "Debug directory");
if (componentFactory.Win32ResourcesNode != null)
{
componentGraph.AddRoot(componentFactory.Win32ResourcesNode, "Win32 resources");
}
componentGraph.ComputeMarkedNodes();
componentFactory.Header.Add(Internal.Runtime.ReadyToRunSectionType.OwnerCompositeExecutable, ownerExecutableNode, ownerExecutableNode);
ReadyToRunObjectWriter.EmitObject(
outputFile,
componentModule: inputModule,
inputFiles: new string[] { inputFile },
componentGraph.MarkedNodeList,
componentFactory,
generateMapFile: false,
generateMapCsvFile: false,
generatePdbFile: false,
pdbPath: null,
generatePerfMapFile: false,
perfMapPath: null,
perfMapFormatVersion: _perfMapFormatVersion,
generateProfileFile: false,
_profileData.CallChainProfile,
customPESectionAlignment: 0);
}