public virtual void AttachToDependencyGraph(DependencyAnalyzerBase <NodeFactory> graph)
{
ReadyToRunHeader = new ReadyToRunHeaderNode(Target);
graph.AddRoot(ReadyToRunHeader, "ReadyToRunHeader is always generated");
graph.AddRoot(new ModulesSectionNode(Target), "ModulesSection is always generated");
graph.AddRoot(GCStaticsRegion, "GC StaticsRegion is always generated");
graph.AddRoot(ThreadStaticsRegion, "ThreadStaticsRegion is always generated");
graph.AddRoot(EagerCctorTable, "EagerCctorTable is always generated");
graph.AddRoot(TypeManagerIndirection, "TypeManagerIndirection is always generated");
graph.AddRoot(DispatchMapTable, "DispatchMapTable is always generated");
graph.AddRoot(FrozenSegmentRegion, "FrozenSegmentRegion is always generated");
graph.AddRoot(InterfaceDispatchCellSection, "Interface dispatch cell section is always generated");
ReadyToRunHeader.Add(ReadyToRunSectionType.GCStaticRegion, GCStaticsRegion, GCStaticsRegion.StartSymbol, GCStaticsRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticRegion, ThreadStaticsRegion, ThreadStaticsRegion.StartSymbol, ThreadStaticsRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.EagerCctor, EagerCctorTable, EagerCctorTable.StartSymbol, EagerCctorTable.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.TypeManagerIndirection, TypeManagerIndirection, TypeManagerIndirection);
ReadyToRunHeader.Add(ReadyToRunSectionType.InterfaceDispatchTable, DispatchMapTable, DispatchMapTable.StartSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.FrozenObjectRegion, FrozenSegmentRegion, FrozenSegmentRegion.StartSymbol, FrozenSegmentRegion.EndSymbol);
var commonFixupsTableNode = new ExternalReferencesTableNode("CommonFixupsTable", this);
InteropStubManager.AddToReadyToRunHeader(ReadyToRunHeader, this, commonFixupsTableNode);
MetadataManager.AddToReadyToRunHeader(ReadyToRunHeader, this, commonFixupsTableNode);
MetadataManager.AttachToDependencyGraph(graph);
ReadyToRunHeader.Add(MetadataManager.BlobIdToReadyToRunSection(ReflectionMapBlob.CommonFixupsTable), commonFixupsTableNode, commonFixupsTableNode, commonFixupsTableNode.EndSymbol);
}
public void AddCompilationRoot(MethodDesc method, string reason, string exportName = null)
{
var methodEntryPoint = _factory.MethodEntrypoint(method);
_graph.AddRoot(methodEntryPoint, reason);
if (exportName != null)
{
_factory.NodeAliases.Add(methodEntryPoint, exportName);
}
}
private void AddCompilationRoot(MethodDesc method, string reason)
{
if (_dependencyGraph != null)
{
_dependencyGraph.AddRoot(_nodeFactory.MethodEntrypoint(method), reason);
}
else
{
AddMethod(method);
}
}
private void AddCompilationRoot(MethodDesc method, string reason, string exportName = null)
{
var methodEntryPoint = _nodeFactory.MethodEntrypoint(method);
_dependencyGraph.AddRoot(methodEntryPoint, reason);
if (exportName != null)
{
_nodeFactory.NodeAliases.Add(methodEntryPoint, exportName);
}
}
public virtual void AttachToDependencyGraph(DependencyAnalyzerBase <NodeFactory> graph)
{
ReadyToRunHeader = new ReadyToRunHeaderNode(Target);
graph.AddRoot(ReadyToRunHeader, "ReadyToRunHeader is always generated");
graph.AddRoot(new ModulesSectionNode(Target), "ModulesSection is always generated");
graph.AddRoot(GCStaticsRegion, "GC StaticsRegion is always generated");
graph.AddRoot(ThreadStaticsRegion, "ThreadStaticsRegion is always generated");
graph.AddRoot(EagerCctorTable, "EagerCctorTable is always generated");
graph.AddRoot(TypeManagerIndirection, "TypeManagerIndirection is always generated");
graph.AddRoot(DispatchMapTable, "DispatchMapTable is always generated");
graph.AddRoot(FrozenSegmentRegion, "FrozenSegmentRegion is always generated");
if (Target.IsWindows)
{
// We need 2 delimiter symbols to bound the unboxing stubs region on Windows platforms (these symbols are
// accessed using extern "C" variables in the bootstrapper)
// On non-Windows platforms, the linker emits special symbols with special names at the begining/end of a section
// so we do not need to emit them ourselves.
graph.AddRoot(new WindowsUnboxingStubsRegionNode(false), "UnboxingStubsRegion delimiter for Windows platform");
graph.AddRoot(new WindowsUnboxingStubsRegionNode(true), "UnboxingStubsRegion delimiter for Windows platform");
}
ReadyToRunHeader.Add(ReadyToRunSectionType.GCStaticRegion, GCStaticsRegion, GCStaticsRegion.StartSymbol, GCStaticsRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticRegion, ThreadStaticsRegion, ThreadStaticsRegion.StartSymbol, ThreadStaticsRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.EagerCctor, EagerCctorTable, EagerCctorTable.StartSymbol, EagerCctorTable.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.TypeManagerIndirection, TypeManagerIndirection, TypeManagerIndirection);
ReadyToRunHeader.Add(ReadyToRunSectionType.InterfaceDispatchTable, DispatchMapTable, DispatchMapTable.StartSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.FrozenObjectRegion, FrozenSegmentRegion, FrozenSegmentRegion.StartSymbol, FrozenSegmentRegion.EndSymbol);
var commonFixupsTableNode = new ExternalReferencesTableNode("CommonFixupsTable", this);
InteropStubManager.AddToReadyToRunHeader(ReadyToRunHeader, this, commonFixupsTableNode);
MetadataManager.AddToReadyToRunHeader(ReadyToRunHeader, this, commonFixupsTableNode);
MetadataManager.AttachToDependencyGraph(graph);
ReadyToRunHeader.Add(MetadataManager.BlobIdToReadyToRunSection(ReflectionMapBlob.CommonFixupsTable), commonFixupsTableNode, commonFixupsTableNode, commonFixupsTableNode.EndSymbol);
}
public virtual void AttachToDependencyGraph(DependencyAnalyzerBase <NodeFactory> graph)
{
ReadyToRunHeader = new ReadyToRunHeaderNode(Target);
graph.AddRoot(ReadyToRunHeader, "ReadyToRunHeader is always generated");
graph.AddRoot(new ModulesSectionNode(Target), "ModulesSection is always generated");
graph.AddRoot(GCStaticsRegion, "GC StaticsRegion is always generated");
graph.AddRoot(ThreadStaticsRegion, "ThreadStaticsRegion is always generated");
graph.AddRoot(EagerCctorTable, "EagerCctorTable is always generated");
graph.AddRoot(TypeManagerIndirection, "TypeManagerIndirection is always generated");
graph.AddRoot(DispatchMapTable, "DispatchMapTable is always generated");
graph.AddRoot(FrozenSegmentRegion, "FrozenSegmentRegion is always generated");
ReadyToRunHeader.Add(ReadyToRunSectionType.GCStaticRegion, GCStaticsRegion, GCStaticsRegion.StartSymbol, GCStaticsRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticRegion, ThreadStaticsRegion, ThreadStaticsRegion.StartSymbol, ThreadStaticsRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.EagerCctor, EagerCctorTable, EagerCctorTable.StartSymbol, EagerCctorTable.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.TypeManagerIndirection, TypeManagerIndirection, TypeManagerIndirection);
ReadyToRunHeader.Add(ReadyToRunSectionType.InterfaceDispatchTable, DispatchMapTable, DispatchMapTable.StartSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.FrozenObjectRegion, FrozenSegmentRegion, FrozenSegmentRegion.StartSymbol, FrozenSegmentRegion.EndSymbol);
MetadataManager.AddToReadyToRunHeader(ReadyToRunHeader);
MetadataManager.AttachToDependencyGraph(graph);
}
public void AddCompilationRoot(MethodDesc method, string reason, string exportName = null)
{
MethodDesc canonMethod = method.GetCanonMethodTarget(CanonicalFormKind.Specific);
IMethodNode methodEntryPoint;
if (canonMethod != method)
{
methodEntryPoint = _factory.ShadowConcreteMethod(method);
}
else
{
methodEntryPoint = _factory.MethodEntrypoint(method);
}
_graph.AddRoot(methodEntryPoint, reason);
if (exportName != null)
{
_factory.NodeAliases.Add(methodEntryPoint, exportName);
}
}
public override void AttachToDependencyGraph(DependencyAnalyzerBase <NodeFactory> graph)
{
ReadyToRunHeader = new ReadyToRunHeaderNode(Target);
graph.AddRoot(ReadyToRunHeader, "ReadyToRunHeader is always generated");
graph.AddRoot(new ModulesSectionNode(Target), "ModulesSection is always generated");
graph.AddRoot(EagerCctorTable, "EagerCctorTable is always generated");
graph.AddRoot(DispatchMapTable, "DispatchMapTable is always generated");
graph.AddRoot(FrozenSegmentRegion, "FrozenSegmentRegion is always generated");
graph.AddRoot(InterfaceDispatchCellSection, "Interface dispatch cell section is always generated");
graph.AddRoot(TypeManagerIndirection, "ModuleManagerIndirection is always generated");
graph.AddRoot(GCStaticsRegion, "GC StaticsRegion is always generated");
graph.AddRoot(GCStaticDescRegion, "GC Static Desc is always generated");
graph.AddRoot(ThreadStaticsOffsetRegion, "Thread Statics Offset Region is always generated");
graph.AddRoot(ThreadStaticGCDescRegion, "Thread Statics GC Desc Region is always generated");
graph.AddRoot(ImportAddressTablesTable, "Import address tables region");
if (Target.IsWindows)
{
// We need 2 delimiter symbols to bound the unboxing stubs region on Windows platforms (these symbols are
// accessed using extern "C" variables in the bootstrapper)
// On non-Windows platforms, the linker emits special symbols with special names at the begining/end of a section
// so we do not need to emit them ourselves.
graph.AddRoot(new WindowsUnboxingStubsRegionNode(false), "UnboxingStubsRegion delimiter for Windows platform");
graph.AddRoot(new WindowsUnboxingStubsRegionNode(true), "UnboxingStubsRegion delimiter for Windows platform");
}
// The native part of the MRT library links against CRT which defines _tls_index and _tls_used.
if (!buildMRT)
{
graph.AddRoot(ThreadStaticsIndex, "Thread statics index is always generated");
graph.AddRoot(TLSDirectory, "TLS Directory is always generated");
}
ReadyToRunHeader.Add(ReadyToRunSectionType.EagerCctor, EagerCctorTable, EagerCctorTable.StartSymbol, EagerCctorTable.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.InterfaceDispatchTable, DispatchMapTable, DispatchMapTable.StartSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.FrozenObjectRegion, FrozenSegmentRegion, FrozenSegmentRegion.StartSymbol, FrozenSegmentRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.TypeManagerIndirection, TypeManagerIndirection, TypeManagerIndirection);
ReadyToRunHeader.Add(ReadyToRunSectionType.GCStaticRegion, GCStaticsRegion, GCStaticsRegion.StartSymbol, GCStaticsRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.GCStaticDesc, GCStaticDescRegion, GCStaticDescRegion.StartSymbol, GCStaticDescRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticOffsetRegion, ThreadStaticsOffsetRegion, ThreadStaticsOffsetRegion.StartSymbol, ThreadStaticsOffsetRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticGCDescRegion, ThreadStaticGCDescRegion, ThreadStaticGCDescRegion.StartSymbol, ThreadStaticGCDescRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.LoopHijackFlag, LoopHijackFlag, LoopHijackFlag);
ReadyToRunHeader.Add(ReadyToRunSectionType.ImportAddressTables, ImportAddressTablesTable, ImportAddressTablesTable.StartSymbol, ImportAddressTablesTable.EndSymbol);
if (!buildMRT)
{
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticIndex, ThreadStaticsIndex, ThreadStaticsIndex);
}
var commonFixupsTableNode = new ExternalReferencesTableNode("CommonFixupsTable", this);
InteropStubManager.AddToReadyToRunHeader(ReadyToRunHeader, this, commonFixupsTableNode);
MetadataManager.AddToReadyToRunHeader(ReadyToRunHeader, this, commonFixupsTableNode);
MetadataManager.AttachToDependencyGraph(graph);
ReadyToRunHeader.Add(MetadataManager.BlobIdToReadyToRunSection(ReflectionMapBlob.CommonFixupsTable), commonFixupsTableNode, commonFixupsTableNode, commonFixupsTableNode.EndSymbol);
}
public override void AttachToDependencyGraph(DependencyAnalyzerBase <NodeFactory> graph)
{
Header = new HeaderNode(Target);
var compilerIdentifierNode = new CompilerIdentifierNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.CompilerIdentifier, compilerIdentifierNode, compilerIdentifierNode);
RuntimeFunctionsTable = new RuntimeFunctionsTableNode(this);
Header.Add(Internal.Runtime.ReadyToRunSectionType.RuntimeFunctions, RuntimeFunctionsTable, RuntimeFunctionsTable);
RuntimeFunctionsGCInfo = new RuntimeFunctionsGCInfoNode();
graph.AddRoot(RuntimeFunctionsGCInfo, "GC info is always generated");
ProfileDataSection = new ProfileDataSectionNode();
Header.Add(Internal.Runtime.ReadyToRunSectionType.ProfileDataInfo, ProfileDataSection, ProfileDataSection.StartSymbol);
ExceptionInfoLookupTableNode exceptionInfoLookupTableNode = new ExceptionInfoLookupTableNode(this);
Header.Add(Internal.Runtime.ReadyToRunSectionType.ExceptionInfo, exceptionInfoLookupTableNode, exceptionInfoLookupTableNode);
graph.AddRoot(exceptionInfoLookupTableNode, "ExceptionInfoLookupTable is always generated");
MethodEntryPointTable = new MethodEntryPointTableNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.MethodDefEntryPoints, MethodEntryPointTable, MethodEntryPointTable);
ManifestMetadataTable = new ManifestMetadataTableNode(InputModuleContext.GlobalContext);
Header.Add(Internal.Runtime.ReadyToRunSectionType.ManifestMetadata, ManifestMetadataTable, ManifestMetadataTable);
Resolver.SetModuleIndexLookup(ManifestMetadataTable.ModuleToIndex);
InstanceEntryPointTable = new InstanceEntryPointTableNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.InstanceMethodEntryPoints, InstanceEntryPointTable, InstanceEntryPointTable);
TypesTable = new TypesTableNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.AvailableTypes, TypesTable, TypesTable);
ImportSectionsTable = new ImportSectionsTableNode(this);
Header.Add(Internal.Runtime.ReadyToRunSectionType.ImportSections, ImportSectionsTable, ImportSectionsTable.StartSymbol);
DebugInfoTable = new DebugInfoTableNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.DebugInfo, DebugInfoTable, DebugInfoTable);
// Core library attributes are checked FAR more often than other dlls
// attributes, so produce a highly efficient table for determining if they are
// present. Other assemblies *MAY* benefit from this feature, but it doesn't show
// as useful at this time.
if (this.AttributePresenceFilter != null)
{
Header.Add(Internal.Runtime.ReadyToRunSectionType.AttributePresence, AttributePresenceFilter, AttributePresenceFilter);
}
EagerImports = new ImportSectionNode(
"EagerImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_UNKNOWN,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_EAGER,
(byte)Target.PointerSize,
emitPrecode: false,
emitGCRefMap: false);
ImportSectionsTable.AddEmbeddedObject(EagerImports);
// All ready-to-run images have a module import helper which gets patched by the runtime on image load
ModuleImport = new Import(EagerImports, new ReadyToRunHelperSignature(
ILCompiler.ReadyToRunHelper.Module));
graph.AddRoot(ModuleImport, "Module import is required by the R2R format spec");
if (Target.Architecture != TargetArchitecture.X86)
{
Import personalityRoutineImport = new Import(EagerImports, new ReadyToRunHelperSignature(
ILCompiler.ReadyToRunHelper.PersonalityRoutine));
PersonalityRoutine = new ImportThunk(
ILCompiler.ReadyToRunHelper.PersonalityRoutine, this, personalityRoutineImport, useVirtualCall: false);
graph.AddRoot(PersonalityRoutine, "Personality routine is faster to root early rather than referencing it from each unwind info");
Import filterFuncletPersonalityRoutineImport = new Import(EagerImports, new ReadyToRunHelperSignature(
ILCompiler.ReadyToRunHelper.PersonalityRoutineFilterFunclet));
FilterFuncletPersonalityRoutine = new ImportThunk(
ILCompiler.ReadyToRunHelper.PersonalityRoutineFilterFunclet, this, filterFuncletPersonalityRoutineImport, useVirtualCall: false);
graph.AddRoot(FilterFuncletPersonalityRoutine, "Filter funclet personality routine is faster to root early rather than referencing it from each unwind info");
}
MethodImports = new ImportSectionNode(
"MethodImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_STUB_DISPATCH,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_PCODE,
(byte)Target.PointerSize,
emitPrecode: false,
emitGCRefMap: true);
ImportSectionsTable.AddEmbeddedObject(MethodImports);
DispatchImports = new ImportSectionNode(
"DispatchImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_STUB_DISPATCH,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_PCODE,
(byte)Target.PointerSize,
emitPrecode: false,
emitGCRefMap: true);
ImportSectionsTable.AddEmbeddedObject(DispatchImports);
HelperImports = new ImportSectionNode(
"HelperImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_UNKNOWN,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_PCODE,
(byte)Target.PointerSize,
emitPrecode: false,
emitGCRefMap: false);
ImportSectionsTable.AddEmbeddedObject(HelperImports);
PrecodeImports = new ImportSectionNode(
"PrecodeImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_UNKNOWN,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_PCODE,
(byte)Target.PointerSize,
emitPrecode: true,
emitGCRefMap: false);
ImportSectionsTable.AddEmbeddedObject(PrecodeImports);
StringImports = new ImportSectionNode(
"StringImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_STRING_HANDLE,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_UNKNOWN,
(byte)Target.PointerSize,
emitPrecode: true,
emitGCRefMap: false);
ImportSectionsTable.AddEmbeddedObject(StringImports);
graph.AddRoot(ImportSectionsTable, "Import sections table is always generated");
graph.AddRoot(ModuleImport, "Module import is always generated");
graph.AddRoot(EagerImports, "Eager imports are always generated");
graph.AddRoot(MethodImports, "Method imports are always generated");
graph.AddRoot(DispatchImports, "Dispatch imports are always generated");
graph.AddRoot(HelperImports, "Helper imports are always generated");
graph.AddRoot(PrecodeImports, "Precode helper imports are always generated");
graph.AddRoot(StringImports, "String imports are always generated");
graph.AddRoot(Header, "ReadyToRunHeader is always generated");
graph.AddRoot(CopiedCorHeaderNode, "MSIL COR header is always generated");
if (Win32ResourcesNode != null)
{
graph.AddRoot(Win32ResourcesNode, "Win32 Resources are placed if not empty");
}
MetadataManager.AttachToDependencyGraph(graph);
}
/// <summary>
/// Initialize the WindowsDebugData emission pipeline.
/// Cannot be called twice
/// </summary>
/// <param name="nonSectionBasedDebugInfoWriter">debug$T section generation interface. If null, use managed implementation that generates a object file section.</param>
/// <param name="mergedAssemblyRecords">record of how assemblies are merged. If null, do not genearate extended debug information</param>
/// <param name="graph">Graph to attach WindowsDebugData to</param>
public void Init(ITypesDebugInfoWriter nonSectionBasedDebugInfoWriter, MergedAssemblyRecords mergedAssemblyRecords, DependencyAnalyzerBase <NodeFactory> graph)
{
Debug.Assert(_userDefinedTypeDescriptor == null); // Cannot be called twice
Debug.Assert(graph != null);
_debugNeedTypeIndicesStore = new WindowsDebugNeedTypeIndicesStoreNode();
if (mergedAssemblyRecords != null)
{
_debugPseudoAssemblySection = new WindowsDebugPseudoAssemblySection(_nodeFactory.TypeSystemContext);
_debugMergedAssembliesSection = new WindowsDebugMergedAssembliesSection(mergedAssemblyRecords);
_debugILImagesSection = new WindowsDebugILImagesSection(mergedAssemblyRecords);
_debugManagedNativeDictionaryInfoSection = new WindowsDebugManagedNativeDictionaryInfoSection();
}
bool is64Bit = _nodeFactory.Target.PointerSize == 8 ? true : false;
if (nonSectionBasedDebugInfoWriter != null)
{
_userDefinedTypeDescriptor = new UserDefinedTypeDescriptor(nonSectionBasedDebugInfoWriter, is64Bit, _nodeFactory.Target.Abi);
}
else
{
_debugTypeRecordsSection = new WindowsDebugTypeRecordsSection(new DebugInfoWriter(), _nodeFactory);
_userDefinedTypeDescriptor = new UserDefinedTypeDescriptor(_debugTypeRecordsSection, is64Bit, _nodeFactory.Target.Abi);
}
if (mergedAssemblyRecords != null)
{
_debugTypeSignatureMapSection = new WindowsDebugTypeSignatureMapSection(_userDefinedTypeDescriptor);
_debugMethodSignatureMapSection = new WindowsDebugMethodSignatureMapSection();
}
graph.AddRoot(_debugNeedTypeIndicesStore, "Debug Force All EETypes to have type indices");
if (_debugManagedNativeDictionaryInfoSection != null)
{
graph.AddRoot(_debugManagedNativeDictionaryInfoSection, "Debug Method MDToken map");
}
if (_debugMethodSignatureMapSection != null)
{
graph.AddRoot(_debugMethodSignatureMapSection, "Debug Method MDToken map");
}
if (_debugTypeSignatureMapSection != null)
{
graph.AddRoot(_debugTypeSignatureMapSection, "Debug Type MDToken map");
}
if (_debugILImagesSection != null)
{
graph.AddRoot(_debugILImagesSection, "Debug Merged ILImages");
}
if (_debugMergedAssembliesSection != null)
{
graph.AddRoot(_debugMergedAssembliesSection, "Debug MergedAssemblyRecords");
}
if (_debugPseudoAssemblySection != null)
{
graph.AddRoot(_debugPseudoAssemblySection, "Debug PseudoAssembly");
}
if (_debugTypeRecordsSection != null)
{
graph.AddRoot(_debugTypeRecordsSection, "Debug Type Records");
}
}
public override void AttachToDependencyGraph(DependencyAnalyzerBase <NodeFactory> graph)
{
Header = new HeaderNode(Target);
var compilerIdentifierNode = new CompilerIdentifierNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.CompilerIdentifier, compilerIdentifierNode, compilerIdentifierNode);
RuntimeFunctionsTable = new RuntimeFunctionsTableNode(this);
Header.Add(Internal.Runtime.ReadyToRunSectionType.RuntimeFunctions, RuntimeFunctionsTable, RuntimeFunctionsTable);
RuntimeFunctionsGCInfo = new RuntimeFunctionsGCInfoNode();
graph.AddRoot(RuntimeFunctionsGCInfo, "GC info is always generated");
ExceptionInfoLookupTableNode exceptionInfoLookupTableNode = new ExceptionInfoLookupTableNode(this);
Header.Add(Internal.Runtime.ReadyToRunSectionType.ExceptionInfo, exceptionInfoLookupTableNode, exceptionInfoLookupTableNode);
graph.AddRoot(exceptionInfoLookupTableNode, "ExceptionInfoLookupTable is always generated");
MethodEntryPointTable = new MethodEntryPointTableNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.MethodDefEntryPoints, MethodEntryPointTable, MethodEntryPointTable);
InstanceEntryPointTable = new InstanceEntryPointTableNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.InstanceMethodEntryPoints, InstanceEntryPointTable, InstanceEntryPointTable);
TypesTable = new TypesTableNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.AvailableTypes, TypesTable, TypesTable);
ImportSectionsTable = new ImportSectionsTableNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.ImportSections, ImportSectionsTable, ImportSectionsTable.StartSymbol);
DebugInfoTable = new DebugInfoTableNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.DebugInfo, DebugInfoTable, DebugInfoTable);
EagerImports = new ImportSectionNode(
"EagerImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_UNKNOWN,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_EAGER,
(byte)Target.PointerSize,
emitPrecode: false,
emitGCRefMap: false);
ImportSectionsTable.AddEmbeddedObject(EagerImports);
// All ready-to-run images have a module import helper which gets patched by the runtime on image load
ModuleImport = new Import(EagerImports, new ReadyToRunHelperSignature(
ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_Module));
graph.AddRoot(ModuleImport, "Module import is required by the R2R format spec");
if (Target.Architecture != TargetArchitecture.X86)
{
Import personalityRoutineImport = new Import(EagerImports, new ReadyToRunHelperSignature(
ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_PersonalityRoutine));
PersonalityRoutine = new ImportThunk(
ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_PersonalityRoutine, this, personalityRoutineImport);
graph.AddRoot(PersonalityRoutine, "Personality routine is faster to root early rather than referencing it from each unwind info");
Import filterFuncletPersonalityRoutineImport = new Import(EagerImports, new ReadyToRunHelperSignature(
ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_PersonalityRoutineFilterFunclet));
FilterFuncletPersonalityRoutine = new ImportThunk(
ILCompiler.DependencyAnalysis.ReadyToRun.ReadyToRunHelper.READYTORUN_HELPER_PersonalityRoutineFilterFunclet, this, filterFuncletPersonalityRoutineImport);
graph.AddRoot(FilterFuncletPersonalityRoutine, "Filter funclet personality routine is faster to root early rather than referencing it from each unwind info");
}
MethodImports = new ImportSectionNode(
"MethodImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_STUB_DISPATCH,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_PCODE,
(byte)Target.PointerSize,
emitPrecode: false,
emitGCRefMap: true);
ImportSectionsTable.AddEmbeddedObject(MethodImports);
DispatchImports = new ImportSectionNode(
"DispatchImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_STUB_DISPATCH,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_PCODE,
(byte)Target.PointerSize,
emitPrecode: false,
emitGCRefMap: true);
ImportSectionsTable.AddEmbeddedObject(DispatchImports);
HelperImports = new ImportSectionNode(
"HelperImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_UNKNOWN,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_PCODE,
(byte)Target.PointerSize,
emitPrecode: false,
emitGCRefMap: false);
ImportSectionsTable.AddEmbeddedObject(HelperImports);
PrecodeImports = new ImportSectionNode(
"PrecodeImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_UNKNOWN,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_PCODE,
(byte)Target.PointerSize,
emitPrecode: true,
emitGCRefMap: false);
ImportSectionsTable.AddEmbeddedObject(PrecodeImports);
StringImports = new ImportSectionNode(
"StringImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_STRING_HANDLE,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_UNKNOWN,
(byte)Target.PointerSize,
emitPrecode: true,
emitGCRefMap: false);
ImportSectionsTable.AddEmbeddedObject(StringImports);
graph.AddRoot(ImportSectionsTable, "Import sections table is always generated");
graph.AddRoot(ModuleImport, "Module import is always generated");
graph.AddRoot(EagerImports, "Eager imports are always generated");
graph.AddRoot(MethodImports, "Method imports are always generated");
graph.AddRoot(DispatchImports, "Dispatch imports are always generated");
graph.AddRoot(HelperImports, "Helper imports are always generated");
graph.AddRoot(PrecodeImports, "Precode imports are always generated");
graph.AddRoot(StringImports, "String imports are always generated");
graph.AddRoot(Header, "ReadyToRunHeader is always generated");
MetadataManager.AttachToDependencyGraph(graph);
}
public override void AttachToDependencyGraph(DependencyAnalyzerBase <NodeFactory> graph)
{
ReadyToRunHeader = new ReadyToRunHeaderNode(Target);
graph.AddRoot(ReadyToRunHeader, "ReadyToRunHeader is always generated");
graph.AddRoot(new ModulesSectionNode(Target), "ModulesSection is always generated");
graph.AddRoot(EagerCctorTable, "EagerCctorTable is always generated");
graph.AddRoot(DispatchMapTable, "DispatchMapTable is always generated");
graph.AddRoot(FrozenSegmentRegion, "FrozenSegmentRegion is always generated");
graph.AddRoot(TypeManagerIndirection, "ModuleManagerIndirection is always generated");
graph.AddRoot(GCStaticsRegion, "GC StaticsRegion is always generated");
graph.AddRoot(GCStaticDescRegion, "GC Static Desc is always generated");
graph.AddRoot(ThreadStaticsRegion, "Thread Statics Region is always generated");
graph.AddRoot(ThreadStaticsOffsetRegion, "Thread Statics Offset Region is always generated");
graph.AddRoot(ThreadStaticGCDescRegion, "Thread Statics GC Desc Region is always generated");
graph.AddRoot(ThreadStaticsIndex, "Thread statics index is always generated");
graph.AddRoot(ThreadStaticsStartOffset, "Thread statics start offset is always generated");
graph.AddRoot(TLSDirectory, "TLS Directory is always generated");
ReadyToRunHeader.Add(ReadyToRunSectionType.EagerCctor, EagerCctorTable, EagerCctorTable.StartSymbol, EagerCctorTable.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.InterfaceDispatchTable, DispatchMapTable, DispatchMapTable.StartSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.FrozenObjectRegion, FrozenSegmentRegion, FrozenSegmentRegion.StartSymbol, FrozenSegmentRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.TypeManagerIndirection, TypeManagerIndirection, TypeManagerIndirection);
ReadyToRunHeader.Add(ReadyToRunSectionType.GCStaticRegion, GCStaticsRegion, GCStaticsRegion.StartSymbol, GCStaticsRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.GCStaticDesc, GCStaticDescRegion, GCStaticDescRegion.StartSymbol, GCStaticDescRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticRegion, ThreadStaticsRegion, ThreadStaticsRegion.StartSymbol, ThreadStaticsRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticOffsetRegion, ThreadStaticsOffsetRegion, ThreadStaticsOffsetRegion.StartSymbol, ThreadStaticsOffsetRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticGCDescRegion, ThreadStaticGCDescRegion, ThreadStaticGCDescRegion.StartSymbol, ThreadStaticGCDescRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticIndex, ThreadStaticsIndex, ThreadStaticsIndex);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticStartOffset, ThreadStaticsStartOffset, ThreadStaticsStartOffset);
MetadataManager.AddToReadyToRunHeader(ReadyToRunHeader);
MetadataManager.AttachToDependencyGraph(graph);
}
public void AddCompilationRoot(MethodDesc method, string reason, string exportName = null)
{
MethodDesc canonMethod = method.GetCanonMethodTarget(CanonicalFormKind.Specific);
IMethodNode methodEntryPoint = _factory.MethodEntrypoint(canonMethod);
_graph.AddRoot(methodEntryPoint, reason);
if (exportName != null)
{
_factory.NodeAliases.Add(methodEntryPoint, exportName);
}
if (canonMethod != method && method.HasInstantiation)
{
_graph.AddRoot(_factory.MethodGenericDictionary(method), reason);
}
}
public override void AttachToDependencyGraph(DependencyAnalyzerBase <NodeFactory> graph)
{
ReadyToRunHeader = new ReadyToRunHeaderNode(Target);
graph.AddRoot(ReadyToRunHeader, "ReadyToRunHeader is always generated");
graph.AddRoot(new ModulesSectionNode(Target), "ModulesSection is always generated");
graph.AddRoot(EagerCctorTable, "EagerCctorTable is always generated");
graph.AddRoot(DispatchMapTable, "DispatchMapTable is always generated");
graph.AddRoot(FrozenSegmentRegion, "FrozenSegmentRegion is always generated");
graph.AddRoot(TypeManagerIndirection, "ModuleManagerIndirection is always generated");
graph.AddRoot(GCStaticsRegion, "GC StaticsRegion is always generated");
graph.AddRoot(GCStaticDescRegion, "GC Static Desc is always generated");
graph.AddRoot(ThreadStaticsOffsetRegion, "Thread Statics Offset Region is always generated");
graph.AddRoot(ThreadStaticGCDescRegion, "Thread Statics GC Desc Region is always generated");
// The native part of the MRT library links against CRT which defines _tls_index and _tls_used.
if (!buildMRT)
{
graph.AddRoot(ThreadStaticsIndex, "Thread statics index is always generated");
graph.AddRoot(TLSDirectory, "TLS Directory is always generated");
}
ReadyToRunHeader.Add(ReadyToRunSectionType.EagerCctor, EagerCctorTable, EagerCctorTable.StartSymbol, EagerCctorTable.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.InterfaceDispatchTable, DispatchMapTable, DispatchMapTable.StartSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.FrozenObjectRegion, FrozenSegmentRegion, FrozenSegmentRegion.StartSymbol, FrozenSegmentRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.TypeManagerIndirection, TypeManagerIndirection, TypeManagerIndirection);
ReadyToRunHeader.Add(ReadyToRunSectionType.GCStaticRegion, GCStaticsRegion, GCStaticsRegion.StartSymbol, GCStaticsRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.GCStaticDesc, GCStaticDescRegion, GCStaticDescRegion.StartSymbol, GCStaticDescRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticOffsetRegion, ThreadStaticsOffsetRegion, ThreadStaticsOffsetRegion.StartSymbol, ThreadStaticsOffsetRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticGCDescRegion, ThreadStaticGCDescRegion, ThreadStaticGCDescRegion.StartSymbol, ThreadStaticGCDescRegion.EndSymbol);
if (!buildMRT)
{
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticIndex, ThreadStaticsIndex, ThreadStaticsIndex);
}
MetadataManager.AddToReadyToRunHeader(ReadyToRunHeader, this);
MetadataManager.AttachToDependencyGraph(graph);
}
public void AttachToDependencyGraph(DependencyAnalyzerBase <NodeFactory> graph)
{
graph.ComputingDependencyPhaseChange += Graph_ComputingDependencyPhaseChange;
var compilerIdentifierNode = new CompilerIdentifierNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.CompilerIdentifier, compilerIdentifierNode, compilerIdentifierNode);
RuntimeFunctionsTable = new RuntimeFunctionsTableNode(this);
Header.Add(Internal.Runtime.ReadyToRunSectionType.RuntimeFunctions, RuntimeFunctionsTable, RuntimeFunctionsTable);
RuntimeFunctionsGCInfo = new RuntimeFunctionsGCInfoNode();
graph.AddRoot(RuntimeFunctionsGCInfo, "GC info is always generated");
ProfileDataSection = new ProfileDataSectionNode();
Header.Add(Internal.Runtime.ReadyToRunSectionType.ProfileDataInfo, ProfileDataSection, ProfileDataSection.StartSymbol);
DelayLoadMethodCallThunks = new DelayLoadMethodCallThunkNodeRange();
Header.Add(Internal.Runtime.ReadyToRunSectionType.DelayLoadMethodCallThunks, DelayLoadMethodCallThunks, DelayLoadMethodCallThunks);
ExceptionInfoLookupTableNode exceptionInfoLookupTableNode = new ExceptionInfoLookupTableNode(this);
Header.Add(Internal.Runtime.ReadyToRunSectionType.ExceptionInfo, exceptionInfoLookupTableNode, exceptionInfoLookupTableNode);
graph.AddRoot(exceptionInfoLookupTableNode, "ExceptionInfoLookupTable is always generated");
ManifestMetadataTable = new ManifestMetadataTableNode(this);
Header.Add(Internal.Runtime.ReadyToRunSectionType.ManifestMetadata, ManifestMetadataTable, ManifestMetadataTable);
Resolver.SetModuleIndexLookup(ManifestMetadataTable.ModuleToIndex);
ManifestAssemblyMvidHeaderNode mvidTableNode = new ManifestAssemblyMvidHeaderNode(ManifestMetadataTable);
Header.Add(Internal.Runtime.ReadyToRunSectionType.ManifestAssemblyMvids, mvidTableNode, mvidTableNode);
AssemblyTableNode assemblyTable = null;
if (CompilationModuleGroup.IsCompositeBuildMode)
{
assemblyTable = new AssemblyTableNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.ComponentAssemblies, assemblyTable, assemblyTable);
}
// Generate per assembly header tables
int assemblyIndex = -1;
foreach (EcmaModule inputModule in CompilationModuleGroup.CompilationModuleSet)
{
assemblyIndex++;
HeaderNode tableHeader = Header;
if (assemblyTable != null)
{
AssemblyHeaderNode perAssemblyHeader = new AssemblyHeaderNode(Target, ReadyToRunFlags.READYTORUN_FLAG_Component, assemblyIndex);
assemblyTable.Add(perAssemblyHeader);
tableHeader = perAssemblyHeader;
}
MethodEntryPointTableNode methodEntryPointTable = new MethodEntryPointTableNode(inputModule, Target);
tableHeader.Add(Internal.Runtime.ReadyToRunSectionType.MethodDefEntryPoints, methodEntryPointTable, methodEntryPointTable);
TypesTableNode typesTable = new TypesTableNode(Target, inputModule);
tableHeader.Add(Internal.Runtime.ReadyToRunSectionType.AvailableTypes, typesTable, typesTable);
InliningInfoNode inliningInfoTable = new InliningInfoNode(Target, inputModule);
tableHeader.Add(Internal.Runtime.ReadyToRunSectionType.InliningInfo2, inliningInfoTable, inliningInfoTable);
// Core library attributes are checked FAR more often than other dlls
// attributes, so produce a highly efficient table for determining if they are
// present. Other assemblies *MAY* benefit from this feature, but it doesn't show
// as useful at this time.
if (inputModule == TypeSystemContext.SystemModule)
{
AttributePresenceFilterNode attributePresenceTable = new AttributePresenceFilterNode(inputModule);
Header.Add(Internal.Runtime.ReadyToRunSectionType.AttributePresence, attributePresenceTable, attributePresenceTable);
}
}
InstanceEntryPointTable = new InstanceEntryPointTableNode(this);
Header.Add(Internal.Runtime.ReadyToRunSectionType.InstanceMethodEntryPoints, InstanceEntryPointTable, InstanceEntryPointTable);
ImportSectionsTable = new ImportSectionsTableNode(this);
Header.Add(Internal.Runtime.ReadyToRunSectionType.ImportSections, ImportSectionsTable, ImportSectionsTable.StartSymbol);
DebugInfoTable = new DebugInfoTableNode(Target);
Header.Add(Internal.Runtime.ReadyToRunSectionType.DebugInfo, DebugInfoTable, DebugInfoTable);
EagerImports = new ImportSectionNode(
"EagerImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_UNKNOWN,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_EAGER,
(byte)Target.PointerSize,
emitPrecode: false,
emitGCRefMap: false);
ImportSectionsTable.AddEmbeddedObject(EagerImports);
// All ready-to-run images have a module import helper which gets patched by the runtime on image load
ModuleImport = new Import(EagerImports, new ReadyToRunHelperSignature(
ReadyToRunHelper.Module));
graph.AddRoot(ModuleImport, "Module import is required by the R2R format spec");
if (Target.Architecture != TargetArchitecture.X86)
{
Import personalityRoutineImport = new Import(EagerImports, new ReadyToRunHelperSignature(
ReadyToRunHelper.PersonalityRoutine));
PersonalityRoutine = new ImportThunk(this,
ReadyToRunHelper.PersonalityRoutine, EagerImports, useVirtualCall: false, useJumpableStub: false);
graph.AddRoot(PersonalityRoutine, "Personality routine is faster to root early rather than referencing it from each unwind info");
Import filterFuncletPersonalityRoutineImport = new Import(EagerImports, new ReadyToRunHelperSignature(
ReadyToRunHelper.PersonalityRoutineFilterFunclet));
FilterFuncletPersonalityRoutine = new ImportThunk(this,
ReadyToRunHelper.PersonalityRoutineFilterFunclet, EagerImports, useVirtualCall: false, useJumpableStub: false);
graph.AddRoot(FilterFuncletPersonalityRoutine, "Filter funclet personality routine is faster to root early rather than referencing it from each unwind info");
}
if ((ProfileDataManager != null) && (ProfileDataManager.EmbedPgoDataInR2RImage))
{
// Profile instrumentation data attaches here
HashSet <MethodDesc> methodsToInsertInstrumentationDataFor = new HashSet <MethodDesc>();
foreach (EcmaModule inputModule in CompilationModuleGroup.CompilationModuleSet)
{
foreach (MethodDesc method in ProfileDataManager.GetMethodsForModuleDesc(inputModule))
{
if (ProfileDataManager[method].SchemaData != null)
{
methodsToInsertInstrumentationDataFor.Add(method);
}
}
}
if (methodsToInsertInstrumentationDataFor.Count != 0)
{
MethodDesc[] methodsToInsert = methodsToInsertInstrumentationDataFor.ToArray();
methodsToInsert.MergeSort(new TypeSystemComparer().Compare);
InstrumentationDataTable = new InstrumentationDataTableNode(this, methodsToInsert, ProfileDataManager);
Header.Add(Internal.Runtime.ReadyToRunSectionType.PgoInstrumentationData, InstrumentationDataTable, InstrumentationDataTable);
}
}
MethodImports = new ImportSectionNode(
"MethodImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_STUB_DISPATCH,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_PCODE,
(byte)Target.PointerSize,
emitPrecode: false,
emitGCRefMap: true);
ImportSectionsTable.AddEmbeddedObject(MethodImports);
DispatchImports = new ImportSectionNode(
"DispatchImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_STUB_DISPATCH,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_PCODE,
(byte)Target.PointerSize,
emitPrecode: false,
emitGCRefMap: true);
ImportSectionsTable.AddEmbeddedObject(DispatchImports);
HelperImports = new ImportSectionNode(
"HelperImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_UNKNOWN,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_PCODE,
(byte)Target.PointerSize,
emitPrecode: false,
emitGCRefMap: false);
ImportSectionsTable.AddEmbeddedObject(HelperImports);
PrecodeImports = new ImportSectionNode(
"PrecodeImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_UNKNOWN,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_PCODE,
(byte)Target.PointerSize,
emitPrecode: true,
emitGCRefMap: false);
ImportSectionsTable.AddEmbeddedObject(PrecodeImports);
StringImports = new ImportSectionNode(
"StringImports",
CorCompileImportType.CORCOMPILE_IMPORT_TYPE_STRING_HANDLE,
CorCompileImportFlags.CORCOMPILE_IMPORT_FLAGS_UNKNOWN,
(byte)Target.PointerSize,
emitPrecode: true,
emitGCRefMap: false);
ImportSectionsTable.AddEmbeddedObject(StringImports);
graph.AddRoot(ImportSectionsTable, "Import sections table is always generated");
graph.AddRoot(ModuleImport, "Module import is always generated");
graph.AddRoot(EagerImports, "Eager imports are always generated");
graph.AddRoot(MethodImports, "Method imports are always generated");
graph.AddRoot(DispatchImports, "Dispatch imports are always generated");
graph.AddRoot(HelperImports, "Helper imports are always generated");
graph.AddRoot(PrecodeImports, "Precode helper imports are always generated");
graph.AddRoot(StringImports, "String imports are always generated");
graph.AddRoot(Header, "ReadyToRunHeader is always generated");
graph.AddRoot(CopiedCorHeaderNode, "MSIL COR header is always generated for R2R files");
graph.AddRoot(DebugDirectoryNode, "Debug Directory will always contain at least one entry");
if (Win32ResourcesNode != null)
{
graph.AddRoot(Win32ResourcesNode, "Win32 Resources are placed if not empty");
}
MetadataManager.AttachToDependencyGraph(graph);
}
public void AddRoot(string nodeNode, string reason)
{
_analyzer.AddRoot(this.GetNode(nodeNode), reason);
}
public override void AttachToDependencyGraph(DependencyAnalyzerBase <NodeFactory> graph)
{
ReadyToRunHeader = new ReadyToRunHeaderNode(Target);
graph.AddRoot(ReadyToRunHeader, "ReadyToRunHeader is always generated");
graph.AddRoot(new ModulesSectionNode(Target), "ModulesSection is always generated");
graph.AddRoot(EagerCctorTable, "EagerCctorTable is always generated");
graph.AddRoot(DispatchMapTable, "DispatchMapTable is always generated");
graph.AddRoot(FrozenSegmentRegion, "FrozenSegmentRegion is always generated");
graph.AddRoot(InterfaceDispatchCellSection, "Interface dispatch cell section is always generated");
graph.AddRoot(TypeManagerIndirection, "ModuleManagerIndirection is always generated");
graph.AddRoot(GCStaticsRegion, "GC StaticsRegion is always generated");
graph.AddRoot(GCStaticDescRegion, "GC Static Desc is always generated");
graph.AddRoot(ThreadStaticsOffsetRegion, "Thread Statics Offset Region is always generated");
graph.AddRoot(ThreadStaticGCDescRegion, "Thread Statics GC Desc Region is always generated");
graph.AddRoot(ImportAddressTablesTable, "Import address tables region");
// The native part of the MRT library links against CRT which defines _tls_index and _tls_used.
if (!buildMRT)
{
graph.AddRoot(ThreadStaticsIndex, "Thread statics index is always generated");
graph.AddRoot(TLSDirectory, "TLS Directory is always generated");
}
ReadyToRunHeader.Add(ReadyToRunSectionType.EagerCctor, EagerCctorTable, EagerCctorTable.StartSymbol, EagerCctorTable.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.InterfaceDispatchTable, DispatchMapTable, DispatchMapTable.StartSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.FrozenObjectRegion, FrozenSegmentRegion, FrozenSegmentRegion.StartSymbol, FrozenSegmentRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.TypeManagerIndirection, TypeManagerIndirection, TypeManagerIndirection);
ReadyToRunHeader.Add(ReadyToRunSectionType.GCStaticRegion, GCStaticsRegion, GCStaticsRegion.StartSymbol, GCStaticsRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.GCStaticDesc, GCStaticDescRegion, GCStaticDescRegion.StartSymbol, GCStaticDescRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticOffsetRegion, ThreadStaticsOffsetRegion, ThreadStaticsOffsetRegion.StartSymbol, ThreadStaticsOffsetRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticGCDescRegion, ThreadStaticGCDescRegion, ThreadStaticGCDescRegion.StartSymbol, ThreadStaticGCDescRegion.EndSymbol);
ReadyToRunHeader.Add(ReadyToRunSectionType.LoopHijackFlag, LoopHijackFlag, LoopHijackFlag);
ReadyToRunHeader.Add(ReadyToRunSectionType.ImportAddressTables, ImportAddressTablesTable, ImportAddressTablesTable.StartSymbol, ImportAddressTablesTable.EndSymbol);
if (!buildMRT)
{
ReadyToRunHeader.Add(ReadyToRunSectionType.ThreadStaticIndex, ThreadStaticsIndex, ThreadStaticsIndex);
}
var commonFixupsTableNode = new ExternalReferencesTableNode("CommonFixupsTable", this);
InteropStubManager.AddToReadyToRunHeader(ReadyToRunHeader, this, commonFixupsTableNode);
MetadataManager.AddToReadyToRunHeader(ReadyToRunHeader, this, commonFixupsTableNode);
MetadataManager.AttachToDependencyGraph(graph);
ReadyToRunHeader.Add(MetadataManager.BlobIdToReadyToRunSection(ReflectionMapBlob.CommonFixupsTable), commonFixupsTableNode, commonFixupsTableNode, commonFixupsTableNode.EndSymbol);
}