NodeFactory

CodeGen\ReadyToRunObjectWriter.cs (3)

32private readonly NodeFactory _nodeFactory; 125NodeFactory factory, 313NodeFactory factory,

Compiler\DependencyAnalysis\AllMethodsOnTypeNode.cs (6)

12public class AllMethodsOnTypeNode : DependencyNodeCore<NodeFactory> 31public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory context) => null; 32public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => null; 34public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context) 57protected override string GetName(NodeFactory factory) => $"All methods on type {Type.ToString()}";

Compiler\DependencyAnalysis\ArrayOfEmbeddedDataNode.cs (6)

41protected override string GetName(NodeFactory factory) => $"Region {this.GetMangledName(factory.NameMangler)}"; 43public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.DataSection; 52protected virtual void GetElementDataForNodes(ref ObjectDataBuilder builder, NodeFactory factory, bool relocsOnly) 78protected virtual int GetAlignmentRequirement(NodeFactory factory) { return factory.Target.PointerSize; } 80public override ObjectData GetData(NodeFactory factory, bool relocsOnly) 96public override bool ShouldSkipEmittingObjectNode(NodeFactory factory)

Compiler\DependencyAnalysis\ArrayOfEmbeddedPointersNode.cs (3)

85protected override string GetName(NodeFactory factory) => $"Embedded pointer to {Target.GetMangledName(factory.NameMangler)}"; 87protected override void OnMarked(NodeFactory factory) 94public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)

Compiler\DependencyAnalysis\EmbeddedObjectNode.cs (4)

62public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory factory) => null; 63public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory factory) => null; 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) 39public abstract override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory);

Compiler\DependencyAnalysis\ReadyToRun\AssemblyTableNode.cs (1)

39public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\AttributePresenceFilterNode.cs (1)

300public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\CompilerIdentifierNode.cs (2)

13public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 34public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\CopiedCorHeaderNode.cs (3)

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

Compiler\DependencyAnalysis\ReadyToRun\CopiedFieldRvaNode.cs (3)

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

Compiler\DependencyAnalysis\ReadyToRun\CopiedManagedResourcesNode.cs (3)

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

Compiler\DependencyAnalysis\ReadyToRun\CopiedMetadataBlobNode.cs (5)

28public override ObjectNodeSection GetSection(NodeFactory factory) 42private void WriteMethodTableRvas(NodeFactory factory, ref ObjectDataBuilder builder, ref BlobReader reader) 73private void WriteFieldRvas(NodeFactory factory, ref ObjectDataBuilder builder, ref BlobReader reader) 112public unsafe override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 149protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\ReadyToRun\CopiedMethodILDeduplicator.cs (2)

21public void DeduplicatePass(NodeFactory factory, Dictionary<ISymbolNode, ISymbolNode> previousSymbolRemapping, Dictionary<ISymbolNode, ISymbolNode> symbolRemapping) 64public InternKey(CopiedMethodILNode node, NodeFactory factory)

Compiler\DependencyAnalysis\ReadyToRun\CopiedMethodILNode.cs (3)

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

Compiler\DependencyAnalysis\ReadyToRun\CopiedStrongNameSignatureNode.cs (3)

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

Compiler\DependencyAnalysis\ReadyToRun\DebugDirectoryEntryNode.cs (11)

31public override ObjectNodeSection GetSection(NodeFactory factory) 46protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 103public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 177public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 243private class RSDSChecksumNode : DependencyNodeCore<NodeFactory>, IChecksumNode 272public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory context) => []; 273public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context) => []; 274public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => []; 275protected override string GetName(NodeFactory context) 301public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\DebugDirectoryNode.cs (3)

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

Compiler\DependencyAnalysis\ReadyToRun\DebugInfoTableNode.cs (1)

72public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\DeferredTillPhaseNode.cs (10)

11class DeferredTillPhaseNode : DependencyNodeCore<NodeFactory> 14private readonly List<DependencyNodeCore<NodeFactory>> _dependencies = new List<DependencyNodeCore<NodeFactory>>(); 29public void AddDependency(DependencyNodeCore<NodeFactory> newDependency) 45public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory context) => null; 46public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context) 50yield return new DependencyNodeCore<NodeFactory>.DependencyListEntry(dependencyNode, "DeferredDependency"); 53public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => throw new NotImplementedException(); 54protected override string GetName(NodeFactory context) => $"DeferredTillPhaseNode {_phase}";

Compiler\DependencyAnalysis\ReadyToRun\DelayLoadHelperImport.cs (3)

30NodeFactory factory, 83public override void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 108public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)

Compiler\DependencyAnalysis\ReadyToRun\DelayLoadHelperMethodImport.cs (2)

25NodeFactory factory, 39public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)

Compiler\DependencyAnalysis\ReadyToRun\DelayLoadMethodImport.cs (2)

17NodeFactory factory, 43public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)

Compiler\DependencyAnalysis\ReadyToRun\DelegateCtorSignature.cs (2)

36public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 66protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory)

Compiler\DependencyAnalysis\ReadyToRun\EnclosingTypeMapNode.cs (1)

42public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\ExceptionInfoLookupTableNode.cs (9)

17public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 49public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 54protected override string GetName(NodeFactory context) 67private readonly NodeFactory _nodeFactory; 71public ExceptionInfoLookupTableNode(NodeFactory nodeFactory) 106public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 141public override bool ShouldSkipEmittingObjectNode(NodeFactory factory) 147protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 149return new DependencyNodeCore<NodeFactory>.DependencyList(new DependencyListEntry[] { new DependencyListEntry(_ehInfoNode, "EH info array") });

Compiler\DependencyAnalysis\ReadyToRun\FieldFixupSignature.cs (2)

22public FieldFixupSignature(ReadyToRunFixupKind fixupKind, FieldWithToken fieldWithToken, NodeFactory factory) 33public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\GCRefMapNode.cs (3)

27public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 53public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 113protected override string GetName(NodeFactory factory)

Compiler\DependencyAnalysis\ReadyToRun\GenericLookupSignature.cs (2)

48public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 133protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory)

Compiler\DependencyAnalysis\ReadyToRun\HotColdMapNode.cs (1)

33public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\ILBodyFixupSignature.cs (4)

56protected override void OnMarked(NodeFactory context) 61public static void NotifyComplete(NodeFactory factory, List<ILBodyFixupSignature> completeListOfSigs) 70private ModuleToken GetModuleToken(NodeFactory factory) 79public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\Import.cs (4)

31protected override void OnMarked(NodeFactory factory) 36protected override string GetName(NodeFactory factory) 47public override void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 63public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)

Compiler\DependencyAnalysis\ReadyToRun\ImportSectionNode.cs (7)

22public override bool ShouldSkipEmittingObjectNode(NodeFactory factory) => false; 26protected override int GetAlignmentRequirement(NodeFactory factory) 61public void MaterializeSignature(NodeFactory r2rFactory) 75public void AddImport(NodeFactory factory, Import import) 105public override void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 145public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context) 155protected override string GetName(NodeFactory context)

Compiler\DependencyAnalysis\ReadyToRun\ImportSectionsTableNode.cs (3)

10private readonly NodeFactory _r2rFactory; 14public ImportSectionsTableNode(NodeFactory r2rFactory) 33protected override void GetElementDataForNodes(ref ObjectDataBuilder builder, NodeFactory factory, bool relocsOnly)

Compiler\DependencyAnalysis\ReadyToRun\ImportThunk.cs (4)

37public ImportThunk(NodeFactory factory, ReadyToRunHelper helperId, ImportSectionNode containingImportSection, bool useVirtualCall, bool useJumpableStub) 74protected override string GetName(NodeFactory factory) 97protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 105protected override void OnMarked(NodeFactory factory)

Compiler\DependencyAnalysis\ReadyToRun\InjectStringThunksSignature.cs (1)

26public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\InliningInfoNode.cs (1)

57public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\InstanceEntryPointTableNode.cs (5)

23private readonly NodeFactory _factory; 26public InstanceEntryPointTableNode(NodeFactory factory) 57public static byte[] BuildSignatureForMethodDefinedInModule(MethodDesc method, NodeFactory factory) 85private byte[] BuildSignatureForMethod(MethodWithGCInfo method, NodeFactory factory) 90public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\InstrumentationDataTableNode.cs (4)

25private readonly NodeFactory _factory; 30public InstrumentationDataTableNode(NodeFactory factory, ProfileDataManager profileDataManager) 212protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 235public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\ManifestAssemblyMvidHeaderNode.cs (3)

24public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 44protected override string GetName(NodeFactory nodeFactory) 51public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\ManifestMetadataTableNode.cs (3)

80private readonly NodeFactory _nodeFactory; 84public ManifestMetadataTableNode(NodeFactory nodeFactory) 293public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\MethodColdCodeNode.cs (3)

25public override ObjectNodeSection GetSection(NodeFactory factory) 51public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) => _methodColdCode; 53protected override string GetName(NodeFactory context) => throw new NotImplementedException();

Compiler\DependencyAnalysis\ReadyToRun\MethodEntryPointTableNode.cs (1)

42public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\MethodFixupSignature.cs (3)

54protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 65list = list ?? new DependencyAnalysisFramework.DependencyNodeCore<NodeFactory>.DependencyList(); 79public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\MethodGCInfoNode.cs (8)

32protected override void OnMarked(NodeFactory factory) 41public int[] CalculateFuncletOffsets(NodeFactory factory) 158private IEnumerable<GCInfoComponent> EncodeDataCore(NodeFactory factory) 228public MethodGCInfoNodeDeduplicatingComparer(NodeFactory factory) 233NodeFactory _factory; 249public override void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 281protected override string GetName(NodeFactory context) 289public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context) => null;

Compiler\DependencyAnalysis\ReadyToRun\MethodIsGenericMapNode.cs (1)

32public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\MethodWithGCInfo.cs (9)

43protected override void OnMarked(NodeFactory context) 57private void RegisterInlineeModuleIndices(NodeFactory factory) 101public override ObjectData GetData(NodeFactory factory, bool relocsOnly) 140public byte[] GetFixupBlob(NodeFactory factory) 264protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 293protected override string GetName(NodeFactory factory) 304public override ObjectNodeSection GetSection(NodeFactory factory) 390public void InitializeInliningInfo(MethodDesc[] inlinedMethods, NodeFactory factory) 408public override bool ShouldSkipEmittingObjectNode(NodeFactory factory) => IsEmpty;

Compiler\DependencyAnalysis\ReadyToRun\NewArrayFixupSignature.cs (1)

25public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\NewObjectFixupSignature.cs (1)

25public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\OwnerCompositeExecutableNode.cs (2)

19public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 35public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\PrecodeHelperImport.cs (3)

15public PrecodeHelperImport(NodeFactory factory, Signature signature) 25protected override string GetName(NodeFactory factory) 32public override void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly)

Compiler\DependencyAnalysis\ReadyToRun\PrecodeMethodImport.cs (2)

19NodeFactory factory, 48public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory)

Compiler\DependencyAnalysis\ReadyToRun\ReadyToRunHeaderNode.cs (9)

25protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 29public override ObjectNodeSection GetSection(NodeFactory factory) 86public HeaderItem(ReadyToRunSectionType id, DependencyNodeCore<NodeFactory> node, ISymbolNode startSymbol) 94public readonly DependencyNodeCore<NodeFactory> Node; 116public void Add(ReadyToRunSectionType id, DependencyNodeCore<NodeFactory> node, ISymbolNode startSymbol) 122where T : DependencyNodeCore<NodeFactory>, ISymbolNode 130protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 141public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 143public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\ReadyToRunHelperSignature.cs (1)

24public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\ReadyToRunInstructionSetSupportSignature.cs (1)

75public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\ReadyToRunModuleSignature.cs (1)

17public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\ResumptionStubEntryPointSignature.cs (1)

17public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\RuntimeFunctionsGCInfoNode.cs (1)

21public override ObjectNodeSection GetSection(NodeFactory factory)

Compiler\DependencyAnalysis\ReadyToRun\RuntimeFunctionsTableNode.cs (4)

18private readonly NodeFactory _nodeFactory; 21public RuntimeFunctionsTableNode(NodeFactory nodeFactory) 26public override ObjectNodeSection GetSection(NodeFactory factory) 64public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\Signature.cs (2)

10public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.DataSection; 18protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler);

Compiler\DependencyAnalysis\ReadyToRun\SignatureBuilder.cs (2)

579public ObjectDataSignatureBuilder(NodeFactory factory, bool relocsOnly) 604public SignatureContext EmitFixup(NodeFactory factory, ReadyToRunFixupKind fixupKind, IEcmaModule targetModule, SignatureContext outerContext)

Compiler\DependencyAnalysis\ReadyToRun\SignatureEmbeddedPointerIndirectionNode.cs (3)

20protected override string GetName(NodeFactory factory) => $"Embedded pointer to {Target.GetMangledName(factory.NameMangler)}"; 22public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory) 30public override void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly)

Compiler\DependencyAnalysis\ReadyToRun\StringDiscoverableAssemblyStubNode.cs (2)

25protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 33protected override void OnMarked(NodeFactory factory)

Compiler\DependencyAnalysis\ReadyToRun\StringImport.cs (2)

20public override void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 29protected override string GetName(NodeFactory context)

Compiler\DependencyAnalysis\ReadyToRun\StringImportSignature.cs (1)

20public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\SymbolNodeRange.cs (8)

15public sealed class SymbolNodeRange(string name) : DependencyNodeCore<NodeFactory>, ISymbolRangeNode 20protected override string GetName(NodeFactory context) => name; 42public ISymbolNode StartNode(NodeFactory factory) => _startNode; 43public ISymbolNode EndNode(NodeFactory factory) => _endNode; 51public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory context) => []; 52public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context) => []; 53public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => [];

Compiler\DependencyAnalysis\ReadyToRun\Target_ARM\ImportThunk.cs (1)

18protected override void EmitCode(NodeFactory factory, ref ARM.ARMEmitter instructionEncoder, bool relocsOnly)

Compiler\DependencyAnalysis\ReadyToRun\Target_ARM64\ImportThunk.cs (1)

16protected override void EmitCode(NodeFactory factory, ref ARM64Emitter instructionEncoder, bool relocsOnly)

Compiler\DependencyAnalysis\ReadyToRun\Target_LoongArch64\ImportThunk.cs (1)

16protected override void EmitCode(NodeFactory factory, ref LoongArch64Emitter instructionEncoder, bool relocsOnly)

Compiler\DependencyAnalysis\ReadyToRun\Target_RiscV64\ImportThunk.cs (1)

16protected override void EmitCode(NodeFactory factory, ref RiscV64Emitter instructionEncoder, bool relocsOnly)

Compiler\DependencyAnalysis\ReadyToRun\Target_Wasm\ImportThunk.cs (1)

17protected override void EmitCode(NodeFactory factory, ref WasmEmitter instructionEncoder, bool relocsOnly)

Compiler\DependencyAnalysis\ReadyToRun\Target_X64\ImportThunk.cs (1)

18protected override void EmitCode(NodeFactory factory, ref X64Emitter instructionEncoder, bool relocsOnly)

Compiler\DependencyAnalysis\ReadyToRun\Target_X86\ImportThunk.cs (1)

18protected override void EmitCode(NodeFactory factory, ref X86Emitter instructionEncoder, bool relocsOnly)

Compiler\DependencyAnalysis\ReadyToRun\TypeFixupSignature.cs (3)

34public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 204protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 223public static void AddDependenciesForAsyncStateMachineBox(ref DependencyList dependencies, NodeFactory factory, TypeDesc type)

Compiler\DependencyAnalysis\ReadyToRun\TypeGenericInfoMapNode.cs (1)

35public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\TypesTableNode.cs (1)

27public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\VirtualResolutionFixupSignature.cs (1)

42public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\WasmImportThunk.cs (10)

Compiler\DependencyAnalysis\ReadyToRun\WasmImportThunkPortableEntrypoint.cs (4)

21public WasmImportThunkPortableEntrypoint(NodeFactory factory, DelayLoadHelperImport import) 35protected override string GetName(NodeFactory factory) 48public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 69public override ObjectData GetData(NodeFactory factory, System.Boolean relocsOnly = false)

Compiler\DependencyAnalysis\ReadyToRun\WasmInterpreterToR2RThunkNode.cs (11)

33public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.TextSection; 43public WasmInterpreterToR2RThunkNode(NodeFactory factory, WasmSignature wasmSignature) 57protected override string GetName(NodeFactory factory) 72protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 80protected override void EmitCode(NodeFactory factory, ref Wasm.WasmEmitter instructionEncoder, bool relocsOnly) 282protected override void EmitCode(NodeFactory factory, ref X64.X64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 283protected override void EmitCode(NodeFactory factory, ref X86.X86Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 284protected override void EmitCode(NodeFactory factory, ref ARM.ARMEmitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 285protected override void EmitCode(NodeFactory factory, ref ARM64.ARM64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 286protected override void EmitCode(NodeFactory factory, ref LoongArch64.LoongArch64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 287protected override void EmitCode(NodeFactory factory, ref RiscV64.RiscV64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); }

Compiler\DependencyAnalysis\ReadyToRun\WasmR2RToInterpreterThunkNode.cs (11)

43public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.TextSection; 52public WasmR2RToInterpreterThunkNode(NodeFactory factory, WasmSignature wasmSignature) 67protected override string GetName(NodeFactory factory) 82protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 89protected override void EmitCode(NodeFactory factory, ref Wasm.WasmEmitter instructionEncoder, bool relocsOnly) 348protected override void EmitCode(NodeFactory factory, ref X64.X64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 349protected override void EmitCode(NodeFactory factory, ref X86.X86Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 350protected override void EmitCode(NodeFactory factory, ref ARM.ARMEmitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 351protected override void EmitCode(NodeFactory factory, ref ARM64.ARM64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 352protected override void EmitCode(NodeFactory factory, ref LoongArch64.LoongArch64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 353protected override void EmitCode(NodeFactory factory, ref RiscV64.RiscV64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); }

Compiler\DependencyAnalysis\ReadyToRun\Win32ResourcesNode.cs (3)

22public override ObjectNodeSection GetSection(NodeFactory factory) 42public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 57protected override string GetName(NodeFactory context)

Compiler\DependencyAnalysis\ReadyToRunCodegenNodeFactory.cs (2)

106public void GenerateHotColdMap(DependencyAnalyzerBase<NodeFactory> dependencyGraph) 860public void AttachToDependencyGraph(DependencyAnalyzerBase<NodeFactory> graph, ILProvider ilProvider)

Compiler\DependencyAnalysis\ReadyToRunSymbolNodeFactory.cs (2)

42private readonly NodeFactory _codegenNodeFactory; 47public ReadyToRunSymbolNodeFactory(NodeFactory codegenNodeFactory, bool verifyTypeAndFieldLayout)

Compiler\FileLayoutOptimizer.cs (5)

55NodeFactory nodeFactory, 70private NodeFactory _nodeFactory; 73public ImmutableArray<DependencyNodeCore<NodeFactory>> ApplyProfilerGuidedMethodSort(ImmutableArray<DependencyNodeCore<NodeFactory>> nodes) 119void ApplySortToDependencies(DependencyNodeCore<NodeFactory> node, int depth)

Compiler\ReadyToRunCodegenCompilation.cs (21)

Compiler\ReadyToRunCodegenCompilationBuilder.cs (3)

269NodeFactory factory = new NodeFactory( 288IComparer<DependencyNodeCore<NodeFactory>> comparer = new SortableDependencyNode.ObjectNodeComparer(CompilerComparer.Instance); 289DependencyAnalyzerBase<NodeFactory> graph = CreateDependencyGraph(factory, comparer);

Compiler\ReadyToRunExternalTypeMapNode.cs (6)

40public Vertex CreateTypeMap(NodeFactory factory, NativeWriter writer, Section section, INativeFormatTypeReferenceProvider externalReferences) 69public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory context) => []; 70public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context) 84public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => []; 85protected override string GetName(NodeFactory context) => $"ExternalTypeMap {TypeMapGroup} entries in assembly {TriggeringModule.GetDisplayName()}";

Compiler\ReadyToRunProxyTypeMapNode.cs (6)

38public Vertex CreateTypeMap(NodeFactory factory, NativeWriter writer, Section section, INativeFormatTypeReferenceProvider ProxyReferences) 69public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory context) => []; 70public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context) 85public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => []; 86protected override string GetName(NodeFactory context) => $"ProxyTypeMap {TypeMapGroup} entries in assembly {TriggeringModule.GetDisplayName()}";

Compiler\ReadyToRunTableManager.cs (4)

56private NodeFactory _factory; 65public void AttachToDependencyGraph(DependencyAnalyzerBase<NodeFactory> graph, NodeFactory factory) 71protected virtual void Graph_NewMarkedNode(DependencyNodeCore<NodeFactory> obj)

Compiler\ReadyToRunTypeMapManager.cs (2)

19public override void AttachToDependencyGraph(DependencyAnalyzerBase<NodeFactory> graph) 54public void AddToReadyToRunHeader(ReadyToRunHeaderNode header, NodeFactory nodeFactory, ImportReferenceProvider importReferenceProvider)

Compiler\TypeMapAssemblyTargetsNode.cs (4)

37protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 60public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 96public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.ReadOnlyDataSection; 97protected override string GetName(NodeFactory context) => $"Type Map Assembly Targets Tables ({_assemblyTypeMaps.AssociatedModule.Assembly.GetName().Name})";

JitInterface\CorInfoImpl.ReadyToRun.cs (1)

32using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList;

src\runtime\src\coreclr\tools\Common\Compiler\CompilationBuilder.cs (3)

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

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\AssemblyStubNode.cs (9)

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\INodeWithRuntimeDeterminedDependencies.cs (2)

7using DependencyListEntry = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyListEntry; 20IEnumerable<DependencyListEntry> InstantiateDependencies(NodeFactory factory, Instantiation typeInstantiation, Instantiation methodInstantiation, bool isConcreteInstantiation);

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\IObjectDumper.cs (2)

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

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\ISymbolNode.cs (4)

13public interface ISymbolNode : IDependencyNode<NodeFactory> 42ISymbolNode NodeForLinkage(NodeFactory factory); 85ISymbolNode StartNode(NodeFactory factory); 90ISymbolNode EndNode(NodeFactory factory);

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\MethodReadOnlyDataNode.cs (3)

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);

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\MethodReadWriteDataNode.cs (3)

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\ObjectDataBuilder.cs (2)

20public ObjectDataBuilder(NodeFactory factory, bool relocsOnly) : this(factory.Target, relocsOnly) 259var node = symbol as ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<NodeFactory>;

src\runtime\src\coreclr\tools\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 IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory) 85protected virtual DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 90public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory factory) => null; 91public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory factory) => null;

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\ShadowMethodNode.cs (7)

22public abstract class ShadowMethodNode : DependencyNodeCore<NodeFactory>, IMethodNode, ISymbolNodeWithLinkage 54public ISymbolNode NodeForLinkage(NodeFactory factory) 59public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory) 87public sealed override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory factory) 112protected override string GetName(NodeFactory factory) => $"{Method} backed by {CanonicalMethodNode.GetMangledName(factory.NameMangler)}"; 118public sealed override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory factory) => null;

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\SortableDependencyNode.cs (4)

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

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_ARM\ARMEmitter.cs (1)

10public ARMEmitter(NodeFactory factory, bool relocsOnly)

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_ARM64\ARM64Emitter.cs (1)

11public ARM64Emitter(NodeFactory factory, bool relocsOnly)

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_LoongArch64\LoongArch64Emitter.cs (1)

11public LoongArch64Emitter(NodeFactory factory, bool relocsOnly)

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_RiscV64\RiscV64Emitter.cs (1)

11public RiscV64Emitter(NodeFactory factory, bool relocsOnly)

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_Wasm\WasmEmitter.cs (1)

16public struct WasmEmitter(NodeFactory factory, bool relocsOnly)

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_X64\X64Emitter.cs (1)

11public X64Emitter(NodeFactory factory, bool relocsOnly)

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\Target_X86\X86Emitter.cs (1)

11public X86Emitter(NodeFactory factory, bool relocsOnly)

src\runtime\src\coreclr\tools\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)

src\runtime\src\coreclr\tools\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);

src\runtime\src\coreclr\tools\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";

src\runtime\src\coreclr\tools\Common\Compiler\IExternalTypeMapNode.cs (1)

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

src\runtime\src\coreclr\tools\Common\Compiler\IProxyTypeMapNode.cs (1)

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

src\runtime\src\coreclr\tools\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)

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\CoffObjectWriter.cs (1)

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

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\ElfObjectWriter.cs (1)

56public ElfObjectWriter(NodeFactory factory, ObjectWritingOptions options)

src\runtime\src\coreclr\tools\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)

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\ObjectWriter.cs (3)

32private protected readonly NodeFactory _nodeFactory; 51private protected ObjectWriter(NodeFactory factory, ObjectWritingOptions options, OutputInfoBuilder outputInfoBuilder = null) 705public static void EmitObject(string objectFilePath, IReadOnlyCollection<DependencyNode> nodes, NodeFactory factory, ObjectWritingOptions options, IObjectDumper dumper, Logger logger)

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\PEObjectWriter.cs (1)

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

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\UnixObjectWriter.cs (1)

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

src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\WasmObjectWriter.cs (1)

68public WasmObjectWriter(NodeFactory factory, ObjectWritingOptions options, OutputInfoBuilder outputInfoBuilder)

src\runtime\src\coreclr\tools\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";

src\runtime\src\coreclr\tools\Common\Compiler\TypeMapManager.cs (2)

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

src\runtime\src\coreclr\tools\Common\JitInterface\CorInfoImpl.cs (1)

36using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList;