private int Run(string[] args)
{
InitializeDefaultOptions();
ArgumentSyntax syntax = ParseCommandLine(args);
if (_help)
{
Help(syntax.GetHelpText());
return(1);
}
if (_inputFilePaths.Count == 0)
{
throw new CommandLineException("No input files specified");
}
if (_outputFilePath == null)
{
throw new CommandLineException("Output filename must be specified (/out <file>)");
}
//
// Initialize type system context
//
SharedGenericsMode genericsMode = _useSharedGenerics ?
SharedGenericsMode.CanonicalReferenceTypes : SharedGenericsMode.Disabled;
var typeSystemContext = new CompilerTypeSystemContext(new TargetDetails(_targetArchitecture, _targetOS), genericsMode);
typeSystemContext.InputFilePaths = _inputFilePaths;
typeSystemContext.ReferenceFilePaths = _referenceFilePaths;
typeSystemContext.SetSystemModule(typeSystemContext.GetModuleForSimpleName(_systemModuleName));
//
// Initialize compilation group and compilation roots
//
// Single method mode?
MethodDesc singleMethod = CheckAndParseSingleMethodModeArguments(typeSystemContext);
CompilationModuleGroup compilationGroup;
List <ICompilationRootProvider> compilationRoots = new List <ICompilationRootProvider>();
if (singleMethod != null)
{
// Compiling just a single method
compilationGroup = new SingleMethodCompilationModuleGroup(singleMethod);
compilationRoots.Add(new SingleMethodRootProvider(singleMethod));
}
else
{
// Either single file, or multifile library, or multifile consumption.
EcmaModule entrypointModule = null;
foreach (var inputFile in typeSystemContext.InputFilePaths)
{
EcmaModule module = typeSystemContext.GetModuleFromPath(inputFile.Value);
if (module.PEReader.PEHeaders.IsExe)
{
if (entrypointModule != null)
{
throw new Exception("Multiple EXE modules");
}
entrypointModule = module;
}
compilationRoots.Add(new ExportedMethodsRootProvider(module));
}
if (entrypointModule != null)
{
compilationRoots.Add(new MainMethodRootProvider(entrypointModule));
}
if (_multiFile)
{
List <EcmaModule> inputModules = new List <EcmaModule>();
foreach (var inputFile in typeSystemContext.InputFilePaths)
{
EcmaModule module = typeSystemContext.GetModuleFromPath(inputFile.Value);
if (entrypointModule == null)
{
// This is a multifile production build - we need to root all methods
compilationRoots.Add(new LibraryRootProvider(module));
}
inputModules.Add(module);
}
if (entrypointModule == null)
{
compilationGroup = new MultiFileSharedCompilationModuleGroup(typeSystemContext, inputModules);
}
else
{
compilationGroup = new MultiFileLeafCompilationModuleGroup(typeSystemContext, inputModules);
}
}
else
{
if (entrypointModule == null)
{
throw new Exception("No entrypoint module");
}
compilationRoots.Add(new ExportedMethodsRootProvider((EcmaModule)typeSystemContext.SystemModule));
// System.Private.Reflection.Execution needs to establish a communication channel with System.Private.CoreLib
// at process startup. This is done through an eager constructor that calls into CoreLib and passes it
// a callback object.
//
// Since CoreLib cannot reference anything, the type and it's eager constructor won't be added to the compilation
// unless we explictly add it.
var refExec = typeSystemContext.GetModuleForSimpleName("System.Private.Reflection.Execution", false);
if (refExec != null)
{
var exec = refExec.GetType("Internal.Reflection.Execution", "ReflectionExecution");
compilationRoots.Add(new SingleMethodRootProvider(exec.GetStaticConstructor()));
}
compilationGroup = new SingleFileCompilationModuleGroup(typeSystemContext);
}
foreach (var rdXmlFilePath in _rdXmlFilePaths)
{
compilationRoots.Add(new RdXmlRootProvider(typeSystemContext, rdXmlFilePath));
}
}
//
// Compile
//
CompilationBuilder builder;
if (_isCppCodegen)
{
builder = new CppCodegenCompilationBuilder(typeSystemContext, compilationGroup);
}
else
{
builder = new RyuJitCompilationBuilder(typeSystemContext, compilationGroup);
}
var logger = _isVerbose ? new Logger(Console.Out, true) : Logger.Null;
DependencyTrackingLevel trackingLevel = _dgmlLogFileName == null ?
DependencyTrackingLevel.None : (_generateFullDgmlLog ? DependencyTrackingLevel.All : DependencyTrackingLevel.First);
ICompilation compilation = builder
.UseBackendOptions(_codegenOptions)
.UseLogger(logger)
.UseDependencyTracking(trackingLevel)
.UseCompilationRoots(compilationRoots)
.ToCompilation();
compilation.Compile(_outputFilePath);
if (_dgmlLogFileName != null)
{
compilation.WriteDependencyLog(_dgmlLogFileName);
}
return(0);
}
private int Run(string[] args)
{
InitializeDefaultOptions();
ArgumentSyntax syntax = ParseCommandLine(args);
if (_help)
{
Help(syntax.GetHelpText());
return(1);
}
if (_inputFilePaths.Count == 0)
{
throw new CommandLineException("No input files specified");
}
if (_outputFilePath == null)
{
throw new CommandLineException("Output filename must be specified (/out <file>)");
}
//
// Initialize type system context
//
SharedGenericsMode genericsMode = _useSharedGenerics ?
SharedGenericsMode.CanonicalReferenceTypes : SharedGenericsMode.Disabled;
var typeSystemContext = new CompilerTypeSystemContext(new TargetDetails(_targetArchitecture, _targetOS), genericsMode);
typeSystemContext.InputFilePaths = _inputFilePaths;
typeSystemContext.ReferenceFilePaths = _referenceFilePaths;
typeSystemContext.SetSystemModule(typeSystemContext.GetModuleForSimpleName(_systemModuleName));
//
// Initialize compilation group and compilation roots
//
// Single method mode?
MethodDesc singleMethod = CheckAndParseSingleMethodModeArguments(typeSystemContext);
CompilationModuleGroup compilationGroup;
List <ICompilationRootProvider> compilationRoots = new List <ICompilationRootProvider>();
if (singleMethod != null)
{
// Compiling just a single method
compilationGroup = new SingleMethodCompilationModuleGroup(singleMethod);
compilationRoots.Add(new SingleMethodRootProvider(singleMethod));
}
else
{
// Either single file, or multifile library, or multifile consumption.
EcmaModule entrypointModule = null;
foreach (var inputFile in typeSystemContext.InputFilePaths)
{
EcmaModule module = typeSystemContext.GetModuleFromPath(inputFile.Value);
if (module.PEReader.PEHeaders.IsExe)
{
if (entrypointModule != null)
{
throw new Exception("Multiple EXE modules");
}
entrypointModule = module;
}
compilationRoots.Add(new ExportedMethodsRootProvider(module));
}
if (entrypointModule != null)
{
LibraryInitializers libraryInitializers =
new LibraryInitializers(typeSystemContext, _isCppCodegen);
compilationRoots.Add(new MainMethodRootProvider(entrypointModule, libraryInitializers.LibraryInitializerMethods));
}
if (_multiFile)
{
List <EcmaModule> inputModules = new List <EcmaModule>();
foreach (var inputFile in typeSystemContext.InputFilePaths)
{
EcmaModule module = typeSystemContext.GetModuleFromPath(inputFile.Value);
if (entrypointModule == null)
{
// This is a multifile production build - we need to root all methods
compilationRoots.Add(new LibraryRootProvider(module));
}
inputModules.Add(module);
}
if (entrypointModule == null)
{
compilationGroup = new MultiFileSharedCompilationModuleGroup(typeSystemContext, inputModules);
}
else
{
compilationGroup = new MultiFileLeafCompilationModuleGroup(typeSystemContext, inputModules);
}
}
else
{
if (entrypointModule == null)
{
throw new Exception("No entrypoint module");
}
compilationRoots.Add(new ExportedMethodsRootProvider((EcmaModule)typeSystemContext.SystemModule));
compilationGroup = new SingleFileCompilationModuleGroup(typeSystemContext);
}
foreach (var rdXmlFilePath in _rdXmlFilePaths)
{
compilationRoots.Add(new RdXmlRootProvider(typeSystemContext, rdXmlFilePath));
}
}
//
// Compile
//
CompilationBuilder builder;
if (_isCppCodegen)
{
builder = new CppCodegenCompilationBuilder(typeSystemContext, compilationGroup);
}
else
{
builder = new RyuJitCompilationBuilder(typeSystemContext, compilationGroup);
}
var logger = _isVerbose ? new Logger(Console.Out, true) : Logger.Null;
DependencyTrackingLevel trackingLevel = _dgmlLogFileName == null ?
DependencyTrackingLevel.None : (_generateFullDgmlLog ? DependencyTrackingLevel.All : DependencyTrackingLevel.First);
ICompilation compilation = builder
.UseBackendOptions(_codegenOptions)
.UseLogger(logger)
.UseDependencyTracking(trackingLevel)
.UseCompilationRoots(compilationRoots)
.UseOptimizationMode(_optimizationMode)
.UseDebugInfo(_enableDebugInfo)
.ToCompilation();
compilation.Compile(_outputFilePath);
if (_dgmlLogFileName != null)
{
compilation.WriteDependencyLog(_dgmlLogFileName);
}
return(0);
}
private int Run(string[] args)
{
InitializeDefaultOptions();
ArgumentSyntax syntax = ParseCommandLine(args);
if (_help)
{
Help(syntax.GetHelpText());
return(1);
}
if (_outputFilePath == null)
{
throw new CommandLineException("Output filename must be specified (/out <file>)");
}
//
// Set target Architecture and OS
//
if (_targetArchitectureStr != null)
{
if (_targetArchitectureStr.Equals("x86", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.X86;
}
else if (_targetArchitectureStr.Equals("x64", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.X64;
}
else if (_targetArchitectureStr.Equals("arm", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.ARM;
}
else if (_targetArchitectureStr.Equals("armel", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.ARMEL;
}
else if (_targetArchitectureStr.Equals("arm64", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.ARM64;
}
else
{
throw new CommandLineException("Target architecture is not supported");
}
}
if (_targetOSStr != null)
{
if (_targetOSStr.Equals("windows", StringComparison.OrdinalIgnoreCase))
{
_targetOS = TargetOS.Windows;
}
else if (_targetOSStr.Equals("linux", StringComparison.OrdinalIgnoreCase))
{
_targetOS = TargetOS.Linux;
}
else if (_targetOSStr.Equals("osx", StringComparison.OrdinalIgnoreCase))
{
_targetOS = TargetOS.OSX;
}
else
{
throw new CommandLineException("Target OS is not supported");
}
}
//
// Initialize type system context
//
SharedGenericsMode genericsMode = _useSharedGenerics ?
SharedGenericsMode.CanonicalReferenceTypes : SharedGenericsMode.Disabled;
var typeSystemContext = new CompilerTypeSystemContext(new TargetDetails(_targetArchitecture, _targetOS, TargetAbi.CoreRT), genericsMode);
//
// TODO: To support our pre-compiled test tree, allow input files that aren't managed assemblies since
// some tests contain a mixture of both managed and native binaries.
//
// See: https://github.com/dotnet/corert/issues/2785
//
// When we undo this this hack, replace this foreach with
// typeSystemContext.InputFilePaths = _inputFilePaths;
//
Dictionary <string, string> inputFilePaths = new Dictionary <string, string>();
foreach (var inputFile in _inputFilePaths)
{
try
{
var module = typeSystemContext.GetModuleFromPath(inputFile.Value);
inputFilePaths.Add(inputFile.Key, inputFile.Value);
}
catch (TypeSystemException.BadImageFormatException)
{
// Keep calm and carry on.
}
}
typeSystemContext.InputFilePaths = inputFilePaths;
typeSystemContext.ReferenceFilePaths = _referenceFilePaths;
typeSystemContext.SetSystemModule(typeSystemContext.GetModuleForSimpleName(_systemModuleName));
if (typeSystemContext.InputFilePaths.Count == 0)
{
throw new CommandLineException("No input files specified");
}
//
// Initialize compilation group and compilation roots
//
// Single method mode?
MethodDesc singleMethod = CheckAndParseSingleMethodModeArguments(typeSystemContext);
CompilationModuleGroup compilationGroup;
List <ICompilationRootProvider> compilationRoots = new List <ICompilationRootProvider>();
if (singleMethod != null)
{
// Compiling just a single method
compilationGroup = new SingleMethodCompilationModuleGroup(singleMethod);
compilationRoots.Add(new SingleMethodRootProvider(singleMethod));
}
else
{
// Either single file, or multifile library, or multifile consumption.
EcmaModule entrypointModule = null;
foreach (var inputFile in typeSystemContext.InputFilePaths)
{
EcmaModule module = typeSystemContext.GetModuleFromPath(inputFile.Value);
if (module.PEReader.PEHeaders.IsExe)
{
if (entrypointModule != null)
{
throw new Exception("Multiple EXE modules");
}
entrypointModule = module;
}
compilationRoots.Add(new ExportedMethodsRootProvider(module));
}
if (entrypointModule != null)
{
LibraryInitializers libraryInitializers =
new LibraryInitializers(typeSystemContext, _isCppCodegen);
compilationRoots.Add(new MainMethodRootProvider(entrypointModule, libraryInitializers.LibraryInitializerMethods));
}
if (_multiFile)
{
List <EcmaModule> inputModules = new List <EcmaModule>();
foreach (var inputFile in typeSystemContext.InputFilePaths)
{
EcmaModule module = typeSystemContext.GetModuleFromPath(inputFile.Value);
if (entrypointModule == null)
{
// This is a multifile production build - we need to root all methods
compilationRoots.Add(new LibraryRootProvider(module));
}
inputModules.Add(module);
}
if (entrypointModule == null)
{
compilationGroup = new MultiFileSharedCompilationModuleGroup(typeSystemContext, inputModules);
}
else
{
compilationGroup = new MultiFileLeafCompilationModuleGroup(typeSystemContext, inputModules);
}
}
else
{
if (entrypointModule == null)
{
throw new Exception("No entrypoint module");
}
compilationRoots.Add(new ExportedMethodsRootProvider((EcmaModule)typeSystemContext.SystemModule));
compilationGroup = new SingleFileCompilationModuleGroup(typeSystemContext);
}
foreach (var rdXmlFilePath in _rdXmlFilePaths)
{
compilationRoots.Add(new RdXmlRootProvider(typeSystemContext, rdXmlFilePath));
}
}
//
// Compile
//
CompilationBuilder builder;
if (_isCppCodegen)
{
builder = new CppCodegenCompilationBuilder(typeSystemContext, compilationGroup);
}
else
{
builder = new RyuJitCompilationBuilder(typeSystemContext, compilationGroup);
}
var logger = _isVerbose ? new Logger(Console.Out, true) : Logger.Null;
DependencyTrackingLevel trackingLevel = _dgmlLogFileName == null ?
DependencyTrackingLevel.None : (_generateFullDgmlLog ? DependencyTrackingLevel.All : DependencyTrackingLevel.First);
ICompilation compilation = builder
.UseBackendOptions(_codegenOptions)
.UseLogger(logger)
.UseDependencyTracking(trackingLevel)
.UseCompilationRoots(compilationRoots)
.UseOptimizationMode(_optimizationMode)
.UseDebugInfo(_enableDebugInfo)
.ToCompilation();
ObjectDumper dumper = _mapFileName != null ? new ObjectDumper(_mapFileName) : null;
compilation.Compile(_outputFilePath, dumper);
if (_dgmlLogFileName != null)
{
compilation.WriteDependencyLog(_dgmlLogFileName);
}
return(0);
}
private int Run(string[] args)
{
InitializeDefaultOptions();
ArgumentSyntax syntax = ParseCommandLine(args);
if (_help)
{
Help(syntax.GetHelpText());
return 1;
}
if (_inputFilePaths.Count == 0)
throw new CommandLineException("No input files specified");
if (_outputFilePath == null)
throw new CommandLineException("Output filename must be specified (/out <file>)");
//
// Initialize type system context
//
SharedGenericsMode genericsMode = _useSharedGenerics ?
SharedGenericsMode.CanonicalReferenceTypes : SharedGenericsMode.Disabled;
var typeSystemContext = new CompilerTypeSystemContext(new TargetDetails(_targetArchitecture, _targetOS), genericsMode);
typeSystemContext.InputFilePaths = _inputFilePaths;
typeSystemContext.ReferenceFilePaths = _referenceFilePaths;
typeSystemContext.SetSystemModule(typeSystemContext.GetModuleForSimpleName(_systemModuleName));
//
// Initialize compilation group and compilation roots
//
// Single method mode?
MethodDesc singleMethod = CheckAndParseSingleMethodModeArguments(typeSystemContext);
CompilationModuleGroup compilationGroup;
List<ICompilationRootProvider> compilationRoots = new List<ICompilationRootProvider>();
if (singleMethod != null)
{
// Compiling just a single method
compilationGroup = new SingleMethodCompilationModuleGroup(singleMethod);
compilationRoots.Add(new SingleMethodRootProvider(singleMethod));
}
else
{
// Either single file, or multifile library, or multifile consumption.
EcmaModule entrypointModule = null;
foreach (var inputFile in typeSystemContext.InputFilePaths)
{
EcmaModule module = typeSystemContext.GetModuleFromPath(inputFile.Value);
if (module.PEReader.PEHeaders.IsExe)
{
if (entrypointModule != null)
throw new Exception("Multiple EXE modules");
entrypointModule = module;
}
compilationRoots.Add(new ExportedMethodsRootProvider(module));
}
if (entrypointModule != null)
{
compilationRoots.Add(new MainMethodRootProvider(entrypointModule));
}
if (_multiFile)
{
List<EcmaModule> inputModules = new List<EcmaModule>();
foreach (var inputFile in typeSystemContext.InputFilePaths)
{
EcmaModule module = typeSystemContext.GetModuleFromPath(inputFile.Value);
if (entrypointModule == null)
{
// This is a multifile production build - we need to root all methods
compilationRoots.Add(new LibraryRootProvider(module));
}
inputModules.Add(module);
}
if (entrypointModule == null)
compilationGroup = new MultiFileSharedCompilationModuleGroup(typeSystemContext, inputModules);
else
compilationGroup = new MultiFileLeafCompilationModuleGroup(typeSystemContext, inputModules);
}
else
{
if (entrypointModule == null)
throw new Exception("No entrypoint module");
compilationRoots.Add(new ExportedMethodsRootProvider((EcmaModule)typeSystemContext.SystemModule));
// System.Private.Reflection.Execution needs to establish a communication channel with System.Private.CoreLib
// at process startup. This is done through an eager constructor that calls into CoreLib and passes it
// a callback object.
//
// Since CoreLib cannot reference anything, the type and it's eager constructor won't be added to the compilation
// unless we explictly add it.
var refExec = typeSystemContext.GetModuleForSimpleName("System.Private.Reflection.Execution", false);
if (refExec != null)
{
var exec = refExec.GetType("Internal.Reflection.Execution", "ReflectionExecution");
compilationRoots.Add(new SingleMethodRootProvider(exec.GetStaticConstructor()));
}
compilationGroup = new SingleFileCompilationModuleGroup(typeSystemContext);
}
foreach (var rdXmlFilePath in _rdXmlFilePaths)
{
compilationRoots.Add(new RdXmlRootProvider(typeSystemContext, rdXmlFilePath));
}
}
//
// Compile
//
CompilationBuilder builder;
if (_isCppCodegen)
builder = new CppCodegenCompilationBuilder(typeSystemContext, compilationGroup);
else
builder = new RyuJitCompilationBuilder(typeSystemContext, compilationGroup);
var logger = _isVerbose ? new Logger(Console.Out, true) : Logger.Null;
DependencyTrackingLevel trackingLevel = _dgmlLogFileName == null ?
DependencyTrackingLevel.None : (_generateFullDgmlLog ? DependencyTrackingLevel.All : DependencyTrackingLevel.First);
ICompilation compilation = builder
.UseBackendOptions(_codegenOptions)
.UseLogger(logger)
.UseDependencyTracking(trackingLevel)
.UseCompilationRoots(compilationRoots)
.ToCompilation();
compilation.Compile(_outputFilePath);
if (_dgmlLogFileName != null)
compilation.WriteDependencyLog(_dgmlLogFileName);
return 0;
}