Index: docs/LangRef.rst
===================================================================
--- docs/LangRef.rst
+++ docs/LangRef.rst
@@ -5059,10 +5059,10 @@
 in ``op2``.
 
 If the ``nuw`` keyword is present, then the shift produces a :ref:`poison
-value <poisonvalues>` if it shifts out any non-zero bits. If the
-``nsw`` keyword is present, then the shift produces a :ref:`poison
-value <poisonvalues>` if it shifts out any bits that disagree with the
-resultant sign bit. As such, NUW/NSW have the same semantics as they
+value <poisonvalues>` if it shifts out any non-zero bits.
+If the ``nsw`` keyword is present, then the shift produces a :ref:`poison
+value <poisonvalues>` if ``op1`` is not one and it shifts out any non-sign bits.
+As such, NUW/NSW have the same semantics as they
 would if the shift were expressed as a mul instruction with the same
 nsw/nuw bits in (mul %op1, (shl 1, %op2)).
 
Index: lib/Analysis/InstructionSimplify.cpp
===================================================================
--- lib/Analysis/InstructionSimplify.cpp
+++ lib/Analysis/InstructionSimplify.cpp
@@ -2302,8 +2302,14 @@
         Lower = CI2->getValue().shl(ShiftAmount);
         Upper = CI2->getValue() + 1;
       } else {
-        // 'shl nsw CI2, x' produces [CI2, CI2 << CLZ(CI2)-1]
-        unsigned ShiftAmount = CI2->getValue().countLeadingZeros() - 1;
+        unsigned ShiftAmount;
+        if (CI2->isOne()) {
+          // 'shl nsw 1, x' produces [1, 1 << (Width-1)]
+          ShiftAmount = Width - 1;
+        } else {
+          // 'shl nsw CI2, x' produces [CI2, CI2 << CLZ(CI2)-1]
+          ShiftAmount = CI2->getValue().countLeadingZeros() - 1;
+        }
         Lower = CI2->getValue();
         Upper = CI2->getValue().shl(ShiftAmount) + 1;
       }
Index: lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
===================================================================
--- lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
+++ lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
@@ -200,8 +200,7 @@
       BinaryOperator *BO = BinaryOperator::CreateMul(NewOp, Shl);
       if (I.hasNoUnsignedWrap() && Mul->hasNoUnsignedWrap())
         BO->setHasNoUnsignedWrap();
-      if (I.hasNoSignedWrap() && Mul->hasNoSignedWrap() &&
-          Shl->isNotMinSignedValue())
+      if (I.hasNoSignedWrap() && Mul->hasNoSignedWrap())
         BO->setHasNoSignedWrap();
       return BO;
     }
@@ -221,7 +220,7 @@
 
         if (I.hasNoUnsignedWrap())
           Shl->setHasNoUnsignedWrap();
-        if (I.hasNoSignedWrap() && NewCst->isNotMinSignedValue())
+        if (I.hasNoSignedWrap())
           Shl->setHasNoSignedWrap();
 
         return Shl;
Index: test/Transforms/InstCombine/2011-06-13-nsw-alloca.ll
===================================================================
--- test/Transforms/InstCombine/2011-06-13-nsw-alloca.ll
+++ test/Transforms/InstCombine/2011-06-13-nsw-alloca.ll
@@ -15,7 +15,7 @@
 
 ; <label>:4                                       ; preds = %0
   %5 = load i32, i32* %1, align 4
-  %6 = shl nsw i32 %5, 3
+  %6 = mul nsw i32 %5, 8
 ; With "nsw", the alloca and its bitcast can be fused:
   %7 = add nsw i32 %6, 2048
 ;  CHECK: alloca double
Index: test/Transforms/InstCombine/cast.ll
===================================================================
--- test/Transforms/InstCombine/cast.ll
+++ test/Transforms/InstCombine/cast.ll
@@ -780,7 +780,7 @@
 
 define double @test69(double *%p, i64 %i) {
 ; CHECK-LABEL: @test69(
-  %o = shl nsw i64 %i, 3
+  %o = mul nsw i64 %i, 8
   %q = bitcast double* %p to i8*
   %pp = getelementptr inbounds i8, i8* %q, i64 %o
 ; CHECK-NEXT: getelementptr inbounds double, double*
@@ -821,7 +821,7 @@
 
 define double @test72(double *%p, i32 %i) {
 ; CHECK-LABEL: @test72(
-  %so = shl nsw i32 %i, 3
+  %so = mul nsw i32 %i, 8
   %o = sext i32 %so to i64
 ; CHECK-NEXT: sext i32 %i to i64
   %q = bitcast double* %p to i8*
@@ -836,7 +836,7 @@
 
 define double @test73(double *%p, i128 %i) {
 ; CHECK-LABEL: @test73(
-  %lo = shl nsw i128 %i, 3
+  %lo = mul nsw i128 %i, 8
   %o = trunc i128 %lo to i64
 ; CHECK-NEXT: trunc i128 %i to i64
   %q = bitcast double* %p to i8*
@@ -948,7 +948,7 @@
 
 define double @test80([100 x double]* %p, i32 %i) {
 ; CHECK-LABEL: @test80(
-  %tmp = shl nsw i32 %i, 3
+  %tmp = mul nsw i32 %i, 8
 ; CHECK-NEXT: sext i32 %i to i64
   %q = bitcast [100 x double]* %p to i8*
   %pp = getelementptr i8, i8* %q, i32 %tmp
@@ -965,7 +965,7 @@
 ; CHECK-NEXT: getelementptr [100 x double], [100 x double] addrspace(1)* %p
 ; CHECK-NEXT: load double, double addrspace(1)*
 ; CHECK-NEXT: ret double
-  %tmp = shl nsw i32 %i, 3
+  %tmp = mul nsw i32 %i, 8
   %q = addrspacecast [100 x double] addrspace(1)* %p to i8 addrspace(2)*
   %pp = getelementptr i8, i8 addrspace(2)* %q, i32 %tmp
   %r = addrspacecast i8 addrspace(2)* %pp to double addrspace(1)*
@@ -979,7 +979,7 @@
 ; CHECK-NEXT: addrspacecast double addrspace(1)*
 ; CHECK-NEXT: load double, double addrspace(3)*
 ; CHECK-NEXT: ret double
-  %tmp = shl nsw i32 %i, 3
+  %tmp = mul nsw i32 %i, 8
   %q = addrspacecast [100 x double] addrspace(1)* %p to i8 addrspace(2)*
   %pp = getelementptr i8, i8 addrspace(2)* %q, i32 %tmp
   %r = addrspacecast i8 addrspace(2)* %pp to double addrspace(3)*
@@ -989,7 +989,7 @@
 
 define double @test80_as1([100 x double] addrspace(1)* %p, i16 %i) {
 ; CHECK-LABEL: @test80_as1(
-  %tmp = shl nsw i16 %i, 3
+  %tmp = mul nsw i16 %i, 8
 ; CHECK-NEXT: sext i16 %i to i32
   %q = bitcast [100 x double] addrspace(1)* %p to i8 addrspace(1)*
   %pp = getelementptr i8, i8 addrspace(1)* %q, i16 %tmp
Index: test/Transforms/InstSimplify/compare.ll
===================================================================
--- test/Transforms/InstSimplify/compare.ll
+++ test/Transforms/InstSimplify/compare.ll
@@ -1056,12 +1056,12 @@
 ; CHECK-NEXT: ret i1 false
 }
 
-define i1 @icmp_shl_nsw_1(i64 %a) {
- %shl = shl nsw i64 1, %a
- %cmp = icmp sge i64 %shl, 0
+define i1 @icmp_shl_nsw_2(i64 %a) {
+ %shl = shl nsw i64 2, %a
+ %cmp = icmp sgt i64 %shl, 0
  ret i1 %cmp
 
-; CHECK-LABEL: @icmp_shl_nsw_1
+; CHECK-LABEL: @icmp_shl_nsw_2
 ; CHECK-NEXT: ret i1 true
 }