APFloat: Add getExactLog2Abs

[arsenm]

Summary

Like the recently added getExactLog2 except ignore the sign bit.

[sepavloff]

llvm/include/llvm/ADT/APFloat.h

494–495

It looks like using std::optional<int> as return value can produce clearer interface, no?

[arsenm]

llvm/include/llvm/ADT/APFloat.h

494–495

It shouldn’t differ from the non-abs version. I also don’t think optional is any nicer here

[sepavloff]

LGTM.

llvm/include/llvm/ADT/APFloat.h

500

inline is excessive here, a member function defined in its class definition is inline (https://eel.is/c++draft/class.mfct#1).

[arsenm]

8a02fd3f94ff706c88cec14f1501cac6b6248162

llvm/include/llvm/ADT/APFloat.h

public:
   /// 1.01E-2              4             1       1.01E-2
   void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision = 0,
                 unsigned FormatMaxPadding = 3, bool TruncateZero = true) const;
 
   /// If this value has an exact multiplicative inverse, store it in inv and
   /// return true.
   bool getExactInverse(APFloat *inv) const;
 
+  // If this is an exact power of two, return the exponent while ignoring the
+  // sign bit. If it's not an exact power of 2, return INT_MIN
+  LLVM_READONLY
+  int getExactLog2Abs() const;
+
   // If this is an exact power of two, return the exponent. If it's not an exact
   // power of 2, return INT_MIN
   LLVM_READONLY
-  int getExactLog2() const;
+  inline int getExactLog2() const {
+    return isNegative() ? INT_MIN : getExactLog2Abs();
+  }
 
   /// Returns the exponent of the internal representation of the APFloat.
   ///
   /// 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
public:
 
   void toString(SmallVectorImpl<char> &Str, unsigned FormatPrecision,
                 unsigned FormatMaxPadding, bool TruncateZero = true) const;
 
   bool getExactInverse(APFloat *inv) const;
 
   LLVM_READONLY
   int getExactLog2() const;
+  LLVM_READONLY
+  int getExactLog2Abs() const;
 
   friend DoubleAPFloat scalbn(const DoubleAPFloat &X, int Exp, roundingMode);
   friend DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp, roundingMode);
   friend hash_code hash_value(const DoubleAPFloat &Arg);
 };
 
 hash_code hash_value(const DoubleAPFloat &Arg);
 
public:
   void print(raw_ostream &) const;
   void dump() const;
 
   bool getExactInverse(APFloat *inv) const {
     APFLOAT_DISPATCH_ON_SEMANTICS(getExactInverse(inv));
   }
 
   LLVM_READONLY
+  int getExactLog2Abs() const {
+    APFLOAT_DISPATCH_ON_SEMANTICS(getExactLog2Abs());
+  }
+
+  LLVM_READONLY
   int getExactLog2() const {
     APFLOAT_DISPATCH_ON_SEMANTICS(getExactLog2());
   }
 
   friend hash_code hash_value(const APFloat &Arg);
   friend int ilogb(const APFloat &Arg) { return ilogb(Arg.getIEEE()); }
   friend APFloat scalbn(APFloat X, int Exp, roundingMode RM);
   friend APFloat frexp(const APFloat &X, int &Exp, roundingMode RM);

llvm/lib/Support/APFloat.cpp

assert(reciprocal.isFiniteNonZero() &&
          reciprocal.significandLSB() == reciprocal.semantics->precision - 1);
 
   if (inv)
     *inv = APFloat(reciprocal, *semantics);
 
   return true;
 }
 
-int IEEEFloat::getExactLog2() const {
-  if (!isFinite() || isZero() || isNegative())
+int IEEEFloat::getExactLog2Abs() const {
+  if (!isFinite() || isZero())
     return INT_MIN;
 
   const integerPart *Parts = significandParts();
   const int PartCount = partCountForBits(semantics->precision);
 
   int PopCount = 0;
   for (int i = 0; i < PartCount; ++i) {
     PopCount += llvm::popcount(Parts[i]);
bool DoubleAPFloat::getExactInverse(APFloat *inv) const {
   return Ret;
 }
 
 int DoubleAPFloat::getExactLog2() const {
   // TODO: Implement me
   return INT_MIN;
 }
 
+int DoubleAPFloat::getExactLog2Abs() const {
+  // TODO: Implement me
+  return INT_MIN;
+}
+
 DoubleAPFloat scalbn(const DoubleAPFloat &Arg, int Exp,
                      APFloat::roundingMode RM) {
   assert(Arg.Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
   return DoubleAPFloat(semPPCDoubleDouble, scalbn(Arg.Floats[0], Exp, RM),
                        scalbn(Arg.Floats[1], Exp, RM));
 }
 
 DoubleAPFloat frexp(const DoubleAPFloat &Arg, int &Exp,

llvm/unittests/ADT/APFloatTest.cpp

for (unsigned I = 0; I != APFloat::S_MaxSemantics + 1; ++I) {
     auto SemEnum = static_cast<APFloat::Semantics>(I);
     const fltSemantics &Semantics = APFloat::EnumToSemantics(SemEnum);
 
     APFloat One(Semantics, "1.0");
 
     if (I == APFloat::S_PPCDoubleDouble) {
       // Not implemented
       EXPECT_EQ(INT_MIN, One.getExactLog2());
+      EXPECT_EQ(INT_MIN, One.getExactLog2Abs());
       continue;
     }
 
     int MinExp = APFloat::semanticsMinExponent(Semantics);
     int MaxExp = APFloat::semanticsMaxExponent(Semantics);
     int Precision = APFloat::semanticsPrecision(Semantics);
 
     EXPECT_EQ(0, One.getExactLog2());
     EXPECT_EQ(INT_MIN, APFloat(Semantics, "3.0").getExactLog2());
     EXPECT_EQ(INT_MIN, APFloat(Semantics, "-3.0").getExactLog2());
+    EXPECT_EQ(INT_MIN, APFloat(Semantics, "3.0").getExactLog2Abs());
+    EXPECT_EQ(INT_MIN, APFloat(Semantics, "-3.0").getExactLog2Abs());
     EXPECT_EQ(3, APFloat(Semantics, "8.0").getExactLog2());
     EXPECT_EQ(INT_MIN, APFloat(Semantics, "-8.0").getExactLog2());
-    EXPECT_EQ(INT_MIN, APFloat(Semantics, "-0.25").getExactLog2());
     EXPECT_EQ(-2, APFloat(Semantics, "0.25").getExactLog2());
+    EXPECT_EQ(-2, APFloat(Semantics, "0.25").getExactLog2Abs());
+    EXPECT_EQ(INT_MIN, APFloat(Semantics, "-0.25").getExactLog2());
+    EXPECT_EQ(-2, APFloat(Semantics, "-0.25").getExactLog2Abs());
+    EXPECT_EQ(3, APFloat(Semantics, "8.0").getExactLog2Abs());
+    EXPECT_EQ(3, APFloat(Semantics, "-8.0").getExactLog2Abs());
 
     EXPECT_EQ(INT_MIN, APFloat::getZero(Semantics, false).getExactLog2());
     EXPECT_EQ(INT_MIN, APFloat::getZero(Semantics, true).getExactLog2());
     EXPECT_EQ(INT_MIN, APFloat::getInf(Semantics).getExactLog2());
     EXPECT_EQ(INT_MIN, APFloat::getInf(Semantics, true).getExactLog2());
     EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, false).getExactLog2());
     EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, true).getExactLog2());
 
+    EXPECT_EQ(INT_MIN, APFloat::getZero(Semantics, false).getExactLog2Abs());
+    EXPECT_EQ(INT_MIN, APFloat::getZero(Semantics, true).getExactLog2Abs());
+    EXPECT_EQ(INT_MIN, APFloat::getInf(Semantics).getExactLog2Abs());
+    EXPECT_EQ(INT_MIN, APFloat::getInf(Semantics, true).getExactLog2Abs());
+    EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, false).getExactLog2Abs());
+    EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, true).getExactLog2Abs());
+
     EXPECT_EQ(INT_MIN,
               scalbn(One, MinExp - Precision - 1, APFloat::rmNearestTiesToEven)
                   .getExactLog2());
     EXPECT_EQ(INT_MIN,
               scalbn(One, MinExp - Precision, APFloat::rmNearestTiesToEven)
                   .getExactLog2());
 
     EXPECT_EQ(