[NativeAOT-LLVM] Port the ExternSymbolNode change (#3131)

SingleAccretion · web-flow · commit ce33e12937b9 · 2025-07-12T22:13:31.000-07:00
* [NativeAOT] Split `ExternSymbolNode` into two types for data and functions (#117346)

This allows to distinguish the symbol type for a node with a simple type check.

* NAOT-LLVM fixes
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Compilation.cs
@@ -329,7 +329,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 derive 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;
@@ -31,6 +33,7 @@ public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
         {
             sb.Append(_name);
         }
+
         public int Offset => 0;
         public virtual bool RepresentsIndirectionCell => _isIndirection;
 
@@ -44,8 +47,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);
@@ -58,11 +59,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
@@ -735,7 +735,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
@@ -45,7 +45,7 @@ public NodeFactory(
         {
             _target = context.Target;
 
-            InitialInterfaceDispatchStub = new AddressTakenExternSymbolNode("RhpInitialDynamicInterfaceDispatch");
+            InitialInterfaceDispatchStub = new AddressTakenExternFunctionSymbolNode("RhpInitialDynamicInterfaceDispatch");
 
             _context = context;
             _compilationModuleGroup = compilationModuleGroup;
@@ -256,13 +256,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) =>
@@ -762,7 +766,7 @@ public ISortableSymbolNode TypeThreadStaticIndex(MetadataType type)
             }
             else
             {
-                return ExternSymbol(NameMangler.NodeMangler.ThreadStaticsIndex(type));
+                return ExternDataSymbol(NameMangler.NodeMangler.ThreadStaticsIndex(type));
             }
         }
 
@@ -872,24 +876,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)
         {
-            return _externIndirectSymbols.GetOrAdd(name);
+            return _externDataSymbols.GetOrAdd(name);
+        }
+
+        public ISortableSymbolNode ExternVariable(string name)
+        {
+            string mangledName = NameMangler.NodeMangler.ExternVariable(name);
+            return _externDataSymbols.GetOrAdd(mangledName);
         }
 
         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
@@ -147,7 +147,7 @@ protected override void EmitCode(NodeFactory factory, ref ARM64Emitter encoder,
                             encoder.EmitINT3();
 
                             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
@@ -139,7 +139,7 @@ protected override void EmitCode(NodeFactory factory, ref LoongArch64Emitter enc
                             encoder.EmitBreak();
 
                             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
@@ -137,7 +137,7 @@ protected override void EmitCode(NodeFactory factory, ref RiscV64Emitter encoder
                             encoder.EmitBreak();
 
                             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_Wasm/MetadataManager.Wasm.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_Wasm/MetadataManager.Wasm.cs
@@ -86,6 +86,6 @@ private static bool IsPossibleDelegateTarget(NodeFactory factory, IWasmMethodCod
     public partial class ObjectDataInterner
     {
         public static ObjectDataInterner NullWithTracking { get; } =
-            new ObjectDataInterner() { _symbolRemapping = new() { [new ExternSymbolNode("")] = null } };
+            new ObjectDataInterner() { _symbolRemapping = new() { [new ExternFunctionSymbolNode("")] = null } };
     }
 }
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_Wasm/WasmFunctionType.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_Wasm/WasmFunctionType.cs
@@ -27,7 +27,8 @@ public override int GetHashCode()
             return hash.ToHashCode();
         }
 
-        public static bool IsFunction(ISymbolNode symbol) => symbol is ExternSymbolNode or IWasmFunctionNode or IMethodNode { Offset: 0 };
+        public static bool IsFunction(ISymbolNode symbol) =>
+            symbol is ExternFunctionSymbolNode or IWasmFunctionNode or IMethodNode { Offset: 0 };
 
         public static bool Equals(WasmFunctionType type, WasmValueType result, ReadOnlySpan<WasmValueType> parameters) =>
             type._result == result && type.Parameters.SequenceEqual(parameters);
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
@@ -198,7 +198,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
@@ -476,7 +476,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.LLVM/CodeGen/WasmObjectWriter.EmitObject.cs b/src/coreclr/tools/aot/ILCompiler.LLVM/CodeGen/WasmObjectWriter.EmitObject.cs
@@ -90,7 +90,7 @@ private sealed class StackTraceIpCanaryNode : ObjectNode, ISymbolDefinitionNode
             public override ObjectData GetData(NodeFactory factory, bool relocsOnly)
             {
                 byte[] data = new byte[4];
-                ExternSymbolNode canary = new ExternSymbolNode("RhpGetStackTraceIpCanary");
+                ExternFunctionSymbolNode canary = new ExternFunctionSymbolNode("RhpGetStackTraceIpCanary");
                 Relocation reloc = new Relocation(RelocType.R_WASM_FUNCTION_INDEX_I32, 0, canary);
                 return new ObjectData(data, [reloc], data.Length, [this]);
             }
diff --git a/src/coreclr/tools/aot/ILCompiler.LLVM/CodeGen/WasmObjectWriter.cs b/src/coreclr/tools/aot/ILCompiler.LLVM/CodeGen/WasmObjectWriter.cs
@@ -819,13 +819,12 @@ public readonly WasmFunctionType GetFunctionType(NodeFactory factory)
                     case IMethodNode methodNode:
                         return WasmAbi.GetWasmFunctionType(methodNode.Method);
                     default:
-                        // We assume extenal symbol nodes are functions. This is rather fragile, but handling this precisely
-                        // would require modifying producers of these nodes to provide more information (namely, the signature
-                        // for function symbols).
+                        // The below is rather fragile, but handling this precisely would require modifying producers of
+                        // these nodes to provide more information (namely, the signature for function symbols).
                         // TODO-LLVM-Bug: depending on the order symbols are encountered, this hack could lead to problems.
                         // E. g. a "naked" RhpNewFast, then a "properly typed" RhpNewFast runtime import. However, the linker
                         // can tolerate mismatches, so as long as the problematic functions aren't called directly...
-                        Debug.Assert(Symbol is ExternSymbolNode);
+                        Debug.Assert(Symbol is ExternFunctionSymbolNode);
                         return new WasmFunctionType(WasmValueType.Invalid, []);
                 }
             }
diff --git a/src/coreclr/tools/aot/ILCompiler.LLVM/Compiler/DependencyAnalysis/ExternMethodCellNode.cs b/src/coreclr/tools/aot/ILCompiler.LLVM/Compiler/DependencyAnalysis/ExternMethodCellNode.cs
@@ -143,7 +143,7 @@ public override int CompareToImpl(ISortableNode other, CompilerComparer comparer
         protected override string GetName(NodeFactory context) => $"{nameof(ExternMethodCellNode)} {ExternMethodName}";
     }
 
-    internal sealed class ExternWasmMethodNode(ExternMethodCellNode methodCell) : ExternSymbolNode(methodCell.ExternMethodName), IWasmFunctionNode
+    internal sealed class ExternWasmMethodNode(ExternMethodCellNode methodCell) : ExternFunctionSymbolNode(methodCell.ExternMethodName), IWasmFunctionNode
     {
         private readonly ExternMethodCellNode _methodCell = methodCell;
 
diff --git a/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.Llvm.cs b/src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.Llvm.cs
@@ -112,7 +112,7 @@ public static int getSignatureForMethodSymbol(IntPtr thisHandle, void* symbolHan
 
             // TODO-LLVM: below is a hack. A proper solution would involve upstream work to allow ExternSymbolNode
             // to specify whether it represents a function or data symbol (and what its signature is if the former).
-            if (node is ExternSymbolNode externSymbolNode)
+            if (node is ExternFunctionSymbolNode externSymbolNode)
             {
                 ReadOnlySpan<byte> name = externSymbolNode.Utf8Name.AsSpan();
                 if (name.StartsWith("RhpNew"u8))
@@ -187,7 +187,7 @@ private static CorInfoLlvmEHModel getExceptionHandlingModel(IntPtr thisHandle)
         private static IntPtr getExceptionThrownVariable(IntPtr thisHandle)
         {
             CorInfoImpl _this = GetThis(thisHandle);
-            ISymbolNode node = _this._compilation.NodeFactory.ExternSymbol("RhpExceptionThrown");
+            ISymbolNode node = _this._compilation.NodeFactory.ExternDataSymbol("RhpExceptionThrown");
             return _this.ObjectToHandle(node);
         }
 
@@ -277,7 +277,7 @@ private ObjectData GetLlvmEHInfo(CORINFO_LLVM_EH_CLAUSE* pClauses, int count, ou
                 if ((pClause->Flags & CORINFO_EH_CLAUSE_FLAGS.CORINFO_EH_CLAUSE_FILTER) != 0)
                 {
                     GetMangledFilterFuncletName(sb, pClause->FilterIndex);
-                    symbol = factory.ExternSymbol(sb.ToString());
+                    symbol = factory.ExternFunctionSymbol(sb.ToString());
                 }
                 else
                 {
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
`@@ -329,7 +329,7 @@ public ISymbolNode ComputeConstantLookup(ReadyToRunHelperId lookupKind, object t`
`329`	`329`	`case ReadyToRunHelperId.ObjectAllocator:`
`330`	`330`	`{`
`331`	`331`	`var type = (TypeDesc)targetOfLookup;`
`332`		`- return NodeFactory.ExternSymbol(JitHelper.GetNewObjectHelperForType(type));`
	`332`	`+ return NodeFactory.ExternFunctionSymbol(JitHelper.GetNewObjectHelperForType(type));`
`333`	`333`	`}`
`334`	`334`
`335`	`335`	`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 derive 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;`
`@@ -31,6 +33,7 @@ public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)`
`31`	`33`	`{`
`32`	`34`	`sb.Append(_name);`
`33`	`35`	`}`
	`36`	`+`
`34`	`37`	`public int Offset => 0;`
`35`	`38`	`public virtual bool RepresentsIndirectionCell => _isIndirection;`
`36`	`39`
`@@ -44,8 +47,6 @@ public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)`
`44`	`47`	`public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory factory) => null;`
`45`	`48`
`46`	`49`	`#if !SUPPORT_JIT`
`47`		`- public override int ClassCode => 1092559304;`
`48`		`-`
`49`	`50`	`public override int CompareToImpl(ISortableNode other, CompilerComparer comparer)`
`50`	`51`	`{`
`51`	`52`	`return _name.CompareTo(((ExternSymbolNode)other)._name);`
`@@ -58,11 +59,26 @@ public override string ToString()`
`58`	`59`	`}`
`59`	`60`	`}`
`60`	`61`
`61`		`- public class AddressTakenExternSymbolNode : ExternSymbolNode`
	`62`	`+ /// <summary>`
	`63`	`+ /// Represents a function symbol that is defined externally and statically linked to the output obj file.`
	`64`	`+ /// </summary>`
	`65`	`+ public class ExternFunctionSymbolNode(Utf8String name, bool isIndirection = false) : ExternSymbolNode(name, isIndirection)`
`62`	`66`	`{`
`63`		`- public AddressTakenExternSymbolNode(Utf8String name)`
`64`		`- : base(name) { }`
	`67`	`+ public override int ClassCode => 1452455506;`
	`68`	`+ }`
`65`	`69`
	`70`	`+ public class AddressTakenExternFunctionSymbolNode(Utf8String name) : ExternFunctionSymbolNode(name)`
	`71`	`+ {`
`66`	`72`	`public override int ClassCode => -45645737;`
`67`	`73`	`}`
	`74`	`+`
	`75`	`+ /// <summary>`
	`76`	`+ /// Represents a data symbol that is defined externally and statically linked to the output obj file.`
	`77`	`+ /// </summary>`
	`78`	`+ public class ExternDataSymbolNode(Utf8String name) : ExternSymbolNode(name)`
	`79`	`+ {`
	`80`	`+ public override int ClassCode => 1428609964;`
	`81`	`+`
	`82`	`+ protected override string GetName(NodeFactory factory) => $"ExternDataSymbolNode {ToString()}";`
	`83`	`+ }`
`68`	`84`	`}`
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
`@@ -735,7 +735,7 @@ public ObjectAllocatorGenericLookupResult(TypeDesc type)`
`735`	`735`	`public override ISymbolNode GetTarget(NodeFactory factory, GenericLookupResultContext dictionary)`
`736`	`736`	`{`
`737`	`737`	`TypeDesc instantiatedType = _type.GetNonRuntimeDeterminedTypeFromRuntimeDeterminedSubtypeViaSubstitution(dictionary.TypeInstantiation, dictionary.MethodInstantiation);`
`738`		`- return factory.ExternSymbol(JitHelper.GetNewObjectHelperForType(instantiatedType));`
	`738`	`+ return factory.ExternFunctionSymbol(JitHelper.GetNewObjectHelperForType(instantiatedType));`
`739`	`739`	`}`
`740`	`740`
`741`	`741`	`public override void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public NodeFactory(`
`45`	`45`	`{`
`46`	`46`	`_target = context.Target;`
`47`	`47`
`48`		`- InitialInterfaceDispatchStub = new AddressTakenExternSymbolNode("RhpInitialDynamicInterfaceDispatch");`
	`48`	`+ InitialInterfaceDispatchStub = new AddressTakenExternFunctionSymbolNode("RhpInitialDynamicInterfaceDispatch");`
`49`	`49`
`50`	`50`	`_context = context;`
`51`	`51`	`_compilationModuleGroup = compilationModuleGroup;`
`@@ -256,13 +256,17 @@ private void CreateNodeCaches()`
`256`	`256`	`return new FieldRvaDataNode(key);`
`257`	`257`	`});`
`258`	`258`
`259`		`- _externSymbols = new NodeCache<string, ExternSymbolNode>((string name) =>`
	`259`	`+ _externFunctionSymbols = new NodeCache<string, ExternFunctionSymbolNode>((string name) =>`
`260`	`260`	`{`
`261`		`- return new ExternSymbolNode(name);`
	`261`	`+ return new ExternFunctionSymbolNode(name);`
`262`	`262`	`});`
`263`		`- _externIndirectSymbols = new NodeCache<string, ExternSymbolNode>((string name) =>`
	`263`	`+ _externIndirectFunctionSymbols = new NodeCache<string, ExternFunctionSymbolNode>((string name) =>`
`264`	`264`	`{`
`265`		`- return new ExternSymbolNode(name, isIndirection: true);`
	`265`	`+ return new ExternFunctionSymbolNode(name, isIndirection: true);`
	`266`	`+ });`
	`267`	`+ _externDataSymbols = new NodeCache<string, ExternDataSymbolNode>((string name) =>`
	`268`	`+ {`
	`269`	`+ return new ExternDataSymbolNode(name);`
`266`	`270`	`});`
`267`	`271`
`268`	`272`	`_pInvokeModuleFixups = new NodeCache<PInvokeModuleData, PInvokeModuleFixupNode>((PInvokeModuleData moduleData) =>`
`@@ -762,7 +766,7 @@ public ISortableSymbolNode TypeThreadStaticIndex(MetadataType type)`
`762`	`766`	`}`
`763`	`767`	`else`
`764`	`768`	`{`
`765`		`- return ExternSymbol(NameMangler.NodeMangler.ThreadStaticsIndex(type));`
	`769`	`+ return ExternDataSymbol(NameMangler.NodeMangler.ThreadStaticsIndex(type));`
`766`	`770`	`}`
`767`	`771`	`}`
`768`	`772`
`@@ -872,24 +876,31 @@ internal ISymbolNode GenericVariance(GenericVarianceDetails details)`
`872`	`876`	`return _genericVariances.GetOrAdd(details);`
`873`	`877`	`}`
`874`	`878`
`875`		`- private NodeCache<string, ExternSymbolNode> _externSymbols;`
	`879`	`+ private NodeCache<string, ExternFunctionSymbolNode> _externFunctionSymbols;`
`876`	`880`
`877`		`- public ISortableSymbolNode ExternSymbol(string name)`
	`881`	`+ public ISortableSymbolNode ExternFunctionSymbol(string name)`
`878`	`882`	`{`
`879`		`- return _externSymbols.GetOrAdd(name);`
	`883`	`+ return _externFunctionSymbols.GetOrAdd(name);`
`880`	`884`	`}`
`881`	`885`
`882`		`- public ISortableSymbolNode ExternVariable(string name)`
	`886`	`+ private NodeCache<string, ExternFunctionSymbolNode> _externIndirectFunctionSymbols;`
	`887`	`+`
	`888`	`+ public ISortableSymbolNode ExternIndirectFunctionSymbol(string name)`
`883`	`889`	`{`
`884`		`- string mangledName = NameMangler.NodeMangler.ExternVariable(name);`
`885`		`- return _externSymbols.GetOrAdd(mangledName);`
	`890`	`+ return _externIndirectFunctionSymbols.GetOrAdd(name);`
`886`	`891`	`}`
`887`	`892`
`888`		`- private NodeCache<string, ExternSymbolNode> _externIndirectSymbols;`
	`893`	`+ private NodeCache<string, ExternDataSymbolNode> _externDataSymbols;`
`889`	`894`
`890`		`- public ISortableSymbolNode ExternIndirectSymbol(string name)`
	`895`	`+ public ISortableSymbolNode ExternDataSymbol(string name)`
`891`	`896`	`{`
`892`		`- return _externIndirectSymbols.GetOrAdd(name);`
	`897`	`+ return _externDataSymbols.GetOrAdd(name);`
	`898`	`+ }`
	`899`	`+`
	`900`	`+ public ISortableSymbolNode ExternVariable(string name)`
	`901`	`+ {`
	`902`	`+ string mangledName = NameMangler.NodeMangler.ExternVariable(name);`
	`903`	`+ return _externDataSymbols.GetOrAdd(mangledName);`
`893`	`904`	`}`
`894`	`905`
`895`	`906`	`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
`@@ -147,7 +147,7 @@ protected override void EmitCode(NodeFactory factory, ref ARM64Emitter encoder,`
`147`	`147`	`encoder.EmitINT3();`
`148`	`148`
`149`	`149`	`encoder.EmitMOV(encoder.TargetRegister.Arg1, factory.InterfaceDispatchCell(targetMethod));`
`150`		`- encoder.EmitJMP(factory.ExternSymbol("RhpResolveInterfaceMethod"));`
	`150`	`+ encoder.EmitJMP(factory.ExternFunctionSymbol("RhpResolveInterfaceMethod"));`
`151`	`151`	`}`
`152`	`152`	`else`
`153`	`153`	`{`