APFloat: Fix ilogb for denormals

[scanon]

lib/Support/APFloat.cpp

3959

Follow the IEEE terminology and use "significand" rather than "mantissa" (which is commonly used, but technically incorrect).

[arsenm]

Rename variable

[scanon]

Thanks.

[arsenm]

r263370

include/llvm/ADT/APFloat.h

public:
   ///
   /// Because the radix of APFloat is 2, this is equivalent to floor(log2(x)).
   /// For special APFloat values, this returns special error codes:
   ///
   ///   NaN -> \c IEK_NaN
   ///   0   -> \c IEK_Zero
   ///   Inf -> \c IEK_Inf
   ///
-  friend int ilogb(const APFloat &Arg) {
-    if (Arg.isNaN())
-      return IEK_NaN;
-    if (Arg.isZero())
-      return IEK_Zero;
-    if (Arg.isInfinity())
-      return IEK_Inf;
-
-    return Arg.exponent;
-  }
+  friend int ilogb(const APFloat &Arg);
 
   /// \brief Returns: X * 2^Exp for integral exponents.
   friend APFloat scalbn(APFloat X, int Exp, roundingMode);
 
 private:
 
   /// \name Simple Queries
   /// @{

lib/Support/APFloat.cpp

 void
 APFloat::makeZero(bool Negative) {
   category = fcZero;
   sign = Negative;
   exponent = semantics->minExponent-1;
   APInt::tcSet(significandParts(), 0, partCount());  
 }
 
+int llvm::ilogb(const APFloat &Arg) {
+  if (Arg.isNaN())
+    return APFloat::IEK_NaN;
+  if (Arg.isZero())
+    return APFloat::IEK_Zero;
+  if (Arg.isInfinity())
+    return APFloat::IEK_Inf;
+  if (!Arg.isDenormal())
+    return Arg.exponent;
+
+  APFloat Normalized(Arg);
+  int SignificandBits = Arg.getSemantics().precision - 1;
+
+  Normalized.exponent += SignificandBits;
+  Normalized.normalize(APFloat::rmNearestTiesToEven, lfExactlyZero);
+  return Normalized.exponent - SignificandBits;
+}
+
 APFloat llvm::scalbn(APFloat X, int Exp, APFloat::roundingMode RoundingMode) {
   auto MaxExp = X.getSemantics().maxExponent;
   auto MinExp = X.getSemantics().minExponent;
 
   // If Exp is wildly out-of-scale, simply adding it to X.exponent will
   // overflow; clamp it to a safe range before adding, but ensure that the range
   // is large enough that the clamp does not change the result. The range we
   // need to support is the difference between the largest possible exponent and

unittests/ADT/APFloatTest.cpp

TEST(APFloatTest, abs) {
   EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
   EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
   EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
   EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
   EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
 }
 
 TEST(APFloatTest, ilogb) {
+  EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble, false)));
+  EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble, true)));
+  EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble, "0x1.ffffffffffffep-1024")));
+  EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble, "0x1.ffffffffffffep-1023")));
+  EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble, "-0x1.ffffffffffffep-1023")));
+  EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble, "0x1p-51")));
+  EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble, "0x1.c60f120d9f87cp-1023")));
+  EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble, "0x0.ffffp-1")));
+  EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble, "0x1.fffep-1023")));
+  EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble, false)));
+  EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble, true)));
+
+
   EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle, "0x1p+0")));
   EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle, "-0x1p+0")));
   EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle, "0x1p+42")));
   EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle, "0x1p-42")));
 
   EXPECT_EQ(APFloat::IEK_Inf,
             ilogb(APFloat::getInf(APFloat::IEEEsingle, false)));
   EXPECT_EQ(APFloat::IEK_Inf,
             ilogb(APFloat::getInf(APFloat::IEEEsingle, true)));
   EXPECT_EQ(APFloat::IEK_Zero,
             ilogb(APFloat::getZero(APFloat::IEEEsingle, false)));
   EXPECT_EQ(APFloat::IEK_Zero,
             ilogb(APFloat::getZero(APFloat::IEEEsingle, true)));
   EXPECT_EQ(APFloat::IEK_NaN,
             ilogb(APFloat::getNaN(APFloat::IEEEsingle, false)));
   EXPECT_EQ(APFloat::IEK_NaN,
             ilogb(APFloat::getSNaN(APFloat::IEEEsingle, false)));
 
   EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle, false)));
   EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle, true)));
-  EXPECT_EQ(-126, ilogb(APFloat::getSmallest(APFloat::IEEEsingle, false)));
-  EXPECT_EQ(-126, ilogb(APFloat::getSmallest(APFloat::IEEEsingle, true)));
+
+  EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle, false)));
+  EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle, true)));
   EXPECT_EQ(-126,
             ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle, false)));
   EXPECT_EQ(-126,
             ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle, true)));
 }
 
 TEST(APFloatTest, scalbn) {