ValueTracking: fdiv sign handling in computeKnownFPClass

[arsenm]

Summary

Copy what cannotBeOrderedLessThanZeroImpl checks for fdiv.

[kpn]

Seems reasonable. LGTM.

[foad]

llvm/include/llvm/Analysis/ValueTracking.h

354–356

llvm/lib/Analysis/ValueTracking.cpp

4594

WantInfNan || WantNegative is true, else we would have bailed out

4611–4613

This may be true but it seems weirdly specific, and the comment doesn't really say what it does.

I think it generalises to:

if (KnownLHS.isKnownNot(fcNegative) && KnownRHS.isKnownNot(fcNegative))
  Known.knownNot(fcNegative);

... plus three other cases for the other combinations of LHS/RHS known not positive/negative.

This is basically saying that ignoring nans, the sign of the result is the xor of the signs of the arguments, which is also true for FMul.

[foad]

llvm/lib/Analysis/ValueTracking.cpp

4579

4587

4591–4592

neverInfinity and neverZero are not useful on their own, only if you already know neverNan.

4597

[foad]

LGTM with comment nit.

llvm/lib/Analysis/ValueTracking.cpp

4611

Comment should say +ve / +ve is +ve.

[arsenm]

llvm/lib/Analysis/ValueTracking.cpp

4611

ve?

[foad]

llvm/lib/Analysis/ValueTracking.cpp

4611

"+ve" is short for "positive". I just mean the comment should describe what the code is doing, instead of just mentioning a true but largely irrelevant fact.

[arsenm]

be8aafa1e2178810f06e5390f58058c31f16f66e

llvm/include/llvm/Analysis/ValueTracking.h

if (SignBit)
       SignBit = !*SignBit;
   }
 
   void fabs() {
     KnownFPClasses = llvm::fabs(KnownFPClasses);
     SignBit = false;
   }
 
+  /// Return true if the sign bit must be 0, ignoring the sign of nans.
+  bool signBitIsZeroOrNaN() const {
+    return isKnownNever(fcNegative);
+  }
+
   /// Assume the sign bit is zero.
-  void signBitIsZero() {
-    KnownFPClasses = (KnownFPClasses & fcPositive) |
-                     (KnownFPClasses & fcNan);
+  void signBitMustBeZero() {
+    KnownFPClasses &= (fcPositive | fcNan);
     SignBit = false;
   }
 
   void copysign(const KnownFPClass &Sign) {
     // Start assuming nothing about the sign.
     SignBit = Sign.SignBit;
     if (!SignBit)
       return;

llvm/lib/Analysis/ValueTracking.cpp

if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Op)) {
 
         // sitofp and uitofp turn into +0.0 for zero.
         Known.knownNot(fcNegZero);
 
         // Integers cannot be subnormal
         Known.knownNot(fcSubnormal);
 
         if (IID == Intrinsic::experimental_constrained_uitofp)
-          Known.signBitIsZero();
+          Known.signBitMustBeZero();
 
         // TODO: Copy inf handling from instructions
         break;
       default:
         break;
       }
     }
 
if (KnownRHS.isKnownNeverNaN() &&
           (KnownRHS.isKnownNeverInfinity() ||
            KnownRHS.isKnownNeverLogicalZero(*F, Op->getType())))
         Known.knownNot(fcNan);
     }
 
     break;
   }
   case Instruction::FDiv: {
+    // X / X is always exactly 1.0 or a NaN.
+    if (Op->getOperand(0) == Op->getOperand(1)) {
+      // TODO: Could filter out snan if we inspect the operand
+      Known.KnownFPClasses = fcNan | fcPosNormal;
+      break;
+    }
+
     const bool WantNan = (InterestedClasses & fcNan) != fcNone;
-    if (!WantNan)
+    const bool WantNegative =
+        (InterestedClasses & KnownFPClass::OrderedLessThanZeroMask) != fcNone;
+    if (!WantNan && !WantNegative)
       break;
 
     // TODO: FRem
     KnownFPClass KnownLHS, KnownRHS;
 
     computeKnownFPClass(Op->getOperand(1), DemandedElts,
                         fcNan | fcInf | fcZero | fcSubnormal, KnownRHS,
                         Depth + 1, Q, TLI);
 
-    bool KnowSomethingUseful = KnownRHS.isKnownNeverNaN() ||
-                               KnownRHS.isKnownNeverInfinity() ||
-                               KnownRHS.isKnownNeverZero();
+    bool KnowSomethingUseful =
+        KnownRHS.isKnownNeverNaN() || KnownRHS.isKnownNeverInfinity() ||
+        KnownRHS.isKnownNeverZero() || KnownRHS.signBitIsZeroOrNaN();
 
     if (KnowSomethingUseful) {
       computeKnownFPClass(Op->getOperand(0), DemandedElts,
-                          fcNan | fcInf | fcZero, KnownLHS, Depth + 1, Q, TLI);
+                          fcNan | fcInf | fcZero |
+                              KnownFPClass::OrderedLessThanZeroMask,
+                          KnownLHS, Depth + 1, Q, TLI);
     }
 
     const Function *F = cast<Instruction>(Op)->getFunction();
 
     // Only 0/0, Inf/Inf, Inf REM x and x REM 0 produce NaN.
-    // TODO: Track sign bit.
     if (KnownLHS.isKnownNeverNaN() && KnownRHS.isKnownNeverNaN() &&
         (KnownLHS.isKnownNeverInfinity() || KnownRHS.isKnownNeverInfinity()) &&
         (KnownLHS.isKnownNeverLogicalZero(*F, Op->getType()) ||
          KnownRHS.isKnownNeverLogicalZero(*F, Op->getType()))) {
       Known.knownNot(fcNan);
     }
 
+    // X / -0.0 is -Inf (or NaN).
+    if (KnownLHS.isKnownNever(fcNegative) && KnownRHS.isKnownNever(fcNegative))
+      Known.knownNot(fcNegative);
+
     break;
   }
   case Instruction::FPExt: {
     // Infinity, nan and zero propagate from source.
     computeKnownFPClass(Op->getOperand(0), DemandedElts, InterestedClasses,
                         Known, Depth + 1, Q, TLI);
 
     const fltSemantics &DstTy =
case Instruction::UIToFP: {
     Known.knownNot(fcNan);
 
     // Integers cannot be subnormal
     Known.knownNot(fcSubnormal);
 
     // sitofp and uitofp turn into +0.0 for zero.
     Known.knownNot(fcNegZero);
     if (Op->getOpcode() == Instruction::UIToFP)
-      Known.signBitIsZero();
+      Known.signBitMustBeZero();
 
     if (InterestedClasses & fcInf) {
       // Get width of largest magnitude integer (remove a bit if signed).
       // This still works for a signed minimum value because the largest FP
       // value is scaled by some fraction close to 2.0 (1.0 + 0.xxxx).
       int IntSize = Op->getOperand(0)->getType()->getScalarSizeInBits();
       if (Op->getOpcode() == Instruction::SIToFP)
         --IntSize;

llvm/test/Transforms/Attributor/nofpclass-fdiv.ll

 ; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FDIV]]
 ;
   %fdiv = fdiv float %arg0, %arg1
   ret float %fdiv
 }
 
 define float @ret_fdiv_same_operands(float %arg) #0 {
-; CHECK-LABEL: define float @ret_fdiv_same_operands
+; CHECK-LABEL: define nofpclass(inf zero sub nnorm) float @ret_fdiv_same_operands
 ; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[ARG]], [[ARG]]
 ; CHECK-NEXT:    ret float [[FDIV]]
 ;
   %fdiv = fdiv float %arg, %arg
   ret float %fdiv
 }
 
 define float @ret_fdiv_same_operands_nosnan(float nofpclass(snan) %arg) #0 {
-; CHECK-LABEL: define float @ret_fdiv_same_operands_nosnan
+; CHECK-LABEL: define nofpclass(inf zero sub nnorm) float @ret_fdiv_same_operands_nosnan
 ; CHECK-SAME: (float nofpclass(snan) [[ARG:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[ARG]], [[ARG]]
 ; CHECK-NEXT:    ret float [[FDIV]]
 ;
   %fdiv = fdiv float %arg, %arg
   ret float %fdiv
 }
 
 define float @ret_fdiv_same_operands_noqnan(float nofpclass(qnan) %arg) #0 {
-; CHECK-LABEL: define float @ret_fdiv_same_operands_noqnan
+; CHECK-LABEL: define nofpclass(inf zero sub nnorm) float @ret_fdiv_same_operands_noqnan
 ; CHECK-SAME: (float nofpclass(qnan) [[ARG:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[ARG]], [[ARG]]
 ; CHECK-NEXT:    ret float [[FDIV]]
 ;
   %fdiv = fdiv float %arg, %arg
   ret float %fdiv
 }
 
 define float @ret_fdiv_same_operands_nonan(float nofpclass(nan) %arg) #0 {
-; CHECK-LABEL: define float @ret_fdiv_same_operands_nonan
+; CHECK-LABEL: define nofpclass(inf zero sub nnorm) float @ret_fdiv_same_operands_nonan
 ; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[ARG]], [[ARG]]
 ; CHECK-NEXT:    ret float [[FDIV]]
 ;
   %fdiv = fdiv float %arg, %arg
   ret float %fdiv
 }
 

 ; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FDIV]]
 ;
   %fdiv = fdiv float %arg0, %arg1
   ret float %fdiv
 }
 
 define float @ret_fdiv_no_neg_nzero(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) #0 {
-; CHECK-LABEL: define float @ret_fdiv_no_neg_nzero
+; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_fdiv_no_neg_nzero
 ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FDIV]]
 ;
   %fdiv = fdiv float %arg0, %arg1
   ret float %fdiv
 }
 
 define float @ret_fdiv_no_neg_rhs_no_nzero(float nofpclass(ninf nsub nnorm) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) #0 {
 ; CHECK-LABEL: define float @ret_fdiv_no_neg_rhs_no_nzero
 ; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FDIV]]
 ;
   %fdiv = fdiv float %arg0, %arg1
   ret float %fdiv
 }
 
 define float @ret_fdiv_no_neg_no_zero_rhs(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm zero) %arg1) #0 {
-; CHECK-LABEL: define float @ret_fdiv_no_neg_no_zero_rhs
+; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @ret_fdiv_no_neg_no_zero_rhs
 ; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf zero nsub nnorm) [[ARG1:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:    [[FDIV:%.*]] = fdiv float [[ARG0]], [[ARG1]]
 ; CHECK-NEXT:    ret float [[FDIV]]
 ;
   %fdiv = fdiv float %arg0, %arg1
   ret float %fdiv
 }
 
 attributes #0 = { "denormal-fp-math"="ieee,ieee" }
 attributes #1 = { "denormal-fp-math"="ieee,preserve-sign" }
 attributes #2 = { "denormal-fp-math"="ieee,positive-zero" }
 attributes #3 = { "denormal-fp-math"="ieee,dynamic" }
 ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
 ; TUNIT: {{.*}}