Add new precode type for interpreter

janvorli · janvorli · commit 66dfe948ba53 · 2025-02-06T15:14:40.000+01:00
diff --git a/src/coreclr/inc/utilcode.h b/src/coreclr/inc/utilcode.h
@@ -3969,7 +3969,4 @@ struct SpinConstants
 
 extern SpinConstants g_SpinConstants;
 
-// This value is or-ed to the code address as a marker to indicate it is an address of the interpreter IR bytecode
-static const size_t InterpretedCodeAddressFlag = 2;
-
 #endif // __UtilCode_h__
diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp
@@ -13143,11 +13143,6 @@ PCODE UnsafeJitFunction(PrepareCodeConfig* config,
         ret |= THUMB_CODE;
 #endif
 
-        if (config->IsInterpreterCode())
-        {
-            ret |= InterpretedCodeAddressFlag;
-        }
-
         // We are done
         break;
     }
diff --git a/src/coreclr/vm/method.cpp b/src/coreclr/vm/method.cpp
@@ -3044,7 +3044,7 @@ void MethodDesc::TrySetInitialCodeEntryPointForVersionableMethod(
     else
     {
         _ASSERTE(IsVersionableWithPrecode());
-        GetOrCreatePrecode()->SetTargetInterlocked(entryPoint, TRUE /* fOnlyRedirectFromPrestub */, (entryPoint & InterpretedCodeAddressFlag) /* fInterpreter */);
+        GetOrCreatePrecode()->SetTargetInterlocked(entryPoint, TRUE /* fOnlyRedirectFromPrestub */);
     }
 }
 
diff --git a/src/coreclr/vm/precode.cpp b/src/coreclr/vm/precode.cpp
@@ -182,56 +182,25 @@ PCODE Precode::TryToSkipFixupPrecode(PCODE addr)
     return 0;
 }
 
-#ifdef FEATURE_INTERPRETER
-static TADDR GetMethodDescFromPrecodeData(TADDR methodDesc)
-{
-    LIMITED_METHOD_CONTRACT;
-    if ((methodDesc & InterpretedCodeAddressFlag) == 0)
-    {
-        return methodDesc;
-    }
-
-    PTR_CodeHeader pCodeHeader = PTR_CodeHeader(EEJitManager::GetCodeHeaderFromStartAddress(methodDesc & ~InterpretedCodeAddressFlag));
-    return dac_cast<TADDR>(pCodeHeader->GetMethodDesc());
-}
+#ifndef DACCESS_COMPILE
 
-static PCODE GetTargetFromPrecodeData(TADDR methodDesc, PCODE target)
+InterpreterPrecode* Precode::AllocateInterpreterPrecode(PCODE byteCode,
+                                                        LoaderAllocator *  pLoaderAllocator,
+                                                        AllocMemTracker *  pamTracker)
 {
-    LIMITED_METHOD_CONTRACT;
-    if ((methodDesc & InterpretedCodeAddressFlag) == 0)
+    CONTRACTL
     {
-        return target;
+        THROWS;
+        GC_NOTRIGGER;
+        MODE_ANY;
     }
+    CONTRACTL_END;
 
-    return dac_cast<PCODE>(methodDesc);
-}
-
-TADDR FixupPrecode::GetMethodDesc()
-{
-    LIMITED_METHOD_CONTRACT;
-    return GetMethodDescFromPrecodeData(dac_cast<TADDR>(GetData()->MethodDesc));
-}
-
-PCODE FixupPrecode::GetTarget()
-{
-    LIMITED_METHOD_DAC_CONTRACT;
-    return GetTargetFromPrecodeData(dac_cast<TADDR>(GetData()->MethodDesc), GetData()->Target);
-}
-
-TADDR StubPrecode::GetMethodDesc()
-{
-    LIMITED_METHOD_CONTRACT;
-    return GetMethodDescFromPrecodeData(dac_cast<TADDR>(GetData()->MethodDesc));
-}
-
-PCODE StubPrecode::GetTarget()
-{
-    LIMITED_METHOD_DAC_CONTRACT;
-    return GetTargetFromPrecodeData(dac_cast<TADDR>(GetData()->MethodDesc), GetData()->Target);
+    SIZE_T size = sizeof(InterpreterPrecode);
+    InterpreterPrecode* pPrecode = (InterpreterPrecode*)pamTracker->Track(pLoaderAllocator->GetNewStubPrecodeHeap()->AllocAlignedMem(size, 1));
+    pPrecode->Init(pPrecode, byteCode);
+    return pPrecode;
 }
-#endif // FEATURE_INTERPRETER
-
-#ifndef DACCESS_COMPILE
 
 Precode* Precode::Allocate(PrecodeType t, MethodDesc* pMD,
                            LoaderAllocator *  pLoaderAllocator,
@@ -327,7 +296,7 @@ void Precode::ResetTargetInterlocked()
     // interlocked operation above (see ClrFlushInstructionCache())
 }
 
-BOOL Precode::SetTargetInterlocked(PCODE target, BOOL fOnlyRedirectFromPrestub, BOOL fInterpreter)
+BOOL Precode::SetTargetInterlocked(PCODE target, BOOL fOnlyRedirectFromPrestub)
 {
     WRAPPER_NO_CONTRACT;
     _ASSERTE(!IsPointingToPrestub(target));
@@ -342,18 +311,17 @@ BOOL Precode::SetTargetInterlocked(PCODE target, BOOL fOnlyRedirectFromPrestub,
     switch (precodeType)
     {
     case PRECODE_STUB:
-        ret = AsStubPrecode()->SetTargetInterlocked(target, expected, fInterpreter);
+        ret = AsStubPrecode()->SetTargetInterlocked(target, expected);
         break;
 
 #ifdef HAS_FIXUP_PRECODE
     case PRECODE_FIXUP:
-        ret = AsFixupPrecode()->SetTargetInterlocked(target, expected, fInterpreter);
+        ret = AsFixupPrecode()->SetTargetInterlocked(target, expected);
         break;
 #endif // HAS_FIXUP_PRECODE
 
 #ifdef HAS_THISPTR_RETBUF_PRECODE
     case PRECODE_THISPTR_RETBUF:
-        _ASSERTE(!fInterpreter);
         ret = AsThisPtrRetBufPrecode()->SetTargetInterlocked(target, expected);
         ClrFlushInstructionCache(this, sizeof(ThisPtrRetBufPrecode), /* hasCodeExecutedBefore */ true);
         break;
@@ -533,6 +501,16 @@ BOOL StubPrecode::IsStubPrecodeByASM(PCODE addr)
 #endif // TARGET_X86
 }
 
+void InterpreterPrecode::Init(InterpreterPrecode* pPrecodeRX, TADDR byteCodeAddr)
+{
+    WRAPPER_NO_CONTRACT;
+    InterpreterPrecodeData *pStubData = GetData();
+
+    pStubData->Target = (PCODE)InterpreterStub;
+    pStubData->ByteCodeAddr = byteCodeAddr;
+    pStubData->Type = InterpreterPrecode::Type;
+}
+
 #ifdef HAS_NDIRECT_IMPORT_PRECODE
 
 void NDirectImportPrecode::Init(NDirectImportPrecode* pPrecodeRX, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator)
diff --git a/src/coreclr/vm/precode.h b/src/coreclr/vm/precode.h
@@ -76,7 +76,7 @@ struct InvalidPrecode
 
 struct StubPrecodeData
 {
-    TADDR MethodDesc; // MethodDesc pointer or interpreted code address or-ed with the InterpretedCodeAddressFlag
+    TADDR MethodDesc;
     PCODE Target;
     BYTE Type;
 };
@@ -133,26 +133,18 @@ struct StubPrecode
     }
 
     TADDR GetMethodDesc()
-#ifdef FEATURE_INTERPRETER
-    ;
-#else
     {
         LIMITED_METHOD_DAC_CONTRACT;
 
         return dac_cast<TADDR>(GetData()->MethodDesc);
     }
-#endif
 
     PCODE GetTarget()
-#ifdef FEATURE_INTERPRETER
-    ;
-#else
     {
         LIMITED_METHOD_DAC_CONTRACT;
 
         return GetData()->Target;
     }
-#endif
 
     BYTE GetType()
     {
@@ -175,7 +167,7 @@ struct StubPrecode
         InterlockedExchangeT<PCODE>(&pData->Target, GetPreStubEntryPoint());
     }
 
-    BOOL SetTargetInterlocked(TADDR target, TADDR expected, BOOL fInterpreter)
+    BOOL SetTargetInterlocked(TADDR target, TADDR expected)
     {
         CONTRACTL
         {
@@ -184,12 +176,6 @@ struct StubPrecode
         }
         CONTRACTL_END;
 
-#ifdef FEATURE_INTERPRETER
-        if (fInterpreter)
-        {
-            target = (PCODE)InterpreterStub;
-        }
-#endif
         StubPrecodeData *pData = GetData();
         return InterlockedCompareExchangeT<PCODE>(&pData->Target, (PCODE)target, (PCODE)expected) == expected;
   }
@@ -222,13 +208,42 @@ typedef DPTR(NDirectImportPrecode) PTR_NDirectImportPrecode;
 
 #endif // HAS_NDIRECT_IMPORT_PRECODE
 
+struct InterpreterPrecodeData
+{
+    TADDR ByteCodeAddr;
+    PCODE Target;
+    BYTE Type;
+};
+
+typedef DPTR(InterpreterPrecodeData) PTR_InterpreterPrecodeData;
+
+struct InterpreterPrecode
+{
+    static const int Type = 0x06;
+
+    BYTE m_code[StubPrecode::CodeSize];
+
+    void Init(InterpreterPrecode* pPrecodeRX, TADDR byteCodeAddr);
+
+    PTR_InterpreterPrecodeData GetData() const
+    {
+        LIMITED_METHOD_CONTRACT;
+        return dac_cast<PTR_InterpreterPrecodeData>(dac_cast<TADDR>(this) + GetStubCodePageSize());
+    }
+
+    PCODE GetEntryPoint()
+    {
+        LIMITED_METHOD_CONTRACT;
+        return PINSTRToPCODE(dac_cast<TADDR>(this));
+    }
+};
 
 #ifdef HAS_FIXUP_PRECODE
 
 struct FixupPrecodeData
 {
     PCODE Target;
-    TADDR MethodDesc;  // MethodDesc pointer or interpreted code address or-ed with the InterpretedCodeAddressFlag
+    TADDR MethodDesc;
     PCODE PrecodeFixupThunk;
 };
 
@@ -289,23 +304,15 @@ struct FixupPrecode
     }
 
     TADDR GetMethodDesc()
-#ifdef FEATURE_INTERPRETER
-    ;
-#else
     {
         return (TADDR)GetData()->MethodDesc;
     }
-#endif
 
     PCODE GetTarget()
-#ifdef FEATURE_INTERPRETER
-    ;
-#else
     {
         LIMITED_METHOD_DAC_CONTRACT;
         return GetData()->Target;
     }
-#endif
 
     PCODE *GetTargetSlot()
     {
@@ -331,7 +338,7 @@ struct FixupPrecode
         InterlockedExchangeT<PCODE>(&GetData()->Target, target);
     }
 
-    BOOL SetTargetInterlocked(TADDR target, TADDR expected, BOOL fInterpreter)
+    BOOL SetTargetInterlocked(TADDR target, TADDR expected)
     {
         CONTRACTL
         {
@@ -340,15 +347,6 @@ struct FixupPrecode
         }
         CONTRACTL_END;
 
-#ifdef FEATURE_INTERPRETER
-        if (fInterpreter)
-        {
-            _ASSERTE(IS_ALIGNED(&GetData()->PrecodeFixupThunk, sizeof(SIZE_T)));
-            _ASSERTE((PCODE)GetData()->Target == ((PCODE)this + FixupCodeOffset));
-            PCODE oldTarget = (PCODE)GetData()->PrecodeFixupThunk;
-            return InterlockedCompareExchangeT<PCODE>(&GetData()->PrecodeFixupThunk, (PCODE)InterpreterStub, (PCODE)oldTarget) == (PCODE)oldTarget;
-        }
-#endif
         PCODE oldTarget = (PCODE)GetData()->Target;
         if (oldTarget != ((PCODE)this + FixupCodeOffset))
         {
@@ -381,6 +379,7 @@ typedef DPTR(class Precode) PTR_Precode;
 enum PrecodeType {
     PRECODE_INVALID         = InvalidPrecode::Type,
     PRECODE_STUB            = StubPrecode::Type,
+    PRECODE_INTERPRETER     = InterpreterPrecode::Type,
 #ifdef HAS_NDIRECT_IMPORT_PRECODE
     PRECODE_NDIRECT_IMPORT  = NDirectImportPrecode::Type,
 #endif // HAS_NDIRECT_IMPORT_PRECODE
@@ -568,11 +567,15 @@ class Precode {
 
     static Precode* Allocate(PrecodeType t, MethodDesc* pMD,
         LoaderAllocator *pLoaderAllocator, AllocMemTracker *pamTracker);
+
+    static InterpreterPrecode* AllocateInterpreterPrecode(PCODE byteCode,
+        LoaderAllocator *  pLoaderAllocator, AllocMemTracker *  pamTracker);
+
     void Init(Precode* pPrecodeRX, PrecodeType t, MethodDesc* pMD, LoaderAllocator *pLoaderAllocator);
 
 #ifndef DACCESS_COMPILE
     void ResetTargetInterlocked();
-    BOOL SetTargetInterlocked(PCODE target, BOOL fOnlyRedirectFromPrestub = TRUE, BOOL fInterpreter = FALSE);
+    BOOL SetTargetInterlocked(PCODE target, BOOL fOnlyRedirectFromPrestub = TRUE);
 
     // Reset precode to point to prestub
     void Reset();
diff --git a/src/coreclr/vm/prestub.cpp b/src/coreclr/vm/prestub.cpp
@@ -426,9 +426,14 @@ PCODE MethodDesc::PrepareILBasedCode(PrepareCodeConfig* pConfig)
         LOG((LF_CLASSLOADER, LL_INFO1000000,
             "    In PrepareILBasedCode, calling JitCompileCode\n"));
         pCode = JitCompileCode(pConfig);
+
         if (pConfig->IsInterpreterCode())
         {
-            pCode |= InterpretedCodeAddressFlag;
+            AllocMemTracker amt;
+            InterpreterPrecode* pPrecode = Precode::AllocateInterpreterPrecode(pCode, GetLoaderAllocator(), &amt);
+            amt.SuppressRelease();
+            pCode = PINSTRToPCODE(pPrecode->GetEntryPoint());
+            SetNativeCodeInterlocked(pCode);
         }
     }
     else
@@ -2691,7 +2696,6 @@ extern "C" PCODE STDCALL PreStubWorker(TransitionBlock* pTransitionBlock, Method
 #ifdef FEATURE_INTERPRETER
 extern "C" void STDCALL ExecuteInterpretedMethod(TransitionBlock* pTransitionBlock, TADDR byteCodeAddr)
 {
-    byteCodeAddr &= ~InterpretedCodeAddressFlag;
     CodeHeader* pCodeHeader = EEJitManager::GetCodeHeaderFromStartAddress(byteCodeAddr);
 
     EEJitManager *pManager = ExecutionManager::GetEEJitManager();

Original file line number	Diff line number	Diff line change
`@@ -3044,7 +3044,7 @@ void MethodDesc::TrySetInitialCodeEntryPointForVersionableMethod(`
`3044`	`3044`	`else`
`3045`	`3045`	`{`
`3046`	`3046`	`_ASSERTE(IsVersionableWithPrecode());`
`3047`		`- GetOrCreatePrecode()->SetTargetInterlocked(entryPoint, TRUE /* fOnlyRedirectFromPrestub /, (entryPoint & InterpretedCodeAddressFlag) / fInterpreter */);`
	`3047`	`+ GetOrCreatePrecode()->SetTargetInterlocked(entryPoint, TRUE /* fOnlyRedirectFromPrestub */);`
`3048`	`3048`	`}`
`3049`	`3049`	`}`
`3050`	`3050`
Original file line number	Diff line number	Diff line change
`@@ -426,9 +426,14 @@ PCODE MethodDesc::PrepareILBasedCode(PrepareCodeConfig* pConfig)`
`426`	`426`	`LOG((LF_CLASSLOADER, LL_INFO1000000,`
`427`	`427`	`" In PrepareILBasedCode, calling JitCompileCode\n"));`
`428`	`428`	`pCode = JitCompileCode(pConfig);`
	`429`	`+`
`429`	`430`	`if (pConfig->IsInterpreterCode())`
`430`	`431`	`{`
`431`		`- pCode \|= InterpretedCodeAddressFlag;`
	`432`	`+ AllocMemTracker amt;`
	`433`	`+ InterpreterPrecode* pPrecode = Precode::AllocateInterpreterPrecode(pCode, GetLoaderAllocator(), &amt);`
	`434`	`+ amt.SuppressRelease();`
	`435`	`+ pCode = PINSTRToPCODE(pPrecode->GetEntryPoint());`
	`436`	`+ SetNativeCodeInterlocked(pCode);`
`432`	`437`	`}`
`433`	`438`	`}`
`434`	`439`	`else`
`@@ -2691,7 +2696,6 @@ extern "C" PCODE STDCALL PreStubWorker(TransitionBlock* pTransitionBlock, Method`
`2691`	`2696`	`#ifdef FEATURE_INTERPRETER`
`2692`	`2697`	`extern "C" void STDCALL ExecuteInterpretedMethod(TransitionBlock* pTransitionBlock, TADDR byteCodeAddr)`
`2693`	`2698`	`{`
`2694`		`- byteCodeAddr &= ~InterpretedCodeAddressFlag;`
`2695`	`2699`	`CodeHeader* pCodeHeader = EEJitManager::GetCodeHeaderFromStartAddress(byteCodeAddr);`
`2696`	`2700`
`2697`	`2701`	`EEJitManager *pManager = ExecutionManager::GetEEJitManager();`