[llvm] [DA] runtime predicates for delinearization bounds checks (PR #170713)
Sebastian Pop via llvm-commits
llvm-commits at lists.llvm.org
Thu Dec 4 10:20:46 PST 2025
https://github.com/sebpop created https://github.com/llvm/llvm-project/pull/170713
When compile-time checks fail, rely on runtime SCEV predicates, instead of failing delinearization entirely. This allows delinearization to succeed in more cases where compile-time proofs are not possible, enabling more precise dependence analysis under runtime assumptions.
>From acfe5744f3a84af20b1240dbed1dfeac1c76ef65 Mon Sep 17 00:00:00 2001
From: Sebastian Pop <spop at nvidia.com>
Date: Wed, 26 Nov 2025 08:27:17 -0500
Subject: [PATCH] [DA] runtime predicates for delinearization bounds checks
When compile-time checks fail, rely on runtime SCEV predicates, instead of
failing delinearization entirely. This allows delinearization to succeed in
more cases where compile-time proofs are not possible, enabling more precise
dependence analysis under runtime assumptions.
---
llvm/include/llvm/Analysis/Delinearization.h | 13 ++--
.../llvm/Analysis/DependenceAnalysis.h | 9 ++-
llvm/lib/Analysis/Delinearization.cpp | 46 +++++++++---
llvm/lib/Analysis/DependenceAnalysis.cpp | 39 +++++-----
.../Analysis/DependenceAnalysis/Banerjee.ll | 72 +++++++++++++++----
.../DependenceAnalysis/Constraints.ll | 35 +++++++--
.../Analysis/DependenceAnalysis/DADelin.ll | 33 ++++++++-
.../DependenceAnalysis/DifferentOffsets.ll | 6 ++
.../Analysis/DependenceAnalysis/ExactRDIV.ll | 20 ++++--
llvm/test/Analysis/DependenceAnalysis/GCD.ll | 66 ++++++++++++++---
.../Analysis/DependenceAnalysis/Invariant.ll | 3 +-
.../MismatchingNestLevels.ll | 4 ++
.../NonCanonicalizedSubscript.ll | 7 +-
.../DependenceAnalysis/Preliminary.ll | 9 +++
.../PreliminaryNoValidityCheckFixedSize.ll | 9 +++
.../DependenceAnalysis/Propagating.ll | 46 +++++++++---
.../SimpleSIVNoValidityCheck.ll | 27 +++++++
.../Analysis/DependenceAnalysis/StrongSIV.ll | 3 +
.../DependenceAnalysis/SymbolicSIV.ll | 14 ++++
.../DependenceAnalysis/WeakCrossingSIV.ll | 4 ++
.../DependenceAnalysis/WeakZeroDstSIV.ll | 1 +
.../DependenceAnalysis/WeakZeroSrcSIV.ll | 1 +
.../becount-couldnotcompute.ll | 1 +
.../compute-absolute-value.ll | 4 ++
.../DependenceAnalysis/gcd-miv-overflow.ll | 7 ++
.../DependenceAnalysis/monotonicity-cast.ll | 2 +
.../monotonicity-no-wrap-flags.ll | 2 +
.../DependenceAnalysis/zero-coefficient.ll | 1 +
.../loop-interchange-optimization-remarks.ll | 14 ++--
29 files changed, 407 insertions(+), 91 deletions(-)
diff --git a/llvm/include/llvm/Analysis/Delinearization.h b/llvm/include/llvm/Analysis/Delinearization.h
index 8fb30925b1ba7..7346128c0b510 100644
--- a/llvm/include/llvm/Analysis/Delinearization.h
+++ b/llvm/include/llvm/Analysis/Delinearization.h
@@ -26,6 +26,7 @@ class GetElementPtrInst;
class Instruction;
class ScalarEvolution;
class SCEV;
+class SCEVPredicate;
/// Compute the array dimensions Sizes from the set of Terms extracted from
/// the memory access function of this SCEVAddRecExpr (second step of
@@ -144,11 +145,13 @@ bool delinearizeFixedSizeArray(ScalarEvolution &SE, const SCEV *Expr,
/// Check that each subscript in \p Subscripts is within the corresponding size
/// in \p Sizes. For the outermost dimension, the subscript being negative is
/// allowed. If \p Ptr is not nullptr, it may be used to get information from
-/// the IR pointer value, which may help in the validation.
-bool validateDelinearizationResult(ScalarEvolution &SE,
- ArrayRef<const SCEV *> Sizes,
- ArrayRef<const SCEV *> Subscripts,
- const Value *Ptr = nullptr);
+/// the IR pointer value, which may help in the validation. If \p Assume is not
+/// nullptr and a compile-time check fails, runtime predicates are added to
+/// \p Assume instead of returning false.
+bool validateDelinearizationResult(
+ ScalarEvolution &SE, ArrayRef<const SCEV *> Sizes,
+ ArrayRef<const SCEV *> Subscripts, const Value *Ptr = nullptr,
+ SmallVectorImpl<const SCEVPredicate *> *Assume = nullptr);
/// Gathers the individual index expressions from a GEP instruction.
///
diff --git a/llvm/include/llvm/Analysis/DependenceAnalysis.h b/llvm/include/llvm/Analysis/DependenceAnalysis.h
index 6dec24fc9f104..80095e91fcc6b 100644
--- a/llvm/include/llvm/Analysis/DependenceAnalysis.h
+++ b/llvm/include/llvm/Analysis/DependenceAnalysis.h
@@ -754,7 +754,8 @@ class DependenceInfo {
/// Given a linear access function, tries to recover subscripts
/// for each dimension of the array element access.
bool tryDelinearize(Instruction *Src, Instruction *Dst,
- SmallVectorImpl<Subscript> &Pair);
+ SmallVectorImpl<Subscript> &Pair,
+ SmallVectorImpl<const SCEVPredicate *> &Assume);
/// Tries to delinearize \p Src and \p Dst access functions for a fixed size
/// multi-dimensional array. Calls delinearizeFixedSizeArray() to delinearize
@@ -762,7 +763,8 @@ class DependenceInfo {
bool tryDelinearizeFixedSize(Instruction *Src, Instruction *Dst,
const SCEV *SrcAccessFn, const SCEV *DstAccessFn,
SmallVectorImpl<const SCEV *> &SrcSubscripts,
- SmallVectorImpl<const SCEV *> &DstSubscripts);
+ SmallVectorImpl<const SCEV *> &DstSubscripts,
+ SmallVectorImpl<const SCEVPredicate *> &Assume);
/// Tries to delinearize access function for a multi-dimensional array with
/// symbolic runtime sizes.
@@ -771,7 +773,8 @@ class DependenceInfo {
tryDelinearizeParametricSize(Instruction *Src, Instruction *Dst,
const SCEV *SrcAccessFn, const SCEV *DstAccessFn,
SmallVectorImpl<const SCEV *> &SrcSubscripts,
- SmallVectorImpl<const SCEV *> &DstSubscripts);
+ SmallVectorImpl<const SCEV *> &DstSubscripts,
+ SmallVectorImpl<const SCEVPredicate *> &Assume);
/// checkSubscript - Helper function for checkSrcSubscript and
/// checkDstSubscript to avoid duplicate code
diff --git a/llvm/lib/Analysis/Delinearization.cpp b/llvm/lib/Analysis/Delinearization.cpp
index 7bf83ccf9c172..68928c62ab569 100644
--- a/llvm/lib/Analysis/Delinearization.cpp
+++ b/llvm/lib/Analysis/Delinearization.cpp
@@ -753,24 +753,34 @@ static bool isKnownLessThan(ScalarEvolution *SE, const SCEV *S,
return SE->isKnownNegative(LimitedBound);
}
-bool llvm::validateDelinearizationResult(ScalarEvolution &SE,
- ArrayRef<const SCEV *> Sizes,
- ArrayRef<const SCEV *> Subscripts,
- const Value *Ptr) {
+bool llvm::validateDelinearizationResult(
+ ScalarEvolution &SE, ArrayRef<const SCEV *> Sizes,
+ ArrayRef<const SCEV *> Subscripts, const Value *Ptr,
+ SmallVectorImpl<const SCEVPredicate *> *Assume) {
// Sizes and Subscripts are as follows:
- //
// Sizes: [UNK][S_2]...[S_n]
// Subscripts: [I_1][I_2]...[I_n]
//
// where the size of the outermost dimension is unknown (UNK).
+ // Unify types of two SCEVs to the wider type.
+ auto UnifyTypes =
+ [&](const SCEV *&A,
+ const SCEV *&B) -> std::pair<const SCEV *, const SCEV *> {
+ Type *WiderType = SE.getWiderType(A->getType(), B->getType());
+ return {SE.getNoopOrSignExtend(A, WiderType),
+ SE.getNoopOrSignExtend(B, WiderType)};
+ };
+
auto AddOverflow = [&](const SCEV *A, const SCEV *B) -> const SCEV * {
+ std::tie(A, B) = UnifyTypes(A, B);
if (!SE.willNotOverflow(Instruction::Add, /*IsSigned=*/true, A, B))
return nullptr;
return SE.getAddExpr(A, B);
};
auto MulOverflow = [&](const SCEV *A, const SCEV *B) -> const SCEV * {
+ std::tie(A, B) = UnifyTypes(A, B);
if (!SE.willNotOverflow(Instruction::Mul, /*IsSigned=*/true, A, B))
return nullptr;
return SE.getMulExpr(A, B);
@@ -780,10 +790,28 @@ bool llvm::validateDelinearizationResult(ScalarEvolution &SE,
for (size_t I = 1; I < Sizes.size(); ++I) {
const SCEV *Size = Sizes[I - 1];
const SCEV *Subscript = Subscripts[I];
- if (!isKnownNonNegative(&SE, Subscript, Ptr))
- return false;
- if (!isKnownLessThan(&SE, Subscript, Size))
- return false;
+
+ // Check Subscript >= 0.
+ if (!isKnownNonNegative(&SE, Subscript, Ptr)) {
+ if (!Assume)
+ return false;
+ const SCEVPredicate *Pred = SE.getComparePredicate(
+ ICmpInst::ICMP_SGE, Subscript, SE.getZero(Subscript->getType()));
+ Assume->push_back(Pred);
+ }
+
+ // Check Subscript < Size.
+ if (!isKnownLessThan(&SE, Subscript, Size)) {
+ if (!Assume)
+ return false;
+ // Need to unify types before creating the predicate.
+ Type *WiderType = SE.getWiderType(Subscript->getType(), Size->getType());
+ const SCEV *SubscriptExt = SE.getNoopOrSignExtend(Subscript, WiderType);
+ const SCEV *SizeExt = SE.getNoopOrSignExtend(Size, WiderType);
+ const SCEVPredicate *Pred =
+ SE.getComparePredicate(ICmpInst::ICMP_SLT, SubscriptExt, SizeExt);
+ Assume->push_back(Pred);
+ }
}
// The offset computation is as follows:
diff --git a/llvm/lib/Analysis/DependenceAnalysis.cpp b/llvm/lib/Analysis/DependenceAnalysis.cpp
index 9b9c80a9b3266..858cbafdc3a0a 100644
--- a/llvm/lib/Analysis/DependenceAnalysis.cpp
+++ b/llvm/lib/Analysis/DependenceAnalysis.cpp
@@ -3176,8 +3176,9 @@ const SCEV *DependenceInfo::getUpperBound(BoundInfo *Bound) const {
/// source and destination array references are recurrences on a nested loop,
/// this function flattens the nested recurrences into separate recurrences
/// for each loop level.
-bool DependenceInfo::tryDelinearize(Instruction *Src, Instruction *Dst,
- SmallVectorImpl<Subscript> &Pair) {
+bool DependenceInfo::tryDelinearize(
+ Instruction *Src, Instruction *Dst, SmallVectorImpl<Subscript> &Pair,
+ SmallVectorImpl<const SCEVPredicate *> &Assume) {
assert(isLoadOrStore(Src) && "instruction is not load or store");
assert(isLoadOrStore(Dst) && "instruction is not load or store");
Value *SrcPtr = getLoadStorePointerOperand(Src);
@@ -3197,9 +3198,9 @@ bool DependenceInfo::tryDelinearize(Instruction *Src, Instruction *Dst,
SmallVector<const SCEV *, 4> SrcSubscripts, DstSubscripts;
if (!tryDelinearizeFixedSize(Src, Dst, SrcAccessFn, DstAccessFn,
- SrcSubscripts, DstSubscripts) &&
+ SrcSubscripts, DstSubscripts, Assume) &&
!tryDelinearizeParametricSize(Src, Dst, SrcAccessFn, DstAccessFn,
- SrcSubscripts, DstSubscripts))
+ SrcSubscripts, DstSubscripts, Assume))
return false;
assert(isLoopInvariant(SrcBase, SrcLoop) &&
@@ -3245,7 +3246,8 @@ bool DependenceInfo::tryDelinearize(Instruction *Src, Instruction *Dst,
bool DependenceInfo::tryDelinearizeFixedSize(
Instruction *Src, Instruction *Dst, const SCEV *SrcAccessFn,
const SCEV *DstAccessFn, SmallVectorImpl<const SCEV *> &SrcSubscripts,
- SmallVectorImpl<const SCEV *> &DstSubscripts) {
+ SmallVectorImpl<const SCEV *> &DstSubscripts,
+ SmallVectorImpl<const SCEVPredicate *> &Assume) {
LLVM_DEBUG({
const SCEVUnknown *SrcBase =
dyn_cast<SCEVUnknown>(SE->getPointerBase(SrcAccessFn));
@@ -3285,10 +3287,12 @@ bool DependenceInfo::tryDelinearizeFixedSize(
// dimensions. For example some C language usage/interpretation make it
// impossible to verify this at compile-time. As such we can only delinearize
// iff the subscripts are positive and are less than the range of the
- // dimension.
+ // dimension. If compile-time checks fail, add runtime predicates.
if (!DisableDelinearizationChecks) {
- if (!validateDelinearizationResult(*SE, SrcSizes, SrcSubscripts, SrcPtr) ||
- !validateDelinearizationResult(*SE, DstSizes, DstSubscripts, DstPtr)) {
+ if (!validateDelinearizationResult(*SE, SrcSizes, SrcSubscripts, SrcPtr,
+ &Assume) ||
+ !validateDelinearizationResult(*SE, DstSizes, DstSubscripts, DstPtr,
+ &Assume)) {
SrcSubscripts.clear();
DstSubscripts.clear();
return false;
@@ -3305,7 +3309,8 @@ bool DependenceInfo::tryDelinearizeFixedSize(
bool DependenceInfo::tryDelinearizeParametricSize(
Instruction *Src, Instruction *Dst, const SCEV *SrcAccessFn,
const SCEV *DstAccessFn, SmallVectorImpl<const SCEV *> &SrcSubscripts,
- SmallVectorImpl<const SCEV *> &DstSubscripts) {
+ SmallVectorImpl<const SCEV *> &DstSubscripts,
+ SmallVectorImpl<const SCEVPredicate *> &Assume) {
Value *SrcPtr = getLoadStorePointerOperand(Src);
Value *DstPtr = getLoadStorePointerOperand(Dst);
@@ -3346,15 +3351,13 @@ bool DependenceInfo::tryDelinearizeParametricSize(
SrcSubscripts.size() != DstSubscripts.size())
return false;
- // Statically check that the array bounds are in-range. The first subscript we
- // don't have a size for and it cannot overflow into another subscript, so is
- // always safe. The others need to be 0 <= subscript[i] < bound, for both src
- // and dst.
- // FIXME: It may be better to record these sizes and add them as constraints
- // to the dependency checks.
+ // Check that the array bounds are in-range. If compile-time checks fail,
+ // add runtime predicates.
if (!DisableDelinearizationChecks)
- if (!validateDelinearizationResult(*SE, Sizes, SrcSubscripts, SrcPtr) ||
- !validateDelinearizationResult(*SE, Sizes, DstSubscripts, DstPtr))
+ if (!validateDelinearizationResult(*SE, Sizes, SrcSubscripts, SrcPtr,
+ &Assume) ||
+ !validateDelinearizationResult(*SE, Sizes, DstSubscripts, DstPtr,
+ &Assume))
return false;
return true;
@@ -3507,7 +3510,7 @@ DependenceInfo::depends(Instruction *Src, Instruction *Dst,
SCEVUnionPredicate(Assume, *SE));
if (Delinearize) {
- if (tryDelinearize(Src, Dst, Pair)) {
+ if (tryDelinearize(Src, Dst, Pair, Assume)) {
LLVM_DEBUG(dbgs() << " delinearized\n");
Pairs = Pair.size();
}
diff --git a/llvm/test/Analysis/DependenceAnalysis/Banerjee.ll b/llvm/test/Analysis/DependenceAnalysis/Banerjee.ll
index 6dde8844c6040..6e75887db06d4 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Banerjee.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Banerjee.ll
@@ -46,9 +46,14 @@ define void @banerjee0(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
;
; DELIN-LABEL: 'banerjee0'
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
-; DELIN-NEXT: da analyze - none!
+; DELIN-NEXT: da analyze - consistent output [0 0]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.body3> slt) 10
+; DELIN-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.body3> slt) 10
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %0 = load i64, ptr %arrayidx6, align 8
-; DELIN-NEXT: da analyze - flow [<= <>]!
+; DELIN-NEXT: da analyze - consistent flow [0 1]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.body3> slt) 10
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: %0 = load i64, ptr %arrayidx6, align 8
@@ -132,12 +137,18 @@ define void @banerjee1(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; DELIN-LABEL: 'banerjee1'
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
; DELIN-NEXT: da analyze - output [* *]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.body3> slt) 10
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %2 = load i64, ptr %arrayidx6, align 8
; DELIN-NEXT: da analyze - flow [* <>]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.body3> slt) 10
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %2, ptr %B.addr.12, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: %2 = load i64, ptr %arrayidx6, align 8 --> Dst: %2 = load i64, ptr %arrayidx6, align 8
; DELIN-NEXT: da analyze - input [* *]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.body3> slt) 10
; DELIN-NEXT: Src: %2 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %2, ptr %B.addr.12, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: store i64 %2, ptr %B.addr.12, align 8 --> Dst: store i64 %2, ptr %B.addr.12, align 8
@@ -320,11 +331,16 @@ define void @banerjee3(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
; DELIN-NEXT: da analyze - none!
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %0 = load i64, ptr %arrayidx7, align 8
-; DELIN-NEXT: da analyze - flow [> >]!
+; DELIN-NEXT: da analyze - consistent flow [-9 -9]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {9,+,1}<nuw><nsw><%for.body3> slt) 10
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx7, align 8 --> Dst: %0 = load i64, ptr %arrayidx7, align 8
-; DELIN-NEXT: da analyze - none!
+; DELIN-NEXT: da analyze - consistent input [0 0]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {9,+,1}<nuw><nsw><%for.body3> slt) 10
+; DELIN-NEXT: Compare predicate: {9,+,1}<nuw><nsw><%for.body3> slt) 10
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx7, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
@@ -490,11 +506,16 @@ define void @banerjee5(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
; DELIN-NEXT: da analyze - none!
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %0 = load i64, ptr %arrayidx6, align 8
-; DELIN-NEXT: da analyze - flow [< <]!
+; DELIN-NEXT: da analyze - consistent flow [9 9]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {-9,+,1}<nsw><%for.body3> sge) 0
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: %0 = load i64, ptr %arrayidx6, align 8
-; DELIN-NEXT: da analyze - none!
+; DELIN-NEXT: da analyze - consistent input [0 0]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {-9,+,1}<nsw><%for.body3> sge) 0
+; DELIN-NEXT: Compare predicate: {-9,+,1}<nsw><%for.body3> sge) 0
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
@@ -575,11 +596,16 @@ define void @banerjee6(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
; DELIN-NEXT: da analyze - none!
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %0 = load i64, ptr %arrayidx7, align 8
-; DELIN-NEXT: da analyze - flow [=> <>]!
+; DELIN-NEXT: da analyze - consistent flow [0 -9]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {9,+,1}<nuw><nsw><%for.body3> slt) 10
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx7, align 8 --> Dst: %0 = load i64, ptr %arrayidx7, align 8
-; DELIN-NEXT: da analyze - none!
+; DELIN-NEXT: da analyze - consistent input [0 0]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {9,+,1}<nuw><nsw><%for.body3> slt) 10
+; DELIN-NEXT: Compare predicate: {9,+,1}<nuw><nsw><%for.body3> slt) 10
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx7, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
@@ -745,11 +771,16 @@ define void @banerjee8(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
; DELIN-NEXT: da analyze - none!
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %0 = load i64, ptr %arrayidx7, align 8
-; DELIN-NEXT: da analyze - flow [> <>]!
+; DELIN-NEXT: da analyze - consistent flow [-1 -1]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.body3> slt) 10
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx7, align 8 --> Dst: %0 = load i64, ptr %arrayidx7, align 8
-; DELIN-NEXT: da analyze - none!
+; DELIN-NEXT: da analyze - consistent input [0 0]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.body3> slt) 10
+; DELIN-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.body3> slt) 10
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx7, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
@@ -828,9 +859,14 @@ define void @banerjee9(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
;
; DELIN-LABEL: 'banerjee9'
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
-; DELIN-NEXT: da analyze - output [* *]!
+; DELIN-NEXT: da analyze - consistent output [0 0]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {0,+,30}<nuw><nsw><%for.cond1.preheader> slt) 500
+; DELIN-NEXT: Compare predicate: {0,+,30}<nuw><nsw><%for.cond1.preheader> slt) 500
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %1 = load i64, ptr %arrayidx7, align 8
-; DELIN-NEXT: da analyze - flow [<= 0|<]!
+; DELIN-NEXT: da analyze - flow [< 0]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {0,+,30}<nuw><nsw><%for.cond1.preheader> slt) 500
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: %1 = load i64, ptr %arrayidx7, align 8 --> Dst: %1 = load i64, ptr %arrayidx7, align 8
@@ -1005,7 +1041,10 @@ define void @banerjee11(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: %0 = load i64, ptr %arrayidx6, align 8
-; DELIN-NEXT: da analyze - none!
+; DELIN-NEXT: da analyze - consistent input [0 0]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {11,+,-1}<nsw><%for.body3> sge) 0
+; DELIN-NEXT: Compare predicate: {11,+,-1}<nsw><%for.body3> sge) 0
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
@@ -1087,10 +1126,15 @@ define void @banerjee12(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
; DELIN-NEXT: da analyze - none!
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: %0 = load i64, ptr %arrayidx6, align 8
; DELIN-NEXT: da analyze - flow [0 <>]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {11,+,-1}<nsw><%for.body3> sge) 0
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: %0 = load i64, ptr %arrayidx6, align 8
-; DELIN-NEXT: da analyze - none!
+; DELIN-NEXT: da analyze - consistent input [0 0]!
+; DELIN-NEXT: Runtime Assumptions:
+; DELIN-NEXT: Compare predicate: {11,+,-1}<nsw><%for.body3> sge) 0
+; DELIN-NEXT: Compare predicate: {11,+,-1}<nsw><%for.body3> sge) 0
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
; DELIN-NEXT: da analyze - confused!
; DELIN-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
diff --git a/llvm/test/Analysis/DependenceAnalysis/Constraints.ll b/llvm/test/Analysis/DependenceAnalysis/Constraints.ll
index 65dbcef153d19..7d69835133f7e 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Constraints.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Constraints.ll
@@ -37,7 +37,10 @@ define void @dep_constraint_crash_test(i32 %M, i32 %N) {
; CHECK-NEXT: Src: %out_l.promoted = load i32, ptr @out_l, align 4 --> Dst: store i32 %33, ptr @out_l, align 4
; CHECK-NEXT: da analyze - consistent anti [|<]!
; CHECK-NEXT: Src: store i32 0, ptr %13, align 4 --> Dst: store i32 0, ptr %13, align 4
-; CHECK-NEXT: da analyze - output [S * *]!
+; CHECK-NEXT: da analyze - consistent output [S 0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {10,+,10}<nuw><nsw><%.lr.ph4> slt) 111
+; CHECK-NEXT: Compare predicate: {10,+,10}<nuw><nsw><%.lr.ph4> slt) 111
; CHECK-NEXT: Src: store i32 0, ptr %13, align 4 --> Dst: %18 = load i32, ptr %17, align 4
; CHECK-NEXT: da analyze - flow [S * *|<]!
; CHECK-NEXT: Src: store i32 0, ptr %13, align 4 --> Dst: %20 = load i32, ptr %19, align 4
@@ -47,7 +50,10 @@ define void @dep_constraint_crash_test(i32 %M, i32 %N) {
; CHECK-NEXT: Src: store i32 0, ptr %13, align 4 --> Dst: store i32 %24, ptr %25, align 4
; CHECK-NEXT: da analyze - output [S * *|<]!
; CHECK-NEXT: Src: store i32 0, ptr %13, align 4 --> Dst: %27 = load i32, ptr %26, align 4
-; CHECK-NEXT: da analyze - flow [S * *|<]!
+; CHECK-NEXT: da analyze - flow [S 0 *|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {10,+,10}<nuw><nsw><%.lr.ph4> slt) 111
+; CHECK-NEXT: Compare predicate: {10,+,11}<%.lr.ph4> slt) 111
; CHECK-NEXT: Src: store i32 0, ptr %13, align 4 --> Dst: %29 = load i32, ptr %28, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 0, ptr %13, align 4 --> Dst: store i32 %30, ptr %31, align 4
@@ -75,7 +81,10 @@ define void @dep_constraint_crash_test(i32 %M, i32 %N) {
; CHECK-NEXT: Src: %18 = load i32, ptr %17, align 4 --> Dst: store i32 %33, ptr @out_l, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: %20 = load i32, ptr %19, align 4 --> Dst: %20 = load i32, ptr %19, align 4
-; CHECK-NEXT: da analyze - input [S * S *]!
+; CHECK-NEXT: da analyze - consistent input [S 0 S 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%.lr.ph> slt) 11
+; CHECK-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%.lr.ph> slt) 11
; CHECK-NEXT: Src: %20 = load i32, ptr %19, align 4 --> Dst: %23 = load i32, ptr %22, align 4
; CHECK-NEXT: da analyze - input [S * * *|<]!
; CHECK-NEXT: Src: %20 = load i32, ptr %19, align 4 --> Dst: store i32 %24, ptr %25, align 4
@@ -85,7 +94,10 @@ define void @dep_constraint_crash_test(i32 %M, i32 %N) {
; CHECK-NEXT: Src: %20 = load i32, ptr %19, align 4 --> Dst: %29 = load i32, ptr %28, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: %20 = load i32, ptr %19, align 4 --> Dst: store i32 %30, ptr %31, align 4
-; CHECK-NEXT: da analyze - anti [S * *|<]!
+; CHECK-NEXT: da analyze - anti [S 0 *|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%.lr.ph> slt) 11
+; CHECK-NEXT: Compare predicate: {1,+,1}<nw><%.lr.ph4> slt) 11
; CHECK-NEXT: Src: %20 = load i32, ptr %19, align 4 --> Dst: %32 = load i32, ptr %6, align 4
; CHECK-NEXT: da analyze - input [S|<]!
; CHECK-NEXT: Src: %20 = load i32, ptr %19, align 4 --> Dst: store i32 %33, ptr @out_l, align 4
@@ -117,7 +129,10 @@ define void @dep_constraint_crash_test(i32 %M, i32 %N) {
; CHECK-NEXT: Src: store i32 %24, ptr %25, align 4 --> Dst: store i32 %33, ptr @out_l, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: %27 = load i32, ptr %26, align 4 --> Dst: %27 = load i32, ptr %26, align 4
-; CHECK-NEXT: da analyze - input [S * *]!
+; CHECK-NEXT: da analyze - consistent input [S 0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {10,+,11}<%.lr.ph4> slt) 111
+; CHECK-NEXT: Compare predicate: {10,+,11}<%.lr.ph4> slt) 111
; CHECK-NEXT: Src: %27 = load i32, ptr %26, align 4 --> Dst: %29 = load i32, ptr %28, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: %27 = load i32, ptr %26, align 4 --> Dst: store i32 %30, ptr %31, align 4
@@ -127,7 +142,10 @@ define void @dep_constraint_crash_test(i32 %M, i32 %N) {
; CHECK-NEXT: Src: %27 = load i32, ptr %26, align 4 --> Dst: store i32 %33, ptr @out_l, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: %29 = load i32, ptr %28, align 4 --> Dst: %29 = load i32, ptr %28, align 4
-; CHECK-NEXT: da analyze - input [S * *]!
+; CHECK-NEXT: da analyze - consistent input [S 0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {1,+,1}<nw><%.lr.ph4> slt) 11
+; CHECK-NEXT: Compare predicate: {1,+,1}<nw><%.lr.ph4> slt) 11
; CHECK-NEXT: Src: %29 = load i32, ptr %28, align 4 --> Dst: store i32 %30, ptr %31, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: %29 = load i32, ptr %28, align 4 --> Dst: %32 = load i32, ptr %6, align 4
@@ -135,7 +153,10 @@ define void @dep_constraint_crash_test(i32 %M, i32 %N) {
; CHECK-NEXT: Src: %29 = load i32, ptr %28, align 4 --> Dst: store i32 %33, ptr @out_l, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %30, ptr %31, align 4 --> Dst: store i32 %30, ptr %31, align 4
-; CHECK-NEXT: da analyze - output [S * *]!
+; CHECK-NEXT: da analyze - consistent output [S 0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {1,+,1}<nw><%.lr.ph4> slt) 11
+; CHECK-NEXT: Compare predicate: {1,+,1}<nw><%.lr.ph4> slt) 11
; CHECK-NEXT: Src: store i32 %30, ptr %31, align 4 --> Dst: %32 = load i32, ptr %6, align 4
; CHECK-NEXT: da analyze - flow [S|<]!
; CHECK-NEXT: Src: store i32 %30, ptr %31, align 4 --> Dst: store i32 %33, ptr @out_l, align 4
diff --git a/llvm/test/Analysis/DependenceAnalysis/DADelin.ll b/llvm/test/Analysis/DependenceAnalysis/DADelin.ll
index 429e37de0a453..1b00b695e0c13 100644
--- a/llvm/test/Analysis/DependenceAnalysis/DADelin.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/DADelin.ll
@@ -3,8 +3,8 @@
; RUN: | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "thumbv8m.main-arm-none-eabi"
+;; A[*][m][o]
;; for (int i = 0; i < n; i++)
;; for (int j = 0; j < m; j++)
;; for (int k = 0; k < o; k++)
@@ -70,6 +70,7 @@ for.cond.cleanup: ; preds = %for.cond.cleanup3,
ret void
}
+;; A[*][m][o]
;; for (int i = 0; i < n; i++)
;; for (int j = 0; j < m; j++)
;; for (int k = 0; k < o; k++)
@@ -83,6 +84,8 @@ define void @t2(i32 %n, i32 %m, i32 %o, ptr nocapture %A) {
; CHECK-NEXT: da analyze - anti [* * *|<]!
; CHECK-NEXT: Src: store i32 %add12, ptr %arrayidx2, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4
; CHECK-NEXT: da analyze - output [* * *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.body8> slt) %o
;
entry:
%cmp49 = icmp sgt i32 %n, 0
@@ -137,6 +140,7 @@ for.cond.cleanup: ; preds = %for.cond.cleanup3,
ret void
}
+;; A[*][m][o]
;; for (int i = 0; i < n; i++)
;; for (int j = 0; j < m; j++)
;; for (int k = 0; k < o; k++)
@@ -150,6 +154,8 @@ define void @t3(i32 %n, i32 %m, i32 %o, ptr nocapture %A) {
; CHECK-NEXT: da analyze - anti [* * *|<]!
; CHECK-NEXT: Src: store i32 %add12, ptr %arrayidx2, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4
; CHECK-NEXT: da analyze - output [* * *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {-1,+,1}<nsw><%for.body8> sge) 0
;
entry:
%cmp49 = icmp sgt i32 %n, 0
@@ -204,6 +210,7 @@ for.cond.cleanup: ; preds = %for.cond.cleanup3,
ret void
}
+;; A[*][m][o]
;; for (int i = 0; i < n; i++)
;; for (int j = 0; j < m; j++)
;; for (int k = 0; k < o; k++)
@@ -217,6 +224,8 @@ define void @t4(i32 %n, i32 %m, i32 %o, ptr nocapture %A) {
; CHECK-NEXT: da analyze - anti [* * *|<]!
; CHECK-NEXT: Src: store i32 %add12, ptr %arrayidx2, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4
; CHECK-NEXT: da analyze - output [* * *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.cond5.preheader> slt) %m
;
entry:
%cmp49 = icmp sgt i32 %n, 0
@@ -284,6 +293,9 @@ define void @t5(i32 %n, i32 %m, i32 %o, ptr nocapture %A) {
; CHECK-NEXT: da analyze - anti [* * *|<]!
; CHECK-NEXT: Src: store i32 %add12, ptr %arrayidx2, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4
; CHECK-NEXT: da analyze - output [* * *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {-1,+,1}<%for.cond5.preheader> sge) 0
+; CHECK-NEXT: Compare predicate: {-1,+,1}<%for.cond5.preheader> slt) %m
;
entry:
%cmp49 = icmp sgt i32 %n, 0
@@ -548,8 +560,13 @@ define double @test_sizes(i16 %h, i16 %N, ptr nocapture %array) {
; CHECK-NEXT: da analyze - consistent input [0 S]!
; CHECK-NEXT: Src: %2 = load i16, ptr %arrayidx, align 4 --> Dst: store i16 %add6, ptr %arrayidx8, align 4
; CHECK-NEXT: da analyze - anti [* *|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.body> slt) (sext i16 %h to i32)
; CHECK-NEXT: Src: store i16 %add6, ptr %arrayidx8, align 4 --> Dst: store i16 %add6, ptr %arrayidx8, align 4
; CHECK-NEXT: da analyze - output [* *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {(sext i16 {2,+,(1 + %h)}<%for.body> to i32),+,1}<nsw><%for.body5> sge) 0
+; CHECK-NEXT: Compare predicate: {(sext i16 {2,+,(1 + %h)}<%for.body> to i32),+,1}<nsw><%for.body5> slt) (sext i16 %h to i32)
;
entry:
%cmp28 = icmp sgt i16 %N, 1
@@ -599,10 +616,16 @@ define void @nonnegative(ptr nocapture %A, i32 %N) {
; CHECK-LABEL: 'nonnegative'
; CHECK-NEXT: Src: store i32 1, ptr %arrayidx, align 4 --> Dst: store i32 1, ptr %arrayidx, align 4
; CHECK-NEXT: da analyze - output [* *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,1}<nuw><%for.inner> slt) %N
; CHECK-NEXT: Src: store i32 1, ptr %arrayidx, align 4 --> Dst: store i32 2, ptr %arrayidx, align 4
; CHECK-NEXT: da analyze - output [* *|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,1}<nuw><%for.inner> slt) %N
; CHECK-NEXT: Src: store i32 2, ptr %arrayidx, align 4 --> Dst: store i32 2, ptr %arrayidx, align 4
; CHECK-NEXT: da analyze - output [* *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,1}<nuw><%for.inner> slt) %N
;
entry:
%cmp44 = icmp eq i32 %N, 0
@@ -648,12 +671,16 @@ define void @coeff_may_negative(ptr %a, i32 %k) {
; CHECK-NEXT: Src: store i8 42, ptr %idx.0, align 1 --> Dst: store i8 42, ptr %idx.0, align 1
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 0 slt) %k
; CHECK-NEXT: Compare predicate: %k ne) 0
; CHECK-NEXT: Src: store i8 42, ptr %idx.0, align 1 --> Dst: store i8 42, ptr %idx.1, align 1
; CHECK-NEXT: da analyze - output [*|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 0 slt) %k
; CHECK-NEXT: Src: store i8 42, ptr %idx.1, align 1 --> Dst: store i8 42, ptr %idx.1, align 1
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 0 slt) %k
; CHECK-NEXT: Compare predicate: %k ne) 0
;
entry:
@@ -691,12 +718,16 @@ define void @coeff_positive(ptr %a, i32 %k) {
; CHECK-NEXT: Src: store i8 42, ptr %idx.0, align 1 --> Dst: store i8 42, ptr %idx.0, align 1
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 0 slt) %k
; CHECK-NEXT: Compare predicate: %k ne) 0
; CHECK-NEXT: Src: store i8 42, ptr %idx.0, align 1 --> Dst: store i8 42, ptr %idx.1, align 1
; CHECK-NEXT: da analyze - output [*|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 0 slt) %k
; CHECK-NEXT: Src: store i8 42, ptr %idx.1, align 1 --> Dst: store i8 42, ptr %idx.1, align 1
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 0 slt) %k
; CHECK-NEXT: Compare predicate: %k ne) 0
;
entry:
diff --git a/llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll b/llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll
index 3360e603eb406..d89bc4dbedd7f 100644
--- a/llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll
@@ -98,8 +98,14 @@ define void @linearized_accesses(i64 %n, i64 %m, i64 %o, ptr %A) {
; CHECK-LABEL: 'linearized_accesses'
; CHECK-NEXT: Src: store i32 1, ptr %idx0, align 4 --> Dst: store i32 1, ptr %idx0, align 4
; CHECK-NEXT: da analyze - output [* * *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,2}<%for.j> slt) %m
+; CHECK-NEXT: Compare predicate: {0,+,2}<%for.k> slt) %o
; CHECK-NEXT: Src: store i32 1, ptr %idx0, align 4 --> Dst: store i32 1, ptr %idx1, align 4
; CHECK-NEXT: da analyze - output [* * *|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,2}<%for.j> slt) %m
+; CHECK-NEXT: Compare predicate: {0,+,2}<%for.k> slt) %o
; CHECK-NEXT: Src: store i32 1, ptr %idx1, align 4 --> Dst: store i32 1, ptr %idx1, align 4
; CHECK-NEXT: da analyze - output [* * *]!
;
diff --git a/llvm/test/Analysis/DependenceAnalysis/ExactRDIV.ll b/llvm/test/Analysis/DependenceAnalysis/ExactRDIV.ll
index b5ece14121686..759975d62a683 100644
--- a/llvm/test/Analysis/DependenceAnalysis/ExactRDIV.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/ExactRDIV.ll
@@ -498,7 +498,10 @@ for.end8: ; preds = %for.body4
define void @rdiv9(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-LABEL: 'rdiv9'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,-1}<nsw><%for.body3> sge) 0
+; CHECK-NEXT: Compare predicate: {0,+,-1}<nsw><%for.body3> sge) 0
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -554,7 +557,10 @@ for.end7: ; preds = %for.inc5
define void @rdiv10(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-LABEL: 'rdiv10'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,-1}<nsw><%for.body3> sge) 0
+; CHECK-NEXT: Compare predicate: {0,+,-1}<nsw><%for.body3> sge) 0
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -609,7 +615,10 @@ for.end7: ; preds = %for.inc5
define void @rdiv11(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-LABEL: 'rdiv11'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,-1}<nsw><%for.body3> sge) 0
+; CHECK-NEXT: Compare predicate: {0,+,-1}<nsw><%for.body3> sge) 0
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -664,7 +673,10 @@ for.end7: ; preds = %for.inc5
define void @rdiv12(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-LABEL: 'rdiv12'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,-1}<nsw><%for.body3> sge) 0
+; CHECK-NEXT: Compare predicate: {0,+,-1}<nsw><%for.body3> sge) 0
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx4, align 4
; CHECK-NEXT: da analyze - flow [* *|<]!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
diff --git a/llvm/test/Analysis/DependenceAnalysis/GCD.ll b/llvm/test/Analysis/DependenceAnalysis/GCD.ll
index cb14d189afe4c..c884583c56e76 100644
--- a/llvm/test/Analysis/DependenceAnalysis/GCD.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/GCD.ll
@@ -15,13 +15,19 @@ target triple = "x86_64-apple-macosx10.6.0"
define void @gcd0(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-LABEL: 'gcd0'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-NEXT: da analyze - output [* *]!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,2}<nuw><nsw><%for.cond1.preheader> slt) 4
+; CHECK-NEXT: Compare predicate: {0,+,2}<nuw><nsw><%for.cond1.preheader> slt) 4
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx7, align 4
; CHECK-NEXT: da analyze - flow [=> *|<]!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx7, align 4 --> Dst: %0 = load i32, ptr %arrayidx7, align 4
-; CHECK-NEXT: da analyze - input [* *]!
+; CHECK-NEXT: da analyze - consistent input [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,6}<nuw><nsw><%for.cond1.preheader> slt) 8
+; CHECK-NEXT: Compare predicate: {0,+,6}<nuw><nsw><%for.cond1.preheader> slt) 8
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx7, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.11, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -74,13 +80,19 @@ for.end10: ; preds = %for.inc8
define void @gcd1(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-LABEL: 'gcd1'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-NEXT: da analyze - output [* *]!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,2}<nuw><nsw><%for.cond1.preheader> slt) 4
+; CHECK-NEXT: Compare predicate: {0,+,2}<nuw><nsw><%for.cond1.preheader> slt) 4
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx8, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx8, align 4 --> Dst: %0 = load i32, ptr %arrayidx8, align 4
-; CHECK-NEXT: da analyze - input [* *]!
+; CHECK-NEXT: da analyze - consistent input [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {1,+,6}<nuw><nsw><%for.cond1.preheader> slt) 8
+; CHECK-NEXT: Compare predicate: {1,+,6}<nuw><nsw><%for.cond1.preheader> slt) 8
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx8, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.11, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -134,13 +146,19 @@ for.end11: ; preds = %for.inc9
define void @gcd2(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-LABEL: 'gcd2'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-NEXT: da analyze - output [* *]!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {1,+,2}<nuw><nsw><%for.cond1.preheader> slt) 4
+; CHECK-NEXT: Compare predicate: {1,+,2}<nuw><nsw><%for.cond1.preheader> slt) 4
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx8, align 4
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx8, align 4 --> Dst: %0 = load i32, ptr %arrayidx8, align 4
-; CHECK-NEXT: da analyze - input [* *]!
+; CHECK-NEXT: da analyze - consistent input [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,6}<nuw><nsw><%for.cond1.preheader> slt) 8
+; CHECK-NEXT: Compare predicate: {0,+,6}<nuw><nsw><%for.cond1.preheader> slt) 8
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx8, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.11, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -194,13 +212,25 @@ for.end11: ; preds = %for.inc9
define void @gcd3(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-LABEL: 'gcd3'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-NEXT: da analyze - output [* *]!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.cond1.preheader> slt) 2
+; CHECK-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.cond1.preheader> slt) 2
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx6, align 4
-; CHECK-NEXT: da analyze - flow [<> *]!
+; CHECK-NEXT: da analyze - consistent flow [1 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.cond1.preheader> slt) 2
+; CHECK-NEXT: Compare predicate: {-1,+,1}<nsw><%for.cond1.preheader> sge) 0
+; CHECK-NEXT: Compare predicate: {-1,+,1}<nsw><%for.cond1.preheader> slt) 2
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx6, align 4 --> Dst: %0 = load i32, ptr %arrayidx6, align 4
-; CHECK-NEXT: da analyze - input [* *]!
+; CHECK-NEXT: da analyze - consistent input [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {-1,+,1}<nsw><%for.cond1.preheader> sge) 0
+; CHECK-NEXT: Compare predicate: {-1,+,1}<nsw><%for.cond1.preheader> slt) 2
+; CHECK-NEXT: Compare predicate: {-1,+,1}<nsw><%for.cond1.preheader> sge) 0
+; CHECK-NEXT: Compare predicate: {-1,+,1}<nsw><%for.cond1.preheader> slt) 2
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx6, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.11, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -253,12 +283,18 @@ define void @gcd4(ptr %A, ptr %B, i64 %M, i64 %N) nounwind uwtable ssp {
; CHECK-LABEL: 'gcd4'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
; CHECK-NEXT: da analyze - output [* *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,5}<nuw><nsw><%for.cond1.preheader> slt) %M
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx16, align 4
; CHECK-NEXT: da analyze - flow [* *|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,5}<nuw><nsw><%for.cond1.preheader> slt) %M
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx16, align 4 --> Dst: %0 = load i32, ptr %arrayidx16, align 4
; CHECK-NEXT: da analyze - input [* *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {4,+,15}<nw><%for.cond1.preheader> slt) %M
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx16, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.11, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -321,12 +357,18 @@ define void @gcd5(ptr %A, ptr %B, i64 %M, i64 %N) nounwind uwtable ssp {
; CHECK-LABEL: 'gcd5'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
; CHECK-NEXT: da analyze - output [* *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,5}<nuw><nsw><%for.cond1.preheader> slt) %M
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx16, align 4
; CHECK-NEXT: da analyze - flow [* *|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,5}<nuw><nsw><%for.cond1.preheader> slt) %M
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx16, align 4 --> Dst: %0 = load i32, ptr %arrayidx16, align 4
; CHECK-NEXT: da analyze - input [* *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {5,+,15}<nw><%for.cond1.preheader> slt) %M
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx16, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.11, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -389,12 +431,18 @@ define void @gcd6(i64 %n, ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-LABEL: 'gcd6'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx5, align 4 --> Dst: store i32 %conv, ptr %arrayidx5, align 4
; CHECK-NEXT: da analyze - output [* *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,4}<nuw><nsw><%for.body3> slt) %n
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx5, align 4 --> Dst: %2 = load i32, ptr %arrayidx9, align 4
; CHECK-NEXT: da analyze - flow [* *|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,4}<nuw><nsw><%for.body3> slt) %n
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx5, align 4 --> Dst: store i32 %2, ptr %B.addr.12, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %2 = load i32, ptr %arrayidx9, align 4 --> Dst: %2 = load i32, ptr %arrayidx9, align 4
; CHECK-NEXT: da analyze - input [* *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {1,+,6}<nuw><nsw><%for.body3> slt) %n
; CHECK-NEXT: Src: %2 = load i32, ptr %arrayidx9, align 4 --> Dst: store i32 %2, ptr %B.addr.12, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i32 %2, ptr %B.addr.12, align 4 --> Dst: store i32 %2, ptr %B.addr.12, align 4
diff --git a/llvm/test/Analysis/DependenceAnalysis/Invariant.ll b/llvm/test/Analysis/DependenceAnalysis/Invariant.ll
index 5fc9dc3e031ab..b1a53cfe7994f 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Invariant.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Invariant.ll
@@ -2,7 +2,6 @@
; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
; RUN: | FileCheck %s
-; XFAIL: *
; Currently fails since delinearization doesn't work as expected, due to the
; inconsistency in the estimated array sizes between `rr[i][j]` and `rr[j][j]`.
; The latter is now regarded as an access to a 1D array.
@@ -26,7 +25,7 @@ define float @foo(float %g, ptr %rr) nounwind {
; CHECK-NEXT: Src: %0 = load float, ptr %arrayidx4, align 4 --> Dst: %0 = load float, ptr %arrayidx4, align 4
; CHECK-NEXT: da analyze - consistent input [S 0]!
; CHECK-NEXT: Src: %0 = load float, ptr %arrayidx4, align 4 --> Dst: %1 = load float, ptr %arrayidx6, align 4
-; CHECK-NEXT: da analyze - input [* 0|<]!
+; CHECK-NEXT: da analyze - input [* *|<]!
; CHECK-NEXT: Src: %1 = load float, ptr %arrayidx6, align 4 --> Dst: %1 = load float, ptr %arrayidx6, align 4
; CHECK-NEXT: da analyze - none!
;
diff --git a/llvm/test/Analysis/DependenceAnalysis/MismatchingNestLevels.ll b/llvm/test/Analysis/DependenceAnalysis/MismatchingNestLevels.ll
index ed7f087e98b00..a030f1e653e89 100644
--- a/llvm/test/Analysis/DependenceAnalysis/MismatchingNestLevels.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/MismatchingNestLevels.ll
@@ -64,8 +64,12 @@ define dso_local void @test2(i32 noundef zeroext %n, ptr noundef %A, ptr noalias
; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store float 1.230000e+02, ptr %arrayidx7, align 4 --> Dst: store float 1.230000e+02, ptr %arrayidx7, align 4
; CHECK-NEXT: da analyze - output [*]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: (1 + (zext i32 %n to i64))<nuw><nsw> slt) (zext i32 (1 + %n) to i64)
; CHECK-NEXT: Src: store float 1.230000e+02, ptr %arrayidx7, align 4 --> Dst: store float %conv13, ptr %arrayidx17, align 4
; CHECK-NEXT: da analyze - output [*|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: (1 + (zext i32 %n to i64))<nuw><nsw> slt) (zext i32 (1 + %n) to i64)
; CHECK-NEXT: Src: store float %conv13, ptr %arrayidx17, align 4 --> Dst: store float %conv13, ptr %arrayidx17, align 4
; CHECK-NEXT: da analyze - none!
;
diff --git a/llvm/test/Analysis/DependenceAnalysis/NonCanonicalizedSubscript.ll b/llvm/test/Analysis/DependenceAnalysis/NonCanonicalizedSubscript.ll
index 0cee9aa90236a..6176859f0d2ac 100644
--- a/llvm/test/Analysis/DependenceAnalysis/NonCanonicalizedSubscript.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/NonCanonicalizedSubscript.ll
@@ -57,9 +57,12 @@ for.end:
define void @coupled_miv_type_mismatch(i32 %n) {
; CHECK-LABEL: 'coupled_miv_type_mismatch'
; CHECK-NEXT: Src: %2 = load i32, ptr %arrayidx5, align 4 --> Dst: %2 = load i32, ptr %arrayidx5, align 4
-; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: da analyze - consistent input [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {10003,+,1}<nw><%for.cond1> slt) 10005
+; CHECK-NEXT: Compare predicate: {10003,+,1}<nw><%for.cond1> slt) 10005
; CHECK-NEXT: Src: %2 = load i32, ptr %arrayidx5, align 4 --> Dst: store i32 %add6, ptr %arrayidx10, align 4
-; CHECK-NEXT: da analyze - anti [< >]!
+; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %add6, ptr %arrayidx10, align 4 --> Dst: store i32 %add6, ptr %arrayidx10, align 4
; CHECK-NEXT: da analyze - none!
;
diff --git a/llvm/test/Analysis/DependenceAnalysis/Preliminary.ll b/llvm/test/Analysis/DependenceAnalysis/Preliminary.ll
index 8cb0e2ac770dc..664f7f89fd9d1 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Preliminary.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Preliminary.ll
@@ -60,12 +60,21 @@ define void @p2(i64 %n, ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-LABEL: 'p2'
; CHECK-NEXT: Src: store i64 %i.011, ptr %arrayidx8, align 8 --> Dst: store i64 %i.011, ptr %arrayidx8, align 8
; CHECK-NEXT: da analyze - output [* * *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.cond4.preheader> slt) 100
+; CHECK-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.body6> slt) 100
; CHECK-NEXT: Src: store i64 %i.011, ptr %arrayidx8, align 8 --> Dst: %0 = load i64, ptr %arrayidx17, align 8
; CHECK-NEXT: da analyze - flow [* *|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.cond4.preheader> slt) 100
+; CHECK-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.body6> slt) 100
; CHECK-NEXT: Src: store i64 %i.011, ptr %arrayidx8, align 8 --> Dst: store i64 %0, ptr %B.addr.24, align 8
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i64, ptr %arrayidx17, align 8 --> Dst: %0 = load i64, ptr %arrayidx17, align 8
; CHECK-NEXT: da analyze - input [* * *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {2,+,1}<nuw><%for.cond4.preheader> slt) 100
+; CHECK-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.body12> slt) 100
; CHECK-NEXT: Src: %0 = load i64, ptr %arrayidx17, align 8 --> Dst: store i64 %0, ptr %B.addr.24, align 8
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i64 %0, ptr %B.addr.24, align 8 --> Dst: store i64 %0, ptr %B.addr.24, align 8
diff --git a/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll b/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll
index 8cd29e691a7ef..a3b45f5f309fc 100644
--- a/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll
@@ -33,12 +33,21 @@ define void @p2(i64 %n, ptr %A, ptr %B) nounwind uwtable ssp {
; LIN-LABEL: 'p2'
; LIN-NEXT: Src: store i64 %i.011, ptr %arrayidx8, align 8 --> Dst: store i64 %i.011, ptr %arrayidx8, align 8
; LIN-NEXT: da analyze - output [* * *]!
+; LIN-NEXT: Runtime Assumptions:
+; LIN-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.cond4.preheader> slt) 100
+; LIN-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.body6> slt) 100
; LIN-NEXT: Src: store i64 %i.011, ptr %arrayidx8, align 8 --> Dst: %0 = load i64, ptr %arrayidx17, align 8
; LIN-NEXT: da analyze - flow [* *|<]!
+; LIN-NEXT: Runtime Assumptions:
+; LIN-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.cond4.preheader> slt) 100
+; LIN-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.body6> slt) 100
; LIN-NEXT: Src: store i64 %i.011, ptr %arrayidx8, align 8 --> Dst: store i64 %0, ptr %B.addr.24, align 8
; LIN-NEXT: da analyze - confused!
; LIN-NEXT: Src: %0 = load i64, ptr %arrayidx17, align 8 --> Dst: %0 = load i64, ptr %arrayidx17, align 8
; LIN-NEXT: da analyze - input [* * *]!
+; LIN-NEXT: Runtime Assumptions:
+; LIN-NEXT: Compare predicate: {2,+,1}<nuw><%for.cond4.preheader> slt) 100
+; LIN-NEXT: Compare predicate: {1,+,1}<nuw><nsw><%for.body12> slt) 100
; LIN-NEXT: Src: %0 = load i64, ptr %arrayidx17, align 8 --> Dst: store i64 %0, ptr %B.addr.24, align 8
; LIN-NEXT: da analyze - confused!
; LIN-NEXT: Src: store i64 %0, ptr %B.addr.24, align 8 --> Dst: store i64 %0, ptr %B.addr.24, align 8
diff --git a/llvm/test/Analysis/DependenceAnalysis/Propagating.ll b/llvm/test/Analysis/DependenceAnalysis/Propagating.ll
index 17f2de43cc611..e1583ae5e1fbe 100644
--- a/llvm/test/Analysis/DependenceAnalysis/Propagating.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/Propagating.ll
@@ -14,9 +14,12 @@ target triple = "x86_64-apple-macosx10.6.0"
define void @prop0(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'prop0'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx5, align 4 --> Dst: store i32 %conv, ptr %arrayidx5, align 4
-; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {100,+,1}<nuw><nsw><%for.body3> slt) 101
+; CHECK-NEXT: Compare predicate: {100,+,1}<nuw><nsw><%for.body3> slt) 101
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx5, align 4 --> Dst: %0 = load i32, ptr %arrayidx8, align 4
-; CHECK-NEXT: da analyze - flow [< >]!
+; CHECK-NEXT: da analyze - none!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx5, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx8, align 4 --> Dst: %0 = load i32, ptr %arrayidx8, align 4
@@ -147,7 +150,10 @@ define void @prop2(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx4, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx7, align 4 --> Dst: %0 = load i32, ptr %arrayidx7, align 4
-; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: da analyze - consistent input [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {9,+,1}<nuw><nsw><%for.body3> slt) 101
+; CHECK-NEXT: Compare predicate: {9,+,1}<nuw><nsw><%for.body3> slt) 101
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx7, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.11, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -198,13 +204,19 @@ for.end10: ; preds = %for.inc8
define void @prop3(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'prop3'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx4, align 4 --> Dst: store i32 %conv, ptr %arrayidx4, align 4
-; CHECK-NEXT: da analyze - output [* *]!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,2}<nuw><nsw><%for.body3> slt) 101
+; CHECK-NEXT: Compare predicate: {0,+,2}<nuw><nsw><%for.body3> slt) 101
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx4, align 4 --> Dst: %0 = load i32, ptr %arrayidx8, align 4
; CHECK-NEXT: da analyze - flow [<> *]!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx4, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx8, align 4 --> Dst: %0 = load i32, ptr %arrayidx8, align 4
-; CHECK-NEXT: da analyze - input [* *]!
+; CHECK-NEXT: da analyze - consistent input [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {5,+,2}<nuw><nsw><%for.body3> slt) 99
+; CHECK-NEXT: Compare predicate: {5,+,2}<nuw><nsw><%for.body3> slt) 99
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx8, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.11, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -256,9 +268,14 @@ for.end11: ; preds = %for.inc9
define void @prop4(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'prop4'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx6, align 4 --> Dst: store i32 %conv, ptr %arrayidx6, align 4
-; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {99,+,1}<nuw><nsw><%for.body3> slt) 102
+; CHECK-NEXT: Compare predicate: {99,+,1}<nuw><nsw><%for.body3> slt) 102
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx6, align 4 --> Dst: %0 = load i32, ptr %arrayidx10, align 4
-; CHECK-NEXT: da analyze - flow [< <>]!
+; CHECK-NEXT: da analyze - consistent flow [1 99]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {99,+,1}<nuw><nsw><%for.body3> slt) 102
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx6, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx10, align 4 --> Dst: %0 = load i32, ptr %arrayidx10, align 4
@@ -315,7 +332,10 @@ for.end13: ; preds = %for.inc11
define void @prop5(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'prop5'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx7, align 4 --> Dst: store i32 %conv, ptr %arrayidx7, align 4
-; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {-28290,+,1}<nsw><%for.body3> sge) 0
+; CHECK-NEXT: Compare predicate: {-28290,+,1}<nsw><%for.body3> sge) 0
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx7, align 4 --> Dst: %0 = load i32, ptr %arrayidx12, align 4
; CHECK-NEXT: da analyze - flow [* *|<]!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx7, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -375,7 +395,10 @@ for.end15: ; preds = %for.inc13
define void @prop6(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'prop6'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx6, align 4 --> Dst: store i32 %conv, ptr %arrayidx6, align 4
-; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {102,+,1}<nuw><nsw><%for.body3> slt) 104
+; CHECK-NEXT: Compare predicate: {102,+,1}<nuw><nsw><%for.body3> slt) 104
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx6, align 4 --> Dst: %0 = load i32, ptr %arrayidx11, align 4
; CHECK-NEXT: da analyze - flow [=> <>]!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx6, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
@@ -555,7 +578,10 @@ for.end12: ; preds = %for.inc10
define void @prop9(ptr %A, ptr %B, i32 %n) nounwind uwtable ssp {
; CHECK-LABEL: 'prop9'
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx7, align 4 --> Dst: store i32 %conv, ptr %arrayidx7, align 4
-; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: da analyze - consistent output [0 0]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {197,+,1}<nuw><nsw><%for.body3> slt) 205
+; CHECK-NEXT: Compare predicate: {197,+,1}<nuw><nsw><%for.body3> slt) 205
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx7, align 4 --> Dst: %0 = load i32, ptr %arrayidx9, align 4
; CHECK-NEXT: da analyze - flow [<= <]!
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx7, align 4 --> Dst: store i32 %0, ptr %B.addr.11, align 4
diff --git a/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheck.ll b/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheck.ll
index 181a4494b036e..4f541af740ae9 100644
--- a/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheck.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheck.ll
@@ -22,10 +22,16 @@ define void @t1(i32 signext %n, i32 signext %m, ptr %a) {
; LIN-LABEL: 't1'
; LIN-NEXT: Src: %6 = load i32, ptr %arrayidx7, align 4 --> Dst: %6 = load i32, ptr %arrayidx7, align 4
; LIN-NEXT: da analyze - input [* *]!
+; LIN-NEXT: Runtime Assumptions:
+; LIN-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.body4> slt) (zext i32 %m to i64)
; LIN-NEXT: Src: %6 = load i32, ptr %arrayidx7, align 4 --> Dst: store i32 %6, ptr %arrayidx11, align 4
; LIN-NEXT: da analyze - anti [* *|<]!
+; LIN-NEXT: Runtime Assumptions:
+; LIN-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.body4> slt) (zext i32 %m to i64)
; LIN-NEXT: Src: store i32 %6, ptr %arrayidx11, align 4 --> Dst: store i32 %6, ptr %arrayidx11, align 4
; LIN-NEXT: da analyze - output [* *]!
+; LIN-NEXT: Runtime Assumptions:
+; LIN-NEXT: Compare predicate: {2,+,1}<nuw><nsw><%for.body4> slt) (zext i32 %m to i64)
;
entry:
%0 = zext i32 %m to i64
@@ -87,10 +93,22 @@ define void @t2(i32 signext %n, i32 signext %m, ptr %a) {
; LIN-LABEL: 't2'
; LIN-NEXT: Src: %21 = load i32, ptr %arrayidx28, align 4 --> Dst: %21 = load i32, ptr %arrayidx28, align 4
; LIN-NEXT: da analyze - input [* * * * *]!
+; LIN-NEXT: Runtime Assumptions:
+; LIN-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.body4> slt) (zext i32 %n to i64)
+; LIN-NEXT: Compare predicate: {0,+,1}<%for.body12> slt) (zext i32 %n to i64)
+; LIN-NEXT: Compare predicate: {2,+,1}<nuw><nsw><%for.body17> slt) (zext i32 %m to i64)
; LIN-NEXT: Src: %21 = load i32, ptr %arrayidx28, align 4 --> Dst: store i32 %21, ptr %arrayidx38, align 4
; LIN-NEXT: da analyze - anti [* * * * *|<]!
+; LIN-NEXT: Runtime Assumptions:
+; LIN-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.body4> slt) (zext i32 %n to i64)
+; LIN-NEXT: Compare predicate: {0,+,1}<%for.body12> slt) (zext i32 %n to i64)
+; LIN-NEXT: Compare predicate: {2,+,1}<nuw><nsw><%for.body17> slt) (zext i32 %m to i64)
; LIN-NEXT: Src: store i32 %21, ptr %arrayidx38, align 4 --> Dst: store i32 %21, ptr %arrayidx38, align 4
; LIN-NEXT: da analyze - output [* * * * *]!
+; LIN-NEXT: Runtime Assumptions:
+; LIN-NEXT: Compare predicate: {2,+,1}<nuw><nsw><%for.body4> slt) (zext i32 %n to i64)
+; LIN-NEXT: Compare predicate: {3,+,1}<%for.body12> slt) (zext i32 %n to i64)
+; LIN-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%for.body17> slt) (zext i32 %m to i64)
;
entry:
%0 = zext i32 %n to i64
@@ -217,10 +235,19 @@ define void @t3(i64 %n, i64 %m, i64 %lb, ptr %a) {
; LIN-LABEL: 't3'
; LIN-NEXT: Src: %2 = load i32, ptr %arrayidx6, align 4 --> Dst: %2 = load i32, ptr %arrayidx6, align 4
; LIN-NEXT: da analyze - input [* *]!
+; LIN-NEXT: Runtime Assumptions:
+; LIN-NEXT: Compare predicate: {(-2 + %lb),+,1}<%for.body4> sge) 0
+; LIN-NEXT: Compare predicate: {(-2 + %lb),+,1}<%for.body4> slt) %m
; LIN-NEXT: Src: %2 = load i32, ptr %arrayidx6, align 4 --> Dst: store i32 %2, ptr %arrayidx8, align 4
; LIN-NEXT: da analyze - anti [* *|<]!
+; LIN-NEXT: Runtime Assumptions:
+; LIN-NEXT: Compare predicate: {(-2 + %lb),+,1}<%for.body4> sge) 0
+; LIN-NEXT: Compare predicate: {(-2 + %lb),+,1}<%for.body4> slt) %m
; LIN-NEXT: Src: store i32 %2, ptr %arrayidx8, align 4 --> Dst: store i32 %2, ptr %arrayidx8, align 4
; LIN-NEXT: da analyze - output [* *]!
+; LIN-NEXT: Runtime Assumptions:
+; LIN-NEXT: Compare predicate: {%lb,+,1}<%for.body4> sge) 0
+; LIN-NEXT: Compare predicate: {%lb,+,1}<%for.body4> slt) %m
;
entry:
%0 = add i64 %n, -1
diff --git a/llvm/test/Analysis/DependenceAnalysis/StrongSIV.ll b/llvm/test/Analysis/DependenceAnalysis/StrongSIV.ll
index 02fbaf2910c70..ff537a7c34eec 100644
--- a/llvm/test/Analysis/DependenceAnalysis/StrongSIV.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/StrongSIV.ll
@@ -494,16 +494,19 @@ define void @strong10(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 5 slt) %n
; CHECK-NEXT: Compare predicate: (4 * %n) ne) 0
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx3, align 4
; CHECK-NEXT: da analyze - consistent flow [0|<]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 5 slt) %n
; CHECK-NEXT: Compare predicate: (4 * %n) ne) 0
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: %0 = load i32, ptr %arrayidx3, align 4
; CHECK-NEXT: da analyze - consistent input [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 5 slt) %n
; CHECK-NEXT: Compare predicate: (4 * %n) ne) 0
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - confused!
diff --git a/llvm/test/Analysis/DependenceAnalysis/SymbolicSIV.ll b/llvm/test/Analysis/DependenceAnalysis/SymbolicSIV.ll
index a33a10b5e1c2d..01323800dbbd0 100644
--- a/llvm/test/Analysis/DependenceAnalysis/SymbolicSIV.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/SymbolicSIV.ll
@@ -383,14 +383,21 @@ define void @symbolicsiv6(ptr %A, ptr %B, i64 %n, i64 %N, i64 %M) nounwind uwtab
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: %M sge) 0
+; CHECK-NEXT: Compare predicate: %M slt) %N
; CHECK-NEXT: Compare predicate: (16 * %N) ne) 0
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx7, align 4
; CHECK-NEXT: da analyze - flow [*|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: %M sge) 0
+; CHECK-NEXT: Compare predicate: %M slt) %N
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx7, align 4 --> Dst: %0 = load i32, ptr %arrayidx7, align 4
; CHECK-NEXT: da analyze - consistent input [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: (1 + (3 * %M)) sge) 0
+; CHECK-NEXT: Compare predicate: (1 + (3 * %M)) slt) %N
; CHECK-NEXT: Compare predicate: (16 * %N) ne) 0
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx7, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4
; CHECK-NEXT: da analyze - confused!
@@ -443,14 +450,21 @@ define void @symbolicsiv7(ptr %A, ptr %B, i64 %n, i64 %N, i64 %M) nounwind uwtab
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: %M sge) 0
+; CHECK-NEXT: Compare predicate: %M slt) %N
; CHECK-NEXT: Compare predicate: (8 * %N) ne) 0
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %1 = load i32, ptr %arrayidx6, align 4
; CHECK-NEXT: da analyze - flow [*|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: %M sge) 0
+; CHECK-NEXT: Compare predicate: %M slt) %N
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %1, ptr %B.addr.02, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %1 = load i32, ptr %arrayidx6, align 4 --> Dst: %1 = load i32, ptr %arrayidx6, align 4
; CHECK-NEXT: da analyze - consistent input [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: (2 + (-3 * %M)) sge) 0
+; CHECK-NEXT: Compare predicate: (2 + (-3 * %M)) slt) %N
; CHECK-NEXT: Compare predicate: (8 * %N) ne) 0
; CHECK-NEXT: Src: %1 = load i32, ptr %arrayidx6, align 4 --> Dst: store i32 %1, ptr %B.addr.02, align 4
; CHECK-NEXT: da analyze - confused!
diff --git a/llvm/test/Analysis/DependenceAnalysis/WeakCrossingSIV.ll b/llvm/test/Analysis/DependenceAnalysis/WeakCrossingSIV.ll
index c7accfd46a4d7..8dcc72c18c903 100644
--- a/llvm/test/Analysis/DependenceAnalysis/WeakCrossingSIV.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/WeakCrossingSIV.ll
@@ -16,14 +16,18 @@ define void @weakcrossing0(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 1 slt) %n
; CHECK-NEXT: Compare predicate: (4 * %n) ne) 0
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
; CHECK-NEXT: da analyze - flow [0|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 1 slt) %n
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4
; CHECK-NEXT: da analyze - confused!
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
; CHECK-NEXT: da analyze - consistent input [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 1 slt) %n
; CHECK-NEXT: Compare predicate: (-4 * %n) ne) 0
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4
; CHECK-NEXT: da analyze - confused!
diff --git a/llvm/test/Analysis/DependenceAnalysis/WeakZeroDstSIV.ll b/llvm/test/Analysis/DependenceAnalysis/WeakZeroDstSIV.ll
index f8a045c425029..6079da863be3d 100644
--- a/llvm/test/Analysis/DependenceAnalysis/WeakZeroDstSIV.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/WeakZeroDstSIV.ll
@@ -92,6 +92,7 @@ define void @weakzerodst1(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 10 slt) %n
; CHECK-NEXT: Compare predicate: (4 * %n) ne) 0
; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
; CHECK-NEXT: da analyze - flow [p<=|<]!
diff --git a/llvm/test/Analysis/DependenceAnalysis/WeakZeroSrcSIV.ll b/llvm/test/Analysis/DependenceAnalysis/WeakZeroSrcSIV.ll
index 4ed0abd8d98a9..056ae1b43860b 100644
--- a/llvm/test/Analysis/DependenceAnalysis/WeakZeroSrcSIV.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/WeakZeroSrcSIV.ll
@@ -96,6 +96,7 @@ define void @weakzerosrc1(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp {
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
; CHECK-NEXT: da analyze - consistent input [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 10 slt) %n
; CHECK-NEXT: Compare predicate: (4 * %n) ne) 0
; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4
; CHECK-NEXT: da analyze - confused!
diff --git a/llvm/test/Analysis/DependenceAnalysis/becount-couldnotcompute.ll b/llvm/test/Analysis/DependenceAnalysis/becount-couldnotcompute.ll
index 1674badd4d6b9..9751f2821b153 100644
--- a/llvm/test/Analysis/DependenceAnalysis/becount-couldnotcompute.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/becount-couldnotcompute.ll
@@ -9,6 +9,7 @@ define void @test(i64 %conv, ptr %a) {
; CHECK-NEXT: Src: %ld = load i32, ptr %arrayidx12, align 4 --> Dst: %ld = load i32, ptr %arrayidx12, align 4
; CHECK-NEXT: da analyze - consistent input [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%loop> slt) %conv
; CHECK-NEXT: Compare predicate: (4 + (4 * %conv)) ne) 0
;
entry:
diff --git a/llvm/test/Analysis/DependenceAnalysis/compute-absolute-value.ll b/llvm/test/Analysis/DependenceAnalysis/compute-absolute-value.ll
index f3ce956545482..a42f03f5c7caa 100644
--- a/llvm/test/Analysis/DependenceAnalysis/compute-absolute-value.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/compute-absolute-value.ll
@@ -18,12 +18,16 @@ define void @unknown_sign(ptr %a, i64 %k) {
; CHECK-NEXT: Src: store i8 1, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.0, align 1
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 0 slt) %k
; CHECK-NEXT: Compare predicate: (-1 * %k) ne) 0
; CHECK-NEXT: Src: store i8 1, ptr %idx.0, align 1 --> Dst: store i8 2, ptr %idx.1, align 1
; CHECK-NEXT: da analyze - output [*|<]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 0 slt) %k
; CHECK-NEXT: Src: store i8 2, ptr %idx.1, align 1 --> Dst: store i8 2, ptr %idx.1, align 1
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 1 slt) %k
; CHECK-NEXT: Compare predicate: (-1 * %k) ne) 0
;
entry:
diff --git a/llvm/test/Analysis/DependenceAnalysis/gcd-miv-overflow.ll b/llvm/test/Analysis/DependenceAnalysis/gcd-miv-overflow.ll
index ff8f32b9c8276..1c5b6035cd442 100644
--- a/llvm/test/Analysis/DependenceAnalysis/gcd-miv-overflow.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/gcd-miv-overflow.ll
@@ -26,17 +26,24 @@ define void @gcdmiv_coef_ovfl(ptr %A, i64 %m) {
; CHECK-ALL-NEXT: Src: store i8 1, ptr %gep.0, align 1 --> Dst: store i8 1, ptr %gep.0, align 1
; CHECK-ALL-NEXT: da analyze - consistent output [0]!
; CHECK-ALL-NEXT: Runtime Assumptions:
+; CHECK-ALL-NEXT: Compare predicate: 4 slt) %m
; CHECK-ALL-NEXT: Compare predicate: (3 * %m) ne) 0
; CHECK-ALL-NEXT: Src: store i8 1, ptr %gep.0, align 1 --> Dst: store i8 2, ptr %gep.1, align 1
; CHECK-ALL-NEXT: da analyze - output [*|<]!
+; CHECK-ALL-NEXT: Runtime Assumptions:
+; CHECK-ALL-NEXT: Compare predicate: 4 slt) %m
; CHECK-ALL-NEXT: Src: store i8 2, ptr %gep.1, align 1 --> Dst: store i8 2, ptr %gep.1, align 1
; CHECK-ALL-NEXT: da analyze - none!
;
; CHECK-GCD-MIV-LABEL: 'gcdmiv_coef_ovfl'
; CHECK-GCD-MIV-NEXT: Src: store i8 1, ptr %gep.0, align 1 --> Dst: store i8 1, ptr %gep.0, align 1
; CHECK-GCD-MIV-NEXT: da analyze - consistent output [*]!
+; CHECK-GCD-MIV-NEXT: Runtime Assumptions:
+; CHECK-GCD-MIV-NEXT: Compare predicate: 4 slt) %m
; CHECK-GCD-MIV-NEXT: Src: store i8 1, ptr %gep.0, align 1 --> Dst: store i8 2, ptr %gep.1, align 1
; CHECK-GCD-MIV-NEXT: da analyze - consistent output [*|<]!
+; CHECK-GCD-MIV-NEXT: Runtime Assumptions:
+; CHECK-GCD-MIV-NEXT: Compare predicate: 4 slt) %m
; CHECK-GCD-MIV-NEXT: Src: store i8 2, ptr %gep.1, align 1 --> Dst: store i8 2, ptr %gep.1, align 1
; CHECK-GCD-MIV-NEXT: da analyze - consistent output [*]!
;
diff --git a/llvm/test/Analysis/DependenceAnalysis/monotonicity-cast.ll b/llvm/test/Analysis/DependenceAnalysis/monotonicity-cast.ll
index 966e4462fb887..1de70ca3eb634 100644
--- a/llvm/test/Analysis/DependenceAnalysis/monotonicity-cast.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/monotonicity-cast.ll
@@ -16,6 +16,8 @@ define void @sext_nsw(ptr %a, i8 %start, i8 %step) {
; CHECK-NEXT: Src: store i8 0, ptr %idx, align 1 --> Dst: store i8 0, ptr %idx, align 1
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: (sext i8 %start to i64) sge) 0
+; CHECK-NEXT: Compare predicate: (sext i8 %start to i64) slt) (sext i8 %step to i64)
; CHECK-NEXT: Compare predicate: (sext i8 %step to i64) ne) 0
;
entry:
diff --git a/llvm/test/Analysis/DependenceAnalysis/monotonicity-no-wrap-flags.ll b/llvm/test/Analysis/DependenceAnalysis/monotonicity-no-wrap-flags.ll
index df42c757a3b63..a3dfaf92d3033 100644
--- a/llvm/test/Analysis/DependenceAnalysis/monotonicity-no-wrap-flags.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/monotonicity-no-wrap-flags.ll
@@ -264,6 +264,8 @@ define void @nested_loop_step(ptr %a, i64 %n, i64 %m, i64 %step) {
; CHECK-EMPTY:
; CHECK-NEXT: Src: store i8 0, ptr %idx, align 1 --> Dst: store i8 0, ptr %idx, align 1
; CHECK-NEXT: da analyze - output [* *]!
+; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: {0,+,1}<nuw><nsw><%loop.i.header> slt) %step
;
entry:
%guard.i = icmp sgt i64 %n, 0
diff --git a/llvm/test/Analysis/DependenceAnalysis/zero-coefficient.ll b/llvm/test/Analysis/DependenceAnalysis/zero-coefficient.ll
index 55f0ecc123e3a..5d440eb8d704c 100644
--- a/llvm/test/Analysis/DependenceAnalysis/zero-coefficient.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/zero-coefficient.ll
@@ -15,6 +15,7 @@ define void @test_zero_coefficient(ptr noalias %A, i64 %k) {
; CHECK-NEXT: Src: store i8 42, ptr %idx, align 1 --> Dst: store i8 42, ptr %idx, align 1
; CHECK-NEXT: da analyze - consistent output [0]!
; CHECK-NEXT: Runtime Assumptions:
+; CHECK-NEXT: Compare predicate: 0 slt) %k
; CHECK-NEXT: Compare predicate: %k ne) 0
;
entry:
diff --git a/llvm/test/Transforms/LoopInterchange/loop-interchange-optimization-remarks.ll b/llvm/test/Transforms/LoopInterchange/loop-interchange-optimization-remarks.ll
index 14836ba73433d..5ca3879431034 100644
--- a/llvm/test/Transforms/LoopInterchange/loop-interchange-optimization-remarks.ll
+++ b/llvm/test/Transforms/LoopInterchange/loop-interchange-optimization-remarks.ll
@@ -68,10 +68,10 @@ for.end19:
; CHECK: --- !Missed
; CHECK-NEXT: Pass: loop-interchange
-; CHECK-NEXT: Name: Dependence
+; CHECK-NEXT: Name: InterchangeNotProfitable
; CHECK-NEXT: Function: test01
; CHECK-NEXT: Args:
-; CHECK-NEXT: - String: All loops have dependencies in all directions.
+; CHECK-NEXT: - String: Interchanging loops is not considered to improve cache locality nor vectorization.
; CHECK-NEXT: ...
; DELIN: --- !Analysis
@@ -142,12 +142,12 @@ define void @test02(i32 %k, i32 %N) {
; CHECK-NEXT: - String: Computed dependence info, invoking the transform.
; CHECK-NEXT: ...
-; CHECK: --- !Missed
+; CHECK: --- !Passed
; CHECK-NEXT: Pass: loop-interchange
-; CHECK-NEXT: Name: Dependence
+; CHECK-NEXT: Name: Interchanged
; CHECK-NEXT: Function: test02
; CHECK-NEXT: Args:
-; CHECK-NEXT: - String: All loops have dependencies in all directions.
+; CHECK-NEXT: - String: Loop interchanged with enclosing loop.
; CHECK-NEXT: ...
; DELIN: --- !Analysis
@@ -287,10 +287,10 @@ for.end17:
; CHECK: --- !Missed
; CHECK-NEXT: Pass: loop-interchange
-; CHECK-NEXT: Name: Dependence
+; CHECK-NEXT: Name: NotTightlyNested
; CHECK-NEXT: Function: test04
; CHECK-NEXT: Args:
-; CHECK-NEXT: - String: All loops have dependencies in all directions.
+; CHECK-NEXT: - String: Cannot interchange loops because they are not tightly nested.
; CHECK-NEXT: ...
; DELIN: --- !Missed
More information about the llvm-commits
mailing list