diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -6302,6 +6302,24 @@
       return getSCEV(U->getOperand(0));
     break;
 
+  case Instruction::IntToPtr:
+  case Instruction::PtrToInt:
+    // It's tempting to handle inttoptr and ptrtoint as no-ops,
+    // however this can lead to pointer expressions which cannot safely be
+    // expanded to GEPs because ScalarEvolution doesn't respect
+    // the GEP aliasing rules when simplifying integer expressions.
+    //
+    // However, given
+    //                  %x = ???
+    //   %y = inttoptr %x  or  %y = ptrtoint %x
+    //   %z = inttoptr %x  or  %z = ptrtoint %x
+    // it is safe to say that %y and %z are the same thing.
+    //
+    // So instead of modelling the cast itself as unknown,
+    // since the casts are transparent within SCEV,
+    // we can at least model the casts original value as unknow instead.
+    return getTruncateOrZeroExtend(getUnknown(U->getOperand(0)), U->getType());
+
   case Instruction::SDiv:
     // If both operands are non-negative, this is just an udiv.
     if (isKnownNonNegative(getSCEV(U->getOperand(0))) &&
@@ -6316,11 +6334,6 @@
       return getURemExpr(getSCEV(U->getOperand(0)), getSCEV(U->getOperand(1)));
     break;
 
-  // It's tempting to handle inttoptr and ptrtoint as no-ops, however this can
-  // lead to pointer expressions which cannot safely be expanded to GEPs,
-  // because ScalarEvolution doesn't respect the GEP aliasing rules when
-  // simplifying integer expressions.
-
   case Instruction::GetElementPtr:
     return createNodeForGEP(cast<GEPOperator>(U));
 
diff --git a/llvm/lib/Transforms/Utils/SimplifyIndVar.cpp b/llvm/lib/Transforms/Utils/SimplifyIndVar.cpp
--- a/llvm/lib/Transforms/Utils/SimplifyIndVar.cpp
+++ b/llvm/lib/Transforms/Utils/SimplifyIndVar.cpp
@@ -427,7 +427,7 @@
              : &ScalarEvolution::getZeroExtendExpr;
 
   // Check ext(LHS op RHS) == ext(LHS) op ext(RHS)
-  auto *NarrowTy = cast<IntegerType>(LHS->getType());
+  auto *NarrowTy = cast<IntegerType>(SE->getEffectiveSCEVType(LHS->getType()));
   auto *WideTy =
     IntegerType::get(NarrowTy->getContext(), NarrowTy->getBitWidth() * 2);
 
diff --git a/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll b/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll
--- a/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll
+++ b/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll
@@ -33,9 +33,9 @@
 ; CHECK-NEXT:    %1 = load i32*, i32** @c, align 8
 ; CHECK-NEXT:    --> %1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
 ; CHECK-NEXT:    %sub.ptr.lhs.cast = ptrtoint i32* %1 to i64
-; CHECK-NEXT:    --> %sub.ptr.lhs.cast U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
+; CHECK-NEXT:    --> %1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
 ; CHECK-NEXT:    %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, ptrtoint ([1 x i32]* @b to i64)
-; CHECK-NEXT:    --> ((-1 * ptrtoint ([1 x i32]* @b to i64)) + %sub.ptr.lhs.cast) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
+; CHECK-NEXT:    --> ((-1 * @b) + %1) 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: full-set S: [-2305843009213693952,2305843009213693952) Exits: <<Unknown>> LoopDispositions: { %for.cond: Variant }
 ; CHECK-NEXT:    %arrayidx1 = getelementptr inbounds [1 x i8], [1 x i8]* %arrayidx, i64 0, i64 %sub.ptr.div
diff --git a/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll b/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
--- a/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
+++ b/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
@@ -170,14 +170,14 @@
   %int5 = add i32 %int0, 5
   %int.zext = zext i32 %int5 to i64
 ; CHECK:  %int.zext = zext i32 %int5 to i64
-; CHECK-NEXT:  -->  (1 + (zext i32 (4 + %int0) to i64))<nuw><nsw> U: [1,4294967294) S: [1,4294967297)
+; CHECK-NEXT:  --> (1 + (zext i32 (4 + (trunc i8* %ptr to i32)) to i64))<nuw><nsw> U: [1,4294967294) S: [1,4294967297)
 
   %ptr_noalign = bitcast [16 x i8]* @z_addr_noalign to i8*
   %int0_na = ptrtoint i8* %ptr_noalign to i32
   %int5_na = add i32 %int0_na, 5
   %int.zext_na = zext i32 %int5_na to i64
 ; CHECK:  %int.zext_na = zext i32 %int5_na to i64
-; CHECK-NEXT:  -->  (zext i32 (5 + %int0_na) to i64) U: [0,4294967296) S: [0,4294967296)
+; CHECK-NEXT:  --> (zext i32 (5 + (trunc i8* %ptr_noalign to i32)) to i64) U: [0,4294967296) S: [0,4294967296)
 
   %tmp = load i32, i32* %tmp_addr
   %mul = and i32 %tmp, -4
diff --git a/llvm/test/Analysis/ScalarEvolution/scalable-vector.ll b/llvm/test/Analysis/ScalarEvolution/scalable-vector.ll
--- a/llvm/test/Analysis/ScalarEvolution/scalable-vector.ll
+++ b/llvm/test/Analysis/ScalarEvolution/scalable-vector.ll
@@ -2,9 +2,9 @@
 ; RUN: opt "-passes=print<scalar-evolution>" -disable-output < %s 2>&1 | FileCheck %s
 
 ; CHECK: %1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* null, i32 3
-; CHECK: -->  (3 * sizeof(<vscale x 4 x i32>)) U: [0,-15) S: [-9223372036854775808,9223372036854775793)
+; CHECK: --> (3 * getelementptr (<vscale x 4 x i32>, <vscale x 4 x i32>* null, i64 1)) U: [0,-15) S: [-9223372036854775808,9223372036854775793)
 ; CHECK: %2 = getelementptr <vscale x 1 x i64>, <vscale x 1 x i64>* %p, i32 1
-; CHECK: -->  (sizeof(<vscale x 1 x i64>) + %p) U: full-set S: full-set
+; CHECK: --> (getelementptr (<vscale x 1 x i64>, <vscale x 1 x i64>* null, i64 1) + %p) U: full-set S: full-set
 define void @a(<vscale x 1 x i64> *%p) {
   getelementptr <vscale x 4 x i32>, <vscale x 4 x i32> *null, i32 3
   getelementptr <vscale x 1 x i64>, <vscale x 1 x i64> *%p, i32 1
diff --git a/llvm/test/Analysis/ScalarEvolution/semi-transparent-inttoptr-ptrtoint-casts.ll b/llvm/test/Analysis/ScalarEvolution/semi-transparent-inttoptr-ptrtoint-casts.ll
--- a/llvm/test/Analysis/ScalarEvolution/semi-transparent-inttoptr-ptrtoint-casts.ll
+++ b/llvm/test/Analysis/ScalarEvolution/semi-transparent-inttoptr-ptrtoint-casts.ll
@@ -19,13 +19,13 @@
 ; CHECK-NEXT:    %in_adj = getelementptr inbounds i8, i8* %in, i64 42
 ; CHECK-NEXT:    --> (42 + %in)<nsw> U: [-9223372036854775766,-9223372036854775808) S: [-9223372036854775766,-9223372036854775808)
 ; CHECK-NEXT:    %p0 = ptrtoint i8* %in_adj to i64
-; CHECK-NEXT:    --> %p0 U: full-set S: full-set
+; CHECK-NEXT:    --> %in_adj U: full-set S: full-set
 ; CHECK-NEXT:    %p1 = ptrtoint i8* %in_adj to i64
-; CHECK-NEXT:    --> %p1 U: full-set S: full-set
+; CHECK-NEXT:    --> %in_adj U: full-set S: full-set
 ; CHECK-NEXT:    %p2 = ptrtoint i8* %in_adj to i32
-; CHECK-NEXT:    --> %p2 U: full-set S: full-set
+; CHECK-NEXT:    --> (trunc i8* %in_adj to i32) U: full-set S: full-set
 ; CHECK-NEXT:    %p3 = ptrtoint i8* %in_adj to i128
-; CHECK-NEXT:    --> %p3 U: [0,18446744073709551616) S: [-18446744073709551616,18446744073709551616)
+; CHECK-NEXT:    --> (zext i8* %in_adj to i128) U: [0,18446744073709551616) S: [0,18446744073709551616)
 ; CHECK-NEXT:  Determining loop execution counts for: @ptrtoint
 ;
   %in_adj = getelementptr inbounds i8, i8* %in, i64 42
@@ -46,9 +46,9 @@
 ; CHECK-NEXT:    %in_adj = add i64 %in0, 42
 ; CHECK-NEXT:    --> (42 + %in0) U: full-set S: full-set
 ; CHECK-NEXT:    %i0 = inttoptr i64 %in_adj to i8*
-; CHECK-NEXT:    --> %i0 U: full-set S: full-set
+; CHECK-NEXT:    --> %in_adj U: full-set S: full-set
 ; CHECK-NEXT:    %i1 = inttoptr i64 %in_adj to i8*
-; CHECK-NEXT:    --> %i1 U: full-set S: full-set
+; CHECK-NEXT:    --> %in_adj U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @inttoptr
 ;
   %in_adj = add i64 %in0, 42
@@ -64,7 +64,7 @@
 ; CHECK-NEXT:    %in_adj = add i32 %in1, 42
 ; CHECK-NEXT:    --> (42 + %in1) U: full-set S: full-set
 ; CHECK-NEXT:    %i0 = inttoptr i32 %in_adj to i8*
-; CHECK-NEXT:    --> %i0 U: [0,4294967296) S: [-4294967296,4294967296)
+; CHECK-NEXT:    --> (zext i32 %in_adj to i64) U: [0,4294967296) S: [0,4294967296)
 ; CHECK-NEXT:  Determining loop execution counts for: @inttoptr_widening
 ;
   %in_adj = add i32 %in1, 42
@@ -78,7 +78,7 @@
 ; CHECK-NEXT:    %in_adj = add i128 %in2, 42
 ; CHECK-NEXT:    --> (42 + %in2) U: full-set S: full-set
 ; CHECK-NEXT:    %i0 = inttoptr i128 %in_adj to i8*
-; CHECK-NEXT:    --> %i0 U: full-set S: full-set
+; CHECK-NEXT:    --> (trunc i128 %in_adj to i64) U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @inttoptr_narrowing
 ;
   %in_adj = add i128 %in2, 42
@@ -92,17 +92,17 @@
 ; CHECK-LABEL: 'onlysemitransparency'
 ; CHECK-NEXT:  Classifying expressions for: @onlysemitransparency
 ; CHECK-NEXT:    %i0 = ptrtoint i8* %in to i64
-; CHECK-NEXT:    --> %i0 U: full-set S: full-set
+; CHECK-NEXT:    --> %in U: full-set S: full-set
 ; CHECK-NEXT:    %i1 = inttoptr i64 %i0 to i8*
-; CHECK-NEXT:    --> %i1 U: full-set S: full-set
+; CHECK-NEXT:    --> %i0 U: full-set S: full-set
 ; CHECK-NEXT:    %i2 = ptrtoint i8* %i1 to i64
-; CHECK-NEXT:    --> %i2 U: full-set S: full-set
+; CHECK-NEXT:    --> %i1 U: full-set S: full-set
 ; CHECK-NEXT:    %i3 = inttoptr i64 %i2 to i8*
-; CHECK-NEXT:    --> %i3 U: full-set S: full-set
+; CHECK-NEXT:    --> %i2 U: full-set S: full-set
 ; CHECK-NEXT:    %i4 = ptrtoint i8* %i3 to i64
-; CHECK-NEXT:    --> %i4 U: full-set S: full-set
+; CHECK-NEXT:    --> %i3 U: full-set S: full-set
 ; CHECK-NEXT:    %i5 = inttoptr i64 %i4 to i8*
-; CHECK-NEXT:    --> %i5 U: full-set S: full-set
+; CHECK-NEXT:    --> %i4 U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @onlysemitransparency
 ;
   %i0 = ptrtoint i8* %in to i64
diff --git a/llvm/test/CodeGen/ARM/lsr-undef-in-binop.ll b/llvm/test/CodeGen/ARM/lsr-undef-in-binop.ll
--- a/llvm/test/CodeGen/ARM/lsr-undef-in-binop.ll
+++ b/llvm/test/CodeGen/ARM/lsr-undef-in-binop.ll
@@ -186,7 +186,8 @@
   br i1 %114, label %124, label %115
 
 ; CHECK-LABEL: .preheader:
-; CHECK-NEXT: sub i32 [[OLD_CAST]], [[NEW_CAST]]
+; CHECK-NEXT: [[NEG_NEW_CAST:%[0-9]+]] = sub i32 0, [[NEW_CAST]]
+; CHECK-NEXT: getelementptr i8, i8* %97, i32 [[NEG_NEW_CAST]]
 ; <label>:115:                                    ; preds = %111, %115
   %116 = phi i8* [ %118, %115 ], [ %97, %111 ]
   %117 = phi i8* [ %119, %115 ], [ %11, %111 ]
diff --git a/llvm/test/CodeGen/PowerPC/sms-iterator.ll b/llvm/test/CodeGen/PowerPC/sms-iterator.ll
--- a/llvm/test/CodeGen/PowerPC/sms-iterator.ll
+++ b/llvm/test/CodeGen/PowerPC/sms-iterator.ll
@@ -5,7 +5,7 @@
 
 %0 = type { i32, [16 x double] }
 
-; CHECK: MII = 8 MAX_II = 18
+; CHECK: MII = 6 MAX_II = 16
 
 define dso_local fastcc double @_ZN3povL9polysolveEiPdS0_() unnamed_addr #0 {
   br label %1
diff --git a/llvm/test/CodeGen/X86/ragreedy-hoist-spill.ll b/llvm/test/CodeGen/X86/ragreedy-hoist-spill.ll
--- a/llvm/test/CodeGen/X86/ragreedy-hoist-spill.ll
+++ b/llvm/test/CodeGen/X86/ragreedy-hoist-spill.ll
@@ -268,9 +268,9 @@
 ; CHECK-NEXT:  LBB0_48: ## %if.then1477
 ; CHECK-NEXT:    movl $1, %edx
 ; CHECK-NEXT:    callq _write
-; CHECK-NEXT:    subq %rbx, %r14
 ; CHECK-NEXT:    movq _syHistory@{{.*}}(%rip), %rax
-; CHECK-NEXT:    leaq 8189(%r14,%rax), %rax
+; CHECK-NEXT:    subq %rbx, %rax
+; CHECK-NEXT:    leaq 8189(%rax,%r14), %rax
 ; CHECK-NEXT:    .p2align 4, 0x90
 ; CHECK-NEXT:  LBB0_49: ## %for.body1723
 ; CHECK-NEXT:    ## =>This Inner Loop Header: Depth=1
diff --git a/llvm/test/Other/constant-fold-gep.ll b/llvm/test/Other/constant-fold-gep.ll
--- a/llvm/test/Other/constant-fold-gep.ll
+++ b/llvm/test/Other/constant-fold-gep.ll
@@ -181,16 +181,16 @@
 ; TO: }
 ; SCEV: Classifying expressions for: @goo8
 ; SCEV:   %t = bitcast i8* getelementptr (i8, i8* inttoptr (i32 1 to i8*), i32 -1) to i8*
-; SCEV:   -->  (-1 + inttoptr (i32 1 to i8*))
+; SCEV:   --> (-1 + (zext i32 1 to i64))<nsw> U: [0,1) S: [-1,4294967295)
 ; SCEV: Classifying expressions for: @goo1
 ; SCEV:   %t = bitcast i1* getelementptr (i1, i1* inttoptr (i32 1 to i1*), i32 -1) to i1*
-; SCEV:   -->  (-1 + inttoptr (i32 1 to i1*))
+; SCEV:   --> (-1 + (zext i32 1 to i64))<nsw> U: [0,1) S: [-1,4294967295)
 ; SCEV: Classifying expressions for: @foo8
 ; SCEV:   %t = bitcast i8* getelementptr (i8, i8* inttoptr (i32 1 to i8*), i32 -2) to i8*
-; SCEV:   -->  (-2 + inttoptr (i32 1 to i8*))
+; SCEV:   --> (-2 + (zext i32 1 to i64))<nuw><nsw> U: [-1,0) S: [-2,0)
 ; SCEV: Classifying expressions for: @foo1
 ; SCEV:   %t = bitcast i1* getelementptr (i1, i1* inttoptr (i32 1 to i1*), i32 -2) to i1*
-; SCEV:   -->  (-2 + inttoptr (i32 1 to i1*))
+; SCEV:   --> (-2 + (zext i32 1 to i64))<nuw><nsw> U: [-1,0) S: [-2,0)
 ; SCEV: Classifying expressions for: @hoo8
 ; SCEV:   -->  -1
 ; SCEV: Classifying expressions for: @hoo1
@@ -313,31 +313,31 @@
 ; TO: }
 ; SCEV: Classifying expressions for: @fa
 ; SCEV:   %t = bitcast i64 mul (i64 ptrtoint (double* getelementptr (double, double* null, i32 1) to i64), i64 2310) to i64
-; SCEV:   -->  (2310 * sizeof(double))
+; SCEV:   --> (2310 * getelementptr (double, double* null, i32 1)) U: [0,-15) S: [-9223372036854775808,9223372036854775793)
 ; SCEV: Classifying expressions for: @fb
 ; SCEV:   %t = bitcast i64 ptrtoint (double* getelementptr ({ i1, double }, { i1, double }* null, i64 0, i32 1) to i64) to i64
-; SCEV:   -->  alignof(double)
+; SCEV:   --> getelementptr ({ i1, double }, { i1, double }* null, i64 0, i32 1) U: [0,-7) S: [-9223372036854775808,9223372036854775801)
 ; SCEV: Classifying expressions for: @fc
 ; SCEV:   %t = bitcast i64 mul nuw (i64 ptrtoint (double* getelementptr (double, double* null, i32 1) to i64), i64 2) to i64
-; SCEV:   -->  (2 * sizeof(double))
+; SCEV:   --> (2 * getelementptr (double, double* null, i32 1)) U: [0,-15) S: [-9223372036854775808,9223372036854775793)
 ; SCEV: Classifying expressions for: @fd
 ; SCEV:   %t = bitcast i64 mul nuw (i64 ptrtoint (double* getelementptr (double, double* null, i32 1) to i64), i64 11) to i64
-; SCEV:   -->  (11 * sizeof(double))
+; SCEV:   --> (11 * getelementptr (double, double* null, i32 1)) U: [0,-7) S: [-9223372036854775808,9223372036854775801)
 ; SCEV: Classifying expressions for: @fe
 ; SCEV:   %t = bitcast i64 ptrtoint (double* getelementptr ({ double, float, double, double }, { double, float, double, double }* null, i64 0, i32 2) to i64) to i64
-; SCEV:   -->  offsetof({ double, float, double, double }, 2)
+; SCEV:   --> getelementptr ({ double, float, double, double }, { double, float, double, double }* null, i64 0, i32 2) U: [0,-15) S: [-9223372036854775808,9223372036854775793)
 ; SCEV: Classifying expressions for: @ff
 ; SCEV:   %t = bitcast i64 1 to i64
 ; SCEV:   -->  1
 ; SCEV: Classifying expressions for: @fg
 ; SCEV:   %t = bitcast i64 ptrtoint (double* getelementptr ({ i1, double }, { i1, double }* null, i64 0, i32 1) to i64) to i64
-; SCEV:   -->  alignof(double)
+; SCEV:   --> getelementptr ({ i1, double }, { i1, double }* null, i64 0, i32 1) U: [0,-7) S: [-9223372036854775808,9223372036854775801)
 ; SCEV: Classifying expressions for: @fh
 ; SCEV:   %t = bitcast i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64) to i64
-; SCEV:   -->  sizeof(i1*)
+; SCEV:   --> getelementptr (i1*, i1** null, i32 1) U: [0,-7) S: [-9223372036854775808,9223372036854775801)
 ; SCEV: Classifying expressions for: @fi
 ; SCEV:   %t = bitcast i64 ptrtoint (i1** getelementptr ({ i1, i1* }, { i1, i1* }* null, i64 0, i32 1) to i64) to i64
-; SCEV:   -->  alignof(i1*)
+; SCEV:   --> getelementptr ({ i1, i1* }, { i1, i1* }* null, i64 0, i32 1) U: [0,-7) S: [-9223372036854775808,9223372036854775801)
 
 define i64 @fa() nounwind {
   %t = bitcast i64 mul (i64 3, i64 mul (i64 ptrtoint ({[7 x double], [7 x double]}* getelementptr ({[7 x double], [7 x double]}, {[7 x double], [7 x double]}* null, i64 11) to i64), i64 5)) to i64
diff --git a/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll b/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll
--- a/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll
+++ b/llvm/test/Transforms/IndVarSimplify/2011-11-01-lftrptr.ll
@@ -21,7 +21,7 @@
 ; PTR64:       loop:
 ; PTR64-NEXT:    [[P_01_US_US:%.*]] = phi i8* [ null, [[PREHEADER]] ], [ [[GEP:%.*]], [[LOOP]] ]
 ; PTR64-NEXT:    [[GEP]] = getelementptr inbounds i8, i8* [[P_01_US_US]], i64 1
-; PTR64-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]]
+; PTR64-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]], align 1
 ; PTR64-NEXT:    [[EXITCOND:%.*]] = icmp ne i8* [[GEP]], [[END]]
 ; PTR64-NEXT:    br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]]
 ; PTR64:       exit.loopexit:
@@ -41,7 +41,7 @@
 ; PTR32:       loop:
 ; PTR32-NEXT:    [[P_01_US_US:%.*]] = phi i8* [ null, [[PREHEADER]] ], [ [[GEP:%.*]], [[LOOP]] ]
 ; PTR32-NEXT:    [[GEP]] = getelementptr inbounds i8, i8* [[P_01_US_US]], i64 1
-; PTR32-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]]
+; PTR32-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]], align 1
 ; PTR32-NEXT:    [[EXITCOND:%.*]] = icmp ne i8* [[GEP]], [[END]]
 ; PTR32-NEXT:    br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]]
 ; PTR32:       exit.loopexit:
@@ -84,7 +84,7 @@
 ; PTR64:       loop:
 ; PTR64-NEXT:    [[P_01_US_US:%.*]] = phi i8* [ [[BUF]], [[PREHEADER]] ], [ [[GEP:%.*]], [[LOOP]] ]
 ; PTR64-NEXT:    [[GEP]] = getelementptr inbounds i8, i8* [[P_01_US_US]], i64 1
-; PTR64-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]]
+; PTR64-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]], align 1
 ; PTR64-NEXT:    [[EXITCOND:%.*]] = icmp ne i8* [[GEP]], [[END]]
 ; PTR64-NEXT:    br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]]
 ; PTR64:       exit.loopexit:
@@ -104,7 +104,7 @@
 ; PTR32:       loop:
 ; PTR32-NEXT:    [[P_01_US_US:%.*]] = phi i8* [ [[BUF]], [[PREHEADER]] ], [ [[GEP:%.*]], [[LOOP]] ]
 ; PTR32-NEXT:    [[GEP]] = getelementptr inbounds i8, i8* [[P_01_US_US]], i64 1
-; PTR32-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]]
+; PTR32-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]], align 1
 ; PTR32-NEXT:    [[EXITCOND:%.*]] = icmp ne i8* [[GEP]], [[END]]
 ; PTR32-NEXT:    br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]]
 ; PTR32:       exit.loopexit:
@@ -155,7 +155,7 @@
 ; PTR64:       loop:
 ; PTR64-NEXT:    [[P_01_US_US:%.*]] = phi i8* [ null, [[PREHEADER]] ], [ [[GEP:%.*]], [[LOOP]] ]
 ; PTR64-NEXT:    [[GEP]] = getelementptr inbounds i8, i8* [[P_01_US_US]], i64 1
-; PTR64-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]]
+; PTR64-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]], align 1
 ; PTR64-NEXT:    [[EXITCOND:%.*]] = icmp ne i8* [[GEP]], [[TMP5]]
 ; PTR64-NEXT:    br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]]
 ; PTR64:       exit.loopexit:
@@ -166,21 +166,23 @@
 ; PTR64-NEXT:    ret i8 [[RET]]
 ;
 ; PTR32-LABEL: @testnullptrint(
+; PTR32-NEXT:    [[BUF1:%.*]] = ptrtoint i8* [[BUF:%.*]] to i32
 ; PTR32-NEXT:    br label [[LOOPGUARD:%.*]]
 ; PTR32:       loopguard:
-; PTR32-NEXT:    [[BI:%.*]] = ptrtoint i8* [[BUF:%.*]] to i32
+; PTR32-NEXT:    [[BI:%.*]] = ptrtoint i8* [[BUF]] to i32
 ; PTR32-NEXT:    [[EI:%.*]] = ptrtoint i8* [[END:%.*]] to i32
 ; PTR32-NEXT:    [[CNT:%.*]] = sub i32 [[EI]], [[BI]]
-; PTR32-NEXT:    [[CNT1:%.*]] = inttoptr i32 [[CNT]] to i8*
 ; PTR32-NEXT:    [[GUARD:%.*]] = icmp ult i32 0, [[CNT]]
 ; PTR32-NEXT:    br i1 [[GUARD]], label [[PREHEADER:%.*]], label [[EXIT:%.*]]
 ; PTR32:       preheader:
+; PTR32-NEXT:    [[TMP1:%.*]] = sub i32 0, [[BUF1]]
+; PTR32-NEXT:    [[SCEVGEP:%.*]] = getelementptr i8, i8* [[END]], i32 [[TMP1]]
 ; PTR32-NEXT:    br label [[LOOP:%.*]]
 ; PTR32:       loop:
 ; PTR32-NEXT:    [[P_01_US_US:%.*]] = phi i8* [ null, [[PREHEADER]] ], [ [[GEP:%.*]], [[LOOP]] ]
 ; PTR32-NEXT:    [[GEP]] = getelementptr inbounds i8, i8* [[P_01_US_US]], i64 1
-; PTR32-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]]
-; PTR32-NEXT:    [[EXITCOND:%.*]] = icmp ne i8* [[GEP]], [[CNT1]]
+; PTR32-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]], align 1
+; PTR32-NEXT:    [[EXITCOND:%.*]] = icmp ne i8* [[GEP]], [[SCEVGEP]]
 ; PTR32-NEXT:    br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]]
 ; PTR32:       exit.loopexit:
 ; PTR32-NEXT:    [[SNEXT_LCSSA:%.*]] = phi i8 [ [[SNEXT]], [[LOOP]] ]
@@ -231,7 +233,7 @@
 ; PTR64-NEXT:    [[P_01_US_US:%.*]] = phi i8* [ [[BUF]], [[PREHEADER]] ], [ [[GEP:%.*]], [[LOOP]] ]
 ; PTR64-NEXT:    [[IV:%.*]] = phi i32 [ [[BI]], [[PREHEADER]] ], [ [[IVNEXT:%.*]], [[LOOP]] ]
 ; PTR64-NEXT:    [[GEP]] = getelementptr inbounds i8, i8* [[P_01_US_US]], i64 1
-; PTR64-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]]
+; PTR64-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]], align 1
 ; PTR64-NEXT:    [[IVNEXT]] = add nuw i32 [[IV]], 1
 ; PTR64-NEXT:    [[EXITCOND:%.*]] = icmp ne i32 [[IVNEXT]], [[CNT]]
 ; PTR64-NEXT:    br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]]
@@ -256,10 +258,10 @@
 ; PTR32-NEXT:    [[P_01_US_US:%.*]] = phi i8* [ [[BUF]], [[PREHEADER]] ], [ [[GEP:%.*]], [[LOOP]] ]
 ; PTR32-NEXT:    [[IV:%.*]] = phi i32 [ [[BI]], [[PREHEADER]] ], [ [[IVNEXT:%.*]], [[LOOP]] ]
 ; PTR32-NEXT:    [[GEP]] = getelementptr inbounds i8, i8* [[P_01_US_US]], i64 1
-; PTR32-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]]
+; PTR32-NEXT:    [[SNEXT:%.*]] = load i8, i8* [[GEP]], align 1
 ; PTR32-NEXT:    [[IVNEXT]] = add nuw i32 [[IV]], 1
-; PTR32-NEXT:    [[EXITCOND:%.*]] = icmp ne i32 [[IVNEXT]], [[CNT]]
-; PTR32-NEXT:    br i1 [[EXITCOND]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]]
+; PTR32-NEXT:    [[CMP:%.*]] = icmp ult i32 [[IVNEXT]], [[CNT]]
+; PTR32-NEXT:    br i1 [[CMP]], label [[LOOP]], label [[EXIT_LOOPEXIT:%.*]]
 ; PTR32:       exit.loopexit:
 ; PTR32-NEXT:    [[SNEXT_LCSSA:%.*]] = phi i8 [ [[SNEXT]], [[LOOP]] ]
 ; PTR32-NEXT:    br label [[EXIT]]
diff --git a/llvm/test/Transforms/LoopStrengthReduce/post-inc-icmpzero.ll b/llvm/test/Transforms/LoopStrengthReduce/post-inc-icmpzero.ll
--- a/llvm/test/Transforms/LoopStrengthReduce/post-inc-icmpzero.ll
+++ b/llvm/test/Transforms/LoopStrengthReduce/post-inc-icmpzero.ll
@@ -8,13 +8,22 @@
 ; CHECK:   [[r2:%[a-z0-9\.]+]] = lshr exact i64 [[r1]], 1
 ; CHECK:   [[r3:%[a-z0-9\.]+]] = bitcast i64 [[r2]] to i64
 ; CHECK: for.body.lr.ph:
-; CHECK:   [[r4:%[a-z0-9]+]] = shl nuw i64 [[r3]], 1
 ; CHECK:   br label %for.body
 ; CHECK: for.body:
-; CHECK:   %lsr.iv2 = phi i64 [ %lsr.iv.next, %for.body ], [ [[r4]], %for.body.lr.ph ]
-; CHECK:   %lsr.iv.next = add i64 %lsr.iv2, -2
+; CHECK:   %lsr.iv8 = phi [33 x i16]* [ %3, %for.body ], [ %2, %for.body.lr.ph ]
+; CHECK:   %lsr.iv = phi i64 [ %lsr.iv.next, %for.body ], [ 0, %for.body.lr.ph ]
+; CHECK:   %lsr.iv810 = bitcast [33 x i16]* %lsr.iv8 to i16*
+; CHECK:   %uglygep = getelementptr i8, i8* %scevgep1, i64 %lsr.iv
+; CHECK:   %uglygep2 = bitcast i8* %uglygep to i16*
+; CHECK:   %tmp29 = load i16, i16* %lsr.iv810, align 2
+; CHECK:   store i16 %tmp29, i16* %uglygep2, align 2
+; CHECK:   %lsr.iv.next = add i64 %lsr.iv, 2
 ; CHECK:   %lsr.iv.next3 = inttoptr i64 %lsr.iv.next to i16*
+; CHECK:   %scevgep9 = getelementptr [33 x i16], [33 x i16]* %lsr.iv8, i64 0, i64 1
+; CHECK:   %3 = bitcast i16* %scevgep9 to [33 x i16]*
 ; CHECK:   %cmp27 = icmp eq i16* %lsr.iv.next3, null
+; CHECK:   br i1 %cmp27, label %for.end.loopexit, label %for.body
+
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 
diff --git a/llvm/test/Transforms/PhaseOrdering/scev-custom-dl.ll b/llvm/test/Transforms/PhaseOrdering/scev-custom-dl.ll
--- a/llvm/test/Transforms/PhaseOrdering/scev-custom-dl.ll
+++ b/llvm/test/Transforms/PhaseOrdering/scev-custom-dl.ll
@@ -114,7 +114,7 @@
 declare void @llvm.experimental.guard(i1, ...)
 
 ; This tests getRangeRef acts as intended with different idx size.
-; CHECK: max backedge-taken count is 318
+; CHECK: max backedge-taken count is 41
 define void @test_range_ref1(i8 %t) {
  entry:
   %t.ptr = inttoptr i8 %t to i8*