fixup! [libc][math][c23] Add f16divf C23 math function

Fix and optimize exception signaling, and fix missing include.

Author: overmighty

libc/src/__support/FPUtil/CMakeLists.txt

@@ -199,6 +199,7 @@ add_header_library(
   HDRS
     dyadic_float.h
   DEPENDS
+    .fenv_impl
     .fp_bits
     .multiply_add
     libc.src.__support.CPP.type_traits

libc/src/__support/FPUtil/dyadic_float.h

@@ -9,6 +9,7 @@
 #ifndef LLVM_LIBC_SRC___SUPPORT_FPUTIL_DYADIC_FLOAT_H
 #define LLVM_LIBC_SRC___SUPPORT_FPUTIL_DYADIC_FLOAT_H
 
+#include "FEnvImpl.h"
 #include "FPBits.h"
 #include "multiply_add.h"
 #include "src/__support/CPP/type_traits.h"
@@ -86,11 +87,11 @@ template <size_t Bits> struct DyadicFloat {
 
   // Assume that it is already normalized.
   // Output is rounded correctly with respect to the current rounding mode.
-  template <typename T,
+  template <typename T, bool ShouldSignalExceptions,
             typename = cpp::enable_if_t<cpp::is_floating_point_v<T> &&
                                             (FPBits<T>::FRACTION_LEN < Bits),
                                         void>>
-  LIBC_INLINE explicit constexpr operator T() const {
+  LIBC_INLINE constexpr T as() const {
     if (LIBC_UNLIKELY(mantissa.is_zero()))
       return FPBits<T>::zero(sign).get_val();
 
@@ -110,7 +111,14 @@ template <size_t Bits> struct DyadicFloat {
       // volatile prevents constant propagation that would result in infinity
       // always being returned no matter the current rounding mode.
       volatile T two(2.0);
-      return two * d_hi;
+      T r = two * d_hi;
+
+      // TODO: Whether rounding down the absolute value to max_normal should
+      // also raise FE_OVERFLOW and set ERANGE is debatable.
+      if (ShouldSignalExceptions && FPBits<T>(r).is_inf())
+        set_errno_if_required(ERANGE);
+
+      return r;
     }
 
     bool denorm = false;
@@ -192,8 +200,10 @@ template <size_t Bits> struct DyadicFloat {
         // "tininess" before or after rounding for base-2 formats, as long as
         // the same choice is made for all operations. Our choice to check after
         // rounding might not be the same as the hardware's.
-        if (round_and_sticky)
+        if (ShouldSignalExceptions && round_and_sticky) {
+          set_errno_if_required(ERANGE);
           raise_except_if_required(FE_UNDERFLOW);
+        }
       }
 
       return FPBits<T>(r_bits).get_val();
@@ -202,6 +212,14 @@ template <size_t Bits> struct DyadicFloat {
     return r;
   }
 
+  template <typename T,
+            typename = cpp::enable_if_t<cpp::is_floating_point_v<T> &&
+                                            (FPBits<T>::FRACTION_LEN < Bits),
+                                        void>>
+  LIBC_INLINE explicit constexpr operator T() const {
+    return as<T, /*ShouldSignalExceptions=*/false>();
+  }
+
   LIBC_INLINE explicit constexpr operator MantissaType() const {
     if (mantissa.is_zero())
       return 0;

libc/src/__support/FPUtil/generic/div.h

@@ -116,12 +116,7 @@ div(InType x, InType y) {
   DyadicFloat result(result_sign, result_exp, q);
   result.mantissa += r != 0;
 
-  OutType output = static_cast<OutType>(result);
-
-  if (test_except(FE_OVERFLOW | FE_UNDERFLOW) != 0)
-    set_errno_if_required(ERANGE);
-
-  return output;
+  return result.template as<OutType, /*ShouldSignalExceptions=*/true>();
 }
 
 } // namespace LIBC_NAMESPACE::fputil::generic

libc/test/src/math/smoke/DivTest.h

@@ -107,11 +107,9 @@ class DivTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
     if (ForceRoundingMode r(RoundingMode::TowardZero); r.success) {
       EXPECT_FP_EQ_WITH_EXCEPTION(max_normal, func(max_normal, min_normal),
                                   FE_OVERFLOW | FE_INEXACT);
-      EXPECT_MATH_ERRNO(ERANGE);
       EXPECT_FP_EQ_WITH_EXCEPTION(neg_max_normal,
                                   func(neg_max_normal, min_denormal),
                                   FE_OVERFLOW | FE_INEXACT);
-      EXPECT_MATH_ERRNO(ERANGE);
 
       EXPECT_FP_EQ_WITH_EXCEPTION(zero, func(min_denormal, max_normal),
                                   FE_UNDERFLOW | FE_INEXACT);
@@ -124,7 +122,6 @@ class DivTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
     if (ForceRoundingMode r(RoundingMode::Downward); r.success) {
       EXPECT_FP_EQ_WITH_EXCEPTION(max_normal, func(max_normal, min_normal),
                                   FE_OVERFLOW | FE_INEXACT);
-      EXPECT_MATH_ERRNO(ERANGE);
       EXPECT_FP_EQ_WITH_EXCEPTION(-inf, func(neg_max_normal, min_denormal),
                                   FE_OVERFLOW | FE_INEXACT);
       EXPECT_MATH_ERRNO(ERANGE);
@@ -145,7 +142,6 @@ class DivTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
       EXPECT_FP_EQ_WITH_EXCEPTION(neg_max_normal,
                                   func(neg_max_normal, min_denormal),
                                   FE_OVERFLOW | FE_INEXACT);
-      EXPECT_MATH_ERRNO(ERANGE);
 
       EXPECT_FP_EQ_WITH_EXCEPTION(min_denormal, func(min_denormal, max_normal),
                                   FE_UNDERFLOW | FE_INEXACT);