Skip to content

Commit 86016b2

Browse files
fhahnfhahn
committed
!fixup check object size to determine no-wrap.
1 parent 64952aa commit 86016b2

File tree

5 files changed

+148
-17
lines changed

5 files changed

+148
-17
lines changed

‎llvm/lib/Analysis/Loads.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -333,6 +333,8 @@ bool llvm::isDereferenceableAndAlignedInLoop(
333333

334334
// Try to get the access size.
335335
const SCEV *PtrDiff = SE.getMinusSCEV(AccessEnd, AccessStart);
336+
if (isa<SCEVCouldNotCompute>(PtrDiff))
337+
return false;
336338
APInt MaxPtrDiff = SE.getUnsignedRangeMax(PtrDiff);
337339

338340
Value *Base = nullptr;

‎llvm/lib/Analysis/LoopAccessAnalysis.cpp

Lines changed: 51 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -188,6 +188,51 @@ RuntimeCheckingPtrGroup::RuntimeCheckingPtrGroup(
188188
Members.push_back(Index);
189189
}
190190

191+
/// Return true, if evaluating \p AR at \p MaxBTC cannot wrap, because \p AR at
192+
/// \p MaxBTC is guaranteed inbounds of the accessed object.
193+
static bool evaluateAddRecAtMaxBTCWillNotWrap(const SCEVAddRecExpr *AR,
194+
const SCEV *MaxBTC,
195+
ScalarEvolution &SE,
196+
const DataLayout &DL) {
197+
auto *PointerBase = SE.getPointerBase(AR->getStart());
198+
auto *StartPtr = dyn_cast<SCEVUnknown>(PointerBase);
199+
if (!StartPtr)
200+
return false;
201+
bool CheckForNonNull, CheckForFreed;
202+
uint64_t DerefBytes = StartPtr->getValue()->getPointerDereferenceableBytes(
203+
DL, CheckForNonNull, CheckForFreed);
204+
205+
if (CheckForNonNull || CheckForFreed)
206+
return false;
207+
208+
const SCEV *Step = AR->getStepRecurrence(SE);
209+
Type *WiderTy = SE.getWiderType(MaxBTC->getType(), Step->getType());
210+
Step = SE.getNoopOrSignExtend(Step, WiderTy);
211+
MaxBTC = SE.getNoopOrSignExtend(MaxBTC, WiderTy);
212+
if (SE.isKnownPositive(Step)) {
213+
// For positive steps, check if (AR->getStart() - StartPtr) + MaxBTC <=
214+
// DerefBytes / Step
215+
return SE.isKnownPredicate(
216+
CmpInst::ICMP_ULE,
217+
SE.getAddExpr(SE.getMinusSCEV(AR->getStart(), StartPtr), MaxBTC),
218+
SE.getUDivExpr(SE.getConstant(WiderTy, DerefBytes), Step));
219+
}
220+
if (SE.isKnownNegative(Step)) {
221+
// For negative steps, check using StartOffset == AR->getStart() - StartPtr:
222+
// * StartOffset >= MaxBTC * Step
223+
// * AND StartOffset <= DerefBytes / Step
224+
auto *StartOffset = SE.getMinusSCEV(AR->getStart(), StartPtr);
225+
return SE.isKnownPredicate(
226+
CmpInst::ICMP_UGE, StartOffset,
227+
SE.getMulExpr(MaxBTC, SE.getNegativeSCEV(Step))) &&
228+
SE.isKnownPredicate(
229+
CmpInst::ICMP_ULE, StartOffset,
230+
SE.getUDivExpr(SE.getConstant(WiderTy, DerefBytes),
231+
SE.getNegativeSCEV(Step)));
232+
}
233+
return false;
234+
}
235+
191236
std::pair<const SCEV *, const SCEV *> llvm::getStartAndEndForAccess(
192237
const Loop *Lp, const SCEV *PtrExpr, Type *AccessTy, const SCEV *BTC,
193238
const SCEV *MaxBTC, ScalarEvolution *SE,
@@ -226,12 +271,12 @@ std::pair<const SCEV *, const SCEV *> llvm::getStartAndEndForAccess(
226271
// will get incremented by EltSize before returning, so this effectively
227272
// sets ScEnd to unsigned max. Note that LAA separately checks that
228273
// accesses cannot not wrap, so unsigned max represents an upper bound.
229-
// TODO: Use additional information to determine no-wrap including
230-
// size/dereferencability info from the accessed object.
231-
ScEnd = AR->evaluateAtIteration(MaxBTC, *SE);
232-
if (!SE->isKnownNonNegative(SE->getMinusSCEV(ScEnd, ScStart)))
233-
ScEnd = SE->getNegativeSCEV(
234-
SE->getAddExpr(EltSizeSCEV, SE->getOne(EltSizeSCEV->getType())));
274+
ScEnd = SE->getAddExpr(
275+
SE->getNegativeSCEV(EltSizeSCEV),
276+
SE->getSCEV(ConstantExpr::getIntToPtr(
277+
ConstantInt::get(EltSizeSCEV->getType(), -1), AR->getType())));
278+
if (evaluateAddRecAtMaxBTCWillNotWrap(AR, MaxBTC, *SE, DL))
279+
ScEnd = AR->evaluateAtIteration(MaxBTC, *SE);
235280
}
236281
const SCEV *Step = AR->getStepRecurrence(*SE);
237282

‎llvm/test/Analysis/LoopAccessAnalysis/early-exit-runtime-checks.ll

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -72,10 +72,10 @@ define void @all_exits_dominate_latch_countable_exits_at_most_500_iterations_not
7272
; CHECK-NEXT: %gep.A = getelementptr inbounds i32, ptr %A, i64 %iv
7373
; CHECK-NEXT: Grouped accesses:
7474
; CHECK-NEXT: Group [[GRP3]]:
75-
; CHECK-NEXT: (Low: %B High: (2000 + %B))
75+
; CHECK-NEXT: (Low: %B High: inttoptr (i64 -1 to ptr))
7676
; CHECK-NEXT: Member: {%B,+,4}<nuw><%loop.header>
7777
; CHECK-NEXT: Group [[GRP4]]:
78-
; CHECK-NEXT: (Low: %A High: (2000 + %A))
78+
; CHECK-NEXT: (Low: %A High: inttoptr (i64 -1 to ptr))
7979
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop.header>
8080
; CHECK-EMPTY:
8181
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -188,10 +188,10 @@ define i32 @all_exits_dominate_latch_countable_exits_at_most_1000_iterations_not
188188
; CHECK-NEXT: %gep.A = getelementptr inbounds i32, ptr %A, i64 %iv
189189
; CHECK-NEXT: Grouped accesses:
190190
; CHECK-NEXT: Group [[GRP7]]:
191-
; CHECK-NEXT: (Low: %B High: (4004 + %B))
191+
; CHECK-NEXT: (Low: %B High: inttoptr (i64 -1 to ptr))
192192
; CHECK-NEXT: Member: {%B,+,4}<nuw><%loop.header>
193193
; CHECK-NEXT: Group [[GRP8]]:
194-
; CHECK-NEXT: (Low: %A High: (4004 + %A))
194+
; CHECK-NEXT: (Low: %A High: inttoptr (i64 -1 to ptr))
195195
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop.header>
196196
; CHECK-EMPTY:
197197
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.
@@ -233,6 +233,7 @@ e.2:
233233
ret i32 2
234234
}
235235

236+
236237
define i32 @not_all_exits_dominate_latch(ptr %A, ptr %B) {
237238
; CHECK-LABEL: 'not_all_exits_dominate_latch'
238239
; CHECK-NEXT: loop.header:
@@ -345,10 +346,10 @@ define i32 @b3_does_not_dominate_latch_not_known_deref(ptr %A, ptr %B) {
345346
; CHECK-NEXT: %gep.A = getelementptr inbounds i32, ptr %A, i64 %iv
346347
; CHECK-NEXT: Grouped accesses:
347348
; CHECK-NEXT: Group [[GRP11]]:
348-
; CHECK-NEXT: (Low: %B High: (4004 + %B))
349+
; CHECK-NEXT: (Low: %B High: inttoptr (i64 -1 to ptr))
349350
; CHECK-NEXT: Member: {%B,+,4}<nuw><%loop.header>
350351
; CHECK-NEXT: Group [[GRP12]]:
351-
; CHECK-NEXT: (Low: %A High: (4004 + %A))
352+
; CHECK-NEXT: (Low: %A High: inttoptr (i64 -1 to ptr))
352353
; CHECK-NEXT: Member: {%A,+,4}<nuw><%loop.header>
353354
; CHECK-EMPTY:
354355
; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop.

‎llvm/test/Analysis/LoopAccessAnalysis/evaluate-at-symbolic-max-backedge-taken-count-may-wrap.ll

Lines changed: 7 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33

44
target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
55

6+
; FIXME: Start == End for access group with AddRec.
67
define void @runtime_checks_with_symbolic_max_btc_neg_1(ptr %P, ptr %S, i32 %x, i32 %y) {
78
; CHECK-LABEL: 'runtime_checks_with_symbolic_max_btc_neg_1'
89
; CHECK-NEXT: loop:
@@ -16,7 +17,7 @@ define void @runtime_checks_with_symbolic_max_btc_neg_1(ptr %P, ptr %S, i32 %x,
1617
; CHECK-NEXT: ptr %S
1718
; CHECK-NEXT: Grouped accesses:
1819
; CHECK-NEXT: Group [[GRP1]]:
19-
; CHECK-NEXT: (Low: ((4 * %y) + %P) High: -1)
20+
; CHECK-NEXT: (Low: ((4 * %y) + %P) High: inttoptr (i32 -1 to ptr))
2021
; CHECK-NEXT: Member: {((4 * %y) + %P),+,4}<%loop>
2122
; CHECK-NEXT: Group [[GRP2]]:
2223
; CHECK-NEXT: (Low: %S High: (4 + %S))
@@ -43,6 +44,7 @@ exit:
4344
ret void
4445
}
4546

47+
; FIXME: Start > End for access group with AddRec.
4648
define void @runtime_check_with_symbolic_max_btc_neg_2(ptr %P, ptr %S, i32 %x, i32 %y) {
4749
; CHECK-LABEL: 'runtime_check_with_symbolic_max_btc_neg_2'
4850
; CHECK-NEXT: loop:
@@ -56,7 +58,7 @@ define void @runtime_check_with_symbolic_max_btc_neg_2(ptr %P, ptr %S, i32 %x, i
5658
; CHECK-NEXT: ptr %S
5759
; CHECK-NEXT: Grouped accesses:
5860
; CHECK-NEXT: Group [[GRP3]]:
59-
; CHECK-NEXT: (Low: ((4 * %y) + %P) High: -1)
61+
; CHECK-NEXT: (Low: ((4 * %y) + %P) High: inttoptr (i32 -1 to ptr))
6062
; CHECK-NEXT: Member: {((4 * %y) + %P),+,4}<%loop>
6163
; CHECK-NEXT: Group [[GRP4]]:
6264
; CHECK-NEXT: (Low: %S High: (4 + %S))
@@ -135,8 +137,8 @@ exit:
135137
ret i32 %res
136138
}
137139

138-
; FIXME: evaluating at symbolic max BTC wraps around to a positive
139-
; offset: (2 + (2 * %y) + %P)
140+
; Evaluating at symbolic max BTC wraps around to a positive
141+
; offset: (2 + (2 * %y) + %P).
140142
define void @runtime_check_with_symbolic_max_wraps_to_positive_offset(ptr %P, ptr %S, i32 %x, i32 %y) {
141143
; CHECK-LABEL: 'runtime_check_with_symbolic_max_wraps_to_positive_offset'
142144
; CHECK-NEXT: loop:
@@ -150,7 +152,7 @@ define void @runtime_check_with_symbolic_max_wraps_to_positive_offset(ptr %P, pt
150152
; CHECK-NEXT: ptr %S
151153
; CHECK-NEXT: Grouped accesses:
152154
; CHECK-NEXT: Group [[GRP5]]:
153-
; CHECK-NEXT: (Low: ((2 * %y) + %P) High: (2 + (2 * %y) + %P))
155+
; CHECK-NEXT: (Low: ((2 * %y) + %P) High: inttoptr (i32 -1 to ptr))
154156
; CHECK-NEXT: Member: {((2 * %y) + %P),+,2}<%loop>
155157
; CHECK-NEXT: Group [[GRP6]]:
156158
; CHECK-NEXT: (Low: %S High: (4 + %S))

‎llvm/test/Transforms/LoopVectorize/single_early_exit_live_outs.ll

Lines changed: 81 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1560,6 +1560,57 @@ define i64 @same_exit_block_pre_inc_use1_reverse() {
15601560
; CHECK-NEXT: [[P2:%.*]] = alloca [1024 x i8], align 1
15611561
; CHECK-NEXT: call void @init_mem(ptr [[P1]], i64 1024)
15621562
; CHECK-NEXT: call void @init_mem(ptr [[P2]], i64 1024)
1563+
; CHECK-NEXT: br i1 false, label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]]
1564+
; CHECK: vector.ph:
1565+
; CHECK-NEXT: br label [[VECTOR_BODY:%.*]]
1566+
; CHECK: vector.body:
1567+
; CHECK-NEXT: [[INDEX1:%.*]] = phi i64 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT4:%.*]], [[VECTOR_BODY]] ]
1568+
; CHECK-NEXT: [[VEC_IND:%.*]] = phi <4 x i64> [ <i64 1023, i64 1022, i64 1021, i64 1020>, [[VECTOR_PH]] ], [ [[VEC_IND_NEXT:%.*]], [[VECTOR_BODY]] ]
1569+
; CHECK-NEXT: [[OFFSET_IDX:%.*]] = sub i64 1023, [[INDEX1]]
1570+
; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[OFFSET_IDX]], 0
1571+
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i8, ptr [[P1]], i64 [[TMP0]]
1572+
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[TMP1]], i32 0
1573+
; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[TMP2]], i32 -3
1574+
; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <4 x i8>, ptr [[TMP3]], align 1
1575+
; CHECK-NEXT: [[REVERSE:%.*]] = shufflevector <4 x i8> [[WIDE_LOAD]], <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
1576+
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds i8, ptr [[P2]], i64 [[TMP0]]
1577+
; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds i8, ptr [[TMP4]], i32 0
1578+
; CHECK-NEXT: [[TMP6:%.*]] = getelementptr inbounds i8, ptr [[TMP5]], i32 -3
1579+
; CHECK-NEXT: [[WIDE_LOAD2:%.*]] = load <4 x i8>, ptr [[TMP6]], align 1
1580+
; CHECK-NEXT: [[REVERSE3:%.*]] = shufflevector <4 x i8> [[WIDE_LOAD2]], <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
1581+
; CHECK-NEXT: [[TMP7:%.*]] = icmp eq <4 x i8> [[REVERSE]], [[REVERSE3]]
1582+
; CHECK-NEXT: [[INDEX_NEXT4]] = add nuw i64 [[INDEX1]], 4
1583+
; CHECK-NEXT: [[TMP8:%.*]] = xor <4 x i1> [[TMP7]], splat (i1 true)
1584+
; CHECK-NEXT: [[TMP9:%.*]] = call i1 @llvm.vector.reduce.or.v4i1(<4 x i1> [[TMP8]])
1585+
; CHECK-NEXT: [[TMP10:%.*]] = icmp eq i64 [[INDEX_NEXT4]], 1020
1586+
; CHECK-NEXT: [[VEC_IND_NEXT]] = add <4 x i64> [[VEC_IND]], splat (i64 -4)
1587+
; CHECK-NEXT: [[TMP11:%.*]] = or i1 [[TMP9]], [[TMP10]]
1588+
; CHECK-NEXT: br i1 [[TMP11]], label [[MIDDLE_SPLIT:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP38:![0-9]+]]
1589+
; CHECK: middle.split:
1590+
; CHECK-NEXT: br i1 [[TMP9]], label [[VECTOR_EARLY_EXIT:%.*]], label [[MIDDLE_BLOCK:%.*]]
1591+
; CHECK: middle.block:
1592+
; CHECK-NEXT: br i1 false, label [[LOOP_END:%.*]], label [[SCALAR_PH]]
1593+
; CHECK: vector.early.exit:
1594+
; CHECK-NEXT: [[FIRST_ACTIVE_LANE:%.*]] = call i64 @llvm.experimental.cttz.elts.i64.v4i1(<4 x i1> [[TMP8]], i1 true)
1595+
; CHECK-NEXT: [[EARLY_EXIT_VALUE:%.*]] = extractelement <4 x i64> [[VEC_IND]], i64 [[FIRST_ACTIVE_LANE]]
1596+
; CHECK-NEXT: br label [[LOOP_END]]
1597+
; CHECK: scalar.ph:
1598+
; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ 3, [[MIDDLE_BLOCK]] ], [ 1023, [[ENTRY:%.*]] ]
1599+
; CHECK-NEXT: br label [[LOOP:%.*]]
1600+
; CHECK: loop:
1601+
; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ [[INDEX_NEXT:%.*]], [[LOOP_INC:%.*]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ]
1602+
; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i8, ptr [[P1]], i64 [[INDEX]]
1603+
; CHECK-NEXT: [[LD1:%.*]] = load i8, ptr [[ARRAYIDX]], align 1
1604+
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i8, ptr [[P2]], i64 [[INDEX]]
1605+
; CHECK-NEXT: [[LD2:%.*]] = load i8, ptr [[ARRAYIDX1]], align 1
1606+
; CHECK-NEXT: [[CMP3:%.*]] = icmp eq i8 [[LD1]], [[LD2]]
1607+
; CHECK-NEXT: br i1 [[CMP3]], label [[LOOP_INC]], label [[LOOP_END]]
1608+
; CHECK: loop.inc:
1609+
; CHECK-NEXT: [[INDEX_NEXT]] = add i64 [[INDEX]], -1
1610+
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp eq i64 [[INDEX_NEXT]], 0
1611+
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP_END]], label [[LOOP]], !llvm.loop [[LOOP39:![0-9]+]]
1612+
; CHECK: loop.end:
1613+
; CHECK-NEXT: [[RETVAL:%.*]] = phi i64 [ [[INDEX]], [[LOOP]] ], [ 1024, [[LOOP_INC]] ], [ 1024, [[MIDDLE_BLOCK]] ], [ [[EARLY_EXIT_VALUE]], [[VECTOR_EARLY_EXIT]] ]
15631614
; CHECK-NEXT: ret i64 [[RETVAL]]
15641615
;
15651616
entry:
@@ -1664,6 +1715,32 @@ define i64 @same_exit_block_pre_inc_use1_deref_ptrs(ptr dereferenceable(1024) %p
16641715
; CHECK-NEXT: [[TMP8:%.*]] = icmp eq i64 [[INDEX_NEXT3]], 64
16651716
; CHECK-NEXT: [[VEC_IND_NEXT]] = add <4 x i64> [[VEC_IND]], splat (i64 4)
16661717
; CHECK-NEXT: [[TMP9:%.*]] = or i1 [[TMP7]], [[TMP8]]
1718+
; CHECK-NEXT: br i1 [[TMP9]], label [[MIDDLE_SPLIT:%.*]], label [[VECTOR_BODY]], !llvm.loop [[LOOP40:![0-9]+]]
1719+
; CHECK: middle.split:
1720+
; CHECK-NEXT: br i1 [[TMP7]], label [[VECTOR_EARLY_EXIT:%.*]], label [[MIDDLE_BLOCK:%.*]]
1721+
; CHECK: middle.block:
1722+
; CHECK-NEXT: br i1 true, label [[LOOP_END:%.*]], label [[SCALAR_PH]]
1723+
; CHECK: vector.early.exit:
1724+
; CHECK-NEXT: [[FIRST_ACTIVE_LANE:%.*]] = call i64 @llvm.experimental.cttz.elts.i64.v4i1(<4 x i1> [[TMP6]], i1 true)
1725+
; CHECK-NEXT: [[EARLY_EXIT_VALUE:%.*]] = extractelement <4 x i64> [[VEC_IND]], i64 [[FIRST_ACTIVE_LANE]]
1726+
; CHECK-NEXT: br label [[LOOP_END]]
1727+
; CHECK: scalar.ph:
1728+
; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ 67, [[MIDDLE_BLOCK]] ], [ 3, [[ENTRY:%.*]] ]
1729+
; CHECK-NEXT: br label [[LOOP:%.*]]
1730+
; CHECK: loop:
1731+
; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ [[INDEX_NEXT:%.*]], [[LOOP_INC:%.*]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ]
1732+
; CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i8, ptr [[P1]], i64 [[INDEX]]
1733+
; CHECK-NEXT: [[LD1:%.*]] = load i8, ptr [[ARRAYIDX]], align 1
1734+
; CHECK-NEXT: [[ARRAYIDX1:%.*]] = getelementptr inbounds i8, ptr [[P2]], i64 [[INDEX]]
1735+
; CHECK-NEXT: [[LD2:%.*]] = load i8, ptr [[ARRAYIDX1]], align 1
1736+
; CHECK-NEXT: [[CMP3:%.*]] = icmp eq i8 [[LD1]], [[LD2]]
1737+
; CHECK-NEXT: br i1 [[CMP3]], label [[LOOP_INC]], label [[LOOP_END]]
1738+
; CHECK: loop.inc:
1739+
; CHECK-NEXT: [[INDEX_NEXT]] = add i64 [[INDEX]], 1
1740+
; CHECK-NEXT: [[EXITCOND:%.*]] = icmp ne i64 [[INDEX_NEXT]], 67
1741+
; CHECK-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[LOOP_END]], !llvm.loop [[LOOP41:![0-9]+]]
1742+
; CHECK: loop.end:
1743+
; CHECK-NEXT: [[RETVAL:%.*]] = phi i64 [ [[INDEX]], [[LOOP]] ], [ 67, [[LOOP_INC]] ], [ 67, [[MIDDLE_BLOCK]] ], [ [[EARLY_EXIT_VALUE]], [[VECTOR_EARLY_EXIT]] ]
16671744
; CHECK-NEXT: ret i64 [[RETVAL]]
16681745
;
16691746
entry:
@@ -1731,4 +1808,8 @@ attributes #0 = { "vector-function-abi-variant"="_ZGVsNxv_foo(foo_vec)" }
17311808
; CHECK: [[LOOP35]] = distinct !{[[LOOP35]], [[META2]], [[META1]]}
17321809
; CHECK: [[LOOP36]] = distinct !{[[LOOP36]], [[META1]], [[META2]]}
17331810
; CHECK: [[LOOP37]] = distinct !{[[LOOP37]], [[META2]], [[META1]]}
1811+
; CHECK: [[LOOP38]] = distinct !{[[LOOP38]], [[META1]], [[META2]]}
1812+
; CHECK: [[LOOP39]] = distinct !{[[LOOP39]], [[META2]], [[META1]]}
1813+
; CHECK: [[LOOP40]] = distinct !{[[LOOP40]], [[META1]], [[META2]]}
1814+
; CHECK: [[LOOP41]] = distinct !{[[LOOP41]], [[META2]], [[META1]]}
17341815
;.

0 commit comments

Comments
 (0)