[llvm] [polly] [SCEV] Use SCEVPtrToAddr instead of SCEVPtrToInt in SCEV. (PR #180244)
Florian Hahn via llvm-commits
llvm-commits at lists.llvm.org
Mon Jul 13 05:37:17 PDT 2026
https://github.com/fhahn updated https://github.com/llvm/llvm-project/pull/180244
>From 7e4ad10ea4803b1f34b7ceecc421b0504202eb80 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Mon, 13 Jul 2026 13:23:10 +0100
Subject: [PATCH 01/14] [GVN] Add more ptrtoaddr/ptrtoint tests: PRE and CFG
merging.
---
llvm/test/Transforms/GVN/ptrtoaddr.ll | 45 +++++++++++++++++++++++++++
1 file changed, 45 insertions(+)
diff --git a/llvm/test/Transforms/GVN/ptrtoaddr.ll b/llvm/test/Transforms/GVN/ptrtoaddr.ll
index a731ef433741a..359e16d0c39df 100644
--- a/llvm/test/Transforms/GVN/ptrtoaddr.ll
+++ b/llvm/test/Transforms/GVN/ptrtoaddr.ll
@@ -74,3 +74,48 @@ define i64 @ptrtoaddr_wrong_type(ptr %p) {
%r = add i64 %z, %a
ret i64 %r
}
+
+define i64 @ptrtoint_not_pred_from_ptrtoaddr(ptr %p, i1 %c) {
+; CHECK-LABEL: define i64 @ptrtoint_not_pred_from_ptrtoaddr(
+; CHECK-SAME: ptr [[P:%.*]], i1 [[C:%.*]]) {
+; CHECK-NEXT: [[A:%.*]] = ptrtoaddr ptr [[P]] to i64
+; CHECK-NEXT: br i1 [[C]], label %[[THEN:.*]], label %[[ELSE:.*]]
+; CHECK: [[THEN]]:
+; CHECK-NEXT: br label %[[MERGE:.*]]
+; CHECK: [[ELSE]]:
+; CHECK-NEXT: br label %[[MERGE]]
+; CHECK: [[MERGE]]:
+; CHECK-NEXT: [[I:%.*]] = ptrtoint ptr [[P]] to i64
+; CHECK-NEXT: ret i64 [[I]]
+;
+ %a = ptrtoaddr ptr %p to i64
+ br i1 %c, label %then, label %else
+
+then:
+ br label %merge
+
+else:
+ br label %merge
+
+merge:
+ %i = ptrtoint ptr %p to i64
+ ret i64 %i
+}
+
+define i64 @no_transitive_merge_of_ptrtoint_and_ptrtoaddr(ptr %p) {
+; CHECK-LABEL: define i64 @no_transitive_merge_of_ptrtoint_and_ptrtoaddr(
+; CHECK-SAME: ptr [[P:%.*]]) {
+; CHECK-NEXT: [[A:%.*]] = ptrtoaddr ptr [[P]] to i64
+; CHECK-NEXT: [[ADDA:%.*]] = add i64 [[A]], 7
+; CHECK-NEXT: [[I:%.*]] = ptrtoint ptr [[P]] to i64
+; CHECK-NEXT: [[ADDI:%.*]] = add i64 [[I]], 7
+; CHECK-NEXT: [[R:%.*]] = add i64 [[ADDA]], [[ADDI]]
+; CHECK-NEXT: ret i64 [[R]]
+;
+ %a = ptrtoaddr ptr %p to i64
+ %adda = add i64 %a, 7
+ %i = ptrtoint ptr %p to i64
+ %addi = add i64 %i, 7
+ %r = add i64 %adda, %addi
+ ret i64 %r
+}
>From b939de6736b44a242601679bf2c9a44b8102c05d Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Mon, 13 Jul 2026 13:27:56 +0100
Subject: [PATCH 02/14] [GVN] Reuse dominating PtrToInt for PtrToAddr.
A ptrtoaddr and a ptrtoint of the same pointer compute the same value
when the address width equals the pointer representation width. Reuse
a dominating ptrtoint in place of a ptrtoaddr.
This fixes a few end-to-end regressions with
https://github.com/llvm/llvm-project/pull/180244.
I am not sure if there's a better way to implement this. Initially I
tried to use the same numbering for PtrToInt and PtrToAddr, but then
there are multiple places where we need to check the direction is
correct, which seemed a bit more fragile.
---
llvm/lib/Transforms/Scalar/GVN.cpp | 24 ++++++++++++++++++++++++
llvm/test/Transforms/GVN/ptrtoaddr.ll | 3 +--
2 files changed, 25 insertions(+), 2 deletions(-)
diff --git a/llvm/lib/Transforms/Scalar/GVN.cpp b/llvm/lib/Transforms/Scalar/GVN.cpp
index 517d33bfba103..91939bb965a5c 100644
--- a/llvm/lib/Transforms/Scalar/GVN.cpp
+++ b/llvm/lib/Transforms/Scalar/GVN.cpp
@@ -3400,6 +3400,30 @@ bool GVNPass::processInstruction(Instruction *I) {
return false;
}
+ // A ptrtoaddr and a ptrtoint of the same pointer compute the same value when
+ // the address width equals the pointer representation width. Reuse a
+ // dominating ptrtoint in place of a ptrtoaddr.
+ if (auto *PTA = dyn_cast<PtrToAddrInst>(I)) {
+ const DataLayout &DL = I->getDataLayout();
+ unsigned AS = PTA->getPointerAddressSpace();
+ Value *Ptr = PTA->getPointerOperand();
+ if (DL.getAddressSizeInBits(AS) == DL.getPointerSizeInBits(AS) &&
+ !DL.hasUnstableRepresentation(AS) && Ptr->hasUseList()) {
+ unsigned Scanned = 0;
+ for (User *U : Ptr->users()) {
+ if (++Scanned >= ScanUsersLimit)
+ break;
+ auto *PTI = dyn_cast<PtrToIntInst>(U);
+ if (PTI && PTI->getType() == I->getType() && PTI != I &&
+ DT->dominates(PTI, I)) {
+ patchAndReplaceAllUsesWith(I, PTI);
+ salvageAndRemoveInstruction(I);
+ return true;
+ }
+ }
+ }
+ }
+
// If the number we were assigned was a brand new VN, then we don't
// need to do a lookup to see if the number already exists
// somewhere in the domtree: it can't!
diff --git a/llvm/test/Transforms/GVN/ptrtoaddr.ll b/llvm/test/Transforms/GVN/ptrtoaddr.ll
index 359e16d0c39df..c96961762194e 100644
--- a/llvm/test/Transforms/GVN/ptrtoaddr.ll
+++ b/llvm/test/Transforms/GVN/ptrtoaddr.ll
@@ -33,8 +33,7 @@ define i64 @ptrtoaddr_reuses_dominating_ptrtoint(ptr %p) {
; CHECK-LABEL: define i64 @ptrtoaddr_reuses_dominating_ptrtoint(
; CHECK-SAME: ptr [[P:%.*]]) {
; CHECK-NEXT: [[I:%.*]] = ptrtoint ptr [[P]] to i64
-; CHECK-NEXT: [[A:%.*]] = ptrtoaddr ptr [[P]] to i64
-; CHECK-NEXT: [[R:%.*]] = add i64 [[I]], [[A]]
+; CHECK-NEXT: [[R:%.*]] = add i64 [[I]], [[I]]
; CHECK-NEXT: ret i64 [[R]]
;
%i = ptrtoint ptr %p to i64
>From 9c7ab5d2db0b40085d036af136d5a98e112d8b84 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Fri, 16 Jan 2026 13:47:29 +0000
Subject: [PATCH 03/14] [SCEV] Use SCEVPtrToAddr instead of SCEVPtrToInt in
SCEV.
Use SCEVPtrToAddr instead of SCEVPtrToInt for pointer -> int
conversion in SCEV, like when computing trip count expressions.
getPtrToIntExpr now also creates SCEVPtrToAddrExpr.
I've left removal of SCEVPtrToIntExpr out of this PR, to limit the
scope. Removal will be done as NFC follow-up, or could be pulled into
this PR.
---
llvm/include/llvm/Analysis/ScalarEvolution.h | 1 -
llvm/lib/Analysis/ScalarEvolution.cpp | 83 +++-----
llvm/lib/Transforms/Utils/LoopUtils.cpp | 26 +--
.../Utils/ScalarEvolutionExpander.cpp | 8 +-
.../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 | 40 ++--
.../test/Analysis/ScalarEvolution/ptrtoint.ll | 184 +++++++++---------
.../trip-multiple-guard-info.ll | 36 ++--
.../IndVarSimplify/2011-11-01-lftrptr.ll | 12 +-
.../IndVarSimplify/pointer-loop-guards.ll | 4 +-
.../test/Transforms/IndVarSimplify/pr45835.ll | 12 +-
.../test/Transforms/IndVarSimplify/pr59633.ll | 2 +-
.../LoopIdiom/memset-debugify-remarks.ll | 4 +-
.../2013-01-14-ReuseCast.ll | 2 +-
.../X86/expander-crashes.ll | 2 +-
.../AArch64/apple-unrolling-multi-exit.ll | 8 +-
.../AArch64/unrolling-multi-exit.ll | 16 +-
.../LoopVectorize/AArch64/induction-costs.ll | 8 +-
.../AArch64/partial-reduce-constant-ops.ll | 28 +--
.../partial-reduce-incomplete-chains.ll | 4 +-
.../replicating-load-store-costs-apple.ll | 4 +-
.../AArch64/replicating-load-store-costs.ll | 4 +-
.../AArch64/sve-live-out-pointer-induction.ll | 4 +-
...-interleave-to-widen-memory-derived-ivs.ll | 12 +-
.../LoopVectorize/PowerPC/exit-branch-cost.ll | 4 +-
.../LoopVectorize/PowerPC/pr41179.ll | 4 +-
.../LoopVectorize/RISCV/pointer-induction.ll | 10 +-
.../VPlan/vplan-predicate-switch.ll | 4 +-
.../VPlan/vplan-printing-reductions.ll | 10 +-
.../VPlan/vplan-sink-scalars-and-merge.ll | 2 +-
.../WebAssembly/induction-branch-cost.ll | 4 +-
.../LoopVectorize/X86/cost-model.ll | 6 +-
.../X86/fold-tail-low-trip-count.ll | 4 +-
.../X86/interleave-opaque-pointers.ll | 4 +-
.../Transforms/LoopVectorize/X86/optsize.ll | 8 +-
.../Transforms/LoopVectorize/X86/pr48340.ll | 8 +-
.../Transforms/LoopVectorize/X86/pr72969.ll | 6 +-
.../LoopVectorize/X86/predicate-switch.ll | 48 ++---
.../epilog-vectorization-any-of-reductions.ll | 4 +-
.../epilog-vectorization-scev-expansion.ll | 14 +-
...aved-accesses-different-insert-position.ll | 4 +-
.../interleaved-accesses-metadata.ll | 14 +-
.../test/Transforms/LoopVectorize/metadata.ll | 16 +-
.../Transforms/LoopVectorize/opaque-ptr.ll | 30 ++-
.../LoopVectorize/pointer-induction.ll | 2 +-
llvm/test/Transforms/LoopVectorize/pr45259.ll | 4 +-
.../LoopVectorize/predicate-switch.ll | 8 +-
.../preserve-dbg-loc-and-loop-metadata.ll | 8 +-
.../LoopVectorize/runtime-check-known-true.ll | 2 +-
.../runtime-check-needed-but-empty.ll | 2 +-
.../LoopVectorize/scev-predicate-reasoning.ll | 11 +-
.../PhaseOrdering/AArch64/std-find.ll | 8 +-
.../X86/pr48844-br-to-switch-vectorization.ll | 4 +-
.../enable-loop-header-duplication-oz.ll | 4 +-
.../PhaseOrdering/scev-custom-dl.ll | 11 +-
polly/test/ScopInfo/int2ptr_ptr2int.ll | 13 +-
polly/test/ScopInfo/int2ptr_ptr2int_2.ll | 11 +-
70 files changed, 535 insertions(+), 607 deletions(-)
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
index 0a9a4370d5e80..be0799e4230fd 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -733,7 +733,6 @@ class ScalarEvolution {
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);
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 134be6ac097e0..6fbc8e414499f 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -1167,46 +1167,6 @@ class SCEVCastSinkingRewriter
}
};
-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<const SCEV *>(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,10 +1204,22 @@ 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<SCEVCouldNotCompute>(IntOp))
- return IntOp;
+ // 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 via ptrtoaddr 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();
+ const SCEV *IntOp = getPtrToAddrExpr(Op);
return getTruncateOrZeroExtend(IntOp, Ty);
}
@@ -5025,6 +4997,9 @@ const SCEV *ScalarEvolution::getPointerBase(const SCEV *V) {
}
assert(PtrOp && "Must have pointer op");
V = PtrOp;
+ } else if (auto *PtrToAddr = dyn_cast<SCEVPtrToAddrExpr>(V)) {
+ // Strip ptrtoaddr to continue extracting the base pointer.
+ V = PtrToAddr->getOperand();
} else // Not something we can look further into.
return V;
}
@@ -6310,7 +6285,7 @@ ScalarEvolution::createNodeForSelectOrPHIInstWithICmpInstCond(Type *Ty,
}
auto CoerceOperand = [&](const SCEV *Op) -> const SCEV * {
if (Op->getType()->isPointerTy()) {
- Op = getLosslessPtrToIntExpr(Op);
+ Op = getPtrToAddrExpr(Op);
if (isa<SCEVCouldNotCompute>(Op))
return Op;
}
@@ -9559,12 +9534,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<SCEVCouldNotCompute>(LHS))
return LHS;
}
if (RHS->getType()->isPointerTy()) {
- RHS = getLosslessPtrToIntExpr(RHS);
+ RHS = getPtrToAddrExpr(RHS);
if (isa<SCEVCouldNotCompute>(RHS))
return RHS;
}
@@ -9577,12 +9552,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<SCEVCouldNotCompute>(LHS))
return LHS;
}
if (RHS->getType()->isPointerTy()) {
- RHS = getLosslessPtrToIntExpr(RHS);
+ RHS = getPtrToAddrExpr(RHS);
if (isa<SCEVCouldNotCompute>(RHS))
return RHS;
}
@@ -13615,12 +13590,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<SCEVCouldNotCompute>(Start))
return Start;
}
if (RHS->getType()->isPointerTy()) {
- RHS = getLosslessPtrToIntExpr(RHS);
+ RHS = getPtrToAddrExpr(RHS);
if (isa<SCEVCouldNotCompute>(RHS))
return RHS;
}
@@ -13923,12 +13898,12 @@ ScalarEvolution::ExitLimit ScalarEvolution::howManyGreaterThans(
}
if (Start->getType()->isPointerTy()) {
- Start = getLosslessPtrToIntExpr(Start);
+ Start = getPtrToAddrExpr(Start);
if (isa<SCEVCouldNotCompute>(Start))
return Start;
}
if (End->getType()->isPointerTy()) {
- End = getLosslessPtrToIntExpr(End);
+ End = getPtrToAddrExpr(End);
if (isa<SCEVCouldNotCompute>(End))
return End;
}
@@ -16175,8 +16150,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<SCEVCouldNotCompute>(LHS) || isa<SCEVCouldNotCompute>(RHS))
break;
}
diff --git a/llvm/lib/Transforms/Utils/LoopUtils.cpp b/llvm/lib/Transforms/Utils/LoopUtils.cpp
index a2630c481a72e..d86d6138ed5f9 100644
--- a/llvm/lib/Transforms/Utils/LoopUtils.cpp
+++ b/llvm/lib/Transforms/Utils/LoopUtils.cpp
@@ -2250,24 +2250,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<SCEVPtrToAddrRewriter> {
- 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<PointerDiffInfo> Checks, SCEVExpander &Expander,
function_ref<Value *(IRBuilderBase &, unsigned)> GetVF, unsigned IC) {
@@ -2279,8 +2261,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<std::pair<Value *, Value *>, Value *> SeenCompares;
@@ -2300,10 +2280,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 125571b18dddc..9f85281d359d6 100644
--- a/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp
+++ b/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp
@@ -1268,8 +1268,7 @@ Value *SCEVExpander::tryToReuseLCSSAPhi(SCEVUseT<const SCEVAddRecExpr *> 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<SCEVConstant, SCEVUnknown>(Op))
return nullptr;
return Diff;
@@ -1285,13 +1284,8 @@ Value *SCEVExpander::tryToReuseLCSSAPhi(SCEVUseT<const SCEVAddRecExpr *> 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);
}
diff --git a/llvm/test/Analysis/LoopAccessAnalysis/runtime-check-known-true.ll b/llvm/test/Analysis/LoopAccessAnalysis/runtime-check-known-true.ll
index 30c80880024bb..6ff9f124fa066 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 7120eec5982e9..03d8dcdb683ad 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %for.cond: Variant }
+; CHECK-NEXT: --> (ptrtoaddr ptr %load1 to i64) U: full-set S: full-set Exits: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %for.cond: Variant }
+; CHECK-NEXT: --> ((-1 * (ptrtoaddr ptr @b to i64)) + (ptrtoaddr ptr %load1 to i64)) U: full-set S: full-set Exits: <<Unknown>> 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: <<Unknown>> 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 d4e00c69dcf64..5c9e4e1a87abe 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: --> (ptrtoaddr ptr %alloca to i64) U: [4,-7) 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: --> (ptrtoaddr ptr addrspace(1) %alloca to i64) U: [0,-7) 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 77642f0c3f1ee..f21c8aaa368c1 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: <<Unknown>> 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: --> (ptrtoaddr ptr %ptr to i64) U: full-set S: full-set
; CHECK-NEXT: %r = add i64 %i, %ptr.int
-; CHECK-NEXT: --> {(ptrtoint ptr %ptr to i64),+,1}<nw><%loop> U: full-set S: full-set --> ((%n umin_seq %m) + (ptrtoint ptr %ptr to i64)) U: full-set S: full-set
+; CHECK-NEXT: --> {(ptrtoaddr ptr %ptr to i64),+,1}<%loop> U: full-set S: full-set --> ((%n umin_seq %m) + (ptrtoaddr ptr %ptr to i64)) 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 f7ebfbbd50ca8..ce899726d44cd 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}<nuw><%loop> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %p to i64)) + (ptrtoint ptr %end to i64)) /u 4))<nuw> + %p) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {%p,+,4}<nuw><%loop> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %p to i64)) + (ptrtoaddr ptr %end to i64)) /u 4))<nuw> + %p) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.next = getelementptr inbounds i32, ptr %iv, i64 1
-; CHECK-NEXT: --> {(4 + %p)<nuw>,+,4}<nuw><%loop> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %p to i64)) + (ptrtoint ptr %end to i64)) /u 4))<nuw> + %p) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {(4 + %p)<nuw>,+,4}<nuw><%loop> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-4 + (-1 * (ptrtoaddr ptr %p to i64)) + (ptrtoaddr ptr %end to i64)) /u 4))<nuw> + %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}<nw><%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}<nw><%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}<nw><%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}<nw><%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}<nuw><%loop> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %p to i64)) + (ptrtoint ptr %end to i64)) /u 4))<nuw> + %p) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {%p,+,4}<nuw><%loop> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %p to i64)) + (ptrtoaddr ptr %end to i64)) /u 4))<nuw> + %p) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.next = getelementptr nusw i32, ptr %iv, i64 1
-; CHECK-NEXT: --> {(4 + %p)<nuw>,+,4}<nuw><%loop> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %p to i64)) + (ptrtoint ptr %end to i64)) /u 4))<nuw> + %p) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {(4 + %p)<nuw>,+,4}<nuw><%loop> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-4 + (-1 * (ptrtoaddr ptr %p to i64)) + (ptrtoaddr ptr %end to i64)) /u 4))<nuw> + %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}<nw><%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}<nw><%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}<nw><%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}<nw><%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 bab3a28d1e8a4..0ed2ab0b647b4 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)<nuw><nsw>,+,-1}<nw><%while.cond111> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %while.cond111: Computable, %while.body: Uniform }
; CHECK-NEXT: %lastout.2271 = phi ptr [ %incdec.ptr126, %while.body125 ], [ %ptr, %while.end117 ]
-; CHECK-NEXT: --> {%ptr,+,1}<nuw><%while.body125> U: full-set S: full-set Exits: {(-2 + (-1 * (ptrtoint ptr %ptr to i64)) + %ptr),+,-1}<nw><%while.cond111> LoopDispositions: { %while.body125: Computable }
+; CHECK-NEXT: --> {%ptr,+,1}<nuw><%while.body125> U: full-set S: full-set Exits: {(-2 + (-1 * (ptrtoaddr ptr %ptr to i64)) + %ptr),+,-1}<nw><%while.cond111> LoopDispositions: { %while.body125: Computable }
; CHECK-NEXT: %incdec.ptr126 = getelementptr inbounds i8, ptr %lastout.2271, i64 1
-; CHECK-NEXT: --> {(1 + %ptr),+,1}<nuw><%while.body125> U: full-set S: full-set Exits: {(-1 + (-1 * (ptrtoint ptr %ptr to i64)) + %ptr),+,-1}<nw><%while.cond111> LoopDispositions: { %while.body125: Computable }
+; CHECK-NEXT: --> {(1 + %ptr),+,1}<nuw><%while.body125> U: full-set S: full-set Exits: {(-1 + (-1 * (ptrtoaddr ptr %ptr to i64)) + %ptr),+,-1}<nw><%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}<nw><%while.cond111>
+; CHECK-NEXT: Loop %while.body125: backedge-taken count is {(-2 + (-1 * (ptrtoaddr ptr %ptr to i64))),+,-1}<nw><%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}<nw><%while.cond111>
+; CHECK-NEXT: Loop %while.body125: symbolic max backedge-taken count is {(-2 + (-1 * (ptrtoaddr ptr %ptr to i64))),+,-1}<nw><%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}<nuw><%loop> U: full-set S: full-set Exits: ((8 * ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8))<nuw> + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {%a,+,8}<nuw><%loop> U: full-set S: full-set Exits: ((8 * ((-8 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 8))<nuw> + %a) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8
-; CHECK-NEXT: --> {(8 + %a),+,8}<nuw><%loop> U: full-set S: full-set Exits: (8 + (8 * ((-8 + (-1 * (ptrtoint ptr %a to i64)) + (ptrtoint ptr %b to i64)) /u 8))<nuw> + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {(8 + %a),+,8}<nuw><%loop> U: full-set S: full-set Exits: (8 + (8 * ((-8 + (-1 * (ptrtoaddr ptr %a to i64)) + (ptrtoaddr ptr %b to i64)) /u 8))<nuw> + %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: <multiple exits> 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: <multiple exits> 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: <multiple exits> 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: <multiple exits> 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 220c5a1deb1a0..f808f5351dc30 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 b096adc7c5eb4..ba3ad4cbd1866 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: --> (trunc i64 (ptrtoaddr ptr @z_addr to i64) to i32) 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 + (trunc i64 (ptrtoaddr ptr @z_addr to i64) to i32)) 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))<nuw><nsw> U: [1,4294967294) S: [1,4294967297)
+; CHECK-NEXT: --> (1 + (zext i32 (4 + (trunc i64 (ptrtoaddr ptr @z_addr to i64) to i32)) to i64))<nuw><nsw> 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: --> (trunc i64 (ptrtoaddr ptr @z_addr_noalign to i64) to i32) 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 + (trunc i64 (ptrtoaddr ptr @z_addr_noalign to i64) to i32)) 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 + (trunc i64 (ptrtoaddr ptr @z_addr_noalign to i64) to i32)) 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 e13a8976bf5ac..85c213c7ab090 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)<nuw> U: [8000,0) S: [8000,0)
; CHECK-NEXT: %iv = phi ptr [ %init, %entry ], [ %iv.next, %loop ]
-; CHECK-NEXT: --> {(8000 + %startptr)<nuw>,+,4}<nuw><%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))<nuw> + %startptr) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {(8000 + %startptr)<nuw>,+,4}<nuw><%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))<nuw> + %startptr) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.next = getelementptr inbounds i32, ptr %iv, i64 1
-; CHECK-NEXT: --> {(8004 + %startptr),+,4}<nuw><%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))<nuw> + %startptr) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {(8004 + %startptr),+,4}<nuw><%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))<nuw> + %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 4d668d1ffef11..c529f9e39a13d 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}<nuw><%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))<nuw> + %begin) LoopDispositions: { %for.body.i.i: Computable }
+; CHECK-NEXT: --> {%begin,+,4}<nuw><%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))<nuw> + %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}<nuw><%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))<nuw> + %begin) LoopDispositions: { %for.body.i.i: Computable }
+; CHECK-NEXT: --> {(4 + %begin),+,4}<nuw><%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))<nuw> + %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}<nuw><nsw><%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}<nuw><nsw><%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}<nuw><nsw><%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))<nuw><nsw> LoopDispositions: { %for.body.i.i: Computable }
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%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))<nuw><nsw> LoopDispositions: { %for.body.i.i: Computable }
; CHECK-NEXT: %ptrincdec.i.i = getelementptr inbounds i32, ptr %begin, i64 %tmp
-; CHECK-NEXT: --> {(4 + %begin),+,4}<nuw><%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))<nuw> + %begin) LoopDispositions: { %for.body.i.i: Computable }
+; CHECK-NEXT: --> {(4 + %begin),+,4}<nuw><%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))<nuw> + %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}<nuw><%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))<nuw> + %begin) LoopDispositions: { %for.body.i.i: Computable }
+; CHECK-NEXT: --> {%begin,+,4}<nuw><%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))<nuw> + %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}<nuw><%bb2> U: full-set S: full-set Exits: ((4 * ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64))<nuw> umax (ptrtoint ptr %arg1 to i64))) /u 4))<nuw> + %arg) LoopDispositions: { %bb2: Computable }
+; CHECK-NEXT: --> {%arg,+,4}<nuw><%bb2> U: full-set S: full-set Exits: ((4 * ((-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + ((4 + (ptrtoaddr ptr %arg to i64))<nuw> umax (ptrtoaddr ptr %arg1 to i64))) /u 4))<nuw> + %arg) LoopDispositions: { %bb2: Computable }
; CHECK-NEXT: %tmp4 = getelementptr inbounds i32, ptr %tmp, i64 1
-; CHECK-NEXT: --> {(4 + %arg)<nuw>,+,4}<nuw><%bb2> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64))<nuw> umax (ptrtoint ptr %arg1 to i64))) /u 4))<nuw> + %arg) LoopDispositions: { %bb2: Computable }
+; CHECK-NEXT: --> {(4 + %arg)<nuw>,+,4}<nuw><%bb2> U: [4,0) S: [4,0) Exits: (4 + (4 * ((-1 + (-1 * (ptrtoaddr ptr %arg to i64)) + ((4 + (ptrtoaddr ptr %arg to i64))<nuw> umax (ptrtoaddr ptr %arg1 to i64))) /u 4))<nuw> + %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))<nuw> 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))<nuw> 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))<nuw> 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))<nuw> 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 6d6143367756e..339435e6beb74 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: --> (ptrtoaddr ptr %obj to i64) 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 (ptrtoaddr ptr %obj to i64) 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))<nsw> U: [-15,1) S: [-15,1)
+; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj to i64) to i4) to i64))<nsw> 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))<nsw> + %obj) U: full-set S: full-set
+; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj to i64) to i4) to i64))<nsw> + %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: --> (ptrtoaddr ptr %obj_donor to i64) 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 (ptrtoaddr ptr %obj_donor to i64) 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))<nsw> U: [-15,1) S: [-15,1)
+; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> 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))<nsw> + %obj_to_align) U: full-set S: full-set
+; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> + %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: --> (ptrtoaddr ptr %obj to i64) 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 + (ptrtoaddr ptr %obj to i64)) 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))<nuw> U: [0,-15) S: [-9223372036854775808,9223372036854775793)
+; CHECK-NEXT: --> (16 * ((15 + (ptrtoaddr ptr %obj to i64)) /u 16))<nuw> 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))<nuw> + (-1 * (ptrtoint ptr %obj to i64))) U: full-set S: full-set
+; CHECK-NEXT: --> ((16 * ((15 + (ptrtoaddr ptr %obj to i64)) /u 16))<nuw> + (-1 * (ptrtoaddr ptr %obj to i64))) 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))<nuw> + (-1 * (ptrtoint ptr %obj to i64)) + %obj) U: full-set S: full-set
+; CHECK-NEXT: --> ((16 * ((15 + (ptrtoaddr ptr %obj to i64)) /u 16))<nuw> + (-1 * (ptrtoaddr ptr %obj to i64)) + %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: --> (ptrtoaddr ptr %obj_donor to i64) 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 + (ptrtoaddr ptr %obj_donor to i64)) 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))<nuw> U: [0,-15) S: [-9223372036854775808,9223372036854775793)
+; CHECK-NEXT: --> (16 * ((15 + (ptrtoaddr ptr %obj_donor to i64)) /u 16))<nuw> 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))<nuw> + (-1 * (ptrtoint ptr %obj_donor to i64))) U: full-set S: full-set
+; CHECK-NEXT: --> ((16 * ((15 + (ptrtoaddr ptr %obj_donor to i64)) /u 16))<nuw> + (-1 * (ptrtoaddr ptr %obj_donor to i64))) 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))<nuw> + (-1 * (ptrtoint ptr %obj_donor to i64)) + %obj_to_align) U: full-set S: full-set
+; CHECK-NEXT: --> ((16 * ((15 + (ptrtoaddr ptr %obj_donor to i64)) /u 16))<nuw> + (-1 * (ptrtoaddr ptr %obj_donor to i64)) + %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: --> (ptrtoaddr ptr %obj to i64) 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 (ptrtoaddr ptr %obj to i64) 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))<nsw> U: [-15,1) S: [-15,1)
+; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj to i64) to i4) to i64))<nsw> 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))<nsw> + %obj) U: full-set S: full-set
+; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj to i64) to i4) to i64))<nsw> + %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))<nsw> + %obj) U: full-set S: full-set
+; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj to i64) to i4) to i64))<nsw> + %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: --> (ptrtoaddr ptr %obj_donor to i64) 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 (ptrtoaddr ptr %obj_donor to i64) 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))<nsw> U: [-15,1) S: [-15,1)
+; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> 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))<nsw> + %obj_to_align) U: full-set S: full-set
+; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> + %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))<nsw> + %obj_to_align) U: full-set S: full-set
+; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> + %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: --> (ptrtoaddr ptr %obj_donor to i64) 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 (ptrtoaddr ptr %obj_donor to i64) 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))<nsw> U: [-15,1) S: [-15,1)
+; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> 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))<nsw> + %second_obj) U: full-set S: full-set
+; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> + %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))<nsw> + %second_obj) U: full-set S: full-set
+; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> + %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 89cc110a45df4..7e9bba49f278e 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 1805b983c8e2e..c408a111c5679 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: <multiple exits> 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 d92056b9ffdd8..99a45def1ba8b 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: <<Unknown>> 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: --> ((ptrtoaddr ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: --> ((ptrtoaddr ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: <<Unknown>> 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: <<Unknown>> 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: --> ((ptrtoaddr ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr ptr @global 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: --> ((ptrtoaddr ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr ptr @global 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: <<Unknown>> 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: <<Unknown>> 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 (trunc i64 (ptrtoaddr ptr @global to i64) to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 (trunc i64 (ptrtoaddr ptr @global to i64) 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 (trunc i64 (ptrtoaddr ptr @global to i64) to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 (trunc i64 (ptrtoaddr ptr @global to i64) 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: <<Unknown>> 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: <<Unknown>> 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: --> ((ptrtoaddr ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr ptr @global 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: --> ((ptrtoaddr ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr ptr @global 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: <<Unknown>> 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: <<Unknown>> 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: --> ((ptrtoaddr ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: --> ((ptrtoaddr ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: <<Unknown>> 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: <<Unknown>> 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: --> ((ptrtoaddr ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr ptr @global 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: --> ((ptrtoaddr ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr ptr @global 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: <<Unknown>> 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 * (trunc i64 (ptrtoaddr ptr @global to i64) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (trunc i64 (ptrtoaddr ptr @global to i64) 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: <<Unknown>> 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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (zext i16 (ptrtoint ptr @global to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
+; PTR16_IDX16-NEXT: --> ((-1 * (zext i16 (ptrtoaddr ptr @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (zext i16 (ptrtoaddr ptr @global to i16) to i32))<nsw> + %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: <<Unknown>> 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 (trunc i64 (ptrtoaddr ptr @global to i64) to i16) to i32) U: [-32768,32768) S: [-32768,32768) Exits: (sext i16 (trunc i64 (ptrtoaddr ptr @global to i64) 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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (trunc i64 (ptrtoint ptr @global to i64) to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
+; PTR64_IDX64-NEXT: --> ((-1 * (sext i16 (trunc i64 (ptrtoaddr ptr @global to i64) to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (trunc i64 (ptrtoaddr ptr @global to i64) to i16) to i32))<nsw> + %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: <<Unknown>> 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 (ptrtoaddr ptr @global to i16) to i32) U: [-32768,32768) S: [-32768,32768) Exits: (sext i16 (ptrtoaddr 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))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (ptrtoint ptr @global to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
+; PTR16_IDX16-NEXT: --> ((-1 * (sext i16 (ptrtoaddr ptr @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (ptrtoaddr ptr @global to i16) to i32))<nsw> + %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: <<Unknown>> 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}<nuw><%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}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (-1 + (trunc i64 (ptrtoaddr ptr @sext_like_noop to i64) 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}<nuw><%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}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + (trunc i64 (ptrtoaddr ptr @sext_like_noop to i64) to i32)) LoopDispositions: { %for.body: Computable }
; PTR64_IDX64-NEXT: %inc = add nuw i32 %i, 1
-; PTR64_IDX64-NEXT: --> {2,+,1}<nuw><%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}<nuw><%for.body> U: [2,0) S: [2,0) Exits: (trunc i64 (ptrtoaddr ptr @sext_like_noop to i64) 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 + (trunc i64 (ptrtoaddr ptr @sext_like_noop to i64) 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 + (trunc i64 (ptrtoaddr ptr @sext_like_noop to i64) 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}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i64))<nsw> U: [-1,65535) S: [-1,65535)
+; PTR16_IDX16-NEXT: --> (sext i32 {1,+,1}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i16 (ptrtoaddr ptr @sext_like_noop to i16) to i64))<nsw> 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}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32))<nsw> LoopDispositions: { %for.body: Computable }
+; PTR16_IDX16-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + (zext i16 (ptrtoaddr ptr @sext_like_noop to i16) to i32))<nsw> LoopDispositions: { %for.body: Computable }
; PTR16_IDX16-NEXT: %inc = add nuw i32 %i, 1
-; PTR16_IDX16-NEXT: --> {2,+,1}<nuw><%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}<nuw><%for.body> U: [2,0) S: [2,0) Exits: (zext i16 (ptrtoaddr ptr @sext_like_noop to i16) 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))<nsw>
+; PTR16_IDX16-NEXT: Loop %for.body: backedge-taken count is (-2 + (zext i16 (ptrtoaddr ptr @sext_like_noop to i16) to i32))<nsw>
; 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))<nsw>
+; PTR16_IDX16-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + (zext i16 (ptrtoaddr ptr @sext_like_noop to i16) to i32))<nsw>
; 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 6eb0d2014a32e..592d87c7ea5a9 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))<nuw> U: [7,0) S: [5,0)
+; CHECK-NEXT: --> (5 + (ptrtoaddr ptr @glob.i32.align2 to i64))<nuw> U: [7,0) S: [5,0)
; 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 + (ptrtoaddr 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))<nuw><nsw> U: [15,0) S: [-9223372036854775801,-9223372036854775808)
+; CHECK-NEXT: --> (7 + (ptrtoaddr ptr @glob.i32.align8 to i64))<nuw><nsw> U: [15,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 + (ptrtoaddr 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))<nuw><nsw> U: [31,0) S: [-9223372036854775793,-9223372036854775808)
+; CHECK-NEXT: --> (15 + (ptrtoaddr ptr @glob.i32.align16 to i64))<nuw><nsw> U: [31,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 + (ptrtoaddr 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))<nuw> U: [32,-15) S: [-9223372036854775808,9223372036854775793)
+; CHECK-NEXT: --> (16 + (ptrtoaddr ptr @array4xi32 to i64))<nuw> U: [32,-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))<nuw> U: [47,0) S: [31,0)
+; CHECK-NEXT: --> (31 + (ptrtoaddr ptr @array4xi32 to i64))<nuw> U: [47,0) S: [31,0)
; 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 + (ptrtoaddr 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 + (ptrtoaddr ptr @array4xi32 to i64)) U: [49,2) S: [-9223372036854775775,-9223372036854775790)
; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_16_size_16_add_33
;
entry:
@@ -130,11 +130,11 @@ 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))<nuw> U: [32,-15) S: [-9223372036854775808,9223372036854775793)
+; CHECK-NEXT: --> (16 + (ptrtoaddr ptr @array4xi32 to i64))<nuw> U: [32,-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))<nuw> U: [32,-15) S: [-9223372036854775808,9223372036854775793)
+; CHECK-NEXT: --> (16 + (ptrtoaddr ptr @array4xi32 to i64))<nuw> U: [32,-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: --> (32 + (ptrtoaddr 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: Determining loop execution counts for: @ptrtoint_align_16_size_16_add_16_umax_sub
@@ -151,11 +151,11 @@ 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))<nuw> U: [47,0) S: [31,0)
+; CHECK-NEXT: --> (31 + (ptrtoaddr ptr @array4xi32 to i64))<nuw> U: [47,0) S: [31,0)
; 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))<nuw> U: [47,0) S: [31,0)
+; CHECK-NEXT: --> (31 + (ptrtoaddr ptr @array4xi32 to i64))<nuw> U: [47,0) S: [31,0)
; CHECK-NEXT: %add = add i64 %umax, 16
-; CHECK-NEXT: --> (47 + (ptrtoint ptr @array4xi32 to i64)) U: [63,16) S: [-9223372036854775761,-9223372036854775776)
+; CHECK-NEXT: --> (47 + (ptrtoaddr ptr @array4xi32 to i64)) U: [63,16) S: [-9223372036854775761,-9223372036854775776)
; CHECK-NEXT: %sub = sub i64 %add, ptrtoint (ptr @array4xi32 to i64)
; CHECK-NEXT: --> 47 U: [47,48) S: [47,48)
; CHECK-NEXT: Determining loop execution counts for: @ptrtoint_align_16_size_16_add_31_umax_sub
@@ -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 + (ptrtoaddr 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 + (ptrtoaddr ptr @array4xi32 to i64)) umax (ptrtoaddr ptr @array4xi32 to i64)) U: [16,-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 + (ptrtoaddr ptr @array4xi32 to i64)) umax (ptrtoaddr 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 * (ptrtoaddr ptr @array4xi32 to i64)) + ((32 + (ptrtoaddr ptr @array4xi32 to i64)) umax (ptrtoaddr 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.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
index 2b07c944eb1d1..4c152649c0342 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: --> (ptrtoaddr ptr %in to i64) 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: --> (trunc i64 (ptrtoaddr ptr %in to i64) to i32) 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: --> (trunc i64 (ptrtoaddr ptr %in to i64) to i16) 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: --> (zext i64 (ptrtoaddr ptr %in to i64) to i128) 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: --> (zext i32 (ptrtoaddr ptr %in to i32) to i64) 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: --> (ptrtoaddr ptr %in to i32) 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: --> (trunc i32 (ptrtoaddr ptr %in to i32) to i16) 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: --> (zext i32 (ptrtoaddr ptr %in to i32) to i128) 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: --> (ptrtoaddr ptr addrspace(1) %in to i64) 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: --> (trunc i64 (ptrtoaddr ptr addrspace(1) %in to i64) to i32) 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: --> (trunc i64 (ptrtoaddr ptr addrspace(1) %in to i64) to i16) 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: --> (zext i64 (ptrtoaddr ptr addrspace(1) %in to i64) to i128) 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: --> (zext i32 (ptrtoaddr ptr addrspace(1) %in to i32) to i64) 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: --> (ptrtoaddr ptr addrspace(1) %in to i32) 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: --> (trunc i32 (ptrtoaddr ptr addrspace(1) %in to i32) to i16) 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: --> (zext i32 (ptrtoaddr ptr addrspace(1) %in to i32) to i128) 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: --> (ptrtoaddr ptr %in to i64) 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: --> (zext i32 (ptrtoaddr ptr %in to i32) to i64) 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: --> (ptrtoaddr ptr addrspace(1) %in_casted to i64) 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: --> (zext i32 (ptrtoaddr ptr addrspace(1) %in_casted to i32) to i64) 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: --> (ptrtoaddr ptr %in_casted to i64) 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: --> (zext i32 (ptrtoaddr ptr %in_casted to i32) to i64) U: [0,4294967296) S: [0,4294967296)
; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_inttoptr
;
%in_casted = inttoptr i64 %in to ptr
@@ -173,13 +173,13 @@ 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: --> (ptrtoaddr 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: --> (zext i32 (ptrtoaddr 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
;
%p0 = ptrtoint ptr inttoptr (i64 42 to ptr) to i64
@@ -194,7 +194,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 +202,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: --> (zext i32 (42 + (ptrtoaddr ptr %in to i32)) to i64) 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 +224,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))<nuw><nsw> + %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))<nuw><nsw> + (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))<nuw><nsw> + (ptrtoaddr ptr %in to i64)) LoopDispositions: { %loop: Computable }
; X64-NEXT: %i9 = add nuw nsw i64 %i6, 1
; X64-NEXT: --> {1,+,1}<nuw><%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 +242,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: --> (zext i32 {(ptrtoaddr ptr %in to i32),+,4}<%loop> to i64) U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (-4 + (4 * %count) + (ptrtoaddr ptr %in to i32)) to i64) LoopDispositions: { %loop: Computable }
; X32-NEXT: %i9 = add nuw nsw i64 %i6, 1
; X32-NEXT: --> {1,+,1}<nuw><%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 +276,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 +284,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: --> ((zext i32 (ptrtoaddr ptr %in0 to i32) to i64) umax (zext i32 (ptrtoaddr ptr %in1 to i32) to i64)) U: [0,4294967296) S: [0,4294967296)
; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_umax
;
%c = icmp uge ptr %in0, %in1
@@ -300,7 +300,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 +308,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: --> (zext i32 ((ptrtoaddr ptr %in0 to i32) smax (ptrtoaddr ptr %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296)
; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_smax
;
%c = icmp sge ptr %in0, %in1
@@ -324,7 +324,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 +332,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: --> ((zext i32 (ptrtoaddr ptr %in0 to i32) to i64) umin (zext i32 (ptrtoaddr ptr %in1 to i32) to i64)) U: [0,4294967296) S: [0,4294967296)
; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_umin
;
%c = icmp ule ptr %in0, %in1
@@ -348,7 +348,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 +356,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: --> (zext i32 ((ptrtoaddr ptr %in0 to i32) smin (ptrtoaddr ptr %in1 to i32)) to i64) U: [0,4294967296) S: [0,4294967296)
; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_smin
;
%c = icmp sle ptr %in0, %in1
@@ -374,53 +374,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: --> (ptrtoaddr ptr %arg to i64) U: full-set S: full-set
; X64-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i14, %bb6 ]
-; X64-NEXT: --> {%arg,+,1}<nuw><%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}<nuw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X64-NEXT: --> {(ptrtoint ptr %arg to i64),+,1}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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}<nw><%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}<nw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i13 = add i8 %i12, %i8
; X64-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i14 = getelementptr inbounds i8, ptr %i7, i64 1
-; X64-NEXT: --> {(1 + %arg),+,1}<nuw><%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}<nuw><%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: --> (zext i32 (ptrtoaddr ptr %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296)
; X32-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i14, %bb6 ]
-; X32-NEXT: --> {%arg,+,1}<nuw><%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}<nuw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X32-NEXT: --> {(zext i32 (ptrtoint ptr %arg to i32) to i64),+,1}<nuw><%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: --> {(zext i32 (ptrtoaddr ptr %arg to i32) to i64),+,1}<nuw><%bb6> U: [0,8589934590) S: [0,8589934590) Exits: ((zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) + (zext i32 (ptrtoaddr ptr %arg to i32) to i64)) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i10 = sub i64 %i9, %i4
-; X32-NEXT: --> {0,+,1}<nuw><%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: --> {0,+,1}<nuw><%bb6> U: [0,4294967295) S: [0,4294967295) Exits: (zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10
-; X32-NEXT: --> {%arg2,+,1}<nw><%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: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32) + %arg2) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i12 = load i8, ptr %i11, align 1
; X32-NEXT: --> %i12 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i13 = add i8 %i12, %i8
; X32-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i14 = getelementptr inbounds i8, ptr %i7, i64 1
-; X32-NEXT: --> {(1 + %arg),+,1}<nuw><%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}<nuw><%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 +451,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: --> (ptrtoaddr ptr %arg to i64) U: full-set S: full-set
; X64-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i14, %bb6 ]
-; X64-NEXT: --> {%arg,+,1}<nuw><%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}<nuw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X64-NEXT: --> {(ptrtoint ptr %arg to i64),+,1}<nuw><%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}<nuw><%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}<nuw><%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}<nuw><%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}<nw><%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}<nw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i13 = add i8 %i12, %i8
; X64-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i14 = getelementptr inbounds i8, ptr %i7, i64 1
-; X64-NEXT: --> {(1 + %arg),+,1}<nuw><%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}<nuw><%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: --> (zext i32 (ptrtoaddr ptr %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296)
; X32-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i14, %bb6 ]
-; X32-NEXT: --> {%arg,+,1}<nuw><%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}<nuw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X32-NEXT: --> {(zext i32 (ptrtoint ptr %arg to i32) to i64),+,1}<nuw><%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: --> {(zext i32 (ptrtoaddr ptr %arg to i32) to i64),+,1}<nuw><%bb6> U: [0,8589934590) S: [0,8589934590) Exits: ((zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) + (zext i32 (ptrtoaddr ptr %arg to i32) to i64)) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i10 = sub i64 %i9, %i4
-; X32-NEXT: --> {0,+,1}<nuw><%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: --> {0,+,1}<nuw><%bb6> U: [0,4294967295) S: [0,4294967295) Exits: (zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10
-; X32-NEXT: --> {%arg2,+,1}<nw><%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: --> {%arg2,+,1}<%bb6> U: full-set S: full-set Exits: (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32) + %arg2) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i12 = load i8, ptr %i11, align 1
; X32-NEXT: --> %i12 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i13 = add i8 %i12, %i8
; X32-NEXT: --> (%i12 + %i8) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i14 = getelementptr inbounds i8, ptr %i7, i64 1
-; X32-NEXT: --> {(1 + %arg),+,1}<nuw><%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}<nuw><%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 +535,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: --> (ptrtoaddr ptr %arg to i64) U: full-set S: full-set
; X64-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i15, %bb6 ]
-; X64-NEXT: --> {%arg,+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
+; X64-NEXT: --> {%arg,+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
; X64-NEXT: %i8 = load i32, ptr %i7, align 4
; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X64-NEXT: --> {(ptrtoint ptr %arg to i64),+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4))<nuw> + (ptrtoint ptr %arg to i64)) LoopDispositions: { %bb6: Computable }
+; X64-NEXT: --> {(ptrtoaddr ptr %arg to i64),+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4))<nuw> + (ptrtoaddr ptr %arg to i64)) LoopDispositions: { %bb6: Computable }
; X64-NEXT: %i10 = sub i64 %i9, %i4
-; X64-NEXT: --> {0,+,4}<nuw><%bb6> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4))<nuw> LoopDispositions: { %bb6: Computable }
+; X64-NEXT: --> {0,+,4}<nuw><%bb6> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4))<nuw> LoopDispositions: { %bb6: Computable }
; X64-NEXT: %i11 = ashr exact i64 %i10, 2
; X64-NEXT: --> %i11 U: [-2305843009213693952,2305843009213693952) S: [-2305843009213693952,2305843009213693952) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i12 = getelementptr inbounds i32, ptr %arg2, i64 %i11
@@ -553,25 +553,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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i15 = getelementptr inbounds i32, ptr %i7, i64 1
-; X64-NEXT: --> {(4 + %arg),+,4}<nuw><%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
+; X64-NEXT: --> {(4 + %arg),+,4}<nuw><%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4))<nuw> + %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: --> (zext i32 (ptrtoaddr ptr %arg to i32) to i64) U: [0,4294967296) S: [0,4294967296)
; X32-NEXT: %i7 = phi ptr [ %arg, %bb3 ], [ %i15, %bb6 ]
-; X32-NEXT: --> {%arg,+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> {%arg,+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i8 = load i32, ptr %i7, align 4
; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X32-NEXT: --> {(zext i32 (ptrtoint ptr %arg to i32) to i64),+,4}<nuw><%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))<nuw><nsw>) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> {(zext i32 (ptrtoaddr ptr %arg to i32) to i64),+,4}<nuw><%bb6> U: [0,8589934588) S: [0,8589934588) Exits: ((zext i32 (ptrtoaddr ptr %arg to i32) to i64) + (4 * ((zext i32 (-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) /u 4))<nuw><nsw>) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i10 = sub i64 %i9, %i4
-; X32-NEXT: --> {0,+,4}<nuw><%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))<nuw><nsw> LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> {0,+,4}<nuw><%bb6> U: [0,4294967293) S: [0,4294967293) Exits: (4 * ((zext i32 (-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) /u 4))<nuw><nsw> LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i11 = ashr exact i64 %i10, 2
; X32-NEXT: --> %i11 U: [-2147483648,2147483648) S: [-2147483648,2147483648) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i12 = getelementptr inbounds i32, ptr %arg2, i64 %i11
@@ -581,11 +581,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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i15 = getelementptr inbounds i32, ptr %i7, i64 1
-; X32-NEXT: --> {(4 + %arg),+,4}<nuw><%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> {(4 + %arg),+,4}<nuw><%bb6> U: full-set S: full-set Exits: (4 + (4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) /u 4))<nuw> + %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 +619,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: --> (ptrtoaddr ptr %arg to i64) 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) + (ptrtoaddr ptr %arg to i64)) U: full-set S: full-set
; X64-NEXT: %i9 = phi i64 [ 1, %bb7 ], [ %i11, %bb10 ]
; X64-NEXT: --> {1,+,1}<nuw><%bb8> U: [1,0) S: [1,0) Exits: <<Unknown>> LoopDispositions: { %bb8: Computable }
; X64-NEXT: %i11 = add nuw i64 %i9, 1
@@ -629,18 +629,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: <multiple exits> 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) + (ptrtoaddr ptr %arg to i64))
; 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) + (ptrtoaddr ptr %arg to i64))
; 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) + (ptrtoaddr ptr %arg to i64))
;
; 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: --> (zext i32 (ptrtoaddr ptr %arg to i32) to i64) 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: --> ((zext i32 (ptrtoaddr ptr %arg to i32) to i64) + (-1 * %arg1)) U: full-set S: full-set
; X32-NEXT: %i9 = phi i64 [ 1, %bb7 ], [ %i11, %bb10 ]
; X32-NEXT: --> {1,+,1}<nuw><%bb8> U: [1,0) S: [1,0) Exits: <<Unknown>> LoopDispositions: { %bb8: Computable }
; X32-NEXT: %i11 = add nuw i64 %i9, 1
@@ -648,11 +648,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: <multiple exits> 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 + (zext i32 (ptrtoaddr ptr %arg to i32) to i64) + (-1 * %arg1))
; 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 + (zext i32 (ptrtoaddr ptr %arg to i32) to i64) + (-1 * %arg1))
; 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 + (zext i32 (ptrtoaddr ptr %arg to i32) to i64) + (-1 * %arg1))
;
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 aeda7f61a7575..512e583928804 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)<nuw><nsw>,+,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)<nuw><nsw>,+,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/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll b/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll
index cb0be523c7095..b0fbe8e62d056 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]]
diff --git a/llvm/test/Transforms/IndVarSimplify/pointer-loop-guards.ll b/llvm/test/Transforms/IndVarSimplify/pointer-loop-guards.ll
index dbd572d611632..8d9b369198507 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/pr45835.ll b/llvm/test/Transforms/IndVarSimplify/pr45835.ll
index 66635204e465e..4fa2d7a85fb0a 100644
--- a/llvm/test/Transforms/IndVarSimplify/pr45835.ll
+++ b/llvm/test/Transforms/IndVarSimplify/pr45835.ll
@@ -20,8 +20,8 @@ define internal fastcc void @d(ptr %c) unnamed_addr #0 {
; ALWAYS-NEXT: br i1 false, label [[CONT:%.*]], label [[WHILE_END_LOOPEXIT:%.*]]
; ALWAYS: cont:
; ALWAYS-NEXT: switch i64 0, label [[WHILE_COND]] [
-; ALWAYS-NEXT: i64 -1, label [[HANDLER_POINTER_OVERFLOW_I:%.*]]
-; ALWAYS-NEXT: i64 0, label [[HANDLER_POINTER_OVERFLOW_I]]
+; ALWAYS-NEXT: i64 -1, label [[HANDLER_POINTER_OVERFLOW_I:%.*]]
+; ALWAYS-NEXT: i64 0, label [[HANDLER_POINTER_OVERFLOW_I]]
; ALWAYS-NEXT: ]
; ALWAYS: handler.pointer_overflow.i:
; ALWAYS-NEXT: [[A_MUX_LCSSA4:%.*]] = phi ptr [ [[UMAX]], [[CONT]] ], [ [[UMAX]], [[CONT]] ]
@@ -42,8 +42,8 @@ define internal fastcc void @d(ptr %c) unnamed_addr #0 {
; NEVER: cont:
; NEVER-NEXT: [[A_MUX:%.*]] = select i1 [[CMP]], ptr @a, ptr [[C]]
; NEVER-NEXT: switch i64 0, label [[WHILE_COND]] [
-; NEVER-NEXT: i64 -1, label [[HANDLER_POINTER_OVERFLOW_I:%.*]]
-; NEVER-NEXT: i64 0, label [[HANDLER_POINTER_OVERFLOW_I]]
+; NEVER-NEXT: i64 -1, label [[HANDLER_POINTER_OVERFLOW_I:%.*]]
+; NEVER-NEXT: i64 0, label [[HANDLER_POINTER_OVERFLOW_I]]
; NEVER-NEXT: ]
; NEVER: handler.pointer_overflow.i:
; NEVER-NEXT: [[A_MUX_LCSSA4:%.*]] = phi ptr [ [[A_MUX]], [[CONT]] ], [ [[A_MUX]], [[CONT]] ]
@@ -64,8 +64,8 @@ define internal fastcc void @d(ptr %c) unnamed_addr #0 {
; CHEAP: cont:
; CHEAP-NEXT: [[A_MUX:%.*]] = select i1 [[CMP]], ptr @a, ptr [[C]]
; CHEAP-NEXT: switch i64 0, label [[WHILE_COND]] [
-; CHEAP-NEXT: i64 -1, label [[HANDLER_POINTER_OVERFLOW_I:%.*]]
-; CHEAP-NEXT: i64 0, label [[HANDLER_POINTER_OVERFLOW_I]]
+; CHEAP-NEXT: i64 -1, label [[HANDLER_POINTER_OVERFLOW_I:%.*]]
+; CHEAP-NEXT: i64 0, label [[HANDLER_POINTER_OVERFLOW_I]]
; CHEAP-NEXT: ]
; CHEAP: handler.pointer_overflow.i:
; CHEAP-NEXT: [[A_MUX_LCSSA4:%.*]] = phi ptr [ [[A_MUX]], [[CONT]] ], [ [[A_MUX]], [[CONT]] ]
diff --git a/llvm/test/Transforms/IndVarSimplify/pr59633.ll b/llvm/test/Transforms/IndVarSimplify/pr59633.ll
index 888a45b714dc6..1a47995884af8 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 c116b473e74ee..5be1e8f689145 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/LoopStrengthReduce/2013-01-14-ReuseCast.ll b/llvm/test/Transforms/LoopStrengthReduce/2013-01-14-ReuseCast.ll
index db40bba62ebcf..9984dd4716426 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/X86/expander-crashes.ll b/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll
index d652e5c5aa060..bb759aefcdf44 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 b0730ec330cd4..8caa5eddc7134 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 6714c5bbe431c..7ee6f7eaf570d 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/induction-costs.ll b/llvm/test/Transforms/LoopVectorize/AArch64/induction-costs.ll
index b49e1aa5b4e46..678f10ea89a7d 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: [[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:%.*]] = 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: [[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: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[END1]], i64 [[START2]])
; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[UMAX]], 1
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
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 ba00cb0c543fd..2f744b8ea043b 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: [[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]], 1
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[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]], 1
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[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]], 1
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[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]], 1
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[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]], 1
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[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]], 1
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[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]], 1
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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 9e4b3b5a921e5..809cca12a44ad 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: [[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]], 1
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP1]], 16
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 5d754fea2b84d..7322e3dd0bea0 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
@@ -451,8 +451,8 @@ define void @test_prefer_vector_addressing(ptr %start, ptr %ms, ptr noalias %src
; CHECK-LABEL: define void @test_prefer_vector_addressing(
; CHECK-SAME: ptr [[START:%.*]], ptr [[MS:%.*]], ptr noalias [[SRC:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[ENTRY:.*:]]
-; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; CHECK-NEXT: [[MS1:%.*]] = ptrtoint ptr [[MS]] to i64
+; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; CHECK-NEXT: [[MS1:%.*]] = ptrtoaddr ptr [[MS]] to i64
; CHECK-NEXT: [[GEP_START:%.*]] = getelementptr i8, ptr [[START]], i64 3
; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[START2]], 3
; CHECK-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[MS1]], i64 [[TMP0]])
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 ed550598cb872..0f04c2cd15478 100644
--- a/llvm/test/Transforms/LoopVectorize/AArch64/replicating-load-store-costs.ll
+++ b/llvm/test/Transforms/LoopVectorize/AArch64/replicating-load-store-costs.ll
@@ -447,8 +447,8 @@ define void @test_prefer_vector_addressing(ptr %start, ptr %ms, ptr noalias %src
; CHECK-LABEL: define void @test_prefer_vector_addressing(
; CHECK-SAME: ptr [[START:%.*]], ptr [[MS:%.*]], ptr noalias [[SRC:%.*]]) #[[ATTR0]] {
; CHECK-NEXT: [[ENTRY:.*:]]
-; CHECK-NEXT: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; CHECK-NEXT: [[MS1:%.*]] = ptrtoint ptr [[MS]] to i64
+; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; CHECK-NEXT: [[MS1:%.*]] = ptrtoaddr ptr [[MS]] to i64
; CHECK-NEXT: [[GEP_START:%.*]] = getelementptr i8, ptr [[START]], i64 3
; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[START2]], 3
; CHECK-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[MS1]], i64 [[TMP0]])
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 0ae1da776eff3..0a6b7029bae0e 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: [[TMP0:%.*]] = add i64 [[END1]], -8
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START_22]]
; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3
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 d39a7b0c23ef8..e9982905bdcd5 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: [[A2:%.*]] = ptrtoint ptr [[A]] to i64
-; VF2-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; VF2-NEXT: [[A2:%.*]] = ptrtoaddr ptr [[A]] to i64
+; VF2-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; VF2-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -16
; VF2-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[A2]]
; 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: [[A2:%.*]] = ptrtoint ptr [[A]] to i64
-; VF2IC2-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; VF2IC2-NEXT: [[A2:%.*]] = ptrtoaddr ptr [[A]] to i64
+; VF2IC2-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; VF2IC2-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -16
; VF2IC2-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[A2]]
; 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: [[A2:%.*]] = ptrtoint ptr [[A]] to i64
-; VF4-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; VF4-NEXT: [[A2:%.*]] = ptrtoaddr ptr [[A]] to i64
+; VF4-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; VF4-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -16
; VF4-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[A2]]
; 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 5fc88479ac42a..50215c35fe346 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 889ce79f45698..a68356623eb75 100644
--- a/llvm/test/Transforms/LoopVectorize/PowerPC/pr41179.ll
+++ b/llvm/test/Transforms/LoopVectorize/PowerPC/pr41179.ll
@@ -4,8 +4,8 @@
define void @foo(ptr %start, ptr %end) {
; CHECK-LABEL: @foo(
; 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: [[TMP0:%.*]] = trunc i64 [[END1]] to i32
; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[END1]], -1
; CHECK-NEXT: [[UMIN:%.*]] = call i64 @llvm.umin.i64(i64 [[START2]], i64 [[TMP1]])
diff --git a/llvm/test/Transforms/LoopVectorize/RISCV/pointer-induction.ll b/llvm/test/Transforms/LoopVectorize/RISCV/pointer-induction.ll
index 3a3833a1ed2c8..6fe0ea3ac8ae2 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: [[P2:%.*]] = ptrtoint ptr [[P]] to i64
-; CHECK-NEXT: [[P_END1:%.*]] = ptrtoint ptr [[P_END]] to i64
+; CHECK-NEXT: [[P2:%.*]] = ptrtoaddr ptr [[P]] to i64
+; CHECK-NEXT: [[P_END1:%.*]] = ptrtoaddr ptr [[P_END]] to i64
; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[P_END1]], 1
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[P2]]
; CHECK-NEXT: br label %[[VECTOR_PH:.*]]
@@ -63,13 +63,13 @@ 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: [[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: [[SCEVGEP6:%.*]] = getelementptr i8, ptr [[START]], i64 4
; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -12
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; CHECK-NEXT: [[TMP2:%.*]] = udiv i64 [[TMP1]], 12
; CHECK-NEXT: [[TMP3:%.*]] = add nuw nsw i64 [[TMP2]], 1
-; CHECK-NEXT: [[SCEVGEP6:%.*]] = getelementptr i8, ptr [[START]], i64 4
; CHECK-NEXT: br label %[[VECTOR_MEMCHECK:.*]]
; CHECK: [[VECTOR_MEMCHECK]]:
; CHECK-NEXT: [[BROADCAST_SPLATINSERT:%.*]] = insertelement <vscale x 2 x ptr> poison, ptr [[DST]], i64 0
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-predicate-switch.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-predicate-switch.ll
index 2204d3acb7f87..e83cb06083705 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-predicate-switch.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-predicate-switch.ll
@@ -7,8 +7,8 @@ define void @switch4_default_common_dest_with_case(ptr %start, ptr %end) {
; CHECK-NEXT: Live-in ir<%0> = original trip-count
; CHECK-EMPTY:
; CHECK-NEXT: ir-bb<entry>:
-; CHECK-NEXT: IR %start2 = ptrtoint ptr %start to i64
-; CHECK-NEXT: IR %end1 = ptrtoint ptr %end to i64
+; CHECK-NEXT: IR %start2 = ptrtoaddr ptr %start to i64
+; CHECK-NEXT: IR %end1 = ptrtoaddr ptr %end to i64
; CHECK-NEXT: IR %0 = sub i64 %end1, %start2
; CHECK-NEXT: EMIT vp<%min.iters.check> = icmp ult ir<%0>, ir<2>
; CHECK-NEXT: EMIT branch-on-cond vp<%min.iters.check>
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions.ll b/llvm/test/Transforms/LoopVectorize/VPlan/vplan-printing-reductions.ll
index 6d7d7e73ce1ad..e0f7c304f656c 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<entry>:
-; 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<entry>:
-; 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<entry>:
-; 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<entry>:
-; 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<entry>:
-; 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 2e9c7e7880795..a6af9ff43b371 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<entry>:
-; 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 5fa5fa93775a7..9fdd54ed4dc4a 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: [[END2:%.*]] = ptrtoint ptr [[END]] to i32
-; CHECK-NEXT: [[START_11:%.*]] = ptrtoint ptr [[START_1]] to i32
+; CHECK-NEXT: [[END2:%.*]] = ptrtoaddr ptr [[END]] to i32
+; CHECK-NEXT: [[START_11:%.*]] = ptrtoaddr ptr [[START_1]] 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/cost-model.ll b/llvm/test/Transforms/LoopVectorize/X86/cost-model.ll
index ea98c4c116952..7fee20ab39c88 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: [[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:%.*]] = 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 65729c941696b..9122a2f600afd 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
@@ -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: [[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]], 1
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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 1944387ece3e7..bea5893b7d932 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: [[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/X86/optsize.ll b/llvm/test/Transforms/LoopVectorize/X86/optsize.ll
index 8460af9e6aa25..62f3efc622528 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: [[END2:%.*]] = ptrtoint ptr [[END]] to i32
-; CHECK-NEXT: [[START1:%.*]] = ptrtoint ptr [[START]] to i32
+; CHECK-NEXT: [[END2:%.*]] = ptrtoaddr ptr [[END]] to i32
+; CHECK-NEXT: [[START1:%.*]] = ptrtoaddr ptr [[START]] to i32
; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[START1]], -72
; CHECK-NEXT: [[TMP1:%.*]] = sub i32 [[TMP0]], [[END2]]
; 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: [[END2:%.*]] = ptrtoint ptr [[END]] to i32
-; AUTOVF-NEXT: [[START1:%.*]] = ptrtoint ptr [[START]] to i32
+; AUTOVF-NEXT: [[END2:%.*]] = ptrtoaddr ptr [[END]] to i32
+; AUTOVF-NEXT: [[START1:%.*]] = ptrtoaddr ptr [[START]] to i32
; AUTOVF-NEXT: [[TMP0:%.*]] = add i32 [[START1]], -72
; AUTOVF-NEXT: [[TMP1:%.*]] = sub i32 [[TMP0]], [[END2]]
; 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 5eb12b5e932f2..28a26e2710ac7 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: [[TMP0:%.*]] = add i64 [[P_LAST1]], -1024
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[P3]]
; 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: [[TMP0:%.*]] = add i64 [[P_LAST1]], -1024
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[P3]]
; 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 e06a063fe4aa7..c57c235662c14 100644
--- a/llvm/test/Transforms/LoopVectorize/X86/pr72969.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/pr72969.ll
@@ -27,9 +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: [[P1:%.*]] = ptrtoaddr ptr [[P]] to i64
; VEC-NEXT: [[TMP0:%.*]] = add i64 [[P1]], 16
-; VEC-NEXT: [[UMAX2:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP0]], i64 add (i64 ptrtoint (ptr @h to i64), i64 1))
+; VEC-NEXT: [[UMAX2:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP0]], i64 add (i64 ptrtoaddr (ptr @h to i64), i64 1))
; VEC-NEXT: [[TMP1:%.*]] = add i64 [[UMAX2]], -9
; VEC-NEXT: [[TMP2:%.*]] = sub i64 [[TMP1]], [[P1]]
; VEC-NEXT: [[TMP3:%.*]] = lshr i64 [[TMP2]], 3
@@ -38,7 +38,7 @@ define void @test(ptr %p) {
; 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: [[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: [[TMP8:%.*]] = lshr i64 [[TMP7]], 3
diff --git a/llvm/test/Transforms/LoopVectorize/X86/predicate-switch.ll b/llvm/test/Transforms/LoopVectorize/X86/predicate-switch.ll
index 4802df6caee6d..43330e4102384 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; COST-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; COST-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; COST-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; COST-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; COST-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; FORCED-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; FORCED-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; FORCED-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; COST-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; COST-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; COST-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; COST-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; COST-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; FORCED-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; FORCED-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; FORCED-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; FORCED-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; FORCED-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; FORCED-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; COST-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; COST-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; COST-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; COST-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; COST-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; FORCED-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; FORCED-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; FORCED-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; FORCED-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; FORCED-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; FORCED-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; FORCED-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; FORCED-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; FORCED-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; FORCED-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; FORCED-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; FORCED-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; FORCED-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; FORCED-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; FORCED-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; FORCED-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; FORCED-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; FORCED-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; FORCED-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; FORCED-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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 2e8daad1daf9b..4eae5ae759833 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 e23985f313339..cd502b080d7bd 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/interleaved-accesses-different-insert-position.ll b/llvm/test/Transforms/LoopVectorize/interleaved-accesses-different-insert-position.ll
index fcfdafa82d75c..9d495e5f3b349 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: [[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:%.*]] = 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 e9dfebff0d809..e14f6f99efbc7 100644
--- a/llvm/test/Transforms/LoopVectorize/interleaved-accesses-metadata.ll
+++ b/llvm/test/Transforms/LoopVectorize/interleaved-accesses-metadata.ll
@@ -76,12 +76,10 @@ 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: [[BASE3:%.*]] = ptrtoint ptr [[BASE]] to i64
-; CHECK-NEXT: [[END2:%.*]] = ptrtoint ptr [[END]] to i64
-; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
-; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[BASE2]]
+; CHECK-NEXT: [[BASE3:%.*]] = ptrtoaddr ptr [[BASE]] to i64
+; CHECK-NEXT: [[END2:%.*]] = ptrtoaddr ptr [[END]] to i64
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[END2]], -8
+; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[BASE3]]
; 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
@@ -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: [[BASE2:%.*]] = ptrtoint ptr [[BASE]] to i64
-; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; CHECK-NEXT: [[BASE2:%.*]] = ptrtoaddr ptr [[BASE]] to i64
+; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[BASE2]]
; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3
diff --git a/llvm/test/Transforms/LoopVectorize/metadata.ll b/llvm/test/Transforms/LoopVectorize/metadata.ll
index 2040dbe247608..9c4176e50a26f 100644
--- a/llvm/test/Transforms/LoopVectorize/metadata.ll
+++ b/llvm/test/Transforms/LoopVectorize/metadata.ll
@@ -501,11 +501,9 @@ 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: [[SRC2:%.*]] = ptrtoint ptr [[SRC]] to i64
-; CHECK-NEXT: [[DST1:%.*]] = ptrtoint ptr [[DST]] to i64
-; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST3]], [[SRC4]]
+; CHECK-NEXT: [[SRC2:%.*]] = ptrtoaddr ptr [[SRC]] to i64
+; CHECK-NEXT: [[DST1:%.*]] = ptrtoaddr ptr [[DST]] to i64
+; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[DST1]], [[SRC2]]
; 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
@@ -554,11 +552,9 @@ 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: [[SRC2:%.*]] = ptrtoint ptr [[SRC]] to i64
-; INTERLEAVE-NEXT: [[DST1:%.*]] = ptrtoint ptr [[DST]] to i64
-; INTERLEAVE-NEXT: [[TMP2:%.*]] = sub i64 [[DST3]], [[SRC4]]
+; INTERLEAVE-NEXT: [[SRC2:%.*]] = ptrtoaddr ptr [[SRC]] to i64
+; INTERLEAVE-NEXT: [[DST1:%.*]] = ptrtoaddr ptr [[DST]] to i64
+; INTERLEAVE-NEXT: [[TMP2:%.*]] = sub i64 [[DST1]], [[SRC2]]
; 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
diff --git a/llvm/test/Transforms/LoopVectorize/opaque-ptr.ll b/llvm/test/Transforms/LoopVectorize/opaque-ptr.ll
index c3978d173fd87..391d6095538ec 100644
--- a/llvm/test/Transforms/LoopVectorize/opaque-ptr.ll
+++ b/llvm/test/Transforms/LoopVectorize/opaque-ptr.ll
@@ -4,14 +4,10 @@
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_START2:%.*]] = ptrtoint ptr [[P1_START]] to i64
-; CHECK-NEXT: [[P1_END1:%.*]] = ptrtoint ptr [[P1_END]] to i64
-; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[P1_END6]], -4
-; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[P1_START7]]
+; CHECK-NEXT: [[P1_START2:%.*]] = ptrtoaddr ptr [[P1_START:%.*]] to i64
+; CHECK-NEXT: [[P1_END1:%.*]] = ptrtoaddr ptr [[P1_END:%.*]] to i64
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[P1_END1]], -4
+; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[P1_START2]]
; 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
@@ -24,8 +20,8 @@ define void @test_ptr_iv_no_inbounds(ptr %p1.start, ptr %p2.start, ptr %p1.end)
; 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: [[TMP8:%.*]] = add i64 [[P1_END3]], -4
-; CHECK-NEXT: [[TMP9:%.*]] = sub i64 [[TMP8]], [[P1_START4]]
+; CHECK-NEXT: [[TMP8:%.*]] = add i64 [[P1_END1]], -4
+; CHECK-NEXT: [[TMP9:%.*]] = sub i64 [[TMP8]], [[P1_START2]]
; CHECK-NEXT: [[TMP10:%.*]] = lshr i64 [[TMP9]], 2
; CHECK-NEXT: [[TMP11:%.*]] = shl nuw i64 [[TMP10]], 2
; CHECK-NEXT: [[TMP12:%.*]] = add i64 [[TMP11]], 4
@@ -97,12 +93,10 @@ 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_START2:%.*]] = ptrtoint ptr [[P1_START]] to i64
-; CHECK-NEXT: [[P1_END1:%.*]] = ptrtoint ptr [[P1_END]] to i64
-; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[P1_END4]], -4
-; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[P1_START5]]
+; CHECK-NEXT: [[P1_START2:%.*]] = ptrtoaddr ptr [[P1_START:%.*]] to i64
+; CHECK-NEXT: [[P1_END1:%.*]] = ptrtoaddr ptr [[P1_END:%.*]] to i64
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[P1_END1]], -4
+; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[P1_START2]]
; 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
@@ -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: [[TMP0:%.*]] = add i64 [[END1]], -8
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3
diff --git a/llvm/test/Transforms/LoopVectorize/pointer-induction.ll b/llvm/test/Transforms/LoopVectorize/pointer-induction.ll
index 0bd18f3f90307..1c7eb3ff1805d 100644
--- a/llvm/test/Transforms/LoopVectorize/pointer-induction.ll
+++ b/llvm/test/Transforms/LoopVectorize/pointer-induction.ll
@@ -8,7 +8,7 @@ target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16
define void @a(ptr readnone %b) {
; CHECK-LABEL: @a(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[B1:%.*]] = ptrtoint ptr [[B:%.*]] to i64
+; CHECK-NEXT: [[B1:%.*]] = ptrtoaddr ptr [[B:%.*]] to i64
; 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:
diff --git a/llvm/test/Transforms/LoopVectorize/pr45259.ll b/llvm/test/Transforms/LoopVectorize/pr45259.ll
index ed45353c216b4..a3d793c817420 100644
--- a/llvm/test/Transforms/LoopVectorize/pr45259.ll
+++ b/llvm/test/Transforms/LoopVectorize/pr45259.ll
@@ -6,11 +6,11 @@
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:
diff --git a/llvm/test/Transforms/LoopVectorize/predicate-switch.ll b/llvm/test/Transforms/LoopVectorize/predicate-switch.ll
index abb64bd1bf088..e7367fd78a232 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; IC1-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; IC1-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; IC1-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64
-; IC2-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; IC2-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
+; IC2-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] 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 8a136a85bd8d3..ac8ac87b39b0e 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: [[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]], -8
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; 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: [[START2:%.*]] = ptrtoint ptr [[START]] to i64, !dbg [[DBG34:![0-9]+]]
-; DEBUGLOC-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64, !dbg [[DBG34]]
+; DEBUGLOC-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64, !dbg [[DBG34:![0-9]+]]
+; DEBUGLOC-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64, !dbg [[DBG34]]
; DEBUGLOC-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8, !dbg [[DBG34]]
; DEBUGLOC-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]], !dbg [[DBG34]]
; DEBUGLOC-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 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 98c80065c792b..1c21a7305f4cd 100644
--- a/llvm/test/Transforms/LoopVectorize/runtime-check-known-true.ll
+++ b/llvm/test/Transforms/LoopVectorize/runtime-check-known-true.ll
@@ -5,7 +5,7 @@ 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
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 cd7af0e94ab15..83dbcdef99b04 100644
--- a/llvm/test/Transforms/LoopVectorize/runtime-check-needed-but-empty.ll
+++ b/llvm/test/Transforms/LoopVectorize/runtime-check-needed-but-empty.ll
@@ -77,7 +77,7 @@ define void @diff_memcheck_known_false_for_vf_4(ptr %B, ptr %A, ptr %end) {
; CHECK-LABEL: define void @diff_memcheck_known_false_for_vf_4(
; CHECK-SAME: ptr [[B:%.*]], ptr [[A:%.*]], ptr [[END:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
-; CHECK-NEXT: [[END1:%.*]] = ptrtoint ptr [[END]] to i64
+; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
; CHECK-NEXT: [[A_INT:%.*]] = ptrtoint ptr [[A]] to i64
; CHECK-NEXT: [[B_CAST:%.*]] = ptrtoint ptr [[B]] to i64
; CHECK-NEXT: [[PTR_SUB:%.*]] = sub i64 [[A_INT]], [[B_CAST]]
diff --git a/llvm/test/Transforms/LoopVectorize/scev-predicate-reasoning.ll b/llvm/test/Transforms/LoopVectorize/scev-predicate-reasoning.ll
index 5cf72a642147c..84fc77cd44651 100644
--- a/llvm/test/Transforms/LoopVectorize/scev-predicate-reasoning.ll
+++ b/llvm/test/Transforms/LoopVectorize/scev-predicate-reasoning.ll
@@ -122,20 +122,19 @@ define void @implied_wrap_predicate(ptr %A, ptr %B, ptr %C) {
; CHECK-LABEL: define void @implied_wrap_predicate(
; CHECK-SAME: ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
-; CHECK-NEXT: [[A3:%.*]] = ptrtoint ptr [[A]] to i64
; CHECK-NEXT: [[C2:%.*]] = ptrtoaddr ptr [[C]] to i64
-; CHECK-NEXT: [[A1:%.*]] = ptrtoint ptr [[A]] to i64
-; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[A3]], 16
-; CHECK-NEXT: [[UMAX4:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP0]], i64 add (i64 ptrtoint (ptr @h to i64), i64 1))
+; CHECK-NEXT: [[A1:%.*]] = ptrtoaddr ptr [[A]] to i64
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[A1]], 16
+; CHECK-NEXT: [[UMAX4:%.*]] = call i64 @llvm.umax.i64(i64 [[TMP0]], i64 add (i64 ptrtoaddr (ptr @h to i64), i64 1))
; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[UMAX4]], -9
-; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[TMP1]], [[A3]]
+; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[TMP1]], [[A1]]
; 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]], 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: [[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: [[TMP8:%.*]] = lshr i64 [[TMP7]], 3
diff --git a/llvm/test/Transforms/PhaseOrdering/AArch64/std-find.ll b/llvm/test/Transforms/PhaseOrdering/AArch64/std-find.ll
index 69b23200b239b..c6b4ca5181a12 100644
--- a/llvm/test/Transforms/PhaseOrdering/AArch64/std-find.ll
+++ b/llvm/test/Transforms/PhaseOrdering/AArch64/std-find.ll
@@ -146,8 +146,8 @@ define i64 @std_find_i16_constant_offset_with_assumptions(ptr %first.coerce, i16
; CHECK-NEXT: [[TMP8:%.*]] = getelementptr i8, ptr [[FIRST_COERCE]], i64 [[TMP7]]
; CHECK-NEXT: br label %[[RETURN]]
; CHECK: [[RETURN]]:
-; CHECK-NEXT: [[__FIRST_ADDR_0_LCSSA_I_I_PH:%.*]] = phi ptr [ [[TMP8]], %[[VECTOR_EARLY_EXIT]] ], [ [[COERCE_VAL_IP]], %[[VECTOR_BODY_INTERIM_14]] ]
-; CHECK-NEXT: [[DOTPRE:%.*]] = ptrtoint ptr [[__FIRST_ADDR_0_LCSSA_I_I_PH]] to i64
+; CHECK-NEXT: [[MERGE:%.*]] = phi ptr [ [[TMP8]], %[[VECTOR_EARLY_EXIT]] ], [ [[COERCE_VAL_IP]], %[[VECTOR_BODY_INTERIM_14]] ]
+; CHECK-NEXT: [[DOTPRE:%.*]] = ptrtoint ptr [[MERGE]] to i64
; CHECK-NEXT: ret i64 [[DOTPRE]]
;
entry:
@@ -202,8 +202,8 @@ define i64 @std_find_i16_constant_offset_no_assumptions(ptr %first.coerce, i16 n
; CHECK-NEXT: [[CMP_NOT_I_I:%.*]] = icmp eq ptr [[PTR_IV_NEXT]], [[COERCE_VAL_IP]]
; CHECK-NEXT: br i1 [[CMP_NOT_I_I]], label %[[RETURN]], label %[[LOOP_HEADER]]
; CHECK: [[RETURN]]:
-; CHECK-NEXT: [[MERGE_PH:%.*]] = phi ptr [ [[PTR_IV]], %[[LOOP_HEADER]] ], [ [[COERCE_VAL_IP]], %[[LOOP_LATCH]] ]
-; CHECK-NEXT: [[DOTPRE:%.*]] = ptrtoint ptr [[MERGE_PH]] to i64
+; CHECK-NEXT: [[MERGE:%.*]] = phi ptr [ [[PTR_IV]], %[[LOOP_HEADER]] ], [ [[COERCE_VAL_IP]], %[[LOOP_LATCH]] ]
+; CHECK-NEXT: [[DOTPRE:%.*]] = ptrtoint ptr [[MERGE]] to i64
; CHECK-NEXT: ret i64 [[DOTPRE]]
;
entry:
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 b2e07e77b05c5..9bb67bd299eed 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/enable-loop-header-duplication-oz.ll b/llvm/test/Transforms/PhaseOrdering/enable-loop-header-duplication-oz.ll
index 299c42aab4504..d6e57edb8cc8b 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 025a1b34086aa..978ecd2bd32ac 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}<nuw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {%t.ptr,+,1}<nuw><nsw><%loop> U: [0,297) S: [0,297) Exits: (-1 + (-1 * (ptrtoaddr ptr %t.ptr to i32))<nsw> + ((1 + (ptrtoaddr ptr %t.ptr to i32))<nuw><nsw> 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)<nuw><nsw>,+,1}<nw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {(1 + %t.ptr)<nuw><nsw>,+,1}<nuw><nsw><%loop> U: [1,298) S: [1,298) Exits: ((-1 * (ptrtoaddr ptr %t.ptr to i32))<nsw> + ((1 + (ptrtoaddr ptr %t.ptr to i32))<nuw><nsw> 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))<nsw> + ((1 + (ptrtoaddr ptr %t.ptr to i32))<nuw><nsw> 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))<nsw> + ((1 + (ptrtoaddr ptr %t.ptr to i32))<nuw><nsw> 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/polly/test/ScopInfo/int2ptr_ptr2int.ll b/polly/test/ScopInfo/int2ptr_ptr2int.ll
index adefe794561c2..3bd2d08278211 100644
--- a/polly/test/ScopInfo/int2ptr_ptr2int.ll
+++ b/polly/test/ScopInfo/int2ptr_ptr2int.ll
@@ -16,11 +16,8 @@
; 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
@@ -33,10 +30,10 @@
; 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
;
diff --git a/polly/test/ScopInfo/int2ptr_ptr2int_2.ll b/polly/test/ScopInfo/int2ptr_ptr2int_2.ll
index a88fcdc0f9b12..b7f3fb809f416 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"
>From 215bf815754651206fe21f158c1a1ae401f9ab48 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Wed, 11 Feb 2026 15:39:41 +0000
Subject: [PATCH 04/14] !fixup address comments, thanks
---
llvm/lib/Analysis/ScalarEvolution.cpp | 3 ---
llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp | 3 ++-
.../Transforms/LoopIdiom/reuse-lcssa-phi-scev-expansion.ll | 2 +-
3 files changed, 3 insertions(+), 5 deletions(-)
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 6fbc8e414499f..7e55827bc28be 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -4997,9 +4997,6 @@ const SCEV *ScalarEvolution::getPointerBase(const SCEV *V) {
}
assert(PtrOp && "Must have pointer op");
V = PtrOp;
- } else if (auto *PtrToAddr = dyn_cast<SCEVPtrToAddrExpr>(V)) {
- // Strip ptrtoaddr to continue extracting the base pointer.
- V = PtrToAddr->getOperand();
} else // Not something we can look further into.
return V;
}
diff --git a/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp b/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp
index 9f85281d359d6..7a775acb7bd5a 100644
--- a/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp
+++ b/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp
@@ -1453,7 +1453,8 @@ Value *SCEVExpander::visitPtrToAddrExpr(SCEVUseT<const SCEVPtrToAddrExpr *> S) {
Value *V = expand(S->getOperand());
Type *Ty = S->getType();
- // ptrtoaddr and ptrtoint produce the same value, so try to reuse either.
+ // ptrtoaddr and ptrtoint produce the same value if the result type matches,
+ // so try to reuse either.
if (!isa<Constant>(V)) {
BasicBlock::iterator BIP = Builder.GetInsertPoint();
for (User *U : V->users()) {
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 d0e70c21c7bc6..05ef5d111fe55 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]] ]
>From c4cfd7955e6f5bea36dc773caf185e2ff724254b Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Fri, 13 Feb 2026 13:55:16 +0000
Subject: [PATCH 05/14] !fixup use SCEVUnknown for ptrtoint
---
llvm/lib/Analysis/ScalarEvolution.cpp | 37 ++---
.../add-expr-pointer-operand-sorting.ll | 2 +-
llvm/test/Analysis/ScalarEvolution/alloca.ll | 4 +-
.../ScalarEvolution/exit-count-select-safe.ll | 4 +-
.../ScalarEvolution/no-wrap-add-exprs.ll | 12 +-
.../ScalarEvolution/pointer-rounding.ll | 66 ++++-----
.../ptrtoint-constantexpr-loop.ll | 56 ++++----
.../ScalarEvolution/ptrtoint-global.ll | 44 +++---
.../test/Analysis/ScalarEvolution/ptrtoint.ll | 130 +++++++++---------
llvm/test/Analysis/ScalarEvolution/scev-aa.ll | 2 +-
llvm/test/CodeGen/AArch64/ragreedy-csr.ll | 6 +-
.../Thumb2/LowOverheadLoops/while-loops.ll | 125 ++++++++---------
.../Thumb2/mve-tailpred-loopinvariant.ll | 105 +++++++++++---
.../IndVarSimplify/2011-11-01-lftrptr.ll | 16 ++-
.../test/Transforms/IndVarSimplify/pr59633.ll | 7 +-
.../reuse-lcssa-phi-scev-expansion.ll | 11 +-
.../RISCV/lsr-drop-solution-dbg-msg.ll | 4 +-
.../X86/expander-crashes.ll | 23 ++--
.../AArch64/aggressive-interleaving.ll | 4 +-
.../LoopVectorize/induction-ptrcasts.ll | 70 +++++-----
.../Analysis/ScalarEvolutionTest.cpp | 8 +-
21 files changed, 397 insertions(+), 339 deletions(-)
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 7e55827bc28be..537b2ef48957b 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -1204,23 +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!");
- // 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 via ptrtoaddr 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();
-
- const SCEV *IntOp = getPtrToAddrExpr(Op);
- 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,
@@ -8089,6 +8075,23 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
SCEV::NoWrapFlags Flags = SCEV::FlagAnyWrap;
if (BO->Op)
Flags = getNoWrapFlagsFromUB(BO->Op);
+
+ // Special case: sub (ptrtoint p1), (ptrtoint p2) -> subtract of ptrtoaddr
+ // expressions. While we don't model ptrtoint directly in SCEV, the
+ // difference between two pointer addresses is well-defined.
+ Value *PtrLHS, *PtrRHS;
+ if (match(BO->LHS, m_PtrToInt(m_Value(PtrLHS))) &&
+ match(BO->RHS, m_PtrToInt(m_Value(PtrRHS)))) {
+ const SCEV *AddrLHS = getPtrToAddrExpr(getSCEV(PtrLHS));
+ const SCEV *AddrRHS = getPtrToAddrExpr(getSCEV(PtrRHS));
+ if (!isa<SCEVCouldNotCompute>(AddrLHS) &&
+ !isa<SCEVCouldNotCompute>(AddrRHS)) {
+ Type *Ty = BO->LHS->getType();
+ return getMinusSCEV(getTruncateOrZeroExtend(AddrLHS, Ty),
+ getTruncateOrZeroExtend(AddrRHS, Ty), Flags);
+ }
+ }
+
LHS = getSCEV(BO->LHS);
RHS = getSCEV(BO->RHS);
return getMinusSCEV(LHS, RHS, Flags);
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 03d8dcdb683ad..5dffee19cb312 100644
--- a/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll
+++ b/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll
@@ -30,7 +30,7 @@ define i32 @d(i32 %base) {
; CHECK-NEXT: %load1 = load ptr, ptr @c, align 8
; CHECK-NEXT: --> %load1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %sub.ptr.lhs.cast = ptrtoint ptr %load1 to i64
-; CHECK-NEXT: --> (ptrtoaddr ptr %load1 to i64) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
+; CHECK-NEXT: --> %sub.ptr.lhs.cast U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, ptrtoint (ptr @b to i64)
; CHECK-NEXT: --> ((-1 * (ptrtoaddr ptr @b to i64)) + (ptrtoaddr ptr %load1 to i64)) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
; CHECK-NEXT: %sub.ptr.div = sdiv exact i64 %sub.ptr.sub, 4
diff --git a/llvm/test/Analysis/ScalarEvolution/alloca.ll b/llvm/test/Analysis/ScalarEvolution/alloca.ll
index 5c9e4e1a87abe..97555be0991c1 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: --> (ptrtoaddr 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: --> (ptrtoaddr 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 f21c8aaa368c1..f3a0047b6e815 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: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: %ptr.int = ptrtoint ptr %ptr to i64
-; CHECK-NEXT: --> (ptrtoaddr 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: --> {(ptrtoaddr ptr %ptr to i64),+,1}<%loop> U: full-set S: full-set --> ((%n umin_seq %m) + (ptrtoaddr 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/no-wrap-add-exprs.ll b/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
index ba3ad4cbd1866..4a997ca565b29 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 (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr ptr @z_addr to i64) to i32)) to i64))<nuw><nsw> U: [1,4294967294) S: [1,4294967297)
+; CHECK-NEXT: --> (1 + (zext i32 (4 + %int0) to i64))<nuw><nsw> 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 (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr 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/pointer-rounding.ll b/llvm/test/Analysis/ScalarEvolution/pointer-rounding.ll
index 339435e6beb74..38d96241b53a1 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: --> (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr ptr %obj to i64) to i4) to i64))<nsw> U: [-15,1) S: [-15,1)
+; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> U: [-15,1) S: [-15,1)
; CHECK-NEXT: %i4 = getelementptr i8, ptr %obj, i64 %i3
-; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj to i64) to i4) to i64))<nsw> + %obj) U: full-set S: full-set
+; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> + %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: --> (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> U: [-15,1) S: [-15,1)
+; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> U: [-15,1) S: [-15,1)
; CHECK-NEXT: %i4 = getelementptr i8, ptr %obj_to_align, i64 %i3
-; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> + %obj_to_align) U: full-set S: full-set
+; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> + %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: --> (ptrtoaddr 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 + (ptrtoaddr 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 + (ptrtoaddr ptr %obj to i64)) /u 16))<nuw> U: [0,-15) S: [-9223372036854775808,9223372036854775793)
+; CHECK-NEXT: --> (16 * ((15 + %intptr) /u 16))<nuw> U: [0,-15) S: [-9223372036854775808,9223372036854775793)
; CHECK-NEXT: %diff = sub i64 %aligned_intptr, %intptr
-; CHECK-NEXT: --> ((16 * ((15 + (ptrtoaddr ptr %obj to i64)) /u 16))<nuw> + (-1 * (ptrtoaddr ptr %obj to i64))) U: full-set S: full-set
+; CHECK-NEXT: --> ((16 * ((15 + %intptr) /u 16))<nuw> + (-1 * %intptr)) U: full-set S: full-set
; CHECK-NEXT: %aligned_result = getelementptr i8, ptr %obj, i64 %diff
-; CHECK-NEXT: --> ((16 * ((15 + (ptrtoaddr ptr %obj to i64)) /u 16))<nuw> + (-1 * (ptrtoaddr ptr %obj to i64)) + %obj) U: full-set S: full-set
+; CHECK-NEXT: --> ((16 * ((15 + %intptr) /u 16))<nuw> + (-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: --> (ptrtoaddr 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 + (ptrtoaddr 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 + (ptrtoaddr ptr %obj_donor to i64)) /u 16))<nuw> U: [0,-15) S: [-9223372036854775808,9223372036854775793)
+; CHECK-NEXT: --> (16 * ((15 + %intptr) /u 16))<nuw> U: [0,-15) S: [-9223372036854775808,9223372036854775793)
; CHECK-NEXT: %diff = sub i64 %aligned_intptr, %intptr
-; CHECK-NEXT: --> ((16 * ((15 + (ptrtoaddr ptr %obj_donor to i64)) /u 16))<nuw> + (-1 * (ptrtoaddr ptr %obj_donor to i64))) U: full-set S: full-set
+; CHECK-NEXT: --> ((16 * ((15 + %intptr) /u 16))<nuw> + (-1 * %intptr)) U: full-set S: full-set
; CHECK-NEXT: %aligned_result = getelementptr i8, ptr %obj_to_align, i64 %diff
-; CHECK-NEXT: --> ((16 * ((15 + (ptrtoaddr ptr %obj_donor to i64)) /u 16))<nuw> + (-1 * (ptrtoaddr ptr %obj_donor to i64)) + %obj_to_align) U: full-set S: full-set
+; CHECK-NEXT: --> ((16 * ((15 + %intptr) /u 16))<nuw> + (-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: --> (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr ptr %obj to i64) to i4) to i64))<nsw> U: [-15,1) S: [-15,1)
+; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> U: [-15,1) S: [-15,1)
; CHECK-NEXT: %i5 = getelementptr i8, ptr %obj, i64 %i4
-; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj to i64) to i4) to i64))<nsw> + %obj) U: full-set S: full-set
+; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> + %obj) U: full-set S: full-set
; CHECK-NEXT: %i6 = getelementptr i8, ptr %i5, i64 16
-; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj to i64) to i4) to i64))<nsw> + %obj) U: full-set S: full-set
+; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> + %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: --> (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> U: [-15,1) S: [-15,1)
+; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> U: [-15,1) S: [-15,1)
; CHECK-NEXT: %i5 = getelementptr i8, ptr %obj_to_align, i64 %i4
-; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> + %obj_to_align) U: full-set S: full-set
+; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> + %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 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> + %obj_to_align) U: full-set S: full-set
+; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> + %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: --> (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> U: [-15,1) S: [-15,1)
+; CHECK-NEXT: --> (-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> U: [-15,1) S: [-15,1)
; CHECK-NEXT: %i5 = getelementptr i8, ptr %second_obj, i64 %i4
-; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> + %second_obj) U: full-set S: full-set
+; CHECK-NEXT: --> ((-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> + %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 (ptrtoaddr ptr %obj_donor to i64) to i4) to i64))<nsw> + %second_obj) U: full-set S: full-set
+; CHECK-NEXT: --> (16 + (-1 * (zext i4 (trunc i64 %i to i4) to i64))<nsw> + %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/ptrtoint-constantexpr-loop.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll
index 99a45def1ba8b..99ecb3c9a7cb9 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: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, ptr %arg, i64 ptrtoint (ptr @global to i64)
-; PTR64_IDX64-NEXT: --> ((ptrtoaddr ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: --> ((ptrtoaddr ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, ptr %arg, i64 ptrtoint (ptr @global to i64)
-; PTR16_IDX16-NEXT: --> ((ptrtoaddr ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: --> ((ptrtoaddr ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, ptr %arg, i32 ptrtoint (ptr @global to i32)
-; PTR64_IDX64-NEXT: --> ((sext i32 (trunc i64 (ptrtoaddr ptr @global to i64) to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 (trunc i64 (ptrtoaddr 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 (ptrtoaddr ptr @global to i64) to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 (trunc i64 (ptrtoaddr 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, ptr %arg, i32 ptrtoint (ptr @global to i32)
-; PTR16_IDX16-NEXT: --> ((ptrtoaddr ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: --> ((ptrtoaddr ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR64_IDX64-NEXT: %tmp12 = getelementptr i8, ptr %arg, i128 ptrtoint (ptr @global to i128)
-; PTR64_IDX64-NEXT: --> ((ptrtoaddr ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: --> ((ptrtoaddr ptr @global to i64) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %bb11: Computable }
; PTR16_IDX16-NEXT: %tmp12 = getelementptr i8, ptr %arg, i128 ptrtoint (ptr @global to i128)
-; PTR16_IDX16-NEXT: --> ((ptrtoaddr ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: --> ((ptrtoaddr ptr @global to i16) + %arg) U: full-set S: full-set Exits: ((ptrtoaddr 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: <<Unknown>> 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 (ptrtoaddr ptr @global to i64) to i32)) + %arg) U: full-set S: full-set Exits: ((-1 * (trunc i64 (ptrtoaddr 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: <<Unknown>> 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 (ptrtoaddr ptr @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (zext i16 (ptrtoaddr ptr @global to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
+; PTR16_IDX16-NEXT: --> ((-1 * ptrtoint (ptr @global to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * ptrtoint (ptr @global to i32))<nsw> + %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: <<Unknown>> 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 (ptrtoaddr ptr @global to i64) to i16) to i32) U: [-32768,32768) S: [-32768,32768) Exits: (sext i16 (trunc i64 (ptrtoaddr 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 (ptrtoaddr ptr @global to i64) to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (trunc i64 (ptrtoaddr ptr @global to i64) to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
+; PTR64_IDX64-NEXT: --> ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32))<nsw> + %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: <<Unknown>> 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 (ptrtoaddr ptr @global to i16) to i32) U: [-32768,32768) S: [-32768,32768) Exits: (sext i16 (ptrtoaddr 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 (ptrtoaddr ptr @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 (ptrtoaddr ptr @global to i16) to i32))<nsw> + %arg) LoopDispositions: { %bb7: Invariant }
+; PTR16_IDX16-NEXT: --> ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32))<nsw> + %arg) U: full-set S: full-set Exits: ((-1 * (sext i16 ptrtoint (ptr @global to i16) to i32))<nsw> + %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: <<Unknown>> 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}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (sext i32 (-1 + (trunc i64 (ptrtoaddr ptr @sext_like_noop to i64) to i32)) to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648)
+; PTR64_IDX64-NEXT: --> (sext i32 {1,+,1}<nuw><%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}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + (trunc i64 (ptrtoaddr ptr @sext_like_noop to i64) to i32)) LoopDispositions: { %for.body: Computable }
+; PTR64_IDX64-NEXT: --> {1,+,1}<nuw><%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}<nuw><%for.body> U: [2,0) S: [2,0) Exits: (trunc i64 (ptrtoaddr ptr @sext_like_noop to i64) to i32) LoopDispositions: { %for.body: Computable }
+; PTR64_IDX64-NEXT: --> {2,+,1}<nuw><%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 (ptrtoaddr 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 (ptrtoaddr 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}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i16 (ptrtoaddr ptr @sext_like_noop to i16) to i64))<nsw> U: [-1,65535) S: [-1,65535)
+; PTR16_IDX16-NEXT: --> (sext i32 {1,+,1}<nuw><%for.body> to i64) U: [-2147483648,2147483648) S: [-2147483648,2147483648) --> (-1 + (zext i32 ptrtoint (ptr @sext_like_noop to i32) to i64))<nsw> 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}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + (zext i16 (ptrtoaddr ptr @sext_like_noop to i16) to i32))<nsw> LoopDispositions: { %for.body: Computable }
+; PTR16_IDX16-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,0) S: [1,0) Exits: (-1 + ptrtoint (ptr @sext_like_noop to i32))<nsw> LoopDispositions: { %for.body: Computable }
; PTR16_IDX16-NEXT: %inc = add nuw i32 %i, 1
-; PTR16_IDX16-NEXT: --> {2,+,1}<nuw><%for.body> U: [2,0) S: [2,0) Exits: (zext i16 (ptrtoaddr ptr @sext_like_noop to i16) to i32) LoopDispositions: { %for.body: Computable }
+; PTR16_IDX16-NEXT: --> {2,+,1}<nuw><%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 (ptrtoaddr ptr @sext_like_noop to i16) to i32))<nsw>
+; PTR16_IDX16-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))<nsw>
; 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 (ptrtoaddr ptr @sext_like_noop to i16) to i32))<nsw>
+; PTR16_IDX16-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))<nsw>
; 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 592d87c7ea5a9..5d54aa622a8be 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 + (ptrtoaddr ptr @glob.i32.align2 to i64))<nuw> 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 + (ptrtoaddr 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 + (ptrtoaddr ptr @glob.i32.align8 to i64))<nuw><nsw> U: [15,0) S: [-9223372036854775801,-9223372036854775808)
+; CHECK-NEXT: --> (7 + ptrtoint (ptr @glob.i32.align8 to i64))<nuw><nsw> 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 + (ptrtoaddr 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 + (ptrtoaddr ptr @glob.i32.align16 to i64))<nuw><nsw> U: [31,0) S: [-9223372036854775793,-9223372036854775808)
+; CHECK-NEXT: --> (15 + ptrtoint (ptr @glob.i32.align16 to i64))<nuw><nsw> 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 + (ptrtoaddr 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 + (ptrtoaddr ptr @array4xi32 to i64))<nuw> 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 + (ptrtoaddr ptr @array4xi32 to i64))<nuw> 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 + (ptrtoaddr 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 + (ptrtoaddr 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 + (ptrtoaddr ptr @array4xi32 to i64))<nuw> 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 + (ptrtoaddr ptr @array4xi32 to i64))<nuw> 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 + (ptrtoaddr 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 + (ptrtoaddr ptr @array4xi32 to i64))<nuw> 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 + (ptrtoaddr ptr @array4xi32 to i64))<nuw> 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 + (ptrtoaddr 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 + (ptrtoaddr 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 + (ptrtoaddr ptr @array4xi32 to i64)) umax (ptrtoaddr 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 + (ptrtoaddr ptr @array4xi32 to i64)) umax (ptrtoaddr 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 * (ptrtoaddr ptr @array4xi32 to i64)) + ((32 + (ptrtoaddr ptr @array4xi32 to i64)) umax (ptrtoaddr 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.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
index 4c152649c0342..be34e7c6b3a54 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: --> (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr 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: --> (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr 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: --> (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr 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: --> (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr 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: --> (ptrtoaddr 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 (ptrtoaddr 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: --> (ptrtoaddr 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 (ptrtoaddr 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: --> (ptrtoaddr 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 (ptrtoaddr 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: --> (ptrtoaddr 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 (ptrtoaddr 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 + (ptrtoaddr 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_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 + (ptrtoaddr 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))<nuw><nsw> + %in) LoopDispositions: { %loop: Computable }
; X64-NEXT: %i8 = ptrtoint ptr %i7 to i64
-; X64-NEXT: --> {(ptrtoaddr ptr %in to i64),+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * (zext i32 %count to i64))<nuw><nsw> + (ptrtoaddr ptr %in to i64)) LoopDispositions: { %loop: Computable }
+; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; X64-NEXT: %i9 = add nuw nsw i64 %i6, 1
; X64-NEXT: --> {1,+,1}<nuw><%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 {(ptrtoaddr ptr %in to i32),+,4}<%loop> to i64) U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (-4 + (4 * %count) + (ptrtoaddr ptr %in to i32)) to i64) LoopDispositions: { %loop: Computable }
+; X32-NEXT: --> %i8 U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; X32-NEXT: %i9 = add nuw nsw i64 %i6, 1
; X32-NEXT: --> {1,+,1}<nuw><%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: --> ((ptrtoaddr ptr %in0 to i64) umax (ptrtoaddr ptr %in1 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_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 (ptrtoaddr ptr %in0 to i32) to i64) umax (zext i32 (ptrtoaddr 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: --> ((ptrtoaddr ptr %in0 to i64) smax (ptrtoaddr ptr %in1 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_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 ((ptrtoaddr ptr %in0 to i32) smax (ptrtoaddr 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: --> ((ptrtoaddr ptr %in0 to i64) umin (ptrtoaddr ptr %in1 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_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 (ptrtoaddr ptr %in0 to i32) to i64) umin (zext i32 (ptrtoaddr 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: --> ((ptrtoaddr ptr %in0 to i64) smin (ptrtoaddr ptr %in1 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_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 ((ptrtoaddr ptr %in0 to i32) smin (ptrtoaddr 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,13 +368,13 @@ 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: --> (ptrtoaddr 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}<nuw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X64-NEXT: --> {(ptrtoaddr ptr %arg to i64),+,1}<nuw><%bb6> U: full-set S: full-set Exits: (-1 + (ptrtoaddr ptr %arg1 to i64)) LoopDispositions: { %bb6: Computable }
+; X64-NEXT: --> %i9 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i10 = sub i64 %i9, %i4
; X64-NEXT: --> {0,+,1}<nuw><%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
@@ -400,13 +394,13 @@ define void @pr46786_c26_char(ptr %arg, ptr %arg1, ptr %arg2) {
; 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 (ptrtoaddr 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}<nuw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X32-NEXT: --> {(zext i32 (ptrtoaddr ptr %arg to i32) to i64),+,1}<nuw><%bb6> U: [0,8589934590) S: [0,8589934590) Exits: ((zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) + (zext i32 (ptrtoaddr ptr %arg to i32) to i64)) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> %i9 U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i10 = sub i64 %i9, %i4
; X32-NEXT: --> {0,+,1}<nuw><%bb6> U: [0,4294967295) S: [0,4294967295) Exits: (zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10
@@ -451,13 +445,13 @@ 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: --> (ptrtoaddr 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}<nuw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X64-NEXT: --> {(ptrtoaddr ptr %arg to i64),+,1}<nuw><%bb6> U: full-set S: full-set Exits: (-1 + (ptrtoaddr ptr %arg1 to i64)) LoopDispositions: { %bb6: Computable }
+; X64-NEXT: --> %i9 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i10 = sub i64 %i9, %i4
; X64-NEXT: --> {0,+,1}<nuw><%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
@@ -477,13 +471,13 @@ define void @pr46786_c26_char_cmp_ops_swapped(ptr %arg, ptr %arg1, ptr %arg2) {
; 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 (ptrtoaddr 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}<nuw><%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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X32-NEXT: --> {(zext i32 (ptrtoaddr ptr %arg to i32) to i64),+,1}<nuw><%bb6> U: [0,8589934590) S: [0,8589934590) Exits: ((zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) + (zext i32 (ptrtoaddr ptr %arg to i32) to i64)) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> %i9 U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i10 = sub i64 %i9, %i4
; X32-NEXT: --> {0,+,1}<nuw><%bb6> U: [0,4294967295) S: [0,4294967295) Exits: (zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10
@@ -535,13 +529,13 @@ 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: --> (ptrtoaddr 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}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
; X64-NEXT: %i8 = load i32, ptr %i7, align 4
; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X64-NEXT: --> {(ptrtoaddr ptr %arg to i64),+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4))<nuw> + (ptrtoaddr ptr %arg to i64)) LoopDispositions: { %bb6: Computable }
+; X64-NEXT: --> %i9 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i10 = sub i64 %i9, %i4
; X64-NEXT: --> {0,+,4}<nuw><%bb6> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4))<nuw> LoopDispositions: { %bb6: Computable }
; X64-NEXT: %i11 = ashr exact i64 %i10, 2
@@ -563,13 +557,13 @@ define void @pr46786_c26_int(ptr %arg, ptr %arg1, ptr %arg2) {
; 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 (ptrtoaddr 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}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) /u 4))<nuw> + %arg) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i8 = load i32, ptr %i7, align 4
; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X32-NEXT: --> {(zext i32 (ptrtoaddr ptr %arg to i32) to i64),+,4}<nuw><%bb6> U: [0,8589934588) S: [0,8589934588) Exits: ((zext i32 (ptrtoaddr ptr %arg to i32) to i64) + (4 * ((zext i32 (-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) /u 4))<nuw><nsw>) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> %i9 U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i10 = sub i64 %i9, %i4
; X32-NEXT: --> {0,+,4}<nuw><%bb6> U: [0,4294967293) S: [0,4294967293) Exits: (4 * ((zext i32 (-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) /u 4))<nuw><nsw> LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i11 = ashr exact i64 %i10, 2
@@ -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: --> (ptrtoaddr 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) + (ptrtoaddr 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}<nuw><%bb8> U: [1,0) S: [1,0) Exits: <<Unknown>> 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: <multiple exits> Unpredictable backedge-taken count.
; X64-NEXT: exit count for bb8: ***COULDNOTCOMPUTE***
-; X64-NEXT: exit count for bb10: (-2 + (-1 * %arg1) + (ptrtoaddr 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) + (ptrtoaddr 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) + (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr 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}<nuw><%bb8> U: [1,0) S: [1,0) Exits: <<Unknown>> 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: <multiple exits> Unpredictable backedge-taken count.
; X32-NEXT: exit count for bb8: ***COULDNOTCOMPUTE***
-; X32-NEXT: exit count for bb10: (-2 + (zext i32 (ptrtoaddr 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 (ptrtoaddr 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 (ptrtoaddr 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/scev-aa.ll b/llvm/test/Analysis/ScalarEvolution/scev-aa.ll
index a1d3699b3cb4b..30b7c45f8f5af 100644
--- a/llvm/test/Analysis/ScalarEvolution/scev-aa.ll
+++ b/llvm/test/Analysis/ScalarEvolution/scev-aa.ll
@@ -342,7 +342,7 @@ for.end:
}
; CHECK-LABEL: Function: test_different_pointer_bases_of_inttoptr: 2 pointers, 0 call sites
-; CHECK: NoAlias: <16 x i8>* %tmp5, <16 x i8>* %tmp7
+; CHECK: MayAlias: <16 x i8>* %tmp5, <16 x i8>* %tmp7
define void @test_different_pointer_bases_of_inttoptr() {
entry:
diff --git a/llvm/test/CodeGen/AArch64/ragreedy-csr.ll b/llvm/test/CodeGen/AArch64/ragreedy-csr.ll
index 249a08118386f..25752707f2719 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/LowOverheadLoops/while-loops.ll b/llvm/test/CodeGen/Thumb2/LowOverheadLoops/while-loops.ll
index cbcbf1f392ce8..a637fe0ca446b 100644
--- a/llvm/test/CodeGen/Thumb2/LowOverheadLoops/while-loops.ll
+++ b/llvm/test/CodeGen/Thumb2/LowOverheadLoops/while-loops.ll
@@ -161,81 +161,76 @@ define dso_local i32 @b(ptr %c, i32 %d, i32 %e, ptr %n) "frame-pointer"="all" {
; CHECK-NEXT: add r7, sp, #12
; CHECK-NEXT: .save {r8, r9, r10, r11}
; CHECK-NEXT: push.w {r8, r9, r10, r11}
-; CHECK-NEXT: .pad #16
-; CHECK-NEXT: sub sp, #16
+; CHECK-NEXT: .pad #12
+; CHECK-NEXT: sub sp, #12
; CHECK-NEXT: wls lr, r1, .LBB2_3
; CHECK-NEXT: @ %bb.1: @ %while.body.preheader
-; CHECK-NEXT: adds r6, r3, #4
-; CHECK-NEXT: adds r1, r0, #4
-; CHECK-NEXT: mvn r8, #1
-; CHECK-NEXT: @ implicit-def: $r9
-; CHECK-NEXT: @ implicit-def: $r4
+; CHECK-NEXT: mvn r10, #1
+; CHECK-NEXT: @ implicit-def: $r1
+; CHECK-NEXT: @ implicit-def: $r12
+; CHECK-NEXT: mov r4, r0
+; CHECK-NEXT: mov r9, r3
; CHECK-NEXT: str r2, [sp] @ 4-byte Spill
; CHECK-NEXT: .LBB2_2: @ %while.body
; CHECK-NEXT: @ =>This Inner Loop Header: Depth=1
-; CHECK-NEXT: str r1, [sp, #12] @ 4-byte Spill
-; CHECK-NEXT: asrs r2, r4, #31
-; CHECK-NEXT: ldr r1, [sp, #12] @ 4-byte Reload
-; CHECK-NEXT: ldr r1, [r1]
-; CHECK-NEXT: muls r1, r3, r1
-; CHECK-NEXT: adds r4, r4, r1
-; CHECK-NEXT: adc.w r1, r2, r1, asr #31
-; CHECK-NEXT: adds.w r2, r4, #-2147483648
-; CHECK-NEXT: ldrd r2, r4, [r8]
-; CHECK-NEXT: adc r5, r1, #0
-; CHECK-NEXT: str r2, [sp, #4] @ 4-byte Spill
-; CHECK-NEXT: smull r4, r2, r4, r9
-; CHECK-NEXT: asrs r1, r5, #31
-; CHECK-NEXT: str r5, [sp, #8] @ 4-byte Spill
-; CHECK-NEXT: subs r4, r5, r4
-; CHECK-NEXT: sbcs r1, r2
-; CHECK-NEXT: ldr r2, [sp, #12] @ 4-byte Reload
-; CHECK-NEXT: adds.w r10, r4, #-2147483648
-; CHECK-NEXT: adc r1, r1, #0
-; CHECK-NEXT: ldr r4, [r2, #-4]
+; CHECK-NEXT: strd r3, r4, [sp, #4] @ 8-byte Folded Spill
+; CHECK-NEXT: asr.w r5, r12, #31
+; CHECK-NEXT: ldr r2, [sp, #8] @ 4-byte Reload
+; CHECK-NEXT: ldr r4, [r2, #4]!
+; CHECK-NEXT: str r2, [sp, #8] @ 4-byte Spill
; CHECK-NEXT: muls r4, r3, r4
-; CHECK-NEXT: adds r3, #4
-; CHECK-NEXT: adds.w r12, r4, #-2147483648
-; CHECK-NEXT: asr.w r5, r4, #31
-; CHECK-NEXT: ldr r4, [r6]
-; CHECK-NEXT: adc r5, r5, #0
-; CHECK-NEXT: mul r2, r4, r0
-; CHECK-NEXT: adds r0, #4
-; CHECK-NEXT: add.w r2, r2, #-2147483648
-; CHECK-NEXT: asrl r12, r5, r2
-; CHECK-NEXT: smull r2, r5, r4, r12
-; CHECK-NEXT: lsll r2, r5, #30
-; CHECK-NEXT: ldr r2, [sp, #4] @ 4-byte Reload
-; CHECK-NEXT: asr.w r11, r5, #31
-; CHECK-NEXT: mov r12, r5
-; CHECK-NEXT: lsll r12, r11, r4
-; CHECK-NEXT: mul r2, r2, r9
-; CHECK-NEXT: lsrl r12, r11, #2
+; CHECK-NEXT: adds.w r6, r12, r4
+; CHECK-NEXT: adc.w r5, r5, r4, asr #31
+; CHECK-NEXT: adds.w r6, r6, #-2147483648
+; CHECK-NEXT: adc r12, r5, #0
+; CHECK-NEXT: ldrd r2, r5, [r10]
+; CHECK-NEXT: smull r5, r6, r5, r1
+; CHECK-NEXT: asr.w r4, r12, #31
+; CHECK-NEXT: muls r2, r1, r2
+; CHECK-NEXT: ldr r1, [sp, #4] @ 4-byte Reload
+; CHECK-NEXT: subs.w r5, r12, r5
+; CHECK-NEXT: sbcs r4, r6
+; CHECK-NEXT: adds.w r6, r5, #-2147483648
+; CHECK-NEXT: adc r5, r4, #0
+; CHECK-NEXT: ldr r4, [r0]
; CHECK-NEXT: adds r2, #2
-; CHECK-NEXT: lsll r12, r11, r2
+; CHECK-NEXT: muls r4, r3, r4
+; CHECK-NEXT: adds.w r8, r4, #-2147483648
+; CHECK-NEXT: asr.w r3, r4, #31
+; CHECK-NEXT: ldr r4, [r9, #4]!
+; CHECK-NEXT: adc r3, r3, #0
+; CHECK-NEXT: muls r0, r4, r0
+; CHECK-NEXT: add.w r0, r0, #-2147483648
+; CHECK-NEXT: asrl r8, r3, r0
+; CHECK-NEXT: smull r0, r3, r4, r8
+; CHECK-NEXT: lsll r0, r3, #30
+; CHECK-NEXT: asr.w r11, r3, #31
+; CHECK-NEXT: mov r0, r3
+; CHECK-NEXT: lsll r0, r11, r4
+; CHECK-NEXT: lsrl r0, r11, #2
+; CHECK-NEXT: lsll r0, r11, r2
+; CHECK-NEXT: add.w r0, r0, #-2147483648
+; CHECK-NEXT: asrl r6, r5, r0
+; CHECK-NEXT: movs r0, #2
+; CHECK-NEXT: lsrl r6, r5, #2
+; CHECK-NEXT: str r6, [r0]
+; CHECK-NEXT: ldr r0, [r10], #-4
+; CHECK-NEXT: mls r0, r0, r4, r12
+; CHECK-NEXT: ldr r4, [sp, #8] @ 4-byte Reload
+; CHECK-NEXT: adds.w r12, r0, #-2147483648
+; CHECK-NEXT: asr.w r2, r0, #31
+; CHECK-NEXT: adc r3, r2, #0
; CHECK-NEXT: ldr r2, [sp] @ 4-byte Reload
-; CHECK-NEXT: add.w r5, r12, #-2147483648
-; CHECK-NEXT: asrl r10, r1, r5
-; CHECK-NEXT: ldr r5, [sp, #8] @ 4-byte Reload
-; CHECK-NEXT: lsrl r10, r1, #2
-; CHECK-NEXT: movs r1, #2
-; CHECK-NEXT: mov r9, r10
-; CHECK-NEXT: str.w r10, [r1]
-; CHECK-NEXT: ldr r1, [r8], #-4
-; CHECK-NEXT: mls r5, r1, r4, r5
-; CHECK-NEXT: adds.w r4, r5, #-2147483648
-; CHECK-NEXT: asr.w r1, r5, #31
-; CHECK-NEXT: adc r1, r1, #0
-; CHECK-NEXT: lsrl r4, r1, #2
-; CHECK-NEXT: rsbs r1, r4, #0
-; CHECK-NEXT: str r1, [r2]
-; CHECK-NEXT: str r1, [r6, #-4]
-; CHECK-NEXT: adds r6, #4
-; CHECK-NEXT: ldr r1, [sp, #12] @ 4-byte Reload
-; CHECK-NEXT: adds r1, #4
+; CHECK-NEXT: lsrl r12, r3, #2
+; CHECK-NEXT: rsb.w r0, r12, #0
+; CHECK-NEXT: mov r3, r9
+; CHECK-NEXT: str r0, [r2]
+; CHECK-NEXT: str r0, [r1]
+; CHECK-NEXT: mov r0, r4
+; CHECK-NEXT: mov r1, r6
; CHECK-NEXT: le lr, .LBB2_2
; CHECK-NEXT: .LBB2_3: @ %while.end
-; CHECK-NEXT: add sp, #16
+; CHECK-NEXT: add sp, #12
; CHECK-NEXT: pop.w {r8, r9, r10, r11}
; CHECK-NEXT: pop {r4, r5, r6, r7, pc}
entry:
diff --git a/llvm/test/CodeGen/Thumb2/mve-tailpred-loopinvariant.ll b/llvm/test/CodeGen/Thumb2/mve-tailpred-loopinvariant.ll
index 6b2a6e63af23b..91828c4d698ab 100644
--- a/llvm/test/CodeGen/Thumb2/mve-tailpred-loopinvariant.ll
+++ b/llvm/test/CodeGen/Thumb2/mve-tailpred-loopinvariant.ll
@@ -8,25 +8,98 @@
define i32 @a(ptr readnone %b, ptr %c) {
; CHECK-LABEL: a:
; CHECK: @ %bb.0: @ %entry
-; CHECK-NEXT: .save {r4, lr}
-; CHECK-NEXT: push {r4, lr}
+; CHECK-NEXT: .save {r4, r5, r6, lr}
+; CHECK-NEXT: push {r4, r5, r6, lr}
+; CHECK-NEXT: .vsave {d8, d9, d10, d11, d12, d13, d14, d15}
+; CHECK-NEXT: vpush {d8, d9, d10, d11, d12, d13, d14, d15}
+; CHECK-NEXT: .pad #64
+; CHECK-NEXT: sub sp, #64
; CHECK-NEXT: cmp r0, r1
-; CHECK-NEXT: it ls
-; CHECK-NEXT: popls {r4, pc}
-; CHECK-NEXT: .LBB0_1: @ %while.body.preheader
-; CHECK-NEXT: subs r4, r0, r1
-; CHECK-NEXT: movs r2, #0
-; CHECK-NEXT: mov r3, r1
-; CHECK-NEXT: dlstp.8 lr, r4
+; CHECK-NEXT: bls .LBB0_3
+; CHECK-NEXT: @ %bb.1: @ %while.body.preheader
+; CHECK-NEXT: subs r2, r0, r1
+; CHECK-NEXT: movs r3, #1
+; CHECK-NEXT: add.w r0, r2, #15
+; CHECK-NEXT: vdup.32 q1, r2
+; CHECK-NEXT: bic r0, r0, #15
+; CHECK-NEXT: adr r2, .LCPI0_1
+; CHECK-NEXT: subs r0, #16
+; CHECK-NEXT: vldrw.u32 q4, [r2]
+; CHECK-NEXT: adr r2, .LCPI0_2
+; CHECK-NEXT: add r5, sp, #32
+; CHECK-NEXT: add.w lr, r3, r0, lsr #4
+; CHECK-NEXT: adr r3, .LCPI0_0
+; CHECK-NEXT: vldrw.u32 q5, [r2]
+; CHECK-NEXT: adr r2, .LCPI0_3
+; CHECK-NEXT: vldrw.u32 q0, [r3]
+; CHECK-NEXT: vldrw.u32 q6, [r2]
+; CHECK-NEXT: add r3, sp, #16
+; CHECK-NEXT: add r6, sp, #48
+; CHECK-NEXT: movs r0, #0
+; CHECK-NEXT: vmov.i8 q2, #0x0
+; CHECK-NEXT: vmov.i8 q3, #0xff
+; CHECK-NEXT: mov r2, r1
+; CHECK-NEXT: vstrw.32 q0, [sp] @ 16-byte Spill
; CHECK-NEXT: .LBB0_2: @ %vector.body
; CHECK-NEXT: @ =>This Inner Loop Header: Depth=1
-; CHECK-NEXT: adds r0, r1, r2
-; CHECK-NEXT: vidup.u8 q0, r0, #1
-; CHECK-NEXT: adds r2, #16
-; CHECK-NEXT: vstrb.8 q0, [r3], #16
-; CHECK-NEXT: letp lr, .LBB0_2
-; CHECK-NEXT: @ %bb.3: @ %while.end
-; CHECK-NEXT: pop {r4, pc}
+; CHECK-NEXT: vldrw.u32 q0, [sp] @ 16-byte Reload
+; CHECK-NEXT: adds r4, r1, r0
+; CHECK-NEXT: vqadd.u32 q7, q0, r0
+; CHECK-NEXT: vcmp.u32 hi, q1, q7
+; CHECK-NEXT: vpsel q7, q3, q2
+; CHECK-NEXT: vstrh.32 q7, [r5, #8]
+; CHECK-NEXT: vqadd.u32 q7, q4, r0
+; CHECK-NEXT: vcmp.u32 hi, q1, q7
+; CHECK-NEXT: vpsel q7, q3, q2
+; CHECK-NEXT: vstrh.32 q7, [r5]
+; CHECK-NEXT: vqadd.u32 q7, q5, r0
+; CHECK-NEXT: vcmp.u32 hi, q1, q7
+; CHECK-NEXT: vpsel q7, q3, q2
+; CHECK-NEXT: vstrh.32 q7, [r3, #8]
+; CHECK-NEXT: vqadd.u32 q7, q6, r0
+; CHECK-NEXT: vcmp.u32 hi, q1, q7
+; CHECK-NEXT: adds r0, #16
+; CHECK-NEXT: vpsel q7, q3, q2
+; CHECK-NEXT: vstrh.32 q7, [r3]
+; CHECK-NEXT: vldrw.u32 q7, [r5]
+; CHECK-NEXT: vcmp.i16 ne, q7, zr
+; CHECK-NEXT: vpsel q7, q3, q2
+; CHECK-NEXT: vstrb.16 q7, [r6, #8]
+; CHECK-NEXT: vldrw.u32 q7, [r3]
+; CHECK-NEXT: vcmp.i16 ne, q7, zr
+; CHECK-NEXT: vpsel q7, q3, q2
+; CHECK-NEXT: vstrb.16 q7, [r6]
+; CHECK-NEXT: vidup.u8 q7, r4, #1
+; CHECK-NEXT: vldrw.u32 q0, [r6]
+; CHECK-NEXT: vpt.i8 ne, q0, zr
+; CHECK-NEXT: vstrbt.8 q7, [r2], #16
+; CHECK-NEXT: le lr, .LBB0_2
+; CHECK-NEXT: .LBB0_3: @ %while.end
+; CHECK-NEXT: add sp, #64
+; CHECK-NEXT: vpop {d8, d9, d10, d11, d12, d13, d14, d15}
+; CHECK-NEXT: pop {r4, r5, r6, pc}
+; CHECK-NEXT: .p2align 4
+; CHECK-NEXT: @ %bb.4:
+; CHECK-NEXT: .LCPI0_0:
+; CHECK-NEXT: .long 12 @ 0xc
+; CHECK-NEXT: .long 13 @ 0xd
+; CHECK-NEXT: .long 14 @ 0xe
+; CHECK-NEXT: .long 15 @ 0xf
+; CHECK-NEXT: .LCPI0_1:
+; CHECK-NEXT: .long 8 @ 0x8
+; CHECK-NEXT: .long 9 @ 0x9
+; CHECK-NEXT: .long 10 @ 0xa
+; CHECK-NEXT: .long 11 @ 0xb
+; CHECK-NEXT: .LCPI0_2:
+; CHECK-NEXT: .long 4 @ 0x4
+; CHECK-NEXT: .long 5 @ 0x5
+; CHECK-NEXT: .long 6 @ 0x6
+; CHECK-NEXT: .long 7 @ 0x7
+; CHECK-NEXT: .LCPI0_3:
+; CHECK-NEXT: .long 0 @ 0x0
+; CHECK-NEXT: .long 1 @ 0x1
+; CHECK-NEXT: .long 2 @ 0x2
+; CHECK-NEXT: .long 3 @ 0x3
entry:
%cmp3 = icmp ugt ptr %b, %c
br i1 %cmp3, label %while.body.preheader, label %while.end
diff --git a/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll b/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll
index b0fbe8e62d056..86eb247742ce2 100644
--- a/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll
+++ b/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll
@@ -150,16 +150,20 @@ exit:
define i8 @testnullptrint(ptr %buf, ptr %end) nounwind {
; PTR64-LABEL: @testnullptrint(
+; 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: [[BI:%.*]] = ptrtoint ptr [[BUF:%.*]] to i32
-; PTR64-NEXT: [[EI:%.*]] = ptrtoint ptr [[END:%.*]] to i32
+; PTR64-NEXT: [[BI:%.*]] = ptrtoint ptr [[BUF]] to i32
+; PTR64-NEXT: [[EI:%.*]] = ptrtoint ptr [[END]] to i32
; PTR64-NEXT: [[CNT:%.*]] = sub i32 [[EI]], [[BI]]
; PTR64-NEXT: [[GUARD:%.*]] = icmp ult i32 0, [[CNT]]
; PTR64-NEXT: br i1 [[GUARD]], label [[PREHEADER:%.*]], label [[EXIT:%.*]]
; PTR64: preheader:
-; PTR64-NEXT: [[TMP1:%.*]] = add i32 [[EI]], -1
-; PTR64-NEXT: [[TMP2:%.*]] = sub i32 [[TMP1]], [[BI]]
+; PTR64-NEXT: [[TMP1:%.*]] = trunc i64 [[END1]] to i32
+; PTR64-NEXT: [[TMP5:%.*]] = add i32 [[TMP1]], -1
+; PTR64-NEXT: [[TMP6:%.*]] = trunc i64 [[BUF2]] to i32
+; PTR64-NEXT: [[TMP2:%.*]] = sub i32 [[TMP5]], [[TMP6]]
; PTR64-NEXT: [[TMP3:%.*]] = zext i32 [[TMP2]] to i64
; PTR64-NEXT: [[TMP4:%.*]] = add nuw nsw i64 [[TMP3]], 1
; PTR64-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr null, i64 [[TMP4]]
@@ -245,7 +249,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 +274,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/pr59633.ll b/llvm/test/Transforms/IndVarSimplify/pr59633.ll
index 1a47995884af8..bdafdfc47818f 100644
--- a/llvm/test/Transforms/IndVarSimplify/pr59633.ll
+++ b/llvm/test/Transforms/IndVarSimplify/pr59633.ll
@@ -7,12 +7,13 @@ declare void @foo(i64 noundef)
define void @pr59633(ptr noundef %ptr) {
; CHECK-LABEL: @pr59633(
; CHECK-NEXT: entry:
-; 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:%.*]]
; CHECK: while.body:
+; CHECK-NEXT: [[PTR_ADDR_0:%.*]] = phi ptr [ [[PTR:%.*]], [[ENTRY:%.*]] ], [ [[ADD_PTR:%.*]], [[WHILE_BODY]] ]
+; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[PTR_ADDR_0]] to i64
+; CHECK-NEXT: [[TMP1:%.*]] = and i64 [[TMP0]], 15
; CHECK-NEXT: tail call void @foo(i64 noundef [[TMP1]])
+; CHECK-NEXT: [[ADD_PTR]] = getelementptr inbounds i8, ptr [[PTR_ADDR_0]], i64 16
; CHECK-NEXT: br label [[WHILE_BODY]]
;
entry:
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 05ef5d111fe55..36ab894f9dd3c 100644
--- a/llvm/test/Transforms/LoopIdiom/reuse-lcssa-phi-scev-expansion.ll
+++ b/llvm/test/Transforms/LoopIdiom/reuse-lcssa-phi-scev-expansion.ll
@@ -227,27 +227,20 @@ 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:%.*]] = 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]] ]
; CHECK-NEXT: [[P_0:%.*]] = phi ptr [ [[A]], %[[ENTRY]] ], [ [[P_0_NEXT:%.*]], %[[LOOP_1]] ]
; CHECK-NEXT: [[P_0_NEXT]] = getelementptr i8, ptr [[P_0]], i64 -1
; CHECK-NEXT: call void @foo()
-; CHECK-NEXT: [[INDVAR_NEXT]] = add i32 [[INDVAR]], 1
; CHECK-NEXT: br i1 false, label %[[MIDDLE:.*]], label %[[LOOP_1]]
; CHECK: [[MIDDLE]]:
-; CHECK-NEXT: [[INDVAR_LCSSA:%.*]] = phi i32 [ [[INDVAR]], %[[LOOP_1]] ]
; CHECK-NEXT: [[P_0_LCSSA:%.*]] = phi ptr [ [[P_0]], %[[LOOP_1]] ]
; CHECK-NEXT: [[P_0_TO_INT:%.*]] = ptrtoint ptr [[P_0_LCSSA]] to i64
; CHECK-NEXT: [[TRUNC:%.*]] = trunc i64 [[P_0_TO_INT]] to i32
; CHECK-NEXT: [[TMP0:%.*]] = zext i32 [[TRUNC]] to i64
-; CHECK-NEXT: [[TMP1:%.*]] = mul nsw i64 [[TMP0]], -1
+; CHECK-NEXT: [[TMP1:%.*]] = sub i64 0, [[TMP0]]
; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[B]], i64 [[TMP1]]
-; CHECK-NEXT: [[TMP2:%.*]] = trunc i64 [[A1]] to i32
-; CHECK-NEXT: [[TMP3:%.*]] = add i32 [[TMP2]], 1
-; CHECK-NEXT: [[TMP6:%.*]] = mul i32 [[INDVAR_LCSSA]], -1
-; CHECK-NEXT: [[TMP5:%.*]] = add i32 [[TMP6]], [[TMP3]]
+; CHECK-NEXT: [[TMP5:%.*]] = add i32 [[TRUNC]], 1
; CHECK-NEXT: [[TMP4:%.*]] = zext i32 [[TMP5]] to i64
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[SCEVGEP]], i8 0, i64 [[TMP4]], i1 false)
; CHECK-NEXT: br label %[[LOOP_2:.*]]
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 3eade6474e61f..b3b2f657f07c4 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 bb759aefcdf44..277489dd34a08 100644
--- a/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll
+++ b/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll
@@ -11,33 +11,30 @@ 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:%.*]] = 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:%.*]] ]
-; CHECK-NEXT: [[IV:%.*]] = phi ptr [ [[IV_NEXT:%.*]], [[LOOP_1_HEADER]] ], [ [[START]], [[ENTRY]] ]
+; CHECK-NEXT: [[IV:%.*]] = phi ptr [ [[IV_NEXT:%.*]], [[LOOP_1_HEADER]] ], [ [[START:%.*]], [[ENTRY:%.*]] ]
; CHECK-NEXT: [[IV_NEXT]] = getelementptr inbounds [[STRUCT_HOGE:%.*]], ptr [[IV]], i64 1
-; CHECK-NEXT: [[LSR_IV_NEXT5]] = add nuw i64 [[LSR_IV4]], 16
; CHECK-NEXT: [[EC:%.*]] = icmp eq ptr [[IV_NEXT]], [[END:%.*]]
; CHECK-NEXT: br i1 [[EC]], label [[LOOP_2_PH:%.*]], label [[LOOP_1_HEADER]]
; CHECK: loop.2.ph:
-; CHECK-NEXT: [[LSR_IV_NEXT5_LCSSA:%.*]] = phi i64 [ [[LSR_IV_NEXT5]], [[LOOP_1_HEADER]] ]
-; CHECK-NEXT: [[IV_NEXT_LCSSA:%.*]] = phi ptr [ [[IV_NEXT]], [[LOOP_1_HEADER]] ]
+; CHECK-NEXT: [[IV_NEXT_LCSSA:%.*]] = getelementptr i8, ptr [[IV_NEXT]], i64 12
; CHECK-NEXT: br label [[LOOP_2_HEADER:%.*]]
; CHECK: loop.2.header:
-; CHECK-NEXT: [[LSR_IV2:%.*]] = phi i64 [ [[LSR_IV_NEXT3:%.*]], [[LOOP_2_LATCH:%.*]] ], [ [[LSR_IV_NEXT5_LCSSA]], [[LOOP_2_PH]] ]
-; CHECK-NEXT: [[IV2:%.*]] = phi ptr [ [[IV2_NEXT:%.*]], [[LOOP_2_LATCH]] ], [ [[IV_NEXT_LCSSA]], [[LOOP_2_PH]] ]
-; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[LSR_IV2]], 12
+; CHECK-NEXT: [[IV2:%.*]] = phi ptr [ [[IV2_NEXT:%.*]], [[LOOP_2_LATCH:%.*]] ], [ [[IV_NEXT_LCSSA]], [[LOOP_2_PH]] ]
+; CHECK-NEXT: [[SCEVGEP5:%.*]] = getelementptr i8, ptr [[IV2]], i64 -12
+; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[IV2]] to i64
; CHECK-NEXT: call void @use.i64(i64 [[TMP0]])
-; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[IV2]], i64 8
+; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[IV2]], i64 -4
; CHECK-NEXT: store i32 10, ptr [[SCEVGEP]], align 8
-; CHECK-NEXT: [[EC_2:%.*]] = icmp ugt ptr [[IV2]], [[PTR_2:%.*]]
+; CHECK-NEXT: [[EC_2:%.*]] = icmp ugt ptr [[SCEVGEP5]], [[PTR_2:%.*]]
; CHECK-NEXT: br i1 [[EC_2]], label [[LOOP_2_EXIT:%.*]], label [[LOOP_2_LATCH]]
; CHECK: loop.2.latch:
-; CHECK-NEXT: [[IV2_NEXT]] = getelementptr inbounds [[STRUCT_HOGE]], ptr [[IV2]], i64 1
-; CHECK-NEXT: [[LSR_IV_NEXT3]] = add i64 [[LSR_IV2]], 16
+; CHECK-NEXT: [[IV2_NEXT]] = getelementptr i8, ptr [[IV2]], i64 16
; CHECK-NEXT: br label [[LOOP_2_HEADER]]
; CHECK: loop.2.exit:
+; CHECK-NEXT: [[SCEVGEP4:%.*]] = getelementptr i8, ptr [[IV2]], i64 -12
+; CHECK-NEXT: [[LSR_IV2:%.*]] = ptrtoint ptr [[SCEVGEP4]] to i64
; CHECK-NEXT: ret i64 [[LSR_IV2]]
;
entry:
diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll b/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll
index 3eaf4c4b1b3f4..70d15bb740284 100644
--- a/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll
+++ b/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll
@@ -17,11 +17,11 @@ define void @test_interleave_reduction(ptr %arg, ptr %arg1) {
; A320: [[OUTER]]:
; A320-NEXT: [[TPM26:%.*]] = add i64 0, 1
; A320-NEXT: [[TPM10:%.*]] = alloca i32, align 8
-; A320-NEXT: [[TPM102:%.*]] = ptrtoint ptr [[TPM10]] to i64
+; A320-NEXT: [[TPM102:%.*]] = ptrtoaddr ptr [[TPM10]] to i64
; A320-NEXT: [[TPM27:%.*]] = getelementptr inbounds i32, ptr [[TPM10]], i64 [[TPM26]]
; A320-NEXT: [[TPM28:%.*]] = getelementptr inbounds ptr, ptr [[TPM15]], i64 0
; A320-NEXT: [[TPM29:%.*]] = load ptr, ptr [[TPM28]], align 8
-; A320-NEXT: [[TPM291:%.*]] = ptrtoint ptr [[TPM29]] to i64
+; A320-NEXT: [[TPM291:%.*]] = ptrtoaddr ptr [[TPM29]] to i64
; A320-NEXT: [[TPM17:%.*]] = alloca double, align 8
; A320-NEXT: [[TPM32:%.*]] = getelementptr inbounds double, ptr [[TPM17]], i64 [[TPM26]]
; A320-NEXT: [[TMP0:%.*]] = add i64 [[TPM291]], -8
diff --git a/llvm/test/Transforms/LoopVectorize/induction-ptrcasts.ll b/llvm/test/Transforms/LoopVectorize/induction-ptrcasts.ll
index a744025cf3889..9ed17f194c5aa 100644
--- a/llvm/test/Transforms/LoopVectorize/induction-ptrcasts.ll
+++ b/llvm/test/Transforms/LoopVectorize/induction-ptrcasts.ll
@@ -7,31 +7,30 @@
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: [[TMP0:%.*]] = add i64 [[TMP6]], -1
+; VF1-NEXT: [[ENTRY1:.*:]]
+; VF1-NEXT: [[SMIN:%.*]] = call i64 @llvm.smin.i64(i64 add (i64 ptrtoaddr (ptr @f to i64), i64 -4), i64 0)
+; VF1-NEXT: [[TMP0:%.*]] = sub i64 add (i64 ptrtoaddr (ptr @f to i64), i64 -1), [[SMIN]]
; VF1-NEXT: [[TMP1:%.*]] = lshr i64 [[TMP0]], 2
; VF1-NEXT: [[TMP2:%.*]] = add nuw nsw i64 [[TMP1]], 1
; VF1-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP2]], 2
-; VF1-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]]
-; VF1: [[VECTOR_PH]]:
+; VF1-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[ENTRY:.*]]
+; VF1: [[ENTRY]]:
; VF1-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[TMP2]], 2
; VF1-NEXT: [[N_VEC:%.*]] = sub i64 [[TMP2]], [[N_MOD_VF]]
; VF1-NEXT: [[TMP4:%.*]] = shl i64 [[N_VEC]], 2
; VF1-NEXT: [[TMP5:%.*]] = getelementptr i8, ptr null, i64 [[TMP4]]
-; VF1-NEXT: br label %[[VECTOR_BODY:.*]]
-; VF1: [[VECTOR_BODY]]:
-; VF1-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
-; VF1-NEXT: [[OFFSET_IDX:%.*]] = shl i64 [[INDEX]], 2
-; VF1-NEXT: [[INDUCTION3:%.*]] = add i64 [[OFFSET_IDX]], 4
+; VF1-NEXT: br label %[[LOOP:.*]]
+; VF1: [[LOOP]]:
+; VF1-NEXT: [[INDUCTION3:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_INT_NEXT:%.*]], %[[LOOP]] ]
+; VF1-NEXT: [[OFFSET_IDX:%.*]] = shl i64 [[INDUCTION3]], 2
+; VF1-NEXT: [[TMP6:%.*]] = add i64 [[OFFSET_IDX]], 4
; VF1-NEXT: [[TMP7:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[OFFSET_IDX]]
-; VF1-NEXT: [[TMP8:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[INDUCTION3]]
+; VF1-NEXT: [[TMP10:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[TMP6]]
; VF1-NEXT: store i8 0, ptr [[TMP7]], align 1
-; VF1-NEXT: store i8 0, ptr [[TMP8]], align 1
-; VF1-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
-; VF1-NEXT: [[TMP9:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]]
-; VF1-NEXT: br i1 [[TMP9]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP0:![0-9]+]]
+; VF1-NEXT: store i8 0, ptr [[TMP10]], align 1
+; VF1-NEXT: [[IV_INT_NEXT]] = add nuw i64 [[INDUCTION3]], 2
+; VF1-NEXT: [[TMP9:%.*]] = icmp eq i64 [[IV_INT_NEXT]], [[N_VEC]]
+; VF1-NEXT: br i1 [[TMP9]], label %[[MIDDLE_BLOCK:.*]], label %[[LOOP]], !llvm.loop [[LOOP0:![0-9]+]]
; VF1: [[MIDDLE_BLOCK]]:
; VF1-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[TMP2]], [[N_VEC]]
; VF1-NEXT: br i1 [[CMP_N]], [[EXIT:label %.*]], label %[[SCALAR_PH]]
@@ -39,31 +38,30 @@ 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: [[TMP0:%.*]] = add i64 [[TMP7]], -1
+; VF2-NEXT: [[ENTRY1:.*:]]
+; VF2-NEXT: [[SMIN:%.*]] = call i64 @llvm.smin.i64(i64 add (i64 ptrtoaddr (ptr @f to i64), i64 -4), i64 0)
+; VF2-NEXT: [[TMP0:%.*]] = sub i64 add (i64 ptrtoaddr (ptr @f to i64), i64 -1), [[SMIN]]
; VF2-NEXT: [[TMP1:%.*]] = lshr i64 [[TMP0]], 2
; VF2-NEXT: [[TMP2:%.*]] = add nuw nsw i64 [[TMP1]], 1
; VF2-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP2]], 2
-; VF2-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[VECTOR_PH:.*]]
-; VF2: [[VECTOR_PH]]:
+; VF2-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[SCALAR_PH:.*]], label %[[ENTRY:.*]]
+; VF2: [[ENTRY]]:
; VF2-NEXT: [[N_MOD_VF:%.*]] = urem i64 [[TMP2]], 2
; VF2-NEXT: [[N_VEC:%.*]] = sub i64 [[TMP2]], [[N_MOD_VF]]
-; VF2-NEXT: [[TMP6:%.*]] = shl i64 [[N_VEC]], 2
-; VF2-NEXT: [[TMP5:%.*]] = getelementptr i8, ptr null, i64 [[TMP6]]
-; VF2-NEXT: br label %[[VECTOR_BODY:.*]]
-; VF2: [[VECTOR_BODY]]:
-; VF2-NEXT: [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
-; VF2-NEXT: [[OFFSET_IDX:%.*]] = shl i64 [[INDEX]], 2
-; VF2-NEXT: [[TMP4:%.*]] = add i64 [[OFFSET_IDX]], 4
-; VF2-NEXT: [[TMP9:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[OFFSET_IDX]]
-; VF2-NEXT: [[TMP10:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[TMP4]]
-; VF2-NEXT: store i8 0, ptr [[TMP9]], align 1
-; VF2-NEXT: store i8 0, ptr [[TMP10]], align 1
-; VF2-NEXT: [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
-; VF2-NEXT: [[TMP11:%.*]] = icmp eq i64 [[INDEX_NEXT]], [[N_VEC]]
-; VF2-NEXT: br i1 [[TMP11]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP0:![0-9]+]]
+; VF2-NEXT: [[TMP11:%.*]] = shl i64 [[N_VEC]], 2
+; VF2-NEXT: [[TMP5:%.*]] = getelementptr i8, ptr null, i64 [[TMP11]]
+; VF2-NEXT: br label %[[LOOP:.*]]
+; VF2: [[LOOP]]:
+; VF2-NEXT: [[TMP4:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_INT_NEXT:%.*]], %[[LOOP]] ]
+; VF2-NEXT: [[OFFSET_IDX:%.*]] = shl i64 [[TMP4]], 2
+; VF2-NEXT: [[TMP6:%.*]] = add i64 [[OFFSET_IDX]], 4
+; VF2-NEXT: [[TMP7:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[OFFSET_IDX]]
+; VF2-NEXT: [[TMP8:%.*]] = getelementptr inbounds i8, ptr [[A]], i64 [[TMP6]]
+; VF2-NEXT: store i8 0, ptr [[TMP7]], align 1
+; VF2-NEXT: store i8 0, ptr [[TMP8]], align 1
+; VF2-NEXT: [[IV_INT_NEXT]] = add nuw i64 [[TMP4]], 2
+; VF2-NEXT: [[TMP9:%.*]] = icmp eq i64 [[IV_INT_NEXT]], [[N_VEC]]
+; VF2-NEXT: br i1 [[TMP9]], label %[[MIDDLE_BLOCK:.*]], label %[[LOOP]], !llvm.loop [[LOOP0:![0-9]+]]
; VF2: [[MIDDLE_BLOCK]]:
; VF2-NEXT: [[CMP_N:%.*]] = icmp eq i64 [[TMP2]], [[N_VEC]]
; VF2-NEXT: br i1 [[CMP_N]], [[EXIT:label %.*]], label %[[SCALAR_PH]]
diff --git a/llvm/unittests/Analysis/ScalarEvolutionTest.cpp b/llvm/unittests/Analysis/ScalarEvolutionTest.cpp
index 99edc5b25f3e2..286811bc7bc42 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);
>From 63e3cec39c1d1b4a67f2fe03ee1835e42eaeb94d Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Mon, 16 Feb 2026 12:36:24 +0000
Subject: [PATCH 06/14] !fixup support a few more patterns.
---
llvm/lib/Analysis/ScalarEvolution.cpp | 28 +++++++++----
.../Utils/ScalarEvolutionExpander.cpp | 19 +++++++++
.../IndVarSimplify/2011-11-01-lftrptr.ll | 12 ++----
.../epilog-vectorization-scev-expansion.ll | 41 +++++++++++++++++++
4 files changed, 83 insertions(+), 17 deletions(-)
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 537b2ef48957b..067f11e0c26de 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -5946,6 +5946,21 @@ const SCEV *ScalarEvolution::createAddRecFromPHI(PHINode *PN) {
// the back-edge.
const SCEV *BEValue = getSCEV(BEValueV);
+ // If the backedge value is an SCEVUnknown from a ptrtoint, try to use
+ // ptrtoaddr to get a usable SCEV expression. This allows recognizing
+ // integer induction variables derived from pointer inductions.
+ if (isa<SCEVUnknown>(BEValue))
+ if (auto *PTI = dyn_cast<PtrToIntInst>(BEValueV)) {
+ const SCEV *PtrAddr = getPtrToAddrExpr(getSCEV(PTI->getOperand(0)));
+ if (!isa<SCEVCouldNotCompute>(PtrAddr)) {
+ // Adjust type to match the ptrtoint result type if needed.
+ Type *DestTy = PTI->getType();
+ if (PtrAddr->getType() != DestTy)
+ PtrAddr = getTruncateOrZeroExtend(PtrAddr, DestTy);
+ BEValue = PtrAddr;
+ }
+ }
+
// NOTE: If BEValue is loop invariant, we know that the PHI node just
// has a special value for the first iteration of the loop.
@@ -8361,15 +8376,10 @@ 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<SCEVCouldNotCompute>(IntOp))
- return getUnknown(V);
- return IntOp;
+ // IMPORTANT: Do NOT use getPtrToAddrExpr here! Using SCEVPtrToAddr for
+ // PtrToInt is NOT safe because the expander may replace IR ptrtoint with
+ // ptrtoaddr, which changes semantics. We must keep ptrtoint as SCEVUnknown.
+ return getUnknown(V);
}
case Instruction::IntToPtr:
// Just don't deal with inttoptr casts.
diff --git a/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp b/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp
index 7a775acb7bd5a..d7c499542e475 100644
--- a/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp
+++ b/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp
@@ -1477,6 +1477,25 @@ Value *SCEVExpander::visitPtrToIntExpr(SCEVUseT<const SCEVPtrToIntExpr *> S) {
}
Value *SCEVExpander::visitTruncateExpr(SCEVUseT<const SCEVTruncateExpr *> 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<SCEVPtrToAddrExpr>(S->getOperand())) {
+ Value *PtrOp = expand(PtrToAddr->getOperand());
+ if (!isa<Constant>(PtrOp)) {
+ BasicBlock::iterator BIP = Builder.GetInsertPoint();
+ for (User *U : PtrOp->users()) {
+ auto *CI = dyn_cast<CastInst>(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/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll b/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll
index 86eb247742ce2..259ee322bdc00 100644
--- a/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll
+++ b/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll
@@ -150,20 +150,16 @@ exit:
define i8 @testnullptrint(ptr %buf, ptr %end) nounwind {
; PTR64-LABEL: @testnullptrint(
-; 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: [[BI:%.*]] = ptrtoint ptr [[BUF]] to i32
-; PTR64-NEXT: [[EI:%.*]] = ptrtoint ptr [[END]] to i32
+; PTR64-NEXT: [[BI:%.*]] = ptrtoint ptr [[BUF:%.*]] to i32
+; PTR64-NEXT: [[EI:%.*]] = ptrtoint ptr [[END:%.*]] to i32
; PTR64-NEXT: [[CNT:%.*]] = sub i32 [[EI]], [[BI]]
; PTR64-NEXT: [[GUARD:%.*]] = icmp ult i32 0, [[CNT]]
; PTR64-NEXT: br i1 [[GUARD]], label [[PREHEADER:%.*]], label [[EXIT:%.*]]
; PTR64: preheader:
-; PTR64-NEXT: [[TMP1:%.*]] = trunc i64 [[END1]] to i32
-; PTR64-NEXT: [[TMP5:%.*]] = add i32 [[TMP1]], -1
-; PTR64-NEXT: [[TMP6:%.*]] = trunc i64 [[BUF2]] to i32
-; PTR64-NEXT: [[TMP2:%.*]] = sub i32 [[TMP5]], [[TMP6]]
+; PTR64-NEXT: [[TMP1:%.*]] = add i32 [[EI]], -1
+; PTR64-NEXT: [[TMP2:%.*]] = sub i32 [[TMP1]], [[BI]]
; PTR64-NEXT: [[TMP3:%.*]] = zext i32 [[TMP2]] to i64
; PTR64-NEXT: [[TMP4:%.*]] = add nuw nsw i64 [[TMP3]], 1
; PTR64-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr null, i64 [[TMP4]]
diff --git a/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll b/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll
index cd502b080d7bd..41f527b97ecaf 100644
--- a/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll
+++ b/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll
@@ -71,3 +71,44 @@ loop:
exit:
ret void
}
+
+; Test that SCEV expander reuses existing ptrtoint instructions when expanding
+; ptrtoaddr expressions for trip count calculation.
+define void @test_scev_expansion_reuses_ptrtoint(ptr %base, i64 %n) {
+; CHECK-LABEL: define void @test_scev_expansion_reuses_ptrtoint(
+; CHECK-SAME: ptr [[BASE:%.*]], i64 [[N:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: [[BASE_INT:%.*]] = ptrtoint ptr [[BASE]] to i64
+; CHECK-NEXT: [[DUMMY:%.*]] = add i64 [[BASE_INT]], 1
+; CHECK-NEXT: call void @use(i64 [[DUMMY]])
+; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i64 [[N]], 0
+; CHECK-NEXT: br i1 [[CMP]], label %[[LOOP_PH:.*]], label %[[EXIT:.*]]
+; CHECK: [[LOOP_PH]]:
+; Verify that the existing ptrtoint (%base.int) is reused in trip count computation.
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[N]], [[BASE_INT]]
+; CHECK-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[BASE_INT]], i64 [[TMP0]])
+; CHECK-NOT: ptrtoaddr
+entry:
+ %base.int = ptrtoint ptr %base to i64
+ %dummy = add i64 %base.int, 1
+ call void @use(i64 %dummy)
+ %cmp = icmp ugt i64 %n, 0
+ br i1 %cmp, label %loop.ph, label %exit
+
+loop.ph:
+ br label %loop
+
+loop:
+ %iv = phi i64 [ 0, %loop.ph ], [ %iv.next, %loop ]
+ %ptr = getelementptr inbounds i8, ptr %base, i64 %iv
+ store i8 0, ptr %ptr, align 1
+ %iv.next = add nuw i64 %iv, 1
+ %end = getelementptr inbounds i8, ptr %base, i64 %n
+ %cmp.loop = icmp ult ptr %ptr, %end
+ br i1 %cmp.loop, label %loop, label %exit
+
+exit:
+ ret void
+}
+
+declare void @use(i64)
>From 63b1b6b9defbea1a71e134fe10882a96af29ed61 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Fri, 13 Mar 2026 10:40:00 +0000
Subject: [PATCH 07/14] !fixup update new tests
---
...sform-narrow-interleave-to-widen-memory-cost.ll | 2 +-
.../LoopVectorize/X86/fold-tail-low-trip-count.ll | 4 ++--
.../LoopVectorize/runtime-checks-difference.ll | 14 +++++---------
3 files changed, 8 insertions(+), 12 deletions(-)
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 345dbaf761539..c471b5668f021 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/X86/fold-tail-low-trip-count.ll b/llvm/test/Transforms/LoopVectorize/X86/fold-tail-low-trip-count.ll
index 9122a2f600afd..0e5a3b338712a 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: [[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]], 1
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; CHECK-NEXT: br label %[[VECTOR_PH:.*]]
diff --git a/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll b/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
index f7ff1ff733082..56e45039eed95 100644
--- a/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
+++ b/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
@@ -526,12 +526,6 @@ define void @diff_check_via_i32_ptrarith(ptr %origin, ptr %dst, ptr %base, i32 %
; 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: [[TMP13:%.*]] = sub i64 [[LHS]], [[TMP12]]
; CHECK-NEXT: [[TMP14:%.*]] = sub i64 [[TMP13]], 1
; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP14]], 3
@@ -571,6 +565,7 @@ define void @phi_of_ptrtoint_diff_check(ptr %base, ptr %end, i64 %n, i1 %cond) {
; CHECK-LABEL: define void @phi_of_ptrtoint_diff_check(
; CHECK-SAME: ptr [[BASE:%.*]], ptr [[END:%.*]], i64 [[N:%.*]], i1 [[COND:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: [[BASE2:%.*]] = ptrtoaddr ptr [[BASE]] to i64
; CHECK-NEXT: [[END_INT:%.*]] = ptrtoint ptr [[END]] to i64
; CHECK-NEXT: [[EXT:%.*]] = getelementptr inbounds nuw i8, ptr [[END]], i64 [[N]]
; CHECK-NEXT: [[EXT_INT:%.*]] = ptrtoint ptr [[EXT]] to i64
@@ -588,12 +583,13 @@ define void @phi_of_ptrtoint_diff_check(ptr %base, ptr %end, i64 %n, i1 %cond) {
; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[SRC]], [[END]]
; CHECK-NEXT: br i1 [[CMP]], label %[[LOOP_PREHEADER:.*]], [[EXIT:label %.*]]
; CHECK: [[LOOP_PREHEADER]]:
-; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[N]], [[END_INT]]
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[END2_INT]], [[END_INT]]
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[DST_INT]]
-; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP1]], 4
+; CHECK-NEXT: [[TMP4:%.*]] = sub i64 [[TMP1]], [[BASE2]]
+; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP4]], 4
; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], [[SCALAR_PH:label %.*]], label %[[VECTOR_MEMCHECK:.*]]
; CHECK: [[VECTOR_MEMCHECK]]:
-; CHECK-NEXT: [[TMP2:%.*]] = add i64 [[N]], [[DST_PTR1]]
+; CHECK-NEXT: [[TMP2:%.*]] = add i64 [[END2_INT]], [[DST_PTR1]]
; CHECK-NEXT: [[TMP3:%.*]] = sub i64 [[TMP2]], [[DST_INT]]
; CHECK-NEXT: [[TMP4:%.*]] = sub i64 [[TMP3]], 1
; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP4]], 3
>From d8baf4b61ae0de6eb05008dec0c16474e3a9d381 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Sat, 14 Mar 2026 09:32:21 +0000
Subject: [PATCH 08/14] !fixup support sub
---
llvm/lib/Analysis/ScalarEvolution.cpp | 48 ++++---
.../test/Analysis/ScalarEvolution/ptrtoint.ll | 16 +--
.../ScalarEvolution/two-loop-latches.ll | 12 +-
.../Thumb2/LowOverheadLoops/while-loops.ll | 125 +++++++++---------
.../Thumb2/mve-tailpred-loopinvariant.ll | 121 ++++-------------
.../test/Transforms/IndVarSimplify/pr45835.ll | 12 +-
.../test/Transforms/IndVarSimplify/pr59633.ll | 7 +-
.../reuse-lcssa-phi-scev-expansion.ll | 11 +-
.../X86/expander-crashes.ll | 23 ++--
.../AArch64/aggressive-interleaving.ll | 4 +-
.../epilog-vectorization-scev-expansion.ll | 61 ++-------
.../runtime-checks-difference.ll | 14 +-
12 files changed, 185 insertions(+), 269 deletions(-)
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 067f11e0c26de..73ad035790c51 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -8091,20 +8091,33 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
if (BO->Op)
Flags = getNoWrapFlagsFromUB(BO->Op);
- // Special case: sub (ptrtoint p1), (ptrtoint p2) -> subtract of ptrtoaddr
- // expressions. While we don't model ptrtoint directly in SCEV, the
+ // 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;
- if (match(BO->LHS, m_PtrToInt(m_Value(PtrLHS))) &&
- match(BO->RHS, m_PtrToInt(m_Value(PtrRHS)))) {
- const SCEV *AddrLHS = getPtrToAddrExpr(getSCEV(PtrLHS));
- const SCEV *AddrRHS = getPtrToAddrExpr(getSCEV(PtrRHS));
- if (!isa<SCEVCouldNotCompute>(AddrLHS) &&
- !isa<SCEVCouldNotCompute>(AddrRHS)) {
- Type *Ty = BO->LHS->getType();
- return getMinusSCEV(getTruncateOrZeroExtend(AddrLHS, Ty),
- getTruncateOrZeroExtend(AddrRHS, Ty), Flags);
- }
+ 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 to ptrtoaddr. When only one side
+ // is ptrtoint, skip SCEVUnknown pointers since wrapping them
+ // in ptrtoaddr adds no useful structure.
+ auto GetOp = [&](bool HasPtr, Value *PtrOp, Value *IntOp,
+ bool OtherHasPtr) -> const SCEV * {
+ if (HasPtr) {
+ const SCEV *PtrSCEV = getSCEV(PtrOp);
+ if (OtherHasPtr || !isa<SCEVUnknown>(PtrSCEV)) {
+ const SCEV *Addr = getPtrToAddrExpr(PtrSCEV);
+ if (!isa<SCEVCouldNotCompute>(Addr) &&
+ getTypeSizeInBits(IntOp->getType()) <=
+ getTypeSizeInBits(Addr->getType()))
+ return getTruncateOrZeroExtend(Addr, IntOp->getType());
+ }
+ }
+ return getSCEV(IntOp);
+ };
+ 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);
@@ -8376,9 +8389,14 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
}
case Instruction::PtrToInt: {
- // IMPORTANT: Do NOT use getPtrToAddrExpr here! Using SCEVPtrToAddr for
- // PtrToInt is NOT safe because the expander may replace IR ptrtoint with
- // ptrtoaddr, which changes semantics. We must keep ptrtoint as SCEVUnknown.
+ // Keep ptrtoint as SCEVUnknown, except ptrtoint of a pointer add-rec to
+ // preserve the integer induction structure.
+ const SCEV *PtrSCEV = getSCEV(U->getOperand(0));
+ if (isa<SCEVAddRecExpr>(PtrSCEV)) {
+ const SCEV *Addr = getPtrToAddrExpr(PtrSCEV);
+ if (!isa<SCEVCouldNotCompute>(Addr))
+ return Addr;
+ }
return getUnknown(V);
}
case Instruction::IntToPtr:
diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
index be34e7c6b3a54..5882700a783af 100644
--- a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
+++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
@@ -218,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))<nuw><nsw> + %in) LoopDispositions: { %loop: Computable }
; X64-NEXT: %i8 = ptrtoint ptr %i7 to i64
-; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
+; X64-NEXT: --> {(ptrtoaddr ptr %in to i64),+,4}<%loop> U: full-set S: full-set Exits: (-4 + (4 * (zext i32 %count to i64))<nuw><nsw> + (ptrtoaddr ptr %in to i64)) LoopDispositions: { %loop: Computable }
; X64-NEXT: %i9 = add nuw nsw i64 %i6, 1
; X64-NEXT: --> {1,+,1}<nuw><%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
@@ -236,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: --> %i8 U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
+; X32-NEXT: --> (zext i32 {(ptrtoaddr ptr %in to i32),+,4}<%loop> to i64) U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (-4 + (4 * %count) + (ptrtoaddr ptr %in to i32)) to i64) LoopDispositions: { %loop: Computable }
; X32-NEXT: %i9 = add nuw nsw i64 %i6, 1
; X32-NEXT: --> {1,+,1}<nuw><%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
@@ -374,7 +374,7 @@ define void @pr46786_c26_char(ptr %arg, ptr %arg1, ptr %arg2) {
; X64-NEXT: %i8 = load i8, ptr %i7, align 1
; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X64-NEXT: --> %i9 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
+; X64-NEXT: --> {(ptrtoaddr ptr %arg to i64),+,1}<nuw><%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}<nuw><%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
@@ -400,7 +400,7 @@ define void @pr46786_c26_char(ptr %arg, ptr %arg1, ptr %arg2) {
; X32-NEXT: %i8 = load i8, ptr %i7, align 1
; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X32-NEXT: --> %i9 U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
+; X32-NEXT: --> {(zext i32 (ptrtoaddr ptr %arg to i32) to i64),+,1}<nuw><%bb6> U: [0,8589934590) S: [0,8589934590) Exits: ((zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) + (zext i32 (ptrtoaddr ptr %arg to i32) to i64)) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i10 = sub i64 %i9, %i4
; X32-NEXT: --> {0,+,1}<nuw><%bb6> U: [0,4294967295) S: [0,4294967295) Exits: (zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10
@@ -451,7 +451,7 @@ define void @pr46786_c26_char_cmp_ops_swapped(ptr %arg, ptr %arg1, ptr %arg2) {
; X64-NEXT: %i8 = load i8, ptr %i7, align 1
; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X64-NEXT: --> %i9 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
+; X64-NEXT: --> {(ptrtoaddr ptr %arg to i64),+,1}<nuw><%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}<nuw><%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
@@ -477,7 +477,7 @@ define void @pr46786_c26_char_cmp_ops_swapped(ptr %arg, ptr %arg1, ptr %arg2) {
; X32-NEXT: %i8 = load i8, ptr %i7, align 1
; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X32-NEXT: --> %i9 U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
+; X32-NEXT: --> {(zext i32 (ptrtoaddr ptr %arg to i32) to i64),+,1}<nuw><%bb6> U: [0,8589934590) S: [0,8589934590) Exits: ((zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) + (zext i32 (ptrtoaddr ptr %arg to i32) to i64)) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i10 = sub i64 %i9, %i4
; X32-NEXT: --> {0,+,1}<nuw><%bb6> U: [0,4294967295) S: [0,4294967295) Exits: (zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i11 = getelementptr inbounds i8, ptr %arg2, i64 %i10
@@ -535,7 +535,7 @@ define void @pr46786_c26_int(ptr %arg, ptr %arg1, ptr %arg2) {
; X64-NEXT: %i8 = load i32, ptr %i7, align 4
; X64-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X64-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X64-NEXT: --> %i9 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
+; X64-NEXT: --> {(ptrtoaddr ptr %arg to i64),+,4}<nuw><%bb6> U: full-set S: full-set Exits: ((4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4))<nuw> + (ptrtoaddr ptr %arg to i64)) LoopDispositions: { %bb6: Computable }
; X64-NEXT: %i10 = sub i64 %i9, %i4
; X64-NEXT: --> {0,+,4}<nuw><%bb6> U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: (4 * ((-4 + (-1 * (ptrtoaddr ptr %arg to i64)) + (ptrtoaddr ptr %arg1 to i64)) /u 4))<nuw> LoopDispositions: { %bb6: Computable }
; X64-NEXT: %i11 = ashr exact i64 %i10, 2
@@ -563,7 +563,7 @@ define void @pr46786_c26_int(ptr %arg, ptr %arg1, ptr %arg2) {
; X32-NEXT: %i8 = load i32, ptr %i7, align 4
; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X32-NEXT: --> %i9 U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
+; X32-NEXT: --> {(zext i32 (ptrtoaddr ptr %arg to i32) to i64),+,4}<nuw><%bb6> U: [0,8589934588) S: [0,8589934588) Exits: ((zext i32 (ptrtoaddr ptr %arg to i32) to i64) + (4 * ((zext i32 (-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) /u 4))<nuw><nsw>) LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i10 = sub i64 %i9, %i4
; X32-NEXT: --> {0,+,4}<nuw><%bb6> U: [0,4294967293) S: [0,4294967293) Exits: (4 * ((zext i32 (-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) /u 4))<nuw><nsw> LoopDispositions: { %bb6: Computable }
; X32-NEXT: %i11 = ashr exact i64 %i10, 2
diff --git a/llvm/test/Analysis/ScalarEvolution/two-loop-latches.ll b/llvm/test/Analysis/ScalarEvolution/two-loop-latches.ll
index 1faf6f70fc34a..a85626c7c02e9 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)<nuw><nsw>,+,-32}<%b1> U: [0,-31) S: [-9223372036854775808,9223372036854775777) Exits: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %b3: Variant, %b1: Variant }
; CHECK-NEXT: %ld2 = load i8, ptr null, align 1
; CHECK-NEXT: --> %ld2 U: full-set S: full-set Exits: <<Unknown>> 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: <multiple exits> 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: <multiple exits> 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/Thumb2/LowOverheadLoops/while-loops.ll b/llvm/test/CodeGen/Thumb2/LowOverheadLoops/while-loops.ll
index a637fe0ca446b..cbcbf1f392ce8 100644
--- a/llvm/test/CodeGen/Thumb2/LowOverheadLoops/while-loops.ll
+++ b/llvm/test/CodeGen/Thumb2/LowOverheadLoops/while-loops.ll
@@ -161,76 +161,81 @@ define dso_local i32 @b(ptr %c, i32 %d, i32 %e, ptr %n) "frame-pointer"="all" {
; CHECK-NEXT: add r7, sp, #12
; CHECK-NEXT: .save {r8, r9, r10, r11}
; CHECK-NEXT: push.w {r8, r9, r10, r11}
-; CHECK-NEXT: .pad #12
-; CHECK-NEXT: sub sp, #12
+; CHECK-NEXT: .pad #16
+; CHECK-NEXT: sub sp, #16
; CHECK-NEXT: wls lr, r1, .LBB2_3
; CHECK-NEXT: @ %bb.1: @ %while.body.preheader
-; CHECK-NEXT: mvn r10, #1
-; CHECK-NEXT: @ implicit-def: $r1
-; CHECK-NEXT: @ implicit-def: $r12
-; CHECK-NEXT: mov r4, r0
-; CHECK-NEXT: mov r9, r3
+; CHECK-NEXT: adds r6, r3, #4
+; CHECK-NEXT: adds r1, r0, #4
+; CHECK-NEXT: mvn r8, #1
+; CHECK-NEXT: @ implicit-def: $r9
+; CHECK-NEXT: @ implicit-def: $r4
; CHECK-NEXT: str r2, [sp] @ 4-byte Spill
; CHECK-NEXT: .LBB2_2: @ %while.body
; CHECK-NEXT: @ =>This Inner Loop Header: Depth=1
-; CHECK-NEXT: strd r3, r4, [sp, #4] @ 8-byte Folded Spill
-; CHECK-NEXT: asr.w r5, r12, #31
-; CHECK-NEXT: ldr r2, [sp, #8] @ 4-byte Reload
-; CHECK-NEXT: ldr r4, [r2, #4]!
-; CHECK-NEXT: str r2, [sp, #8] @ 4-byte Spill
+; CHECK-NEXT: str r1, [sp, #12] @ 4-byte Spill
+; CHECK-NEXT: asrs r2, r4, #31
+; CHECK-NEXT: ldr r1, [sp, #12] @ 4-byte Reload
+; CHECK-NEXT: ldr r1, [r1]
+; CHECK-NEXT: muls r1, r3, r1
+; CHECK-NEXT: adds r4, r4, r1
+; CHECK-NEXT: adc.w r1, r2, r1, asr #31
+; CHECK-NEXT: adds.w r2, r4, #-2147483648
+; CHECK-NEXT: ldrd r2, r4, [r8]
+; CHECK-NEXT: adc r5, r1, #0
+; CHECK-NEXT: str r2, [sp, #4] @ 4-byte Spill
+; CHECK-NEXT: smull r4, r2, r4, r9
+; CHECK-NEXT: asrs r1, r5, #31
+; CHECK-NEXT: str r5, [sp, #8] @ 4-byte Spill
+; CHECK-NEXT: subs r4, r5, r4
+; CHECK-NEXT: sbcs r1, r2
+; CHECK-NEXT: ldr r2, [sp, #12] @ 4-byte Reload
+; CHECK-NEXT: adds.w r10, r4, #-2147483648
+; CHECK-NEXT: adc r1, r1, #0
+; CHECK-NEXT: ldr r4, [r2, #-4]
; CHECK-NEXT: muls r4, r3, r4
-; CHECK-NEXT: adds.w r6, r12, r4
-; CHECK-NEXT: adc.w r5, r5, r4, asr #31
-; CHECK-NEXT: adds.w r6, r6, #-2147483648
-; CHECK-NEXT: adc r12, r5, #0
-; CHECK-NEXT: ldrd r2, r5, [r10]
-; CHECK-NEXT: smull r5, r6, r5, r1
-; CHECK-NEXT: asr.w r4, r12, #31
-; CHECK-NEXT: muls r2, r1, r2
-; CHECK-NEXT: ldr r1, [sp, #4] @ 4-byte Reload
-; CHECK-NEXT: subs.w r5, r12, r5
-; CHECK-NEXT: sbcs r4, r6
-; CHECK-NEXT: adds.w r6, r5, #-2147483648
-; CHECK-NEXT: adc r5, r4, #0
-; CHECK-NEXT: ldr r4, [r0]
+; CHECK-NEXT: adds r3, #4
+; CHECK-NEXT: adds.w r12, r4, #-2147483648
+; CHECK-NEXT: asr.w r5, r4, #31
+; CHECK-NEXT: ldr r4, [r6]
+; CHECK-NEXT: adc r5, r5, #0
+; CHECK-NEXT: mul r2, r4, r0
+; CHECK-NEXT: adds r0, #4
+; CHECK-NEXT: add.w r2, r2, #-2147483648
+; CHECK-NEXT: asrl r12, r5, r2
+; CHECK-NEXT: smull r2, r5, r4, r12
+; CHECK-NEXT: lsll r2, r5, #30
+; CHECK-NEXT: ldr r2, [sp, #4] @ 4-byte Reload
+; CHECK-NEXT: asr.w r11, r5, #31
+; CHECK-NEXT: mov r12, r5
+; CHECK-NEXT: lsll r12, r11, r4
+; CHECK-NEXT: mul r2, r2, r9
+; CHECK-NEXT: lsrl r12, r11, #2
; CHECK-NEXT: adds r2, #2
-; CHECK-NEXT: muls r4, r3, r4
-; CHECK-NEXT: adds.w r8, r4, #-2147483648
-; CHECK-NEXT: asr.w r3, r4, #31
-; CHECK-NEXT: ldr r4, [r9, #4]!
-; CHECK-NEXT: adc r3, r3, #0
-; CHECK-NEXT: muls r0, r4, r0
-; CHECK-NEXT: add.w r0, r0, #-2147483648
-; CHECK-NEXT: asrl r8, r3, r0
-; CHECK-NEXT: smull r0, r3, r4, r8
-; CHECK-NEXT: lsll r0, r3, #30
-; CHECK-NEXT: asr.w r11, r3, #31
-; CHECK-NEXT: mov r0, r3
-; CHECK-NEXT: lsll r0, r11, r4
-; CHECK-NEXT: lsrl r0, r11, #2
-; CHECK-NEXT: lsll r0, r11, r2
-; CHECK-NEXT: add.w r0, r0, #-2147483648
-; CHECK-NEXT: asrl r6, r5, r0
-; CHECK-NEXT: movs r0, #2
-; CHECK-NEXT: lsrl r6, r5, #2
-; CHECK-NEXT: str r6, [r0]
-; CHECK-NEXT: ldr r0, [r10], #-4
-; CHECK-NEXT: mls r0, r0, r4, r12
-; CHECK-NEXT: ldr r4, [sp, #8] @ 4-byte Reload
-; CHECK-NEXT: adds.w r12, r0, #-2147483648
-; CHECK-NEXT: asr.w r2, r0, #31
-; CHECK-NEXT: adc r3, r2, #0
+; CHECK-NEXT: lsll r12, r11, r2
; CHECK-NEXT: ldr r2, [sp] @ 4-byte Reload
-; CHECK-NEXT: lsrl r12, r3, #2
-; CHECK-NEXT: rsb.w r0, r12, #0
-; CHECK-NEXT: mov r3, r9
-; CHECK-NEXT: str r0, [r2]
-; CHECK-NEXT: str r0, [r1]
-; CHECK-NEXT: mov r0, r4
-; CHECK-NEXT: mov r1, r6
+; CHECK-NEXT: add.w r5, r12, #-2147483648
+; CHECK-NEXT: asrl r10, r1, r5
+; CHECK-NEXT: ldr r5, [sp, #8] @ 4-byte Reload
+; CHECK-NEXT: lsrl r10, r1, #2
+; CHECK-NEXT: movs r1, #2
+; CHECK-NEXT: mov r9, r10
+; CHECK-NEXT: str.w r10, [r1]
+; CHECK-NEXT: ldr r1, [r8], #-4
+; CHECK-NEXT: mls r5, r1, r4, r5
+; CHECK-NEXT: adds.w r4, r5, #-2147483648
+; CHECK-NEXT: asr.w r1, r5, #31
+; CHECK-NEXT: adc r1, r1, #0
+; CHECK-NEXT: lsrl r4, r1, #2
+; CHECK-NEXT: rsbs r1, r4, #0
+; CHECK-NEXT: str r1, [r2]
+; CHECK-NEXT: str r1, [r6, #-4]
+; CHECK-NEXT: adds r6, #4
+; CHECK-NEXT: ldr r1, [sp, #12] @ 4-byte Reload
+; CHECK-NEXT: adds r1, #4
; CHECK-NEXT: le lr, .LBB2_2
; CHECK-NEXT: .LBB2_3: @ %while.end
-; CHECK-NEXT: add sp, #12
+; CHECK-NEXT: add sp, #16
; CHECK-NEXT: pop.w {r8, r9, r10, r11}
; CHECK-NEXT: pop {r4, r5, r6, r7, pc}
entry:
diff --git a/llvm/test/CodeGen/Thumb2/mve-tailpred-loopinvariant.ll b/llvm/test/CodeGen/Thumb2/mve-tailpred-loopinvariant.ll
index 91828c4d698ab..de34106e5fed8 100644
--- a/llvm/test/CodeGen/Thumb2/mve-tailpred-loopinvariant.ll
+++ b/llvm/test/CodeGen/Thumb2/mve-tailpred-loopinvariant.ll
@@ -1,115 +1,40 @@
; 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:
; CHECK: @ %bb.0: @ %entry
-; CHECK-NEXT: .save {r4, r5, r6, lr}
-; CHECK-NEXT: push {r4, r5, r6, lr}
-; CHECK-NEXT: .vsave {d8, d9, d10, d11, d12, d13, d14, d15}
-; CHECK-NEXT: vpush {d8, d9, d10, d11, d12, d13, d14, d15}
-; CHECK-NEXT: .pad #64
-; CHECK-NEXT: sub sp, #64
+; CHECK-NEXT: .save {r4, lr}
+; CHECK-NEXT: push {r4, lr}
; CHECK-NEXT: cmp r0, r1
-; CHECK-NEXT: bls .LBB0_3
-; CHECK-NEXT: @ %bb.1: @ %while.body.preheader
-; CHECK-NEXT: subs r2, r0, r1
-; CHECK-NEXT: movs r3, #1
-; CHECK-NEXT: add.w r0, r2, #15
-; CHECK-NEXT: vdup.32 q1, r2
-; CHECK-NEXT: bic r0, r0, #15
-; CHECK-NEXT: adr r2, .LCPI0_1
-; CHECK-NEXT: subs r0, #16
-; CHECK-NEXT: vldrw.u32 q4, [r2]
-; CHECK-NEXT: adr r2, .LCPI0_2
-; CHECK-NEXT: add r5, sp, #32
-; CHECK-NEXT: add.w lr, r3, r0, lsr #4
-; CHECK-NEXT: adr r3, .LCPI0_0
-; CHECK-NEXT: vldrw.u32 q5, [r2]
-; CHECK-NEXT: adr r2, .LCPI0_3
-; CHECK-NEXT: vldrw.u32 q0, [r3]
-; CHECK-NEXT: vldrw.u32 q6, [r2]
-; CHECK-NEXT: add r3, sp, #16
-; CHECK-NEXT: add r6, sp, #48
-; CHECK-NEXT: movs r0, #0
-; CHECK-NEXT: vmov.i8 q2, #0x0
-; CHECK-NEXT: vmov.i8 q3, #0xff
-; CHECK-NEXT: mov r2, r1
-; CHECK-NEXT: vstrw.32 q0, [sp] @ 16-byte Spill
+; CHECK-NEXT: it ls
+; CHECK-NEXT: popls {r4, pc}
+; CHECK-NEXT: .LBB0_1: @ %while.body.preheader
+; CHECK-NEXT: subs r4, r0, r1
+; CHECK-NEXT: movs r2, #0
+; CHECK-NEXT: mov r3, r1
+; CHECK-NEXT: dlstp.8 lr, r4
; CHECK-NEXT: .LBB0_2: @ %vector.body
; CHECK-NEXT: @ =>This Inner Loop Header: Depth=1
-; CHECK-NEXT: vldrw.u32 q0, [sp] @ 16-byte Reload
-; CHECK-NEXT: adds r4, r1, r0
-; CHECK-NEXT: vqadd.u32 q7, q0, r0
-; CHECK-NEXT: vcmp.u32 hi, q1, q7
-; CHECK-NEXT: vpsel q7, q3, q2
-; CHECK-NEXT: vstrh.32 q7, [r5, #8]
-; CHECK-NEXT: vqadd.u32 q7, q4, r0
-; CHECK-NEXT: vcmp.u32 hi, q1, q7
-; CHECK-NEXT: vpsel q7, q3, q2
-; CHECK-NEXT: vstrh.32 q7, [r5]
-; CHECK-NEXT: vqadd.u32 q7, q5, r0
-; CHECK-NEXT: vcmp.u32 hi, q1, q7
-; CHECK-NEXT: vpsel q7, q3, q2
-; CHECK-NEXT: vstrh.32 q7, [r3, #8]
-; CHECK-NEXT: vqadd.u32 q7, q6, r0
-; CHECK-NEXT: vcmp.u32 hi, q1, q7
-; CHECK-NEXT: adds r0, #16
-; CHECK-NEXT: vpsel q7, q3, q2
-; CHECK-NEXT: vstrh.32 q7, [r3]
-; CHECK-NEXT: vldrw.u32 q7, [r5]
-; CHECK-NEXT: vcmp.i16 ne, q7, zr
-; CHECK-NEXT: vpsel q7, q3, q2
-; CHECK-NEXT: vstrb.16 q7, [r6, #8]
-; CHECK-NEXT: vldrw.u32 q7, [r3]
-; CHECK-NEXT: vcmp.i16 ne, q7, zr
-; CHECK-NEXT: vpsel q7, q3, q2
-; CHECK-NEXT: vstrb.16 q7, [r6]
-; CHECK-NEXT: vidup.u8 q7, r4, #1
-; CHECK-NEXT: vldrw.u32 q0, [r6]
-; CHECK-NEXT: vpt.i8 ne, q0, zr
-; CHECK-NEXT: vstrbt.8 q7, [r2], #16
-; CHECK-NEXT: le lr, .LBB0_2
-; CHECK-NEXT: .LBB0_3: @ %while.end
-; CHECK-NEXT: add sp, #64
-; CHECK-NEXT: vpop {d8, d9, d10, d11, d12, d13, d14, d15}
-; CHECK-NEXT: pop {r4, r5, r6, pc}
-; CHECK-NEXT: .p2align 4
-; CHECK-NEXT: @ %bb.4:
-; CHECK-NEXT: .LCPI0_0:
-; CHECK-NEXT: .long 12 @ 0xc
-; CHECK-NEXT: .long 13 @ 0xd
-; CHECK-NEXT: .long 14 @ 0xe
-; CHECK-NEXT: .long 15 @ 0xf
-; CHECK-NEXT: .LCPI0_1:
-; CHECK-NEXT: .long 8 @ 0x8
-; CHECK-NEXT: .long 9 @ 0x9
-; CHECK-NEXT: .long 10 @ 0xa
-; CHECK-NEXT: .long 11 @ 0xb
-; CHECK-NEXT: .LCPI0_2:
-; CHECK-NEXT: .long 4 @ 0x4
-; CHECK-NEXT: .long 5 @ 0x5
-; CHECK-NEXT: .long 6 @ 0x6
-; CHECK-NEXT: .long 7 @ 0x7
-; CHECK-NEXT: .LCPI0_3:
-; CHECK-NEXT: .long 0 @ 0x0
-; CHECK-NEXT: .long 1 @ 0x1
-; CHECK-NEXT: .long 2 @ 0x2
-; CHECK-NEXT: .long 3 @ 0x3
+; CHECK-NEXT: adds r0, r1, r2
+; CHECK-NEXT: vidup.u8 q0, r0, #1
+; CHECK-NEXT: adds r2, #16
+; CHECK-NEXT: vstrb.8 q0, [r3], #16
+; CHECK-NEXT: letp lr, .LBB0_2
+; CHECK-NEXT: @ %bb.3: @ %while.end
+; CHECK-NEXT: pop {r4, pc}
entry:
%cmp3 = icmp ugt ptr %b, %c
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
@@ -162,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/pr45835.ll b/llvm/test/Transforms/IndVarSimplify/pr45835.ll
index 4fa2d7a85fb0a..66635204e465e 100644
--- a/llvm/test/Transforms/IndVarSimplify/pr45835.ll
+++ b/llvm/test/Transforms/IndVarSimplify/pr45835.ll
@@ -20,8 +20,8 @@ define internal fastcc void @d(ptr %c) unnamed_addr #0 {
; ALWAYS-NEXT: br i1 false, label [[CONT:%.*]], label [[WHILE_END_LOOPEXIT:%.*]]
; ALWAYS: cont:
; ALWAYS-NEXT: switch i64 0, label [[WHILE_COND]] [
-; ALWAYS-NEXT: i64 -1, label [[HANDLER_POINTER_OVERFLOW_I:%.*]]
-; ALWAYS-NEXT: i64 0, label [[HANDLER_POINTER_OVERFLOW_I]]
+; ALWAYS-NEXT: i64 -1, label [[HANDLER_POINTER_OVERFLOW_I:%.*]]
+; ALWAYS-NEXT: i64 0, label [[HANDLER_POINTER_OVERFLOW_I]]
; ALWAYS-NEXT: ]
; ALWAYS: handler.pointer_overflow.i:
; ALWAYS-NEXT: [[A_MUX_LCSSA4:%.*]] = phi ptr [ [[UMAX]], [[CONT]] ], [ [[UMAX]], [[CONT]] ]
@@ -42,8 +42,8 @@ define internal fastcc void @d(ptr %c) unnamed_addr #0 {
; NEVER: cont:
; NEVER-NEXT: [[A_MUX:%.*]] = select i1 [[CMP]], ptr @a, ptr [[C]]
; NEVER-NEXT: switch i64 0, label [[WHILE_COND]] [
-; NEVER-NEXT: i64 -1, label [[HANDLER_POINTER_OVERFLOW_I:%.*]]
-; NEVER-NEXT: i64 0, label [[HANDLER_POINTER_OVERFLOW_I]]
+; NEVER-NEXT: i64 -1, label [[HANDLER_POINTER_OVERFLOW_I:%.*]]
+; NEVER-NEXT: i64 0, label [[HANDLER_POINTER_OVERFLOW_I]]
; NEVER-NEXT: ]
; NEVER: handler.pointer_overflow.i:
; NEVER-NEXT: [[A_MUX_LCSSA4:%.*]] = phi ptr [ [[A_MUX]], [[CONT]] ], [ [[A_MUX]], [[CONT]] ]
@@ -64,8 +64,8 @@ define internal fastcc void @d(ptr %c) unnamed_addr #0 {
; CHEAP: cont:
; CHEAP-NEXT: [[A_MUX:%.*]] = select i1 [[CMP]], ptr @a, ptr [[C]]
; CHEAP-NEXT: switch i64 0, label [[WHILE_COND]] [
-; CHEAP-NEXT: i64 -1, label [[HANDLER_POINTER_OVERFLOW_I:%.*]]
-; CHEAP-NEXT: i64 0, label [[HANDLER_POINTER_OVERFLOW_I]]
+; CHEAP-NEXT: i64 -1, label [[HANDLER_POINTER_OVERFLOW_I:%.*]]
+; CHEAP-NEXT: i64 0, label [[HANDLER_POINTER_OVERFLOW_I]]
; CHEAP-NEXT: ]
; CHEAP: handler.pointer_overflow.i:
; CHEAP-NEXT: [[A_MUX_LCSSA4:%.*]] = phi ptr [ [[A_MUX]], [[CONT]] ], [ [[A_MUX]], [[CONT]] ]
diff --git a/llvm/test/Transforms/IndVarSimplify/pr59633.ll b/llvm/test/Transforms/IndVarSimplify/pr59633.ll
index bdafdfc47818f..1a47995884af8 100644
--- a/llvm/test/Transforms/IndVarSimplify/pr59633.ll
+++ b/llvm/test/Transforms/IndVarSimplify/pr59633.ll
@@ -7,13 +7,12 @@ declare void @foo(i64 noundef)
define void @pr59633(ptr noundef %ptr) {
; CHECK-LABEL: @pr59633(
; CHECK-NEXT: entry:
+; 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:%.*]]
; CHECK: while.body:
-; CHECK-NEXT: [[PTR_ADDR_0:%.*]] = phi ptr [ [[PTR:%.*]], [[ENTRY:%.*]] ], [ [[ADD_PTR:%.*]], [[WHILE_BODY]] ]
-; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[PTR_ADDR_0]] to i64
-; CHECK-NEXT: [[TMP1:%.*]] = and i64 [[TMP0]], 15
; CHECK-NEXT: tail call void @foo(i64 noundef [[TMP1]])
-; CHECK-NEXT: [[ADD_PTR]] = getelementptr inbounds i8, ptr [[PTR_ADDR_0]], i64 16
; CHECK-NEXT: br label [[WHILE_BODY]]
;
entry:
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 36ab894f9dd3c..05ef5d111fe55 100644
--- a/llvm/test/Transforms/LoopIdiom/reuse-lcssa-phi-scev-expansion.ll
+++ b/llvm/test/Transforms/LoopIdiom/reuse-lcssa-phi-scev-expansion.ll
@@ -227,20 +227,27 @@ 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:%.*]] = 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]] ]
; CHECK-NEXT: [[P_0:%.*]] = phi ptr [ [[A]], %[[ENTRY]] ], [ [[P_0_NEXT:%.*]], %[[LOOP_1]] ]
; CHECK-NEXT: [[P_0_NEXT]] = getelementptr i8, ptr [[P_0]], i64 -1
; CHECK-NEXT: call void @foo()
+; CHECK-NEXT: [[INDVAR_NEXT]] = add i32 [[INDVAR]], 1
; CHECK-NEXT: br i1 false, label %[[MIDDLE:.*]], label %[[LOOP_1]]
; CHECK: [[MIDDLE]]:
+; CHECK-NEXT: [[INDVAR_LCSSA:%.*]] = phi i32 [ [[INDVAR]], %[[LOOP_1]] ]
; CHECK-NEXT: [[P_0_LCSSA:%.*]] = phi ptr [ [[P_0]], %[[LOOP_1]] ]
; CHECK-NEXT: [[P_0_TO_INT:%.*]] = ptrtoint ptr [[P_0_LCSSA]] to i64
; CHECK-NEXT: [[TRUNC:%.*]] = trunc i64 [[P_0_TO_INT]] to i32
; CHECK-NEXT: [[TMP0:%.*]] = zext i32 [[TRUNC]] to i64
-; CHECK-NEXT: [[TMP1:%.*]] = sub i64 0, [[TMP0]]
+; CHECK-NEXT: [[TMP1:%.*]] = mul nsw i64 [[TMP0]], -1
; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[B]], i64 [[TMP1]]
-; CHECK-NEXT: [[TMP5:%.*]] = add i32 [[TRUNC]], 1
+; CHECK-NEXT: [[TMP2:%.*]] = trunc i64 [[A1]] to i32
+; CHECK-NEXT: [[TMP3:%.*]] = add i32 [[TMP2]], 1
+; CHECK-NEXT: [[TMP6:%.*]] = mul i32 [[INDVAR_LCSSA]], -1
+; CHECK-NEXT: [[TMP5:%.*]] = add i32 [[TMP6]], [[TMP3]]
; CHECK-NEXT: [[TMP4:%.*]] = zext i32 [[TMP5]] to i64
; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 [[SCEVGEP]], i8 0, i64 [[TMP4]], i1 false)
; CHECK-NEXT: br label %[[LOOP_2:.*]]
diff --git a/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll b/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll
index 277489dd34a08..bb759aefcdf44 100644
--- a/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll
+++ b/llvm/test/Transforms/LoopStrengthReduce/X86/expander-crashes.ll
@@ -11,30 +11,33 @@ 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:%.*]] = ptrtoaddr ptr [[START:%.*]] to i64
; CHECK-NEXT: br label [[LOOP_1_HEADER:%.*]]
; CHECK: loop.1.header:
-; CHECK-NEXT: [[IV:%.*]] = phi ptr [ [[IV_NEXT:%.*]], [[LOOP_1_HEADER]] ], [ [[START:%.*]], [[ENTRY:%.*]] ]
+; CHECK-NEXT: [[LSR_IV4:%.*]] = phi i64 [ [[LSR_IV_NEXT5:%.*]], [[LOOP_1_HEADER]] ], [ [[START1]], [[ENTRY:%.*]] ]
+; CHECK-NEXT: [[IV:%.*]] = phi ptr [ [[IV_NEXT:%.*]], [[LOOP_1_HEADER]] ], [ [[START]], [[ENTRY]] ]
; CHECK-NEXT: [[IV_NEXT]] = getelementptr inbounds [[STRUCT_HOGE:%.*]], ptr [[IV]], i64 1
+; CHECK-NEXT: [[LSR_IV_NEXT5]] = add nuw i64 [[LSR_IV4]], 16
; CHECK-NEXT: [[EC:%.*]] = icmp eq ptr [[IV_NEXT]], [[END:%.*]]
; CHECK-NEXT: br i1 [[EC]], label [[LOOP_2_PH:%.*]], label [[LOOP_1_HEADER]]
; CHECK: loop.2.ph:
-; CHECK-NEXT: [[IV_NEXT_LCSSA:%.*]] = getelementptr i8, ptr [[IV_NEXT]], i64 12
+; CHECK-NEXT: [[LSR_IV_NEXT5_LCSSA:%.*]] = phi i64 [ [[LSR_IV_NEXT5]], [[LOOP_1_HEADER]] ]
+; CHECK-NEXT: [[IV_NEXT_LCSSA:%.*]] = phi ptr [ [[IV_NEXT]], [[LOOP_1_HEADER]] ]
; CHECK-NEXT: br label [[LOOP_2_HEADER:%.*]]
; CHECK: loop.2.header:
-; CHECK-NEXT: [[IV2:%.*]] = phi ptr [ [[IV2_NEXT:%.*]], [[LOOP_2_LATCH:%.*]] ], [ [[IV_NEXT_LCSSA]], [[LOOP_2_PH]] ]
-; CHECK-NEXT: [[SCEVGEP5:%.*]] = getelementptr i8, ptr [[IV2]], i64 -12
-; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[IV2]] to i64
+; CHECK-NEXT: [[LSR_IV2:%.*]] = phi i64 [ [[LSR_IV_NEXT3:%.*]], [[LOOP_2_LATCH:%.*]] ], [ [[LSR_IV_NEXT5_LCSSA]], [[LOOP_2_PH]] ]
+; CHECK-NEXT: [[IV2:%.*]] = phi ptr [ [[IV2_NEXT:%.*]], [[LOOP_2_LATCH]] ], [ [[IV_NEXT_LCSSA]], [[LOOP_2_PH]] ]
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[LSR_IV2]], 12
; CHECK-NEXT: call void @use.i64(i64 [[TMP0]])
-; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[IV2]], i64 -4
+; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[IV2]], i64 8
; CHECK-NEXT: store i32 10, ptr [[SCEVGEP]], align 8
-; CHECK-NEXT: [[EC_2:%.*]] = icmp ugt ptr [[SCEVGEP5]], [[PTR_2:%.*]]
+; CHECK-NEXT: [[EC_2:%.*]] = icmp ugt ptr [[IV2]], [[PTR_2:%.*]]
; CHECK-NEXT: br i1 [[EC_2]], label [[LOOP_2_EXIT:%.*]], label [[LOOP_2_LATCH]]
; CHECK: loop.2.latch:
-; CHECK-NEXT: [[IV2_NEXT]] = getelementptr i8, ptr [[IV2]], i64 16
+; CHECK-NEXT: [[IV2_NEXT]] = getelementptr inbounds [[STRUCT_HOGE]], ptr [[IV2]], i64 1
+; CHECK-NEXT: [[LSR_IV_NEXT3]] = add i64 [[LSR_IV2]], 16
; CHECK-NEXT: br label [[LOOP_2_HEADER]]
; CHECK: loop.2.exit:
-; CHECK-NEXT: [[SCEVGEP4:%.*]] = getelementptr i8, ptr [[IV2]], i64 -12
-; CHECK-NEXT: [[LSR_IV2:%.*]] = ptrtoint ptr [[SCEVGEP4]] to i64
; CHECK-NEXT: ret i64 [[LSR_IV2]]
;
entry:
diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll b/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll
index 70d15bb740284..3eaf4c4b1b3f4 100644
--- a/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll
+++ b/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll
@@ -17,11 +17,11 @@ define void @test_interleave_reduction(ptr %arg, ptr %arg1) {
; A320: [[OUTER]]:
; A320-NEXT: [[TPM26:%.*]] = add i64 0, 1
; A320-NEXT: [[TPM10:%.*]] = alloca i32, align 8
-; A320-NEXT: [[TPM102:%.*]] = ptrtoaddr ptr [[TPM10]] to i64
+; A320-NEXT: [[TPM102:%.*]] = ptrtoint ptr [[TPM10]] to i64
; A320-NEXT: [[TPM27:%.*]] = getelementptr inbounds i32, ptr [[TPM10]], i64 [[TPM26]]
; A320-NEXT: [[TPM28:%.*]] = getelementptr inbounds ptr, ptr [[TPM15]], i64 0
; A320-NEXT: [[TPM29:%.*]] = load ptr, ptr [[TPM28]], align 8
-; A320-NEXT: [[TPM291:%.*]] = ptrtoaddr ptr [[TPM29]] to i64
+; A320-NEXT: [[TPM291:%.*]] = ptrtoint ptr [[TPM29]] to i64
; A320-NEXT: [[TPM17:%.*]] = alloca double, align 8
; A320-NEXT: [[TPM32:%.*]] = getelementptr inbounds double, ptr [[TPM17]], i64 [[TPM26]]
; A320-NEXT: [[TMP0:%.*]] = add i64 [[TPM291]], -8
diff --git a/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll b/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll
index 41f527b97ecaf..f83e115cb6515 100644
--- a/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll
+++ b/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll
@@ -8,12 +8,14 @@ define void @test_epilogue_step_scev_expansion(ptr %dst) {
; CHECK-LABEL: define void @test_epilogue_step_scev_expansion(
; CHECK-SAME: ptr [[DST:%.*]]) {
; CHECK-NEXT: [[ITER_CHECK:.*]]:
-; CHECK-NEXT: br i1 false, label %[[VEC_EPILOG_SCALAR_PH:.*]], label %[[VECTOR_MAIN_LOOP_ITER_CHECK:.*]]
+; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) to i64)), 4
+; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[VEC_EPILOG_SCALAR_PH:.*]], label %[[VECTOR_MAIN_LOOP_ITER_CHECK:.*]]
; CHECK: [[VECTOR_MAIN_LOOP_ITER_CHECK]]:
-; CHECK-NEXT: br i1 false, label %[[VEC_EPILOG_PH:.*]], label %[[VECTOR_PH:.*]]
+; CHECK-NEXT: [[MIN_ITERS_CHECK1:%.*]] = icmp ult i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) to i64)), 8
+; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK1]], label %[[VEC_EPILOG_PH:.*]], label %[[VECTOR_PH:.*]]
; CHECK: [[VECTOR_PH]]:
-; 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: [[N_MOD_VF:%.*]] = urem i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) to i64)), 8
+; CHECK-NEXT: [[N_VEC:%.*]] = sub i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) 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 +25,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 ptrtoaddr (ptr @end to i64)), [[N_VEC]]
+; CHECK-NEXT: [[CMP_N:%.*]] = icmp eq i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) 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 ptrtoaddr (ptr @end to i64)), [[N_VEC]]
+; CHECK-NEXT: [[N_VEC_REMAINING:%.*]] = sub i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) 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 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: [[N_MOD_VF2:%.*]] = urem i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) to i64)), 4
+; CHECK-NEXT: [[N_VEC2:%.*]] = sub i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) to i64)), [[N_MOD_VF2]]
; 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 +44,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 ptrtoaddr (ptr @end to i64)), [[N_VEC2]]
+; CHECK-NEXT: [[CMP_N5:%.*]] = icmp eq i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) 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]] ]
@@ -71,44 +73,3 @@ loop:
exit:
ret void
}
-
-; Test that SCEV expander reuses existing ptrtoint instructions when expanding
-; ptrtoaddr expressions for trip count calculation.
-define void @test_scev_expansion_reuses_ptrtoint(ptr %base, i64 %n) {
-; CHECK-LABEL: define void @test_scev_expansion_reuses_ptrtoint(
-; CHECK-SAME: ptr [[BASE:%.*]], i64 [[N:%.*]]) {
-; CHECK-NEXT: [[ENTRY:.*]]:
-; CHECK-NEXT: [[BASE_INT:%.*]] = ptrtoint ptr [[BASE]] to i64
-; CHECK-NEXT: [[DUMMY:%.*]] = add i64 [[BASE_INT]], 1
-; CHECK-NEXT: call void @use(i64 [[DUMMY]])
-; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i64 [[N]], 0
-; CHECK-NEXT: br i1 [[CMP]], label %[[LOOP_PH:.*]], label %[[EXIT:.*]]
-; CHECK: [[LOOP_PH]]:
-; Verify that the existing ptrtoint (%base.int) is reused in trip count computation.
-; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[N]], [[BASE_INT]]
-; CHECK-NEXT: [[UMAX:%.*]] = call i64 @llvm.umax.i64(i64 [[BASE_INT]], i64 [[TMP0]])
-; CHECK-NOT: ptrtoaddr
-entry:
- %base.int = ptrtoint ptr %base to i64
- %dummy = add i64 %base.int, 1
- call void @use(i64 %dummy)
- %cmp = icmp ugt i64 %n, 0
- br i1 %cmp, label %loop.ph, label %exit
-
-loop.ph:
- br label %loop
-
-loop:
- %iv = phi i64 [ 0, %loop.ph ], [ %iv.next, %loop ]
- %ptr = getelementptr inbounds i8, ptr %base, i64 %iv
- store i8 0, ptr %ptr, align 1
- %iv.next = add nuw i64 %iv, 1
- %end = getelementptr inbounds i8, ptr %base, i64 %n
- %cmp.loop = icmp ult ptr %ptr, %end
- br i1 %cmp.loop, label %loop, label %exit
-
-exit:
- ret void
-}
-
-declare void @use(i64)
diff --git a/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll b/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
index 56e45039eed95..23bacc556e882 100644
--- a/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
+++ b/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
@@ -526,6 +526,7 @@ define void @diff_check_via_i32_ptrarith(ptr %origin, ptr %dst, ptr %base, i32 %
; 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: [[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
@@ -565,7 +566,6 @@ define void @phi_of_ptrtoint_diff_check(ptr %base, ptr %end, i64 %n, i1 %cond) {
; CHECK-LABEL: define void @phi_of_ptrtoint_diff_check(
; CHECK-SAME: ptr [[BASE:%.*]], ptr [[END:%.*]], i64 [[N:%.*]], i1 [[COND:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
-; CHECK-NEXT: [[BASE2:%.*]] = ptrtoaddr ptr [[BASE]] to i64
; CHECK-NEXT: [[END_INT:%.*]] = ptrtoint ptr [[END]] to i64
; CHECK-NEXT: [[EXT:%.*]] = getelementptr inbounds nuw i8, ptr [[END]], i64 [[N]]
; CHECK-NEXT: [[EXT_INT:%.*]] = ptrtoint ptr [[EXT]] to i64
@@ -583,16 +583,14 @@ define void @phi_of_ptrtoint_diff_check(ptr %base, ptr %end, i64 %n, i1 %cond) {
; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[SRC]], [[END]]
; CHECK-NEXT: br i1 [[CMP]], label %[[LOOP_PREHEADER:.*]], [[EXIT:label %.*]]
; CHECK: [[LOOP_PREHEADER]]:
-; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[END2_INT]], [[END_INT]]
-; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[DST_INT]]
-; CHECK-NEXT: [[TMP4:%.*]] = sub i64 [[TMP1]], [[BASE2]]
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[N]], [[END_INT]]
+; CHECK-NEXT: [[TMP4:%.*]] = sub i64 [[TMP0]], [[DST_INT]]
; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP4]], 4
; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], [[SCALAR_PH:label %.*]], label %[[VECTOR_MEMCHECK:.*]]
; CHECK: [[VECTOR_MEMCHECK]]:
-; CHECK-NEXT: [[TMP2:%.*]] = add i64 [[END2_INT]], [[DST_PTR1]]
-; CHECK-NEXT: [[TMP3:%.*]] = sub i64 [[TMP2]], [[DST_INT]]
-; CHECK-NEXT: [[TMP4:%.*]] = sub i64 [[TMP3]], 1
-; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP4]], 3
+; CHECK-NEXT: [[TMP2:%.*]] = add i64 [[N]], [[DST_PTR1]]
+; CHECK-NEXT: [[TMP5:%.*]] = sub i64 [[TMP2]], [[DST_INT]]
+; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP5]], 4
; CHECK-NEXT: br i1 [[DIFF_CHECK]], [[SCALAR_PH]], [[VECTOR_PH:label %.*]]
;
entry:
>From 31cf18e9b10450177064636111bcef1c9771c9f4 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Thu, 19 Mar 2026 12:43:00 +0000
Subject: [PATCH 09/14] !fixup fix polly failures
---
llvm/lib/Analysis/ScalarEvolution.cpp | 5 +++--
.../test/Analysis/ScalarEvolution/ptrtoint.ll | 18 ++++++++---------
.../epilog-vectorization-scev-expansion.ll | 20 +++++++++----------
polly/test/ScopInfo/int2ptr_ptr2int.ll | 16 ++++++++-------
polly/test/ScopInfo/int2ptr_ptr2int_2.ll | 4 ++--
5 files changed, 32 insertions(+), 31 deletions(-)
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 73ad035790c51..3e66172837d97 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -8394,8 +8394,9 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
const SCEV *PtrSCEV = getSCEV(U->getOperand(0));
if (isa<SCEVAddRecExpr>(PtrSCEV)) {
const SCEV *Addr = getPtrToAddrExpr(PtrSCEV);
- if (!isa<SCEVCouldNotCompute>(Addr))
- return Addr;
+ if (!isa<SCEVCouldNotCompute>(Addr) &&
+ getTypeSizeInBits(V->getType()) <= getTypeSizeInBits(Addr->getType()))
+ return getTruncateOrNoop(Addr, V->getType());
}
return getUnknown(V);
}
diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
index 5882700a783af..66a0eb0319cac 100644
--- a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
+++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
@@ -236,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 {(ptrtoaddr ptr %in to i32),+,4}<%loop> to i64) U: [0,4294967296) S: [0,4294967296) Exits: (zext i32 (-4 + (4 * %count) + (ptrtoaddr ptr %in to i32)) to i64) LoopDispositions: { %loop: Computable }
+; X32-NEXT: --> %i8 U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; X32-NEXT: %i9 = add nuw nsw i64 %i6, 1
; X32-NEXT: --> {1,+,1}<nuw><%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
@@ -400,11 +400,11 @@ define void @pr46786_c26_char(ptr %arg, ptr %arg1, ptr %arg2) {
; X32-NEXT: %i8 = load i8, ptr %i7, align 1
; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X32-NEXT: --> {(zext i32 (ptrtoaddr ptr %arg to i32) to i64),+,1}<nuw><%bb6> U: [0,8589934590) S: [0,8589934590) Exits: ((zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) + (zext i32 (ptrtoaddr ptr %arg to i32) to i64)) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> %i9 U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i10 = sub i64 %i9, %i4
-; X32-NEXT: --> {0,+,1}<nuw><%bb6> U: [0,4294967295) S: [0,4294967295) Exits: (zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> ((-1 * %i4)<nsw> + %i9) U: [-4294967295,4294967296) S: [-4294967295,4294967296) Exits: <<Unknown>> 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 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr 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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i12 = load i8, ptr %i11, align 1
; X32-NEXT: --> %i12 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i13 = add i8 %i12, %i8
@@ -477,11 +477,11 @@ define void @pr46786_c26_char_cmp_ops_swapped(ptr %arg, ptr %arg1, ptr %arg2) {
; X32-NEXT: %i8 = load i8, ptr %i7, align 1
; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X32-NEXT: --> {(zext i32 (ptrtoaddr ptr %arg to i32) to i64),+,1}<nuw><%bb6> U: [0,8589934590) S: [0,8589934590) Exits: ((zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) + (zext i32 (ptrtoaddr ptr %arg to i32) to i64)) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> %i9 U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i10 = sub i64 %i9, %i4
-; X32-NEXT: --> {0,+,1}<nuw><%bb6> U: [0,4294967295) S: [0,4294967295) Exits: (zext i32 (-1 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> ((-1 * %i4)<nsw> + %i9) U: [-4294967295,4294967296) S: [-4294967295,4294967296) Exits: <<Unknown>> 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 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr 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: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i12 = load i8, ptr %i11, align 1
; X32-NEXT: --> %i12 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i13 = add i8 %i12, %i8
@@ -563,9 +563,9 @@ define void @pr46786_c26_int(ptr %arg, ptr %arg1, ptr %arg2) {
; X32-NEXT: %i8 = load i32, ptr %i7, align 4
; X32-NEXT: --> %i8 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i9 = ptrtoint ptr %i7 to i64
-; X32-NEXT: --> {(zext i32 (ptrtoaddr ptr %arg to i32) to i64),+,4}<nuw><%bb6> U: [0,8589934588) S: [0,8589934588) Exits: ((zext i32 (ptrtoaddr ptr %arg to i32) to i64) + (4 * ((zext i32 (-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) /u 4))<nuw><nsw>) LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> %i9 U: [0,4294967296) S: [0,4294967296) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i10 = sub i64 %i9, %i4
-; X32-NEXT: --> {0,+,4}<nuw><%bb6> U: [0,4294967293) S: [0,4294967293) Exits: (4 * ((zext i32 (-4 + (-1 * (ptrtoaddr ptr %arg to i32)) + (ptrtoaddr ptr %arg1 to i32)) to i64) /u 4))<nuw><nsw> LoopDispositions: { %bb6: Computable }
+; X32-NEXT: --> ((-1 * %i4)<nsw> + %i9) U: [-4294967295,4294967296) S: [-4294967295,4294967296) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i11 = ashr exact i64 %i10, 2
; X32-NEXT: --> %i11 U: [-2147483648,2147483648) S: [-2147483648,2147483648) Exits: <<Unknown>> LoopDispositions: { %bb6: Variant }
; X32-NEXT: %i12 = getelementptr inbounds i32, ptr %arg2, i64 %i11
diff --git a/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll b/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll
index f83e115cb6515..cd502b080d7bd 100644
--- a/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll
+++ b/llvm/test/Transforms/LoopVectorize/epilog-vectorization-scev-expansion.ll
@@ -8,14 +8,12 @@ define void @test_epilogue_step_scev_expansion(ptr %dst) {
; CHECK-LABEL: define void @test_epilogue_step_scev_expansion(
; CHECK-SAME: ptr [[DST:%.*]]) {
; CHECK-NEXT: [[ITER_CHECK:.*]]:
-; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) to i64)), 4
-; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK]], label %[[VEC_EPILOG_SCALAR_PH:.*]], label %[[VECTOR_MAIN_LOOP_ITER_CHECK:.*]]
+; CHECK-NEXT: br i1 false, label %[[VEC_EPILOG_SCALAR_PH:.*]], label %[[VECTOR_MAIN_LOOP_ITER_CHECK:.*]]
; CHECK: [[VECTOR_MAIN_LOOP_ITER_CHECK]]:
-; CHECK-NEXT: [[MIN_ITERS_CHECK1:%.*]] = icmp ult i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) to i64)), 8
-; CHECK-NEXT: br i1 [[MIN_ITERS_CHECK1]], label %[[VEC_EPILOG_PH:.*]], label %[[VECTOR_PH:.*]]
+; CHECK-NEXT: br i1 false, label %[[VEC_EPILOG_PH:.*]], label %[[VECTOR_PH:.*]]
; CHECK: [[VECTOR_PH]]:
-; CHECK-NEXT: [[N_MOD_VF:%.*]] = urem i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) to i64)), 8
-; CHECK-NEXT: [[N_VEC:%.*]] = sub i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) 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]] ]
@@ -25,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 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) 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 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) 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_VF2:%.*]] = urem i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) to i64)), 4
-; CHECK-NEXT: [[N_VEC2:%.*]] = sub i64 sub (i64 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) to i64)), [[N_MOD_VF2]]
+; 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]] ]
@@ -44,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 1, i64 ptrtoint (ptr getelementptr inbounds nuw (i8, ptr @end, i64 1) 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/polly/test/ScopInfo/int2ptr_ptr2int.ll b/polly/test/ScopInfo/int2ptr_ptr2int.ll
index 3bd2d08278211..7c3e4b060b662 100644
--- a/polly/test/ScopInfo/int2ptr_ptr2int.ll
+++ b/polly/test/ScopInfo/int2ptr_ptr2int.ll
@@ -19,8 +19,9 @@
; IR: polly.stmt.for.body:
; 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_
@@ -35,7 +36,6 @@
; 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"
@@ -50,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 b7f3fb809f416..77293529e9cf7 100644
--- a/polly/test/ScopInfo/int2ptr_ptr2int_2.ll
+++ b/polly/test/ScopInfo/int2ptr_ptr2int_2.ll
@@ -46,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
>From 77fa114aad581eafd70cc93cec31de707e10d05a Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Tue, 9 Jun 2026 20:11:23 +0200
Subject: [PATCH 10/14] !fixup update after rebase
---
llvm/lib/Analysis/ScalarEvolution.cpp | 46 +++++++------------
.../Analysis/ScalarEvolutionAliasAnalysis.cpp | 26 +++++------
llvm/test/Analysis/ScalarEvolution/scev-aa.ll | 2 +-
llvm/test/Transforms/IndVarSimplify/callbr.ll | 4 +-
.../LoopVectorize/AArch64/reduction-cost.ll | 14 ++----
.../X86/CostModel/vpinstruction-cost.ll | 4 +-
...nd-sink-mem-ops-with-invariant-pointers.ll | 14 +++---
.../optimal-epilog-vectorization-liveout.ll | 23 ++++------
...e-to-enable-unrolling-and-vectorization.ll | 4 +-
.../PhaseOrdering/AArch64/std-find.ll | 8 ++--
10 files changed, 61 insertions(+), 84 deletions(-)
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 3e66172837d97..d7c93f8c9c16b 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -5946,21 +5946,6 @@ const SCEV *ScalarEvolution::createAddRecFromPHI(PHINode *PN) {
// the back-edge.
const SCEV *BEValue = getSCEV(BEValueV);
- // If the backedge value is an SCEVUnknown from a ptrtoint, try to use
- // ptrtoaddr to get a usable SCEV expression. This allows recognizing
- // integer induction variables derived from pointer inductions.
- if (isa<SCEVUnknown>(BEValue))
- if (auto *PTI = dyn_cast<PtrToIntInst>(BEValueV)) {
- const SCEV *PtrAddr = getPtrToAddrExpr(getSCEV(PTI->getOperand(0)));
- if (!isa<SCEVCouldNotCompute>(PtrAddr)) {
- // Adjust type to match the ptrtoint result type if needed.
- Type *DestTy = PTI->getType();
- if (PtrAddr->getType() != DestTy)
- PtrAddr = getTruncateOrZeroExtend(PtrAddr, DestTy);
- BEValue = PtrAddr;
- }
- }
-
// NOTE: If BEValue is loop invariant, we know that the PHI node just
// has a special value for the first iteration of the loop.
@@ -8098,22 +8083,23 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
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 to ptrtoaddr. When only one side
- // is ptrtoint, skip SCEVUnknown pointers since wrapping them
- // in ptrtoaddr adds no useful structure.
- auto GetOp = [&](bool HasPtr, Value *PtrOp, Value *IntOp,
- bool OtherHasPtr) -> const SCEV * {
- if (HasPtr) {
- const SCEV *PtrSCEV = getSCEV(PtrOp);
- if (OtherHasPtr || !isa<SCEVUnknown>(PtrSCEV)) {
- const SCEV *Addr = getPtrToAddrExpr(PtrSCEV);
- if (!isa<SCEVCouldNotCompute>(Addr) &&
- getTypeSizeInBits(IntOp->getType()) <=
- getTypeSizeInBits(Addr->getType()))
- return getTruncateOrZeroExtend(Addr, IntOp->getType());
- }
+ // 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<SCEVUnknown>(PtrSCEV)) {
+ const SCEV *Addr = getPtrToAddrExpr(PtrSCEV);
+ if (!isa<SCEVCouldNotCompute>(Addr) &&
+ getTypeSizeInBits(OrigOp->getType()) <=
+ getTypeSizeInBits(Addr->getType()))
+ return getTruncateOrNoop(Addr, OrigOp->getType());
}
- return getSCEV(IntOp);
+ return getSCEV(OrigOp);
};
const SCEV *L = GetOp(HasPtrLHS, PtrLHS, BO->LHS, HasPtrRHS);
const SCEV *R = GetOp(HasPtrRHS, PtrRHS, BO->RHS, HasPtrLHS);
diff --git a/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp b/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
index ee5480c460836..0ab888b2880ff 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<SCEVCouldNotCompute>(AInt) && !isa<SCEVCouldNotCompute>(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<uint64_t>(LocA.Size.getValue())
@@ -61,19 +74,6 @@ AliasResult SCEVAAResult::alias(const MemoryLocation &LocA,
? static_cast<uint64_t>(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<SCEVCouldNotCompute>(AInt) && !isa<SCEVCouldNotCompute>(BInt)) {
- AS = AInt;
- BS = BInt;
- }
-
// Compute the difference between the two pointers.
const SCEV *BA = SE.getMinusSCEV(BS, AS);
diff --git a/llvm/test/Analysis/ScalarEvolution/scev-aa.ll b/llvm/test/Analysis/ScalarEvolution/scev-aa.ll
index 30b7c45f8f5af..a1d3699b3cb4b 100644
--- a/llvm/test/Analysis/ScalarEvolution/scev-aa.ll
+++ b/llvm/test/Analysis/ScalarEvolution/scev-aa.ll
@@ -342,7 +342,7 @@ for.end:
}
; CHECK-LABEL: Function: test_different_pointer_bases_of_inttoptr: 2 pointers, 0 call sites
-; CHECK: MayAlias: <16 x i8>* %tmp5, <16 x i8>* %tmp7
+; CHECK: NoAlias: <16 x i8>* %tmp5, <16 x i8>* %tmp7
define void @test_different_pointer_bases_of_inttoptr() {
entry:
diff --git a/llvm/test/Transforms/IndVarSimplify/callbr.ll b/llvm/test/Transforms/IndVarSimplify/callbr.ll
index 2cdfea4dc0c20..6232c726a13c0 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/LoopVectorize/AArch64/reduction-cost.ll b/llvm/test/Transforms/LoopVectorize/AArch64/reduction-cost.ll
index 0065ecdec0112..583bdd8ef8fc1 100644
--- a/llvm/test/Transforms/LoopVectorize/AArch64/reduction-cost.ll
+++ b/llvm/test/Transforms/LoopVectorize/AArch64/reduction-cost.ll
@@ -108,26 +108,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: [[SRC2:%.*]] = ptrtoint ptr [[SRC]] to i64
-; CHECK-NEXT: [[DST1:%.*]] = ptrtoint ptr [[DST]] to i64
+; CHECK-NEXT: [[SRC7:%.*]] = ptrtoaddr ptr [[SRC]] to i64
+; CHECK-NEXT: [[DST6:%.*]] = ptrtoaddr ptr [[DST]] to i64
; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[DST6]], [[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 [[DST1]] to i3
-; CHECK-NEXT: [[TMP4:%.*]] = trunc i64 [[SRC2]] to i3
+; CHECK-NEXT: [[TMP3:%.*]] = trunc i64 [[DST6]] 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 [[DST3]], [[SRC4]]
+; CHECK-NEXT: [[TMP7:%.*]] = sub i64 [[DST6]], [[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/X86/CostModel/vpinstruction-cost.ll b/llvm/test/Transforms/LoopVectorize/X86/CostModel/vpinstruction-cost.ll
index 421ce3c18d95b..6ccc5dc7241a1 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))<nuw><nsw>
+; 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))<nuw><nsw>
; CHECK: Cost of 0 for VF 2: EMIT-SCALAR vp<%bc.resume.val> = phi [ vp<[[VP4:%[0-9]+]]>, middle.block ], [ ir<%start>, ir-bb<entry> ]
; 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))<nuw><nsw>
+; 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))<nuw><nsw>
; CHECK: Cost of 0 for VF 4: EMIT-SCALAR vp<%bc.resume.val> = phi [ vp<[[VP4]]>, middle.block ], [ ir<%start>, ir-bb<entry> ]
; 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/hoist-and-sink-mem-ops-with-invariant-pointers.ll b/llvm/test/Transforms/LoopVectorize/hoist-and-sink-mem-ops-with-invariant-pointers.ll
index 9e5cd1a25c6f1..70eb2a2825132 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,10 +209,8 @@ 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: [[N1:%.*]] = ptrtoint ptr [[N]] to i64
+; CHECK-NEXT: [[P6:%.*]] = ptrtoaddr ptr [[P]] to i64
+; CHECK-NEXT: [[N5:%.*]] = ptrtoaddr ptr [[N]] to i64
; CHECK-NEXT: [[TMP0:%.*]] = mul i64 [[N5]], 3074457345618258603
; CHECK-NEXT: [[TMP1:%.*]] = mul i64 [[P6]], 3074457345618258603
; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[TMP0]], [[TMP1]]
@@ -221,13 +219,13 @@ define void @load_store_noalias_via_tbaa(ptr %p, ptr %q, ptr %n) {
; 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:%.*]] = trunc i64 [[N1]] to i2
-; CHECK-NEXT: [[TMP6:%.*]] = trunc i64 [[P2]] to i2
+; CHECK-NEXT: [[TMP5:%.*]] = trunc i64 [[N5]] to i2
+; CHECK-NEXT: [[TMP6:%.*]] = trunc i64 [[P6]] to i2
; CHECK-NEXT: [[TMP7:%.*]] = sub i2 [[TMP5]], [[TMP6]]
; CHECK-NEXT: [[TMP8:%.*]] = zext i2 [[TMP7]] to i64
; CHECK-NEXT: [[IDENT_CHECK:%.*]] = icmp ne i64 [[TMP8]], 0
-; CHECK-NEXT: [[TMP9:%.*]] = mul i64 [[N1]], 3074457345618258603
-; CHECK-NEXT: [[TMP10:%.*]] = mul i64 [[P2]], 3074457345618258603
+; CHECK-NEXT: [[TMP9:%.*]] = mul i64 [[N5]], 3074457345618258603
+; CHECK-NEXT: [[TMP10:%.*]] = mul i64 [[P6]], 3074457345618258603
; CHECK-NEXT: [[TMP11:%.*]] = sub i64 [[TMP9]], [[TMP10]]
; CHECK-NEXT: [[TMP12:%.*]] = lshr i64 [[TMP11]], 2
; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[P]], i64 4
diff --git a/llvm/test/Transforms/LoopVectorize/optimal-epilog-vectorization-liveout.ll b/llvm/test/Transforms/LoopVectorize/optimal-epilog-vectorization-liveout.ll
index 3098786a635a4..d96da0b56da96 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,16 +216,15 @@ 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: [[TMP18:%.*]] = sub i64 [[TMP8]], 1
-; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP18]], 15
+; CHECK-NEXT: [[TMP8:%.*]] = sub i64 [[DST3]], [[START5]]
+; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP8]], 16
; CHECK-NEXT: br i1 [[DIFF_CHECK]], label %[[VEC_EPILOG_SCALAR_PH]], label %[[VECTOR_MAIN_LOOP_ITER_CHECK:.*]]
; CHECK: [[VECTOR_MAIN_LOOP_ITER_CHECK]]:
; CHECK-NEXT: [[MIN_ITERS_CHECK6:%.*]] = icmp ult i64 [[TMP3]], 4
@@ -277,12 +274,12 @@ define ptr @test_ptr_iv_live_out(ptr %start, ptr %end, ptr %dst) {
; CHECK-NEXT: [[CMP_N13:%.*]] = icmp eq i64 [[TMP3]], [[N_VEC8]]
; CHECK-NEXT: br i1 [[CMP_N13]], label %[[EXIT]], label %[[VEC_EPILOG_SCALAR_PH]]
; CHECK: [[VEC_EPILOG_SCALAR_PH]]:
-; CHECK-NEXT: [[BC_RESUME_VAL15:%.*]] = phi i64 [ [[N_VEC8]], %[[VEC_EPILOG_MIDDLE_BLOCK]] ], [ [[N_VEC]], %[[VEC_EPILOG_ITER_CHECK]] ], [ 0, %[[VECTOR_MEMCHECK]] ], [ 0, %[[VECTOR_SCEVCHECK]] ], [ 0, %[[ITER_CHECK]] ]
-; CHECK-NEXT: [[BC_RESUME_VAL16:%.*]] = phi ptr [ [[TMP14]], %[[VEC_EPILOG_MIDDLE_BLOCK]] ], [ [[TMP10]], %[[VEC_EPILOG_ITER_CHECK]] ], [ [[START]], %[[VECTOR_MEMCHECK]] ], [ [[START]], %[[VECTOR_SCEVCHECK]] ], [ [[START]], %[[ITER_CHECK]] ]
+; CHECK-NEXT: [[BC_RESUME_VAL13:%.*]] = phi i64 [ [[N_VEC8]], %[[VEC_EPILOG_MIDDLE_BLOCK]] ], [ [[N_VEC]], %[[VEC_EPILOG_ITER_CHECK]] ], [ 0, %[[VECTOR_MEMCHECK]] ], [ 0, %[[VECTOR_SCEVCHECK]] ], [ 0, %[[ITER_CHECK]] ]
+; CHECK-NEXT: [[BC_RESUME_VAL14:%.*]] = phi ptr [ [[TMP14]], %[[VEC_EPILOG_MIDDLE_BLOCK]] ], [ [[TMP10]], %[[VEC_EPILOG_ITER_CHECK]] ], [ [[START]], %[[VECTOR_MEMCHECK]] ], [ [[START]], %[[VECTOR_SCEVCHECK]] ], [ [[START]], %[[ITER_CHECK]] ]
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
-; CHECK-NEXT: [[IV:%.*]] = phi i64 [ [[BC_RESUME_VAL15]], %[[VEC_EPILOG_SCALAR_PH]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
-; CHECK-NEXT: [[PTR_IV:%.*]] = phi ptr [ [[BC_RESUME_VAL16]], %[[VEC_EPILOG_SCALAR_PH]] ], [ [[PTR_NEXT:%.*]], %[[LOOP]] ]
+; CHECK-NEXT: [[IV:%.*]] = phi i64 [ [[BC_RESUME_VAL13]], %[[VEC_EPILOG_SCALAR_PH]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
+; CHECK-NEXT: [[PTR_IV:%.*]] = phi ptr [ [[BC_RESUME_VAL14]], %[[VEC_EPILOG_SCALAR_PH]] ], [ [[PTR_NEXT:%.*]], %[[LOOP]] ]
; CHECK-NEXT: [[L:%.*]] = load i32, ptr [[PTR_IV]], align 4
; CHECK-NEXT: [[GEP:%.*]] = getelementptr i32, ptr [[DST]], i64 [[IV]]
; CHECK-NEXT: store i32 [[L]], ptr [[GEP]], align 4
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 976ed37b6871a..4e5ce493ef5d5 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/AArch64/std-find.ll b/llvm/test/Transforms/PhaseOrdering/AArch64/std-find.ll
index c6b4ca5181a12..69b23200b239b 100644
--- a/llvm/test/Transforms/PhaseOrdering/AArch64/std-find.ll
+++ b/llvm/test/Transforms/PhaseOrdering/AArch64/std-find.ll
@@ -146,8 +146,8 @@ define i64 @std_find_i16_constant_offset_with_assumptions(ptr %first.coerce, i16
; CHECK-NEXT: [[TMP8:%.*]] = getelementptr i8, ptr [[FIRST_COERCE]], i64 [[TMP7]]
; CHECK-NEXT: br label %[[RETURN]]
; CHECK: [[RETURN]]:
-; CHECK-NEXT: [[MERGE:%.*]] = phi ptr [ [[TMP8]], %[[VECTOR_EARLY_EXIT]] ], [ [[COERCE_VAL_IP]], %[[VECTOR_BODY_INTERIM_14]] ]
-; CHECK-NEXT: [[DOTPRE:%.*]] = ptrtoint ptr [[MERGE]] to i64
+; CHECK-NEXT: [[__FIRST_ADDR_0_LCSSA_I_I_PH:%.*]] = phi ptr [ [[TMP8]], %[[VECTOR_EARLY_EXIT]] ], [ [[COERCE_VAL_IP]], %[[VECTOR_BODY_INTERIM_14]] ]
+; CHECK-NEXT: [[DOTPRE:%.*]] = ptrtoint ptr [[__FIRST_ADDR_0_LCSSA_I_I_PH]] to i64
; CHECK-NEXT: ret i64 [[DOTPRE]]
;
entry:
@@ -202,8 +202,8 @@ define i64 @std_find_i16_constant_offset_no_assumptions(ptr %first.coerce, i16 n
; CHECK-NEXT: [[CMP_NOT_I_I:%.*]] = icmp eq ptr [[PTR_IV_NEXT]], [[COERCE_VAL_IP]]
; CHECK-NEXT: br i1 [[CMP_NOT_I_I]], label %[[RETURN]], label %[[LOOP_HEADER]]
; CHECK: [[RETURN]]:
-; CHECK-NEXT: [[MERGE:%.*]] = phi ptr [ [[PTR_IV]], %[[LOOP_HEADER]] ], [ [[COERCE_VAL_IP]], %[[LOOP_LATCH]] ]
-; CHECK-NEXT: [[DOTPRE:%.*]] = ptrtoint ptr [[MERGE]] to i64
+; CHECK-NEXT: [[MERGE_PH:%.*]] = phi ptr [ [[PTR_IV]], %[[LOOP_HEADER]] ], [ [[COERCE_VAL_IP]], %[[LOOP_LATCH]] ]
+; CHECK-NEXT: [[DOTPRE:%.*]] = ptrtoint ptr [[MERGE_PH]] to i64
; CHECK-NEXT: ret i64 [[DOTPRE]]
;
entry:
>From afb2d7a9991f233b55478420d8540892e5c70330 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Sun, 5 Jul 2026 08:50:08 +0100
Subject: [PATCH 11/14] !fixup model ptrtoint of structured pointers, fix
folding regression
---
llvm/include/llvm/Analysis/ScalarEvolution.h | 2 +-
llvm/lib/Analysis/ScalarEvolution.cpp | 9 ++++++---
llvm/test/Analysis/ScalarEvolution/ptrtoint.ll | 10 +++++-----
llvm/test/Transforms/PhaseOrdering/AArch64/std-find.ll | 4 ++--
4 files changed, 14 insertions(+), 11 deletions(-)
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
index be0799e4230fd..7a4dbd5278a91 100644
--- a/llvm/include/llvm/Analysis/ScalarEvolution.h
+++ b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -875,7 +875,7 @@ class ScalarEvolution {
/// 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/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index d7c93f8c9c16b..c261330aab0fc 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -8375,10 +8375,13 @@ const SCEV *ScalarEvolution::createSCEV(Value *V) {
}
case Instruction::PtrToInt: {
- // Keep ptrtoint as SCEVUnknown, except ptrtoint of a pointer add-rec to
- // preserve the integer induction structure.
+ // 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<SCEVAddRecExpr>(PtrSCEV)) {
+ if (!isa<SCEVUnknown>(PtrSCEV)) {
const SCEV *Addr = getPtrToAddrExpr(PtrSCEV);
if (!isa<SCEVCouldNotCompute>(Addr) &&
getTypeSizeInBits(V->getType()) <= getTypeSizeInBits(Addr->getType()))
diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
index 66a0eb0319cac..04e49f5fb149f 100644
--- a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
+++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
@@ -188,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: --> %p0 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'
@@ -270,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: --> %p0 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'
@@ -294,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: --> %p0 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'
@@ -318,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: --> %p0 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'
@@ -342,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: --> %p0 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'
diff --git a/llvm/test/Transforms/PhaseOrdering/AArch64/std-find.ll b/llvm/test/Transforms/PhaseOrdering/AArch64/std-find.ll
index 69b23200b239b..5941eb6fa8046 100644
--- a/llvm/test/Transforms/PhaseOrdering/AArch64/std-find.ll
+++ b/llvm/test/Transforms/PhaseOrdering/AArch64/std-find.ll
@@ -253,8 +253,8 @@ define ptr @std_find_caller(ptr noundef %first, ptr noundef %last) {
; CHECK-NEXT: [[FIRST3:%.*]] = ptrtoint ptr [[FIRST]] to i64
; CHECK-NEXT: [[PTR_SUB:%.*]] = sub i64 [[LAST_I64]], [[FIRST3]]
; CHECK-NEXT: [[SCEVGEP:%.*]] = getelementptr i8, ptr [[FIRST]], i64 [[PTR_SUB]]
-; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[LAST_I64]], [[FIRST3]]
-; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP0]], -2
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[LAST_I64]], -2
+; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[FIRST3]]
; CHECK-NEXT: [[TMP2:%.*]] = lshr exact i64 [[TMP1]], 1
; CHECK-NEXT: [[TMP3:%.*]] = add nuw i64 [[TMP2]], 1
; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP1]], 14
>From 9396189925a8579d6454113f92d29b25db6b07e3 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Sun, 5 Jul 2026 09:34:00 +0100
Subject: [PATCH 12/14] !fixup expand ptrtoaddr as ptrtoint when equivalent
ptrtoint exists, to enable CSE
---
.../Utils/ScalarEvolutionExpander.cpp | 12 +++-
.../Utils/ScalarEvolutionExpanderTest.cpp | 67 +++++++++++++++++++
2 files changed, 78 insertions(+), 1 deletion(-)
diff --git a/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp b/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp
index d7c499542e475..1358df82d1709 100644
--- a/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp
+++ b/llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp
@@ -1455,6 +1455,7 @@ Value *SCEVExpander::visitPtrToAddrExpr(SCEVUseT<const SCEVPtrToAddrExpr *> S) {
// ptrtoaddr and ptrtoint produce the same value if the result type matches,
// so try to reuse either.
+ CastInst::CastOps Opcode = CastInst::PtrToAddr;
if (!isa<Constant>(V)) {
BasicBlock::iterator BIP = Builder.GetInsertPoint();
for (User *U : V->users()) {
@@ -1464,9 +1465,18 @@ Value *SCEVExpander::visitPtrToAddrExpr(SCEVUseT<const SCEVPtrToAddrExpr *> S) {
CI->getOpcode() == CastInst::PtrToInt) &&
&*BIP != CI && SE.DT.dominates(CI, &*BIP))
return CI;
+ // If an equivalent ptrtoint of the same pointer already exists (but does
+ // not dominate the insertion point, so cannot be reused directly), emit
+ // a ptrtoint rather than a ptrtoaddr. Both compute the same value, and
+ // materializing the same opcode lets a later CSE/GVN pass merge the two.
+ // This does not lose any alias-analysis precision: ptrtoint captures the
+ // pointer's provenance in addition to its address, but that provenance
+ // is already captured by the pre-existing ptrtoint.
+ if (CI && CI->getType() == Ty && CI->getOpcode() == CastInst::PtrToInt)
+ Opcode = CastInst::PtrToInt;
}
}
- return ReuseOrCreateCast(V, Ty, CastInst::PtrToAddr,
+ return ReuseOrCreateCast(V, Ty, Opcode,
GetOptimalInsertionPointForCastOf(V));
}
diff --git a/llvm/unittests/Transforms/Utils/ScalarEvolutionExpanderTest.cpp b/llvm/unittests/Transforms/Utils/ScalarEvolutionExpanderTest.cpp
index 5dcc833d8893f..3247ae631ca53 100644
--- a/llvm/unittests/Transforms/Utils/ScalarEvolutionExpanderTest.cpp
+++ b/llvm/unittests/Transforms/Utils/ScalarEvolutionExpanderTest.cpp
@@ -1036,4 +1036,71 @@ TEST_F(ScalarEvolutionExpanderTest, InsertBinopReuseShlWithMatchingFlags) {
EXPECT_TRUE(ShlInst->hasNoSignedWrap());
}
+// When expanding a ptrtoaddr SCEV and an equivalent ptrtoint of the same
+// pointer already exists but does not dominate the insertion point, the
+// expander should emit a ptrtoint (rather than a ptrtoaddr) so that a later
+// CSE/GVN pass can merge the two. ptrtoint and ptrtoaddr compute the same
+// value here, and no alias-analysis precision is lost because the pointer's
+// provenance is already captured by the pre-existing ptrtoint.
+TEST_F(ScalarEvolutionExpanderTest, ExpandPtrToAddrReusesPtrToInt) {
+ LLVMContext C;
+ SMDiagnostic Err;
+ std::unique_ptr<Module> M = parseAssemblyString(
+ "define i64 @f(ptr %p) { "
+ "entry: "
+ " br label %next "
+ "next: "
+ " %pi = ptrtoint ptr %p to i64 "
+ " ret i64 %pi "
+ "} ",
+ Err, C);
+ assert(M && "Could not parse module?");
+ assert(!verifyModule(*M) && "Must have been well formed!");
+
+ Function *F = M->getFunction("f");
+ ASSERT_NE(F, nullptr) << "Could not find function 'f'";
+
+ ScalarEvolution SE = buildSE(*F);
+ const SCEV *Addr = SE.getPtrToAddrExpr(SE.getSCEV(F->getArg(0)));
+ ASSERT_FALSE(isa<SCEVCouldNotCompute>(Addr));
+
+ // Expand in the entry block, which does not contain (and is dominated by no)
+ // ptrtoint. The pre-existing %pi in %next does not dominate the insertion
+ // point, so it can't be reused directly, but its presence should steer the
+ // expander to emit a ptrtoint.
+ auto *InsertBefore = F->getEntryBlock().getTerminator();
+ SCEVExpander Exp(SE, "expander");
+ auto *I = cast<Instruction>(Exp.expandCodeFor(Addr, nullptr, InsertBefore));
+ EXPECT_EQ(I->getOpcode(), Instruction::PtrToInt)
+ << "Expected ptrtoint to be emitted when an equivalent ptrtoint exists";
+}
+
+// When expanding a ptrtoaddr SCEV and no equivalent ptrtoint of the same
+// pointer exists, the expander should emit a ptrtoaddr, preserving the
+// stronger alias-analysis semantics (ptrtoaddr captures only the address).
+TEST_F(ScalarEvolutionExpanderTest, ExpandPtrToAddrKeepsPtrToAddr) {
+ LLVMContext C;
+ SMDiagnostic Err;
+ std::unique_ptr<Module> M = parseAssemblyString("define i64 @f(ptr %p) { "
+ "entry: "
+ " ret i64 0 "
+ "} ",
+ Err, C);
+ assert(M && "Could not parse module?");
+ assert(!verifyModule(*M) && "Must have been well formed!");
+
+ Function *F = M->getFunction("f");
+ ASSERT_NE(F, nullptr) << "Could not find function 'f'";
+
+ ScalarEvolution SE = buildSE(*F);
+ const SCEV *Addr = SE.getPtrToAddrExpr(SE.getSCEV(F->getArg(0)));
+ ASSERT_FALSE(isa<SCEVCouldNotCompute>(Addr));
+
+ auto *InsertBefore = F->getEntryBlock().getTerminator();
+ SCEVExpander Exp(SE, "expander");
+ auto *I = cast<Instruction>(Exp.expandCodeFor(Addr, nullptr, InsertBefore));
+ EXPECT_EQ(I->getOpcode(), Instruction::PtrToAddr)
+ << "Expected ptrtoaddr to be kept when no equivalent ptrtoint exists";
+}
+
} // end namespace llvm
>From 314618f969d3f35ea8a17ebae020015fe63ce96b Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Mon, 6 Jul 2026 09:48:54 +0100
Subject: [PATCH 13/14] !fixup add IR regression test for ptrtoaddr/ptrtoint
expansion dedup
---
.../expand-ptrtoaddr-reuse-ptrtoint.ll | 64 +++++++++++++++++++
1 file changed, 64 insertions(+)
create mode 100644 llvm/test/Transforms/LoopStrengthReduce/AArch64/expand-ptrtoaddr-reuse-ptrtoint.ll
diff --git a/llvm/test/Transforms/LoopStrengthReduce/AArch64/expand-ptrtoaddr-reuse-ptrtoint.ll b/llvm/test/Transforms/LoopStrengthReduce/AArch64/expand-ptrtoaddr-reuse-ptrtoint.ll
new file mode 100644
index 0000000000000..136e530fc3be0
--- /dev/null
+++ b/llvm/test/Transforms/LoopStrengthReduce/AArch64/expand-ptrtoaddr-reuse-ptrtoint.ll
@@ -0,0 +1,64 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -passes='loop-reduce' -S %s | FileCheck %s
+
+target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-n32:64-S128-Fn32"
+target triple = "arm64-apple-macosx15.0.0"
+
+; When SCEVExpander materializes the address of %end for the loop trip count and
+; an equivalent `ptrtoint ptr %end` already exists (used by %slack), it should
+; expand as `ptrtoint` rather than `ptrtoaddr`, so both conversions of %end use
+; the same opcode and can be CSE'd. Otherwise %end is converted to an integer
+; twice (once via ptrtoaddr, once via ptrtoint), which is pure redundancy.
+
+define i64 @expand_reuses_existing_ptrtoint(ptr %begin, ptr %end, ptr %cap) {
+; CHECK-LABEL: @expand_reuses_existing_ptrtoint(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[BEGIN2:%.*]] = ptrtoaddr ptr [[BEGIN:%.*]] to i64
+; CHECK-NEXT: [[END1:%.*]] = ptrtoint 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:
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -8
+; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[BEGIN2]]
+; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 3
+; CHECK-NEXT: [[TMP3:%.*]] = shl nuw i64 [[TMP2]], 3
+; CHECK-NEXT: [[TMP4:%.*]] = add i64 [[TMP3]], 8
+; CHECK-NEXT: br label [[COUNT:%.*]]
+; CHECK: count:
+; CHECK-NEXT: [[P:%.*]] = phi ptr [ [[BEGIN]], [[COUNT_PH]] ], [ [[PN:%.*]], [[COUNT]] ]
+; CHECK-NEXT: [[PN]] = getelementptr inbounds nuw i8, ptr [[P]], i64 8
+; CHECK-NEXT: [[D:%.*]] = icmp eq ptr [[PN]], [[END]]
+; CHECK-NEXT: br i1 [[D]], label [[DONE_LOOPEXIT:%.*]], label [[COUNT]]
+; CHECK: done.loopexit:
+; CHECK-NEXT: br label [[DONE]]
+; CHECK: done:
+; CHECK-NEXT: [[USED:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[TMP4]], [[DONE_LOOPEXIT]] ]
+; CHECK-NEXT: [[CAPI:%.*]] = ptrtoint ptr [[CAP:%.*]] to i64
+; CHECK-NEXT: [[ENDI:%.*]] = ptrtoint ptr [[END]] to i64
+; CHECK-NEXT: [[SLACK:%.*]] = sub i64 [[CAPI]], [[ENDI]]
+; CHECK-NEXT: [[TOTAL:%.*]] = add i64 [[USED]], [[SLACK]]
+; CHECK-NEXT: ret i64 [[TOTAL]]
+;
+entry:
+ %c0 = icmp eq ptr %begin, %end
+ br i1 %c0, label %done, label %count.ph
+
+count.ph:
+ br label %count
+
+count:
+ %p = phi ptr [ %begin, %count.ph ], [ %pn, %count ]
+ %n = phi i64 [ 0, %count.ph ], [ %nn, %count ]
+ %pn = getelementptr inbounds nuw i8, ptr %p, i64 8
+ %nn = add i64 %n, 8
+ %d = icmp eq ptr %pn, %end
+ br i1 %d, label %done, label %count
+
+done:
+ %used = phi i64 [ 0, %entry ], [ %nn, %count ]
+ %capi = ptrtoint ptr %cap to i64
+ %endi = ptrtoint ptr %end to i64
+ %slack = sub i64 %capi, %endi
+ %total = add i64 %used, %slack
+ ret i64 %total
+}
>From ef0cf590ba3b509bb9b8e1c6fd90fb48183dfc07 Mon Sep 17 00:00:00 2001
From: Florian Hahn <flo at fhahn.com>
Date: Mon, 6 Jul 2026 10:15:04 +0100
Subject: [PATCH 14/14] !fixup add IndVarSimplify IR regression test for
ptrtoaddr/ptrtoint dedup
---
.../ScalarEvolution/exit-count-select-safe.ll | 2 +-
.../ptrtoint-special-pointers.ll | 19 +++++++++---------
.../AArch64/aggressive-interleaving.ll | 4 ++--
.../LoopVectorize/RISCV/pointer-induction.ll | 2 +-
.../LoopVectorize/VPlan/expand-scev.ll | 4 ++--
.../vplan-printing-reductions-tail-folded.ll | 10 +++++-----
.../optimal-epilog-vectorization-liveout.ll | 3 ++-
.../runtime-checks-difference.ll | 15 +++++++-------
.../single-early-exit-deref-assumptions.ll | 20 +++++++++----------
9 files changed, 41 insertions(+), 38 deletions(-)
diff --git a/llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll b/llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll
index f3a0047b6e815..c200c8c5e7734 100644
--- a/llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll
+++ b/llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll
@@ -509,7 +509,7 @@ define i64 @uminseq_vs_ptrtoint_complexity(i64 %n, i64 %m, ptr %ptr) {
; CHECK-NEXT: %ptr.int = ptrtoint ptr %ptr to i64
; CHECK-NEXT: --> %ptr.int U: full-set S: full-set
; CHECK-NEXT: %r = add i64 %i, %ptr.int
-; 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: --> ({0,+,1}<nuw><%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/ptrtoint-special-pointers.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint-special-pointers.ll
index 9130db57727f6..b9877f46189d8 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}<nuw><%loop> U: full-set S: full-set Exits: <<Unknown>> 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: <<Unknown>> LoopDispositions: { %loop: Variant }
+; CHECK-NEXT: --> {(ptrtoaddr ptr addrspace(1) %in to i64),+,4}<nuw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.next = getelementptr inbounds i32, ptr addrspace(1) %iv, i64 1
; CHECK-NEXT: --> {(4 + %in),+,4}<nw><%loop> U: full-set S: full-set Exits: <<Unknown>> 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}<nuw><%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {%start,+,4}<nuw><%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))<nuw> umax (ptrtoaddr ptr addrspace(1) %end to i64))) /u 4))<nuw> + %start) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.next = getelementptr inbounds i32, ptr addrspace(1) %iv, i64 1
-; CHECK-NEXT: --> {(4 + %start)<nuw>,+,4}<nuw><%loop> U: [4,0) S: [4,0) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {(4 + %start)<nuw>,+,4}<nuw><%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))<nuw> umax (ptrtoaddr ptr addrspace(1) %end to i64))) /u 4))<nuw> + %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))<nuw> 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))<nuw> 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/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll b/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll
index 3eaf4c4b1b3f4..70d15bb740284 100644
--- a/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll
+++ b/llvm/test/Transforms/LoopVectorize/AArch64/aggressive-interleaving.ll
@@ -17,11 +17,11 @@ define void @test_interleave_reduction(ptr %arg, ptr %arg1) {
; A320: [[OUTER]]:
; A320-NEXT: [[TPM26:%.*]] = add i64 0, 1
; A320-NEXT: [[TPM10:%.*]] = alloca i32, align 8
-; A320-NEXT: [[TPM102:%.*]] = ptrtoint ptr [[TPM10]] to i64
+; A320-NEXT: [[TPM102:%.*]] = ptrtoaddr ptr [[TPM10]] to i64
; A320-NEXT: [[TPM27:%.*]] = getelementptr inbounds i32, ptr [[TPM10]], i64 [[TPM26]]
; A320-NEXT: [[TPM28:%.*]] = getelementptr inbounds ptr, ptr [[TPM15]], i64 0
; A320-NEXT: [[TPM29:%.*]] = load ptr, ptr [[TPM28]], align 8
-; A320-NEXT: [[TPM291:%.*]] = ptrtoint ptr [[TPM29]] to i64
+; A320-NEXT: [[TPM291:%.*]] = ptrtoaddr ptr [[TPM29]] to i64
; A320-NEXT: [[TPM17:%.*]] = alloca double, align 8
; A320-NEXT: [[TPM32:%.*]] = getelementptr inbounds double, ptr [[TPM17]], i64 [[TPM26]]
; A320-NEXT: [[TMP0:%.*]] = add i64 [[TPM291]], -8
diff --git a/llvm/test/Transforms/LoopVectorize/RISCV/pointer-induction.ll b/llvm/test/Transforms/LoopVectorize/RISCV/pointer-induction.ll
index 6fe0ea3ac8ae2..7680d36f00583 100644
--- a/llvm/test/Transforms/LoopVectorize/RISCV/pointer-induction.ll
+++ b/llvm/test/Transforms/LoopVectorize/RISCV/pointer-induction.ll
@@ -65,11 +65,11 @@ define i1 @scalarize_ptr_induction(ptr %start, ptr %end, ptr noalias %dst, i1 %c
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[START2:%.*]] = ptrtoaddr ptr [[START]] to i64
; CHECK-NEXT: [[END1:%.*]] = ptrtoaddr ptr [[END]] to i64
-; CHECK-NEXT: [[SCEVGEP6:%.*]] = getelementptr i8, ptr [[START]], i64 4
; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[END1]], -12
; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[START2]]
; CHECK-NEXT: [[TMP2:%.*]] = udiv i64 [[TMP1]], 12
; CHECK-NEXT: [[TMP3:%.*]] = add nuw nsw i64 [[TMP2]], 1
+; CHECK-NEXT: [[SCEVGEP6:%.*]] = getelementptr i8, ptr [[START]], i64 4
; CHECK-NEXT: br label %[[VECTOR_MEMCHECK:.*]]
; CHECK: [[VECTOR_MEMCHECK]]:
; CHECK-NEXT: [[BROADCAST_SPLATINSERT:%.*]] = insertelement <vscale x 2 x ptr> poison, ptr [[DST]], i64 0
diff --git a/llvm/test/Transforms/LoopVectorize/VPlan/expand-scev.ll b/llvm/test/Transforms/LoopVectorize/VPlan/expand-scev.ll
index d19c09486a95b..e360a5c3e6e1c 100644
--- a/llvm/test/Transforms/LoopVectorize/VPlan/expand-scev.ll
+++ b/llvm/test/Transforms/LoopVectorize/VPlan/expand-scev.ll
@@ -263,8 +263,8 @@ define void @scev_ptrtoint_expanded(ptr %start, ptr %end) {
; CHECK-NEXT: Live-in ir<%0> = original trip-count
; CHECK-EMPTY:
; CHECK-NEXT: ir-bb<entry>:
-; CHECK-NEXT: IR %start2 = ptrtoint ptr %start to i64
-; CHECK-NEXT: IR %end1 = ptrtoint ptr %end to i64
+; CHECK-NEXT: IR %start2 = ptrtoaddr ptr %start to i64
+; CHECK-NEXT: IR %end1 = ptrtoaddr ptr %end to i64
; CHECK-NEXT: IR %0 = sub i64 %end1, %start2
; CHECK-NEXT: EMIT vp<%min.iters.check> = icmp ult ir<%0>, ir<4>
; 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 9ed9d2677fd89..e592e784ca6a2 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<entry>:
-; 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<entry>:
-; 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<entry>:
-; 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<entry>:
-; 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<entry>:
-; 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/optimal-epilog-vectorization-liveout.ll b/llvm/test/Transforms/LoopVectorize/optimal-epilog-vectorization-liveout.ll
index d96da0b56da96..f2c4995086229 100644
--- a/llvm/test/Transforms/LoopVectorize/optimal-epilog-vectorization-liveout.ll
+++ b/llvm/test/Transforms/LoopVectorize/optimal-epilog-vectorization-liveout.ll
@@ -224,7 +224,8 @@ define ptr @test_ptr_iv_live_out(ptr %start, ptr %end, ptr %dst) {
; CHECK-NEXT: br i1 [[IDENT_CHECK]], label %[[VEC_EPILOG_SCALAR_PH]], label %[[VECTOR_MEMCHECK:.*]]
; CHECK: [[VECTOR_MEMCHECK]]:
; CHECK-NEXT: [[TMP8:%.*]] = sub i64 [[DST3]], [[START5]]
-; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP8]], 16
+; 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:.*]]
; CHECK: [[VECTOR_MAIN_LOOP_ITER_CHECK]]:
; CHECK-NEXT: [[MIN_ITERS_CHECK6:%.*]] = icmp ult i64 [[TMP3]], 4
diff --git a/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll b/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
index 23bacc556e882..80ab963afde5a 100644
--- a/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
+++ b/llvm/test/Transforms/LoopVectorize/runtime-checks-difference.ll
@@ -516,20 +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: [[TMP14:%.*]] = add i32 [[D]], [[TMP1]]
; CHECK-NEXT: [[TMP4:%.*]] = add i32 [[TMP14]], -1
-; CHECK-NEXT: [[TMP5:%.*]] = zext i32 [[TMP4]] to i64
+; CHECK-NEXT: [[TMP3:%.*]] = trunc i64 [[LHS]] to i32
+; CHECK-NEXT: [[TMP7:%.*]] = sub i32 [[TMP4]], [[TMP3]]
+; CHECK-NEXT: [[TMP5:%.*]] = zext i32 [[TMP7]] 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: [[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: [[TMP9:%.*]] = sub i64 [[TMP13]], 1
+; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP9]], 3
; CHECK-NEXT: br i1 [[DIFF_CHECK]], [[SCALAR_PH]], [[VECTOR_PH:label %.*]]
;
entry:
@@ -590,7 +590,8 @@ define void @phi_of_ptrtoint_diff_check(ptr %base, ptr %end, i64 %n, i1 %cond) {
; CHECK: [[VECTOR_MEMCHECK]]:
; CHECK-NEXT: [[TMP2:%.*]] = add i64 [[N]], [[DST_PTR1]]
; CHECK-NEXT: [[TMP5:%.*]] = sub i64 [[TMP2]], [[DST_INT]]
-; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP5]], 4
+; CHECK-NEXT: [[TMP6:%.*]] = sub i64 [[TMP5]], 1
+; CHECK-NEXT: [[DIFF_CHECK:%.*]] = icmp ult i64 [[TMP6]], 3
; CHECK-NEXT: br i1 [[DIFF_CHECK]], [[SCALAR_PH]], [[VECTOR_PH:label %.*]]
;
entry:
diff --git a/llvm/test/Transforms/LoopVectorize/single-early-exit-deref-assumptions.ll b/llvm/test/Transforms/LoopVectorize/single-early-exit-deref-assumptions.ll
index 8be66cc4c8ef8..0d8552a2c0fbb 100644
--- a/llvm/test/Transforms/LoopVectorize/single-early-exit-deref-assumptions.ll
+++ b/llvm/test/Transforms/LoopVectorize/single-early-exit-deref-assumptions.ll
@@ -398,8 +398,8 @@ define ptr @find_deref_pointer_distance_align_attribute_argument(ptr align 2 %fi
; CHECK-NEXT: [[C_0:%.*]] = icmp eq ptr [[FIRST]], [[LAST]]
; CHECK-NEXT: br i1 [[C_0]], label %[[EXIT:.*]], label %[[LOOP_HEADER_PREHEADER:.*]]
; CHECK: [[LOOP_HEADER_PREHEADER]]:
-; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[LAST_I64]], [[FIRST_I64]]
-; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP0]], -2
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[LAST_I64]], -2
+; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[FIRST_I64]]
; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 1
; CHECK-NEXT: [[TMP3:%.*]] = add nuw i64 [[TMP2]], 1
; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP3]], 4
@@ -491,8 +491,8 @@ define ptr @find_deref_pointer_distance_align_assumption(ptr %first, ptr %last)
; CHECK-NEXT: [[C_0:%.*]] = icmp eq ptr [[FIRST]], [[LAST]]
; CHECK-NEXT: br i1 [[C_0]], label %[[EXIT:.*]], label %[[LOOP_HEADER_PREHEADER:.*]]
; CHECK: [[LOOP_HEADER_PREHEADER]]:
-; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[LAST_I64]], [[FIRST_I64]]
-; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP0]], -2
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[LAST_I64]], -2
+; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[FIRST_I64]]
; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 1
; CHECK-NEXT: [[TMP3:%.*]] = add nuw i64 [[TMP2]], 1
; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP3]], 4
@@ -704,8 +704,8 @@ define i64 @find_if_pointer_distance_deref_via_assumption(ptr %vec) nofree nosyn
; CHECK-NEXT: br i1 [[IS_EMPTY]], label %[[EXIT:.*]], label %[[LOOP_PREHEADER:.*]]
; CHECK: [[LOOP_PREHEADER]]:
; CHECK-NEXT: [[END_PTR:%.*]] = getelementptr i8, ptr [[BEGIN]], i64 [[DISTANCE]]
-; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[END_INT]], [[BEGIN_INT]]
-; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP0]], -2
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[END_INT]], -2
+; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[BEGIN_INT]]
; CHECK-NEXT: [[TMP2:%.*]] = lshr i64 [[TMP1]], 1
; CHECK-NEXT: [[TMP3:%.*]] = add nuw i64 [[TMP2]], 1
; CHECK-NEXT: [[MIN_ITERS_CHECK:%.*]] = icmp ult i64 [[TMP3]], 4
@@ -1108,8 +1108,8 @@ define i64 @VectorizingWithoutNoSyncAttributeTest(ptr noundef nonnull readonly a
; CHECK-NEXT: [[C_1:%.*]] = icmp eq ptr [[L_V]], [[L_GEP_V]]
; CHECK-NEXT: br i1 [[C_1]], label %[[EXIT:.*]], label %[[LOOP_PREHEADER:.*]]
; CHECK: [[LOOP_PREHEADER]]:
-; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[PI_L_GEP_V]], [[PI_L_V]]
-; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP0]], -4
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[PI_L_GEP_V]], -4
+; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[PI_L_V]]
; 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]], 4
@@ -1225,8 +1225,8 @@ define i64 @volatileNotVectorizingTest(ptr noundef nonnull readonly align 8 capt
; CHECK-NEXT: [[C_1:%.*]] = icmp eq ptr [[L_V]], [[L_GEP_V]]
; CHECK-NEXT: br i1 [[C_1]], label %[[EXIT:.*]], label %[[LOOP_PREHEADER:.*]]
; CHECK: [[LOOP_PREHEADER]]:
-; CHECK-NEXT: [[TMP0:%.*]] = sub i64 [[PI_L_GEP_V]], [[PI_L_V]]
-; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP0]], -4
+; CHECK-NEXT: [[TMP0:%.*]] = add i64 [[PI_L_GEP_V]], -4
+; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[TMP0]], [[PI_L_V]]
; 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]], 4
More information about the llvm-commits
mailing list