public void CompileSingleFile()
{
NodeFactory.NameMangler = NameMangler;
_nodeFactory = new NodeFactory(_typeSystemContext, _typeInitManager, _compilationModuleGroup, _options.IsCppCodeGen);
// Choose which dependency graph implementation to use based on the amount of logging requested.
if (_options.DgmlLog == null)
{
// No log uses the NoLogStrategy
_dependencyGraph = new DependencyAnalyzer<NoLogStrategy<NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
if (_options.FullLog)
{
// Full log uses the full log strategy
_dependencyGraph = new DependencyAnalyzer<FullGraphLogStrategy<NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
// Otherwise, use the first mark strategy
_dependencyGraph = new DependencyAnalyzer<FirstMarkLogStrategy<NodeFactory>, NodeFactory>(_nodeFactory, null);
}
}
_nodeFactory.AttachToDependencyGraph(_dependencyGraph);
_compilationModuleGroup.AddWellKnownTypes();
_compilationModuleGroup.AddCompilationRoots();
if (!_options.IsCppCodeGen && !_options.MultiFile)
{
// TODO: build a general purpose way to hook up pieces that would be part of the core library
// if factoring of the core library respected how things are, versus how they would be in
// a magic world (future customers of this mechanism will be interop and serialization).
var refExec = _typeSystemContext.GetModuleForSimpleName("System.Private.Reflection.Execution");
var exec = refExec.GetKnownType("Internal.Reflection.Execution", "ReflectionExecution");
AddCompilationRoot(exec.GetStaticConstructor(), "Reflection execution");
}
if (_options.IsCppCodeGen)
{
_cppWriter = new CppCodeGen.CppWriter(this);
_dependencyGraph.ComputeDependencyRoutine += CppCodeGenComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
_cppWriter.OutputCode(nodes, _compilationModuleGroup.StartupCodeMain);
}
else
{
_corInfo = new CorInfoImpl(this);
_dependencyGraph.ComputeDependencyRoutine += ComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
ObjectWriter.EmitObject(_options.OutputFilePath, nodes, _nodeFactory);
}
if (_options.DgmlLog != null)
{
using (FileStream dgmlOutput = new FileStream(_options.DgmlLog, FileMode.Create))
{
DgmlWriter.WriteDependencyGraphToStream(dgmlOutput, _dependencyGraph);
dgmlOutput.Flush();
}
}
}
public void Compile()
{
NodeFactory.NameMangler = NameMangler;
string systemModuleName = ((IAssemblyDesc)_typeSystemContext.SystemModule).GetName().Name;
// TODO: just something to get Runtime.Base compiled
if (systemModuleName != "System.Private.CoreLib")
{
NodeFactory.CompilationUnitPrefix = systemModuleName.Replace(".", "_");
}
else
{
NodeFactory.CompilationUnitPrefix = NameMangler.SanitizeName(Path.GetFileNameWithoutExtension(Options.OutputFilePath));
}
if (_options.IsCppCodeGen)
{
_nodeFactory = new CppCodegenNodeFactory(_typeSystemContext, _compilationModuleGroup);
}
else
{
_nodeFactory = new RyuJitNodeFactory(_typeSystemContext, _compilationModuleGroup);
}
// Choose which dependency graph implementation to use based on the amount of logging requested.
if (_options.DgmlLog == null)
{
// No log uses the NoLogStrategy
_dependencyGraph = new DependencyAnalyzer <NoLogStrategy <NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
if (_options.FullLog)
{
// Full log uses the full log strategy
_dependencyGraph = new DependencyAnalyzer <FullGraphLogStrategy <NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
// Otherwise, use the first mark strategy
_dependencyGraph = new DependencyAnalyzer <FirstMarkLogStrategy <NodeFactory>, NodeFactory>(_nodeFactory, null);
}
}
_nodeFactory.AttachToDependencyGraph(_dependencyGraph);
if (_options.IsCppCodeGen)
{
_cppWriter = new CppCodeGen.CppWriter(this);
_dependencyGraph.ComputeDependencyRoutine += CppCodeGenComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
_cppWriter.OutputCode(nodes, _compilationModuleGroup.StartupCodeMain, _nodeFactory);
}
else
{
_corInfo = new CorInfoImpl(this);
_dependencyGraph.ComputeDependencyRoutine += ComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
ObjectWriter.EmitObject(_options.OutputFilePath, nodes, _nodeFactory);
}
if (_options.DgmlLog != null)
{
using (FileStream dgmlOutput = new FileStream(_options.DgmlLog, FileMode.Create))
{
DgmlWriter.WriteDependencyGraphToStream(dgmlOutput, _dependencyGraph);
dgmlOutput.Flush();
}
}
}
public void CompileSingleFile()
{
NodeFactory.NameMangler = NameMangler;
_nodeFactory = new NodeFactory(_typeSystemContext, _typeInitManager, _compilationModuleGroup, _options.IsCppCodeGen);
// Choose which dependency graph implementation to use based on the amount of logging requested.
if (_options.DgmlLog == null)
{
// No log uses the NoLogStrategy
_dependencyGraph = new DependencyAnalyzer<NoLogStrategy<NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
if (_options.FullLog)
{
// Full log uses the full log strategy
_dependencyGraph = new DependencyAnalyzer<FullGraphLogStrategy<NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
// Otherwise, use the first mark strategy
_dependencyGraph = new DependencyAnalyzer<FirstMarkLogStrategy<NodeFactory>, NodeFactory>(_nodeFactory, null);
}
}
_nodeFactory.AttachToDependencyGraph(_dependencyGraph);
_compilationModuleGroup.AddWellKnownTypes();
_compilationModuleGroup.AddCompilationRoots();
if (_options.IsCppCodeGen)
{
_cppWriter = new CppCodeGen.CppWriter(this);
_dependencyGraph.ComputeDependencyRoutine += CppCodeGenComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
_cppWriter.OutputCode(nodes, _compilationModuleGroup.StartupCodeMain);
}
else
{
_corInfo = new CorInfoImpl(this);
_dependencyGraph.ComputeDependencyRoutine += ComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
ObjectWriter.EmitObject(_options.OutputFilePath, nodes, _nodeFactory);
}
if (_options.DgmlLog != null)
{
using (FileStream dgmlOutput = new FileStream(_options.DgmlLog, FileMode.Create))
{
DgmlWriter.WriteDependencyGraphToStream(dgmlOutput, _dependencyGraph);
dgmlOutput.Flush();
}
}
}
public void CompileSingleFile()
{
NodeFactory.NameMangler = NameMangler;
_nodeFactory = new NodeFactory(_typeSystemContext, _options.IsCppCodeGen);
// Choose which dependency graph implementation to use based on the amount of logging requested.
if (_options.DgmlLog == null)
{
// No log uses the NoLogStrategy
_dependencyGraph = new DependencyAnalyzer <NoLogStrategy <NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
if (_options.FullLog)
{
// Full log uses the full log strategy
_dependencyGraph = new DependencyAnalyzer <FullGraphLogStrategy <NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
// Otherwise, use the first mark strategy
_dependencyGraph = new DependencyAnalyzer <FirstMarkLogStrategy <NodeFactory>, NodeFactory>(_nodeFactory, null);
}
}
_nodeFactory.AttachToDependencyGraph(_dependencyGraph);
AddWellKnownTypes();
AddCompilationRoots();
if (_options.IsCppCodeGen)
{
_cppWriter = new CppCodeGen.CppWriter(this);
_dependencyGraph.ComputeDependencyRoutine += CppCodeGenComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
_cppWriter.OutputCode(nodes);
}
else
{
_corInfo = new CorInfoImpl(this);
_dependencyGraph.ComputeDependencyRoutine += ComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
ObjectWriter.EmitObject(_options.OutputFilePath, nodes, _nodeFactory);
}
if (_options.DgmlLog != null)
{
using (FileStream dgmlOutput = new FileStream(_options.DgmlLog, FileMode.Create))
{
DgmlWriter.WriteDependencyGraphToStream(dgmlOutput, _dependencyGraph);
dgmlOutput.Flush();
}
}
}
public void CompileSingleFile(MethodDesc mainMethod)
{
if (_options.IsCppCodeGen)
{
_cppWriter = new CppCodeGen.CppWriter(this);
}
else
{
_corInfo = new CorInfoImpl(this);
}
_mainMethod = mainMethod;
if (!_options.IsCppCodeGen)
{
NodeFactory.NameMangler = NameMangler;
_nodeFactory = new NodeFactory(_typeSystemContext);
// Choose which dependency graph implementation to use based on the amount of logging requested.
if (_options.DgmlLog == null)
{
// No log uses the NoLogStrategy
_dependencyGraph = new DependencyAnalyzer<NoLogStrategy<NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
if (_options.FullLog)
{
// Full log uses the full log strategy
_dependencyGraph = new DependencyAnalyzer<FullGraphLogStrategy<NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
// Otherwise, use the first mark strategy
_dependencyGraph = new DependencyAnalyzer<FirstMarkLogStrategy<NodeFactory>, NodeFactory>(_nodeFactory, null);
}
}
_nodeFactory.AttachToDependencyGraph(_dependencyGraph);
AddWellKnownTypes();
AddCompilationRoots();
_dependencyGraph.ComputeDependencyRoutine += ComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
ObjectWriter.EmitObject(OutputPath, nodes, _nodeFactory);
if (_options.DgmlLog != null)
{
using (FileStream dgmlOutput = new FileStream(_options.DgmlLog, FileMode.Create))
{
DgmlWriter.WriteDependencyGraphToStream(dgmlOutput, _dependencyGraph);
dgmlOutput.Flush();
}
}
}
else
{
AddWellKnownTypes();
AddCompilationRoots();
while (_methodsThatNeedsCompilation != null)
{
CompileMethods();
ExpandVirtualMethods();
}
_cppWriter.OutputCode();
}
}
public void Compile()
{
NodeFactory.NameMangler = NameMangler;
string systemModuleName = ((IAssemblyDesc)_typeSystemContext.SystemModule).GetName().Name;
// TODO: just something to get Runtime.Base compiled
if (systemModuleName != "System.Private.CoreLib")
{
NodeFactory.CompilationUnitPrefix = systemModuleName.Replace(".", "_");
}
else
{
NodeFactory.CompilationUnitPrefix = NameMangler.SanitizeName(Path.GetFileNameWithoutExtension(Options.OutputFilePath));
}
if (_options.IsCppCodeGen)
{
_nodeFactory = new CppCodegenNodeFactory(_typeSystemContext, _compilationModuleGroup);
}
else
{
_nodeFactory = new RyuJitNodeFactory(_typeSystemContext, _compilationModuleGroup);
}
// Choose which dependency graph implementation to use based on the amount of logging requested.
if (_options.DgmlLog == null)
{
// No log uses the NoLogStrategy
_dependencyGraph = new DependencyAnalyzer<NoLogStrategy<NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
if (_options.FullLog)
{
// Full log uses the full log strategy
_dependencyGraph = new DependencyAnalyzer<FullGraphLogStrategy<NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
// Otherwise, use the first mark strategy
_dependencyGraph = new DependencyAnalyzer<FirstMarkLogStrategy<NodeFactory>, NodeFactory>(_nodeFactory, null);
}
}
_nodeFactory.AttachToDependencyGraph(_dependencyGraph);
if (_options.IsCppCodeGen)
{
_cppWriter = new CppCodeGen.CppWriter(this);
_dependencyGraph.ComputeDependencyRoutine += CppCodeGenComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
_cppWriter.OutputCode(nodes, _compilationModuleGroup.StartupCodeMain, _nodeFactory);
}
else
{
_corInfo = new CorInfoImpl(this);
_dependencyGraph.ComputeDependencyRoutine += ComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
ObjectWriter.EmitObject(_options.OutputFilePath, nodes, _nodeFactory);
}
if (_options.DgmlLog != null)
{
using (FileStream dgmlOutput = new FileStream(_options.DgmlLog, FileMode.Create))
{
DgmlWriter.WriteDependencyGraphToStream(dgmlOutput, _dependencyGraph);
dgmlOutput.Flush();
}
}
}
public void CompileSingleFile()
{
NodeFactory.NameMangler = NameMangler;
_nodeFactory = new NodeFactory(_typeSystemContext, _typeInitManager, _compilationModuleGroup, _options.IsCppCodeGen);
// Choose which dependency graph implementation to use based on the amount of logging requested.
if (_options.DgmlLog == null)
{
// No log uses the NoLogStrategy
_dependencyGraph = new DependencyAnalyzer <NoLogStrategy <NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
if (_options.FullLog)
{
// Full log uses the full log strategy
_dependencyGraph = new DependencyAnalyzer <FullGraphLogStrategy <NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
// Otherwise, use the first mark strategy
_dependencyGraph = new DependencyAnalyzer <FirstMarkLogStrategy <NodeFactory>, NodeFactory>(_nodeFactory, null);
}
}
_nodeFactory.AttachToDependencyGraph(_dependencyGraph);
_compilationModuleGroup.AddWellKnownTypes();
_compilationModuleGroup.AddCompilationRoots();
if (!_options.IsCppCodeGen && !_options.MultiFile)
{
// TODO: build a general purpose way to hook up pieces that would be part of the core library
// if factoring of the core library respected how things are, versus how they would be in
// a magic world (future customers of this mechanism will be interop and serialization).
var refExec = _typeSystemContext.GetModuleForSimpleName("System.Private.Reflection.Execution");
var exec = refExec.GetKnownType("Internal.Reflection.Execution", "ReflectionExecution");
AddCompilationRoot(exec.GetStaticConstructor(), "Reflection execution");
}
if (_options.IsCppCodeGen)
{
_cppWriter = new CppCodeGen.CppWriter(this);
_dependencyGraph.ComputeDependencyRoutine += CppCodeGenComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
_cppWriter.OutputCode(nodes, _compilationModuleGroup.StartupCodeMain);
}
else
{
_corInfo = new CorInfoImpl(this);
_dependencyGraph.ComputeDependencyRoutine += ComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
ObjectWriter.EmitObject(_options.OutputFilePath, nodes, _nodeFactory);
}
if (_options.DgmlLog != null)
{
using (FileStream dgmlOutput = new FileStream(_options.DgmlLog, FileMode.Create))
{
DgmlWriter.WriteDependencyGraphToStream(dgmlOutput, _dependencyGraph);
dgmlOutput.Flush();
}
}
}
public void CompileSingleFile(MethodDesc mainMethod)
{
if (_options.IsCppCodeGen)
{
_cppWriter = new CppCodeGen.CppWriter(this);
}
else
{
_corInfo = new CorInfoImpl(this);
}
_mainMethod = mainMethod;
if (!_options.IsCppCodeGen)
{
_nodeFactory = new NodeFactory(this._typeSystemContext);
NodeFactory.NameMangler = NameMangler;
// Choose which dependency graph implementation to use based on the amount of logging requested.
if (_options.DgmlLog == null)
{
// No log uses the NoLogStrategy
_dependencyGraph = new DependencyAnalyzer <NoLogStrategy <NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
if (_options.FullLog)
{
// Full log uses the full log strategy
_dependencyGraph = new DependencyAnalyzer <FullGraphLogStrategy <NodeFactory>, NodeFactory>(_nodeFactory, null);
}
else
{
// Otherwise, use the first mark strategy
_dependencyGraph = new DependencyAnalyzer <FirstMarkLogStrategy <NodeFactory>, NodeFactory>(_nodeFactory, null);
}
}
_nodeFactory.AttachToDependencyGraph(_dependencyGraph);
AddWellKnownTypes();
AddCompilationRoots();
_dependencyGraph.ComputeDependencyRoutine += ComputeDependencyNodeDependencies;
var nodes = _dependencyGraph.MarkedNodeList;
var mainMethodNode = (_mainMethod != null) ? _nodeFactory.MethodEntrypoint(_mainMethod) : null;
ObjectWriter.EmitObject(OutputPath, nodes, mainMethodNode, _nodeFactory);
if (_options.DgmlLog != null)
{
using (FileStream dgmlOutput = new FileStream(_options.DgmlLog, FileMode.Create))
{
DgmlWriter.WriteDependencyGraphToStream(dgmlOutput, _dependencyGraph);
dgmlOutput.Flush();
}
}
}
else
{
AddWellKnownTypes();
AddCompilationRoots();
while (_methodsThatNeedsCompilation != null)
{
CompileMethods();
ExpandVirtualMethods();
}
_cppWriter.OutputCode();
}
}
