[SimplifyCFG] Guard branch folding by speculate blocks flag

[tejohnson]

Summary

Guard FoldBranchToCommonDest in SimplifyCFG with the SpeculateBlocks
flag as it can also speculate instructions.

This was split out of D155997.

[nikic]

LGTM

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

if (LandingPadInst *LPad = dyn_cast<LandingPadInst>(I)) {
     if (I->isTerminator() && TryToMergeLandingPad(LPad, BI, BB, DTU))
       return true;
   }
 
   // If this basic block is ONLY a compare and a branch, and if a predecessor
   // branches to us and our successor, fold the comparison into the
   // predecessor and use logical operations to update the incoming value
   // for PHI nodes in common successor.
-  if (FoldBranchToCommonDest(BI, DTU, /*MSSAU=*/nullptr, &TTI,
+  if (Options.SpeculateBlocks &&
+      FoldBranchToCommonDest(BI, DTU, /*MSSAU=*/nullptr, &TTI,
                              Options.BonusInstThreshold))
     return requestResimplify();
   return false;
 }
 
 static BasicBlock *allPredecessorsComeFromSameSource(BasicBlock *BB) {
   BasicBlock *PredPred = nullptr;
   for (auto *P : predecessors(BB)) {
if (Imp) {
     BI->setCondition(TorF);
     RecursivelyDeleteTriviallyDeadInstructions(OldCond);
     return requestResimplify();
   }
 
   // If this basic block is ONLY a compare and a branch, and if a predecessor
   // branches to us and one of our successors, fold the comparison into the
   // predecessor and use logical operations to pick the right destination.
-  if (FoldBranchToCommonDest(BI, DTU, /*MSSAU=*/nullptr, &TTI,
+  if (Options.SpeculateBlocks &&
+      FoldBranchToCommonDest(BI, DTU, /*MSSAU=*/nullptr, &TTI,
                              Options.BonusInstThreshold))
     return requestResimplify();
 
   // We have a conditional branch to two blocks that are only reachable
   // from BI.  We know that the condbr dominates the two blocks, so see if
   // there is any identical code in the "then" and "else" blocks.  If so, we
   // can hoist it up to the branching block.
   if (BI->getSuccessor(0)->getSinglePredecessor()) {

llvm/test/Transforms/SimplifyCFG/speculate-blocks.ll

 entry:
   br i1 %a, label %bb, label %bb2
 bb:
   br label %bb2
 bb2:
   %r = phi i32 [ 2, %entry ], [ 5, %bb ]
   ret i32 %r
 }
+
+define void @fold_branch_to_common_dest(i8 %v0, i8 %v1) {
+; YES-LABEL: define void @fold_branch_to_common_dest
+; YES-SAME: (i8 [[V0:%.*]], i8 [[V1:%.*]]) {
+; YES-NEXT:  pred:
+; YES-NEXT:    [[C0:%.*]] = icmp eq i8 [[V0]], 0
+; YES-NEXT:    [[C1:%.*]] = icmp eq i8 [[V1]], 0
+; YES-NEXT:    [[OR_COND:%.*]] = select i1 [[C0]], i1 [[C1]], i1 false
+; YES-NEXT:    br i1 [[OR_COND]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT:%.*]]
+; YES:       common.ret:
+; YES-NEXT:    ret void
+; YES:       final_left:
+; YES-NEXT:    call void @sideeffect0()
+; YES-NEXT:    br label [[COMMON_RET:%.*]]
+; YES:       final_right:
+; YES-NEXT:    call void @sideeffect1()
+; YES-NEXT:    br label [[COMMON_RET]]
+;
+; NO-LABEL: define void @fold_branch_to_common_dest
+; NO-SAME: (i8 [[V0:%.*]], i8 [[V1:%.*]]) {
+; NO-NEXT:  pred:
+; NO-NEXT:    [[C0:%.*]] = icmp eq i8 [[V0]], 0
+; NO-NEXT:    br i1 [[C0]], label [[DISPATCH:%.*]], label [[FINAL_RIGHT:%.*]]
+; NO:       dispatch:
+; NO-NEXT:    [[C1:%.*]] = icmp eq i8 [[V1]], 0
+; NO-NEXT:    br i1 [[C1]], label [[FINAL_LEFT:%.*]], label [[FINAL_RIGHT]]
+; NO:       common.ret:
+; NO-NEXT:    ret void
+; NO:       final_left:
+; NO-NEXT:    call void @sideeffect0()
+; NO-NEXT:    br label [[COMMON_RET:%.*]]
+; NO:       final_right:
+; NO-NEXT:    call void @sideeffect1()
+; NO-NEXT:    br label [[COMMON_RET]]
+;
+pred:
+  %c0 = icmp eq i8 %v0, 0
+  br i1 %c0, label %dispatch, label %final_right
+dispatch:
+  %c1 = icmp eq i8 %v1, 0
+  br i1 %c1, label %final_left, label %final_right
+final_left:
+  call void @sideeffect0()
+  ret void
+final_right:
+  call void @sideeffect1()
+  ret void
+}
+
+declare void @sideeffect0()
+declare void @sideeffect1()