[libc] Add utility classes for checking exceptional values.

[lntue]

Summary

This is refactored from https://reviews.llvm.org/D123154.

[sivachandra]

libc/src/__support/FPUtil/except_value_utils.h

20

Can you please add documentation about the need and how to use this class?

41

What is x_abs here?

[lntue]

Address comments.

[lntue]

Update comments.

[lntue]

libc/src/__support/FPUtil/except_value_utils.h

41

Oops, copy-paste error! Fixed.

[sivachandra]

libc/src/__support/FPUtil/except_value_utils.h

43–46

May be use a struct?

template <typename T> struct ExceptValueOuput {
  T rnd_towardzero_result;
  T rnd_upward_offset;
  T rnd_downward_offset;
  T rnd_nearest_offset;
}

55

Because of the name like check, I was thinking this is a test utility. May be call it expect_value_output or something like that?

Also, @jeffbailey is working on an equivalent of std::optional: https://reviews.llvm.org/D129920. It seems like using it here would be appropriate?

Lastly, does it have to be a static method - can it not be a non-static method? Then, you can name the method just get_output?

58

I still see typos and improper naming conventions - for example, I think you want to using ExceptionalValues here and not ExceptValues? Which makes wonder if this is being sufficiently tested? If not in use, just remove it?

79

Can you add documentation about this method so that it is clear as to why it there at all?

[lntue]

Use cpp::Optional from https://reviews.llvm.org/D129920 as return type.

[lntue]

libc/src/__support/FPUtil/except_value_utils.h

55

I updated the patch to use cpp::Optional from @jeffbailey patch https://reviews.llvm.org/D129920, and change these to standalone methods.

[jeffbailey]

libc/src/__support/FPUtil/except_value_utils.h

55

Since the interface is from the C++ standard and I know the thing works based on our tz variable parsing tests, I could commit what I have in that patch and then do the changes that I want to do for better conformance in a follow-up patch.

libc/src/__support/FPUtil/CMakeLists.txt

 #TODO(michaelrj): separate the fputil library into individual targets.
 add_header_library(
   fputil
   HDRS
     FEnvImpl.h
     BasicOperations.h
     DivisionAndRemainderOperations.h
     FloatProperties.h
     FPBits.h
     BasicOperations.h
     ManipulationFunctions.h
     NearestIntegerOperations.h
     NormalFloat.h
     PlatformDefs.h
     builtin_wrappers.h
+    except_value_utils.h
   DEPENDS
     libc.include.math
     libc.include.errno
     libc.include.fenv
     libc.src.__support.common
     libc.src.__support.CPP.bit
+    libc.src.__support.CPP.optional
     libc.src.__support.CPP.type_traits
     libc.src.__support.CPP.uint128
     libc.src.errno.errno
 )
 
 add_header_library(
   xfloat
   HDRS

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 {
+
+// 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<float, N> Excepts {
+//     {  <list of input bits> },
+//     {  <list of output bits and offsets> }
+//   };
+//
+// Check for exceptional inputs:
+//   if (auto result = check_except_values<float, 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 {
+  using UIntType = typename FPBits<T>::UIntType;
+  static constexpr int SIZE = N;
+  // Input bits.
+  UIntType inputs[SIZE];
+  ExceptValueOutput<UIntType> outputs[SIZE];
+};
+
+template <typename T, int N>
+cpp::Optional<T> check_except_values(const ExceptValues<T, N> &ExceptVals,
+                                     typename FPBits<T>::UIntType x_bits) {
+  using UIntType = typename FPBits<T>::UIntType;
+  for (int i = 0; i < N; ++i) {
+    if (unlikely(x_bits == ExceptVals.inputs[i])) {
+      UIntType 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;
+}
+
+// Check exceptional values for odd functions: f(-x) = -f(x).
+template <typename T, int N>
+cpp::Optional<T>
+check_odd_func_except_values(const ExceptValues<T, N> &ExceptVals,
+                             typename FPBits<T>::UIntType x_abs, bool sign) {
+  using UIntType = typename FPBits<T>::UIntType;
+  for (int i = 0; i < N; ++i) {
+    if (unlikely(x_abs == ExceptVals.inputs[i])) {
+      UIntType out_bits = ExceptVals.outputs[i].rnd_towardzero_result;
+      switch (fputil::get_round()) {
+      case FE_UPWARD:
+        out_bits += sign ? ExceptVals.outputs[i].rnd_downward_offset
+                         : ExceptVals.outputs[i].rnd_upward_offset;
+        break;
+      case FE_DOWNWARD:
+        out_bits += sign ? ExceptVals.outputs[i].rnd_upward_offset
+                         : ExceptVals.outputs[i].rnd_downward_offset;
+        break;
+      case FE_TONEAREST:
+        out_bits += ExceptVals.outputs[i].rnd_tonearest_offset;
+        break;
+      }
+      result = FPBits<T>(out_bits).get_val();
+      if (sign)
+        result = -result;
+
+      return result;
+    }
+  }
+  return cpp::Nullopt;
+}
+
+} // namespace fputil
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_EXCEPT_VALUE_UTILS_H

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

fputil_common_hdrs = [
     "src/__support/FPUtil/FPBits.h",
     "src/__support/FPUtil/FloatProperties.h",
     "src/__support/FPUtil/Hypot.h",
     "src/__support/FPUtil/ManipulationFunctions.h",
     "src/__support/FPUtil/NearestIntegerOperations.h",
     "src/__support/FPUtil/NormalFloat.h",
     "src/__support/FPUtil/PlatformDefs.h",
     "src/__support/FPUtil/builtin_wrappers.h",
+    "src/__support/FPUtil/except_value_utils.h",
 ]
 
 fputil_hdrs = selects.with_or({
     "//conditions:default": fputil_common_hdrs,
     PLATFORM_CPU_X86_64: fputil_common_hdrs + [
         "src/__support/FPUtil/x86_64/LongDoubleBits.h",
         "src/__support/FPUtil/x86_64/NextAfterLongDouble.h",
         "src/__support/FPUtil/x86_64/FEnvImpl.h",