Skip to content

Commit 725e43e

Browse files
fhahnfhahn
committed
[SCEV] Add early exit tests with alignment assumptions.
Precommit tests from llvm#108632. (cherry picked from commit 383a670)
1 parent 6e0f052 commit 725e43e

File tree

1 file changed

+268
-0
lines changed

1 file changed

+268
-0
lines changed

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

Lines changed: 268 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1595,6 +1595,274 @@ exit:
15951595
ret i32 0
15961596
}
15971597

1598+
define void @ptr_induction_eq_2(ptr %a, i64 %n) {
1599+
; CHECK-LABEL: 'ptr_induction_eq_2'
1600+
; CHECK-NEXT: Classifying expressions for: @ptr_induction_eq_2
1601+
; CHECK-NEXT: %b = getelementptr inbounds ptr, ptr %a, i64 %n
1602+
; CHECK-NEXT: --> ((8 * %n)<nsw> + %a) U: full-set S: full-set
1603+
; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop ], [ %a, %entry ]
1604+
; CHECK-NEXT: --> {%a,+,8}<nuw><%loop> U: full-set S: full-set Exits: ((8 * ((-8 + (8 * %n)<nsw>) /u 8))<nuw> + %a) LoopDispositions: { %loop: Computable }
1605+
; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1606+
; CHECK-NEXT: --> {(8 + %a),+,8}<nuw><%loop> U: full-set S: full-set Exits: (8 + (8 * ((-8 + (8 * %n)<nsw>) /u 8))<nuw> + %a) LoopDispositions: { %loop: Computable }
1607+
; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_eq_2
1608+
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-8 + (8 * %n)<nsw>) /u 8)
1609+
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693951
1610+
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (8 * %n)<nsw>) /u 8)
1611+
; CHECK-NEXT: Loop %loop: Trip multiple is 1
1612+
;
1613+
entry:
1614+
%b = getelementptr inbounds ptr, ptr %a, i64 %n
1615+
%cmp = icmp eq ptr %a, %b
1616+
br i1 %cmp, label %exit, label %loop
1617+
1618+
loop:
1619+
%ptr.iv = phi ptr [ %ptr.iv.next, %loop ], [ %a, %entry ]
1620+
%ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1621+
%exitcond = icmp eq ptr %ptr.iv.next, %b
1622+
br i1 %exitcond, label %exit, label %loop
1623+
1624+
exit:
1625+
ret void
1626+
}
1627+
1628+
define void @ptr_induction_early_exit_eq_1_with_align_on_load(ptr %a, ptr %b, ptr %c) {
1629+
; CHECK-LABEL: 'ptr_induction_early_exit_eq_1_with_align_on_load'
1630+
; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_1_with_align_on_load
1631+
; CHECK-NEXT: %a_ = load ptr, ptr %a, align 8, !align !0
1632+
; CHECK-NEXT: --> %a_ U: [0,-7) S: [-9223372036854775808,9223372036854775801)
1633+
; CHECK-NEXT: %b_ = load ptr, ptr %b, align 8, !align !0
1634+
; CHECK-NEXT: --> %b_ U: [0,-7) S: [-9223372036854775808,9223372036854775801)
1635+
; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ]
1636+
; CHECK-NEXT: --> {%a_,+,8}<nuw><%loop> U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1637+
; CHECK-NEXT: %ld1 = load ptr, ptr %ptr.iv, align 8
1638+
; CHECK-NEXT: --> %ld1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
1639+
; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1640+
; CHECK-NEXT: --> {(8 + %a_),+,8}<nw><%loop> U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1641+
; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_with_align_on_load
1642+
; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
1643+
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
1644+
; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8)
1645+
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693951
1646+
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8)
1647+
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
1648+
; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8)
1649+
;
1650+
entry:
1651+
%a_ = load ptr, ptr %a, !align !{i64 8}
1652+
%b_ = load ptr, ptr %b, !align !{i64 8}
1653+
%cmp = icmp eq ptr %a_, %b_
1654+
br i1 %cmp, label %exit, label %loop
1655+
1656+
loop:
1657+
%ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ]
1658+
%ld1 = load ptr, ptr %ptr.iv, align 8
1659+
%earlyexitcond = icmp eq ptr %ld1, %c
1660+
br i1 %earlyexitcond, label %exit, label %loop.inc
1661+
1662+
loop.inc:
1663+
%ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1664+
%exitcond = icmp eq ptr %ptr.iv.next, %b_
1665+
br i1 %exitcond, label %exit, label %loop
1666+
1667+
exit:
1668+
ret void
1669+
}
1670+
1671+
define void @ptr_induction_early_exit_eq_1_with_align_on_arguments(ptr align 8 %a, ptr align 8 %b, ptr %c) {
1672+
; CHECK-LABEL: 'ptr_induction_early_exit_eq_1_with_align_on_arguments'
1673+
; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_1_with_align_on_arguments
1674+
; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a, %entry ]
1675+
; CHECK-NEXT: --> {%a,+,8}<nuw><%loop> U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1676+
; CHECK-NEXT: %ld1 = load ptr, ptr %ptr.iv, align 8
1677+
; CHECK-NEXT: --> %ld1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
1678+
; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1679+
; CHECK-NEXT: --> {(8 + %a),+,8}<nw><%loop> U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1680+
; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_with_align_on_arguments
1681+
; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
1682+
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
1683+
; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8)
1684+
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693951
1685+
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8)
1686+
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
1687+
; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8)
1688+
;
1689+
entry:
1690+
%cmp = icmp eq ptr %a, %b
1691+
br i1 %cmp, label %exit, label %loop
1692+
1693+
loop:
1694+
%ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a, %entry ]
1695+
%ld1 = load ptr, ptr %ptr.iv, align 8
1696+
%earlyexitcond = icmp eq ptr %ld1, %c
1697+
br i1 %earlyexitcond, label %exit, label %loop.inc
1698+
1699+
loop.inc:
1700+
%ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1701+
%exitcond = icmp eq ptr %ptr.iv.next, %b
1702+
br i1 %exitcond, label %exit, label %loop
1703+
1704+
exit:
1705+
ret void
1706+
}
1707+
1708+
define void @ptr_induction_early_exit_eq_1_align_assumption_1(ptr %a, ptr %b, ptr %c) {
1709+
; CHECK-LABEL: 'ptr_induction_early_exit_eq_1_align_assumption_1'
1710+
; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_1_align_assumption_1
1711+
; CHECK-NEXT: %a_ = load ptr, ptr %a, align 8
1712+
; CHECK-NEXT: --> %a_ U: full-set S: full-set
1713+
; CHECK-NEXT: %b_ = load ptr, ptr %b, align 8
1714+
; CHECK-NEXT: --> %b_ U: full-set S: full-set
1715+
; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ]
1716+
; CHECK-NEXT: --> {%a_,+,8}<nuw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1717+
; CHECK-NEXT: %ld1 = load ptr, ptr %ptr.iv, align 8
1718+
; CHECK-NEXT: --> %ld1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
1719+
; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1720+
; CHECK-NEXT: --> {(8 + %a_),+,8}<nw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1721+
; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_align_assumption_1
1722+
; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
1723+
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
1724+
; CHECK-NEXT: exit count for loop.inc: ***COULDNOTCOMPUTE***
1725+
; CHECK-NEXT: predicated exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8)
1726+
; CHECK-NEXT: Predicates:
1727+
; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0
1728+
; CHECK-EMPTY:
1729+
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
1730+
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
1731+
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
1732+
; CHECK-NEXT: symbolic max exit count for loop.inc: ***COULDNOTCOMPUTE***
1733+
; CHECK-NEXT: predicated symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8)
1734+
; CHECK-NEXT: Predicates:
1735+
; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0
1736+
; CHECK-EMPTY:
1737+
; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 2305843009213693951
1738+
; CHECK-NEXT: Predicates:
1739+
; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0
1740+
; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8)
1741+
; CHECK-NEXT: Predicates:
1742+
; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0
1743+
;
1744+
entry:
1745+
%a_ = load ptr, ptr %a
1746+
call void @llvm.assume(i1 true) [ "align"(ptr %a_, i64 8) ]
1747+
%b_ = load ptr, ptr %b
1748+
call void @llvm.assume(i1 true) [ "align"(ptr %b_, i64 8) ]
1749+
%cmp = icmp eq ptr %a_, %b_
1750+
br i1 %cmp, label %exit, label %loop
1751+
1752+
loop:
1753+
%ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ]
1754+
%ld1 = load ptr, ptr %ptr.iv, align 8
1755+
%earlyexitcond = icmp eq ptr %ld1, %c
1756+
br i1 %earlyexitcond, label %exit, label %loop.inc
1757+
1758+
loop.inc:
1759+
%ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1760+
%exitcond = icmp eq ptr %ptr.iv.next, %b_
1761+
br i1 %exitcond, label %exit, label %loop
1762+
1763+
exit:
1764+
ret void
1765+
}
1766+
1767+
define void @ptr_induction_early_exit_eq_1_align_assumption_2(ptr %a, ptr %b, ptr %c) {
1768+
; CHECK-LABEL: 'ptr_induction_early_exit_eq_1_align_assumption_2'
1769+
; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_1_align_assumption_2
1770+
; CHECK-NEXT: %a_ = load ptr, ptr %a, align 8
1771+
; CHECK-NEXT: --> %a_ U: full-set S: full-set
1772+
; CHECK-NEXT: %b_ = load ptr, ptr %b, align 8
1773+
; CHECK-NEXT: --> %b_ U: full-set S: full-set
1774+
; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ]
1775+
; CHECK-NEXT: --> {%a_,+,8}<nuw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1776+
; CHECK-NEXT: %ld1 = load ptr, ptr %ptr.iv, align 8
1777+
; CHECK-NEXT: --> %ld1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
1778+
; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1779+
; CHECK-NEXT: --> {(8 + %a_),+,8}<nw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1780+
; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_align_assumption_2
1781+
; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
1782+
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
1783+
; CHECK-NEXT: exit count for loop.inc: ***COULDNOTCOMPUTE***
1784+
; CHECK-NEXT: predicated exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8)
1785+
; CHECK-NEXT: Predicates:
1786+
; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0
1787+
; CHECK-EMPTY:
1788+
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
1789+
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
1790+
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
1791+
; CHECK-NEXT: symbolic max exit count for loop.inc: ***COULDNOTCOMPUTE***
1792+
; CHECK-NEXT: predicated symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8)
1793+
; CHECK-NEXT: Predicates:
1794+
; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0
1795+
; CHECK-EMPTY:
1796+
; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 2305843009213693951
1797+
; CHECK-NEXT: Predicates:
1798+
; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0
1799+
; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8)
1800+
; CHECK-NEXT: Predicates:
1801+
; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0
1802+
;
1803+
entry:
1804+
%a_ = load ptr, ptr %a
1805+
%b_ = load ptr, ptr %b
1806+
call void @llvm.assume(i1 true) [ "align"(ptr %a_, i64 8) ]
1807+
call void @llvm.assume(i1 true) [ "align"(ptr %b_, i64 8) ]
1808+
%cmp = icmp eq ptr %a_, %b_
1809+
br i1 %cmp, label %exit, label %loop
1810+
1811+
loop:
1812+
%ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ]
1813+
%ld1 = load ptr, ptr %ptr.iv, align 8
1814+
%earlyexitcond = icmp eq ptr %ld1, %c
1815+
br i1 %earlyexitcond, label %exit, label %loop.inc
1816+
1817+
loop.inc:
1818+
%ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1819+
%exitcond = icmp eq ptr %ptr.iv.next, %b_
1820+
br i1 %exitcond, label %exit, label %loop
1821+
1822+
exit:
1823+
ret void
1824+
}
1825+
1826+
define void @ptr_induction_early_exit_eq_2(ptr %a, i64 %n, ptr %c) {
1827+
; CHECK-LABEL: 'ptr_induction_early_exit_eq_2'
1828+
; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_2
1829+
; CHECK-NEXT: %b = getelementptr inbounds ptr, ptr %a, i64 %n
1830+
; CHECK-NEXT: --> ((8 * %n)<nsw> + %a) U: full-set S: full-set
1831+
; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a, %entry ]
1832+
; CHECK-NEXT: --> {%a,+,8}<nuw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1833+
; CHECK-NEXT: %ld1 = load ptr, ptr %ptr.iv, align 8
1834+
; CHECK-NEXT: --> %ld1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
1835+
; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
1836+
; CHECK-NEXT: --> {(8 + %a),+,8}<nw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
1837+
; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_2
1838+
; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
1839+
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
1840+
; CHECK-NEXT: exit count for loop.inc: ((-8 + (8 * %n)<nsw>) /u 8)
1841+
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693951
1842+
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (8 * %n)<nsw>) /u 8)
1843+
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
1844+
; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (8 * %n)<nsw>) /u 8)
1845+
;
1846+
entry:
1847+
%b = getelementptr inbounds ptr, ptr %a, i64 %n
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+
15981866
define void @gep_addrec_nw(ptr %a) {
15991867
; CHECK-LABEL: 'gep_addrec_nw'
16001868
; CHECK-NEXT: Classifying expressions for: @gep_addrec_nw

0 commit comments

Comments
 (0)