[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

42–45

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;
}

54

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?

57

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?

78

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

54

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

54

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.type_traits
     libc.src.__support.CPP.uint128

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"
+
+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::ExceptionalValues<float, N> Excepts {
+//     {  <list of input bits> },
+//     {  <list of output bits and offsets> }
+//   };
+//
+// Check for exceptional inputs:
+//   using ExceptChecker = typename fputil::ExceptionChecker<float, N>;
+//   if (float result; ExceptChecker::check(Excepts, x_bits, result))
+//     return result;
+
+template <typename T, int N> struct ExceptionalValues {
+  using UIntType = typename FPBits<T>::UIntType;
+  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];
+};
+
+template <typename T, int N> struct ExceptionChecker {
+  using UIntType = typename FPBits<T>::UIntType;
+  using FPBits = FPBits<T>;
+  using ExceptionalValues = ExceptionalValues<T, N>;
+
+  static bool check(const ExceptionalValues &ExceptionalValues, UIntType x_bits,
+                    T &result) {
+    for (int i = 0; i < N; ++i) {
+      if (unlikely(x_bits == ExceptVals.inputs[i])) {
+        UIntType out_bits = ExceptVals.outputs[i][0]; // FE_TOWARDZERO
+        switch (fputil::get_round()) {
+        case FE_UPWARD:
+          out_bits += ExceptVals.outputs[i][1];
+          break;
+        case FE_DOWNWARD:
+          out_bits += ExceptVals.outputs[i][2];
+          break;
+        case FE_TONEAREST:
+          out_bits += ExceptVals.outputs[i][3];
+          break;
+        }
+        result = FPBits(out_bits).get_val();
+
+        return true;
+      }
+    }
+    return false;
+  }
+
+  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;
+
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+} // 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",