https://github.com/fhahn created https://github.com/llvm/llvm-project/pull/91962
Use SCEVUse to add a NUW flag to the upper bound of an accessed pointer. We must already have proved that the pointers do not wrap, as otherwise we could not use them for runtime check computations. By adding the use-specific NUW flag, we can detect cases where SCEV can prove that the compared pointers must overlap, so the runtime checks will always be false. In that case, there is no point in vectorizing with runtime checks. Note that this depends c2895cd27fbf200d1da056bc66d77eeb62690bf0, which could be submitted separately if desired; without the current change, I don't think it triggers in practice though. Depends on https://github.com/llvm/llvm-project/pull/91961 >From 448c6db95cf89b8f6d007f7049afd02ca21d4427 Mon Sep 17 00:00:00 2001 From: Florian Hahn <f...@fhahn.com> Date: Wed, 1 May 2024 11:03:42 +0100 Subject: [PATCH 1/3] [SCEV,LAA] Add tests to make sure scoped SCEVs don't impact other SCEVs. --- .../LoopAccessAnalysis/scoped-scevs.ll | 182 ++++++++++++++++++ 1 file changed, 182 insertions(+) create mode 100644 llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll diff --git a/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll b/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll new file mode 100644 index 0000000000000..323ba2a739cf8 --- /dev/null +++ b/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll @@ -0,0 +1,182 @@ +; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 4 +; RUN: opt -passes='print<access-info>,print<scalar-evolution>' -disable-output %s 2>&1 | FileCheck --check-prefixes=LAA,AFTER %s +; RUN: opt -passes='print<scalar-evolution>,print<access-info>,print<scalar-evolution>' -disable-output %s 2>&1 | FileCheck --check-prefixes=BEFORE,LAA,AFTER %s + +target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128" + +declare void @use(ptr) + +; Check that scoped expressions created by LAA do not interfere with non-scoped +; SCEVs with the same operands. The tests first run print<scalar-evolution> to +; populate the SCEV cache. They contain a GEP computing A+405, which is the end +; of the accessed range, before and/or after the loop. No nuw flags should be +; added to them in the second print<scalar-evolution> output. + +define ptr @test_ptr_range_end_computed_before_and_after_loop(ptr %A) { +; BEFORE-LABEL: 'test_ptr_range_end_computed_before_and_after_loop' +; BEFORE-NEXT: Classifying expressions for: @test_ptr_range_end_computed_before_and_after_loop +; BEFORE: %x = getelementptr inbounds i8, ptr %A, i64 405 +; BEFORE-NEXT: --> (405 + %A) U: full-set S: full-set +; BEFORE: %y = getelementptr inbounds i8, ptr %A, i64 405 +; BEFORE-NEXT: --> (405 + %A) U: full-set S: full-set +; +; LAA-LABEL: 'test_ptr_range_end_computed_before_and_after_loop' +; LAA-NEXT: loop: +; LAA-NEXT: Memory dependences are safe with run-time checks +; LAA-NEXT: Dependences: +; LAA-NEXT: Run-time memory checks: +; LAA-NEXT: Check 0: +; LAA-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]): +; LAA-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv +; LAA-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]): +; LAA-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv +; LAA-NEXT: Grouped accesses: +; LAA-NEXT: Group [[GRP1]]: +; LAA-NEXT: (Low: (1 + %A) High: (405 + %A)) +; LAA-NEXT: Member: {(1 + %A),+,4}<nw><%loop> +; LAA-NEXT: Group [[GRP2]]: +; LAA-NEXT: (Low: %A High: (101 + %A)) +; LAA-NEXT: Member: {%A,+,1}<nuw><%loop> +; LAA-EMPTY: +; LAA-NEXT: Non vectorizable stores to invariant address were not found in loop. +; LAA-NEXT: SCEV assumptions: +; LAA-EMPTY: +; LAA-NEXT: Expressions re-written: +; +; AFTER-LABEL: 'test_ptr_range_end_computed_before_and_after_loop' +; AFTER-NEXT: Classifying expressions for: @test_ptr_range_end_computed_before_and_after_loop +; AFTER: %x = getelementptr inbounds i8, ptr %A, i64 405 +; AFTER-NEXT: --> (405 + %A) U: full-set S: full-set +; AFTER: %y = getelementptr inbounds i8, ptr %A, i64 405 +; AFTER-NEXT: --> (405 + %A) U: full-set S: full-set +entry: + %A.1 = getelementptr inbounds i8, ptr %A, i64 1 + %x = getelementptr inbounds i8, ptr %A, i64 405 + call void @use(ptr %x) + br label %loop + +loop: + %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] + %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv + %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv + %l = load i8, ptr %gep.A, align 1 + %ext = zext i8 %l to i32 + store i32 %ext, ptr %gep.A.400, align 4 + %iv.next = add nuw nsw i64 %iv, 1 + %ec = icmp eq i64 %iv, 100 + br i1 %ec, label %exit, label %loop + +exit: + %y = getelementptr inbounds i8, ptr %A, i64 405 + ret ptr %y +} + +define void @test_ptr_range_end_computed_before_loop(ptr %A) { +; BEFORE-LABEL: 'test_ptr_range_end_computed_before_loop' +; BEFORE-NEXT: Classifying expressions for: @test_ptr_range_end_computed_before_loop +; BEFORE-NEXT: %A.1 = getelementptr inbounds i8, ptr %A, i64 1 +; BEFORE-NEXT: --> (1 + %A) U: full-set S: full-set +; BEFORE-NEXT: %x = getelementptr inbounds i8, ptr %A, i64 405 +; +; LAA-LABEL: 'test_ptr_range_end_computed_before_loop' +; LAA-NEXT: loop: +; LAA-NEXT: Memory dependences are safe with run-time checks +; LAA-NEXT: Dependences: +; LAA-NEXT: Run-time memory checks: +; LAA-NEXT: Check 0: +; LAA-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]): +; LAA-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv +; LAA-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]): +; LAA-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv +; LAA-NEXT: Grouped accesses: +; LAA-NEXT: Group [[GRP3]]: +; LAA-NEXT: (Low: (1 + %A) High: (405 + %A)) +; LAA-NEXT: Member: {(1 + %A),+,4}<nw><%loop> +; LAA-NEXT: Group [[GRP4]]: +; LAA-NEXT: (Low: %A High: (101 + %A)) +; LAA-NEXT: Member: {%A,+,1}<nuw><%loop> +; LAA-EMPTY: +; LAA-NEXT: Non vectorizable stores to invariant address were not found in loop. +; LAA-NEXT: SCEV assumptions: +; LAA-EMPTY: +; LAA-NEXT: Expressions re-written: +; +; AFTER-LABEL: Classifying expressions for: @test_ptr_range_end_computed_before_loop +; AFTER-NEXT: %A.1 = getelementptr inbounds i8, ptr %A, i64 1 +; AFTER-NEXT: --> (1 + %A) U: full-set S: full-set +; AFTER-NEXT: %x = getelementptr inbounds i8, ptr %A, i64 405 +; +entry: + %A.1 = getelementptr inbounds i8, ptr %A, i64 1 + %x = getelementptr inbounds i8, ptr %A, i64 405 + call void @use(ptr %x) + br label %loop + +loop: + %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] + %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv + %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv + %l = load i8, ptr %gep.A, align 1 + %ext = zext i8 %l to i32 + store i32 %ext, ptr %gep.A.400, align 4 + %iv.next = add nuw nsw i64 %iv, 1 + %ec = icmp eq i64 %iv, 100 + br i1 %ec, label %exit, label %loop + +exit: + ret void +} + +define ptr @test_ptr_range_end_computed_after_loop(ptr %A) { +; BEFORE-LABEL: 'test_ptr_range_end_computed_after_loop' +; BEFORE-NEXT: Classifying expressions for: @test_ptr_range_end_computed_after_loop +; BEFORE: %y = getelementptr inbounds i8, ptr %A, i64 405 +; BEFORE-NEXT: --> (405 + %A) U: full-set S: full-set +; +; LAA-LABEL: 'test_ptr_range_end_computed_after_loop' +; LAA-NEXT: loop: +; LAA-NEXT: Memory dependences are safe with run-time checks +; LAA-NEXT: Dependences: +; LAA-NEXT: Run-time memory checks: +; LAA-NEXT: Check 0: +; LAA-NEXT: Comparing group ([[GRP5:0x[0-9a-f]+]]): +; LAA-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv +; LAA-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]): +; LAA-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv +; LAA-NEXT: Grouped accesses: +; LAA-NEXT: Group [[GRP5]]: +; LAA-NEXT: (Low: (1 + %A)<nuw> High: (405 + %A)) +; LAA-NEXT: Member: {(1 + %A)<nuw>,+,4}<nuw><%loop> +; LAA-NEXT: Group [[GRP6]]: +; LAA-NEXT: (Low: %A High: (101 + %A)) +; LAA-NEXT: Member: {%A,+,1}<nuw><%loop> +; LAA-EMPTY: +; LAA-NEXT: Non vectorizable stores to invariant address were not found in loop. +; LAA-NEXT: SCEV assumptions: +; LAA-EMPTY: +; LAA-NEXT: Expressions re-written: +; +; AFTER-LABEL: 'test_ptr_range_end_computed_after_loop' +; AFTER-NEXT: Classifying expressions for: @test_ptr_range_end_computed_after_loop +; AFTER: %y = getelementptr inbounds i8, ptr %A, i64 405 +; AFTER-NEXT: --> (405 + %A) U: full-set S: full-set +; +entry: + %A.1 = getelementptr inbounds i8, ptr %A, i64 1 + br label %loop + +loop: + %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] + %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv + %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv + %l = load i8, ptr %gep.A, align 1 + %ext = zext i8 %l to i32 + store i32 %ext, ptr %gep.A.400, align 4 + %iv.next = add nuw nsw i64 %iv, 1 + %ec = icmp eq i64 %iv, 100 + br i1 %ec, label %exit, label %loop + +exit: + %y = getelementptr inbounds i8, ptr %A, i64 405 + ret ptr %y +} >From 29065eb594674ee415b361c6b755547b7c62915c Mon Sep 17 00:00:00 2001 From: Florian Hahn <f...@fhahn.com> Date: Mon, 13 May 2024 13:05:39 +0100 Subject: [PATCH 2/3] [SCEV] Don't require NUW at first add when checking A+C1 < (A+C2)<nuw> Relax the NUW requirements for isKnownPredicateViaNoOverflow, if the second operand (Y) is a BinOp. The code only simplifies the condition if C1 < C2, so if the BinOp is NUW, it doesn't matter whether the first operand also has the NUW flag, as it cannot wrap if C1 < C2. --- llvm/lib/Analysis/ScalarEvolution.cpp | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp index 320be6f26fc0a..047789e175068 100644 --- a/llvm/lib/Analysis/ScalarEvolution.cpp +++ b/llvm/lib/Analysis/ScalarEvolution.cpp @@ -11228,8 +11228,7 @@ bool ScalarEvolution::isKnownPredicateViaNoOverflow(ICmpInst::Predicate Pred, XNonConstOp = X; XFlagsPresent = ExpectedFlags; } - if (!isa<SCEVConstant>(XConstOp) || - (XFlagsPresent & ExpectedFlags) != ExpectedFlags) + if (!isa<SCEVConstant>(XConstOp)) return false; if (!splitBinaryAdd(Y, YConstOp, YNonConstOp, YFlagsPresent)) { @@ -11238,13 +11237,22 @@ bool ScalarEvolution::isKnownPredicateViaNoOverflow(ICmpInst::Predicate Pred, YFlagsPresent = ExpectedFlags; } - if (!isa<SCEVConstant>(YConstOp) || - (YFlagsPresent & ExpectedFlags) != ExpectedFlags) + if (YNonConstOp != XNonConstOp) return false; - if (YNonConstOp != XNonConstOp) + if (!isa<SCEVConstant>(YConstOp)) return false; + if (YNonConstOp != Y && ExpectedFlags == SCEV::FlagNUW) { + if ((YFlagsPresent & ExpectedFlags) != ExpectedFlags) + return false; + } else { + if ((XFlagsPresent & ExpectedFlags) != ExpectedFlags) + return false; + if ((YFlagsPresent & ExpectedFlags) != ExpectedFlags) + return false; + } + OutC1 = cast<SCEVConstant>(XConstOp)->getAPInt(); OutC2 = cast<SCEVConstant>(YConstOp)->getAPInt(); >From 8fef35a4e70b35231f4401db5408990db310bf02 Mon Sep 17 00:00:00 2001 From: Florian Hahn <f...@fhahn.com> Date: Sun, 12 May 2024 10:32:11 +0100 Subject: [PATCH 3/3] [LAA] Use SCEVUse to add extra NUW flags to pointer bounds. Use SCEVUse to add a NUW flag to the upper bound of an accessed pointer. We must already have proved that the pointers do not wrap, as otherwise we could not use them for runtime check computations. By adding the use-specific NUW flag, we can detect cases where SCEV can prove that the compared pointers must overlap, so the runtime checks will always be false. In that case, there is no point in vectorizing with runtime checks. Note that this depends c2895cd27fbf200d1da056bc66d77eeb62690bf0, which could be submitted separately if desired; without the current change, I don't think it triggers in practice though. --- .../llvm/Analysis/LoopAccessAnalysis.h | 14 +- llvm/lib/Analysis/LoopAccessAnalysis.cpp | 20 ++- llvm/lib/Analysis/ScalarEvolution.cpp | 2 + .../LoopAccessAnalysis/forked-pointers.ll | 134 +++++++++--------- .../LoopAccessAnalysis/scoped-scevs.ll | 39 +---- 5 files changed, 96 insertions(+), 113 deletions(-) diff --git a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h index 6ebd0fb8477a0..0663ef6a2865d 100644 --- a/llvm/include/llvm/Analysis/LoopAccessAnalysis.h +++ b/llvm/include/llvm/Analysis/LoopAccessAnalysis.h @@ -372,10 +372,10 @@ struct RuntimeCheckingPtrGroup { /// The SCEV expression which represents the upper bound of all the /// pointers in this group. - const SCEV *High; + SCEVUse High; /// The SCEV expression which represents the lower bound of all the /// pointers in this group. - const SCEV *Low; + SCEVUse Low; /// Indices of all the pointers that constitute this grouping. SmallVector<unsigned, 2> Members; /// Address space of the involved pointers. @@ -413,10 +413,10 @@ class RuntimePointerChecking { TrackingVH<Value> PointerValue; /// Holds the smallest byte address accessed by the pointer throughout all /// iterations of the loop. - const SCEV *Start; + SCEVUse Start; /// Holds the largest byte address accessed by the pointer throughout all /// iterations of the loop, plus 1. - const SCEV *End; + SCEVUse End; /// Holds the information if this pointer is used for writing to memory. bool IsWritePtr; /// Holds the id of the set of pointers that could be dependent because of a @@ -429,7 +429,7 @@ class RuntimePointerChecking { /// True if the pointer expressions needs to be frozen after expansion. bool NeedsFreeze; - PointerInfo(Value *PointerValue, const SCEV *Start, const SCEV *End, + PointerInfo(Value *PointerValue, SCEVUse Start, SCEVUse End, bool IsWritePtr, unsigned DependencySetId, unsigned AliasSetId, const SCEV *Expr, bool NeedsFreeze) : PointerValue(PointerValue), Start(Start), End(End), @@ -443,8 +443,10 @@ class RuntimePointerChecking { /// Reset the state of the pointer runtime information. void reset() { Need = false; + AlwaysFalse = false; Pointers.clear(); Checks.clear(); + CheckingGroups.clear(); } /// Insert a pointer and calculate the start and end SCEVs. @@ -501,6 +503,8 @@ class RuntimePointerChecking { /// This flag indicates if we need to add the runtime check. bool Need = false; + bool AlwaysFalse = false; + /// Information about the pointers that may require checking. SmallVector<PointerInfo, 2> Pointers; diff --git a/llvm/lib/Analysis/LoopAccessAnalysis.cpp b/llvm/lib/Analysis/LoopAccessAnalysis.cpp index e1d0f900c9050..208c034763f7c 100644 --- a/llvm/lib/Analysis/LoopAccessAnalysis.cpp +++ b/llvm/lib/Analysis/LoopAccessAnalysis.cpp @@ -210,8 +210,8 @@ void RuntimePointerChecking::insert(Loop *Lp, Value *Ptr, const SCEV *PtrExpr, bool NeedsFreeze) { ScalarEvolution *SE = PSE.getSE(); - const SCEV *ScStart; - const SCEV *ScEnd; + SCEVUse ScStart; + SCEVUse ScEnd; if (SE->isLoopInvariant(PtrExpr, Lp)) { ScStart = ScEnd = PtrExpr; @@ -223,6 +223,8 @@ void RuntimePointerChecking::insert(Loop *Lp, Value *Ptr, const SCEV *PtrExpr, ScStart = AR->getStart(); ScEnd = AR->evaluateAtIteration(Ex, *SE); const SCEV *Step = AR->getStepRecurrence(*SE); + if (auto *Comm = dyn_cast<SCEVCommutativeExpr>(ScEnd)) + ScEnd = SCEVUse(ScEnd, 2); // For expressions with negative step, the upper bound is ScStart and the // lower bound is ScEnd. @@ -244,7 +246,10 @@ void RuntimePointerChecking::insert(Loop *Lp, Value *Ptr, const SCEV *PtrExpr, auto &DL = Lp->getHeader()->getModule()->getDataLayout(); Type *IdxTy = DL.getIndexType(Ptr->getType()); const SCEV *EltSizeSCEV = SE->getStoreSizeOfExpr(IdxTy, AccessTy); - ScEnd = SE->getAddExpr(ScEnd, EltSizeSCEV); + // TODO: this computes one-past-the-end. ScEnd + EltSizeSCEV - 1 is the last + // accessed byte. Not entirely sure if one-past-the-end must also not wrap? If + // it does, could compute and use last accessed byte instead. + ScEnd = SCEVUse(SE->getAddExpr(ScEnd, EltSizeSCEV), 2); Pointers.emplace_back(Ptr, ScStart, ScEnd, WritePtr, DepSetId, ASId, PtrExpr, NeedsFreeze); @@ -379,6 +384,11 @@ SmallVector<RuntimePointerCheck, 4> RuntimePointerChecking::generateChecks() { if (needsChecking(CGI, CGJ)) { tryToCreateDiffCheck(CGI, CGJ); Checks.push_back(std::make_pair(&CGI, &CGJ)); + if (SE->isKnownPredicate(CmpInst::ICMP_UGT, CGI.High, CGJ.Low) && + SE->isKnownPredicate(CmpInst::ICMP_ULE, CGI.Low, CGJ.High)) { + AlwaysFalse = true; + return {}; + } } } } @@ -635,8 +645,7 @@ void RuntimePointerChecking::print(raw_ostream &OS, unsigned Depth) const { const auto &CG = CheckingGroups[I]; OS.indent(Depth + 2) << "Group " << &CG << ":\n"; - OS.indent(Depth + 4) << "(Low: " << *CG.Low << " High: " << *CG.High - << ")\n"; + OS.indent(Depth + 4) << "(Low: " << CG.Low << " High: " << CG.High << ")\n"; for (unsigned J = 0; J < CG.Members.size(); ++J) { OS.indent(Depth + 6) << "Member: " << *Pointers[CG.Members[J]].Expr << "\n"; @@ -1274,6 +1283,7 @@ bool AccessAnalysis::canCheckPtrAtRT(RuntimePointerChecking &RtCheck, // If we can do run-time checks, but there are no checks, no runtime checks // are needed. This can happen when all pointers point to the same underlying // object for example. + CanDoRT &= !RtCheck.AlwaysFalse; RtCheck.Need = CanDoRT ? RtCheck.getNumberOfChecks() != 0 : MayNeedRTCheck; bool CanDoRTIfNeeded = !RtCheck.Need || CanDoRT; diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp index 047789e175068..04d7450e6cc2e 100644 --- a/llvm/lib/Analysis/ScalarEvolution.cpp +++ b/llvm/lib/Analysis/ScalarEvolution.cpp @@ -11886,6 +11886,8 @@ bool ScalarEvolution::splitBinaryAdd(SCEVUse Expr, SCEVUse &L, SCEVUse &R, L = AE->getOperand(0); R = AE->getOperand(1); Flags = AE->getNoWrapFlags(); + Flags = setFlags(AE->getNoWrapFlags(), + static_cast<SCEV::NoWrapFlags>(Expr.getInt())); return true; } diff --git a/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll b/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll index cd388b4ee87f2..2f9f6dc39b19d 100644 --- a/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll +++ b/llvm/test/Analysis/LoopAccessAnalysis/forked-pointers.ll @@ -24,14 +24,14 @@ define void @forked_ptrs_simple(ptr nocapture readonly %Base1, ptr nocapture rea ; CHECK-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2 ; CHECK-NEXT: Grouped accesses: ; CHECK-NEXT: Group [[GRP1]]: -; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)) +; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw)) ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop> ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%loop> ; CHECK-NEXT: Group [[GRP2]]: -; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1)) +; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1)(u nuw)) ; CHECK-NEXT: Member: {%Base1,+,4}<nw><%loop> ; CHECK-NEXT: Group [[GRP3]]: -; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2)) +; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2)(u nuw)) ; CHECK-NEXT: Member: {%Base2,+,4}<nw><%loop> ; CHECK-EMPTY: ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -58,14 +58,14 @@ define void @forked_ptrs_simple(ptr nocapture readonly %Base1, ptr nocapture rea ; RECURSE-NEXT: %select = select i1 %cmp, ptr %gep.1, ptr %gep.2 ; RECURSE-NEXT: Grouped accesses: ; RECURSE-NEXT: Group [[GRP4]]: -; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest)) +; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw)) ; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%loop> ; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%loop> ; RECURSE-NEXT: Group [[GRP5]]: -; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1)) +; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1)(u nuw)) ; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%loop> ; RECURSE-NEXT: Group [[GRP6]]: -; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2)) +; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2)(u nuw)) ; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%loop> ; RECURSE-EMPTY: ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -132,16 +132,16 @@ define dso_local void @forked_ptrs_different_base_same_offset(ptr nocapture read ; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv ; CHECK-NEXT: Grouped accesses: ; CHECK-NEXT: Group [[GRP7]]: -; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)) +; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw)) ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP8]]: -; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) +; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP9]]: -; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2)) +; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2)(u nuw)) ; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body> ; CHECK-NEXT: Group [[GRP10]]: -; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1)) +; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1)(u nuw)) ; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body> ; CHECK-EMPTY: ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -171,16 +171,16 @@ define dso_local void @forked_ptrs_different_base_same_offset(ptr nocapture read ; RECURSE-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv ; RECURSE-NEXT: Grouped accesses: ; RECURSE-NEXT: Group [[GRP11]]: -; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest)) +; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw)) ; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%for.body> ; RECURSE-NEXT: Group [[GRP12]]: -; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)) +; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; RECURSE-NEXT: Group [[GRP13]]: -; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2)) +; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2)(u nuw)) ; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%for.body> ; RECURSE-NEXT: Group [[GRP14]]: -; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1)) +; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1)(u nuw)) ; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%for.body> ; RECURSE-EMPTY: ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -232,16 +232,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_64b(ptr nocapture ; CHECK-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv ; CHECK-NEXT: Grouped accesses: ; CHECK-NEXT: Group [[GRP15]]: -; CHECK-NEXT: (Low: %Dest High: (800 + %Dest)) +; CHECK-NEXT: (Low: %Dest High: (800 + %Dest)(u nuw)) ; CHECK-NEXT: Member: {%Dest,+,8}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP16]]: -; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) +; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP17]]: -; CHECK-NEXT: (Low: %Base2 High: (800 + %Base2)) +; CHECK-NEXT: (Low: %Base2 High: (800 + %Base2)(u nuw)) ; CHECK-NEXT: Member: {%Base2,+,8}<nw><%for.body> ; CHECK-NEXT: Group [[GRP18]]: -; CHECK-NEXT: (Low: %Base1 High: (800 + %Base1)) +; CHECK-NEXT: (Low: %Base1 High: (800 + %Base1)(u nuw)) ; CHECK-NEXT: Member: {%Base1,+,8}<nw><%for.body> ; CHECK-EMPTY: ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -271,16 +271,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_64b(ptr nocapture ; RECURSE-NEXT: %.sink.in = getelementptr inbounds double, ptr %spec.select, i64 %indvars.iv ; RECURSE-NEXT: Grouped accesses: ; RECURSE-NEXT: Group [[GRP19]]: -; RECURSE-NEXT: (Low: %Dest High: (800 + %Dest)) +; RECURSE-NEXT: (Low: %Dest High: (800 + %Dest)(u nuw)) ; RECURSE-NEXT: Member: {%Dest,+,8}<nuw><%for.body> ; RECURSE-NEXT: Group [[GRP20]]: -; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)) +; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; RECURSE-NEXT: Group [[GRP21]]: -; RECURSE-NEXT: (Low: %Base2 High: (800 + %Base2)) +; RECURSE-NEXT: (Low: %Base2 High: (800 + %Base2)(u nuw)) ; RECURSE-NEXT: Member: {%Base2,+,8}<nw><%for.body> ; RECURSE-NEXT: Group [[GRP22]]: -; RECURSE-NEXT: (Low: %Base1 High: (800 + %Base1)) +; RECURSE-NEXT: (Low: %Base1 High: (800 + %Base1)(u nuw)) ; RECURSE-NEXT: Member: {%Base1,+,8}<nw><%for.body> ; RECURSE-EMPTY: ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -332,16 +332,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_23b(ptr nocapture ; CHECK-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv ; CHECK-NEXT: Grouped accesses: ; CHECK-NEXT: Group [[GRP23]]: -; CHECK-NEXT: (Low: %Dest High: (399 + %Dest)) +; CHECK-NEXT: (Low: %Dest High: (399 + %Dest)(u nuw)) ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP24]]: -; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) +; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP25]]: -; CHECK-NEXT: (Low: %Base2 High: (399 + %Base2)) +; CHECK-NEXT: (Low: %Base2 High: (399 + %Base2)(u nuw)) ; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body> ; CHECK-NEXT: Group [[GRP26]]: -; CHECK-NEXT: (Low: %Base1 High: (399 + %Base1)) +; CHECK-NEXT: (Low: %Base1 High: (399 + %Base1)(u nuw)) ; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body> ; CHECK-EMPTY: ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -371,16 +371,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_23b(ptr nocapture ; RECURSE-NEXT: %.sink.in = getelementptr inbounds i23, ptr %spec.select, i64 %indvars.iv ; RECURSE-NEXT: Grouped accesses: ; RECURSE-NEXT: Group [[GRP27]]: -; RECURSE-NEXT: (Low: %Dest High: (399 + %Dest)) +; RECURSE-NEXT: (Low: %Dest High: (399 + %Dest)(u nuw)) ; RECURSE-NEXT: Member: {%Dest,+,4}<nuw><%for.body> ; RECURSE-NEXT: Group [[GRP28]]: -; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)) +; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; RECURSE-NEXT: Group [[GRP29]]: -; RECURSE-NEXT: (Low: %Base2 High: (399 + %Base2)) +; RECURSE-NEXT: (Low: %Base2 High: (399 + %Base2)(u nuw)) ; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%for.body> ; RECURSE-NEXT: Group [[GRP30]]: -; RECURSE-NEXT: (Low: %Base1 High: (399 + %Base1)) +; RECURSE-NEXT: (Low: %Base1 High: (399 + %Base1)(u nuw)) ; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%for.body> ; RECURSE-EMPTY: ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -432,16 +432,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_6b(ptr nocapture r ; CHECK-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv ; CHECK-NEXT: Grouped accesses: ; CHECK-NEXT: Group [[GRP31]]: -; CHECK-NEXT: (Low: %Dest High: (100 + %Dest)) +; CHECK-NEXT: (Low: %Dest High: (100 + %Dest)(u nuw)) ; CHECK-NEXT: Member: {%Dest,+,1}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP32]]: -; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) +; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP33]]: -; CHECK-NEXT: (Low: %Base2 High: (100 + %Base2)) +; CHECK-NEXT: (Low: %Base2 High: (100 + %Base2)(u nuw)) ; CHECK-NEXT: Member: {%Base2,+,1}<nw><%for.body> ; CHECK-NEXT: Group [[GRP34]]: -; CHECK-NEXT: (Low: %Base1 High: (100 + %Base1)) +; CHECK-NEXT: (Low: %Base1 High: (100 + %Base1)(u nuw)) ; CHECK-NEXT: Member: {%Base1,+,1}<nw><%for.body> ; CHECK-EMPTY: ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -471,16 +471,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_6b(ptr nocapture r ; RECURSE-NEXT: %.sink.in = getelementptr inbounds i6, ptr %spec.select, i64 %indvars.iv ; RECURSE-NEXT: Grouped accesses: ; RECURSE-NEXT: Group [[GRP35]]: -; RECURSE-NEXT: (Low: %Dest High: (100 + %Dest)) +; RECURSE-NEXT: (Low: %Dest High: (100 + %Dest)(u nuw)) ; RECURSE-NEXT: Member: {%Dest,+,1}<nuw><%for.body> ; RECURSE-NEXT: Group [[GRP36]]: -; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)) +; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; RECURSE-NEXT: Group [[GRP37]]: -; RECURSE-NEXT: (Low: %Base2 High: (100 + %Base2)) +; RECURSE-NEXT: (Low: %Base2 High: (100 + %Base2)(u nuw)) ; RECURSE-NEXT: Member: {%Base2,+,1}<nw><%for.body> ; RECURSE-NEXT: Group [[GRP38]]: -; RECURSE-NEXT: (Low: %Base1 High: (100 + %Base1)) +; RECURSE-NEXT: (Low: %Base1 High: (100 + %Base1)(u nuw)) ; RECURSE-NEXT: Member: {%Base1,+,1}<nw><%for.body> ; RECURSE-EMPTY: ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -532,16 +532,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_possible_poison(pt ; CHECK-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv ; CHECK-NEXT: Grouped accesses: ; CHECK-NEXT: Group [[GRP39]]: -; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)) +; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw)) ; CHECK-NEXT: Member: {%Dest,+,4}<nw><%for.body> ; CHECK-NEXT: Group [[GRP40]]: -; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) +; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP41]]: -; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2)) +; CHECK-NEXT: (Low: %Base2 High: (400 + %Base2)(u nuw)) ; CHECK-NEXT: Member: {%Base2,+,4}<nw><%for.body> ; CHECK-NEXT: Group [[GRP42]]: -; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1)) +; CHECK-NEXT: (Low: %Base1 High: (400 + %Base1)(u nuw)) ; CHECK-NEXT: Member: {%Base1,+,4}<nw><%for.body> ; CHECK-EMPTY: ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -571,16 +571,16 @@ define dso_local void @forked_ptrs_different_base_same_offset_possible_poison(pt ; RECURSE-NEXT: %.sink.in = getelementptr inbounds float, ptr %spec.select, i64 %indvars.iv ; RECURSE-NEXT: Grouped accesses: ; RECURSE-NEXT: Group [[GRP43]]: -; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest)) +; RECURSE-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw)) ; RECURSE-NEXT: Member: {%Dest,+,4}<nw><%for.body> ; RECURSE-NEXT: Group [[GRP44]]: -; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)) +; RECURSE-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; RECURSE-NEXT: Group [[GRP45]]: -; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2)) +; RECURSE-NEXT: (Low: %Base2 High: (400 + %Base2)(u nuw)) ; RECURSE-NEXT: Member: {%Base2,+,4}<nw><%for.body> ; RECURSE-NEXT: Group [[GRP46]]: -; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1)) +; RECURSE-NEXT: (Low: %Base1 High: (400 + %Base1)(u nuw)) ; RECURSE-NEXT: Member: {%Base1,+,4}<nw><%for.body> ; RECURSE-EMPTY: ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -696,13 +696,13 @@ define dso_local void @forked_ptrs_add_to_offset(ptr nocapture readonly %Base, p ; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset ; CHECK-NEXT: Grouped accesses: ; CHECK-NEXT: Group [[GRP47]]: -; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)) +; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw)) ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP48]]: -; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) +; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP49]]: -; CHECK-NEXT: (Low: ((4 * %extra_offset) + %Base) High: (404 + (4 * %extra_offset) + %Base)) +; CHECK-NEXT: (Low: ((4 * %extra_offset) + %Base) High: (404 + (4 * %extra_offset) + %Base)(u nuw)) ; CHECK-NEXT: Member: {(4 + (4 * %extra_offset) + %Base),+,4}<%for.body> ; CHECK-NEXT: Member: {((4 * %extra_offset) + %Base),+,4}<%for.body> ; CHECK-EMPTY: @@ -764,13 +764,13 @@ define dso_local void @forked_ptrs_sub_from_offset(ptr nocapture readonly %Base, ; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset ; CHECK-NEXT: Grouped accesses: ; CHECK-NEXT: Group [[GRP50]]: -; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)) +; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw)) ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP51]]: -; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) +; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP52]]: -; CHECK-NEXT: (Low: ((-4 * %extra_offset) + %Base) High: (404 + (-4 * %extra_offset) + %Base)) +; CHECK-NEXT: (Low: ((-4 * %extra_offset) + %Base) High: (404 + (-4 * %extra_offset) + %Base)(u nuw)) ; CHECK-NEXT: Member: {(4 + (-4 * %extra_offset) + %Base),+,4}<%for.body> ; CHECK-NEXT: Member: {((-4 * %extra_offset) + %Base),+,4}<%for.body> ; CHECK-EMPTY: @@ -832,13 +832,13 @@ define dso_local void @forked_ptrs_add_sub_offset(ptr nocapture readonly %Base, ; CHECK-NEXT: %arrayidx3 = getelementptr inbounds float, ptr %Base, i64 %offset ; CHECK-NEXT: Grouped accesses: ; CHECK-NEXT: Group [[GRP53]]: -; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)) +; CHECK-NEXT: (Low: %Dest High: (400 + %Dest)(u nuw)) ; CHECK-NEXT: Member: {%Dest,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP54]]: -; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)) +; CHECK-NEXT: (Low: %Preds High: (400 + %Preds)(u nuw)) ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP55]]: -; CHECK-NEXT: (Low: ((4 * %to_add) + (-4 * %to_sub) + %Base) High: (404 + (4 * %to_add) + (-4 * %to_sub) + %Base)) +; CHECK-NEXT: (Low: ((4 * %to_add) + (-4 * %to_sub) + %Base) High: (404 + (4 * %to_add) + (-4 * %to_sub) + %Base)(u nuw)) ; CHECK-NEXT: Member: {(4 + (4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body> ; CHECK-NEXT: Member: {((4 * %to_add) + (-4 * %to_sub) + %Base),+,4}<%for.body> ; CHECK-EMPTY: @@ -1256,10 +1256,10 @@ define void @sc_add_expr_ice(ptr %Base1, ptr %Base2, i64 %N) { ; CHECK-NEXT: %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel ; CHECK-NEXT: Grouped accesses: ; CHECK-NEXT: Group [[GRP56]]: -; CHECK-NEXT: (Low: %Base1 High: (8 + %Base1)) +; CHECK-NEXT: (Low: %Base1 High: (8 + %Base1)(u nuw)) ; CHECK-NEXT: Member: %Base1 ; CHECK-NEXT: Group [[GRP57]]: -; CHECK-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2)) +; CHECK-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2)(u nuw)) ; CHECK-NEXT: Member: {%Base2,+,8}<%for.body> ; CHECK-EMPTY: ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -1283,10 +1283,10 @@ define void @sc_add_expr_ice(ptr %Base1, ptr %Base2, i64 %N) { ; RECURSE-NEXT: %fptr = getelementptr inbounds double, ptr %Base2, i64 %sel ; RECURSE-NEXT: Grouped accesses: ; RECURSE-NEXT: Group [[GRP58]]: -; RECURSE-NEXT: (Low: %Base1 High: (8 + %Base1)) +; RECURSE-NEXT: (Low: %Base1 High: (8 + %Base1)(u nuw)) ; RECURSE-NEXT: Member: %Base1 ; RECURSE-NEXT: Group [[GRP59]]: -; RECURSE-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2)) +; RECURSE-NEXT: (Low: %Base2 High: ((8 * %N) + %Base2)(u nuw)) ; RECURSE-NEXT: Member: {%Base2,+,8}<%for.body> ; RECURSE-EMPTY: ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -1345,16 +1345,16 @@ define void @forked_ptrs_with_different_base(ptr nocapture readonly %Preds, ptr ; CHECK-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv ; CHECK-NEXT: Grouped accesses: ; CHECK-NEXT: Group [[GRP60]]: -; CHECK-NEXT: (Low: %1 High: (63992 + %1)) +; CHECK-NEXT: (Low: %1 High: (63992 + %1)(u nuw)) ; CHECK-NEXT: Member: {%1,+,8}<nw><%for.body> ; CHECK-NEXT: Group [[GRP63]]: -; CHECK-NEXT: (Low: %2 High: (63992 + %2)) +; CHECK-NEXT: (Low: %2 High: (63992 + %2)(u nuw)) ; CHECK-NEXT: Member: {%2,+,8}<nw><%for.body> ; CHECK-NEXT: Group [[GRP61]]: -; CHECK-NEXT: (Low: %Preds High: (31996 + %Preds)) +; CHECK-NEXT: (Low: %Preds High: (31996 + %Preds)(u nuw)) ; CHECK-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; CHECK-NEXT: Group [[GRP62]]: -; CHECK-NEXT: (Low: %0 High: (63992 + %0)) +; CHECK-NEXT: (Low: %0 High: (63992 + %0)(u nuw)) ; CHECK-NEXT: Member: {%0,+,8}<nw><%for.body> ; CHECK-EMPTY: ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. @@ -1389,16 +1389,16 @@ define void @forked_ptrs_with_different_base(ptr nocapture readonly %Preds, ptr ; RECURSE-NEXT: %arrayidx5 = getelementptr inbounds double, ptr %0, i64 %indvars.iv ; RECURSE-NEXT: Grouped accesses: ; RECURSE-NEXT: Group [[GRP64]]: -; RECURSE-NEXT: (Low: %1 High: (63992 + %1)) +; RECURSE-NEXT: (Low: %1 High: (63992 + %1)(u nuw)) ; RECURSE-NEXT: Member: {%1,+,8}<nw><%for.body> ; RECURSE-NEXT: Group [[GRP67]]: -; RECURSE-NEXT: (Low: %2 High: (63992 + %2)) +; RECURSE-NEXT: (Low: %2 High: (63992 + %2)(u nuw)) ; RECURSE-NEXT: Member: {%2,+,8}<nw><%for.body> ; RECURSE-NEXT: Group [[GRP65]]: -; RECURSE-NEXT: (Low: %Preds High: (31996 + %Preds)) +; RECURSE-NEXT: (Low: %Preds High: (31996 + %Preds)(u nuw)) ; RECURSE-NEXT: Member: {%Preds,+,4}<nuw><%for.body> ; RECURSE-NEXT: Group [[GRP66]]: -; RECURSE-NEXT: (Low: %0 High: (63992 + %0)) +; RECURSE-NEXT: (Low: %0 High: (63992 + %0)(u nuw)) ; RECURSE-NEXT: Member: {%0,+,8}<nw><%for.body> ; RECURSE-EMPTY: ; RECURSE-NEXT: Non vectorizable stores to invariant address were not found in loop. diff --git a/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll b/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll index 323ba2a739cf8..ea354f468c0ef 100644 --- a/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll +++ b/llvm/test/Analysis/LoopAccessAnalysis/scoped-scevs.ll @@ -22,21 +22,10 @@ define ptr @test_ptr_range_end_computed_before_and_after_loop(ptr %A) { ; ; LAA-LABEL: 'test_ptr_range_end_computed_before_and_after_loop' ; LAA-NEXT: loop: -; LAA-NEXT: Memory dependences are safe with run-time checks +; LAA-NEXT: Report: cannot check memory dependencies at runtime ; LAA-NEXT: Dependences: ; LAA-NEXT: Run-time memory checks: -; LAA-NEXT: Check 0: -; LAA-NEXT: Comparing group ([[GRP1:0x[0-9a-f]+]]): -; LAA-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv -; LAA-NEXT: Against group ([[GRP2:0x[0-9a-f]+]]): -; LAA-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv ; LAA-NEXT: Grouped accesses: -; LAA-NEXT: Group [[GRP1]]: -; LAA-NEXT: (Low: (1 + %A) High: (405 + %A)) -; LAA-NEXT: Member: {(1 + %A),+,4}<nw><%loop> -; LAA-NEXT: Group [[GRP2]]: -; LAA-NEXT: (Low: %A High: (101 + %A)) -; LAA-NEXT: Member: {%A,+,1}<nuw><%loop> ; LAA-EMPTY: ; LAA-NEXT: Non vectorizable stores to invariant address were not found in loop. ; LAA-NEXT: SCEV assumptions: @@ -80,21 +69,10 @@ define void @test_ptr_range_end_computed_before_loop(ptr %A) { ; ; LAA-LABEL: 'test_ptr_range_end_computed_before_loop' ; LAA-NEXT: loop: -; LAA-NEXT: Memory dependences are safe with run-time checks +; LAA-NEXT: Report: cannot check memory dependencies at runtime ; LAA-NEXT: Dependences: ; LAA-NEXT: Run-time memory checks: -; LAA-NEXT: Check 0: -; LAA-NEXT: Comparing group ([[GRP3:0x[0-9a-f]+]]): -; LAA-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv -; LAA-NEXT: Against group ([[GRP4:0x[0-9a-f]+]]): -; LAA-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv ; LAA-NEXT: Grouped accesses: -; LAA-NEXT: Group [[GRP3]]: -; LAA-NEXT: (Low: (1 + %A) High: (405 + %A)) -; LAA-NEXT: Member: {(1 + %A),+,4}<nw><%loop> -; LAA-NEXT: Group [[GRP4]]: -; LAA-NEXT: (Low: %A High: (101 + %A)) -; LAA-NEXT: Member: {%A,+,1}<nuw><%loop> ; LAA-EMPTY: ; LAA-NEXT: Non vectorizable stores to invariant address were not found in loop. ; LAA-NEXT: SCEV assumptions: @@ -135,21 +113,10 @@ define ptr @test_ptr_range_end_computed_after_loop(ptr %A) { ; ; LAA-LABEL: 'test_ptr_range_end_computed_after_loop' ; LAA-NEXT: loop: -; LAA-NEXT: Memory dependences are safe with run-time checks +; LAA-NEXT: Report: cannot check memory dependencies at runtime ; LAA-NEXT: Dependences: ; LAA-NEXT: Run-time memory checks: -; LAA-NEXT: Check 0: -; LAA-NEXT: Comparing group ([[GRP5:0x[0-9a-f]+]]): -; LAA-NEXT: %gep.A.400 = getelementptr inbounds i32, ptr %A.1, i64 %iv -; LAA-NEXT: Against group ([[GRP6:0x[0-9a-f]+]]): -; LAA-NEXT: %gep.A = getelementptr inbounds i8, ptr %A, i64 %iv ; LAA-NEXT: Grouped accesses: -; LAA-NEXT: Group [[GRP5]]: -; LAA-NEXT: (Low: (1 + %A)<nuw> High: (405 + %A)) -; LAA-NEXT: Member: {(1 + %A)<nuw>,+,4}<nuw><%loop> -; LAA-NEXT: Group [[GRP6]]: -; LAA-NEXT: (Low: %A High: (101 + %A)) -; LAA-NEXT: Member: {%A,+,1}<nuw><%loop> ; LAA-EMPTY: ; LAA-NEXT: Non vectorizable stores to invariant address were not found in loop. ; LAA-NEXT: SCEV assumptions: _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
