ValueTrackng: Handle sign bit for fptrunc

[foad]

I feel like there are undocumented assumptions here.

Does fptrunc +/- 0.0 preserve sign?

Is Known.SignBit supposed to be accurate even for Nans? That seems unfortunate, since for a lot of operations you won't be able to propagate it unless you can prove something isn't Nan.

llvm/lib/Analysis/ValueTracking.cpp

4082

Writing this as KnownSrc.isKnownNot(NegExcept0) would make it clearer that the source and result classes are the same here.

Also why can't this logic be mirrored for PosExcept0?

[arsenm]

In D148599#4277139, @foad wrote:

I feel like there are undocumented assumptions here.

Does fptrunc +/- 0.0 preserve sign?

Yes

Is Known.SignBit supposed to be accurate even for Nans? That seems unfortunate, since for a lot of operations you won't be able to propagate it unless you can prove something isn't Nan.

That’s the only reason you need it. Otherwise you can infer from the mask. I only expect it to be useful for the few signbit operations

llvm/lib/Analysis/ValueTracking.cpp

4082

It could be but it’s more cases to test and less useful

[foad]

Is Known.SignBit supposed to be accurate even for Nans? That seems unfortunate, since for a lot of operations you won't be able to propagate it unless you can prove something isn't Nan.

That’s the only reason you need it. Otherwise you can infer from the mask.

Ack. Could do with an explanatory note on the definition of SignBit.

But there's something odd here: the case in which you set SignBit in this patch is exactly the case in which you don't really need to because it could be inferred from the mask.

To put it another way, the information provided by SignBit overlaps with the mask, and each could be used to refine the other. Maybe the internal representation of KnownFPClass should be more orthogonal - you could have just a mask, but with separate bits for PosSNan NegSNan PosQNan NegQNan.

[arsenm]

Move mask handling, refine nan source propagation

[arsenm]

ping

[arsenm]

dd61b63b5ca1c8a15013e2154bf3b30243df66bd

llvm/include/llvm/Analysis/ValueTracking.h

struct KnownFPClass {
   /// extends isKnownNeverZero to cover the case where the assumed
   /// floating-point mode for the function interprets denormals as zero.
   bool isKnownNeverLogicalZero(const Function &F, Type *Ty) const;
 
   /// Return true if it's know this can never be interpreted as a negative zero.
   bool isKnownNeverLogicalNegZero(const Function &F, Type *Ty) const;
 
 
+  static constexpr FPClassTest OrderedLessThanZeroMask =
+    fcNegSubnormal | fcNegNormal | fcNegInf;
+
 /// Return true if we can prove that the analyzed floating-point value is
   /// either NaN or never less than -0.0.
   ///
   ///      NaN --> true
   ///       +0 --> true
   ///       -0 --> true
   ///   x > +0 --> true
   ///   x < -0 --> false
   bool cannotBeOrderedLessThanZero() const {
-    const FPClassTest OrderedNegMask = fcNegSubnormal | fcNegNormal | fcNegInf;
-    return (KnownFPClasses & OrderedNegMask) == fcNone;
+    return isKnownNever(OrderedLessThanZeroMask);
   }
 
   KnownFPClass &operator|=(const KnownFPClass &RHS) {
     KnownFPClasses = KnownFPClasses | RHS.KnownFPClasses;
 
     if (SignBit != RHS.SignBit)
       SignBit = std::nullopt;
     return *this;
if (!SignBit)
       return;
 
     if (*SignBit)
       KnownFPClasses = KnownFPClasses & fcNegative;
     else
       KnownFPClasses = KnownFPClasses & fcPositive;
   }
 
+  // Propagate knowledge that a non-NaN source implies the result can also not
+  // be a NaN. For unconstrained operations, signaling nans are not guaranteed
+  // to be quieted but cannot be introduced.
+  void propagateNaN(const KnownFPClass &Src, bool PreserveSign = false) {
+    if (Src.isKnownNever(fcNan)) {
+      knownNot(fcNan);
+      if (PreserveSign)
+        SignBit = Src.SignBit;
+    } else if (Src.isKnownNever(fcSNan))
+      knownNot(fcSNan);
+  }
+
   void resetAll() { *this = KnownFPClass(); }
 };
 
 inline KnownFPClass operator|(KnownFPClass LHS, const KnownFPClass &RHS) {
   LHS |= RHS;
   return LHS;
 }
 

llvm/lib/Analysis/ValueTracking.cpp

 }
 
 static void computeKnownFPClassForFPTrunc(const Operator *Op,
                                           const APInt &DemandedElts,
                                           FPClassTest InterestedClasses,
                                           KnownFPClass &Known, unsigned Depth,
                                           const Query &Q,
                                           const TargetLibraryInfo *TLI) {
-  if ((InterestedClasses & fcNan) == fcNone)
+  if ((InterestedClasses &
+       (KnownFPClass::OrderedLessThanZeroMask | fcNan)) == fcNone)
     return;
 
   KnownFPClass KnownSrc;
   computeKnownFPClass(Op->getOperand(0), DemandedElts, InterestedClasses,
                       KnownSrc, Depth + 1, Q, TLI);
-  if (KnownSrc.isKnownNeverNaN())
-    Known.knownNot(fcNan);
+
+  // Sign should be preserved
+  // TODO: Handle cannot be ordered greater than zero
+  if (KnownSrc.cannotBeOrderedLessThanZero())
+    Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
+
+  Known.propagateNaN(KnownSrc, true);
 
   // Infinity needs a range check.
-  // TODO: Sign bit should be preserved
 }
 
 // TODO: Merge implementation of cannotBeOrderedLessThanZero into here.
 void computeKnownFPClass(const Value *V, const APInt &DemandedElts,
                          FPClassTest InterestedClasses, KnownFPClass &Known,
                          unsigned Depth, const Query &Q,
                          const TargetLibraryInfo *TLI) {
   assert(Known.isUnknown() && "should not be called with known information");

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

 ; CHECK-NEXT:    [[EXT:%.*]] = fptrunc double [[ARG0]] to float
 ; CHECK-NEXT:    ret float [[EXT]]
 ;
   %ext = fptrunc double %arg0 to float
   ret float %ext
 }
 
 define float @ret_fptrunc_nosnan(double nofpclass(snan) %arg0) {
-; CHECK-LABEL: define float @ret_fptrunc_nosnan
+; CHECK-LABEL: define nofpclass(snan) float @ret_fptrunc_nosnan
 ; CHECK-SAME: (double nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[EXT:%.*]] = fptrunc double [[ARG0]] to float
 ; CHECK-NEXT:    ret float [[EXT]]
 ;
   %ext = fptrunc double %arg0 to float
   ret float %ext
 }
 

 ; CHECK-NEXT:    [[EXT:%.*]] = fptrunc double [[ARG0]] to float
 ; CHECK-NEXT:    ret float [[EXT]]
 ;
   %ext = fptrunc double %arg0 to float
   ret float %ext
 }
 
 define float @ret_fptrunc_posonly(double nofpclass(ninf nnorm nsub nzero) %arg0) {
-; CHECK-LABEL: define float @ret_fptrunc_posonly
-; CHECK-SAME: (double nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-LABEL: define nofpclass(ninf nsub nnorm) float @ret_fptrunc_posonly
+; CHECK-SAME: (double nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[EXT:%.*]] = fptrunc double [[ARG0]] to float
 ; CHECK-NEXT:    ret float [[EXT]]
 ;
   %ext = fptrunc double %arg0 to float
   ret float %ext
 }
 
 define float @ret_fptrunc_posonly_zero(double nofpclass(ninf nnorm nsub) %arg0) {
-; CHECK-LABEL: define float @ret_fptrunc_posonly_zero
-; CHECK-SAME: (double nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-LABEL: define nofpclass(ninf nsub nnorm) float @ret_fptrunc_posonly_zero
+; CHECK-SAME: (double nofpclass(ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[EXT:%.*]] = fptrunc double [[ARG0]] to float
 ; CHECK-NEXT:    ret float [[EXT]]
 ;
   %ext = fptrunc double %arg0 to float
   ret float %ext
 }
 
 define float @ret_fptrunc_posonly_zero_nan(double nofpclass(ninf nnorm nsub nan) %arg0) {
-; CHECK-LABEL: define float @ret_fptrunc_posonly_zero_nan
-; CHECK-SAME: (double nofpclass(nan ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-LABEL: define nofpclass(nan ninf nsub nnorm) float @ret_fptrunc_posonly_zero_nan
+; CHECK-SAME: (double nofpclass(nan ninf nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[EXT:%.*]] = fptrunc double [[ARG0]] to float
 ; CHECK-NEXT:    ret float [[EXT]]
 ;
   %ext = fptrunc double %arg0 to float
   ret float %ext
 }
 
 define float @ret_fptrunc_posonly_nan(double nofpclass(ninf nnorm nsub nzero nan) %arg0) {
-; CHECK-LABEL: define float @ret_fptrunc_posonly_nan
-; CHECK-SAME: (double nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-LABEL: define nofpclass(nan ninf nsub nnorm) float @ret_fptrunc_posonly_nan
+; CHECK-SAME: (double nofpclass(nan ninf nzero nsub nnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[EXT:%.*]] = fptrunc double [[ARG0]] to float
 ; CHECK-NEXT:    ret float [[EXT]]
 ;
   %ext = fptrunc double %arg0 to float
   ret float %ext
 }
 
 define float @ret_fptrunc_negonly(double nofpclass(pinf pnorm psub pzero) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_negonly
-; CHECK-SAME: (double nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(pinf pzero psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[EXT:%.*]] = fptrunc double [[ARG0]] to float
 ; CHECK-NEXT:    ret float [[EXT]]
 ;
   %ext = fptrunc double %arg0 to float
   ret float %ext
 }
 
 define float @ret_fptrunc_negonly_zero(double nofpclass(pinf pnorm psub) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_negonly_zero
-; CHECK-SAME: (double nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[EXT:%.*]] = fptrunc double [[ARG0]] to float
 ; CHECK-NEXT:    ret float [[EXT]]
 ;
   %ext = fptrunc double %arg0 to float
   ret float %ext
 }
 
 define float @ret_fptrunc_negonly_zero_nan(double nofpclass(pinf pnorm psub nan) %arg0) {
-; CHECK-LABEL: define float @ret_fptrunc_negonly_zero_nan
-; CHECK-SAME: (double nofpclass(nan pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-LABEL: define nofpclass(nan) float @ret_fptrunc_negonly_zero_nan
+; CHECK-SAME: (double nofpclass(nan pinf psub pnorm) [[ARG0:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    [[EXT:%.*]] = fptrunc double [[ARG0]] to float
 ; CHECK-NEXT:    ret float [[EXT]]
 ;
   %ext = fptrunc double %arg0 to float
   ret float %ext
 }
 
 define float @ret_fptrunc_round(double %arg0) {

 ; CHECK-NEXT:    [[EXT:%.*]] = call float @llvm.fptrunc.round.f32.f64(double [[ARG0]], metadata !"round.downward") #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[EXT]]
 ;
   %ext = call float @llvm.fptrunc.round.f32.f64(double %arg0, metadata !"round.downward")
   ret float %ext
 }
 
 define float @ret_fptrunc_round_nosnan(double nofpclass(snan) %arg0) {
-; CHECK-LABEL: define float @ret_fptrunc_round_nosnan
+; CHECK-LABEL: define nofpclass(snan) float @ret_fptrunc_round_nosnan
 ; CHECK-SAME: (double nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] {
-; CHECK-NEXT:    [[EXT:%.*]] = call float @llvm.fptrunc.round.f32.f64(double [[ARG0]], metadata !"round.downward") #[[ATTR2]]
+; CHECK-NEXT:    [[EXT:%.*]] = call nofpclass(snan) float @llvm.fptrunc.round.f32.f64(double [[ARG0]], metadata !"round.downward") #[[ATTR2]]
 ; CHECK-NEXT:    ret float [[EXT]]
 ;
   %ext = call float @llvm.fptrunc.round.f32.f64(double %arg0, metadata !"round.downward")
   ret float %ext
 }
 
 define float @ret_fptrunc_round_noinf(double nofpclass(inf) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_round_noinf