From 8e76c3f0d29a713c41f1b3d0f19d965a504481cf Mon Sep 17 00:00:00 2001 From: Florian Hahn Date: Fri, 24 Jul 2026 20:20:48 +0100 Subject: [PATCH] [SCEV] Use SCEVPtrToAddr instead of SCEVPtrToInt in SCEV. (#180244) Use SCEVPtrToAddr instead of SCEVPtrToInt for pointer -> int conversion in SCEV, like when computing trip count expressions. getPtrToIntExpr now also creates SCEVPtrToAddrExpr. Removal of SCEVPtrToIntExpr out of this PR, to limit the scope and will be done as NFC follow-up. PR: https://github.com/llvm/llvm-project/pull/180244 --- llvm/include/llvm/Analysis/ScalarEvolution.h | 3 +- .../Utils/ScalarEvolutionExpander.h | 8 + llvm/lib/Analysis/ScalarEvolution.cpp | 123 +++++------ .../Analysis/ScalarEvolutionAliasAnalysis.cpp | 26 +-- llvm/lib/Transforms/Utils/LoopUtils.cpp | 26 +-- .../Utils/ScalarEvolutionExpander.cpp | 77 +++++-- llvm/lib/Transforms/Vectorize/VPlanUtils.cpp | 16 ++ .../runtime-check-known-true.ll | 8 +- .../add-expr-pointer-operand-sorting.ll | 4 +- llvm/test/Analysis/ScalarEvolution/alloca.ll | 4 +- .../ScalarEvolution/exit-count-select-safe.ll | 4 +- .../ScalarEvolution/flags-from-poison.ll | 32 +-- .../max-backedge-taken-count-guard-info.ll | 40 ++-- .../ne-guard-multiple-trip-count.ll | 16 +- .../ScalarEvolution/no-wrap-add-exprs.ll | 12 +- .../no-wrap-symbolic-becount.ll | 8 +- llvm/test/Analysis/ScalarEvolution/nsw.ll | 28 +-- .../ScalarEvolution/pointer-rounding.ll | 66 +++--- llvm/test/Analysis/ScalarEvolution/pr46786.ll | 30 +-- ...ted-max-backedge-taken-count-guard-info.ll | 38 ++-- .../ptrtoint-constantexpr-loop.ll | 56 ++--- .../ScalarEvolution/ptrtoint-global.ll | 44 ++-- .../ptrtoint-special-pointers.ll | 19 +- .../test/Analysis/ScalarEvolution/ptrtoint.ll | 198 +++++++++--------- .../trip-multiple-guard-info.ll | 36 ++-- .../ScalarEvolution/two-loop-latches.ll | 12 +- llvm/test/CodeGen/AArch64/ragreedy-csr.ll | 6 +- .../Thumb2/mve-tailpred-loopinvariant.ll | 16 +- .../IndVarSimplify/2011-11-01-lftrptr.ll | 16 +- .../AArch64/ptrtoaddr-ptrtoint.ll | 6 +- .../X86/ptrtoaddr-narrow-pointer.ll | 12 +- llvm/test/Transforms/IndVarSimplify/callbr.ll | 4 +- .../IndVarSimplify/pointer-loop-guards.ll | 4 +- .../test/Transforms/IndVarSimplify/pr59633.ll | 2 +- .../LoopIdiom/memset-debugify-remarks.ll | 4 +- .../reuse-lcssa-phi-scev-expansion.ll | 2 +- .../2013-01-14-ReuseCast.ll | 2 +- .../expand-ptrtoaddr-reuse-ptrtoint.ll | 4 +- .../RISCV/lsr-drop-solution-dbg-msg.ll | 4 +- .../X86/expander-crashes.ll | 2 +- .../AArch64/apple-unrolling-multi-exit.ll | 8 +- .../AArch64/unrolling-multi-exit.ll | 16 +- .../AArch64/aggressive-interleaving.ll | 4 +- .../LoopVectorize/AArch64/induction-costs.ll | 8 +- .../AArch64/partial-reduce-constant-ops.ll | 28 +-- .../partial-reduce-incomplete-chains.ll | 4 +- .../LoopVectorize/AArch64/reduction-cost.ll | 16 +- .../replicating-load-store-costs-apple.ll | 4 +- .../AArch64/replicating-load-store-costs.ll | 4 +- .../AArch64/sve-live-out-pointer-induction.ll | 4 +- ...-narrow-interleave-to-widen-memory-cost.ll | 2 +- ...-interleave-to-widen-memory-derived-ivs.ll | 12 +- .../LoopVectorize/PowerPC/exit-branch-cost.ll | 4 +- .../LoopVectorize/PowerPC/pr41179.ll | 18 +- .../LoopVectorize/RISCV/pointer-induction.ll | 8 +- .../LoopVectorize/VPlan/expand-scev.ll | 4 +- .../VPlan/vplan-predicate-switch.ll | 4 +- .../vplan-printing-reductions-tail-folded.ll | 10 +- .../VPlan/vplan-printing-reductions.ll | 10 +- .../VPlan/vplan-sink-scalars-and-merge.ll | 2 +- .../WebAssembly/induction-branch-cost.ll | 4 +- .../X86/CostModel/vpinstruction-cost.ll | 4 +- .../LoopVectorize/X86/cost-model.ll | 6 +- .../X86/fold-tail-low-trip-count.ll | 8 +- .../X86/interleave-opaque-pointers.ll | 4 +- .../Transforms/LoopVectorize/X86/optsize.ll | 8 +- .../Transforms/LoopVectorize/X86/pr48340.ll | 8 +- .../Transforms/LoopVectorize/X86/pr72969.ll | 11 +- .../LoopVectorize/X86/predicate-switch.ll | 48 ++--- .../epilog-vectorization-any-of-reductions.ll | 4 +- .../epilog-vectorization-scev-expansion.ll | 14 +- ...nd-sink-mem-ops-with-invariant-pointers.ll | 10 +- .../LoopVectorize/induction-ptrcasts.ll | 8 +- ...aved-accesses-different-insert-position.ll | 4 +- .../interleaved-accesses-metadata.ll | 14 +- .../test/Transforms/LoopVectorize/metadata.ll | 20 +- .../Transforms/LoopVectorize/opaque-ptr.ll | 58 +++-- .../optimal-epilog-vectorization-liveout.ll | 12 +- .../LoopVectorize/pointer-induction.ll | 2 +- llvm/test/Transforms/LoopVectorize/pr45259.ll | 10 +- .../LoopVectorize/predicate-switch.ll | 8 +- .../preserve-dbg-loc-and-loop-metadata.ll | 8 +- .../LoopVectorize/runtime-check-known-true.ll | 5 +- .../runtime-check-needed-but-empty.ll | 6 +- .../runtime-checks-difference.ll | 19 +- .../LoopVectorize/scev-predicate-reasoning.ll | 13 +- ...e-to-enable-unrolling-and-vectorization.ll | 4 +- .../X86/pr48844-br-to-switch-vectorization.ll | 4 +- .../PhaseOrdering/X86/ptrtoaddr-ptrtoint.ll | 72 ++++--- .../enable-loop-header-duplication-oz.ll | 4 +- .../PhaseOrdering/scev-custom-dl.ll | 11 +- .../Analysis/ScalarEvolutionTest.cpp | 8 +- polly/test/ScopInfo/int2ptr_ptr2int.ll | 29 ++- polly/test/ScopInfo/int2ptr_ptr2int_2.ll | 15 +- 94 files changed, 831 insertions(+), 820 deletions(-) diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h index 0a9a4370d5e8..7a4dbd5278a9 100644 --- a/llvm/include/llvm/Analysis/ScalarEvolution.h +++ b/llvm/include/llvm/Analysis/ScalarEvolution.h @@ -733,7 +733,6 @@ public: LLVM_ABI const SCEV *getConstant(ConstantInt *V); LLVM_ABI const SCEV *getConstant(const APInt &Val); LLVM_ABI const SCEV *getConstant(Type *Ty, uint64_t V, bool isSigned = false); - LLVM_ABI const SCEV *getLosslessPtrToIntExpr(const SCEV *Op); LLVM_ABI const SCEV *getPtrToAddrExpr(const SCEV *Op); LLVM_ABI const SCEV *getPtrToIntExpr(const SCEV *Op, Type *Ty); @@ -876,7 +875,7 @@ public: /// If the LHS and RHS are pointers which don't share a common base /// (according to getPointerBase()), this returns a SCEVCouldNotCompute. /// To compute the difference between two unrelated pointers, you can - /// explicitly convert the arguments using getPtrToIntExpr(), for pointer + /// explicitly convert the arguments using getPtrToAddrExpr(), for pointer /// types that support it. LLVM_ABI const SCEV *getMinusSCEV(SCEVUse LHS, SCEVUse RHS, SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap, diff --git a/llvm/include/llvm/Transforms/Utils/ScalarEvolutionExpander.h b/llvm/include/llvm/Transforms/Utils/ScalarEvolutionExpander.h index 70bc4e68d68c..5d514568b013 100644 --- a/llvm/include/llvm/Transforms/Utils/ScalarEvolutionExpander.h +++ b/llvm/include/llvm/Transforms/Utils/ScalarEvolutionExpander.h @@ -15,6 +15,7 @@ #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseSet.h" +#include "llvm/ADT/STLFunctionalExtras.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Analysis/InstSimplifyFolder.h" #include "llvm/Analysis/ScalarEvolutionExpressions.h" @@ -316,6 +317,13 @@ public: dropPoisonGeneratingAnnotationsAndReinfer(ScalarEvolution &SE, Instruction *I); + /// Find an existing cast among \p PtrOp's users that computes the same value + /// as a `ptrtoaddr` of \p PtrOp to \p Ty and can be reused when expanding + /// ptrtoaddr. + LLVM_ABI static CastInst * + findReusableCastForPtrToAddr(Value *PtrOp, Type *Ty, const DataLayout &DL, + function_ref Dominates); + /// Insert code to directly compute the specified SCEV expression into the /// program. The code is inserted into the specified block. LLVM_ABI Value *expandCodeFor(SCEVUse SH, Type *Ty, BasicBlock::iterator I); diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp index c74708fc73e5..a9bec7bd91e8 100644 --- a/llvm/lib/Analysis/ScalarEvolution.cpp +++ b/llvm/lib/Analysis/ScalarEvolution.cpp @@ -1167,46 +1167,6 @@ public: } }; -const SCEV *ScalarEvolution::getLosslessPtrToIntExpr(const SCEV *Op) { - assert(Op->getType()->isPointerTy() && "Op must be a pointer"); - - // It isn't legal for optimizations to construct new ptrtoint expressions - // for non-integral pointers. - if (getDataLayout().isNonIntegralPointerType(Op->getType())) - return getCouldNotCompute(); - - Type *IntPtrTy = getDataLayout().getIntPtrType(Op->getType()); - - // We can only trivially model ptrtoint if SCEV's effective (integer) type - // is sufficiently wide to represent all possible pointer values. - // We could theoretically teach SCEV to truncate wider pointers, but - // that isn't implemented for now. - if (getDataLayout().getTypeSizeInBits(getEffectiveSCEVType(Op->getType())) != - getDataLayout().getTypeSizeInBits(IntPtrTy)) - return getCouldNotCompute(); - - // Use the rewriter to sink the cast down to SCEVUnknown leaves. - const SCEV *IntOp = SCEVCastSinkingRewriter::rewrite( - Op, *this, IntPtrTy, [this, IntPtrTy](const SCEVUnknown *U) { - FoldingSetNodeID ID; - ID.AddInteger(scPtrToInt); - ID.AddPointer(U); - void *IP = nullptr; - if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) - return S; - SCEV *S = new (SCEVAllocator) - SCEVPtrToIntExpr(ID.Intern(SCEVAllocator), U, IntPtrTy); - UniqueSCEVs.InsertNode(S, IP); - S->computeAndSetCanonical(*this); - registerUser(S, U); - return static_cast(S); - }); - assert(IntOp->getType()->isIntegerTy() && - "We must have succeeded in sinking the cast, " - "and ending up with an integer-typed expression!"); - return IntOp; -} - const SCEV *ScalarEvolution::getPtrToAddrExpr(const SCEV *Op) { assert(Op->getType()->isPointerTy() && "Op must be a pointer"); @@ -1244,11 +1204,9 @@ const SCEV *ScalarEvolution::getPtrToAddrExpr(const SCEV *Op) { const SCEV *ScalarEvolution::getPtrToIntExpr(const SCEV *Op, Type *Ty) { assert(Ty->isIntegerTy() && "Target type must be an integer type!"); - const SCEV *IntOp = getLosslessPtrToIntExpr(Op); - if (isa(IntOp)) - return IntOp; - - return getTruncateOrZeroExtend(IntOp, Ty); + // We don't model ptrtoint in SCEV. Return CouldNotCompute, which will cause + // callers to fall back to SCEVUnknown. + return getCouldNotCompute(); } const SCEV *ScalarEvolution::getTruncateExpr(const SCEV *Op, Type *Ty, @@ -6324,7 +6282,7 @@ ScalarEvolution::createNodeForSelectOrPHIInstWithICmpInstCond(Type *Ty, } auto CoerceOperand = [&](const SCEV *Op) -> const SCEV * { if (Op->getType()->isPointerTy()) { - Op = getLosslessPtrToIntExpr(Op); + Op = getPtrToAddrExpr(Op); if (isa(Op)) return Op; } @@ -8131,6 +8089,37 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) { SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap; if (BO->Op) Flags = getNoWrapFlagsFromUB(BO->Op); + + // Try to use ptrtoaddr for subtracts with at least one ptrtoint + // operand. While we don't model ptrtoint directly in SCEV, the + // difference between two pointer addresses is well-defined. + Value *PtrLHS, *PtrRHS; + bool HasPtrLHS = match(BO->LHS, m_PtrToInt(m_Value(PtrLHS))); + bool HasPtrRHS = match(BO->RHS, m_PtrToInt(m_Value(PtrRHS))); + if (HasPtrLHS || HasPtrRHS) { + // Convert a ptrtoint operand (OrigOp) to ptrtoaddr of its pointer + // PtrOp. When only one side is ptrtoint (BothPtr is false), skip + // SCEVUnknown pointers since wrapping them in ptrtoaddr adds no + // useful structure. + auto GetOp = [&](bool HasPtr, Value *PtrOp, Value *OrigOp, + bool BothPtr) -> const SCEV * { + if (!HasPtr) + return getSCEV(OrigOp); + const SCEV *PtrSCEV = getSCEV(PtrOp); + if (BothPtr || !isa(PtrSCEV)) { + const SCEV *Addr = getPtrToAddrExpr(PtrSCEV); + if (!isa(Addr) && + getTypeSizeInBits(OrigOp->getType()) <= + getTypeSizeInBits(Addr->getType())) + return getTruncateOrNoop(Addr, OrigOp->getType()); + } + return getSCEV(OrigOp); + }; + const SCEV *L = GetOp(HasPtrLHS, PtrLHS, BO->LHS, HasPtrRHS); + const SCEV *R = GetOp(HasPtrRHS, PtrRHS, BO->RHS, HasPtrLHS); + return getMinusSCEV(L, R, Flags); + } + LHS = getSCEV(BO->LHS); RHS = getSCEV(BO->RHS); return getMinusSCEV(LHS, RHS, Flags); @@ -8400,15 +8389,19 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) { } case Instruction::PtrToInt: { - // Pointer to integer cast is straight-forward, so do model it. - const SCEV *Op = getSCEV(U->getOperand(0)); - Type *DstIntTy = U->getType(); - // But only if effective SCEV (integer) type is wide enough to represent - // all possible pointer values. - const SCEV *IntOp = getPtrToIntExpr(Op, DstIntTy); - if (isa(IntOp)) - return getUnknown(V); - return IntOp; + // Keep ptrtoint as SCEVUnknown, except when the pointer operand has SCEV + // structure (e.g. a pointer add-rec or an offset from a known base). In + // that case model it via ptrtoaddr to preserve the integer structure + // (induction, constant folding). A bare SCEVUnknown pointer gains no + // structure from wrapping it in ptrtoaddr, so leave it opaque. + const SCEV *PtrSCEV = getSCEV(U->getOperand(0)); + if (!isa(PtrSCEV)) { + const SCEV *Addr = getPtrToAddrExpr(PtrSCEV); + if (!isa(Addr) && + getTypeSizeInBits(V->getType()) <= getTypeSizeInBits(Addr->getType())) + return getTruncateOrNoop(Addr, V->getType()); + } + return getUnknown(V); } case Instruction::IntToPtr: // Just don't deal with inttoptr casts. @@ -9573,12 +9566,12 @@ ScalarEvolution::ExitLimit ScalarEvolution::computeExitLimitFromICmp( case ICmpInst::ICMP_NE: { // while (X != Y) // Convert to: while (X-Y != 0) if (LHS->getType()->isPointerTy()) { - LHS = getLosslessPtrToIntExpr(LHS); + LHS = getPtrToAddrExpr(LHS); if (isa(LHS)) return LHS; } if (RHS->getType()->isPointerTy()) { - RHS = getLosslessPtrToIntExpr(RHS); + RHS = getPtrToAddrExpr(RHS); if (isa(RHS)) return RHS; } @@ -9591,12 +9584,12 @@ ScalarEvolution::ExitLimit ScalarEvolution::computeExitLimitFromICmp( case ICmpInst::ICMP_EQ: { // while (X == Y) // Convert to: while (X-Y == 0) if (LHS->getType()->isPointerTy()) { - LHS = getLosslessPtrToIntExpr(LHS); + LHS = getPtrToAddrExpr(LHS); if (isa(LHS)) return LHS; } if (RHS->getType()->isPointerTy()) { - RHS = getLosslessPtrToIntExpr(RHS); + RHS = getPtrToAddrExpr(RHS); if (isa(RHS)) return RHS; } @@ -13629,12 +13622,12 @@ ScalarEvolution::howManyLessThans(const SCEV *LHS, const SCEV *RHS, const SCEV *OrigStart = Start; const SCEV *OrigRHS = RHS; if (Start->getType()->isPointerTy()) { - Start = getLosslessPtrToIntExpr(Start); + Start = getPtrToAddrExpr(Start); if (isa(Start)) return Start; } if (RHS->getType()->isPointerTy()) { - RHS = getLosslessPtrToIntExpr(RHS); + RHS = getPtrToAddrExpr(RHS); if (isa(RHS)) return RHS; } @@ -13937,12 +13930,12 @@ ScalarEvolution::ExitLimit ScalarEvolution::howManyGreaterThans( } if (Start->getType()->isPointerTy()) { - Start = getLosslessPtrToIntExpr(Start); + Start = getPtrToAddrExpr(Start); if (isa(Start)) return Start; } if (End->getType()->isPointerTy()) { - End = getLosslessPtrToIntExpr(End); + End = getPtrToAddrExpr(End); if (isa(End)) return End; } @@ -16202,8 +16195,8 @@ void ScalarEvolution::LoopGuards::collectFromBlock( // inequalities in a separate map, and materialize the rewrite lazily // when encountering a suitable subtraction while re-writing. if (LHS->getType()->isPointerTy()) { - LHS = SE.getLosslessPtrToIntExpr(LHS); - RHS = SE.getLosslessPtrToIntExpr(RHS); + LHS = SE.getPtrToAddrExpr(LHS); + RHS = SE.getPtrToAddrExpr(RHS); if (isa(LHS) || isa(RHS)) break; } diff --git a/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp b/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp index ee5480c46083..0ab888b2880f 100644 --- a/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp +++ b/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp @@ -53,6 +53,19 @@ AliasResult SCEVAAResult::alias(const MemoryLocation &LocA, // If something is known about the difference between the two addresses, // see if it's enough to prove a NoAlias. if (canComputePointerDiff(SE, AS, BS)) { + // Firstly, try to convert the two pointers into address expressions to + // handle two pointers with different pointer bases. + // Either both pointers are used with ptrtoaddr or neither, so we can't end + // up with a ptr + int mix. + const SCEV *AInt = SE.getPtrToAddrExpr(AS); + const SCEV *BInt = SE.getPtrToAddrExpr(BS); + if (!isa(AInt) && !isa(BInt)) { + AS = AInt; + BS = BInt; + } + + // Compute the bit width after the conversion above, as ptrtoaddr may + // produce a narrower (address-sized) type than the pointer representation. unsigned BitWidth = SE.getTypeSizeInBits(AS->getType()); APInt ASizeInt(BitWidth, LocA.Size.hasValue() ? static_cast(LocA.Size.getValue()) @@ -61,19 +74,6 @@ AliasResult SCEVAAResult::alias(const MemoryLocation &LocA, ? static_cast(LocB.Size.getValue()) : MemoryLocation::UnknownSize); - // Firstly, try to convert the two pointers into ptrtoint expressions to - // handle two pointers with different pointer bases. - // Either both pointers are used with ptrtoint or neither, so we can't end - // up with a ptr + int mix. - const SCEV *AInt = - SE.getPtrToIntExpr(AS, SE.getEffectiveSCEVType(AS->getType())); - const SCEV *BInt = - SE.getPtrToIntExpr(BS, SE.getEffectiveSCEVType(BS->getType())); - if (!isa(AInt) && !isa(BInt)) { - AS = AInt; - BS = BInt; - } - // Compute the difference between the two pointers. const SCEV *BA = SE.getMinusSCEV(BS, AS); diff --git a/llvm/lib/Transforms/Utils/LoopUtils.cpp b/llvm/lib/Transforms/Utils/LoopUtils.cpp index 591407770d73..d42a3b54ab5e 100644 --- a/llvm/lib/Transforms/Utils/LoopUtils.cpp +++ b/llvm/lib/Transforms/Utils/LoopUtils.cpp @@ -2259,24 +2259,6 @@ Value *llvm::addRuntimeChecks( return MemoryRuntimeCheck; } -namespace { -/// Rewriter to replace SCEVPtrToIntExpr with SCEVPtrToAddrExpr when the result -/// type matches the pointer address type. This allows expressions mixing -/// ptrtoint and ptrtoaddr to simplify properly. -struct SCEVPtrToAddrRewriter : SCEVRewriteVisitor { - const DataLayout &DL; - SCEVPtrToAddrRewriter(ScalarEvolution &SE, const DataLayout &DL) - : SCEVRewriteVisitor(SE), DL(DL) {} - - const SCEV *visitPtrToIntExpr(const SCEVPtrToIntExpr *E) { - const SCEV *Op = visit(E->getOperand()); - if (E->getType() == DL.getAddressType(E->getOperand()->getType())) - return SE.getPtrToAddrExpr(Op); - return Op == E->getOperand() ? E : SE.getPtrToIntExpr(Op, E->getType()); - } -}; -} // namespace - Value *llvm::addDiffRuntimeChecks( Instruction *Loc, ArrayRef Checks, SCEVExpander &Expander, function_ref GetVF, unsigned IC) { @@ -2288,8 +2270,6 @@ Value *llvm::addDiffRuntimeChecks( Value *MemoryRuntimeCheck = nullptr; auto &SE = *Expander.getSE(); - const DataLayout &DL = Loc->getDataLayout(); - SCEVPtrToAddrRewriter Rewriter(SE, DL); // Map to keep track of created compares, The key is the pair of operands for // the compare, to allow detecting and re-using redundant compares. DenseMap, Value *> SeenCompares; @@ -2309,10 +2289,8 @@ Value *llvm::addDiffRuntimeChecks( ConstantInt::get(Ty, ICTimesAccessSize)); ThresholdMinusOne = ChkBuilder.CreateSub(VFTimesICTimesSize, One); } - const SCEV *SinkStartRewritten = Rewriter.visit(SinkStart); - const SCEV *SrcStartRewritten = Rewriter.visit(SrcStart); - Value *Diff = Expander.expandCodeFor( - SE.getMinusSCEV(SinkStartRewritten, SrcStartRewritten), Ty, Loc); + Value *Diff = + Expander.expandCodeFor(SE.getMinusSCEV(SinkStart, SrcStart), Ty, Loc); // Check if the same compare has already been created earlier. In that case, // there is no need to check it again. diff --git a/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp b/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp index 125571b18ddd..18350f29aa43 100644 --- a/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp +++ b/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp @@ -1268,8 +1268,7 @@ Value *SCEVExpander::tryToReuseLCSSAPhi(SCEVUseT S) { const SCEV *Op = Diff; match(Op, m_scev_Add(m_SCEVConstant(), m_SCEV(Op))); match(Op, m_scev_Mul(m_scev_AllOnes(), m_SCEV(Op))); - match(Op, m_scev_PtrToAddr(m_SCEV(Op))) || - match(Op, m_scev_PtrToInt(m_SCEV(Op))); + match(Op, m_scev_PtrToAddr(m_SCEV(Op))); if (!isa(Op)) return nullptr; return Diff; @@ -1285,13 +1284,8 @@ Value *SCEVExpander::tryToReuseLCSSAPhi(SCEVUseT S) { const SCEV *Diff = nullptr; if (STy->isIntegerTy() && PhiTy->isPointerTy() && DL.getAddressType(PhiTy) == STy) { - // Prefer ptrtoaddr over ptrtoint. const SCEV *AddrSCEV = SE.getPtrToAddrExpr(ExitSCEV); Diff = CanReuse(AddrSCEV); - if (!Diff) { - const SCEV *IntSCEV = SE.getPtrToIntExpr(ExitSCEV, STy); - Diff = CanReuse(IntSCEV); - } } else if (STy == PhiTy) { Diff = CanReuse(ExitSCEV); } @@ -1455,22 +1449,48 @@ Value *SCEVExpander::visitAddRecExpr(SCEVUseT S) { return expand(T); } +/// Return true if \p CI computes the same value as a `ptrtoaddr` of its +/// pointer operand to \p Ty. +static bool canReuseCastForPtrToAddr(const CastInst *CI, Type *Ty, + const DataLayout &DL) { + if (CI->getType() != Ty) + return false; + if (CI->getOpcode() == CastInst::PtrToAddr) + return true; + if (CI->getOpcode() != CastInst::PtrToInt) + return false; + unsigned AS = CI->getSrcTy()->getPointerAddressSpace(); + return DL.getPointerSizeInBits(AS) == DL.getIndexSizeInBits(AS); +} + +CastInst *SCEVExpander::findReusableCastForPtrToAddr( + Value *PtrOp, Type *Ty, const DataLayout &DL, + function_ref Dominates) { + // Constants have no use list to scan. + if (isa(PtrOp)) + return nullptr; + for (User *U : PtrOp->users()) { + auto *CI = dyn_cast(U); + if (!CI || !canReuseCastForPtrToAddr(CI, Ty, DL)) + continue; + if (Dominates(CI)) + return CI; + } + return nullptr; +} + Value *SCEVExpander::visitPtrToAddrExpr(SCEVUseT S) { Value *V = expand(S->getOperand()); Type *Ty = S->getType(); - // ptrtoaddr and ptrtoint produce the same value, so try to reuse either. - if (!isa(V)) { - BasicBlock::iterator BIP = Builder.GetInsertPoint(); - for (User *U : V->users()) { - auto *CI = dyn_cast(U); - if (CI && CI->getType() == Ty && - (CI->getOpcode() == CastInst::PtrToAddr || - CI->getOpcode() == CastInst::PtrToInt) && - &*BIP != CI && SE.DT.dominates(CI, &*BIP)) - return CI; - } - } + // ptrtoaddr and ptrtoint can produce the same value, so try to reuse either. + BasicBlock::iterator BIP = Builder.GetInsertPoint(); + if (CastInst *CI = + findReusableCastForPtrToAddr(V, Ty, DL, [&](const CastInst *CI) { + return &*BIP != CI && SE.DT.dominates(CI, &*BIP); + })) + return CI; + return ReuseOrCreateCast(V, Ty, CastInst::PtrToAddr, GetOptimalInsertionPointForCastOf(V)); } @@ -1482,6 +1502,25 @@ Value *SCEVExpander::visitPtrToIntExpr(SCEVUseT S) { } Value *SCEVExpander::visitTruncateExpr(SCEVUseT S) { + Type *Ty = S->getType(); + + // When truncating a ptrtoaddr, check for existing ptrtoint instructions that + // convert directly to the target type, to avoid generating redundant + // ptrtoaddr + trunc sequences. + if (auto *PtrToAddr = dyn_cast(S->getOperand())) { + Value *PtrOp = expand(PtrToAddr->getOperand()); + if (!isa(PtrOp)) { + BasicBlock::iterator BIP = Builder.GetInsertPoint(); + for (User *U : PtrOp->users()) { + auto *CI = dyn_cast(U); + if (CI && CI->getType() == Ty && + CI->getOpcode() == CastInst::PtrToInt && &*BIP != CI && + SE.DT.dominates(CI, &*BIP)) + return CI; + } + } + } + Value *V = expand(S->getOperand()); return Builder.CreateTrunc(V, S->getType()); } diff --git a/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp b/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp index 3b3bea2f6e8b..95a4350d5c09 100644 --- a/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp +++ b/llvm/lib/Transforms/Vectorize/VPlanUtils.cpp @@ -934,6 +934,22 @@ VPValue *VPSCEVExpander::tryToExpand(const SCEV *S) { default: llvm_unreachable("Unhandled cast SCEV"); } + + // When expanding ptrtoaddr, first check if there's an existing ptrtoint we + // can reuse. + if (Opcode == Instruction::PtrToAddr) { + VPlan &Plan = Builder.getPlan(); + BasicBlock *PH = cast(Plan.getEntry())->getIRBasicBlock(); + if (auto *IRV = dyn_cast(Op)) { + if (CastInst *CI = SCEVExpander::findReusableCastForPtrToAddr( + IRV->getValue(), S->getType(), PH->getDataLayout(), + [&](const CastInst *CI) { + return SE.DT.dominates(CI->getParent(), PH); + })) + return Plan.getOrAddLiveIn(CI); + } + } + return Builder.createScalarCast(Opcode, Op, S->getType(), DL); } case scUMaxExpr: diff --git a/llvm/test/Analysis/LoopAccessAnalysis/runtime-check-known-true.ll b/llvm/test/Analysis/LoopAccessAnalysis/runtime-check-known-true.ll index 30c80880024b..6ff9f124fa06 100644 --- a/llvm/test/Analysis/LoopAccessAnalysis/runtime-check-known-true.ll +++ b/llvm/test/Analysis/LoopAccessAnalysis/runtime-check-known-true.ll @@ -15,15 +15,15 @@ define void @test_runtime_check_known_false_after_construction(ptr %start.1, ptr ; CHECK-NEXT: %ptr.iv.2 = phi ptr [ %ptr.iv.2.next, %loop ], [ %start.2.diff, %entry ] ; CHECK-NEXT: Grouped accesses: ; CHECK-NEXT: Group GRP0: -; CHECK-NEXT: (Low: ((-8 * ((2305843009213693951 * (8 + (-1 * (ptrtoint ptr %start.1 to i64)) + (ptrtoint ptr %end to i64))) /u 8)) + %start.1) High: (8 + %start.1)) +; CHECK-NEXT: (Low: ((-8 * ((2305843009213693951 * (8 + (-1 * (ptrtoaddr ptr %start.1 to i64)) + (ptrtoaddr ptr %end to i64))) /u 8)) + %start.1) High: (8 + %start.1)) ; CHECK-NEXT: Member: {%start.1,+,-8}<%loop> ; CHECK-NEXT: Group GRP1: -; CHECK-NEXT: (Low: (-8 + (-8 * ((2305843009213693951 * (8 + (-1 * (ptrtoint ptr %start.1 to i64)) + (ptrtoint ptr %end to i64))) /u 8)) + (-1 * (ptrtoint ptr %start.2 to i64)) + (ptrtoint ptr %start.1 to i64) + %start.2) High: ((-1 * (ptrtoint ptr %start.2 to i64)) + (ptrtoint ptr %start.1 to i64) + %start.2)) -; CHECK-NEXT: Member: {(-8 + (-1 * (ptrtoint ptr %start.2 to i64)) + (ptrtoint ptr %start.1 to i64) + %start.2),+,-8}<%loop> +; CHECK-NEXT: (Low: (-8 + (-8 * ((2305843009213693951 * (8 + (-1 * (ptrtoaddr ptr %start.1 to i64)) + (ptrtoaddr ptr %end to i64))) /u 8)) + (-1 * (ptrtoaddr ptr %start.2 to i64)) + (ptrtoaddr ptr %start.1 to i64) + %start.2) High: ((-1 * (ptrtoaddr ptr %start.2 to i64)) + (ptrtoaddr ptr %start.1 to i64) + %start.2)) +; CHECK-NEXT: Member: {(-8 + (-1 * (ptrtoaddr ptr %start.2 to i64)) + (ptrtoaddr ptr %start.1 to i64) + %start.2),+,-8}<%loop> ; CHECK-EMPTY: ; CHECK-NEXT: Non vectorizable stores to invariant address were not found in loop. ; CHECK-NEXT: SCEV assumptions: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %end to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %start.1 to i64) to i3))) to i64) == 0 +; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoaddr ptr %end to i64) to i3) + (-1 * (trunc i64 (ptrtoaddr ptr %start.1 to i64) to i3))) to i64) == 0 ; CHECK-EMPTY: ; CHECK-NEXT: Expressions re-written: ; diff --git a/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll b/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll index 7120eec5982e..5dffee19cb31 100644 --- a/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll +++ b/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll @@ -30,9 +30,9 @@ define i32 @d(i32 %base) { ; CHECK-NEXT: %load1 = load ptr, ptr @c, align 8 ; CHECK-NEXT: --> %load1 U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: %sub.ptr.lhs.cast = ptrtoint ptr %load1 to i64 -; CHECK-NEXT: --> (ptrtoint ptr %load1 to i64) U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } +; CHECK-NEXT: --> %sub.ptr.lhs.cast U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, ptrtoint (ptr @b to i64) -; CHECK-NEXT: --> ((-1 * (ptrtoint ptr @b to i64)) + (ptrtoint ptr %load1 to i64)) U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } +; CHECK-NEXT: --> ((-1 * (ptrtoaddr ptr @b to i64)) + (ptrtoaddr ptr %load1 to i64)) U: full-set S: full-set Exits: <> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: %sub.ptr.div = sdiv exact i64 %sub.ptr.sub, 4 ; CHECK-NEXT: --> %sub.ptr.div U: [-2305843009213693952,2305843009213693952) S: [-2305843009213693952,2305843009213693952) Exits: <> LoopDispositions: { %for.cond: Variant } ; CHECK-NEXT: %arrayidx1 = getelementptr inbounds [1 x i8], ptr %arrayidx, i64 0, i64 %sub.ptr.div diff --git a/llvm/test/Analysis/ScalarEvolution/alloca.ll b/llvm/test/Analysis/ScalarEvolution/alloca.ll index d4e00c69dcf6..97555be0991c 100644 --- a/llvm/test/Analysis/ScalarEvolution/alloca.ll +++ b/llvm/test/Analysis/ScalarEvolution/alloca.ll @@ -7,7 +7,7 @@ define i64 @alloca_non_null() { ; CHECK-NEXT: %alloca = alloca i32, align 4 ; CHECK-NEXT: --> %alloca U: [4,-7) S: [-9223372036854775808,9223372036854775805) ; CHECK-NEXT: %int = ptrtoint ptr %alloca to i64 -; CHECK-NEXT: --> (ptrtoint ptr %alloca to i64) U: [4,-7) S: [-9223372036854775808,9223372036854775805) +; CHECK-NEXT: --> %int U: [0,-3) S: [-9223372036854775808,9223372036854775805) ; CHECK-NEXT: Determining loop execution counts for: @alloca_non_null ; %alloca = alloca i32, align 4 @@ -21,7 +21,7 @@ define i64 @alloca_maybe_null() { ; CHECK-NEXT: %alloca = alloca i32, align 4, addrspace(1) ; CHECK-NEXT: --> %alloca U: [0,-7) S: [-9223372036854775808,9223372036854775805) ; CHECK-NEXT: %int = ptrtoint ptr addrspace(1) %alloca to i64 -; CHECK-NEXT: --> (ptrtoint ptr addrspace(1) %alloca to i64) U: [0,-7) S: [-9223372036854775808,9223372036854775805) +; CHECK-NEXT: --> %int U: [0,-3) S: [-9223372036854775808,9223372036854775805) ; CHECK-NEXT: Determining loop execution counts for: @alloca_maybe_null ; %alloca = alloca i32, align 4, addrspace(1) diff --git a/llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll b/llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll index 77642f0c3f1e..c200c8c5e773 100644 --- a/llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll +++ b/llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll @@ -507,9 +507,9 @@ define i64 @uminseq_vs_ptrtoint_complexity(i64 %n, i64 %m, ptr %ptr) { ; CHECK-NEXT: %cond = select i1 %cond_p0, i1 %cond_p1, i1 false ; CHECK-NEXT: --> (%cond_p0 umin_seq %cond_p1) U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Variant } ; CHECK-NEXT: %ptr.int = ptrtoint ptr %ptr to i64 -; CHECK-NEXT: --> (ptrtoint ptr %ptr to i64) U: full-set S: full-set +; CHECK-NEXT: --> %ptr.int U: full-set S: full-set ; CHECK-NEXT: %r = add i64 %i, %ptr.int -; CHECK-NEXT: --> {(ptrtoint ptr %ptr to i64),+,1}<%loop> U: full-set S: full-set --> ((%n umin_seq %m) + (ptrtoint ptr %ptr to i64)) U: full-set S: full-set +; CHECK-NEXT: --> ({0,+,1}<%loop> + %ptr.int) U: full-set S: full-set --> ((%n umin_seq %m) + %ptr.int) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @uminseq_vs_ptrtoint_complexity ; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -1 diff --git a/llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll b/llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll index f7ebfbbd50ca..ce899726d44c 100644 --- a/llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll +++ b/llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll @@ -2044,13 +2044,13 @@ define void @addrec_gep_inbounds_nneg(ptr %p, ptr %end) { ; CHECK-LABEL: 'addrec_gep_inbounds_nneg' ; CHECK-NEXT: Classifying expressions for: @addrec_gep_inbounds_nneg ; CHECK-NEXT: %iv = phi ptr [ %p, %entry ], [ %iv.next, %loop ] -; CHECK-NEXT: --> {%p,+,4}<%loop> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %p to i64)) + (ptrtoint ptr %end to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%p,+,4}<%loop> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %p to i64)) + (ptrtoaddr ptr %end to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.next = getelementptr inbounds i32, ptr %iv, i64 1 -; CHECK-NEXT: --> {(4 + %p),+,4}<%loop> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %p to i64)) + (ptrtoint ptr %end to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(4 + %p),+,4}<%loop> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-4 + (-1 * (ptrtoaddr ptr %p to i64)) + (ptrtoaddr ptr %end to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @addrec_gep_inbounds_nneg -; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %p to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %p to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 4611686018427387903 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %p to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %p to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: @@ -2068,13 +2068,13 @@ define void @addrec_gep_inbounds_neg(ptr %p, ptr %end) { ; CHECK-LABEL: 'addrec_gep_inbounds_neg' ; CHECK-NEXT: Classifying expressions for: @addrec_gep_inbounds_neg ; CHECK-NEXT: %iv = phi ptr [ %p, %entry ], [ %iv.next, %loop ] -; CHECK-NEXT: --> {%p,+,-4}<%loop> U: full-set S: full-set Exits: ((-4 * ((-4 + (-1 * (ptrtoint ptr %end to i64)) + (ptrtoint ptr %p to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%p,+,-4}<%loop> U: full-set S: full-set Exits: ((-4 * ((-4 + (-1 * (ptrtoaddr ptr %end to i64)) + (ptrtoaddr ptr %p to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.next = getelementptr inbounds i32, ptr %iv, i64 -1 -; CHECK-NEXT: --> {(-4 + %p),+,-4}<%loop> U: full-set S: full-set Exits: (-4 + (-4 * ((-4 + (-1 * (ptrtoint ptr %end to i64)) + (ptrtoint ptr %p to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(-4 + %p),+,-4}<%loop> U: full-set S: full-set Exits: (-4 + (-4 * ((-4 + (-1 * (ptrtoaddr ptr %end to i64)) + (ptrtoaddr ptr %p to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @addrec_gep_inbounds_neg -; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %end to i64)) + (ptrtoint ptr %p to i64)) /u 4) +; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %end to i64)) + (ptrtoaddr ptr %p to i64)) /u 4) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 4611686018427387903 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %end to i64)) + (ptrtoint ptr %p to i64)) /u 4) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %end to i64)) + (ptrtoaddr ptr %p to i64)) /u 4) ; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: @@ -2092,13 +2092,13 @@ define void @addrec_gep_nusw_nneg(ptr %p, ptr %end) { ; CHECK-LABEL: 'addrec_gep_nusw_nneg' ; CHECK-NEXT: Classifying expressions for: @addrec_gep_nusw_nneg ; CHECK-NEXT: %iv = phi ptr [ %p, %entry ], [ %iv.next, %loop ] -; CHECK-NEXT: --> {%p,+,4}<%loop> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %p to i64)) + (ptrtoint ptr %end to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%p,+,4}<%loop> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %p to i64)) + (ptrtoaddr ptr %end to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.next = getelementptr nusw i32, ptr %iv, i64 1 -; CHECK-NEXT: --> {(4 + %p),+,4}<%loop> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %p to i64)) + (ptrtoint ptr %end to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(4 + %p),+,4}<%loop> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-4 + (-1 * (ptrtoaddr ptr %p to i64)) + (ptrtoaddr ptr %end to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @addrec_gep_nusw_nneg -; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %p to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %p to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 4611686018427387903 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %p to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %p to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: @@ -2116,13 +2116,13 @@ define void @addrec_gep_nusw_neg(ptr %p, ptr %end) { ; CHECK-LABEL: 'addrec_gep_nusw_neg' ; CHECK-NEXT: Classifying expressions for: @addrec_gep_nusw_neg ; CHECK-NEXT: %iv = phi ptr [ %p, %entry ], [ %iv.next, %loop ] -; CHECK-NEXT: --> {%p,+,-4}<%loop> U: full-set S: full-set Exits: ((-4 * ((-4 + (-1 * (ptrtoint ptr %end to i64)) + (ptrtoint ptr %p to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%p,+,-4}<%loop> U: full-set S: full-set Exits: ((-4 * ((-4 + (-1 * (ptrtoaddr ptr %end to i64)) + (ptrtoaddr ptr %p to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.next = getelementptr nusw i32, ptr %iv, i64 -1 -; CHECK-NEXT: --> {(-4 + %p),+,-4}<%loop> U: full-set S: full-set Exits: (-4 + (-4 * ((-4 + (-1 * (ptrtoint ptr %end to i64)) + (ptrtoint ptr %p to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(-4 + %p),+,-4}<%loop> U: full-set S: full-set Exits: (-4 + (-4 * ((-4 + (-1 * (ptrtoaddr ptr %end to i64)) + (ptrtoaddr ptr %p to i64)) /u 4)) + %p) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @addrec_gep_nusw_neg -; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %end to i64)) + (ptrtoint ptr %p to i64)) /u 4) +; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %end to i64)) + (ptrtoaddr ptr %p to i64)) /u 4) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 4611686018427387903 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %end to i64)) + (ptrtoint ptr %p to i64)) /u 4) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %end to i64)) + (ptrtoaddr ptr %p to i64)) /u 4) ; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: diff --git a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll index 03c3f0e80e0e..1cc52d34758d 100644 --- a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll +++ b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll @@ -778,13 +778,13 @@ define void @crash(ptr %ptr) { ; CHECK-NEXT: %incdec.ptr112 = getelementptr inbounds i8, ptr %text.addr.5, i64 -1 ; CHECK-NEXT: --> {(-1 + null),+,-1}<%while.cond111> U: full-set S: full-set Exits: <> LoopDispositions: { %while.cond111: Computable, %while.body: Uniform } ; CHECK-NEXT: %lastout.2271 = phi ptr [ %incdec.ptr126, %while.body125 ], [ %ptr, %while.end117 ] -; CHECK-NEXT: --> {%ptr,+,1}<%while.body125> U: full-set S: full-set Exits: {(-2 + (-1 * (ptrtoint ptr %ptr to i64)) + %ptr),+,-1}<%while.cond111> LoopDispositions: { %while.body125: Computable } +; CHECK-NEXT: --> {%ptr,+,1}<%while.body125> U: full-set S: full-set Exits: {(-2 + (-1 * (ptrtoaddr ptr %ptr to i64)) + %ptr),+,-1}<%while.cond111> LoopDispositions: { %while.body125: Computable } ; CHECK-NEXT: %incdec.ptr126 = getelementptr inbounds i8, ptr %lastout.2271, i64 1 -; CHECK-NEXT: --> {(1 + %ptr),+,1}<%while.body125> U: full-set S: full-set Exits: {(-1 + (-1 * (ptrtoint ptr %ptr to i64)) + %ptr),+,-1}<%while.cond111> LoopDispositions: { %while.body125: Computable } +; CHECK-NEXT: --> {(1 + %ptr),+,1}<%while.body125> U: full-set S: full-set Exits: {(-1 + (-1 * (ptrtoaddr ptr %ptr to i64)) + %ptr),+,-1}<%while.cond111> LoopDispositions: { %while.body125: Computable } ; CHECK-NEXT: Determining loop execution counts for: @crash -; CHECK-NEXT: Loop %while.body125: backedge-taken count is {(-2 + (-1 * (ptrtoint ptr %ptr to i64))),+,-1}<%while.cond111> +; CHECK-NEXT: Loop %while.body125: backedge-taken count is {(-2 + (-1 * (ptrtoaddr ptr %ptr to i64))),+,-1}<%while.cond111> ; CHECK-NEXT: Loop %while.body125: constant max backedge-taken count is i64 -2 -; CHECK-NEXT: Loop %while.body125: symbolic max backedge-taken count is {(-2 + (-1 * (ptrtoint ptr %ptr to i64))),+,-1}<%while.cond111> +; CHECK-NEXT: Loop %while.body125: symbolic max backedge-taken count is {(-2 + (-1 * (ptrtoaddr ptr %ptr to i64))),+,-1}<%while.cond111> ; CHECK-NEXT: Loop %while.body125: Trip multiple is 1 ; CHECK-NEXT: Loop %while.cond111: Unpredictable backedge-taken count. ; CHECK-NEXT: Loop %while.cond111: Unpredictable constant max backedge-taken count. @@ -1361,13 +1361,13 @@ define void @ptr_induction_eq_1(ptr %a, ptr %b) { ; CHECK-LABEL: 'ptr_induction_eq_1' ; CHECK-NEXT: Classifying expressions for: @ptr_induction_eq_1 ; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop ], [ %a, %entry ] -; CHECK-NEXT: --> {%a,+,8}<%loop> U: full-set S: full-set Exits: ((8 * ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8)) + %a) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%a,+,8}<%loop> U: full-set S: full-set Exits: ((8 * ((-8 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 8)) + %a) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8 -; CHECK-NEXT: --> {(8 + %a),+,8}<%loop> U: full-set S: full-set Exits: (8 + (8 * ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8)) + %a) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(8 + %a),+,8}<%loop> U: full-set S: full-set Exits: (8 + (8 * ((-8 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 8)) + %a) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_eq_1 -; CHECK-NEXT: Loop %loop: backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8) +; CHECK-NEXT: Loop %loop: backedge-taken count is ((-8 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 8) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693951 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 8) ; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: @@ -1430,11 +1430,11 @@ define void @ptr_induction_early_exit_eq_1_with_align_on_load(ptr %a, ptr %b, pt ; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_with_align_on_load ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) +; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoaddr ptr %a_ to i64)) + (ptrtoaddr ptr %b_ to i64)) /u 8) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693950 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoaddr ptr %a_ to i64)) + (ptrtoaddr ptr %b_ to i64)) /u 8) ; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) +; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoaddr ptr %a_ to i64)) + (ptrtoaddr ptr %b_ to i64)) /u 8) ; entry: %a_ = load ptr, ptr %a, !align !{i64 8} @@ -1469,11 +1469,11 @@ define void @ptr_induction_early_exit_eq_1_with_align_on_arguments(ptr align 8 % ; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_with_align_on_arguments ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8) +; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 8) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693950 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 8) ; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8) +; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 8) ; entry: %cmp = icmp eq ptr %a, %b @@ -1510,11 +1510,11 @@ define void @ptr_induction_early_exit_eq_1_align_assumption_1(ptr %a, ptr %b, pt ; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_align_assumption_1 ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) +; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoaddr ptr %a_ to i64)) + (ptrtoaddr ptr %b_ to i64)) /u 8) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693950 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoaddr ptr %a_ to i64)) + (ptrtoaddr ptr %b_ to i64)) /u 8) ; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) +; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoaddr ptr %a_ to i64)) + (ptrtoaddr ptr %b_ to i64)) /u 8) ; entry: %a_ = load ptr, ptr %a @@ -1555,11 +1555,11 @@ define void @ptr_induction_early_exit_eq_1_align_assumption_2(ptr %a, ptr %b, pt ; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_align_assumption_2 ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) +; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoaddr ptr %a_ to i64)) + (ptrtoaddr ptr %b_ to i64)) /u 8) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693950 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoaddr ptr %a_ to i64)) + (ptrtoaddr ptr %b_ to i64)) /u 8) ; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) +; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoaddr ptr %a_ to i64)) + (ptrtoaddr ptr %b_ to i64)) /u 8) ; entry: %a_ = load ptr, ptr %a diff --git a/llvm/test/Analysis/ScalarEvolution/ne-guard-multiple-trip-count.ll b/llvm/test/Analysis/ScalarEvolution/ne-guard-multiple-trip-count.ll index 220c5a1deb1a..f808f5351dc3 100644 --- a/llvm/test/Analysis/ScalarEvolution/ne-guard-multiple-trip-count.ll +++ b/llvm/test/Analysis/ScalarEvolution/ne-guard-multiple-trip-count.ll @@ -9,13 +9,13 @@ define void @test_guard_order_b_then_c_and_d(ptr %a, ptr %b, ptr %c, ptr %d) { ; CHECK-LABEL: 'test_guard_order_b_then_c_and_d' ; CHECK-NEXT: Classifying expressions for: @test_guard_order_b_then_c_and_d ; CHECK-NEXT: %iv = phi ptr [ %a, %entry ], [ %iv.next, %loop ] -; CHECK-NEXT: --> {%a,+,1}<%loop> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64) + %a) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%a,+,1}<%loop> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64) + %a) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.next = getelementptr i8, ptr %iv, i64 1 -; CHECK-NEXT: --> {(1 + %a),+,1}<%loop> U: full-set S: full-set Exits: ((-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64) + %a) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(1 + %a),+,1}<%loop> U: full-set S: full-set Exits: ((-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64) + %a) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @test_guard_order_b_then_c_and_d -; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) +; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -2 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) ; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: @@ -42,13 +42,13 @@ define void @test_guard_order_d_then_c_and_b(ptr %a, ptr %b, ptr %c, ptr %d) { ; CHECK-LABEL: 'test_guard_order_d_then_c_and_b' ; CHECK-NEXT: Classifying expressions for: @test_guard_order_d_then_c_and_b ; CHECK-NEXT: %iv = phi ptr [ %a, %entry ], [ %iv.next, %loop ] -; CHECK-NEXT: --> {%a,+,1}<%loop> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64) + %a) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%a,+,1}<%loop> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64) + %a) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.next = getelementptr i8, ptr %iv, i64 1 -; CHECK-NEXT: --> {(1 + %a),+,1}<%loop> U: full-set S: full-set Exits: ((-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64) + %a) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(1 + %a),+,1}<%loop> U: full-set S: full-set Exits: ((-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64) + %a) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @test_guard_order_d_then_c_and_b -; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) +; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -2 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) ; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: diff --git a/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll b/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll index b096adc7c5eb..4a997ca565b2 100644 --- a/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll +++ b/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll @@ -185,19 +185,19 @@ define void @f3(ptr %x_addr, ptr %y_addr, ptr %tmp_addr) { ; CHECK-NEXT: %ptr = bitcast ptr @z_addr to ptr ; CHECK-NEXT: --> @z_addr U: [4,-19) S: [-9223372036854775808,9223372036854775805) ; CHECK-NEXT: %int0 = ptrtoint ptr %ptr to i32 -; CHECK-NEXT: --> (trunc i64 (ptrtoint ptr @z_addr to i64) to i32) U: [0,-3) S: [-2147483648,2147483645) +; CHECK-NEXT: --> %int0 U: [0,-3) S: [-2147483648,2147483645) ; CHECK-NEXT: %int5 = add i32 %int0, 5 -; CHECK-NEXT: --> (5 + (trunc i64 (ptrtoint ptr @z_addr to i64) to i32)) U: [5,2) S: [-2147483643,-2147483646) +; CHECK-NEXT: --> (5 + %int0) U: [5,2) S: [-2147483643,-2147483646) ; CHECK-NEXT: %int.zext = zext i32 %int5 to i64 -; CHECK-NEXT: --> (1 + (zext i32 (4 + (trunc i64 (ptrtoint ptr @z_addr to i64) to i32)) to i64)) U: [1,4294967294) S: [1,4294967297) +; CHECK-NEXT: --> (1 + (zext i32 (4 + %int0) to i64)) U: [1,4294967294) S: [1,4294967297) ; CHECK-NEXT: %ptr_noalign = bitcast ptr @z_addr_noalign to ptr ; CHECK-NEXT: --> @z_addr_noalign U: [1,-16) S: full-set ; CHECK-NEXT: %int0_na = ptrtoint ptr %ptr_noalign to i32 -; CHECK-NEXT: --> (trunc i64 (ptrtoint ptr @z_addr_noalign to i64) to i32) U: full-set S: full-set +; CHECK-NEXT: --> %int0_na U: full-set S: full-set ; CHECK-NEXT: %int5_na = add i32 %int0_na, 5 -; CHECK-NEXT: --> (5 + (trunc i64 (ptrtoint ptr @z_addr_noalign to i64) to i32)) U: full-set S: full-set +; CHECK-NEXT: --> (5 + %int0_na) U: full-set S: full-set ; CHECK-NEXT: %int.zext_na = zext i32 %int5_na to i64 -; CHECK-NEXT: --> (zext i32 (5 + (trunc i64 (ptrtoint ptr @z_addr_noalign to i64) to i32)) to i64) U: [0,4294967296) S: [0,4294967296) +; CHECK-NEXT: --> (zext i32 (5 + %int0_na) to i64) U: [0,4294967296) S: [0,4294967296) ; CHECK-NEXT: %tmp = load i32, ptr %tmp_addr, align 4 ; CHECK-NEXT: --> %tmp U: full-set S: full-set ; CHECK-NEXT: %mul = and i32 %tmp, -4 diff --git a/llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll b/llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll index e13a8976bf5a..85c213c7ab09 100644 --- a/llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll +++ b/llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll @@ -126,13 +126,13 @@ define void @pointer_iv_nowrap_guard(ptr %startptr, ptr %endptr) local_unnamed_a ; CHECK-NEXT: %init = getelementptr inbounds i32, ptr %startptr, i64 2000 ; CHECK-NEXT: --> (8000 + %startptr) U: [8000,0) S: [8000,0) ; CHECK-NEXT: %iv = phi ptr [ %init, %entry ], [ %iv.next, %loop ] -; CHECK-NEXT: --> {(8000 + %startptr),+,4}<%loop> U: [8000,0) S: [8000,0) Exits: (8000 + (4 * ((-8001 + (-1 * (ptrtoint ptr %startptr to i64)) + ((8004 + (ptrtoint ptr %startptr to i64)) umax (ptrtoint ptr %endptr to i64))) /u 4)) + %startptr) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(8000 + %startptr),+,4}<%loop> U: [8000,0) S: [8000,0) Exits: (8000 + (4 * ((-8001 + (-1 * (ptrtoaddr ptr %startptr to i64)) + ((8004 + (ptrtoaddr ptr %startptr to i64)) umax (ptrtoaddr ptr %endptr to i64))) /u 4)) + %startptr) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.next = getelementptr inbounds i32, ptr %iv, i64 1 -; CHECK-NEXT: --> {(8004 + %startptr),+,4}<%loop> U: full-set S: full-set Exits: (8004 + (4 * ((-8001 + (-1 * (ptrtoint ptr %startptr to i64)) + ((8004 + (ptrtoint ptr %startptr to i64)) umax (ptrtoint ptr %endptr to i64))) /u 4)) + %startptr) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(8004 + %startptr),+,4}<%loop> U: full-set S: full-set Exits: (8004 + (4 * ((-8001 + (-1 * (ptrtoaddr ptr %startptr to i64)) + ((8004 + (ptrtoaddr ptr %startptr to i64)) umax (ptrtoaddr ptr %endptr to i64))) /u 4)) + %startptr) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @pointer_iv_nowrap_guard -; CHECK-NEXT: Loop %loop: backedge-taken count is ((-8001 + (-1 * (ptrtoint ptr %startptr to i64)) + ((8004 + (ptrtoint ptr %startptr to i64)) umax (ptrtoint ptr %endptr to i64))) /u 4) +; CHECK-NEXT: Loop %loop: backedge-taken count is ((-8001 + (-1 * (ptrtoaddr ptr %startptr to i64)) + ((8004 + (ptrtoaddr ptr %startptr to i64)) umax (ptrtoaddr ptr %endptr to i64))) /u 4) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 4611686018427387903 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8001 + (-1 * (ptrtoint ptr %startptr to i64)) + ((8004 + (ptrtoint ptr %startptr to i64)) umax (ptrtoint ptr %endptr to i64))) /u 4) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8001 + (-1 * (ptrtoaddr ptr %startptr to i64)) + ((8004 + (ptrtoaddr ptr %startptr to i64)) umax (ptrtoaddr ptr %endptr to i64))) /u 4) ; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: diff --git a/llvm/test/Analysis/ScalarEvolution/nsw.ll b/llvm/test/Analysis/ScalarEvolution/nsw.ll index 4d668d1ffef1..c529f9e39a13 100644 --- a/llvm/test/Analysis/ScalarEvolution/nsw.ll +++ b/llvm/test/Analysis/ScalarEvolution/nsw.ll @@ -71,13 +71,13 @@ define void @test2(ptr %begin, ptr %end) ssp { ; CHECK-LABEL: 'test2' ; CHECK-NEXT: Classifying expressions for: @test2 ; CHECK-NEXT: %__first.addr.02.i.i = phi ptr [ %begin, %for.body.lr.ph.i.i ], [ %ptrincdec.i.i, %for.body.i.i ] -; CHECK-NEXT: --> {%begin,+,4}<%for.body.i.i> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)) + %begin) LoopDispositions: { %for.body.i.i: Computable } +; CHECK-NEXT: --> {%begin,+,4}<%for.body.i.i> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %begin to i64)) + (ptrtoaddr ptr %end to i64)) /u 4)) + %begin) LoopDispositions: { %for.body.i.i: Computable } ; CHECK-NEXT: %ptrincdec.i.i = getelementptr inbounds i32, ptr %__first.addr.02.i.i, i64 1 -; CHECK-NEXT: --> {(4 + %begin),+,4}<%for.body.i.i> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)) + %begin) LoopDispositions: { %for.body.i.i: Computable } +; CHECK-NEXT: --> {(4 + %begin),+,4}<%for.body.i.i> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoaddr ptr %begin to i64)) + (ptrtoaddr ptr %end to i64)) /u 4)) + %begin) LoopDispositions: { %for.body.i.i: Computable } ; CHECK-NEXT: Determining loop execution counts for: @test2 -; CHECK-NEXT: Loop %for.body.i.i: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %for.body.i.i: backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %begin to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Loop %for.body.i.i: constant max backedge-taken count is i64 4611686018427387903 -; CHECK-NEXT: Loop %for.body.i.i: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %for.body.i.i: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %begin to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Loop %for.body.i.i: Trip multiple is 1 ; entry: @@ -106,17 +106,17 @@ define void @test3(ptr %begin, ptr %end) nounwind ssp { ; CHECK-LABEL: 'test3' ; CHECK-NEXT: Classifying expressions for: @test3 ; CHECK-NEXT: %indvar.i.i = phi i64 [ %tmp, %for.body.i.i ], [ 0, %entry ] -; CHECK-NEXT: --> {0,+,1}<%for.body.i.i> U: [0,4611686018427387904) S: [0,4611686018427387904) Exits: ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4) LoopDispositions: { %for.body.i.i: Computable } +; CHECK-NEXT: --> {0,+,1}<%for.body.i.i> U: [0,4611686018427387904) S: [0,4611686018427387904) Exits: ((-4 + (-1 * (ptrtoaddr ptr %begin to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) LoopDispositions: { %for.body.i.i: Computable } ; CHECK-NEXT: %tmp = add nsw i64 %indvar.i.i, 1 -; CHECK-NEXT: --> {1,+,1}<%for.body.i.i> U: [1,4611686018427387905) S: [1,4611686018427387905) Exits: (1 + ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)) LoopDispositions: { %for.body.i.i: Computable } +; CHECK-NEXT: --> {1,+,1}<%for.body.i.i> U: [1,4611686018427387905) S: [1,4611686018427387905) Exits: (1 + ((-4 + (-1 * (ptrtoaddr ptr %begin to i64)) + (ptrtoaddr ptr %end to i64)) /u 4)) LoopDispositions: { %for.body.i.i: Computable } ; CHECK-NEXT: %ptrincdec.i.i = getelementptr inbounds i32, ptr %begin, i64 %tmp -; CHECK-NEXT: --> {(4 + %begin),+,4}<%for.body.i.i> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)) + %begin) LoopDispositions: { %for.body.i.i: Computable } +; CHECK-NEXT: --> {(4 + %begin),+,4}<%for.body.i.i> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoaddr ptr %begin to i64)) + (ptrtoaddr ptr %end to i64)) /u 4)) + %begin) LoopDispositions: { %for.body.i.i: Computable } ; CHECK-NEXT: %__first.addr.08.i.i = getelementptr inbounds i32, ptr %begin, i64 %indvar.i.i -; CHECK-NEXT: --> {%begin,+,4}<%for.body.i.i> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)) + %begin) LoopDispositions: { %for.body.i.i: Computable } +; CHECK-NEXT: --> {%begin,+,4}<%for.body.i.i> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %begin to i64)) + (ptrtoaddr ptr %end to i64)) /u 4)) + %begin) LoopDispositions: { %for.body.i.i: Computable } ; CHECK-NEXT: Determining loop execution counts for: @test3 -; CHECK-NEXT: Loop %for.body.i.i: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %for.body.i.i: backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %begin to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Loop %for.body.i.i: constant max backedge-taken count is i64 4611686018427387903 -; CHECK-NEXT: Loop %for.body.i.i: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %for.body.i.i: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %begin to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Loop %for.body.i.i: Trip multiple is 1 ; entry: @@ -200,13 +200,13 @@ define void @PR12376(ptr nocapture %arg, ptr nocapture %arg1) { ; CHECK-LABEL: 'PR12376' ; CHECK-NEXT: Classifying expressions for: @PR12376 ; CHECK-NEXT: %tmp = phi ptr [ %arg, %bb ], [ %tmp4, %bb2 ] -; CHECK-NEXT: --> {%arg,+,4}<%bb2> U: full-set S: full-set Exits: ((4 * ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64)) umax (ptrtoint ptr %arg1 to i64))) /u 4)) + %arg) LoopDispositions: { %bb2: Computable } +; CHECK-NEXT: --> {%arg,+,4}<%bb2> U: full-set S: full-set Exits: ((4 * ((-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + ((4 + (ptrtoaddr ptr %arg to i64)) umax (ptrtoaddr ptr %arg1 to i64))) /u 4)) + %arg) LoopDispositions: { %bb2: Computable } ; CHECK-NEXT: %tmp4 = getelementptr inbounds i32, ptr %tmp, i64 1 -; CHECK-NEXT: --> {(4 + %arg),+,4}<%bb2> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64)) umax (ptrtoint ptr %arg1 to i64))) /u 4)) + %arg) LoopDispositions: { %bb2: Computable } +; CHECK-NEXT: --> {(4 + %arg),+,4}<%bb2> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + ((4 + (ptrtoaddr ptr %arg to i64)) umax (ptrtoaddr ptr %arg1 to i64))) /u 4)) + %arg) LoopDispositions: { %bb2: Computable } ; CHECK-NEXT: Determining loop execution counts for: @PR12376 -; CHECK-NEXT: Loop %bb2: backedge-taken count is ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64)) umax (ptrtoint ptr %arg1 to i64))) /u 4) +; CHECK-NEXT: Loop %bb2: backedge-taken count is ((-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + ((4 + (ptrtoaddr ptr %arg to i64)) umax (ptrtoaddr ptr %arg1 to i64))) /u 4) ; CHECK-NEXT: Loop %bb2: constant max backedge-taken count is i64 4611686018427387902 -; CHECK-NEXT: Loop %bb2: symbolic max backedge-taken count is ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64)) umax (ptrtoint ptr %arg1 to i64))) /u 4) +; CHECK-NEXT: Loop %bb2: symbolic max backedge-taken count is ((-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + ((4 + (ptrtoaddr ptr %arg to i64)) umax (ptrtoaddr ptr %arg1 to i64))) /u 4) ; CHECK-NEXT: Loop %bb2: Trip multiple is 1 ; bb: diff --git a/llvm/test/Analysis/ScalarEvolution/pointer-rounding.ll b/llvm/test/Analysis/ScalarEvolution/pointer-rounding.ll index 6d6143367756..38d96241b53a 100644 --- a/llvm/test/Analysis/ScalarEvolution/pointer-rounding.ll +++ b/llvm/test/Analysis/ScalarEvolution/pointer-rounding.ll @@ -5,13 +5,13 @@ define ptr @pointer_align_down(ptr %obj) { ; CHECK-LABEL: 'pointer_align_down' ; CHECK-NEXT: Classifying expressions for: @pointer_align_down ; CHECK-NEXT: %i = ptrtoint ptr %obj to i64 -; CHECK-NEXT: --> (ptrtoint ptr %obj to i64) U: full-set S: full-set +; CHECK-NEXT: --> %i U: full-set S: full-set ; CHECK-NEXT: %i2 = and i64 %i, 15 -; CHECK-NEXT: --> (zext i4 (trunc i64 (ptrtoint ptr %obj to i64) to i4) to i64) U: [0,16) S: [0,16) +; CHECK-NEXT: --> (zext i4 (trunc i64 %i to i4) to i64) U: [0,16) S: [0,16) ; CHECK-NEXT: %i3 = sub nsw i64 0, %i2 -; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj to i64) to i4) to i64)) U: [-15,1) S: [-15,1) +; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 %i to i4) to i64)) U: [-15,1) S: [-15,1) ; CHECK-NEXT: %i4 = getelementptr i8, ptr %obj, i64 %i3 -; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj to i64) to i4) to i64)) + %obj) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 %i to i4) to i64)) + %obj) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @pointer_align_down ; %i = ptrtoint ptr %obj to i64 @@ -25,13 +25,13 @@ define ptr @pointer_align_down_different_donor(ptr %obj_to_align, ptr %obj_donor ; CHECK-LABEL: 'pointer_align_down_different_donor' ; CHECK-NEXT: Classifying expressions for: @pointer_align_down_different_donor ; CHECK-NEXT: %i = ptrtoint ptr %obj_donor to i64 -; CHECK-NEXT: --> (ptrtoint ptr %obj_donor to i64) U: full-set S: full-set +; CHECK-NEXT: --> %i U: full-set S: full-set ; CHECK-NEXT: %i2 = and i64 %i, 15 -; CHECK-NEXT: --> (zext i4 (trunc i64 (ptrtoint ptr %obj_donor to i64) to i4) to i64) U: [0,16) S: [0,16) +; CHECK-NEXT: --> (zext i4 (trunc i64 %i to i4) to i64) U: [0,16) S: [0,16) ; CHECK-NEXT: %i3 = sub nsw i64 0, %i2 -; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj_donor to i64) to i4) to i64)) U: [-15,1) S: [-15,1) +; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 %i to i4) to i64)) U: [-15,1) S: [-15,1) ; CHECK-NEXT: %i4 = getelementptr i8, ptr %obj_to_align, i64 %i3 -; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj_donor to i64) to i4) to i64)) + %obj_to_align) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 %i to i4) to i64)) + %obj_to_align) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @pointer_align_down_different_donor ; %i = ptrtoint ptr %obj_donor to i64 @@ -45,15 +45,15 @@ define ptr @pointer_align_up(ptr noundef %obj) { ; CHECK-LABEL: 'pointer_align_up' ; CHECK-NEXT: Classifying expressions for: @pointer_align_up ; CHECK-NEXT: %intptr = ptrtoint ptr %obj to i64 -; CHECK-NEXT: --> (ptrtoint ptr %obj to i64) U: full-set S: full-set +; CHECK-NEXT: --> %intptr U: full-set S: full-set ; CHECK-NEXT: %over_boundary = add i64 %intptr, 15 -; CHECK-NEXT: --> (15 + (ptrtoint ptr %obj to i64)) U: full-set S: full-set +; CHECK-NEXT: --> (15 + %intptr) U: full-set S: full-set ; CHECK-NEXT: %aligned_intptr = and i64 %over_boundary, -16 -; CHECK-NEXT: --> (16 * ((15 + (ptrtoint ptr %obj to i64)) /u 16)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) +; CHECK-NEXT: --> (16 * ((15 + %intptr) /u 16)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: %diff = sub i64 %aligned_intptr, %intptr -; CHECK-NEXT: --> ((16 * ((15 + (ptrtoint ptr %obj to i64)) /u 16)) + (-1 * (ptrtoint ptr %obj to i64))) U: full-set S: full-set +; CHECK-NEXT: --> ((16 * ((15 + %intptr) /u 16)) + (-1 * %intptr)) U: full-set S: full-set ; CHECK-NEXT: %aligned_result = getelementptr i8, ptr %obj, i64 %diff -; CHECK-NEXT: --> ((16 * ((15 + (ptrtoint ptr %obj to i64)) /u 16)) + (-1 * (ptrtoint ptr %obj to i64)) + %obj) U: full-set S: full-set +; CHECK-NEXT: --> ((16 * ((15 + %intptr) /u 16)) + (-1 * %intptr) + %obj) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @pointer_align_up ; %intptr = ptrtoint ptr %obj to i64 @@ -68,15 +68,15 @@ define ptr @pointer_align_up_different_donor(ptr noundef %obj_to_align, ptr %obj ; CHECK-LABEL: 'pointer_align_up_different_donor' ; CHECK-NEXT: Classifying expressions for: @pointer_align_up_different_donor ; CHECK-NEXT: %intptr = ptrtoint ptr %obj_donor to i64 -; CHECK-NEXT: --> (ptrtoint ptr %obj_donor to i64) U: full-set S: full-set +; CHECK-NEXT: --> %intptr U: full-set S: full-set ; CHECK-NEXT: %over_boundary = add i64 %intptr, 15 -; CHECK-NEXT: --> (15 + (ptrtoint ptr %obj_donor to i64)) U: full-set S: full-set +; CHECK-NEXT: --> (15 + %intptr) U: full-set S: full-set ; CHECK-NEXT: %aligned_intptr = and i64 %over_boundary, -16 -; CHECK-NEXT: --> (16 * ((15 + (ptrtoint ptr %obj_donor to i64)) /u 16)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) +; CHECK-NEXT: --> (16 * ((15 + %intptr) /u 16)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: %diff = sub i64 %aligned_intptr, %intptr -; CHECK-NEXT: --> ((16 * ((15 + (ptrtoint ptr %obj_donor to i64)) /u 16)) + (-1 * (ptrtoint ptr %obj_donor to i64))) U: full-set S: full-set +; CHECK-NEXT: --> ((16 * ((15 + %intptr) /u 16)) + (-1 * %intptr)) U: full-set S: full-set ; CHECK-NEXT: %aligned_result = getelementptr i8, ptr %obj_to_align, i64 %diff -; CHECK-NEXT: --> ((16 * ((15 + (ptrtoint ptr %obj_donor to i64)) /u 16)) + (-1 * (ptrtoint ptr %obj_donor to i64)) + %obj_to_align) U: full-set S: full-set +; CHECK-NEXT: --> ((16 * ((15 + %intptr) /u 16)) + (-1 * %intptr) + %obj_to_align) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @pointer_align_up_different_donor ; %intptr = ptrtoint ptr %obj_donor to i64 @@ -91,15 +91,15 @@ define ptr @pointer_align_up_with_select(ptr %obj) { ; CHECK-LABEL: 'pointer_align_up_with_select' ; CHECK-NEXT: Classifying expressions for: @pointer_align_up_with_select ; CHECK-NEXT: %i = ptrtoint ptr %obj to i64 -; CHECK-NEXT: --> (ptrtoint ptr %obj to i64) U: full-set S: full-set +; CHECK-NEXT: --> %i U: full-set S: full-set ; CHECK-NEXT: %i2 = and i64 %i, 15 -; CHECK-NEXT: --> (zext i4 (trunc i64 (ptrtoint ptr %obj to i64) to i4) to i64) U: [0,16) S: [0,16) +; CHECK-NEXT: --> (zext i4 (trunc i64 %i to i4) to i64) U: [0,16) S: [0,16) ; CHECK-NEXT: %i4 = sub nsw i64 0, %i2 -; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj to i64) to i4) to i64)) U: [-15,1) S: [-15,1) +; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 %i to i4) to i64)) U: [-15,1) S: [-15,1) ; CHECK-NEXT: %i5 = getelementptr i8, ptr %obj, i64 %i4 -; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj to i64) to i4) to i64)) + %obj) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 %i to i4) to i64)) + %obj) U: full-set S: full-set ; CHECK-NEXT: %i6 = getelementptr i8, ptr %i5, i64 16 -; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj to i64) to i4) to i64)) + %obj) U: full-set S: full-set +; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 %i to i4) to i64)) + %obj) U: full-set S: full-set ; CHECK-NEXT: %i7 = select i1 %i3, ptr %obj, ptr %i6 ; CHECK-NEXT: --> %i7 U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @pointer_align_up_with_select @@ -118,15 +118,15 @@ define ptr @pointer_align_up_with_select_different_donor(ptr %obj_to_align, ptr ; CHECK-LABEL: 'pointer_align_up_with_select_different_donor' ; CHECK-NEXT: Classifying expressions for: @pointer_align_up_with_select_different_donor ; CHECK-NEXT: %i = ptrtoint ptr %obj_donor to i64 -; CHECK-NEXT: --> (ptrtoint ptr %obj_donor to i64) U: full-set S: full-set +; CHECK-NEXT: --> %i U: full-set S: full-set ; CHECK-NEXT: %i2 = and i64 %i, 15 -; CHECK-NEXT: --> (zext i4 (trunc i64 (ptrtoint ptr %obj_donor to i64) to i4) to i64) U: [0,16) S: [0,16) +; CHECK-NEXT: --> (zext i4 (trunc i64 %i to i4) to i64) U: [0,16) S: [0,16) ; CHECK-NEXT: %i4 = sub nsw i64 0, %i2 -; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj_donor to i64) to i4) to i64)) U: [-15,1) S: [-15,1) +; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 %i to i4) to i64)) U: [-15,1) S: [-15,1) ; CHECK-NEXT: %i5 = getelementptr i8, ptr %obj_to_align, i64 %i4 -; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj_donor to i64) to i4) to i64)) + %obj_to_align) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 %i to i4) to i64)) + %obj_to_align) U: full-set S: full-set ; CHECK-NEXT: %i6 = getelementptr i8, ptr %i5, i64 16 -; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj_donor to i64) to i4) to i64)) + %obj_to_align) U: full-set S: full-set +; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 %i to i4) to i64)) + %obj_to_align) U: full-set S: full-set ; CHECK-NEXT: %i7 = select i1 %i3, ptr %obj_to_align, ptr %i6 ; CHECK-NEXT: --> %i7 U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @pointer_align_up_with_select_different_donor @@ -145,15 +145,15 @@ define ptr @pointer_align_up_with_select_different_objects_bad(ptr %first_obj, p ; CHECK-LABEL: 'pointer_align_up_with_select_different_objects_bad' ; CHECK-NEXT: Classifying expressions for: @pointer_align_up_with_select_different_objects_bad ; CHECK-NEXT: %i = ptrtoint ptr %obj_donor to i64 -; CHECK-NEXT: --> (ptrtoint ptr %obj_donor to i64) U: full-set S: full-set +; CHECK-NEXT: --> %i U: full-set S: full-set ; CHECK-NEXT: %i2 = and i64 %i, 15 -; CHECK-NEXT: --> (zext i4 (trunc i64 (ptrtoint ptr %obj_donor to i64) to i4) to i64) U: [0,16) S: [0,16) +; CHECK-NEXT: --> (zext i4 (trunc i64 %i to i4) to i64) U: [0,16) S: [0,16) ; CHECK-NEXT: %i4 = sub nsw i64 0, %i2 -; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj_donor to i64) to i4) to i64)) U: [-15,1) S: [-15,1) +; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 %i to i4) to i64)) U: [-15,1) S: [-15,1) ; CHECK-NEXT: %i5 = getelementptr i8, ptr %second_obj, i64 %i4 -; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj_donor to i64) to i4) to i64)) + %second_obj) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 %i to i4) to i64)) + %second_obj) U: full-set S: full-set ; CHECK-NEXT: %i6 = getelementptr i8, ptr %i5, i64 16 -; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 (ptrtoint ptr %obj_donor to i64) to i4) to i64)) + %second_obj) U: full-set S: full-set +; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 %i to i4) to i64)) + %second_obj) U: full-set S: full-set ; CHECK-NEXT: %i7 = select i1 %i3, ptr %first_obj, ptr %i6 ; CHECK-NEXT: --> %i7 U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @pointer_align_up_with_select_different_objects_bad diff --git a/llvm/test/Analysis/ScalarEvolution/pr46786.ll b/llvm/test/Analysis/ScalarEvolution/pr46786.ll index 89cc110a45df..7e9bba49f278 100644 --- a/llvm/test/Analysis/ScalarEvolution/pr46786.ll +++ b/llvm/test/Analysis/ScalarEvolution/pr46786.ll @@ -15,11 +15,11 @@ define ptr @FSE_decompress_usingDTable(ptr %arg, i32 %arg1, i32 %arg2, i32 %arg3 ; CHECK-NEXT: %i5 = getelementptr inbounds i8, ptr %i, i32 %i4 ; CHECK-NEXT: --> ((-1 * %arg1) + %arg2 + %arg) U: full-set S: full-set ; CHECK-NEXT: %i7 = select i1 %i6, i32 %arg2, i32 %arg1 -; CHECK-NEXT: --> ((-1 * (ptrtoint ptr %arg to i32)) + (((-1 * %arg1) + (ptrtoint ptr %arg to i32) + %arg2) umin (ptrtoint ptr %arg to i32)) + %arg1) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (ptrtoaddr ptr %arg to i32)) + (((-1 * %arg1) + (ptrtoaddr ptr %arg to i32) + %arg2) umin (ptrtoaddr ptr %arg to i32)) + %arg1) U: full-set S: full-set ; CHECK-NEXT: %i8 = sub i32 %arg3, %i7 -; CHECK-NEXT: --> ((-1 * (((-1 * %arg1) + (ptrtoint ptr %arg to i32) + %arg2) umin (ptrtoint ptr %arg to i32))) + (-1 * %arg1) + (ptrtoint ptr %arg to i32) + %arg3) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (((-1 * %arg1) + (ptrtoaddr ptr %arg to i32) + %arg2) umin (ptrtoaddr ptr %arg to i32))) + (-1 * %arg1) + (ptrtoaddr ptr %arg to i32) + %arg3) U: full-set S: full-set ; CHECK-NEXT: %i9 = getelementptr inbounds i8, ptr %arg, i32 %i8 -; CHECK-NEXT: --> ((-1 * (((-1 * %arg1) + (ptrtoint ptr %arg to i32) + %arg2) umin (ptrtoint ptr %arg to i32))) + (-1 * %arg1) + (ptrtoint ptr %arg to i32) + %arg3 + %arg) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (((-1 * %arg1) + (ptrtoaddr ptr %arg to i32) + %arg2) umin (ptrtoaddr ptr %arg to i32))) + (-1 * %arg1) + (ptrtoaddr ptr %arg to i32) + %arg3 + %arg) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @FSE_decompress_usingDTable ; bb: @@ -41,11 +41,11 @@ define ptr @test_01(ptr %p) { ; CHECK-NEXT: %p2 = getelementptr i8, ptr %p, i32 1 ; CHECK-NEXT: --> (1 + %p) U: full-set S: full-set ; CHECK-NEXT: %index = select i1 %cmp, i32 2, i32 1 -; CHECK-NEXT: --> ((-1 * (ptrtoint ptr %p to i32)) + ((1 + (ptrtoint ptr %p to i32)) umax (2 + (ptrtoint ptr %p to i32)))) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (ptrtoaddr ptr %p to i32)) + ((1 + (ptrtoaddr ptr %p to i32)) umax (2 + (ptrtoaddr ptr %p to i32)))) U: full-set S: full-set ; CHECK-NEXT: %neg_index = sub i32 0, %index -; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoint ptr %p to i32)) umax (2 + (ptrtoint ptr %p to i32)))) + (ptrtoint ptr %p to i32)) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoaddr ptr %p to i32)) umax (2 + (ptrtoaddr ptr %p to i32)))) + (ptrtoaddr ptr %p to i32)) U: full-set S: full-set ; CHECK-NEXT: %gep = getelementptr i8, ptr %p, i32 %neg_index -; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoint ptr %p to i32)) umax (2 + (ptrtoint ptr %p to i32)))) + (ptrtoint ptr %p to i32) + %p) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoaddr ptr %p to i32)) umax (2 + (ptrtoaddr ptr %p to i32)))) + (ptrtoaddr ptr %p to i32) + %p) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @test_01 ; %p1 = getelementptr i8, ptr %p, i32 2 @@ -65,11 +65,11 @@ define ptr @test_02(ptr %p) { ; CHECK-NEXT: %p2 = getelementptr i8, ptr %p, i32 1 ; CHECK-NEXT: --> (1 + %p) U: full-set S: full-set ; CHECK-NEXT: %index = select i1 %cmp, i32 2, i32 1 -; CHECK-NEXT: --> ((-1 * (ptrtoint ptr %p to i32)) + ((1 + (ptrtoint ptr %p to i32)) smax (2 + (ptrtoint ptr %p to i32)))) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (ptrtoaddr ptr %p to i32)) + ((1 + (ptrtoaddr ptr %p to i32)) smax (2 + (ptrtoaddr ptr %p to i32)))) U: full-set S: full-set ; CHECK-NEXT: %neg_index = sub i32 0, %index -; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoint ptr %p to i32)) smax (2 + (ptrtoint ptr %p to i32)))) + (ptrtoint ptr %p to i32)) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoaddr ptr %p to i32)) smax (2 + (ptrtoaddr ptr %p to i32)))) + (ptrtoaddr ptr %p to i32)) U: full-set S: full-set ; CHECK-NEXT: %gep = getelementptr i8, ptr %p, i32 %neg_index -; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoint ptr %p to i32)) smax (2 + (ptrtoint ptr %p to i32)))) + (ptrtoint ptr %p to i32) + %p) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoaddr ptr %p to i32)) smax (2 + (ptrtoaddr ptr %p to i32)))) + (ptrtoaddr ptr %p to i32) + %p) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @test_02 ; %p1 = getelementptr i8, ptr %p, i32 2 @@ -89,11 +89,11 @@ define ptr @test_03(ptr %p) { ; CHECK-NEXT: %p2 = getelementptr i8, ptr %p, i32 1 ; CHECK-NEXT: --> (1 + %p) U: full-set S: full-set ; CHECK-NEXT: %index = select i1 %cmp, i32 2, i32 1 -; CHECK-NEXT: --> ((-1 * (ptrtoint ptr %p to i32)) + ((1 + (ptrtoint ptr %p to i32)) umin (2 + (ptrtoint ptr %p to i32)))) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (ptrtoaddr ptr %p to i32)) + ((1 + (ptrtoaddr ptr %p to i32)) umin (2 + (ptrtoaddr ptr %p to i32)))) U: full-set S: full-set ; CHECK-NEXT: %neg_index = sub i32 0, %index -; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoint ptr %p to i32)) umin (2 + (ptrtoint ptr %p to i32)))) + (ptrtoint ptr %p to i32)) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoaddr ptr %p to i32)) umin (2 + (ptrtoaddr ptr %p to i32)))) + (ptrtoaddr ptr %p to i32)) U: full-set S: full-set ; CHECK-NEXT: %gep = getelementptr i8, ptr %p, i32 %neg_index -; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoint ptr %p to i32)) umin (2 + (ptrtoint ptr %p to i32)))) + (ptrtoint ptr %p to i32) + %p) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoaddr ptr %p to i32)) umin (2 + (ptrtoaddr ptr %p to i32)))) + (ptrtoaddr ptr %p to i32) + %p) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @test_03 ; %p1 = getelementptr i8, ptr %p, i32 2 @@ -113,11 +113,11 @@ define ptr @test_04(ptr %p) { ; CHECK-NEXT: %p2 = getelementptr i8, ptr %p, i32 1 ; CHECK-NEXT: --> (1 + %p) U: full-set S: full-set ; CHECK-NEXT: %index = select i1 %cmp, i32 2, i32 1 -; CHECK-NEXT: --> ((-1 * (ptrtoint ptr %p to i32)) + ((1 + (ptrtoint ptr %p to i32)) smin (2 + (ptrtoint ptr %p to i32)))) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (ptrtoaddr ptr %p to i32)) + ((1 + (ptrtoaddr ptr %p to i32)) smin (2 + (ptrtoaddr ptr %p to i32)))) U: full-set S: full-set ; CHECK-NEXT: %neg_index = sub i32 0, %index -; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoint ptr %p to i32)) smin (2 + (ptrtoint ptr %p to i32)))) + (ptrtoint ptr %p to i32)) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoaddr ptr %p to i32)) smin (2 + (ptrtoaddr ptr %p to i32)))) + (ptrtoaddr ptr %p to i32)) U: full-set S: full-set ; CHECK-NEXT: %gep = getelementptr i8, ptr %p, i32 %neg_index -; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoint ptr %p to i32)) smin (2 + (ptrtoint ptr %p to i32)))) + (ptrtoint ptr %p to i32) + %p) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * ((1 + (ptrtoaddr ptr %p to i32)) smin (2 + (ptrtoaddr ptr %p to i32)))) + (ptrtoaddr ptr %p to i32) + %p) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @test_04 ; %p1 = getelementptr i8, ptr %p, i32 2 diff --git a/llvm/test/Analysis/ScalarEvolution/predicated-max-backedge-taken-count-guard-info.ll b/llvm/test/Analysis/ScalarEvolution/predicated-max-backedge-taken-count-guard-info.ll index 1805b983c8e2..c408a111c567 100644 --- a/llvm/test/Analysis/ScalarEvolution/predicated-max-backedge-taken-count-guard-info.ll +++ b/llvm/test/Analysis/ScalarEvolution/predicated-max-backedge-taken-count-guard-info.ll @@ -7,15 +7,15 @@ define i32 @ptr_induction_ult(ptr %a, ptr %b) { ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. ; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. -; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (((-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 4) +; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (((-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 4) ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %b to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %a to i64) to i2))) to i64) == 0 +; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoaddr ptr %b to i64) to i2) + (-1 * (trunc i64 (ptrtoaddr ptr %a to i64) to i2))) to i64) == 0 ; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 4611686018427387903 ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %b to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %a to i64) to i2))) to i64) == 0 -; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is (((-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 4) +; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoaddr ptr %b to i64) to i2) + (-1 * (trunc i64 (ptrtoaddr ptr %a to i64) to i2))) to i64) == 0 +; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is (((-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 4) ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %b to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %a to i64) to i2))) to i64) == 0 +; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoaddr ptr %b to i64) to i2) + (-1 * (trunc i64 (ptrtoaddr ptr %a to i64) to i2))) to i64) == 0 ; entry: %cmp.6 = icmp ult ptr %a, %b @@ -37,15 +37,15 @@ define i32 @ptr_induction_ult_3_step_6(ptr %a, ptr %b) { ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. ; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. -; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (((3074457345618258603 * (ptrtoint ptr %b to i64)) + (-3074457345618258603 * (ptrtoint ptr %a to i64))) /u 2) +; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (((3074457345618258603 * (ptrtoaddr ptr %b to i64)) + (-3074457345618258603 * (ptrtoaddr ptr %a to i64))) /u 2) ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i1 (trunc i64 ((-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) to i1) to i64) == 0 +; CHECK-NEXT: Equal predicate: (zext i1 (trunc i64 ((-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) to i1) to i64) == 0 ; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 9223372036854775807 ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i1 (trunc i64 ((-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) to i1) to i64) == 0 -; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is (((3074457345618258603 * (ptrtoint ptr %b to i64)) + (-3074457345618258603 * (ptrtoint ptr %a to i64))) /u 2) +; CHECK-NEXT: Equal predicate: (zext i1 (trunc i64 ((-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) to i1) to i64) == 0 +; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is (((3074457345618258603 * (ptrtoaddr ptr %b to i64)) + (-3074457345618258603 * (ptrtoaddr ptr %a to i64))) /u 2) ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i1 (trunc i64 ((-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) to i1) to i64) == 0 +; CHECK-NEXT: Equal predicate: (zext i1 (trunc i64 ((-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) to i1) to i64) == 0 ; entry: %cmp.6 = icmp ult ptr %a, %b @@ -64,9 +64,9 @@ exit: define i32 @ptr_induction_ult_3_step_7(ptr %a, ptr %b) { ; CHECK-LABEL: 'ptr_induction_ult_3_step_7' ; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_ult_3_step_7 -; CHECK-NEXT: Loop %loop: backedge-taken count is ((7905747460161236407 * (ptrtoint ptr %b to i64)) + (-7905747460161236407 * (ptrtoint ptr %a to i64))) +; CHECK-NEXT: Loop %loop: backedge-taken count is ((7905747460161236407 * (ptrtoaddr ptr %b to i64)) + (-7905747460161236407 * (ptrtoaddr ptr %a to i64))) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -1 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((7905747460161236407 * (ptrtoint ptr %b to i64)) + (-7905747460161236407 * (ptrtoint ptr %a to i64))) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((7905747460161236407 * (ptrtoaddr ptr %b to i64)) + (-7905747460161236407 * (ptrtoaddr ptr %a to i64))) ; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: @@ -92,24 +92,24 @@ define void @ptr_induction_early_exit_eq_1(ptr %a, ptr %b, ptr %c) { ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE*** ; CHECK-NEXT: exit count for loop.inc: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: predicated exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8) +; CHECK-NEXT: predicated exit count for loop.inc: ((-8 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 8) ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a to i64) to i3))) to i64) == 0 +; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoaddr ptr %b to i64) to i3) + (-1 * (trunc i64 (ptrtoaddr ptr %a to i64) to i3))) to i64) == 0 ; CHECK-EMPTY: ; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. ; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. ; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE*** ; CHECK-NEXT: symbolic max exit count for loop.inc: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: predicated symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8) +; CHECK-NEXT: predicated symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 8) ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a to i64) to i3))) to i64) == 0 +; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoaddr ptr %b to i64) to i3) + (-1 * (trunc i64 (ptrtoaddr ptr %a to i64) to i3))) to i64) == 0 ; CHECK-EMPTY: ; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 2305843009213693951 ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a to i64) to i3))) to i64) == 0 -; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8) +; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoaddr ptr %b to i64) to i3) + (-1 * (trunc i64 (ptrtoaddr ptr %a to i64) to i3))) to i64) == 0 +; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 8) ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a to i64) to i3))) to i64) == 0 +; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoaddr ptr %b to i64) to i3) + (-1 * (trunc i64 (ptrtoaddr ptr %a to i64) to i3))) to i64) == 0 ; entry: %cmp = icmp eq ptr %a, %b diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll index d92056b9ffdd..99ecb3c9a7cb 100644 --- a/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll +++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll @@ -13,9 +13,9 @@ define hidden ptr @trunc_ptr_to_i64(ptr %arg, ptr %arg10) { ; PTR64_IDX64-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX64-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } ; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, ptr %arg, i64 ptrtoint (ptr @global to i64) -; PTR64_IDX64-NEXT: --> ((ptrtoint ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX64-NEXT: --> (ptrtoint (ptr @global to i64) + %arg) U: full-set S: full-set Exits: (ptrtoint (ptr @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX64-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr -; PTR64_IDX64-NEXT: --> ((ptrtoint ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX64-NEXT: --> (ptrtoint (ptr @global to i64) + %arg) U: full-set S: full-set Exits: (ptrtoint (ptr @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX64-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR64_IDX64-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2 @@ -47,9 +47,9 @@ define hidden ptr @trunc_ptr_to_i64(ptr %arg, ptr %arg10) { ; PTR16_IDX16-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX16-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } ; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, ptr %arg, i64 ptrtoint (ptr @global to i64) -; PTR16_IDX16-NEXT: --> ((ptrtoint ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX16-NEXT: --> ((trunc i64 ptrtoint (ptr @global to i64) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint (ptr @global to i64) to i16) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX16-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr -; PTR16_IDX16-NEXT: --> ((ptrtoint ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX16-NEXT: --> ((trunc i64 ptrtoint (ptr @global to i64) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint (ptr @global to i64) to i16) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX16-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR16_IDX16-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2 @@ -83,9 +83,9 @@ define hidden ptr @trunc_ptr_to_i32(ptr %arg, ptr %arg10) { ; PTR64_IDX64-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX64-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } ; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, ptr %arg, i32 ptrtoint (ptr @global to i32) -; PTR64_IDX64-NEXT: --> ((sext i32 (trunc i64 (ptrtoint ptr @global to i64) to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 (trunc i64 (ptrtoint ptr @global to i64) to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX64-NEXT: --> ((sext i32 ptrtoint (ptr @global to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 ptrtoint (ptr @global to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX64-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr -; PTR64_IDX64-NEXT: --> ((sext i32 (trunc i64 (ptrtoint ptr @global to i64) to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 (trunc i64 (ptrtoint ptr @global to i64) to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX64-NEXT: --> ((sext i32 ptrtoint (ptr @global to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 ptrtoint (ptr @global to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX64-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR64_IDX64-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2 @@ -117,9 +117,9 @@ define hidden ptr @trunc_ptr_to_i32(ptr %arg, ptr %arg10) { ; PTR16_IDX16-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX16-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } ; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, ptr %arg, i32 ptrtoint (ptr @global to i32) -; PTR16_IDX16-NEXT: --> ((ptrtoint ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX16-NEXT: --> ((trunc i32 ptrtoint (ptr @global to i32) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i32 ptrtoint (ptr @global to i32) to i16) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX16-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr -; PTR16_IDX16-NEXT: --> ((ptrtoint ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX16-NEXT: --> ((trunc i32 ptrtoint (ptr @global to i32) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i32 ptrtoint (ptr @global to i32) to i16) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX16-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR16_IDX16-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2 @@ -153,9 +153,9 @@ define hidden ptr @trunc_ptr_to_i128(ptr %arg, ptr %arg10) { ; PTR64_IDX64-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR64_IDX64-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } ; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, ptr %arg, i128 ptrtoint (ptr @global to i128) -; PTR64_IDX64-NEXT: --> ((ptrtoint ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX64-NEXT: --> ((trunc i128 ptrtoint (ptr @global to i128) to i64) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint (ptr @global to i128) to i64) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX64-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr -; PTR64_IDX64-NEXT: --> ((ptrtoint ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i64) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR64_IDX64-NEXT: --> ((trunc i128 ptrtoint (ptr @global to i128) to i64) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint (ptr @global to i128) to i64) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR64_IDX64-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR64_IDX64-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR64_IDX64-NEXT: %tmp18 = add i32 %tmp, 2 @@ -187,9 +187,9 @@ define hidden ptr @trunc_ptr_to_i128(ptr %arg, ptr %arg10) { ; PTR16_IDX16-NEXT: %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ] ; PTR16_IDX16-NEXT: --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <> LoopDispositions: { %bb11: Computable } ; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, ptr %arg, i128 ptrtoint (ptr @global to i128) -; PTR16_IDX16-NEXT: --> ((ptrtoint ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX16-NEXT: --> ((trunc i128 ptrtoint (ptr @global to i128) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint (ptr @global to i128) to i16) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX16-NEXT: %tmp13 = bitcast ptr %tmp12 to ptr -; PTR16_IDX16-NEXT: --> ((ptrtoint ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoint ptr @global to i16) + %arg) LoopDispositions: { %bb11: Invariant } +; PTR16_IDX16-NEXT: --> ((trunc i128 ptrtoint (ptr @global to i128) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint (ptr @global to i128) to i16) + %arg) LoopDispositions: { %bb11: Invariant } ; PTR16_IDX16-NEXT: %tmp14 = load i32, ptr %tmp13, align 4 ; PTR16_IDX16-NEXT: --> %tmp14 U: full-set S: full-set Exits: <> LoopDispositions: { %bb11: Variant } ; PTR16_IDX16-NEXT: %tmp18 = add i32 %tmp, 2 @@ -222,7 +222,7 @@ define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) { ; PTR64_IDX64-LABEL: 'zext_ptr_to_i32' ; PTR64_IDX64-NEXT: Classifying expressions for: @zext_ptr_to_i32 ; PTR64_IDX64-NEXT: %tmp = sub i32 %arg, ptrtoint (ptr @global to i32) -; PTR64_IDX64-NEXT: --> ((-1 * (trunc i64 (ptrtoint ptr @global to i64) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (trunc i64 (ptrtoint ptr @global to i64) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } +; PTR64_IDX64-NEXT: --> ((-1 * ptrtoint (ptr @global to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint (ptr @global to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; PTR64_IDX64-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; PTR64_IDX64-NEXT: --> %tmp9 U: [0,2) S: [0,2) Exits: <> LoopDispositions: { %bb7: Variant } ; PTR64_IDX64-NEXT: Determining loop execution counts for: @zext_ptr_to_i32 @@ -244,7 +244,7 @@ define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) { ; PTR16_IDX16-LABEL: 'zext_ptr_to_i32' ; PTR16_IDX16-NEXT: Classifying expressions for: @zext_ptr_to_i32 ; PTR16_IDX16-NEXT: %tmp = sub i32 %arg, ptrtoint (ptr @global to i32) -; PTR16_IDX16-NEXT: --> ((-1 * (zext i16 (ptrtoint ptr @global to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (zext i16 (ptrtoint ptr @global to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } +; PTR16_IDX16-NEXT: --> ((-1 * ptrtoint (ptr @global to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint (ptr @global to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; PTR16_IDX16-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; PTR16_IDX16-NEXT: --> %tmp9 U: [0,2) S: [0,2) Exits: <> LoopDispositions: { %bb7: Variant } ; PTR16_IDX16-NEXT: Determining loop execution counts for: @zext_ptr_to_i32 @@ -270,9 +270,9 @@ define void @sext_to_i32(i32 %arg, i32 %arg6) { ; PTR64_IDX64-LABEL: 'sext_to_i32' ; PTR64_IDX64-NEXT: Classifying expressions for: @sext_to_i32 ; PTR64_IDX64-NEXT: %ext = sext i16 ptrtoint (ptr @global to i16) to i32 -; PTR64_IDX64-NEXT: --> (sext i16 (trunc i64 (ptrtoint ptr @global to i64) to i16) to i32) U: [-32768,32768) S: [-32768,32768) Exits: (sext i16 (trunc i64 (ptrtoint ptr @global to i64) to i16) to i32) LoopDispositions: { %bb7: Invariant } +; PTR64_IDX64-NEXT: --> (sext i16 ptrtoint (ptr @global to i16) to i32) U: [-32768,32768) S: [-32768,32768) Exits: (sext i16 ptrtoint (ptr @global to i16) to i32) LoopDispositions: { %bb7: Invariant } ; PTR64_IDX64-NEXT: %tmp = sub i32 %arg, %ext -; PTR64_IDX64-NEXT: --> ((-1 * (sext i16 (trunc i64 (ptrtoint ptr @global to i64) to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (trunc i64 (ptrtoint ptr @global to i64) to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } +; PTR64_IDX64-NEXT: --> ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; PTR64_IDX64-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; PTR64_IDX64-NEXT: --> %tmp9 U: [0,2) S: [0,2) Exits: <> LoopDispositions: { %bb7: Variant } ; PTR64_IDX64-NEXT: Determining loop execution counts for: @sext_to_i32 @@ -296,9 +296,9 @@ define void @sext_to_i32(i32 %arg, i32 %arg6) { ; PTR16_IDX16-LABEL: 'sext_to_i32' ; PTR16_IDX16-NEXT: Classifying expressions for: @sext_to_i32 ; PTR16_IDX16-NEXT: %ext = sext i16 ptrtoint (ptr @global to i16) to i32 -; PTR16_IDX16-NEXT: --> (sext i16 (ptrtoint ptr @global to i16) to i32) U: [-32768,32768) S: [-32768,32768) Exits: (sext i16 (ptrtoint ptr @global to i16) to i32) LoopDispositions: { %bb7: Invariant } +; PTR16_IDX16-NEXT: --> (sext i16 ptrtoint (ptr @global to i16) to i32) U: [-32768,32768) S: [-32768,32768) Exits: (sext i16 ptrtoint (ptr @global to i16) to i32) LoopDispositions: { %bb7: Invariant } ; PTR16_IDX16-NEXT: %tmp = sub i32 %arg, %ext -; PTR16_IDX16-NEXT: --> ((-1 * (sext i16 (ptrtoint ptr @global to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (ptrtoint ptr @global to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } +; PTR16_IDX16-NEXT: --> ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32)) + %arg) LoopDispositions: { %bb7: Invariant } ; PTR16_IDX16-NEXT: %tmp9 = select i1 %tmp8, i16 0, i16 1 ; PTR16_IDX16-NEXT: --> %tmp9 U: [0,2) S: [0,2) Exits: <> LoopDispositions: { %bb7: Variant } ; PTR16_IDX16-NEXT: Determining loop execution counts for: @sext_to_i32 @@ -325,17 +325,17 @@ define i64 @sext_like_noop(i32 %n) { ; PTR64_IDX64-LABEL: 'sext_like_noop' ; PTR64_IDX64-NEXT: Classifying expressions for: @sext_like_noop ; PTR64_IDX64-NEXT: %ii = sext i32 %i to i64 -; PTR64_IDX64-NEXT: --> (sext i32 {1,+,1}<%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (-1 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32)) to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) +; PTR64_IDX64-NEXT: --> (sext i32 {1,+,1}<%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (-1 + ptrtoint (ptr @sext_like_noop to i32)) to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) ; PTR64_IDX64-NEXT: %div = sdiv i64 55555, %ii ; PTR64_IDX64-NEXT: --> %div U: full-set S: full-set ; PTR64_IDX64-NEXT: %i = phi i32 [ %inc, %for.body ], [ 1, %entry ] -; PTR64_IDX64-NEXT: --> {1,+,1}<%for.body> U: [1,0) S: [1,0) Exits: (-1 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32)) LoopDispositions: { %for.body: Computable } +; PTR64_IDX64-NEXT: --> {1,+,1}<%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (ptr @sext_like_noop to i32)) LoopDispositions: { %for.body: Computable } ; PTR64_IDX64-NEXT: %inc = add nuw i32 %i, 1 -; PTR64_IDX64-NEXT: --> {2,+,1}<%for.body> U: [2,0) S: [2,0) Exits: (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32) LoopDispositions: { %for.body: Computable } +; PTR64_IDX64-NEXT: --> {2,+,1}<%for.body> U: [2,0) S: [2,0) Exits: ptrtoint (ptr @sext_like_noop to i32) LoopDispositions: { %for.body: Computable } ; PTR64_IDX64-NEXT: Determining loop execution counts for: @sext_like_noop -; PTR64_IDX64-NEXT: Loop %for.body: backedge-taken count is (-2 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32)) +; PTR64_IDX64-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32)) ; PTR64_IDX64-NEXT: Loop %for.body: constant max backedge-taken count is i32 -1 -; PTR64_IDX64-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32)) +; PTR64_IDX64-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32)) ; PTR64_IDX64-NEXT: Loop %for.body: Trip multiple is 1 ; ; PTR64_IDX32-LABEL: 'sext_like_noop' @@ -357,17 +357,17 @@ define i64 @sext_like_noop(i32 %n) { ; PTR16_IDX16-LABEL: 'sext_like_noop' ; PTR16_IDX16-NEXT: Classifying expressions for: @sext_like_noop ; PTR16_IDX16-NEXT: %ii = sext i32 %i to i64 -; PTR16_IDX16-NEXT: --> (sext i32 {1,+,1}<%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i64)) U: [-1,65535) S: [-1,65535) +; PTR16_IDX16-NEXT: --> (sext i32 {1,+,1}<%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i32 ptrtoint (ptr @sext_like_noop to i32) to i64)) U: [-1,65535) S: [-1,65535) ; PTR16_IDX16-NEXT: %div = sdiv i64 55555, %ii ; PTR16_IDX16-NEXT: --> %div U: full-set S: full-set ; PTR16_IDX16-NEXT: %i = phi i32 [ %inc, %for.body ], [ 1, %entry ] -; PTR16_IDX16-NEXT: --> {1,+,1}<%for.body> U: [1,0) S: [1,0) Exits: (-1 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32)) LoopDispositions: { %for.body: Computable } +; PTR16_IDX16-NEXT: --> {1,+,1}<%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (ptr @sext_like_noop to i32)) LoopDispositions: { %for.body: Computable } ; PTR16_IDX16-NEXT: %inc = add nuw i32 %i, 1 -; PTR16_IDX16-NEXT: --> {2,+,1}<%for.body> U: [2,0) S: [2,0) Exits: (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32) LoopDispositions: { %for.body: Computable } +; PTR16_IDX16-NEXT: --> {2,+,1}<%for.body> U: [2,0) S: [2,0) Exits: ptrtoint (ptr @sext_like_noop to i32) LoopDispositions: { %for.body: Computable } ; PTR16_IDX16-NEXT: Determining loop execution counts for: @sext_like_noop -; PTR16_IDX16-NEXT: Loop %for.body: backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32)) +; PTR16_IDX16-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32)) ; PTR16_IDX16-NEXT: Loop %for.body: constant max backedge-taken count is i32 -1 -; PTR16_IDX16-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32)) +; PTR16_IDX16-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32)) ; PTR16_IDX16-NEXT: Loop %for.body: Trip multiple is 1 ; entry: diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint-global.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint-global.ll index 6eb0d2014a32..5d54aa622a8b 100644 --- a/llvm/test/Analysis/ScalarEvolution/ptrtoint-global.ll +++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint-global.ll @@ -10,7 +10,7 @@ define i64 @ptrtoint_align_2_size_4_add_5() { ; CHECK-LABEL: 'ptrtoint_align_2_size_4_add_5' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_2_size_4_add_5 ; CHECK-NEXT: %add = add i64 ptrtoint (ptr @glob.i32.align2 to i64), 5 -; CHECK-NEXT: --> (5 + (ptrtoint ptr @glob.i32.align2 to i64)) U: [7,0) S: [5,0) +; CHECK-NEXT: --> (5 + ptrtoint (ptr @glob.i32.align2 to i64)) U: [5,4) S: [-9223372036854775803,-9223372036854775804) ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_2_size_4_add_5 ; entry: @@ -22,7 +22,7 @@ define i64 @ptrtoint_align_2_size_4_add_6() { ; CHECK-LABEL: 'ptrtoint_align_2_size_4_add_6' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_2_size_4_add_6 ; CHECK-NEXT: %add = add i64 ptrtoint (ptr @glob.i32.align2 to i64), 6 -; CHECK-NEXT: --> (6 + (ptrtoint ptr @glob.i32.align2 to i64)) U: [0,-1) S: [-9223372036854775808,9223372036854775807) +; CHECK-NEXT: --> (6 + ptrtoint (ptr @glob.i32.align2 to i64)) U: [0,-1) S: [-9223372036854775808,9223372036854775807) ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_2_size_4_add_6 ; entry: @@ -34,7 +34,7 @@ define i64 @ptrtoint_align_8_size_4_add_7() { ; CHECK-LABEL: 'ptrtoint_align_8_size_4_add_7' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_8_size_4_add_7 ; CHECK-NEXT: %add = add i64 ptrtoint (ptr @glob.i32.align8 to i64), 7 -; CHECK-NEXT: --> (7 + (ptrtoint ptr @glob.i32.align8 to i64)) U: [15,0) S: [-9223372036854775801,-9223372036854775808) +; CHECK-NEXT: --> (7 + ptrtoint (ptr @glob.i32.align8 to i64)) U: [7,0) S: [-9223372036854775801,-9223372036854775808) ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_8_size_4_add_7 ; entry: @@ -46,7 +46,7 @@ define i64 @ptrtoint_align_8_size_4_add_8() { ; CHECK-LABEL: 'ptrtoint_align_8_size_4_add_8' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_8_size_4_add_8 ; CHECK-NEXT: %add = add i64 ptrtoint (ptr @glob.i32.align8 to i64), 8 -; CHECK-NEXT: --> (8 + (ptrtoint ptr @glob.i32.align8 to i64)) U: [0,-7) S: [-9223372036854775808,9223372036854775801) +; CHECK-NEXT: --> (8 + ptrtoint (ptr @glob.i32.align8 to i64)) U: [0,-7) S: [-9223372036854775808,9223372036854775801) ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_8_size_4_add_8 ; entry: @@ -58,7 +58,7 @@ define i64 @ptrtoint_align_16_size_4_add_15() { ; CHECK-LABEL: 'ptrtoint_align_16_size_4_add_15' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_16_size_4_add_15 ; CHECK-NEXT: %add = add i64 ptrtoint (ptr @glob.i32.align16 to i64), 15 -; CHECK-NEXT: --> (15 + (ptrtoint ptr @glob.i32.align16 to i64)) U: [31,0) S: [-9223372036854775793,-9223372036854775808) +; CHECK-NEXT: --> (15 + ptrtoint (ptr @glob.i32.align16 to i64)) U: [15,0) S: [-9223372036854775793,-9223372036854775808) ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_16_size_4_add_15 ; entry: @@ -70,7 +70,7 @@ define i64 @ptrtoint_align_16_size_4_add_16() { ; CHECK-LABEL: 'ptrtoint_align_16_size_4_add_16' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_16_size_4_add_16 ; CHECK-NEXT: %add = add i64 ptrtoint (ptr @glob.i32.align16 to i64), 16 -; CHECK-NEXT: --> (16 + (ptrtoint ptr @glob.i32.align16 to i64)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) +; CHECK-NEXT: --> (16 + ptrtoint (ptr @glob.i32.align16 to i64)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_16_size_4_add_16 ; entry: @@ -82,7 +82,7 @@ define i64 @ptrtoint_align_16_size_16_add_16() { ; CHECK-LABEL: 'ptrtoint_align_16_size_16_add_16' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_16_size_16_add_16 ; CHECK-NEXT: %add = add i64 ptrtoint (ptr @array4xi32 to i64), 16 -; CHECK-NEXT: --> (16 + (ptrtoint ptr @array4xi32 to i64)) U: [32,-15) S: [-9223372036854775808,9223372036854775793) +; CHECK-NEXT: --> (16 + ptrtoint (ptr @array4xi32 to i64)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_16_size_16_add_16 ; entry: @@ -94,7 +94,7 @@ define i64 @ptrtoint_align_16_size_16_add_31() { ; CHECK-LABEL: 'ptrtoint_align_16_size_16_add_31' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_16_size_16_add_31 ; CHECK-NEXT: %add = add i64 ptrtoint (ptr @array4xi32 to i64), 31 -; CHECK-NEXT: --> (31 + (ptrtoint ptr @array4xi32 to i64)) U: [47,0) S: [31,0) +; CHECK-NEXT: --> (31 + ptrtoint (ptr @array4xi32 to i64)) U: [31,16) S: [-9223372036854775777,-9223372036854775792) ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_16_size_16_add_31 ; entry: @@ -106,7 +106,7 @@ define i64 @ptrtoint_align_16_size_16_add_32() { ; CHECK-LABEL: 'ptrtoint_align_16_size_16_add_32' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_16_size_16_add_32 ; CHECK-NEXT: %add = add i64 ptrtoint (ptr @array4xi32 to i64), 32 -; CHECK-NEXT: --> (32 + (ptrtoint ptr @array4xi32 to i64)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) +; CHECK-NEXT: --> (32 + ptrtoint (ptr @array4xi32 to i64)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_16_size_16_add_32 ; entry: @@ -118,7 +118,7 @@ define i64 @ptrtoint_align_16_size_16_add_33() { ; CHECK-LABEL: 'ptrtoint_align_16_size_16_add_33' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_16_size_16_add_33 ; CHECK-NEXT: %add = add i64 ptrtoint (ptr @array4xi32 to i64), 33 -; CHECK-NEXT: --> (33 + (ptrtoint ptr @array4xi32 to i64)) U: [49,2) S: [-9223372036854775775,-9223372036854775790) +; CHECK-NEXT: --> (33 + ptrtoint (ptr @array4xi32 to i64)) U: [33,18) S: [-9223372036854775775,-9223372036854775790) ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_16_size_16_add_33 ; entry: @@ -130,13 +130,13 @@ define i64 @ptrtoint_align_16_size_16_add_16_umax_sub() { ; CHECK-LABEL: 'ptrtoint_align_16_size_16_add_16_umax_sub' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_16_size_16_add_16_umax_sub ; CHECK-NEXT: %add.16 = add i64 ptrtoint (ptr @array4xi32 to i64), 16 -; CHECK-NEXT: --> (16 + (ptrtoint ptr @array4xi32 to i64)) U: [32,-15) S: [-9223372036854775808,9223372036854775793) +; CHECK-NEXT: --> (16 + ptrtoint (ptr @array4xi32 to i64)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: %umax = call i64 @llvm.umax.i64(i64 ptrtoint (ptr @array4xi32 to i64), i64 %add.16) -; CHECK-NEXT: --> (16 + (ptrtoint ptr @array4xi32 to i64)) U: [32,-15) S: [-9223372036854775808,9223372036854775793) +; CHECK-NEXT: --> ((16 + ptrtoint (ptr @array4xi32 to i64)) umax ptrtoint (ptr @array4xi32 to i64)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: %add = add i64 %umax, 16 -; CHECK-NEXT: --> (32 + (ptrtoint ptr @array4xi32 to i64)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) +; CHECK-NEXT: --> (16 + ((16 + ptrtoint (ptr @array4xi32 to i64)) umax ptrtoint (ptr @array4xi32 to i64))) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: %sub = sub i64 %add, ptrtoint (ptr @array4xi32 to i64) -; CHECK-NEXT: --> 32 U: [32,33) S: [32,33) +; CHECK-NEXT: --> (16 + (-1 * ptrtoint (ptr @array4xi32 to i64)) + ((16 + ptrtoint (ptr @array4xi32 to i64)) umax ptrtoint (ptr @array4xi32 to i64))) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_16_size_16_add_16_umax_sub ; entry: @@ -151,13 +151,13 @@ define i64 @ptrtoint_align_16_size_16_add_31_umax_sub() { ; CHECK-LABEL: 'ptrtoint_align_16_size_16_add_31_umax_sub' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_16_size_16_add_31_umax_sub ; CHECK-NEXT: %add.31 = add i64 ptrtoint (ptr @array4xi32 to i64), 31 -; CHECK-NEXT: --> (31 + (ptrtoint ptr @array4xi32 to i64)) U: [47,0) S: [31,0) +; CHECK-NEXT: --> (31 + ptrtoint (ptr @array4xi32 to i64)) U: [31,16) S: [-9223372036854775777,-9223372036854775792) ; CHECK-NEXT: %umax = call i64 @llvm.umax.i64(i64 ptrtoint (ptr @array4xi32 to i64), i64 %add.31) -; CHECK-NEXT: --> (31 + (ptrtoint ptr @array4xi32 to i64)) U: [47,0) S: [31,0) +; CHECK-NEXT: --> ((31 + ptrtoint (ptr @array4xi32 to i64)) umax ptrtoint (ptr @array4xi32 to i64)) U: full-set S: full-set ; CHECK-NEXT: %add = add i64 %umax, 16 -; CHECK-NEXT: --> (47 + (ptrtoint ptr @array4xi32 to i64)) U: [63,16) S: [-9223372036854775761,-9223372036854775776) +; CHECK-NEXT: --> (16 + ((31 + ptrtoint (ptr @array4xi32 to i64)) umax ptrtoint (ptr @array4xi32 to i64))) U: full-set S: full-set ; CHECK-NEXT: %sub = sub i64 %add, ptrtoint (ptr @array4xi32 to i64) -; CHECK-NEXT: --> 47 U: [47,48) S: [47,48) +; CHECK-NEXT: --> (16 + (-1 * ptrtoint (ptr @array4xi32 to i64)) + ((31 + ptrtoint (ptr @array4xi32 to i64)) umax ptrtoint (ptr @array4xi32 to i64))) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_16_size_16_add_31_umax_sub ; entry: @@ -172,13 +172,13 @@ define i64 @ptrtoint_align_16_size_16_add_32_umax_sub() { ; CHECK-LABEL: 'ptrtoint_align_16_size_16_add_32_umax_sub' ; CHECK-NEXT: Classifying expressions for: @ptrtoint_align_16_size_16_add_32_umax_sub ; CHECK-NEXT: %add.32 = add i64 ptrtoint (ptr @array4xi32 to i64), 32 -; CHECK-NEXT: --> (32 + (ptrtoint ptr @array4xi32 to i64)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) +; CHECK-NEXT: --> (32 + ptrtoint (ptr @array4xi32 to i64)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: %umax = call i64 @llvm.umax.i64(i64 ptrtoint (ptr @array4xi32 to i64), i64 %add.32) -; CHECK-NEXT: --> ((32 + (ptrtoint ptr @array4xi32 to i64)) umax (ptrtoint ptr @array4xi32 to i64)) U: [16,-15) S: [-9223372036854775808,9223372036854775793) +; CHECK-NEXT: --> ((32 + ptrtoint (ptr @array4xi32 to i64)) umax ptrtoint (ptr @array4xi32 to i64)) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: %add = add i64 %umax, 16 -; CHECK-NEXT: --> (16 + ((32 + (ptrtoint ptr @array4xi32 to i64)) umax (ptrtoint ptr @array4xi32 to i64))) U: [0,-15) S: [-9223372036854775808,9223372036854775793) +; CHECK-NEXT: --> (16 + ((32 + ptrtoint (ptr @array4xi32 to i64)) umax ptrtoint (ptr @array4xi32 to i64))) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: %sub = sub i64 %add, ptrtoint (ptr @array4xi32 to i64) -; CHECK-NEXT: --> (16 + (-1 * (ptrtoint ptr @array4xi32 to i64)) + ((32 + (ptrtoint ptr @array4xi32 to i64)) umax (ptrtoint ptr @array4xi32 to i64))) U: [0,-15) S: [-9223372036854775808,9223372036854775793) +; CHECK-NEXT: --> (16 + (-1 * ptrtoint (ptr @array4xi32 to i64)) + ((32 + ptrtoint (ptr @array4xi32 to i64)) umax ptrtoint (ptr @array4xi32 to i64))) U: [0,-15) S: [-9223372036854775808,9223372036854775793) ; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_16_size_16_add_32_umax_sub ; entry: diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint-special-pointers.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint-special-pointers.ll index 9130db57727f..b9877f46189d 100644 --- a/llvm/test/Analysis/ScalarEvolution/ptrtoint-special-pointers.ll +++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint-special-pointers.ll @@ -18,7 +18,7 @@ define i64 @sub_ptrtoint_fat_to_addrwidth(ptr addrspace(1) %p, ptr addrspace(1) ; CHECK-NEXT: %q.int = ptrtoint ptr addrspace(1) %q to i64 ; CHECK-NEXT: --> %q.int U: full-set S: full-set ; CHECK-NEXT: %sub = sub i64 %p.int, %q.int -; CHECK-NEXT: --> ((-1 * %q.int) + %p.int) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (ptrtoaddr ptr addrspace(1) %q to i64)) + (ptrtoaddr ptr addrspace(1) %p to i64)) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @sub_ptrtoint_fat_to_addrwidth ; %p.int = ptrtoint ptr addrspace(1) %p to i64 @@ -75,7 +75,7 @@ define i64 @sub_ptrtoint_external_state(ptr addrspace(3) %p, ptr addrspace(3) %q ; CHECK-NEXT: %q.int = ptrtoint ptr addrspace(3) %q to i64 ; CHECK-NEXT: --> %q.int U: full-set S: full-set ; CHECK-NEXT: %sub = sub i64 %p.int, %q.int -; CHECK-NEXT: --> ((-1 * %q.int) + %p.int) U: full-set S: full-set +; CHECK-NEXT: --> ((-1 * (ptrtoaddr ptr addrspace(3) %q to i64)) + (ptrtoaddr ptr addrspace(3) %p to i64)) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @sub_ptrtoint_external_state ; %p.int = ptrtoint ptr addrspace(3) %p to i64 @@ -91,7 +91,7 @@ define void @ptrtoint_addrec_fat_to_addrwidth(ptr addrspace(1) %in) { ; CHECK-NEXT: %iv = phi ptr addrspace(1) [ %in, %entry ], [ %iv.next, %loop ] ; CHECK-NEXT: --> {%in,+,4}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.int = ptrtoint ptr addrspace(1) %iv to i64 -; CHECK-NEXT: --> %iv.int U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Variant } +; CHECK-NEXT: --> {(ptrtoaddr ptr addrspace(1) %in to i64),+,4}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.next = getelementptr inbounds i32, ptr addrspace(1) %iv, i64 1 ; CHECK-NEXT: --> {(4 + %in),+,4}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %c = call i1 @cond() @@ -155,7 +155,7 @@ define i32 @sub_ptrtoint_narrower_than_addr(ptr addrspace(1) %p, ptr addrspace(1 ; CHECK-NEXT: %q.int = ptrtoint ptr addrspace(1) %q to i32 ; CHECK-NEXT: --> %q.int U: full-set S: full-set ; CHECK-NEXT: %sub = sub i32 %p.int, %q.int -; CHECK-NEXT: --> ((-1 * %q.int) + %p.int) U: full-set S: full-set +; CHECK-NEXT: --> ((trunc i64 (ptrtoaddr ptr addrspace(1) %p to i64) to i32) + (-1 * (trunc i64 (ptrtoaddr ptr addrspace(1) %q to i64) to i32))) U: full-set S: full-set ; CHECK-NEXT: Determining loop execution counts for: @sub_ptrtoint_narrower_than_addr ; %p.int = ptrtoint ptr addrspace(1) %p to i32 @@ -169,13 +169,14 @@ define void @fat_ptr_ult_backedge_count(ptr addrspace(1) %start, ptr addrspace(1 ; CHECK-LABEL: 'fat_ptr_ult_backedge_count' ; CHECK-NEXT: Classifying expressions for: @fat_ptr_ult_backedge_count ; CHECK-NEXT: %iv = phi ptr addrspace(1) [ %start, %entry ], [ %iv.next, %loop ] -; CHECK-NEXT: --> {%start,+,4}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%start,+,4}<%loop> U: full-set S: full-set Exits: ((4 * ((-1 + (-1 * (ptrtoaddr ptr addrspace(1) %start to i64)) + ((4 + (ptrtoaddr ptr addrspace(1) %start to i64)) umax (ptrtoaddr ptr addrspace(1) %end to i64))) /u 4)) + %start) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.next = getelementptr inbounds i32, ptr addrspace(1) %iv, i64 1 -; CHECK-NEXT: --> {(4 + %start),+,4}<%loop> U: [4,0) S: [4,0) Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(4 + %start),+,4}<%loop> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-1 + (-1 * (ptrtoaddr ptr addrspace(1) %start to i64)) + ((4 + (ptrtoaddr ptr addrspace(1) %start to i64)) umax (ptrtoaddr ptr addrspace(1) %end to i64))) /u 4)) + %start) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @fat_ptr_ult_backedge_count -; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. -; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. -; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + (-1 * (ptrtoaddr ptr addrspace(1) %start to i64)) + ((4 + (ptrtoaddr ptr addrspace(1) %start to i64)) umax (ptrtoaddr ptr addrspace(1) %end to i64))) /u 4) +; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 4611686018427387902 +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 + (-1 * (ptrtoaddr ptr addrspace(1) %start to i64)) + ((4 + (ptrtoaddr ptr addrspace(1) %start to i64)) umax (ptrtoaddr ptr addrspace(1) %end to i64))) /u 4) +; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: br label %loop diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll index 4863477fbd97..0a6d25b30d6d 100644 --- a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll +++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll @@ -14,25 +14,25 @@ define void @ptrtoint(ptr %in, ptr %out0, ptr %out1, ptr %out2, ptr %out3) { ; X64-LABEL: 'ptrtoint' ; X64-NEXT: Classifying expressions for: @ptrtoint ; X64-NEXT: %p0 = ptrtoint ptr %in to i64 -; X64-NEXT: --> (ptrtoint ptr %in to i64) U: full-set S: full-set +; X64-NEXT: --> %p0 U: full-set S: full-set ; X64-NEXT: %p1 = ptrtoint ptr %in to i32 -; X64-NEXT: --> (trunc i64 (ptrtoint ptr %in to i64) to i32) U: full-set S: full-set +; X64-NEXT: --> %p1 U: full-set S: full-set ; X64-NEXT: %p2 = ptrtoint ptr %in to i16 -; X64-NEXT: --> (trunc i64 (ptrtoint ptr %in to i64) to i16) U: full-set S: full-set +; X64-NEXT: --> %p2 U: full-set S: full-set ; X64-NEXT: %p3 = ptrtoint ptr %in to i128 -; X64-NEXT: --> (zext i64 (ptrtoint ptr %in to i64) to i128) U: [0,18446744073709551616) S: [0,18446744073709551616) +; X64-NEXT: --> %p3 U: [0,18446744073709551616) S: [0,18446744073709551616) ; X64-NEXT: Determining loop execution counts for: @ptrtoint ; ; X32-LABEL: 'ptrtoint' ; X32-NEXT: Classifying expressions for: @ptrtoint ; X32-NEXT: %p0 = ptrtoint ptr %in to i64 -; X32-NEXT: --> (zext i32 (ptrtoint ptr %in to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %p0 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: %p1 = ptrtoint ptr %in to i32 -; X32-NEXT: --> (ptrtoint ptr %in to i32) U: full-set S: full-set +; X32-NEXT: --> %p1 U: full-set S: full-set ; X32-NEXT: %p2 = ptrtoint ptr %in to i16 -; X32-NEXT: --> (trunc i32 (ptrtoint ptr %in to i32) to i16) U: full-set S: full-set +; X32-NEXT: --> %p2 U: full-set S: full-set ; X32-NEXT: %p3 = ptrtoint ptr %in to i128 -; X32-NEXT: --> (zext i32 (ptrtoint ptr %in to i32) to i128) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %p3 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint ; %p0 = ptrtoint ptr %in to i64 @@ -51,25 +51,25 @@ define void @ptrtoint_as1(ptr addrspace(1) %in, ptr %out0, ptr %out1, ptr %out2, ; X64-LABEL: 'ptrtoint_as1' ; X64-NEXT: Classifying expressions for: @ptrtoint_as1 ; X64-NEXT: %p0 = ptrtoint ptr addrspace(1) %in to i64 -; X64-NEXT: --> (ptrtoint ptr addrspace(1) %in to i64) U: full-set S: full-set +; X64-NEXT: --> %p0 U: full-set S: full-set ; X64-NEXT: %p1 = ptrtoint ptr addrspace(1) %in to i32 -; X64-NEXT: --> (trunc i64 (ptrtoint ptr addrspace(1) %in to i64) to i32) U: full-set S: full-set +; X64-NEXT: --> %p1 U: full-set S: full-set ; X64-NEXT: %p2 = ptrtoint ptr addrspace(1) %in to i16 -; X64-NEXT: --> (trunc i64 (ptrtoint ptr addrspace(1) %in to i64) to i16) U: full-set S: full-set +; X64-NEXT: --> %p2 U: full-set S: full-set ; X64-NEXT: %p3 = ptrtoint ptr addrspace(1) %in to i128 -; X64-NEXT: --> (zext i64 (ptrtoint ptr addrspace(1) %in to i64) to i128) U: [0,18446744073709551616) S: [0,18446744073709551616) +; X64-NEXT: --> %p3 U: [0,18446744073709551616) S: [0,18446744073709551616) ; X64-NEXT: Determining loop execution counts for: @ptrtoint_as1 ; ; X32-LABEL: 'ptrtoint_as1' ; X32-NEXT: Classifying expressions for: @ptrtoint_as1 ; X32-NEXT: %p0 = ptrtoint ptr addrspace(1) %in to i64 -; X32-NEXT: --> (zext i32 (ptrtoint ptr addrspace(1) %in to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %p0 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: %p1 = ptrtoint ptr addrspace(1) %in to i32 -; X32-NEXT: --> (ptrtoint ptr addrspace(1) %in to i32) U: full-set S: full-set +; X32-NEXT: --> %p1 U: full-set S: full-set ; X32-NEXT: %p2 = ptrtoint ptr addrspace(1) %in to i16 -; X32-NEXT: --> (trunc i32 (ptrtoint ptr addrspace(1) %in to i32) to i16) U: full-set S: full-set +; X32-NEXT: --> %p2 U: full-set S: full-set ; X32-NEXT: %p3 = ptrtoint ptr addrspace(1) %in to i128 -; X32-NEXT: --> (zext i32 (ptrtoint ptr addrspace(1) %in to i32) to i128) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %p3 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_as1 ; %p0 = ptrtoint ptr addrspace(1) %in to i64 @@ -90,7 +90,7 @@ define void @ptrtoint_of_bitcast(ptr %in, ptr %out0) { ; X64-NEXT: %in_casted = bitcast ptr %in to ptr ; X64-NEXT: --> %in U: full-set S: full-set ; X64-NEXT: %p0 = ptrtoint ptr %in_casted to i64 -; X64-NEXT: --> (ptrtoint ptr %in to i64) U: full-set S: full-set +; X64-NEXT: --> %p0 U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_bitcast ; ; X32-LABEL: 'ptrtoint_of_bitcast' @@ -98,7 +98,7 @@ define void @ptrtoint_of_bitcast(ptr %in, ptr %out0) { ; X32-NEXT: %in_casted = bitcast ptr %in to ptr ; X32-NEXT: --> %in U: full-set S: full-set ; X32-NEXT: %p0 = ptrtoint ptr %in_casted to i64 -; X32-NEXT: --> (zext i32 (ptrtoint ptr %in to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %p0 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_bitcast ; %in_casted = bitcast ptr %in to ptr @@ -114,7 +114,7 @@ define void @ptrtoint_of_addrspacecast(ptr %in, ptr %out0) { ; X64-NEXT: %in_casted = addrspacecast ptr %in to ptr addrspace(1) ; X64-NEXT: --> %in_casted U: full-set S: full-set ; X64-NEXT: %p0 = ptrtoint ptr addrspace(1) %in_casted to i64 -; X64-NEXT: --> (ptrtoint ptr addrspace(1) %in_casted to i64) U: full-set S: full-set +; X64-NEXT: --> %p0 U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_addrspacecast ; ; X32-LABEL: 'ptrtoint_of_addrspacecast' @@ -122,7 +122,7 @@ define void @ptrtoint_of_addrspacecast(ptr %in, ptr %out0) { ; X32-NEXT: %in_casted = addrspacecast ptr %in to ptr addrspace(1) ; X32-NEXT: --> %in_casted U: full-set S: full-set ; X32-NEXT: %p0 = ptrtoint ptr addrspace(1) %in_casted to i64 -; X32-NEXT: --> (zext i32 (ptrtoint ptr addrspace(1) %in_casted to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %p0 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_addrspacecast ; %in_casted = addrspacecast ptr %in to ptr addrspace(1) @@ -138,7 +138,7 @@ define void @ptrtoint_of_inttoptr(i64 %in, ptr %out0) { ; X64-NEXT: %in_casted = inttoptr i64 %in to ptr ; X64-NEXT: --> %in_casted U: full-set S: full-set ; X64-NEXT: %p0 = ptrtoint ptr %in_casted to i64 -; X64-NEXT: --> (ptrtoint ptr %in_casted to i64) U: full-set S: full-set +; X64-NEXT: --> %p0 U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_inttoptr ; ; X32-LABEL: 'ptrtoint_of_inttoptr' @@ -146,7 +146,7 @@ define void @ptrtoint_of_inttoptr(i64 %in, ptr %out0) { ; X32-NEXT: %in_casted = inttoptr i64 %in to ptr ; X32-NEXT: --> %in_casted U: full-set S: full-set ; X32-NEXT: %p0 = ptrtoint ptr %in_casted to i64 -; X32-NEXT: --> (zext i32 (ptrtoint ptr %in_casted to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %p0 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_inttoptr ; %in_casted = inttoptr i64 %in to ptr @@ -160,7 +160,7 @@ define void @ptrtoint_of_nullptr(ptr %out0) { ; ALL-LABEL: 'ptrtoint_of_nullptr' ; ALL-NEXT: Classifying expressions for: @ptrtoint_of_nullptr ; ALL-NEXT: %p0 = ptrtoint ptr null to i64 -; ALL-NEXT: --> 0 U: [0,1) S: [0,1) +; ALL-NEXT: --> %p0 U: [0,1) S: [0,1) ; ALL-NEXT: Determining loop execution counts for: @ptrtoint_of_nullptr ; %p0 = ptrtoint ptr null to i64 @@ -170,17 +170,11 @@ define void @ptrtoint_of_nullptr(ptr %out0) { ; A constant inttoptr argument of an ptrtoint is still bad. define void @ptrtoint_of_constantexpr_inttoptr(ptr %out0) { -; X64-LABEL: 'ptrtoint_of_constantexpr_inttoptr' -; X64-NEXT: Classifying expressions for: @ptrtoint_of_constantexpr_inttoptr -; X64-NEXT: %p0 = ptrtoint ptr inttoptr (i64 42 to ptr) to i64 -; X64-NEXT: --> (ptrtoint ptr inttoptr (i64 42 to ptr) to i64) U: [42,43) S: [42,43) -; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_constantexpr_inttoptr -; -; X32-LABEL: 'ptrtoint_of_constantexpr_inttoptr' -; X32-NEXT: Classifying expressions for: @ptrtoint_of_constantexpr_inttoptr -; X32-NEXT: %p0 = ptrtoint ptr inttoptr (i64 42 to ptr) to i64 -; X32-NEXT: --> (zext i32 (ptrtoint ptr inttoptr (i64 42 to ptr) to i32) to i64) U: [42,43) S: [42,43) -; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_constantexpr_inttoptr +; ALL-LABEL: 'ptrtoint_of_constantexpr_inttoptr' +; ALL-NEXT: Classifying expressions for: @ptrtoint_of_constantexpr_inttoptr +; ALL-NEXT: %p0 = ptrtoint ptr inttoptr (i64 42 to ptr) to i64 +; ALL-NEXT: --> %p0 U: [42,43) S: [42,43) +; ALL-NEXT: Determining loop execution counts for: @ptrtoint_of_constantexpr_inttoptr ; %p0 = ptrtoint ptr inttoptr (i64 42 to ptr) to i64 store i64 %p0, ptr %out0 @@ -194,7 +188,7 @@ define void @ptrtoint_of_gep(ptr %in, ptr %out0) { ; X64-NEXT: %in_adj = getelementptr inbounds i8, ptr %in, i64 42 ; X64-NEXT: --> (42 + %in) U: full-set S: full-set ; X64-NEXT: %p0 = ptrtoint ptr %in_adj to i64 -; X64-NEXT: --> (42 + (ptrtoint ptr %in to i64)) U: full-set S: full-set +; X64-NEXT: --> (42 + (ptrtoaddr ptr %in to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_gep ; ; X32-LABEL: 'ptrtoint_of_gep' @@ -202,7 +196,7 @@ define void @ptrtoint_of_gep(ptr %in, ptr %out0) { ; X32-NEXT: %in_adj = getelementptr inbounds i8, ptr %in, i64 42 ; X32-NEXT: --> (42 + %in) U: full-set S: full-set ; X32-NEXT: %p0 = ptrtoint ptr %in_adj to i64 -; X32-NEXT: --> (zext i32 (42 + (ptrtoint ptr %in to i32)) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %p0 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_gep ; %in_adj = getelementptr inbounds i8, ptr %in, i64 42 @@ -224,7 +218,7 @@ define void @ptrtoint_of_addrec(ptr %in, i32 %count) { ; X64-NEXT: %i7 = getelementptr inbounds i32, ptr %in, i64 %i6 ; X64-NEXT: --> {%in,+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * (zext i32 %count to i64)) + %in) LoopDispositions: { %loop: Computable } ; X64-NEXT: %i8 = ptrtoint ptr %i7 to i64 -; X64-NEXT: --> {(ptrtoint ptr %in to i64),+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * (zext i32 %count to i64)) + (ptrtoint ptr %in to i64)) LoopDispositions: { %loop: Computable } +; X64-NEXT: --> {(ptrtoaddr ptr %in to i64),+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * (zext i32 %count to i64)) + (ptrtoaddr ptr %in to i64)) LoopDispositions: { %loop: Computable } ; X64-NEXT: %i9 = add nuw nsw i64 %i6, 1 ; X64-NEXT: --> {1,+,1}<%loop> U: [1,0) S: [1,0) Exits: (zext i32 %count to i64) LoopDispositions: { %loop: Computable } ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_addrec @@ -242,7 +236,7 @@ define void @ptrtoint_of_addrec(ptr %in, i32 %count) { ; X32-NEXT: %i7 = getelementptr inbounds i32, ptr %in, i64 %i6 ; X32-NEXT: --> {%in,+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * %count) + %in) LoopDispositions: { %loop: Computable } ; X32-NEXT: %i8 = ptrtoint ptr %i7 to i64 -; X32-NEXT: --> (zext i32 {(ptrtoint ptr %in to i32),+,4}<%loop> to i64) U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (-4 + (4 * %count) + (ptrtoint ptr %in to i32)) to i64) LoopDispositions: { %loop: Computable } +; X32-NEXT: --> %i8 U: [0,4294967296) S: [0,4294967296) Exits: <> LoopDispositions: { %loop: Variant } ; X32-NEXT: %i9 = add nuw nsw i64 %i6, 1 ; X32-NEXT: --> {1,+,1}<%loop> U: [1,0) S: [1,0) Exits: (zext i32 %count to i64) LoopDispositions: { %loop: Computable } ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_addrec @@ -276,7 +270,7 @@ define void @ptrtoint_of_umax(ptr %in0, ptr %in1, ptr %out0) { ; X64-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X64-NEXT: --> (%in0 umax %in1) U: full-set S: full-set ; X64-NEXT: %p0 = ptrtoint ptr %s to i64 -; X64-NEXT: --> ((ptrtoint ptr %in0 to i64) umax (ptrtoint ptr %in1 to i64)) U: full-set S: full-set +; X64-NEXT: --> ((ptrtoaddr ptr %in0 to i64) umax (ptrtoaddr ptr %in1 to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_umax ; ; X32-LABEL: 'ptrtoint_of_umax' @@ -284,7 +278,7 @@ define void @ptrtoint_of_umax(ptr %in0, ptr %in1, ptr %out0) { ; X32-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X32-NEXT: --> (%in0 umax %in1) U: full-set S: full-set ; X32-NEXT: %p0 = ptrtoint ptr %s to i64 -; X32-NEXT: --> ((zext i32 (ptrtoint ptr %in0 to i32) to i64) umax (zext i32 (ptrtoint ptr %in1 to i32) to i64)) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %p0 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_umax ; %c = icmp uge ptr %in0, %in1 @@ -300,7 +294,7 @@ define void @ptrtoint_of_smax(ptr %in0, ptr %in1, ptr %out0) { ; X64-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X64-NEXT: --> (%in0 smax %in1) U: full-set S: full-set ; X64-NEXT: %p0 = ptrtoint ptr %s to i64 -; X64-NEXT: --> ((ptrtoint ptr %in0 to i64) smax (ptrtoint ptr %in1 to i64)) U: full-set S: full-set +; X64-NEXT: --> ((ptrtoaddr ptr %in0 to i64) smax (ptrtoaddr ptr %in1 to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_smax ; ; X32-LABEL: 'ptrtoint_of_smax' @@ -308,7 +302,7 @@ define void @ptrtoint_of_smax(ptr %in0, ptr %in1, ptr %out0) { ; X32-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X32-NEXT: --> (%in0 smax %in1) U: full-set S: full-set ; X32-NEXT: %p0 = ptrtoint ptr %s to i64 -; X32-NEXT: --> (zext i32 ((ptrtoint ptr %in0 to i32) smax (ptrtoint ptr %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %p0 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_smax ; %c = icmp sge ptr %in0, %in1 @@ -324,7 +318,7 @@ define void @ptrtoint_of_umin(ptr %in0, ptr %in1, ptr %out0) { ; X64-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X64-NEXT: --> (%in0 umin %in1) U: full-set S: full-set ; X64-NEXT: %p0 = ptrtoint ptr %s to i64 -; X64-NEXT: --> ((ptrtoint ptr %in0 to i64) umin (ptrtoint ptr %in1 to i64)) U: full-set S: full-set +; X64-NEXT: --> ((ptrtoaddr ptr %in0 to i64) umin (ptrtoaddr ptr %in1 to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_umin ; ; X32-LABEL: 'ptrtoint_of_umin' @@ -332,7 +326,7 @@ define void @ptrtoint_of_umin(ptr %in0, ptr %in1, ptr %out0) { ; X32-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X32-NEXT: --> (%in0 umin %in1) U: full-set S: full-set ; X32-NEXT: %p0 = ptrtoint ptr %s to i64 -; X32-NEXT: --> ((zext i32 (ptrtoint ptr %in0 to i32) to i64) umin (zext i32 (ptrtoint ptr %in1 to i32) to i64)) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %p0 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_umin ; %c = icmp ule ptr %in0, %in1 @@ -348,7 +342,7 @@ define void @ptrtoint_of_smin(ptr %in0, ptr %in1, ptr %out0) { ; X64-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X64-NEXT: --> (%in0 smin %in1) U: full-set S: full-set ; X64-NEXT: %p0 = ptrtoint ptr %s to i64 -; X64-NEXT: --> ((ptrtoint ptr %in0 to i64) smin (ptrtoint ptr %in1 to i64)) U: full-set S: full-set +; X64-NEXT: --> ((ptrtoaddr ptr %in0 to i64) smin (ptrtoaddr ptr %in1 to i64)) U: full-set S: full-set ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_smin ; ; X32-LABEL: 'ptrtoint_of_smin' @@ -356,7 +350,7 @@ define void @ptrtoint_of_smin(ptr %in0, ptr %in1, ptr %out0) { ; X32-NEXT: %s = select i1 %c, ptr %in0, ptr %in1 ; X32-NEXT: --> (%in0 smin %in1) U: full-set S: full-set ; X32-NEXT: %p0 = ptrtoint ptr %s to i64 -; X32-NEXT: --> (zext i32 ((ptrtoint ptr %in0 to i32) smin (ptrtoint ptr %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %p0 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_smin ; %c = icmp sle ptr %in0, %in1 @@ -374,53 +368,53 @@ define void @pr46786_c26_char(ptr %arg, ptr %arg1, ptr %arg2) { ; X64-LABEL: 'pr46786_c26_char' ; X64-NEXT: Classifying expressions for: @pr46786_c26_char ; X64-NEXT: %i4 = ptrtoint ptr %arg to i64 -; X64-NEXT: --> (ptrtoint ptr %arg to i64) U: full-set S: full-set +; X64-NEXT: --> %i4 U: full-set S: full-set ; X64-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i14, %bb6 ] -; X64-NEXT: --> {%arg,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {%arg,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i8 = load i8, ptr %i7, align 1 ; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64 -; X64-NEXT: --> {(ptrtoint ptr %arg to i64),+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (ptrtoint ptr %arg1 to i64)) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {(ptrtoaddr ptr %arg to i64),+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (ptrtoaddr ptr %arg1 to i64)) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i10 = sub i64 %i9, %i4 -; X64-NEXT: --> {0,+,1}<%bb6> U: [0,-1) S: [0,-1) Exits: (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {0,+,1}<%bb6> U: [0,-1) S: [0,-1) Exits: (-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10 -; X64-NEXT: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64) + %arg2) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64) + %arg2) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i12 = load i8, ptr %i11, align 1 ; X64-NEXT: --> %i12 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i13 = add i8 %i12, %i8 ; X64-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i14 = getelementptr inbounds i8, ptr %i7, i64 1 -; X64-NEXT: --> {(1 + %arg),+,1}<%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {(1 + %arg),+,1}<%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable } ; X64-NEXT: Determining loop execution counts for: @pr46786_c26_char -; X64-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) +; X64-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) ; X64-NEXT: Loop %bb6: constant max backedge-taken count is i64 -2 -; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) +; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) ; X64-NEXT: Loop %bb6: Trip multiple is 1 ; ; X32-LABEL: 'pr46786_c26_char' ; X32-NEXT: Classifying expressions for: @pr46786_c26_char ; X32-NEXT: %i4 = ptrtoint ptr %arg to i64 -; X32-NEXT: --> (zext i32 (ptrtoint ptr %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %i4 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i14, %bb6 ] -; X32-NEXT: --> {%arg,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> {%arg,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i8 = load i8, ptr %i7, align 1 ; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64 -; X32-NEXT: --> {(zext i32 (ptrtoint ptr %arg to i32) to i64),+,1}<%bb6> U: [0,8589934590) S: [0,8589934590) Exits: ((zext i32 (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) to i64) + (zext i32 (ptrtoint ptr %arg to i32) to i64)) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> %i9 U: [0,4294967296) S: [0,4294967296) Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i10 = sub i64 %i9, %i4 -; X32-NEXT: --> {0,+,1}<%bb6> U: [0,4294967295) S: [0,4294967295) Exits: (zext i32 (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> ((-1 * %i4) + %i9) U: [-4294967295,4294967296) S: [-4294967295,4294967296) Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10 -; X32-NEXT: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32) + %arg2) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> ((trunc i64 %i9 to i32) + (-1 * (trunc i64 %i4 to i32)) + %arg2) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i12 = load i8, ptr %i11, align 1 ; X32-NEXT: --> %i12 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i13 = add i8 %i12, %i8 ; X32-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i14 = getelementptr inbounds i8, ptr %i7, i64 1 -; X32-NEXT: --> {(1 + %arg),+,1}<%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> {(1 + %arg),+,1}<%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable } ; X32-NEXT: Determining loop execution counts for: @pr46786_c26_char -; X32-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) +; X32-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) ; X32-NEXT: Loop %bb6: constant max backedge-taken count is i32 -2 -; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) +; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) ; X32-NEXT: Loop %bb6: Trip multiple is 1 ; %i = icmp eq ptr %arg, %arg1 @@ -451,53 +445,53 @@ define void @pr46786_c26_char_cmp_ops_swapped(ptr %arg, ptr %arg1, ptr %arg2) { ; X64-LABEL: 'pr46786_c26_char_cmp_ops_swapped' ; X64-NEXT: Classifying expressions for: @pr46786_c26_char_cmp_ops_swapped ; X64-NEXT: %i4 = ptrtoint ptr %arg to i64 -; X64-NEXT: --> (ptrtoint ptr %arg to i64) U: full-set S: full-set +; X64-NEXT: --> %i4 U: full-set S: full-set ; X64-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i14, %bb6 ] -; X64-NEXT: --> {%arg,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {%arg,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i8 = load i8, ptr %i7, align 1 ; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64 -; X64-NEXT: --> {(ptrtoint ptr %arg to i64),+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (ptrtoint ptr %arg1 to i64)) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {(ptrtoaddr ptr %arg to i64),+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (ptrtoaddr ptr %arg1 to i64)) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i10 = sub i64 %i9, %i4 -; X64-NEXT: --> {0,+,1}<%bb6> U: [0,-1) S: [0,-1) Exits: (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {0,+,1}<%bb6> U: [0,-1) S: [0,-1) Exits: (-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10 -; X64-NEXT: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64) + %arg2) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64) + %arg2) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i12 = load i8, ptr %i11, align 1 ; X64-NEXT: --> %i12 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i13 = add i8 %i12, %i8 ; X64-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i14 = getelementptr inbounds i8, ptr %i7, i64 1 -; X64-NEXT: --> {(1 + %arg),+,1}<%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {(1 + %arg),+,1}<%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64) + %arg) LoopDispositions: { %bb6: Computable } ; X64-NEXT: Determining loop execution counts for: @pr46786_c26_char_cmp_ops_swapped -; X64-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) +; X64-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) ; X64-NEXT: Loop %bb6: constant max backedge-taken count is i64 -2 -; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) +; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) ; X64-NEXT: Loop %bb6: Trip multiple is 1 ; ; X32-LABEL: 'pr46786_c26_char_cmp_ops_swapped' ; X32-NEXT: Classifying expressions for: @pr46786_c26_char_cmp_ops_swapped ; X32-NEXT: %i4 = ptrtoint ptr %arg to i64 -; X32-NEXT: --> (zext i32 (ptrtoint ptr %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %i4 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i14, %bb6 ] -; X32-NEXT: --> {%arg,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> {%arg,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i8 = load i8, ptr %i7, align 1 ; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64 -; X32-NEXT: --> {(zext i32 (ptrtoint ptr %arg to i32) to i64),+,1}<%bb6> U: [0,8589934590) S: [0,8589934590) Exits: ((zext i32 (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) to i64) + (zext i32 (ptrtoint ptr %arg to i32) to i64)) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> %i9 U: [0,4294967296) S: [0,4294967296) Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i10 = sub i64 %i9, %i4 -; X32-NEXT: --> {0,+,1}<%bb6> U: [0,4294967295) S: [0,4294967295) Exits: (zext i32 (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> ((-1 * %i4) + %i9) U: [-4294967295,4294967296) S: [-4294967295,4294967296) Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10 -; X32-NEXT: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32) + %arg2) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> ((trunc i64 %i9 to i32) + (-1 * (trunc i64 %i4 to i32)) + %arg2) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i12 = load i8, ptr %i11, align 1 ; X32-NEXT: --> %i12 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i13 = add i8 %i12, %i8 ; X32-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i14 = getelementptr inbounds i8, ptr %i7, i64 1 -; X32-NEXT: --> {(1 + %arg),+,1}<%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> {(1 + %arg),+,1}<%bb6> U: full-set S: full-set Exits: ((-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32) + %arg) LoopDispositions: { %bb6: Computable } ; X32-NEXT: Determining loop execution counts for: @pr46786_c26_char_cmp_ops_swapped -; X32-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) +; X32-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) ; X32-NEXT: Loop %bb6: constant max backedge-taken count is i32 -2 -; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) +; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) ; X32-NEXT: Loop %bb6: Trip multiple is 1 ; %i = icmp eq ptr %arg1, %arg @@ -535,15 +529,15 @@ define void @pr46786_c26_int(ptr %arg, ptr %arg1, ptr %arg2) { ; X64-LABEL: 'pr46786_c26_int' ; X64-NEXT: Classifying expressions for: @pr46786_c26_int ; X64-NEXT: %i4 = ptrtoint ptr %arg to i64 -; X64-NEXT: --> (ptrtoint ptr %arg to i64) U: full-set S: full-set +; X64-NEXT: --> %i4 U: full-set S: full-set ; X64-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i15, %bb6 ] -; X64-NEXT: --> {%arg,+,4}<%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {%arg,+,4}<%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i8 = load i32, ptr %i7, align 4 ; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64 -; X64-NEXT: --> {(ptrtoint ptr %arg to i64),+,4}<%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4)) + (ptrtoint ptr %arg to i64)) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {(ptrtoaddr ptr %arg to i64),+,4}<%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4)) + (ptrtoaddr ptr %arg to i64)) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i10 = sub i64 %i9, %i4 -; X64-NEXT: --> {0,+,4}<%bb6> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4)) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {0,+,4}<%bb6> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4)) LoopDispositions: { %bb6: Computable } ; X64-NEXT: %i11 = ashr exact i64 %i10, 2 ; X64-NEXT: --> %i11 U: [-2305843009213693952,2305843009213693952) S: [-2305843009213693952,2305843009213693952) Exits: <> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i12 = getelementptr inbounds i32, ptr %arg2, i64 %i11 @@ -553,25 +547,25 @@ define void @pr46786_c26_int(ptr %arg, ptr %arg1, ptr %arg2) { ; X64-NEXT: %i14 = add nsw i32 %i13, %i8 ; X64-NEXT: --> (%i13 + %i8) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X64-NEXT: %i15 = getelementptr inbounds i32, ptr %i7, i64 1 -; X64-NEXT: --> {(4 + %arg),+,4}<%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } +; X64-NEXT: --> {(4 + %arg),+,4}<%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } ; X64-NEXT: Determining loop execution counts for: @pr46786_c26_int -; X64-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4) +; X64-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4) ; X64-NEXT: Loop %bb6: constant max backedge-taken count is i64 4611686018427387903 -; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4) +; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4) ; X64-NEXT: Loop %bb6: Trip multiple is 1 ; ; X32-LABEL: 'pr46786_c26_int' ; X32-NEXT: Classifying expressions for: @pr46786_c26_int ; X32-NEXT: %i4 = ptrtoint ptr %arg to i64 -; X32-NEXT: --> (zext i32 (ptrtoint ptr %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %i4 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i15, %bb6 ] -; X32-NEXT: --> {%arg,+,4}<%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> {%arg,+,4}<%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } ; X32-NEXT: %i8 = load i32, ptr %i7, align 4 ; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64 -; X32-NEXT: --> {(zext i32 (ptrtoint ptr %arg to i32) to i64),+,4}<%bb6> U: [0,8589934588) S: [0,8589934588) Exits: ((zext i32 (ptrtoint ptr %arg to i32) to i64) + (4 * ((zext i32 (-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) to i64) /u 4))) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> %i9 U: [0,4294967296) S: [0,4294967296) Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i10 = sub i64 %i9, %i4 -; X32-NEXT: --> {0,+,4}<%bb6> U: [0,4294967293) S: [0,4294967293) Exits: (4 * ((zext i32 (-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) to i64) /u 4)) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> ((-1 * %i4) + %i9) U: [-4294967295,4294967296) S: [-4294967295,4294967296) Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i11 = ashr exact i64 %i10, 2 ; X32-NEXT: --> %i11 U: [-2147483648,2147483648) S: [-2147483648,2147483648) Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i12 = getelementptr inbounds i32, ptr %arg2, i64 %i11 @@ -581,11 +575,11 @@ define void @pr46786_c26_int(ptr %arg, ptr %arg1, ptr %arg2) { ; X32-NEXT: %i14 = add nsw i32 %i13, %i8 ; X32-NEXT: --> (%i13 + %i8) U: full-set S: full-set Exits: <> LoopDispositions: { %bb6: Variant } ; X32-NEXT: %i15 = getelementptr inbounds i32, ptr %i7, i64 1 -; X32-NEXT: --> {(4 + %arg),+,4}<%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } +; X32-NEXT: --> {(4 + %arg),+,4}<%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) /u 4)) + %arg) LoopDispositions: { %bb6: Computable } ; X32-NEXT: Determining loop execution counts for: @pr46786_c26_int -; X32-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4) +; X32-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) /u 4) ; X32-NEXT: Loop %bb6: constant max backedge-taken count is i32 1073741823 -; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4) +; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) /u 4) ; X32-NEXT: Loop %bb6: Trip multiple is 1 ; %i = icmp eq ptr %arg, %arg1 @@ -619,9 +613,9 @@ define void @ptrtoint_of_integer(ptr %arg, i64 %arg1, i1 %arg2) local_unnamed_ad ; X64-LABEL: 'ptrtoint_of_integer' ; X64-NEXT: Classifying expressions for: @ptrtoint_of_integer ; X64-NEXT: %i4 = ptrtoint ptr %arg to i64 -; X64-NEXT: --> (ptrtoint ptr %arg to i64) U: full-set S: full-set +; X64-NEXT: --> %i4 U: full-set S: full-set ; X64-NEXT: %i6 = sub i64 %i4, %arg1 -; X64-NEXT: --> ((-1 * %arg1) + (ptrtoint ptr %arg to i64)) U: full-set S: full-set +; X64-NEXT: --> ((-1 * %arg1) + %i4) U: full-set S: full-set ; X64-NEXT: %i9 = phi i64 [ 1, %bb7 ], [ %i11, %bb10 ] ; X64-NEXT: --> {1,+,1}<%bb8> U: [1,0) S: [1,0) Exits: <> LoopDispositions: { %bb8: Computable } ; X64-NEXT: %i11 = add nuw i64 %i9, 1 @@ -629,18 +623,18 @@ define void @ptrtoint_of_integer(ptr %arg, i64 %arg1, i1 %arg2) local_unnamed_ad ; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_integer ; X64-NEXT: Loop %bb8: Unpredictable backedge-taken count. ; X64-NEXT: exit count for bb8: ***COULDNOTCOMPUTE*** -; X64-NEXT: exit count for bb10: (-2 + (-1 * %arg1) + (ptrtoint ptr %arg to i64)) +; X64-NEXT: exit count for bb10: (-2 + (-1 * %arg1) + %i4) ; X64-NEXT: Loop %bb8: constant max backedge-taken count is i64 -1 -; X64-NEXT: Loop %bb8: symbolic max backedge-taken count is (-2 + (-1 * %arg1) + (ptrtoint ptr %arg to i64)) +; X64-NEXT: Loop %bb8: symbolic max backedge-taken count is (-2 + (-1 * %arg1) + %i4) ; X64-NEXT: symbolic max exit count for bb8: ***COULDNOTCOMPUTE*** -; X64-NEXT: symbolic max exit count for bb10: (-2 + (-1 * %arg1) + (ptrtoint ptr %arg to i64)) +; X64-NEXT: symbolic max exit count for bb10: (-2 + (-1 * %arg1) + %i4) ; ; X32-LABEL: 'ptrtoint_of_integer' ; X32-NEXT: Classifying expressions for: @ptrtoint_of_integer ; X32-NEXT: %i4 = ptrtoint ptr %arg to i64 -; X32-NEXT: --> (zext i32 (ptrtoint ptr %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296) +; X32-NEXT: --> %i4 U: [0,4294967296) S: [0,4294967296) ; X32-NEXT: %i6 = sub i64 %i4, %arg1 -; X32-NEXT: --> ((zext i32 (ptrtoint ptr %arg to i32) to i64) + (-1 * %arg1)) U: full-set S: full-set +; X32-NEXT: --> ((-1 * %arg1) + %i4) U: full-set S: full-set ; X32-NEXT: %i9 = phi i64 [ 1, %bb7 ], [ %i11, %bb10 ] ; X32-NEXT: --> {1,+,1}<%bb8> U: [1,0) S: [1,0) Exits: <> LoopDispositions: { %bb8: Computable } ; X32-NEXT: %i11 = add nuw i64 %i9, 1 @@ -648,11 +642,11 @@ define void @ptrtoint_of_integer(ptr %arg, i64 %arg1, i1 %arg2) local_unnamed_ad ; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_integer ; X32-NEXT: Loop %bb8: Unpredictable backedge-taken count. ; X32-NEXT: exit count for bb8: ***COULDNOTCOMPUTE*** -; X32-NEXT: exit count for bb10: (-2 + (zext i32 (ptrtoint ptr %arg to i32) to i64) + (-1 * %arg1)) +; X32-NEXT: exit count for bb10: (-2 + (-1 * %arg1) + %i4) ; X32-NEXT: Loop %bb8: constant max backedge-taken count is i64 -1 -; X32-NEXT: Loop %bb8: symbolic max backedge-taken count is (-2 + (zext i32 (ptrtoint ptr %arg to i32) to i64) + (-1 * %arg1)) +; X32-NEXT: Loop %bb8: symbolic max backedge-taken count is (-2 + (-1 * %arg1) + %i4) ; X32-NEXT: symbolic max exit count for bb8: ***COULDNOTCOMPUTE*** -; X32-NEXT: symbolic max exit count for bb10: (-2 + (zext i32 (ptrtoint ptr %arg to i32) to i64) + (-1 * %arg1)) +; X32-NEXT: symbolic max exit count for bb10: (-2 + (-1 * %arg1) + %i4) ; bb: %i = icmp eq ptr %arg, null diff --git a/llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll b/llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll index aeda7f61a757..512e58392880 100644 --- a/llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll +++ b/llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll @@ -585,15 +585,15 @@ define void @test_ptr_aligned_by_2_and_4_via_assumption(ptr %start, ptr %end) { ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. ; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. -; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i2 (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2)) to i64) == 0 +; CHECK-NEXT: Equal predicate: (zext i2 (-1 * (trunc i64 (ptrtoaddr ptr %start to i64) to i2)) to i64) == 0 ; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 4611686018427387903 ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i2 (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2)) to i64) == 0 -; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Equal predicate: (zext i2 (-1 * (trunc i64 (ptrtoaddr ptr %start to i64) to i2)) to i64) == 0 +; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i2 (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2)) to i64) == 0 +; CHECK-NEXT: Equal predicate: (zext i2 (-1 * (trunc i64 (ptrtoaddr ptr %start to i64) to i2)) to i64) == 0 ; entry: call void @llvm.assume(i1 true) [ "align"(ptr %start, i64 2) ] @@ -615,13 +615,13 @@ define void @test_ptrs_aligned_by_4_via_assumption(ptr %start, ptr %end) { ; CHECK-LABEL: 'test_ptrs_aligned_by_4_via_assumption' ; CHECK-NEXT: Classifying expressions for: @test_ptrs_aligned_by_4_via_assumption ; CHECK-NEXT: %iv = phi ptr [ %start, %entry ], [ %iv.next, %loop ] -; CHECK-NEXT: --> {%start,+,4}<%loop> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64) + %start) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%start,+,4}<%loop> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (-4 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64) + %start) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.next = getelementptr i8, ptr %iv, i64 4 -; CHECK-NEXT: --> {(4 + %start),+,4}<%loop> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: ((-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64) + %start) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(4 + %start),+,4}<%loop> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: ((-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64) + %start) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @test_ptrs_aligned_by_4_via_assumption -; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 4611686018427387903 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: @@ -644,13 +644,13 @@ define void @test_ptrs_aligned_by_8_via_assumption(ptr %start, ptr %end) { ; CHECK-LABEL: 'test_ptrs_aligned_by_8_via_assumption' ; CHECK-NEXT: Classifying expressions for: @test_ptrs_aligned_by_8_via_assumption ; CHECK-NEXT: %iv = phi ptr [ %start, %entry ], [ %iv.next, %loop ] -; CHECK-NEXT: --> {%start,+,4}<%loop> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64) + %start) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%start,+,4}<%loop> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (-4 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64) + %start) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %iv.next = getelementptr i8, ptr %iv, i64 4 -; CHECK-NEXT: --> {(4 + %start),+,4}<%loop> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: ((-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64) + %start) LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(4 + %start),+,4}<%loop> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: ((-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64) + %start) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @test_ptrs_aligned_by_8_via_assumption -; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 4611686018427387903 -; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: @@ -684,15 +684,15 @@ define void @test_ptr_aligned_by_4_via_assumption_multiple_loop_predecessors(ptr ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. ; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. -; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i2 (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2)) to i64) == 0 +; CHECK-NEXT: Equal predicate: (zext i2 (-1 * (trunc i64 (ptrtoaddr ptr %start to i64) to i2)) to i64) == 0 ; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 4611686018427387903 ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i2 (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2)) to i64) == 0 -; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4) +; CHECK-NEXT: Equal predicate: (zext i2 (-1 * (trunc i64 (ptrtoaddr ptr %start to i64) to i2)) to i64) == 0 +; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) /u 4) ; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i2 (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2)) to i64) == 0 +; CHECK-NEXT: Equal predicate: (zext i2 (-1 * (trunc i64 (ptrtoaddr ptr %start to i64) to i2)) to i64) == 0 ; entry: call void @llvm.assume(i1 true) [ "align"(ptr %start, i64 2) ] diff --git a/llvm/test/Analysis/ScalarEvolution/two-loop-latches.ll b/llvm/test/Analysis/ScalarEvolution/two-loop-latches.ll index 1faf6f70fc34..a85626c7c02e 100644 --- a/llvm/test/Analysis/ScalarEvolution/two-loop-latches.ll +++ b/llvm/test/Analysis/ScalarEvolution/two-loop-latches.ll @@ -12,20 +12,20 @@ define void @f(ptr %a0) { ; CHECK-NEXT: %inc = getelementptr i8, ptr %phi1, i64 -32 ; CHECK-NEXT: --> {(-32 + null),+,-32}<%b1> U: [0,-31) S: [-9223372036854775808,9223372036854775777) Exits: <> LoopDispositions: { %b1: Computable, %b3: Invariant } ; CHECK-NEXT: %phi2 = phi ptr [ %a0, %b2 ], [ %inc2, %b5 ] -; CHECK-NEXT: --> {%a0,+,1}<%b3> U: full-set S: full-set Exits: ((-1 * (ptrtoint ptr %a0 to i64)) + %a0) LoopDispositions: { %b3: Computable, %b1: Uniform } +; CHECK-NEXT: --> {%a0,+,1}<%b3> U: full-set S: full-set Exits: ((-1 * (ptrtoaddr ptr %a0 to i64)) + %a0) LoopDispositions: { %b3: Computable, %b1: Uniform } ; CHECK-NEXT: %ld1 = load i8, ptr %phi2, align 1 ; CHECK-NEXT: --> %ld1 U: full-set S: full-set Exits: <> LoopDispositions: { %b3: Variant, %b1: Variant } ; CHECK-NEXT: %ld2 = load i8, ptr null, align 1 ; CHECK-NEXT: --> %ld2 U: full-set S: full-set Exits: <> LoopDispositions: { %b3: Variant, %b1: Variant } ; CHECK-NEXT: %inc2 = getelementptr i8, ptr %phi2, i64 1 -; CHECK-NEXT: --> {(1 + %a0),+,1}<%b3> U: full-set S: full-set Exits: (1 + (-1 * (ptrtoint ptr %a0 to i64)) + %a0) LoopDispositions: { %b3: Computable, %b1: Uniform } +; CHECK-NEXT: --> {(1 + %a0),+,1}<%b3> U: full-set S: full-set Exits: (1 + (-1 * (ptrtoaddr ptr %a0 to i64)) + %a0) LoopDispositions: { %b3: Computable, %b1: Uniform } ; CHECK-NEXT: Determining loop execution counts for: @f -; CHECK-NEXT: Loop %b3: backedge-taken count is (-1 * (ptrtoint ptr %a0 to i64)) -; CHECK-NEXT: exit count for b3: (-1 * (ptrtoint ptr %a0 to i64)) +; CHECK-NEXT: Loop %b3: backedge-taken count is (-1 * (ptrtoaddr ptr %a0 to i64)) +; CHECK-NEXT: exit count for b3: (-1 * (ptrtoaddr ptr %a0 to i64)) ; CHECK-NEXT: exit count for b4: ***COULDNOTCOMPUTE*** ; CHECK-NEXT: Loop %b3: constant max backedge-taken count is i64 -1 -; CHECK-NEXT: Loop %b3: symbolic max backedge-taken count is (-1 * (ptrtoint ptr %a0 to i64)) -; CHECK-NEXT: symbolic max exit count for b3: (-1 * (ptrtoint ptr %a0 to i64)) +; CHECK-NEXT: Loop %b3: symbolic max backedge-taken count is (-1 * (ptrtoaddr ptr %a0 to i64)) +; CHECK-NEXT: symbolic max exit count for b3: (-1 * (ptrtoaddr ptr %a0 to i64)) ; CHECK-NEXT: symbolic max exit count for b4: ***COULDNOTCOMPUTE*** ; CHECK-NEXT: Loop %b3: Trip multiple is 1 ; CHECK-NEXT: Loop %b1: Unpredictable backedge-taken count. diff --git a/llvm/test/CodeGen/AArch64/ragreedy-csr.ll b/llvm/test/CodeGen/AArch64/ragreedy-csr.ll index 249a08118386..25752707f271 100644 --- a/llvm/test/CodeGen/AArch64/ragreedy-csr.ll +++ b/llvm/test/CodeGen/AArch64/ragreedy-csr.ll @@ -69,7 +69,7 @@ define fastcc i32 @prune_match(ptr nocapture readonly %a, ptr nocapture readonly ; CHECK-NEXT: and w8, w8, #0x8000 ; CHECK-NEXT: cbnz w8, LBB0_6 ; CHECK-NEXT: LBB0_4: ; %lor.rhs -; CHECK-NEXT: ldrsb x8, [x10, x11] +; CHECK-NEXT: ldrsb x8, [x11, x10] ; CHECK-NEXT: tbnz x8, #63, LBB0_8 ; CHECK-NEXT: ; %bb.5: ; %cond.true.i.i217 ; CHECK-NEXT: add x8, x14, x8, lsl #2 @@ -77,8 +77,8 @@ define fastcc i32 @prune_match(ptr nocapture readonly %a, ptr nocapture readonly ; CHECK-NEXT: and w8, w8, #0x8000 ; CHECK-NEXT: cbz w8, LBB0_9 ; CHECK-NEXT: LBB0_6: ; %while.body -; CHECK-NEXT: ldrb w8, [x9, x11] -; CHECK-NEXT: ldrb w15, [x10, x11] +; CHECK-NEXT: ldrb w8, [x11, x9] +; CHECK-NEXT: ldrb w15, [x11, x10] ; CHECK-NEXT: cmp w8, w15 ; CHECK-NEXT: b.ne LBB0_32 ; CHECK-NEXT: ; %bb.7: ; %if.end17 diff --git a/llvm/test/CodeGen/Thumb2/mve-tailpred-loopinvariant.ll b/llvm/test/CodeGen/Thumb2/mve-tailpred-loopinvariant.ll index 6b2a6e63af23..de34106e5fed 100644 --- a/llvm/test/CodeGen/Thumb2/mve-tailpred-loopinvariant.ll +++ b/llvm/test/CodeGen/Thumb2/mve-tailpred-loopinvariant.ll @@ -1,9 +1,8 @@ ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; RUN: llc -mtriple=thumbv8.1m.main-none-none-eabi -mattr=+mve -verify-machineinstrs %s -o - | FileCheck %s -; This test has an instruction that gets sunk into the loop, that is a -; active.lane.mask operand. (%exitcount.ptrcnt.to.int = ptrtoint). We -; need to make sure it is loop invariant. +; This test has exit count computed as a pointer difference using ptrtoaddr. +; We need to make sure it is loop invariant. define i32 @a(ptr readnone %b, ptr %c) { ; CHECK-LABEL: a: @@ -32,11 +31,10 @@ entry: br i1 %cmp3, label %while.body.preheader, label %while.end while.body.preheader: ; preds = %entry - %c5 = ptrtoint ptr %c to i32 - %0 = sub i32 0, %c5 - %uglygep = getelementptr i8, ptr %b, i32 %0 - %exitcount.ptrcnt.to.int = ptrtoint ptr %uglygep to i32 - %n.rnd.up = add i32 %exitcount.ptrcnt.to.int, 15 + %b.addr = ptrtoaddr ptr %b to i32 + %c.addr = ptrtoaddr ptr %c to i32 + %exitcount = sub i32 %b.addr, %c.addr + %n.rnd.up = add i32 %exitcount, 15 %n.vec = and i32 %n.rnd.up, -16 br label %vector.body @@ -89,7 +87,7 @@ vector.body: ; preds = %vector.body, %while %29 = insertelement <16 x ptr> %28, ptr %next.gep19, i32 13 %30 = insertelement <16 x ptr> %29, ptr %next.gep20, i32 14 %31 = insertelement <16 x ptr> %30, ptr %next.gep21, i32 15 - %active.lane.mask = call <16 x i1> @llvm.get.active.lane.mask.v16i1.i32(i32 %index, i32 %exitcount.ptrcnt.to.int) + %active.lane.mask = call <16 x i1> @llvm.get.active.lane.mask.v16i1.i32(i32 %index, i32 %exitcount) %32 = ptrtoint <16 x ptr> %31 to <16 x i32> %33 = trunc <16 x i32> %32 to <16 x i8> call void @llvm.masked.store.v16i8.p0(<16 x i8> %33, ptr %next.gep, i32 1, <16 x i1> %active.lane.mask) diff --git a/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll b/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll index cb0be523c709..259ee322bdc0 100644 --- a/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll +++ b/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll @@ -12,7 +12,7 @@ define i8 @testnullptrptr(ptr %buf, ptr %end) nounwind { ; PTR64-LABEL: @testnullptrptr( -; PTR64-NEXT: [[END1:%.*]] = ptrtoint ptr [[END:%.*]] to i64 +; PTR64-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END:%.*]] to i64 ; PTR64-NEXT: br label [[LOOPGUARD:%.*]] ; PTR64: loopguard: ; PTR64-NEXT: [[GUARD:%.*]] = icmp ult ptr null, [[END]] @@ -34,7 +34,7 @@ define i8 @testnullptrptr(ptr %buf, ptr %end) nounwind { ; PTR64-NEXT: ret i8 [[RET]] ; ; PTR32-LABEL: @testnullptrptr( -; PTR32-NEXT: [[END1:%.*]] = ptrtoint ptr [[END:%.*]] to i32 +; PTR32-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END:%.*]] to i32 ; PTR32-NEXT: br label [[LOOPGUARD:%.*]] ; PTR32: loopguard: ; PTR32-NEXT: [[GUARD:%.*]] = icmp ult ptr null, [[END]] @@ -79,8 +79,8 @@ exit: define i8 @testptrptr(ptr %buf, ptr %end) nounwind { ; PTR64-LABEL: @testptrptr( -; PTR64-NEXT: [[BUF2:%.*]] = ptrtoint ptr [[BUF:%.*]] to i64 -; PTR64-NEXT: [[END1:%.*]] = ptrtoint ptr [[END:%.*]] to i64 +; PTR64-NEXT: [[BUF2:%.*]] = ptrtoaddr ptr [[BUF:%.*]] to i64 +; PTR64-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END:%.*]] to i64 ; PTR64-NEXT: br label [[LOOPGUARD:%.*]] ; PTR64: loopguard: ; PTR64-NEXT: [[GUARD:%.*]] = icmp ult ptr [[BUF]], [[END]] @@ -103,8 +103,8 @@ define i8 @testptrptr(ptr %buf, ptr %end) nounwind { ; PTR64-NEXT: ret i8 [[RET]] ; ; PTR32-LABEL: @testptrptr( -; PTR32-NEXT: [[BUF2:%.*]] = ptrtoint ptr [[BUF:%.*]] to i32 -; PTR32-NEXT: [[END1:%.*]] = ptrtoint ptr [[END:%.*]] to i32 +; PTR32-NEXT: [[BUF2:%.*]] = ptrtoaddr ptr [[BUF:%.*]] to i32 +; PTR32-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END:%.*]] to i32 ; PTR32-NEXT: br label [[LOOPGUARD:%.*]] ; PTR32: loopguard: ; PTR32-NEXT: [[GUARD:%.*]] = icmp ult ptr [[BUF]], [[END]] @@ -245,7 +245,7 @@ define i8 @testptrint(ptr %buf, ptr %end) nounwind { ; PTR64-NEXT: [[GEP]] = getelementptr inbounds i8, ptr [[P_01_US_US]], i64 1 ; PTR64-NEXT: [[SNEXT:%.*]] = load i8, ptr [[GEP]], align 1 ; PTR64-NEXT: [[IVNEXT]] = add nuw i32 [[IV]], 1 -; PTR64-NEXT: [[EXITCOND:%.*]] = icmp ne i32 [[IVNEXT]], [[CNT]] +; PTR64-NEXT: [[EXITCOND:%.*]] = icmp ult i32 [[IVNEXT]], [[CNT]] ; PTR64-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]] ; PTR64: exit.loopexit: ; PTR64-NEXT: [[SNEXT_LCSSA:%.*]] = phi i8 [ [[SNEXT]], [[LOOP]] ] @@ -270,7 +270,7 @@ define i8 @testptrint(ptr %buf, ptr %end) nounwind { ; PTR32-NEXT: [[GEP]] = getelementptr inbounds i8, ptr [[P_01_US_US]], i64 1 ; PTR32-NEXT: [[SNEXT:%.*]] = load i8, ptr [[GEP]], align 1 ; PTR32-NEXT: [[IVNEXT]] = add nuw i32 [[IV]], 1 -; PTR32-NEXT: [[EXITCOND:%.*]] = icmp ne i32 [[IVNEXT]], [[CNT]] +; PTR32-NEXT: [[EXITCOND:%.*]] = icmp ult i32 [[IVNEXT]], [[CNT]] ; PTR32-NEXT: br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]] ; PTR32: exit.loopexit: ; PTR32-NEXT: [[SNEXT_LCSSA:%.*]] = phi i8 [ [[SNEXT]], [[LOOP]] ] diff --git a/llvm/test/Transforms/IndVarSimplify/AArch64/ptrtoaddr-ptrtoint.ll b/llvm/test/Transforms/IndVarSimplify/AArch64/ptrtoaddr-ptrtoint.ll index fee21dc0a930..fcb9d0a65602 100644 --- a/llvm/test/Transforms/IndVarSimplify/AArch64/ptrtoaddr-ptrtoint.ll +++ b/llvm/test/Transforms/IndVarSimplify/AArch64/ptrtoaddr-ptrtoint.ll @@ -7,7 +7,7 @@ define i64 @count_then_convert(ptr %end) { ; CHECK-LABEL: define i64 @count_then_convert( ; CHECK-SAME: ptr [[END:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; CHECK-NEXT: [[ISEMPTY:%.*]] = icmp eq ptr [[END]], null ; CHECK-NEXT: br i1 [[ISEMPTY]], label %[[EXIT:.*]], label %[[BODY_PH:.*]] ; CHECK: [[BODY_PH]]: @@ -51,8 +51,8 @@ define i64 @ptrtoint_sub_in_exit(ptr %start, ptr %bound) { ; CHECK-LABEL: define i64 @ptrtoint_sub_in_exit( ; CHECK-SAME: ptr [[START:%.*]], ptr [[BOUND:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[START3:%.*]] = ptrtoint ptr [[START]] to i64 -; CHECK-NEXT: [[BOUND2:%.*]] = ptrtoint ptr [[BOUND]] to i64 +; CHECK-NEXT: [[START3:%.*]] = ptrtoaddr ptr [[START]] to i64 +; CHECK-NEXT: [[BOUND2:%.*]] = ptrtoaddr ptr [[BOUND]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[BOUND2]], [[START3]] ; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[START]], i64 [[TMP0]] ; CHECK-NEXT: br label %[[BODY:.*]] diff --git a/llvm/test/Transforms/IndVarSimplify/X86/ptrtoaddr-narrow-pointer.ll b/llvm/test/Transforms/IndVarSimplify/X86/ptrtoaddr-narrow-pointer.ll index 0019e7b1eea1..6bc351144011 100644 --- a/llvm/test/Transforms/IndVarSimplify/X86/ptrtoaddr-narrow-pointer.ll +++ b/llvm/test/Transforms/IndVarSimplify/X86/ptrtoaddr-narrow-pointer.ll @@ -8,20 +8,20 @@ define ptr addrspace(1) @exit_value_narrow_address(ptr addrspace(1) %start, ptr ; CHECK-LABEL: define ptr addrspace(1) @exit_value_narrow_address( ; CHECK-SAME: ptr addrspace(1) [[START:%.*]], ptr addrspace(1) [[END:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: +; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr addrspace(1) [[START]] to i32 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr addrspace(1) [[END]] to i32 ; CHECK-NEXT: [[PRE:%.*]] = icmp ult ptr addrspace(1) [[START]], [[END]] ; CHECK-NEXT: br i1 [[PRE]], label %[[LOOP_PREHEADER:.*]], label %[[EXIT:.*]] ; CHECK: [[LOOP_PREHEADER]]: ; CHECK-NEXT: br label %[[LOOP:.*]] ; CHECK: [[LOOP]]: -; CHECK-NEXT: [[P:%.*]] = phi ptr addrspace(1) [ [[P_NEXT:%.*]], %[[LOOP]] ], [ [[START]], %[[LOOP_PREHEADER]] ] -; CHECK-NEXT: [[P_NEXT]] = getelementptr inbounds i8, ptr addrspace(1) [[P]], i64 1 -; CHECK-NEXT: [[C:%.*]] = icmp ult ptr addrspace(1) [[P_NEXT]], [[END]] -; CHECK-NEXT: br i1 [[C]], label %[[LOOP]], label %[[EXIT_LOOPEXIT:.*]] +; CHECK-NEXT: br i1 false, label %[[LOOP]], label %[[EXIT_LOOPEXIT:.*]] ; CHECK: [[EXIT_LOOPEXIT]]: -; CHECK-NEXT: [[P_NEXT_LCSSA:%.*]] = phi ptr addrspace(1) [ [[P_NEXT]], %[[LOOP]] ] +; CHECK-NEXT: [[TMP0:%.*]] = sub i32 [[END1]], [[START2]] +; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr addrspace(1) [[START]], i32 [[TMP0]] ; CHECK-NEXT: br label %[[EXIT]] ; CHECK: [[EXIT]]: -; CHECK-NEXT: [[RES:%.*]] = phi ptr addrspace(1) [ [[START]], %[[ENTRY]] ], [ [[P_NEXT_LCSSA]], %[[EXIT_LOOPEXIT]] ] +; CHECK-NEXT: [[RES:%.*]] = phi ptr addrspace(1) [ [[START]], %[[ENTRY]] ], [ [[SCEVGEP]], %[[EXIT_LOOPEXIT]] ] ; CHECK-NEXT: ret ptr addrspace(1) [[RES]] ; entry: diff --git a/llvm/test/Transforms/IndVarSimplify/callbr.ll b/llvm/test/Transforms/IndVarSimplify/callbr.ll index 2cdfea4dc0c2..6232c726a13c 100644 --- a/llvm/test/Transforms/IndVarSimplify/callbr.ll +++ b/llvm/test/Transforms/IndVarSimplify/callbr.ll @@ -5,7 +5,7 @@ define ptr @callbr_result_exit_value(ptr %a0) { ; CHECK-LABEL: define ptr @callbr_result_exit_value( ; CHECK-SAME: ptr [[A0:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*:]] -; CHECK-NEXT: [[A02:%.*]] = ptrtoint ptr [[A0]] to i64 +; CHECK-NEXT: [[A02:%.*]] = ptrtoaddr ptr [[A0]] to i64 ; CHECK-NEXT: [[OUT:%.*]] = callbr ptr asm "", "=r,!i"() ; CHECK-NEXT: to label %[[D:.*]] [label %[[INDIRECT:.*]]] ; CHECK: [[INDIRECT]]: @@ -18,7 +18,7 @@ define ptr @callbr_result_exit_value(ptr %a0) { ; CHECK: [[LOOP]]: ; CHECK-NEXT: br i1 true, label %[[EXIT:.*]], label %[[LOOP]] ; CHECK: [[EXIT]]: -; CHECK-NEXT: [[OUT1:%.*]] = ptrtoint ptr [[OUT]] to i64 +; CHECK-NEXT: [[OUT1:%.*]] = ptrtoaddr ptr [[OUT]] to i64 ; CHECK-NEXT: [[DIFF:%.*]] = sub i64 [[OUT1]], [[A02]] ; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[A0]], i64 [[DIFF]] ; CHECK-NEXT: ret ptr [[SCEVGEP]] diff --git a/llvm/test/Transforms/IndVarSimplify/pointer-loop-guards.ll b/llvm/test/Transforms/IndVarSimplify/pointer-loop-guards.ll index dbd572d61163..8d9b36919850 100644 --- a/llvm/test/Transforms/IndVarSimplify/pointer-loop-guards.ll +++ b/llvm/test/Transforms/IndVarSimplify/pointer-loop-guards.ll @@ -32,8 +32,8 @@ define i64 @test_ptr_compare_guard(ptr %start, ptr %end) { ; N32-LABEL: define i64 @test_ptr_compare_guard( ; N32-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) { ; N32-NEXT: [[ENTRY:.*]]: -; N32-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 -; N32-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; N32-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 +; N32-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; N32-NEXT: [[C_0:%.*]] = icmp eq ptr [[START]], [[END]] ; N32-NEXT: br i1 [[C_0]], label %[[EXIT:.*]], label %[[LOOP_HEADER_PREHEADER:.*]] ; N32: [[LOOP_HEADER_PREHEADER]]: diff --git a/llvm/test/Transforms/IndVarSimplify/pr59633.ll b/llvm/test/Transforms/IndVarSimplify/pr59633.ll index 888a45b714dc..1a47995884af 100644 --- a/llvm/test/Transforms/IndVarSimplify/pr59633.ll +++ b/llvm/test/Transforms/IndVarSimplify/pr59633.ll @@ -7,7 +7,7 @@ declare void @foo(i64 noundef) define void @pr59633(ptr noundef %ptr) { ; CHECK-LABEL: @pr59633( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[PTR1:%.*]] = ptrtoint ptr [[PTR:%.*]] to i64 +; CHECK-NEXT: [[PTR1:%.*]] = ptrtoaddr ptr [[PTR:%.*]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = trunc i64 [[PTR1]] to i4 ; CHECK-NEXT: [[TMP1:%.*]] = zext i4 [[TMP0]] to i64 ; CHECK-NEXT: br label [[WHILE_BODY:%.*]] diff --git a/llvm/test/Transforms/LoopIdiom/memset-debugify-remarks.ll b/llvm/test/Transforms/LoopIdiom/memset-debugify-remarks.ll index c116b473e74e..5be1e8f68914 100644 --- a/llvm/test/Transforms/LoopIdiom/memset-debugify-remarks.ll +++ b/llvm/test/Transforms/LoopIdiom/memset-debugify-remarks.ll @@ -33,8 +33,8 @@ target triple = "x86_64-unknown-linux-gnu" define void @_Z15my_basic_memsetPcS_c(ptr %ptr, ptr %end, i8 %value) { ; CHECK-LABEL: @_Z15my_basic_memsetPcS_c( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[PTR2:%.*]] = ptrtoint ptr [[PTR:%.*]] to i64, !dbg [[DBG15:![0-9]+]] -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END:%.*]] to i64, !dbg [[DBG15]] +; CHECK-NEXT: [[PTR2:%.*]] = ptrtoaddr ptr [[PTR:%.*]] to i64, !dbg [[DBG15:![0-9]+]] +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END:%.*]] to i64, !dbg [[DBG15]] ; CHECK-NEXT: [[CMP3:%.*]] = icmp eq ptr [[PTR]], [[END]], !dbg [[DBG15]] ; CHECK-NEXT: #dbg_value(i1 [[CMP3]], [[META9:![0-9]+]], !DIExpression(), [[DBG15]]) ; CHECK-NEXT: br i1 [[CMP3]], label [[FOR_END:%.*]], label [[FOR_BODY_PREHEADER:%.*]], !dbg [[DBG16:![0-9]+]] diff --git a/llvm/test/Transforms/LoopIdiom/reuse-lcssa-phi-scev-expansion.ll b/llvm/test/Transforms/LoopIdiom/reuse-lcssa-phi-scev-expansion.ll index d0e70c21c7bc..05ef5d111fe5 100644 --- a/llvm/test/Transforms/LoopIdiom/reuse-lcssa-phi-scev-expansion.ll +++ b/llvm/test/Transforms/LoopIdiom/reuse-lcssa-phi-scev-expansion.ll @@ -227,7 +227,7 @@ define void @expand_truncated_ptrtoint(ptr %A, ptr %B) { ; CHECK-LABEL: define void @expand_truncated_ptrtoint( ; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 +; CHECK-NEXT: [[A1:%.*]] = ptrtoaddr ptr [[A]] to i64 ; CHECK-NEXT: br label %[[LOOP_1:.*]] ; CHECK: [[LOOP_1]]: ; CHECK-NEXT: [[INDVAR:%.*]] = phi i32 [ [[INDVAR_NEXT:%.*]], %[[LOOP_1]] ], [ 0, %[[ENTRY]] ] diff --git a/llvm/test/Transforms/LoopStrengthReduce/2013-01-14-ReuseCast.ll b/llvm/test/Transforms/LoopStrengthReduce/2013-01-14-ReuseCast.ll index db40bba62ebc..9984dd471642 100644 --- a/llvm/test/Transforms/LoopStrengthReduce/2013-01-14-ReuseCast.ll +++ b/llvm/test/Transforms/LoopStrengthReduce/2013-01-14-ReuseCast.ll @@ -12,7 +12,7 @@ target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f3 ; CHECK: bb: ; "dead" ptrpoint not emitted (or dead code eliminated) with ; current LSR cost model. -; CHECK-NOT: = ptrtoint ptr undef to i64 +; CHECK-NOT: = ptrtoaddr ptr undef to i64 ; CHECK: .lr.ph ; CHECK: ret void define void @VerifyDiagnosticConsumerTest(i1 %arg) unnamed_addr nounwind uwtable align 2 { diff --git a/llvm/test/Transforms/LoopStrengthReduce/AArch64/expand-ptrtoaddr-reuse-ptrtoint.ll b/llvm/test/Transforms/LoopStrengthReduce/AArch64/expand-ptrtoaddr-reuse-ptrtoint.ll index 38d9ad141837..b842e1677be3 100644 --- a/llvm/test/Transforms/LoopStrengthReduce/AArch64/expand-ptrtoaddr-reuse-ptrtoint.ll +++ b/llvm/test/Transforms/LoopStrengthReduce/AArch64/expand-ptrtoaddr-reuse-ptrtoint.ll @@ -7,8 +7,8 @@ define i64 @expand_reuses_existing_ptrtoint(ptr %begin, ptr %end, ptr %cap) { ; CHECK-LABEL: define i64 @expand_reuses_existing_ptrtoint( ; CHECK-SAME: ptr [[BEGIN:%.*]], ptr [[END:%.*]], ptr [[CAP:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[BEGIN2:%.*]] = ptrtoint ptr [[BEGIN]] to i64 -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; CHECK-NEXT: [[BEGIN2:%.*]] = ptrtoaddr ptr [[BEGIN]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; CHECK-NEXT: [[C0:%.*]] = icmp eq ptr [[BEGIN]], [[END]] ; CHECK-NEXT: br i1 [[C0]], label %[[DONE:.*]], label %[[COUNT_PH:.*]] ; CHECK: [[COUNT_PH]]: diff --git a/llvm/test/Transforms/LoopStrengthReduce/RISCV/lsr-drop-solution-dbg-msg.ll b/llvm/test/Transforms/LoopStrengthReduce/RISCV/lsr-drop-solution-dbg-msg.ll index 3eade6474e61..b3b2f657f07c 100644 --- a/llvm/test/Transforms/LoopStrengthReduce/RISCV/lsr-drop-solution-dbg-msg.ll +++ b/llvm/test/Transforms/LoopStrengthReduce/RISCV/lsr-drop-solution-dbg-msg.ll @@ -6,8 +6,8 @@ target datalayout = "e-m:e-p:64:64-i64:64-i128:128-n64-S128" target triple = "riscv64-unknown-linux-gnu" define ptr @foo(ptr %a0, ptr %a1, i64 %a2) { -;DEBUG: The baseline solution requires 2 instructions 4 regs, with addrec cost 2, plus 3 setup cost -;DEBUG: The chosen solution requires 3 instructions 6 regs, with addrec cost 1, plus 2 base adds, plus 4 setup cost +;DEBUG: The baseline solution requires 2 instructions 4 regs, with addrec cost 2, plus 4 setup cost +;DEBUG: The chosen solution requires 3 instructions 6 regs, with addrec cost 1, plus 2 base adds, plus 5 setup cost ;DEBUG: Baseline is more profitable than chosen solution, dropping LSR solution. ;DEBUG2: Baseline is more profitable than chosen solution, add option 'lsr-drop-solution' to drop LSR solution. diff --git a/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll b/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll index d652e5c5aa06..bb759aefcdf4 100644 --- a/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll +++ b/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll @@ -11,7 +11,7 @@ target triple = "x86_64-apple-macosx10.15.0" define i64 @blam(ptr %start, ptr %end, ptr %ptr.2) { ; CHECK-LABEL: @blam( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[START1:%.*]] = ptrtoint ptr [[START:%.*]] to i64 +; CHECK-NEXT: [[START1:%.*]] = ptrtoaddr ptr [[START:%.*]] to i64 ; CHECK-NEXT: br label [[LOOP_1_HEADER:%.*]] ; CHECK: loop.1.header: ; CHECK-NEXT: [[LSR_IV4:%.*]] = phi i64 [ [[LSR_IV_NEXT5:%.*]], [[LOOP_1_HEADER]] ], [ [[START1]], [[ENTRY:%.*]] ] diff --git a/llvm/test/Transforms/LoopUnroll/AArch64/apple-unrolling-multi-exit.ll b/llvm/test/Transforms/LoopUnroll/AArch64/apple-unrolling-multi-exit.ll index b0730ec330cd..8caa5eddc713 100644 --- a/llvm/test/Transforms/LoopUnroll/AArch64/apple-unrolling-multi-exit.ll +++ b/llvm/test/Transforms/LoopUnroll/AArch64/apple-unrolling-multi-exit.ll @@ -13,10 +13,10 @@ define i1 @multi_2_exit_find_i8_loop(ptr %vec, i8 %tgt) { ; APPLE-SAME: ptr [[VEC:%.*]], i8 [[TGT:%.*]]) #[[ATTR0:[0-9]+]] { ; APPLE-NEXT: [[ENTRY:.*]]: ; APPLE-NEXT: [[START:%.*]] = load ptr, ptr [[VEC]], align 8 -; APPLE-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; APPLE-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; APPLE-NEXT: [[GEP_END:%.*]] = getelementptr inbounds nuw i8, ptr [[VEC]], i64 1 ; APPLE-NEXT: [[END:%.*]] = load ptr, ptr [[GEP_END]], align 8 -; APPLE-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; APPLE-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; APPLE-NEXT: [[TMP0:%.*]] = sub i64 [[END1]], [[START2]] ; APPLE-NEXT: [[TMP1:%.*]] = freeze i64 [[TMP0]] ; APPLE-NEXT: [[TMP2:%.*]] = add i64 [[TMP1]], -1 @@ -136,11 +136,11 @@ define i1 @multi_2_exit_find_ptr_loop(ptr %vec, ptr %tgt) { ; APPLE-SAME: ptr [[VEC:%.*]], ptr [[TGT:%.*]]) #[[ATTR0]] { ; APPLE-NEXT: [[ENTRY:.*]]: ; APPLE-NEXT: [[START:%.*]] = load ptr, ptr [[VEC]], align 8 -; APPLE-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; APPLE-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; APPLE-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[START]], i64 8) ] ; APPLE-NEXT: [[GEP_END:%.*]] = getelementptr inbounds nuw i8, ptr [[VEC]], i64 8 ; APPLE-NEXT: [[END:%.*]] = load ptr, ptr [[GEP_END]], align 8 -; APPLE-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; APPLE-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; APPLE-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[END]], i64 8) ] ; APPLE-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8 ; APPLE-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]] diff --git a/llvm/test/Transforms/LoopUnroll/AArch64/unrolling-multi-exit.ll b/llvm/test/Transforms/LoopUnroll/AArch64/unrolling-multi-exit.ll index 6714c5bbe431..7ee6f7eaf570 100644 --- a/llvm/test/Transforms/LoopUnroll/AArch64/unrolling-multi-exit.ll +++ b/llvm/test/Transforms/LoopUnroll/AArch64/unrolling-multi-exit.ll @@ -10,10 +10,10 @@ define i1 @multi_2_exiting_find_i8_loop_same_exit(ptr %vec, i8 %tgt) { ; UNROLL4-SAME: ptr [[VEC:%.*]], i8 [[TGT:%.*]]) #[[ATTR0:[0-9]+]] { ; UNROLL4-NEXT: [[ENTRY:.*]]: ; UNROLL4-NEXT: [[START:%.*]] = load ptr, ptr [[VEC]], align 8 -; UNROLL4-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; UNROLL4-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; UNROLL4-NEXT: [[GEP_END:%.*]] = getelementptr inbounds nuw i8, ptr [[VEC]], i64 1 ; UNROLL4-NEXT: [[END:%.*]] = load ptr, ptr [[GEP_END]], align 8 -; UNROLL4-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; UNROLL4-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; UNROLL4-NEXT: [[TMP0:%.*]] = sub i64 [[END1]], [[START2]] ; UNROLL4-NEXT: [[TMP1:%.*]] = freeze i64 [[TMP0]] ; UNROLL4-NEXT: [[TMP2:%.*]] = add i64 [[TMP1]], -1 @@ -133,10 +133,10 @@ define i1 @multi_2_exiting_find_i8_loop_diff_exit(ptr %vec, i8 %tgt) { ; UNROLL4-SAME: ptr [[VEC:%.*]], i8 [[TGT:%.*]]) #[[ATTR0]] { ; UNROLL4-NEXT: [[ENTRY:.*]]: ; UNROLL4-NEXT: [[START:%.*]] = load ptr, ptr [[VEC]], align 8 -; UNROLL4-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; UNROLL4-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; UNROLL4-NEXT: [[GEP_END:%.*]] = getelementptr inbounds nuw i8, ptr [[VEC]], i64 1 ; UNROLL4-NEXT: [[END:%.*]] = load ptr, ptr [[GEP_END]], align 8 -; UNROLL4-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; UNROLL4-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; UNROLL4-NEXT: [[TMP0:%.*]] = sub i64 [[END1]], [[START2]] ; UNROLL4-NEXT: [[TMP1:%.*]] = freeze i64 [[TMP0]] ; UNROLL4-NEXT: [[TMP2:%.*]] = add i64 [[TMP1]], -1 @@ -252,11 +252,11 @@ define i1 @multi_2_exiting_find_ptr_loop_same_exit(ptr %vec, ptr %tgt) { ; UNROLL4-SAME: ptr [[VEC:%.*]], ptr [[TGT:%.*]]) #[[ATTR0]] { ; UNROLL4-NEXT: [[ENTRY:.*]]: ; UNROLL4-NEXT: [[START:%.*]] = load ptr, ptr [[VEC]], align 8 -; UNROLL4-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; UNROLL4-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; UNROLL4-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[START]], i64 8) ] ; UNROLL4-NEXT: [[GEP_END:%.*]] = getelementptr inbounds nuw i8, ptr [[VEC]], i64 8 ; UNROLL4-NEXT: [[END:%.*]] = load ptr, ptr [[GEP_END]], align 8 -; UNROLL4-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; UNROLL4-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; UNROLL4-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[END]], i64 8) ] ; UNROLL4-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8 ; UNROLL4-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]] @@ -387,11 +387,11 @@ define ptr @multi_2_exiting_find_ptr_loop_diff_exit(ptr %vec, ptr %tgt) { ; UNROLL4-SAME: ptr [[VEC:%.*]], ptr [[TGT:%.*]]) #[[ATTR0]] { ; UNROLL4-NEXT: [[ENTRY:.*]]: ; UNROLL4-NEXT: [[START:%.*]] = load ptr, ptr [[VEC]], align 8 -; UNROLL4-NEXT: [[START3:%.*]] = ptrtoint ptr [[START]] to i64 +; UNROLL4-NEXT: [[START3:%.*]] = ptrtoaddr ptr [[START]] to i64 ; UNROLL4-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[START]], i64 8) ] ; UNROLL4-NEXT: [[GEP_END:%.*]] = getelementptr inbounds nuw i8, ptr [[VEC]], i64 8 ; UNROLL4-NEXT: [[END:%.*]] = load ptr, ptr [[GEP_END]], align 8 -; UNROLL4-NEXT: [[END2:%.*]] = ptrtoint ptr [[END]] to i64 +; UNROLL4-NEXT: [[END2:%.*]] = ptrtoaddr ptr [[END]] to i64 ; UNROLL4-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[END]], i64 8) ] ; UNROLL4-NEXT: [[TMP0:%.*]] = add i64 [[END2]], -8 ; UNROLL4-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START3]] diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll b/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll index a9a91519e7d3..23ffc98cbc28 100644 --- a/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll @@ -22,8 +22,8 @@ define void @test_interleave_reduction(ptr %arg, ptr %arg1) { ; A320-NEXT: [[TPM29:%.*]] = load ptr, ptr [[TPM28]], align 8 ; A320-NEXT: [[TPM17:%.*]] = alloca double, align 8 ; A320-NEXT: [[TPM32:%.*]] = getelementptr inbounds double, ptr [[TPM17]], i64 [[TPM26]] -; A320-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[TPM29]] to i64 -; A320-NEXT: [[TPM102:%.*]] = ptrtoint ptr [[TPM10]] to i64 +; A320-NEXT: [[TMP0:%.*]] = ptrtoaddr ptr [[TPM29]] to i64 +; A320-NEXT: [[TPM102:%.*]] = ptrtoaddr ptr [[TPM10]] to i64 ; A320-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[TPM102]] ; A320-NEXT: [[TMP6:%.*]] = add i64 [[TMP1]], -8 ; A320-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP6]], 2 diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/induction-costs.ll b/llvm/test/Transforms/LoopVectorize/AArch64/induction-costs.ll index 5e68b6d6c748..29f54d4103db 100644 --- a/llvm/test/Transforms/LoopVectorize/AArch64/induction-costs.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/induction-costs.ll @@ -99,8 +99,8 @@ define i64 @pointer_induction_only(ptr %start, ptr %end) { ; CHECK-LABEL: define i64 @pointer_induction_only( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[END1]], [[START2]] ; CHECK-NEXT: [[TMP1:%.*]] = lshr i64 [[TMP0]], 2 ; CHECK-NEXT: [[TMP2:%.*]] = add nuw nsw i64 [[TMP1]], 1 @@ -435,8 +435,8 @@ define i32 @load_from_pointer_induction(ptr %start, ptr %end) { ; CHECK-LABEL: define i32 @load_from_pointer_induction( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = call i64 @llvm.umax.i64(i64 [[END1]], i64 [[START2]]) ; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]] ; CHECK-NEXT: [[TMP20:%.*]] = add i64 [[TMP1]], 1 diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/partial-reduce-constant-ops.ll b/llvm/test/Transforms/LoopVectorize/AArch64/partial-reduce-constant-ops.ll index 94f98343421b..2122cfcaca26 100644 --- a/llvm/test/Transforms/LoopVectorize/AArch64/partial-reduce-constant-ops.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/partial-reduce-constant-ops.ll @@ -7,8 +7,8 @@ define i32 @red_zext_mul_by_63(ptr %start, ptr %end) { ; CHECK-LABEL: define i32 @red_zext_mul_by_63( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP7:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP7:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP8:%.*]] = sub i64 [[END1]], [[TMP7]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP8]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP1]], 16 @@ -73,8 +73,8 @@ define i32 @red_zext_mul_by_255(ptr %start, ptr %end) { ; CHECK-LABEL: define i32 @red_zext_mul_by_255( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP5:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP5:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP8:%.*]] = sub i64 [[END1]], [[TMP5]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP8]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP1]], 16 @@ -139,8 +139,8 @@ define i32 @red_zext_mul_by_256(ptr %start, ptr %end) { ; CHECK-LABEL: define i32 @red_zext_mul_by_256( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP8:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP8:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP9:%.*]] = sub i64 [[END1]], [[TMP8]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP9]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP1]], 16 @@ -205,8 +205,8 @@ define i32 @red_sext_mul_by_63(ptr %start, ptr %end) { ; CHECK-LABEL: define i32 @red_sext_mul_by_63( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP7:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP7:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP8:%.*]] = sub i64 [[END1]], [[TMP7]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP8]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP1]], 16 @@ -273,8 +273,8 @@ define i32 @red_sext_mul_by_128(ptr %start, ptr %end) { ; CHECK-LABEL: define i32 @red_sext_mul_by_128( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP8:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP8:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP9:%.*]] = sub i64 [[END1]], [[TMP8]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP9]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP1]], 16 @@ -340,8 +340,8 @@ define i32 @red_sext_mul_by_255(ptr %start, ptr %end) { ; CHECK-LABEL: define i32 @red_sext_mul_by_255( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP8:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP8:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP9:%.*]] = sub i64 [[END1]], [[TMP8]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP9]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP1]], 16 @@ -406,8 +406,8 @@ define i32 @red_sext_mul_by_256(ptr %start, ptr %end) { ; CHECK-LABEL: define i32 @red_sext_mul_by_256( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP8:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP8:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP9:%.*]] = sub i64 [[END1]], [[TMP8]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP9]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP1]], 16 diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/partial-reduce-incomplete-chains.ll b/llvm/test/Transforms/LoopVectorize/AArch64/partial-reduce-incomplete-chains.ll index 00e9fb2f7dc4..f338b6cc6ad8 100644 --- a/llvm/test/Transforms/LoopVectorize/AArch64/partial-reduce-incomplete-chains.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/partial-reduce-incomplete-chains.ll @@ -7,8 +7,8 @@ define i32 @red_extended_add_incomplete_chain(ptr %start, ptr %end, i32 %offset) ; CHECK-LABEL: define i32 @red_extended_add_incomplete_chain( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]], i32 [[OFFSET:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP8:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP8:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP9:%.*]] = sub i64 [[END1]], [[TMP8]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP9]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP1]], 16 diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/reduction-cost.ll b/llvm/test/Transforms/LoopVectorize/AArch64/reduction-cost.ll index 7f21fdeb2b76..af6166be4ab4 100644 --- a/llvm/test/Transforms/LoopVectorize/AArch64/reduction-cost.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/reduction-cost.ll @@ -92,26 +92,22 @@ define i32 @or_reduction_with_freeze(ptr %dst, ptr %src) { ; CHECK-LABEL: define i32 @or_reduction_with_freeze( ; CHECK-SAME: ptr [[DST:%.*]], ptr [[SRC:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[SRC7:%.*]] = ptrtoint ptr [[SRC]] to i64 -; CHECK-NEXT: [[DST6:%.*]] = ptrtoint ptr [[DST]] to i64 -; CHECK-NEXT: [[SRC4:%.*]] = ptrtoint ptr [[SRC]] to i64 -; CHECK-NEXT: [[DST3:%.*]] = ptrtoint ptr [[DST]] to i64 -; CHECK-NEXT: [[DST1:%.*]] = ptrtoint ptr [[DST]] to i64 -; CHECK-NEXT: [[TMP11:%.*]] = ptrtoint ptr [[SRC]] to i64 -; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[DST1]], [[TMP11]] +; CHECK-NEXT: [[SRC7:%.*]] = ptrtoaddr ptr [[SRC]] to i64 +; CHECK-NEXT: [[DST1:%.*]] = ptrtoaddr ptr [[DST]] to i64 +; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[DST1]], [[SRC7]] ; CHECK-NEXT: [[TMP1:%.*]] = lshr i64 [[TMP0]], 3 ; CHECK-NEXT: [[TMP2:%.*]] = add nuw nsw i64 [[TMP1]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP2]], 10 ; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_SCEVCHECK:.*]] ; CHECK: [[VECTOR_SCEVCHECK]]: -; CHECK-NEXT: [[TMP3:%.*]] = trunc i64 [[DST3]] to i3 -; CHECK-NEXT: [[TMP4:%.*]] = trunc i64 [[SRC4]] to i3 +; CHECK-NEXT: [[TMP3:%.*]] = trunc i64 [[DST1]] to i3 +; CHECK-NEXT: [[TMP4:%.*]] = trunc i64 [[SRC7]] to i3 ; CHECK-NEXT: [[TMP5:%.*]] = sub i3 [[TMP3]], [[TMP4]] ; CHECK-NEXT: [[TMP6:%.*]] = zext i3 [[TMP5]] to i64 ; CHECK-NEXT: [[IDENT_CHECK:%.*]] = icmp ne i64 [[TMP6]], 0 ; CHECK-NEXT: br i1 [[IDENT_CHECK]], label %[[SCALAR_PH]], label %[[VECTOR_MEMCHECK:.*]] ; CHECK: [[VECTOR_MEMCHECK]]: -; CHECK-NEXT: [[TMP7:%.*]] = sub i64 [[DST6]], [[SRC7]] +; CHECK-NEXT: [[TMP7:%.*]] = sub i64 [[DST1]], [[SRC7]] ; CHECK-NEXT: [[TMP8:%.*]] = lshr i64 [[TMP7]], 3 ; CHECK-NEXT: [[TMP9:%.*]] = shl nuw i64 [[TMP8]], 3 ; CHECK-NEXT: [[TMP10:%.*]] = add i64 [[TMP9]], 8 diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/replicating-load-store-costs-apple.ll b/llvm/test/Transforms/LoopVectorize/AArch64/replicating-load-store-costs-apple.ll index e46509a4e1c6..64c78cc86543 100644 --- a/llvm/test/Transforms/LoopVectorize/AArch64/replicating-load-store-costs-apple.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/replicating-load-store-costs-apple.ll @@ -452,8 +452,8 @@ define void @test_prefer_vector_addressing(ptr %start, ptr %ms, ptr noalias %src ; CHECK-SAME: ptr [[START:%.*]], ptr [[MS:%.*]], ptr noalias [[SRC:%.*]]) #[[ATTR0]] { ; CHECK-NEXT: [[ENTRY:.*:]] ; CHECK-NEXT: [[GEP_START:%.*]] = getelementptr i8, ptr [[START]], i64 3 -; CHECK-NEXT: [[TMP10:%.*]] = ptrtoint ptr [[MS]] to i64 -; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[TMP10:%.*]] = ptrtoaddr ptr [[MS]] to i64 +; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[START2]], 3 ; CHECK-NEXT: [[TMP1:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP10]], i64 [[TMP0]]) ; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[TMP1]], [[START2]] diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/replicating-load-store-costs.ll b/llvm/test/Transforms/LoopVectorize/AArch64/replicating-load-store-costs.ll index 3c4833012a04..d090be609700 100644 --- a/llvm/test/Transforms/LoopVectorize/AArch64/replicating-load-store-costs.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/replicating-load-store-costs.ll @@ -448,8 +448,8 @@ define void @test_prefer_vector_addressing(ptr %start, ptr %ms, ptr noalias %src ; CHECK-SAME: ptr [[START:%.*]], ptr [[MS:%.*]], ptr noalias [[SRC:%.*]]) #[[ATTR0]] { ; CHECK-NEXT: [[ENTRY:.*:]] ; CHECK-NEXT: [[GEP_START:%.*]] = getelementptr i8, ptr [[START]], i64 3 -; CHECK-NEXT: [[TMP10:%.*]] = ptrtoint ptr [[MS]] to i64 -; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[TMP10:%.*]] = ptrtoaddr ptr [[MS]] to i64 +; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[START2]], 3 ; CHECK-NEXT: [[TMP1:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP10]], i64 [[TMP0]]) ; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[TMP1]], [[START2]] diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/sve-live-out-pointer-induction.ll b/llvm/test/Transforms/LoopVectorize/AArch64/sve-live-out-pointer-induction.ll index 82c07cd0e586..31c089d65abf 100644 --- a/llvm/test/Transforms/LoopVectorize/AArch64/sve-live-out-pointer-induction.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/sve-live-out-pointer-induction.ll @@ -4,8 +4,8 @@ define ptr @test(ptr %start.1, ptr %start.2, ptr %end) { ; CHECK-LABEL: @test( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[START_22:%.*]] = ptrtoint ptr [[START_2:%.*]] to i64 -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END:%.*]] to i64 +; CHECK-NEXT: [[START_22:%.*]] = ptrtoaddr ptr [[START_2:%.*]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END:%.*]] to i64 ; CHECK-NEXT: [[TMP6:%.*]] = sub i64 [[START_22]], [[END1]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP6]], -8 ; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/transform-narrow-interleave-to-widen-memory-cost.ll b/llvm/test/Transforms/LoopVectorize/AArch64/transform-narrow-interleave-to-widen-memory-cost.ll index 42115d8c8106..e9205e9e38b5 100644 --- a/llvm/test/Transforms/LoopVectorize/AArch64/transform-narrow-interleave-to-widen-memory-cost.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/transform-narrow-interleave-to-widen-memory-cost.ll @@ -505,7 +505,7 @@ define void @test_interleave_group_epilogue_with_preheader_phi(ptr %src, ptr %ds ; CHECK-LABEL: define void @test_interleave_group_epilogue_with_preheader_phi( ; CHECK-SAME: ptr [[SRC:%.*]], ptr [[DST:%.*]]) #[[ATTR0]] { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[SRC1:%.*]] = ptrtoint ptr [[SRC]] to i64 +; CHECK-NEXT: [[SRC1:%.*]] = ptrtoaddr ptr [[SRC]] to i64 ; CHECK-NEXT: br label %[[ITER_CHECK:.*]] ; CHECK: [[ITER_CHECK]]: ; CHECK-NEXT: [[DST_PRE:%.*]] = phi ptr [ [[DST]], %[[ENTRY]] ] diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/transform-narrow-interleave-to-widen-memory-derived-ivs.ll b/llvm/test/Transforms/LoopVectorize/AArch64/transform-narrow-interleave-to-widen-memory-derived-ivs.ll index 3236935e448f..9eeff5bc9b89 100644 --- a/llvm/test/Transforms/LoopVectorize/AArch64/transform-narrow-interleave-to-widen-memory-derived-ivs.ll +++ b/llvm/test/Transforms/LoopVectorize/AArch64/transform-narrow-interleave-to-widen-memory-derived-ivs.ll @@ -131,8 +131,8 @@ define void @derived_pointer_ivs(ptr noalias %a, ptr noalias %b, ptr %end) { ; VF2-LABEL: define void @derived_pointer_ivs( ; VF2-SAME: ptr noalias [[A:%.*]], ptr noalias [[B:%.*]], ptr [[END:%.*]]) { ; VF2-NEXT: [[ENTRY:.*:]] -; VF2-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; VF2-NEXT: [[TMP4:%.*]] = ptrtoint ptr [[A]] to i64 +; VF2-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; VF2-NEXT: [[TMP4:%.*]] = ptrtoaddr ptr [[A]] to i64 ; VF2-NEXT: [[TMP5:%.*]] = sub i64 [[END1]], [[TMP4]] ; VF2-NEXT: [[TMP1:%.*]] = add i64 [[TMP5]], -16 ; VF2-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 4 @@ -164,8 +164,8 @@ define void @derived_pointer_ivs(ptr noalias %a, ptr noalias %b, ptr %end) { ; VF2IC2-LABEL: define void @derived_pointer_ivs( ; VF2IC2-SAME: ptr noalias [[A:%.*]], ptr noalias [[B:%.*]], ptr [[END:%.*]]) { ; VF2IC2-NEXT: [[ENTRY:.*:]] -; VF2IC2-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; VF2IC2-NEXT: [[TMP4:%.*]] = ptrtoint ptr [[A]] to i64 +; VF2IC2-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; VF2IC2-NEXT: [[TMP4:%.*]] = ptrtoaddr ptr [[A]] to i64 ; VF2IC2-NEXT: [[TMP5:%.*]] = sub i64 [[END1]], [[TMP4]] ; VF2IC2-NEXT: [[TMP1:%.*]] = add i64 [[TMP5]], -16 ; VF2IC2-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 4 @@ -202,8 +202,8 @@ define void @derived_pointer_ivs(ptr noalias %a, ptr noalias %b, ptr %end) { ; VF4-LABEL: define void @derived_pointer_ivs( ; VF4-SAME: ptr noalias [[A:%.*]], ptr noalias [[B:%.*]], ptr [[END:%.*]]) { ; VF4-NEXT: [[ENTRY:.*:]] -; VF4-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; VF4-NEXT: [[TMP4:%.*]] = ptrtoint ptr [[A]] to i64 +; VF4-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; VF4-NEXT: [[TMP4:%.*]] = ptrtoaddr ptr [[A]] to i64 ; VF4-NEXT: [[TMP5:%.*]] = sub i64 [[END1]], [[TMP4]] ; VF4-NEXT: [[TMP1:%.*]] = add i64 [[TMP5]], -16 ; VF4-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 4 diff --git a/llvm/test/Transforms/LoopVectorize/PowerPC/exit-branch-cost.ll b/llvm/test/Transforms/LoopVectorize/PowerPC/exit-branch-cost.ll index 5fc88479ac42..50215c35fe34 100644 --- a/llvm/test/Transforms/LoopVectorize/PowerPC/exit-branch-cost.ll +++ b/llvm/test/Transforms/LoopVectorize/PowerPC/exit-branch-cost.ll @@ -8,8 +8,8 @@ define i1 @select_exit_cond(ptr %start, ptr %end, i64 %N) { ; CHECK-LABEL: define i1 @select_exit_cond( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]], i64 [[N:%.*]]) { ; CHECK-NEXT: [[ITER_CHECK:.*]]: -; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = freeze i64 [[N]] ; CHECK-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[END1]], i64 [[START2]]) ; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[UMAX]], [[START2]] diff --git a/llvm/test/Transforms/LoopVectorize/PowerPC/pr41179.ll b/llvm/test/Transforms/LoopVectorize/PowerPC/pr41179.ll index fa2b4e95b594..4c912ace678b 100644 --- a/llvm/test/Transforms/LoopVectorize/PowerPC/pr41179.ll +++ b/llvm/test/Transforms/LoopVectorize/PowerPC/pr41179.ll @@ -4,12 +4,12 @@ define void @foo(ptr %start, ptr %end) { ; CHECK-LABEL: @foo( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END:%.*]] to i64 -; CHECK-NEXT: [[TMP9:%.*]] = ptrtoint ptr [[START:%.*]] to i64 -; CHECK-NEXT: [[TMP10:%.*]] = add i64 [[TMP9]], -1 -; CHECK-NEXT: [[UMIN:%.*]] = call i64 @llvm.umin.i64(i64 [[END1]], i64 [[TMP10]]) +; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START:%.*]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END:%.*]] to i64 +; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[END1]], -1 +; CHECK-NEXT: [[UMIN:%.*]] = call i64 @llvm.umin.i64(i64 [[START2]], i64 [[TMP1]]) ; CHECK-NEXT: [[TMP2:%.*]] = trunc i64 [[UMIN]] to i32 -; CHECK-NEXT: [[TMP0:%.*]] = trunc i64 [[TMP9]] to i32 +; CHECK-NEXT: [[TMP0:%.*]] = trunc i64 [[END1]] to i32 ; CHECK-NEXT: [[TMP3:%.*]] = sub i32 [[TMP0]], [[TMP2]] ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i32 [[TMP3]], 2 ; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] @@ -24,8 +24,8 @@ define void @foo(ptr %start, ptr %end) { ; CHECK-NEXT: [[INDUCTION3:%.*]] = add i32 [[OFFSET_IDX]], -1 ; CHECK-NEXT: [[TMP4:%.*]] = sub i32 -1, [[INDEX]] ; CHECK-NEXT: [[TMP5:%.*]] = add nsw i32 -1, [[INDUCTION3]] -; CHECK-NEXT: [[TMP6:%.*]] = getelementptr i8, ptr [[START]], i32 [[TMP4]] -; CHECK-NEXT: [[TMP7:%.*]] = getelementptr i8, ptr [[START]], i32 [[TMP5]] +; CHECK-NEXT: [[TMP6:%.*]] = getelementptr i8, ptr [[END]], i32 [[TMP4]] +; CHECK-NEXT: [[TMP7:%.*]] = getelementptr i8, ptr [[END]], i32 [[TMP5]] ; CHECK-NEXT: store i8 0, ptr [[TMP6]], align 1 ; CHECK-NEXT: store i8 0, ptr [[TMP7]], align 1 ; CHECK-NEXT: [[INDEX_NEXT]] = add nuw i32 [[INDEX]], 2 @@ -40,9 +40,9 @@ define void @foo(ptr %start, ptr %end) { ; CHECK: while.body: ; CHECK-NEXT: [[COUNT_09:%.*]] = phi i32 [ [[ADD:%.*]], [[WHILE_BODY]] ], [ [[BC_RESUME_VAL]], [[SCALAR_PH]] ] ; CHECK-NEXT: [[ADD]] = add nsw i32 -1, [[COUNT_09]] -; CHECK-NEXT: [[G:%.*]] = getelementptr i8, ptr [[START]], i32 [[ADD]] +; CHECK-NEXT: [[G:%.*]] = getelementptr i8, ptr [[END]], i32 [[ADD]] ; CHECK-NEXT: store i8 0, ptr [[G]], align 1 -; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[END]], [[G]] +; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[START]], [[G]] ; CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY]], label [[WHILE_END_LOOPEXIT]], !llvm.loop [[LOOP3:![0-9]+]] ; CHECK: while.end.loopexit: ; CHECK-NEXT: ret void diff --git a/llvm/test/Transforms/LoopVectorize/RISCV/pointer-induction.ll b/llvm/test/Transforms/LoopVectorize/RISCV/pointer-induction.ll index 195de9c8da6a..a55985caa28a 100644 --- a/llvm/test/Transforms/LoopVectorize/RISCV/pointer-induction.ll +++ b/llvm/test/Transforms/LoopVectorize/RISCV/pointer-induction.ll @@ -7,8 +7,8 @@ define void @ptr_induction(ptr %p, ptr noalias %q, ptr noalias %p.end) #0 { ; CHECK-LABEL: define void @ptr_induction( ; CHECK-SAME: ptr [[P:%.*]], ptr noalias [[Q:%.*]], ptr noalias [[P_END:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-NEXT: [[ENTRY:.*:]] -; CHECK-NEXT: [[P_END1:%.*]] = ptrtoint ptr [[P_END]] to i64 -; CHECK-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[P]] to i64 +; CHECK-NEXT: [[P_END1:%.*]] = ptrtoaddr ptr [[P_END]] to i64 +; CHECK-NEXT: [[TMP1:%.*]] = ptrtoaddr ptr [[P]] to i64 ; CHECK-NEXT: [[TMP8:%.*]] = sub i64 [[P_END1]], [[TMP1]] ; CHECK-NEXT: [[TMP3:%.*]] = add i64 [[TMP8]], 1 ; CHECK-NEXT: br label %[[VECTOR_PH:.*]] @@ -63,8 +63,8 @@ define i1 @scalarize_ptr_induction(ptr %start, ptr %end, ptr noalias %dst, i1 %c ; CHECK-LABEL: define i1 @scalarize_ptr_induction( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]], ptr noalias [[DST:%.*]], i1 [[C:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-NEXT: [[ENTRY:.*:]] -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP4:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP4:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP5:%.*]] = sub i64 [[END1]], [[TMP4]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP5]], -12 ; CHECK-NEXT: [[TMP2:%.*]] = udiv i64 [[TMP1]], 12 diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/expand-scev.ll b/llvm/test/Transforms/LoopVectorize/VPlan/expand-scev.ll index 89279ea5629d..573dc9056f8b 100644 --- a/llvm/test/Transforms/LoopVectorize/VPlan/expand-scev.ll +++ b/llvm/test/Transforms/LoopVectorize/VPlan/expand-scev.ll @@ -262,8 +262,8 @@ define void @scev_ptrtoint_expanded(ptr %start, ptr %end) { ; CHECK: VPlan 'Final VPlan for VF={4},UF={1}' { ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT-SCALAR vp<[[VP2:%[0-9]+]]> = ptrtoint ir<%end> to i64 -; CHECK-NEXT: EMIT-SCALAR vp<[[VP3:%[0-9]+]]> = ptrtoint ir<%start> to i64 +; CHECK-NEXT: EMIT-SCALAR vp<[[VP2:%[0-9]+]]> = ptrtoaddr ir<%end> to i64 +; CHECK-NEXT: EMIT-SCALAR vp<[[VP3:%[0-9]+]]> = ptrtoaddr ir<%start> to i64 ; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = sub vp<[[VP2]]>, vp<[[VP3]]> ; CHECK-NEXT: EMIT vp<%min.iters.check> = icmp ult vp<[[VP4]]>, ir<4> ; CHECK-NEXT: EMIT branch-on-cond vp<%min.iters.check> diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-predicate-switch.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-predicate-switch.ll index dc0c67326702..b07fa2d73ea3 100644 --- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-predicate-switch.ll +++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-predicate-switch.ll @@ -6,8 +6,8 @@ define void @switch4_default_common_dest_with_case(ptr %start, ptr %end) { ; CHECK: VPlan 'Final VPlan for VF={2},UF={1}' { ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT-SCALAR vp<[[VP2:%[0-9]+]]> = ptrtoint ir<%end> to i64 -; CHECK-NEXT: EMIT-SCALAR vp<[[VP3:%[0-9]+]]> = ptrtoint ir<%start> to i64 +; CHECK-NEXT: EMIT-SCALAR vp<[[VP2:%[0-9]+]]> = ptrtoaddr ir<%end> to i64 +; CHECK-NEXT: EMIT-SCALAR vp<[[VP3:%[0-9]+]]> = ptrtoaddr ir<%start> to i64 ; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = sub vp<[[VP2]]>, vp<[[VP3]]> ; CHECK-NEXT: EMIT vp<%min.iters.check> = icmp ult vp<[[VP4]]>, ir<2> ; CHECK-NEXT: EMIT branch-on-cond vp<%min.iters.check> diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions-tail-folded.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions-tail-folded.ll index df5c69b6cf84..618f53845fc9 100644 --- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions-tail-folded.ll +++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions-tail-folded.ll @@ -797,7 +797,7 @@ define i32 @print_mulacc_extended_const(ptr %start, ptr %end) { ; CHECK-NEXT: Live-in vp<[[VP3:%[0-9]+]]> = backedge-taken count ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = EXPAND SCEV (1 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) +; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = EXPAND SCEV (1 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) ; CHECK-NEXT: Successor(s): scalar.ph, vector.ph ; CHECK-EMPTY: ; CHECK-NEXT: vector.ph: @@ -859,7 +859,7 @@ define i32 @print_mulacc_extended_const_lhs(ptr %start, ptr %end) { ; CHECK-NEXT: Live-in vp<[[VP3:%[0-9]+]]> = backedge-taken count ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = EXPAND SCEV (1 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) +; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = EXPAND SCEV (1 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) ; CHECK-NEXT: Successor(s): scalar.ph, vector.ph ; CHECK-EMPTY: ; CHECK-NEXT: vector.ph: @@ -923,7 +923,7 @@ define i32 @print_mulacc_not_extended_const(ptr %start, ptr %end) { ; CHECK-NEXT: Live-in vp<[[VP3:%[0-9]+]]> = backedge-taken count ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = EXPAND SCEV (1 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) +; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = EXPAND SCEV (1 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) ; CHECK-NEXT: Successor(s): scalar.ph, vector.ph ; CHECK-EMPTY: ; CHECK-NEXT: vector.ph: @@ -987,7 +987,7 @@ define i64 @print_ext_mulacc_extended_const(ptr %start, ptr %end) { ; CHECK-NEXT: Live-in vp<[[VP3:%[0-9]+]]> = backedge-taken count ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = EXPAND SCEV (1 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) +; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = EXPAND SCEV (1 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) ; CHECK-NEXT: Successor(s): scalar.ph, vector.ph ; CHECK-EMPTY: ; CHECK-NEXT: vector.ph: @@ -1051,7 +1051,7 @@ define i64 @print_ext_mulacc_not_extended_const(ptr %start, ptr %end) { ; CHECK-NEXT: Live-in vp<[[VP3:%[0-9]+]]> = backedge-taken count ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = EXPAND SCEV (1 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) +; CHECK-NEXT: EMIT vp<[[VP4:%[0-9]+]]> = EXPAND SCEV (1 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) ; CHECK-NEXT: Successor(s): scalar.ph, vector.ph ; CHECK-EMPTY: ; CHECK-NEXT: vector.ph: diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions.ll index 6d7d7e73ce1a..e0f7c304f656 100644 --- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions.ll +++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions.ll @@ -1000,7 +1000,7 @@ define i32 @print_mulacc_extended_const(ptr %start, ptr %end) { ; CHECK-NEXT: vp<[[VP3:%[0-9]+]]> = original trip-count ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT vp<[[VP3]]> = EXPAND SCEV (1 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) +; CHECK-NEXT: EMIT vp<[[VP3]]> = EXPAND SCEV (1 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) ; CHECK-NEXT: Successor(s): scalar.ph, vector.ph ; CHECK-EMPTY: ; CHECK-NEXT: vector.ph: @@ -1078,7 +1078,7 @@ define i32 @print_mulacc_extended_const_lhs(ptr %start, ptr %end) { ; CHECK-NEXT: vp<[[VP3:%[0-9]+]]> = original trip-count ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT vp<[[VP3]]> = EXPAND SCEV (1 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) +; CHECK-NEXT: EMIT vp<[[VP3]]> = EXPAND SCEV (1 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) ; CHECK-NEXT: Successor(s): scalar.ph, vector.ph ; CHECK-EMPTY: ; CHECK-NEXT: vector.ph: @@ -1158,7 +1158,7 @@ define i32 @print_mulacc_not_extended_const(ptr %start, ptr %end) { ; CHECK-NEXT: vp<[[VP3:%[0-9]+]]> = original trip-count ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT vp<[[VP3]]> = EXPAND SCEV (1 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) +; CHECK-NEXT: EMIT vp<[[VP3]]> = EXPAND SCEV (1 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) ; CHECK-NEXT: Successor(s): scalar.ph, vector.ph ; CHECK-EMPTY: ; CHECK-NEXT: vector.ph: @@ -1238,7 +1238,7 @@ define i64 @print_ext_mulacc_extended_const(ptr %start, ptr %end) { ; CHECK-NEXT: vp<[[VP3:%[0-9]+]]> = original trip-count ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT vp<[[VP3]]> = EXPAND SCEV (1 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) +; CHECK-NEXT: EMIT vp<[[VP3]]> = EXPAND SCEV (1 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) ; CHECK-NEXT: Successor(s): scalar.ph, vector.ph ; CHECK-EMPTY: ; CHECK-NEXT: vector.ph: @@ -1319,7 +1319,7 @@ define i64 @print_ext_mulacc_not_extended_const(ptr %start, ptr %end) { ; CHECK-NEXT: vp<[[VP3:%[0-9]+]]> = original trip-count ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT vp<[[VP3]]> = EXPAND SCEV (1 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) +; CHECK-NEXT: EMIT vp<[[VP3]]> = EXPAND SCEV (1 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) ; CHECK-NEXT: Successor(s): scalar.ph, vector.ph ; CHECK-EMPTY: ; CHECK-NEXT: vector.ph: diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-sink-scalars-and-merge.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-sink-scalars-and-merge.ll index 2e9c7e788079..a6af9ff43b37 100644 --- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-sink-scalars-and-merge.ll +++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-sink-scalars-and-merge.ll @@ -1420,7 +1420,7 @@ define void @ptr_induction_remove_dead_recipe(ptr %start, ptr %end) { ; CHECK-NEXT: vp<[[VP3:%[0-9]+]]> = original trip-count ; CHECK-EMPTY: ; CHECK-NEXT: ir-bb: -; CHECK-NEXT: EMIT vp<[[VP3]]> = EXPAND SCEV ((-1 * (ptrtoint ptr %end to i64)) + (ptrtoint ptr %start to i64)) +; CHECK-NEXT: EMIT vp<[[VP3]]> = EXPAND SCEV ((-1 * (ptrtoaddr ptr %end to i64)) + (ptrtoaddr ptr %start to i64)) ; CHECK-NEXT: Successor(s): scalar.ph, vector.ph ; CHECK-EMPTY: ; CHECK-NEXT: vector.ph: diff --git a/llvm/test/Transforms/LoopVectorize/WebAssembly/induction-branch-cost.ll b/llvm/test/Transforms/LoopVectorize/WebAssembly/induction-branch-cost.ll index 7e7bd3243ab7..0f4dc1af8285 100644 --- a/llvm/test/Transforms/LoopVectorize/WebAssembly/induction-branch-cost.ll +++ b/llvm/test/Transforms/LoopVectorize/WebAssembly/induction-branch-cost.ll @@ -8,8 +8,8 @@ define void @induction_phi_and_branch_cost(ptr %end, ptr %start.1, ptr %start.2) ; CHECK-LABEL: define void @induction_phi_and_branch_cost( ; CHECK-SAME: ptr [[END:%.*]], ptr [[START_1:%.*]], ptr [[START_2:%.*]]) #[[ATTR0:[0-9]+]] { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[START_11:%.*]] = ptrtoint ptr [[START_1]] to i32 -; CHECK-NEXT: [[END2:%.*]] = ptrtoint ptr [[END]] to i32 +; CHECK-NEXT: [[START_11:%.*]] = ptrtoaddr ptr [[START_1]] to i32 +; CHECK-NEXT: [[END2:%.*]] = ptrtoaddr ptr [[END]] to i32 ; CHECK-NEXT: [[TMP0:%.*]] = sub i32 [[START_11]], [[END2]] ; CHECK-NEXT: [[TMP1:%.*]] = lshr i32 [[TMP0]], 2 ; CHECK-NEXT: [[TMP2:%.*]] = add nuw nsw i32 [[TMP1]], 1 diff --git a/llvm/test/Transforms/LoopVectorize/X86/CostModel/vpinstruction-cost.ll b/llvm/test/Transforms/LoopVectorize/X86/CostModel/vpinstruction-cost.ll index 421ce3c18d95..6ccc5dc7241a 100644 --- a/llvm/test/Transforms/LoopVectorize/X86/CostModel/vpinstruction-cost.ll +++ b/llvm/test/Transforms/LoopVectorize/X86/CostModel/vpinstruction-cost.ll @@ -217,7 +217,7 @@ define void @test_vpinstruction_switch_cost(ptr %start, ptr %end) { ; CHECK: Cost of 0 for VF 2: EMIT vp<%index.next> = add nuw vp<[[VP5]]>, vp<[[VP1:%[0-9]+]]> ; CHECK: Cost of 1 for VF 2: EMIT branch-on-count vp<%index.next>, vp<[[VP2:%[0-9]+]]> ; CHECK: Cost of 0 for VF 2: vector loop backedge -; CHECK: Cost of 0 for VF 2: EMIT vp<[[VP3:%[0-9]+]]> = EXPAND SCEV (1 + ((-8 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 8)) +; CHECK: Cost of 0 for VF 2: EMIT vp<[[VP3:%[0-9]+]]> = EXPAND SCEV (1 + ((-8 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) /u 8)) ; CHECK: Cost of 0 for VF 2: EMIT-SCALAR vp<%bc.resume.val> = phi [ vp<[[VP4:%[0-9]+]]>, middle.block ], [ ir<%start>, ir-bb ] ; CHECK: Cost of 0 for VF 2: IR %ptr.iv = phi ptr [ %start, %entry ], [ %ptr.iv.next, %loop.latch ] (extra operand: vp<%bc.resume.val> from scalar.ph) ; CHECK: Cost of 0 for VF 2: IR %l = load i64, ptr %ptr.iv, align 1 @@ -248,7 +248,7 @@ define void @test_vpinstruction_switch_cost(ptr %start, ptr %end) { ; CHECK: Cost of 0 for VF 4: EMIT vp<%index.next> = add nuw vp<[[VP5]]>, vp<[[VP1]]> ; CHECK: Cost of 1 for VF 4: EMIT branch-on-count vp<%index.next>, vp<[[VP2]]> ; CHECK: Cost of 0 for VF 4: vector loop backedge -; CHECK: Cost of 0 for VF 4: EMIT vp<[[VP3]]> = EXPAND SCEV (1 + ((-8 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 8)) +; CHECK: Cost of 0 for VF 4: EMIT vp<[[VP3]]> = EXPAND SCEV (1 + ((-8 + (-1 * (ptrtoaddr ptr %start to i64)) + (ptrtoaddr ptr %end to i64)) /u 8)) ; CHECK: Cost of 0 for VF 4: EMIT-SCALAR vp<%bc.resume.val> = phi [ vp<[[VP4]]>, middle.block ], [ ir<%start>, ir-bb ] ; CHECK: Cost of 0 for VF 4: IR %ptr.iv = phi ptr [ %start, %entry ], [ %ptr.iv.next, %loop.latch ] (extra operand: vp<%bc.resume.val> from scalar.ph) ; CHECK: Cost of 0 for VF 4: IR %l = load i64, ptr %ptr.iv, align 1 diff --git a/llvm/test/Transforms/LoopVectorize/X86/cost-model.ll b/llvm/test/Transforms/LoopVectorize/X86/cost-model.ll index c32d67d54838..941641fd688c 100644 --- a/llvm/test/Transforms/LoopVectorize/X86/cost-model.ll +++ b/llvm/test/Transforms/LoopVectorize/X86/cost-model.ll @@ -550,8 +550,8 @@ define i1 @any_of_cost(ptr %start, ptr %end) #0 { ; CHECK-LABEL: define i1 @any_of_cost( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR2]] { ; CHECK-NEXT: [[ENTRY:.*:]] -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[END1]], [[START2]] ; CHECK-NEXT: [[TMP1:%.*]] = udiv i64 [[TMP0]], 40 ; CHECK-NEXT: [[TMP2:%.*]] = add nuw nsw i64 [[TMP1]], 1 @@ -625,7 +625,7 @@ define i64 @cost_assume(ptr %end, i64 %N) { ; CHECK-LABEL: define i64 @cost_assume( ; CHECK-SAME: ptr [[END:%.*]], i64 [[N:%.*]]) #[[ATTR1]] { ; CHECK-NEXT: [[ENTRY:.*:]] -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -9 ; CHECK-NEXT: [[TMP1:%.*]] = udiv i64 [[TMP0]], 9 ; CHECK-NEXT: [[TMP2:%.*]] = add nuw nsw i64 [[TMP1]], 1 diff --git a/llvm/test/Transforms/LoopVectorize/X86/fold-tail-low-trip-count.ll b/llvm/test/Transforms/LoopVectorize/X86/fold-tail-low-trip-count.ll index d83617bf7b45..789e9f34f5b4 100644 --- a/llvm/test/Transforms/LoopVectorize/X86/fold-tail-low-trip-count.ll +++ b/llvm/test/Transforms/LoopVectorize/X86/fold-tail-low-trip-count.ll @@ -44,8 +44,8 @@ define ptr @low_trip_count_via_profile_info_with_iv_live_out(ptr align 16 %start ; CHECK-LABEL: define ptr @low_trip_count_via_profile_info_with_iv_live_out( ; CHECK-SAME: ptr align 16 [[START:%.*]], ptr align 16 [[END:%.*]], ptr noalias [[SRC:%.*]]) #[[ATTR0]] { ; CHECK-NEXT: [[ENTRY:.*:]] -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP7:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP7:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP8:%.*]] = sub i64 [[END1]], [[TMP7]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP8]], 1 ; CHECK-NEXT: br label %[[VECTOR_PH:.*]] @@ -98,8 +98,8 @@ define void @low_trip_count_via_profile_info(ptr align 16 %start, ptr align 16 % ; CHECK-LABEL: define void @low_trip_count_via_profile_info( ; CHECK-SAME: ptr align 16 [[START:%.*]], ptr align 16 [[END:%.*]], ptr noalias [[SRC:%.*]]) #[[ATTR0]] { ; CHECK-NEXT: [[ENTRY:.*:]] -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP6:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP6:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP7:%.*]] = sub i64 [[END1]], [[TMP6]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP7]], 1 ; CHECK-NEXT: br label %[[VECTOR_PH:.*]] diff --git a/llvm/test/Transforms/LoopVectorize/X86/interleave-opaque-pointers.ll b/llvm/test/Transforms/LoopVectorize/X86/interleave-opaque-pointers.ll index 4f52fcfb5402..bbc74e05b72c 100644 --- a/llvm/test/Transforms/LoopVectorize/X86/interleave-opaque-pointers.ll +++ b/llvm/test/Transforms/LoopVectorize/X86/interleave-opaque-pointers.ll @@ -9,8 +9,8 @@ target triple = "x86_64-linux-gnu" define void @test_pr55375_interleave_opaque_ptr(ptr %start, ptr %end) { ; CHECK-LABEL: @test_pr55375_interleave_opaque_ptr( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START:%.*]] to i64 -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END:%.*]] to i64 +; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START:%.*]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END:%.*]] to i64 ; CHECK-NEXT: [[TMP5:%.*]] = sub i64 [[START2]], [[END1]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP5]], -16 ; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 4 diff --git a/llvm/test/Transforms/LoopVectorize/X86/optsize.ll b/llvm/test/Transforms/LoopVectorize/X86/optsize.ll index fa3b93503ecd..00f44956b8a1 100644 --- a/llvm/test/Transforms/LoopVectorize/X86/optsize.ll +++ b/llvm/test/Transforms/LoopVectorize/X86/optsize.ll @@ -325,8 +325,8 @@ define void @tail_folded_store_avx512(ptr %start, ptr %end) #3 { ; CHECK-LABEL: define void @tail_folded_store_avx512( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR3:[0-9]+]] { ; CHECK-NEXT: [[ENTRY:.*:]] -; CHECK-NEXT: [[START1:%.*]] = ptrtoint ptr [[START]] to i32 -; CHECK-NEXT: [[TMP4:%.*]] = ptrtoint ptr [[END]] to i32 +; CHECK-NEXT: [[START1:%.*]] = ptrtoaddr ptr [[START]] to i32 +; CHECK-NEXT: [[TMP4:%.*]] = ptrtoaddr ptr [[END]] to i32 ; CHECK-NEXT: [[TMP8:%.*]] = sub i32 [[START1]], [[TMP4]] ; CHECK-NEXT: [[TMP1:%.*]] = add i32 [[TMP8]], -72 ; CHECK-NEXT: [[TMP2:%.*]] = udiv i32 [[TMP1]], 72 @@ -360,8 +360,8 @@ define void @tail_folded_store_avx512(ptr %start, ptr %end) #3 { ; AUTOVF-LABEL: define void @tail_folded_store_avx512( ; AUTOVF-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR3:[0-9]+]] { ; AUTOVF-NEXT: [[ENTRY:.*:]] -; AUTOVF-NEXT: [[START1:%.*]] = ptrtoint ptr [[START]] to i32 -; AUTOVF-NEXT: [[TMP4:%.*]] = ptrtoint ptr [[END]] to i32 +; AUTOVF-NEXT: [[START1:%.*]] = ptrtoaddr ptr [[START]] to i32 +; AUTOVF-NEXT: [[TMP4:%.*]] = ptrtoaddr ptr [[END]] to i32 ; AUTOVF-NEXT: [[TMP8:%.*]] = sub i32 [[START1]], [[TMP4]] ; AUTOVF-NEXT: [[TMP1:%.*]] = add i32 [[TMP8]], -72 ; AUTOVF-NEXT: [[TMP2:%.*]] = udiv i32 [[TMP1]], 72 diff --git a/llvm/test/Transforms/LoopVectorize/X86/pr48340.ll b/llvm/test/Transforms/LoopVectorize/X86/pr48340.ll index 1c3454da43a2..7a1030e3d758 100644 --- a/llvm/test/Transforms/LoopVectorize/X86/pr48340.ll +++ b/llvm/test/Transforms/LoopVectorize/X86/pr48340.ll @@ -10,8 +10,8 @@ target triple = "x86_64-unknown-linux-gnu" define ptr @foo(ptr %p, ptr %p.last) #0 { ; CHECK-LABEL: @foo( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[P3:%.*]] = ptrtoint ptr [[P:%.*]] to i64 -; CHECK-NEXT: [[P_LAST1:%.*]] = ptrtoint ptr [[P_LAST:%.*]] to i64 +; CHECK-NEXT: [[P3:%.*]] = ptrtoaddr ptr [[P:%.*]] to i64 +; CHECK-NEXT: [[P_LAST1:%.*]] = ptrtoaddr ptr [[P_LAST:%.*]] to i64 ; CHECK-NEXT: [[TMP6:%.*]] = sub i64 [[P3]], [[P_LAST1]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP6]], -1024 ; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 10 @@ -70,8 +70,8 @@ exit: define ptr @bar(ptr %p, ptr %p.last) #0 { ; CHECK-LABEL: @bar( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[P3:%.*]] = ptrtoint ptr [[P:%.*]] to i64 -; CHECK-NEXT: [[P_LAST1:%.*]] = ptrtoint ptr [[P_LAST:%.*]] to i64 +; CHECK-NEXT: [[P3:%.*]] = ptrtoaddr ptr [[P:%.*]] to i64 +; CHECK-NEXT: [[P_LAST1:%.*]] = ptrtoaddr ptr [[P_LAST:%.*]] to i64 ; CHECK-NEXT: [[TMP6:%.*]] = sub i64 [[P3]], [[P_LAST1]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP6]], -1024 ; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 10 diff --git a/llvm/test/Transforms/LoopVectorize/X86/pr72969.ll b/llvm/test/Transforms/LoopVectorize/X86/pr72969.ll index f96de49bcb5a..ed598ffa1f13 100644 --- a/llvm/test/Transforms/LoopVectorize/X86/pr72969.ll +++ b/llvm/test/Transforms/LoopVectorize/X86/pr72969.ll @@ -27,10 +27,9 @@ define void @test(ptr %p) { ; VEC-LABEL: define void @test( ; VEC-SAME: ptr [[P:%.*]]) #[[ATTR0:[0-9]+]] { ; VEC-NEXT: entry: -; VEC-NEXT: [[P1:%.*]] = ptrtoint ptr [[P]] to i64 -; VEC-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[P]] to i64 +; VEC-NEXT: [[TMP0:%.*]] = ptrtoaddr ptr [[P]] to i64 ; VEC-NEXT: [[TMP1:%.*]] = add i64 [[TMP0]], 16 -; VEC-NEXT: [[TMP9:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP1]], i64 add (i64 ptrtoint (ptr @h to i64), i64 1)) +; VEC-NEXT: [[TMP9:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP1]], i64 add (i64 ptrtoaddr (ptr @h to i64), i64 1)) ; VEC-NEXT: [[TMP15:%.*]] = sub i64 [[TMP9]], [[TMP0]] ; VEC-NEXT: [[TMP2:%.*]] = add i64 [[TMP15]], -9 ; VEC-NEXT: [[TMP3:%.*]] = lshr i64 [[TMP2]], 3 @@ -38,10 +37,10 @@ define void @test(ptr %p) { ; VEC-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP4]], 8 ; VEC-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_SCEVCHECK:%.*]] ; VEC: vector.scevcheck: -; VEC-NEXT: [[TMP5:%.*]] = add i64 [[P1]], 16 -; VEC-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP5]], i64 add (i64 ptrtoint (ptr @h to i64), i64 1)) +; VEC-NEXT: [[TMP5:%.*]] = add i64 [[TMP0]], 16 +; VEC-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP5]], i64 add (i64 ptrtoaddr (ptr @h to i64), i64 1)) ; VEC-NEXT: [[TMP6:%.*]] = add i64 [[UMAX]], -9 -; VEC-NEXT: [[TMP7:%.*]] = sub i64 [[TMP6]], [[P1]] +; VEC-NEXT: [[TMP7:%.*]] = sub i64 [[TMP6]], [[TMP0]] ; VEC-NEXT: [[TMP8:%.*]] = lshr i64 [[TMP7]], 3 ; VEC-NEXT: [[TMP10:%.*]] = trunc i64 [[TMP8]] to i16 ; VEC-NEXT: [[TMP11:%.*]] = add i16 2, [[TMP10]] diff --git a/llvm/test/Transforms/LoopVectorize/X86/predicate-switch.ll b/llvm/test/Transforms/LoopVectorize/X86/predicate-switch.ll index 1b20ad367a4e..7070a7b20f01 100644 --- a/llvm/test/Transforms/LoopVectorize/X86/predicate-switch.ll +++ b/llvm/test/Transforms/LoopVectorize/X86/predicate-switch.ll @@ -6,8 +6,8 @@ define void @switch_default_to_latch_common_dest(ptr %start, ptr %end) { ; COST-LABEL: define void @switch_default_to_latch_common_dest( ; COST-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0:[0-9]+]] { ; COST-NEXT: [[ENTRY:.*]]: -; COST-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; COST-NEXT: [[TMP11:%.*]] = ptrtoint ptr [[START]] to i64 +; COST-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; COST-NEXT: [[TMP11:%.*]] = ptrtoaddr ptr [[START]] to i64 ; COST-NEXT: [[TMP12:%.*]] = sub i64 [[END1]], [[TMP11]] ; COST-NEXT: [[TMP1:%.*]] = add i64 [[TMP12]], -8 ; COST-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 @@ -58,8 +58,8 @@ define void @switch_default_to_latch_common_dest(ptr %start, ptr %end) { ; FORCED-LABEL: define void @switch_default_to_latch_common_dest( ; FORCED-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0:[0-9]+]] { ; FORCED-NEXT: [[ENTRY:.*]]: -; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; FORCED-NEXT: [[TMP15:%.*]] = ptrtoint ptr [[START]] to i64 +; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; FORCED-NEXT: [[TMP15:%.*]] = ptrtoaddr ptr [[START]] to i64 ; FORCED-NEXT: [[TMP16:%.*]] = sub i64 [[END1]], [[TMP15]] ; FORCED-NEXT: [[TMP1:%.*]] = add i64 [[TMP16]], -8 ; FORCED-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 @@ -141,8 +141,8 @@ define void @switch_default_to_latch_common_dest_using_branches(ptr %start, ptr ; COST-LABEL: define void @switch_default_to_latch_common_dest_using_branches( ; COST-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; COST-NEXT: [[ENTRY:.*]]: -; COST-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; COST-NEXT: [[TMP13:%.*]] = ptrtoint ptr [[START]] to i64 +; COST-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; COST-NEXT: [[TMP13:%.*]] = ptrtoaddr ptr [[START]] to i64 ; COST-NEXT: [[TMP14:%.*]] = sub i64 [[END1]], [[TMP13]] ; COST-NEXT: [[TMP1:%.*]] = add i64 [[TMP14]], -8 ; COST-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 @@ -196,8 +196,8 @@ define void @switch_default_to_latch_common_dest_using_branches(ptr %start, ptr ; FORCED-LABEL: define void @switch_default_to_latch_common_dest_using_branches( ; FORCED-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; FORCED-NEXT: [[ENTRY:.*]]: -; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; FORCED-NEXT: [[TMP19:%.*]] = ptrtoint ptr [[START]] to i64 +; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; FORCED-NEXT: [[TMP19:%.*]] = ptrtoaddr ptr [[START]] to i64 ; FORCED-NEXT: [[TMP20:%.*]] = sub i64 [[END1]], [[TMP19]] ; FORCED-NEXT: [[TMP1:%.*]] = add i64 [[TMP20]], -8 ; FORCED-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 @@ -319,8 +319,8 @@ define void @switch_all_dests_distinct(ptr %start, ptr %end) { ; FORCED-LABEL: define void @switch_all_dests_distinct( ; FORCED-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; FORCED-NEXT: [[ENTRY:.*]]: -; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; FORCED-NEXT: [[TMP21:%.*]] = ptrtoint ptr [[START]] to i64 +; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; FORCED-NEXT: [[TMP21:%.*]] = ptrtoaddr ptr [[START]] to i64 ; FORCED-NEXT: [[TMP22:%.*]] = sub i64 [[END1]], [[TMP21]] ; FORCED-NEXT: [[TMP1:%.*]] = add i64 [[TMP22]], -8 ; FORCED-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 @@ -437,8 +437,8 @@ define void @switch_all_dests_distinct_variant_using_branches(ptr %start, ptr %e ; COST-LABEL: define void @switch_all_dests_distinct_variant_using_branches( ; COST-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; COST-NEXT: [[ENTRY:.*]]: -; COST-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; COST-NEXT: [[TMP16:%.*]] = ptrtoint ptr [[START]] to i64 +; COST-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; COST-NEXT: [[TMP16:%.*]] = ptrtoaddr ptr [[START]] to i64 ; COST-NEXT: [[TMP17:%.*]] = sub i64 [[END1]], [[TMP16]] ; COST-NEXT: [[TMP1:%.*]] = add i64 [[TMP17]], -8 ; COST-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 @@ -509,8 +509,8 @@ define void @switch_all_dests_distinct_variant_using_branches(ptr %start, ptr %e ; FORCED-LABEL: define void @switch_all_dests_distinct_variant_using_branches( ; FORCED-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; FORCED-NEXT: [[ENTRY:.*]]: -; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; FORCED-NEXT: [[TMP25:%.*]] = ptrtoint ptr [[START]] to i64 +; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; FORCED-NEXT: [[TMP25:%.*]] = ptrtoaddr ptr [[START]] to i64 ; FORCED-NEXT: [[TMP26:%.*]] = sub i64 [[END1]], [[TMP25]] ; FORCED-NEXT: [[TMP1:%.*]] = add i64 [[TMP26]], -8 ; FORCED-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 @@ -669,8 +669,8 @@ define void @switch_multiple_common_dests(ptr %start, ptr %end) { ; FORCED-LABEL: define void @switch_multiple_common_dests( ; FORCED-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; FORCED-NEXT: [[ENTRY:.*]]: -; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; FORCED-NEXT: [[TMP29:%.*]] = ptrtoint ptr [[START]] to i64 +; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; FORCED-NEXT: [[TMP29:%.*]] = ptrtoaddr ptr [[START]] to i64 ; FORCED-NEXT: [[TMP30:%.*]] = sub i64 [[END1]], [[TMP29]] ; FORCED-NEXT: [[TMP1:%.*]] = add i64 [[TMP30]], -8 ; FORCED-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 @@ -818,8 +818,8 @@ define void @switch4_default_common_dest_with_case(ptr %start, ptr %end) { ; FORCED-LABEL: define void @switch4_default_common_dest_with_case( ; FORCED-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; FORCED-NEXT: [[ENTRY:.*]]: -; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; FORCED-NEXT: [[TMP17:%.*]] = ptrtoint ptr [[START]] to i64 +; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; FORCED-NEXT: [[TMP17:%.*]] = ptrtoaddr ptr [[START]] to i64 ; FORCED-NEXT: [[TMP18:%.*]] = sub i64 [[END1]], [[TMP17]] ; FORCED-NEXT: [[TMP1:%.*]] = add i64 [[TMP18]], -8 ; FORCED-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 @@ -954,8 +954,8 @@ define void @switch_under_br_default_common_dest_with_case(ptr %start, ptr %end, ; FORCED-LABEL: define void @switch_under_br_default_common_dest_with_case( ; FORCED-SAME: ptr [[START:%.*]], ptr [[END:%.*]], i64 [[X:%.*]]) #[[ATTR0]] { ; FORCED-NEXT: [[ENTRY:.*]]: -; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; FORCED-NEXT: [[TMP25:%.*]] = ptrtoint ptr [[START]] to i64 +; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; FORCED-NEXT: [[TMP25:%.*]] = ptrtoaddr ptr [[START]] to i64 ; FORCED-NEXT: [[TMP26:%.*]] = sub i64 [[END1]], [[TMP25]] ; FORCED-NEXT: [[TMP1:%.*]] = add i64 [[TMP26]], -8 ; FORCED-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 @@ -1107,8 +1107,8 @@ define void @br_under_switch_default_common_dest_with_case(ptr %start, ptr %end, ; FORCED-LABEL: define void @br_under_switch_default_common_dest_with_case( ; FORCED-SAME: ptr [[START:%.*]], ptr [[END:%.*]], i64 [[X:%.*]]) #[[ATTR0]] { ; FORCED-NEXT: [[ENTRY:.*]]: -; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; FORCED-NEXT: [[TMP29:%.*]] = ptrtoint ptr [[START]] to i64 +; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; FORCED-NEXT: [[TMP29:%.*]] = ptrtoaddr ptr [[START]] to i64 ; FORCED-NEXT: [[TMP30:%.*]] = sub i64 [[END1]], [[TMP29]] ; FORCED-NEXT: [[TMP1:%.*]] = add i64 [[TMP30]], -8 ; FORCED-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 @@ -1261,8 +1261,8 @@ define void @large_number_of_cases(ptr %start, ptr %end) { ; FORCED-LABEL: define void @large_number_of_cases( ; FORCED-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) #[[ATTR0]] { ; FORCED-NEXT: [[ENTRY:.*]]: -; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; FORCED-NEXT: [[TMP43:%.*]] = ptrtoint ptr [[START]] to i64 +; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; FORCED-NEXT: [[TMP43:%.*]] = ptrtoaddr ptr [[START]] to i64 ; FORCED-NEXT: [[TMP44:%.*]] = sub i64 [[END1]], [[TMP43]] ; FORCED-NEXT: [[TMP1:%.*]] = add i64 [[TMP44]], -8 ; FORCED-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 diff --git a/llvm/test/Transforms/LoopVectorize/epilog-vectorization-any-of-reductions.ll b/llvm/test/Transforms/LoopVectorize/epilog-vectorization-any-of-reductions.ll index 2e8daad1daf9..4eae5ae75983 100644 --- a/llvm/test/Transforms/LoopVectorize/epilog-vectorization-any-of-reductions.ll +++ b/llvm/test/Transforms/LoopVectorize/epilog-vectorization-any-of-reductions.ll @@ -301,8 +301,8 @@ define i1 @any_of_reduction_i1_epilog2(ptr %start, ptr %end, i64 %x) { ; CHECK-LABEL: define i1 @any_of_reduction_i1_epilog2( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]], i64 [[X:%.*]]) { ; CHECK-NEXT: iter.check: -; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -16 ; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]] ; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 4 diff --git a/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll b/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll index e23985f31333..cd502b080d7b 100644 --- a/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll +++ b/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll @@ -12,8 +12,8 @@ define void @test_epilogue_step_scev_expansion(ptr %dst) { ; CHECK: [[VECTOR_MAIN_LOOP_ITER_CHECK]]: ; CHECK-NEXT: br i1 false, label %[[VEC_EPILOG_PH:.*]], label %[[VECTOR_PH:.*]] ; CHECK: [[VECTOR_PH]]: -; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i64 sub (i64 0, i64 ptrtoint (ptr @end to i64)), 8 -; CHECK-NEXT: [[N_VEC:%.*]] = sub i64 sub (i64 0, i64 ptrtoint (ptr @end to i64)), [[N_MOD_VF]] +; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i64 sub (i64 0, i64 ptrtoaddr (ptr @end to i64)), 8 +; CHECK-NEXT: [[N_VEC:%.*]] = sub i64 sub (i64 0, i64 ptrtoaddr (ptr @end to i64)), [[N_MOD_VF]] ; CHECK-NEXT: br label %[[VECTOR_BODY:.*]] ; CHECK: [[VECTOR_BODY]]: ; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ] @@ -23,16 +23,16 @@ define void @test_epilogue_step_scev_expansion(ptr %dst) { ; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]] ; CHECK-NEXT: br i1 [[TMP1]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP0:![0-9]+]] ; CHECK: [[MIDDLE_BLOCK]]: -; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i64 sub (i64 0, i64 ptrtoint (ptr @end to i64)), [[N_VEC]] +; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i64 sub (i64 0, i64 ptrtoaddr (ptr @end to i64)), [[N_VEC]] ; CHECK-NEXT: br i1 [[CMP_N]], label %[[EXIT:.*]], label %[[VEC_EPILOG_ITER_CHECK:.*]] ; CHECK: [[VEC_EPILOG_ITER_CHECK]]: -; CHECK-NEXT: [[N_VEC_REMAINING:%.*]] = sub i64 sub (i64 0, i64 ptrtoint (ptr @end to i64)), [[N_VEC]] +; CHECK-NEXT: [[N_VEC_REMAINING:%.*]] = sub i64 sub (i64 0, i64 ptrtoaddr (ptr @end to i64)), [[N_VEC]] ; CHECK-NEXT: [[MIN_EPILOG_ITERS_CHECK:%.*]] = icmp ult i64 [[N_VEC_REMAINING]], 4 ; CHECK-NEXT: br i1 [[MIN_EPILOG_ITERS_CHECK]], label %[[VEC_EPILOG_SCALAR_PH]], label %[[VEC_EPILOG_PH]], !prof [[PROF3:![0-9]+]] ; CHECK: [[VEC_EPILOG_PH]]: ; CHECK-NEXT: [[VEC_EPILOG_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC]], %[[VEC_EPILOG_ITER_CHECK]] ], [ 0, %[[VECTOR_MAIN_LOOP_ITER_CHECK]] ] -; CHECK-NEXT: [[N_MOD_VF1:%.*]] = urem i64 sub (i64 0, i64 ptrtoint (ptr @end to i64)), 4 -; CHECK-NEXT: [[N_VEC2:%.*]] = sub i64 sub (i64 0, i64 ptrtoint (ptr @end to i64)), [[N_MOD_VF1]] +; CHECK-NEXT: [[N_MOD_VF1:%.*]] = urem i64 sub (i64 0, i64 ptrtoaddr (ptr @end to i64)), 4 +; CHECK-NEXT: [[N_VEC2:%.*]] = sub i64 sub (i64 0, i64 ptrtoaddr (ptr @end to i64)), [[N_MOD_VF1]] ; CHECK-NEXT: br label %[[VEC_EPILOG_VECTOR_BODY:.*]] ; CHECK: [[VEC_EPILOG_VECTOR_BODY]]: ; CHECK-NEXT: [[INDEX3:%.*]] = phi i64 [ [[VEC_EPILOG_RESUME_VAL]], %[[VEC_EPILOG_PH]] ], [ [[INDEX_NEXT4:%.*]], %[[VEC_EPILOG_VECTOR_BODY]] ] @@ -42,7 +42,7 @@ define void @test_epilogue_step_scev_expansion(ptr %dst) { ; CHECK-NEXT: [[TMP3:%.*]] = icmp eq i64 [[INDEX_NEXT4]], [[N_VEC2]] ; CHECK-NEXT: br i1 [[TMP3]], label %[[VEC_EPILOG_MIDDLE_BLOCK:.*]], label %[[VEC_EPILOG_VECTOR_BODY]], !llvm.loop [[LOOP4:![0-9]+]] ; CHECK: [[VEC_EPILOG_MIDDLE_BLOCK]]: -; CHECK-NEXT: [[CMP_N5:%.*]] = icmp eq i64 sub (i64 0, i64 ptrtoint (ptr @end to i64)), [[N_VEC2]] +; CHECK-NEXT: [[CMP_N5:%.*]] = icmp eq i64 sub (i64 0, i64 ptrtoaddr (ptr @end to i64)), [[N_VEC2]] ; CHECK-NEXT: br i1 [[CMP_N5]], label %[[EXIT]], label %[[VEC_EPILOG_SCALAR_PH]] ; CHECK: [[VEC_EPILOG_SCALAR_PH]]: ; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi i64 [ [[N_VEC2]], %[[VEC_EPILOG_MIDDLE_BLOCK]] ], [ [[N_VEC]], %[[VEC_EPILOG_ITER_CHECK]] ], [ 0, %[[ITER_CHECK]] ] diff --git a/llvm/test/Transforms/LoopVectorize/hoist-and-sink-mem-ops-with-invariant-pointers.ll b/llvm/test/Transforms/LoopVectorize/hoist-and-sink-mem-ops-with-invariant-pointers.ll index 4349e7ea277f..dd4d913eec0f 100644 --- a/llvm/test/Transforms/LoopVectorize/hoist-and-sink-mem-ops-with-invariant-pointers.ll +++ b/llvm/test/Transforms/LoopVectorize/hoist-and-sink-mem-ops-with-invariant-pointers.ll @@ -209,12 +209,10 @@ define void @load_store_noalias_via_tbaa(ptr %p, ptr %q, ptr %n) { ; CHECK-LABEL: define void @load_store_noalias_via_tbaa( ; CHECK-SAME: ptr [[P:%.*]], ptr [[Q:%.*]], ptr [[N:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*:]] -; CHECK-NEXT: [[P6:%.*]] = ptrtoint ptr [[P]] to i64 -; CHECK-NEXT: [[N5:%.*]] = ptrtoint ptr [[N]] to i64 -; CHECK-NEXT: [[P2:%.*]] = ptrtoint ptr [[P]] to i64 -; CHECK-NEXT: [[TMP1:%.*]] = mul i64 [[P2]], -3074457345618258603 -; CHECK-NEXT: [[N1:%.*]] = ptrtoint ptr [[N]] to i64 -; CHECK-NEXT: [[TMP17:%.*]] = mul i64 [[N1]], 3074457345618258603 +; CHECK-NEXT: [[P6:%.*]] = ptrtoaddr ptr [[P]] to i64 +; CHECK-NEXT: [[N5:%.*]] = ptrtoaddr ptr [[N]] to i64 +; CHECK-NEXT: [[TMP1:%.*]] = mul i64 [[P6]], -3074457345618258603 +; CHECK-NEXT: [[TMP17:%.*]] = mul i64 [[N5]], 3074457345618258603 ; CHECK-NEXT: [[TMP2:%.*]] = add i64 [[TMP1]], [[TMP17]] ; CHECK-NEXT: [[TMP3:%.*]] = lshr i64 [[TMP2]], 2 ; CHECK-NEXT: [[TMP4:%.*]] = add nuw nsw i64 [[TMP3]], 1 diff --git a/llvm/test/Transforms/LoopVectorize/induction-ptrcasts.ll b/llvm/test/Transforms/LoopVectorize/induction-ptrcasts.ll index a744025cf388..113ceedbddb1 100644 --- a/llvm/test/Transforms/LoopVectorize/induction-ptrcasts.ll +++ b/llvm/test/Transforms/LoopVectorize/induction-ptrcasts.ll @@ -8,8 +8,8 @@ define void @int_iv_based_on_pointer_iv(ptr %A) { ; VF1-LABEL: define void @int_iv_based_on_pointer_iv( ; VF1-SAME: ptr [[A:%.*]]) { ; VF1-NEXT: [[ENTRY:.*:]] -; VF1-NEXT: [[SMIN:%.*]] = call i64 @llvm.smin.i64(i64 add (i64 ptrtoint (ptr @f to i64), i64 -4), i64 0) -; VF1-NEXT: [[TMP6:%.*]] = sub i64 ptrtoint (ptr @f to i64), [[SMIN]] +; VF1-NEXT: [[SMIN:%.*]] = call i64 @llvm.smin.i64(i64 add (i64 ptrtoaddr (ptr @f to i64), i64 -4), i64 0) +; VF1-NEXT: [[TMP6:%.*]] = sub i64 ptrtoaddr (ptr @f to i64), [[SMIN]] ; VF1-NEXT: [[TMP0:%.*]] = add i64 [[TMP6]], -1 ; VF1-NEXT: [[TMP1:%.*]] = lshr i64 [[TMP0]], 2 ; VF1-NEXT: [[TMP2:%.*]] = add nuw nsw i64 [[TMP1]], 1 @@ -40,8 +40,8 @@ define void @int_iv_based_on_pointer_iv(ptr %A) { ; VF2-LABEL: define void @int_iv_based_on_pointer_iv( ; VF2-SAME: ptr [[A:%.*]]) { ; VF2-NEXT: [[ENTRY:.*:]] -; VF2-NEXT: [[SMIN:%.*]] = call i64 @llvm.smin.i64(i64 add (i64 ptrtoint (ptr @f to i64), i64 -4), i64 0) -; VF2-NEXT: [[TMP7:%.*]] = sub i64 ptrtoint (ptr @f to i64), [[SMIN]] +; VF2-NEXT: [[SMIN:%.*]] = call i64 @llvm.smin.i64(i64 add (i64 ptrtoaddr (ptr @f to i64), i64 -4), i64 0) +; VF2-NEXT: [[TMP7:%.*]] = sub i64 ptrtoaddr (ptr @f to i64), [[SMIN]] ; VF2-NEXT: [[TMP0:%.*]] = add i64 [[TMP7]], -1 ; VF2-NEXT: [[TMP1:%.*]] = lshr i64 [[TMP0]], 2 ; VF2-NEXT: [[TMP2:%.*]] = add nuw nsw i64 [[TMP1]], 1 diff --git a/llvm/test/Transforms/LoopVectorize/interleaved-accesses-different-insert-position.ll b/llvm/test/Transforms/LoopVectorize/interleaved-accesses-different-insert-position.ll index 2fbe72985179..98023afa33dc 100644 --- a/llvm/test/Transforms/LoopVectorize/interleaved-accesses-different-insert-position.ll +++ b/llvm/test/Transforms/LoopVectorize/interleaved-accesses-different-insert-position.ll @@ -138,8 +138,8 @@ define i64 @interleave_group_load_pointer_type(ptr %start, ptr %end) { ; CHECK-LABEL: define i64 @interleave_group_load_pointer_type( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[END1]], [[START2]] ; CHECK-NEXT: [[TMP1:%.*]] = udiv i64 [[TMP0]], 24 ; CHECK-NEXT: [[TMP2:%.*]] = add nuw nsw i64 [[TMP1]], 1 diff --git a/llvm/test/Transforms/LoopVectorize/interleaved-accesses-metadata.ll b/llvm/test/Transforms/LoopVectorize/interleaved-accesses-metadata.ll index eba2fcafbda4..a20359e48d98 100644 --- a/llvm/test/Transforms/LoopVectorize/interleaved-accesses-metadata.ll +++ b/llvm/test/Transforms/LoopVectorize/interleaved-accesses-metadata.ll @@ -76,18 +76,16 @@ define void @ir_tbaa_different(ptr %base, ptr %end, ptr %src) { ; CHECK-LABEL: define void @ir_tbaa_different( ; CHECK-SAME: ptr [[BASE:%.*]], ptr [[END:%.*]], ptr [[SRC:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[BASE2:%.*]] = ptrtoint ptr [[BASE]] to i64 -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[END2:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP10:%.*]] = ptrtoint ptr [[BASE]] to i64 -; CHECK-NEXT: [[TMP16:%.*]] = sub i64 [[END2]], [[TMP10]] +; CHECK-NEXT: [[BASE2:%.*]] = ptrtoaddr ptr [[BASE]] to i64 +; CHECK-NEXT: [[END2:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP16:%.*]] = sub i64 [[END2]], [[BASE2]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP16]], -8 ; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 ; CHECK-NEXT: [[TMP3:%.*]] = add nuw nsw i64 [[TMP2]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP3]], 2 ; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] ; CHECK: [[VECTOR_MEMCHECK]]: -; CHECK-NEXT: [[TMP17:%.*]] = add i64 [[END1]], -8 +; CHECK-NEXT: [[TMP17:%.*]] = add i64 [[END2]], -8 ; CHECK-NEXT: [[TMP12:%.*]] = sub i64 [[TMP17]], [[BASE2]] ; CHECK-NEXT: [[TMP13:%.*]] = lshr i64 [[TMP12]], 3 ; CHECK-NEXT: [[TMP14:%.*]] = shl nuw i64 [[TMP13]], 3 @@ -170,8 +168,8 @@ define void @noalias_metadata_from_versioning(ptr %base, ptr %end, ptr %src) { ; CHECK-LABEL: define void @noalias_metadata_from_versioning( ; CHECK-SAME: ptr [[BASE:%.*]], ptr [[END:%.*]], ptr [[SRC:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP10:%.*]] = ptrtoint ptr [[BASE]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP10:%.*]] = ptrtoaddr ptr [[BASE]] to i64 ; CHECK-NEXT: [[TMP11:%.*]] = sub i64 [[END1]], [[TMP10]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP11]], -8 ; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 diff --git a/llvm/test/Transforms/LoopVectorize/metadata.ll b/llvm/test/Transforms/LoopVectorize/metadata.ll index 66881a385e65..361f015a12cc 100644 --- a/llvm/test/Transforms/LoopVectorize/metadata.ll +++ b/llvm/test/Transforms/LoopVectorize/metadata.ll @@ -501,18 +501,16 @@ define void @noalias_metadata(ptr align 8 %dst, ptr align 8 %src) { ; CHECK-LABEL: define void @noalias_metadata( ; CHECK-SAME: ptr align 8 [[DST:%.*]], ptr align 8 [[SRC:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[SRC4:%.*]] = ptrtoint ptr [[SRC]] to i64 -; CHECK-NEXT: [[DST3:%.*]] = ptrtoint ptr [[DST]] to i64 -; CHECK-NEXT: [[DST1:%.*]] = ptrtoint ptr [[DST]] to i64 -; CHECK-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[SRC]] to i64 -; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST1]], [[TMP1]] +; CHECK-NEXT: [[SRC4:%.*]] = ptrtoaddr ptr [[SRC]] to i64 +; CHECK-NEXT: [[DST1:%.*]] = ptrtoaddr ptr [[DST]] to i64 +; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST1]], [[SRC4]] ; CHECK-NEXT: [[TMP3:%.*]] = lshr i64 [[TMP2]], 3 ; CHECK-NEXT: [[TMP4:%.*]] = add nuw nsw i64 [[TMP3]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP4]], 2 ; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] ; CHECK: [[VECTOR_MEMCHECK]]: ; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[DST]], i64 8 -; CHECK-NEXT: [[TMP5:%.*]] = add i64 [[DST3]], 8 +; CHECK-NEXT: [[TMP5:%.*]] = add i64 [[DST1]], 8 ; CHECK-NEXT: [[TMP22:%.*]] = sub i64 [[TMP5]], [[SRC4]] ; CHECK-NEXT: [[SCEVGEP5:%.*]] = getelementptr i8, ptr [[SRC]], i64 [[TMP22]] ; CHECK-NEXT: [[BOUND0:%.*]] = icmp ult ptr [[DST]], [[SCEVGEP5]] @@ -554,18 +552,16 @@ define void @noalias_metadata(ptr align 8 %dst, ptr align 8 %src) { ; INTERLEAVE-LABEL: define void @noalias_metadata( ; INTERLEAVE-SAME: ptr align 8 [[DST:%.*]], ptr align 8 [[SRC:%.*]]) { ; INTERLEAVE-NEXT: [[ENTRY:.*]]: -; INTERLEAVE-NEXT: [[SRC4:%.*]] = ptrtoint ptr [[SRC]] to i64 -; INTERLEAVE-NEXT: [[DST3:%.*]] = ptrtoint ptr [[DST]] to i64 -; INTERLEAVE-NEXT: [[DST1:%.*]] = ptrtoint ptr [[DST]] to i64 -; INTERLEAVE-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[SRC]] to i64 -; INTERLEAVE-NEXT: [[TMP2:%.*]] = sub i64 [[DST1]], [[TMP1]] +; INTERLEAVE-NEXT: [[SRC4:%.*]] = ptrtoaddr ptr [[SRC]] to i64 +; INTERLEAVE-NEXT: [[DST1:%.*]] = ptrtoaddr ptr [[DST]] to i64 +; INTERLEAVE-NEXT: [[TMP2:%.*]] = sub i64 [[DST1]], [[SRC4]] ; INTERLEAVE-NEXT: [[TMP3:%.*]] = lshr i64 [[TMP2]], 3 ; INTERLEAVE-NEXT: [[TMP4:%.*]] = add nuw nsw i64 [[TMP3]], 1 ; INTERLEAVE-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP4]], 4 ; INTERLEAVE-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_MEMCHECK:.*]] ; INTERLEAVE: [[VECTOR_MEMCHECK]]: ; INTERLEAVE-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[DST]], i64 8 -; INTERLEAVE-NEXT: [[TMP5:%.*]] = add i64 [[DST3]], 8 +; INTERLEAVE-NEXT: [[TMP5:%.*]] = add i64 [[DST1]], 8 ; INTERLEAVE-NEXT: [[TMP22:%.*]] = sub i64 [[TMP5]], [[SRC4]] ; INTERLEAVE-NEXT: [[SCEVGEP5:%.*]] = getelementptr i8, ptr [[SRC]], i64 [[TMP22]] ; INTERLEAVE-NEXT: [[BOUND0:%.*]] = icmp ult ptr [[DST]], [[SCEVGEP5]] diff --git a/llvm/test/Transforms/LoopVectorize/opaque-ptr.ll b/llvm/test/Transforms/LoopVectorize/opaque-ptr.ll index cb84af11b215..7c5a0481c9e5 100644 --- a/llvm/test/Transforms/LoopVectorize/opaque-ptr.ll +++ b/llvm/test/Transforms/LoopVectorize/opaque-ptr.ll @@ -4,34 +4,30 @@ define void @test_ptr_iv_no_inbounds(ptr %p1.start, ptr %p2.start, ptr %p1.end) { ; CHECK-LABEL: @test_ptr_iv_no_inbounds( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[P1_START7:%.*]] = ptrtoint ptr [[P1_START:%.*]] to i64 -; CHECK-NEXT: [[P1_END6:%.*]] = ptrtoint ptr [[P1_END:%.*]] to i64 -; CHECK-NEXT: [[P1_START4:%.*]] = ptrtoint ptr [[P1_START]] to i64 -; CHECK-NEXT: [[P1_END3:%.*]] = ptrtoint ptr [[P1_END]] to i64 -; CHECK-NEXT: [[P1_END1:%.*]] = ptrtoint ptr [[P1_END]] to i64 -; CHECK-NEXT: [[TMP8:%.*]] = ptrtoint ptr [[P1_START]] to i64 -; CHECK-NEXT: [[TMP14:%.*]] = sub i64 [[P1_END1]], [[TMP8]] +; CHECK-NEXT: [[P1_END1:%.*]] = ptrtoaddr ptr [[P1_END:%.*]] to i64 +; CHECK-NEXT: [[TMP8:%.*]] = ptrtoaddr ptr [[P1_START:%.*]] to i64 +; CHECK-NEXT: [[TMP14:%.*]] = sub i64 [[TMP8]], [[P1_END1]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP14]], -4 ; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 2 ; CHECK-NEXT: [[TMP3:%.*]] = add nuw nsw i64 [[TMP2]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP3]], 2 ; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_SCEVCHECK:%.*]] ; CHECK: vector.scevcheck: -; CHECK-NEXT: [[TMP4:%.*]] = trunc i64 [[P1_END3]] to i2 -; CHECK-NEXT: [[TMP5:%.*]] = trunc i64 [[P1_START4]] to i2 +; CHECK-NEXT: [[TMP4:%.*]] = trunc i64 [[TMP8]] to i2 +; CHECK-NEXT: [[TMP5:%.*]] = trunc i64 [[P1_END1]] to i2 ; CHECK-NEXT: [[TMP6:%.*]] = sub i2 [[TMP4]], [[TMP5]] ; CHECK-NEXT: [[TMP7:%.*]] = zext i2 [[TMP6]] to i64 ; CHECK-NEXT: [[IDENT_CHECK:%.*]] = icmp ne i64 [[TMP7]], 0 ; CHECK-NEXT: br i1 [[IDENT_CHECK]], label [[SCALAR_PH]], label [[VECTOR_MEMCHECK:%.*]] ; CHECK: vector.memcheck: -; CHECK-NEXT: [[TMP15:%.*]] = add i64 [[P1_END6]], -4 -; CHECK-NEXT: [[TMP9:%.*]] = sub i64 [[TMP15]], [[P1_START7]] +; CHECK-NEXT: [[TMP15:%.*]] = add i64 [[TMP8]], -4 +; CHECK-NEXT: [[TMP9:%.*]] = sub i64 [[TMP15]], [[P1_END1]] ; CHECK-NEXT: [[TMP10:%.*]] = lshr i64 [[TMP9]], 2 ; CHECK-NEXT: [[TMP11:%.*]] = shl nuw i64 [[TMP10]], 2 ; CHECK-NEXT: [[TMP12:%.*]] = add i64 [[TMP11]], 4 -; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[P1_START]], i64 [[TMP12]] +; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[P1_END]], i64 [[TMP12]] ; CHECK-NEXT: [[SCEVGEP5:%.*]] = getelementptr i8, ptr [[P2_START:%.*]], i64 [[TMP12]] -; CHECK-NEXT: [[BOUND0:%.*]] = icmp ult ptr [[P1_START]], [[SCEVGEP5]] +; CHECK-NEXT: [[BOUND0:%.*]] = icmp ult ptr [[P1_END]], [[SCEVGEP5]] ; CHECK-NEXT: [[BOUND1:%.*]] = icmp ult ptr [[P2_START]], [[SCEVGEP]] ; CHECK-NEXT: [[FOUND_CONFLICT:%.*]] = and i1 [[BOUND0]], [[BOUND1]] ; CHECK-NEXT: br i1 [[FOUND_CONFLICT]], label [[SCALAR_PH]], label [[VECTOR_PH:%.*]] @@ -39,13 +35,13 @@ define void @test_ptr_iv_no_inbounds(ptr %p1.start, ptr %p2.start, ptr %p1.end) ; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[TMP3]], 2 ; CHECK-NEXT: [[N_VEC:%.*]] = sub i64 [[TMP3]], [[N_MOD_VF]] ; CHECK-NEXT: [[TMP13:%.*]] = shl i64 [[N_VEC]], 2 -; CHECK-NEXT: [[IND_END:%.*]] = getelementptr i8, ptr [[P1_START]], i64 [[TMP13]] +; CHECK-NEXT: [[TMP16:%.*]] = getelementptr i8, ptr [[P1_END]], i64 [[TMP13]] ; CHECK-NEXT: [[IND_END8:%.*]] = getelementptr i8, ptr [[P2_START]], i64 [[TMP13]] ; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] ; CHECK: vector.body: ; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] ; CHECK-NEXT: [[OFFSET_IDX:%.*]] = shl i64 [[INDEX]], 2 -; CHECK-NEXT: [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[P1_START]], i64 [[OFFSET_IDX]] +; CHECK-NEXT: [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[P1_END]], i64 [[OFFSET_IDX]] ; CHECK-NEXT: [[NEXT_GEP8:%.*]] = getelementptr i8, ptr [[P2_START]], i64 [[OFFSET_IDX]] ; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <2 x float>, ptr [[NEXT_GEP]], align 4, !alias.scope [[META0:![0-9]+]], !noalias [[META3:![0-9]+]] ; CHECK-NEXT: [[WIDE_LOAD12:%.*]] = load <2 x float>, ptr [[NEXT_GEP8]], align 4, !alias.scope [[META3]] @@ -58,7 +54,7 @@ define void @test_ptr_iv_no_inbounds(ptr %p1.start, ptr %p2.start, ptr %p1.end) ; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[TMP3]], [[N_VEC]] ; CHECK-NEXT: br i1 [[CMP_N]], label [[EXIT:%.*]], label [[SCALAR_PH]] ; CHECK: scalar.ph: -; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi ptr [ [[IND_END]], [[MIDDLE_BLOCK]] ], [ [[P1_START]], [[ENTRY:%.*]] ], [ [[P1_START]], [[VECTOR_SCEVCHECK]] ], [ [[P1_START]], [[VECTOR_MEMCHECK]] ] +; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi ptr [ [[TMP16]], [[MIDDLE_BLOCK]] ], [ [[P1_END]], [[ENTRY:%.*]] ], [ [[P1_END]], [[VECTOR_SCEVCHECK]] ], [ [[P1_END]], [[VECTOR_MEMCHECK]] ] ; CHECK-NEXT: [[BC_RESUME_VAL9:%.*]] = phi ptr [ [[IND_END8]], [[MIDDLE_BLOCK]] ], [ [[P2_START]], [[ENTRY]] ], [ [[P2_START]], [[VECTOR_SCEVCHECK]] ], [ [[P2_START]], [[VECTOR_MEMCHECK]] ] ; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK: loop: @@ -70,7 +66,7 @@ define void @test_ptr_iv_no_inbounds(ptr %p1.start, ptr %p2.start, ptr %p1.end) ; CHECK-NEXT: store float [[SUM]], ptr [[P1]], align 4 ; CHECK-NEXT: [[P1_NEXT]] = getelementptr float, ptr [[P1]], i64 1 ; CHECK-NEXT: [[P2_NEXT]] = getelementptr float, ptr [[P2]], i64 1 -; CHECK-NEXT: [[C:%.*]] = icmp ne ptr [[P1_NEXT]], [[P1_END]] +; CHECK-NEXT: [[C:%.*]] = icmp ne ptr [[P1_NEXT]], [[P1_START]] ; CHECK-NEXT: br i1 [[C]], label [[LOOP]], label [[EXIT]], !llvm.loop [[LOOP8:![0-9]+]] ; CHECK: exit: ; CHECK-NEXT: ret void @@ -97,25 +93,23 @@ exit: define void @test_ptr_iv_with_inbounds(ptr %p1.start, ptr %p2.start, ptr %p1.end) { ; CHECK-LABEL: @test_ptr_iv_with_inbounds( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[P1_START5:%.*]] = ptrtoint ptr [[P1_START:%.*]] to i64 -; CHECK-NEXT: [[P1_END4:%.*]] = ptrtoint ptr [[P1_END:%.*]] to i64 -; CHECK-NEXT: [[P1_END1:%.*]] = ptrtoint ptr [[P1_END]] to i64 -; CHECK-NEXT: [[TMP4:%.*]] = ptrtoint ptr [[P1_START]] to i64 -; CHECK-NEXT: [[TMP10:%.*]] = sub i64 [[P1_END1]], [[TMP4]] +; CHECK-NEXT: [[P1_END1:%.*]] = ptrtoaddr ptr [[P1_END:%.*]] to i64 +; CHECK-NEXT: [[TMP4:%.*]] = ptrtoaddr ptr [[P1_START:%.*]] to i64 +; CHECK-NEXT: [[TMP10:%.*]] = sub i64 [[TMP4]], [[P1_END1]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP10]], -4 ; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 2 ; CHECK-NEXT: [[TMP3:%.*]] = add nuw nsw i64 [[TMP2]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP3]], 2 ; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_MEMCHECK:%.*]] ; CHECK: vector.memcheck: -; CHECK-NEXT: [[TMP11:%.*]] = add i64 [[P1_END4]], -4 -; CHECK-NEXT: [[TMP5:%.*]] = sub i64 [[TMP11]], [[P1_START5]] +; CHECK-NEXT: [[TMP11:%.*]] = add i64 [[TMP4]], -4 +; CHECK-NEXT: [[TMP5:%.*]] = sub i64 [[TMP11]], [[P1_END1]] ; CHECK-NEXT: [[TMP6:%.*]] = lshr i64 [[TMP5]], 2 ; CHECK-NEXT: [[TMP7:%.*]] = shl nuw i64 [[TMP6]], 2 ; CHECK-NEXT: [[TMP8:%.*]] = add i64 [[TMP7]], 4 -; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[P1_START]], i64 [[TMP8]] +; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[P1_END]], i64 [[TMP8]] ; CHECK-NEXT: [[SCEVGEP3:%.*]] = getelementptr i8, ptr [[P2_START:%.*]], i64 [[TMP8]] -; CHECK-NEXT: [[BOUND0:%.*]] = icmp ult ptr [[P1_START]], [[SCEVGEP3]] +; CHECK-NEXT: [[BOUND0:%.*]] = icmp ult ptr [[P1_END]], [[SCEVGEP3]] ; CHECK-NEXT: [[BOUND1:%.*]] = icmp ult ptr [[P2_START]], [[SCEVGEP]] ; CHECK-NEXT: [[FOUND_CONFLICT:%.*]] = and i1 [[BOUND0]], [[BOUND1]] ; CHECK-NEXT: br i1 [[FOUND_CONFLICT]], label [[SCALAR_PH]], label [[VECTOR_PH:%.*]] @@ -123,13 +117,13 @@ define void @test_ptr_iv_with_inbounds(ptr %p1.start, ptr %p2.start, ptr %p1.end ; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[TMP3]], 2 ; CHECK-NEXT: [[N_VEC:%.*]] = sub i64 [[TMP3]], [[N_MOD_VF]] ; CHECK-NEXT: [[TMP9:%.*]] = shl i64 [[N_VEC]], 2 -; CHECK-NEXT: [[IND_END:%.*]] = getelementptr i8, ptr [[P1_START]], i64 [[TMP9]] +; CHECK-NEXT: [[TMP12:%.*]] = getelementptr i8, ptr [[P1_END]], i64 [[TMP9]] ; CHECK-NEXT: [[IND_END6:%.*]] = getelementptr i8, ptr [[P2_START]], i64 [[TMP9]] ; CHECK-NEXT: br label [[VECTOR_BODY:%.*]] ; CHECK: vector.body: ; CHECK-NEXT: [[INDEX:%.*]] = phi i64 [ 0, [[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], [[VECTOR_BODY]] ] ; CHECK-NEXT: [[OFFSET_IDX:%.*]] = shl i64 [[INDEX]], 2 -; CHECK-NEXT: [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[P1_START]], i64 [[OFFSET_IDX]] +; CHECK-NEXT: [[NEXT_GEP:%.*]] = getelementptr i8, ptr [[P1_END]], i64 [[OFFSET_IDX]] ; CHECK-NEXT: [[NEXT_GEP6:%.*]] = getelementptr i8, ptr [[P2_START]], i64 [[OFFSET_IDX]] ; CHECK-NEXT: [[WIDE_LOAD:%.*]] = load <2 x float>, ptr [[NEXT_GEP]], align 4, !alias.scope [[META9:![0-9]+]], !noalias [[META12:![0-9]+]] ; CHECK-NEXT: [[WIDE_LOAD10:%.*]] = load <2 x float>, ptr [[NEXT_GEP6]], align 4, !alias.scope [[META12]] @@ -142,7 +136,7 @@ define void @test_ptr_iv_with_inbounds(ptr %p1.start, ptr %p2.start, ptr %p1.end ; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[TMP3]], [[N_VEC]] ; CHECK-NEXT: br i1 [[CMP_N]], label [[EXIT:%.*]], label [[SCALAR_PH]] ; CHECK: scalar.ph: -; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi ptr [ [[IND_END]], [[MIDDLE_BLOCK]] ], [ [[P1_START]], [[ENTRY:%.*]] ], [ [[P1_START]], [[VECTOR_MEMCHECK]] ] +; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi ptr [ [[TMP12]], [[MIDDLE_BLOCK]] ], [ [[P1_END]], [[ENTRY:%.*]] ], [ [[P1_END]], [[VECTOR_MEMCHECK]] ] ; CHECK-NEXT: [[BC_RESUME_VAL7:%.*]] = phi ptr [ [[IND_END6]], [[MIDDLE_BLOCK]] ], [ [[P2_START]], [[ENTRY]] ], [ [[P2_START]], [[VECTOR_MEMCHECK]] ] ; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK: loop: @@ -154,7 +148,7 @@ define void @test_ptr_iv_with_inbounds(ptr %p1.start, ptr %p2.start, ptr %p1.end ; CHECK-NEXT: store float [[SUM]], ptr [[P1]], align 4 ; CHECK-NEXT: [[P1_NEXT]] = getelementptr inbounds float, ptr [[P1]], i64 1 ; CHECK-NEXT: [[P2_NEXT]] = getelementptr inbounds float, ptr [[P2]], i64 1 -; CHECK-NEXT: [[C:%.*]] = icmp ne ptr [[P1_NEXT]], [[P1_END]] +; CHECK-NEXT: [[C:%.*]] = icmp ne ptr [[P1_NEXT]], [[P1_START]] ; CHECK-NEXT: br i1 [[C]], label [[LOOP]], label [[EXIT]], !llvm.loop [[LOOP15:![0-9]+]] ; CHECK: exit: ; CHECK-NEXT: ret void @@ -181,8 +175,8 @@ exit: define void @store_pointer_induction(ptr %start, ptr %end) { ; CHECK-LABEL: @store_pointer_induction( ; CHECK-NEXT: entry: -; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START:%.*]] to i64 -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END:%.*]] to i64 +; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START:%.*]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END:%.*]] to i64 ; CHECK-NEXT: [[TMP9:%.*]] = sub i64 [[START2]], [[END1]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP9]], -8 ; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 diff --git a/llvm/test/Transforms/LoopVectorize/optimal-epilog-vectorization-liveout.ll b/llvm/test/Transforms/LoopVectorize/optimal-epilog-vectorization-liveout.ll index 65484adeaab4..7ebfe0ba2a60 100644 --- a/llvm/test/Transforms/LoopVectorize/optimal-epilog-vectorization-liveout.ll +++ b/llvm/test/Transforms/LoopVectorize/optimal-epilog-vectorization-liveout.ll @@ -206,11 +206,9 @@ define ptr @test_ptr_iv_live_out(ptr %start, ptr %end, ptr %dst) { ; CHECK-LABEL: define ptr @test_ptr_iv_live_out( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]], ptr [[DST:%.*]]) { ; CHECK-NEXT: [[ITER_CHECK:.*]]: -; CHECK-NEXT: [[START5:%.*]] = ptrtoint ptr [[START]] to i64 -; CHECK-NEXT: [[END4:%.*]] = ptrtoint ptr [[END]] to i64 ; CHECK-NEXT: [[DST3:%.*]] = ptrtoaddr ptr [[DST]] to i64 -; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; CHECK-NEXT: [[START5:%.*]] = ptrtoaddr ptr [[START]] to i64 +; CHECK-NEXT: [[END4:%.*]] = ptrtoaddr ptr [[END]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[END4]], -4 ; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START5]] ; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 2 @@ -218,14 +216,14 @@ define ptr @test_ptr_iv_live_out(ptr %start, ptr %end, ptr %dst) { ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP3]], 2 ; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[VEC_EPILOG_SCALAR_PH:.*]], label %[[VECTOR_SCEVCHECK:.*]] ; CHECK: [[VECTOR_SCEVCHECK]]: -; CHECK-NEXT: [[TMP4:%.*]] = trunc i64 [[END1]] to i2 -; CHECK-NEXT: [[TMP5:%.*]] = trunc i64 [[START2]] to i2 +; CHECK-NEXT: [[TMP4:%.*]] = trunc i64 [[END4]] to i2 +; CHECK-NEXT: [[TMP5:%.*]] = trunc i64 [[START5]] to i2 ; CHECK-NEXT: [[TMP6:%.*]] = sub i2 [[TMP4]], [[TMP5]] ; CHECK-NEXT: [[TMP7:%.*]] = zext i2 [[TMP6]] to i64 ; CHECK-NEXT: [[IDENT_CHECK:%.*]] = icmp ne i64 [[TMP7]], 0 ; CHECK-NEXT: br i1 [[IDENT_CHECK]], label %[[VEC_EPILOG_SCALAR_PH]], label %[[VECTOR_MEMCHECK:.*]] ; CHECK: [[VECTOR_MEMCHECK]]: -; CHECK-NEXT: [[TMP8:%.*]] = sub i64 [[DST3]], [[START2]] +; CHECK-NEXT: [[TMP8:%.*]] = sub i64 [[DST3]], [[START5]] ; CHECK-NEXT: [[TMP18:%.*]] = sub i64 [[TMP8]], 1 ; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP18]], 15 ; CHECK-NEXT: br i1 [[DIFF_CHECK]], label %[[VEC_EPILOG_SCALAR_PH]], label %[[VECTOR_MAIN_LOOP_ITER_CHECK:.*]] diff --git a/llvm/test/Transforms/LoopVectorize/pointer-induction.ll b/llvm/test/Transforms/LoopVectorize/pointer-induction.ll index e154764f6209..db10937efc12 100644 --- a/llvm/test/Transforms/LoopVectorize/pointer-induction.ll +++ b/llvm/test/Transforms/LoopVectorize/pointer-induction.ll @@ -11,7 +11,7 @@ define void @a(ptr readnone %b) { ; CHECK-NEXT: [[CMP_NOT4:%.*]] = icmp eq ptr [[B:%.*]], null ; CHECK-NEXT: br i1 [[CMP_NOT4]], label [[FOR_COND_CLEANUP:%.*]], label [[FOR_BODY_PREHEADER:%.*]] ; CHECK: for.body.preheader: -; CHECK-NEXT: [[B1:%.*]] = ptrtoint ptr [[B]] to i64 +; CHECK-NEXT: [[B1:%.*]] = ptrtoaddr ptr [[B]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = sub i64 0, [[B1]] ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP0]], 4 ; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]] diff --git a/llvm/test/Transforms/LoopVectorize/pr45259.ll b/llvm/test/Transforms/LoopVectorize/pr45259.ll index 64724519a6c6..49dafe7d93f8 100644 --- a/llvm/test/Transforms/LoopVectorize/pr45259.ll +++ b/llvm/test/Transforms/LoopVectorize/pr45259.ll @@ -6,19 +6,17 @@ define i8 @widget(ptr %arr, i8 %t9) { ; CHECK-LABEL: @widget( ; CHECK-NEXT: bb: -; CHECK-NEXT: [[ARR1:%.*]] = ptrtoint ptr [[ARR:%.*]] to i64 +; CHECK-NEXT: [[ARR1:%.*]] = ptrtoaddr ptr [[ARR:%.*]] to i64 ; CHECK-NEXT: br label [[BB6:%.*]] ; CHECK: bb6: ; CHECK-NEXT: [[T1_0:%.*]] = phi ptr [ [[ARR]], [[BB:%.*]] ], [ null, [[BB6]] ] -; CHECK-NEXT: [[T1_0_LCSSA2:%.*]] = ptrtoint ptr [[T1_0]] to i64 +; CHECK-NEXT: [[T1_0_LCSSA2:%.*]] = ptrtoaddr ptr [[T1_0]] to i64 ; CHECK-NEXT: [[C:%.*]] = call i1 @cond() ; CHECK-NEXT: br i1 [[C]], label [[FOR_PREHEADER:%.*]], label [[BB6]] ; CHECK: for.preheader: ; CHECK-NEXT: [[T1_0_LCSSA1:%.*]] = phi ptr [ [[T1_0]], [[BB6]] ] -; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[ARR]] to i64 -; CHECK-NEXT: [[TMP1:%.*]] = trunc i64 [[TMP0]] to i32 -; CHECK-NEXT: [[TMP2:%.*]] = ptrtoint ptr [[T1_0]] to i64 -; CHECK-NEXT: [[TMP16:%.*]] = trunc i64 [[TMP2]] to i32 +; CHECK-NEXT: [[TMP1:%.*]] = trunc i64 [[ARR1]] to i32 +; CHECK-NEXT: [[TMP16:%.*]] = trunc i64 [[T1_0_LCSSA2]] to i32 ; CHECK-NEXT: [[TMP3:%.*]] = sub i32 [[TMP16]], [[TMP1]] ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i32 [[TMP3]], 4 ; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label [[SCALAR_PH:%.*]], label [[VECTOR_SCEVCHECK:%.*]] diff --git a/llvm/test/Transforms/LoopVectorize/predicate-switch.ll b/llvm/test/Transforms/LoopVectorize/predicate-switch.ll index f1a76a953569..e2890098084c 100644 --- a/llvm/test/Transforms/LoopVectorize/predicate-switch.ll +++ b/llvm/test/Transforms/LoopVectorize/predicate-switch.ll @@ -6,8 +6,8 @@ define void @switch4_default_common_dest_with_case(ptr %start, ptr %end) { ; IC1-LABEL: define void @switch4_default_common_dest_with_case( ; IC1-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) { ; IC1-NEXT: [[ENTRY:.*]]: -; IC1-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; IC1-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; IC1-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; IC1-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; IC1-NEXT: [[TMP0:%.*]] = sub i64 [[END1]], [[START2]] ; IC1-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP0]], 2 ; IC1-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]] @@ -98,8 +98,8 @@ define void @switch4_default_common_dest_with_case(ptr %start, ptr %end) { ; IC2-LABEL: define void @switch4_default_common_dest_with_case( ; IC2-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) { ; IC2-NEXT: [[ENTRY:.*]]: -; IC2-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; IC2-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64 +; IC2-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; IC2-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64 ; IC2-NEXT: [[TMP0:%.*]] = sub i64 [[END1]], [[START2]] ; IC2-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP0]], 4 ; IC2-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]] diff --git a/llvm/test/Transforms/LoopVectorize/preserve-dbg-loc-and-loop-metadata.ll b/llvm/test/Transforms/LoopVectorize/preserve-dbg-loc-and-loop-metadata.ll index 2936444f1d0f..0babffc67a79 100644 --- a/llvm/test/Transforms/LoopVectorize/preserve-dbg-loc-and-loop-metadata.ll +++ b/llvm/test/Transforms/LoopVectorize/preserve-dbg-loc-and-loop-metadata.ll @@ -71,8 +71,8 @@ define void @widen_ptr_induction_dbg(ptr %start, ptr %end) { ; CHECK-LABEL: define void @widen_ptr_induction_dbg( ; CHECK-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP8:%.*]] = ptrtoint ptr [[START]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[TMP8:%.*]] = ptrtoaddr ptr [[START]] to i64 ; CHECK-NEXT: [[TMP9:%.*]] = sub i64 [[END1]], [[TMP8]] ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP9]], -8 ; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3 @@ -113,8 +113,8 @@ define void @widen_ptr_induction_dbg(ptr %start, ptr %end) { ; DEBUGLOC-LABEL: define void @widen_ptr_induction_dbg( ; DEBUGLOC-SAME: ptr [[START:%.*]], ptr [[END:%.*]]) !dbg [[DBG29:![0-9]+]] { ; DEBUGLOC-NEXT: [[ENTRY:.*]]: -; DEBUGLOC-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[END]] to i64, !dbg [[DBG34:![0-9]+]] -; DEBUGLOC-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[START]] to i64, !dbg [[DBG34]] +; DEBUGLOC-NEXT: [[TMP0:%.*]] = ptrtoaddr ptr [[END]] to i64, !dbg [[DBG34:![0-9]+]] +; DEBUGLOC-NEXT: [[TMP1:%.*]] = ptrtoaddr ptr [[START]] to i64, !dbg [[DBG34]] ; DEBUGLOC-NEXT: [[TMP2:%.*]] = sub i64 [[TMP0]], [[TMP1]], !dbg [[DBG34]] ; DEBUGLOC-NEXT: [[TMP7:%.*]] = add i64 [[TMP2]], -8, !dbg [[DBG34]] ; DEBUGLOC-NEXT: [[TMP8:%.*]] = lshr i64 [[TMP7]], 3, !dbg [[DBG34]] diff --git a/llvm/test/Transforms/LoopVectorize/runtime-check-known-true.ll b/llvm/test/Transforms/LoopVectorize/runtime-check-known-true.ll index b5be50e8c7b4..fe2464a01897 100644 --- a/llvm/test/Transforms/LoopVectorize/runtime-check-known-true.ll +++ b/llvm/test/Transforms/LoopVectorize/runtime-check-known-true.ll @@ -5,14 +5,13 @@ define void @test_runtime_check_known_false_after_construction(ptr %start.1, ptr ; CHECK-LABEL: define void @test_runtime_check_known_false_after_construction( ; CHECK-SAME: ptr [[START_1:%.*]], ptr [[START_2:%.*]], ptr [[END:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*]]: -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; CHECK-NEXT: [[GEP_START_2:%.*]] = getelementptr i8, ptr [[START_2]], i64 8 ; CHECK-NEXT: [[START_1_INT:%.*]] = ptrtoint ptr [[START_1]] to i64 ; CHECK-NEXT: [[START_2_INT:%.*]] = ptrtoint ptr [[GEP_START_2]] to i64 ; CHECK-NEXT: [[DIFF:%.*]] = sub i64 [[START_1_INT]], [[START_2_INT]] ; CHECK-NEXT: [[START_2_DIFF:%.*]] = getelementptr i8, ptr [[START_2]], i64 [[DIFF]] -; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START_1_INT]] +; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[END1]], [[START_1_INT]] ; CHECK-NEXT: [[TMP12:%.*]] = add i64 [[TMP1]], 8 ; CHECK-NEXT: [[TMP2:%.*]] = mul i64 [[TMP12]], 2305843009213693951 ; CHECK-NEXT: [[TMP3:%.*]] = lshr i64 [[TMP2]], 3 diff --git a/llvm/test/Transforms/LoopVectorize/runtime-check-needed-but-empty.ll b/llvm/test/Transforms/LoopVectorize/runtime-check-needed-but-empty.ll index 852a5b10d606..0cb40f354cb4 100644 --- a/llvm/test/Transforms/LoopVectorize/runtime-check-needed-but-empty.ll +++ b/llvm/test/Transforms/LoopVectorize/runtime-check-needed-but-empty.ll @@ -81,7 +81,7 @@ define void @diff_memcheck_known_false_for_vf_4(ptr %B, ptr %A, ptr %end) { ; CHECK-NEXT: [[B_CAST:%.*]] = ptrtoint ptr [[B]] to i64 ; CHECK-NEXT: [[PTR_SUB:%.*]] = sub i64 [[A_INT]], [[B_CAST]] ; CHECK-NEXT: [[ADD_PTR11:%.*]] = getelementptr i8, ptr [[B]], i64 [[PTR_SUB]] -; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64 +; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[A_INT]], [[END1]] ; CHECK-NEXT: [[TMP1:%.*]] = lshr i64 [[TMP0]], 3 ; CHECK-NEXT: [[TMP2:%.*]] = add nuw nsw i64 [[TMP1]], 1 @@ -108,11 +108,11 @@ define void @diff_memcheck_known_false_for_vf_4(ptr %B, ptr %A, ptr %end) { ; CHECK-NEXT: br i1 [[CMP_N]], label %[[EXIT:.*]], label %[[SCALAR_PH]] ; CHECK: [[SCALAR_PH]]: ; CHECK-NEXT: [[BC_RESUME_VAL:%.*]] = phi ptr [ [[TMP4]], %[[MIDDLE_BLOCK]] ], [ [[A]], %[[ENTRY]] ] -; CHECK-NEXT: [[BC_RESUME_VAL2:%.*]] = phi ptr [ [[TMP5]], %[[MIDDLE_BLOCK]] ], [ [[ADD_PTR11]], %[[ENTRY]] ] +; CHECK-NEXT: [[BC_RESUME_VAL1:%.*]] = phi ptr [ [[TMP5]], %[[MIDDLE_BLOCK]] ], [ [[ADD_PTR11]], %[[ENTRY]] ] ; CHECK-NEXT: br label %[[LOOP:.*]] ; CHECK: [[LOOP]]: ; CHECK-NEXT: [[IV_1:%.*]] = phi ptr [ [[IV_1_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL]], %[[SCALAR_PH]] ] -; CHECK-NEXT: [[IV_2:%.*]] = phi ptr [ [[IV_2_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL2]], %[[SCALAR_PH]] ] +; CHECK-NEXT: [[IV_2:%.*]] = phi ptr [ [[IV_2_NEXT:%.*]], %[[LOOP]] ], [ [[BC_RESUME_VAL1]], %[[SCALAR_PH]] ] ; CHECK-NEXT: [[IV_2_NEXT]] = getelementptr nusw i8, ptr [[IV_2]], i64 -8 ; CHECK-NEXT: [[IV_1_NEXT]] = getelementptr i8, ptr [[IV_1]], i64 -8 ; CHECK-NEXT: [[TMP10:%.*]] = load i64, ptr [[IV_2_NEXT]], align 8 diff --git a/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll b/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll index f7ff1ff73308..d389162fb555 100644 --- a/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll +++ b/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll @@ -516,25 +516,20 @@ define void @diff_check_via_i32_ptrarith(ptr %origin, ptr %dst, ptr %base, i32 % ; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[OP]], [[N]] ; CHECK-NEXT: br i1 [[CMP]], label %[[LOOP_PH:.*]], [[EXIT:label %.*]] ; CHECK: [[LOOP_PH]]: -; CHECK-NEXT: [[TMP3:%.*]] = trunc i64 [[LHS]] to i32 -; CHECK-NEXT: [[TMP1:%.*]] = trunc i64 [[RHS]] to i32 -; CHECK-NEXT: [[TMP2:%.*]] = sub i32 [[D]], [[TMP3]] -; CHECK-NEXT: [[TMP14:%.*]] = add i32 [[TMP2]], [[TMP1]] +; CHECK-NEXT: [[TMP9:%.*]] = trunc i64 [[LHS]] to i32 +; CHECK-NEXT: [[TMP11:%.*]] = trunc i64 [[RHS]] to i32 +; CHECK-NEXT: [[TMP2:%.*]] = sub i32 [[D]], [[TMP9]] +; CHECK-NEXT: [[TMP14:%.*]] = add i32 [[TMP2]], [[TMP11]] ; CHECK-NEXT: [[TMP4:%.*]] = add i32 [[TMP14]], -1 ; CHECK-NEXT: [[TMP5:%.*]] = zext i32 [[TMP4]] to i64 ; CHECK-NEXT: [[TMP6:%.*]] = add nuw nsw i64 [[TMP5]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP6]], 4 ; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], [[SCALAR_PH:label %.*]], label %[[VECTOR_MEMCHECK:.*]] ; CHECK: [[VECTOR_MEMCHECK]]: -; CHECK-NEXT: [[TMP7:%.*]] = trunc i64 [[RHS]] to i32 -; CHECK-NEXT: [[TMP8:%.*]] = add i32 [[D]], [[TMP7]] -; CHECK-NEXT: [[TMP9:%.*]] = trunc i64 [[LHS]] to i32 -; CHECK-NEXT: [[TMP10:%.*]] = sub i32 [[TMP8]], [[TMP9]] -; CHECK-NEXT: [[TMP11:%.*]] = zext i32 [[TMP10]] to i64 -; CHECK-NEXT: [[TMP12:%.*]] = add i64 [[BASE1]], [[TMP11]] +; CHECK-NEXT: [[TMP12:%.*]] = add i64 [[BASE1]], [[IDX_EXT]] ; CHECK-NEXT: [[TMP13:%.*]] = sub i64 [[LHS]], [[TMP12]] -; CHECK-NEXT: [[TMP14:%.*]] = sub i64 [[TMP13]], 1 -; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP14]], 3 +; CHECK-NEXT: [[TMP10:%.*]] = sub i64 [[TMP13]], 1 +; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP10]], 3 ; CHECK-NEXT: br i1 [[DIFF_CHECK]], [[SCALAR_PH]], [[VECTOR_PH:label %.*]] ; entry: diff --git a/llvm/test/Transforms/LoopVectorize/scev-predicate-reasoning.ll b/llvm/test/Transforms/LoopVectorize/scev-predicate-reasoning.ll index 6d2b0a42298b..9e9ce59a3b27 100644 --- a/llvm/test/Transforms/LoopVectorize/scev-predicate-reasoning.ll +++ b/llvm/test/Transforms/LoopVectorize/scev-predicate-reasoning.ll @@ -123,10 +123,9 @@ define void @implied_wrap_predicate(ptr %A, ptr %B, ptr %C) { ; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]]) { ; CHECK-NEXT: [[ENTRY:.*:]] ; CHECK-NEXT: [[C2:%.*]] = ptrtoaddr ptr [[C]] to i64 -; CHECK-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64 -; CHECK-NEXT: [[A3:%.*]] = ptrtoint ptr [[A]] to i64 +; CHECK-NEXT: [[A3:%.*]] = ptrtoaddr ptr [[A]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[A3]], 16 -; CHECK-NEXT: [[TMP1:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP0]], i64 add (i64 ptrtoint (ptr @h to i64), i64 1)) +; CHECK-NEXT: [[TMP1:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP0]], i64 add (i64 ptrtoaddr (ptr @h to i64), i64 1)) ; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[TMP1]], [[A3]] ; CHECK-NEXT: [[TMP20:%.*]] = add i64 [[TMP2]], -9 ; CHECK-NEXT: [[TMP3:%.*]] = lshr i64 [[TMP20]], 3 @@ -134,10 +133,10 @@ define void @implied_wrap_predicate(ptr %A, ptr %B, ptr %C) { ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP4]], 4 ; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_SCEVCHECK:.*]] ; CHECK: [[VECTOR_SCEVCHECK]]: -; CHECK-NEXT: [[TMP5:%.*]] = add i64 [[A1]], 16 -; CHECK-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP5]], i64 add (i64 ptrtoint (ptr @h to i64), i64 1)) +; CHECK-NEXT: [[TMP5:%.*]] = add i64 [[A3]], 16 +; CHECK-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP5]], i64 add (i64 ptrtoaddr (ptr @h to i64), i64 1)) ; CHECK-NEXT: [[TMP6:%.*]] = add i64 [[UMAX]], -9 -; CHECK-NEXT: [[TMP7:%.*]] = sub i64 [[TMP6]], [[A1]] +; CHECK-NEXT: [[TMP7:%.*]] = sub i64 [[TMP6]], [[A3]] ; CHECK-NEXT: [[TMP8:%.*]] = lshr i64 [[TMP7]], 3 ; CHECK-NEXT: [[TMP9:%.*]] = trunc i64 [[TMP8]] to i16 ; CHECK-NEXT: [[TMP10:%.*]] = add i16 2, [[TMP9]] @@ -146,7 +145,7 @@ define void @implied_wrap_predicate(ptr %A, ptr %B, ptr %C) { ; CHECK-NEXT: [[TMP13:%.*]] = or i1 [[TMP11]], [[TMP12]] ; CHECK-NEXT: br i1 [[TMP13]], label %[[SCALAR_PH]], label %[[VECTOR_MEMCHECK:.*]] ; CHECK: [[VECTOR_MEMCHECK]]: -; CHECK-NEXT: [[TMP14:%.*]] = sub i64 [[C2]], [[A1]] +; CHECK-NEXT: [[TMP14:%.*]] = sub i64 [[C2]], [[A3]] ; CHECK-NEXT: [[TMP21:%.*]] = sub i64 [[TMP14]], 1 ; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP21]], 31 ; CHECK-NEXT: br i1 [[DIFF_CHECK]], label %[[SCALAR_PH]], label %[[VECTOR_PH:.*]] diff --git a/llvm/test/Transforms/PhaseOrdering/AArch64/loop-rotate-to-enable-unrolling-and-vectorization.ll b/llvm/test/Transforms/PhaseOrdering/AArch64/loop-rotate-to-enable-unrolling-and-vectorization.ll index 976ed37b6871..4e5ce493ef5d 100644 --- a/llvm/test/Transforms/PhaseOrdering/AArch64/loop-rotate-to-enable-unrolling-and-vectorization.ll +++ b/llvm/test/Transforms/PhaseOrdering/AArch64/loop-rotate-to-enable-unrolling-and-vectorization.ll @@ -15,8 +15,8 @@ define ptr @search_loop_unrolled(ptr %begin, ptr %end, i8 %val) { ; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[CMP_ENTRY]], i1 true, i1 [[CMP_END2]] ; CHECK-NEXT: br i1 [[OR_COND]], label %[[COMMON_RET:.*]], label %[[FOR_COND:.*]] ; CHECK: [[FOR_COND]]: -; CHECK-NEXT: [[END5:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[BEGIN6:%.*]] = ptrtoint ptr [[BEGIN]] to i64 +; CHECK-NEXT: [[END5:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[BEGIN6:%.*]] = ptrtoaddr ptr [[BEGIN]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = xor i64 [[BEGIN6]], -1 ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP0]], [[END5]] ; CHECK-NEXT: [[TMP2:%.*]] = freeze i64 [[TMP1]] diff --git a/llvm/test/Transforms/PhaseOrdering/X86/pr48844-br-to-switch-vectorization.ll b/llvm/test/Transforms/PhaseOrdering/X86/pr48844-br-to-switch-vectorization.ll index b2e07e77b05c..9bb67bd299ee 100644 --- a/llvm/test/Transforms/PhaseOrdering/X86/pr48844-br-to-switch-vectorization.ll +++ b/llvm/test/Transforms/PhaseOrdering/X86/pr48844-br-to-switch-vectorization.ll @@ -34,8 +34,8 @@ define dso_local void @test(ptr %start, ptr %end) #0 { ; AVX2-NEXT: [[I11_NOT1:%.*]] = icmp eq ptr [[START:%.*]], [[END:%.*]] ; AVX2-NEXT: br i1 [[I11_NOT1]], label [[EXIT:%.*]], label [[BB12_PREHEADER:%.*]] ; AVX2: iter.check: -; AVX2-NEXT: [[END3:%.*]] = ptrtoint ptr [[END]] to i64 -; AVX2-NEXT: [[START4:%.*]] = ptrtoint ptr [[START]] to i64 +; AVX2-NEXT: [[END3:%.*]] = ptrtoaddr ptr [[END]] to i64 +; AVX2-NEXT: [[START4:%.*]] = ptrtoaddr ptr [[START]] to i64 ; AVX2-NEXT: [[TMP0:%.*]] = add i64 [[END3]], -4 ; AVX2-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START4]] ; AVX2-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 2 diff --git a/llvm/test/Transforms/PhaseOrdering/X86/ptrtoaddr-ptrtoint.ll b/llvm/test/Transforms/PhaseOrdering/X86/ptrtoaddr-ptrtoint.ll index efcc1701c9bb..1bb6b2fb5bd3 100644 --- a/llvm/test/Transforms/PhaseOrdering/X86/ptrtoaddr-ptrtoint.ll +++ b/llvm/test/Transforms/PhaseOrdering/X86/ptrtoaddr-ptrtoint.ll @@ -8,33 +8,45 @@ declare void @llvm.memmove.p0.p0.i64(ptr writeonly captures(none), ptr readonly define void @redundant_int_iv(ptr %first) { ; CHECK-LABEL: define void @redundant_int_iv( -; CHECK-SAME: ptr [[FIRST:%.*]]) local_unnamed_addr #[[ATTR0:[0-9]+]] { +; CHECK-SAME: ptr [[FIRST:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] { ; CHECK-NEXT: [[ENTRY:.*]]: ; CHECK-NEXT: [[PTR_INT1:%.*]] = ptrtoint ptr [[FIRST]] to i64 ; CHECK-NEXT: [[OFF2:%.*]] = add i64 [[PTR_INT1]], 1 ; CHECK-NEXT: [[EC_OUTER3:%.*]] = icmp slt i64 [[OFF2]], 0 ; CHECK-NEXT: br i1 [[EC_OUTER3]], label %[[INNER_PH:.*]], label %[[EXIT:.*]] ; CHECK: [[INNER_PH]]: +; CHECK-NEXT: [[PTR_INT5:%.*]] = phi i64 [ [[PTR_INT:%.*]], %[[INNER_PH]] ], [ [[PTR_INT1]], %[[ENTRY]] ] ; CHECK-NEXT: [[PTR_IV4:%.*]] = phi ptr [ [[LAST:%.*]], %[[INNER_PH]] ], [ [[FIRST]], %[[ENTRY]] ] ; CHECK-NEXT: [[LAST]] = getelementptr i8, ptr [[PTR_IV4]], i64 7 ; CHECK-NEXT: [[CUR_NEXT:%.*]] = getelementptr i8, ptr [[PTR_IV4]], i64 1 -; CHECK-NEXT: [[TMP0:%.*]] = load i8, ptr [[PTR_IV4]], align 1 -; CHECK-NEXT: store i8 [[TMP0]], ptr [[CUR_NEXT]], align 1 +; CHECK-NEXT: [[CUR_INT:%.*]] = ptrtoint ptr [[CUR_NEXT]] to i64 +; CHECK-NEXT: [[LEN:%.*]] = sub i64 [[CUR_INT]], [[PTR_INT5]] +; CHECK-NEXT: tail call void @llvm.memmove.p0.p0.i64(ptr align 1 [[CUR_NEXT]], ptr align 1 [[PTR_IV4]], i64 [[LEN]], i1 false) ; CHECK-NEXT: [[CUR_NEXT_1:%.*]] = getelementptr i8, ptr [[PTR_IV4]], i64 2 -; CHECK-NEXT: [[TMP1:%.*]] = load i16, ptr [[PTR_IV4]], align 1 -; CHECK-NEXT: store i16 [[TMP1]], ptr [[CUR_NEXT_1]], align 1 +; CHECK-NEXT: [[CUR_INT_1:%.*]] = ptrtoint ptr [[CUR_NEXT_1]] to i64 +; CHECK-NEXT: [[LEN_1:%.*]] = sub i64 [[CUR_INT_1]], [[PTR_INT5]] +; CHECK-NEXT: tail call void @llvm.memmove.p0.p0.i64(ptr align 1 [[CUR_NEXT_1]], ptr align 1 [[PTR_IV4]], i64 [[LEN_1]], i1 false) ; CHECK-NEXT: [[CUR_NEXT_2:%.*]] = getelementptr i8, ptr [[PTR_IV4]], i64 3 -; CHECK-NEXT: tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(3) [[CUR_NEXT_2]], ptr noundef nonnull align 1 dereferenceable(3) [[PTR_IV4]], i64 3, i1 false) +; CHECK-NEXT: [[CUR_INT_2:%.*]] = ptrtoint ptr [[CUR_NEXT_2]] to i64 +; CHECK-NEXT: [[LEN_2:%.*]] = sub i64 [[CUR_INT_2]], [[PTR_INT5]] +; CHECK-NEXT: tail call void @llvm.memmove.p0.p0.i64(ptr align 1 [[CUR_NEXT_2]], ptr align 1 [[PTR_IV4]], i64 [[LEN_2]], i1 false) ; CHECK-NEXT: [[CUR_NEXT_3:%.*]] = getelementptr i8, ptr [[PTR_IV4]], i64 4 -; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[PTR_IV4]], align 1 -; CHECK-NEXT: store i32 [[TMP2]], ptr [[CUR_NEXT_3]], align 1 +; CHECK-NEXT: [[CUR_INT_3:%.*]] = ptrtoint ptr [[CUR_NEXT_3]] to i64 +; CHECK-NEXT: [[LEN_3:%.*]] = sub i64 [[CUR_INT_3]], [[PTR_INT5]] +; CHECK-NEXT: tail call void @llvm.memmove.p0.p0.i64(ptr align 1 [[CUR_NEXT_3]], ptr align 1 [[PTR_IV4]], i64 [[LEN_3]], i1 false) ; CHECK-NEXT: [[CUR_NEXT_4:%.*]] = getelementptr i8, ptr [[PTR_IV4]], i64 5 -; CHECK-NEXT: tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(5) [[CUR_NEXT_4]], ptr noundef nonnull align 1 dereferenceable(5) [[PTR_IV4]], i64 5, i1 false) +; CHECK-NEXT: [[CUR_INT_4:%.*]] = ptrtoint ptr [[CUR_NEXT_4]] to i64 +; CHECK-NEXT: [[LEN_4:%.*]] = sub i64 [[CUR_INT_4]], [[PTR_INT5]] +; CHECK-NEXT: tail call void @llvm.memmove.p0.p0.i64(ptr align 1 [[CUR_NEXT_4]], ptr align 1 [[PTR_IV4]], i64 [[LEN_4]], i1 false) ; CHECK-NEXT: [[CUR_NEXT_5:%.*]] = getelementptr i8, ptr [[PTR_IV4]], i64 6 -; CHECK-NEXT: tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(6) [[CUR_NEXT_5]], ptr noundef nonnull align 1 dereferenceable(6) [[PTR_IV4]], i64 6, i1 false) +; CHECK-NEXT: [[CUR_INT_5:%.*]] = ptrtoint ptr [[CUR_NEXT_5]] to i64 +; CHECK-NEXT: [[LEN_5:%.*]] = sub i64 [[CUR_INT_5]], [[PTR_INT5]] +; CHECK-NEXT: tail call void @llvm.memmove.p0.p0.i64(ptr align 1 [[CUR_NEXT_5]], ptr align 1 [[PTR_IV4]], i64 [[LEN_5]], i1 false) ; CHECK-NEXT: [[CUR_NEXT_6:%.*]] = getelementptr i8, ptr [[PTR_IV4]], i64 7 -; CHECK-NEXT: tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(7) [[CUR_NEXT_6]], ptr noundef nonnull align 1 dereferenceable(7) [[PTR_IV4]], i64 7, i1 false) -; CHECK-NEXT: [[PTR_INT:%.*]] = ptrtoint ptr [[LAST]] to i64 +; CHECK-NEXT: [[CUR_INT_6:%.*]] = ptrtoint ptr [[CUR_NEXT_6]] to i64 +; CHECK-NEXT: [[LEN_6:%.*]] = sub i64 [[CUR_INT_6]], [[PTR_INT5]] +; CHECK-NEXT: tail call void @llvm.memmove.p0.p0.i64(ptr align 1 [[CUR_NEXT_6]], ptr align 1 [[PTR_IV4]], i64 [[LEN_6]], i1 false) +; CHECK-NEXT: [[PTR_INT]] = ptrtoint ptr [[LAST]] to i64 ; CHECK-NEXT: [[OFF:%.*]] = add i64 [[PTR_INT]], 1 ; CHECK-NEXT: [[EC_OUTER:%.*]] = icmp slt i64 [[OFF]], 0 ; CHECK-NEXT: br i1 [[EC_OUTER]], label %[[INNER_PH]], label %[[EXIT]] @@ -74,13 +86,14 @@ exit: define ptr @cancel_out_of_range(ptr %p) { ; CHECK-LABEL: define noalias noundef ptr @cancel_out_of_range( -; CHECK-SAME: ptr [[P:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] { +; CHECK-SAME: ptr [[P:%.*]]) local_unnamed_addr #[[ATTR2:[0-9]+]] { ; CHECK-NEXT: [[ENTRY:.*:]] -; CHECK-NEXT: [[P1:%.*]] = ptrtoint ptr [[P]] to i64 ; CHECK-NEXT: store ptr [[P]], ptr [[P]], align 8 +; CHECK-NEXT: [[P1:%.*]] = ptrtoint ptr [[P]] to i64 ; CHECK-NEXT: [[TMP0:%.*]] = and i64 [[P1]], 255 ; CHECK-NEXT: [[IS_ZERO:%.*]] = icmp eq i64 [[TMP0]], 0 -; CHECK-NEXT: [[SPEC_SELECT_IDX:%.*]] = select i1 [[IS_ZERO]], i64 0, i64 [[P1]] +; CHECK-NEXT: [[P2:%.*]] = ptrtoaddr ptr [[P]] to i64 +; CHECK-NEXT: [[SPEC_SELECT_IDX:%.*]] = select i1 [[IS_ZERO]], i64 0, i64 [[P2]] ; CHECK-NEXT: [[SPEC_SELECT:%.*]] = getelementptr i8, ptr null, i64 [[SPEC_SELECT_IDX]] ; CHECK-NEXT: ret ptr [[SPEC_SELECT]] ; @@ -108,7 +121,7 @@ loop.dec: define i64 @cse_two_guards(ptr %base, i64 %n, ptr %cmp) { ; CHECK-LABEL: define i64 @cse_two_guards( -; CHECK-SAME: ptr [[BASE:%.*]], i64 [[N:%.*]], ptr nofree readonly captures(none) [[CMP:%.*]]) local_unnamed_addr #[[ATTR0]] { +; CHECK-SAME: ptr [[BASE:%.*]], i64 [[N:%.*]], ptr nofree readonly captures(none) [[CMP:%.*]]) local_unnamed_addr #[[ATTR1]] { ; CHECK-NEXT: [[ENTRY:.*]]: ; CHECK-NEXT: [[N_FR:%.*]] = freeze i64 [[N]] ; CHECK-NEXT: store ptr [[BASE]], ptr [[BASE]], align 8 @@ -116,8 +129,7 @@ define i64 @cse_two_guards(ptr %base, i64 %n, ptr %cmp) { ; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[BASE]] to i64 ; CHECK-NEXT: br i1 [[NE_I_NOT6]], label %[[RET:.*]], label %[[LOOP1_INC_PREHEADER:.*]] ; CHECK: [[LOOP1_INC_PREHEADER]]: -; CHECK-NEXT: [[TMP1:%.*]] = ptrtoint ptr [[BASE]] to i64 -; CHECK-NEXT: [[TMP2:%.*]] = sub i64 add (i64 ptrtoint (ptr @end to i64), i64 -48), [[TMP1]] +; CHECK-NEXT: [[TMP2:%.*]] = sub i64 add (i64 ptrtoaddr (ptr @end to i64), i64 -48), [[TMP0]] ; CHECK-NEXT: [[TMP3:%.*]] = udiv i64 [[TMP2]], 48 ; CHECK-NEXT: [[TMP4:%.*]] = add nuw nsw i64 [[TMP3]], 1 ; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP2]], 144 @@ -144,7 +156,10 @@ define i64 @cse_two_guards(ptr %base, i64 %n, ptr %cmp) { ; CHECK: [[LOOP2_BODY_LR_PH]]: ; CHECK-NEXT: [[SEL_LCSSA:%.*]] = phi i64 [ [[RDX_SELECT]], %[[MIDDLE_BLOCK]] ], [ [[SEL:%.*]], %[[LOOP1_INC]] ] ; CHECK-NEXT: [[TMP9:%.*]] = uitofp nneg i64 [[SEL_LCSSA]] to double -; CHECK-NEXT: [[MIN_ITERS_CHECK18:%.*]] = icmp ult i64 [[TMP2]], 144 +; CHECK-NEXT: [[TMP21:%.*]] = sub i64 add (i64 ptrtoaddr (ptr @end to i64), i64 -48), [[TMP0]] +; CHECK-NEXT: [[TMP27:%.*]] = udiv i64 [[TMP21]], 48 +; CHECK-NEXT: [[TMP28:%.*]] = add nuw nsw i64 [[TMP27]], 1 +; CHECK-NEXT: [[MIN_ITERS_CHECK18:%.*]] = icmp ult i64 [[TMP21]], 144 ; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK18]], label %[[LOOP2_BODY_PREHEADER:.*]], label %[[VECTOR_MEMCHECK:.*]] ; CHECK: [[VECTOR_MEMCHECK]]: ; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[BASE]], i64 8 @@ -154,7 +169,7 @@ define i64 @cse_two_guards(ptr %base, i64 %n, ptr %cmp) { ; CHECK-NEXT: [[FOUND_CONFLICT:%.*]] = and i1 [[BOUND0]], [[BOUND1]] ; CHECK-NEXT: br i1 [[FOUND_CONFLICT]], label %[[LOOP2_BODY_PREHEADER]], label %[[VECTOR_PH19:.*]] ; CHECK: [[VECTOR_PH19]]: -; CHECK-NEXT: [[N_VEC21:%.*]] = and i64 [[TMP4]], 1152921504606846974 +; CHECK-NEXT: [[N_VEC21:%.*]] = and i64 [[TMP28]], 1152921504606846974 ; CHECK-NEXT: [[BROADCAST_SPLATINSERT22:%.*]] = insertelement <2 x double> poison, double [[TMP9]], i64 0 ; CHECK-NEXT: [[TMP10:%.*]] = mul i64 [[N_VEC21]], 48 ; CHECK-NEXT: [[TMP11:%.*]] = getelementptr i8, ptr [[BASE]], i64 [[TMP10]] @@ -188,7 +203,7 @@ define i64 @cse_two_guards(ptr %base, i64 %n, ptr %cmp) { ; CHECK-NEXT: br i1 [[TMP25]], label %[[MIDDLE_BLOCK34:.*]], label %[[VECTOR_BODY28]], !llvm.loop [[LOOP8:![0-9]+]] ; CHECK: [[MIDDLE_BLOCK34]]: ; CHECK-NEXT: [[TMP26:%.*]] = tail call i64 @llvm.experimental.vector.extract.last.active.v2i64(<2 x i64> [[TMP24]], <2 x i1> [[TMP23]], i64 [[TMP0]]) -; CHECK-NEXT: [[CMP_N35:%.*]] = icmp eq i64 [[TMP4]], [[N_VEC21]] +; CHECK-NEXT: [[CMP_N35:%.*]] = icmp eq i64 [[TMP28]], [[N_VEC21]] ; CHECK-NEXT: br i1 [[CMP_N35]], label %[[RET]], label %[[LOOP2_BODY_PREHEADER]] ; CHECK: [[LOOP2_BODY_PREHEADER]]: ; CHECK-NEXT: [[RES12_PH:%.*]] = phi i64 [ [[TMP0]], %[[VECTOR_MEMCHECK]] ], [ [[TMP0]], %[[LOOP2_BODY_LR_PH]] ], [ [[TMP26]], %[[MIDDLE_BLOCK34]] ] @@ -269,7 +284,7 @@ loop2.inc: define i1 @iter_ne(ptr %it) { ; CHECK-LABEL: define i1 @iter_ne( -; CHECK-SAME: ptr nofree readonly captures(none) [[IT:%.*]]) local_unnamed_addr #[[ATTR2:[0-9]+]] { +; CHECK-SAME: ptr nofree readonly captures(none) [[IT:%.*]]) local_unnamed_addr #[[ATTR3:[0-9]+]] { ; CHECK-NEXT: [[CUR:%.*]] = load ptr, ptr [[IT]], align 8 ; CHECK-NEXT: [[NE:%.*]] = icmp ne ptr [[CUR]], @end ; CHECK-NEXT: ret i1 [[NE]] @@ -281,7 +296,7 @@ define i1 @iter_ne(ptr %it) { define ptr @iter_inc(ptr %it) { ; CHECK-LABEL: define noalias noundef ptr @iter_inc( -; CHECK-SAME: ptr nofree captures(none) [[IT:%.*]]) local_unnamed_addr #[[ATTR3:[0-9]+]] { +; CHECK-SAME: ptr nofree captures(none) [[IT:%.*]]) local_unnamed_addr #[[ATTR4:[0-9]+]] { ; CHECK-NEXT: [[CUR:%.*]] = load ptr, ptr [[IT]], align 8 ; CHECK-NEXT: [[NEXT:%.*]] = getelementptr nusw nuw i8, ptr [[CUR]], i64 48 ; CHECK-NEXT: store ptr [[NEXT]], ptr [[IT]], align 8 @@ -295,7 +310,7 @@ define ptr @iter_inc(ptr %it) { define i1 @lambda(ptr %lam, ptr %cmp) { ; CHECK-LABEL: define i1 @lambda( -; CHECK-SAME: ptr nofree readonly captures(none) [[LAM:%.*]], ptr nofree readonly captures(none) [[CMP:%.*]]) local_unnamed_addr #[[ATTR2]] { +; CHECK-SAME: ptr nofree readonly captures(none) [[LAM:%.*]], ptr nofree readonly captures(none) [[CMP:%.*]]) local_unnamed_addr #[[ATTR3]] { ; CHECK-NEXT: [[CMP_VAL:%.*]] = load i64, ptr [[CMP]], align 8 ; CHECK-NEXT: [[CMP_F:%.*]] = uitofp i64 [[CMP_VAL]] to double ; CHECK-NEXT: [[LAM_VAL:%.*]] = load i64, ptr [[LAM]], align 8 @@ -320,15 +335,18 @@ define ptr @gep_base_cancel(ptr %p, ptr %end, ptr noalias %a) { ; CHECK-NEXT: [[IN_BOUNDS6:%.*]] = icmp ult ptr [[P]], [[END]] ; CHECK-NEXT: br i1 [[IN_BOUNDS6]], label %[[BODY_PREHEADER:.*]], label %[[COMMON_RET:.*]] ; CHECK: [[BODY_PREHEADER]]: -; CHECK-NEXT: [[END15:%.*]] = ptrtoint ptr [[END]] to i64 -; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr inttoptr (i64 -1 to ptr), i64 [[END15]] +; CHECK-NEXT: [[END15:%.*]] = ptrtoaddr ptr [[END]] to i64 +; CHECK-NEXT: [[P16:%.*]] = ptrtoaddr ptr [[P]] to i64 +; CHECK-NEXT: [[TMP0:%.*]] = xor i64 [[P16]], -1 +; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP0]], [[END15]] +; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[P]], i64 [[TMP1]] ; CHECK-NEXT: [[CHAR_PEEL:%.*]] = load i8, ptr [[P]], align 1 ; CHECK-NEXT: switch i8 [[CHAR_PEEL]], label %[[TRAP:.*]] [ ; CHECK-NEXT: i8 33, label %[[ADVANCE_PEEL:.*]] ; CHECK-NEXT: i8 36, label %[[ADVANCE_PEEL]] ; CHECK-NEXT: ] ; CHECK: [[ADVANCE_PEEL]]: -; CHECK-NEXT: [[EXITCOND_PEEL_NOT:%.*]] = icmp eq ptr [[P]], [[SCEVGEP]] +; CHECK-NEXT: [[EXITCOND_PEEL_NOT:%.*]] = icmp eq i64 [[TMP1]], 0 ; CHECK-NEXT: br i1 [[EXITCOND_PEEL_NOT]], label %[[COMMON_RET]], label %[[BODY:.*]] ; CHECK: [[COMMON_RET]]: ; CHECK-NEXT: [[RET_KNOWN_TR3:%.*]] = phi ptr [ [[A_TR9_LCSSA:%.*]], %[[TRAP]] ], [ null, %[[ENTRY]] ], [ null, %[[ADVANCE_PEEL]] ], [ null, %[[ADVANCE:.*]] ] diff --git a/llvm/test/Transforms/PhaseOrdering/enable-loop-header-duplication-oz.ll b/llvm/test/Transforms/PhaseOrdering/enable-loop-header-duplication-oz.ll index 299c42aab450..d6e57edb8cc8 100644 --- a/llvm/test/Transforms/PhaseOrdering/enable-loop-header-duplication-oz.ll +++ b/llvm/test/Transforms/PhaseOrdering/enable-loop-header-duplication-oz.ll @@ -30,8 +30,8 @@ define void @test(i8* noalias nonnull align 1 %start, i8* %end) minsize { ; ROTATION-NEXT: [[_12_I1:%.*]] = icmp eq ptr [[START]], [[END]] ; ROTATION-NEXT: br i1 [[_12_I1]], label [[EXIT:%.*]], label [[LOOP_LATCH_PREHEADER:%.*]] ; ROTATION: loop.latch.preheader: -; ROTATION-NEXT: [[END3:%.*]] = ptrtoint ptr [[END]] to i64 -; ROTATION-NEXT: [[START4:%.*]] = ptrtoint ptr [[START]] to i64 +; ROTATION-NEXT: [[END3:%.*]] = ptrtoaddr ptr [[END]] to i64 +; ROTATION-NEXT: [[START4:%.*]] = ptrtoaddr ptr [[START]] to i64 ; ROTATION-NEXT: [[TMP0:%.*]] = sub i64 [[END3]], [[START4]] ; ROTATION-NEXT: tail call void @llvm.memset.p0.i64(ptr nonnull align 1 [[START]], i8 1, i64 [[TMP0]], i1 false) ; ROTATION-NEXT: br label [[EXIT]] diff --git a/llvm/test/Transforms/PhaseOrdering/scev-custom-dl.ll b/llvm/test/Transforms/PhaseOrdering/scev-custom-dl.ll index 025a1b34086a..978ecd2bd32a 100644 --- a/llvm/test/Transforms/PhaseOrdering/scev-custom-dl.ll +++ b/llvm/test/Transforms/PhaseOrdering/scev-custom-dl.ll @@ -198,13 +198,14 @@ define void @test_range_ref1(i8 %t) { ; CHECK-NEXT: %t.ptr = inttoptr i40 %0 to ptr ; CHECK-NEXT: --> %t.ptr U: [0,256) S: [0,256) ; CHECK-NEXT: %idx = phi ptr [ %t.ptr, %entry ], [ %snext, %loop ] -; CHECK-NEXT: --> {%t.ptr,+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%t.ptr,+,1}<%loop> U: [0,297) S: [0,297) Exits: (-1 + (-1 * (ptrtoaddr ptr %t.ptr to i32)) + ((1 + (ptrtoaddr ptr %t.ptr to i32)) umax (ptrtoaddr ptr inttoptr (i8 42 to ptr) to i32)) + %t.ptr) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %snext = getelementptr inbounds nuw i8, ptr %idx, i32 1 -; CHECK-NEXT: --> {(1 + %t.ptr),+,1}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(1 + %t.ptr),+,1}<%loop> U: [1,298) S: [1,298) Exits: ((-1 * (ptrtoaddr ptr %t.ptr to i32)) + ((1 + (ptrtoaddr ptr %t.ptr to i32)) umax (ptrtoaddr ptr inttoptr (i8 42 to ptr) to i32)) + %t.ptr) LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @test_range_ref1 -; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. -; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. -; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %t.ptr to i32)) + ((1 + (ptrtoaddr ptr %t.ptr to i32)) umax (ptrtoaddr ptr inttoptr (i8 42 to ptr) to i32))) +; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 41 +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoaddr ptr %t.ptr to i32)) + ((1 + (ptrtoaddr ptr %t.ptr to i32)) umax (ptrtoaddr ptr inttoptr (i8 42 to ptr) to i32))) +; CHECK-NEXT: Loop %loop: Trip multiple is 1 ; entry: %t.ptr = inttoptr i8 %t to ptr diff --git a/llvm/unittests/Analysis/ScalarEvolutionTest.cpp b/llvm/unittests/Analysis/ScalarEvolutionTest.cpp index 99edc5b25f3e..286811bc7bc4 100644 --- a/llvm/unittests/Analysis/ScalarEvolutionTest.cpp +++ b/llvm/unittests/Analysis/ScalarEvolutionTest.cpp @@ -704,7 +704,7 @@ TEST_F(ScalarEvolutionsTest, SCEVZeroExtendExpr) { ReturnInst::Create(Context, nullptr, EndBB); ScalarEvolution SE = buildSE(*F); const SCEV *S = SE.getSCEV(Accum); - S = SE.getLosslessPtrToIntExpr(S); + S = SE.getPtrToAddrExpr(S); Type *I128Ty = Type::getInt128Ty(Context); SE.getZeroExtendExpr(S, I128Ty); } @@ -1802,9 +1802,9 @@ TEST_F(ScalarEvolutionsTest, ComplexityComparatorIsStrictWeakOrdering2) { const SCEV *S1 = SE.getSCEV(F->getArg(1)); const SCEV *S2 = SE.getSCEV(F->getArg(2)); - const SCEV *P0 = SE.getPtrToIntExpr(S0, Int64Ty); - const SCEV *P1 = SE.getPtrToIntExpr(S1, Int64Ty); - const SCEV *P2 = SE.getPtrToIntExpr(S2, Int64Ty); + const SCEV *P0 = SE.getPtrToAddrExpr(S0); + const SCEV *P1 = SE.getPtrToAddrExpr(S1); + const SCEV *P2 = SE.getPtrToAddrExpr(S2); const SCEV *M0 = SE.getNegativeSCEV(P0); const SCEV *M2 = SE.getNegativeSCEV(P2); diff --git a/polly/test/ScopInfo/int2ptr_ptr2int.ll b/polly/test/ScopInfo/int2ptr_ptr2int.ll index adefe794561c..7c3e4b060b66 100644 --- a/polly/test/ScopInfo/int2ptr_ptr2int.ll +++ b/polly/test/ScopInfo/int2ptr_ptr2int.ll @@ -16,14 +16,12 @@ ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: [val, ptr] -> { Stmt_for_body[i0] -> MemRef_A[9 + ptr] }; ; -; IR: entry: -; IR-NEXT: %ptr1 = ptrtoint ptr %ptr to i32 -; ; IR: polly.stmt.for.body: -; IR-NEXT: %p_tmp1 = inttoptr i64 %14 to ptr +; IR-NEXT: %p_tmp1 = inttoptr i64 %{{[0-9]+}} to ptr ; IR-NEXT: %p_add.ptr2 = getelementptr inbounds i64, ptr %p_tmp1, i64 1 -; IR-NEXT: %p_tmp2 = ptrtoint ptr %p_add.ptr2 to i64 -; IR-NEXT: %p_arrayidx = getelementptr inbounds i64, ptr %A, i64 %p_tmp2 +; IR-NEXT: %p_tmp2 = ptrtoaddr ptr %p_add.ptr2 to i32 +; IR-NEXT: %p_tmp2.ext = zext i32 %p_tmp2 to i64 +; IR-NEXT: %p_arrayidx = getelementptr inbounds i64, ptr %A, i64 %p_tmp2.ext ; IR-NEXT: %tmp3_p_scalar_ = load i64, ptr %p_arrayidx, align 8, !alias.scope !2, !noalias !5 ; IR-NEXT: %tmp4_p_scalar_ = load i64, ptr %scevgep, align 8, !alias.scope !2, !noalias !5 ; IR-NEXT: %p_add4 = add nsw i64 %tmp4_p_scalar_, %tmp3_p_scalar_ @@ -33,12 +31,11 @@ ; IR-NEXT: br i1 %polly.loop_cond, label %polly.loop_header, label %polly.loop_exit ; ; IR: polly.loop_preheader: -; IR-NEXT: %14 = add i64 %val, 1 -; IR-NEXT: %15 = shl i32 %ptr1, 3 -; IR-NEXT: %16 = add i32 %15, 72 -; IR-NEXT: %scevgep = getelementptr i8, ptr %A, i32 %16 +; IR-NEXT: %{{[0-9]+}} = add i64 %val, 1 +; IR-NEXT: %[[SHL:[0-9]+]] = shl i32 %{{[0-9]+}}, 3 +; IR-NEXT: %[[ADD:[0-9]+]] = add i32 %[[SHL]], 72 +; IR-NEXT: %scevgep = getelementptr i8, ptr %A, i32 %[[ADD]] ; IR-NEXT: br label %polly.loop_header - ; target datalayout = "e-p:32:32:32-m:e-i64:64-f80:128-n8:16:32:64-S128" @@ -53,13 +50,15 @@ for.cond: ; preds = %for.inc, %entry for.body: ; preds = %for.cond %add.ptr = getelementptr inbounds i64, ptr %ptr, i64 1 - %tmp = ptrtoint ptr %add.ptr to i64 - %add = add nsw i64 %tmp, 1 + %tmp = ptrtoaddr ptr %add.ptr to i32 + %tmp.ext = zext i32 %tmp to i64 + %add = add nsw i64 %tmp.ext, 1 %add1 = add nsw i64 %val, 1 %tmp1 = inttoptr i64 %add1 to ptr %add.ptr2 = getelementptr inbounds i64, ptr %tmp1, i64 1 - %tmp2 = ptrtoint ptr %add.ptr2 to i64 - %arrayidx = getelementptr inbounds i64, ptr %A, i64 %tmp2 + %tmp2 = ptrtoaddr ptr %add.ptr2 to i32 + %tmp2.ext = zext i32 %tmp2 to i64 + %arrayidx = getelementptr inbounds i64, ptr %A, i64 %tmp2.ext %tmp3 = load i64, ptr %arrayidx %arrayidx3 = getelementptr inbounds i64, ptr %A, i64 %add %tmp4 = load i64, ptr %arrayidx3 diff --git a/polly/test/ScopInfo/int2ptr_ptr2int_2.ll b/polly/test/ScopInfo/int2ptr_ptr2int_2.ll index a88fcdc0f9b1..77293529e9cf 100644 --- a/polly/test/ScopInfo/int2ptr_ptr2int_2.ll +++ b/polly/test/ScopInfo/int2ptr_ptr2int_2.ll @@ -18,9 +18,6 @@ ; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0] ; CHECK-NEXT: [val, ptr] -> { Stmt_for_body[i0] -> MemRef_A[9 + ptr] }; -; IR: entry: -; IR-NEXT: %ptr13 = ptrtoint ptr %ptr to i16 -; ; IR: polly.stmt.for.body: ; IR-NEXT: %tmp4_p_scalar_ = load i64, ptr %scevgep, align 8, !alias.scope !5, !noalias !2 ; IR-NEXT: %p_add4 = add nsw i64 %tmp4_p_scalar_, %polly.preload.tmp3.merge @@ -30,10 +27,10 @@ ; IR-NEXT: br i1 %polly.loop_cond, label %polly.loop_header, label %polly.loop_exit ; IR: polly.loop_preheader: -; IR-NEXT: %41 = add i16 %val, 1 -; IR-NEXT: %42 = shl i16 %ptr13, 3 -; IR-NEXT: %43 = add i16 %42, 72 -; IR-NEXT: %scevgep = getelementptr i8, ptr %A, i16 %43 +; IR-NEXT: %{{[0-9]+}} = add i16 %val, 1 +; IR-NEXT: %[[SHL:[0-9]+]] = shl i16 %{{[0-9]+}}, 3 +; IR-NEXT: %[[ADD:[0-9]+]] = add i16 %[[SHL]], 72 +; IR-NEXT: %scevgep = getelementptr i8, ptr %A, i16 %[[ADD]] ; IR-NEXT: br label %polly.loop_header ; target datalayout = "e-p:16:16:16-m:e-i64:64-f80:128-n8:16:16:64-S128" @@ -49,12 +46,12 @@ for.cond: ; preds = %for.inc, %entry for.body: ; preds = %for.cond %add.ptr = getelementptr inbounds i64, ptr %ptr, i64 1 - %tmp = ptrtoint ptr %add.ptr to i16 + %tmp = ptrtoaddr ptr %add.ptr to i16 %add = add nsw i16 %tmp, 1 %add1 = add nsw i16 %val, 1 %tmp1 = inttoptr i16 %add1 to ptr %add.ptr2 = getelementptr inbounds i64, ptr %tmp1, i64 1 - %tmp2 = ptrtoint ptr %add.ptr2 to i16 + %tmp2 = ptrtoaddr ptr %add.ptr2 to i16 %arrayidx = getelementptr inbounds i64, ptr %B, i16 %tmp2 %tmp3 = load i64, ptr %arrayidx %arrayidx3 = getelementptr inbounds i64, ptr %A, i16 %add