Split ExternSymbolNode into two types for functions and data

SingleAccretion · SingleAccretion · commit d62469ac6aae · 2025-07-06T19:35:53.000+03:00
This allows to distinguish the symbol type for a node with a simple type check.
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs
@@ -344,7 +344,7 @@ public ISymbolNode ComputeConstantLookup(ReadyToRunHelperId lookupKind, object t
                 case ReadyToRunHelperId.ObjectAllocator:
                     {
                         var type = (TypeDesc)targetOfLookup;
-                        return NodeFactory.ExternSymbol(JitHelper.GetNewObjectHelperForType(type));
+                        return NodeFactory.ExternFunctionSymbol(JitHelper.GetNewObjectHelperForType(type));
                     }
 
                 default:
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ExternEETypeSymbolNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ExternEETypeSymbolNode.cs
@@ -9,7 +9,7 @@ namespace ILCompiler.DependencyAnalysis
     /// Represents a symbol that is defined externally but modelled as a type in the
     /// DependencyAnalysis infrastructure during compilation.
     /// </summary>
-    public sealed class ExternEETypeSymbolNode : ExternSymbolNode, IEETypeNode
+    public sealed class ExternEETypeSymbolNode : ExternDataSymbolNode, IEETypeNode
     {
         private TypeDesc _type;
 
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ExternMethodSymbolNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ExternMethodSymbolNode.cs
@@ -9,7 +9,7 @@ namespace ILCompiler.DependencyAnalysis
     /// Represents a symbol that is defined externally but modelled as a method
     /// in the DependencyAnalysis infrastructure during compilation
     /// </summary>
-    public sealed class ExternMethodSymbolNode : ExternSymbolNode, IMethodNode
+    public sealed class ExternMethodSymbolNode : ExternFunctionSymbolNode, IMethodNode
     {
         private MethodDesc _method;
 
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ExternSymbolNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ExternSymbolNode.cs
@@ -11,13 +11,15 @@ namespace ILCompiler.DependencyAnalysis
 {
     /// <summary>
     /// Represents a symbol that is defined externally and statically linked to the output obj file.
+    /// When making a new node, do not derived from this class directly, derive from one of its subclasses
+    /// (ExternFunctionSymbolNode / ExternDataSymbolNode) instead.
     /// </summary>
-    public class ExternSymbolNode : SortableDependencyNode, ISortableSymbolNode
+    public abstract class ExternSymbolNode : SortableDependencyNode, ISortableSymbolNode
     {
         private readonly Utf8String _name;
         private readonly bool _isIndirection;
 
-        public ExternSymbolNode(Utf8String name, bool isIndirection = false)
+        protected ExternSymbolNode(Utf8String name, bool isIndirection = false)
         {
             _name = name;
             _isIndirection = isIndirection;
@@ -29,6 +31,7 @@ public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
         {
             sb.Append(_name);
         }
+
         public int Offset => 0;
         public virtual bool RepresentsIndirectionCell => _isIndirection;
 
@@ -42,8 +45,6 @@ public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
         public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory factory) => null;
 
 #if !SUPPORT_JIT
-        public override int ClassCode => 1092559304;
-
         public override int CompareToImpl(ISortableNode other, CompilerComparer comparer)
         {
             return _name.CompareTo(((ExternSymbolNode)other)._name);
@@ -56,11 +57,26 @@ public override string ToString()
         }
     }
 
-    public class AddressTakenExternSymbolNode : ExternSymbolNode
+    /// <summary>
+    /// Represents a function symbol that is defined externally and statically linked to the output obj file.
+    /// </summary>
+    public class ExternFunctionSymbolNode(Utf8String name, bool isIndirection = false) : ExternSymbolNode(name, isIndirection)
     {
-        public AddressTakenExternSymbolNode(Utf8String name)
-            : base(name) { }
+        public override int ClassCode => 1452455506;
+    }
 
+    public class AddressTakenExternFunctionSymbolNode(Utf8String name) : ExternFunctionSymbolNode(name)
+    {
         public override int ClassCode => -45645737;
     }
+
+    /// <summary>
+    /// Represents a data symbol that is defined externally and statically linked to the output obj file.
+    /// </summary>
+    public class ExternDataSymbolNode(Utf8String name) : ExternSymbolNode(name)
+    {
+        public override int ClassCode => 1428609964;
+
+        protected override string GetName(NodeFactory factory) => $"ExternDataSymbolNode {ToString()}";
+    }
 }
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ExternSymbolsImportedNodeProvider.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/ExternSymbolsImportedNodeProvider.cs
@@ -15,12 +15,12 @@ public override IEETypeNode ImportedEETypeNode(NodeFactory factory, TypeDesc typ
 
         public override ISortableSymbolNode ImportedGCStaticNode(NodeFactory factory, MetadataType type)
         {
-            return new ExternSymbolNode(GCStaticsNode.GetMangledName(type, factory.NameMangler));
+            return new ExternDataSymbolNode(GCStaticsNode.GetMangledName(type, factory.NameMangler));
         }
 
         public override ISortableSymbolNode ImportedNonGCStaticNode(NodeFactory factory, MetadataType type)
         {
-            return new ExternSymbolNode(NonGCStaticsNode.GetMangledName(type, factory.NameMangler));
+            return new ExternDataSymbolNode(NonGCStaticsNode.GetMangledName(type, factory.NameMangler));
         }
 
         public override ISortableSymbolNode ImportedMethodDictionaryNode(NodeFactory factory, MethodDesc method)
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/GenericLookupResult.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/GenericLookupResult.cs
@@ -728,7 +728,7 @@ public ObjectAllocatorGenericLookupResult(TypeDesc type)
         public override ISymbolNode GetTarget(NodeFactory factory, GenericLookupResultContext dictionary)
         {
             TypeDesc instantiatedType = _type.GetNonRuntimeDeterminedTypeFromRuntimeDeterminedSubtypeViaSubstitution(dictionary.TypeInstantiation, dictionary.MethodInstantiation);
-            return factory.ExternSymbol(JitHelper.GetNewObjectHelperForType(instantiatedType));
+            return factory.ExternFunctionSymbol(JitHelper.GetNewObjectHelperForType(instantiatedType));
         }
 
         public override void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/NodeFactory.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/NodeFactory.cs
@@ -46,7 +46,7 @@ public NodeFactory(
         {
             _target = context.Target;
 
-            InitialInterfaceDispatchStub = new AddressTakenExternSymbolNode("RhpInitialDynamicInterfaceDispatch");
+            InitialInterfaceDispatchStub = new AddressTakenExternFunctionSymbolNode("RhpInitialDynamicInterfaceDispatch");
 
             _context = context;
             _compilationModuleGroup = compilationModuleGroup;
@@ -263,13 +263,17 @@ private void CreateNodeCaches()
                 return new FieldRvaDataNode(key);
             });
 
-            _externSymbols = new NodeCache<string, ExternSymbolNode>((string name) =>
+            _externFunctionSymbols = new NodeCache<string, ExternFunctionSymbolNode>((string name) =>
             {
-                return new ExternSymbolNode(name);
+                return new ExternFunctionSymbolNode(name);
             });
-            _externIndirectSymbols = new NodeCache<string, ExternSymbolNode>((string name) =>
+            _externIndirectFunctionSymbols = new NodeCache<string, ExternFunctionSymbolNode>((string name) =>
             {
-                return new ExternSymbolNode(name, isIndirection: true);
+                return new ExternFunctionSymbolNode(name, isIndirection: true);
+            });
+            _externDataSymbols = new NodeCache<string, ExternDataSymbolNode>((string name) =>
+            {
+                return new ExternDataSymbolNode(name);
             });
 
             _pInvokeModuleFixups = new NodeCache<PInvokeModuleData, PInvokeModuleFixupNode>((PInvokeModuleData moduleData) =>
@@ -793,7 +797,7 @@ public ISortableSymbolNode TypeThreadStaticIndex(MetadataType type)
             }
             else
             {
-                return ExternSymbol(NameMangler.NodeMangler.ThreadStaticsIndex(type));
+                return ExternDataSymbol(NameMangler.NodeMangler.ThreadStaticsIndex(type));
             }
         }
 
@@ -903,24 +907,31 @@ internal ISymbolNode GenericVariance(GenericVarianceDetails details)
             return _genericVariances.GetOrAdd(details);
         }
 
-        private NodeCache<string, ExternSymbolNode> _externSymbols;
+        private NodeCache<string, ExternFunctionSymbolNode> _externFunctionSymbols;
 
-        public ISortableSymbolNode ExternSymbol(string name)
+        public ISortableSymbolNode ExternFunctionSymbol(string name)
         {
-            return _externSymbols.GetOrAdd(name);
+            return _externFunctionSymbols.GetOrAdd(name);
         }
 
-        public ISortableSymbolNode ExternVariable(string name)
+        private NodeCache<string, ExternFunctionSymbolNode> _externIndirectFunctionSymbols;
+
+        public ISortableSymbolNode ExternIndirectFunctionSymbol(string name)
         {
-            string mangledName = NameMangler.NodeMangler.ExternVariable(name);
-            return _externSymbols.GetOrAdd(mangledName);
+            return _externIndirectFunctionSymbols.GetOrAdd(name);
         }
 
-        private NodeCache<string, ExternSymbolNode> _externIndirectSymbols;
+        private NodeCache<string, ExternDataSymbolNode> _externDataSymbols;
 
-        public ISortableSymbolNode ExternIndirectSymbol(string name)
+        public ISortableSymbolNode ExternDataSymbol(string name)
+        {
+            string mangledName = NameMangler.NodeMangler.ExternVariable(name);
+            return _externDataSymbols.GetOrAdd(mangledName);
+        }
+
+        public ISortableSymbolNode ExternVariable(string name)
         {
-            return _externIndirectSymbols.GetOrAdd(name);
+            return _externDataSymbols.GetOrAdd(name);
         }
 
         private NodeCache<PInvokeModuleData, PInvokeModuleFixupNode> _pInvokeModuleFixups;
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/RuntimeImportMethodNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/RuntimeImportMethodNode.cs
@@ -9,7 +9,7 @@ namespace ILCompiler.DependencyAnalysis
     /// <summary>
     /// Represents a method that is imported from the runtime library.
     /// </summary>
-    public class RuntimeImportMethodNode : ExternSymbolNode, IMethodNode, ISymbolDefinitionNode
+    public class RuntimeImportMethodNode : ExternFunctionSymbolNode, IMethodNode, ISymbolDefinitionNode
     {
         private MethodDesc _method;
 
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_ARM/ARMReadyToRunHelperNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_ARM/ARMReadyToRunHelperNode.cs
@@ -128,7 +128,7 @@ protected override void EmitCode(NodeFactory factory, ref ARMEmitter encoder, bo
                         if (targetMethod.OwningType.IsInterface)
                         {
                             encoder.EmitMOV(encoder.TargetRegister.Arg1, factory.InterfaceDispatchCell(targetMethod));
-                            encoder.EmitJMP(factory.ExternSymbol("RhpResolveInterfaceMethod"));
+                            encoder.EmitJMP(factory.ExternFunctionSymbol("RhpResolveInterfaceMethod"));
                         }
                         else
                         {
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_ARM64/ARM64ReadyToRunHelperNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_ARM64/ARM64ReadyToRunHelperNode.cs
@@ -144,7 +144,7 @@ protected override void EmitCode(NodeFactory factory, ref ARM64Emitter encoder,
                         if (targetMethod.OwningType.IsInterface)
                         {
                             encoder.EmitMOV(encoder.TargetRegister.Arg1, factory.InterfaceDispatchCell(targetMethod));
-                            encoder.EmitJMP(factory.ExternSymbol("RhpResolveInterfaceMethod"));
+                            encoder.EmitJMP(factory.ExternFunctionSymbol("RhpResolveInterfaceMethod"));
                         }
                         else
                         {
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64ReadyToRunHelperNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64ReadyToRunHelperNode.cs
@@ -136,7 +136,7 @@ protected override void EmitCode(NodeFactory factory, ref LoongArch64Emitter enc
                         if (targetMethod.OwningType.IsInterface)
                         {
                             encoder.EmitMOV(encoder.TargetRegister.Arg1, factory.InterfaceDispatchCell(targetMethod));
-                            encoder.EmitJMP(factory.ExternSymbol("RhpResolveInterfaceMethod"));
+                            encoder.EmitJMP(factory.ExternFunctionSymbol("RhpResolveInterfaceMethod"));
                         }
                         else
                         {
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_RiscV64/RiscV64ReadyToRunHelperNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_RiscV64/RiscV64ReadyToRunHelperNode.cs
@@ -134,7 +134,7 @@ protected override void EmitCode(NodeFactory factory, ref RiscV64Emitter encoder
                         if (targetMethod.OwningType.IsInterface)
                         {
                             encoder.EmitMOV(encoder.TargetRegister.Arg1, factory.InterfaceDispatchCell(targetMethod));
-                            encoder.EmitJMP(factory.ExternSymbol("RhpResolveInterfaceMethod"));
+                            encoder.EmitJMP(factory.ExternFunctionSymbol("RhpResolveInterfaceMethod"));
                         }
                         else
                         {
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_X64/X64ReadyToRunHelperNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_X64/X64ReadyToRunHelperNode.cs
@@ -149,7 +149,7 @@ protected override void EmitCode(NodeFactory factory, ref X64Emitter encoder, bo
                         if (targetMethod.OwningType.IsInterface)
                         {
                             encoder.EmitLEAQ(encoder.TargetRegister.Arg1, factory.InterfaceDispatchCell(targetMethod));
-                            encoder.EmitJMP(factory.ExternSymbol("RhpResolveInterfaceMethod"));
+                            encoder.EmitJMP(factory.ExternFunctionSymbol("RhpResolveInterfaceMethod"));
                         }
                         else
                         {
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_X86/X86ReadyToRunHelperNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_X86/X86ReadyToRunHelperNode.cs
@@ -159,7 +159,7 @@ protected override void EmitCode(NodeFactory factory, ref X86Emitter encoder, bo
                         if (targetMethod.OwningType.IsInterface)
                         {
                             encoder.EmitMOV(encoder.TargetRegister.Arg1, factory.InterfaceDispatchCell(targetMethod));
-                            encoder.EmitJMP(factory.ExternSymbol("RhpResolveInterfaceMethod"));
+                            encoder.EmitJMP(factory.ExternFunctionSymbol("RhpResolveInterfaceMethod"));
                         }
                         else
                         {
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ILScanner.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ILScanner.cs
@@ -200,7 +200,7 @@ protected override Helper CreateValueFromKey(ReadyToRunHelper key)
 
                 ISymbolNode entryPoint;
                 if (mangledName != null)
-                    entryPoint = _compilation.NodeFactory.ExternSymbol(mangledName);
+                    entryPoint = _compilation.NodeFactory.ExternFunctionSymbol(mangledName);
                 else
                     entryPoint = _compilation.NodeFactory.MethodEntrypoint(methodDesc);
 
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/ObjectWriter.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/ObjectWriter.cs
@@ -467,7 +467,7 @@ private void EmitObject(string objectFilePath, IReadOnlyCollection<DependencyNod
                         relocTarget.Offset);
 
                     if (_options.HasFlag(ObjectWritingOptions.ControlFlowGuard) &&
-                        relocTarget is IMethodNode or AssemblyStubNode or AddressTakenExternSymbolNode)
+                        relocTarget is IMethodNode or AssemblyStubNode or AddressTakenExternFunctionSymbolNode)
                     {
                         // For now consider all method symbols address taken.
                         // We could restrict this in the future to those that are referenced from
diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs

Original file line number	Diff line number	Diff line change
`@@ -344,7 +344,7 @@ public ISymbolNode ComputeConstantLookup(ReadyToRunHelperId lookupKind, object t`
`344`	`344`	`case ReadyToRunHelperId.ObjectAllocator:`
`345`	`345`	`{`
`346`	`346`	`var type = (TypeDesc)targetOfLookup;`
`347`		`- return NodeFactory.ExternSymbol(JitHelper.GetNewObjectHelperForType(type));`
	`347`	`+ return NodeFactory.ExternFunctionSymbol(JitHelper.GetNewObjectHelperForType(type));`
`348`	`348`	`}`
`349`	`349`
`350`	`350`	`default:`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace ILCompiler.DependencyAnalysis`
`9`	`9`	`/// Represents a symbol that is defined externally but modelled as a type in the`
`10`	`10`	`/// DependencyAnalysis infrastructure during compilation.`
`11`	`11`	`/// </summary>`
`12`		`- public sealed class ExternEETypeSymbolNode : ExternSymbolNode, IEETypeNode`
	`12`	`+ public sealed class ExternEETypeSymbolNode : ExternDataSymbolNode, IEETypeNode`
`13`	`13`	`{`
`14`	`14`	`private TypeDesc _type;`
`15`	`15`
Original file line number	Diff line number	Diff line change
`@@ -11,13 +11,15 @@ namespace ILCompiler.DependencyAnalysis`
`11`	`11`	`{`
`12`	`12`	`/// <summary>`
`13`	`13`	`/// Represents a symbol that is defined externally and statically linked to the output obj file.`
	`14`	`+ /// When making a new node, do not derived from this class directly, derive from one of its subclasses`
	`15`	`+ /// (ExternFunctionSymbolNode / ExternDataSymbolNode) instead.`
`14`	`16`	`/// </summary>`
`15`		`- public class ExternSymbolNode : SortableDependencyNode, ISortableSymbolNode`
	`17`	`+ public abstract class ExternSymbolNode : SortableDependencyNode, ISortableSymbolNode`
`16`	`18`	`{`
`17`	`19`	`private readonly Utf8String _name;`
`18`	`20`	`private readonly bool _isIndirection;`
`19`	`21`
`20`		`- public ExternSymbolNode(Utf8String name, bool isIndirection = false)`
	`22`	`+ protected ExternSymbolNode(Utf8String name, bool isIndirection = false)`
`21`	`23`	`{`
`22`	`24`	`_name = name;`
`23`	`25`	`_isIndirection = isIndirection;`
`@@ -29,6 +31,7 @@ public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)`
`29`	`31`	`{`
`30`	`32`	`sb.Append(_name);`
`31`	`33`	`}`
	`34`	`+`
`32`	`35`	`public int Offset => 0;`
`33`	`36`	`public virtual bool RepresentsIndirectionCell => _isIndirection;`
`34`	`37`
`@@ -42,8 +45,6 @@ public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)`
`42`	`45`	`public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory factory) => null;`
`43`	`46`
`44`	`47`	`#if !SUPPORT_JIT`
`45`		`- public override int ClassCode => 1092559304;`
`46`		`-`
`47`	`48`	`public override int CompareToImpl(ISortableNode other, CompilerComparer comparer)`
`48`	`49`	`{`
`49`	`50`	`return _name.CompareTo(((ExternSymbolNode)other)._name);`
`@@ -56,11 +57,26 @@ public override string ToString()`
`56`	`57`	`}`
`57`	`58`	`}`
`58`	`59`
`59`		`- public class AddressTakenExternSymbolNode : ExternSymbolNode`
	`60`	`+ /// <summary>`
	`61`	`+ /// Represents a function symbol that is defined externally and statically linked to the output obj file.`
	`62`	`+ /// </summary>`
	`63`	`+ public class ExternFunctionSymbolNode(Utf8String name, bool isIndirection = false) : ExternSymbolNode(name, isIndirection)`
`60`	`64`	`{`
`61`		`- public AddressTakenExternSymbolNode(Utf8String name)`
`62`		`- : base(name) { }`
	`65`	`+ public override int ClassCode => 1452455506;`
	`66`	`+ }`
`63`	`67`
	`68`	`+ public class AddressTakenExternFunctionSymbolNode(Utf8String name) : ExternFunctionSymbolNode(name)`
	`69`	`+ {`
`64`	`70`	`public override int ClassCode => -45645737;`
`65`	`71`	`}`
	`72`	`+`
	`73`	`+ /// <summary>`
	`74`	`+ /// Represents a data symbol that is defined externally and statically linked to the output obj file.`
	`75`	`+ /// </summary>`
	`76`	`+ public class ExternDataSymbolNode(Utf8String name) : ExternSymbolNode(name)`
	`77`	`+ {`
	`78`	`+ public override int ClassCode => 1428609964;`
	`79`	`+`
	`80`	`+ protected override string GetName(NodeFactory factory) => $"ExternDataSymbolNode {ToString()}";`
	`81`	`+ }`
`66`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,12 +15,12 @@ public override IEETypeNode ImportedEETypeNode(NodeFactory factory, TypeDesc typ`
`15`	`15`
`16`	`16`	`public override ISortableSymbolNode ImportedGCStaticNode(NodeFactory factory, MetadataType type)`
`17`	`17`	`{`
`18`		`- return new ExternSymbolNode(GCStaticsNode.GetMangledName(type, factory.NameMangler));`
	`18`	`+ return new ExternDataSymbolNode(GCStaticsNode.GetMangledName(type, factory.NameMangler));`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`public override ISortableSymbolNode ImportedNonGCStaticNode(NodeFactory factory, MetadataType type)`
`22`	`22`	`{`
`23`		`- return new ExternSymbolNode(NonGCStaticsNode.GetMangledName(type, factory.NameMangler));`
	`23`	`+ return new ExternDataSymbolNode(NonGCStaticsNode.GetMangledName(type, factory.NameMangler));`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`public override ISortableSymbolNode ImportedMethodDictionaryNode(NodeFactory factory, MethodDesc method)`
Original file line number	Diff line number	Diff line change
`@@ -728,7 +728,7 @@ public ObjectAllocatorGenericLookupResult(TypeDesc type)`
`728`	`728`	`public override ISymbolNode GetTarget(NodeFactory factory, GenericLookupResultContext dictionary)`
`729`	`729`	`{`
`730`	`730`	`TypeDesc instantiatedType = _type.GetNonRuntimeDeterminedTypeFromRuntimeDeterminedSubtypeViaSubstitution(dictionary.TypeInstantiation, dictionary.MethodInstantiation);`
`731`		`- return factory.ExternSymbol(JitHelper.GetNewObjectHelperForType(instantiatedType));`
	`731`	`+ return factory.ExternFunctionSymbol(JitHelper.GetNewObjectHelperForType(instantiatedType));`
`732`	`732`	`}`
`733`	`733`
`734`	`734`	`public override void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public NodeFactory(`
`46`	`46`	`{`
`47`	`47`	`_target = context.Target;`
`48`	`48`
`49`		`- InitialInterfaceDispatchStub = new AddressTakenExternSymbolNode("RhpInitialDynamicInterfaceDispatch");`
	`49`	`+ InitialInterfaceDispatchStub = new AddressTakenExternFunctionSymbolNode("RhpInitialDynamicInterfaceDispatch");`
`50`	`50`
`51`	`51`	`_context = context;`
`52`	`52`	`_compilationModuleGroup = compilationModuleGroup;`
`@@ -263,13 +263,17 @@ private void CreateNodeCaches()`
`263`	`263`	`return new FieldRvaDataNode(key);`
`264`	`264`	`});`
`265`	`265`
`266`		`- _externSymbols = new NodeCache<string, ExternSymbolNode>((string name) =>`
	`266`	`+ _externFunctionSymbols = new NodeCache<string, ExternFunctionSymbolNode>((string name) =>`
`267`	`267`	`{`
`268`		`- return new ExternSymbolNode(name);`
	`268`	`+ return new ExternFunctionSymbolNode(name);`
`269`	`269`	`});`
`270`		`- _externIndirectSymbols = new NodeCache<string, ExternSymbolNode>((string name) =>`
	`270`	`+ _externIndirectFunctionSymbols = new NodeCache<string, ExternFunctionSymbolNode>((string name) =>`
`271`	`271`	`{`
`272`		`- return new ExternSymbolNode(name, isIndirection: true);`
	`272`	`+ return new ExternFunctionSymbolNode(name, isIndirection: true);`
	`273`	`+ });`
	`274`	`+ _externDataSymbols = new NodeCache<string, ExternDataSymbolNode>((string name) =>`
	`275`	`+ {`
	`276`	`+ return new ExternDataSymbolNode(name);`
`273`	`277`	`});`
`274`	`278`
`275`	`279`	`_pInvokeModuleFixups = new NodeCache<PInvokeModuleData, PInvokeModuleFixupNode>((PInvokeModuleData moduleData) =>`
`@@ -793,7 +797,7 @@ public ISortableSymbolNode TypeThreadStaticIndex(MetadataType type)`
`793`	`797`	`}`
`794`	`798`	`else`
`795`	`799`	`{`
`796`		`- return ExternSymbol(NameMangler.NodeMangler.ThreadStaticsIndex(type));`
	`800`	`+ return ExternDataSymbol(NameMangler.NodeMangler.ThreadStaticsIndex(type));`
`797`	`801`	`}`
`798`	`802`	`}`
`799`	`803`
`@@ -903,24 +907,31 @@ internal ISymbolNode GenericVariance(GenericVarianceDetails details)`
`903`	`907`	`return _genericVariances.GetOrAdd(details);`
`904`	`908`	`}`
`905`	`909`
`906`		`- private NodeCache<string, ExternSymbolNode> _externSymbols;`
	`910`	`+ private NodeCache<string, ExternFunctionSymbolNode> _externFunctionSymbols;`
`907`	`911`
`908`		`- public ISortableSymbolNode ExternSymbol(string name)`
	`912`	`+ public ISortableSymbolNode ExternFunctionSymbol(string name)`
`909`	`913`	`{`
`910`		`- return _externSymbols.GetOrAdd(name);`
	`914`	`+ return _externFunctionSymbols.GetOrAdd(name);`
`911`	`915`	`}`
`912`	`916`
`913`		`- public ISortableSymbolNode ExternVariable(string name)`
	`917`	`+ private NodeCache<string, ExternFunctionSymbolNode> _externIndirectFunctionSymbols;`
	`918`	`+`
	`919`	`+ public ISortableSymbolNode ExternIndirectFunctionSymbol(string name)`
`914`	`920`	`{`
`915`		`- string mangledName = NameMangler.NodeMangler.ExternVariable(name);`
`916`		`- return _externSymbols.GetOrAdd(mangledName);`
	`921`	`+ return _externIndirectFunctionSymbols.GetOrAdd(name);`
`917`	`922`	`}`
`918`	`923`
`919`		`- private NodeCache<string, ExternSymbolNode> _externIndirectSymbols;`
	`924`	`+ private NodeCache<string, ExternDataSymbolNode> _externDataSymbols;`
`920`	`925`
`921`		`- public ISortableSymbolNode ExternIndirectSymbol(string name)`
	`926`	`+ public ISortableSymbolNode ExternDataSymbol(string name)`
	`927`	`+ {`
	`928`	`+ string mangledName = NameMangler.NodeMangler.ExternVariable(name);`
	`929`	`+ return _externDataSymbols.GetOrAdd(mangledName);`
	`930`	`+ }`
	`931`	`+`
	`932`	`+ public ISortableSymbolNode ExternVariable(string name)`
`922`	`933`	`{`
`923`		`- return _externIndirectSymbols.GetOrAdd(name);`
	`934`	`+ return _externDataSymbols.GetOrAdd(name);`
`924`	`935`	`}`
`925`	`936`
`926`	`937`	`private NodeCache<PInvokeModuleData, PInvokeModuleFixupNode> _pInvokeModuleFixups;`
Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ protected override void EmitCode(NodeFactory factory, ref ARMEmitter encoder, bo`
`128`	`128`	`if (targetMethod.OwningType.IsInterface)`
`129`	`129`	`{`
`130`	`130`	`encoder.EmitMOV(encoder.TargetRegister.Arg1, factory.InterfaceDispatchCell(targetMethod));`
`131`		`- encoder.EmitJMP(factory.ExternSymbol("RhpResolveInterfaceMethod"));`
	`131`	`+ encoder.EmitJMP(factory.ExternFunctionSymbol("RhpResolveInterfaceMethod"));`
`132`	`132`	`}`
`133`	`133`	`else`
`134`	`134`	`{`
Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ protected override void EmitCode(NodeFactory factory, ref ARM64Emitter encoder,`
`144`	`144`	`if (targetMethod.OwningType.IsInterface)`
`145`	`145`	`{`
`146`	`146`	`encoder.EmitMOV(encoder.TargetRegister.Arg1, factory.InterfaceDispatchCell(targetMethod));`
`147`		`- encoder.EmitJMP(factory.ExternSymbol("RhpResolveInterfaceMethod"));`
	`147`	`+ encoder.EmitJMP(factory.ExternFunctionSymbol("RhpResolveInterfaceMethod"));`
`148`	`148`	`}`
`149`	`149`	`else`
`150`	`150`	`{`