Add SetCondKindAndTarget

src/coreclr/jit/block.h

@@ -704,8 +704,18 @@ struct BasicBlock : private LIR::Range
         return (bbFalseTarget == target);
     }
 
+    void SetCondKindAndTarget(BasicBlock* target)
+    {
+        assert(target != nullptr);
+        bbKind       = BBJ_COND;
+        bbTrueTarget = target;
+    }
+
     void SetKindAndTarget(BBKinds kind, BasicBlock* target = nullptr)
     {
+        // To set BBJ_COND, use SetCondKindAndTarget
+        assert(kind != BBJ_COND);
+
         bbKind   = kind;
         bbTarget = target;
 

src/coreclr/jit/fgbasic.cpp

@@ -2939,6 +2939,25 @@ void Compiler::fgLinkBasicBlocks()
         switch (curBBdesc->GetKind())
         {
             case BBJ_COND:
+            {
+                BasicBlock* const trueTarget = fgLookupBB(curBBdesc->GetTargetOffs());
+                curBBdesc->SetTrueTarget(trueTarget);
+                curBBdesc->SetFalseTarget(curBBdesc->Next());
+                fgAddRefPred<initializingPreds>(trueTarget, curBBdesc, oldEdge);
+                fgAddRefPred<initializingPreds>(curBBdesc->GetFalseTarget(), curBBdesc, oldEdge);
+
+                if (curBBdesc->GetTrueTarget()->bbNum <= curBBdesc->bbNum)
+                {
+                    fgMarkBackwardJump(curBBdesc->GetTrueTarget(), curBBdesc);
+                }
+
+                if (curBBdesc->IsLast())
+                {
+                    BADCODE("Fall thru the end of a method");
+                }
+
+                break;
+            }
             case BBJ_ALWAYS:
             case BBJ_LEAVE:
             {
@@ -2953,32 +2972,10 @@ void Compiler::fgLinkBasicBlocks()
                 curBBdesc->SetKindAndTarget(curBBdesc->GetKind(), jumpDest);
                 fgAddRefPred<initializingPreds>(jumpDest, curBBdesc, oldEdge);
 
-                // Can this block fall through into the next block?
-                //
-                if (curBBdesc->KindIs(BBJ_ALWAYS, BBJ_LEAVE))
-                {
-                    if (curBBdesc->GetTarget()->bbNum <= curBBdesc->bbNum)
-                    {
-                        fgMarkBackwardJump(curBBdesc->GetTarget(), curBBdesc);
-                    }
-                    break;
-                }
-
-                // The fall-through block is also reachable
-                assert(curBBdesc->KindIs(BBJ_COND));
-
-                if (curBBdesc->GetTrueTarget()->bbNum <= curBBdesc->bbNum)
+                if (curBBdesc->GetTarget()->bbNum <= curBBdesc->bbNum)
                 {
-                    fgMarkBackwardJump(curBBdesc->GetTrueTarget(), curBBdesc);
+                    fgMarkBackwardJump(curBBdesc->GetTarget(), curBBdesc);
                 }
-
-                if (curBBdesc->IsLast())
-                {
-                    BADCODE("Fall thru the end of a method");
-                }
-
-                curBBdesc->SetFalseTarget(curBBdesc->Next());
-                fgAddRefPred<initializingPreds>(curBBdesc->GetFalseTarget(), curBBdesc, oldEdge);
                 break;
             }
 

src/coreclr/jit/fgopt.cpp

@@ -1759,7 +1759,7 @@ PhaseStatus Compiler::fgPostImportationCleanup()
                     GenTree* const jumpIfEntryStateZero = gtNewOperNode(GT_JTRUE, TYP_VOID, compareEntryStateToZero);
                     fgNewStmtAtBeg(fromBlock, jumpIfEntryStateZero);
 
-                    fromBlock->SetKindAndTarget(BBJ_COND, toBlock);
+                    fromBlock->SetCondKindAndTarget(toBlock);
                     fgAddRefPred(toBlock, fromBlock);
                     newBlock->inheritWeight(fromBlock);
 
@@ -2315,7 +2315,7 @@ void Compiler::fgCompactBlocks(BasicBlock* block, BasicBlock* bNext)
             break;
 
         case BBJ_COND:
-            block->SetKindAndTarget(BBJ_COND, bNext->GetTrueTarget());
+            block->SetCondKindAndTarget(bNext->GetTrueTarget());
 
             /* Update the predecessor list for 'bNext->bbTarget' */
             fgReplacePred(bNext->GetTrueTarget(), bNext, block);
@@ -3310,7 +3310,7 @@ bool Compiler::fgOptimizeSwitchBranches(BasicBlock* block)
             fgSetStmtSeq(switchStmt);
         }
 
-        block->SetKindAndTarget(BBJ_COND, block->GetSwtTarget()->bbsDstTab[0]);
+        block->SetCondKindAndTarget(block->GetSwtTarget()->bbsDstTab[0]);
 
         JITDUMP("After:\n");
         DISPNODE(switchTree);
@@ -3720,7 +3720,7 @@ bool Compiler::fgOptimizeUncondBranchToSimpleCond(BasicBlock* block, BasicBlock*
 
     // Fix up block's flow
     //
-    block->SetKindAndTarget(BBJ_COND, target->GetTrueTarget());
+    block->SetCondKindAndTarget(target->GetTrueTarget());
     fgAddRefPred(block->GetTrueTarget(), block);
     fgRemoveRefPred(target, block);
 
@@ -4132,7 +4132,7 @@ bool Compiler::fgOptimizeBranch(BasicBlock* bJump)
     // We need to update the following flags of the bJump block if they were set in the bDest block
     bJump->CopyFlags(bDest, BBF_COPY_PROPAGATE);
 
-    bJump->SetKindAndTarget(BBJ_COND, bDestNormalTarget);
+    bJump->SetCondKindAndTarget(bDestNormalTarget);
     bJump->SetFalseTarget(bJump->Next());
 
     /* Update bbRefs and bbPreds */
@@ -4293,7 +4293,7 @@ bool Compiler::fgOptimizeSwitchJumps()
 
         // Wire up the new control flow.
         //
-        block->SetKindAndTarget(BBJ_COND, dominantTarget);
+        block->SetCondKindAndTarget(dominantTarget);
         FlowEdge* const blockToTargetEdge   = fgAddRefPred(dominantTarget, block);
         FlowEdge* const blockToNewBlockEdge = newBlock->bbPreds;
         assert(blockToNewBlockEdge->getSourceBlock() == block);

src/coreclr/jit/flowgraph.cpp

@@ -394,7 +394,7 @@ BasicBlock* Compiler::fgCreateGCPoll(GCPollType pollType, BasicBlock* block)
         }
 #endif
 
-        top->SetKindAndTarget(BBJ_COND, bottom);
+        top->SetCondKindAndTarget(bottom);
         // Bottom has Top and Poll as its predecessors.  Poll has just Top as a predecessor.
         fgAddRefPred(bottom, poll);
         fgAddRefPred(bottom, top);

src/coreclr/jit/indirectcalltransformer.cpp

@@ -278,7 +278,7 @@ class IndirectCallTransformer
 
             // checkBlock
             assert(checkBlock->KindIs(BBJ_ALWAYS));
-            checkBlock->SetKindAndTarget(BBJ_COND, elseBlock);
+            checkBlock->SetCondKindAndTarget(elseBlock);
             compiler->fgAddRefPred(elseBlock, checkBlock);
             compiler->fgAddRefPred(thenBlock, checkBlock);
 
@@ -591,7 +591,7 @@ class IndirectCallTransformer
                 checkFallsThrough          = false;
 
                 // prevCheckBlock is expected to jump to this new check (if its type check doesn't succeed)
-                prevCheckBlock->SetKindAndTarget(BBJ_COND, checkBlock);
+                prevCheckBlock->SetCondKindAndTarget(checkBlock);
                 compiler->fgAddRefPred(checkBlock, prevCheckBlock);
 
                 // Calculate the total likelihood for this check as a sum of likelihoods
@@ -1031,7 +1031,7 @@ class IndirectCallTransformer
             // where we know the last check is always true (in case of "exact" GDV)
             if (!checkFallsThrough)
             {
-                checkBlock->SetKindAndTarget(BBJ_COND, elseBlock);
+                checkBlock->SetCondKindAndTarget(elseBlock);
                 compiler->fgAddRefPred(elseBlock, checkBlock);
             }
             else

src/coreclr/jit/lower.cpp

@@ -965,7 +965,7 @@ GenTree* Lowering::LowerSwitch(GenTree* node)
     // The GT_SWITCH code is still in originalSwitchBB (it will be removed later).
 
     // Turn originalSwitchBB into a BBJ_COND.
-    originalSwitchBB->SetKindAndTarget(BBJ_COND, jumpTab[jumpCnt - 1]);
+    originalSwitchBB->SetCondKindAndTarget(jumpTab[jumpCnt - 1]);
 
     // Fix the pred for the default case: the default block target still has originalSwitchBB
     // as a predecessor, but the fgSplitBlockAfterStatement() moved all predecessors to point
@@ -1100,7 +1100,7 @@ GenTree* Lowering::LowerSwitch(GenTree* node)
             {
                 // Otherwise, it's a conditional branch. Set the branch kind, then add the
                 // condition statement.
-                currentBlock->SetKindAndTarget(BBJ_COND, jumpTab[i]);
+                currentBlock->SetCondKindAndTarget(jumpTab[i]);
 
                 // Now, build the conditional statement for the current case that is
                 // being evaluated:
@@ -1312,7 +1312,7 @@ bool Lowering::TryLowerSwitchToBitTest(
     {
         // GenCondition::C generates JC so we jump to bbCase1 when the bit is set
         bbSwitchCondition = GenCondition::C;
-        bbSwitch->SetKindAndTarget(BBJ_COND, bbCase1);
+        bbSwitch->SetCondKindAndTarget(bbCase1);
 
         comp->fgAddRefPred(bbCase0, bbSwitch);
         comp->fgAddRefPred(bbCase1, bbSwitch);
@@ -1323,7 +1323,7 @@ bool Lowering::TryLowerSwitchToBitTest(
 
         // GenCondition::NC generates JNC so we jump to bbCase0 when the bit is not set
         bbSwitchCondition = GenCondition::NC;
-        bbSwitch->SetKindAndTarget(BBJ_COND, bbCase0);
+        bbSwitch->SetCondKindAndTarget(bbCase0);
 
         comp->fgAddRefPred(bbCase0, bbSwitch);
         comp->fgAddRefPred(bbCase1, bbSwitch);

src/coreclr/jit/morph.cpp

@@ -14904,7 +14904,7 @@ bool Compiler::fgExpandQmarkStmt(BasicBlock* block, Statement* stmt)
         //              bbj_cond(true)
         //
         gtReverseCond(condExpr);
-        condBlock->SetKindAndTarget(BBJ_COND, elseBlock);
+        condBlock->SetCondKindAndTarget(elseBlock);
 
         thenBlock = fgNewBBafter(BBJ_ALWAYS, condBlock, true, remainderBlock);
         thenBlock->SetFlags(propagateFlagsToAll);
@@ -14929,7 +14929,7 @@ bool Compiler::fgExpandQmarkStmt(BasicBlock* block, Statement* stmt)
         //              bbj_cond(true)
         //
         gtReverseCond(condExpr);
-        condBlock->SetKindAndTarget(BBJ_COND, remainderBlock);
+        condBlock->SetCondKindAndTarget(remainderBlock);
         fgAddRefPred(remainderBlock, condBlock);
         // Since we have no false expr, use the one we'd already created.
         thenBlock = elseBlock;
@@ -14945,7 +14945,7 @@ bool Compiler::fgExpandQmarkStmt(BasicBlock* block, Statement* stmt)
         //              +-->------------+
         //              bbj_cond(true)
         //
-        condBlock->SetKindAndTarget(BBJ_COND, remainderBlock);
+        condBlock->SetCondKindAndTarget(remainderBlock);
         fgAddRefPred(remainderBlock, condBlock);
 
         elseBlock->inheritWeightPercentage(condBlock, 50);

src/coreclr/jit/optimizer.cpp

@@ -2846,7 +2846,7 @@ void Compiler::optCopyBlkDest(BasicBlock* from, BasicBlock* to)
             to->SetEhfKindAndTarget(new (this, CMK_BasicBlock) BBehfDesc(this, from->GetEhfTarget()));
             break;
         case BBJ_COND:
-            to->SetKindAndTarget(BBJ_COND, from->GetTrueTarget());
+            to->SetCondKindAndTarget(from->GetTrueTarget());
             break;
         default:
             to->SetKindAndTarget(from->GetKind(), from->GetTarget());

src/coreclr/jit/patchpoint.cpp

@@ -146,7 +146,7 @@ class PatchpointTransformer
         BasicBlock* helperBlock    = CreateAndInsertBasicBlock(BBJ_ALWAYS, block, block->Next());
 
         // Update flow and flags
-        block->SetKindAndTarget(BBJ_COND, remainderBlock);
+        block->SetCondKindAndTarget(remainderBlock);
         block->SetFlags(BBF_INTERNAL);
 
         helperBlock->SetFlags(BBF_BACKWARD_JUMP | BBF_NONE_QUIRK);