Skip to content

Commit 84ea257

Browse files
fhahnfhahn
committed
[SCEV] Add early exit tests with alignment assumptions.
1 parent d4f41be commit 84ea257

File tree

1 file changed

+174
-4
lines changed

1 file changed

+174
-4
lines changed

‎llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll

Lines changed: 174 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1652,10 +1652,7 @@ exit:
16521652
ret void
16531653
}
16541654

1655-
; TODO: It feels like we should be able to calculate the symbolic max
1656-
; exit count for the loop.inc block here, in the same way as
1657-
; ptr_induction_eq_1. The problem seems to be in howFarToZero when the
1658-
; ControlsOnlyExit is set to false.
1655+
; We are not able to compute exit counts, as %a and %b might not be multiples of 8.
16591656
define void @ptr_induction_early_exit_eq_1(ptr %a, ptr %b, ptr %c) {
16601657
; CHECK-LABEL: 'ptr_induction_early_exit_eq_1'
16611658
; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_1
@@ -1693,6 +1690,179 @@ exit:
16931690
ret void
16941691
}
16951692

1693+
; Variant of @ptr_induction_early_exit_eq_1 with alignment info via load metadata.
1694+
define void @ptr_induction_early_exit_eq_1_with_align_on_load(ptr %a, ptr %b, ptr %c) {
1695+
; CHECK-LABEL: 'ptr_induction_early_exit_eq_1_with_align_on_load'
1696+
; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_1_with_align_on_load
1697+
; CHECK-NEXT: %a_ = load ptr, ptr %a, align 8, !align !0
1698+
; CHECK-NEXT: --> %a_ U: [0,-7) S: [-9223372036854775808,9223372036854775801)
1699+
; CHECK-NEXT: %b_ = load ptr, ptr %b, align 8, !align !0
1700+
; CHECK-NEXT: --> %b_ U: [0,-7) S: [-9223372036854775808,9223372036854775801)
1701+
; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ]
1702+
; CHECK-NEXT: --> {%a_,+,8}<nuw><%loop> U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1703+
; CHECK-NEXT: %ld1 = load ptr, ptr %ptr.iv, align 8
1704+
; CHECK-NEXT: --> %ld1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
1705+
; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1706+
; CHECK-NEXT: --> {(8 + %a_),+,8}<nw><%loop> U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1707+
; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_with_align_on_load
1708+
; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
1709+
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
1710+
; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8)
1711+
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693951
1712+
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8)
1713+
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
1714+
; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8)
1715+
;
1716+
entry:
1717+
%a_ = load ptr, ptr %a, !align !{i64 8}
1718+
%b_ = load ptr, ptr %b, !align !{i64 8}
1719+
%cmp = icmp eq ptr %a_, %b_
1720+
br i1 %cmp, label %exit, label %loop
1721+
1722+
loop:
1723+
%ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ]
1724+
%ld1 = load ptr, ptr %ptr.iv, align 8
1725+
%earlyexitcond = icmp eq ptr %ld1, %c
1726+
br i1 %earlyexitcond, label %exit, label %loop.inc
1727+
1728+
loop.inc:
1729+
%ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1730+
%exitcond = icmp eq ptr %ptr.iv.next, %b_
1731+
br i1 %exitcond, label %exit, label %loop
1732+
1733+
exit:
1734+
ret void
1735+
}
1736+
1737+
; Variant of @ptr_induction_early_exit_eq_1 with alignment info via arument attributes.
1738+
define void @ptr_induction_early_exit_eq_1_with_align_on_arguments(ptr align 8 %a, ptr align 8 %b, ptr %c) {
1739+
; CHECK-LABEL: 'ptr_induction_early_exit_eq_1_with_align_on_arguments'
1740+
; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_1_with_align_on_arguments
1741+
; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a, %entry ]
1742+
; CHECK-NEXT: --> {%a,+,8}<nuw><%loop> U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1743+
; CHECK-NEXT: %ld1 = load ptr, ptr %ptr.iv, align 8
1744+
; CHECK-NEXT: --> %ld1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
1745+
; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1746+
; CHECK-NEXT: --> {(8 + %a),+,8}<nw><%loop> U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1747+
; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_with_align_on_arguments
1748+
; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
1749+
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
1750+
; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8)
1751+
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693951
1752+
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8)
1753+
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
1754+
; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8)
1755+
;
1756+
entry:
1757+
%cmp = icmp eq ptr %a, %b
1758+
br i1 %cmp, label %exit, label %loop
1759+
1760+
loop:
1761+
%ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a, %entry ]
1762+
%ld1 = load ptr, ptr %ptr.iv, align 8
1763+
%earlyexitcond = icmp eq ptr %ld1, %c
1764+
br i1 %earlyexitcond, label %exit, label %loop.inc
1765+
1766+
loop.inc:
1767+
%ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1768+
%exitcond = icmp eq ptr %ptr.iv.next, %b
1769+
br i1 %exitcond, label %exit, label %loop
1770+
1771+
exit:
1772+
ret void
1773+
}
1774+
1775+
; Variant of @ptr_induction_early_exit_eq_1 with alignment assumptions.
1776+
define void @ptr_induction_early_exit_eq_1_align_assumption_1(ptr %a, ptr %b, ptr %c) {
1777+
; CHECK-LABEL: 'ptr_induction_early_exit_eq_1_align_assumption_1'
1778+
; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_1_align_assumption_1
1779+
; CHECK-NEXT: %a_ = load ptr, ptr %a, align 8
1780+
; CHECK-NEXT: --> %a_ U: full-set S: full-set
1781+
; CHECK-NEXT: %b_ = load ptr, ptr %b, align 8
1782+
; CHECK-NEXT: --> %b_ U: full-set S: full-set
1783+
; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ]
1784+
; CHECK-NEXT: --> {%a_,+,8}<nuw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1785+
; CHECK-NEXT: %ld1 = load ptr, ptr %ptr.iv, align 8
1786+
; CHECK-NEXT: --> %ld1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
1787+
; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1788+
; CHECK-NEXT: --> {(8 + %a_),+,8}<nw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1789+
; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_align_assumption_1
1790+
; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
1791+
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
1792+
; CHECK-NEXT: exit count for loop.inc: ***COULDNOTCOMPUTE***
1793+
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
1794+
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
1795+
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
1796+
; CHECK-NEXT: symbolic max exit count for loop.inc: ***COULDNOTCOMPUTE***
1797+
;
1798+
entry:
1799+
%a_ = load ptr, ptr %a
1800+
call void @llvm.assume(i1 true) [ "align"(ptr %a_, i64 8) ]
1801+
%b_ = load ptr, ptr %b
1802+
call void @llvm.assume(i1 true) [ "align"(ptr %b_, i64 8) ]
1803+
%cmp = icmp eq ptr %a_, %b_
1804+
br i1 %cmp, label %exit, label %loop
1805+
1806+
loop:
1807+
%ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ]
1808+
%ld1 = load ptr, ptr %ptr.iv, align 8
1809+
%earlyexitcond = icmp eq ptr %ld1, %c
1810+
br i1 %earlyexitcond, label %exit, label %loop.inc
1811+
1812+
loop.inc:
1813+
%ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1814+
%exitcond = icmp eq ptr %ptr.iv.next, %b_
1815+
br i1 %exitcond, label %exit, label %loop
1816+
1817+
exit:
1818+
ret void
1819+
}
1820+
1821+
define void @ptr_induction_early_exit_eq_1_align_assumption_2(ptr %a, ptr %b, ptr %c) {
1822+
; CHECK-LABEL: 'ptr_induction_early_exit_eq_1_align_assumption_2'
1823+
; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_1_align_assumption_2
1824+
; CHECK-NEXT: %a_ = load ptr, ptr %a, align 8
1825+
; CHECK-NEXT: --> %a_ U: full-set S: full-set
1826+
; CHECK-NEXT: %b_ = load ptr, ptr %b, align 8
1827+
; CHECK-NEXT: --> %b_ U: full-set S: full-set
1828+
; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ]
1829+
; CHECK-NEXT: --> {%a_,+,8}<nuw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1830+
; CHECK-NEXT: %ld1 = load ptr, ptr %ptr.iv, align 8
1831+
; CHECK-NEXT: --> %ld1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
1832+
; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1833+
; CHECK-NEXT: --> {(8 + %a_),+,8}<nw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1834+
; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_align_assumption_2
1835+
; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
1836+
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
1837+
; CHECK-NEXT: exit count for loop.inc: ***COULDNOTCOMPUTE***
1838+
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
1839+
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
1840+
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
1841+
; CHECK-NEXT: symbolic max exit count for loop.inc: ***COULDNOTCOMPUTE***
1842+
;
1843+
entry:
1844+
%a_ = load ptr, ptr %a
1845+
%b_ = load ptr, ptr %b
1846+
call void @llvm.assume(i1 true) [ "align"(ptr %a_, i64 8) ]
1847+
call void @llvm.assume(i1 true) [ "align"(ptr %b_, i64 8) ]
1848+
%cmp = icmp eq ptr %a_, %b_
1849+
br i1 %cmp, label %exit, label %loop
1850+
1851+
loop:
1852+
%ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ]
1853+
%ld1 = load ptr, ptr %ptr.iv, align 8
1854+
%earlyexitcond = icmp eq ptr %ld1, %c
1855+
br i1 %earlyexitcond, label %exit, label %loop.inc
1856+
1857+
loop.inc:
1858+
%ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1859+
%exitcond = icmp eq ptr %ptr.iv.next, %b_
1860+
br i1 %exitcond, label %exit, label %loop
1861+
1862+
exit:
1863+
ret void
1864+
}
1865+
16961866
define void @ptr_induction_early_exit_eq_2(ptr %a, i64 %n, ptr %c) {
16971867
; CHECK-LABEL: 'ptr_induction_early_exit_eq_2'
16981868
; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_2

0 commit comments

Comments
 (0)