NOP

Author: VSadov

src/coreclr/jit/codegenlinear.cpp

@@ -774,19 +774,46 @@ void CodeGen::genCodeForBBlist()
                 // If this block jumps to the next one, we might be able to skip emitting the jump
                 if (block->CanRemoveJumpToNext(compiler))
                 {
+                    removedJmp = true;
 #ifdef TARGET_AMD64
                     if (emitNopBeforeEHRegion)
                     {
                         instGen(INS_nop);
+                        break;
                     }
 #endif // TARGET_AMD64
 
-                    removedJmp = true;
+                    // if liveness is changing and the last block ended on emitting a call that can do GC,
+                    // emit a NOP to ensure that GC info is not changing between
+                    // "call has been made" and "call has returned" states.
+                    if (GetEmitter()->emitLastInsIsCallWithGC())
+                    {
+                        BasicBlock* nextBlock = block->Next();
+                        if (nextBlock && !VarSetOps::Equal(compiler, block->bbLiveOut, nextBlock->bbLiveIn))
+                        {
+                            // sanity check: we can only see a reduction of live variable set.
+                            assert(VarSetOps::IsSubset(compiler, nextBlock->bbLiveIn, block->bbLiveOut));
+                            instGen(INS_nop);
+                        }
+                    }
+
                     break;
                 }
 #ifdef TARGET_XARCH
                 // Do not remove a jump between hot and cold regions.
                 bool isRemovableJmpCandidate = !compiler->fgInDifferentRegions(block, block->GetTarget());
+                // if liveness is changing and we've just emitted a GC-capable call, the jump is not removable
+                // to ensure that GC info is not changing between
+                // "call has been made" and "call has returned" states.
+                if (isRemovableJmpCandidate && GetEmitter()->emitLastInsIsCallWithGC())
+                {
+                    if (!VarSetOps::Equal(compiler, block->bbLiveOut, block->GetTarget()->bbLiveIn))
+                    {
+                        // sanity check: we can only see a reduction of live variable set.
+                        assert(VarSetOps::IsSubset(compiler, block->GetTarget()->bbLiveIn, block->bbLiveOut));
+                        isRemovableJmpCandidate = false;
+                    }
+                }
 
                 inst_JMP(EJ_jmp, block->GetTarget(), isRemovableJmpCandidate);
 #else

src/coreclr/jit/emit.cpp

@@ -3640,8 +3640,9 @@ emitter::instrDesc* emitter::emitNewInstrCallInd(int              argCnt,
         instrDescCGCA* id;
 
         id = emitAllocInstrCGCA(retSize);
-
-        id->idSetIsLargeCall();
+        id->idSetIsLargeCns();
+        id->idSetIsCall();
+        assert(id->idIsLargeCall());
 
         VarSetOps::Assign(emitComp, id->idcGCvars, GCvars);
         id->idcGcrefRegs = gcrefRegs;
@@ -3663,6 +3664,7 @@ emitter::instrDesc* emitter::emitNewInstrCallInd(int              argCnt,
 
         /* Make sure we didn't waste space unexpectedly */
         assert(!id->idIsLargeCns());
+        id->idSetIsCall();
 
 #ifdef TARGET_XARCH
         /* Store the displacement and make sure the value fit */
@@ -3720,7 +3722,9 @@ emitter::instrDesc* emitter::emitNewInstrCallDir(int              argCnt,
 
         // printf("Direct call with GC vars / big arg cnt / explicit scope\n");
 
-        id->idSetIsLargeCall();
+        id->idSetIsLargeCns();
+        id->idSetIsCall();
+        assert(id->idIsLargeCall());
 
         VarSetOps::Assign(emitComp, id->idcGCvars, GCvars);
         id->idcGcrefRegs = gcrefRegs;
@@ -3742,6 +3746,7 @@ emitter::instrDesc* emitter::emitNewInstrCallDir(int              argCnt,
 
         /* Make sure we didn't waste space unexpectedly */
         assert(!id->idIsLargeCns());
+        id->idSetIsCall();
 
         /* Save the live GC registers in the unused register fields */
         assert((gcrefRegs & RBM_CALLEE_TRASH) == 0);
@@ -8763,6 +8768,16 @@ void emitter::emitUpdateLiveGCvars(VARSET_VALARG_TP vars, BYTE* addr)
     emitThisGCrefVset = true;
 }
 
+/*****************************************************************************
+ *
+ *  Last emitted instruction is a call that is not a NoGC call.
+ */
+
+bool emitter::emitLastInsIsCallWithGC()
+{
+    return emitLastIns != nullptr && emitLastIns->idIsCall() && !emitLastIns->idIsNoGC();
+}
+
 /*****************************************************************************
  *
  *  Record a call location for GC purposes (we know that this is a method that

src/coreclr/jit/emit.h

@@ -763,10 +763,10 @@ class emitter
         // loongarch64: 28 bits
         // risc-v:      28 bits
 
-        unsigned _idSmallDsc : 1;  // is this a "small" descriptor?
-        unsigned _idLargeCns : 1;  // does a large constant     follow?
-        unsigned _idLargeDsp : 1;  // does a large displacement follow?
-        unsigned _idLargeCall : 1; // large call descriptor used
+        unsigned _idSmallDsc : 1; // is this a "small" descriptor?
+        unsigned _idLargeCns : 1; // does a large constant     follow?
+        unsigned _idLargeDsp : 1; // does a large displacement follow?
+        unsigned _idCall : 1;     // this is a call
 
         // We have several pieces of information we need to encode but which are only applicable
         // to a subset of instrDescs. To accommodate that, we define a several _idCustom# bitfields
@@ -1592,13 +1592,18 @@ class emitter
             _idLargeDsp = 0;
         }
 
-        bool idIsLargeCall() const
+        bool idIsCall() const
+        {
+            return _idCall != 0;
+        }
+        void idSetIsCall()
         {
-            return _idLargeCall != 0;
+            _idCall = 1;
         }
-        void idSetIsLargeCall()
+
+        bool idIsLargeCall() const
         {
-            _idLargeCall = 1;
+            return idIsCall() && idIsLargeCns();
         }
 
         bool idIsBound() const
@@ -3196,6 +3201,8 @@ class emitter
 
     void emitRecordGCcall(BYTE* codePos, unsigned char callInstrSize);
 
+    bool emitLastInsIsCallWithGC();
+
     // Helpers for the above
 
     void emitStackPushLargeStk(BYTE* addr, GCtype gcType, unsigned count = 1);