mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 5.18.0.205

Browse Source 
Former-commit-id: 7f59f7e792705db773f1caecdaa823092f4e2927
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
2018-11-16 08:20:38 +00:00
parent 5cd5df71cc
commit 8e12397d70
28486 changed files with 3867013 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
external/llvm/test/Analysis/BlockFrequencyInfo/bad_input.ll vendored Normal file
View File

@ -0,0 +1,52 @@
; RUN: opt < %s -analyze -block-freq | FileCheck %s
; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
declare void @g(i32 %x)
; CHECK-LABEL: Printing analysis {{.*}} for function 'branch_weight_0':
; CHECK-NEXT: block-frequency-info: branch_weight_0
define void @branch_weight_0(i32 %a) {
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
br label %for.body
; Check that we get 1 and a huge frequency instead of 0,3.
; CHECK-NEXT: for.body: float = 2147483647.8,
for.body:
%i = phi i32 [ 0, %entry ], [ %inc, %for.body ]
call void @g(i32 %i)
%inc = add i32 %i, 1
%cmp = icmp ugt i32 %inc, %a
br i1 %cmp, label %for.end, label %for.body, !prof !0
; CHECK-NEXT: for.end: float = 1.0, int = [[ENTRY]]
for.end:
ret void
}
!0 = !{!"branch_weights", i32 0, i32 3}
; CHECK-LABEL: Printing analysis {{.*}} for function 'infinite_loop'
; CHECK-NEXT: block-frequency-info: infinite_loop
define void @infinite_loop(i1 %x) {
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
br i1 %x, label %for.body, label %for.end, !prof !1
; Check that the infinite loop is arbitrarily scaled to max out at 4096,
; giving 2048 here.
; CHECK-NEXT: for.body: float = 2048.0,
for.body:
%i = phi i32 [ 0, %entry ], [ %inc, %for.body ]
call void @g(i32 %i)
%inc = add i32 %i, 1
br label %for.body
; Check that the exit weight is half of entry, since half is lost in the
; infinite loop above.
; CHECK-NEXT: for.end: float = 0.5,
for.end:
ret void
}
!1 = !{!"branch_weights", i32 1, i32 1}

143
external/llvm/test/Analysis/BlockFrequencyInfo/basic.ll vendored Normal file
View File

@ -0,0 +1,143 @@
; RUN: opt < %s -analyze -block-freq | FileCheck %s
; RUN: opt < %s -analyze -lazy-block-freq | FileCheck %s
; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
define i32 @test1(i32 %i, i32* %a) {
; CHECK-LABEL: Printing analysis {{.*}} for function 'test1':
; CHECK-NEXT: block-frequency-info: test1
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
br label %body
; Loop backedges are weighted and thus their bodies have a greater frequency.
; CHECK-NEXT: body: float = 32.0,
body:
%iv = phi i32 [ 0, %entry ], [ %next, %body ]
%base = phi i32 [ 0, %entry ], [ %sum, %body ]
%arrayidx = getelementptr inbounds i32, i32* %a, i32 %iv
%0 = load i32, i32* %arrayidx
%sum = add nsw i32 %0, %base
%next = add i32 %iv, 1
%exitcond = icmp eq i32 %next, %i
br i1 %exitcond, label %exit, label %body
; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
exit:
ret i32 %sum
}
define i32 @test2(i32 %i, i32 %a, i32 %b) {
; CHECK-LABEL: Printing analysis {{.*}} for function 'test2':
; CHECK-NEXT: block-frequency-info: test2
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
%cond = icmp ult i32 %i, 42
br i1 %cond, label %then, label %else, !prof !0
; The 'then' branch is predicted more likely via branch weight metadata.
; CHECK-NEXT: then: float = 0.9411{{[0-9]*}},
then:
br label %exit
; CHECK-NEXT: else: float = 0.05882{{[0-9]*}},
else:
br label %exit
; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
exit:
%result = phi i32 [ %a, %then ], [ %b, %else ]
ret i32 %result
}
!0 = !{!"branch_weights", i32 64, i32 4}
define i32 @test3(i32 %i, i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) {
; CHECK-LABEL: Printing analysis {{.*}} for function 'test3':
; CHECK-NEXT: block-frequency-info: test3
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
switch i32 %i, label %case_a [ i32 1, label %case_b
i32 2, label %case_c
i32 3, label %case_d
i32 4, label %case_e ], !prof !1
; CHECK-NEXT: case_a: float = 0.05,
case_a:
br label %exit
; CHECK-NEXT: case_b: float = 0.05,
case_b:
br label %exit
; The 'case_c' branch is predicted more likely via branch weight metadata.
; CHECK-NEXT: case_c: float = 0.8,
case_c:
br label %exit
; CHECK-NEXT: case_d: float = 0.05,
case_d:
br label %exit
; CHECK-NEXT: case_e: float = 0.05,
case_e:
br label %exit
; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
exit:
%result = phi i32 [ %a, %case_a ],
[ %b, %case_b ],
[ %c, %case_c ],
[ %d, %case_d ],
[ %e, %case_e ]
ret i32 %result
}
!1 = !{!"branch_weights", i32 4, i32 4, i32 64, i32 4, i32 4}
define void @nested_loops(i32 %a) {
; CHECK-LABEL: Printing analysis {{.*}} for function 'nested_loops':
; CHECK-NEXT: block-frequency-info: nested_loops
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
br label %for.cond1.preheader
; CHECK-NEXT: for.cond1.preheader: float = 4001.0,
for.cond1.preheader:
%x.024 = phi i32 [ 0, %entry ], [ %inc12, %for.inc11 ]
br label %for.cond4.preheader
; CHECK-NEXT: for.cond4.preheader: float = 16007984.8,
for.cond4.preheader:
%y.023 = phi i32 [ 0, %for.cond1.preheader ], [ %inc9, %for.inc8 ]
%add = add i32 %y.023, %x.024
br label %for.body6
; CHECK-NEXT: for.body6: float = 64047914563.9,
for.body6:
%z.022 = phi i32 [ 0, %for.cond4.preheader ], [ %inc, %for.body6 ]
%add7 = add i32 %add, %z.022
tail call void @g(i32 %add7)
%inc = add i32 %z.022, 1
%cmp5 = icmp ugt i32 %inc, %a
br i1 %cmp5, label %for.inc8, label %for.body6, !prof !2
; CHECK-NEXT: for.inc8: float = 16007984.8,
for.inc8:
%inc9 = add i32 %y.023, 1
%cmp2 = icmp ugt i32 %inc9, %a
br i1 %cmp2, label %for.inc11, label %for.cond4.preheader, !prof !2
; CHECK-NEXT: for.inc11: float = 4001.0,
for.inc11:
%inc12 = add i32 %x.024, 1
%cmp = icmp ugt i32 %inc12, %a
br i1 %cmp, label %for.end13, label %for.cond1.preheader, !prof !2
; CHECK-NEXT: for.end13: float = 1.0, int = [[ENTRY]]
for.end13:
ret void
}
declare void @g(i32)
!2 = !{!"branch_weights", i32 1, i32 4000}

28
external/llvm/test/Analysis/BlockFrequencyInfo/double_backedge.ll vendored Normal file
View File

@ -0,0 +1,28 @@
; RUN: opt < %s -analyze -block-freq | FileCheck %s
; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
define void @double_backedge(i1 %x) {
; CHECK-LABEL: Printing analysis {{.*}} for function 'double_backedge':
; CHECK-NEXT: block-frequency-info: double_backedge
entry:
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
br label %loop
loop:
; CHECK-NEXT: loop: float = 10.0,
br i1 %x, label %exit, label %loop.1, !prof !0
loop.1:
; CHECK-NEXT: loop.1: float = 9.0,
br i1 %x, label %loop, label %loop.2, !prof !1
loop.2:
; CHECK-NEXT: loop.2: float = 5.0,
br label %loop
exit:
; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
ret void
}
!0 = !{!"branch_weights", i32 1, i32 9}
!1 = !{!"branch_weights", i32 4, i32 5}

166
external/llvm/test/Analysis/BlockFrequencyInfo/double_exit.ll vendored Normal file
View File

@ -0,0 +1,166 @@
; RUN: opt < %s -analyze -block-freq | FileCheck %s
; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
; CHECK-LABEL: Printing analysis {{.*}} for function 'double_exit':
; CHECK-NEXT: block-frequency-info: double_exit
define i32 @double_exit(i32 %N) {
; Mass = 1
; Frequency = 1
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
br label %outer
; Mass = 1
; Backedge mass = 1/3, exit mass = 2/3
; Loop scale = 3/2
; Pseudo-edges = exit
; Pseudo-mass = 1
; Frequency = 1*3/2*1 = 3/2
; CHECK-NEXT: outer: float = 1.5,
outer:
%I.0 = phi i32 [ 0, %entry ], [ %inc6, %outer.inc ]
%Return.0 = phi i32 [ 0, %entry ], [ %Return.1, %outer.inc ]
%cmp = icmp slt i32 %I.0, %N
br i1 %cmp, label %inner, label %exit, !prof !2 ; 2:1
; Mass = 1
; Backedge mass = 3/5, exit mass = 2/5
; Loop scale = 5/2
; Pseudo-edges = outer.inc @ 1/5, exit @ 1/5
; Pseudo-mass = 2/3
; Frequency = 3/2*1*5/2*2/3 = 5/2
; CHECK-NEXT: inner: float = 2.5,
inner:
%Return.1 = phi i32 [ %Return.0, %outer ], [ %call4, %inner.inc ]
%J.0 = phi i32 [ %I.0, %outer ], [ %inc, %inner.inc ]
%cmp2 = icmp slt i32 %J.0, %N
br i1 %cmp2, label %inner.body, label %outer.inc, !prof !1 ; 4:1
; Mass = 4/5
; Frequency = 5/2*4/5 = 2
; CHECK-NEXT: inner.body: float = 2.0,
inner.body:
%call = call i32 @c2(i32 %I.0, i32 %J.0)
%tobool = icmp ne i32 %call, 0
br i1 %tobool, label %exit, label %inner.inc, !prof !0 ; 3:1
; Mass = 3/5
; Frequency = 5/2*3/5 = 3/2
; CHECK-NEXT: inner.inc: float = 1.5,
inner.inc:
%call4 = call i32 @logic2(i32 %Return.1, i32 %I.0, i32 %J.0)
%inc = add nsw i32 %J.0, 1
br label %inner
; Mass = 1/3
; Frequency = 3/2*1/3 = 1/2
; CHECK-NEXT: outer.inc: float = 0.5,
outer.inc:
%inc6 = add nsw i32 %I.0, 1
br label %outer
; Mass = 1
; Frequency = 1
; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
exit:
%Return.2 = phi i32 [ %Return.1, %inner.body ], [ %Return.0, %outer ]
ret i32 %Return.2
}
!0 = !{!"branch_weights", i32 1, i32 3}
!1 = !{!"branch_weights", i32 4, i32 1}
!2 = !{!"branch_weights", i32 2, i32 1}
declare i32 @c2(i32, i32)
declare i32 @logic2(i32, i32, i32)
; CHECK-LABEL: Printing analysis {{.*}} for function 'double_exit_in_loop':
; CHECK-NEXT: block-frequency-info: double_exit_in_loop
define i32 @double_exit_in_loop(i32 %N) {
; Mass = 1
; Frequency = 1
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
br label %outer
; Mass = 1
; Backedge mass = 1/2, exit mass = 1/2
; Loop scale = 2
; Pseudo-edges = exit
; Pseudo-mass = 1
; Frequency = 1*2*1 = 2
; CHECK-NEXT: outer: float = 2.0,
outer:
%I.0 = phi i32 [ 0, %entry ], [ %inc12, %outer.inc ]
%Return.0 = phi i32 [ 0, %entry ], [ %Return.3, %outer.inc ]
%cmp = icmp slt i32 %I.0, %N
br i1 %cmp, label %middle, label %exit, !prof !3 ; 1:1
; Mass = 1
; Backedge mass = 1/3, exit mass = 2/3
; Loop scale = 3/2
; Pseudo-edges = outer.inc
; Pseudo-mass = 1/2
; Frequency = 2*1*3/2*1/2 = 3/2
; CHECK-NEXT: middle: float = 1.5,
middle:
%J.0 = phi i32 [ %I.0, %outer ], [ %inc9, %middle.inc ]
%Return.1 = phi i32 [ %Return.0, %outer ], [ %Return.2, %middle.inc ]
%cmp2 = icmp slt i32 %J.0, %N
br i1 %cmp2, label %inner, label %outer.inc, !prof !2 ; 2:1
; Mass = 1
; Backedge mass = 3/5, exit mass = 2/5
; Loop scale = 5/2
; Pseudo-edges = middle.inc @ 1/5, outer.inc @ 1/5
; Pseudo-mass = 2/3
; Frequency = 3/2*1*5/2*2/3 = 5/2
; CHECK-NEXT: inner: float = 2.5,
inner:
%Return.2 = phi i32 [ %Return.1, %middle ], [ %call7, %inner.inc ]
%K.0 = phi i32 [ %J.0, %middle ], [ %inc, %inner.inc ]
%cmp5 = icmp slt i32 %K.0, %N
br i1 %cmp5, label %inner.body, label %middle.inc, !prof !1 ; 4:1
; Mass = 4/5
; Frequency = 5/2*4/5 = 2
; CHECK-NEXT: inner.body: float = 2.0,
inner.body:
%call = call i32 @c3(i32 %I.0, i32 %J.0, i32 %K.0)
%tobool = icmp ne i32 %call, 0
br i1 %tobool, label %outer.inc, label %inner.inc, !prof !0 ; 3:1
; Mass = 3/5
; Frequency = 5/2*3/5 = 3/2
; CHECK-NEXT: inner.inc: float = 1.5,
inner.inc:
%call7 = call i32 @logic3(i32 %Return.2, i32 %I.0, i32 %J.0, i32 %K.0)
%inc = add nsw i32 %K.0, 1
br label %inner
; Mass = 1/3
; Frequency = 3/2*1/3 = 1/2
; CHECK-NEXT: middle.inc: float = 0.5,
middle.inc:
%inc9 = add nsw i32 %J.0, 1
br label %middle
; Mass = 1/2
; Frequency = 2*1/2 = 1
; CHECK-NEXT: outer.inc: float = 1.0,
outer.inc:
%Return.3 = phi i32 [ %Return.2, %inner.body ], [ %Return.1, %middle ]
%inc12 = add nsw i32 %I.0, 1
br label %outer
; Mass = 1
; Frequency = 1
; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
exit:
ret i32 %Return.0
}
!3 = !{!"branch_weights", i32 1, i32 1}
declare i32 @c3(i32, i32, i32)
declare i32 @logic3(i32, i32, i32, i32)

41
external/llvm/test/Analysis/BlockFrequencyInfo/extremely-likely-loop-successor.ll vendored Normal file
View File

@ -0,0 +1,41 @@
; RUN: opt < %s -analyze -block-freq | FileCheck %s
; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
; PR21622: Check for a crasher when the sum of exits to the same successor of a
; loop overflows.
; CHECK-LABEL: Printing analysis {{.*}} for function 'extremely_likely_loop_successor':
; CHECK-NEXT: block-frequency-info: extremely_likely_loop_successor
define void @extremely_likely_loop_successor() {
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
br label %loop
; CHECK-NEXT: loop: float = 1.0,
loop:
%exit.1.cond = call i1 @foo()
br i1 %exit.1.cond, label %exit, label %loop.2, !prof !0
; CHECK-NEXT: loop.2: float = 0.0000000
loop.2:
%exit.2.cond = call i1 @foo()
br i1 %exit.2.cond, label %exit, label %loop.3, !prof !0
; CHECK-NEXT: loop.3: float = 0.0000000
loop.3:
%exit.3.cond = call i1 @foo()
br i1 %exit.3.cond, label %exit, label %loop.4, !prof !0
; CHECK-NEXT: loop.4: float = 0.0,
loop.4:
%exit.4.cond = call i1 @foo()
br i1 %exit.4.cond, label %exit, label %loop, !prof !0
; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
exit:
ret void
}
declare i1 @foo()
!0 = !{!"branch_weights", i32 4294967295, i32 1}

419
external/llvm/test/Analysis/BlockFrequencyInfo/irreducible.ll vendored Normal file
View File

@ -0,0 +1,419 @@
; RUN: opt < %s -analyze -block-freq | FileCheck %s
; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
; A loop with multiple exits isn't irreducible. It should be handled
; correctly.
;
; CHECK-LABEL: Printing analysis {{.*}} for function 'multiexit':
; CHECK-NEXT: block-frequency-info: multiexit
define void @multiexit(i1 %x) {
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
br label %loop.1
; CHECK-NEXT: loop.1: float = 2.0,
loop.1:
br i1 %x, label %exit.1, label %loop.2, !prof !0
; CHECK-NEXT: loop.2: float = 1.75,
loop.2:
br i1 %x, label %exit.2, label %loop.1, !prof !1
; CHECK-NEXT: exit.1: float = 0.25,
exit.1:
br label %return
; CHECK-NEXT: exit.2: float = 0.75,
exit.2:
br label %return
; CHECK-NEXT: return: float = 1.0, int = [[ENTRY]]
return:
ret void
}
!0 = !{!"branch_weights", i32 1, i32 7}
!1 = !{!"branch_weights", i32 3, i32 4}
; Irreducible control flow
; ========================
;
; 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.
;
; 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.
;
; Testcase #1
; ===========
;
; In this case c1 and c2 should have frequencies of 15/7 and 13/7,
; respectively. To calculate this, consider assigning 1.0 to entry, and
; distributing frequency iteratively (to infinity). At the first iteration,
; entry gives 3/4 to c1 and 1/4 to c2. At every step after, c1 and c2 give 3/4
; of what they have to each other. Somehow, all of it comes out to exit.
;
; c1 = 3/4 + 1/4*3/4 + 3/4*3^2/4^2 + 1/4*3^3/4^3 + 3/4*3^3/4^3 + ...
; c2 = 1/4 + 3/4*3/4 + 1/4*3^2/4^2 + 3/4*3^3/4^3 + 1/4*3^3/4^3 + ...
;
; Simplify by splitting up the odd and even terms of the series and taking out
; factors so that the infite series matches:
;
; c1 = 3/4 *(9^0/16^0 + 9^1/16^1 + 9^2/16^2 + ...)
; + 3/16*(9^0/16^0 + 9^1/16^1 + 9^2/16^2 + ...)
; c2 = 1/4 *(9^0/16^0 + 9^1/16^1 + 9^2/16^2 + ...)
; + 9/16*(9^0/16^0 + 9^1/16^1 + 9^2/16^2 + ...)
;
; c1 = 15/16*(9^0/16^0 + 9^1/16^1 + 9^2/16^2 + ...)
; c2 = 13/16*(9^0/16^0 + 9^1/16^1 + 9^2/16^2 + ...)
;
; Since this geometric series sums to 16/7:
;
; c1 = 15/7
; c2 = 13/7
;
; If we treat c1 and c2 as members of the same loop, the exit frequency of the
; 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) {
; CHECK-LABEL: Printing analysis {{.*}} for function 'multientry':
; CHECK-NEXT: block-frequency-info: multientry
entry:
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
br i1 %x, label %c1, label %c2, !prof !2
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
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:
; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
ret void
}
!2 = !{!"branch_weights", i32 3, i32 1}
; Testcase #2
; ===========
;
; In this case c1 and c2 should be treated as equals in a single loop. The
; exit frequency is 1/3, so the scaling factor for the loop should be 3.0. The
; loop is entered 2/3 of the time, and c1 and c2 split the total loop frequency
; evenly (1/2), so they should each have frequencies of 1.0 (3.0*2/3*1/2).
; Another way of computing this result is by assigning 1.0 to entry and showing
; that c1 and c2 should accumulate frequencies of:
;
; 1/3 + 2/9 + 4/27 + 8/81 + ...
; 2^0/3^1 + 2^1/3^2 + 2^2/3^3 + 2^3/3^4 + ...
;
; At the first step, c1 and c2 each get 1/3 of the entry. At each subsequent
; step, c1 and c2 each get 1/3 of what's left in c1 and c2 combined. This
; infinite series sums to 1.
define void @crossloops(i2 %x) {
; CHECK-LABEL: Printing analysis {{.*}} for function 'crossloops':
; CHECK-NEXT: block-frequency-info: crossloops
entry:
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
switch i2 %x, label %exit [ i2 1, label %c1
i2 2, label %c2 ], !prof !3
c1:
; CHECK-NEXT: c1: float = 1.0,
switch i2 %x, label %exit [ i2 1, label %c1
i2 2, label %c2 ], !prof !3
c2:
; CHECK-NEXT: c2: float = 1.0,
switch i2 %x, label %exit [ i2 1, label %c1
i2 2, label %c2 ], !prof !3
exit:
; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
ret void
}
!3 = !{!"branch_weights", i32 2, i32 2, i32 2}
; A true loop with irreducible control flow inside.
define void @loop_around_irreducible(i1 %x) {
; 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 = !{!"branch_weights", i32 1, i32 1}
!5 = !{!"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 = !{!"branch_weights", i32 3, i32 1}
!7 = !{!"branch_weights", i32 1, i32 1}
!8 = !{!"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 = !{!"branch_weights", i32 1, i32 1}
!10 = !{!"branch_weights", i32 3, i32 1}
!11 = !{!"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:
; 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 = !{!"branch_weights", i32 3, i32 1}
!13 = !{!"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
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
left:
; CHECK-NEXT: left: float = 2.0,
br i1 %x, label %right, label %loop.end, !prof !16
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
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 = !{!"branch_weights", i32 2, i32 1}
!15 = !{!"branch_weights", i32 1, i32 1}
!16 = !{!"branch_weights", i32 3, i32 1}
!17 = !{!"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
exit:
; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
ret void
}
!18 = !{!"branch_weights", i32 1, i32 1}
!19 = !{!"branch_weights", i32 1, i32 3}
!20 = !{!"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,
; loop headers are affected by the weight of their corresponding back edges.
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 = 0.14
br i1 %x, label %top, label %bottom, !prof !22
right:
; CHECK-NEXT: right: float = 0.42
br i1 %x, label %top, label %bottom, !prof !22
top:
; CHECK-NEXT: top: float = 8.43
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 = !{!"branch_weights", i32 2, i32 1}
!22 = !{!"branch_weights", i32 1, i32 1}
!23 = !{!"branch_weights", i32 8, i32 1, i32 3, i32 12}

156
external/llvm/test/Analysis/BlockFrequencyInfo/irreducible_loop_crash.ll vendored Normal file
View File

@ -0,0 +1,156 @@
; RUN: opt < %s -analyze -block-freq
; RUN: opt < %s -passes='print<block-freq>' -disable-output
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
define void @fn1(i32* %f) {
entry:
%tobool7 = icmp eq i32 undef, 0
br i1 undef, label %if.end.12, label %for.body.5
for.inc:
store i32 undef, i32* %f, align 4
br label %for.body.5
for.body.5: ; preds = %for.cond.4.preheader
br i1 %tobool7, label %for.inc.9, label %for.inc
for.inc.9: ; preds = %for.body.5
br i1 %tobool7, label %for.inc.9.1, label %for.inc
if.end.12: ; preds = %if.end.12, %for.body
br i1 undef, label %for.end.17, label %for.inc
for.end.17: ; preds = %entry
ret void
for.inc.9.1: ; preds = %for.inc.9
br i1 %tobool7, label %for.inc.9.2, label %for.inc
for.inc.9.2: ; preds = %for.inc.9.1
br i1 %tobool7, label %for.inc.9.3, label %for.inc
for.inc.9.3: ; preds = %for.inc.9.2
br i1 %tobool7, label %for.inc.9.4, label %for.inc
for.inc.9.4: ; preds = %for.inc.9.3
br i1 %tobool7, label %for.inc.9.5, label %for.inc
for.inc.9.5: ; preds = %for.inc.9.4
br i1 %tobool7, label %for.inc.9.6, label %for.inc
for.inc.9.6: ; preds = %for.inc.9.5
br i1 %tobool7, label %for.inc.9.7, label %for.inc
for.inc.9.7: ; preds = %for.inc.9.6
br i1 %tobool7, label %for.inc.9.8, label %for.inc
for.inc.9.8: ; preds = %for.inc.9.7
br i1 %tobool7, label %for.inc.9.9, label %for.inc
for.inc.9.9: ; preds = %for.inc.9.8
br i1 %tobool7, label %for.inc.9.10, label %for.inc
for.inc.9.10: ; preds = %for.inc.9.9
br i1 %tobool7, label %for.inc.9.11, label %for.inc
for.inc.9.11: ; preds = %for.inc.9.10
br i1 %tobool7, label %for.inc.9.12, label %for.inc
for.inc.9.12: ; preds = %for.inc.9.11
br i1 %tobool7, label %for.inc.9.13, label %for.inc
for.inc.9.13: ; preds = %for.inc.9.12
br i1 %tobool7, label %for.inc.9.14, label %for.inc
for.inc.9.14: ; preds = %for.inc.9.13
br i1 %tobool7, label %for.inc.9.15, label %for.inc
for.inc.9.15: ; preds = %for.inc.9.14
br i1 %tobool7, label %for.inc.9.16, label %for.inc
for.inc.9.16: ; preds = %for.inc.9.15
br i1 %tobool7, label %for.inc.9.17, label %for.inc
for.inc.9.17: ; preds = %for.inc.9.16
br i1 %tobool7, label %for.inc.9.18, label %for.inc
for.inc.9.18: ; preds = %for.inc.9.17
br i1 %tobool7, label %for.inc.9.19, label %for.inc
for.inc.9.19: ; preds = %for.inc.9.18
br i1 %tobool7, label %for.inc.9.20, label %for.inc
for.inc.9.20: ; preds = %for.inc.9.19
br i1 %tobool7, label %for.inc.9.21, label %for.inc
for.inc.9.21: ; preds = %for.inc.9.20
br i1 %tobool7, label %for.inc.9.22, label %for.inc
for.inc.9.22: ; preds = %for.inc.9.21
br i1 %tobool7, label %for.inc.9.23, label %for.inc
for.inc.9.23: ; preds = %for.inc.9.22
br i1 %tobool7, label %for.inc.9.24, label %for.inc
for.inc.9.24: ; preds = %for.inc.9.23
br i1 %tobool7, label %for.inc.9.25, label %for.inc
for.inc.9.25: ; preds = %for.inc.9.24
br i1 %tobool7, label %for.inc.9.26, label %for.inc
for.inc.9.26: ; preds = %for.inc.9.25
br i1 %tobool7, label %for.inc.9.27, label %for.inc
for.inc.9.27: ; preds = %for.inc.9.26
br i1 %tobool7, label %for.inc.9.28, label %for.inc
for.inc.9.28: ; preds = %for.inc.9.27
br i1 %tobool7, label %for.inc.9.29, label %for.inc
for.inc.9.29: ; preds = %for.inc.9.28
br i1 %tobool7, label %for.inc.9.30, label %for.inc
for.inc.9.30: ; preds = %for.inc.9.29
br i1 %tobool7, label %for.inc.9.31, label %for.inc
for.inc.9.31: ; preds = %for.inc.9.30
br i1 %tobool7, label %for.inc.9.32, label %for.inc
for.inc.9.32: ; preds = %for.inc.9.31
br i1 %tobool7, label %for.inc.9.33, label %for.inc
for.inc.9.33: ; preds = %for.inc.9.32
br i1 %tobool7, label %for.inc.9.34, label %for.inc
for.inc.9.34: ; preds = %for.inc.9.33
br i1 %tobool7, label %for.inc.9.35, label %for.inc
for.inc.9.35: ; preds = %for.inc.9.34
br i1 %tobool7, label %for.inc.9.36, label %for.inc
for.inc.9.36: ; preds = %for.inc.9.35
br i1 %tobool7, label %for.inc.9.37, label %for.inc
for.inc.9.37: ; preds = %for.inc.9.36
br i1 %tobool7, label %for.inc.9.38, label %for.inc
for.inc.9.38: ; preds = %for.inc.9.37
br i1 %tobool7, label %for.inc.9.39, label %for.inc
for.inc.9.39: ; preds = %for.inc.9.38
br i1 %tobool7, label %for.inc.9.40, label %for.inc
for.inc.9.40: ; preds = %for.inc.9.39
br i1 %tobool7, label %for.inc.9.41, label %for.inc
for.inc.9.41: ; preds = %for.inc.9.40
br i1 %tobool7, label %for.inc.9.42, label %for.inc
for.inc.9.42: ; preds = %for.inc.9.41
br i1 %tobool7, label %for.inc.9.43, label %for.inc
for.inc.9.43: ; preds = %for.inc.9.42
br i1 %tobool7, label %if.end.12, label %for.inc
}

226
external/llvm/test/Analysis/BlockFrequencyInfo/irreducible_pgo.ll vendored Normal file
View File

@ -0,0 +1,226 @@
; RUN: opt < %s -analyze -block-freq | FileCheck %s
; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
; Function Attrs: noinline norecurse nounwind readnone uwtable
define i32 @_Z11irreducibleii(i32 %iter_outer, i32 %iter_inner) local_unnamed_addr !prof !27 {
entry:
%cmp24 = icmp sgt i32 %iter_outer, 0
br i1 %cmp24, label %for.body, label %entry.for.cond.cleanup_crit_edge, !prof !28
entry.for.cond.cleanup_crit_edge: ; preds = %entry
br label %for.cond.cleanup
for.cond.cleanup: ; preds = %for.end, %entry.for.cond.cleanup_crit_edge
%sum.0.lcssa = phi i32 [ 0, %entry.for.cond.cleanup_crit_edge ], [ %sum.1, %for.end ]
ret i32 %sum.0.lcssa
for.body: ; preds = %for.end, %entry
%k.026 = phi i32 [ %inc12, %for.end ], [ 0, %entry ]
%sum.025 = phi i32 [ %sum.1, %for.end ], [ 0, %entry ]
%rem23 = and i32 %k.026, 1
%cmp1 = icmp eq i32 %rem23, 0
br i1 %cmp1, label %entry8, label %for.cond2, !prof !29
for.cond2: ; preds = %if.end9, %for.body
%sum.1 = phi i32 [ %add10, %if.end9 ], [ %sum.025, %for.body ]
%i.0 = phi i32 [ %inc, %if.end9 ], [ 0, %for.body ]
%cmp3 = icmp slt i32 %i.0, %iter_inner
br i1 %cmp3, label %for.body4, label %for.end, !prof !30, !irr_loop !31
for.body4: ; preds = %for.cond2
%rem5 = srem i32 %k.026, 3
%cmp6 = icmp eq i32 %rem5, 0
br i1 %cmp6, label %entry8, label %if.end9, !prof !32
entry8: ; preds = %for.body4, %for.body
%sum.2 = phi i32 [ %sum.025, %for.body ], [ %sum.1, %for.body4 ]
%i.1 = phi i32 [ 0, %for.body ], [ %i.0, %for.body4 ]
%add = add nsw i32 %sum.2, 4
br label %if.end9, !irr_loop !33
if.end9: ; preds = %entry8, %for.body4
%sum.3 = phi i32 [ %add, %entry8 ], [ %sum.1, %for.body4 ]
%i.2 = phi i32 [ %i.1, %entry8 ], [ %i.0, %for.body4 ]
%add10 = add nsw i32 %sum.3, 1
%inc = add nsw i32 %i.2, 1
br label %for.cond2, !irr_loop !34
for.end: ; preds = %for.cond2
%inc12 = add nuw nsw i32 %k.026, 1
%exitcond = icmp eq i32 %inc12, %iter_outer
br i1 %exitcond, label %for.cond.cleanup, label %for.body, !prof !35
}
!27 = !{!"function_entry_count", i64 1}
!28 = !{!"branch_weights", i32 1, i32 0}
!29 = !{!"branch_weights", i32 50, i32 50}
!30 = !{!"branch_weights", i32 950, i32 100}
!31 = !{!"loop_header_weight", i64 1050}
!32 = !{!"branch_weights", i32 323, i32 627}
!33 = !{!"loop_header_weight", i64 373}
!34 = !{!"loop_header_weight", i64 1000}
!35 = !{!"branch_weights", i32 1, i32 99}
; CHECK-LABEL: Printing analysis {{.*}} for function '_Z11irreducibleii':
; CHECK-NEXT: block-frequency-info: _Z11irreducibleii
; CHECK-NEXT: - entry: {{.*}} count = 1
; CHECK-NEXT: - entry.for.cond.cleanup_crit_edge: {{.*}} count = 0
; CHECK-NEXT: - for.cond.cleanup: {{.*}} count = 1
; CHECK-NEXT: - for.body: {{.*}} count = 100
; CHECK-NEXT: - for.cond2: {{.*}} count = 1050, irr_loop_header_weight = 1050
; CHECK-NEXT: - for.body4: {{.*}} count = 950
; CHECK-NEXT: - entry8: {{.*}} count = 373, irr_loop_header_weight = 373
; CHECK-NEXT: - if.end9: {{.*}} count = 1000, irr_loop_header_weight = 1000
; CHECK-NEXT: - for.end: {{.*}} count = 100
@targets = local_unnamed_addr global [256 x i8*] zeroinitializer, align 16
@tracing = local_unnamed_addr global i32 0, align 4
; Function Attrs: noinline norecurse nounwind uwtable
define i32 @_Z11irreduciblePh(i8* nocapture readonly %p) !prof !27 {
entry:
%0 = load i32, i32* @tracing, align 4
%1 = trunc i32 %0 to i8
%tobool = icmp eq i32 %0, 0
br label %for.cond1
for.cond1: ; preds = %sw.default, %entry
br label %dispatch_op
dispatch_op: ; preds = %sw.bb6, %for.cond1
switch i8 %1, label %sw.default [
i8 0, label %sw.bb
i8 1, label %dispatch_op.sw.bb6_crit_edge
i8 2, label %sw.bb15
], !prof !36
dispatch_op.sw.bb6_crit_edge: ; preds = %dispatch_op
br label %sw.bb6
sw.bb: ; preds = %indirectgoto, %dispatch_op
br label %exit
TARGET_1: ; preds = %indirectgoto
br label %sw.bb6
sw.bb6: ; preds = %TARGET_1, %dispatch_op.sw.bb6_crit_edge
br i1 %tobool, label %dispatch_op, label %if.then, !prof !37, !irr_loop !38
if.then: ; preds = %sw.bb6
br label %indirectgoto
TARGET_2: ; preds = %indirectgoto
br label %sw.bb15
sw.bb15: ; preds = %TARGET_2, %dispatch_op
br i1 %tobool, label %if.then18, label %exit, !prof !39, !irr_loop !40
if.then18: ; preds = %sw.bb15
br label %indirectgoto
unknown_op: ; preds = %indirectgoto
br label %sw.default
sw.default: ; preds = %unknown_op, %dispatch_op
br label %for.cond1
exit: ; preds = %sw.bb15, %sw.bb
ret i32 0
indirectgoto: ; preds = %if.then18, %if.then
%idxprom21 = zext i32 %0 to i64
%arrayidx22 = getelementptr inbounds [256 x i8*], [256 x i8*]* @targets, i64 0, i64 %idxprom21
%target = load i8*, i8** %arrayidx22, align 8
indirectbr i8* %target, [label %unknown_op, label %sw.bb, label %TARGET_1, label %TARGET_2], !prof !41, !irr_loop !42
}
!36 = !{!"branch_weights", i32 0, i32 0, i32 201, i32 1}
!37 = !{!"branch_weights", i32 201, i32 300}
!38 = !{!"loop_header_weight", i64 501}
!39 = !{!"branch_weights", i32 100, i32 0}
!40 = !{!"loop_header_weight", i64 100}
!41 = !{!"branch_weights", i32 0, i32 1, i32 300, i32 99}
!42 = !{!"loop_header_weight", i64 400}
; CHECK-LABEL: Printing analysis {{.*}} for function '_Z11irreduciblePh':
; CHECK-NEXT: block-frequency-info: _Z11irreduciblePh
; CHECK-NEXT: - entry: {{.*}} count = 1
; CHECK-NEXT: - for.cond1: {{.*}} count = 1
; CHECK-NEXT: - dispatch_op: {{.*}} count = 201
; CHECK-NEXT: - dispatch_op.sw.bb6_crit_edge: {{.*}} count = 200
; CHECK-NEXT: - sw.bb: {{.*}} count = 0
; CHECK-NEXT: - TARGET_1: {{.*}} count = 299
; CHECK-NEXT: - sw.bb6: {{.*}} count = 500, irr_loop_header_weight = 501
; CHECK-NEXT: - if.then: {{.*}} count = 299
; CHECK-NEXT: - TARGET_2: {{.*}} count = 98
; CHECK-NEXT: - sw.bb15: {{.*}} count = 99, irr_loop_header_weight = 100
; CHECK-NEXT: - if.then18: {{.*}} count = 99
; CHECK-NEXT: - unknown_op: {{.*}} count = 0
; CHECK-NEXT: - sw.default: {{.*}} count = 0
; CHECK-NEXT: - exit: {{.*}} count = 1
; CHECK-NEXT: - indirectgoto: {{.*}} count = 399, irr_loop_header_weight = 400
; Missing some irr loop annotations.
; Function Attrs: noinline norecurse nounwind uwtable
define i32 @_Z11irreduciblePh2(i8* nocapture readonly %p) !prof !27 {
entry:
%0 = load i32, i32* @tracing, align 4
%1 = trunc i32 %0 to i8
%tobool = icmp eq i32 %0, 0
br label %for.cond1
for.cond1: ; preds = %sw.default, %entry
br label %dispatch_op
dispatch_op: ; preds = %sw.bb6, %for.cond1
switch i8 %1, label %sw.default [
i8 0, label %sw.bb
i8 1, label %dispatch_op.sw.bb6_crit_edge
i8 2, label %sw.bb15
], !prof !36
dispatch_op.sw.bb6_crit_edge: ; preds = %dispatch_op
br label %sw.bb6
sw.bb: ; preds = %indirectgoto, %dispatch_op
br label %exit
TARGET_1: ; preds = %indirectgoto
br label %sw.bb6
sw.bb6: ; preds = %TARGET_1, %dispatch_op.sw.bb6_crit_edge
br i1 %tobool, label %dispatch_op, label %if.then, !prof !37 ; Missing !irr_loop !38
if.then: ; preds = %sw.bb6
br label %indirectgoto
TARGET_2: ; preds = %indirectgoto
br label %sw.bb15
sw.bb15: ; preds = %TARGET_2, %dispatch_op
br i1 %tobool, label %if.then18, label %exit, !prof !39, !irr_loop !40
if.then18: ; preds = %sw.bb15
br label %indirectgoto
unknown_op: ; preds = %indirectgoto
br label %sw.default
sw.default: ; preds = %unknown_op, %dispatch_op
br label %for.cond1
exit: ; preds = %sw.bb15, %sw.bb
ret i32 0
indirectgoto: ; preds = %if.then18, %if.then
%idxprom21 = zext i32 %0 to i64
%arrayidx22 = getelementptr inbounds [256 x i8*], [256 x i8*]* @targets, i64 0, i64 %idxprom21
%target = load i8*, i8** %arrayidx22, align 8
indirectbr i8* %target, [label %unknown_op, label %sw.bb, label %TARGET_1, label %TARGET_2], !prof !41, !irr_loop !42
}
; CHECK-LABEL: Printing analysis {{.*}} for function '_Z11irreduciblePh2':
; CHECK: block-frequency-info: _Z11irreduciblePh2
; CHECK: - sw.bb6: {{.*}} count = 100
; CHECK: - sw.bb15: {{.*}} count = 100, irr_loop_header_weight = 100
; CHECK: - indirectgoto: {{.*}} count = 400, irr_loop_header_weight = 400

45
external/llvm/test/Analysis/BlockFrequencyInfo/loop_with_branch.ll vendored Normal file
View File

@ -0,0 +1,45 @@
; RUN: opt < %s -analyze -block-freq | FileCheck %s
; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
; CHECK-LABEL: Printing analysis {{.*}} for function 'loop_with_branch':
; CHECK-NEXT: block-frequency-info: loop_with_branch
define void @loop_with_branch(i32 %a) {
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
%skip_loop = call i1 @foo0(i32 %a)
br i1 %skip_loop, label %skip, label %header, !prof !0
; CHECK-NEXT: skip: float = 0.25,
skip:
br label %exit
; CHECK-NEXT: header: float = 4.5,
header:
%i = phi i32 [ 0, %entry ], [ %i.next, %back ]
%i.next = add i32 %i, 1
%choose = call i2 @foo1(i32 %i)
switch i2 %choose, label %exit [ i2 0, label %left
i2 1, label %right ], !prof !1
; CHECK-NEXT: left: float = 1.5,
left:
br label %back
; CHECK-NEXT: right: float = 2.25,
right:
br label %back
; CHECK-NEXT: back: float = 3.75,
back:
br label %header
; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
exit:
ret void
}
declare i1 @foo0(i32)
declare i2 @foo1(i32)
!0 = !{!"branch_weights", i32 1, i32 3}
!1 = !{!"branch_weights", i32 1, i32 2, i32 3}

205
external/llvm/test/Analysis/BlockFrequencyInfo/loops_with_profile_info.ll vendored Normal file
View File

@ -0,0 +1,205 @@
; RUN: opt < %s -analyze -block-freq | FileCheck %s
; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
; This code contains three loops. One is triple-nested, the
; second is double nested and the third is a single loop. At
; runtime, all three loops execute 1,000,000 times each. We use to
; give different frequencies to each of the loops because loop
; scales were limited to no more than 4,096.
;
; This was penalizing the hotness of the second and third loops
; because BFI was reducing the loop scale for for.cond16 and
; for.cond26 to a max of 4,096.
;
; Without this restriction, all loops are now correctly given the same
; frequency values.
;
; Original C code:
;
;
; int g;
; __attribute__((noinline)) void bar() {
; g++;
; }
;
; extern int printf(const char*, ...);
;
; int main()
; {
; int i, j, k;
;
; g = 0;
; for (i = 0; i < 100; i++)
; for (j = 0; j < 100; j++)
; for (k = 0; k < 100; k++)
; bar();
;
; printf ("g = %d\n", g);
; g = 0;
;
; for (i = 0; i < 100; i++)
; for (j = 0; j < 10000; j++)
; bar();
;
; printf ("g = %d\n", g);
; g = 0;
;
;
; for (i = 0; i < 1000000; i++)
; bar();
;
; printf ("g = %d\n", g);
; g = 0;
; }
@g = common global i32 0, align 4
@.str = private unnamed_addr constant [8 x i8] c"g = %d\0A\00", align 1
declare void @bar()
declare i32 @printf(i8*, ...)
; CHECK: Printing analysis {{.*}} for function 'main':
; CHECK-NEXT: block-frequency-info: main
define i32 @main() {
entry:
%retval = alloca i32, align 4
%i = alloca i32, align 4
%j = alloca i32, align 4
%k = alloca i32, align 4
store i32 0, i32* %retval
store i32 0, i32* @g, align 4
store i32 0, i32* %i, align 4
br label %for.cond
for.cond: ; preds = %for.inc10, %entry
%0 = load i32, i32* %i, align 4
%cmp = icmp slt i32 %0, 100
br i1 %cmp, label %for.body, label %for.end12, !prof !1
for.body: ; preds = %for.cond
store i32 0, i32* %j, align 4
br label %for.cond1
for.cond1: ; preds = %for.inc7, %for.body
%1 = load i32, i32* %j, align 4
%cmp2 = icmp slt i32 %1, 100
br i1 %cmp2, label %for.body3, label %for.end9, !prof !2
for.body3: ; preds = %for.cond1
store i32 0, i32* %k, align 4
br label %for.cond4
for.cond4: ; preds = %for.inc, %for.body3
%2 = load i32, i32* %k, align 4
%cmp5 = icmp slt i32 %2, 100
br i1 %cmp5, label %for.body6, label %for.end, !prof !3
; CHECK: - for.body6: float = 500000.5, int = 4000004
for.body6: ; preds = %for.cond4
call void @bar()
br label %for.inc
for.inc: ; preds = %for.body6
%3 = load i32, i32* %k, align 4
%inc = add nsw i32 %3, 1
store i32 %inc, i32* %k, align 4
br label %for.cond4
for.end: ; preds = %for.cond4
br label %for.inc7
for.inc7: ; preds = %for.end
%4 = load i32, i32* %j, align 4
%inc8 = add nsw i32 %4, 1
store i32 %inc8, i32* %j, align 4
br label %for.cond1
for.end9: ; preds = %for.cond1
br label %for.inc10
for.inc10: ; preds = %for.end9
%5 = load i32, i32* %i, align 4
%inc11 = add nsw i32 %5, 1
store i32 %inc11, i32* %i, align 4
br label %for.cond
for.end12: ; preds = %for.cond
%6 = load i32, i32* @g, align 4
%call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i32 %6)
store i32 0, i32* @g, align 4
store i32 0, i32* %i, align 4
br label %for.cond13
for.cond13: ; preds = %for.inc22, %for.end12
%7 = load i32, i32* %i, align 4
%cmp14 = icmp slt i32 %7, 100
br i1 %cmp14, label %for.body15, label %for.end24, !prof !1
for.body15: ; preds = %for.cond13
store i32 0, i32* %j, align 4
br label %for.cond16
for.cond16: ; preds = %for.inc19, %for.body15
%8 = load i32, i32* %j, align 4
%cmp17 = icmp slt i32 %8, 10000
br i1 %cmp17, label %for.body18, label %for.end21, !prof !4
; CHECK: - for.body18: float = 499999.9, int = 3999998
for.body18: ; preds = %for.cond16
call void @bar()
br label %for.inc19
for.inc19: ; preds = %for.body18
%9 = load i32, i32* %j, align 4
%inc20 = add nsw i32 %9, 1
store i32 %inc20, i32* %j, align 4
br label %for.cond16
for.end21: ; preds = %for.cond16
br label %for.inc22
for.inc22: ; preds = %for.end21
%10 = load i32, i32* %i, align 4
%inc23 = add nsw i32 %10, 1
store i32 %inc23, i32* %i, align 4
br label %for.cond13
for.end24: ; preds = %for.cond13
%11 = load i32, i32* @g, align 4
%call25 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i32 %11)
store i32 0, i32* @g, align 4
store i32 0, i32* %i, align 4
br label %for.cond26
for.cond26: ; preds = %for.inc29, %for.end24
%12 = load i32, i32* %i, align 4
%cmp27 = icmp slt i32 %12, 1000000
br i1 %cmp27, label %for.body28, label %for.end31, !prof !5
; CHECK: - for.body28: float = 499995.2, int = 3999961
for.body28: ; preds = %for.cond26
call void @bar()
br label %for.inc29
for.inc29: ; preds = %for.body28
%13 = load i32, i32* %i, align 4
%inc30 = add nsw i32 %13, 1
store i32 %inc30, i32* %i, align 4
br label %for.cond26
for.end31: ; preds = %for.cond26
%14 = load i32, i32* @g, align 4
%call32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i32 %14)
store i32 0, i32* @g, align 4
%15 = load i32, i32* %retval
ret i32 %15
}
!llvm.ident = !{!0}
!0 = !{!"clang version 3.7.0 (trunk 232635) (llvm/trunk 232636)"}
!1 = !{!"branch_weights", i32 101, i32 2}
!2 = !{!"branch_weights", i32 10001, i32 101}
!3 = !{!"branch_weights", i32 1000001, i32 10001}
!4 = !{!"branch_weights", i32 1000001, i32 101}
!5 = !{!"branch_weights", i32 1000001, i32 2}

60
external/llvm/test/Analysis/BlockFrequencyInfo/nested_loop_with_branches.ll vendored Normal file
View File

@ -0,0 +1,60 @@
; RUN: opt < %s -analyze -block-freq | FileCheck %s
; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
; CHECK-LABEL: Printing analysis {{.*}} for function 'nested_loop_with_branches'
; CHECK-NEXT: block-frequency-info: nested_loop_with_branches
define void @nested_loop_with_branches(i32 %a) {
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
%v0 = call i1 @foo0(i32 %a)
br i1 %v0, label %exit, label %outer, !prof !0
; CHECK-NEXT: outer: float = 12.0,
outer:
%i = phi i32 [ 0, %entry ], [ %i.next, %inner.end ], [ %i.next, %no_inner ]
%i.next = add i32 %i, 1
%do_inner = call i1 @foo1(i32 %i)
br i1 %do_inner, label %no_inner, label %inner, !prof !0
; CHECK-NEXT: inner: float = 36.0,
inner:
%j = phi i32 [ 0, %outer ], [ %j.next, %inner.end ]
%side = call i1 @foo3(i32 %j)
br i1 %side, label %left, label %right, !prof !0
; CHECK-NEXT: left: float = 9.0,
left:
%v4 = call i1 @foo4(i32 %j)
br label %inner.end
; CHECK-NEXT: right: float = 27.0,
right:
%v5 = call i1 @foo5(i32 %j)
br label %inner.end
; CHECK-NEXT: inner.end: float = 36.0,
inner.end:
%stay_inner = phi i1 [ %v4, %left ], [ %v5, %right ]
%j.next = add i32 %j, 1
br i1 %stay_inner, label %inner, label %outer, !prof !1
; CHECK-NEXT: no_inner: float = 3.0,
no_inner:
%continue = call i1 @foo6(i32 %i)
br i1 %continue, label %outer, label %exit, !prof !1
; CHECK-NEXT: exit: float = 1.0, int = [[ENTRY]]
exit:
ret void
}
declare i1 @foo0(i32)
declare i1 @foo1(i32)
declare i1 @foo2(i32)
declare i1 @foo3(i32)
declare i1 @foo4(i32)
declare i1 @foo5(i32)
declare i1 @foo6(i32)
!0 = !{!"branch_weights", i32 1, i32 3}
!1 = !{!"branch_weights", i32 3, i32 1}

22
external/llvm/test/Analysis/BlockFrequencyInfo/redundant_edges.ll vendored Normal file
View File

@ -0,0 +1,22 @@
; RUN: opt < %s -analyze -block-freq | FileCheck %s
; RUN: opt < %s -analyze -lazy-block-freq | FileCheck %s
; RUN: opt < %s -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s
define void @test1() {
; CHECK-LABEL: Printing analysis {{.*}} for function 'test1':
; CHECK-NEXT: block-frequency-info: test1
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
entry:
br label %loop
; CHECK-NEXT: loop: float = 32.0
loop:
switch i32 undef, label %loop [
i32 0, label %return
i32 1, label %return
]
; CHECK-NEXT: return: float = 1.0
return:
ret void
}