BRK after throwing calls

src/coreclr/jit/codegenarmarch.cpp

@@ -3394,8 +3394,6 @@ void CodeGen::genCall(GenTreeCall* call)
 
     genCallInstruction(call);
 
-    genDefinePendingCallLabel(call);
-
 #ifdef DEBUG
     // We should not have GC pointers in killed registers live around the call.
     // GC info for arg registers were cleared when consuming arg nodes above
@@ -3411,6 +3409,20 @@ void CodeGen::genCall(GenTreeCall* call)
     assert((gcInfo.gcRegByrefSetCur & killMask) == 0);
 #endif
 
+    if (call->IsNoReturn())
+    {
+        // There are several situations when we need to add another instruction
+        // after a throwing call to help the OS unwinder determine the correct context during unwind.
+        // It also ensures that the gc register liveness doesn't change across throwing call instructions
+        // in fully-interruptible mode.
+        instGen(INS_BREAKPOINT);
+
+        // nothing else needs to be emitted for this call
+        return;
+    }
+
+    genDefinePendingCallLabel(call);
+
     var_types returnType = call->TypeGet();
     if (returnType != TYP_VOID)
     {

src/coreclr/jit/codegenlinear.cpp

@@ -695,39 +695,31 @@ void CodeGen::genCodeForBBlist()
                 break;
 
             case BBJ_THROW:
+#ifdef DEBUG
+            {
                 // If we have a throw at the end of a function or funclet, we need to emit another instruction
                 // afterwards to help the OS unwinder determine the correct context during unwind.
-                // We insert an unexecuted breakpoint instruction in several situations
-                // following a throw instruction:
+                // We need that in the following situations:
                 // 1. If the throw is the last instruction of the function or funclet. This helps
                 //    the OS unwinder determine the correct context during an unwind from the
                 //    thrown exception.
                 // 2. If this is this is the last block of the hot section.
                 // 3. If the subsequent block is a special throw block.
                 // 4. On AMD64, if the next block is in a different EH region.
-                if (block->IsLast() || block->Next()->HasFlag(BBF_FUNCLET_BEG) ||
-                    !BasicBlock::sameEHRegion(block, block->Next()) ||
-                    (!isFramePointerUsed() && compiler->fgIsThrowHlpBlk(block->Next())) ||
-                    block->IsLastHotBlock(compiler))
+                //
+                // The extra instruction is also needed to ensure that gc register liveness doesn't change
+                // across call instructions in fully-interruptible mode.
+                //
+                // Considering that the throwing code is typically rare, and is not on the common/fast path
+                // we just add the instruction after all throwing calls.
+                // We will check that invariant in the most common case - when the throw ends the block.
+                GenTree* call = block->lastNode();
+                if ((call != nullptr) && (call->gtOper == GT_CALL))
                 {
-                    instGen(INS_BREAKPOINT); // This should never get executed
+                    assert(GetEmitter()->emitIsLastInsBreakpoint() || call->AsCall()->IsFastTailCall());
                 }
-                // Do likewise for blocks that end in DOES_NOT_RETURN calls
-                // that were not caught by the above rules. This ensures that
-                // gc register liveness doesn't change across call instructions
-                // in fully-interruptible mode.
-                else
-                {
-                    GenTree* call = block->lastNode();
-
-                    if ((call != nullptr) && (call->gtOper == GT_CALL))
-                    {
-                        if (call->AsCall()->IsNoReturn())
-                        {
-                            instGen(INS_BREAKPOINT); // This should never get executed
-                        }
-                    }
                 }
+#endif // DEBUG
 
                 break;
 

src/coreclr/jit/codegenloongarch64.cpp

@@ -6402,8 +6402,6 @@ void CodeGen::genCall(GenTreeCall* call)
 
     genCallInstruction(call);
 
-    genDefinePendingCallLabel(call);
-
 #ifdef DEBUG
     // We should not have GC pointers in killed registers live around the call.
     // GC info for arg registers were cleared when consuming arg nodes above
@@ -6419,6 +6417,20 @@ void CodeGen::genCall(GenTreeCall* call)
     assert((gcInfo.gcRegByrefSetCur & killMask) == 0);
 #endif
 
+    if (call->IsNoReturn())
+    {
+        // There are several situations when we need to add another instruction
+        // after a throwing call to help the OS unwinder determine the correct context during unwind.
+        // It also ensures that the gc register liveness doesn't change across throwing call instructions
+        // in fully-interruptible mode.
+        instGen(INS_BREAKPOINT);
+
+        // nothing else needs to be emitted for this call
+        return;
+    }
+
+    genDefinePendingCallLabel(call);
+
     var_types returnType = call->TypeGet();
     if (returnType != TYP_VOID)
     {

src/coreclr/jit/codegenriscv64.cpp

@@ -6478,8 +6478,6 @@ void CodeGen::genCall(GenTreeCall* call)
 
     genCallInstruction(call);
 
-    genDefinePendingCallLabel(call);
-
 #ifdef DEBUG
     // We should not have GC pointers in killed registers live around the call.
     // GC info for arg registers were cleared when consuming arg nodes above
@@ -6495,6 +6493,20 @@ void CodeGen::genCall(GenTreeCall* call)
     assert((gcInfo.gcRegByrefSetCur & killMask) == 0);
 #endif
 
+    if (call->IsNoReturn())
+    {
+        // There are several situations when we need to add another instruction
+        // after a throwing call to help the OS unwinder determine the correct context during unwind.
+        // It also ensures that the gc register liveness doesn't change across throwing call instructions
+        // in fully-interruptible mode.
+        instGen(INS_BREAKPOINT);
+
+        // nothing else needs to be emitted for this call
+        return;
+    }
+
+    genDefinePendingCallLabel(call);
+
     var_types returnType = call->TypeGet();
     if (returnType != TYP_VOID)
     {

src/coreclr/jit/codegenxarch.cpp

@@ -6028,8 +6028,6 @@ void CodeGen::genCall(GenTreeCall* call)
 
     genCallInstruction(call X86_ARG(stackArgBytes));
 
-    genDefinePendingCallLabel(call);
-
 #ifdef DEBUG
     // We should not have GC pointers in killed registers live around the call.
     // GC info for arg registers were cleared when consuming arg nodes above
@@ -6045,6 +6043,20 @@ void CodeGen::genCall(GenTreeCall* call)
     assert((gcInfo.gcRegByrefSetCur & killMask) == 0);
 #endif
 
+    if (call->IsNoReturn())
+    {
+        // There are several situations when we need to add another instruction
+        // after a throwing call to help the OS unwinder determine the correct context during unwind.
+        // It also ensures that the gc register liveness doesn't change across throwing call instructions
+        // in fully-interruptible mode.
+        instGen(INS_BREAKPOINT);
+
+        // nothing else needs to be emitted for this call
+        return;
+    }
+
+    genDefinePendingCallLabel(call);
+
     var_types returnType = call->TypeGet();
     if (returnType != TYP_VOID)
     {

src/coreclr/jit/emit.cpp

@@ -2569,6 +2569,17 @@ bool emitter::emitHasEpilogEnd()
 
 #endif // JIT32_GCENCODER
 
+// Is the last instruction emitted a breakpoint instruction?
+bool emitter::emitIsLastInsBreakpoint()
+{
+    if (emitHasLastIns() && (emitLastIns->idIns() == INS_BREAKPOINT))
+    {
+        return true;
+    }
+
+    return false;
+}
+
 #ifdef TARGET_XARCH
 
 /*****************************************************************************

src/coreclr/jit/emit.h

@@ -2757,6 +2757,9 @@ class emitter
         return (emitLastIns != nullptr);
     }
 
+    // Is the last instruction emitted a breakpoint instruction?
+    bool emitIsLastInsBreakpoint();
+
     // Checks to see if we can cross between the two given IG boundaries.
     //
     // We have the following checks: