InstCombine: Preserve nuw when reassociating nuw ops [3/3]

[arsenm]

Summary

Alive says this is OK.

[lebedev.ri]

Can this end up producing anything other than mul-of-add that we care about?
https://rise4fun.com/Alive/WtnX

lib/Transforms/InstCombine/InstructionCombining.cpp

595

Outdated comment?

628–629

Why is this restricted to m_APInt()?
https://rise4fun.com/Alive/WtnX

[lebedev.ri]

(just marking as reviewed)

[arsenm]

Don't restrict to just constant

[lebedev.ri]

Looks good.

lib/Transforms/InstCombine/InstructionCombining.cpp

595

Still outdated?

[arsenm]

r364235

lib/Transforms/InstCombine/InstructionCombining.cpp

if (B == D || (InnerCommutative && B == C)) {
       }
     }
 
   if (SimplifiedInst) {
     ++NumFactor;
     SimplifiedInst->takeName(&I);
 
     // Check if we can add NSW flag to SimplifiedInst. If so, set NSW flag.
     // TODO: Check for NUW.
     if (BinaryOperator *BO = dyn_cast<BinaryOperator>(SimplifiedInst)) {
       if (isa<OverflowingBinaryOperator>(SimplifiedInst)) {
         bool HasNSW = false;
-        if (isa<OverflowingBinaryOperator>(&I))
+        bool HasNUW = false;
+        if (isa<OverflowingBinaryOperator>(&I)) {
           HasNSW = I.hasNoSignedWrap();
+          HasNUW = I.hasNoUnsignedWrap();
+        }
 
-        if (auto *LOBO = dyn_cast<OverflowingBinaryOperator>(LHS))
+        if (auto *LOBO = dyn_cast<OverflowingBinaryOperator>(LHS)) {
           HasNSW &= LOBO->hasNoSignedWrap();
+          HasNUW &= LOBO->hasNoUnsignedWrap();
+        }
 
-        if (auto *ROBO = dyn_cast<OverflowingBinaryOperator>(RHS))
+        if (auto *ROBO = dyn_cast<OverflowingBinaryOperator>(RHS)) {
           HasNSW &= ROBO->hasNoSignedWrap();
+          HasNUW &= ROBO->hasNoUnsignedWrap();
+        }
 
         // We can propagate 'nsw' if we know that
         //  %Y = mul nsw i16 %X, C
         //  %Z = add nsw i16 %Y, %X
         // =>
         //  %Z = mul nsw i16 %X, C+1
         //
         // iff C+1 isn't INT_MIN
         const APInt *CInt;
         if (TopLevelOpcode == Instruction::Add &&
             InnerOpcode == Instruction::Mul)
-          if (match(V, m_APInt(CInt)) && !CInt->isMinSignedValue())
+          if (match(V, m_APInt(CInt))) {
+            if (!CInt->isMinSignedValue())
               BO->setHasNoSignedWrap(HasNSW);
+            BO->setHasNoUnsignedWrap(HasNUW);
+          }
       }
     }
   }
   return SimplifiedInst;
 }
 
 /// This tries to simplify binary operations which some other binary operation
 /// distributes over either by factorizing out common terms

test/Transforms/InstCombine/reassociate-nuw.ll

;
   %sub0 = sub nuw i32 %x, 4
   %sub1 = sub nuw i32 %y, 8
   %sub2 = sub nuw i32 %sub0, %sub1
   ret i32 %sub2
 }
 
 define i32 @tryFactorization_add_nuw_mul_nuw(i32 %x) {
 ; CHECK-LABEL: @tryFactorization_add_nuw_mul_nuw(
-; CHECK-NEXT:    [[ADD2:%.*]] = shl i32 [[X:%.*]], 2
+; CHECK-NEXT:    [[ADD2:%.*]] = shl nuw i32 [[X:%.*]], 2
 ; CHECK-NEXT:    ret i32 [[ADD2]]
 ;
   %mul1 = mul nuw i32 %x, 3
   %add2 = add nuw i32 %mul1, %x
   ret i32 %add2
 }
 
 define i32 @tryFactorization_add_nuw_mul_nuw_int_max(i32 %x) {
 ; CHECK-LABEL: @tryFactorization_add_nuw_mul_nuw_int_max(
-; CHECK-NEXT:    [[ADD2:%.*]] = shl i32 [[X:%.*]], 31
+; CHECK-NEXT:    [[ADD2:%.*]] = shl nuw i32 [[X:%.*]], 31
 ; CHECK-NEXT:    ret i32 [[ADD2]]
 ;
   %mul1 = mul nuw i32 %x, 2147483647
   %add2 = add nuw i32 %mul1, %x
   ret i32 %add2
 }
 
 define i32 @tryFactorization_add_mul_nuw(i32 %x) {