Early work to make it possible to call the interpreter from ReadyToRun code

cshung · cshung · commit 1651e0f536d5 · 2025-01-06T08:04:03.000-08:00
diff --git a/src/coreclr/inc/readytorun.h b/src/coreclr/inc/readytorun.h
@@ -102,6 +102,7 @@ enum class ReadyToRunSectionType : uint32_t
     MethodIsGenericMap          = 121, // Added in V9.0
     EnclosingTypeMap            = 122, // Added in V9.0
     TypeGenericInfoMap          = 123, // Added in V9.0
+    InterpreterMap              = 124, // Prototype
 
     // If you add a new section consider whether it is a breaking or non-breaking change.
     // Usually it is non-breaking, but if it is preferable to have older runtimes fail
@@ -447,6 +448,8 @@ enum ReadyToRunHelper
     READYTORUN_HELPER_StackProbe                = 0x111,
 
     READYTORUN_HELPER_GetCurrentManagedThreadId = 0x112,
+
+    READYTORUN_HELPER_InterpreterRoutine        = 0x113,
 };
 
 #include "readytoruninstructionset.h"
diff --git a/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs b/src/coreclr/tools/Common/Internal/Runtime/ModuleHeaders.cs
@@ -79,6 +79,7 @@ enum ReadyToRunSectionType
         MethodIsGenericMap = 121, // Added in V9.0
         EnclosingTypeMap = 122, // Added in V9.0
         TypeGenericInfoMap = 123, // Added in V9.0
+        InterpreterMap = 124, // Added for prototyping only
 
         //
         // NativeAOT ReadyToRun sections
diff --git a/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs b/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs
@@ -348,6 +348,9 @@ public enum ReadyToRunHelper
 
         GetCurrentManagedThreadId   = 0x112,
 
+        //Interpreter
+        InterpreterRoutine          = 0x113,
+
         // **********************************************************************************************
         //
         // These are not actually part of the R2R file format. We have them here because it's convenient.
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelayLoadMethodImport.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/DelayLoadMethodImport.cs
@@ -46,6 +46,16 @@ public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFacto
             {
                 yield return entry;
             }
+            
+            // It is possible that an instance of DelayLoadMethodImport is constructed by never get into the graph
+            // So we must delay the construction and rooting of the InterpreterImport
+
+            InterpreterImport _interpreterImport = new InterpreterImport();
+            InterpreterStub _interpreterStub = new InterpreterStub(_interpreterImport);
+            factory.AddInterpreterMapping(this, _interpreterImport, _interpreterStub);
+            yield return new DependencyListEntry(_interpreterImport, "Unused reason 1");
+            yield return new DependencyListEntry(_interpreterStub, "Unused reason 2");
+            yield return new DependencyListEntry(factory.InterpreterMap, "Unused reason 3");
             if (_localMethod != null)
                 yield return new DependencyListEntry(_localMethod, "Local method import");
         }
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InterpreterImport.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InterpreterImport.cs
@@ -0,0 +1,63 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Internal.JitInterface;
+using Internal.Text;
+using Internal.TypeSystem;
+using Internal.ReadyToRunConstants;
+using ILCompiler.DependencyAnalysisFramework;
+using System.Collections.Generic;
+
+namespace ILCompiler.DependencyAnalysis.ReadyToRun
+{
+    // An InterpreterImport simply a pointer sized variable that the 
+    // interpreter stub can use to reference the InterpreterMethodInfo
+    public class InterpreterImport : ObjectNode, ISymbolDefinitionNode
+    {
+        public int _id;
+        public static int id = 1;
+
+        public InterpreterImport()
+        {
+            // TODO, andrewau, we need a mechanism to identify the call sites
+            // using a ID is not going to be deterministic 
+            _id = id++;
+        }
+
+        public override int CompareToImpl(ISortableNode other, CompilerComparer comparer)
+        {
+            return this._id - ((InterpreterImport)(other))._id;
+        }
+
+        public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
+        {
+            ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
+            builder.AddSymbol(this);
+            builder.EmitZeroPointer();
+            return builder.ToObjectData();
+        }
+
+        public int Offset { get; set; }
+
+        public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
+            => sb.Append(nameMangler.CompilationUnitPrefix).Append("InterpreterImport").Append(_id.ToString());
+
+        public override ObjectNodeSection GetSection(NodeFactory factory)
+        {
+            return ObjectNodeSection.DataSection;
+        }
+
+        public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context)
+        {
+            yield break;
+        }
+
+        protected override string GetName(NodeFactory context) => "InterpreterImport";
+
+        public override int ClassCode => 46709394;
+
+        public override bool IsShareable => false;
+
+        public override bool StaticDependenciesAreComputed => true;
+    }
+}
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InterpreterMapNode.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InterpreterMapNode.cs
@@ -0,0 +1,49 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+using Internal.Text;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace ILCompiler.DependencyAnalysis.ReadyToRun
+{
+    public class InterpreterMapNode : HeaderTableNode
+    {
+        public override int ClassCode => 25687179;
+
+        private List<DelayLoadMethodImport> leftItems = new List<DelayLoadMethodImport>();
+        private List<InterpreterStub> lastItems = new List<InterpreterStub>();
+        private List<InterpreterImport> rightItems = new List<InterpreterImport>();
+
+        public void AddMapping(DelayLoadMethodImport left, InterpreterImport right, InterpreterStub last)
+        {
+            // TODO, andrewau, this require proper locking and sorting for multithreaded compilation.
+            // correctness and determinism
+            leftItems.Add(left);
+            rightItems.Add(right);
+            lastItems.Add(last);
+        }
+
+        public override void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
+        {
+            sb.Append(nameMangler.CompilationUnitPrefix);
+            sb.Append("__InterpreterMap"u8);
+        }
+
+        public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
+        {
+            ObjectDataBuilder builder = new ObjectDataBuilder(factory, relocsOnly);
+            builder.AddSymbol(this);
+            for (int i = 0; i < leftItems.Count; i++)
+            {
+                // This will emit the RVAs for these 
+                builder.EmitReloc(leftItems[i], RelocType.IMAGE_REL_FILE_ABSOLUTE);
+                builder.EmitReloc(rightItems[i], RelocType.IMAGE_REL_FILE_ABSOLUTE);
+                builder.EmitReloc(lastItems[i], RelocType.IMAGE_REL_FILE_ABSOLUTE);
+            }
+            return builder.ToObjectData();
+        }
+    }
+}
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InterpreterStub.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InterpreterStub.cs
@@ -0,0 +1,68 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Internal.JitInterface;
+using Internal.Text;
+using Internal.TypeSystem;
+using Internal.ReadyToRunConstants;
+using ILCompiler.DependencyAnalysisFramework;
+using System.Collections.Generic;
+
+// TODO, andrewau, other architectures
+using ILCompiler.DependencyAnalysis.X64;
+
+namespace ILCompiler.DependencyAnalysis.ReadyToRun
+{
+    // An InterpreterStub is a small trampoline that 
+    // 1.) Push the InterpreterMethodInfo to the stack, and
+    // 2.) Jump to the InterpreterMethod
+    public class InterpreterStub : ObjectNode, ISymbolDefinitionNode
+    {
+        public InterpreterImport _interpreterImport;
+
+        public InterpreterStub(InterpreterImport interpreterImport)
+        {
+            _interpreterImport = interpreterImport;
+        }
+
+        public override int CompareToImpl(ISortableNode other, CompilerComparer comparer)
+        {
+            return _interpreterImport._id - ((InterpreterStub)(other))._interpreterImport._id;
+        }
+
+        public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
+        {
+            X64Emitter x64Emitter = new X64Emitter(factory, relocsOnly);
+            x64Emitter.Builder.AddSymbol(this);
+            x64Emitter.EmitMOV(Register.RCX, _interpreterImport);
+            // TODO, andrewau, shouldn't have to do this if we can make node represent redirection cell
+            AddrMode addr = new AddrMode(Register.RCX, null, 0, 0, AddrModeSize.Int64);
+            x64Emitter.EmitMOV(Register.RCX, ref addr);
+            x64Emitter.EmitJMP(factory.InterpreterRoutineImport);
+            return x64Emitter.Builder.ToObjectData();
+        }
+
+        public int Offset { get; set; }
+
+        public void AppendMangledName(NameMangler nameMangler, Utf8StringBuilder sb)
+            => sb.Append(nameMangler.CompilationUnitPrefix).Append("InterpreterStub").Append(_interpreterImport._id.ToString());
+
+        public override ObjectNodeSection GetSection(NodeFactory factory)
+        {
+            return ObjectNodeSection.TextSection;
+        }
+
+        public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory context)
+        {
+            yield break;
+        }
+
+        protected override string GetName(NodeFactory context) => "InterpreterStub";
+
+        public override int ClassCode => 95566084;
+
+        public override bool IsShareable => false;
+
+        public override bool StaticDependenciesAreComputed => true;
+    }
+}
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs
@@ -97,6 +97,16 @@ public void GenerateHotColdMap(DependencyAnalyzerBase<NodeFactory> dependencyGra
                 dependencyGraph.AddRoot(HotColdMap, "HotColdMap is generated because there is cold code");
             }
         }
+        
+        public void AddInterpreterMapping(DelayLoadMethodImport left, InterpreterImport right, InterpreterStub last)
+        {
+            if (InterpreterMap == null)
+            {
+                InterpreterMap = new InterpreterMapNode();
+                Header.Add(Internal.Runtime.ReadyToRunSectionType.InterpreterMap, InterpreterMap, InterpreterMap);
+            }
+            InterpreterMap.AddMapping(left, right, last);
+        }
 
         public void SetMarkingComplete()
         {
@@ -372,6 +382,8 @@ private void CreateNodeCaches()
 
         public HotColdMapNode HotColdMap;
 
+        public InterpreterMapNode InterpreterMap;
+
         public RuntimeFunctionsGCInfoNode RuntimeFunctionsGCInfo;
 
         public DelayLoadMethodCallThunkNodeRange DelayLoadMethodCallThunks;
@@ -387,6 +399,8 @@ private void CreateNodeCaches()
 
         public Import ModuleImport;
 
+        public Import InterpreterRoutineImport;
+
         public ISymbolNode PersonalityRoutine;
 
         public ISymbolNode FilterFuncletPersonalityRoutine;
@@ -803,6 +817,10 @@ public void AttachToDependencyGraph(DependencyAnalyzerBase<NodeFactory> graph, I
                 ReadyToRunHelper.Module));
             graph.AddRoot(ModuleImport, "Module import is required by the R2R format spec");
 
+            InterpreterRoutineImport = new Import(EagerImports, new ReadyToRunHelperSignature(
+                ReadyToRunHelper.InterpreterRoutine));
+            graph.AddRoot(InterpreterRoutineImport, "This allow ready to run code to bail to interpreter");
+
             if (Target.Architecture != TargetArchitecture.X86)
             {
                 Import personalityRoutineImport = new Import(EagerImports, new ReadyToRunHelperSignature(
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ReadyToRunCodegenCompilation.cs
@@ -348,7 +348,8 @@ internal ReadyToRunCodegenCompilation(
         {
             _computedFixedLayoutTypesUncached = IsLayoutFixedInCurrentVersionBubbleInternal;
             _resilient = resilient;
-            _parallelism = parallelism;
+            // TODO, andrewau, until we fix the problem in InterpreterMapNode, this is required
+            _parallelism = 1;
             _corInfoImpls = new CorInfoImpl[_parallelism];
             _generateMapFile = generateMapFile;
             _generateMapCsvFile = generateMapCsvFile;
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/ILCompiler.ReadyToRun.csproj
@@ -193,6 +193,9 @@
     <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\GCRefMapNode.cs" />
     <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\GenericLookupSignature.cs" />
     <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\ImportThunk.cs" />
+    <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\InterpreterImport.cs" />
+    <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\InterpreterMapNode.cs" />
+    <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\InterpreterStub.cs" />
     <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\DelegateCtorSignature.cs" />
     <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\DevirtualizationManager.cs" />
     <Compile Include="Compiler\DependencyAnalysis\ReadyToRun\FieldFixupSignature.cs" />
diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs
@@ -511,6 +511,15 @@ private static mdToken FindGenericMethodArgTypeSpec(EcmaModule module)
 
         public static bool ShouldSkipCompilation(InstructionSetSupport instructionSetSupport, MethodDesc methodNeedingCode)
         {
+            // TODO, andrewau, this will restrict the compilation to only a handful of methods for simplicity only
+            if (
+                !string.Equals(methodNeedingCode.Name, "Setup")
+                &&
+                !string.Equals(methodNeedingCode.Name, "Collatz")
+                )
+            {
+                return true;
+            }
             if (methodNeedingCode.IsAggressiveOptimization)
             {
                 return true;
diff --git a/src/coreclr/vm/interpreter.cpp b/src/coreclr/vm/interpreter.cpp
@@ -12902,7 +12902,7 @@ void Interpreter::PrintILProfile(Interpreter::InstrExecRecord *recs, unsigned in
 }
 #endif // INTERP_ILINSTR_PROFILE
 
-void InterpretCallTarget(PCODE pCallTarget, const ARG_SLOT* pArguments, ARG_SLOT* pReturnValue, int cbReturnValue)
+InterpreterMethodInfo* GetInterpreterMethodInfo(PCODE pCallTarget)
 {
     _ASSERTE(InterpreterPrecode::IsInstance(pCallTarget));
 
@@ -12925,6 +12925,13 @@ void InterpretCallTarget(PCODE pCallTarget, const ARG_SLOT* pArguments, ARG_SLOT
         delete jitInfo;
     }
 
+    return methInfo;
+}
+
+void InterpretCallTarget(PCODE pCallTarget, const ARG_SLOT* pArguments, ARG_SLOT* pReturnValue, int cbReturnValue)
+{
+    InterpreterMethodInfo* methInfo = GetInterpreterMethodInfo(pCallTarget);
+
     ARG_SLOT retVal = Interpreter::InterpretMethodBody(methInfo, true, reinterpret_cast<BYTE*>(const_cast<ARG_SLOT*>(pArguments)), NULL);
     if (pReturnValue != NULL)
         *pReturnValue = retVal;
diff --git a/src/coreclr/vm/interpreter.h b/src/coreclr/vm/interpreter.h
@@ -2098,4 +2098,6 @@ unsigned short Interpreter::NumberOfIntegerRegArgs() { return 8; }
 #error Unsupported architecture.
 #endif
 
+InterpreterMethodInfo* GetInterpreterMethodInfo(PCODE pCallTarget);
+
 #endif  // INTERPRETER_H_DEFINED
diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp
@@ -13788,6 +13788,10 @@ BOOL LoadDynamicInfoEntry(Module *currentModule,
                 case READYTORUN_HELPER_DelayLoad_MethodCall:
                     result = (size_t)GetEEFuncEntryPoint(DelayLoad_MethodCall);
                     break;
+            
+                case READYTORUN_HELPER_InterpreterRoutine:
+                    result = (size_t)GetEEFuncEntryPoint(InterpretMethod);
+                    break;
 
                 case READYTORUN_HELPER_DelayLoad_Helper:
                     result = (size_t)GetEEFuncEntryPoint(DelayLoad_Helper);
diff --git a/src/coreclr/vm/method.cpp b/src/coreclr/vm/method.cpp
@@ -3888,8 +3888,17 @@ PrecodeType MethodDesc::GetPrecodeType()
 
     PrecodeType precodeType = PRECODE_INVALID;
 #ifdef FEATURE_INTERPRETER
-    precodeType = PRECODE_INTERPRETER;
-#else // !FEATURE_INTERPRETER
+    if (
+        !m_pszDebugClassName
+        ||
+        !m_pszDebugClassName
+        ||
+        (strcmp("System.AppContext", m_pszDebugClassName) != 0)
+        || 
+        (strcmp("Collatz", m_pszDebugMethodName) != 0)
+    )
+        return PRECODE_INTERPRETER;
+#endif // FEATURE_INTERPRETER
 #ifdef HAS_FIXUP_PRECODE
     if (!RequiresMethodDescCallingConvention())
     {
@@ -3901,7 +3910,6 @@ PrecodeType MethodDesc::GetPrecodeType()
     {
         precodeType = PRECODE_STUB;
     }
-#endif // FEATURE_INTERPRETER
 
     return precodeType;
 }
diff --git a/src/coreclr/vm/prestub.cpp b/src/coreclr/vm/prestub.cpp
diff --git a/src/coreclr/vm/readytoruninfo.cpp b/src/coreclr/vm/readytoruninfo.cpp
diff --git a/src/coreclr/vm/readytoruninfo.h b/src/coreclr/vm/readytoruninfo.h
diff --git a/src/libraries/System.Private.CoreLib/src/System/AppContext.cs b/src/libraries/System.Private.CoreLib/src/System/AppContext.cs

Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,16 @@ public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFacto`
`46`	`46`	`{`
`47`	`47`	`yield return entry;`
`48`	`48`	`}`
	`49`	`+`
	`50`	`+ // It is possible that an instance of DelayLoadMethodImport is constructed by never get into the graph`
	`51`	`+ // So we must delay the construction and rooting of the InterpreterImport`
	`52`	`+`
	`53`	`+ InterpreterImport _interpreterImport = new InterpreterImport();`
	`54`	`+ InterpreterStub _interpreterStub = new InterpreterStub(_interpreterImport);`
	`55`	`+ factory.AddInterpreterMapping(this, _interpreterImport, _interpreterStub);`
	`56`	`+ yield return new DependencyListEntry(_interpreterImport, "Unused reason 1");`
	`57`	`+ yield return new DependencyListEntry(_interpreterStub, "Unused reason 2");`
	`58`	`+ yield return new DependencyListEntry(factory.InterpreterMap, "Unused reason 3");`
`49`	`59`	`if (_localMethod != null)`
`50`	`60`	`yield return new DependencyListEntry(_localMethod, "Local method import");`
`51`	`61`	`}`