DAG: Preserve nuw when reassociating adds

[arsenm]

Summary

DAG version of subset of D39417

[davide]

testcase?

[arsenm]

In D39669#916383, @davide wrote:

testcase?

Test is hard for this short of testing debug info, which is fragile. This prevents some regressions in a future AMDGPU commit

[arsenm]

Handle special case reassociate through shl/add

[davide]

In D39669#916774, @arsenm wrote:

In D39669#916383, @davide wrote:

testcase?

Test is hard for this short of testing debug info, which is fragile. This prevents some regressions in a future AMDGPU commit

CC:ing Adrian for thoughts.

[aprantl]

If it does break a subsequent commit, could you commit that first, and then apply this to fix the regressions introduced by the other commit?

[arsenm]

In D39669#916977, @aprantl wrote:

If it does break a subsequent commit, could you commit that first, and then apply this to fix the regressions introduced by the other commit?

This would be the 3rd time I've had to touch all of the tests impacted by the, and each time it's been a pain. That patch adds folding an addressing mode that doesn't support overflows, so directly checks NUW. Once that's in it should be more straightforward to write the tests with these situations directly feeding into the address expression.

[arsenm]

Looks like this was already done

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

private:
     SDValue visitFP16_TO_FP(SDNode *N);
 
     SDValue visitFADDForFMACombine(SDNode *N);
     SDValue visitFSUBForFMACombine(SDNode *N);
     SDValue visitFMULForFMADistributiveCombine(SDNode *N);
 
     SDValue XformToShuffleWithZero(SDNode *N);
     SDValue ReassociateOps(unsigned Opc, const SDLoc &DL, SDValue LHS,
-                           SDValue RHS);
+                           SDValue RHS, const SDNodeFlags Flags = SDNodeFlags());
 
     SDValue visitShiftByConstant(SDNode *N, ConstantSDNode *Amt);
 
     SDValue foldSelectOfConstants(SDNode *N);
     SDValue foldVSelectOfConstants(SDNode *N);
     SDValue foldBinOpIntoSelect(SDNode *BO);
     bool SimplifySelectOps(SDNode *SELECT, SDValue LHS, SDValue RHS);
     SDValue SimplifyBinOpWithSameOpcodeHands(SDNode *N);
if (LHSCst->getValueType(0) != SVT ||
       return false;
     if (!Match(LHSCst, RHSCst))
       return false;
   }
   return true;
 }
 
 SDValue DAGCombiner::ReassociateOps(unsigned Opc, const SDLoc &DL, SDValue N0,
-                                    SDValue N1) {
+                                    SDValue N1, const SDNodeFlags OrigFlags) {
   EVT VT = N0.getValueType();
   if (N0.getOpcode() == Opc) {
+    SDNodeFlags Flags;
+    Flags.setNoUnsignedWrap(N0->getFlags().hasNoUnsignedWrap() &&
+                            OrigFlags.hasNoUnsignedWrap());
+
     if (SDNode *L = DAG.isConstantIntBuildVectorOrConstantInt(N0.getOperand(1))) {
       if (SDNode *R = DAG.isConstantIntBuildVectorOrConstantInt(N1)) {
         // reassoc. (op (op x, c1), c2) -> (op x, (op c1, c2))
         if (SDValue OpNode = DAG.FoldConstantArithmetic(Opc, DL, VT, L, R))
-          return DAG.getNode(Opc, DL, VT, N0.getOperand(0), OpNode);
+          return DAG.getNode(Opc, DL, VT, N0.getOperand(0), OpNode, Flags);
         return SDValue();
       }
       if (N0.hasOneUse()) {
         // reassoc. (op (op x, c1), y) -> (op (op x, y), c1) iff x+c1 has one
         // use
         SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N0.getOperand(0), N1);
         if (!OpNode.getNode())
           return SDValue();
         AddToWorklist(OpNode.getNode());
-        return DAG.getNode(Opc, DL, VT, OpNode, N0.getOperand(1));
+        return DAG.getNode(Opc, DL, VT, OpNode, N0.getOperand(1), Flags);
       }
     }
   }
 
   if (N1.getOpcode() == Opc) {
+    SDNodeFlags Flags;
+    Flags.setNoUnsignedWrap(OrigFlags.hasNoUnsignedWrap() &&
+                            N1->getFlags().hasNoUnsignedWrap());
+
     if (SDNode *R = DAG.isConstantIntBuildVectorOrConstantInt(N1.getOperand(1))) {
       if (SDNode *L = DAG.isConstantIntBuildVectorOrConstantInt(N0)) {
         // reassoc. (op c2, (op x, c1)) -> (op x, (op c1, c2))
-        if (SDValue OpNode = DAG.FoldConstantArithmetic(Opc, DL, VT, R, L))
-          return DAG.getNode(Opc, DL, VT, N1.getOperand(0), OpNode);
+        if (SDValue OpNode = DAG.FoldConstantArithmetic(Opc, DL, VT, R, L)) {
+          return DAG.getNode(Opc, DL, VT, N1.getOperand(0), OpNode, Flags);
+        }
         return SDValue();
       }
       if (N1.hasOneUse()) {
         // reassoc. (op x, (op y, c1)) -> (op (op x, y), c1) iff x+c1 has one
         // use
-        SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N0, N1.getOperand(0));
+        SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N0, N1.getOperand(0),
+                                     Flags);
         if (!OpNode.getNode())
           return SDValue();
         AddToWorklist(OpNode.getNode());
-        return DAG.getNode(Opc, DL, VT, OpNode, N1.getOperand(1));
+        return DAG.getNode(Opc, DL, VT, OpNode, N1.getOperand(1), Flags);
       }
     }
   }
 
   return SDValue();
 }
 
 SDValue DAGCombiner::CombineTo(SDNode *N, const SDValue *To, unsigned NumTo,
if (N0.getOpcode() == ISD::SIGN_EXTEND && N0.hasOneUse() &&
       }
     }
 
     // Undo the add -> or combine to merge constant offsets from a frame index.
     if (N0.getOpcode() == ISD::OR &&
         isa<FrameIndexSDNode>(N0.getOperand(0)) &&
         isa<ConstantSDNode>(N0.getOperand(1)) &&
         DAG.haveNoCommonBitsSet(N0.getOperand(0), N0.getOperand(1))) {
-      SDValue Add0 = DAG.getNode(ISD::ADD, DL, VT, N1, N0.getOperand(1));
-      return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), Add0);
+      SDNodeFlags Flags;
+      Flags.setNoUnsignedWrap(N->getFlags().hasNoUnsignedWrap());
+
+      SDValue Add0 = DAG.getNode(ISD::ADD, DL, VT, N1, N0.getOperand(1), Flags);
+      return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), Add0, Flags);
     }
   }
 
   if (SDValue NewSel = foldBinOpIntoSelect(N))
     return NewSel;
 
   // reassociate add
-  if (SDValue RADD = ReassociateOps(ISD::ADD, DL, N0, N1))
+  if (SDValue RADD = ReassociateOps(ISD::ADD, DL, N0, N1, N->getFlags()))
     return RADD;
 
   // fold ((0-A) + B) -> B-A
   if (N0.getOpcode() == ISD::SUB &&
       isNullConstantOrNullSplatConstant(N0.getOperand(0)))
     return DAG.getNode(ISD::SUB, DL, VT, N1, N0.getOperand(1));
 
   // fold (A + (0-B)) -> A-B
SDValue DAGCombiner::visitSHL(SDNode *N) {
   if ((N0.getOpcode() == ISD::ADD || N0.getOpcode() == ISD::OR) &&
       N0.getNode()->hasOneUse() &&
       isConstantOrConstantVector(N1, /* No Opaques */ true) &&
       isConstantOrConstantVector(N0.getOperand(1), /* No Opaques */ true)) {
     SDValue Shl0 = DAG.getNode(ISD::SHL, SDLoc(N0), VT, N0.getOperand(0), N1);
     SDValue Shl1 = DAG.getNode(ISD::SHL, SDLoc(N1), VT, N0.getOperand(1), N1);
     AddToWorklist(Shl0.getNode());
     AddToWorklist(Shl1.getNode());
-    return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, Shl0, Shl1);
+
+    SDNodeFlags Flags;
+    Flags.setNoUnsignedWrap(N->getFlags().hasNoUnsignedWrap() &&
+                            (N0.getOpcode() == ISD::OR ||
+                             N0->getFlags().hasNoUnsignedWrap()));
+    return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, Shl0, Shl1, Flags);
   }
 
   // fold (shl (mul x, c1), c2) -> (mul x, c1 << c2)
   if (N0.getOpcode() == ISD::MUL && N0.getNode()->hasOneUse() &&
       isConstantOrConstantVector(N1, /* No Opaques */ true) &&
       isConstantOrConstantVector(N0.getOperand(1), /* No Opaques */ true)) {
     SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(N1), VT, N0.getOperand(1), N1);
     if (isConstantOrConstantVector(Shl))