APFloat: Fix signalling nans for scalbn

[scanon]

lib/Support/APFloat.cpp

3987

Long-term, it is likely better to have normalize quiet SNaN. Can you give that approach a try and see how much short-term fallout there would be? If it's too much of a mess, we can use your current approach instead.

[arsenm]

lib/Support/APFloat.cpp

3987

I tried doing this and expected the other places that do the same thing would happen to work out, but I get some APFloatTest failures. It's quite likely I added this to normalize incorrectly though

[scanon]

OK. Let's take this in as is, then, and someone can look at normalize( ) when they have time.

[arsenm]

r264219

lib/Support/APFloat.cpp

APFloat llvm::scalbn(APFloat X, int Exp, APFloat::roundingMode RoundingMode) {
   // the normalized exponent of half the smallest denormal.
 
   int SignificandBits = X.getSemantics().precision - 1;
   int MaxIncrement = MaxExp - (MinExp - SignificandBits) + 1;
 
   // Clamp to one past the range ends to let normalize handle overlflow.
   X.exponent += std::min(std::max(Exp, -MaxIncrement - 1), MaxIncrement);
   X.normalize(RoundingMode, lfExactlyZero);
+  if (X.isNaN())
+    X.makeQuiet();
   return X;
 }
 
 APFloat llvm::frexp(const APFloat &Val, int &Exp, APFloat::roundingMode RM) {
   Exp = ilogb(Val);
 
   // Quiet signalling nans.
   if (Exp == APFloat::IEK_NaN) {

unittests/ADT/APFloatTest.cpp

TEST(APFloatTest, scalbn) {
   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
 
   EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM)));
   EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM)));
   EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM)));
   EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM)));
   EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM)));
   EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM)));
-  EXPECT_TRUE(SNaN.bitwiseIsEqual(scalbn(SNaN, 0, RM)));
+  EXPECT_FALSE(scalbn(SNaN, 0, RM).isSignaling());
 
   EXPECT_TRUE(PInf.bitwiseIsEqual(
                 scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 128, RM)));
   EXPECT_TRUE(MInf.bitwiseIsEqual(
                 scalbn(APFloat(APFloat::IEEEsingle, "-0x1p+0"), 128, RM)));
   EXPECT_TRUE(PInf.bitwiseIsEqual(
                 scalbn(APFloat(APFloat::IEEEsingle, "0x1p+127"), 1, RM)));
   EXPECT_TRUE(PZero.bitwiseIsEqual(
EXPECT_TRUE(
     .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble, "0x1p+52"), -52, RM)));
 
   EXPECT_TRUE(
     APFloat(APFloat::IEEEdouble, "0x1p-103")
     .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble, "0x1p-51"), -52, RM)));
 
   APFloat ScalbnSNaN = scalbn(SNaN, 0, RM);
   EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling());
+
+  ScalbnSNaN = scalbn(SNaN, 1, RM);
+  EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling());
+
+
+  // Make sure highest bit of payload is preserved.
+  const APInt Payload(64, (UINT64_C(1) << 50) |
+                      (UINT64_C(1) << 49) |
+                      (UINT64_C(1234) << 32) |
+                      1);
+
+  APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble, false,
+                                             &Payload);
+  APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM);
+  EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling());
+  EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51));
 }
 
 TEST(APFloatTest, frexp) {
   const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
 
   APFloat PZero = APFloat::getZero(APFloat::IEEEdouble, false);
   APFloat MZero = APFloat::getZero(APFloat::IEEEdouble, true);
   APFloat One(1.0);