Revert "Do not encode safe points with -1 offset. (#104336)"

src/coreclr/gcinfo/gcinfoencoder.cpp

@@ -1216,19 +1216,42 @@ void GcInfoEncoder::Build()
 
     ///////////////////////////////////////////////////////////////////////
     // Normalize call sites
+    // Eliminate call sites that fall inside interruptible ranges
     ///////////////////////////////////////////////////////////////////////
 
-    _ASSERTE(m_NumCallSites == 0 || numInterruptibleRanges == 0);
-
     UINT32 numCallSites = 0;
     for(UINT32 callSiteIndex = 0; callSiteIndex < m_NumCallSites; callSiteIndex++)
     {
         UINT32 callSite = m_pCallSites[callSiteIndex];
-        callSite += m_pCallSiteSizes[callSiteIndex];
+        // There's a contract with the EE that says for non-leaf stack frames, where the
+        // method is stopped at a call site, the EE will not query with the return PC, but
+        // rather the return PC *minus 1*.
+        // The reason is that variable/register liveness may change at the instruction immediately after the
+        // call, so we want such frames to appear as if they are "within" the call.
+        // Since we use "callSite" as the "key" when we search for the matching descriptor, also subtract 1 here
+        // (after, of course, adding the size of the call instruction to get the return PC).
+        callSite += m_pCallSiteSizes[callSiteIndex] - 1;
 
         _ASSERTE(DENORMALIZE_CODE_OFFSET(NORMALIZE_CODE_OFFSET(callSite)) == callSite);
         UINT32 normOffset = NORMALIZE_CODE_OFFSET(callSite);
-        m_pCallSites[numCallSites++] = normOffset;
+
+        BOOL keepIt = TRUE;
+
+        for(UINT32 intRangeIndex = 0; intRangeIndex < numInterruptibleRanges; intRangeIndex++)
+        {
+            InterruptibleRange *pRange = &pRanges[intRangeIndex];
+            if(pRange->NormStopOffset > normOffset)
+            {
+                if(pRange->NormStartOffset <= normOffset)
+                {
+                    keepIt = FALSE;
+                }
+                break;
+            }
+        }
+
+        if(keepIt)
+            m_pCallSites[numCallSites++] = normOffset;
     }
 
     GCINFO_WRITE_VARL_U(m_Info1, NORMALIZE_NUM_SAFE_POINTS(numCallSites), NUM_SAFE_POINTS_ENCBASE, NumCallSitesSize);
@@ -1395,7 +1418,7 @@ void GcInfoEncoder::Build()
 
         for(pCurrent = pTransitions; pCurrent < pEndTransitions; )
         {
-            if(pCurrent->CodeOffset >= callSite)
+            if(pCurrent->CodeOffset > callSite)
             {
                 couldBeLive |= liveState;
 
@@ -1750,7 +1773,7 @@ void GcInfoEncoder::Build()
         {
             for(pCurrent = pTransitions; pCurrent < pEndTransitions; )
             {
-                if(pCurrent->CodeOffset >= callSite)
+                if(pCurrent->CodeOffset > callSite)
                 {
                     // Time to record the call site
 
@@ -1849,7 +1872,7 @@ void GcInfoEncoder::Build()
 
             for(pCurrent = pTransitions; pCurrent < pEndTransitions; )
             {
-                if(pCurrent->CodeOffset >= callSite)
+                if(pCurrent->CodeOffset > callSite)
                 {
                     // Time to encode the call site
 
@@ -1896,7 +1919,7 @@ void GcInfoEncoder::Build()
 
             for(pCurrent = pTransitions; pCurrent < pEndTransitions; )
             {
-                if(pCurrent->CodeOffset >= callSite)
+                if(pCurrent->CodeOffset > callSite)
                 {
                     // Time to encode the call site
                     GCINFO_WRITE_VECTOR(m_Info1, liveState, CallSiteStateSize);

src/coreclr/inc/gcinfotypes.h

@@ -678,8 +678,8 @@ void FASTCALL decodeCallPattern(int         pattern,
 #define NORMALIZE_SIZE_OF_STACK_AREA(x) ((x)>>2)
 #define DENORMALIZE_SIZE_OF_STACK_AREA(x) ((x)<<2)
 #define CODE_OFFSETS_NEED_NORMALIZATION 1
-#define NORMALIZE_CODE_OFFSET(x) ((x)>>1)   // Instructions are 2/4 bytes long in Thumb/ARM states,
-#define DENORMALIZE_CODE_OFFSET(x) ((x)<<1)
+#define NORMALIZE_CODE_OFFSET(x) (x)   // Instructions are 2/4 bytes long in Thumb/ARM states,
+#define DENORMALIZE_CODE_OFFSET(x) (x) // but the safe-point offsets are encoded with a -1 adjustment.
 #define NORMALIZE_REGISTER(x) (x)
 #define DENORMALIZE_REGISTER(x) (x)
 #define NORMALIZE_NUM_SAFE_POINTS(x) (x)
@@ -734,9 +734,9 @@ void FASTCALL decodeCallPattern(int         pattern,
 #define DENORMALIZE_STACK_BASE_REGISTER(x) ((x)^29)
 #define NORMALIZE_SIZE_OF_STACK_AREA(x) ((x)>>3)
 #define DENORMALIZE_SIZE_OF_STACK_AREA(x) ((x)<<3)
-#define CODE_OFFSETS_NEED_NORMALIZATION 1
-#define NORMALIZE_CODE_OFFSET(x) ((x)>>2)   // Instructions are 4 bytes long
-#define DENORMALIZE_CODE_OFFSET(x) ((x)<<2)
+#define CODE_OFFSETS_NEED_NORMALIZATION 0
+#define NORMALIZE_CODE_OFFSET(x) (x)   // Instructions are 4 bytes long, but the safe-point
+#define DENORMALIZE_CODE_OFFSET(x) (x) // offsets are encoded with a -1 adjustment.
 #define NORMALIZE_REGISTER(x) (x)
 #define DENORMALIZE_REGISTER(x) (x)
 #define NORMALIZE_NUM_SAFE_POINTS(x) (x)
@@ -789,9 +789,9 @@ void FASTCALL decodeCallPattern(int         pattern,
 #define DENORMALIZE_STACK_BASE_REGISTER(x) ((x) == 0 ? 22 : 3)
 #define NORMALIZE_SIZE_OF_STACK_AREA(x) ((x)>>3)
 #define DENORMALIZE_SIZE_OF_STACK_AREA(x) ((x)<<3)
-#define CODE_OFFSETS_NEED_NORMALIZATION 1
-#define NORMALIZE_CODE_OFFSET(x) ((x)>>2)   // Instructions are 4 bytes long
-#define DENORMALIZE_CODE_OFFSET(x) ((x)<<2)
+#define CODE_OFFSETS_NEED_NORMALIZATION 0
+#define NORMALIZE_CODE_OFFSET(x) (x)   // Instructions are 4 bytes long, but the safe-point
+#define DENORMALIZE_CODE_OFFSET(x) (x) // offsets are encoded with a -1 adjustment.
 #define NORMALIZE_REGISTER(x) (x)
 #define DENORMALIZE_REGISTER(x) (x)
 #define NORMALIZE_NUM_SAFE_POINTS(x) (x)
@@ -844,9 +844,9 @@ void FASTCALL decodeCallPattern(int         pattern,
 #define DENORMALIZE_STACK_BASE_REGISTER(x) ((x) == 0 ? 8 : 2)
 #define NORMALIZE_SIZE_OF_STACK_AREA(x) ((x)>>3)
 #define DENORMALIZE_SIZE_OF_STACK_AREA(x) ((x)<<3)
-#define CODE_OFFSETS_NEED_NORMALIZATION 1
-#define NORMALIZE_CODE_OFFSET(x) ((x)>>2)   // Instructions are 4 bytes long
-#define DENORMALIZE_CODE_OFFSET(x) ((x)<<2)
+#define CODE_OFFSETS_NEED_NORMALIZATION 0
+#define NORMALIZE_CODE_OFFSET(x) (x)   // Instructions are 4 bytes long, but the safe-point
+#define DENORMALIZE_CODE_OFFSET(x) (x) // offsets are encoded with a -1 adjustment.
 #define NORMALIZE_REGISTER(x) (x)
 #define DENORMALIZE_REGISTER(x) (x)
 #define NORMALIZE_NUM_SAFE_POINTS(x) (x)

src/coreclr/jit/codegencommon.cpp

@@ -1517,6 +1517,29 @@ void CodeGen::genExitCode(BasicBlock* block)
     if (compiler->getNeedsGSSecurityCookie())
     {
         genEmitGSCookieCheck(jmpEpilog);
+
+        if (jmpEpilog)
+        {
+            // Dev10 642944 -
+            // The GS cookie check created a temp label that has no live
+            // incoming GC registers, we need to fix that
+
+            unsigned   varNum;
+            LclVarDsc* varDsc;
+
+            /* Figure out which register parameters hold pointers */
+
+            for (varNum = 0, varDsc = compiler->lvaTable; varNum < compiler->lvaCount && varDsc->lvIsRegArg;
+                 varNum++, varDsc++)
+            {
+                noway_assert(varDsc->lvIsParam);
+
+                gcInfo.gcMarkRegPtrVal(varDsc->GetArgReg(), varDsc->TypeGet());
+            }
+
+            GetEmitter()->emitThisGCrefRegs = GetEmitter()->emitInitGCrefRegs = gcInfo.gcRegGCrefSetCur;
+            GetEmitter()->emitThisByrefRegs = GetEmitter()->emitInitByrefRegs = gcInfo.gcRegByrefSetCur;
+        }
     }
 
     genReserveEpilog(block);

src/coreclr/jit/emit.cpp

@@ -10427,9 +10427,9 @@ regMaskTP emitter::emitGetGCRegsKilledByNoGCCall(CorInfoHelpFunc helper)
 //    of the last instruction in the region makes GC safe again.
 //    In particular - once the IP is on the first instruction, but not executed it yet,
 //    it is still safe to do GC.
-//    The only special case is when NoGC region is used for prologs.
-//    In such case the GC info could be incorrect until the prolog completes, so the first
-//    instruction cannot have GC.
+//    The only special case is when NoGC region is used for prologs/epilogs.
+//    In such case the GC info could be incorrect until the prolog completes and epilogs
+//    may have unwindability restrictions, so the first instruction cannot have GC.
 
 void emitter::emitDisableGC()
 {

src/coreclr/jit/emitinl.h

@@ -594,7 +594,8 @@ bool emitter::emitGenNoGCLst(Callback& cb)
             emitter::instrDesc* id = emitFirstInstrDesc(ig->igData);
             assert(id != nullptr);
             assert(id->idCodeSize() > 0);
-            if (!cb(ig->igFuncIdx, ig->igOffs, ig->igSize, id->idCodeSize(), ig->igFlags & (IGF_FUNCLET_PROLOG)))
+            if (!cb(ig->igFuncIdx, ig->igOffs, ig->igSize, id->idCodeSize(),
+                    ig->igFlags & (IGF_FUNCLET_PROLOG | IGF_FUNCLET_EPILOG | IGF_EPILOG)))
             {
                 return false;
             }

src/coreclr/jit/gcencode.cpp

@@ -4027,7 +4027,8 @@ class InterruptibleRangeReporter
     // Report everything between the previous region and the current
     // region as interruptible.
 
-    bool operator()(unsigned igFuncIdx, unsigned igOffs, unsigned igSize, unsigned firstInstrSize, bool isInProlog)
+    bool operator()(
+        unsigned igFuncIdx, unsigned igOffs, unsigned igSize, unsigned firstInstrSize, bool isInPrologOrEpilog)
     {
         if (igOffs < m_uninterruptibleEnd)
         {
@@ -4043,7 +4044,7 @@ class InterruptibleRangeReporter
             // Once the first instruction in IG executes, we cannot have GC.
             // But it is ok to have GC while the IP is on the first instruction, unless we are in prolog/epilog.
             unsigned interruptibleEnd = igOffs;
-            if (!isInProlog)
+            if (!isInPrologOrEpilog)
             {
                 interruptibleEnd += firstInstrSize;
             }

src/coreclr/nativeaot/Runtime/thread.cpp

@@ -675,16 +675,10 @@ void Thread::HijackCallback(NATIVE_CONTEXT* pThreadContext, void* pThreadToHijac
     if (runtime->IsConservativeStackReportingEnabled() ||
         codeManager->IsSafePoint(pvAddress))
     {
-        // IsUnwindable is precise on arm64, but can give false negatives on other architectures.
-        // (when IP is on the first instruction of an epilog, we still can unwind,
-        // but we can tell if the instruction is the first only if we can navigate instructions backwards and check)
-        // The preciseness of IsUnwindable is tracked in https://github.com/dotnet/runtime/issues/101932
-#if defined(TARGET_ARM64)
         // we may not be able to unwind in some locations, such as epilogs.
         // such locations should not contain safe points.
         // when scanning conservatively we do not need to unwind
         ASSERT(codeManager->IsUnwindable(pvAddress) || runtime->IsConservativeStackReportingEnabled());
-#endif
 
         // if we are not given a thread to hijack
         // perform in-line wait on the current thread

src/coreclr/nativeaot/Runtime/unix/UnixNativeCodeManager.cpp

@@ -213,18 +213,44 @@ void UnixNativeCodeManager::EnumGcRefs(MethodInfo *    pMethodInfo,
 
 #ifdef TARGET_ARM
     // Ensure that code offset doesn't have the Thumb bit set. We need
-    // it to be aligned to instruction start
+    // it to be aligned to instruction start to make the !isActiveStackFrame
+    // branch below work.
     ASSERT(((uintptr_t)codeOffset & 1) == 0);
 #endif
 
+    bool executionAborted = ((UnixNativeMethodInfo*)pMethodInfo)->executionAborted;
+
+    if (!isActiveStackFrame && !executionAborted)
+    {
+        // the reasons for this adjustment are explained in EECodeManager::EnumGcRefs
+        codeOffset--;
+    }
+
     GcInfoDecoder decoder(
         GCInfoToken(gcInfo),
         GcInfoDecoderFlags(DECODE_GC_LIFETIMES | DECODE_SECURITY_OBJECT | DECODE_VARARG),
         codeOffset
     );
 
+    if (isActiveStackFrame)
+    {
+        // CONSIDER: We can optimize this by remembering the need to adjust in IsSafePoint and propagating into here.
+        //           Or, better yet, maybe we should change the decoder to not require this adjustment.
+        //           The scenario that adjustment tries to handle (fallthrough into BB with random liveness)
+        //           does not seem possible.
+        if (!decoder.HasInterruptibleRanges())
+        {
+            decoder = GcInfoDecoder(
+                GCInfoToken(gcInfo),
+                GcInfoDecoderFlags(DECODE_GC_LIFETIMES | DECODE_SECURITY_OBJECT | DECODE_VARARG),
+                codeOffset - 1
+            );
+
+            assert(decoder.IsInterruptibleSafePoint());
+        }
+    }
+
     ICodeManagerFlags flags = (ICodeManagerFlags)0;
-    bool executionAborted = ((UnixNativeMethodInfo*)pMethodInfo)->executionAborted;
     if (executionAborted)
         flags = ICodeManagerFlags::ExecutionAborted;
 

src/coreclr/nativeaot/Runtime/windows/CoffNativeCodeManager.cpp

@@ -440,8 +440,9 @@ void CoffNativeCodeManager::EnumGcRefs(MethodInfo *    pMethodInfo,
     PTR_uint8_t gcInfo;
     uint32_t codeOffset = GetCodeOffset(pMethodInfo, safePointAddress, &gcInfo);
 
-    ICodeManagerFlags flags = (ICodeManagerFlags)0;
     bool executionAborted = ((CoffNativeMethodInfo *)pMethodInfo)->executionAborted;
+
+    ICodeManagerFlags flags = (ICodeManagerFlags)0;
     if (executionAborted)
         flags = ICodeManagerFlags::ExecutionAborted;
 
@@ -452,13 +453,36 @@ void CoffNativeCodeManager::EnumGcRefs(MethodInfo *    pMethodInfo,
         flags = (ICodeManagerFlags)(flags | ICodeManagerFlags::ActiveStackFrame);
 
 #ifdef USE_GC_INFO_DECODER
+    if (!isActiveStackFrame && !executionAborted)
+    {
+        // the reasons for this adjustment are explained in EECodeManager::EnumGcRefs
+        codeOffset--;
+    }
 
     GcInfoDecoder decoder(
         GCInfoToken(gcInfo),
         GcInfoDecoderFlags(DECODE_GC_LIFETIMES | DECODE_SECURITY_OBJECT | DECODE_VARARG),
         codeOffset
     );
 
+    if (isActiveStackFrame)
+    {
+        // CONSIDER: We can optimize this by remembering the need to adjust in IsSafePoint and propagating into here.
+        //           Or, better yet, maybe we should change the decoder to not require this adjustment.
+        //           The scenario that adjustment tries to handle (fallthrough into BB with random liveness)
+        //           does not seem possible.
+        if (!decoder.HasInterruptibleRanges())
+        {
+            decoder = GcInfoDecoder(
+                GCInfoToken(gcInfo),
+                GcInfoDecoderFlags(DECODE_GC_LIFETIMES | DECODE_SECURITY_OBJECT | DECODE_VARARG),
+                codeOffset - 1
+            );
+
+            assert(decoder.IsInterruptibleSafePoint());
+        }
+    }
+
     if (!decoder.EnumerateLiveSlots(
         pRegisterSet,
         isActiveStackFrame /* reportScratchSlots */,