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 Sizes, - ArrayRef 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 Sizes, + ArrayRef Subscripts, const Value *Ptr = nullptr, + SmallVectorImpl *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 &Pair); + SmallVectorImpl &Pair, + SmallVectorImpl &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 &SrcSubscripts, - SmallVectorImpl &DstSubscripts); + SmallVectorImpl &DstSubscripts, + SmallVectorImpl &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 &SrcSubscripts, - SmallVectorImpl &DstSubscripts); + SmallVectorImpl &DstSubscripts, + SmallVectorImpl &Assume); /// checkSubscript - Helper function for checkSrcSubscript and /// checkDstSubscript to avoid duplicate code diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h index 9ce23ab344668..a63f623bfe515 100644 --- a/llvm/include/llvm/Analysis/ScalarEvolution.h +++ b/llvm/include/llvm/Analysis/ScalarEvolution.h @@ -544,6 +544,14 @@ class ScalarEvolution { const SCEV *LHS, const SCEV *RHS, const Instruction *CtxI = nullptr); + /// Get the predicate that, if true at runtime, proves that the binary + /// operation \p BinOp between \p LHS and \p RHS does not have + /// signed/unsigned overflow (depending on \p Signed). Returns the + /// predicate, or nullptr if no-overflow is already provable at compile time. + LLVM_ABI const SCEVPredicate * + getNoOverflowPredicate(Instruction::BinaryOps BinOp, bool Signed, + const SCEV *LHS, const SCEV *RHS); + /// Parse NSW/NUW flags from add/sub/mul IR binary operation \p Op into /// SCEV no-wrap flags, and deduce flag[s] that aren't known yet. /// Does not mutate the original instruction. Returns std::nullopt if it could diff --git a/llvm/lib/Analysis/Delinearization.cpp b/llvm/lib/Analysis/Delinearization.cpp index 7bf83ccf9c172..fccc1bbacc265 100644 --- a/llvm/lib/Analysis/Delinearization.cpp +++ b/llvm/lib/Analysis/Delinearization.cpp @@ -753,37 +753,104 @@ static bool isKnownLessThan(ScalarEvolution *SE, const SCEV *S, return SE->isKnownNegative(LimitedBound); } -bool llvm::validateDelinearizationResult(ScalarEvolution &SE, - ArrayRef Sizes, - ArrayRef Subscripts, - const Value *Ptr) { +bool llvm::validateDelinearizationResult( + ScalarEvolution &SE, ArrayRef Sizes, + ArrayRef Subscripts, const Value *Ptr, + SmallVectorImpl *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). - auto AddOverflow = [&](const SCEV *A, const SCEV *B) -> const SCEV * { - if (!SE.willNotOverflow(Instruction::Add, /*IsSigned=*/true, A, B)) - return nullptr; + // Helper to add a predicate only if it's not already in the list. + // SCEV interns predicates, so pointer comparison is sufficient. + auto AddPredicate = [&](const SCEVPredicate *Pred) { + if (!Pred || !Assume) + return; + if (!llvm::is_contained(*Assume, Pred)) + Assume->push_back(Pred); + }; + + // Unify types of two SCEVs to the wider type. + auto UnifyTypes = + [&](const SCEV *&A, + const SCEV *&B) -> std::pair { + Type *WiderType = SE.getWiderType(A->getType(), B->getType()); + return {SE.getNoopOrSignExtend(A, WiderType), + SE.getNoopOrSignExtend(B, WiderType)}; + }; + + // Check if the result of A + B (signed) does not overflow. If it can be + // proven at compile-time, return the result. If it might overflow and Assume + // is provided, add a runtime equality predicate and return the result. + // Otherwise return nullptr. + auto AddNoOverflow = [&](const SCEV *A, const SCEV *B) -> const SCEV * { + std::tie(A, B) = UnifyTypes(A, B); + if (const auto *Pred = SE.getNoOverflowPredicate(Instruction::Add, + /*Signed=*/true, A, B)) { + if (!Assume) + return nullptr; + AddPredicate(Pred); + } return SE.getAddExpr(A, B); }; - auto MulOverflow = [&](const SCEV *A, const SCEV *B) -> const SCEV * { - if (!SE.willNotOverflow(Instruction::Mul, /*IsSigned=*/true, A, B)) - return nullptr; + // Check if the result of A * B (signed) does not overflow. If it can be + // proven at compile-time, return the result. If it might overflow and Assume + // is provided, add a runtime equality predicate and return the result. + // Otherwise return nullptr. + auto MulNoOverflow = [&](const SCEV *A, const SCEV *B) -> const SCEV * { + std::tie(A, B) = UnifyTypes(A, B); + if (const auto *Pred = SE.getNoOverflowPredicate(Instruction::Mul, + /*Signed=*/true, A, B)) { + if (!Assume) + return nullptr; + AddPredicate(Pred); + } return SE.getMulExpr(A, B); }; + // Check if the result of A - B (signed) does not overflow. If it can be + // proven at compile-time or if Assume is provided (adding a runtime + // predicate), return true. Otherwise return false. + auto SubNoOverflow = [&](const SCEV *A, const SCEV *B) -> bool { + std::tie(A, B) = UnifyTypes(A, B); + if (const auto *Pred = SE.getNoOverflowPredicate(Instruction::Sub, + /*Signed=*/true, A, B)) { + if (!Assume) + return false; + AddPredicate(Pred); + } + return true; + }; + // Range check: 0 <= I_k < S_k for k = 2..n. 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())); + AddPredicate(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); + AddPredicate(Pred); + } } // The offset computation is as follows: @@ -811,21 +878,20 @@ bool llvm::validateDelinearizationResult(ScalarEvolution &SE, // NOTE: I_1 can be negative, so Min is not just 0. const SCEV *Prod = SE.getOne(Sizes[0]->getType()); for (const SCEV *Size : Sizes) { - Prod = MulOverflow(Prod, Size); + Prod = MulNoOverflow(Prod, Size); if (!Prod) return false; } - const SCEV *Min = MulOverflow(Prod, Subscripts[0]); + const SCEV *Min = MulNoOverflow(Prod, Subscripts[0]); if (!Min) return false; // We have already checked that Min and Prod don't overflow, so it's enough // to check whether Min + Prod - 1 doesn't overflow. - const SCEV *MaxPlusOne = AddOverflow(Min, Prod); + const SCEV *MaxPlusOne = AddNoOverflow(Min, Prod); if (!MaxPlusOne) return false; - if (!SE.willNotOverflow(Instruction::Sub, /*IsSigned=*/true, MaxPlusOne, - SE.getOne(MaxPlusOne->getType()))) + if (!SubNoOverflow(MaxPlusOne, SE.getOne(MaxPlusOne->getType()))) return false; return true; 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 &Pair) { +bool DependenceInfo::tryDelinearize( + Instruction *Src, Instruction *Dst, SmallVectorImpl &Pair, + SmallVectorImpl &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 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 &SrcSubscripts, - SmallVectorImpl &DstSubscripts) { + SmallVectorImpl &DstSubscripts, + SmallVectorImpl &Assume) { LLVM_DEBUG({ const SCEVUnknown *SrcBase = dyn_cast(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 &SrcSubscripts, - SmallVectorImpl &DstSubscripts) { + SmallVectorImpl &DstSubscripts, + SmallVectorImpl &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/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp index e1f90264be7a2..7f61a1c094dda 100644 --- a/llvm/lib/Analysis/ScalarEvolution.cpp +++ b/llvm/lib/Analysis/ScalarEvolution.cpp @@ -2376,6 +2376,49 @@ bool ScalarEvolution::willNotOverflow(Instruction::BinaryOps BinOp, bool Signed, } } +const SCEVPredicate * +ScalarEvolution::getNoOverflowPredicate(Instruction::BinaryOps BinOp, + bool Signed, const SCEV *LHS, + const SCEV *RHS) { + // First check if no-overflow can be proven at compile time. + if (willNotOverflow(BinOp, Signed, LHS, RHS)) + return nullptr; + + const SCEV *(ScalarEvolution::*Operation)(const SCEV *, const SCEV *, + SCEV::NoWrapFlags, unsigned); + switch (BinOp) { + default: + llvm_unreachable("Unsupported binary op"); + case Instruction::Add: + Operation = &ScalarEvolution::getAddExpr; + break; + case Instruction::Sub: + Operation = &ScalarEvolution::getMinusSCEV; + break; + case Instruction::Mul: + Operation = &ScalarEvolution::getMulExpr; + break; + } + + const SCEV *(ScalarEvolution::*Extension)(const SCEV *, Type *, unsigned) = + Signed ? &ScalarEvolution::getSignExtendExpr + : &ScalarEvolution::getZeroExtendExpr; + + // Build predicate: ext(LHS op RHS) == ext(LHS) op ext(RHS) + auto *NarrowTy = cast(LHS->getType()); + auto *WideTy = + IntegerType::get(NarrowTy->getContext(), NarrowTy->getBitWidth() * 2); + + const SCEV *A = (this->*Extension)( + (this->*Operation)(LHS, RHS, SCEV::FlagAnyWrap, 0), WideTy, 0); + const SCEV *LHSB = (this->*Extension)(LHS, WideTy, 0); + const SCEV *RHSB = (this->*Extension)(RHS, WideTy, 0); + const SCEV *B = (this->*Operation)(LHSB, RHSB, SCEV::FlagAnyWrap, 0); + + // Return the equality predicate. + return getEqualPredicate(A, B); +} + std::optional ScalarEvolution::getStrengthenedNoWrapFlagsFromBinOp( const OverflowingBinaryOperator *OBO) { diff --git a/llvm/test/Analysis/DependenceAnalysis/Banerjee.ll b/llvm/test/Analysis/DependenceAnalysis/Banerjee.ll index 6dde8844c6040..efd6f817ef8a5 100644 --- a/llvm/test/Analysis/DependenceAnalysis/Banerjee.ll +++ b/llvm/test/Analysis/DependenceAnalysis/Banerjee.ll @@ -46,9 +46,13 @@ 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}<%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}<%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 @@ -131,13 +135,29 @@ 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: da analyze - consistent output [0 0]! +; DELIN-NEXT: Runtime Assumptions: +; DELIN-NEXT: Compare predicate: {1,+,1}<%for.body3> slt) 10 +; DELIN-NEXT: Equal predicate: (sext i64 {80,+,80}<%for.cond1.preheader> to i128) == {80,+,80}<%for.cond1.preheader> +; DELIN-NEXT: Equal predicate: (sext i64 {160,+,80}<%for.cond1.preheader> to i128) == (80 + (sext i64 {80,+,80}<%for.cond1.preheader> to i128)) +; DELIN-NEXT: Equal predicate: (15 + (sext i64 {144,+,80}<%for.cond1.preheader> to i128)) == (-1 + (sext i64 {160,+,80}<%for.cond1.preheader> to i128)) ; 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: da analyze - consistent flow [0 1]! +; DELIN-NEXT: Runtime Assumptions: +; DELIN-NEXT: Compare predicate: {1,+,1}<%for.body3> slt) 10 +; DELIN-NEXT: Equal predicate: (sext i64 {80,+,80}<%for.cond1.preheader> to i128) == {80,+,80}<%for.cond1.preheader> +; DELIN-NEXT: Equal predicate: (sext i64 {160,+,80}<%for.cond1.preheader> to i128) == (80 + (sext i64 {80,+,80}<%for.cond1.preheader> to i128)) +; DELIN-NEXT: Equal predicate: (15 + (sext i64 {144,+,80}<%for.cond1.preheader> to i128)) == (-1 + (sext i64 {160,+,80}<%for.cond1.preheader> to i128)) +; DELIN-NEXT: Compare predicate: {0,+,1}<%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: da analyze - consistent input [0 0]! +; DELIN-NEXT: Runtime Assumptions: +; DELIN-NEXT: Compare predicate: {0,+,1}<%for.body3> slt) 10 +; DELIN-NEXT: Equal predicate: (sext i64 {80,+,80}<%for.cond1.preheader> to i128) == {80,+,80}<%for.cond1.preheader> +; DELIN-NEXT: Equal predicate: (sext i64 {160,+,80}<%for.cond1.preheader> to i128) == (80 + (sext i64 {80,+,80}<%for.cond1.preheader> to i128)) +; DELIN-NEXT: Equal predicate: (15 + (sext i64 {144,+,80}<%for.cond1.preheader> to i128)) == (-1 + (sext i64 {160,+,80}<%for.cond1.preheader> to i128)) ; 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 +340,15 @@ 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}<%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}<%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 +514,15 @@ 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}<%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}<%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 +603,15 @@ 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}<%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}<%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 +777,15 @@ 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}<%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}<%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 +864,13 @@ 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}<%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}<%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 +1045,9 @@ 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}<%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 +1129,14 @@ 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}<%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}<%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..b58fa2063fe5c 100644 --- a/llvm/test/Analysis/DependenceAnalysis/Constraints.ll +++ b/llvm/test/Analysis/DependenceAnalysis/Constraints.ll @@ -37,7 +37,9 @@ 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}<%.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 +49,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}<%.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 +80,9 @@ 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}<%.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 +92,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}<%.lr.ph> slt) 11 +; CHECK-NEXT: Compare predicate: {1,+,1}<%.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 +127,9 @@ 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: 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 +139,9 @@ 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}<%.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 +149,9 @@ 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}<%.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..fb6730ef877fd 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++) @@ -13,11 +13,29 @@ target triple = "thumbv8m.main-arm-none-eabi" define void @t1(i32 %n, i32 %m, i32 %o, ptr nocapture %A) { ; CHECK-LABEL: 't1' ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx, align 4 -; CHECK-NEXT: da analyze - input [* * *]! +; CHECK-NEXT: da analyze - consistent input [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: store i32 %add12, ptr %arrayidx, align 4 -; CHECK-NEXT: da analyze - anti [* * *|<]! +; CHECK-NEXT: da analyze - consistent anti [0 0 0|<]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; CHECK-NEXT: Src: store i32 %add12, ptr %arrayidx, align 4 --> Dst: store i32 %add12, ptr %arrayidx, align 4 -; CHECK-NEXT: da analyze - output [* * *]! +; CHECK-NEXT: da analyze - consistent output [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; entry: %cmp49 = icmp sgt i32 %n, 0 @@ -70,6 +88,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++) @@ -78,11 +97,31 @@ for.cond.cleanup: ; preds = %for.cond.cleanup3, define void @t2(i32 %n, i32 %m, i32 %o, ptr nocapture %A) { ; CHECK-LABEL: 't2' ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx, align 4 -; CHECK-NEXT: da analyze - input [* * *]! +; CHECK-NEXT: da analyze - consistent input [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4 -; CHECK-NEXT: da analyze - anti [* * *|<]! +; CHECK-NEXT: da analyze - consistent anti [0 0 -1]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Compare predicate: {1,+,1}<%for.body8> slt) %o ; 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: da analyze - consistent output [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {1,+,1}<%for.body8> slt) %o +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; entry: %cmp49 = icmp sgt i32 %n, 0 @@ -137,6 +176,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++) @@ -145,11 +185,31 @@ for.cond.cleanup: ; preds = %for.cond.cleanup3, define void @t3(i32 %n, i32 %m, i32 %o, ptr nocapture %A) { ; CHECK-LABEL: 't3' ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx, align 4 -; CHECK-NEXT: da analyze - input [* * *]! +; CHECK-NEXT: da analyze - consistent input [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4 -; CHECK-NEXT: da analyze - anti [* * *|<]! +; CHECK-NEXT: da analyze - consistent anti [0 0 1]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Compare predicate: {-1,+,1}<%for.body8> sge) 0 ; 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: da analyze - consistent output [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {-1,+,1}<%for.body8> sge) 0 +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; entry: %cmp49 = icmp sgt i32 %n, 0 @@ -204,6 +264,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++) @@ -212,11 +273,31 @@ for.cond.cleanup: ; preds = %for.cond.cleanup3, define void @t4(i32 %n, i32 %m, i32 %o, ptr nocapture %A) { ; CHECK-LABEL: 't4' ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx, align 4 -; CHECK-NEXT: da analyze - input [* * *]! +; CHECK-NEXT: da analyze - consistent input [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4 -; CHECK-NEXT: da analyze - anti [* * *|<]! +; CHECK-NEXT: da analyze - consistent anti [0 -1 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Compare predicate: {1,+,1}<%for.cond5.preheader> slt) %m ; 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: da analyze - consistent output [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {1,+,1}<%for.cond5.preheader> slt) %m +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; entry: %cmp49 = icmp sgt i32 %n, 0 @@ -279,11 +360,33 @@ for.cond.cleanup: ; preds = %for.cond.cleanup3, define void @t5(i32 %n, i32 %m, i32 %o, ptr nocapture %A) { ; CHECK-LABEL: 't5' ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx, align 4 -; CHECK-NEXT: da analyze - input [* * *]! +; CHECK-NEXT: da analyze - consistent input [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4 -; CHECK-NEXT: da analyze - anti [* * *|<]! +; CHECK-NEXT: da analyze - consistent anti [0 1 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Compare predicate: {-1,+,1}<%for.cond5.preheader> sge) 0 +; CHECK-NEXT: Compare predicate: {-1,+,1}<%for.cond5.preheader> slt) %m ; 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: da analyze - consistent output [0 0 0]! +; 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 +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; entry: %cmp49 = icmp sgt i32 %n, 0 @@ -346,11 +449,32 @@ for.cond.cleanup: ; preds = %for.cond.cleanup3, define void @t6(i32 %n, i32 %m, i32 %o, ptr nocapture %A) { ; CHECK-LABEL: 't6' ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx, align 4 -; CHECK-NEXT: da analyze - input [* * *]! +; CHECK-NEXT: da analyze - consistent input [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4 -; CHECK-NEXT: da analyze - anti [* * *|<]! +; CHECK-NEXT: da analyze - consistent anti [-1 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {(sext i32 (4 * %m * %o) to i64),+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(8 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (8 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(8 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; 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: da analyze - consistent output [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {(sext i32 (4 * %m * %o) to i64),+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(8 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (8 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(8 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; entry: %cmp49 = icmp sgt i32 %n, 0 @@ -414,11 +538,32 @@ for.cond.cleanup: ; preds = %for.cond.cleanup3, define void @t7(i32 %n, i32 %m, i32 %o, ptr nocapture %A) { ; CHECK-LABEL: 't7' ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx, align 4 -; CHECK-NEXT: da analyze - input [* * *]! +; CHECK-NEXT: da analyze - consistent input [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4 -; CHECK-NEXT: da analyze - anti [* * *|<]! +; CHECK-NEXT: da analyze - consistent anti [1 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {(-1 * (sext i32 (4 * %m * %o) to i64)),+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {(-4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (3 + (sext i32 {-4,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) == (-1 + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; 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: da analyze - consistent output [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {(-1 * (sext i32 (4 * %m * %o) to i64)),+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {(-4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (3 + (sext i32 {-4,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) == (-1 + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; entry: %cmp49 = icmp sgt i32 %n, 0 @@ -482,11 +627,29 @@ for.cond.cleanup: ; preds = %for.cond.cleanup3, define void @t8(i32 %n, i32 %m, i32 %o, ptr nocapture %A) { ; CHECK-LABEL: 't8' ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx, align 4 -; CHECK-NEXT: da analyze - input [* * *]! +; CHECK-NEXT: da analyze - consistent input [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx, align 4 --> Dst: store i32 %add12, ptr %arrayidx2, align 4 -; CHECK-NEXT: da analyze - anti [* * *|<]! +; CHECK-NEXT: da analyze - consistent anti [0 0 1]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; 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: da analyze - consistent output [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i32 (%m * %o) to i64) == ((sext i32 %m to i64) * (sext i32 %o to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %m * %o) to i64) == (4 * (sext i32 (%m * %o) to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == {0,+,(sext i32 (4 * %m * %o) to i64)}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == ((sext i32 (4 * %m * %o) to i64) + (sext i32 {0,+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.cond1.preheader> to i64) == (-1 + (sext i32 {(4 * %m * %o),+,(4 * %m * %o)}<%for.cond1.preheader> to i64)) ; entry: %cmp49 = icmp sgt i32 %n, 0 @@ -548,8 +711,17 @@ 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}<%for.body> slt) (sext i16 %h to i32) +; CHECK-NEXT: Equal predicate: (sext i32 (2 * (sext i16 %h to i32)) to i64) == (2 * (sext i16 %h to i64)) +; CHECK-NEXT: Compare predicate: {(sext i16 {2,+,(1 + %h)}<%for.body> to i32),+,1}<%for.body5> sge) 0 +; CHECK-NEXT: Compare predicate: {(sext i16 {2,+,(1 + %h)}<%for.body> to i32),+,1}<%for.body5> 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}<%for.body5> sge) 0 +; CHECK-NEXT: Compare predicate: {(sext i16 {2,+,(1 + %h)}<%for.body> to i32),+,1}<%for.body5> slt) (sext i16 %h to i32) +; CHECK-NEXT: Equal predicate: (sext i32 (2 * (sext i16 %h to i32)) to i64) == (2 * (sext i16 %h to i64)) ; entry: %cmp28 = icmp sgt i16 %N, 1 @@ -598,11 +770,29 @@ for.end12: ; preds = %for.inc10, %entry 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: da analyze - consistent output [0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {0,+,1}<%for.inner> slt) %N +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %N) to i64) == (4 * (sext i32 %N to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %N)}<%for.outer> to i64) == ((sext i32 (4 * %N) to i64) * (sext i32 {0,+,1}<%for.outer> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %N),+,(4 * %N)}<%for.outer> to i64) == ((sext i32 (4 * %N) to i64) + (sext i32 {0,+,(4 * %N)}<%for.outer> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %N)),+,(4 * %N)}<%for.outer> to i64) == (-1 + (sext i32 {(4 * %N),+,(4 * %N)}<%for.outer> to i64)) ; 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: da analyze - consistent output [0 0|<]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {0,+,1}<%for.inner> slt) %N +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %N) to i64) == (4 * (sext i32 %N to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %N)}<%for.outer> to i64) == ((sext i32 (4 * %N) to i64) * (sext i32 {0,+,1}<%for.outer> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %N),+,(4 * %N)}<%for.outer> to i64) == ((sext i32 (4 * %N) to i64) + (sext i32 {0,+,(4 * %N)}<%for.outer> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %N)),+,(4 * %N)}<%for.outer> to i64) == (-1 + (sext i32 {(4 * %N),+,(4 * %N)}<%for.outer> to i64)) ; 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: da analyze - consistent output [0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {0,+,1}<%for.inner> slt) %N +; CHECK-NEXT: Equal predicate: (sext i32 (4 * %N) to i64) == (4 * (sext i32 %N to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,(4 * %N)}<%for.outer> to i64) == ((sext i32 (4 * %N) to i64) * (sext i32 {0,+,1}<%for.outer> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(4 * %N),+,(4 * %N)}<%for.outer> to i64) == ((sext i32 (4 * %N) to i64) + (sext i32 {0,+,(4 * %N)}<%for.outer> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (4 * %N)),+,(4 * %N)}<%for.outer> to i64) == (-1 + (sext i32 {(4 * %N),+,(4 * %N)}<%for.outer> to i64)) ; entry: %cmp44 = icmp eq i32 %N, 0 @@ -648,13 +838,27 @@ 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: %k ne) 0 +; CHECK-NEXT: Compare predicate: 0 slt) %k +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,%k}<%loop> to i64) == ((sext i32 {0,+,1}<%loop> to i64) * (sext i32 %k to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {%k,+,%k}<%loop> to i64) == ((sext i32 {0,+,%k}<%loop> to i64) + (sext i32 %k to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + %k),+,%k}<%loop> to i64) == (-1 + (sext i32 {%k,+,%k}<%loop> to i64)) ; 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: da analyze - consistent output [-1]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: 0 slt) %k +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,%k}<%loop> to i64) == ((sext i32 {0,+,1}<%loop> to i64) * (sext i32 %k to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {%k,+,%k}<%loop> to i64) == ((sext i32 {0,+,%k}<%loop> to i64) + (sext i32 %k to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + %k),+,%k}<%loop> to i64) == (-1 + (sext i32 {%k,+,%k}<%loop> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {%k,+,%k}<%loop> to i64) == ((sext i32 {1,+,1}<%loop> to i64) * (sext i32 %k to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(2 * %k),+,%k}<%loop> to i64) == ((sext i32 {%k,+,%k}<%loop> to i64) + (sext i32 %k to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (2 * %k)),+,%k}<%loop> to i64) == (-1 + (sext i32 {(2 * %k),+,%k}<%loop> to i64)) ; 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: %k ne) 0 +; CHECK-NEXT: Compare predicate: 0 slt) %k +; CHECK-NEXT: Equal predicate: (sext i32 {%k,+,%k}<%loop> to i64) == ((sext i32 {1,+,1}<%loop> to i64) * (sext i32 %k to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(2 * %k),+,%k}<%loop> to i64) == ((sext i32 {%k,+,%k}<%loop> to i64) + (sext i32 %k to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (2 * %k)),+,%k}<%loop> to i64) == (-1 + (sext i32 {(2 * %k),+,%k}<%loop> to i64)) ; entry: br label %loop @@ -691,13 +895,27 @@ 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: %k ne) 0 +; CHECK-NEXT: Compare predicate: 0 slt) %k +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,%k}<%loop> to i64) == {0,+,(sext i32 %k to i64)}<%loop> +; CHECK-NEXT: Equal predicate: (sext i32 {%k,+,%k}<%loop> to i64) == ((sext i32 {0,+,%k}<%loop> to i64) + (sext i32 %k to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + %k),+,%k}<%loop> to i64) == (-1 + (sext i32 {%k,+,%k}<%loop> to i64)) ; 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: da analyze - consistent output [-1]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: 0 slt) %k +; CHECK-NEXT: Equal predicate: (sext i32 {0,+,%k}<%loop> to i64) == {0,+,(sext i32 %k to i64)}<%loop> +; CHECK-NEXT: Equal predicate: (sext i32 {%k,+,%k}<%loop> to i64) == ((sext i32 {0,+,%k}<%loop> to i64) + (sext i32 %k to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + %k),+,%k}<%loop> to i64) == (-1 + (sext i32 {%k,+,%k}<%loop> to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {%k,+,%k}<%loop> to i64) == {(sext i32 %k to i64),+,(sext i32 %k to i64)}<%loop> +; CHECK-NEXT: Equal predicate: (sext i32 {(2 * %k),+,%k}<%loop> to i64) == ((sext i32 {%k,+,%k}<%loop> to i64) + (sext i32 %k to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (2 * %k)),+,%k}<%loop> to i64) == (-1 + (sext i32 {(2 * %k),+,%k}<%loop> to i64)) ; 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: %k ne) 0 +; CHECK-NEXT: Compare predicate: 0 slt) %k +; CHECK-NEXT: Equal predicate: (sext i32 {%k,+,%k}<%loop> to i64) == {(sext i32 %k to i64),+,(sext i32 %k to i64)}<%loop> +; CHECK-NEXT: Equal predicate: (sext i32 {(2 * %k),+,%k}<%loop> to i64) == ((sext i32 {%k,+,%k}<%loop> to i64) + (sext i32 %k to i64)) +; CHECK-NEXT: Equal predicate: (sext i32 {(-1 + (2 * %k)),+,%k}<%loop> to i64) == (-1 + (sext i32 {(2 * %k),+,%k}<%loop> to i64)) ; entry: br label %loop diff --git a/llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll b/llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll index 3360e603eb406..fe133144c7485 100644 --- a/llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll +++ b/llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll @@ -97,11 +97,36 @@ entry: 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: da analyze - consistent output [0 0 0]! +; 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: Equal predicate: (sext i64 (%m * %o) to i128) == ((sext i64 %m to i128) * (sext i64 %o to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %m * %o) to i128) == (4 * (sext i64 (%m * %o) to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(8 * %m * %o)}<%for.i> to i128) == ((sext i64 (4 * %m * %o) to i128) * (sext i64 {0,+,2}<%for.i> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %m * %o),+,(8 * %m * %o)}<%for.i> to i128) == ((sext i64 (4 * %m * %o) to i128) + (sext i64 {0,+,(8 * %m * %o)}<%for.i> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %m * %o)),+,(8 * %m * %o)}<%for.i> to i128) == (-1 + (sext i64 {(4 * %m * %o),+,(8 * %m * %o)}<%for.i> to i128)) ; 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: Equal predicate: (sext i64 (%m * %o) to i128) == ((sext i64 %m to i128) * (sext i64 %o to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %m * %o) to i128) == (4 * (sext i64 (%m * %o) to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(8 * %m * %o)}<%for.i> to i128) == ((sext i64 (4 * %m * %o) to i128) * (sext i64 {0,+,2}<%for.i> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %m * %o),+,(8 * %m * %o)}<%for.i> to i128) == ((sext i64 (4 * %m * %o) to i128) + (sext i64 {0,+,(8 * %m * %o)}<%for.i> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %m * %o)),+,(8 * %m * %o)}<%for.i> to i128) == (-1 + (sext i64 {(4 * %m * %o),+,(8 * %m * %o)}<%for.i> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * %m * %o)}<%for.i> to i128) == {0,+,(sext i64 (4 * %m * %o) to i128)}<%for.i> +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %m * %o),+,(4 * %m * %o)}<%for.i> to i128) == ((sext i64 (4 * %m * %o) to i128) + (sext i64 {0,+,(4 * %m * %o)}<%for.i> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.i> to i128) == (-1 + (sext i64 {(4 * %m * %o),+,(4 * %m * %o)}<%for.i> to i128)) ; CHECK-NEXT: Src: store i32 1, ptr %idx1, align 4 --> Dst: store i32 1, ptr %idx1, align 4 -; CHECK-NEXT: da analyze - output [* * *]! +; CHECK-NEXT: da analyze - consistent output [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 (%m * %o) to i128) == ((sext i64 %m to i128) * (sext i64 %o to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %m * %o) to i128) == (4 * (sext i64 (%m * %o) to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * %m * %o)}<%for.i> to i128) == {0,+,(sext i64 (4 * %m * %o) to i128)}<%for.i> +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %m * %o),+,(4 * %m * %o)}<%for.i> to i128) == ((sext i64 (4 * %m * %o) to i128) + (sext i64 {0,+,(4 * %m * %o)}<%for.i> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %m * %o)),+,(4 * %m * %o)}<%for.i> to i128) == (-1 + (sext i64 {(4 * %m * %o),+,(4 * %m * %o)}<%for.i> to i128)) ; entry: br label %for.i diff --git a/llvm/test/Analysis/DependenceAnalysis/ExactRDIV.ll b/llvm/test/Analysis/DependenceAnalysis/ExactRDIV.ll index b5ece14121686..349c81d32cccf 100644 --- a/llvm/test/Analysis/DependenceAnalysis/ExactRDIV.ll +++ b/llvm/test/Analysis/DependenceAnalysis/ExactRDIV.ll @@ -498,7 +498,9 @@ 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}<%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 +556,9 @@ 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}<%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 +613,9 @@ 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}<%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 +670,9 @@ 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}<%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..002df734a7039 100644 --- a/llvm/test/Analysis/DependenceAnalysis/GCD.ll +++ b/llvm/test/Analysis/DependenceAnalysis/GCD.ll @@ -15,13 +15,17 @@ 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}<%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}<%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 +78,17 @@ 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}<%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}<%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 +142,17 @@ 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}<%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}<%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 +206,22 @@ 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}<%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}<%for.cond1.preheader> slt) 2 +; CHECK-NEXT: Compare predicate: {-1,+,1}<%for.cond1.preheader> sge) 0 +; CHECK-NEXT: Compare predicate: {-1,+,1}<%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}<%for.cond1.preheader> sge) 0 +; CHECK-NEXT: Compare predicate: {-1,+,1}<%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 @@ -252,13 +273,25 @@ for.end9: ; preds = %for.inc7 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: da analyze - consistent output [0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {0,+,5}<%for.cond1.preheader> slt) %M +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %M) to i128) == (4 * (sext i64 %M to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(36 * %M * %N),+,(40 * %M)}<%for.body3> to i128) == ((sext i64 (4 * %M) to i128) * (sext i64 {(9 * %N),+,10}<%for.body3> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {((4 + (36 * %N)) * %M),+,(40 * %M)}<%for.body3> to i128) == ((sext i64 (4 * %M) to i128) + (sext i64 {(36 * %M * %N),+,(40 * %M)}<%for.body3> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + ((4 + (36 * %N)) * %M)),+,(40 * %M)}<%for.body3> to i128) == (-1 + (sext i64 {((4 + (36 * %N)) * %M),+,(40 * %M)}<%for.body3> to i128)) ; 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: 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 %arrayidx16, align 4 --> Dst: %0 = load i32, ptr %arrayidx16, align 4 -; CHECK-NEXT: da analyze - input [* *]! +; CHECK-NEXT: da analyze - consistent input [0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {4,+,15}<%for.cond1.preheader> slt) %M +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %M) to i128) == (4 * (sext i64 %M to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-84 * %M * %N),+,(80 * %M)}<%for.body3> to i128) == ((sext i64 (4 * %M) to i128) * (sext i64 {(-21 * %N),+,20}<%for.body3> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {((4 + (-84 * %N)) * %M),+,(80 * %M)}<%for.body3> to i128) == ((sext i64 (4 * %M) to i128) + (sext i64 {(-84 * %M * %N),+,(80 * %M)}<%for.body3> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + ((4 + (-84 * %N)) * %M)),+,(80 * %M)}<%for.body3> to i128) == (-1 + (sext i64 {((4 + (-84 * %N)) * %M),+,(80 * %M)}<%for.body3> to i128)) ; 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 @@ -320,13 +353,35 @@ for.end19: ; preds = %for.inc17 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: da analyze - consistent output [0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {0,+,5}<%for.cond1.preheader> slt) %M +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %M) to i128) == (4 * (sext i64 %M to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(36 * %M * %N),+,(40 * %M)}<%for.body3> to i128) == ((sext i64 (4 * %M) to i128) * (sext i64 {(9 * %N),+,10}<%for.body3> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {((4 + (36 * %N)) * %M),+,(40 * %M)}<%for.body3> to i128) == ((sext i64 (4 * %M) to i128) + (sext i64 {(36 * %M * %N),+,(40 * %M)}<%for.body3> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + ((4 + (36 * %N)) * %M)),+,(40 * %M)}<%for.body3> to i128) == (-1 + (sext i64 {((4 + (36 * %N)) * %M),+,(40 * %M)}<%for.body3> to i128)) ; 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: da analyze - flow [> *]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {0,+,5}<%for.cond1.preheader> slt) %M +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %M) to i128) == (4 * (sext i64 %M to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(36 * %M * %N),+,(40 * %M)}<%for.body3> to i128) == ((sext i64 (4 * %M) to i128) * (sext i64 {(9 * %N),+,10}<%for.body3> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {((4 + (36 * %N)) * %M),+,(40 * %M)}<%for.body3> to i128) == ((sext i64 (4 * %M) to i128) + (sext i64 {(36 * %M * %N),+,(40 * %M)}<%for.body3> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + ((4 + (36 * %N)) * %M)),+,(40 * %M)}<%for.body3> to i128) == (-1 + (sext i64 {((4 + (36 * %N)) * %M),+,(40 * %M)}<%for.body3> to i128)) +; CHECK-NEXT: Compare predicate: {5,+,15}<%for.cond1.preheader> slt) %M +; CHECK-NEXT: Equal predicate: (sext i64 {(-84 * %M * %N),+,(80 * %M)}<%for.body3> to i128) == ((sext i64 (4 * %M) to i128) * (sext i64 {(-21 * %N),+,20}<%for.body3> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {((4 + (-84 * %N)) * %M),+,(80 * %M)}<%for.body3> to i128) == ((sext i64 (4 * %M) to i128) + (sext i64 {(-84 * %M * %N),+,(80 * %M)}<%for.body3> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + ((4 + (-84 * %N)) * %M)),+,(80 * %M)}<%for.body3> to i128) == (-1 + (sext i64 {((4 + (-84 * %N)) * %M),+,(80 * %M)}<%for.body3> to i128)) ; 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: da analyze - consistent input [0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {5,+,15}<%for.cond1.preheader> slt) %M +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %M) to i128) == (4 * (sext i64 %M to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-84 * %M * %N),+,(80 * %M)}<%for.body3> to i128) == ((sext i64 (4 * %M) to i128) * (sext i64 {(-21 * %N),+,20}<%for.body3> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {((4 + (-84 * %N)) * %M),+,(80 * %M)}<%for.body3> to i128) == ((sext i64 (4 * %M) to i128) + (sext i64 {(-84 * %M * %N),+,(80 * %M)}<%for.body3> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + ((4 + (-84 * %N)) * %M)),+,(80 * %M)}<%for.body3> to i128) == (-1 + (sext i64 {((4 + (-84 * %N)) * %M),+,(80 * %M)}<%for.body3> to i128)) ; 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 @@ -388,13 +443,25 @@ for.end19: ; preds = %for.inc17 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: da analyze - consistent output [0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {0,+,4}<%for.body3> slt) %n +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %n) to i128) == (4 * (sext i64 %n to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(8 * %n)}<%for.cond1.preheader> to i128) == ((sext i64 (4 * %n) to i128) * (sext i64 {0,+,2}<%for.cond1.preheader> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %n),+,(8 * %n)}<%for.cond1.preheader> to i128) == ((sext i64 (4 * %n) to i128) + (sext i64 {0,+,(8 * %n)}<%for.cond1.preheader> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %n)),+,(8 * %n)}<%for.cond1.preheader> to i128) == (-1 + (sext i64 {(4 * %n),+,(8 * %n)}<%for.cond1.preheader> to i128)) ; 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: da analyze - none! ; 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: da analyze - consistent input [0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {1,+,6}<%for.body3> slt) %n +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %n) to i128) == (4 * (sext i64 %n to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(32 * %n)}<%for.cond1.preheader> to i128) == ((sext i64 (4 * %n) to i128) * (sext i64 {0,+,8}<%for.cond1.preheader> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %n),+,(32 * %n)}<%for.cond1.preheader> to i128) == ((sext i64 (4 * %n) to i128) + (sext i64 {0,+,(32 * %n)}<%for.cond1.preheader> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %n)),+,(32 * %n)}<%for.cond1.preheader> to i128) == (-1 + (sext i64 {(4 * %n),+,(32 * %n)}<%for.cond1.preheader> to i128)) ; 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" -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..7f78f1ef65872 100644 --- a/llvm/test/Analysis/DependenceAnalysis/MismatchingNestLevels.ll +++ b/llvm/test/Analysis/DependenceAnalysis/MismatchingNestLevels.ll @@ -12,11 +12,23 @@ define void @test1(i64 noundef %n, ptr nocapture noundef writeonly %A) { ; CHECK-LABEL: 'test1' ; CHECK-NEXT: Src: store double %conv, ptr %arrayidx, align 8 --> Dst: store double %conv, ptr %arrayidx, align 8 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {8,+,8}<%for.body> to i128) == {8,+,8}<%for.body> +; CHECK-NEXT: Equal predicate: {7,+,8}<%for.body> == (-1 + (sext i64 {8,+,8}<%for.body> to i128)) ; CHECK-NEXT: Src: store double %conv, ptr %arrayidx, align 8 --> Dst: store double %conv2, ptr %arrayidx3, align 8 ; CHECK-NEXT: da analyze - output [|<]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {8,+,8}<%for.body> to i128) == {8,+,8}<%for.body> +; CHECK-NEXT: Equal predicate: {7,+,8}<%for.body> == (-1 + (sext i64 {8,+,8}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {16,+,8}<%for.body> to i128) == (8 + (sext i64 {8,+,8}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (7 + (sext i64 {8,+,8}<%for.body> to i128)) == (-1 + (sext i64 {16,+,8}<%for.body> to i128)) ; CHECK-NEXT: Src: store double %conv2, ptr %arrayidx3, align 8 --> Dst: store double %conv2, ptr %arrayidx3, align 8 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - output []! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {8,+,8}<%for.body> to i128) == {8,+,8}<%for.body> +; CHECK-NEXT: Equal predicate: (sext i64 {16,+,8}<%for.body> to i128) == (8 + (sext i64 {8,+,8}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (7 + (sext i64 {8,+,8}<%for.body> to i128)) == (-1 + (sext i64 {16,+,8}<%for.body> to i128)) ; entry: %mul1 = mul nsw i64 %n, %n @@ -63,11 +75,25 @@ define dso_local void @test2(i32 noundef zeroext %n, ptr noundef %A, ptr noalias ; CHECK-NEXT: Src: store i32 %conv5, ptr %arrayidx, align 4 --> Dst: store float %conv13, ptr %arrayidx17, align 4 ; 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: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: (1 + (zext i32 %n to i64)) slt) (zext i32 (1 + %n) to i64) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128) == {0,+,(4 * (zext i32 (1 + %n) to i128))}<%for.i> +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * (zext i32 (1 + %n) to i64)),+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128) == ((sext i64 {0,+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128) + (4 * (zext i32 (1 + %n) to i128))) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * (zext i32 (1 + %n) to i64))),+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128) == (-1 + (sext i64 {(4 * (zext i32 (1 + %n) to i64)),+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128)) ; 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: da analyze - output [0|<]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: (1 + (zext i32 %n to i64)) slt) (zext i32 (1 + %n) to i64) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128) == {0,+,(4 * (zext i32 (1 + %n) to i128))}<%for.i> +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * (zext i32 (1 + %n) to i64)),+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128) == ((sext i64 {0,+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128) + (4 * (zext i32 (1 + %n) to i128))) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * (zext i32 (1 + %n) to i64))),+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128) == (-1 + (sext i64 {(4 * (zext i32 (1 + %n) to i64)),+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128)) ; CHECK-NEXT: Src: store float %conv13, ptr %arrayidx17, align 4 --> Dst: store float %conv13, ptr %arrayidx17, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128) == {0,+,(4 * (zext i32 (1 + %n) to i128))}<%for.i> +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * (zext i32 (1 + %n) to i64)),+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128) == ((sext i64 {0,+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128) + (4 * (zext i32 (1 + %n) to i128))) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * (zext i32 (1 + %n) to i64))),+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128) == (-1 + (sext i64 {(4 * (zext i32 (1 + %n) to i64)),+,(4 * (zext i32 (1 + %n) to i64))}<%for.i> to i128)) ; entry: %add = add i32 %n, 1 @@ -139,8 +165,16 @@ define void @test3(i32 noundef %n, ptr noalias noundef %A, ptr noalias noundef % ; CHECK-LABEL: 'test3' ; CHECK-NEXT: Src: store double 0.000000e+00, ptr %arrayidx, align 8 --> Dst: store double 0.000000e+00, ptr %arrayidx, align 8 ; CHECK-NEXT: da analyze - output [* S]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,8}<%for.s> to i128) == {0,+,8}<%for.s> +; CHECK-NEXT: Equal predicate: (sext i64 {8,+,8}<%for.s> to i128) == (8 + (sext i64 {0,+,8}<%for.s> to i128)) +; CHECK-NEXT: Equal predicate: (7 + (sext i64 {0,+,8}<%for.s> to i128)) == (-1 + (sext i64 {8,+,8}<%for.s> to i128)) ; CHECK-NEXT: Src: store double 0.000000e+00, ptr %arrayidx, align 8 --> Dst: store double 1.000000e+00, ptr %arrayidx21, align 8 ; CHECK-NEXT: da analyze - output [*|<]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,8}<%for.s> to i128) == {0,+,8}<%for.s> +; CHECK-NEXT: Equal predicate: (sext i64 {8,+,8}<%for.s> to i128) == (8 + (sext i64 {0,+,8}<%for.s> to i128)) +; CHECK-NEXT: Equal predicate: (7 + (sext i64 {0,+,8}<%for.s> to i128)) == (-1 + (sext i64 {8,+,8}<%for.s> to i128)) ; CHECK-NEXT: Src: store double 1.000000e+00, ptr %arrayidx21, align 8 --> Dst: store double 1.000000e+00, ptr %arrayidx21, align 8 ; CHECK-NEXT: da analyze - none! ; diff --git a/llvm/test/Analysis/DependenceAnalysis/NonCanonicalizedSubscript.ll b/llvm/test/Analysis/DependenceAnalysis/NonCanonicalizedSubscript.ll index 0cee9aa90236a..50bc7118fc49d 100644 --- a/llvm/test/Analysis/DependenceAnalysis/NonCanonicalizedSubscript.ll +++ b/llvm/test/Analysis/DependenceAnalysis/NonCanonicalizedSubscript.ll @@ -57,9 +57,11 @@ 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}<%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..348e442563fa1 100644 --- a/llvm/test/Analysis/DependenceAnalysis/Preliminary.ll +++ b/llvm/test/Analysis/DependenceAnalysis/Preliminary.ll @@ -59,13 +59,34 @@ entry: 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: da analyze - consistent output [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {0,+,1}<%for.cond4.preheader> slt) 100 +; CHECK-NEXT: Compare predicate: {0,+,1}<%for.body6> slt) 100 +; CHECK-NEXT: Equal predicate: (sext i64 {80000,+,80000}<%for.cond1.preheader> to i128) == {80000,+,80000}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (127 + (sext i64 {79872,+,80000}<%for.cond1.preheader> to i128)) == (-1 + (sext i64 {80000,+,80000}<%for.cond1.preheader> to i128)) ; 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: da analyze - flow [-3 -2] / assuming 1 loop level(s) fused: [-3 -2 -1]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {0,+,1}<%for.cond4.preheader> slt) 100 +; CHECK-NEXT: Compare predicate: {0,+,1}<%for.body6> slt) 100 +; CHECK-NEXT: Equal predicate: (sext i64 {80000,+,80000}<%for.cond1.preheader> to i128) == {80000,+,80000}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (127 + (sext i64 {79872,+,80000}<%for.cond1.preheader> to i128)) == (-1 + (sext i64 {80000,+,80000}<%for.cond1.preheader> to i128)) +; CHECK-NEXT: Compare predicate: {2,+,1}<%for.cond4.preheader> slt) 100 +; CHECK-NEXT: Compare predicate: {1,+,1}<%for.body12> slt) 100 +; CHECK-NEXT: Equal predicate: (sext i64 {240000,+,80000}<%for.cond1.preheader> to i128) == (80000 * (sext i64 {3,+,1}<%for.cond1.preheader> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {320000,+,80000}<%for.cond1.preheader> to i128) == (80000 + (sext i64 {240000,+,80000}<%for.cond1.preheader> to i128)) +; CHECK-NEXT: Equal predicate: (127 + (sext i64 {319872,+,80000}<%for.cond1.preheader> to i128)) == (-1 + (sext i64 {320000,+,80000}<%for.cond1.preheader> to i128)) ; 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: da analyze - consistent input [0 0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {2,+,1}<%for.cond4.preheader> slt) 100 +; CHECK-NEXT: Compare predicate: {1,+,1}<%for.body12> slt) 100 +; CHECK-NEXT: Equal predicate: (sext i64 {240000,+,80000}<%for.cond1.preheader> to i128) == (80000 * (sext i64 {3,+,1}<%for.cond1.preheader> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {320000,+,80000}<%for.cond1.preheader> to i128) == (80000 + (sext i64 {240000,+,80000}<%for.cond1.preheader> to i128)) +; CHECK-NEXT: Equal predicate: (127 + (sext i64 {319872,+,80000}<%for.cond1.preheader> to i128)) == (-1 + (sext i64 {320000,+,80000}<%for.cond1.preheader> to i128)) ; 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 @@ -448,7 +469,11 @@ define void @p4(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx5, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp sgt i64 %n, 0 @@ -501,7 +526,11 @@ define void @p5(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx5, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp sgt i64 %n, 0 @@ -544,17 +573,31 @@ for.end: ; preds = %for.end.loopexit, % define void @p6(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-LABEL: 'p6' ; CHECK-NEXT: Src: store i32 %1, ptr %arrayidx, align 4 --> Dst: store i32 %1, ptr %arrayidx, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {12,+,4}<%for.body> to i128) == {12,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: {11,+,4}<%for.body> == (-1 + (sext i64 {12,+,4}<%for.body> to i128)) ; CHECK-NEXT: Src: store i32 %1, ptr %arrayidx, align 4 --> Dst: %2 = load i32, ptr %arrayidx3, align 4 ; CHECK-NEXT: da analyze - consistent flow [2]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {12,+,4}<%for.body> to i128) == {12,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: {11,+,4}<%for.body> == (-1 + (sext i64 {12,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == {4,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: {3,+,4}<%for.body> == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; CHECK-NEXT: Src: store i32 %1, ptr %arrayidx, align 4 --> Dst: store i32 %2, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: %2 = load i32, ptr %arrayidx3, align 4 --> Dst: %2 = load i32, ptr %arrayidx3, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent input [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == {4,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: {3,+,4}<%for.body> == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; CHECK-NEXT: Src: %2 = load i32, ptr %arrayidx3, align 4 --> Dst: store i32 %2, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %2, ptr %B.addr.02, align 4 --> Dst: store i32 %2, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == {4,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: {3,+,4}<%for.body> == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp sgt i64 %n, 0 @@ -727,11 +770,26 @@ entry: define void @foo(ptr %s, i32 %size) nounwind uwtable ssp { ; CHECK-LABEL: 'foo' ; CHECK-NEXT: Src: %1 = load i32, ptr %0, align 4 --> Dst: %1 = load i32, ptr %0, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent input [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%while.body> to i128) == {4,+,4}<%while.body> +; CHECK-NEXT: Equal predicate: (sext i64 {8,+,4}<%while.body> to i128) == (4 + (sext i64 {4,+,4}<%while.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {4,+,4}<%while.body> to i128)) == (-1 + (sext i64 {8,+,4}<%while.body> to i128)) ; CHECK-NEXT: Src: %1 = load i32, ptr %0, align 4 --> Dst: store i32 %1, ptr %i.02, align 4 ; CHECK-NEXT: da analyze - consistent anti [1]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%while.body> to i128) == {4,+,4}<%while.body> +; CHECK-NEXT: Equal predicate: (sext i64 {8,+,4}<%while.body> to i128) == (4 + (sext i64 {4,+,4}<%while.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {4,+,4}<%while.body> to i128)) == (-1 + (sext i64 {8,+,4}<%while.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%while.body> to i128) == {0,+,4}<%while.body> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%while.body> to i128) == (4 + (sext i64 {0,+,4}<%while.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%while.body> to i128)) == (-1 + (sext i64 {4,+,4}<%while.body> to i128)) ; CHECK-NEXT: Src: store i32 %1, ptr %i.02, align 4 --> Dst: store i32 %1, ptr %i.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%while.body> to i128) == {0,+,4}<%while.body> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%while.body> to i128) == (4 + (sext i64 {0,+,4}<%while.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%while.body> to i128)) == (-1 + (sext i64 {4,+,4}<%while.body> to i128)) ; entry: %idx.ext = zext i32 %size to i64 diff --git a/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll b/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll index 8cd29e691a7ef..4fd5500f6ade5 100644 --- a/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll +++ b/llvm/test/Analysis/DependenceAnalysis/PreliminaryNoValidityCheckFixedSize.ll @@ -32,13 +32,34 @@ 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: da analyze - consistent output [0 0 0]! +; LIN-NEXT: Runtime Assumptions: +; LIN-NEXT: Compare predicate: {0,+,1}<%for.cond4.preheader> slt) 100 +; LIN-NEXT: Compare predicate: {0,+,1}<%for.body6> slt) 100 +; LIN-NEXT: Equal predicate: (sext i64 {80000,+,80000}<%for.cond1.preheader> to i128) == {80000,+,80000}<%for.cond1.preheader> +; LIN-NEXT: Equal predicate: (127 + (sext i64 {79872,+,80000}<%for.cond1.preheader> to i128)) == (-1 + (sext i64 {80000,+,80000}<%for.cond1.preheader> to i128)) ; 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: da analyze - flow [-3 -2] / assuming 1 loop level(s) fused: [-3 -2 -1]! +; LIN-NEXT: Runtime Assumptions: +; LIN-NEXT: Compare predicate: {0,+,1}<%for.cond4.preheader> slt) 100 +; LIN-NEXT: Compare predicate: {0,+,1}<%for.body6> slt) 100 +; LIN-NEXT: Equal predicate: (sext i64 {80000,+,80000}<%for.cond1.preheader> to i128) == {80000,+,80000}<%for.cond1.preheader> +; LIN-NEXT: Equal predicate: (127 + (sext i64 {79872,+,80000}<%for.cond1.preheader> to i128)) == (-1 + (sext i64 {80000,+,80000}<%for.cond1.preheader> to i128)) +; LIN-NEXT: Compare predicate: {2,+,1}<%for.cond4.preheader> slt) 100 +; LIN-NEXT: Compare predicate: {1,+,1}<%for.body12> slt) 100 +; LIN-NEXT: Equal predicate: (sext i64 {240000,+,80000}<%for.cond1.preheader> to i128) == (80000 * (sext i64 {3,+,1}<%for.cond1.preheader> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {320000,+,80000}<%for.cond1.preheader> to i128) == (80000 + (sext i64 {240000,+,80000}<%for.cond1.preheader> to i128)) +; LIN-NEXT: Equal predicate: (127 + (sext i64 {319872,+,80000}<%for.cond1.preheader> to i128)) == (-1 + (sext i64 {320000,+,80000}<%for.cond1.preheader> to i128)) ; 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: da analyze - consistent input [0 0 0]! +; LIN-NEXT: Runtime Assumptions: +; LIN-NEXT: Compare predicate: {2,+,1}<%for.cond4.preheader> slt) 100 +; LIN-NEXT: Compare predicate: {1,+,1}<%for.body12> slt) 100 +; LIN-NEXT: Equal predicate: (sext i64 {240000,+,80000}<%for.cond1.preheader> to i128) == (80000 * (sext i64 {3,+,1}<%for.cond1.preheader> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {320000,+,80000}<%for.cond1.preheader> to i128) == (80000 + (sext i64 {240000,+,80000}<%for.cond1.preheader> to i128)) +; LIN-NEXT: Equal predicate: (127 + (sext i64 {319872,+,80000}<%for.cond1.preheader> to i128)) == (-1 + (sext i64 {320000,+,80000}<%for.cond1.preheader> to i128)) ; 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..17e71554b422b 100644 --- a/llvm/test/Analysis/DependenceAnalysis/Propagating.ll +++ b/llvm/test/Analysis/DependenceAnalysis/Propagating.ll @@ -14,9 +14,11 @@ 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}<%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 +149,9 @@ 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}<%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 +202,17 @@ 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}<%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}<%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 +264,13 @@ 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}<%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}<%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 +327,9 @@ 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}<%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 +389,9 @@ 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}<%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 +571,9 @@ 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}<%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..a700e431afaef 100644 --- a/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheck.ll +++ b/llvm/test/Analysis/DependenceAnalysis/SimpleSIVNoValidityCheck.ll @@ -21,11 +21,30 @@ 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: da analyze - consistent input [0 0]! +; LIN-NEXT: Runtime Assumptions: +; LIN-NEXT: Compare predicate: {0,+,1}<%for.body4> slt) (zext i32 %m to i64) +; LIN-NEXT: Equal predicate: (sext i64 {(4 * (zext i32 %m to i64)),+,(4 * (zext i32 %m to i64))}<%for.body> to i128) == {(4 * (zext i32 %m to i128)),+,(4 * (zext i32 %m to i128))}<%for.body> +; LIN-NEXT: Equal predicate: (sext i64 {(8 * (zext i32 %m to i64)),+,(4 * (zext i32 %m to i64))}<%for.body> to i128) == ((sext i64 {(4 * (zext i32 %m to i64)),+,(4 * (zext i32 %m to i64))}<%for.body> to i128) + (4 * (zext i32 %m to i128))) +; LIN-NEXT: Equal predicate: (sext i64 {(-1 + (8 * (zext i32 %m to i64))),+,(4 * (zext i32 %m to i64))}<%for.body> to i128) == (-1 + (sext i64 {(8 * (zext i32 %m to i64)),+,(4 * (zext i32 %m to i64))}<%for.body> to i128)) ; 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: da analyze - consistent anti [1 -2]! +; LIN-NEXT: Runtime Assumptions: +; LIN-NEXT: Compare predicate: {0,+,1}<%for.body4> slt) (zext i32 %m to i64) +; LIN-NEXT: Equal predicate: (sext i64 {(4 * (zext i32 %m to i64)),+,(4 * (zext i32 %m to i64))}<%for.body> to i128) == {(4 * (zext i32 %m to i128)),+,(4 * (zext i32 %m to i128))}<%for.body> +; LIN-NEXT: Equal predicate: (sext i64 {(8 * (zext i32 %m to i64)),+,(4 * (zext i32 %m to i64))}<%for.body> to i128) == ((sext i64 {(4 * (zext i32 %m to i64)),+,(4 * (zext i32 %m to i64))}<%for.body> to i128) + (4 * (zext i32 %m to i128))) +; LIN-NEXT: Equal predicate: (sext i64 {(-1 + (8 * (zext i32 %m to i64))),+,(4 * (zext i32 %m to i64))}<%for.body> to i128) == (-1 + (sext i64 {(8 * (zext i32 %m to i64)),+,(4 * (zext i32 %m to i64))}<%for.body> to i128)) +; LIN-NEXT: Compare predicate: {2,+,1}<%for.body4> slt) (zext i32 %m to i64) +; LIN-NEXT: Equal predicate: (sext i64 {0,+,(4 * (zext i32 %m to i64))}<%for.body> to i128) == {0,+,(4 * (zext i32 %m to i128))}<%for.body> +; LIN-NEXT: Equal predicate: (sext i64 {(4 * (zext i32 %m to i64)),+,(4 * (zext i32 %m to i64))}<%for.body> to i128) == ((sext i64 {0,+,(4 * (zext i32 %m to i64))}<%for.body> to i128) + (4 * (zext i32 %m to i128))) +; LIN-NEXT: Equal predicate: (sext i64 {(-1 + (4 * (zext i32 %m to i64))),+,(4 * (zext i32 %m to i64))}<%for.body> to i128) == (-1 + (sext i64 {(4 * (zext i32 %m to i64)),+,(4 * (zext i32 %m to i64))}<%for.body> to i128)) ; 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: da analyze - consistent output [0 0]! +; LIN-NEXT: Runtime Assumptions: +; LIN-NEXT: Compare predicate: {2,+,1}<%for.body4> slt) (zext i32 %m to i64) +; LIN-NEXT: Equal predicate: (sext i64 {0,+,(4 * (zext i32 %m to i64))}<%for.body> to i128) == {0,+,(4 * (zext i32 %m to i128))}<%for.body> +; LIN-NEXT: Equal predicate: (sext i64 {(4 * (zext i32 %m to i64)),+,(4 * (zext i32 %m to i64))}<%for.body> to i128) == ((sext i64 {0,+,(4 * (zext i32 %m to i64))}<%for.body> to i128) + (4 * (zext i32 %m to i128))) +; LIN-NEXT: Equal predicate: (sext i64 {(-1 + (4 * (zext i32 %m to i64))),+,(4 * (zext i32 %m to i64))}<%for.body> to i128) == (-1 + (sext i64 {(4 * (zext i32 %m to i64)),+,(4 * (zext i32 %m to i64))}<%for.body> to i128)) ; entry: %0 = zext i32 %m to i64 @@ -86,11 +105,50 @@ 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: da analyze - consistent input [0 0 0 0 0]! +; LIN-NEXT: Runtime Assumptions: +; LIN-NEXT: Compare predicate: {0,+,1}<%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}<%for.body17> slt) (zext i32 %m to i64) +; LIN-NEXT: Equal predicate: (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64)) to i128) == ((zext i32 %n to i128) * (zext i32 %n to i128)) +; LIN-NEXT: Equal predicate: (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64)) to i128) == ((zext i32 %n to i128) * (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64)) to i128)) +; LIN-NEXT: Equal predicate: (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128) == ((zext i32 %m to i128) * (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64)) to i128)) +; LIN-NEXT: Equal predicate: (sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128) == (4 * (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128) == {(sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128),+,(sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128)}<%for.body> +; LIN-NEXT: Equal predicate: (sext i64 {(8 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128) == ((sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128) + (sext i64 {(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(-1 + (8 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128) == (-1 + (sext i64 {(8 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128)) ; 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: da analyze - consistent anti [1 -2 0 -3 2]! +; LIN-NEXT: Runtime Assumptions: +; LIN-NEXT: Compare predicate: {0,+,1}<%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}<%for.body17> slt) (zext i32 %m to i64) +; LIN-NEXT: Equal predicate: (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64)) to i128) == ((zext i32 %n to i128) * (zext i32 %n to i128)) +; LIN-NEXT: Equal predicate: (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64)) to i128) == ((zext i32 %n to i128) * (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64)) to i128)) +; LIN-NEXT: Equal predicate: (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128) == ((zext i32 %m to i128) * (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64)) to i128)) +; LIN-NEXT: Equal predicate: (sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128) == (4 * (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128) == {(sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128),+,(sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128)}<%for.body> +; LIN-NEXT: Equal predicate: (sext i64 {(8 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128) == ((sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128) + (sext i64 {(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(-1 + (8 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128) == (-1 + (sext i64 {(8 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128)) +; LIN-NEXT: Compare predicate: {2,+,1}<%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}<%for.body17> slt) (zext i32 %m to i64) +; LIN-NEXT: Equal predicate: (sext i64 {0,+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128) == {0,+,(sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128)}<%for.body> +; LIN-NEXT: Equal predicate: (sext i64 {(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128) == ((sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128) + (sext i64 {0,+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(-1 + (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128) == (-1 + (sext i64 {(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128)) ; 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: da analyze - consistent output [0 0 0 0 0]! +; LIN-NEXT: Runtime Assumptions: +; LIN-NEXT: Compare predicate: {2,+,1}<%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}<%for.body17> slt) (zext i32 %m to i64) +; LIN-NEXT: Equal predicate: (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64)) to i128) == ((zext i32 %n to i128) * (zext i32 %n to i128)) +; LIN-NEXT: Equal predicate: (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64)) to i128) == ((zext i32 %n to i128) * (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64)) to i128)) +; LIN-NEXT: Equal predicate: (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128) == ((zext i32 %m to i128) * (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64)) to i128)) +; LIN-NEXT: Equal predicate: (sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128) == (4 * (sext i64 ((zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {0,+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128) == {0,+,(sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128)}<%for.body> +; LIN-NEXT: Equal predicate: (sext i64 {(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128) == ((sext i64 (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)) to i128) + (sext i64 {0,+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(-1 + (4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128) == (-1 + (sext i64 {(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64)),+,(4 * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %n to i64) * (zext i32 %m to i64))}<%for.body> to i128)) ; entry: %0 = zext i32 %n to i64 @@ -216,11 +274,37 @@ 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: da analyze - consistent input [0 0]! +; 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: Equal predicate: (sext i64 (4 * %m) to i128) == (4 * (sext i64 %m to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(4 * %m),+,(4 * %m)}<%for.body> to i128) == ((sext i64 (4 * %m) to i128) * (sext i64 {1,+,1}<%for.body> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(8 * %m),+,(4 * %m)}<%for.body> to i128) == ((sext i64 (4 * %m) to i128) + (sext i64 {(4 * %m),+,(4 * %m)}<%for.body> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(-1 + (8 * %m)),+,(4 * %m)}<%for.body> to i128) == (-1 + (sext i64 {(8 * %m),+,(4 * %m)}<%for.body> to i128)) ; 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: da analyze - anti [1 *]! +; 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: Equal predicate: (sext i64 (4 * %m) to i128) == (4 * (sext i64 %m to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(4 * %m),+,(4 * %m)}<%for.body> to i128) == ((sext i64 (4 * %m) to i128) * (sext i64 {1,+,1}<%for.body> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(8 * %m),+,(4 * %m)}<%for.body> to i128) == ((sext i64 (4 * %m) to i128) + (sext i64 {(4 * %m),+,(4 * %m)}<%for.body> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(-1 + (8 * %m)),+,(4 * %m)}<%for.body> to i128) == (-1 + (sext i64 {(8 * %m),+,(4 * %m)}<%for.body> to i128)) +; LIN-NEXT: Compare predicate: {%lb,+,1}<%for.body4> sge) 0 +; LIN-NEXT: Compare predicate: {%lb,+,1}<%for.body4> slt) %m +; LIN-NEXT: Equal predicate: (sext i64 {0,+,(4 * %m)}<%for.body> to i128) == ((sext i64 (4 * %m) to i128) * (sext i64 {0,+,1}<%for.body> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(4 * %m),+,(4 * %m)}<%for.body> to i128) == ((sext i64 (4 * %m) to i128) + (sext i64 {0,+,(4 * %m)}<%for.body> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %m)),+,(4 * %m)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %m),+,(4 * %m)}<%for.body> to i128)) ; 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: da analyze - consistent output [0 0]! +; LIN-NEXT: Runtime Assumptions: +; LIN-NEXT: Compare predicate: {%lb,+,1}<%for.body4> sge) 0 +; LIN-NEXT: Compare predicate: {%lb,+,1}<%for.body4> slt) %m +; LIN-NEXT: Equal predicate: (sext i64 (4 * %m) to i128) == (4 * (sext i64 %m to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {0,+,(4 * %m)}<%for.body> to i128) == ((sext i64 (4 * %m) to i128) * (sext i64 {0,+,1}<%for.body> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(4 * %m),+,(4 * %m)}<%for.body> to i128) == ((sext i64 (4 * %m) to i128) + (sext i64 {0,+,(4 * %m)}<%for.body> to i128)) +; LIN-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %m)),+,(4 * %m)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %m),+,(4 * %m)}<%for.body> to i128)) ; entry: %0 = add i64 %n, -1 diff --git a/llvm/test/Analysis/DependenceAnalysis/StrongSIV.ll b/llvm/test/Analysis/DependenceAnalysis/StrongSIV.ll index 02fbaf2910c70..70cf546525a02 100644 --- a/llvm/test/Analysis/DependenceAnalysis/StrongSIV.ll +++ b/llvm/test/Analysis/DependenceAnalysis/StrongSIV.ll @@ -15,17 +15,31 @@ target triple = "x86_64-apple-macosx10.6.0" define void @strong0(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-LABEL: 'strong0' ; CHECK-NEXT: Src: store i32 %1, ptr %arrayidx, align 4 --> Dst: store i32 %1, ptr %arrayidx, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {12,+,4}<%for.body> to i128) == {12,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: {11,+,4}<%for.body> == (-1 + (sext i64 {12,+,4}<%for.body> to i128)) ; CHECK-NEXT: Src: store i32 %1, ptr %arrayidx, align 4 --> Dst: %2 = load i32, ptr %arrayidx3, align 4 ; CHECK-NEXT: da analyze - consistent flow [2]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {12,+,4}<%for.body> to i128) == {12,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: {11,+,4}<%for.body> == (-1 + (sext i64 {12,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == {4,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: {3,+,4}<%for.body> == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; CHECK-NEXT: Src: store i32 %1, ptr %arrayidx, align 4 --> Dst: store i32 %2, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: %2 = load i32, ptr %arrayidx3, align 4 --> Dst: %2 = load i32, ptr %arrayidx3, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent input [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == {4,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: {3,+,4}<%for.body> == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; CHECK-NEXT: Src: %2 = load i32, ptr %arrayidx3, align 4 --> Dst: store i32 %2, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %2, ptr %B.addr.02, align 4 --> Dst: store i32 %2, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == {4,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: {3,+,4}<%for.body> == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp sgt i64 %n, 0 @@ -114,17 +128,36 @@ for.end: ; preds = %for.end.loopexit, % define void @strong2(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-LABEL: 'strong2' ; 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]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {8,+,4}<%for.body> to i128) == (4 * (sext i64 {2,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {12,+,4}<%for.body> to i128) == (4 + (sext i64 {8,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {8,+,4}<%for.body> to i128)) == (-1 + (sext i64 {12,+,4}<%for.body> to i128)) ; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4 ; CHECK-NEXT: da analyze - consistent flow [2]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {8,+,4}<%for.body> to i128) == (4 * (sext i64 {2,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {12,+,4}<%for.body> to i128) == (4 + (sext i64 {8,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {8,+,4}<%for.body> to i128)) == (-1 + (sext i64 {12,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; 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 %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent input [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -437,7 +470,11 @@ define void @strong9(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-ALL-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-ALL-NEXT: da analyze - confused! ; CHECK-ALL-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-ALL-NEXT: da analyze - none! +; CHECK-ALL-NEXT: da analyze - consistent output [0]! +; CHECK-ALL-NEXT: Runtime Assumptions: +; CHECK-ALL-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-ALL-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-ALL-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; ; CHECK-STRONG-SIV-LABEL: 'strong9' ; CHECK-STRONG-SIV-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4 @@ -451,7 +488,11 @@ define void @strong9(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-STRONG-SIV-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-STRONG-SIV-NEXT: da analyze - confused! ; CHECK-STRONG-SIV-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-STRONG-SIV-NEXT: da analyze - none! +; CHECK-STRONG-SIV-NEXT: da analyze - consistent output [0]! +; CHECK-STRONG-SIV-NEXT: Runtime Assumptions: +; CHECK-STRONG-SIV-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-STRONG-SIV-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-STRONG-SIV-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -494,17 +535,29 @@ 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: (4 * %n) ne) 0 +; CHECK-NEXT: Compare predicate: 5 slt) %n +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %n) to i128) == (4 * (sext i64 %n to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * %n)}<%for.body> to i128) == {0,+,(sext i64 (4 * %n) to i128)}<%for.body> +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) + (sext i64 {0,+,(4 * %n)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %n)),+,(4 * %n)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128)) ; 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: (4 * %n) ne) 0 +; CHECK-NEXT: Compare predicate: 5 slt) %n +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %n) to i128) == (4 * (sext i64 %n to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * %n)}<%for.body> to i128) == {0,+,(sext i64 (4 * %n) to i128)}<%for.body> +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) + (sext i64 {0,+,(4 * %n)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %n)),+,(4 * %n)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128)) ; 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: (4 * %n) ne) 0 +; CHECK-NEXT: Compare predicate: 5 slt) %n +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %n) to i128) == (4 * (sext i64 %n to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * %n)}<%for.body> to i128) == {0,+,(sext i64 (4 * %n) to i128)}<%for.body> +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) + (sext i64 {0,+,(4 * %n)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %n)),+,(4 * %n)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128)) ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4 @@ -542,13 +595,13 @@ for.end: ; preds = %for.body ;; A[i] = 0; define void @strong11(ptr %A) nounwind uwtable ssp { -; CHECK-ALL-LABEL: 'strong11' -; CHECK-ALL-NEXT: Src: store i32 0, ptr %arrayidx, align 4 --> Dst: store i32 0, ptr %arrayidx, align 4 -; CHECK-ALL-NEXT: da analyze - none! -; -; CHECK-STRONG-SIV-LABEL: 'strong11' -; CHECK-STRONG-SIV-NEXT: Src: store i32 0, ptr %arrayidx, align 4 --> Dst: store i32 0, ptr %arrayidx, align 4 -; CHECK-STRONG-SIV-NEXT: da analyze - consistent output [0 S]! +; CHECK-LABEL: 'strong11' +; CHECK-NEXT: Src: store i32 0, ptr %arrayidx, align 4 --> Dst: store i32 0, ptr %arrayidx, align 4 +; CHECK-NEXT: da analyze - consistent output [0 S]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.cond1.preheader> to i128) == {0,+,4}<%for.cond1.preheader> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.cond1.preheader> to i128) == (4 + (sext i64 {0,+,4}<%for.cond1.preheader> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.cond1.preheader> to i128)) == (-1 + (sext i64 {4,+,4}<%for.cond1.preheader> to i128)) ; entry: br label %for.cond1.preheader diff --git a/llvm/test/Analysis/DependenceAnalysis/SymbolicRDIV.ll b/llvm/test/Analysis/DependenceAnalysis/SymbolicRDIV.ll index 8b9aa257a7c57..58f007848c4b4 100644 --- a/llvm/test/Analysis/DependenceAnalysis/SymbolicRDIV.ll +++ b/llvm/test/Analysis/DependenceAnalysis/SymbolicRDIV.ll @@ -25,7 +25,11 @@ define void @symbolicrdiv0(ptr %A, ptr %B, i64 %n1, i64 %n2) nounwind uwtable ss ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx8, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body4> to i128) == {0,+,4}<%for.body4> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body4> to i128) == (4 + (sext i64 {0,+,4}<%for.body4> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body4> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body4> to i128)) ; entry: %cmp4 = icmp eq i64 %n1, 0 @@ -94,7 +98,11 @@ define void @symbolicrdiv1(ptr %A, ptr %B, i64 %n1, i64 %n2) nounwind uwtable ss ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx9, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body5> to i128) == {0,+,4}<%for.body5> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body5> to i128) == (4 + (sext i64 {0,+,4}<%for.body5> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body5> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body5> to i128)) ; entry: %cmp4 = icmp eq i64 %n1, 0 @@ -165,7 +173,11 @@ define void @symbolicrdiv2(ptr %A, ptr %B, i64 %n1, i64 %n2) nounwind uwtable ss ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body4> to i128) == {0,+,4}<%for.body4> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body4> to i128) == (4 + (sext i64 {0,+,4}<%for.body4> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body4> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body4> to i128)) ; entry: %cmp4 = icmp eq i64 %n1, 0 @@ -234,7 +246,11 @@ define void @symbolicrdiv3(ptr %A, ptr %B, i64 %n1, i64 %n2) nounwind uwtable ss ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx6, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body4> to i128) == {0,+,4}<%for.body4> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body4> to i128) == (4 + (sext i64 {0,+,4}<%for.body4> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body4> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body4> to i128)) ; entry: %cmp4 = icmp eq i64 %n1, 0 @@ -301,7 +317,11 @@ define void @symbolicrdiv4(ptr %A, ptr %B, i64 %n1, i64 %n2) nounwind uwtable ss ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body4> to i128) == {0,+,4}<%for.body4> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body4> to i128) == (4 + (sext i64 {0,+,4}<%for.body4> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body4> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body4> to i128)) ; entry: %cmp4 = icmp eq i64 %n1, 0 @@ -369,7 +389,11 @@ define void @symbolicrdiv5(ptr %A, ptr %B, i64 %n1, i64 %n2) nounwind uwtable ss ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body4> to i128) == {0,+,4}<%for.body4> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body4> to i128) == (4 + (sext i64 {0,+,4}<%for.body4> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body4> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body4> to i128)) ; entry: %cmp4 = icmp eq i64 %n1, 0 diff --git a/llvm/test/Analysis/DependenceAnalysis/SymbolicSIV.ll b/llvm/test/Analysis/DependenceAnalysis/SymbolicSIV.ll index a33a10b5e1c2d..119e249e0953b 100644 --- a/llvm/test/Analysis/DependenceAnalysis/SymbolicSIV.ll +++ b/llvm/test/Analysis/DependenceAnalysis/SymbolicSIV.ll @@ -23,7 +23,11 @@ define void @symbolicsiv0(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == {0,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -75,7 +79,11 @@ define void @symbolicsiv1(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx5, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == {0,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -129,7 +137,11 @@ define void @symbolicsiv2(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == {0,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -181,7 +193,11 @@ define void @symbolicsiv3(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == {0,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -234,7 +250,11 @@ define void @symbolicsiv4(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == {0,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -286,7 +306,11 @@ define void @symbolicsiv5(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-NEXT: Src: %0 = load i32, ptr %arrayidx4, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == {0,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -336,11 +360,19 @@ define void @weaktest(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; 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 - none! +; CHECK-NEXT: da analyze - consistent input [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,-4}<%for.body> to i128) == (4 * (sext i64 {0,+,-1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,-4}<%for.body> to i128) == (4 + (sext i64 {0,+,-4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,-4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,-4}<%for.body> to i128)) ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -383,19 +415,42 @@ 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: (16 * %N) ne) 0 +; CHECK-NEXT: Compare predicate: %M sge) 0 +; CHECK-NEXT: Compare predicate: %M slt) %N +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %N) to i128) == (4 * (sext i64 %N to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(16 * %N)}<%for.body> to i128) == ((sext i64 (4 * %N) to i128) * (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %N),+,(16 * %N)}<%for.body> to i128) == ((sext i64 (4 * %N) to i128) + (sext i64 {0,+,(16 * %N)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %N)),+,(16 * %N)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %N),+,(16 * %N)}<%for.body> to i128)) ; 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: da analyze - flow [0|<]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: %M sge) 0 +; CHECK-NEXT: Compare predicate: %M slt) %N +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %N) to i128) == (4 * (sext i64 %N to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(16 * %N)}<%for.body> to i128) == ((sext i64 (4 * %N) to i128) * (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %N),+,(16 * %N)}<%for.body> to i128) == ((sext i64 (4 * %N) to i128) + (sext i64 {0,+,(16 * %N)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %N)),+,(16 * %N)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %N),+,(16 * %N)}<%for.body> to i128)) +; CHECK-NEXT: Compare predicate: (1 + (3 * %M)) sge) 0 +; CHECK-NEXT: Compare predicate: (1 + (3 * %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: (16 * %N) ne) 0 +; CHECK-NEXT: Compare predicate: (1 + (3 * %M)) sge) 0 +; CHECK-NEXT: Compare predicate: (1 + (3 * %M)) slt) %N +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %N) to i128) == (4 * (sext i64 %N to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(16 * %N)}<%for.body> to i128) == ((sext i64 (4 * %N) to i128) * (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %N),+,(16 * %N)}<%for.body> to i128) == ((sext i64 (4 * %N) to i128) + (sext i64 {0,+,(16 * %N)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %N)),+,(16 * %N)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %N),+,(16 * %N)}<%for.body> to i128)) ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == {0,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -443,19 +498,42 @@ 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: (8 * %N) ne) 0 +; CHECK-NEXT: Compare predicate: %M sge) 0 +; CHECK-NEXT: Compare predicate: %M slt) %N +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %N) to i128) == (4 * (sext i64 %N to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(8 * %N)}<%for.body> to i128) == ((sext i64 (4 * %N) to i128) * (sext i64 {0,+,2}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %N),+,(8 * %N)}<%for.body> to i128) == ((sext i64 (4 * %N) to i128) + (sext i64 {0,+,(8 * %N)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %N)),+,(8 * %N)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %N),+,(8 * %N)}<%for.body> to i128)) ; 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: da analyze - flow [0|<]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: %M sge) 0 +; CHECK-NEXT: Compare predicate: %M slt) %N +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %N) to i128) == (4 * (sext i64 %N to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(8 * %N)}<%for.body> to i128) == ((sext i64 (4 * %N) to i128) * (sext i64 {0,+,2}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %N),+,(8 * %N)}<%for.body> to i128) == ((sext i64 (4 * %N) to i128) + (sext i64 {0,+,(8 * %N)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %N)),+,(8 * %N)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %N),+,(8 * %N)}<%for.body> to i128)) +; CHECK-NEXT: Compare predicate: (2 + (-3 * %M)) sge) 0 +; CHECK-NEXT: Compare predicate: (2 + (-3 * %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: (8 * %N) ne) 0 +; CHECK-NEXT: Compare predicate: (2 + (-3 * %M)) sge) 0 +; CHECK-NEXT: Compare predicate: (2 + (-3 * %M)) slt) %N +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %N) to i128) == (4 * (sext i64 %N to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(8 * %N)}<%for.body> to i128) == ((sext i64 (4 * %N) to i128) * (sext i64 {0,+,2}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %N),+,(8 * %N)}<%for.body> to i128) == ((sext i64 (4 * %N) to i128) + (sext i64 {0,+,(8 * %N)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %N)),+,(8 * %N)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %N),+,(8 * %N)}<%for.body> to i128)) ; 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! ; CHECK-NEXT: Src: store i32 %1, ptr %B.addr.02, align 4 --> Dst: store i32 %1, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == {0,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 diff --git a/llvm/test/Analysis/DependenceAnalysis/WeakCrossingSIV.ll b/llvm/test/Analysis/DependenceAnalysis/WeakCrossingSIV.ll index c7accfd46a4d7..810df1caf8f68 100644 --- a/llvm/test/Analysis/DependenceAnalysis/WeakCrossingSIV.ll +++ b/llvm/test/Analysis/DependenceAnalysis/WeakCrossingSIV.ll @@ -16,19 +16,40 @@ 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: (4 * %n) ne) 0 +; CHECK-NEXT: Compare predicate: 1 slt) %n +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %n) to i128) == (4 * (sext i64 %n to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) + (sext i64 {0,+,(4 * %n)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %n)),+,(4 * %n)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128)) ; 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: Equal predicate: (sext i64 (4 * %n) to i128) == (4 * (sext i64 %n to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) + (sext i64 {0,+,(4 * %n)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %n)),+,(4 * %n)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(-4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) * (sext i64 {0,+,-1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %n),+,(-4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) + (sext i64 {0,+,(-4 * %n)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %n)),+,(-4 * %n)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %n),+,(-4 * %n)}<%for.body> to i128)) ; 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: (-4 * %n) ne) 0 +; CHECK-NEXT: Compare predicate: 1 slt) %n +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %n) to i128) == (4 * (sext i64 %n to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(-4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) * (sext i64 {0,+,-1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %n),+,(-4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) + (sext i64 {0,+,(-4 * %n)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %n)),+,(-4 * %n)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %n),+,(-4 * %n)}<%for.body> to i128)) ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -80,7 +101,11 @@ define void @weakcrossing1(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -247,17 +272,29 @@ for.end: ; preds = %for.body define void @weakcrossing5(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-LABEL: 'weakcrossing5' ; 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]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,12}<%for.body> to i128) == (4 * (sext i64 {0,+,3}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,12}<%for.body> to i128) == (4 + (sext i64 {0,+,12}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,12}<%for.body> to i128)) == (-1 + (sext i64 {4,+,12}<%for.body> to i128)) ; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %1 = load i32, ptr %arrayidx2, align 4 ; CHECK-NEXT: da analyze - none! ; 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 %arrayidx2, align 4 --> Dst: %1 = load i32, ptr %arrayidx2, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent input [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {20,+,-12}<%for.body> to i128) == (4 * (sext i64 {5,+,-3}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {24,+,-12}<%for.body> to i128) == (4 + (sext i64 {20,+,-12}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {20,+,-12}<%for.body> to i128)) == (-1 + (sext i64 {24,+,-12}<%for.body> to i128)) ; CHECK-NEXT: Src: %1 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %1, ptr %B.addr.02, align 4 ; CHECK-NEXT: da analyze - confused! ; CHECK-NEXT: Src: store i32 %1, ptr %B.addr.02, align 4 --> Dst: store i32 %1, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 diff --git a/llvm/test/Analysis/DependenceAnalysis/WeakZeroDstSIV.ll b/llvm/test/Analysis/DependenceAnalysis/WeakZeroDstSIV.ll index f8a045c425029..5cdcbfbaf7173 100644 --- a/llvm/test/Analysis/DependenceAnalysis/WeakZeroDstSIV.ll +++ b/llvm/test/Analysis/DependenceAnalysis/WeakZeroDstSIV.ll @@ -92,7 +92,11 @@ 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: (4 * %n) ne) 0 +; CHECK-NEXT: Compare predicate: 10 slt) %n +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %n) to i128) == (4 * (sext i64 %n to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) + (sext i64 {0,+,(4 * %n)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %n)),+,(4 * %n)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128)) ; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4 ; CHECK-NEXT: da analyze - flow [p<=|<]! ; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 @@ -102,7 +106,11 @@ define void @weakzerodst1(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -310,7 +318,11 @@ for.end: ; preds = %for.body define void @weakzerodst6(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; CHECK-LABEL: 'weakzerodst6' ; 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]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,12}<%for.body> to i128) == (4 * (sext i64 {0,+,3}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,12}<%for.body> to i128) == (4 + (sext i64 {0,+,12}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,12}<%for.body> to i128)) == (-1 + (sext i64 {4,+,12}<%for.body> to i128)) ; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4 ; CHECK-NEXT: da analyze - none! ; CHECK-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 @@ -320,7 +332,11 @@ define void @weakzerodst6(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 diff --git a/llvm/test/Analysis/DependenceAnalysis/WeakZeroSrcSIV.ll b/llvm/test/Analysis/DependenceAnalysis/WeakZeroSrcSIV.ll index 4ed0abd8d98a9..81141aeadb065 100644 --- a/llvm/test/Analysis/DependenceAnalysis/WeakZeroSrcSIV.ll +++ b/llvm/test/Analysis/DependenceAnalysis/WeakZeroSrcSIV.ll @@ -96,11 +96,19 @@ 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: (4 * %n) ne) 0 +; CHECK-NEXT: Compare predicate: 10 slt) %n +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %n) to i128) == (4 * (sext i64 %n to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128) == ((sext i64 (4 * %n) to i128) + (sext i64 {0,+,(4 * %n)}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %n)),+,(4 * %n)}<%for.body> to i128) == (-1 + (sext i64 {(4 * %n),+,(4 * %n)}<%for.body> to i128)) ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 @@ -314,11 +322,19 @@ define void @weakzerosrc6(ptr %A, ptr %B, i64 %n) nounwind uwtable ssp { ; 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 %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent input [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,12}<%for.body> to i128) == (4 * (sext i64 {0,+,3}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,12}<%for.body> to i128) == (4 + (sext i64 {0,+,12}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,12}<%for.body> to i128)) == (-1 + (sext i64 {4,+,12}<%for.body> to i128)) ; 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! ; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.02, align 4 --> Dst: store i32 %0, ptr %B.addr.02, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,4}<%for.body> to i128) == (4 * (sext i64 {0,+,1}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {4,+,4}<%for.body> to i128) == (4 + (sext i64 {0,+,4}<%for.body> to i128)) +; CHECK-NEXT: Equal predicate: (3 + (sext i64 {0,+,4}<%for.body> to i128)) == (-1 + (sext i64 {4,+,4}<%for.body> to i128)) ; entry: %cmp1 = icmp eq i64 %n, 0 diff --git a/llvm/test/Analysis/DependenceAnalysis/becount-couldnotcompute.ll b/llvm/test/Analysis/DependenceAnalysis/becount-couldnotcompute.ll index 1674badd4d6b9..f6612f5324973 100644 --- a/llvm/test/Analysis/DependenceAnalysis/becount-couldnotcompute.ll +++ b/llvm/test/Analysis/DependenceAnalysis/becount-couldnotcompute.ll @@ -9,7 +9,11 @@ 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: (4 + (4 * %conv)) ne) 0 +; CHECK-NEXT: Compare predicate: {0,+,1}<%loop> slt) %conv +; CHECK-NEXT: Equal predicate: (sext i64 (4 * %conv) to i128) == (4 * (sext i64 %conv to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {0,+,(4 * %conv)}<%loop> to i128) == {0,+,(sext i64 (4 * %conv) to i128)}<%loop> +; CHECK-NEXT: Equal predicate: (sext i64 {(4 * %conv),+,(4 * %conv)}<%loop> to i128) == ((sext i64 (4 * %conv) to i128) + (sext i64 {0,+,(4 * %conv)}<%loop> to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (4 * %conv)),+,(4 * %conv)}<%loop> to i128) == (-1 + (sext i64 {(4 * %conv),+,(4 * %conv)}<%loop> to i128)) ; entry: %sub = add i64 %conv, 1 diff --git a/llvm/test/Analysis/DependenceAnalysis/compute-absolute-value.ll b/llvm/test/Analysis/DependenceAnalysis/compute-absolute-value.ll index f3ce956545482..180d0b0e7efb5 100644 --- a/llvm/test/Analysis/DependenceAnalysis/compute-absolute-value.ll +++ b/llvm/test/Analysis/DependenceAnalysis/compute-absolute-value.ll @@ -18,13 +18,19 @@ 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: (-1 * %k) ne) 0 +; CHECK-NEXT: Compare predicate: 0 slt) %k +; CHECK-NEXT: Equal predicate: {0,+,(sext i64 (-1 * %k) to i128)}<%loop> == {0,+,(-1 * (sext i64 %k to i128))}<%loop> +; CHECK-NEXT: Equal predicate: (sext i64 {%k,+,(-1 * %k)}<%loop> to i128) == {(sext i64 %k to i128),+,(sext i64 (-1 * %k) to i128)}<%loop> +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + %k),+,(-1 * %k)}<%loop> to i128) == (-1 + (sext i64 {%k,+,(-1 * %k)}<%loop> to i128)) ; 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: da analyze - none! ; 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 * %k) ne) 0 +; CHECK-NEXT: Compare predicate: 1 slt) %k +; CHECK-NEXT: Equal predicate: (sext i64 {(2 * %k),+,(-1 * %k)}<%loop> to i128) == {(2 * (sext i64 %k to i128)),+,(-1 * (sext i64 %k to i128))}<%loop> +; CHECK-NEXT: Equal predicate: (sext i64 {(3 * %k),+,(-1 * %k)}<%loop> to i128) == ((sext i64 {(2 * %k),+,(-1 * %k)}<%loop> to i128) + (sext i64 %k to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (3 * %k)),+,(-1 * %k)}<%loop> to i128) == (-1 + (sext i64 {(3 * %k),+,(-1 * %k)}<%loop> to i128)) ; entry: %k.neg = sub nsw i64 0, %k diff --git a/llvm/test/Analysis/DependenceAnalysis/exact-siv-overflow.ll b/llvm/test/Analysis/DependenceAnalysis/exact-siv-overflow.ll index 59e2ed3c7e35f..e189fb2a1c5d6 100644 --- a/llvm/test/Analysis/DependenceAnalysis/exact-siv-overflow.ll +++ b/llvm/test/Analysis/DependenceAnalysis/exact-siv-overflow.ll @@ -26,7 +26,10 @@ define void @exactsiv_const_ovfl(ptr %A) { ; CHECK-LABEL: 'exactsiv_const_ovfl' ; CHECK-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent output [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {-9223372036854775808,+,-6}<%loop.header> to i128) == {9223372036854775808,+,-6}<%loop.header> +; CHECK-NEXT: Equal predicate: {9223372036854775807,+,-6}<%loop.header> == (-1 + (sext i64 {-9223372036854775808,+,-6}<%loop.header> to i128)) ; CHECK-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 ; CHECK-NEXT: da analyze - none! ; CHECK-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 @@ -35,8 +38,14 @@ define void @exactsiv_const_ovfl(ptr %A) { ; CHECK-EXACT-SIV-LABEL: 'exactsiv_const_ovfl' ; CHECK-EXACT-SIV-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1 ; CHECK-EXACT-SIV-NEXT: da analyze - consistent output [*]! +; CHECK-EXACT-SIV-NEXT: Runtime Assumptions: +; CHECK-EXACT-SIV-NEXT: Equal predicate: (sext i64 {-9223372036854775808,+,-6}<%loop.header> to i128) == {9223372036854775808,+,-6}<%loop.header> +; CHECK-EXACT-SIV-NEXT: Equal predicate: {9223372036854775807,+,-6}<%loop.header> == (-1 + (sext i64 {-9223372036854775808,+,-6}<%loop.header> to i128)) ; CHECK-EXACT-SIV-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 ; CHECK-EXACT-SIV-NEXT: da analyze - output [*|<]! +; CHECK-EXACT-SIV-NEXT: Runtime Assumptions: +; CHECK-EXACT-SIV-NEXT: Equal predicate: (sext i64 {-9223372036854775808,+,-6}<%loop.header> to i128) == {9223372036854775808,+,-6}<%loop.header> +; CHECK-EXACT-SIV-NEXT: Equal predicate: {9223372036854775807,+,-6}<%loop.header> == (-1 + (sext i64 {-9223372036854775808,+,-6}<%loop.header> to i128)) ; CHECK-EXACT-SIV-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 ; CHECK-EXACT-SIV-NEXT: da analyze - consistent output [*]! ; diff --git a/llvm/test/Analysis/DependenceAnalysis/gcd-miv-overflow.ll b/llvm/test/Analysis/DependenceAnalysis/gcd-miv-overflow.ll index ff8f32b9c8276..1064ab69b78ab 100644 --- a/llvm/test/Analysis/DependenceAnalysis/gcd-miv-overflow.ll +++ b/llvm/test/Analysis/DependenceAnalysis/gcd-miv-overflow.ll @@ -26,17 +26,25 @@ 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: (3 * %m) ne) 0 +; CHECK-ALL-NEXT: Compare predicate: 4 slt) %m +; CHECK-ALL-NEXT: Equal predicate: (sext i64 {0,+,(3 * %m)}<%loop> to i128) == {0,+,(3 * (sext i64 %m to i128))}<%loop> +; CHECK-ALL-NEXT: Equal predicate: (sext i64 {%m,+,(3 * %m)}<%loop> to i128) == ((sext i64 {0,+,(3 * %m)}<%loop> to i128) + (sext i64 %m to i128)) +; CHECK-ALL-NEXT: Equal predicate: (sext i64 {(-1 + %m),+,(3 * %m)}<%loop> to i128) == (-1 + (sext i64 {%m,+,(3 * %m)}<%loop> to i128)) ; 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: da analyze - none! ; 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: Equal predicate: (sext i64 {0,+,(3 * %m)}<%loop> to i128) == {0,+,(3 * (sext i64 %m to i128))}<%loop> +; CHECK-GCD-MIV-NEXT: Equal predicate: (sext i64 {%m,+,(3 * %m)}<%loop> to i128) == ((sext i64 {0,+,(3 * %m)}<%loop> to i128) + (sext i64 %m to i128)) +; CHECK-GCD-MIV-NEXT: Equal predicate: (sext i64 {(-1 + %m),+,(3 * %m)}<%loop> to i128) == (-1 + (sext i64 {%m,+,(3 * %m)}<%loop> to i128)) ; 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: da analyze - none! ; 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 [*]! ; @@ -81,7 +89,10 @@ exit: define void @gcdmiv_delta_ovfl(ptr %A) { ; CHECK-ALL-LABEL: 'gcdmiv_delta_ovfl' ; CHECK-ALL-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1 -; CHECK-ALL-NEXT: da analyze - none! +; CHECK-ALL-NEXT: da analyze - consistent output [0]! +; CHECK-ALL-NEXT: Runtime Assumptions: +; CHECK-ALL-NEXT: Equal predicate: (sext i64 {-9223372036854775808,+,-6}<%loop.header> to i128) == {9223372036854775808,+,-6}<%loop.header> +; CHECK-ALL-NEXT: Equal predicate: {9223372036854775807,+,-6}<%loop.header> == (-1 + (sext i64 {-9223372036854775808,+,-6}<%loop.header> to i128)) ; CHECK-ALL-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 ; CHECK-ALL-NEXT: da analyze - none! ; CHECK-ALL-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 @@ -90,8 +101,14 @@ define void @gcdmiv_delta_ovfl(ptr %A) { ; CHECK-GCD-MIV-LABEL: 'gcdmiv_delta_ovfl' ; CHECK-GCD-MIV-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1 ; CHECK-GCD-MIV-NEXT: da analyze - consistent output [*]! +; CHECK-GCD-MIV-NEXT: Runtime Assumptions: +; CHECK-GCD-MIV-NEXT: Equal predicate: (sext i64 {-9223372036854775808,+,-6}<%loop.header> to i128) == {9223372036854775808,+,-6}<%loop.header> +; CHECK-GCD-MIV-NEXT: Equal predicate: {9223372036854775807,+,-6}<%loop.header> == (-1 + (sext i64 {-9223372036854775808,+,-6}<%loop.header> to i128)) ; CHECK-GCD-MIV-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 ; CHECK-GCD-MIV-NEXT: da analyze - consistent output [*|<]! +; CHECK-GCD-MIV-NEXT: Runtime Assumptions: +; CHECK-GCD-MIV-NEXT: Equal predicate: (sext i64 {-9223372036854775808,+,-6}<%loop.header> to i128) == {9223372036854775808,+,-6}<%loop.header> +; CHECK-GCD-MIV-NEXT: Equal predicate: {9223372036854775807,+,-6}<%loop.header> == (-1 + (sext i64 {-9223372036854775808,+,-6}<%loop.header> to i128)) ; CHECK-GCD-MIV-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 ; CHECK-GCD-MIV-NEXT: da analyze - consistent output [*]! ; diff --git a/llvm/test/Analysis/DependenceAnalysis/lcssa.ll b/llvm/test/Analysis/DependenceAnalysis/lcssa.ll index ffba9fcb98903..e3088ccacff11 100644 --- a/llvm/test/Analysis/DependenceAnalysis/lcssa.ll +++ b/llvm/test/Analysis/DependenceAnalysis/lcssa.ll @@ -5,7 +5,10 @@ define void @f(ptr %a, i32 %n, i64 %n2) { ; CHECK-LABEL: 'f' ; CHECK-NEXT: Src: %v = load i32, ptr %arrayidx1, align 4 --> Dst: %v = load i32, ptr %arrayidx1, align 4 -; CHECK-NEXT: da analyze - none! +; CHECK-NEXT: da analyze - consistent input [0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Equal predicate: (sext i64 {8,+,4}<%for.body> to i128) == {8,+,4}<%for.body> +; CHECK-NEXT: Equal predicate: {7,+,4}<%for.body> == (-1 + (sext i64 {8,+,4}<%for.body> to i128)) ; CHECK-NEXT: Src: %v = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %add, ptr %a.lcssa, align 4 ; CHECK-NEXT: da analyze - anti [*|<]! ; CHECK-NEXT: Src: store i32 %add, ptr %a.lcssa, align 4 --> Dst: store i32 %add, ptr %a.lcssa, align 4 diff --git a/llvm/test/Analysis/DependenceAnalysis/monotonicity-cast.ll b/llvm/test/Analysis/DependenceAnalysis/monotonicity-cast.ll index 966e4462fb887..9b2eb37140fb8 100644 --- a/llvm/test/Analysis/DependenceAnalysis/monotonicity-cast.ll +++ b/llvm/test/Analysis/DependenceAnalysis/monotonicity-cast.ll @@ -16,7 +16,11 @@ 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 %step to i64) ne) 0 +; 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: Equal predicate: (sext i64 {0,+,(sext i8 %step to i64)}<%loop> to i128) == {0,+,(sext i8 %step to i128)}<%loop> +; CHECK-NEXT: Equal predicate: (sext i64 {(sext i8 %step to i64),+,(sext i8 %step to i64)}<%loop> to i128) == ((sext i64 {0,+,(sext i8 %step to i64)}<%loop> to i128) + (sext i8 %step to i128)) +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + (sext i8 %step to i64)),+,(sext i8 %step to i64)}<%loop> to i128) == (-1 + (sext i64 {(sext i8 %step to i64),+,(sext i8 %step to i64)}<%loop> to i128)) ; entry: br label %loop diff --git a/llvm/test/Analysis/DependenceAnalysis/monotonicity-no-wrap-flags.ll b/llvm/test/Analysis/DependenceAnalysis/monotonicity-no-wrap-flags.ll index df42c757a3b63..654a72b29390f 100644 --- a/llvm/test/Analysis/DependenceAnalysis/monotonicity-no-wrap-flags.ll +++ b/llvm/test/Analysis/DependenceAnalysis/monotonicity-no-wrap-flags.ll @@ -77,6 +77,9 @@ define void @nested_loop_nsw0(ptr %a, i64 %n, i64 %m) { ; 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: Equal predicate: (sext i64 {{\{\{}}1,+,1}<%loop.i.header>,+,1}<%loop.j> to i128) == {{\{\{}}1,+,1}<%loop.i.header>,+,1}<%loop.j> +; CHECK-NEXT: Equal predicate: {{\{\{}}0,+,1}<%loop.i.header>,+,1}<%loop.j> == (-1 + (sext i64 {{\{\{}}1,+,1}<%loop.i.header>,+,1}<%loop.j> to i128)) ; entry: %guard.i = icmp sgt i64 %n, 0 @@ -263,7 +266,11 @@ define void @nested_loop_step(ptr %a, i64 %n, i64 %m, i64 %step) { ; CHECK-NEXT: Monotonicity: MultivariateSignedMonotonic ; 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: da analyze - consistent output [0 0]! +; CHECK-NEXT: Runtime Assumptions: +; CHECK-NEXT: Compare predicate: {0,+,1}<%loop.i.header> slt) %step +; CHECK-NEXT: Equal predicate: (sext i64 {%step,+,%step}<%loop.j> to i128) == {(sext i64 %step to i128),+,(sext i64 %step to i128)}<%loop.j> +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + %step),+,%step}<%loop.j> to i128) == (-1 + (sext i64 {%step,+,%step}<%loop.j> to i128)) ; entry: %guard.i = icmp sgt i64 %n, 0 @@ -471,6 +478,9 @@ define void @conditional_store1(ptr %a, i64 %n, i64 %m) { ; 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: Equal predicate: (sext i64 {{\{\{}}1,+,1}<%loop.i.header>,+,1}<%loop.j.header> to i128) == {{\{\{}}1,+,1}<%loop.i.header>,+,1}<%loop.j.header> +; CHECK-NEXT: Equal predicate: {{\{\{}}0,+,1}<%loop.i.header>,+,1}<%loop.j.header> == (-1 + (sext i64 {{\{\{}}1,+,1}<%loop.i.header>,+,1}<%loop.j.header> to i128)) ; entry: %guard.i = icmp sgt i64 %n, 0 diff --git a/llvm/test/Analysis/DependenceAnalysis/weak-crossing-siv-overflow.ll b/llvm/test/Analysis/DependenceAnalysis/weak-crossing-siv-overflow.ll index ba57c7bf5736a..a212169d39b9b 100644 --- a/llvm/test/Analysis/DependenceAnalysis/weak-crossing-siv-overflow.ll +++ b/llvm/test/Analysis/DependenceAnalysis/weak-crossing-siv-overflow.ll @@ -25,7 +25,10 @@ define void @weakcorssing_delta_ovfl(ptr %A) { ; CHECK-ALL-LABEL: 'weakcorssing_delta_ovfl' ; CHECK-ALL-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1 -; CHECK-ALL-NEXT: da analyze - none! +; CHECK-ALL-NEXT: da analyze - consistent output [0]! +; CHECK-ALL-NEXT: Runtime Assumptions: +; CHECK-ALL-NEXT: Equal predicate: (sext i64 {-9223372036854775808,+,-3}<%loop.header> to i128) == {9223372036854775808,+,-3}<%loop.header> +; CHECK-ALL-NEXT: Equal predicate: {9223372036854775807,+,-3}<%loop.header> == (-1 + (sext i64 {-9223372036854775808,+,-3}<%loop.header> to i128)) ; CHECK-ALL-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 ; CHECK-ALL-NEXT: da analyze - none! ; CHECK-ALL-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 @@ -34,6 +37,9 @@ define void @weakcorssing_delta_ovfl(ptr %A) { ; CHECK-WEAK-CROSSING-SIV-LABEL: 'weakcorssing_delta_ovfl' ; CHECK-WEAK-CROSSING-SIV-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1 ; CHECK-WEAK-CROSSING-SIV-NEXT: da analyze - consistent output [*]! +; CHECK-WEAK-CROSSING-SIV-NEXT: Runtime Assumptions: +; CHECK-WEAK-CROSSING-SIV-NEXT: Equal predicate: (sext i64 {-9223372036854775808,+,-3}<%loop.header> to i128) == {9223372036854775808,+,-3}<%loop.header> +; CHECK-WEAK-CROSSING-SIV-NEXT: Equal predicate: {9223372036854775807,+,-3}<%loop.header> == (-1 + (sext i64 {-9223372036854775808,+,-3}<%loop.header> to i128)) ; CHECK-WEAK-CROSSING-SIV-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 ; CHECK-WEAK-CROSSING-SIV-NEXT: da analyze - none! ; CHECK-WEAK-CROSSING-SIV-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 @@ -87,19 +93,31 @@ exit: define void @weakcorssing_prod_ovfl(ptr %A) { ; CHECK-ALL-LABEL: 'weakcorssing_prod_ovfl' ; CHECK-ALL-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1 -; CHECK-ALL-NEXT: da analyze - none! +; CHECK-ALL-NEXT: da analyze - consistent output [0]! +; CHECK-ALL-NEXT: Runtime Assumptions: +; CHECK-ALL-NEXT: Equal predicate: (sext i64 {-9223372036854775808,+,-3}<%loop> to i128) == {9223372036854775808,+,-3}<%loop> +; CHECK-ALL-NEXT: Equal predicate: {9223372036854775807,+,-3}<%loop> == (-1 + (sext i64 {-9223372036854775808,+,-3}<%loop> to i128)) ; CHECK-ALL-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 ; CHECK-ALL-NEXT: da analyze - none! ; CHECK-ALL-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 -; CHECK-ALL-NEXT: da analyze - none! +; CHECK-ALL-NEXT: da analyze - consistent output [0]! +; CHECK-ALL-NEXT: Runtime Assumptions: +; CHECK-ALL-NEXT: Equal predicate: (sext i64 {2,+,3}<%loop> to i128) == {2,+,3}<%loop> +; CHECK-ALL-NEXT: Equal predicate: {1,+,3}<%loop> == (-1 + (sext i64 {2,+,3}<%loop> to i128)) ; ; CHECK-WEAK-CROSSING-SIV-LABEL: 'weakcorssing_prod_ovfl' ; CHECK-WEAK-CROSSING-SIV-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1 ; CHECK-WEAK-CROSSING-SIV-NEXT: da analyze - consistent output [*]! +; CHECK-WEAK-CROSSING-SIV-NEXT: Runtime Assumptions: +; CHECK-WEAK-CROSSING-SIV-NEXT: Equal predicate: (sext i64 {-9223372036854775808,+,-3}<%loop> to i128) == {9223372036854775808,+,-3}<%loop> +; CHECK-WEAK-CROSSING-SIV-NEXT: Equal predicate: {9223372036854775807,+,-3}<%loop> == (-1 + (sext i64 {-9223372036854775808,+,-3}<%loop> to i128)) ; CHECK-WEAK-CROSSING-SIV-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 ; CHECK-WEAK-CROSSING-SIV-NEXT: da analyze - none! ; CHECK-WEAK-CROSSING-SIV-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1 ; CHECK-WEAK-CROSSING-SIV-NEXT: da analyze - consistent output [*]! +; CHECK-WEAK-CROSSING-SIV-NEXT: Runtime Assumptions: +; CHECK-WEAK-CROSSING-SIV-NEXT: Equal predicate: (sext i64 {2,+,3}<%loop> to i128) == {2,+,3}<%loop> +; CHECK-WEAK-CROSSING-SIV-NEXT: Equal predicate: {1,+,3}<%loop> == (-1 + (sext i64 {2,+,3}<%loop> to i128)) ; entry: br label %loop diff --git a/llvm/test/Analysis/DependenceAnalysis/zero-coefficient.ll b/llvm/test/Analysis/DependenceAnalysis/zero-coefficient.ll index 55f0ecc123e3a..6c66cadd36a3c 100644 --- a/llvm/test/Analysis/DependenceAnalysis/zero-coefficient.ll +++ b/llvm/test/Analysis/DependenceAnalysis/zero-coefficient.ll @@ -15,7 +15,9 @@ 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: %k ne) 0 +; CHECK-NEXT: Compare predicate: 0 slt) %k +; CHECK-NEXT: Equal predicate: (sext i64 {%k,+,%k}<%loop> to i128) == {(sext i64 %k to i128),+,(sext i64 %k to i128)}<%loop> +; CHECK-NEXT: Equal predicate: (sext i64 {(-1 + %k),+,%k}<%loop> to i128) == (-1 + (sext i64 {%k,+,%k}<%loop> to i128)) ; entry: br label %loop 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