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

[arsenm]

Summary

Alive says this is OK.

[lebedev.ri]

Alive agrees here, this looks good for add, mul.
https://rise4fun.com/Alive/vkbp
https://rise4fun.com/Alive/6Rd

lib/Transforms/InstCombine/InstructionCombining.cpp

380

So for the purpose of this patch add/mul only, correct?

[arsenm]

lib/Transforms/InstCombine/InstructionCombining.cpp

380

Yes. Bit-ops are also handled here, but they don't have the flags to preserve

[lebedev.ri]

lib/Transforms/InstCombine/InstructionCombining.cpp

380

Yes, that's what i meant.

[arsenm]

r364234

lib/Transforms/InstCombine/InstructionCombining.cpp

if (I.isAssociative()) {
           ClearSubclassDataAfterReassociation(I);
           Changed = true;
           ++NumReassoc;
           continue;
         }
       }
     }
 
     if (I.isAssociative() && I.isCommutative()) {
       if (simplifyAssocCastAssoc(&I)) {
         Changed = true;
         ++NumReassoc;
         continue;
       }
 
       // Transform: "(A op B) op C" ==> "(C op A) op B" if "C op A" simplifies.
       if (Op0 && Op0->getOpcode() == Opcode) {
if (I.isAssociative() && I.isCommutative()) {
       // Transform: "(A op C1) op (B op C2)" ==> "(A op B) op (C1 op C2)"
       // if C1 and C2 are constants.
       Value *A, *B;
       Constant *C1, *C2;
       if (Op0 && Op1 &&
           Op0->getOpcode() == Opcode && Op1->getOpcode() == Opcode &&
           match(Op0, m_OneUse(m_BinOp(m_Value(A), m_Constant(C1)))) &&
           match(Op1, m_OneUse(m_BinOp(m_Value(B), m_Constant(C2))))) {
-        BinaryOperator *NewBO = BinaryOperator::Create(Opcode, A, B);
+        bool IsNUW = hasNoUnsignedWrap(I) &&
+           hasNoUnsignedWrap(*Op0) &&
+           hasNoUnsignedWrap(*Op1);
+         BinaryOperator *NewBO = (IsNUW && Opcode == Instruction::Add) ?
+           BinaryOperator::CreateNUW(Opcode, A, B) :
+           BinaryOperator::Create(Opcode, A, B);
+
          if (isa<FPMathOperator>(NewBO)) {
           FastMathFlags Flags = I.getFastMathFlags();
           Flags &= Op0->getFastMathFlags();
           Flags &= Op1->getFastMathFlags();
           NewBO->setFastMathFlags(Flags);
         }
         InsertNewInstWith(NewBO, I);
         NewBO->takeName(Op1);
         I.setOperand(0, NewBO);
         I.setOperand(1, ConstantExpr::get(Opcode, C1, C2));
         // Conservatively clear the optional flags, since they may not be
         // preserved by the reassociation.
         ClearSubclassDataAfterReassociation(I);
+        if (IsNUW)
+          I.setHasNoUnsignedWrap(true);
 
         Changed = true;
         continue;
       }
     }
 
     // No further simplifications.
     return Changed;

test/Transforms/InstCombine/reassociate-nuw.ll

 ;
   %add0 = add nuw i32 %x, 4
   %add1 = add i32 %add0, 64
   ret i32 %add1
 }
 
 define i32 @reassoc_x2_add_nuw(i32 %x, i32 %y) {
 ; CHECK-LABEL: @reassoc_x2_add_nuw(
-; CHECK-NEXT:    [[ADD1:%.*]] = add i32 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[ADD2:%.*]] = add i32 [[ADD1]], 12
+; CHECK-NEXT:    [[ADD1:%.*]] = add nuw i32 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    [[ADD2:%.*]] = add nuw i32 [[ADD1]], 12
 ; CHECK-NEXT:    ret i32 [[ADD2]]
 ;
   %add0 = add nuw i32 %x, 4
   %add1 = add nuw i32 %y, 8
   %add2 = add nuw i32 %add0, %add1
   ret i32 %add2
 }
 
 define i32 @reassoc_x2_mul_nuw(i32 %x, i32 %y) {
 ; CHECK-LABEL: @reassoc_x2_mul_nuw(
 ; CHECK-NEXT:    [[MUL1:%.*]] = mul i32 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[MUL2:%.*]] = mul i32 [[MUL1]], 45
+; CHECK-NEXT:    [[MUL2:%.*]] = mul nuw i32 [[MUL1]], 45
 ; CHECK-NEXT:    ret i32 [[MUL2]]
 ;
   %mul0 = mul nuw i32 %x, 5
   %mul1 = mul nuw i32 %y, 9
   %mul2 = mul nuw i32 %mul0, %mul1
   ret i32 %mul2
 }