[CloneFunction] Constant fold terminators before checking single predecessor

[uabelho]

Summary

This fixes PR31105.

There is code trying to delete dead code that does so by e.g. checking if
the single predecessor of a block is the block itself.

That check fails on a block like this
bb:

br i1 undef, label %bb, label %bb

since that has two (identical) predecessors.

However, after the check for dead blocks there is a call to
ConstantFoldTerminator on the basic block, and that call simplifies the
block to
bb:

br label %bb

Therefore we now do the call to ConstantFoldTerminator before the check if
the block is dead, so it can realize that it really is.

The original behavior lead to the block not being removed, but it was
simplified as above, and then we did a call to

Dest->replaceAllUsesWith(&*I);

with old and new being equal, and an assertion triggered.

[fhahn]

LGTM thanks!

test/Transforms/Inline/infinite-loop-two-predecessors.ll

3 ↗

(On Diff #162616)

nit: I think the test could be simplified a bit

define void @f1() {
bb.0:
  br i1 false, label %bb.2, label %bb.1

bb.1:                                             ; preds = %bb.0
  br label %bb.2

bb.2:                                             ; preds = %bb.0, %bb.1
  %tmp0 = phi i1 [ true, %bb.1 ], [ false, %bb.0 ]
  br i1 %tmp0, label %bb.6, label %bb.5

bb.5:                                             ; preds = %bb.5, %bb.5
  br i1 undef, label %bb.5, label %bb.5

bb.6:                                             ; preds = %bb.2
  ret void
}

36 ↗

(On Diff #162616)

CHECK-LABEL?

[uabelho]

Update testcase

[uabelho]

test/Transforms/Inline/infinite-loop-two-predecessors.ll

3 ↗

(On Diff #162616)

Indeed. Thanks!

36 ↗

(On Diff #162616)

Ok. Out of curiosity, is anything really better with CHECK-LABEL compared to CHECK in this case?

llvm/trunk/lib/Transforms/Utils/CloneFunction.cpp

#endif
 
   // Now that the inlined function body has been fully constructed, go through
   // and zap unconditional fall-through branches. This happens all the time when
   // specializing code: code specialization turns conditional branches into
   // uncond branches, and this code folds them.
   Function::iterator Begin = cast<BasicBlock>(VMap[StartingBB])->getIterator();
   Function::iterator I = Begin;
   while (I != NewFunc->end()) {
+    // We need to simplify conditional branches and switches with a constant
+    // operand. We try to prune these out when cloning, but if the
+    // simplification required looking through PHI nodes, those are only
+    // available after forming the full basic block. That may leave some here,
+    // and we still want to prune the dead code as early as possible.
+    //
+    // Do the folding before we check if the block is dead since we want code
+    // like
+    //  bb:
+    //    br i1 undef, label %bb, label %bb
+    // to be simplified to
+    //  bb:
+    //    br label %bb
+    // before we call I->getSinglePredecessor().
+    ConstantFoldTerminator(&*I);
+
     // Check if this block has become dead during inlining or other
     // simplifications. Note that the first block will appear dead, as it has
     // not yet been wired up properly.
     if (I != Begin && (pred_begin(&*I) == pred_end(&*I) ||
                        I->getSinglePredecessor() == &*I)) {
       BasicBlock *DeadBB = &*I++;
       DeleteDeadBlock(DeadBB);
       continue;
     }
 
-    // We need to simplify conditional branches and switches with a constant
-    // operand. We try to prune these out when cloning, but if the
-    // simplification required looking through PHI nodes, those are only
-    // available after forming the full basic block. That may leave some here,
-    // and we still want to prune the dead code as early as possible.
-    ConstantFoldTerminator(&*I);
-
     BranchInst *BI = dyn_cast<BranchInst>(I->getTerminator());
     if (!BI || BI->isConditional()) { ++I; continue; }
 
     BasicBlock *Dest = BI->getSuccessor(0);
     if (!Dest->getSinglePredecessor()) {
       ++I; continue;
     }
 

llvm/trunk/test/Transforms/Inline/infinite-loop-two-predecessors.ll

+; RUN: opt -S -o - %s -inline | FileCheck %s
+
+define void @f1() {
+bb.0:
+  br i1 false, label %bb.2, label %bb.1
+
+bb.1:                                             ; preds = %bb.0
+  br label %bb.2
+
+bb.2:                                             ; preds = %bb.0, %bb.1
+  %tmp0 = phi i1 [ true, %bb.1 ], [ false, %bb.0 ]
+  br i1 %tmp0, label %bb.4, label %bb.3
+
+bb.3:                                             ; preds = %bb.3, %bb.3
+  br i1 undef, label %bb.3, label %bb.3
+
+bb.4:                                             ; preds = %bb.2
+  ret void
+}
+
+define void @f2() {
+bb.0:
+  call void @f1()
+  ret void
+}
+
+; f1 should be inlined into f2 and simplified/collapsed to nothing.
+
+; CHECK-LABEL: define void @f2() {
+; CHECK-NEXT:  bb.0:
+; CHECK-NEXT:    ret void
+; CHECK-NEXT:  }