[X86] Combine ADC(ADD(X,Y),0,Carry) -> ADC(X,Y,Carry)

[chfast]

llvm/lib/Target/X86/X86ISelLowering.cpp

52114

Is it guaranteed the constant is in RHS?

52115

I copied !N->hasAnyUseOfValue(1) from the combineSBB() but I don't understand why this is needed. There is no negative test for it.

[craig.topper]

llvm/lib/Target/X86/X86ISelLowering.cpp

52115

That checks that the EFLAG result is unused. Doing this combine can change the value of the C flag produced by the ADC so we need to make sure no one is looking at it.

[RKSimon]

LGTM - cheers

[xbolva00]

llvm/lib/Target/X86/X86ISelLowering.cpp

52156

OneUseCheck of Add?

@RKSimon

[RKSimon]

llvm/lib/Target/X86/X86ISelLowering.cpp

52156

why?

llvm/lib/Target/X86/X86ISelLowering.cpp

static SDValue combineSBB(SDNode *N, SelectionDAG &DAG) {
   if (SDValue Flags = combineCarryThroughADD(BorrowIn, DAG)) {
     MVT VT = N->getSimpleValueType(0);
     SDVTList VTs = DAG.getVTList(VT, MVT::i32);
     return DAG.getNode(X86ISD::SBB, SDLoc(N), VTs, LHS, RHS, Flags);
   }
 
   // Fold SBB(SUB(X,Y),0,Carry) -> SBB(X,Y,Carry)
   // iff the flag result is dead.
   if (LHS.getOpcode() == ISD::SUB && isNullConstant(RHS) &&
       !N->hasAnyUseOfValue(1))
     return DAG.getNode(X86ISD::SBB, SDLoc(N), N->getVTList(), LHS.getOperand(0),
                        LHS.getOperand(1), BorrowIn);
 
   return SDValue();
 }
 
 // Optimize RES, EFLAGS = X86ISD::ADC LHS, RHS, EFLAGS
 static SDValue combineADC(SDNode *N, SelectionDAG &DAG,
static SDValue combineADC(SDNode *N, SelectionDAG &DAG,
   }
 
   if (SDValue Flags = combineCarryThroughADD(CarryIn, DAG)) {
     MVT VT = N->getSimpleValueType(0);
     SDVTList VTs = DAG.getVTList(VT, MVT::i32);
     return DAG.getNode(X86ISD::ADC, SDLoc(N), VTs, LHS, RHS, Flags);
   }
 
+  // Fold ADC(ADD(X,Y),0,Carry) -> ADC(X,Y,Carry)
+  // iff the flag result is dead.
+  if (LHS.getOpcode() == ISD::ADD && isNullConstant(RHS) &&
+      !N->hasAnyUseOfValue(1))
+    return DAG.getNode(X86ISD::ADC, SDLoc(N), N->getVTList(), LHS.getOperand(0),
+                       LHS.getOperand(1), CarryIn);
+
   return SDValue();
 }
 
 /// If this is an add or subtract where one operand is produced by a cmp+setcc,
 /// then try to convert it to an ADC or SBB. This replaces TEST+SET+{ADD/SUB}
 /// with CMP+{ADC, SBB}.
 static SDValue combineAddOrSubToADCOrSBB(SDNode *N, SelectionDAG &DAG) {
   bool IsSub = N->getOpcode() == ISD::SUB;

llvm/test/CodeGen/X86/addcarry.ll

; CHECK-NEXT:    retq
   %41 = getelementptr inbounds %uint256, %uint256* %0, i64 0, i32 1, i32 1
   store i64 %37, i64* %41, align 8
   ret void
 }
 
 define i32 @addcarry_ult(i32 %a, i32 %b, i32 %x, i32 %y) {
 ; CHECK-LABEL: addcarry_ult:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    # kill: def $esi killed $esi def $rsi
-; CHECK-NEXT:    # kill: def $edi killed $edi def $rdi
-; CHECK-NEXT:    leal (%rdi,%rsi), %eax
+; CHECK-NEXT:    movl %edi, %eax
 ; CHECK-NEXT:    cmpl %ecx, %edx
-; CHECK-NEXT:    adcl $0, %eax
+; CHECK-NEXT:    adcl %esi, %eax
 ; CHECK-NEXT:    retq
   %s = add i32 %a, %b
   %k = icmp ult i32 %x, %y
   %z = zext i1 %k to i32
   %r = add i32 %s, %z
   ret i32 %r
 }
 
 define i32 @addcarry_ugt(i32 %a, i32 %b, i32 %x, i32 %y) {
 ; CHECK-LABEL: addcarry_ugt:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    # kill: def $esi killed $esi def $rsi
-; CHECK-NEXT:    # kill: def $edi killed $edi def $rdi
-; CHECK-NEXT:    leal (%rdi,%rsi), %eax
+; CHECK-NEXT:    movl %edi, %eax
 ; CHECK-NEXT:    cmpl %edx, %ecx
-; CHECK-NEXT:    adcl $0, %eax
+; CHECK-NEXT:    adcl %esi, %eax
 ; CHECK-NEXT:    retq
   %s = add i32 %a, %b
   %k = icmp ugt i32 %x, %y
   %z = zext i1 %k to i32
   %r = add i32 %s, %z
   ret i32 %r
 }