public ILCompilerOptionsBuilder(TestCaseMetadataProvider metadataProvider)
{
Options = new ILCompilerOptions();
_metadataProvider = metadataProvider;
string runtimeBinDir = (string)AppContext.GetData("Mono.Linker.Tests.RuntimeBinDirectory") !;
AppendExpandedPaths(Options.ReferenceFilePaths, Path.Combine(runtimeBinDir, "aotsdk", "*.dll"));
string runtimePackDir = (string)AppContext.GetData("Mono.Linker.Tests.MicrosoftNetCoreAppRuntimePackDirectory") !;
if (!Directory.Exists(runtimePackDir) && runtimePackDir.Contains("Debug"))
{
// Frequently we'll have a Debug runtime and Release libraries, which actually produces a Release runtime pack
// but from within VS we're see Debug everything. So if the runtime pack directory doesn't exist
// try the Release path (simple string replace)
string candidate = runtimePackDir.Replace("Debug", "Release");
if (Directory.Exists(candidate))
{
runtimePackDir = candidate;
}
}
AppendExpandedPaths(Options.ReferenceFilePaths, Path.Combine(runtimePackDir, "*.dll"));
Options.InitAssemblies.Add("System.Private.CoreLib");
Options.InitAssemblies.Add("System.Private.StackTraceMetadata");
Options.InitAssemblies.Add("System.Private.TypeLoader");
Options.InitAssemblies.Add("System.Private.Reflection.Execution");
Options.FeatureSwitches.Add("System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization", false);
Options.FeatureSwitches.Add("System.Resources.ResourceManager.AllowCustomResourceTypes", false);
Options.FeatureSwitches.Add("System.Linq.Expressions.CanCompileToIL", false);
Options.FeatureSwitches.Add("System.Linq.Expressions.CanEmitObjectArrayDelegate", false);
Options.FeatureSwitches.Add("System.Linq.Expressions.CanCreateArbitraryDelegates", false);
}
public void Trim(ILCompilerOptions options, ILogWriter logWriter)
{
ComputeDefaultOptions(out var targetOS, out var targetArchitecture);
var targetDetails = new TargetDetails(targetArchitecture, targetOS, TargetAbi.NativeAot);
CompilerTypeSystemContext typeSystemContext =
new CompilerTypeSystemContext(targetDetails, SharedGenericsMode.CanonicalReferenceTypes, DelegateFeature.All);
typeSystemContext.InputFilePaths = options.InputFilePaths;
typeSystemContext.ReferenceFilePaths = options.ReferenceFilePaths;
typeSystemContext.SetSystemModule(typeSystemContext.GetModuleForSimpleName(DefaultSystemModule));
List <EcmaModule> inputModules = new List <EcmaModule> ();
foreach (var inputFile in typeSystemContext.InputFilePaths)
{
EcmaModule module = typeSystemContext.GetModuleFromPath(inputFile.Value);
inputModules.Add(module);
}
CompilationModuleGroup compilationGroup = new TestInfraMultiFileSharedCompilationModuleGroup(typeSystemContext, inputModules);
List <ICompilationRootProvider> compilationRoots = new List <ICompilationRootProvider> ();
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));
}
compilationRoots.Add(new MainMethodRootProvider(entrypointModule, CreateInitializerList(typeSystemContext, options)));
ILProvider ilProvider = new NativeAotILProvider();
ilProvider = new FeatureSwitchManager(ilProvider, options.FeatureSwitches);
Logger logger = new Logger(logWriter, ilProvider, isVerbose: true);
CompilerGeneratedState compilerGeneratedState = new CompilerGeneratedState(ilProvider, logger);
UsageBasedMetadataManager metadataManager = new UsageBasedMetadataManager(
compilationGroup,
typeSystemContext,
new NoMetadataBlockingPolicy(),
new ManifestResourceBlockingPolicy(options.FeatureSwitches),
logFile: null,
new NoStackTraceEmissionPolicy(),
new NoDynamicInvokeThunkGenerationPolicy(),
new FlowAnnotations(logger, ilProvider, compilerGeneratedState),
UsageBasedMetadataGenerationOptions.ReflectionILScanning,
logger,
Array.Empty <KeyValuePair <string, bool> > (),
Array.Empty <string> (),
options.TrimAssemblies.ToArray());
CompilationBuilder builder = new RyuJitCompilationBuilder(typeSystemContext, compilationGroup)
.UseILProvider(ilProvider)
.UseCompilationUnitPrefix("");
IILScanner scanner = builder.GetILScannerBuilder()
.UseCompilationRoots(compilationRoots)
.UseMetadataManager(metadataManager)
.UseParallelism(System.Diagnostics.Debugger.IsAttached ? 1 : -1)
.ToILScanner();
ILScanResults results = scanner.Scan();
}
private IReadOnlyCollection <MethodDesc> CreateInitializerList(CompilerTypeSystemContext context, ILCompilerOptions options)
{
List <ModuleDesc> assembliesWithInitalizers = new List <ModuleDesc> ();
// Build a list of assemblies that have an initializer that needs to run before
// any user code runs.
foreach (string initAssemblyName in options.InitAssemblies)
{
ModuleDesc assembly = context.ResolveAssembly(new AssemblyName(initAssemblyName), throwIfNotFound: true);
assembliesWithInitalizers.Add(assembly);
}
var libraryInitializers = new LibraryInitializers(context, assembliesWithInitalizers);
List <MethodDesc> initializerList = new List <MethodDesc> (libraryInitializers.LibraryInitializerMethods);
return(initializerList);
}
