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 (_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.ARM;
}
else if (_targetArchitectureStr.Equals("arm64", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.ARM64;
}
else if (_targetArchitectureStr.Equals("wasm", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.Wasm32;
_isWasmCodegen = true;
}
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");
}
}
if (_isWasmCodegen)
{
_targetArchitecture = TargetArchitecture.Wasm32;
}
bool supportsReflection = !_disableReflection && _systemModuleName == DefaultSystemModule;
//
// Initialize type system context
//
SharedGenericsMode genericsMode = _useSharedGenerics || !_isWasmCodegen ?
SharedGenericsMode.CanonicalReferenceTypes : SharedGenericsMode.Disabled;
// TODO: compiler switch for SIMD support?
var simdVectorLength = (_isCppCodegen || _isWasmCodegen) ? SimdVectorLength.None : SimdVectorLength.Vector128Bit;
var targetAbi = _isCppCodegen ? TargetAbi.CppCodegen : TargetAbi.CoreRT;
var targetDetails = new TargetDetails(_targetArchitecture, _targetOS, targetAbi, simdVectorLength);
CompilerTypeSystemContext typeSystemContext =
new CompilerTypeSystemContext(targetDetails, genericsMode, supportsReflection ? DelegateFeature.All : 0);
//
// 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;
bool systemModuleIsInputModule = false;
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;
}
if (module == typeSystemContext.SystemModule)
{
systemModuleIsInputModule = true;
}
compilationRoots.Add(new ExportedMethodsRootProvider(module));
}
if (entrypointModule != null)
{
compilationRoots.Add(new MainMethodRootProvider(entrypointModule, CreateInitializerList(typeSystemContext)));
compilationRoots.Add(new RuntimeConfigurationRootProvider(_runtimeOptions));
}
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);
}
compilationGroup = new MultiFileSharedCompilationModuleGroup(typeSystemContext, inputModules);
}
else
{
if (entrypointModule == null && !_nativeLib)
{
throw new Exception("No entrypoint module");
}
if (!systemModuleIsInputModule)
{
compilationRoots.Add(new ExportedMethodsRootProvider((EcmaModule)typeSystemContext.SystemModule));
}
compilationGroup = new SingleFileCompilationModuleGroup();
}
if (_nativeLib)
{
// Set owning module of generated native library startup method to compiler generated module,
// to ensure the startup method is included in the object file during multimodule mode build
compilationRoots.Add(new NativeLibraryInitializerRootProvider(typeSystemContext.GeneratedAssembly, CreateInitializerList(typeSystemContext)));
compilationRoots.Add(new RuntimeConfigurationRootProvider(_runtimeOptions));
}
if (_rdXmlFilePaths.Count > 0)
{
Console.WriteLine("Warning: RD.XML processing will change before release (https://github.com/dotnet/corert/issues/5001)");
}
foreach (var rdXmlFilePath in _rdXmlFilePaths)
{
compilationRoots.Add(new RdXmlRootProvider(typeSystemContext, rdXmlFilePath));
}
}
//
// Compile
//
CompilationBuilder builder;
if (_isWasmCodegen)
{
builder = new WebAssemblyCodegenCompilationBuilder(typeSystemContext, compilationGroup);
}
else if (_isCppCodegen)
{
builder = new CppCodegenCompilationBuilder(typeSystemContext, compilationGroup);
}
else
{
builder = new RyuJitCompilationBuilder(typeSystemContext, compilationGroup);
}
string compilationUnitPrefix = _multiFile ? System.IO.Path.GetFileNameWithoutExtension(_outputFilePath) : "";
builder.UseCompilationUnitPrefix(compilationUnitPrefix);
PInvokeILEmitterConfiguration pinvokePolicy;
if (!_isCppCodegen && !_isWasmCodegen)
{
pinvokePolicy = new ConfigurablePInvokePolicy(typeSystemContext.Target);
}
else
{
pinvokePolicy = new DirectPInvokePolicy();
}
RemovedFeature removedFeatures = 0;
foreach (string feature in _removedFeatures)
{
if (feature == "EventSource")
{
removedFeatures |= RemovedFeature.Etw;
}
else if (feature == "FrameworkStrings")
{
removedFeatures |= RemovedFeature.FrameworkResources;
}
else if (feature == "Globalization")
{
removedFeatures |= RemovedFeature.Globalization;
}
else if (feature == "Comparers")
{
removedFeatures |= RemovedFeature.Comparers;
}
else if (feature == "CurlHandler")
{
removedFeatures |= RemovedFeature.CurlHandler;
}
}
ILProvider ilProvider = new CoreRTILProvider();
if (removedFeatures != 0)
{
ilProvider = new RemovingILProvider(ilProvider, removedFeatures);
}
var stackTracePolicy = _emitStackTraceData ?
(StackTraceEmissionPolicy) new EcmaMethodStackTraceEmissionPolicy() : new NoStackTraceEmissionPolicy();
MetadataBlockingPolicy mdBlockingPolicy = _noMetadataBlocking
? (MetadataBlockingPolicy) new NoMetadataBlockingPolicy()
: new BlockedInternalsBlockingPolicy(typeSystemContext);
ManifestResourceBlockingPolicy resBlockingPolicy = (removedFeatures & RemovedFeature.FrameworkResources) != 0 ?
new FrameworkStringResourceBlockingPolicy() : (ManifestResourceBlockingPolicy) new NoManifestResourceBlockingPolicy();
UsageBasedMetadataGenerationOptions metadataGenerationOptions = UsageBasedMetadataGenerationOptions.AnonymousTypeHeuristic;
if (_completeTypesMetadata)
{
metadataGenerationOptions |= UsageBasedMetadataGenerationOptions.CompleteTypesOnly;
}
if (_scanReflection)
{
metadataGenerationOptions |= UsageBasedMetadataGenerationOptions.ILScanning;
}
if (_rootAllApplicationAssemblies)
{
metadataGenerationOptions |= UsageBasedMetadataGenerationOptions.FullUserAssemblyRooting;
}
DynamicInvokeThunkGenerationPolicy invokeThunkGenerationPolicy = new DefaultDynamicInvokeThunkGenerationPolicy();
MetadataManager metadataManager;
if (supportsReflection)
{
metadataManager = new UsageBasedMetadataManager(
compilationGroup,
typeSystemContext,
mdBlockingPolicy,
resBlockingPolicy,
_metadataLogFileName,
stackTracePolicy,
invokeThunkGenerationPolicy,
ilProvider,
metadataGenerationOptions);
}
else
{
metadataManager = new EmptyMetadataManager(typeSystemContext, stackTracePolicy, ilProvider);
}
InteropStateManager interopStateManager = new InteropStateManager(typeSystemContext.GeneratedAssembly);
InteropStubManager interopStubManager = new UsageBasedInteropStubManager(interopStateManager, pinvokePolicy);
// Unless explicitly opted in at the command line, we enable scanner for retail builds by default.
// We don't do this for CppCodegen and Wasm, because those codegens are behind.
// We also don't do this for multifile because scanner doesn't simulate inlining (this would be
// fixable by using a CompilationGroup for the scanner that has a bigger worldview, but
// let's cross that bridge when we get there).
bool useScanner = _useScanner ||
(_optimizationMode != OptimizationMode.None && !_isCppCodegen && !_isWasmCodegen && !_multiFile);
useScanner &= !_noScanner;
builder.UseILProvider(ilProvider);
ILScanResults scanResults = null;
if (useScanner)
{
ILScannerBuilder scannerBuilder = builder.GetILScannerBuilder()
.UseCompilationRoots(compilationRoots)
.UseMetadataManager(metadataManager)
.UseSingleThread(enable: _singleThreaded)
.UseInteropStubManager(interopStubManager);
if (_scanDgmlLogFileName != null)
{
scannerBuilder.UseDependencyTracking(_generateFullScanDgmlLog ? DependencyTrackingLevel.All : DependencyTrackingLevel.First);
}
IILScanner scanner = scannerBuilder.ToILScanner();
scanResults = scanner.Scan();
if (metadataManager is UsageBasedMetadataManager usageBasedManager)
{
metadataManager = usageBasedManager.ToAnalysisBasedMetadataManager();
}
else
{
// MetadataManager collects a bunch of state (e.g. list of compiled method bodies) that we need to reset.
Debug.Assert(metadataManager is EmptyMetadataManager);
metadataManager = new EmptyMetadataManager(typeSystemContext, stackTracePolicy, ilProvider);
}
interopStubManager = scanResults.GetInteropStubManager(interopStateManager, pinvokePolicy);
}
var logger = new Logger(Console.Out, _isVerbose);
DebugInformationProvider debugInfoProvider = _enableDebugInfo ?
(_ilDump == null ? new DebugInformationProvider() : new ILAssemblyGeneratingMethodDebugInfoProvider(_ilDump, new EcmaOnlyDebugInformationProvider())) :
new NullDebugInformationProvider();
DependencyTrackingLevel trackingLevel = _dgmlLogFileName == null ?
DependencyTrackingLevel.None : (_generateFullDgmlLog ? DependencyTrackingLevel.All : DependencyTrackingLevel.First);
compilationRoots.Add(metadataManager);
compilationRoots.Add(interopStubManager);
builder
.UseBackendOptions(_codegenOptions)
.UseMethodBodyFolding(enable: _methodBodyFolding)
.UseSingleThread(enable: _singleThreaded)
.UseMetadataManager(metadataManager)
.UseInteropStubManager(interopStubManager)
.UseLogger(logger)
.UseDependencyTracking(trackingLevel)
.UseCompilationRoots(compilationRoots)
.UseOptimizationMode(_optimizationMode)
.UseDebugInfoProvider(debugInfoProvider);
if (scanResults != null)
{
// If we have a scanner, feed the vtable analysis results to the compilation.
// This could be a command line switch if we really wanted to.
builder.UseVTableSliceProvider(scanResults.GetVTableLayoutInfo());
// If we have a scanner, feed the generic dictionary results to the compilation.
// This could be a command line switch if we really wanted to.
builder.UseGenericDictionaryLayoutProvider(scanResults.GetDictionaryLayoutInfo());
// If we feed any outputs of the scanner into the compilation, it's essential
// we use scanner's devirtualization manager. It prevents optimizing codegens
// from accidentally devirtualizing cases that can never happen at runtime
// (e.g. devirtualizing a method on a type that never gets allocated).
builder.UseDevirtualizationManager(scanResults.GetDevirtualizationManager());
}
ICompilation compilation = builder.ToCompilation();
ObjectDumper dumper = _mapFileName != null ? new ObjectDumper(_mapFileName) : null;
CompilationResults compilationResults = compilation.Compile(_outputFilePath, dumper);
if (_exportsFile != null)
{
ExportsFileWriter defFileWriter = new ExportsFileWriter(typeSystemContext, _exportsFile);
foreach (var compilationRoot in compilationRoots)
{
if (compilationRoot is ExportedMethodsRootProvider provider)
{
defFileWriter.AddExportedMethods(provider.ExportedMethods);
}
}
defFileWriter.EmitExportedMethods();
}
if (_dgmlLogFileName != null)
{
compilationResults.WriteDependencyLog(_dgmlLogFileName);
}
if (scanResults != null)
{
SimdHelper simdHelper = new SimdHelper();
if (_scanDgmlLogFileName != null)
{
scanResults.WriteDependencyLog(_scanDgmlLogFileName);
}
// If the scanner and compiler don't agree on what to compile, the outputs of the scanner might not actually be usable.
// We are going to check this two ways:
// 1. The methods and types generated during compilation are a subset of method and types scanned
// 2. The methods and types scanned are a subset of methods and types compiled (this has a chance to hold for unoptimized builds only).
// Check that methods and types generated during compilation are a subset of method and types scanned
bool scanningFail = false;
DiffCompilationResults(ref scanningFail, compilationResults.CompiledMethodBodies, scanResults.CompiledMethodBodies,
"Methods", "compiled", "scanned", method => !(method.GetTypicalMethodDefinition() is EcmaMethod) || method.Name == "ThrowPlatformNotSupportedException");
DiffCompilationResults(ref scanningFail, compilationResults.ConstructedEETypes, scanResults.ConstructedEETypes,
"EETypes", "compiled", "scanned", type => !(type.GetTypeDefinition() is EcmaType));
// If optimizations are enabled, the results will for sure not match in the other direction due to inlining, etc.
// But there's at least some value in checking the scanner doesn't expand the universe too much in debug.
if (_optimizationMode == OptimizationMode.None)
{
// Check that methods and types scanned are a subset of methods and types compiled
// If we find diffs here, they're not critical, but still might be causing a Size on Disk regression.
bool dummy = false;
// We additionally skip methods in SIMD module because there's just too many intrisics to handle and IL scanner
// doesn't expand them. They would show up as noisy diffs.
DiffCompilationResults(ref dummy, scanResults.CompiledMethodBodies, compilationResults.CompiledMethodBodies,
"Methods", "scanned", "compiled", method => !(method.GetTypicalMethodDefinition() is EcmaMethod) || simdHelper.IsSimdType(method.OwningType));
DiffCompilationResults(ref dummy, scanResults.ConstructedEETypes, compilationResults.ConstructedEETypes,
"EETypes", "scanned", "compiled", type => !(type.GetTypeDefinition() is EcmaType));
}
if (scanningFail)
{
throw new Exception("Scanning failure");
}
}
if (debugInfoProvider is IDisposable)
{
((IDisposable)debugInfoProvider).Dispose();
}
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.ARM;
}
else if (_targetArchitectureStr.Equals("arm64", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.ARM64;
}
else if (_targetArchitectureStr.Equals("wasm", StringComparison.OrdinalIgnoreCase))
{
_targetArchitecture = TargetArchitecture.Wasm32;
_isWasmCodegen = true;
}
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");
}
}
if (_isWasmCodegen)
{
_targetArchitecture = TargetArchitecture.Wasm32;
}
InstructionSetSupportBuilder instructionSetSupportBuilder = new InstructionSetSupportBuilder(_targetArchitecture);
// The runtime expects certain baselines that the codegen can assume as well.
if ((_targetArchitecture == TargetArchitecture.X86) || (_targetArchitecture == TargetArchitecture.X64))
{
instructionSetSupportBuilder.AddSupportedInstructionSet("sse");
instructionSetSupportBuilder.AddSupportedInstructionSet("sse2");
}
else if (_targetArchitecture == TargetArchitecture.ARM64)
{
instructionSetSupportBuilder.AddSupportedInstructionSet("base");
instructionSetSupportBuilder.AddSupportedInstructionSet("neon");
}
if (_instructionSet != null)
{
List <string> instructionSetParams = new List <string>();
// Normalize instruction set format to include implied +.
string[] instructionSetParamsInput = _instructionSet.Split(',');
for (int i = 0; i < instructionSetParamsInput.Length; i++)
{
string instructionSet = instructionSetParamsInput[i];
if (String.IsNullOrEmpty(instructionSet))
{
throw new CommandLineException("Instruction set must not be empty");
}
char firstChar = instructionSet[0];
if ((firstChar != '+') && (firstChar != '-'))
{
instructionSet = "+" + instructionSet;
}
instructionSetParams.Add(instructionSet);
}
Dictionary <string, bool> instructionSetSpecification = new Dictionary <string, bool>();
foreach (string instructionSetSpecifier in instructionSetParams)
{
string instructionSet = instructionSetSpecifier.Substring(1, instructionSetSpecifier.Length - 1);
bool enabled = instructionSetSpecifier[0] == '+' ? true : false;
if (enabled)
{
if (!instructionSetSupportBuilder.AddSupportedInstructionSet(instructionSet))
{
throw new CommandLineException($"Unrecognized instruction set '{instructionSet}'");
}
}
else
{
if (!instructionSetSupportBuilder.RemoveInstructionSetSupport(instructionSet))
{
throw new CommandLineException($"Unrecognized instruction set '{instructionSet}'");
}
}
}
}
instructionSetSupportBuilder.ComputeInstructionSetFlags(out var supportedInstructionSet, out var unsupportedInstructionSet,
(string specifiedInstructionSet, string impliedInstructionSet) =>
throw new CommandLineException(String.Format("Unsupported combination of instruction sets: {0}/{1}", specifiedInstructionSet, impliedInstructionSet)));
InstructionSetSupportBuilder optimisticInstructionSetSupportBuilder = new InstructionSetSupportBuilder(_targetArchitecture);
// Optimistically assume some instruction sets are present.
if ((_targetArchitecture == TargetArchitecture.X86) || (_targetArchitecture == TargetArchitecture.X64))
{
// We set these hardware features as enabled always, as most
// of hardware in the wild supports them. Note that we do not indicate support for AVX, or any other
// instruction set which uses the VEX encodings as the presence of those makes otherwise acceptable
// code be unusable on hardware which does not support VEX encodings, as well as emulators that do not
// support AVX instructions.
//
// The compiler is able to generate runtime IsSupported checks for the following instruction sets.
optimisticInstructionSetSupportBuilder.AddSupportedInstructionSet("ssse3");
optimisticInstructionSetSupportBuilder.AddSupportedInstructionSet("aes");
optimisticInstructionSetSupportBuilder.AddSupportedInstructionSet("pclmul");
optimisticInstructionSetSupportBuilder.AddSupportedInstructionSet("lzcnt");
// NOTE: we don't optimistically enable SSE4.1/SSE4.2 because RyuJIT can opportunistically use
// these instructions in e.g. optimizing Math.Round or Vector<T> operations without IsSupported guards.
// If SSE4.2 was enabled, we can also opportunistically enable POPCNT
Debug.Assert(InstructionSet.X64_SSE42 == InstructionSet.X86_SSE42);
if (supportedInstructionSet.HasInstructionSet(InstructionSet.X64_SSE42))
{
optimisticInstructionSetSupportBuilder.AddSupportedInstructionSet("popcnt");
}
// If AVX was enabled, we can opportunistically enable FMA/BMI
Debug.Assert(InstructionSet.X64_AVX == InstructionSet.X86_AVX);
if (supportedInstructionSet.HasInstructionSet(InstructionSet.X64_AVX))
{
optimisticInstructionSetSupportBuilder.AddSupportedInstructionSet("fma");
optimisticInstructionSetSupportBuilder.AddSupportedInstructionSet("bmi1");
optimisticInstructionSetSupportBuilder.AddSupportedInstructionSet("bmi2");
}
}
optimisticInstructionSetSupportBuilder.ComputeInstructionSetFlags(out var optimisticInstructionSet, out _,
(string specifiedInstructionSet, string impliedInstructionSet) => throw new NotSupportedException());
optimisticInstructionSet.Remove(unsupportedInstructionSet);
optimisticInstructionSet.Add(supportedInstructionSet);
var instructionSetSupport = new InstructionSetSupport(supportedInstructionSet,
unsupportedInstructionSet,
optimisticInstructionSet,
InstructionSetSupportBuilder.GetNonSpecifiableInstructionSetsForArch(_targetArchitecture),
_targetArchitecture);
bool supportsReflection = !_disableReflection && _systemModuleName == DefaultSystemModule;
//
// Initialize type system context
//
SharedGenericsMode genericsMode = SharedGenericsMode.CanonicalReferenceTypes;
var simdVectorLength = (_isCppCodegen || _isWasmCodegen) ? SimdVectorLength.None : instructionSetSupport.GetVectorTSimdVector();
var targetAbi = _isCppCodegen ? TargetAbi.CppCodegen : TargetAbi.CoreRT;
var targetDetails = new TargetDetails(_targetArchitecture, _targetOS, targetAbi, simdVectorLength);
CompilerTypeSystemContext typeSystemContext =
new CompilerTypeSystemContext(targetDetails, genericsMode, supportsReflection ? DelegateFeature.All : 0);
//
// 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;
if (!typeSystemContext.InputFilePaths.ContainsKey(_systemModuleName) &&
!typeSystemContext.ReferenceFilePaths.ContainsKey(_systemModuleName))
{
throw new CommandLineException($"System module {_systemModuleName} does not exists. Make sure that you specify --systemmodule");
}
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;
bool systemModuleIsInputModule = false;
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;
}
if (module == typeSystemContext.SystemModule)
{
systemModuleIsInputModule = true;
}
compilationRoots.Add(new ExportedMethodsRootProvider(module));
}
if (entrypointModule != null)
{
compilationRoots.Add(new MainMethodRootProvider(entrypointModule, CreateInitializerList(typeSystemContext)));
compilationRoots.Add(new RuntimeConfigurationRootProvider(_runtimeOptions));
compilationRoots.Add(new ExpectedIsaFeaturesRootProvider(instructionSetSupport));
}
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);
}
compilationGroup = new MultiFileSharedCompilationModuleGroup(typeSystemContext, inputModules);
}
else
{
if (entrypointModule == null && !_nativeLib)
{
throw new Exception("No entrypoint module");
}
if (!systemModuleIsInputModule)
{
compilationRoots.Add(new ExportedMethodsRootProvider((EcmaModule)typeSystemContext.SystemModule));
}
compilationGroup = new SingleFileCompilationModuleGroup();
}
if (_nativeLib)
{
// Set owning module of generated native library startup method to compiler generated module,
// to ensure the startup method is included in the object file during multimodule mode build
compilationRoots.Add(new NativeLibraryInitializerRootProvider(typeSystemContext.GeneratedAssembly, CreateInitializerList(typeSystemContext)));
compilationRoots.Add(new RuntimeConfigurationRootProvider(_runtimeOptions));
compilationRoots.Add(new ExpectedIsaFeaturesRootProvider(instructionSetSupport));
}
if (_rdXmlFilePaths.Count > 0)
{
Console.WriteLine("Warning: RD.XML processing will change before release (https://github.com/dotnet/corert/issues/5001)");
}
foreach (var rdXmlFilePath in _rdXmlFilePaths)
{
compilationRoots.Add(new RdXmlRootProvider(typeSystemContext, rdXmlFilePath));
}
}
//
// Compile
//
CompilationBuilder builder;
if (_isWasmCodegen)
{
builder = new WebAssemblyCodegenCompilationBuilder(typeSystemContext, compilationGroup);
}
else if (_isCppCodegen)
{
builder = new CppCodegenCompilationBuilder(typeSystemContext, compilationGroup);
}
else
{
builder = new RyuJitCompilationBuilder(typeSystemContext, compilationGroup);
}
string compilationUnitPrefix = _multiFile ? System.IO.Path.GetFileNameWithoutExtension(_outputFilePath) : "";
builder.UseCompilationUnitPrefix(compilationUnitPrefix);
PInvokeILEmitterConfiguration pinvokePolicy;
if (!_isCppCodegen && !_isWasmCodegen)
{
pinvokePolicy = new ConfigurablePInvokePolicy(typeSystemContext.Target);
}
else
{
pinvokePolicy = new DirectPInvokePolicy();
}
RemovedFeature removedFeatures = 0;
foreach (string feature in _removedFeatures)
{
if (feature == "EventSource")
{
removedFeatures |= RemovedFeature.Etw;
}
else if (feature == "FrameworkStrings")
{
removedFeatures |= RemovedFeature.FrameworkResources;
}
else if (feature == "Globalization")
{
removedFeatures |= RemovedFeature.Globalization;
}
else if (feature == "Comparers")
{
removedFeatures |= RemovedFeature.Comparers;
}
else if (feature == "SerializationGuard")
{
removedFeatures |= RemovedFeature.SerializationGuard;
}
else if (feature == "XmlNonFileStream")
{
removedFeatures |= RemovedFeature.XmlDownloadNonFileStream;
}
}
ILProvider ilProvider = new CoreRTILProvider();
if (removedFeatures != 0)
{
ilProvider = new RemovingILProvider(ilProvider, removedFeatures);
}
var stackTracePolicy = _emitStackTraceData ?
(StackTraceEmissionPolicy) new EcmaMethodStackTraceEmissionPolicy() : new NoStackTraceEmissionPolicy();
MetadataBlockingPolicy mdBlockingPolicy;
ManifestResourceBlockingPolicy resBlockingPolicy;
UsageBasedMetadataGenerationOptions metadataGenerationOptions = UsageBasedMetadataGenerationOptions.IteropILScanning;
if (supportsReflection)
{
mdBlockingPolicy = _noMetadataBlocking
? (MetadataBlockingPolicy) new NoMetadataBlockingPolicy()
: new BlockedInternalsBlockingPolicy(typeSystemContext);
resBlockingPolicy = (removedFeatures & RemovedFeature.FrameworkResources) != 0
? new FrameworkStringResourceBlockingPolicy()
: (ManifestResourceBlockingPolicy) new NoManifestResourceBlockingPolicy();
metadataGenerationOptions |= UsageBasedMetadataGenerationOptions.AnonymousTypeHeuristic;
if (_completeTypesMetadata)
{
metadataGenerationOptions |= UsageBasedMetadataGenerationOptions.CompleteTypesOnly;
}
if (_scanReflection)
{
metadataGenerationOptions |= UsageBasedMetadataGenerationOptions.ReflectionILScanning;
}
if (_rootAllApplicationAssemblies)
{
metadataGenerationOptions |= UsageBasedMetadataGenerationOptions.FullUserAssemblyRooting;
}
}
else
{
mdBlockingPolicy = new FullyBlockedMetadataBlockingPolicy();
resBlockingPolicy = new FullyBlockedManifestResourceBlockingPolicy();
}
DynamicInvokeThunkGenerationPolicy invokeThunkGenerationPolicy = new DefaultDynamicInvokeThunkGenerationPolicy();
MetadataManager metadataManager = new UsageBasedMetadataManager(
compilationGroup,
typeSystemContext,
mdBlockingPolicy,
resBlockingPolicy,
_metadataLogFileName,
stackTracePolicy,
invokeThunkGenerationPolicy,
ilProvider,
metadataGenerationOptions);
InteropStateManager interopStateManager = new InteropStateManager(typeSystemContext.GeneratedAssembly);
InteropStubManager interopStubManager = new UsageBasedInteropStubManager(interopStateManager, pinvokePolicy);
// Unless explicitly opted in at the command line, we enable scanner for retail builds by default.
// We don't do this for CppCodegen and Wasm, because those codegens are behind.
// We also don't do this for multifile because scanner doesn't simulate inlining (this would be
// fixable by using a CompilationGroup for the scanner that has a bigger worldview, but
// let's cross that bridge when we get there).
bool useScanner = _useScanner ||
(_optimizationMode != OptimizationMode.None && !_isCppCodegen && !_isWasmCodegen && !_multiFile);
useScanner &= !_noScanner;
// Enable static data preinitialization in optimized builds.
bool preinitStatics = _preinitStatics ||
(_optimizationMode != OptimizationMode.None && !_isCppCodegen && !_multiFile);
preinitStatics &= !_noPreinitStatics;
var preinitManager = new PreinitializationManager(typeSystemContext, compilationGroup, ilProvider, preinitStatics);
builder
.UseILProvider(ilProvider)
.UsePreinitializationManager(preinitManager);
ILScanResults scanResults = null;
if (useScanner)
{
ILScannerBuilder scannerBuilder = builder.GetILScannerBuilder()
.UseCompilationRoots(compilationRoots)
.UseMetadataManager(metadataManager)
.UseSingleThread(enable: _singleThreaded)
.UseInteropStubManager(interopStubManager);
if (_scanDgmlLogFileName != null)
{
scannerBuilder.UseDependencyTracking(_generateFullScanDgmlLog ? DependencyTrackingLevel.All : DependencyTrackingLevel.First);
}
IILScanner scanner = scannerBuilder.ToILScanner();
scanResults = scanner.Scan();
metadataManager = ((UsageBasedMetadataManager)metadataManager).ToAnalysisBasedMetadataManager();
interopStubManager = scanResults.GetInteropStubManager(interopStateManager, pinvokePolicy);
}
var logger = new Logger(Console.Out, _isVerbose);
DebugInformationProvider debugInfoProvider = _enableDebugInfo ?
(_ilDump == null ? new DebugInformationProvider() : new ILAssemblyGeneratingMethodDebugInfoProvider(_ilDump, new EcmaOnlyDebugInformationProvider())) :
new NullDebugInformationProvider();
DependencyTrackingLevel trackingLevel = _dgmlLogFileName == null ?
DependencyTrackingLevel.None : (_generateFullDgmlLog ? DependencyTrackingLevel.All : DependencyTrackingLevel.First);
compilationRoots.Add(metadataManager);
compilationRoots.Add(interopStubManager);
builder
.UseInstructionSetSupport(instructionSetSupport)
.UseBackendOptions(_codegenOptions)
.UseMethodBodyFolding(enable: _methodBodyFolding)
.UseSingleThread(enable: _singleThreaded)
.UseMetadataManager(metadataManager)
.UseInteropStubManager(interopStubManager)
.UseLogger(logger)
.UseDependencyTracking(trackingLevel)
.UseCompilationRoots(compilationRoots)
.UseOptimizationMode(_optimizationMode)
.UseDebugInfoProvider(debugInfoProvider);
if (scanResults != null)
{
// If we have a scanner, feed the vtable analysis results to the compilation.
// This could be a command line switch if we really wanted to.
builder.UseVTableSliceProvider(scanResults.GetVTableLayoutInfo());
// If we have a scanner, feed the generic dictionary results to the compilation.
// This could be a command line switch if we really wanted to.
builder.UseGenericDictionaryLayoutProvider(scanResults.GetDictionaryLayoutInfo());
// If we feed any outputs of the scanner into the compilation, it's essential
// we use scanner's devirtualization manager. It prevents optimizing codegens
// from accidentally devirtualizing cases that can never happen at runtime
// (e.g. devirtualizing a method on a type that never gets allocated).
builder.UseDevirtualizationManager(scanResults.GetDevirtualizationManager());
}
ICompilation compilation = builder.ToCompilation();
ObjectDumper dumper = _mapFileName != null ? new ObjectDumper(_mapFileName) : null;
CompilationResults compilationResults = compilation.Compile(_outputFilePath, dumper);
if (_exportsFile != null)
{
ExportsFileWriter defFileWriter = new ExportsFileWriter(typeSystemContext, _exportsFile);
foreach (var compilationRoot in compilationRoots)
{
if (compilationRoot is ExportedMethodsRootProvider provider)
{
defFileWriter.AddExportedMethods(provider.ExportedMethods);
}
}
defFileWriter.EmitExportedMethods();
}
if (_dgmlLogFileName != null)
{
compilationResults.WriteDependencyLog(_dgmlLogFileName);
}
if (scanResults != null)
{
if (_scanDgmlLogFileName != null)
{
scanResults.WriteDependencyLog(_scanDgmlLogFileName);
}
// If the scanner and compiler don't agree on what to compile, the outputs of the scanner might not actually be usable.
// We are going to check this two ways:
// 1. The methods and types generated during compilation are a subset of method and types scanned
// 2. The methods and types scanned are a subset of methods and types compiled (this has a chance to hold for unoptimized builds only).
// Check that methods and types generated during compilation are a subset of method and types scanned
bool scanningFail = false;
DiffCompilationResults(ref scanningFail, compilationResults.CompiledMethodBodies, scanResults.CompiledMethodBodies,
"Methods", "compiled", "scanned", method => !(method.GetTypicalMethodDefinition() is EcmaMethod) || method.Name == "ThrowPlatformNotSupportedException" || method.Name == "ThrowArgumentOutOfRangeException");
DiffCompilationResults(ref scanningFail, compilationResults.ConstructedEETypes, scanResults.ConstructedEETypes,
"EETypes", "compiled", "scanned", type => !(type.GetTypeDefinition() is EcmaType));
// If optimizations are enabled, the results will for sure not match in the other direction due to inlining, etc.
// But there's at least some value in checking the scanner doesn't expand the universe too much in debug.
if (_optimizationMode == OptimizationMode.None)
{
// Check that methods and types scanned are a subset of methods and types compiled
// If we find diffs here, they're not critical, but still might be causing a Size on Disk regression.
bool dummy = false;
// We additionally skip methods in SIMD module because there's just too many intrisics to handle and IL scanner
// doesn't expand them. They would show up as noisy diffs.
DiffCompilationResults(ref dummy, scanResults.CompiledMethodBodies, compilationResults.CompiledMethodBodies,
"Methods", "scanned", "compiled", method => !(method.GetTypicalMethodDefinition() is EcmaMethod) || method.OwningType.IsIntrinsic);
DiffCompilationResults(ref dummy, scanResults.ConstructedEETypes, compilationResults.ConstructedEETypes,
"EETypes", "scanned", "compiled", type => !(type.GetTypeDefinition() is EcmaType));
}
if (scanningFail)
{
throw new Exception("Scanning failure");
}
}
if (debugInfoProvider is IDisposable)
{
((IDisposable)debugInfoProvider).Dispose();
}
preinitManager.LogStatistics(logger);
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 || !_isCppCodegen ?
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);
}
compilationGroup = new MultiFileSharedCompilationModuleGroup(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);
CompilerGeneratedMetadataManager metadataManager = new CompilerGeneratedMetadataManager(compilationGroup, typeSystemContext, _metadataLogFileName);
ICompilation compilation = builder
.UseBackendOptions(_codegenOptions)
.UseMetadataManager(metadataManager)
.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);
}
compilationGroup = new MultiFileCompilationModuleGroup(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();
}
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 (_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");
}
}
if (_isWasmCodegen)
{
_targetArchitecture = TargetArchitecture.Wasm32;
}
//
// Initialize type system context
//
SharedGenericsMode genericsMode = _useSharedGenerics || (!_isCppCodegen && !_isWasmCodegen) ?
SharedGenericsMode.CanonicalReferenceTypes : SharedGenericsMode.Disabled;
// TODO: compiler switch for SIMD support?
var simdVectorLength = (_isCppCodegen || _isWasmCodegen) ? SimdVectorLength.None : SimdVectorLength.Vector128Bit;
var targetDetails = new TargetDetails(_targetArchitecture, _targetOS, TargetAbi.CoreRT, simdVectorLength);
var typeSystemContext = new CompilerTypeSystemContext(targetDetails, 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;
}
// TODO: Wasm fails to compile some of the exported methods due to missing opcodes
if (!_isWasmCodegen)
{
compilationRoots.Add(new ExportedMethodsRootProvider(module));
}
}
if (entrypointModule != null)
{
// TODO: Wasm fails to compile some of the library initializers
if (!_isWasmCodegen)
{
LibraryInitializers libraryInitializers =
new LibraryInitializers(typeSystemContext, _isCppCodegen);
compilationRoots.Add(new MainMethodRootProvider(entrypointModule, libraryInitializers.LibraryInitializerMethods));
}
else
{
compilationRoots.Add(new RawMainMethodRootProvider(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);
}
compilationGroup = new MultiFileSharedCompilationModuleGroup(typeSystemContext, inputModules);
}
else
{
if (entrypointModule == null)
{
throw new Exception("No entrypoint module");
}
// TODO: Wasm fails to compile some of the xported methods due to missing opcodes
if (!_isWasmCodegen)
{
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 (_isWasmCodegen)
{
builder = new WebAssemblyCodegenCompilationBuilder(typeSystemContext, compilationGroup);
}
else if (_isCppCodegen)
{
builder = new CppCodegenCompilationBuilder(typeSystemContext, compilationGroup);
}
else
{
builder = new RyuJitCompilationBuilder(typeSystemContext, compilationGroup);
}
bool useScanner = _useScanner ||
(_optimizationMode != OptimizationMode.None && !_isCppCodegen && !_isWasmCodegen);
useScanner &= !_noScanner;
ILScanResults scanResults = null;
if (useScanner)
{
ILScannerBuilder scannerBuilder = builder.GetILScannerBuilder()
.UseCompilationRoots(compilationRoots);
if (_scanDgmlLogFileName != null)
{
scannerBuilder.UseDependencyTracking(_generateFullScanDgmlLog ? DependencyTrackingLevel.All : DependencyTrackingLevel.First);
}
IILScanner scanner = scannerBuilder.ToILScanner();
scanResults = scanner.Scan();
}
var logger = new Logger(Console.Out, _isVerbose);
DebugInformationProvider debugInfoProvider = _enableDebugInfo ?
(_ilDump == null ? new DebugInformationProvider() : new ILAssemblyGeneratingMethodDebugInfoProvider(_ilDump, new EcmaOnlyDebugInformationProvider())) :
new NullDebugInformationProvider();
DependencyTrackingLevel trackingLevel = _dgmlLogFileName == null ?
DependencyTrackingLevel.None : (_generateFullDgmlLog ? DependencyTrackingLevel.All : DependencyTrackingLevel.First);
CompilerGeneratedMetadataManager metadataManager = new CompilerGeneratedMetadataManager(compilationGroup, typeSystemContext, _metadataLogFileName);
builder
.UseBackendOptions(_codegenOptions)
.UseMetadataManager(metadataManager)
.UseLogger(logger)
.UseDependencyTracking(trackingLevel)
.UseCompilationRoots(compilationRoots)
.UseOptimizationMode(_optimizationMode)
.UseDebugInfoProvider(debugInfoProvider);
if (scanResults != null)
{
// If we have a scanner, feed the vtable analysis results to the compilation.
// This could be a command line switch if we really wanted to.
builder.UseVTableSliceProvider(scanResults.GetVTableLayoutInfo());
// If we have a scanner, feed the generic dictionary results to the compilation.
// This could be a command line switch if we really wanted to.
builder.UseGenericDictionaryLayoutProvider(scanResults.GetDictionaryLayoutInfo());
}
ICompilation compilation = builder.ToCompilation();
ObjectDumper dumper = _mapFileName != null ? new ObjectDumper(_mapFileName) : null;
CompilationResults compilationResults = compilation.Compile(_outputFilePath, dumper);
if (_dgmlLogFileName != null)
{
compilationResults.WriteDependencyLog(_dgmlLogFileName);
}
if (scanResults != null)
{
SimdHelper simdHelper = new SimdHelper();
if (_scanDgmlLogFileName != null)
{
scanResults.WriteDependencyLog(_scanDgmlLogFileName);
}
// If the scanner and compiler don't agree on what to compile, the outputs of the scanner might not actually be usable.
// We are going to check this two ways:
// 1. The methods and types generated during compilation are a subset of method and types scanned
// 2. The methods and types scanned are a subset of methods and types compiled (this has a chance to hold for unoptimized builds only).
// Check that methods and types generated during compilation are a subset of method and types scanned
bool scanningFail = false;
DiffCompilationResults(ref scanningFail, compilationResults.CompiledMethodBodies, scanResults.CompiledMethodBodies,
"Methods", "compiled", "scanned", method => !(method.GetTypicalMethodDefinition() is EcmaMethod));
DiffCompilationResults(ref scanningFail, compilationResults.ConstructedEETypes, scanResults.ConstructedEETypes,
"EETypes", "compiled", "scanned", type => !(type.GetTypeDefinition() is EcmaType));
// If optimizations are enabled, the results will for sure not match in the other direction due to inlining, etc.
// But there's at least some value in checking the scanner doesn't expand the universe too much in debug.
if (_optimizationMode == OptimizationMode.None)
{
// Check that methods and types scanned are a subset of methods and types compiled
// If we find diffs here, they're not critical, but still might be causing a Size on Disk regression.
bool dummy = false;
// We additionally skip methods in SIMD module because there's just too many intrisics to handle and IL scanner
// doesn't expand them. They would show up as noisy diffs.
DiffCompilationResults(ref dummy, scanResults.CompiledMethodBodies, compilationResults.CompiledMethodBodies,
"Methods", "scanned", "compiled", method => !(method.GetTypicalMethodDefinition() is EcmaMethod) || simdHelper.IsInSimdModule(method.OwningType));
DiffCompilationResults(ref dummy, scanResults.ConstructedEETypes, compilationResults.ConstructedEETypes,
"EETypes", "scanned", "compiled", type => !(type.GetTypeDefinition() is EcmaType));
}
if (scanningFail)
{
throw new Exception("Scanning failure");
}
}
if (debugInfoProvider is IDisposable)
{
((IDisposable)debugInfoProvider).Dispose();
}
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
//
// Single method mode?
MethodDesc singleMethod = CheckAndParseSingleMethodModeArguments(typeSystemContext);
CompilationModuleGroup compilationGroup;
if (singleMethod != null)
{
compilationGroup = new SingleMethodCompilationModuleGroup(typeSystemContext, singleMethod);
}
else if (_multiFile)
{
compilationGroup = new MultiFileCompilationModuleGroup(typeSystemContext);
}
else
{
compilationGroup = new SingleFileCompilationModuleGroup(typeSystemContext);
}
//
// 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)
.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);
}