NodeFactory

Compiler\AnalysisBasedInteropStubManager.cs (6)

11using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 12using DependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencySink; 13using IDependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.IDependencySink; 46public override void AddDependenciesDueToMethodCodePresence(IDependencySink dependencies, NodeFactory factory, MethodDesc method) 50public override void AddInterestingInteropConstructedTypeDependencies(DependencySink dependencies, NodeFactory factory, TypeDesc type) 54public override void AddMarshalAPIsGenericDependencies(IDependencySink dependencies, NodeFactory factory, MethodDesc method)

Compiler\AnalysisBasedMetadataManager.cs (1)

143protected override void ComputeMetadata(NodeFactory factory,

Compiler\Compilation.cs (11)

25protected readonly DependencyAnalyzerBase<NodeFactory> _dependencyGraph; 26protected readonly NodeFactory _nodeFactory; 32public NodeFactory NodeFactory => _nodeFactory; 42DependencyAnalyzerBase<NodeFactory> dependencyGraph, 43NodeFactory nodeFactory, 88protected abstract void ComputeDependencyNodeDependencies(List<DependencyNodeCore<NodeFactory>> obj); 627private readonly DependencyAnalyzerBase<NodeFactory> _graph; 628protected readonly NodeFactory _factory; 630protected ImmutableArray<DependencyNodeCore<NodeFactory>> MarkedNodes 638internal CompilationResults(DependencyAnalyzerBase<NodeFactory> graph, NodeFactory factory)

Compiler\CompilerGeneratedInteropStubManager.cs (1)

31public sealed override void AddToReadyToRunHeader(ReadyToRunHeaderNode header, NodeFactory nodeFactory, ExternalReferencesTableNode commonFixupsTableNode)

Compiler\Dataflow\AttributeDataFlow.cs (3)

18using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 28private readonly NodeFactory _factory; 33public AttributeDataFlow(Logger logger, NodeFactory factory, FlowAnnotations annotations, in MessageOrigin origin)

Compiler\Dataflow\GenericArgumentDataFlow.cs (6)

14using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 15using DependencyListEntry = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyListEntry; 16using IDependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.IDependencySink; 27NodeFactory factory, 45public static void ProcessGenericArgumentDataFlow(IDependencySink dependencies, NodeFactory factory, in MessageOrigin origin, TypeDesc type, MethodDesc contextMethod) 52NodeFactory factory,

Compiler\Dataflow\HandleCallAction.cs (6)

16using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 17using DependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencySink; 824NodeFactory factory, 828DependencyNodeCore<NodeFactory>? otherReasonNode) 853NodeFactory factory, 857DependencyNodeCore<NodeFactory>? otherReasonNode)

Compiler\Dataflow\ReflectionMarker.cs (4)

16using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 17using IDependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.IDependencySink; 34public NodeFactory Factory { get; } 55NodeFactory factory,

Compiler\Dataflow\ReflectionMethodBodyScanner.cs (7)

19using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 20using DependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencySink; 23using NodeFactory = ILCompiler.DependencyAnalysis.NodeFactory; 32private readonly NodeFactory _factory; 103private ReflectionMethodBodyScanner(NodeFactory factory, FlowAnnotations annotations, Logger logger, MessageOrigin origin) 128public static DependencyList ScanAndProcessReturnValue(NodeFactory factory, FlowAnnotations annotations, Logger logger, MethodIL methodIL, out List<(MethodDesc OwningMethod, INodeWithRuntimeDeterminedDependencies Dependency)> runtimeDependencies) 142public static void AddTypeGetTypeDataflowDependencies(DependencySink dependencies, NodeFactory factory, FlowAnnotations flowAnnotations, Logger logger, MetadataType type)

Compiler\DelegateCreationInfo.cs (3)

109public GenericLookupResult GetLookupKind(NodeFactory factory) 133public ISymbolNode GetTargetNode(NodeFactory factory) 186public static DelegateCreationInfo Create(TypeDesc delegateType, MethodDesc targetMethod, TypeDesc constrainedType, NodeFactory factory, bool followVirtualDispatch)

Compiler\DependencyAnalysis\AddressTakenMethodNode.cs (6)

40protected override string GetName(NodeFactory factory) 45public override bool ShouldSkipEmittingObjectNode(NodeFactory factory) 50public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 51public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 69public ISymbolNode NodeForLinkage(NodeFactory factory)

Compiler\DependencyAnalysis\AnalysisCharacteristicNode.cs (6)

10public class AnalysisCharacteristicNode : DependencyNodeCore<NodeFactory> 21public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 22public override void AddStaticDependencies(DependencySink sink, NodeFactory context) { } 23public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 24protected override string GetName(NodeFactory context) => $"Analysis characteristic: {Characteristic}";

Compiler\DependencyAnalysis\AnalyzedExternalTypeMapNode.cs (7)

17public Vertex CreateTypeMap(NodeFactory factory, NativeWriter writer, Section section, INativeFormatTypeReferenceProvider externalReferences) 35public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 36public override void AddStaticDependencies(DependencySink sink, NodeFactory context) 43public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 44protected override string GetName(NodeFactory context) => $"Analyzed External Type Map: {TypeMapGroup}"; 45public IExternalTypeMapNode ToAnalysisBasedNode(NodeFactory factory) => this;

Compiler\DependencyAnalysis\AnalyzedProxyTypeMapNode.cs (7)

17public Vertex CreateTypeMap(NodeFactory factory, NativeWriter writer, Section section, INativeFormatTypeReferenceProvider externalReferences) 35public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 36public override void AddStaticDependencies(DependencySink sink, NodeFactory context) 44public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 45protected override string GetName(NodeFactory context) => $"Analyzed Proxy Type Map: {typeMapGroup}"; 46public IProxyTypeMapNode ToAnalysisBasedNode(NodeFactory factory) => this;

Compiler\DependencyAnalysis\ArrayMapNode.cs (3)

31public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 35protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 37public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ArrayOfEmbeddedDataNode.cs (5)

36protected override string GetName(NodeFactory factory) => $"Region {this.GetMangledName(factory.NameMangler)}"; 38public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.DataSection; 47protected virtual void GetElementDataForNodes(ref ObjectDataBuilder builder, NodeFactory factory, bool relocsOnly) 73public override ObjectData GetData(NodeFactory factory, bool relocsOnly) 89public override bool ShouldSkipEmittingObjectNode(NodeFactory factory)

Compiler\DependencyAnalysis\ArrayOfEmbeddedPointersNode.cs (3)

80protected override string GetName(NodeFactory factory) => $"Embedded pointer to {Target.GetMangledName(factory.NameMangler)}"; 82protected override void OnMarked(NodeFactory factory) 89public override void AddStaticDependencies(DependencySink sink, NodeFactory factory)

Compiler\DependencyAnalysis\ArrayOfFrozenObjectsNode.cs (4)

21private static void AlignNextObject(ref ObjectDataBuilder builder, NodeFactory factory) 26protected override ObjectData GetDehydratableData(NodeFactory factory, bool relocsOnly) 61protected override ObjectNodeSection GetDehydratedSection(NodeFactory factory) => ObjectNodeSection.DataSection; 62protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\BlobNode.cs (3)

25public override ObjectNodeSection GetSection(NodeFactory factory) => _section; 35public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 40protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\ByRefTypeMapNode.cs (3)

30public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 34protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 36public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\CanonicalDefinitionEETypeNode.cs (3)

14public CanonicalDefinitionEETypeNode(NodeFactory factory, TypeDesc type) : base(factory, type) 19public override bool ShouldSkipEmittingObjectNode(NodeFactory factory) => false; 22protected override void ComputeNonRelocationBasedDependencies(DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\ClassConstructorContextMap.cs (3)

29public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 34protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 36public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\CodeBasedDependencyAlgorithm.cs (6)

Compiler\DependencyAnalysis\ConstructedEETypeNode.cs (9)

Compiler\DependencyAnalysis\CustomAttributeBasedDependencyAlgorithm.cs (19)

Compiler\DependencyAnalysis\CustomAttributeMetadataNode.cs (6)

16internal sealed class CustomAttributeMetadataNode : DependencyNodeCore<NodeFactory> 33public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) { } 35protected override string GetName(NodeFactory factory) 44public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 45public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\DataflowAnalyzedMethodNode.cs (6)

19public class DataflowAnalyzedMethodNode : DependencyNodeCore<NodeFactory> 31public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 49public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) 78protected override string GetName(NodeFactory factory) 87public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { }

Compiler\DependencyAnalysis\DataflowAnalyzedTypeDefinitionNode.cs (7)

18public class DataflowAnalyzedTypeDefinitionNode : DependencyNodeCore<NodeFactory> 28public static void AddDependencies(DependencySink dependencies, NodeFactory factory, FlowAnnotations flowAnnotations, TypeDesc type) 65public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 91protected override string GetName(NodeFactory factory) 100public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 101public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { }

Compiler\DependencyAnalysis\DataOnlyEETypeNode.cs (3)

35protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 37protected override ObjectNodeSection GetDehydratedSection(NodeFactory factory) 69protected override ObjectData GetDehydratableData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\DehydratableObjectNode.cs (4)

8public sealed override ObjectNodeSection GetSection(NodeFactory factory) 17public sealed override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 38protected abstract ObjectNodeSection GetDehydratedSection(NodeFactory factory); 39protected abstract ObjectData GetDehydratableData(NodeFactory factory, bool relocsOnly = false);

Compiler\DependencyAnalysis\DehydratedDataNode.cs (3)

50protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 52public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 320public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection;

Compiler\DependencyAnalysis\DelegateMarshallingDataNode.cs (6)

17public class DelegateMarshallingDataNode : DependencyNodeCore<NodeFactory> 29public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 40protected override string GetName(NodeFactory context) 49public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 50public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { }

Compiler\DependencyAnalysis\DelegateMarshallingStubMapNode.cs (3)

33public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 37protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 39public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\DelegateTargetVirtualMethodNode.cs (12)

16public class DelegateTargetVirtualMethodNode : DependencyNodeCore<NodeFactory> 28protected override string GetName(NodeFactory factory) 33public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) { } 38public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 39public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { } 42public sealed class ReflectableVirtualMethodImplNode : DependencyNodeCore<NodeFactory> 56protected override string GetName(NodeFactory factory) 61public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) { } 67public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 75public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\DictionaryLayoutNode.cs (10)

24public abstract class DictionaryLayoutNode : DependencyNodeCore<NodeFactory> 50public virtual ObjectNodeSection DictionarySection(NodeFactory factory) 109public virtual ICollection<NativeLayoutVertexNode> GetTemplateEntries(NodeFactory factory) 120public virtual void EmitDictionaryData(ref ObjectDataBuilder builder, NodeFactory factory, GenericDictionaryNode dictionary, bool fixedLayoutOnly) 140public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 146foreach (DependencyNodeCore<NodeFactory> dependency in lookupResult.NonRelocDependenciesFromUsage(factory)) 154public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 176protected override string GetName(NodeFactory factory) => $"Dictionary layout for {_owningMethodOrType}"; 183public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\DispatchCellNode.cs (5)

77protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 81public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 108public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 109public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\DispatchCellSectionNode.cs (3)

19public override ObjectData GetData(NodeFactory factory, bool relocsOnly) 41public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.BssSection; 42protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\DynamicDependencyAttributesOnEntityNode.cs (9)

27public class DynamicDependencyAttributesOnEntityNode : DependencyNodeCore<NodeFactory> 37public static void AddDependenciesDueToDynamicDependencyAttribute(IDependencySink dependencies, NodeFactory factory, EcmaMethod method) 45public static void AddDependenciesDueToDynamicDependencyAttribute(IDependencySink dependencies, NodeFactory factory, EcmaField field) 53public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 77NodeFactory factory, 236protected override string GetName(NodeFactory factory) 245public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 246public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { }

Compiler\DependencyAnalysis\EETypeNode.cs (30)

Compiler\DependencyAnalysis\EmbeddedObjectNode.cs (4)

62public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 63public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { } 65public abstract void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly);

Compiler\DependencyAnalysis\EmbeddedPointerIndirectionNode.cs (2)

32public override void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 47public abstract override void AddStaticDependencies(DependencySink sink, NodeFactory factory);

Compiler\DependencyAnalysis\EmbeddedTrimmingDescriptorNode.cs (6)

19public class EmbeddedTrimmingDescriptorNode : DependencyNodeCore<NodeFactory> 28public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 64protected override string GetName(NodeFactory factory) 73public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 74public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { }

Compiler\DependencyAnalysis\EventMetadataNode.cs (6)

19internal sealed class EventMetadataNode : DependencyNodeCore<NodeFactory> 30public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) { } 32public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 37protected override string GetName(NodeFactory factory) 46public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\ExactMethodInstantiationsEntryNode.cs (6)

14public class ExactMethodInstantiationsEntryNode : DependencyNodeCore<NodeFactory> 28public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 32protected override string GetName(NodeFactory factory) 41public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 42public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\ExactMethodInstantiationsNode.cs (4)

34public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 36protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 38public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 104public static void GetExactMethodInstantiationDependenciesForMethod(DependencySink dependencies, NodeFactory factory, MethodDesc method)

Compiler\DependencyAnalysis\ExternalReferencesTableNode.cs (5)

19private readonly NodeFactory _nodeFactory; 24public ExternalReferencesTableNode(string blobName, NodeFactory nodeFactory) 65public override ObjectNodeSection GetSection(NodeFactory factory) 75protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 77public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ExternalTypeMapNode.cs (9)

34public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) 55public override void AddStaticDependencies(DependencySink sink, NodeFactory context) 70public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 71protected override string GetName(NodeFactory context) => $"External type map: {TypeMapGroup}"; 81private IEnumerable<(string Name, IEETypeNode target)> GetMarkedEntries(NodeFactory factory) 98private static IEETypeNode GetEffectiveTrimTargetType(NodeFactory factory, TypeDesc trimmingTargetType) 101public Vertex CreateTypeMap(NodeFactory factory, NativeWriter writer, Section section, INativeFormatTypeReferenceProvider externalReferences) 119public IExternalTypeMapNode ToAnalysisBasedNode(NodeFactory factory)

Compiler\DependencyAnalysis\ExternalTypeMapRequestNode.cs (6)

12public sealed class ExternalTypeMapRequestNode(TypeDesc typeMapGroup) : DependencyNodeCore<NodeFactory> 23public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 24public override void AddStaticDependencies(DependencySink sink, NodeFactory context) { } 25public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 26protected override string GetName(NodeFactory context) => $"External type map request: {TypeMapGroup}";

Compiler\DependencyAnalysis\ExternEETypeSymbolNode.cs (1)

17public ExternEETypeSymbolNode(NodeFactory factory, TypeDesc type)

Compiler\DependencyAnalysis\ExternMethodSymbolNode.cs (1)

18public ExternMethodSymbolNode(NodeFactory factory, MethodDesc method, bool isUnboxing = false)

Compiler\DependencyAnalysis\ExternSymbolsImportedNodeProvider.cs (5)

13public override IEETypeNode ImportedEETypeNode(NodeFactory factory, TypeDesc type) 18public override ISortableSymbolNode ImportedGCStaticNode(NodeFactory factory, MetadataType type) 23public override ISortableSymbolNode ImportedNonGCStaticNode(NodeFactory factory, MetadataType type) 28public override ISortableSymbolNode ImportedMethodDictionaryNode(NodeFactory factory, MethodDesc method) 33public override IMethodNode ImportedMethodCodeNode(NodeFactory factory, MethodDesc method, bool unboxingStub)

Compiler\DependencyAnalysis\FatFunctionPointerNode.cs (3)

46protected override ObjectNodeSection GetDehydratedSection(NodeFactory factory) 56protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 58protected override ObjectData GetDehydratableData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\FieldMetadataNode.cs (7)

26internal sealed class FieldMetadataNode : DependencyNodeCore<NodeFactory> 38public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 61public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 66protected override string GetName(NodeFactory factory) 71protected override void OnMarked(NodeFactory factory) 81public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\FieldRvaDataNode.cs (4)

26public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 37public int GetAlignment(NodeFactory factory) 43public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 53protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\FrozenObjectNode.cs (3)

38public sealed override void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 47public sealed override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 62public abstract void EncodeContents(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly);

Compiler\DependencyAnalysis\FrozenRuntimeTypeNode.cs (2)

31public override void EncodeContents(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 42protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\FrozenStringNode.cs (2)

27public override void EncodeContents(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 42protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\FunctionPointerMapNode.cs (4)

32public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 36protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 38public static void AddHashtableDependencies(DependencySink dependencies, NodeFactory factory, FunctionPointerType type) 45public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\GCStaticsNode.cs (7)

33protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 48private ISymbolNode GetGCStaticEETypeNode(NodeFactory factory) 55protected override void ComputeNonRelocationBasedDependencies(DependencySink sink, NodeFactory factory) 70public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 82public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.DataSection; 87public int GetAlignment(NodeFactory factory) => factory.Target.PointerSize; 89public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\GCStaticsPreInitDataNode.cs (3)

27protected override string GetName(NodeFactory factory) => GetMangledName(_preinitializationInfo.Type, factory.NameMangler); 44public override ObjectNodeSection GetSection(NodeFactory factory) 53public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\GenericCompositionNode.cs (4)

23public override bool ShouldSkipEmittingObjectNode(NodeFactory factory) => !_metadataEnabled && factory.MetadataEnabledGenericComposition(_details).Marked; 44public override ObjectNodeSection GetSection(NodeFactory factory) 56public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 80protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\GenericDefinitionEETypeNode.cs (12)

Compiler\DependencyAnalysis\GenericDictionaryNode.cs (17)

Compiler\DependencyAnalysis\GenericLookupResult.cs (38)

Compiler\DependencyAnalysis\GenericMethodsHashtableEntryNode.cs (6)

12public class GenericMethodsHashtableEntryNode : DependencyNodeCore<NodeFactory> 23public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 27protected override string GetName(NodeFactory factory) 36public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 37public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\GenericMethodsHashtableNode.cs (4)

34public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 36protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 38public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 97public static void GetGenericMethodsHashtableDependenciesForMethod(DependencySink dependencies, NodeFactory factory, MethodDesc method)

Compiler\DependencyAnalysis\GenericMethodsTemplateMap.cs (4)

33public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 35protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 37public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 76public static void AddTemplateMethodDependencies(IDependencySink dependencies, NodeFactory factory, MethodDesc method)

Compiler\DependencyAnalysis\GenericStaticBaseInfoNode.cs (6)

16internal sealed class GenericStaticBaseInfoNode : DependencyNodeCore<NodeFactory> 27public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 32protected override string GetName(NodeFactory factory) 41public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 42public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\GenericTypesHashtableNode.cs (3)

31public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 33protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 35public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\GenericTypesTemplateMap.cs (5)

33public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 35protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 37public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 72public static void AddTemplateTypeDependencies(IDependencySink dependencies, NodeFactory factory, TypeDesc type) 87public static TypeDesc ConvertArrayOfTToRegularArray(NodeFactory factory, TypeDesc type)

Compiler\DependencyAnalysis\GenericVarianceNode.cs (3)

39public override ObjectNodeSection GetSection(NodeFactory factory) 51public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 62protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\GenericVirtualMethodImplNode.cs (6)

16public class GenericVirtualMethodImplNode : DependencyNodeCore<NodeFactory> 35protected override string GetName(NodeFactory factory) => "__GVMImplNode_" + factory.NameMangler.GetMangledMethodName(_method); 37public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 67public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 71public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\GenericVirtualMethodTableNode.cs (4)

36public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 38protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 47public static void AddGenericVirtualMethodImplementationDependencies(DependencySink dependencies, NodeFactory factory, MethodDesc callingMethod, MethodDesc implementationMethod) 76public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\GvmDispatchCellInfoSectionNode.cs (6)

13using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 14using DependencyListEntry = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyListEntry; 31public override ObjectData GetData(NodeFactory factory, bool relocsOnly) 87public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 88protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 100public static void AddCellDependencies(DependencySink dependencies, NodeFactory factory, MethodDesc targetMethod)

Compiler\DependencyAnalysis\ImportedNodeProvider.cs (10)

Compiler\DependencyAnalysis\InlineableStringsResourceNode.cs (7)

18internal sealed class InlineableStringsResourceNode : DependencyNodeCore<NodeFactory> 61public static void AddDependenciesDueToResourceStringUse(IDependencySink dependencies, NodeFactory factory, MethodDesc method) 70public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 71public override void AddStaticDependencies(DependencySink sink, NodeFactory context) { } 72public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 73protected override string GetName(NodeFactory context)

Compiler\DependencyAnalysis\INodeWithCodeInfo.Aot.cs (1)

28ISymbolNode GetAssociatedDataNode(NodeFactory factory);

Compiler\DependencyAnalysis\InterfaceDispatchCellInfoSectionNode.cs (7)

13using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 14using DependencyListEntry = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyListEntry; 31public override ObjectData GetData(NodeFactory factory, bool relocsOnly) 80public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 81protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 93public static void AddCellDependencies(DependencySink dependencies, NodeFactory factory, MethodDesc targetMethod) 105private static IEETypeNode GetInterfaceTypeNode(NodeFactory factory, MethodDesc targetMethod)

Compiler\DependencyAnalysis\InterfaceDispatchMapNode.cs (7)

19public InterfaceDispatchMapNode(NodeFactory factory, TypeDesc type) 31protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 43public override ObjectNodeSection GetSection(NodeFactory factory) 51protected override void ComputeNonRelocationBasedDependencies(DependencySink sink, NodeFactory factory) 66public static bool MightHaveInterfaceDispatchMap(TypeDesc type, NodeFactory factory) 131private void EmitDispatchMap(ref ObjectDataBuilder builder, NodeFactory factory) 331public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\InterfaceGenericVirtualMethodTableNode.cs (4)

38public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 40protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 49public static void AddGenericVirtualMethodImplementationDependencies(DependencySink dependencies, NodeFactory factory, MethodDesc callingMethod, TypeDesc implementationType, MethodDesc implementationMethod) 121public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\InterfaceUseNode.cs (6)

19internal sealed class InterfaceUseNode : DependencyNodeCore<NodeFactory> 30protected override string GetName(NodeFactory factory) => $"Interface use: {Type}"; 32public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) { } 37public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 38public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { }

Compiler\DependencyAnalysis\InvalidExternalTypeMapNode.cs (7)

23public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 24public override void AddStaticDependencies(DependencySink sink, NodeFactory context) 29public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 30protected override string GetName(NodeFactory context) => $"Invalid external type map: {TypeMapGroup}"; 39public Vertex CreateTypeMap(NodeFactory factory, NativeWriter writer, Section section, INativeFormatTypeReferenceProvider externalReferences) 48public IExternalTypeMapNode ToAnalysisBasedNode(NodeFactory factory) => new InvalidExternalTypeMapNode(TypeMapGroup, ThrowingMethodStub);

Compiler\DependencyAnalysis\InvalidProxyTypeMapNode.cs (7)

26public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 27public override void AddStaticDependencies(DependencySink sink, NodeFactory context) 32public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 33protected override string GetName(NodeFactory context) => $"Invalid proxy type map: {TypeMapGroup}"; 38public Vertex CreateTypeMap(NodeFactory factory, NativeWriter writer, Section section, INativeFormatTypeReferenceProvider externalReferences) 47public IProxyTypeMapNode ToAnalysisBasedNode(NodeFactory factory) => new InvalidProxyTypeMapNode(TypeMapGroup, ThrowingMethodStub);

Compiler\DependencyAnalysis\ISpecialUnboxThunkNode.cs (1)

12ISymbolNode GetUnboxingThunkTarget(NodeFactory factory);

Compiler\DependencyAnalysis\JumpStubNode.cs (1)

30protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\ManagedDataDescriptorNode.cs (4)

31public override ObjectNodeSection GetSection(NodeFactory factory) => 44protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 46public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 95private static byte[] BuildJsonDescriptor(NodeFactory factory)

Compiler\DependencyAnalysis\MetadataEETypeNode.cs (8)

Compiler\DependencyAnalysis\MetadataNode.cs (3)

23public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 27protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 29public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\MethodAssociatedDataNode.cs (3)

35protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 37public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 68public override ObjectData GetData(NodeFactory factory, bool relocsOnly)

Compiler\DependencyAnalysis\MethodExceptionHandlingInfoNode.cs (3)

25public override ObjectNodeSection GetSection(NodeFactory factory) => _owningMethod.Context.Target.IsWindows 38public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 43protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\MethodMetadataNode.cs (7)

29internal sealed class MethodMetadataNode : DependencyNodeCore<NodeFactory> 43public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 124public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 129protected override string GetName(NodeFactory factory) 134protected override void OnMarked(NodeFactory factory) 144public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\MethodParameterMetadataNode.cs (6)

16internal sealed class MethodParameterMetadataNode : DependencyNodeCore<NodeFactory> 27public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) { } 29protected override string GetName(NodeFactory factory) 38public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 39public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\ModuleInitializerListNode.cs (3)

26public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.DataSection; 30protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 32public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ModuleMetadataNode.cs (6)

21internal sealed class ModuleMetadataNode : DependencyNodeCore<NodeFactory> 33public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 53public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 58protected override string GetName(NodeFactory factory) 67public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\ModulesSectionNode.cs (3)

17public override ObjectNodeSection GetSection(NodeFactory factory) 24protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 35public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ModuleUseBasedDependencyAlgorithm.cs (2)

6using IDependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.IDependencySink; 12internal static void AddDependenciesDueToModuleUse(IDependencySink dependencyList, NodeFactory factory, ModuleDesc module)

Compiler\DependencyAnalysis\NativeLayoutInfoNode.cs (4)

46public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 48protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 61public void SaveNativeLayoutInfoWriter(NodeFactory factory) 76public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\NativeLayoutVertexNode.cs (118)

Compiler\DependencyAnalysis\NodeFactory.cs (20)

752protected readonly NodeFactory _factory; 753public TypeSymbolHashtable(NodeFactory factory) => _factory = factory; 762public NecessaryTypeSymbolHashtable(NodeFactory factory) : base(factory) { } 793public MetadataTypeSymbolHashtable(NodeFactory factory) : base(factory) { } 821public ConstructedTypeSymbolHashtable(NodeFactory factory) : base(factory) { } 1067private readonly NodeFactory _factory; 1068public VTableSliceHashtable(NodeFactory factory) => _factory = factory; 1126private readonly NodeFactory _factory; 1127public MethodEntrypointHashtable(NodeFactory factory) => _factory = factory; 1331private readonly NodeFactory _factory; 1332public ShadowConcreteMethodHashtable(NodeFactory factory) => _factory = factory; 1349private readonly NodeFactory _factory; 1350public ShadowNonConcreteMethodHashtable(NodeFactory factory) => _factory = factory; 1418private readonly NodeFactory _factory; 1419public VirtualMethodUseHashtable(NodeFactory factory) => _factory = factory; 1435public DependencyNodeCore<NodeFactory> VirtualMethodUse(MethodDesc decl) 1442public DependencyNodeCore<NodeFactory> VariantInterfaceMethodUse(MethodDesc decl) 1449public DependencyNodeCore<NodeFactory> InterfaceUse(TypeDesc type) 1717public virtual void AttachToDependencyGraph(DependencyAnalyzerBase<NodeFactory> graph) 1753private sealed class ExternalReferencesTableIndex(ExternalReferencesTableNode table, NodeFactory factory) : INativeFormatTypeReferenceProvider

Compiler\DependencyAnalysis\NodeFactory.NativeLayout.cs (2)

20private NodeFactory _factory; 22public NativeLayoutHelper(NodeFactory factory)

Compiler\DependencyAnalysis\NonGCStaticsNode.cs (6)

34protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 36protected override ObjectNodeSection GetDehydratedSection(NodeFactory factory) 147public int GetAlignment(NodeFactory factory) 159public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 171protected override void ComputeNonRelocationBasedDependencies(DependencySink sink, NodeFactory factory) 183protected override ObjectData GetDehydratableData(NodeFactory factory, bool relocsOnly)

Compiler\DependencyAnalysis\NotReadOnlyFieldNode.cs (6)

17public class NotReadOnlyFieldNode : DependencyNodeCore<NodeFactory> 30protected override string GetName(NodeFactory factory) 39public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) { } 40public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 41public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\ObjectGetTypeCalledNode.cs (6)

17internal sealed class ObjectGetTypeCalledNode : DependencyNodeCore<NodeFactory> 26protected override string GetName(NodeFactory factory) 31public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) { } 36public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 37public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\ObjectGetTypeFlowDependenciesNode.cs (6)

19internal sealed class ObjectGetTypeFlowDependenciesNode : DependencyNodeCore<NodeFactory> 28protected override string GetName(NodeFactory factory) 33public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 65public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 66public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\PInvokeMethodFixupNode.cs (3)

38protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 40public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.DataSection; 44public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\PInvokeModuleFixupNode.cs (3)

35protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 37public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.DataSection; 41public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\PointerTypeMapNode.cs (3)

Compiler\DependencyAnalysis\PropertyMetadataNode.cs (6)

19internal sealed class PropertyMetadataNode : DependencyNodeCore<NodeFactory> 30public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) { } 32public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 37protected override string GetName(NodeFactory factory) 46public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\ProxyTypeMapNode.cs (8)

41public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) 63public override void AddStaticDependencies(DependencySink sink, NodeFactory context) { } 64public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 65protected override string GetName(NodeFactory context) => $"Proxy type map: {TypeMapGroup}"; 67private IEnumerable<(IEETypeNode key, IEETypeNode value)> GetMarkedEntries(NodeFactory factory) 81public Vertex CreateTypeMap(NodeFactory factory, NativeWriter writer, Section section, INativeFormatTypeReferenceProvider externalReferences) 99public IProxyTypeMapNode ToAnalysisBasedNode(NodeFactory factory)

Compiler\DependencyAnalysis\ProxyTypeMapRequestNode.cs (6)

12public sealed class ProxyTypeMapRequestNode(TypeDesc typeMapGroup) : DependencyNodeCore<NodeFactory> 23public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 24public override void AddStaticDependencies(DependencySink sink, NodeFactory context) { } 25public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 26protected override string GetName(NodeFactory context) => $"Proxy type map request: {TypeMapGroup}";

Compiler\DependencyAnalysis\ReadyToRunGenericHelperNode.cs (15)

Compiler\DependencyAnalysis\ReadyToRunHeaderNode.cs (3)

42protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 46public override ObjectNodeSection GetSection(NodeFactory factory) 54public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRunHelperNode.cs (3)

87protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 121protected override void ComputeNonRelocationBasedDependencies(DependencySink sink, NodeFactory factory) 164public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory)

Compiler\DependencyAnalysis\ReflectedDelegateNode.cs (6)

17public class ReflectedDelegateNode : DependencyNodeCore<NodeFactory> 36protected override string GetName(NodeFactory factory) 41public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) { } 46public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 47public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\ReflectedFieldNode.cs (6)

20public class ReflectedFieldNode : DependencyNodeCore<NodeFactory> 33public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 102protected override string GetName(NodeFactory factory) 111public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 112public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\ReflectedMethodNode.cs (6)

21public class ReflectedMethodNode : DependencyNodeCore<NodeFactory> 33public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 48protected override string GetName(NodeFactory factory) 57public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 58public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\ReflectedTypeNode.cs (6)

22public class ReflectedTypeNode : DependencyNodeCore<NodeFactory> 35public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 44protected override string GetName(NodeFactory factory) 53public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 54public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\ReflectionFieldMapNode.cs (3)

34public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 38protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 40public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReflectionInvokeMapNode.cs (5)

35public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 39protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 41public static void AddDependenciesDueToReflectability(IDependencySink dependencies, NodeFactory factory, MethodDesc method) 83internal static void AddSignatureDependency(IDependencySink dependencies, NodeFactory factory, TypeSystemEntity referent, TypeDesc type, string reason, bool isOut) 121public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReflectionInvokeSupportDependencyAlgorithm.cs (3)

Compiler\DependencyAnalysis\ReflectionVirtualInvokeMapNode.cs (5)

37public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 39protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 41public static bool NeedsVirtualInvokeInfo(NodeFactory factory, MethodDesc method) 80public static void AddVirtualInvokeMapDependencies(IDependencySink dependencies, NodeFactory factory, MethodDesc method) 107public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ResourceDataNode.cs (5)

32public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 43protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 45public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 62public IReadOnlyList<ResourceIndexData> GetOrCreateIndexData(NodeFactory factory) 117private byte[] GenerateResourceBlob(NodeFactory factory)

Compiler\DependencyAnalysis\ResourceIndexNode.cs (4)

28public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 39protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 41public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 62private byte[] GenerateIndexBlob(NodeFactory factory)

Compiler\DependencyAnalysis\RuntimeFieldHandleNode.cs (4)

30protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 34protected override ObjectNodeSection GetDehydratedSection(NodeFactory factory) 42protected override void ComputeNonRelocationBasedDependencies(DependencySink sink, NodeFactory factory) 47protected override ObjectData GetDehydratableData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\RuntimeMethodHandleNode.cs (4)

38protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 42protected override ObjectNodeSection GetDehydratedSection(NodeFactory factory) 50protected override void ComputeNonRelocationBasedDependencies(DependencySink sink, NodeFactory factory) 67protected override ObjectData GetDehydratableData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ScannedMethodNode.cs (13)

Compiler\DependencyAnalysis\SealedVTableNode.cs (6)

32protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 34public override ObjectNodeSection GetSection(NodeFactory factory) => _type.Context.Target.IsWindows ? ObjectNodeSection.FoldableReadOnlyDataSection : ObjectNodeSection.DataSection; 61public override bool ShouldSkipEmittingObjectNode(NodeFactory factory) 99public bool BuildSealedVTableSlots(NodeFactory factory, bool relocsOnly) 248protected override void ComputeNonRelocationBasedDependencies(DependencySink sink, NodeFactory factory) 268public override ObjectData GetData(NodeFactory factory, bool relocsOnly)

Compiler\DependencyAnalysis\SerializedFrozenObjectNode.cs (4)

10using CombinedDependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.CombinedDependencyList; 53public override void EncodeContents(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 59protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 63public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory)

Compiler\DependencyAnalysis\StackTraceDocumentsNode.cs (3)

28public override ObjectNodeSection GetSection(NodeFactory factory) 49protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 51public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\StackTraceLineNumbersNode.cs (3)

Compiler\DependencyAnalysis\StackTraceMethodMappingNode.cs (3)

23public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 37protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 39public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\StaticsInfoHashtableNode.cs (4)

35public override ObjectNodeSection GetSection(NodeFactory factory) => _externalReferences.GetSection(factory); 37protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 44public static void AddStaticsInfoDependencies(DependencySink dependencies, NodeFactory factory, MetadataType metadataType) 68public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\StringAllocatorMethodNode.cs (6)

22internal sealed class StringAllocatorMethodNode : DependencyNodeCore<NodeFactory>, IMethodNode 49public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 65public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 66public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 68protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\StructMarshallingDataNode.cs (6)

16public class StructMarshallingDataNode : DependencyNodeCore<NodeFactory> 27public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 43protected override string GetName(NodeFactory context) 52public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 53public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { }

Compiler\DependencyAnalysis\StructMarshallingStubMapNode.cs (3)

Compiler\DependencyAnalysis\Target_ARM\ARMJumpStubNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref ARMEmitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_ARM\ARMReadyToRunGenericHelperNode.cs (4)

24protected void EmitDictionaryLookup(NodeFactory factory, ref ARMEmitter encoder, Register context, Register result, GenericLookupResult lookup, bool relocsOnly) 56protected sealed override void EmitCode(NodeFactory factory, ref ARMEmitter encoder, bool relocsOnly) 212protected virtual void EmitLoadGenericContext(NodeFactory factory, ref ARMEmitter encoder, bool relocsOnly) 220protected override void EmitLoadGenericContext(NodeFactory factory, ref ARMEmitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_ARM\ARMReadyToRunHelperNode.cs (1)

20protected override void EmitCode(NodeFactory factory, ref ARMEmitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_ARM\ARMTentativeMethodNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref ARMEmitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_ARM\ARMUnboxingStubNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref ARMEmitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_ARM64\ARM64JumpStubNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref ARM64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_ARM64\ARM64ReadyToRunGenericHelperNode.cs (4)

24protected void EmitDictionaryLookup(NodeFactory factory, ref ARM64Emitter encoder, Register context, Register result, GenericLookupResult lookup, bool relocsOnly) 55protected sealed override void EmitCode(NodeFactory factory, ref ARM64Emitter encoder, bool relocsOnly) 211protected virtual void EmitLoadGenericContext(NodeFactory factory, ref ARM64Emitter encoder, bool relocsOnly) 219protected override void EmitLoadGenericContext(NodeFactory factory, ref ARM64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_ARM64\ARM64ReadyToRunHelperNode.cs (1)

20protected override void EmitCode(NodeFactory factory, ref ARM64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_ARM64\ARM64TentativeMethodNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref ARM64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_ARM64\ARM64UnboxingStubNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref ARM64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64JumpStubNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref LoongArch64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64ReadyToRunGenericHelperNode.cs (4)

24protected void EmitDictionaryLookup(NodeFactory factory, ref LoongArch64Emitter encoder, Register context, Register result, GenericLookupResult lookup, bool relocsOnly) 55protected sealed override void EmitCode(NodeFactory factory, ref LoongArch64Emitter encoder, bool relocsOnly) 213protected virtual void EmitLoadGenericContext(NodeFactory factory, ref LoongArch64Emitter encoder, bool relocsOnly) 221protected override void EmitLoadGenericContext(NodeFactory factory, ref LoongArch64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64ReadyToRunHelperNode.cs (1)

20protected override void EmitCode(NodeFactory factory, ref LoongArch64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64TentativeMethodNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref LoongArch64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64UnboxingStubNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref LoongArch64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_RiscV64\RiscV64JumpStubNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref RiscV64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_RiscV64\RiscV64ReadyToRunGenericHelperNode.cs (4)

24protected void EmitDictionaryLookup(NodeFactory factory, ref RiscV64Emitter encoder, Register context, Register result, GenericLookupResult lookup, bool relocsOnly) 54protected sealed override void EmitCode(NodeFactory factory, ref RiscV64Emitter encoder, bool relocsOnly) 210protected virtual void EmitLoadGenericContext(NodeFactory factory, ref RiscV64Emitter encoder, bool relocsOnly) 218protected override void EmitLoadGenericContext(NodeFactory factory, ref RiscV64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_RiscV64\RiscV64ReadyToRunHelperNode.cs (1)

20protected override void EmitCode(NodeFactory factory, ref RiscV64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_RiscV64\RiscV64TentativeMethodNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref RiscV64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_RiscV64\RiscV64UnboxingStubNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref RiscV64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_Wasm\WasmJumpStubNode.cs (1)

12protected override void EmitCode(NodeFactory factory, ref WasmEmitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_Wasm\WasmReadyToRunGenericHelperNode.cs (4)

38NodeFactory factory, 69protected sealed override void EmitCode(NodeFactory factory, ref WasmEmitter encoder, bool relocsOnly) 195NodeFactory factory, 206NodeFactory factory,

Compiler\DependencyAnalysis\Target_Wasm\WasmReadyToRunHelperNode.cs (1)

47protected override void EmitCode(NodeFactory factory, ref WasmEmitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_Wasm\WasmTentativeMethodNode.cs (1)

13protected override void EmitCode(NodeFactory factory, ref WasmEmitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_Wasm\WasmUnboxingStubNode.cs (1)

12protected override void EmitCode(NodeFactory factory, ref WasmEmitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_X64\X64JumpStubNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref X64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_X64\X64ReadyToRunGenericHelperNode.cs (4)

24protected void EmitDictionaryLookup(NodeFactory factory, ref X64Emitter encoder, Register context, Register result, GenericLookupResult lookup, bool relocsOnly) 57protected sealed override void EmitCode(NodeFactory factory, ref X64Emitter encoder, bool relocsOnly) 220protected virtual void EmitLoadGenericContext(NodeFactory factory, ref X64Emitter encoder, bool relocsOnly) 228protected override void EmitLoadGenericContext(NodeFactory factory, ref X64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_X64\X64ReadyToRunHelperNode.cs (1)

20protected override void EmitCode(NodeFactory factory, ref X64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_X64\X64TentativeMethodNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref X64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_X64\X64UnboxingStubNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref X64Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_X86\X86JumpStubNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref X86Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_X86\X86ReadyToRunGenericHelperNode.cs (4)

16protected void EmitDictionaryLookup(NodeFactory factory, ref X86Emitter encoder, Register context, Register result, GenericLookupResult lookup, bool relocsOnly) 50protected sealed override void EmitCode(NodeFactory factory, ref X86Emitter encoder, bool relocsOnly) 214protected virtual void EmitLoadGenericContext(NodeFactory factory, ref X86Emitter encoder, bool relocsOnly) 227protected override void EmitLoadGenericContext(NodeFactory factory, ref X86Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_X86\X86ReadyToRunHelperNode.cs (1)

20protected override void EmitCode(NodeFactory factory, ref X86Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_X86\X86TentativeMethodNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref X86Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\Target_X86\X86UnboxingStubNode.cs (1)

10protected override void EmitCode(NodeFactory factory, ref X86Emitter encoder, bool relocsOnly)

Compiler\DependencyAnalysis\TentativeInstanceMethodNode.cs (3)

34protected override ISymbolNode GetTarget(NodeFactory factory) 41public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 59protected override string GetName(NodeFactory factory)

Compiler\DependencyAnalysis\TentativeMethodNode.cs (7)

32protected virtual ISymbolNode GetTarget(NodeFactory factory) 41protected override string GetName(NodeFactory factory) 46public override bool ShouldSkipEmittingObjectNode(NodeFactory factory) 52public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 53public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 71public ISymbolNode NodeForLinkage(NodeFactory factory)

Compiler\DependencyAnalysis\ThreadStaticsNode.cs (8)

22public ThreadStaticsNode(MetadataType type, NodeFactory factory) 29public ThreadStaticsNode(InlinedThreadStatics inlined, NodeFactory factory) 34protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 36protected override void OnMarked(NodeFactory factory) 56private ISymbolNode GetGCStaticEETypeNode(NodeFactory factory) 70public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 105public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 119public override void EncodeData(ref ObjectDataBuilder builder, NodeFactory factory, bool relocsOnly)

Compiler\DependencyAnalysis\TlsRootNode.cs (3)

17protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 19public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.TLSSection; 23public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\TrimmingDescriptorNode.cs (6)

11public class TrimmingDescriptorNode : DependencyNodeCore<NodeFactory> 25public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 41protected override string GetName(NodeFactory factory) 50public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 51public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { }

Compiler\DependencyAnalysis\TypeGVMEntriesNode.cs (6)

16internal sealed class TypeGVMEntriesNode : DependencyNodeCore<NodeFactory> 57protected override string GetName(NodeFactory factory) => "__TypeGVMEntriesNode_" + factory.NameMangler.GetMangledTypeName(_associatedType); 58public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 59public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 61public override void AddStaticDependencies(DependencySink sink, NodeFactory context)

Compiler\DependencyAnalysis\TypeManagerIndirectionNode.cs (3)

17protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 19public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.DataSection; 23public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\TypeMetadataMapNode.cs (3)

Compiler\DependencyAnalysis\TypeMetadataNode.cs (8)

24internal sealed class TypeMetadataNode : DependencyNodeCore<NodeFactory> 36public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 107public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 116public static void AddMetadataDependencies(IDependencySink dependencies, NodeFactory nodeFactory, TypeDesc type, string reason) 177protected override string GetName(NodeFactory factory) 182protected override void OnMarked(NodeFactory factory) 192public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\TypeThreadStaticIndexNode.cs (4)

33protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 35protected override ObjectNodeSection GetDehydratedSection(NodeFactory factory) 46protected override void ComputeNonRelocationBasedDependencies(DependencySink sink, NodeFactory factory) 53protected override ObjectData GetDehydratableData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\UnboxingStubNode.cs (3)

18public override ObjectNodeSection GetSection(NodeFactory factory) 38private ISymbolNode GetUnderlyingMethodEntrypoint(NodeFactory factory) 54protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\VariantInterfaceMethodUseNode.cs (8)

22internal sealed class VariantInterfaceMethodUseNode : DependencyNodeCore<NodeFactory> 46public static bool IsVariantInterfaceImplementation(NodeFactory factory, TypeDesc providingType, DefType implementedInterface) 95public static bool IsVariantMethodCall(NodeFactory factory, MethodDesc calledMethod) 143protected override string GetName(NodeFactory factory) => $"VariantInterfaceMethodUse {_decl}"; 150public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) { } 151public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 152public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

Compiler\DependencyAnalysis\VTableSliceNode.cs (7)

18public abstract class VTableSliceNode : DependencyNodeCore<NodeFactory> 76protected override string GetName(NodeFactory factory) => $"__vtable_{factory.NameMangler.GetMangledTypeName(_type)}"; 80public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 94public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 95public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { } 220public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory)

Compiler\DescriptorMarker.cs (5)

17using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 32private NodeFactory _factory; 37public DescriptorMarker(Logger logger, NodeFactory factory, Stream documentStream, string xmlDocumentLocation, IReadOnlyDictionary<string, bool> featureSwitchValues) 44public DescriptorMarker(Logger logger, NodeFactory factory, Stream documentStream, ManifestResource resource, ModuleDesc resourceAssembly, string xmlDocumentLocation, IReadOnlyDictionary<string, bool> featureSwitchValues) 338public static DependencyList GetDependencies(Logger logger, NodeFactory factory, Stream documentStream, ManifestResource resource, ModuleDesc resourceAssembly, string xmlDocumentLocation, IReadOnlyDictionary<string, bool> featureSwitchValues)

Compiler\EmptyInteropStubManager.cs (6)

7using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 8using DependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencySink; 9using IDependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.IDependencySink; 39public override void AddDependenciesDueToMethodCodePresence(IDependencySink dependencies, NodeFactory factory, MethodDesc method) 43public override void AddInterestingInteropConstructedTypeDependencies(DependencySink dependencies, NodeFactory factory, TypeDesc type) 47public override void AddMarshalAPIsGenericDependencies(IDependencySink dependencies, NodeFactory factory, MethodDesc method)

Compiler\ILScanner.cs (21)

33DependencyAnalyzerBase<NodeFactory> dependencyGraph, 53protected override void ComputeDependencyNodeDependencies(List<DependencyNodeCore<NodeFactory>> obj) 59foreach (DependencyNodeCore<NodeFactory> dependency in obj) 221internal ILScanResults(DependencyAnalyzerBase<NodeFactory> graph, NodeFactory factory) 280foreach (DependencyNodeCore<NodeFactory> n in MarkedNodes) 291public ScannedVTableProvider(ImmutableArray<DependencyNodeCore<NodeFactory>> markedNodes) 335public ScannedDictionaryLayoutProvider(NodeFactory factory, ImmutableArray<DependencyNodeCore<NodeFactory>> markedNodes) 357private static GenericLookupResult[] OptimizeSlots(NodeFactory factory, IEnumerable<GenericLookupResult> slots, out GenericLookupResult[] discarded) 461public ScannedDevirtualizationManager(NodeFactory factory, ImmutableArray<DependencyNodeCore<NodeFactory>> markedNodes) 594static List<MethodDesc> BuildVTable(NodeFactory factory, TypeDesc currentType, TypeDesc implType, List<MethodDesc> vtable) 638private static bool CanAssumeWholeProgramViewOnTypeUse(NodeFactory factory, TypeDesc implementingType, DefType baseType) 814public ScannedInliningPolicy(CompilationModuleGroup baseGroup, ImmutableArray<DependencyNodeCore<NodeFactory>> markedNodes) 856public ScannedMethodImportationErrorProvider(ImmutableArray<DependencyNodeCore<NodeFactory>> markedNodes) 883public ScannedInlinedThreadStatics(NodeFactory factory, ImmutableArray<DependencyNodeCore<NodeFactory>> markedNodes) 940public ScannedPreinitializationPolicy(PreinitializationManager preinitManager, ImmutableArray<DependencyNodeCore<NodeFactory>> markedNodes) 991public ScannedReadOnlyPolicy(ImmutableArray<DependencyNodeCore<NodeFactory>> markedNodes) 1022public ScannedTypeMapManager(NodeFactory factory)

Compiler\ILScannerBuilder.cs (1)

86DependencyAnalyzerBase<NodeFactory> graph = _dependencyTrackingLevel.CreateDependencyGraph(nodeFactory);

Compiler\InteropStubManager.cs (6)

10using DependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencySink; 11using IDependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.IDependencySink; 28public abstract void AddDependenciesDueToMethodCodePresence(IDependencySink dependencies, NodeFactory factory, MethodDesc method); 30public abstract void AddInterestingInteropConstructedTypeDependencies(DependencySink dependencies, NodeFactory factory, TypeDesc type); 38public abstract void AddMarshalAPIsGenericDependencies(IDependencySink dependencies, NodeFactory factory, MethodDesc method); 40public virtual void AddToReadyToRunHeader(ReadyToRunHeaderNode header, NodeFactory nodeFactory, ExternalReferencesTableNode commonFixupsTableNode)

Compiler\MetadataManager.cs (46)

Compiler\MethodBodyDeduplicator.cs (4)

37public void DeduplicatePass(NodeFactory factory, Dictionary<ISymbolNode, ISymbolNode> previousSymbolRemapping, Dictionary<ISymbolNode, ISymbolNode> symbolRemapping) 74public MethodInternKey(IMethodBodyNode node, NodeFactory factory, Dictionary<ISymbolNode, ISymbolNode> interner) 129private readonly NodeFactory _factory; 133public MethodInternComparer(NodeFactory factory, Dictionary<ISymbolNode, ISymbolNode> interner, bool genericsOnly)

Compiler\MstatObjectDumper.cs (8)

58protected override void DumpObjectNode(NodeFactory factory, ObjectNode node, ObjectData objectData) 66_types.LoadConstantI4(AppendMangledName(DependencyNodeCore<NodeFactory>.GetNodeName(node, factory))); 72DependencyNodeCore<NodeFactory>.GetNodeName(node, factory), 83_fieldRvas.LoadConstantI4(AppendMangledName(DependencyNodeCore<NodeFactory>.GetNodeName(node, factory))); 110public override void ReportFoldedNode(NodeFactory factory, ObjectNode originalNode, ISymbolNode targetNode) 121private void DumpFrozenRegion(NodeFactory factory) 130_frozenObjects.LoadConstantI4(AppendMangledName(DependencyNodeCore<NodeFactory>.GetNodeName(frozenObject, factory))); 144private void DumpResourceData(NodeFactory factory, ResourceDataNode resourceData)

Compiler\ObjectDumper.cs (4)

16void IObjectDumper.DumpObjectNode(NodeFactory factory, ObjectNode node, ObjectData objectData) => DumpObjectNode(factory, node, objectData); 17protected abstract void DumpObjectNode(NodeFactory factory, ObjectNode node, ObjectData objectData); 19public virtual void ReportFoldedNode(NodeFactory factory, ObjectNode originalNode, ISymbolNode targetNode) { } 58protected override void DumpObjectNode(NodeFactory factory, ObjectNode node, ObjectData objectData)

Compiler\ObjectWriter\ObjectWriter.Aot.cs (1)

22public static void EmitObject(string objectFilePath, IReadOnlyCollection<DependencyNode> nodes, NodeFactory factory, ObjectWritingOptions options, IObjectDumper dumper, Logger logger)

Compiler\ReachabilityInstrumentationProvider.cs (16)

Compiler\RootingHelpers.cs (16)

Compiler\RootingServiceProvider.cs (3)

18private readonly NodeFactory _factory; 21public RootingServiceProvider(NodeFactory factory, RootAdder rootAdder) 82Debug.Assert(o is IDependencyNode<NodeFactory>);

Compiler\RuntimeConfigurationRootProvider.cs (3)

57public override ObjectNodeSection GetSection(NodeFactory factory) => 60protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 62public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\RuntimeConstructableTypeDependencies.cs (4)

10using DependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencySink; 16public static IEETypeNode GetEffectiveTrimTargetType(NodeFactory factory, TypeDesc trimmingTargetType, bool conditionConstructed) 60NodeFactory factory, 68dependencies.Add(new DependencyNodeCore<NodeFactory>.CombinedDependencyListEntry(

Compiler\SourceLinkWriter.cs (1)

37protected override void DumpObjectNode(NodeFactory factory, ObjectNode node, ObjectData objectData)

Compiler\TypePreinit.cs (45)

Compiler\UnmanagedEntryPointsRootProvider.cs (8)

45private sealed class UnmanagedEntryPointsNode : DependencyNodeCore<NodeFactory> 110public override void AddStaticDependencies(DependencySink sink, NodeFactory context) 128public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) 149public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 151private void AddMethodStaticDependencies(DependencySink sink, NodeFactory context, EcmaMethod method, string reason, Utf8String exportName) 158private IMethodNode GetMethodEntrypointAndAddAlias(NodeFactory context, EcmaMethod method, Utf8String exportName) 185protected override string GetName(NodeFactory context) => $"Unmanaged entry points: {_module}";

Compiler\UsageBasedInteropStubManager.cs (6)

Compiler\UsageBasedMetadataManager.cs (41)

Compiler\UsageBasedTypeMapManager.cs (8)

19private sealed class AllTypeMapsNode(TypeMapMetadata typeMapState) : DependencyNodeCore<NodeFactory> 29public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) 38public override void AddStaticDependencies(DependencySink sink, NodeFactory context) { } 39public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory context) { } 40protected override string GetName(NodeFactory context) => $"Type maps root node: {typeMapState.DiagnosticName}"; 71public override void AttachToDependencyGraph(DependencyAnalyzerBase<NodeFactory> graph) 78private void Graph_NewMarkedNode(DependencyNodeCore<NodeFactory> obj)

Compiler\UserDefinedTypeDescriptor.cs (3)

21private NodeFactory _nodeFactory; 23private NodeFactory NodeFactory => _nodeFactory; 29public UserDefinedTypeDescriptor(ITypesDebugInfoWriter objectWriter, NodeFactory nodeFactory)

Compiler\VirtualMethodCallHelper.cs (5)

13public static int GetDefaultInterfaceMethodSlot(NodeFactory factory, MethodDesc method, TypeDesc implType, DefType interfaceOnDefinition, bool countDictionarySlots = true) 35public static int GetVirtualMethodSlot(NodeFactory factory, MethodDesc method, TypeDesc implType, bool countDictionarySlots = true) 92private static int GetNumberOfSlotsInCurrentType(NodeFactory factory, TypeDesc implType, bool countDictionarySlots) 121private static int GetNumberOfBaseSlots(NodeFactory factory, TypeDesc owningType, bool countDictionarySlots) 156public static int GetGenericDictionarySlot(NodeFactory factory, TypeDesc type)

Compiler\Win32ResourcesRootProvider.cs (3)

60public override ObjectNodeSection GetSection(NodeFactory factory) => _section; 62protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 64public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) => _data;

Compiler\XmlObjectDumper.cs (1)

41protected override void DumpObjectNode(NodeFactory nodeFactory, ObjectNode node, ObjectData objectData)

IL\ILImporter.Scanner.cs (3)

14using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 15using CombinedDependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.CombinedDependencyList; 16using DependencyListEntry = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyListEntry;

parent\parent\Common\Compiler\CompilationBuilder.cs (3)

89protected DependencyAnalyzerBase<NodeFactory> CreateDependencyGraph(NodeFactory factory, IComparer<DependencyNodeCore<NodeFactory>> comparer = null)

parent\parent\Common\Compiler\DependencyAnalysis\AssemblyStubNode.cs (9)

parent\parent\Common\Compiler\DependencyAnalysis\ExternSymbolNode.cs (6)

30protected override string GetName(NodeFactory factory) => $"ExternSymbol {_name}{(_isIndirection ? " (indirected)" : "")}"; 47public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) { } 48public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 49public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { } 100protected override string GetName(NodeFactory factory) => $"ExternDataSymbolNode {ToString()}";

parent\parent\Common\Compiler\DependencyAnalysis\GVMDependenciesNode.cs (12)

26public class GVMDependenciesNode : DependencyNodeCore<NodeFactory> 43protected override string GetName(NodeFactory factory) => "__GVMDependenciesNode_" + factory.NameMangler.GetMangledMethodName(_method); 45public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 49DependencyNodeCore<NodeFactory> node = GetVirtualMethodImplNode(factory, _method); 62public override void AddConditionalDependencies(DependencySink sink, NodeFactory context) { } 79public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) 88DependencyNodeCore<NodeFactory> entry = markedNodes[i]; 173DependencyNodeCore<NodeFactory> node = GetVirtualMethodImplNode(factory, canonImpl); 244DependencyNodeCore<NodeFactory> node = GetVirtualMethodImplNode(factory, instantiatedTargetMethod); 271private static DependencyNodeCore<NodeFactory> GetVirtualMethodImplNode(NodeFactory factory, MethodDesc method)

parent\parent\Common\Compiler\DependencyAnalysis\IMethodBodyNode.cs (3)

7using DependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencySink; 20void AddRuntimeDeterminedStaticDependencies(DependencySink sink, NodeFactory factory, MethodDesc concreteMethod); 26void AddRuntimeDeterminedConditionalDependencies(DependencySink sink, NodeFactory factory, MethodDesc concreteMethod);

parent\parent\Common\Compiler\DependencyAnalysis\INodeWithRuntimeDeterminedDependencies.cs (3)

8using DependencySink = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencySink; 25NodeFactory factory, 29DependencyNodeCore<NodeFactory>? otherReasonNode);

parent\parent\Common\Compiler\DependencyAnalysis\IObjectDumper.cs (2)

10void DumpObjectNode(NodeFactory factory, ObjectNode node, ObjectData objectData); 11void ReportFoldedNode(NodeFactory factory, ObjectNode originalNode, ISymbolNode targetNode);

parent\parent\Common\Compiler\DependencyAnalysis\IObjectNodeWithAlignment.cs (1)

15int GetAlignment(NodeFactory factory);

parent\parent\Common\Compiler\DependencyAnalysis\ISymbolNode.cs (4)

14public interface ISymbolNode : IDependencyNode<NodeFactory> 43ISymbolNode NodeForLinkage(NodeFactory factory); 86ISymbolNode StartNode(NodeFactory factory); 91ISymbolNode EndNode(NodeFactory factory);

parent\parent\Common\Compiler\DependencyAnalysis\MethodReadOnlyDataNode.cs (4)

22public override bool ShouldSkipEmittingObjectNode(NodeFactory factory) 29public override ObjectNodeSection GetSection(NodeFactory factory) 47public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 52protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

parent\parent\Common\Compiler\DependencyAnalysis\MethodReadWriteDataNode.cs (4)

parent\parent\Common\Compiler\DependencyAnalysis\ObjectDataBuilder.cs (1)

20public ObjectDataBuilder(NodeFactory factory, bool relocsOnly) : this(factory.Target, relocsOnly)

parent\parent\Common\Compiler\DependencyAnalysis\ObjectNode.cs (8)

31public abstract ObjectData GetData(NodeFactory factory, bool relocsOnly = false); 33public abstract ObjectNodeSection GetSection(NodeFactory factory); 47public virtual bool ShouldSkipEmittingObjectNode(NodeFactory factory) 56public sealed override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 76protected virtual void ComputeNonRelocationBasedDependencies(DependencySink sink, NodeFactory factory) 80public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 81public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

parent\parent\Common\Compiler\DependencyAnalysis\ShadowMethodNode.cs (7)

22public abstract class ShadowMethodNode : DependencyNodeCore<NodeFactory>, IMethodNode, ISymbolNodeWithLinkage 54public ISymbolNode NodeForLinkage(NodeFactory factory) 59public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 67public sealed override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) 73protected override string GetName(NodeFactory factory) => $"{Method} backed by {CanonicalMethodNode.GetMangledName(factory.NameMangler)}"; 79public sealed override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

parent\parent\Common\Compiler\DependencyAnalysis\SortableDependencyNode.cs (4)

13public abstract partial class SortableDependencyNode : DependencyNodeCore<NodeFactory>, ISortableNode 139public class ObjectNodeComparer : IComparer<DependencyNodeCore<NodeFactory>> 148public int Compare(DependencyNodeCore<NodeFactory> x1, DependencyNodeCore<NodeFactory> y1)

parent\parent\Common\Compiler\DependencyAnalysis\Target_ARM\ARMEmitter.cs (1)

10public ARMEmitter(NodeFactory factory, bool relocsOnly)

parent\parent\Common\Compiler\DependencyAnalysis\Target_ARM64\ARM64Emitter.cs (1)

11public ARM64Emitter(NodeFactory factory, bool relocsOnly)

parent\parent\Common\Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64Emitter.cs (1)

11public LoongArch64Emitter(NodeFactory factory, bool relocsOnly)

parent\parent\Common\Compiler\DependencyAnalysis\Target_RiscV64\RiscV64Emitter.cs (1)

11public RiscV64Emitter(NodeFactory factory, bool relocsOnly)

parent\parent\Common\Compiler\DependencyAnalysis\Target_Wasm\WasmEmitter.cs (1)

11public struct WasmEmitter(NodeFactory factory, bool relocsOnly)

parent\parent\Common\Compiler\DependencyAnalysis\Target_X64\X64Emitter.cs (1)

11public X64Emitter(NodeFactory factory, bool relocsOnly)

parent\parent\Common\Compiler\DependencyAnalysis\Target_X86\X86Emitter.cs (1)

11public X86Emitter(NodeFactory factory, bool relocsOnly)

parent\parent\Common\Compiler\DependencyAnalysis\VirtualMethodUseNode.cs (7)

22public sealed class VirtualMethodUseNode : DependencyNodeCore<NodeFactory> 44protected override string GetName(NodeFactory factory) => $"VirtualMethodUse {_decl}"; 47protected override void OnMarked(NodeFactory factory) 63public override void AddStaticDependencies(DependencySink sink, NodeFactory factory) 82public override void AddConditionalDependencies(DependencySink sink, NodeFactory factory) { } 83public override void SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, DependencySink sink, NodeFactory factory) { }

parent\parent\Common\Compiler\DependencyAnalysis\WasmTypeNode.cs (3)

33public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.WasmTypeSection; 35protected override string GetName(NodeFactory factory) 38public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

parent\parent\Common\Compiler\DependencyAnalysis\WasmWellKnownGlobalSymbolNode.cs (1)

37protected override string GetName(NodeFactory factory) => $"WasmWellKnownGlobal {this.ToString()}";

parent\parent\Common\Compiler\DependencyTrackingLevel.cs (12)

35public static DependencyAnalyzerBase<NodeFactory> CreateDependencyGraph(this DependencyTrackingLevel trackingLevel, NodeFactory factory, IComparer<DependencyNodeCore<NodeFactory>> comparer = null) 41if (EventSourceLogStrategy<NodeFactory>.IsEventSourceEnabled) 42return new DependencyAnalyzer<EventSourceLogStrategy<NodeFactory>, NodeFactory>(factory, comparer); 44return new DependencyAnalyzer<NoLogStrategy<NodeFactory>, NodeFactory>(factory, comparer); 47return new DependencyAnalyzer<FirstMarkLogStrategy<NodeFactory>, NodeFactory>(factory, comparer); 50return new DependencyAnalyzer<FullGraphLogStrategy<NodeFactory>, NodeFactory>(factory, comparer);

parent\parent\Common\Compiler\ExternalTypeMapObjectNode.cs (3)

26public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 66public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 73protected override string GetName(NodeFactory context) => "External Type Map Hash Table";

parent\parent\Common\Compiler\IExternalTypeMapNode.cs (2)

17Vertex CreateTypeMap(NodeFactory factory, NativeWriter writer, Section section, INativeFormatTypeReferenceProvider externalReferences); 19IExternalTypeMapNode ToAnalysisBasedNode(NodeFactory factory);

parent\parent\Common\Compiler\IProxyTypeMapNode.cs (2)

17Vertex CreateTypeMap(NodeFactory factory, NativeWriter writer, Section section, INativeFormatTypeReferenceProvider externalReferences); 19IProxyTypeMapNode ToAnalysisBasedNode(NodeFactory factory);

parent\parent\Common\Compiler\MethodExtensions.cs (1)

108public static bool CanMethodBeInSealedVTable(this MethodDesc method, NodeFactory factory)

parent\parent\Common\Compiler\ObjectDataInterner.cs (3)

21void DeduplicatePass(NodeFactory factory, Dictionary<ISymbolNode, ISymbolNode> previousSymbolRemapping, Dictionary<ISymbolNode, ISymbolNode> symbolRemapping); 36private void EnsureMap(NodeFactory factory) 77public ISymbolNode GetDeduplicatedSymbol(NodeFactory factory, ISymbolNode original)

parent\parent\Common\Compiler\ObjectWriter\CoffObjectWriter.cs (1)

65public CoffObjectWriter(NodeFactory factory, ObjectWritingOptions options, OutputInfoBuilder outputInfoBuilder = null)

parent\parent\Common\Compiler\ObjectWriter\ElfObjectWriter.cs (1)

56public ElfObjectWriter(NodeFactory factory, ObjectWritingOptions options)

parent\parent\Common\Compiler\ObjectWriter\MachObjectWriter.cs (2)

76public MachObjectWriter(NodeFactory factory, ObjectWritingOptions options, OutputInfoBuilder outputInfoBuilder = null) 102public MachObjectWriter(NodeFactory factory, ObjectWritingOptions options, OutputInfoBuilder outputInfoBuilder, string baseSymbolName)

parent\parent\Common\Compiler\ObjectWriter\ObjectWriter.cs (2)

32private protected readonly NodeFactory _nodeFactory; 51private protected ObjectWriter(NodeFactory factory, ObjectWritingOptions options, OutputInfoBuilder outputInfoBuilder = null)

parent\parent\Common\Compiler\ObjectWriter\PEObjectWriter.cs (1)

85public PEObjectWriter(NodeFactory factory, ObjectWritingOptions options, OutputInfoBuilder outputInfoBuilder, string outputPath, int sectionAlignment, int? coffTimestamp)

parent\parent\Common\Compiler\ObjectWriter\UnixObjectWriter.cs (1)

29protected UnixObjectWriter(NodeFactory factory, ObjectWritingOptions options, OutputInfoBuilder outputInfoBuilder = null)

parent\parent\Common\Compiler\ObjectWriter\WasmFunctionBodyDeduplicator.cs (2)

22NodeFactory factory, 157NodeFactory factory,

parent\parent\Common\Compiler\ObjectWriter\WasmObjectWriter.cs (1)

119protected WasmObjectWriter(NodeFactory factory, ObjectWritingOptions options, OutputInfoBuilder outputInfoBuilder)

parent\parent\Common\Compiler\ObjectWriter\WasmRelocatableObjectWriter.cs (1)

66public WasmRelocatableObjectWriter(NodeFactory factory, ObjectWritingOptions options, OutputInfoBuilder outputInfoBuilder = null) : base(factory, options, outputInfoBuilder)

parent\parent\Common\Compiler\ProxyTypeMapObjectNode.cs (3)

27public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 68public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 75protected override string GetName(NodeFactory context) => "Proxy Type Map Hash Table";

parent\parent\Common\Compiler\TypeMapManager.cs (2)

28public virtual void AttachToDependencyGraph(DependencyAnalyzerBase<NodeFactory> graph) 40public virtual void AddToReadyToRunHeader(ReadyToRunHeaderNode header, NodeFactory nodeFactory, INativeFormatTypeReferenceProvider commonFixupsTableNode)