Initial interpreter wire-in (#112202)

* Initial interpreter wire-in

This change adds initial support for a new interpreter to coreclr. The
interpreter will have a compilation phase that generates an IR byte code
and will behave as a JIT. This change allows the runtime to understand
that the generated code is an interpreter IR and when runtime attempts
to execute such a method, it calls into the ExecuteInterpretedMethod.
This will call into the interpreter execution code once the actual
interpreter is merged in.
The change uses the StubPrecode and FixupPrecode as a mean to call the
InterpreterStub with a special register loaded with a pointer to the
IR byte code of the methods and TransitionFrame to get the arguments
from. So instead of MethodDesc, the stub data holds the IR address and
instead of the usual generated code target, it holds the
InterpreterStub. There is a small twist for FixupPrecode. This precode
has two parts ensuring that we load the MethodDesc into the special
register only at the first call when we need to know what method we are
going to compile. In follow up calls, it invokes the target directly
without loading that register. For interpreter, it is always kept in the
state of going through the register loading path so that the interpreter
execution knows what to run.
The plan is to use AltJit mechanism to load the interpreter during its
development. That allows us to interpret only a subset of the methods
and fall back to JIT for the ones we cannot interpret yet.

* Fix incorrect lookup for CodeHeader

Found by PR feedback, instead of InterpretedCodeAddressFlag, it was
using 1.

* Add new precode type for interpreter

* Put all interpreter related code under #ifdef

Also enable the interpreter in debug / checked builds only by default

* Fix OSX x64 build break

Author: janvorli

src/coreclr/clrdefinitions.cmake

@@ -126,6 +126,8 @@ if (CLR_CMAKE_TARGET_WIN32 AND (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_
     add_definitions(-DFEATURE_INTEROP_DEBUGGING)
 endif (CLR_CMAKE_TARGET_WIN32 AND (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386 OR CLR_CMAKE_TARGET_ARCH_ARM64))
 
+add_compile_definitions($<${FEATURE_INTERPRETER}:FEATURE_INTERPRETER>)
+
 if (CLR_CMAKE_TARGET_WIN32)
     add_definitions(-DFEATURE_ISYM_READER)
 endif(CLR_CMAKE_TARGET_WIN32)

src/coreclr/clrfeatures.cmake

@@ -16,6 +16,14 @@ if(NOT DEFINED FEATURE_DBGIPC)
   endif()
 endif(NOT DEFINED FEATURE_DBGIPC)
 
+if(NOT DEFINED FEATURE_INTERPRETER)
+  if(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM64)
+    set(FEATURE_INTERPRETER $<IF:$<CONFIG:Debug,Checked>,1,0>)
+  else(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM64)
+    set(FEATURE_INTERPRETER 0)
+  endif(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM64)
+endif(NOT DEFINED FEATURE_INTERPRETER)
+
 if(NOT DEFINED FEATURE_STANDALONE_GC)
   set(FEATURE_STANDALONE_GC 1)
 endif(NOT DEFINED FEATURE_STANDALONE_GC)

src/coreclr/inc/corinfo.h

@@ -786,7 +786,7 @@ enum CorInfoFlag
 enum CorInfoMethodRuntimeFlags
 {
     CORINFO_FLG_BAD_INLINEE         = 0x00000001, // The method is not suitable for inlining
-    // unused                       = 0x00000002,
+    CORINFO_FLG_INTERPRETER         = 0x00000002, // The method was compiled by the interpreter
     // unused                       = 0x00000004,
     CORINFO_FLG_SWITCHED_TO_MIN_OPT = 0x00000008, // The JIT decided to switch to MinOpt for this method, when it was not requested
     CORINFO_FLG_SWITCHED_TO_OPTIMIZED = 0x00000010, // The JIT decided to switch to tier 1 for this method, when a different tier was requested

src/coreclr/vm/amd64/AsmHelpers.asm

@@ -11,6 +11,9 @@ extern  ProfileLeave:proc
 extern  ProfileTailcall:proc
 extern OnHijackWorker:proc
 extern JIT_RareDisableHelperWorker:proc
+ifdef FEATURE_INTERPRETER
+extern ExecuteInterpretedMethod:proc
+endif
 
 extern g_pPollGC:QWORD
 extern g_TrapReturningThreads:DWORD
@@ -477,4 +480,21 @@ JIT_PollGCRarePath:
     TAILJMP_RAX
 LEAF_END JIT_PollGC, _TEXT
 
+ifdef FEATURE_INTERPRETER
+NESTED_ENTRY InterpreterStub, _TEXT
+
+        PROLOG_WITH_TRANSITION_BLOCK
+
+        ;
+        ; call ExecuteInterpretedMethod
+        ;
+        lea             rcx, [rsp + __PWTB_TransitionBlock]     ; pTransitionBlock*
+        mov             rdx, METHODDESC_REGISTER
+        call            ExecuteInterpretedMethod
+
+        EPILOG_WITH_TRANSITION_BLOCK_RETURN
+
+NESTED_END InterpreterStub, _TEXT
+endif ; FEATURE_INTERPRETER
+
         end

src/coreclr/vm/amd64/asmhelpers.S

@@ -333,3 +333,22 @@ LOCAL_LABEL(JIT_PollGCRarePath):
         mov     rax, [rax]
         jmp     rax
 LEAF_END  JIT_PollGC, _TEXT
+
+#ifdef FEATURE_INTERPRETER
+NESTED_ENTRY InterpreterStub, _TEXT, NoHandler
+
+        PROLOG_WITH_TRANSITION_BLOCK 8, 0, 0, 0, 0
+        mov             [rsp], rax // Return buffer in Swift calling convention
+
+        #
+        # call ExecuteInterpretedMethod
+        #
+        lea             rdi, [rsp + __PWTB_TransitionBlock]     // pTransitionBlock*
+        mov             rsi, METHODDESC_REGISTER
+        call            C_FUNC(ExecuteInterpretedMethod)
+
+        mov             rax, [rsp]
+        EPILOG_WITH_TRANSITION_BLOCK_RETURN
+
+NESTED_END InterpreterStub, _TEXT
+#endif // FEATURE_INTERPRETER

src/coreclr/vm/arm64/asmhelpers.S

@@ -835,3 +835,18 @@ LOCAL_LABEL(JIT_PollGCRarePath):
         ldr     x9, [x9]
         br x9
 LEAF_END  JIT_PollGC, _TEXT
+
+#ifdef FEATURE_INTERPRETER
+NESTED_ENTRY InterpreterStub, _TEXT, NoHandler
+
+    PROLOG_WITH_TRANSITION_BLOCK
+
+    add x0, sp, #__PWTB_TransitionBlock // pTransitionBlock
+    mov x1, METHODDESC_REGISTER // pMethodDesc
+
+    bl  C_FUNC(ExecuteInterpretedMethod)
+
+    EPILOG_WITH_TRANSITION_BLOCK_RETURN
+
+NESTED_END InterpreterStub, _TEXT
+#endif // FEATURE_INTERPRETER

src/coreclr/vm/arm64/asmhelpers.asm

@@ -21,6 +21,9 @@
 #endif
     IMPORT HijackHandler
     IMPORT ThrowControlForThread
+#ifdef FEATURE_INTERPRETER
+    IMPORT ExecuteInterpretedMethod
+#endif
 
 #ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
     IMPORT  g_sw_ww_table
@@ -1211,6 +1214,20 @@ JIT_PollGCRarePath
         br x9
     LEAF_END
 
+#ifdef FEATURE_INTERPRETER
+    NESTED_ENTRY InterpreterStub
+
+        PROLOG_WITH_TRANSITION_BLOCK
+
+        add         x0, sp, #__PWTB_TransitionBlock ; pTransitionBlock
+        mov         x1, METHODDESC_REGISTER         ; pMethodDesc
+
+        bl          ExecuteInterpretedMethod
+
+        EPILOG_WITH_TRANSITION_BLOCK_RETURN
+
+    NESTED_END
+#endif // FEATURE_INTERPRETER
 
 ; Must be at very end of file
     END

src/coreclr/vm/jitinterface.cpp

@@ -6611,7 +6611,11 @@ void CEEInfo::setMethodAttribs (
         ftn->SetNotInline(true);
     }
 
-    if (attribs & (CORINFO_FLG_SWITCHED_TO_OPTIMIZED | CORINFO_FLG_SWITCHED_TO_MIN_OPT))
+    if (attribs & (CORINFO_FLG_SWITCHED_TO_OPTIMIZED | CORINFO_FLG_SWITCHED_TO_MIN_OPT
+#ifdef FEATURE_INTERPRETER
+     | CORINFO_FLG_INTERPRETER
+#endif // FEATURE_INTERPRETER
+     ))
     {
         PrepareCodeConfig *config = GetThread()->GetCurrentPrepareCodeConfig();
         if (config != nullptr)
@@ -6621,6 +6625,12 @@ void CEEInfo::setMethodAttribs (
                 _ASSERTE(!ftn->IsJitOptimizationDisabled());
                 config->SetJitSwitchedToMinOpt();
             }
+#ifdef FEATURE_INTERPRETER
+            else if (attribs & CORINFO_FLG_INTERPRETER)
+            {
+                config->SetIsInterpreterCode();
+            }
+#endif // FEATURE_INTERPRETER
 #ifdef FEATURE_TIERED_COMPILATION
             else if (attribs & CORINFO_FLG_SWITCHED_TO_OPTIMIZED)
             {

src/coreclr/vm/method.hpp

@@ -2060,6 +2060,20 @@ class PrepareCodeConfig
         m_jitSwitchedToMinOpt = true;
     }
 
+#ifdef FEATURE_INTERPRETER
+    void SetIsInterpreterCode()
+    {
+        LIMITED_METHOD_CONTRACT;
+        m_isInterpreterCode = true;
+    }
+
+    bool IsInterpreterCode() const
+    {
+        LIMITED_METHOD_CONTRACT;
+        return m_isInterpreterCode;
+    }
+#endif // FEATURE_INTERPRETER
+
 #ifdef FEATURE_TIERED_COMPILATION
 public:
     bool JitSwitchedToOptimized() const
@@ -2128,6 +2142,9 @@ class PrepareCodeConfig
 #ifdef FEATURE_TIERED_COMPILATION
     bool m_jitSwitchedToOptimized; // when a different tier was requested
 #endif
+#ifdef FEATURE_INTERPRETER
+    bool m_isInterpreterCode; // The generated code is interpreter IR
+#endif // FEATURE_INTERPRETER
     PrepareCodeConfig *m_nextInSameThread;
 };
 

src/coreclr/vm/precode.cpp

@@ -184,6 +184,26 @@ PCODE Precode::TryToSkipFixupPrecode(PCODE addr)
 
 #ifndef DACCESS_COMPILE
 
+#ifdef FEATURE_INTERPRETER
+InterpreterPrecode* Precode::AllocateInterpreterPrecode(PCODE byteCode,
+                                                        LoaderAllocator *  pLoaderAllocator,
+                                                        AllocMemTracker *  pamTracker)
+{
+    CONTRACTL
+    {
+        THROWS;
+        GC_NOTRIGGER;
+        MODE_ANY;
+    }
+    CONTRACTL_END;
+
+    SIZE_T size = sizeof(InterpreterPrecode);
+    InterpreterPrecode* pPrecode = (InterpreterPrecode*)pamTracker->Track(pLoaderAllocator->GetNewStubPrecodeHeap()->AllocAlignedMem(size, 1));
+    pPrecode->Init(pPrecode, byteCode);
+    return pPrecode;
+}
+#endif // FEATURE_INTERPRETER
+
 Precode* Precode::Allocate(PrecodeType t, MethodDesc* pMD,
                            LoaderAllocator *  pLoaderAllocator,
                            AllocMemTracker *  pamTracker)
@@ -483,6 +503,18 @@ BOOL StubPrecode::IsStubPrecodeByASM(PCODE addr)
 #endif // TARGET_X86
 }
 
+#ifdef FEATURE_INTERPRETER
+void InterpreterPrecode::Init(InterpreterPrecode* pPrecodeRX, TADDR byteCodeAddr)
+{
+    WRAPPER_NO_CONTRACT;
+    InterpreterPrecodeData *pStubData = GetData();
+
+    pStubData->Target = (PCODE)InterpreterStub;
+    pStubData->ByteCodeAddr = byteCodeAddr;
+    pStubData->Type = InterpreterPrecode::Type;
+}
+#endif // FEATURE_INTERPRETER
+
 #ifdef HAS_NDIRECT_IMPORT_PRECODE
 
 void NDirectImportPrecode::Init(NDirectImportPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)