[SimplifyCFG] Relax restriction for folding unconditional branches

[skatkov]

Summary

The commit rL308422 introduces a restriction for folding unconditional
branches. Specifically if empty block with unconditional branch leads to
header of the loop then elimination of this basic block is prohibited.
However it seems this condition is redundantly strict.
If elimination of this basic block does not introduce more back edges
then we can eliminate this block.

The patch implements this relax of restriction.

[skatkov]

ping

[pacxx]

LGTM

[efriedma]

lib/Transforms/Utils/SimplifyCFG.cpp

5740 ↗

(On Diff #131967)

getSinglePredecessor()?

test/Transforms/SimplifyCFG/UncondBranchToHeader.ll

16 ↗

(On Diff #131967)

Do we really need SimplifyCFG to rotate loops? We have a dedicated LoopRotate pass for this sort of transform.

But I guess it's okay.

[skatkov]

lib/Transforms/Utils/SimplifyCFG.cpp

5740 ↗

(On Diff #131967)

make sense.

test/Transforms/SimplifyCFG/UncondBranchToHeader.ll

16 ↗

(On Diff #131967)

Hi Eli, I did not follow what you mean here as rotate loop?

Header will be the same. In this particular case the loop will just consists from one basic block header after transformation...

[skatkov]

test/Transforms/SimplifyCFG/UncondBranchToHeader.ll

16 ↗

(On Diff #131967)

Or you mean that before it was not bottom formed loop and now it is?

[efriedma]

test/Transforms/SimplifyCFG/UncondBranchToHeader.ll

16 ↗

(On Diff #131967)

I don't think I've ever seen the term "bottom formed loop", but yes, that's what I meant.

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

bool SimplifyCFGOpt::SimplifyUncondBranch(BranchInst *BI,
   BasicBlock *BB = BI->getParent();
   BasicBlock *Succ = BI->getSuccessor(0);
 
   // If the Terminator is the only non-phi instruction, simplify the block.
   // If LoopHeader is provided, check if the block or its successor is a loop
   // header. (This is for early invocations before loop simplify and
   // vectorization to keep canonical loop forms for nested loops. These blocks
   // can be eliminated when the pass is invoked later in the back-end.)
+  // Note that if BB has only one predecessor then we do not introduce new
+  // backedge, so we can eliminate BB.
   bool NeedCanonicalLoop =
       Options.NeedCanonicalLoop &&
-      (LoopHeaders && (LoopHeaders->count(BB) || LoopHeaders->count(Succ)));
+      (LoopHeaders && !BB->getSinglePredecessor() &&
+       (LoopHeaders->count(BB) || LoopHeaders->count(Succ)));
   BasicBlock::iterator I = BB->getFirstNonPHIOrDbg()->getIterator();
   if (I->isTerminator() && BB != &BB->getParent()->getEntryBlock() &&
       !NeedCanonicalLoop && TryToSimplifyUncondBranchFromEmptyBlock(BB))
     return true;
 
   // If the only instruction in the block is a seteq/setne comparison against a
   // constant, try to simplify the block.
   if (ICmpInst *ICI = dyn_cast<ICmpInst>(I))

llvm/trunk/test/Transforms/LoopUnroll/peel-loop.ll

 ; CHECK: store i32 1, i32* %[[INC1]], align 4
 ; CHECK: %[[CMP2:.*]] = icmp sgt i32 %k, 2
 ; CHECK: br i1 %[[CMP2]], label %[[NEXT2:.*]], label %for.end
 ; CHECK: [[NEXT2]]:
 ; CHECK: %[[INC2:.*]] = getelementptr inbounds i32, i32* %p, i64 2
 ; CHECK: store i32 2, i32* %[[INC2]], align 4
 ; CHECK: %[[CMP3:.*]] = icmp eq i32 %k, 3
 ; CHECK: br i1 %[[CMP3]], label %for.end, label %[[LOOP_PH:.*]]
-; CHECK: [[LOOP_PH]]:
-; CHECK: br label %[[LOOP:.*]]
-; CHECK: [[LOOP]]:
-; CHECK: %[[IV:.*]] = phi i32 [ 3, %[[LOOP_PH]] ], [ {{.*}}, %[[LOOP]] ]
+; CHECK: for.end:
+; CHECK: ret void
 
 define void @basic(i32* %p, i32 %k) #0 {
 entry:
   %cmp3 = icmp slt i32 0, %k
   br i1 %cmp3, label %for.body.lr.ph, label %for.end
 
 for.body.lr.ph:                                   ; preds = %entry
   br label %for.body

 ; CHECK: store i32 1, i32* %[[INC1]], align 4
 ; CHECK: %[[CMP2:.*]] = icmp sgt i32 %k, 2
 ; CHECK: br i1 %[[CMP2]], label %[[NEXT2:.*]], label %for.end
 ; CHECK: [[NEXT2]]:
 ; CHECK: %[[INC2:.*]] = getelementptr inbounds i32, i32* %p, i64 2
 ; CHECK: store i32 2, i32* %[[INC2]], align 4
 ; CHECK: %[[CMP3:.*]] = icmp eq i32 %k, 3
 ; CHECK: br i1 %[[CMP3]], label %for.end, label %[[LOOP_PH:.*]]
-; CHECK: [[LOOP_PH]]:
-; CHECK: br label %[[LOOP:.*]]
-; CHECK: [[LOOP]]:
-; CHECK: %[[IV:.*]] = phi i32 [ 3, %[[LOOP_PH]] ], [ %[[IV:.*]], %[[LOOP]] ]
-; CHECK: %ret = phi i32 [ 0, %entry ], [ 1, %[[NEXT0]] ], [ 2, %[[NEXT1]] ], [ 3, %[[NEXT2]] ], [ %[[IV]], %[[LOOP]] ]
+; CHECK: for.end:
+; CHECK: %ret = phi i32 [ 0, %entry ], [ 1, %[[NEXT0]] ], [ 2, %[[NEXT1]] ], [ 3, %[[NEXT2]] ], [ %inc, %for.body ]
 ; CHECK: ret i32 %ret
 define i32 @output(i32* %p, i32 %k) #0 {
 entry:
   %cmp3 = icmp slt i32 0, %k
   br i1 %cmp3, label %for.body.lr.ph, label %for.end
 
 for.body.lr.ph:                                   ; preds = %entry
   br label %for.body

llvm/trunk/test/Transforms/LoopUnswitch/2015-06-17-Metadata.ll

 
 for.body:                                         ; preds = %for.inc, %for.body.lr.ph
   %inc.i = phi i32 [ 0, %for.body.lr.ph ], [ %inc, %for.inc ]
   %mul.i = phi i32 [ 3, %for.body.lr.ph ], [ %mul.p, %for.inc ]
   %add.i = phi i32 [ %a, %for.body.lr.ph ], [ %add.p, %for.inc ]
   %cmp1 = icmp eq i32 %a, 12345
   br i1 %cmp1, label %if.then, label %if.else, !prof !0
 ; CHECK: %cmp1 = icmp eq i32 %a, 12345
-; CHECK-NEXT: br i1 %cmp1, label %for.body.preheader.split.us, label %for.body.preheader.split, !prof !0
+; CHECK-NEXT: br i1 %cmp1, label %for.body.us, label %for.body, !prof !0
 if.then:                                          ; preds = %for.body
 ; CHECK: for.body.us:
 ; CHECK: add nsw i32 %{{.*}}, 123
 ; CHECK: %exitcond.us = icmp eq i32 %inc.us, %b
 ; CHECK: br i1 %exitcond.us, label %for.cond.cleanup, label %for.body.us
   %add = add nsw i32 %add.i, 123
   br label %for.inc
 

 }
 
 define void @foo_swapped(i32 %a, i32 %b) {
 ;CHECK-LABEL: foo_swapped
 entry:
   br label %for.body
 ;CHECK: entry:
 ;CHECK-NEXT: %cmp1 = icmp eq i32 1, 2
-;CHECK-NEXT: br i1 %cmp1, label %entry.split, label %for.cond.cleanup.split, !prof !1
+;CHECK-NEXT: br i1 %cmp1, label %for.body, label %for.cond.cleanup.split, !prof !1
 ;CHECK: for.body:
 for.body:                                         ; preds = %for.inc, %entry
   %inc.i = phi i32 [ 0, %entry ], [ %inc, %if.then ]
   %add.i = phi i32 [ 100, %entry ], [ %add, %if.then ]
   %inc = add nuw nsw i32 %inc.i, 1
   %cmp1 = icmp eq i32 1, 2
   br i1 %cmp1, label %if.then, label  %for.cond.cleanup, !prof !0
 

llvm/trunk/test/Transforms/LoopUnswitch/infinite-loop.ll

 ; STATS: 2 loop-unswitch - Number of branches unswitched
 ; STATS: 2 loop-unswitch - Number of unswitches that are trivial
 
 ; CHECK-LABEL: @func_16(
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT: br i1 %a, label %entry.split, label %abort0.split
 
 ; CHECK: entry.split:
-; CHECK-NEXT: br i1 %b, label %entry.split.split, label %abort1.split
+; CHECK-NEXT: br i1 %b, label %for.body, label %abort1.split
 
 ; CHECK: for.body:
 ; CHECK-NEXT: br label %for.body
 
 ; CHECK: abort0.split:
 ; CHECK-NEXT: call void @end0() [[NOR_NUW:#[0-9]+]]
 ; CHECK-NEXT: unreachable
 

llvm/trunk/test/Transforms/SimplifyCFG/UncondBranchToHeader.ll

+; RUN: opt < %s -simplifycfg -S | FileCheck %s
+
+; Check that we can get rid of empty block leading to header
+; if it does not introduce new edge.
+define i32 @test(i32 %c) {
+entry:
+  br label %header
+header:
+  %i = phi i32 [0, %entry], [%i.1, %backedge]
+  %i.1 = add i32 %i, 1
+  %cmp = icmp slt i32 %i.1, %c
+  br i1 %cmp, label %backedge, label %exit
+; CHECK-NOT: backedge:
+backedge:
+  br label %header
+exit:
+  ret i32 %i
+}