Register funcptr precodes in backpatching table for proper tiered compilation lifecycle

Funcptr precodes for backpatchable methods are now registered in the entry point
slot backpatching table at creation time, replacing the ad-hoc funcptr precode
lookup and patching that was previously done in TryBackpatchEntryPointSlots.

This ensures:
- During non-final tiers, funcptr precode targets point to the method's precode
  (temporary entry point), so calls flow through the same path as vtable calls
- At final tier, SetBackpatchableEntryPoint calls Backpatch_Locked to update all
  registered slots (including funcptr precodes) to the final code
- During rejit, BackpatchToResetEntryPointSlots resets funcptr targets via the
  backpatching table, ensuring proper re-discovery through the prestub

The change adds Precode::GetTargetSlot() and StubPrecode::GetTargetSlot() to
expose the writable target field address for registration as a SlotType_Normal
entry point slot.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: davidwrighton

src/coreclr/vm/fptrstubs.cpp

@@ -76,6 +76,9 @@ PCODE FuncPtrStubs::GetFuncPtrStub(MethodDesc * pMD, PrecodeType type)
 
     if (pPrecode != NULL)
     {
+        LOG((LF_TIEREDCOMPILATION, LL_INFO10000,
+            "FuncPtrStubs::GetFuncPtrStub pMD=%p type=%d - found existing stub, entryPoint=" FMT_ADDR "\n",
+            pMD, type, DBG_ADDR(pPrecode->GetEntryPoint())));
         return pPrecode->GetEntryPoint();
     }
 
@@ -141,6 +144,10 @@ PCODE FuncPtrStubs::GetFuncPtrStub(MethodDesc * pMD, PrecodeType type)
                 pPrecode = pNewPrecode;
                 m_hashTable.Add(pPrecode);
                 amt.SuppressRelease();
+                LOG((LF_TIEREDCOMPILATION, LL_INFO10000,
+                    "FuncPtrStubs::GetFuncPtrStub pMD=%p type=%d - created new stub,"
+                    " target=" FMT_ADDR " setTargetAfter=%d\n",
+                    pMD, type, DBG_ADDR(target), setTargetAfterAddingToHashTable));
             }
             else
             {
@@ -155,18 +162,26 @@ PCODE FuncPtrStubs::GetFuncPtrStub(MethodDesc * pMD, PrecodeType type)
 
         _ASSERTE(pMD->IsVersionableWithVtableSlotBackpatch());
 
-        PCODE temporaryEntryPoint = pMD->GetTemporaryEntryPoint();
+        LoaderAllocator *mdLoaderAllocator = pMD->GetLoaderAllocator();
         MethodDescBackpatchInfoTracker::ConditionalLockHolder slotBackpatchLockHolder;
 
-        // Set the funcptr stub's entry point to the current entry point inside the lock and after the funcptr stub is exposed,
-        // to synchronize with backpatching in MethodDesc::BackpatchEntryPointSlots()
-        PCODE entryPoint = pMD->GetMethodEntryPoint();
-        if (entryPoint != temporaryEntryPoint)
-        {
-            // Need only patch the precode from the prestub, since if someone else managed to patch the precode already then its
-            // target would already be up-to-date
-            pPrecode->SetTargetInterlocked(entryPoint, TRUE /* fOnlyRedirectFromPrestub */);
-        }
+        // Register the funcptr precode's target slot in the backpatching table. This records the slot and
+        // immediately backpatches it to the current entry point. During non-final tiers, GetMethodEntryPoint()
+        // returns the temporary entry point (method's precode), so calls through the funcptr stub will flow
+        // through the method's precode to the current code. At final tier, the slot is updated to point
+        // directly to the final code along with all other registered entry point slots.
+        PCODE currentEntryPoint = pMD->GetMethodEntryPoint();
+        LOG((LF_TIEREDCOMPILATION, LL_INFO10000,
+            "FuncPtrStubs::GetFuncPtrStub pMD=%p (%s::%s) - registering funcptr precode target in backpatch table,"
+            " currentEntryPoint=" FMT_ADDR "\n",
+            pMD, pMD->m_pszDebugClassName, pMD->m_pszDebugMethodName, DBG_ADDR(currentEntryPoint)));
+        MethodDescBackpatchInfoTracker *backpatchTracker = mdLoaderAllocator->GetMethodDescBackpatchInfoTracker();
+        backpatchTracker->AddSlotAndPatch_Locked(
+            pMD,
+            mdLoaderAllocator,
+            (TADDR)pPrecode->GetTargetSlot(),
+            EntryPointSlots::SlotType_Normal,
+            currentEntryPoint);
     }
 
     return pPrecode->GetEntryPoint();

src/coreclr/vm/method.cpp

@@ -3226,27 +3226,9 @@ bool MethodDesc::TryBackpatchEntryPointSlots(
         this, m_pszDebugClassName, m_pszDebugMethodName, DBG_ADDR(entryPoint), DBG_ADDR(previousEntryPoint),
         IsVersionableWithVtableSlotBackpatch()));
 
-    if (IsVersionableWithVtableSlotBackpatch())
-    {
-        // Backpatch the func ptr stub if it was created
-        FuncPtrStubs *funcPtrStubs = mdLoaderAllocator->GetFuncPtrStubsNoCreate();
-        if (funcPtrStubs != nullptr)
-        {
-            Precode *funcPtrPrecode = funcPtrStubs->Lookup(this);
-            if (funcPtrPrecode != nullptr)
-            {
-                if (isPrestubEntryPoint)
-                {
-                    funcPtrPrecode->ResetTargetInterlocked();
-                }
-                else
-                {
-                    funcPtrPrecode->SetTargetInterlocked(entryPoint, FALSE /* fOnlyRedirectFromPrestub */);
-                }
-            }
-        }
-    }
-
+    // Backpatch all registered entry point slots. For methods versionable with vtable slot backpatch,
+    // this also handles funcptr precodes which are registered in the backpatch table at creation time
+    // (see FuncPtrStubs::GetFuncPtrStub).
     backpatchInfoTracker->Backpatch_Locked(this, entryPoint);
 
     // Set the entry point to backpatch inside the lock to synchronize with backpatching in MethodDesc::DoBackpatch(), and set
@@ -3359,8 +3341,9 @@ void MethodDesc::ResetCodeEntryPoint()
 }
 
 // Sets the entry point for a backpatchable method during tiered compilation.
-// For final tier: sets the owning vtable slot to codeEntryPoint and resets the precode to prestub,
-//   enabling lazy vtable slot discovery via DoBackpatch().
+// For final tier: sets the owning vtable slot to codeEntryPoint, backpatches all registered entry point
+//   slots (e.g. funcptr precodes) to codeEntryPoint, and resets the method's precode to prestub to enable
+//   lazy vtable slot discovery via DoBackpatch().
 // For non-final tier: redirects the precode target to codeEntryPoint without modifying the vtable slot.
 //   The vtable slot stays at the temporary entry point (precode), preventing DoBackpatch() from
 //   recording vtable slots during non-final tiers.
@@ -3370,16 +3353,25 @@ void MethodDesc::SetBackpatchableEntryPoint(PCODE codeEntryPoint, bool isFinalTi
     _ASSERTE(MayHaveEntryPointSlotsToBackpatch());
     _ASSERTE(codeEntryPoint != (PCODE)NULL);
     _ASSERTE(!isFinalTier || !fOnlyRedirectFromPrestub);
+    _ASSERTE(!isFinalTier || MethodDescBackpatchInfoTracker::IsLockOwnedByCurrentThread());
 
     Precode *precode = Precode::GetPrecodeFromEntryPoint(GetTemporaryEntryPoint());
     if (isFinalTier)
     {
         LOG((LF_TIEREDCOMPILATION, LL_INFO10000,
             "MethodDesc::SetBackpatchableEntryPoint pMD=%p (%s::%s) entryPoint=" FMT_ADDR
             " isFinalTier=true - setting owning vtable slot to final code,"
-            " resetting precode to prestub for lazy DoBackpatch\n",
+            " backpatching registered slots, resetting precode to prestub for lazy DoBackpatch\n",
             this, m_pszDebugClassName, m_pszDebugMethodName, DBG_ADDR(codeEntryPoint)));
         SetMethodEntryPoint(codeEntryPoint);
+
+        // Backpatch all registered entry point slots (e.g. funcptr precodes) to the final code.
+        // Vtable slots are not yet registered at this point — they are lazily discovered and recorded
+        // by DoBackpatch() when the next call goes through the precode → prestub path.
+        LoaderAllocator *mdLoaderAllocator = GetLoaderAllocator();
+        MethodDescBackpatchInfoTracker *backpatchTracker = mdLoaderAllocator->GetMethodDescBackpatchInfoTracker();
+        backpatchTracker->Backpatch_Locked(this, codeEntryPoint);
+
         precode->ResetTargetInterlocked();
     }
     else

src/coreclr/vm/precode.cpp

@@ -126,6 +126,28 @@ PCODE Precode::GetTarget()
     return target;
 }
 
+#ifndef DACCESS_COMPILE
+PTR_PCODE Precode::GetTargetSlot()
+{
+    LIMITED_METHOD_CONTRACT;
+
+    PrecodeType precodeType = GetType();
+    switch (precodeType)
+    {
+    case PRECODE_STUB:
+        return AsStubPrecode()->GetTargetSlot();
+#ifdef HAS_FIXUP_PRECODE
+    case PRECODE_FIXUP:
+        return AsFixupPrecode()->GetTargetSlot();
+#endif // HAS_FIXUP_PRECODE
+
+    default:
+        UnexpectedPrecodeType("Precode::GetTargetSlot", precodeType);
+        return NULL;
+    }
+}
+#endif // !DACCESS_COMPILE
+
 MethodDesc* Precode::GetMethodDesc(BOOL fSpeculative /*= FALSE*/)
 {
     CONTRACTL {

src/coreclr/vm/precode.h

@@ -151,6 +151,12 @@ struct StubPrecode
         return GetData()->Target;
     }
 
+    PCODE *GetTargetSlot()
+    {
+        LIMITED_METHOD_CONTRACT;
+        return &GetData()->Target;
+    }
+
     BYTE GetType();
 
     static BOOL IsStubPrecodeByASM(PCODE addr);

src/coreclr/vm/prestub.cpp

@@ -101,9 +101,13 @@ PCODE MethodDesc::DoBackpatch(MethodTable * pMT, MethodTable *pDispatchingMT, bo
         _ASSERTE(!(pMT->IsInterface() && !IsStatic()));
 
         // Backpatching the funcptr stub:
-        //     For methods versionable with vtable slot backpatch, a funcptr stub is guaranteed to point to the at-the-time
-        //     current entry point shortly after creation, and backpatching it further is taken care of by
-        //     MethodDesc::BackpatchEntryPointSlots()
+        //     For methods versionable with vtable slot backpatch, funcptr precodes are registered in the
+        //     backpatching table (see FuncPtrStubs::GetFuncPtrStub). During non-final tiers, the funcptr
+        //     precode target is set to the temporary entry point (the method's precode), so calls through
+        //     the funcptr stub flow through the method's precode to the current code. At final tier, the
+        //     funcptr precode target is updated to the final code by Backpatch_Locked in
+        //     SetBackpatchableEntryPoint(). Because the funcptr precode is in the backpatching table, it is
+        //     also updated during rejit scenarios via BackpatchToResetEntryPointSlots().
 
         // Backpatching the temporary entry point:
         //     The temporary entry point is not directly backpatched for methods versionable with vtable slot backpatch.