ValueTracking: Make computeKnownFPClass respect UseInstrInfo

[arsenm]

Summary

Don't really know why you would want to use this and I still think the
argument name is unclear.

[arsenm]

ping, should avoid regressing this behavior for the release now that all the old functions are gone

[jcranmer-intel]

llvm/unittests/Analysis/ValueTrackingTest.cpp

2010

Why is nofpclass being looked at for UseInstrInfo = false? It doesn't make much sense for nnan and nofpclass(nan) to be treated differently...

[arsenm]

llvm/unittests/Analysis/ValueTrackingTest.cpp

2010

I don't really know what UseInstrInfo is supposed to mean, but this matched the previous behavior. The parameter is undocumented and based on SimplifyQuery it means "don't use flags" for an uncertain definition of flags.

[arsenm]

Also ignore nofpclass

[arsenm]

ping

llvm/unittests/Analysis/ValueTrackingTest.cpp

2010

My guess is this should also skip using assumes, but that also has never happened

[arsenm]

ping

llvm/lib/Analysis/ValueTracking.cpp

for (unsigned i = 0; i != NumElts; ++i) {
 
       KnownFPClass KnownElt{CElt->getValueAPF().classify(), CElt->isNegative()};
       Known |= KnownElt;
     }
 
     return;
   }
 
+  const Operator *Op = dyn_cast<Operator>(V);
   FPClassTest KnownNotFromFlags = fcNone;
+
+  if (Q.IIQ.UseInstrInfo) {
     if (const auto *CB = dyn_cast<CallBase>(V))
       KnownNotFromFlags |= CB->getRetNoFPClass();
     else if (const auto *Arg = dyn_cast<Argument>(V))
       KnownNotFromFlags |= Arg->getNoFPClass();
 
-  const Operator *Op = dyn_cast<Operator>(V);
     if (const FPMathOperator *FPOp = dyn_cast_or_null<FPMathOperator>(Op)) {
       if (FPOp->hasNoNaNs())
         KnownNotFromFlags |= fcNan;
       if (FPOp->hasNoInfs())
         KnownNotFromFlags |= fcInf;
     }
+  }
 
   if (Q.AC) {
     FPClassTest AssumedClasses = computeKnownFPClassFromAssumes(V, Q);
     KnownNotFromFlags |= ~AssumedClasses;
   }
 
   // We no longer need to find out about these bits from inputs if we can
   // assume this from flags/attributes.

llvm/unittests/Analysis/ValueTrackingTest.cpp

KnownFPClass UseInstrInfoNoNan =
                             nullptr, nullptr, nullptr, /*UseInstrInfo=*/true);
     EXPECT_EQ(fcPositive | fcNegZero | fcQNan,
               UseInstrInfoNoNan.KnownFPClasses);
     EXPECT_EQ(std::nullopt, UseInstrInfoNoNan.SignBit);
 
     KnownFPClass NoUseInstrInfoNoNan =
         computeKnownFPClass(A3, M->getDataLayout(), fcAllFlags, 0, nullptr,
                             nullptr, nullptr, nullptr, /*UseInstrInfo=*/false);
-    EXPECT_EQ(fcPositive | fcNegZero | fcQNan,
+    EXPECT_EQ(fcPositive | fcNegZero | fcNan,
               NoUseInstrInfoNoNan.KnownFPClasses);
     EXPECT_EQ(std::nullopt, NoUseInstrInfoNoNan.SignBit);
   }
 
   {
     KnownFPClass UseInstrInfoNSZNoNan =
         computeKnownFPClass(A4, M->getDataLayout(), fcAllFlags, 0, nullptr,
                             nullptr, nullptr, nullptr, /*UseInstrInfo=*/true);
     EXPECT_EQ(fcPositive | fcQNan, UseInstrInfoNSZNoNan.KnownFPClasses);
     EXPECT_EQ(false, UseInstrInfoNSZNoNan.SignBit);
 
     KnownFPClass NoUseInstrInfoNSZNoNan =
         computeKnownFPClass(A4, M->getDataLayout(), fcAllFlags, 0, nullptr,
                             nullptr, nullptr, nullptr, /*UseInstrInfo=*/false);
-    EXPECT_EQ(fcPositive | fcNegZero | fcQNan,
+    EXPECT_EQ(fcPositive | fcNegZero | fcNan,
               NoUseInstrInfoNSZNoNan.KnownFPClasses);
     EXPECT_EQ(std::nullopt, NoUseInstrInfoNSZNoNan.SignBit);
   }
 }
 
+/// Test that the UseInstrInfo parameter is respected.
+TEST_F(ComputeKnownFPClassTest, RespectIgnoreFlags) {
+  parseAssembly(
+      "declare float @func()\n"
+      "define float @test(i1 %cond, float %arg0, float %arg1) {\n"
+      "  %A = fadd nnan float %arg0, %arg1\n"
+      "  %A2 = fmul ninf float %arg0, %arg1\n"
+      "  %A3 = call nofpclass(inf nan) float @func()\n"
+      "  ret float %A\n"
+      "}\n");
+
+  {
+    KnownFPClass UseInstrInfoNoNaN =
+        computeKnownFPClass(A, M->getDataLayout(), fcAllFlags, 0, nullptr,
+                            nullptr, nullptr, nullptr, /*UseInstrInfo=*/true);
+    EXPECT_EQ(~fcNan, UseInstrInfoNoNaN.KnownFPClasses);
+    EXPECT_EQ(std::nullopt, UseInstrInfoNoNaN.SignBit);
+  }
+
+  {
+    KnownFPClass UseInstrInfoNoInf =
+        computeKnownFPClass(A2, M->getDataLayout(), fcAllFlags, 0, nullptr,
+                            nullptr, nullptr, nullptr, /*UseInstrInfo=*/true);
+    EXPECT_EQ(~fcInf, UseInstrInfoNoInf.KnownFPClasses);
+    EXPECT_EQ(std::nullopt, UseInstrInfoNoInf.SignBit);
+  }
+
+  {
+    KnownFPClass NoUseInstrInfoNoNaN =
+        computeKnownFPClass(A, M->getDataLayout(), fcAllFlags, 0, nullptr,
+                            nullptr, nullptr, nullptr, /*UseInstrInfo=*/false);
+    EXPECT_EQ(fcAllFlags, NoUseInstrInfoNoNaN.KnownFPClasses);
+    EXPECT_EQ(std::nullopt, NoUseInstrInfoNoNaN.SignBit);
+  }
+
+  {
+    KnownFPClass NoUseInstrInfoNoInf =
+        computeKnownFPClass(A2, M->getDataLayout(), fcAllFlags, 0, nullptr,
+                            nullptr, nullptr, nullptr, /*UseInstrInfo=*/false);
+    EXPECT_EQ(fcAllFlags, NoUseInstrInfoNoInf.KnownFPClasses);
+    EXPECT_EQ(std::nullopt, NoUseInstrInfoNoInf.SignBit);
+  }
+
+  {
+    KnownFPClass UseInstrUsesOther =
+        computeKnownFPClass(A3, M->getDataLayout(), fcAllFlags, 0, nullptr,
+                            nullptr, nullptr, nullptr, /*UseInstrInfo=*/true);
+    EXPECT_EQ(~(fcNan | fcInf), UseInstrUsesOther.KnownFPClasses);
+    EXPECT_EQ(std::nullopt, UseInstrUsesOther.SignBit);
+  }
+
+  // No looking at nofpclass attribute
+  {
+    KnownFPClass NoUseInstrUsesOther =
+        computeKnownFPClass(A3, M->getDataLayout(), fcAllFlags, 0, nullptr,
+                            nullptr, nullptr, nullptr, /*UseInstrInfo=*/false);
+    EXPECT_EQ(fcAllFlags, NoUseInstrUsesOther.KnownFPClasses);
+    EXPECT_EQ(std::nullopt, NoUseInstrUsesOther.SignBit);
+  }
+}
+
 TEST_F(ValueTrackingTest, isNonZeroRecurrence) {
   parseAssembly(R"(
     define i1 @test(i8 %n, i8 %r) {
     entry:
       br label %loop
     loop:
       %p = phi i8 [ -1, %entry ], [ %next, %loop ]
       %next = add nsw i8 %p, -1