[llvm] b7116ba - [DAG] computeOverflowForUnsignedAdd - use ConstantRange::unsignedAddMayOverflow as fallback

[Simon Pilgrim via llvm-commits]

Author: Simon Pilgrim
Date: 2023-05-06T22:03:38+01:00
New Revision: b7116ba8b05ef7a9aa200d8c23606272184b3928

URL: https://github.com/llvm/llvm-project/commit/b7116ba8b05ef7a9aa200d8c23606272184b3928
DIFF: https://github.com/llvm/llvm-project/commit/b7116ba8b05ef7a9aa200d8c23606272184b3928.diff

LOG: [DAG] computeOverflowForUnsignedAdd - use ConstantRange::unsignedAddMayOverflow as fallback

Replaces the more specific uadd_ov case

Added: 
    

Modified: 
    llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
    llvm/test/CodeGen/X86/dagcombine-cse.ll

Removed: 
    


################################################################################
diff  --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index 942d2641ba7d..f19f5644132a 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -3943,6 +3943,20 @@ KnownBits SelectionDAG::computeKnownBits(SDValue Op, const APInt &DemandedElts,
   return Known;
 }
 
+/// Convert ConstantRange OverflowResult into SelectionDAG::OverflowKind.
+static SelectionDAG::OverflowKind mapOverflowResult(ConstantRange::OverflowResult OR) {
+  switch (OR) {
+  case ConstantRange::OverflowResult::MayOverflow:
+    return SelectionDAG::OFK_Sometime;
+  case ConstantRange::OverflowResult::AlwaysOverflowsLow:
+  case ConstantRange::OverflowResult::AlwaysOverflowsHigh:
+    return SelectionDAG::OFK_Always;
+  case ConstantRange::OverflowResult::NeverOverflows:
+    return SelectionDAG::OFK_Never;
+  }
+  llvm_unreachable("Unknown OverflowResult");
+}
+
 SelectionDAG::OverflowKind
 SelectionDAG::computeOverflowForSignedAdd(SDValue N0, SDValue N1) const {
   // X + 0 never overflow
@@ -3964,26 +3978,21 @@ SelectionDAG::computeOverflowForUnsignedAdd(SDValue N0, SDValue N1) const {
   if (isNullConstant(N1))
     return OFK_Never;
 
-  KnownBits N1Known = computeKnownBits(N1);
-  if (N1Known.Zero.getBoolValue()) {
-    KnownBits N0Known = computeKnownBits(N0);
-
-    bool overflow;
-    (void)N0Known.getMaxValue().uadd_ov(N1Known.getMaxValue(), overflow);
-    if (!overflow)
-      return OFK_Never;
-  }
-
   // mulhi + 1 never overflow
+  KnownBits N1Known = computeKnownBits(N1);
   if (N0.getOpcode() == ISD::UMUL_LOHI && N0.getResNo() == 1 &&
       N1Known.getMaxValue().ult(2))
     return OFK_Never;
+
+  KnownBits N0Known = computeKnownBits(N0);
   if (N1.getOpcode() == ISD::UMUL_LOHI && N1.getResNo() == 1 &&
-      computeKnownBits(N0).getMaxValue().ult(2))
+      N0Known.getMaxValue().ult(2))
     return OFK_Never;
 
-  // TODO: Add ConstantRange::unsignedAddMayOverflow handling.
-  return OFK_Sometime;
+  // Fallback to ConstantRange::unsignedAddMayOverflow handling.
+  ConstantRange N0Range = ConstantRange::fromKnownBits(N0Known, false);
+  ConstantRange N1Range = ConstantRange::fromKnownBits(N1Known, false);
+  return mapOverflowResult(N0Range.unsignedAddMayOverflow(N1Range));
 }
 
 SelectionDAG::OverflowKind

diff  --git a/llvm/test/CodeGen/X86/dagcombine-cse.ll b/llvm/test/CodeGen/X86/dagcombine-cse.ll
index 0efb371c274f..222a4d78668b 100644
--- a/llvm/test/CodeGen/X86/dagcombine-cse.ll
+++ b/llvm/test/CodeGen/X86/dagcombine-cse.ll
@@ -50,6 +50,7 @@ define i96 @square_high(i96 %x) nounwind {
 ; X86-NEXT:    pushl %ebx
 ; X86-NEXT:    pushl %edi
 ; X86-NEXT:    pushl %esi
+; X86-NEXT:    pushl %eax
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %edi
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %esi
 ; X86-NEXT:    movl %edi, %eax
@@ -72,37 +73,31 @@ define i96 @square_high(i96 %x) nounwind {
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %esi
 ; X86-NEXT:    movl %esi, %eax
 ; X86-NEXT:    mull %edi
-; X86-NEXT:    movl %edx, %edi
+; X86-NEXT:    movl %edx, (%esp) ## 4-byte Spill
 ; X86-NEXT:    movl %eax, %ebp
 ; X86-NEXT:    movl %esi, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
-; X86-NEXT:    movl %eax, %esi
-; X86-NEXT:    addl %edi, %esi
-; X86-NEXT:    adcl $0, %edx
+; X86-NEXT:    movl %edx, %esi
+; X86-NEXT:    movl %eax, %edi
+; X86-NEXT:    addl (%esp), %edi ## 4-byte Folded Reload
+; X86-NEXT:    adcl $0, %esi
 ; X86-NEXT:    addl %ebp, %ebx
-; X86-NEXT:    adcl %esi, %ecx
-; X86-NEXT:    setb %al
-; X86-NEXT:    movl %edx, %edi
-; X86-NEXT:    adcl $0, %edi
+; X86-NEXT:    adcl %edi, %ecx
+; X86-NEXT:    movl %esi, %eax
+; X86-NEXT:    adcl $0, %eax
+; X86-NEXT:    setb %dl
 ; X86-NEXT:    addl %ebp, %ebx
-; X86-NEXT:    adcl %ecx, %esi
-; X86-NEXT:    setb %cl
-; X86-NEXT:    adcl %edx, %edi
-; X86-NEXT:    addb $255, %cl
-; X86-NEXT:    movl %edx, %ecx
+; X86-NEXT:    adcl %ecx, %edi
+; X86-NEXT:    movzbl %dl, %ecx
+; X86-NEXT:    adcl %eax, %esi
 ; X86-NEXT:    adcl $0, %ecx
-; X86-NEXT:    setb %ah
-; X86-NEXT:    addb $255, %al
-; X86-NEXT:    adcl %edx, %ecx
-; X86-NEXT:    movzbl %ah, %ebx
-; X86-NEXT:    adcl $0, %ebx
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    mull %eax
-; X86-NEXT:    addl %eax, %edi
-; X86-NEXT:    adcl %edx, %ebx
-; X86-NEXT:    movl %esi, %eax
-; X86-NEXT:    movl %edi, %edx
-; X86-NEXT:    movl %ebx, %ecx
+; X86-NEXT:    addl %eax, %esi
+; X86-NEXT:    adcl %edx, %ecx
+; X86-NEXT:    movl %edi, %eax
+; X86-NEXT:    movl %esi, %edx
+; X86-NEXT:    addl $4, %esp
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    popl %edi
 ; X86-NEXT:    popl %ebx