[DAGCombine] (addcarry (add|uaddo X, Y), 0, Carry) -> (addcarry X, Y, Carry)

[deadalnix]

Summary

Do the transform when the carry isn't used. It's a pattern exposed when legalizing large integers.

[RKSimon]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

2158

Might it be quicker if we check for ISD::ADD/ISD::UADDO first before calling the heavier isNullConstan/hasAnyUseOfValue checks?

[deadalnix]

Check for opcode before uses.

[RKSimon]

LGTM with one minor

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

2158

The comment doesn't grok well, maybe just:

// IIF the flag result is dead:
// (addcarry (add|uaddo X, Y), 0, Carry) -> (addcarry X, Y, Carry)

[deadalnix]

Fix comment.

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

private:
     SDValue visitSUB(SDNode *N);
     SDValue visitADDC(SDNode *N);
     SDValue visitUADDO(SDNode *N);
     SDValue visitUADDOLike(SDValue N0, SDValue N1, SDNode *N);
     SDValue visitSUBC(SDNode *N);
     SDValue visitUSUBO(SDNode *N);
     SDValue visitADDE(SDNode *N);
     SDValue visitADDCARRY(SDNode *N);
+    SDValue visitADDCARRYLike(SDValue N0, SDValue N1, SDValue CarryIn, SDNode *N);
     SDValue visitSUBE(SDNode *N);
     SDValue visitSUBCARRY(SDNode *N);
     SDValue visitMUL(SDNode *N);
     SDValue useDivRem(SDNode *N);
     SDValue visitSDIV(SDNode *N);
     SDValue visitUDIV(SDNode *N);
     SDValue visitREM(SDNode *N);
     SDValue visitMULHU(SDNode *N);
SDValue DAGCombiner::visitADDCARRY(SDNode *N) {
   if (N0C && !N1C)
     return DAG.getNode(ISD::ADDCARRY, SDLoc(N), N->getVTList(),
                        N1, N0, CarryIn);
 
   // fold (addcarry x, y, false) -> (uaddo x, y)
   if (isNullConstant(CarryIn))
     return DAG.getNode(ISD::UADDO, SDLoc(N), N->getVTList(), N0, N1);
 
+  if (SDValue Combined = visitADDCARRYLike(N0, N1, CarryIn, N))
+    return Combined;
+
+  if (SDValue Combined = visitADDCARRYLike(N1, N0, CarryIn, N))
+    return Combined;
+
+  return SDValue();
+}
+
+SDValue DAGCombiner::visitADDCARRYLike(SDValue N0, SDValue N1, SDValue CarryIn,
+                                       SDNode *N) {
+  // If the flag result is dead, we can do transform that invalidate it.
+  if (!N->hasAnyUseOfValue(1)) {
+    // (addcarry (add|uaddo X, Y), 0, Carry) -> (addcarry X, Y, Carry)
+    if ((N0.getOpcode() == ISD::ADD || N0.getOpcode() == ISD::UADDO) &&
+        isNullConstant(N1))
+      return DAG.getNode(ISD::ADDCARRY, SDLoc(N), N->getVTList(),
+                         N0.getOperand(0), N0.getOperand(1), CarryIn);
+  }
+
   return SDValue();
 }
 
 // Since it may not be valid to emit a fold to zero for vector initializers
 // check if we can before folding.
 static SDValue tryFoldToZero(const SDLoc &DL, const TargetLowering &TLI, EVT VT,
                              SelectionDAG &DAG, bool LegalOperations,
                              bool LegalTypes) {

test/CodeGen/X86/addcarry.ll

entry:
   %19 = trunc i128 %18 to i32
   store i32 %19, i32* %15, align 4
   ret void
 }
 
 define i64 @shiftadd(i64 %a, i64 %b, i64 %c, i64 %d) {
 ; CHECK-LABEL: shiftadd:
 ; CHECK:       # BB#0: # %entry
-; CHECK-NEXT:    leaq (%rdx,%rcx), %rax
 ; CHECK-NEXT:    addq %rsi, %rdi
-; CHECK-NEXT:    adcq $0, %rax
+; CHECK-NEXT:    adcq %rcx, %rdx
+; CHECK-NEXT:    movq %rdx, %rax
 ; CHECK-NEXT:    retq
 entry:
   %0 = zext i64 %a to i128
   %1 = zext i64 %b to i128
   %2 = add i128 %0, %1
   %3 = lshr i128 %2, 64
   %4 = trunc i128 %3 to i64
   %5 = add i64 %c, %d
   %6 = add i64 %4, %5
   ret i64 %6
 }