[libc][NFC] Use cpp::optional for checking exceptional values of math functions.

[lntue]

Summary

Update the utility functions for checking exceptional values of math
functions to use cpp::optional return values.

[sivachandra]

libc/src/__support/FPUtil/except_value_utils.h

44

I want to suggest a rearrangement:

template <typename T, size_t N> struct ExceptValues {
  static_assert(cpp::is_floating_point_v<T>, "...");
  using UIntType = typename FPBits<T>::UIntType;
  struct Mapping { // This is the same as ExceptValueOutput from above with an additional field
    UIntType input;
    UIntType rnd_towardzero_result;
    ...
  };

  Mapping values[N];

  // You can choose to prevent implicit type promotions and convertions using enable_if
  constexpr cpp::optional<T> lookup(UIntType bits) const {
    ...
  }
  constexpr cpp::optional<T> lookup(T x) const {
    // Implement this method if required
  }
  constexpr cpp::optional<T> lookup_odd(UIntType bits) const {
    ...
  }
  constexpr cpp::optional<T> lookup_odd(T x) const (
    // Implement this method if required.
  }
};

libc/src/math/generic/cosf.cpp

114

Patterns like this should get simplified to:

if (auto r = COSF_EXCEPTS.lookup(x_abs); unlikely(r))
  return r;

[lntue]

Address comments.

[lntue]

libc/src/math/generic/cosf.cpp

114

I tried it but our current implementation of cpp::optional has no implicit conversion to T and the conversion to bool is explicit.

[sivachandra]

libc/src/math/generic/cosf.cpp

114

Ah yes! We should do *r but thats a nitty nit at this point.

libc/src/__support/FPUtil/CMakeLists.txt

 
 add_header_library(
   except_value_utils
   HDRS
     except_value_utils.h
   DEPENDS
     .fp_bits
     .fenv_impl
+    libc.src.__support.CPP.optional
 )
 
 
 add_header_library(
   hypot
   HDRS
     Hypot.h
   DEPENDS

libc/src/__support/FPUtil/except_value_utils.h

 //===-- Common header for helpers to set exceptional values -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_FPUTIL_EXCEPT_VALUE_UTILS_H
 #define LLVM_LIBC_SRC_SUPPORT_FPUTIL_EXCEPT_VALUE_UTILS_H
 
 #include "FEnvImpl.h"
 #include "FPBits.h"
+#include "src/__support/CPP/optional.h"
 
 namespace __llvm_libc {
 
 namespace fputil {
 
-template <typename T, int N> struct ExceptionalValues {
-  using UIntType = typename FPBits<T>::UIntType;
+// This file contains utility functions and classes to manage exceptional values
+// when there are many of them.
+//
+// Example usage:
+//
+// Define list of exceptional inputs and outputs:
+//   static constexpr int N = ...;  // Number of exceptional values.
+//   static constexpr fputil::ExceptValues<UIntType, N> Excepts {
+//     {  <list of input bits> },
+//     {  <list of output bits and offsets> }
+//   };
+//
+// Check for exceptional inputs:
+//   if (auto result = check_except_values<UIntType, N>(Excepts, x_bits);
+//       unlikely(result.has_value()))
+//     return result.value();
+
+template <typename T> struct ExceptValueOutput {
+  T rnd_towardzero_result;
+  T rnd_upward_offset;
+  T rnd_downward_offset;
+  T rnd_tonearest_offset;
+};
+
+template <typename T, int N> struct ExceptValues {
   static constexpr int SIZE = N;
   // Input bits.
-  UIntType inputs[SIZE];
-  // Output bits contains 4 values:
-  //   output[i][0]: output bits corresponding to FE_TOWARDZERO
-  //   output[i][1]: offset for FE_UPWARD
-  //   output[i][2]: offset for FE_DOWNWARD
-  //   output[i][3]: offset for FE_TONEAREST
-  UIntType outputs[SIZE][4];
+  T inputs[SIZE];
+  // Output bits.
+  ExceptValueOutput<T> outputs[SIZE];
 };
 
-template <typename T, int N> struct ExceptionChecker {
-  using UIntType = typename FPBits<T>::UIntType;
-  using FPBits = FPBits<T>;
-  using ExceptionalValues = ExceptionalValues<T, N>;
+template <typename T, int N, typename BitType = typename FPBits<T>::UIntType>
+cpp::optional<T> check_except_values(const ExceptValues<BitType, N> &ExceptVals,
+                                     BitType x_bits) {
+  for (int i = 0; i < N; ++i) {
+    if (unlikely(x_bits == ExceptVals.inputs[i])) {
+      BitType out_bits = ExceptVals.outputs[i].rnd_towardzero_result;
+      switch (fputil::get_round()) {
+      case FE_UPWARD:
+        out_bits += ExceptVals.outputs[i].rnd_upward_offset;
+        break;
+      case FE_DOWNWARD:
+        out_bits += ExceptVals.outputs[i].rnd_downward_offset;
+        break;
+      case FE_TONEAREST:
+        out_bits += ExceptVals.outputs[i].rnd_tonearest_offset;
+        break;
+      }
+      return FPBits<T>(out_bits).get_val();
+    }
+  }
+  return cpp::nullopt;
+}
 
-  static bool check_odd_func(const ExceptionalValues &ExceptVals,
-                             UIntType x_abs, bool sign, T &result) {
-    for (int i = 0; i < N; ++i) {
-      if (unlikely(x_abs == ExceptVals.inputs[i])) {
-        UIntType out_bits = ExceptVals.outputs[i][0]; // FE_TOWARDZERO
-        switch (fputil::get_round()) {
-        case FE_UPWARD:
-          out_bits +=
-              sign ? ExceptVals.outputs[i][2] : ExceptVals.outputs[i][1];
-          break;
-        case FE_DOWNWARD:
-          out_bits +=
-              sign ? ExceptVals.outputs[i][1] : ExceptVals.outputs[i][2];
-          break;
-        case FE_TONEAREST:
-          out_bits += ExceptVals.outputs[i][3];
-          break;
-        }
-        result = FPBits(out_bits).get_val();
-        if (sign)
-          result = -result;
+// Check exceptional values for odd functions: f(-x) = -f(x).
+template <typename T, int N, typename BitType = typename FPBits<T>::UIntType>
+cpp::optional<T>
+check_odd_func_except_values(const ExceptValues<BitType, N> &ExceptVals,
+                             BitType x_abs, bool sign) {
+      BitType out_bits = ExceptVals.outputs[i].rnd_towardzero_result;
+        out_bits += sign ? ExceptVals.outputs[i].rnd_downward_offset
+                         : ExceptVals.outputs[i].rnd_upward_offset;
+        out_bits += sign ? ExceptVals.outputs[i].rnd_upward_offset
+                         : ExceptVals.outputs[i].rnd_downward_offset;
+        out_bits += ExceptVals.outputs[i].rnd_tonearest_offset;
+      T result = FPBits<T>(out_bits).get_val();
 
-        return true;
-      }
-    }
-    return false;
-  }
-};
+      return result;
+  return cpp::nullopt;
 
 } // namespace fputil
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_EXCEPT_VALUE_UTILS_H

libc/src/math/generic/cosf.cpp

 #include "src/__support/FPUtil/multiply_add.h"
 #include "src/__support/common.h"
 
 #include <errno.h>
 
 namespace __llvm_libc {
 
 // Exceptional cases for cosf.
-static constexpr int COSF_EXCEPTS = 6;
+static constexpr int N_EXCEPTS = 6;
 
-static constexpr fputil::ExceptionalValues<float, COSF_EXCEPTS> CosfExcepts{
+static constexpr fputil::ExceptValues<uint32_t, N_EXCEPTS> COSF_EXCEPTS{
     /* inputs */ {
         0x55325019, // x = 0x1.64a032p43
         0x5922aa80, // x = 0x1.4555p51
         0x5aa4542c, // x = 0x1.48a858p54
         0x5f18b878, // x = 0x1.3170fp63
         0x6115cb11, // x = 0x1.2b9622p67
         0x7beef5ef, // x = 0x1.ddebdep120
     },
if (unlikely(x_abs < 0x3980'0000U)) {
     // emulated version of FMA.
 #if defined(LIBC_TARGET_HAS_FMA)
     return fputil::multiply_add(xbits.get_val(), -0x1.0p-25f, 1.0f);
 #else
     return static_cast<float>(fputil::multiply_add(xd, -0x1.0p-25, 1.0));
 #endif // LIBC_TARGET_HAS_FMA
   }
 
-  using ExceptChecker = typename fputil::ExceptionChecker<float, COSF_EXCEPTS>;
-  {
-    float result;
-    if (ExceptChecker::check_odd_func(CosfExcepts, x_abs, false, result))
-      return result;
-  }
+  if (auto r =
+          fputil::check_except_values<float, N_EXCEPTS>(COSF_EXCEPTS, x_abs);
+      unlikely(r.has_value()))
+    return r.value();
 
   // x is inf or nan.
   if (unlikely(x_abs >= 0x7f80'0000U)) {
     if (x_abs == 0x7f80'0000U) {
       errno = EDOM;
       fputil::set_except(FE_INVALID);
     }
     return x +

libc/src/math/generic/tanf.cpp

static constexpr double TAN_K_PI_OVER_32[32] = {
     -0x1.a5f59e90600ddp1,  -0x1.3504f333f9de6p1,  -0x1.def13b73c1406p0,
     -0x1.7f218e25a7461p0,  -0x1.37efd8d87607ep0,  -0x1.0000000000000p0,
     -0x1.a43002ae4285p-1,  -0x1.561b82ab7f99p-1,  -0x1.11ab7190834ecp-1,
     -0x1.a827999fcef32p-2, -0x1.36a08355c63dcp-2, -0x1.975f5e0553158p-3,
     -0x1.936bb8c5b2da2p-4, 0.0000000000000000,
 };
 
 // Exceptional cases for tanf.
-static constexpr int TANF_EXCEPTS = 6;
+static constexpr int N_EXCEPTS = 6;
 
-static constexpr fputil::ExceptionalValues<float, TANF_EXCEPTS> TanfExcepts{
+static constexpr fputil::ExceptValues<uint32_t, N_EXCEPTS> TANF_EXCEPTS{
     /* inputs */ {
         0x531d744c, // x = 0x1.3ae898p39
         0x57d7b0ed, // x = 0x1.af61dap48
         0x65ee8695, // x = 0x1.dd0d2ap76
         0x6798fe4f, // x = 0x1.31fc9ep80
         0x6ad36709, // x = 0x1.a6ce12p86
         0x72b505bb, // x = 0x1.6a0b76p102
     },
#endif // LIBC_TARGET_HAS_FMA
 
   // Perform the first step of range reduction: find k and y such that
   //   x = (k + y) * pi/32,
   //   where k is an integer, and |y| <= 0.5.
   if (likely(x_abs < FAST_PASS_BOUND)) {
     k = small_range_reduction(xd, y);
   } else {
 
-    using ExceptChecker =
-        typename fputil::ExceptionChecker<float, TANF_EXCEPTS>;
-    {
-      float result;
-      if (ExceptChecker::check_odd_func(TanfExcepts, x_abs, x_sign <= 0.0,
-                                        result))
-        return result;
-    }
+    if (auto r = fputil::check_odd_func_except_values<float, N_EXCEPTS>(
+            TANF_EXCEPTS, x_abs, x_sign <= 0.0);
+        unlikely(r.has_value()))
+      return r.value();
 
     fputil::FPBits<float> x_bits(x_abs);
     k = large_range_reduction(xd, x_bits.get_exponent(), y);
   }
 
   // Only care about the lowest 5 bits of k.
   k &= 31;
   // Adjust y if k >= 16.