NodeFactory

CodeGen\ReadyToRunObjectWriter.cs (3)

32private readonly NodeFactory _nodeFactory; 125NodeFactory factory, 320NodeFactory 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\ArrayInterfaceMethodsNode.cs (6)

23public class ArrayInterfaceMethodsNode : DependencyNodeCore<NodeFactory> 40public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context) => null; 41public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => null; 43public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory factory) 82protected override string GetName(NodeFactory factory) => $"Array interface methods on {_arrayType}";

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\InheritedVirtualMethodsNode.cs (10)

22public class InheritedVirtualMethodsNode : DependencyNodeCore<NodeFactory> 43public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context) => null; 44public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => null; 46public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory factory) 71DependencyNodeCore<NodeFactory> implNode = GetVirtualMethodImplNode(factory, canonImpl); 126DependencyNodeCore<NodeFactory> implNode = GetVirtualMethodImplNode(factory, canonImpl); 176private static DependencyNodeCore<NodeFactory> GetVirtualMethodImplNode(NodeFactory factory, MethodDesc method) 192protected override string GetName(NodeFactory factory) => $"Inherited virtual methods on {_type}";

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

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

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

309public 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 (4)

28public override ObjectNodeSection GetSection(NodeFactory factory) 43public int GetAlignment(NodeFactory factory) 81public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 122protected 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 (4)

30public override ObjectNodeSection GetSection(NodeFactory factory) 41protected override string GetName(NodeFactory factory) => this.GetMangledName(factory.NameMangler); 48public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false) 75private static bool MayNeedILAtRuntime(NodeFactory factory, MethodDesc method)

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 274public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory context) => []; 275public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory context) => []; 276public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context) => []; 277protected override string GetName(NodeFactory context) 303public 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, 75public override void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 100public 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) 151public override bool ShouldSkipEmittingObjectNode(NodeFactory factory) 157protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 159return 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 (5)

31protected override void OnMarked(NodeFactory factory) 36protected override string GetName(NodeFactory factory) 50public int GetAlignment(NodeFactory factory) => Table.EntrySize; 52public override void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 68public 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 (2)

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

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

32protected override void OnMarked(NodeFactory factory) 51public int[] CalculateFuncletOffsets(NodeFactory factory) 179private IEnumerable<GCInfoComponent> EncodeDataCore(NodeFactory factory) 250public MethodGCInfoNodeDeduplicatingComparer(NodeFactory factory) 255NodeFactory _factory; 271public override void EncodeData(ref ObjectDataBuilder dataBuilder, NodeFactory factory, bool relocsOnly) 307protected override string GetName(NodeFactory context) 315public 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)

44protected override void OnMarked(NodeFactory context) 58private void RegisterInlineeModuleIndices(NodeFactory factory) 102public override ObjectData GetData(NodeFactory factory, bool relocsOnly) 141public byte[] GetFixupBlob(NodeFactory factory) 265protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 294protected override string GetName(NodeFactory factory) 305public override ObjectNodeSection GetSection(NodeFactory factory) 459public void InitializeInliningInfo(MethodDesc[] inlinedMethods, NodeFactory factory) 477public override bool ShouldSkipEmittingObjectNode(NodeFactory factory) => IsEmpty;

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

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

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)

79public 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)

18public 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)

20private readonly NodeFactory _nodeFactory; 23public RuntimeFunctionsTableNode(NodeFactory nodeFactory) 28public override ObjectNodeSection GetSection(NodeFactory factory) 118public 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\StoreMultiCallableAddrOfCodeSignature.cs (1)

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

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) 225public 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)

34public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.TextSection; 74public WasmInterpreterToR2RThunkNode(NodeFactory factory, WasmSignature wasmSignature) 88protected override string GetName(NodeFactory factory) 103protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 111protected override void EmitCode(NodeFactory factory, ref Wasm.WasmEmitter instructionEncoder, bool relocsOnly) 333protected override void EmitCode(NodeFactory factory, ref X64.X64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 334protected override void EmitCode(NodeFactory factory, ref X86.X86Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 335protected override void EmitCode(NodeFactory factory, ref ARM.ARMEmitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 336protected override void EmitCode(NodeFactory factory, ref ARM64.ARM64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 337protected override void EmitCode(NodeFactory factory, ref LoongArch64.LoongArch64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 338protected override void EmitCode(NodeFactory factory, ref RiscV64.RiscV64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); }

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

44public override ObjectNodeSection GetSection(NodeFactory factory) => ObjectNodeSection.TextSection; 83public WasmR2RToInterpreterThunkNode(NodeFactory factory, WasmSignature wasmSignature) 98protected override string GetName(NodeFactory factory) 113protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory) 120protected override void EmitCode(NodeFactory factory, ref Wasm.WasmEmitter instructionEncoder, bool relocsOnly) 401protected override void EmitCode(NodeFactory factory, ref X64.X64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 402protected override void EmitCode(NodeFactory factory, ref X86.X86Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 403protected override void EmitCode(NodeFactory factory, ref ARM.ARMEmitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 404protected override void EmitCode(NodeFactory factory, ref ARM64.ARM64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 405protected override void EmitCode(NodeFactory factory, ref LoongArch64.LoongArch64Emitter instructionEncoder, bool relocsOnly) { throw new NotSupportedException(); } 406protected 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 (3)

25using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 108public void GenerateHotColdMap(DependencyAnalyzerBase<NodeFactory> dependencyGraph) 944public 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\ExternSymbolNode.cs (6)

28protected override string GetName(NodeFactory factory) => $"ExternSymbol {_name}{(_isIndirection ? " (indirected)" : "")}"; 43public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory) => null; 44public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory factory) => null; 45public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory factory) => null; 80protected override string GetName(NodeFactory factory) => $"ExternDataSymbolNode {ToString()}";

src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\GVMDependenciesNode.cs (12)

26public class GVMDependenciesNode : DependencyNodeCore<NodeFactory> 43protected override string GetName(NodeFactory factory) => "__GVMDependenciesNode_" + factory.NameMangler.GetMangledMethodName(_method); 45public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory) 49DependencyNodeCore<NodeFactory> node = GetVirtualMethodImplNode(factory, _method); 62public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory context) => null; 79public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory factory) 90DependencyNodeCore<NodeFactory> entry = markedNodes[i]; 168DependencyNodeCore<NodeFactory> node = GetVirtualMethodImplNode(factory, canonImpl); 239DependencyNodeCore<NodeFactory> node = GetVirtualMethodImplNode(factory, instantiatedTargetMethod); 268private static DependencyNodeCore<NodeFactory> GetVirtualMethodImplNode(NodeFactory factory, MethodDesc method)

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\IObjectNodeWithAlignment.cs (1)

15int GetAlignment(NodeFactory factory);

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

14public interface ISymbolNode : IDependencyNode<NodeFactory> 43ISymbolNode NodeForLinkage(NodeFactory factory); 86ISymbolNode StartNode(NodeFactory factory); 91ISymbolNode 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 139public class ObjectNodeComparer : IComparer<DependencyNodeCore<NodeFactory>> 148public 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\VirtualMethodUseNode.cs (6)

22public sealed class VirtualMethodUseNode : DependencyNodeCore<NodeFactory> 44protected override string GetName(NodeFactory factory) => $"VirtualMethodUse {_decl}"; 83public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFactory factory) => null; 86public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory factory) => null; 87public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory factory) => null;

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\DependencyAnalysis\WasmWellKnownGlobalSymbolNode.cs (1)

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

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) 709public 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)

85public 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 (2)

39using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList; 3659NodeFactory factory = _compilation.NodeFactory;