ValueTracking: Handle fptrunc_round in computeKnownFPClass

[foad]

llvm/lib/Analysis/ValueTracking.cpp

4078

I think there might be subtle bugs lurking in the way you pass InterestedClasses into recursive calls. E.g if InterestedClasses was fcQNan here, and the recursive call returned fcNone, you would conclude the operand is not nan - but in reality it could still be snan.

If I'm right that that's a bug then you could fix this case by passing fcNan into the recursive call.

Anyway this is pre-existing.

[arsenm]

llvm/lib/Analysis/ValueTracking.cpp

4078

InterestedClasses shouldn't be an issue, it's only used for early exiting as it's a compile time hint. The nan propagation could be better, I started introducing a helper for this in D148599

[foad]

llvm/lib/Analysis/ValueTracking.cpp

4078

OK, if we always return conservatively correct info the for the un-interested-classes then I guess there's no bug.

[arsenm]

7aeec64215cdbb2420756808a902a9e6807ecb30

llvm/lib/Analysis/ValueTracking.cpp

static void computeKnownFPClass(const Value *V, KnownFPClass &Known,
                                 FPClassTest InterestedClasses, unsigned Depth,
                                 const Query &Q, const TargetLibraryInfo *TLI) {
   auto *FVTy = dyn_cast<FixedVectorType>(V->getType());
   APInt DemandedElts =
       FVTy ? APInt::getAllOnes(FVTy->getNumElements()) : APInt(1, 1);
   computeKnownFPClass(V, DemandedElts, InterestedClasses, Known, Depth, Q, TLI);
 }
 
+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)
+    return;
+
+  KnownFPClass KnownSrc;
+  computeKnownFPClass(Op->getOperand(0), DemandedElts, InterestedClasses,
+                      KnownSrc, Depth + 1, Q, TLI);
+  if (KnownSrc.isKnownNeverNaN())
+    Known.knownNot(fcNan);
+
+  // 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");
 
   if (!DemandedElts) {
if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Op)) {
                             InterestedClasses, KnownSrc, Depth + 1, Q, TLI);
         if (KnownSrc.isKnownNeverNaN()) {
           Known.knownNot(fcNan);
           Known.SignBit = false;
         }
 
         break;
       }
+      case Intrinsic::fptrunc_round: {
+        computeKnownFPClassForFPTrunc(Op, DemandedElts, InterestedClasses,
+                                      Known, Depth, Q, TLI);
+        break;
+      }
       case Intrinsic::arithmetic_fence: {
         computeKnownFPClass(II->getArgOperand(0), DemandedElts,
                             InterestedClasses, Known, Depth + 1, Q, TLI);
         break;
       }
       case Intrinsic::experimental_constrained_sitofp:
       case Intrinsic::experimental_constrained_uitofp:
         // Cannot produce nan
if (APFloat::isRepresentableAsNormalIn(SrcTy, DstTy))
       Known.knownNot(fcSubnormal);
 
     // Sign bit of a nan isn't guaranteed.
     if (!Known.isKnownNeverNaN())
       Known.SignBit = std::nullopt;
     break;
   }
   case Instruction::FPTrunc: {
-    if ((InterestedClasses & fcNan) == fcNone)
-      break;
-
-    KnownFPClass KnownSrc;
-    computeKnownFPClass(Op->getOperand(0), DemandedElts,
-                        InterestedClasses, KnownSrc, Depth + 1, Q, TLI);
-    if (KnownSrc.isKnownNeverNaN())
-      Known.knownNot(fcNan);
-
-    // Infinity needs a range check.
+    computeKnownFPClassForFPTrunc(Op, DemandedElts, InterestedClasses, Known,
+                                  Depth, Q, TLI);
     break;
   }
   case Instruction::SIToFP:
   case Instruction::UIToFP: {
     // Cannot produce nan
     Known.knownNot(fcNan);
 
     // Integers cannot be subnormal

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
 
+declare float @llvm.fptrunc.round.f32.f64(double, metadata)
+
 define float @ret_fptrunc(double %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc
-; CHECK-SAME: (double [[ARG0:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-SAME: (double [[ARG0:%.*]]) #[[ATTR1:[0-9]+]] {
 ; 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_nonan(double nofpclass(nan) %arg0) {
 ; CHECK-LABEL: define nofpclass(nan) float @ret_fptrunc_nonan
-; CHECK-SAME: (double nofpclass(nan) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(nan) [[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_noqnan(double nofpclass(qnan) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_noqnan
-; CHECK-SAME: (double nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(qnan) [[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_nosnan(double nofpclass(snan) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_nosnan
-; CHECK-SAME: (double nofpclass(snan) [[ARG0:%.*]]) #[[ATTR0]] {
+; 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
 }
 
 define float @ret_fptrunc_noinf(double nofpclass(inf) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_noinf
-; CHECK-SAME: (double nofpclass(inf) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(inf) [[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_nopinf(double nofpclass(pinf) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_nopinf
-; CHECK-SAME: (double nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(pinf) [[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_noninf(double nofpclass(ninf) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_noninf
-; CHECK-SAME: (double nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(ninf) [[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_nozero(double nofpclass(zero) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_nozero
-; CHECK-SAME: (double nofpclass(zero) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(zero) [[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_nopzero(double nofpclass(pzero) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_nopzero
-; CHECK-SAME: (double nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(pzero) [[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_nonzero(double nofpclass(nzero) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_nonzero
-; CHECK-SAME: (double nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(nzero) [[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_nonan_noinf(double nofpclass(nan inf) %arg0) {
 ; CHECK-LABEL: define nofpclass(nan) float @ret_fptrunc_nonan_noinf
-; CHECK-SAME: (double nofpclass(nan inf) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(nan inf) [[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_nosub(double nofpclass(sub) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_nosub
-; CHECK-SAME: (double nofpclass(sub) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(sub) [[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_nonorm(double nofpclass(norm) %arg0) {
 ; CHECK-LABEL: define float @ret_fptrunc_nonorm
-; CHECK-SAME: (double nofpclass(norm) [[ARG0:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (double nofpclass(norm) [[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-LABEL: define float @ret_fptrunc_round
+; CHECK-SAME: (double [[ARG0:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:    [[EXT:%.*]] = call float @llvm.fptrunc.round.f32.f64(double [[ARG0]], metadata !"round.downward") #[[ATTR2:[0-9]+]]
+; 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_nonan(double nofpclass(nan) %arg0) {
+; CHECK-LABEL: define nofpclass(nan) float @ret_fptrunc_round_nonan
+; CHECK-SAME: (double nofpclass(nan) [[ARG0:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:    [[EXT:%.*]] = call nofpclass(nan) 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_noqnan(double nofpclass(qnan) %arg0) {
+; CHECK-LABEL: define float @ret_fptrunc_round_noqnan
+; CHECK-SAME: (double nofpclass(qnan) [[ARG0:%.*]]) #[[ATTR1]] {
+; 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-SAME: (double nofpclass(snan) [[ARG0:%.*]]) #[[ATTR1]] {
+; 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_noinf(double nofpclass(inf) %arg0) {
+; CHECK-LABEL: define float @ret_fptrunc_round_noinf
+; CHECK-SAME: (double nofpclass(inf) [[ARG0:%.*]]) #[[ATTR1]] {
+; 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_nopinf(double nofpclass(pinf) %arg0) {
+; CHECK-LABEL: define float @ret_fptrunc_round_nopinf
+; CHECK-SAME: (double nofpclass(pinf) [[ARG0:%.*]]) #[[ATTR1]] {
+; 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_noninf(double nofpclass(ninf) %arg0) {
+; CHECK-LABEL: define float @ret_fptrunc_round_noninf
+; CHECK-SAME: (double nofpclass(ninf) [[ARG0:%.*]]) #[[ATTR1]] {
+; 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_nozero(double nofpclass(zero) %arg0) {
+; CHECK-LABEL: define float @ret_fptrunc_round_nozero
+; CHECK-SAME: (double nofpclass(zero) [[ARG0:%.*]]) #[[ATTR1]] {
+; 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_nopzero(double nofpclass(pzero) %arg0) {
+; CHECK-LABEL: define float @ret_fptrunc_round_nopzero
+; CHECK-SAME: (double nofpclass(pzero) [[ARG0:%.*]]) #[[ATTR1]] {
+; 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_nonzero(double nofpclass(nzero) %arg0) {
+; CHECK-LABEL: define float @ret_fptrunc_round_nonzero
+; CHECK-SAME: (double nofpclass(nzero) [[ARG0:%.*]]) #[[ATTR1]] {
+; 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_nonan_noinf(double nofpclass(nan inf) %arg0) {
+; CHECK-LABEL: define nofpclass(nan) float @ret_fptrunc_round_nonan_noinf
+; CHECK-SAME: (double nofpclass(nan inf) [[ARG0:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:    [[EXT:%.*]] = call nofpclass(nan) 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_nosub(double nofpclass(sub) %arg0) {
+; CHECK-LABEL: define float @ret_fptrunc_round_nosub
+; CHECK-SAME: (double nofpclass(sub) [[ARG0:%.*]]) #[[ATTR1]] {
+; 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_nonorm(double nofpclass(norm) %arg0) {
+; CHECK-LABEL: define float @ret_fptrunc_round_nonorm
+; CHECK-SAME: (double nofpclass(norm) [[ARG0:%.*]]) #[[ATTR1]] {
+; 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
+}
 ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
 ; TUNIT: {{.*}}