Revert "blockfreq: Approximate irreducible control flow"

This reverts commit r207286.  It causes an ICE on the
cmake-llvm-x86_64-linux buildbot [1]:

    llvm/lib/Analysis/BlockFrequencyInfo.cpp: In lambda function:
    llvm/lib/Analysis/BlockFrequencyInfo.cpp:182:1: internal compiler error: in get_expr_operands, at tree-ssa-operands.c:1035

[1]: http://bb.pgr.jp/builders/cmake-llvm-x86_64-linux/builds/12093/steps/build_llvm/logs/stdio

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207287 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 56 insertions, 281 deletions

diff --git a/test/Analysis/BlockFrequencyInfo/irreducible.ll b/test/Analysis/BlockFrequencyInfo/irreducible.ll
index af4ad15d9c..dd4dd9ed79 100644
--- a/test/Analysis/BlockFrequencyInfo/irreducible.ll
+++ b/test/Analysis/BlockFrequencyInfo/irreducible.ll
@@ -34,28 +34,16 @@ return:
 !0 = metadata !{metadata !"branch_weights", i32 1, i32 7}
 !1 = metadata !{metadata !"branch_weights", i32 3, i32 4}
 
-; Irreducible control flow
-; ========================
+; The current BlockFrequencyInfo algorithm doesn't handle multiple entrances
+; into a loop very well.  The frequencies assigned to blocks in the loop are
+; predictable (and not absurd), but also not correct and therefore not worth
+; testing.
 ;
-; LoopInfo defines a loop as a non-trivial SCC dominated by a single block,
-; called the header.  A given loop, L, can have sub-loops, which are loops
-; within the subgraph of L that excludes the header.
+; There are two testcases below.
 ;
-; In addition to loops, -block-freq has limited support for irreducible SCCs,
-; which are SCCs with multiple entry blocks.  Irreducible SCCs are discovered
-; on they fly, and modelled as loops with multiple headers.
-;
-; The headers of irreducible sub-SCCs consist of its entry blocks and all nodes
-; that are targets of a backedge within it (excluding backedges within true
-; sub-loops).
-;
-; -block-freq is currently designed to act like a block is inserted that
-; intercepts all the edges to the headers.  All backedges and entries point to
-; this block.  Its successors are the headers, which split the frequency
-; evenly.
-;
-; There are a number of testcases below.  Only the first two have detailed
-; explanations.
+; For each testcase, I use a CHECK-NEXT/NOT combo like an XFAIL with the
+; granularity of a single check.  If/when this behaviour is fixed, we'll know
+; about it, and the test should be updated.
 ;
 ; Testcase #1
 ; ===========
@@ -89,31 +77,36 @@ return:
 ; loop as a whole is 1/4, so the loop scale should be 4.  Summing c1 and c2
 ; gives 28/7, or 4.0, which is nice confirmation of the math above.
 ;
-; -block-freq currently treats the two nodes as equals.
-define void @multientry(i1 %x) {
+; However, assuming c1 precedes c2 in reverse post-order, the current algorithm
+; returns 3/4 and 13/16, respectively.  LoopInfo ignores edges between loops
+; (and doesn't see any loops here at all), and -block-freq ignores the
+; irreducible edge from c2 to c1.
+;
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'multientry':
 ; CHECK-NEXT: block-frequency-info: multientry
-entry:
+define void @multientry(i1 %x) {
 ; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
+entry:
   br i1 %x, label %c1, label %c2, !prof !2
 
+; This is like a single-line XFAIL (see above).
+; CHECK-NEXT: c1:
+; CHECK-NOT: float = 2.142857{{[0-9]*}},
 c1:
-; CHECK-NEXT: c1: float = 2.0,
-; The "correct" answer is: float = 2.142857{{[0-9]*}},
   br i1 %x, label %c2, label %exit, !prof !2
 
+; This is like a single-line XFAIL (see above).
+; CHECK-NEXT: c2:
+; CHECK-NOT: float = 1.857142{{[0-9]*}},
 c2:
-; CHECK-NEXT: c2: float = 2.0,
-; The "correct" answer is: float = 1.857142{{[0-9]*}},
   br i1 %x, label %c1, label %exit, !prof !2
 
-exit:
+; We still shouldn't lose any frequency.
 ; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
+exit:
   ret void
 }
 
-!2 = metadata !{metadata !"branch_weights", i32 3, i32 1}
-
 ; Testcase #2
 ; ===========
 ;
@@ -131,291 +124,73 @@ exit:
 ; step, c1 and c2 each get 1/3 of what's left in c1 and c2 combined.  This
 ; infinite series sums to 1.
 ;
-; Since the currently algorithm *always* assumes entry blocks are equal,
-; -block-freq gets the right answers here.
-define void @crossloops(i2 %x) {
+; However, assuming c1 precedes c2 in reverse post-order, the current algorithm
+; returns 1/2 and 3/4, respectively.  LoopInfo ignores edges between loops (and
+; treats c1 and c2 as self-loops only), and -block-freq ignores the irreducible
+; edge from c2 to c1.
+;
+; Below I use a CHECK-NEXT/NOT combo like an XFAIL with the granularity of a
+; single check.  If/when this behaviour is fixed, we'll know about it, and the
+; test should be updated.
+;
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'crossloops':
 ; CHECK-NEXT: block-frequency-info: crossloops
-entry:
+define void @crossloops(i2 %x) {
 ; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
+entry:
   switch i2 %x, label %exit [ i2 1, label %c1
                               i2 2, label %c2 ], !prof !3
 
+; This is like a single-line XFAIL (see above).
+; CHECK-NEXT: c1:
+; CHECK-NOT: float = 1.0,
 c1:
-; CHECK-NEXT: c1: float = 1.0,
   switch i2 %x, label %exit [ i2 1, label %c1
                               i2 2, label %c2 ], !prof !3
 
+; This is like a single-line XFAIL (see above).
+; CHECK-NEXT: c2:
+; CHECK-NOT: float = 1.0,
 c2:
-; CHECK-NEXT: c2: float = 1.0,
   switch i2 %x, label %exit [ i2 1, label %c1
                               i2 2, label %c2 ], !prof !3
 
-exit:
+; We still shouldn't lose any frequency.
 ; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
+exit:
   ret void
 }
 
+!2 = metadata !{metadata !"branch_weights", i32 3, i32 1}
 !3 = metadata !{metadata !"branch_weights", i32 2, i32 2, i32 2}
 
-; A true loop with irreducible control flow inside.
-define void @loop_around_irreducible(i1 %x) {
+; A reducible loop with irreducible control flow inside should still have
+; correct exit frequency.
+;
 ; CHECK-LABEL: Printing analysis {{.*}} for function 'loop_around_irreducible':
 ; CHECK-NEXT: block-frequency-info: loop_around_irreducible
-entry:
-; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
-  br label %loop
-
-loop:
-; CHECK-NEXT: loop: float = 4.0, int = [[HEAD:[0-9]+]]
-  br i1 %x, label %left, label %right, !prof !4
-
-left:
-; CHECK-NEXT: left: float = 8.0,
-  br i1 %x, label %right, label %loop.end, !prof !5
-
-right:
-; CHECK-NEXT: right: float = 8.0,
-  br i1 %x, label %left, label %loop.end, !prof !5
-
-loop.end:
-; CHECK-NEXT: loop.end: float = 4.0, int = [[HEAD]]
-  br i1 %x, label %loop, label %exit, !prof !5
-
-exit:
-; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
-  ret void
-}
-!4 = metadata !{metadata !"branch_weights", i32 1, i32 1}
-!5 = metadata !{metadata !"branch_weights", i32 3, i32 1}
-
-; Two unrelated irreducible SCCs.
-define void @two_sccs(i1 %x) {
-; CHECK-LABEL: Printing analysis {{.*}} for function 'two_sccs':
-; CHECK-NEXT: block-frequency-info: two_sccs
-entry:
-; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
-  br i1 %x, label %a, label %b, !prof !6
-
-a:
-; CHECK-NEXT: a: float = 0.75,
-  br i1 %x, label %a.left, label %a.right, !prof !7
-
-a.left:
-; CHECK-NEXT: a.left: float = 1.5,
-  br i1 %x, label %a.right, label %exit, !prof !6
-
-a.right:
-; CHECK-NEXT: a.right: float = 1.5,
-  br i1 %x, label %a.left, label %exit, !prof !6
-
-b:
-; CHECK-NEXT: b: float = 0.25,
-  br i1 %x, label %b.left, label %b.right, !prof !7
-
-b.left:
-; CHECK-NEXT: b.left: float = 0.625,
-  br i1 %x, label %b.right, label %exit, !prof !8
-
-b.right:
-; CHECK-NEXT: b.right: float = 0.625,
-  br i1 %x, label %b.left, label %exit, !prof !8
-
-exit:
-; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
-  ret void
-}
-!6 = metadata !{metadata !"branch_weights", i32 3, i32 1}
-!7 = metadata !{metadata !"branch_weights", i32 1, i32 1}
-!8 = metadata !{metadata !"branch_weights", i32 4, i32 1}
-
-; A true loop inside irreducible control flow.
-define void @loop_inside_irreducible(i1 %x) {
-; CHECK-LABEL: Printing analysis {{.*}} for function 'loop_inside_irreducible':
-; CHECK-NEXT: block-frequency-info: loop_inside_irreducible
-entry:
-; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
-  br i1 %x, label %left, label %right, !prof !9
-
-left:
-; CHECK-NEXT: left: float = 2.0,
-  br i1 %x, label %right, label %exit, !prof !10
-
-right:
-; CHECK-NEXT: right: float = 2.0, int = [[RIGHT:[0-9]+]]
-  br label %loop
-
-loop:
-; CHECK-NEXT: loop: float = 6.0,
-  br i1 %x, label %loop, label %right.end, !prof !11
-
-right.end:
-; CHECK-NEXT: right.end: float = 2.0, int = [[RIGHT]]
-  br i1 %x, label %left, label %exit, !prof !10
-
-exit:
-; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
-  ret void
-}
-!9 = metadata !{metadata !"branch_weights", i32 1, i32 1}
-!10 = metadata !{metadata !"branch_weights", i32 3, i32 1}
-!11 = metadata !{metadata !"branch_weights", i32 2, i32 1}
-
-; Irreducible control flow in a branch that's in a true loop.
-define void @loop_around_branch_with_irreducible(i1 %x) {
-; CHECK-LABEL: Printing analysis {{.*}} for function 'loop_around_branch_with_irreducible':
-; CHECK-NEXT: block-frequency-info: loop_around_branch_with_irreducible
-entry:
+define void @loop_around_irreducible(i1 %x) {
 ; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
-  br label %loop
-
-loop:
-; CHECK-NEXT: loop: float = 2.0, int = [[LOOP:[0-9]+]]
-  br i1 %x, label %normal, label %irreducible.entry, !prof !12
-
-normal:
-; CHECK-NEXT: normal: float = 1.5,
-  br label %loop.end
-
-irreducible.entry:
-; CHECK-NEXT: irreducible.entry: float = 0.5, int = [[IRREDUCIBLE:[0-9]+]]
-  br i1 %x, label %left, label %right, !prof !13
-
-left:
-; CHECK-NEXT: left: float = 1.0,
-  br i1 %x, label %right, label %irreducible.exit, !prof !12
-
-right:
-; CHECK-NEXT: right: float = 1.0,
-  br i1 %x, label %left, label %irreducible.exit, !prof !12
-
-irreducible.exit:
-; CHECK-NEXT: irreducible.exit: float = 0.5, int = [[IRREDUCIBLE]]
-  br label %loop.end
-
-loop.end:
-; CHECK-NEXT: loop.end: float = 2.0, int = [[LOOP]]
-  br i1 %x, label %loop, label %exit, !prof !13
-
-exit:
-; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
-  ret void
-}
-!12 = metadata !{metadata !"branch_weights", i32 3, i32 1}
-!13 = metadata !{metadata !"branch_weights", i32 1, i32 1}
-
-; Irreducible control flow between two true loops.
-define void @loop_around_branch_with_irreducible_around_loop(i1 %x) {
-; CHECK-LABEL: Printing analysis {{.*}} for function 'loop_around_branch_with_irreducible_around_loop':
-; CHECK-NEXT: block-frequency-info: loop_around_branch_with_irreducible_around_loop
 entry:
-; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
   br label %loop
 
+; CHECK-NEXT: loop: float = [[HEAD:[0-9.]+]], int = [[HEADINT:[0-9]+]]
 loop:
-; CHECK-NEXT: loop: float = 3.0, int = [[LOOP:[0-9]+]]
-  br i1 %x, label %normal, label %irreducible, !prof !14
-
-normal:
-; CHECK-NEXT: normal: float = 2.0,
-  br label %loop.end
-
-irreducible:
-; CHECK-NEXT: irreducible: float = 1.0,
-  br i1 %x, label %left, label %right, !prof !15
+  br i1 %x, label %left, label %right
 
+; CHECK-NEXT: left:
 left:
-; CHECK-NEXT: left: float = 2.0,
-  br i1 %x, label %right, label %loop.end, !prof !16
+  br i1 %x, label %right, label %loop.end
 
+; CHECK-NEXT: right:
 right:
-; CHECK-NEXT: right: float = 2.0, int = [[RIGHT:[0-9]+]]
-  br label %right.loop
-
-right.loop:
-; CHECK-NEXT: right.loop: float = 10.0,
-  br i1 %x, label %right.loop, label %right.end, !prof !17
-
-right.end:
-; CHECK-NEXT: right.end: float = 2.0, int = [[RIGHT]]
-  br i1 %x, label %left, label %loop.end, !prof !16
+  br i1 %x, label %left, label %loop.end
 
+; CHECK-NEXT: loop.end: float = [[HEAD]], int = [[HEADINT]]
 loop.end:
-; CHECK-NEXT: loop.end: float = 3.0, int = [[LOOP]]
-  br i1 %x, label %loop, label %exit, !prof !14
-
-exit:
-; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
-  ret void
-}
-!14 = metadata !{metadata !"branch_weights", i32 2, i32 1}
-!15 = metadata !{metadata !"branch_weights", i32 1, i32 1}
-!16 = metadata !{metadata !"branch_weights", i32 3, i32 1}
-!17 = metadata !{metadata !"branch_weights", i32 4, i32 1}
-
-; An irreducible SCC with a non-header.
-define void @nonheader(i1 %x) {
-; CHECK-LABEL: Printing analysis {{.*}} for function 'nonheader':
-; CHECK-NEXT: block-frequency-info: nonheader
-entry:
-; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
-  br i1 %x, label %left, label %right, !prof !18
-
-left:
-; CHECK-NEXT: left: float = 1.0,
-  br i1 %x, label %bottom, label %exit, !prof !19
-
-right:
-; CHECK-NEXT: right: float = 1.0,
-  br i1 %x, label %bottom, label %exit, !prof !20
-
-bottom:
-; CHECK-NEXT: bottom: float = 1.0,
-  br i1 %x, label %left, label %right, !prof !18
+  br i1 %x, label %loop, label %exit
 
+; CHECK-NEXT: float = 1.0, int = [[ENTRY]]
 exit:
-; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
-  ret void
-}
-!18 = metadata !{metadata !"branch_weights", i32 1, i32 1}
-!19 = metadata !{metadata !"branch_weights", i32 1, i32 3}
-!20 = metadata !{metadata !"branch_weights", i32 3, i32 1}
-
-; An irreducible SCC with an irreducible sub-SCC.  In the current version of
-; -block-freq, this means an extra header.
-;
-; This testcases uses non-trivial branch weights.  The CHECK statements here
-; will start to fail if we change -block-freq to be more accurate.  Currently,
-; we expect left, right and top to be treated as equal headers.
-define void @nonentry_header(i1 %x, i2 %y) {
-; CHECK-LABEL: Printing analysis {{.*}} for function 'nonentry_header':
-; CHECK-NEXT: block-frequency-info: nonentry_header
-entry:
-; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
-  br i1 %x, label %left, label %right, !prof !21
-
-left:
-; CHECK-NEXT: left: float = 3.0,
-  br i1 %x, label %top, label %bottom, !prof !22
-
-right:
-; CHECK-NEXT: right: float = 3.0,
-  br i1 %x, label %top, label %bottom, !prof !22
-
-top:
-; CHECK-NEXT: top: float = 3.0,
-  switch i2 %y, label %exit [ i2 0, label %left
-                              i2 1, label %right
-                              i2 2, label %bottom ], !prof !23
-
-bottom:
-; CHECK-NEXT: bottom: float = 4.5,
-  br label %top
-
-exit:
-; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
   ret void
 }
-!21 = metadata !{metadata !"branch_weights", i32 2, i32 1}
-!22 = metadata !{metadata !"branch_weights", i32 1, i32 1}
-!23 = metadata !{metadata !"branch_weights", i32 8, i32 1, i32 3, i32 12}