[Clang] Support constexpr builtin ilogb

[Izaron]

Summary

Support constexpr version of __builtin_ilogb and its variations.

[Izaron]

This patch is similar to __bultin_fmax: https://reviews.llvm.org/D134369

The constexpr version of ilogb matches the libc realization, this is verified with the same tests:
https://github.com/llvm/llvm-project/blob/main/libc/test/src/math/ILogbTest.h

test_special_numbers -> ILOGB_TEST_SPECIAL_NUMBERS
test_powers_of_two -> ILOGB_TEST_POWERS_OF_TWO
test_some_integers -> ILOGB_TEST_SOME_INTEGERS

https://eel.is/c++draft/library.c#3 says that a floating-point exception other than FE_INEXACT causes it to not be a constant expression.
I check it with small ilog function refactoring and the new function isConstantOpStatus.

The online documentation (https://en.cppreference.com/w/cpp/numeric/math/ilogb) says:

1. If the correct result is greater than INT_MAX or smaller than INT_MIN, FE_INVALID is raised.
2. If arg is ±0, ±∞, or NaN, FE_INVALID is raised.
3. In all other cases, the result is exact (FE_INEXACT is never raised) and the current rounding mode is ignored

The first point seemingly never occur, because llvm's ilogb return type is int.
The second point is handled as expected (APFloatTest.cpp checks it)

[jcranmer-intel]

In D136568#3878104, @Izaron wrote:

The online documentation (https://en.cppreference.com/w/cpp/numeric/math/ilogb) says:

1. If the correct result is greater than INT_MAX or smaller than INT_MIN, FE_INVALID is raised.
2. If arg is ±0, ±∞, or NaN, FE_INVALID is raised.
3. In all other cases, the result is exact (FE_INEXACT is never raised) and the current rounding mode is ignored

The first point seemingly never occur, because llvm's ilogb return type is int.
The second point is handled as expected (APFloatTest.cpp checks it)

FWIW, I would be slightly wary of relying on cppreference as definitive for niche semantic issues like this, although it is correct in this case. C2x is actually pretty well-organized in Annex F, and enumerates most of the corner cases specifically in every function.

clang/lib/AST/ExprConstant.cpp

12452

long double is ppc_fp128 on at least some PPC targets, and while I'm not entirely certain of what ilogb properly returns in the corner cases of the ppc_fp128, I'm not entirely confident that the implementation of APFloat is correct in those cases. I'd like someone with PPC background to comment in here.

clang/test/Sema/constant-builtins-ilogb.cpp

14

Test of smallest subnormal and largest finite number would also be useful.

[aaron.ballman]

In D136568#3880711, @jcranmer-intel wrote:

FWIW, I would be slightly wary of relying on cppreference as definitive for niche semantic issues like this, although it is correct in this case. C2x is actually pretty well-organized in Annex F, and enumerates most of the corner cases specifically in every function.

+1 to this point; the edge cases are pretty tricky and the standard is the source of truth for how we should be implementing this stuff.

clang/lib/AST/ExprConstant.cpp

12452

Paging @hubert.reinterpretcast for help finding a good person to comment on the PPC questions.

llvm/include/llvm/ADT/APFloat.h

450–454

Is this part of the comment still accurate?

[Izaron]

clang/lib/AST/ExprConstant.cpp

12452

@jcranmer-intel constexpr evaluation is quite machine-/target-independent. Clang evaluates it based on its internal representation of float variables.

int ilogb uses Arg.getIEEE(), that returns Clang's internal float representation.

Whichever float semantics is being used, minExponent and maxExponent are representable as APFloatBase::ExponentType, which is int32_t:

/// A signed type to represent a floating point numbers unbiased exponent.
typedef int32_t ExponentType;

We already use int ilogb in some constexpr evaluation code: link, it is working correct because it is working on Clang's float representations.

[jcranmer-intel]

clang/lib/AST/ExprConstant.cpp

12452

We already use int ilogb in some constexpr evaluation code: link, it is working correct because it is working on Clang's float representations.

APFloat::getIEEE(), if I'm following it correctly, only returns the details of the high double in ppc_fp128 floats, and I'm not sufficiently well-versed in the ppc_fp128 format to establish whether or not the low double comes into play here. glibc seems to think that the low double comes into play in at least one case: https://github.com/bminor/glibc/blob/30891f35fa7da832b66d80d0807610df361851f3/sysdeps/ieee754/ldbl-128ibm/e_ilogbl.c

[Izaron]

Add test for min/max value. Fix comment for ilog.

[Izaron]

clang/lib/AST/ExprConstant.cpp

12452

Thanks for the link to the glibc code! It helped me to understand the IEEE754 standard better.

I did some research and it seems like AST supports a fixed set of float types, each working good with ilogb:

half (__fp16, only for OpenCL), float16, float, double, long double, float128

link to SemaExpr.cpp

It means that the constant evaluator doesn't deal with other float types including ppc_fp128.
If ppc_fp128 was supported on the AST level, it would anyway come through type casting, and __builtin_ilog<SUFFIX> would deal with a value of a known type.

I checked the list of builtins - each builtin argument of float type also supports only common float types:
link to Builtins.def 1
link to Builtins.def 2

[Izaron]

Deal with MSVC where sizeof(long double) == sizeof(double)

[majnemer]

clang/lib/AST/ExprConstant.cpp

12452

Won't long double map to ppc_fp128 for some targets?

[Izaron]

clang/lib/AST/ExprConstant.cpp

12452

Hi! It will map, but only after all the constant (constexpr) calculations are done (that is, after the AST parsing stage) - in the Codegen stage.

The Clang's constant evaluator itself never deals with ppc_fp128 and doesn't care about the target.
While parsing the AST, the constant evaluator works on the same level with it, providing calculated values to the AST being built on-the-fly. At the moment AST is built, constant evaluation is over.
The evaluator is target-independent and uses the internal representation for long double, in the form of emulated 80-bit (x86) format.

The Codegen can map the AST's long double to ppc_fp128 on some targets.
It doesn't cause problems because x87 80-bit float is convertible to ppc_fp128 without precision loss.
But the constexpr long double values itself were calculated using the Clang's 80-bit format emulation, before the Codegen stage.

I'm sorry if I'm not describing it clearly. It's important to me that everyone understands what the trick is =)
So, the constant evaluator does everything with 80-bit floats and at the end they can be mapped on ppc_fp128 floats if the target requires it.

[hubert.reinterpretcast]

clang/lib/AST/ExprConstant.cpp

12452

That's kind-of terrible, but at least that means that what ilogb can do within the scope of this patch is very clear.
I am surprised to find that ilogb({2, -0x1p-64}) seems to return 1 on ppc64le Linux.

[hubert.reinterpretcast]

clang/lib/AST/ExprConstant.cpp

12452

Of course I should have used ilogbl...
So, yes, ilogbl({2, -0x1p-64}) returns 0 on ppc64le Linux.

[hubert.reinterpretcast]

clang/lib/AST/ExprConstant.cpp

12452

@Izaron,

The evaluator is target-independent and uses the internal representation for long double, in the form of emulated 80-bit (x86) format.

This the internal representation still 80-bit for platforms where long double uses the IEEE binary 128-bit format?

[Izaron]

clang/lib/AST/ExprConstant.cpp

12452

ilogbl({2, -0x1p-64}) returns 0 on ppc64le Linux.

How did you use ilogbl? I built local Clang with PowerPC support, this worked fine to me:

static_assert(__builtin_ilogbl(-0x1p-64) == -64);
static_assert(__builtin_ilogbl(-0x1p-1074L) == -1074);
// smaller exponents (< -1074) don't work, too small number

I would be glad for any example where constant ilogb would work incorrectly but runtime ilogb correctly. Unfortunately I can't make up such number because I navigate not so good enough in IEEE754 corner cases =(

This the internal representation still 80-bit for platforms where long double uses the IEEE binary 128-bit format?

I just checked with the debugger, the -target ppc64le parameter actually makes the constant evaluator use internal 128-bit format for long double. Yeah, this contradicts to some points what I wrote earlier... =(

[jcranmer-intel]

clang/test/Sema/constant-builtins-ilogb.cpp

53–63

You can simplify at least the float, double, and especially long double tests using something like this:

static_assert(__builtin_ilogbf(__FLT_MIN__) == __FLT_MIN_EXP__ + 1);
static_assert(__builtin_ilogbf(__FLT_MAX__) == __FLT_MAX_EXP__ - 1);

[hubert.reinterpretcast]

clang/lib/AST/ExprConstant.cpp

12452

I would be glad for any example where constant ilogb would work incorrectly but runtime ilogb correctly. Unfortunately I can't make up such number because I navigate not so good enough in IEEE754 corner cases =(

By ilogbl({2, -0x1p-64}), I meant ilogbl(2.L + -0x1p-64). The answer I got at runtime is 0 (which is what I expected). It seems the ilogbl implementation at compile time does not return 0 though.

Here, I try the largest number in the format that is smaller than 2:

$ cat ilogb.cc
#include <math.h>
#include <stdio.h>

constexpr int comptime = __builtin_ilogbl(2.L - __DBL_DENORM_MIN__);
constinit volatile long double rtinput = 2.L - __DBL_DENORM_MIN__;
int runtime;
int main(void) {
  runtime = ilogbl(rtinput);
  printf("comptime(%d)\nruntime(%d)\n", comptime, runtime);
}

$ clang++ -target powerpc64le-unknown-linux-gnu -std=c++20 ilogb.cc && ./a.out
comptime(1)
runtime(0)

clang/test/Sema/constant-builtins-ilogb.cpp

1

There seems to be no C language test in the patch (although the builtin presumably is okay at least as part of arithmetic constant expressions).

@aaron.ballman, what are your thoughts re: integer constant expression contexts? For example:

struct C { int x : __builtin_ilogb(1. + 1.); };

60

This test also fails for PPC double-double (which does not increase the range of exponents).

With C++, it is presumably possible for you to verify using predefined floating point constants with platform-specific values, e.g., __FLT_DENORM_MIN__, and checking the answer by dividing or multiplying the number by 2 (or more generally, the base) in a constexpr function repeatedly.

[aaron.ballman]

clang/test/Sema/constant-builtins-ilogb.cpp

1

WG14 adopted https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2713.htm for C2x to clarify that implementations are not allowed to extend what they consider to be an integer constant expression. The operand in this case is a function call expression, which is not one of the permissible things in an ICE, so the standard doesn't want us to make it one.

I believe that Clang's response to that paper is to implement it to the letter rather than to the intent. e.g., issue a warning that a constant expression is being folded into an ICE but otherwise accept the code. We have too many situations already in which we fold a constant expression to an ICE and changing that behavior would be observable (and a performance regression). So I think it's fine for us to treat the builtin call as an ICE so long as we issue a (pedantic) warning about folding it.

(FWIW, I don't think it qualifies as an arithmetic constant expression because that also doesn't allow function call expressions. But we can extend the definition of an arithmetic constant expression.)

[hubert.reinterpretcast]

clang/test/Sema/constant-builtins-ilogb.cpp

1

Thanks Aaron. I think a C language test for this patch may be a good way to explore the extension space (and any pedantic conformance diagnostics).

Particular to the example above and ICEs is that the argument involves floating-point operations. Would the desired model be that the call is considered a literal for the purposes of the language requirements?

It seems that built-ins that are accepted in constant expressions in C are a more general issue though (and I am not sure if, for this patch, we defer the issue for some general approach that would take care of the class of problems as a whole).

[aaron.ballman]

clang/test/Sema/constant-builtins-ilogb.cpp

1

Thanks Aaron. I think a C language test for this patch may be a good way to explore the extension space (and any pedantic conformance diagnostics).

+1, especially because C2x has support for constexpr object definitions (which we've not implemented in Clang yet).

Particular to the example above and ICEs is that the argument involves floating-point operations. Would the desired model be that the call is considered a literal for the purposes of the language requirements?

I think that model makes the most sense to me. If we can compute the correct answer at compile time, it seems a bit silly to defer until runtime just because the builtin looks like a function call expression.

It seems that built-ins that are accepted in constant expressions in C are a more general issue though (and I am not sure if, for this patch, we defer the issue for some general approach that would take care of the class of problems as a whole).

Yeah, I think it is a more general issue with builtins in C (and how we handle constant expression evaluation in C). I don't think this patch will make the problem significantly *worse*, so I think I'd be fine not addressing the specific concern for this builtin in this patch. But it would probably make a lot of sense for us to fix up the builtin situation before converting a ton of math library functions to builtins since all of those are going to have the same class of concern.

clang/docs/LanguageExtensions.rst

 * ``__builtin_ctzll``
 * ``__builtin_ctzs``
 * ``__builtin_ffs``
 * ``__builtin_ffsl``
 * ``__builtin_ffsll``
 * ``__builtin_fmax``
 * ``__builtin_fmin``
 * ``__builtin_fpclassify``
+* ``__builtin_ilogb``
 * ``__builtin_inf``
 * ``__builtin_isinf``
 * ``__builtin_isinf_sign``
 * ``__builtin_isfinite``
 * ``__builtin_isnan``
 * ``__builtin_isnormal``
 * ``__builtin_nan``
 * ``__builtin_nans``

clang/include/clang/Basic/Builtins.def

 BUILTIN(__builtin_fminf, "fff", "FncE")
 BUILTIN(__builtin_fminf16, "hhh", "FncE")
 BUILTIN(__builtin_fminl, "LdLdLd", "FncE")
 BUILTIN(__builtin_fminf128, "LLdLLdLLd", "FncE")
 BUILTIN(__builtin_hypot , "ddd"  , "Fne")
 BUILTIN(__builtin_hypotf, "fff"  , "Fne")
 BUILTIN(__builtin_hypotl, "LdLdLd", "Fne")
 BUILTIN(__builtin_hypotf128, "LLdLLdLLd", "Fne")
-BUILTIN(__builtin_ilogb , "id", "Fne")
-BUILTIN(__builtin_ilogbf, "if", "Fne")
-BUILTIN(__builtin_ilogbl, "iLd", "Fne")
-BUILTIN(__builtin_ilogbf128, "iLLd", "Fne")
+BUILTIN(__builtin_ilogb , "id", "FneE")
+BUILTIN(__builtin_ilogbf, "if", "FneE")
+BUILTIN(__builtin_ilogbl, "iLd", "FneE")
+BUILTIN(__builtin_ilogbf128, "iLLd", "FneE")
 BUILTIN(__builtin_lgamma , "dd", "Fn")
 BUILTIN(__builtin_lgammaf, "ff", "Fn")
 BUILTIN(__builtin_lgammal, "LdLd", "Fn")
 BUILTIN(__builtin_lgammaf128, "LLdLLd", "Fn")
 BUILTIN(__builtin_llrint, "LLid", "Fne")
 BUILTIN(__builtin_llrintf, "LLif", "Fne")
 BUILTIN(__builtin_llrintl, "LLiLd", "Fne")
 BUILTIN(__builtin_llrintf128, "LLiLLd", "Fne")

clang/lib/AST/ExprConstant.cpp

Optional<APValue> MaybeDestValue =
       BufferToAPValueConverter::convert(Info, *Buffer, BCE);
   if (!MaybeDestValue)
     return false;
 
   DestValue = std::move(*MaybeDestValue);
   return true;
 }
 
+// A call to a C standard library function is a non-constant library call
+// ([defns.nonconst.libcall]) if it raises a floating-point exception other
+// than FE_INEXACT.
+static bool isConstantOpStatus(APFloat::opStatus St) {
+  return (St & ~APFloat::opInexact) == 0;
+}
+
 template <class Derived>
 class ExprEvaluatorBase
   : public ConstStmtVisitor<Derived, bool> {
 private:
   Derived &getDerived() { return static_cast<Derived&>(*this); }
   bool DerivedSuccess(const APValue &V, const Expr *E) {
     return getDerived().Success(V, E);
   }
if (BuiltinOp == Builtin::BI__builtin_add_overflow ||
       Result = Temp;
     }
 
     APValue APV{Result};
     if (!handleAssignment(Info, E, ResultLValue, ResultType, APV))
       return false;
     return Success(DidOverflow, E);
   }
+  case Builtin::BI__builtin_ilogb:
+  case Builtin::BI__builtin_ilogbf:
+  case Builtin::BI__builtin_ilogbl:
+  case Builtin::BI__builtin_ilogbf128: {
+    APFloat F(0.0);
+    if (!EvaluateFloat(E->getArg(0), F, Info))
+      return false;
+
+    int Ilogb;
+    if (APFloat::opStatus St = ilogb(F, Ilogb); !isConstantOpStatus(St))
+      return false;
+
+    APSInt Logb(llvm::APInt(32, Ilogb, /*isSigned=*/true),
+                /*isUnsigned=*/false);
+    Result = APValue(std::move(Logb));
+    return true;
+  }
   }
 }
 
 /// Determine whether this is a pointer past the end of the complete
 /// object referred to by the lvalue.
 static bool isOnePastTheEndOfCompleteObject(const ASTContext &Ctx,
                                             const LValue &LV) {
   // A null pointer can be viewed as being "past the end" but we don't

clang/test/Sema/constant-builtins-ilogb.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// expected-no-diagnostics
+
+constexpr double NaN = __builtin_nan("");
+constexpr double Inf = __builtin_inf();
+constexpr double NegInf = -__builtin_inf();
+
+#define ILOGB_TEST_SPECIAL_NUMBERS(T, FUNC)                \
+    static_assert(!__builtin_constant_p(FUNC(T(0.0))));    \
+    static_assert(!__builtin_constant_p(FUNC(T(-0.0))));   \
+    static_assert(!__builtin_constant_p(FUNC(T(NaN))));    \
+    static_assert(!__builtin_constant_p(FUNC(T(Inf))));    \
+    static_assert(!__builtin_constant_p(FUNC(T(NegInf))));
+
+#define ILOGB_TEST_POWERS_OF_TWO(T, FUNC) \
+    static_assert(0 == FUNC(T(1.0)));     \
+    static_assert(0 == FUNC(T(-1.0)));    \
+    static_assert(1 == FUNC(T(2.0)));     \
+    static_assert(1 == FUNC(T(-2.0)));    \
+    static_assert(2 == FUNC(T(4.0)));     \
+    static_assert(2 == FUNC(T(-4.0)));    \
+    static_assert(3 == FUNC(T(8.0)));     \
+    static_assert(3 == FUNC(T(-8.0)));    \
+    static_assert(4 == FUNC(T(16.0)));    \
+    static_assert(4 == FUNC(T(-16.0)));   \
+    static_assert(5 == FUNC(T(32.0)));    \
+    static_assert(5 == FUNC(T(-32.0)));
+
+#define ILOGB_TEST_SOME_INTEGERS(T, FUNC) \
+    static_assert(1 == FUNC(T(3.0)));     \
+    static_assert(1 == FUNC(T(-3.0)));    \
+    static_assert(2 == FUNC(T(7.0)));     \
+    static_assert(2 == FUNC(T(-7.0)));    \
+    static_assert(3 == FUNC(T(10.0)));    \
+    static_assert(3 == FUNC(T(-10.0)));   \
+    static_assert(4 == FUNC(T(31.0)));    \
+    static_assert(4 == FUNC(T(-31.0)));   \
+    static_assert(5 == FUNC(T(55.0)));    \
+    static_assert(5 == FUNC(T(-55.0)));
+
+#define LIST_ILOGB_TESTS(T, FUNC)       \
+    ILOGB_TEST_SPECIAL_NUMBERS(T, FUNC) \
+    ILOGB_TEST_POWERS_OF_TWO(T, FUNC)   \
+    ILOGB_TEST_SOME_INTEGERS(T, FUNC)
+
+LIST_ILOGB_TESTS(double, __builtin_ilogb)
+LIST_ILOGB_TESTS(float, __builtin_ilogbf)
+LIST_ILOGB_TESTS((long double), __builtin_ilogbl)
+#ifdef __FLOAT128__
+LIST_ILOGB_TESTS(__float128, __builtin_ilogbf128)
+#endif
+
+// assert smallest subnormal and largest finite numbers
+static_assert(__builtin_ilogbf(1.40129846E-45f) == -149);
+static_assert(__builtin_ilogbf(3.40282347E+38f) == 127);
+
+static_assert(__builtin_ilogb(4.9406564584124654E-324) == -1074);
+static_assert(__builtin_ilogb(1.7976931348623157E+308) == 1023);
+
+#if !defined(_WIN32) && !defined(_WIN64) // in MSVC sizeof(long double) == sizeof(double)
+static_assert(__builtin_ilogbl(3.64519953188247460253E-4951L) == -16445);
+static_assert(__builtin_ilogbl(1.18973149535723176502E+4932L) == 16383);
+#endif
+
+#ifdef __FLOAT128__
+static_assert(__builtin_ilogbf128(6.47517511943802511092443895822764655E-4966Q) == -16494);
+static_assert(__builtin_ilogbf128(1.18973149535723176508575932662800702E+4932Q) == 16383);
+#endif

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;
 
-  /// Returns the exponent of the internal representation of the APFloat.
+  /// Calculates the exponent of the internal representation of the APFloat
+  /// and saves the result in `Result`.
   ///
   /// Because the radix of APFloat is 2, this is equivalent to floor(log2(x)).
-  /// For special APFloat values, this returns special error codes:
+  /// For special APFloat values, this saves special error codes to `Result`:
   ///
   ///   NaN -> \c IEK_NaN
   ///   0   -> \c IEK_Zero
   ///   Inf -> \c IEK_Inf
   ///
-  friend int ilogb(const IEEEFloat &Arg);
+  /// and returns `opInvalidOp`. Returns `opOK` for other values.
+  ///
+  friend opStatus ilogb(const IEEEFloat &Arg, int &Result);
 
   /// Returns: X * 2^Exp for integral exponents.
   friend IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode);
 
   friend IEEEFloat frexp(const IEEEFloat &X, int &Exp, roundingMode);
 
   /// \name Special value setters.
   /// @{
private:
   /// Using the extra bit keeps it from failing under VisualStudio.
   fltCategory category : 3;
 
   /// Sign bit of the number.
   unsigned int sign : 1;
 };
 
 hash_code hash_value(const IEEEFloat &Arg);
+IEEEFloat::opStatus ilogb(const IEEEFloat &Arg, int &Result);
 int ilogb(const IEEEFloat &Arg);
 IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode);
 IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM);
 
 // This mode implements more precise float in terms of two APFloats.
 // The interface and layout is designed for arbitrary underlying semantics,
 // though currently only PPCDoubleDouble semantics are supported, whose
 // corresponding underlying semantics are IEEEdouble.
public:
   void print(raw_ostream &) const;
   void dump() const;
 
   bool getExactInverse(APFloat *inv) const {
     APFLOAT_DISPATCH_ON_SEMANTICS(getExactInverse(inv));
   }
 
   friend hash_code hash_value(const APFloat &Arg);
+  friend opStatus ilogb(const APFloat &Arg, int &Result) {
+    return ilogb(Arg.getIEEE(), Result);
+  }
   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);
   friend IEEEFloat;
   friend DoubleAPFloat;
 };
 
 /// See friend declarations above.

llvm/lib/Support/APFloat.cpp

void IEEEFloat::makeZero(bool Negative) {
   APInt::tcSet(significandParts(), 0, partCount());
 }
 
 void IEEEFloat::makeQuiet() {
   assert(isNaN());
   APInt::tcSetBit(significandParts(), semantics->precision - 2);
 }
 
-int ilogb(const IEEEFloat &Arg) {
-  if (Arg.isNaN())
-    return IEEEFloat::IEK_NaN;
-  if (Arg.isZero())
-    return IEEEFloat::IEK_Zero;
-  if (Arg.isInfinity())
-    return IEEEFloat::IEK_Inf;
-  if (!Arg.isDenormal())
-    return Arg.exponent;
+IEEEFloat::opStatus ilogb(const IEEEFloat &Arg, int &Result) {
+  if (Arg.isNaN()) {
+    Result = IEEEFloat::IEK_NaN;
+    return IEEEFloat::opInvalidOp;
+  }
+  if (Arg.isZero()) {
+    Result = IEEEFloat::IEK_Zero;
+    return IEEEFloat::opInvalidOp;
+  }
+  if (Arg.isInfinity()) {
+    Result = IEEEFloat::IEK_Inf;
+    return IEEEFloat::opInvalidOp;
+  }
+  if (!Arg.isDenormal()) {
+    Result = Arg.exponent;
+    return IEEEFloat::opOK;
+  }
 
   IEEEFloat Normalized(Arg);
   int SignificandBits = Arg.getSemantics().precision - 1;
 
   Normalized.exponent += SignificandBits;
   Normalized.normalize(IEEEFloat::rmNearestTiesToEven, lfExactlyZero);
-  return Normalized.exponent - SignificandBits;
+  Result = Normalized.exponent - SignificandBits;
+  return IEEEFloat::opOK;
+}
+
+int ilogb(const IEEEFloat &Arg) {
+  int Result;
+  ilogb(Arg, Result);
+  return Result;
 }
 
 IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::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

llvm/unittests/ADT/APFloatTest.cpp

TEST(APFloatTest, neg) {
   EXPECT_TRUE(Inf.bitwiseIsEqual(-NegInf));
   EXPECT_TRUE(NegInf.bitwiseIsEqual(-Inf));
   EXPECT_TRUE(Inf.bitwiseIsEqual(-NegInf));
   EXPECT_TRUE(NegQNaN.bitwiseIsEqual(-QNaN));
   EXPECT_TRUE(QNaN.bitwiseIsEqual(-NegQNaN));
 }
 
 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(-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)));
+  int Result;
+
+  EXPECT_EQ(ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), false), Result),
+            APFloat::opOK);
+  EXPECT_EQ(-1074, Result);
+  EXPECT_EQ(ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), true), Result),
+            APFloat::opOK);
+  EXPECT_EQ(-1074, Result);
+  EXPECT_EQ(
+      ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1024"), Result),
+      APFloat::opOK);
+  EXPECT_EQ(-1023, Result);
+  EXPECT_EQ(
+      ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023"), Result),
+      APFloat::opOK);
+  EXPECT_EQ(-1023, Result);
+  EXPECT_EQ(
+      ilogb(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023"), Result),
+      APFloat::opOK);
+  EXPECT_EQ(-1023, Result);
+  EXPECT_EQ(ilogb(APFloat(APFloat::IEEEdouble(), "0x1p-51"), Result),
+            APFloat::opOK);
+  EXPECT_EQ(-51, Result);
+  EXPECT_EQ(
+      ilogb(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1023"), Result),
+      APFloat::opOK);
+  EXPECT_EQ(-1023, Result);
+  EXPECT_EQ(ilogb(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"), Result),
+            APFloat::opOK);
+  EXPECT_EQ(-2, Result);
+  EXPECT_EQ(ilogb(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1023"), Result),
+            APFloat::opOK);
+  EXPECT_EQ(-1023, Result);
+  EXPECT_EQ(ilogb(APFloat::getLargest(APFloat::IEEEdouble(), false), Result),
+            APFloat::opOK);
+  EXPECT_EQ(1023, Result);
+  EXPECT_EQ(ilogb(APFloat::getLargest(APFloat::IEEEdouble(), true), Result),
+            APFloat::opOK);
+  EXPECT_EQ(1023, Result);
+
+  EXPECT_EQ(ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+0"), Result),
+            APFloat::opOK);
+  EXPECT_EQ(0, Result);
+  EXPECT_EQ(ilogb(APFloat(APFloat::IEEEsingle(), "-0x1p+0"), Result),
+            APFloat::opOK);
+  EXPECT_EQ(0, Result);
+  EXPECT_EQ(ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+42"), Result),
+            APFloat::opOK);
+  EXPECT_EQ(42, Result);
+  EXPECT_EQ(ilogb(APFloat(APFloat::IEEEsingle(), "0x1p-42"), Result),
+            APFloat::opOK);
+  EXPECT_EQ(-42, Result);
+
+  EXPECT_EQ(ilogb(APFloat::getInf(APFloat::IEEEsingle(), false), Result),
+            APFloat::opInvalidOp);
+  EXPECT_EQ(APFloat::IEK_Inf, Result);
+  EXPECT_EQ(ilogb(APFloat::getInf(APFloat::IEEEsingle(), true), Result),
+            APFloat::opInvalidOp);
+  EXPECT_EQ(APFloat::IEK_Inf, Result);
+  EXPECT_EQ(ilogb(APFloat::getZero(APFloat::IEEEsingle(), false), Result),
+            APFloat::opInvalidOp);
+  EXPECT_EQ(APFloat::IEK_Zero, Result);
+  EXPECT_EQ(ilogb(APFloat::getZero(APFloat::IEEEsingle(), true), Result),
+            APFloat::opInvalidOp);
+  EXPECT_EQ(APFloat::IEK_Zero, Result);
+  EXPECT_EQ(ilogb(APFloat::getNaN(APFloat::IEEEsingle(), false), Result),
+            APFloat::opInvalidOp);
+  EXPECT_EQ(APFloat::IEK_NaN, Result);
+  EXPECT_EQ(ilogb(APFloat::getSNaN(APFloat::IEEEsingle(), false), Result),
+            APFloat::opInvalidOp);
+  EXPECT_EQ(APFloat::IEK_NaN, Result);
+
+  EXPECT_EQ(ilogb(APFloat::getLargest(APFloat::IEEEsingle(), false), Result),
+            APFloat::opOK);
+  EXPECT_EQ(127, Result);
+  EXPECT_EQ(ilogb(APFloat::getLargest(APFloat::IEEEsingle(), true), Result),
+            APFloat::opOK);
+  EXPECT_EQ(127, Result);
+
+  EXPECT_EQ(ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), false), Result),
+            APFloat::opOK);
+  EXPECT_EQ(-149, Result);
+  EXPECT_EQ(ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), true), Result),
+            APFloat::opOK);
+  EXPECT_EQ(-149, Result);
+  EXPECT_EQ(ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false),
+                  Result),
+            APFloat::opOK);
+  EXPECT_EQ(-126, Result);
+  EXPECT_EQ(ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true),
+                  Result),
+            APFloat::opOK);
+  EXPECT_EQ(-126, Result);
 }
 
 TEST(APFloatTest, scalbn) {
 
   const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
   EXPECT_TRUE(
       APFloat(APFloat::IEEEsingle(), "0x1p+0")
       .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 0, RM)));