[SCEV] Index type usually is, but is not guaranteed to be, equal to the pointer bit width

[lebedev.ri]

Summary

As it is being noticed in D89456, and being pointed out
by @efriedma https://reviews.llvm.org/D89456#inline-831603
if we use narrower type to represent the ConstantRange of a pointer,
we will end up with a wrong result.

In datalayout, there's pointer bit width, and a index bit width.
Latter is, by default, equal to the pointer bit width, but it can be different.
And SCEV uses index bit width everywhere, where pointer bit width was obviously meant..

[efriedma]

I'm not sure I completely understand the history from https://reviews.llvm.org/D42123. But I think the idea is that for pointer-type SCEVs, we want to do SCEV arithmetic using the index type because the other bits aren't relevant: from my understanding, they don't participate in pointer arithmetic.

So I think the right solution is to leave this code alone. And maybe don't create SCEVPtrToInt expressions for ptrtoint operations on pointers where getIndexTypeSizeInBits() isn't equal to getTypeSizeInBits(), at least initially, since it's sort of tricky to reason about.

[lebedev.ri]

Thank you for taking a look!

In D89540#2335050, @efriedma wrote:

I'm not sure I completely understand the history from https://reviews.llvm.org/D42123. But I think the idea is that for pointer-type SCEVs, we want to do SCEV arithmetic using the index type because the other bits aren't relevant: from my understanding, they don't participate in pointer arithmetic.

So I think the right solution is to leave this code alone. And maybe don't create SCEVPtrToInt expressions for ptrtoint operations on pointers where getIndexTypeSizeInBits() isn't equal to getTypeSizeInBits(), at least initially, since it's sort of tricky to reason about.

I question sanity of that approach.
That being said, then perhaps D89456 simply should also pretend that the pointer's high bits don't exist if they don't matter for us?

[efriedma]

Assuming we have properly typed SCEVs, we can pretend the high bits of the pointer don't exist in a pointer SCEV. We can't pretend they don't exist in an integer SCEV: that leads to miscompiles. This is why SCEVPtrToIntExpr, specifically, needs special handling.

My suggestion was just to skip creating SCEVPtrToInt was mostly so you don't have to write a bunch of tests for various operations on SCEVPtrToInt expressions involving pointers with a narrow index type. It's probably not hard to implement, just sort of tedious, and we don't have good testing infrastructure.

[lebedev.ri]

Okay, i'm fine with that.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

bool llvm::isConsecutiveAccess(Value *A, Value *B, const DataLayout &DL,
   // equal to the size.
   // BaseDelta = Size - OffsetDelta;
   const SCEV *SizeSCEV = SE.getConstant(Size);
   const SCEV *BaseDelta = SE.getMinusSCEV(SizeSCEV, OffsetDeltaSCEV);
 
   // Otherwise compute the distance with SCEV between the base pointers.
   const SCEV *PtrSCEVA = SE.getSCEV(PtrA);
   const SCEV *PtrSCEVB = SE.getSCEV(PtrB);
-  const SCEV *X = SE.getAddExpr(PtrSCEVA, BaseDelta);
+  const SCEV *X = SE.getAddExpr(
+      PtrSCEVA, SE.getTruncateOrSignExtend(
+                    BaseDelta, SE.getEffectiveSCEVType(PtrSCEVA->getType())));
   return X == PtrSCEVB;
 }
 
 MemoryDepChecker::VectorizationSafetyStatus
 MemoryDepChecker::Dependence::isSafeForVectorization(DepType Type) {
   switch (Type) {
   case NoDep:
   case Forward:

llvm/lib/Analysis/ScalarEvolution.cpp

bool ScalarEvolution::isSCEVable(Type *Ty) const {
   // Integers and pointers are always SCEVable.
   return Ty->isIntOrPtrTy();
 }
 
 /// Return the size in bits of the specified type, for which isSCEVable must
 /// return true.
 uint64_t ScalarEvolution::getTypeSizeInBits(Type *Ty) const {
   assert(isSCEVable(Ty) && "Type is not SCEVable!");
-  if (Ty->isPointerTy())
-    return getDataLayout().getIndexTypeSizeInBits(Ty);
-  return getDataLayout().getTypeSizeInBits(Ty);
+  return getDataLayout().getTypeSizeInBits(getEffectiveSCEVType(Ty));
 }
 
 /// Return a type with the same bitwidth as the given type and which represents
 /// how SCEV will treat the given type, for which isSCEVable must return
-/// true. For pointer types, this is the pointer index sized integer type.
+/// true. For pointer types, this is the pointer-sized integer type.
 Type *ScalarEvolution::getEffectiveSCEVType(Type *Ty) const {
   assert(isSCEVable(Ty) && "Type is not SCEVable!");
 
   if (Ty->isIntegerTy())
     return Ty;
 
   // The only other support type is pointer.
   assert(Ty->isPointerTy() && "Unexpected non-pointer non-integer type!");
-  return getDataLayout().getIndexType(Ty);
+  return getDataLayout().getIntPtrType(Ty);
 }
 
 Type *ScalarEvolution::getWiderType(Type *T1, Type *T2) const {
   return  getTypeSizeInBits(T1) >= getTypeSizeInBits(T2) ? T1 : T2;
 }
 
 const SCEV *ScalarEvolution::getCouldNotCompute() {
   return CouldNotCompute.get();

llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp

bool LoopIdiomRecognize::processLoopStridedStore(
   // header.  This allows us to insert code for it in the preheader.
   unsigned DestAS = DestPtr->getType()->getPointerAddressSpace();
   BasicBlock *Preheader = CurLoop->getLoopPreheader();
   IRBuilder<> Builder(Preheader->getTerminator());
   SCEVExpander Expander(*SE, *DL, "loop-idiom");
   SCEVExpanderCleaner ExpCleaner(Expander, *DT);
 
   Type *DestInt8PtrTy = Builder.getInt8PtrTy(DestAS);
-  Type *IntIdxTy = DL->getIndexType(DestPtr->getType());
+  Type *IntIdxTy = SE->getEffectiveSCEVType(DestPtr->getType());
 
   bool Changed = false;
   const SCEV *Start = Ev->getStart();
   // Handle negative strided loops.
   if (NegStride)
     Start = getStartForNegStride(Start, BECount, IntIdxTy, StoreSize, SE);
 
   // TODO: ideally we should still be able to generate memset if SCEV expander
bool LoopIdiomRecognize::processLoopStoreOfLoopLoad(StoreInst *SI,
   IRBuilder<> Builder(Preheader->getTerminator());
   SCEVExpander Expander(*SE, *DL, "loop-idiom");
 
   SCEVExpanderCleaner ExpCleaner(Expander, *DT);
 
   bool Changed = false;
   const SCEV *StrStart = StoreEv->getStart();
   unsigned StrAS = SI->getPointerAddressSpace();
-  Type *IntIdxTy = Builder.getIntNTy(DL->getIndexSizeInBits(StrAS));
+  Type *IntIdxTy = Builder.getIntNTy(DL->getPointerSizeInBits(StrAS));
 
   // Handle negative strided loops.
   if (NegStride)
     StrStart = getStartForNegStride(StrStart, BECount, IntIdxTy, StoreSize, SE);
 
   // Okay, we have a strided store "p[i]" of a loaded value.  We can turn
   // this into a memcpy in the loop preheader now if we want.  However, this
   // would be unsafe to do if there is anything else in the loop that may read

llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp

Value *SCEVExpander::expandAddToGEP(const SCEV *const *op_begin,
   SmallVector<Value *, 4> GepIndices;
   SmallVector<const SCEV *, 8> Ops(op_begin, op_end);
   bool AnyNonZeroIndices = false;
 
   // Split AddRecs up into parts as either of the parts may be usable
   // without the other.
   SplitAddRecs(Ops, Ty, SE);
 
-  Type *IntIdxTy = DL.getIndexType(PTy);
+  Type *IntIdxTy = DL.getIntPtrType(PTy);
 
   // Descend down the pointer's type and attempt to convert the other
   // operands into GEP indices, at each level. The first index in a GEP
   // indexes into the array implied by the pointer operand; the rest of
   // the indices index into the element or field type selected by the
   // preceding index.
   for (;;) {
     // If the scale size is not 0, attempt to factor out a scale for

llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
 ; RUN: opt < %s --data-layout="p:64:64:64:64" -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck --check-prefixes=ALL,X64,PTR64_IDX64 %s
 ; RUN: opt < %s --data-layout="p:64:64:64:64" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck --check-prefixes=ALL,X64,PTR64_IDX64 %s
 ; RUN: opt < %s --data-layout="p:64:64:64:32" -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck --check-prefixes=ALL,X64,PTR64_IDX32 %s
 ; RUN: opt < %s --data-layout="p:64:64:64:32" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck --check-prefixes=ALL,X64,PTR64_IDX32 %s
 ; RUN: opt < %s --data-layout="p:16:16:16:16" -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck --check-prefixes=ALL,X32,PTR16_IDX16 %s
 ; RUN: opt < %s --data-layout="p:16:16:16:16" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck --check-prefixes=ALL,X32,PTR16_IDX16 %s
 ; RUN: opt < %s --data-layout="p:16:16:16:32" -S -analyze -enable-new-pm=0 -scalar-evolution | FileCheck --check-prefixes=ALL,X32,PTR16_IDX32 %s
 ; RUN: opt < %s --data-layout="p:16:16:16:32" -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck --check-prefixes=ALL,X32,PTR16_IDX32 %s
 
 @global = external hidden global [0 x i8]
 
 declare void @use16(i16)
 
 define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) {
-; PTR64_IDX64-LABEL: 'trunc_ptr_to_i64'
-; PTR64_IDX64-NEXT:  Classifying expressions for: @trunc_ptr_to_i64
-; 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, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64)
-; PTR64_IDX64-NEXT:    --> (ptrtoint ([0 x i8]* @global to i64) + %arg) U: full-set S: full-set Exits: (ptrtoint ([0 x i8]* @global to i64) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR64_IDX64-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
-; PTR64_IDX64-NEXT:    --> (ptrtoint ([0 x i8]* @global to i64) + %arg) U: full-set S: full-set Exits: (ptrtoint ([0 x i8]* @global to i64) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR64_IDX64-NEXT:    %tmp14 = load i32, i32* %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
-; PTR64_IDX64-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR64_IDX64-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i64
-; PTR64_IDX64-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
-; PTR64_IDX64-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
-; PTR64_IDX64-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
-;
-; PTR64_IDX32-LABEL: 'trunc_ptr_to_i64'
-; PTR64_IDX32-NEXT:  Classifying expressions for: @trunc_ptr_to_i64
-; PTR64_IDX32-NEXT:    %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
-; PTR64_IDX32-NEXT:    --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR64_IDX32-NEXT:    %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64)
-; PTR64_IDX32-NEXT:    --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR64_IDX32-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
-; PTR64_IDX32-NEXT:    --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR64_IDX32-NEXT:    %tmp14 = load i32, i32* %tmp13, align 4
-; PTR64_IDX32-NEXT:    --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
-; PTR64_IDX32-NEXT:    %tmp18 = add i32 %tmp, 2
-; PTR64_IDX32-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR64_IDX32-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i64
-; PTR64_IDX32-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
-; PTR64_IDX32-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
-; PTR64_IDX32-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
-;
-; PTR16_IDX16-LABEL: 'trunc_ptr_to_i64'
-; PTR16_IDX16-NEXT:  Classifying expressions for: @trunc_ptr_to_i64
-; 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, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64)
-; PTR16_IDX16-NEXT:    --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR16_IDX16-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
-; PTR16_IDX16-NEXT:    --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR16_IDX16-NEXT:    %tmp14 = load i32, i32* %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
-; PTR16_IDX16-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR16_IDX16-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i64
-; PTR16_IDX16-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
-; PTR16_IDX16-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
-; PTR16_IDX16-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
-;
-; PTR16_IDX32-LABEL: 'trunc_ptr_to_i64'
-; PTR16_IDX32-NEXT:  Classifying expressions for: @trunc_ptr_to_i64
-; PTR16_IDX32-NEXT:    %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
-; PTR16_IDX32-NEXT:    --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR16_IDX32-NEXT:    %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64)
-; PTR16_IDX32-NEXT:    --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) U: [0,131071) S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR16_IDX32-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
-; PTR16_IDX32-NEXT:    --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) U: [0,131071) S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR16_IDX32-NEXT:    %tmp14 = load i32, i32* %tmp13, align 4
-; PTR16_IDX32-NEXT:    --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
-; PTR16_IDX32-NEXT:    %tmp18 = add i32 %tmp, 2
-; PTR16_IDX32-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR16_IDX32-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i64
-; PTR16_IDX32-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
-; PTR16_IDX32-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
-; PTR16_IDX32-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
+; X64-LABEL: 'trunc_ptr_to_i64'
+; X64-NEXT:  Classifying expressions for: @trunc_ptr_to_i64
+; X64-NEXT:    %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
+; X64-NEXT:    --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
+; X64-NEXT:    %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64)
+; X64-NEXT:    --> (ptrtoint ([0 x i8]* @global to i64) + %arg) U: full-set S: full-set Exits: (ptrtoint ([0 x i8]* @global to i64) + %arg) LoopDispositions: { %bb11: Invariant }
+; X64-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
+; X64-NEXT:    --> (ptrtoint ([0 x i8]* @global to i64) + %arg) U: full-set S: full-set Exits: (ptrtoint ([0 x i8]* @global to i64) + %arg) LoopDispositions: { %bb11: Invariant }
+; X64-NEXT:    %tmp14 = load i32, i32* %tmp13, align 4
+; X64-NEXT:    --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
+; X64-NEXT:    %tmp18 = add i32 %tmp, 2
+; X64-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
+; X64-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i64
+; X64-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
+; X64-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
+; X64-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
+;
+; X32-LABEL: 'trunc_ptr_to_i64'
+; X32-NEXT:  Classifying expressions for: @trunc_ptr_to_i64
+; X32-NEXT:    %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
+; X32-NEXT:    --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
+; X32-NEXT:    %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64)
+; X32-NEXT:    --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
+; X32-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
+; X32-NEXT:    --> ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i64 ptrtoint ([0 x i8]* @global to i64) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
+; X32-NEXT:    %tmp14 = load i32, i32* %tmp13, align 4
+; X32-NEXT:    --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
+; X32-NEXT:    %tmp18 = add i32 %tmp, 2
+; X32-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
+; X32-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i64
+; X32-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
+; X32-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
+; X32-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
 ;
 bb:
   br label %bb11
 
 bb11:                                             ; preds = %bb17, %bb
   %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
   %tmp12 = getelementptr i8, i8* %arg, i64 ptrtoint ([0 x i8]* @global to i64)
   %tmp13 = bitcast i8* %tmp12 to i32*
   %tmp14 = load i32, i32* %tmp13, align 4
   %tmp15 = icmp eq i32 %tmp14, 6
   br i1 %tmp15, label %bb16, label %bb17
 
 bb16:                                             ; preds = %bb11
   ret i32* %arg10
 
 bb17:                                             ; preds = %bb11
   %tmp18 = add i32 %tmp, 2
   br label %bb11
 }
 define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) {
-; PTR64_IDX64-LABEL: 'trunc_ptr_to_i32'
-; PTR64_IDX64-NEXT:  Classifying expressions for: @trunc_ptr_to_i32
-; 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, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32)
-; PTR64_IDX64-NEXT:    --> ((sext i32 ptrtoint ([0 x i8]* @global to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 ptrtoint ([0 x i8]* @global to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR64_IDX64-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
-; PTR64_IDX64-NEXT:    --> ((sext i32 ptrtoint ([0 x i8]* @global to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 ptrtoint ([0 x i8]* @global to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR64_IDX64-NEXT:    %tmp14 = load i32, i32* %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
-; PTR64_IDX64-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR64_IDX64-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i32
-; PTR64_IDX64-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
-; PTR64_IDX64-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
-; PTR64_IDX64-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
-;
-; PTR64_IDX32-LABEL: 'trunc_ptr_to_i32'
-; PTR64_IDX32-NEXT:  Classifying expressions for: @trunc_ptr_to_i32
-; PTR64_IDX32-NEXT:    %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
-; PTR64_IDX32-NEXT:    --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR64_IDX32-NEXT:    %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32)
-; PTR64_IDX32-NEXT:    --> (ptrtoint ([0 x i8]* @global to i32) + %arg) U: full-set S: full-set Exits: (ptrtoint ([0 x i8]* @global to i32) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR64_IDX32-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
-; PTR64_IDX32-NEXT:    --> (ptrtoint ([0 x i8]* @global to i32) + %arg) U: full-set S: full-set Exits: (ptrtoint ([0 x i8]* @global to i32) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR64_IDX32-NEXT:    %tmp14 = load i32, i32* %tmp13, align 4
-; PTR64_IDX32-NEXT:    --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
-; PTR64_IDX32-NEXT:    %tmp18 = add i32 %tmp, 2
-; PTR64_IDX32-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR64_IDX32-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i32
-; PTR64_IDX32-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
-; PTR64_IDX32-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
-; PTR64_IDX32-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
-;
-; PTR16_IDX16-LABEL: 'trunc_ptr_to_i32'
-; PTR16_IDX16-NEXT:  Classifying expressions for: @trunc_ptr_to_i32
-; 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, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32)
-; PTR16_IDX16-NEXT:    --> ((trunc i32 ptrtoint ([0 x i8]* @global to i32) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i32 ptrtoint ([0 x i8]* @global to i32) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR16_IDX16-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
-; PTR16_IDX16-NEXT:    --> ((trunc i32 ptrtoint ([0 x i8]* @global to i32) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i32 ptrtoint ([0 x i8]* @global to i32) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR16_IDX16-NEXT:    %tmp14 = load i32, i32* %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
-; PTR16_IDX16-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR16_IDX16-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i32
-; PTR16_IDX16-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
-; PTR16_IDX16-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
-; PTR16_IDX16-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
-;
-; PTR16_IDX32-LABEL: 'trunc_ptr_to_i32'
-; PTR16_IDX32-NEXT:  Classifying expressions for: @trunc_ptr_to_i32
-; PTR16_IDX32-NEXT:    %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
-; PTR16_IDX32-NEXT:    --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR16_IDX32-NEXT:    %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32)
-; PTR16_IDX32-NEXT:    --> (ptrtoint ([0 x i8]* @global to i32) + %arg) U: [0,131071) S: full-set Exits: (ptrtoint ([0 x i8]* @global to i32) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR16_IDX32-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
-; PTR16_IDX32-NEXT:    --> (ptrtoint ([0 x i8]* @global to i32) + %arg) U: [0,131071) S: full-set Exits: (ptrtoint ([0 x i8]* @global to i32) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR16_IDX32-NEXT:    %tmp14 = load i32, i32* %tmp13, align 4
-; PTR16_IDX32-NEXT:    --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
-; PTR16_IDX32-NEXT:    %tmp18 = add i32 %tmp, 2
-; PTR16_IDX32-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR16_IDX32-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i32
-; PTR16_IDX32-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
-; PTR16_IDX32-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
-; PTR16_IDX32-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
+; X64-LABEL: 'trunc_ptr_to_i32'
+; X64-NEXT:  Classifying expressions for: @trunc_ptr_to_i32
+; X64-NEXT:    %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
+; X64-NEXT:    --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
+; X64-NEXT:    %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32)
+; X64-NEXT:    --> ((sext i32 ptrtoint ([0 x i8]* @global to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 ptrtoint ([0 x i8]* @global to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant }
+; X64-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
+; X64-NEXT:    --> ((sext i32 ptrtoint ([0 x i8]* @global to i32) to i64) + %arg) U: full-set S: full-set Exits: ((sext i32 ptrtoint ([0 x i8]* @global to i32) to i64) + %arg) LoopDispositions: { %bb11: Invariant }
+; X64-NEXT:    %tmp14 = load i32, i32* %tmp13, align 4
+; X64-NEXT:    --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
+; X64-NEXT:    %tmp18 = add i32 %tmp, 2
+; X64-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
+; X64-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i32
+; X64-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
+; X64-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
+; X64-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
+;
+; X32-LABEL: 'trunc_ptr_to_i32'
+; X32-NEXT:  Classifying expressions for: @trunc_ptr_to_i32
+; X32-NEXT:    %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
+; X32-NEXT:    --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
+; X32-NEXT:    %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32)
+; X32-NEXT:    --> ((trunc i32 ptrtoint ([0 x i8]* @global to i32) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i32 ptrtoint ([0 x i8]* @global to i32) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
+; X32-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
+; X32-NEXT:    --> ((trunc i32 ptrtoint ([0 x i8]* @global to i32) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i32 ptrtoint ([0 x i8]* @global to i32) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
+; X32-NEXT:    %tmp14 = load i32, i32* %tmp13, align 4
+; X32-NEXT:    --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
+; X32-NEXT:    %tmp18 = add i32 %tmp, 2
+; X32-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
+; X32-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i32
+; X32-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
+; X32-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
+; X32-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
 ;
 bb:
   br label %bb11
 
 bb11:                                             ; preds = %bb17, %bb
   %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
   %tmp12 = getelementptr i8, i8* %arg, i32 ptrtoint ([0 x i8]* @global to i32)
   %tmp13 = bitcast i8* %tmp12 to i32*
   %tmp14 = load i32, i32* %tmp13, align 4
   %tmp15 = icmp eq i32 %tmp14, 6
   br i1 %tmp15, label %bb16, label %bb17
 
 bb16:                                             ; preds = %bb11
   ret i32* %arg10
 
 bb17:                                             ; preds = %bb11
   %tmp18 = add i32 %tmp, 2
   br label %bb11
 }
 define hidden i32* @trunc_ptr_to_i128(i8* %arg, i32* %arg10) {
-; PTR64_IDX64-LABEL: 'trunc_ptr_to_i128'
-; PTR64_IDX64-NEXT:  Classifying expressions for: @trunc_ptr_to_i128
-; 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, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128)
-; PTR64_IDX64-NEXT:    --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i64) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i64) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR64_IDX64-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
-; PTR64_IDX64-NEXT:    --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i64) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i64) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR64_IDX64-NEXT:    %tmp14 = load i32, i32* %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
-; PTR64_IDX64-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR64_IDX64-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i128
-; PTR64_IDX64-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
-; PTR64_IDX64-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
-; PTR64_IDX64-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
-;
-; PTR64_IDX32-LABEL: 'trunc_ptr_to_i128'
-; PTR64_IDX32-NEXT:  Classifying expressions for: @trunc_ptr_to_i128
-; PTR64_IDX32-NEXT:    %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
-; PTR64_IDX32-NEXT:    --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR64_IDX32-NEXT:    %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128)
-; PTR64_IDX32-NEXT:    --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR64_IDX32-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
-; PTR64_IDX32-NEXT:    --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR64_IDX32-NEXT:    %tmp14 = load i32, i32* %tmp13, align 4
-; PTR64_IDX32-NEXT:    --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
-; PTR64_IDX32-NEXT:    %tmp18 = add i32 %tmp, 2
-; PTR64_IDX32-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR64_IDX32-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i128
-; PTR64_IDX32-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
-; PTR64_IDX32-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
-; PTR64_IDX32-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
-;
-; PTR16_IDX16-LABEL: 'trunc_ptr_to_i128'
-; PTR16_IDX16-NEXT:  Classifying expressions for: @trunc_ptr_to_i128
-; 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, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128)
-; PTR16_IDX16-NEXT:    --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR16_IDX16-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
-; PTR16_IDX16-NEXT:    --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR16_IDX16-NEXT:    %tmp14 = load i32, i32* %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
-; PTR16_IDX16-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR16_IDX16-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i128
-; PTR16_IDX16-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
-; PTR16_IDX16-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
-; PTR16_IDX16-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
-;
-; PTR16_IDX32-LABEL: 'trunc_ptr_to_i128'
-; PTR16_IDX32-NEXT:  Classifying expressions for: @trunc_ptr_to_i128
-; PTR16_IDX32-NEXT:    %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
-; PTR16_IDX32-NEXT:    --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR16_IDX32-NEXT:    %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128)
-; PTR16_IDX32-NEXT:    --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) U: [0,131071) S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR16_IDX32-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
-; PTR16_IDX32-NEXT:    --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) U: [0,131071) S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i32) + %arg) LoopDispositions: { %bb11: Invariant }
-; PTR16_IDX32-NEXT:    %tmp14 = load i32, i32* %tmp13, align 4
-; PTR16_IDX32-NEXT:    --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
-; PTR16_IDX32-NEXT:    %tmp18 = add i32 %tmp, 2
-; PTR16_IDX32-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
-; PTR16_IDX32-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i128
-; PTR16_IDX32-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
-; PTR16_IDX32-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
-; PTR16_IDX32-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
+; X64-LABEL: 'trunc_ptr_to_i128'
+; X64-NEXT:  Classifying expressions for: @trunc_ptr_to_i128
+; X64-NEXT:    %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
+; X64-NEXT:    --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
+; X64-NEXT:    %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128)
+; X64-NEXT:    --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i64) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i64) + %arg) LoopDispositions: { %bb11: Invariant }
+; X64-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
+; X64-NEXT:    --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i64) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i64) + %arg) LoopDispositions: { %bb11: Invariant }
+; X64-NEXT:    %tmp14 = load i32, i32* %tmp13, align 4
+; X64-NEXT:    --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
+; X64-NEXT:    %tmp18 = add i32 %tmp, 2
+; X64-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
+; X64-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i128
+; X64-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
+; X64-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
+; X64-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
+;
+; X32-LABEL: 'trunc_ptr_to_i128'
+; X32-NEXT:  Classifying expressions for: @trunc_ptr_to_i128
+; X32-NEXT:    %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
+; X32-NEXT:    --> {0,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
+; X32-NEXT:    %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128)
+; X32-NEXT:    --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
+; X32-NEXT:    %tmp13 = bitcast i8* %tmp12 to i32*
+; X32-NEXT:    --> ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i16) + %arg) U: full-set S: full-set Exits: ((trunc i128 ptrtoint ([0 x i8]* @global to i128) to i16) + %arg) LoopDispositions: { %bb11: Invariant }
+; X32-NEXT:    %tmp14 = load i32, i32* %tmp13, align 4
+; X32-NEXT:    --> %tmp14 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb11: Variant }
+; X32-NEXT:    %tmp18 = add i32 %tmp, 2
+; X32-NEXT:    --> {2,+,2}<%bb11> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %bb11: Computable }
+; X32-NEXT:  Determining loop execution counts for: @trunc_ptr_to_i128
+; X32-NEXT:  Loop %bb11: Unpredictable backedge-taken count.
+; X32-NEXT:  Loop %bb11: Unpredictable max backedge-taken count.
+; X32-NEXT:  Loop %bb11: Unpredictable predicated backedge-taken count.
 ;
 bb:
   br label %bb11
 
 bb11:                                             ; preds = %bb17, %bb
   %tmp = phi i32 [ 0, %bb ], [ %tmp18, %bb17 ]
   %tmp12 = getelementptr i8, i8* %arg, i128 ptrtoint ([0 x i8]* @global to i128)
   %tmp13 = bitcast i8* %tmp12 to i32*

llvm/test/Transforms/PhaseOrdering/scev-custom-dl.ll

 ; RUN: opt -O3 -S -analyze -scalar-evolution < %s | FileCheck %s
 
 target datalayout = "e-m:m-p:40:64:64:32-i32:32-i16:16-i8:8-n32"
 
 ;
 ; This file contains phase ordering tests for scalar evolution.
 ; Test that the standard passes don't obfuscate the IR so scalar evolution can't
 ; recognize expressions.
 
 ; CHECK: test1
 ; The loop body contains two increments by %div.
 ; Make sure that 2*%div is recognizable, and not expressed as a bit mask of %d.
-; CHECK: -->  {%p,+,(8 * (%d /u 4))}
+; CHECK: -->  {%p,+,(8 * ((zext i32 %d to i40) /u 4))}<%for.body> U: full-set S: full-set Exits: ((504 * ((zext i32 %d to i40) /u 4)) + %p)
 define void @test1(i32 %d, i32* %p) nounwind uwtable ssp {
 entry:
   %div = udiv i32 %d, 4
   br label %for.cond
 
 for.cond:                                         ; preds = %for.inc, %entry
   %p.addr.0 = phi i32* [ %p, %entry ], [ %add.ptr1, %for.inc ]
   %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.inc ]
for.inc:                                          ; preds = %for.body
   br label %for.cond
 
 for.end:                                          ; preds = %for.cond
   ret void
 }
 
 ; CHECK: test1a
 ; Same thing as test1, but it is even more tempting to fold 2 * (%d /u 2)
-; CHECK: -->  {%p,+,(8 * (%d /u 2))}
+; CHECK: -->  {%p,+,(8 * ((zext i32 %d to i40) /u 2))}<%for.body> U: full-set S: full-set Exits: ((504 * ((zext i32 %d to i40) /u 2)) + %p)
 define void @test1a(i32 %d, i32* %p) nounwind uwtable ssp {
 entry:
   %div = udiv i32 %d, 2
   br label %for.cond
 
 for.cond:                                         ; preds = %for.inc, %entry
   %p.addr.0 = phi i32* [ %p, %entry ], [ %add.ptr1, %for.inc ]
   %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.inc ]