- Address comment.

- Add trap on raise fp except option that will match glibc's behavior.
- Fix bazel build.

Author: lntue

libc/cmake/modules/LLVMLibCCompileOptionRules.cmake

@@ -116,6 +116,10 @@ function(_get_compile_options_from_config output_var)
     list(APPEND config_options "-DLIBC_THREAD_MODE=${LIBC_CONF_THREAD_MODE}")
   endif()
 
+  if(LIBC_CONF_TRAP_ON_RAISE_FP_EXCEPT)
+    list(APPEND config_options "-DLIBC_TRAP_ON_RAISE_FP_EXCEPT")
+  endif()
+
   set(${output_var} ${config_options} PARENT_SCOPE)
 endfunction(_get_compile_options_from_config)
 

libc/config/config.json

@@ -130,5 +130,11 @@
       "value": true,
       "doc": "Add nullptr checks in the library's implementations to some functions for which passing nullptr is undefined behavior."
     }
+  },
+  "fenv": {
+    "LIBC_CONF_TRAP_ON_RAISE_FP_EXCEPT": {
+      "value": false,
+      "doc": "Trap with SIGFPE when feraiseexcept is called with unmasked floating point exceptions, similar to glibc's behavior.  This is currently working only on x86 with SSE."
+    }
   }
 }

libc/docs/configure.rst

@@ -30,6 +30,8 @@ to learn about the defaults for your platform and target.
     - ``LIBC_CONF_KEEP_FRAME_POINTER``: Keep frame pointer in functions for better debugging experience.
 * **"errno" options**
     - ``LIBC_CONF_ERRNO_MODE``: The implementation used for errno, acceptable values are LIBC_ERRNO_MODE_DEFAULT, LIBC_ERRNO_MODE_UNDEFINED, LIBC_ERRNO_MODE_THREAD_LOCAL, LIBC_ERRNO_MODE_SHARED, LIBC_ERRNO_MODE_EXTERNAL, and LIBC_ERRNO_MODE_SYSTEM_INLINE.
+* **"fenv" options**
+    - ``LIBC_CONF_TRAP_ON_RAISE_FP_EXCEPT``: Trap with SIGFPE when feraiseexcept is called with unmasked floating point exceptions, similar to glibc's behavior.  This is currently working only on x86 with SSE.
 * **"general" options**
     - ``LIBC_ADD_NULL_CHECKS``: Add nullptr checks in the library's implementations to some functions for which passing nullptr is undefined behavior.
 * **"math" options**

libc/src/__support/FPUtil/CMakeLists.txt

@@ -7,6 +7,7 @@ add_header_library(
     libc.hdr.fenv_macros
     libc.hdr.math_macros
     libc.hdr.stdint_proxy
+    libc.src.__support.CPP.bit
     libc.src.__support.CPP.type_traits
     libc.src.__support.macros.attributes
     libc.src.errno.errno

libc/src/__support/FPUtil/x86_64/FEnvImpl.h

@@ -179,7 +179,7 @@ LIBC_INLINE static int get_env(fenv_t *env) {
   return 0;
 }
 
-LIBC_INLINE int set_env(const fenv_t *env) {
+LIBC_INLINE static int set_env(const fenv_t *env) {
   if (env == FE_DFL_ENV) {
 #ifndef LIBC_COMPILER_IS_MSVC
     x87::initialize_x87_state();

libc/src/__support/FPUtil/x86_64/fenv_mxcsr_utils.h

@@ -11,6 +11,7 @@
 
 #include "hdr/stdint_proxy.h"
 #include "hdr/types/fenv_t.h"
+#include "src/__support/CPP/bit.h"
 #include "src/__support/FPUtil/x86_64/fenv_x86_common.h"
 #include "src/__support/macros/attributes.h" // LIBC_INLINE
 #include "src/__support/macros/config.h"
@@ -85,6 +86,40 @@ LIBC_INLINE static void raise_except(uint16_t excepts) {
   uint32_t mxcsr = _MM_GET_EXCEPTION_STATE();
   mxcsr |= excepts;
   _MM_SET_EXCEPTION_STATE(mxcsr);
+#ifdef LIBC_TRAP_ON_RAISE_FP_EXCEPT
+  // We will try to trigger the SIGFPE if floating point exceptions are not
+  // masked.  Since we already set all the floating point exception flags, we
+  // only need to trigger the trap on one of them.
+  static constexpr float EXCEPTION_INPUTS[6][2] = {
+      // FE_INVALID: 0.0 * inf
+      {0.0f, cpp::bit_cast<float>(0x7f80'0000U)},
+      // FE_DENORM: 1.0 * 0x1.0p-128
+      {1.0f, 0x1.0p-128f},
+      // FE_DIVBYZERO: 1.0 / 0.0
+      {1.0f, 0.0f},
+      // FE_OVERFLOW: 0x1.0p127 * 0x1.0p127
+      {0x1.0p127f, 0x1.0p127f},
+      // FE_UNDERFLOW: 0x1.0p-126 * 0x1.0p-126
+      {0x1.0p-126f, 0x1.0p-126f},
+      // FE_INEXACT: (1 + 2^-12) * (1 + 2^-12)
+      {0x1.001p0f, 0x1.001p0f}};
+
+  uint32_t except_masks =
+      (~(get_mxcsr() >> ExceptionFlags::MXCSR_EXCEPTION_MASK_BIT_POSITION)) &
+      excepts;
+  if (except_masks) {
+    int idx = cpp::countr_zero(except_masks);
+    if (idx == 2) {
+      // FE_DIVBYZERO, we need floating point division operations.
+      [[maybe_unused]] volatile float z = EXCEPTION_INPUTS[idx][0];
+      z /= EXCEPTION_INPUTS[idx][1];
+    } else {
+      // For the remaining exceptions, we floating point multiplications.
+      [[maybe_unused]] volatile float z = EXCEPTION_INPUTS[idx][0];
+      z *= EXCEPTION_INPUTS[idx][1];
+    }
+  }
+#endif // LIBC_TRAP_ON_RAISE_FP_EXCEPT
 }
 
 LIBC_INLINE static uint16_t enable_except(uint16_t excepts) {

libc/src/__support/FPUtil/x86_64/fenv_x86_common.h

@@ -9,6 +9,8 @@
 #ifndef LLVM_LIBC_SRC___SUPPORT_FPUTIL_X86_64_FENV_X86_COMMON_H
 #define LLVM_LIBC_SRC___SUPPORT_FPUTIL_X86_64_FENV_X86_COMMON_H
 
+#include <stdbool.h>
+
 #include "hdr/stdint_proxy.h"
 #include "hdr/types/fenv_t.h"
 #include "src/__support/macros/attributes.h"
@@ -23,12 +25,12 @@ namespace fputil {
 namespace internal {
 
 // Default order of floating point exception flags in x87 and mxcsr registers:
-// - Bit 1: Invalid Operations
-// - Bit 2: Denormal
-// - Bit 3: Divide-by-zero
-// - Bit 4: Overflow
-// - Bit 5: Underflow
-// - Bit 6: Inexact
+// - Bit 0: Invalid Operations
+// - Bit 1: Denormal
+// - Bit 2: Divide-by-zero
+// - Bit 3: Overflow
+// - Bit 4: Underflow
+// - Bit 5: Inexact
 struct ExceptionFlags {
   static constexpr uint16_t INVALID_F = 0x1;
   // Some libcs define __FE_DENORM corresponding to the denormal input

libc/test/src/fenv/enabled_exceptions_test.cpp

@@ -26,21 +26,6 @@ using LlvmLibcExceptionStatusTest = LIBC_NAMESPACE::testing::FEnvSafeTest;
 // This test enables an exception and verifies that raising that exception
 // triggers SIGFPE.
 TEST_F(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
-#if defined(LIBC_TARGET_ARCH_IS_ANY_ARM) ||                                    \
-    defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
-  // Few Arm HW implementations do not trap exceptions. We skip this test
-  // completely on such HW.
-  //
-  // Whether HW supports trapping exceptions or not is deduced by enabling an
-  // exception and reading back to see if the exception got enabled. If the
-  // exception did not get enabled, then it means that the HW does not support
-  // trapping exceptions.
-  LIBC_NAMESPACE::fputil::disable_except(FE_ALL_EXCEPT);
-  LIBC_NAMESPACE::fputil::enable_except(FE_DIVBYZERO);
-  if (LIBC_NAMESPACE::fputil::get_except() == 0)
-    return;
-#endif // Architectures where exception trapping is not supported
-
   // TODO: Install a floating point exception handler and verify that the
   // the expected exception was raised. One will have to longjmp back from
   // that exception handler, so such a testing can be done after we have
@@ -61,6 +46,7 @@ TEST_F(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
       ASSERT_EQ(LIBC_NAMESPACE::fetestexcept(others), others);
     }
 
+#if defined(LIBC_TRAP_ON_RAISE_FP_EXCEPT) && defined(__SSE__)
     ASSERT_RAISES_FP_EXCEPT([=] {
       // In test frameworks like Fuchsia's zxtest, this translates to
       // a death test which runs this closure in a different thread. So,
@@ -69,6 +55,7 @@ TEST_F(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
       LIBC_NAMESPACE::fputil::enable_except(e);
       LIBC_NAMESPACE::feraiseexcept(e);
     });
+#endif // LIBC_TRAP_ON_RAISE_FP_EXCEPT
 
     // Cleanup.
     LIBC_NAMESPACE::fputil::disable_except(FE_ALL_EXCEPT);

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

@@ -1225,6 +1225,10 @@ libc_support_library(
     name = "__support_fputil_fenv_impl",
     hdrs = ["src/__support/FPUtil/FEnvImpl.h"],
     textual_hdrs = [
+        "src/__support/FPUtil/x86_64/fenv_mxcsr_utils.h",
+        "src/__support/FPUtil/x86_64/fenv_x86_common.h",
+        "src/__support/FPUtil/x86_64/fenv_x87_only.h",
+        "src/__support/FPUtil/x86_64/fenv_x87_utils.h",
         "src/__support/FPUtil/x86_64/FEnvImpl.h",
         "src/__support/FPUtil/aarch64/FEnvImpl.h",
         "src/__support/FPUtil/aarch64/fenv_darwin_impl.h",