[libc] Add FE_DFL_ENV and handle it in fesetenv.

[michaelrj]

LGTM

libc/config/linux/api.td

let Macros = [
     SimpleMacroDef<"FE_OVERFLOW", "8">,
     SimpleMacroDef<"FE_UNDERFLOW", "16">,
     SimpleMacroDef<"FE_ALL_EXCEPT", "(FE_DIVBYZERO|FE_INEXACT|FE_INVALID|FE_OVERFLOW|FE_UNDERFLOW)">,
 
     SimpleMacroDef<"FE_DOWNWARD", "1">,
     SimpleMacroDef<"FE_TONEAREST", "2">,
     SimpleMacroDef<"FE_TOWARDZERO", "4">,
     SimpleMacroDef<"FE_UPWARD", "8">,
+
+    SimpleMacroDef<"FE_DFL_ENV", "((fenv_t *)-1)">,
   ];
   let TypeDeclarations = [
     FEnvT,
     FExceptT,
   ];
 }
 
 def StringAPI : PublicAPI<"string.h"> {

libc/spec/stdc.td

HeaderSpec Fenv = HeaderSpec<
           Macro<"FE_INVALID">,
           Macro<"FE_OVERFLOW">,
           Macro<"FE_UNDERFLOW">,
           Macro<"FE_ALL_EXCEPT">,
 
           Macro<"FE_DOWNWARD">,
           Macro<"FE_TONEAREST">,
           Macro<"FE_TOWARDZERO">,
-          Macro<"FE_UPWARD">
+          Macro<"FE_UPWARD">,
+
+          Macro<"FE_DFL_ENV">
       ],
       [
           NamedType<"fenv_t">,
           NamedType<"fexcept_t">,
       ], // Types
       [], // Enumerations
       [
           FunctionSpec<

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

 namespace fputil {
 
 struct FEnv {
   struct FPState {
     uint32_t ControlWord;
     uint32_t StatusWord;
   };
 
   static_assert(
       sizeof(fenv_t) == sizeof(FPState),
       "Internal floating point state does not match the public fenv_t type.");
 
   static constexpr uint32_t ToNearest = 0x0;
   static constexpr uint32_t Upward = 0x1;
   static constexpr uint32_t Downward = 0x2;
   static constexpr uint32_t TowardZero = 0x3;
 
struct FEnv {
   static inline int exceptionStatusToMacro(uint32_t status) {
     return (status & Invalid ? FE_INVALID : 0) |
            (status & DivByZero ? FE_DIVBYZERO : 0) |
            (status & Overflow ? FE_OVERFLOW : 0) |
            (status & Underflow ? FE_UNDERFLOW : 0) |
            (status & Inexact ? FE_INEXACT : 0);
   }
 
   static uint32_t getControlWord() { return __arm_rsr("fpcr"); }
 
   static void writeControlWord(uint32_t fpcr) { __arm_wsr("fpcr", fpcr); }
 
   static uint32_t getStatusWord() { return __arm_rsr("fpsr"); }
 
   static void writeStatusWord(uint32_t fpsr) { __arm_wsr("fpsr", fpsr); }
 };
 
 static inline int enableExcept(int excepts) {
   uint32_t newExcepts = FEnv::getStatusValueForExcept(excepts);
   uint32_t controlWord = FEnv::getControlWord();
   int oldExcepts =

 static inline int getEnv(fenv_t *envp) {
   FEnv::FPState *state = reinterpret_cast<FEnv::FPState *>(envp);
   state->ControlWord = FEnv::getControlWord();
   state->StatusWord = FEnv::getStatusWord();
   return 0;
 }
 
 static inline int setEnv(const fenv_t *envp) {
+  if (envp == FE_DFL_ENV) {
+    // Default status and control words bits are all zeros so we just
+    // write zeros.
+    FEnv::writeStatusWord(0);
+    FEnv::writeControlWord(0);
+    return 0;
+  }
   const FEnv::FPState *state = reinterpret_cast<const FEnv::FPState *>(envp);
   FEnv::writeControlWord(state->ControlWord);
   FEnv::writeStatusWord(state->StatusWord);
   return 0;
 }
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_AARCH64_FENVIMPL_H

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

 static inline int getEnv(fenv_t *envp) {
   internal::FPState *state = reinterpret_cast<internal::FPState *>(envp);
   internal::getX87StateDescriptor(state->X87Status);
   state->MXCSR = internal::getMXCSR();
   return 0;
 }
 
 static inline int setEnv(const fenv_t *envp) {
-  const internal::FPState *state =
+  // envp contains everything including pieces like the current
+  // top of FPU stack. We cannot arbitrarily change them. So, we first
+  // read the current status and update only those pieces which are
+  // not disruptive.
+  internal::X87StateDescriptor x87Status;
+  internal::getX87StateDescriptor(x87Status);
+
+  if (envp == FE_DFL_ENV) {
+    // Reset the exception flags in the status word.
+    x87Status.StatusWord &= ~uint16_t(0x3F);
+    // Reset other non-sensitive parts of the status word.
+    for (int i = 0; i < 5; i++)
+      x87Status._[i] = 0;
+    // In the control word, we do the following:
+    // 1. Mask all exceptions
+    // 2. Set rounding mode to round-to-nearest
+    // 3. Set the internal precision to double extended precision.
+    x87Status.ControlWord |= uint16_t(0x3F);         // Mask all exceptions.
+    x87Status.ControlWord &= ~(uint16_t(0x3) << 10); // Round to nearest.
+    x87Status.ControlWord |= (uint16_t(0x3) << 8);   // Extended precision.
+    internal::writeX87StateDescriptor(x87Status);
+
+    // We take the exact same approach MXCSR register as well.
+    // MXCSR has two additional fields, "flush-to-zero" and
+    // "denormals-are-zero". We reset those bits. Also, MXCSR does not
+    // have a field which controls the precision of internal operations.
+    uint32_t mxcsr = internal::getMXCSR();
+    mxcsr &= ~uint16_t(0x3F);        // Clear exception flags.
+    mxcsr &= ~(uint16_t(0x1) << 6);  // Reset denormals-are-zero
+    mxcsr |= (uint16_t(0x3F) << 7);  // Mask exceptions
+    mxcsr &= ~(uint16_t(0x3) << 13); // Round to nearest.
+    mxcsr &= ~(uint16_t(0x1) << 15); // Reset flush-to-zero
+    internal::writeMXCSR(mxcsr);
+
+    return 0;
+  }
+
+  const internal::FPState *fpstate =
       reinterpret_cast<const internal::FPState *>(envp);
-  internal::writeX87StateDescriptor(state->X87Status);
-  internal::writeMXCSR(state->MXCSR);
+
+  // Copy the exception status flags from envp.
+  x87Status.StatusWord &= ~uint16_t(0x3F);
+  x87Status.StatusWord |= (fpstate->X87Status.StatusWord & 0x3F);
+  // Copy other non-sensitive parts of the status word.
+  for (int i = 0; i < 5; i++)
+    x87Status._[i] = fpstate->X87Status._[i];
+  // We can set the x87 control word as is as there no sensitive bits.
+  x87Status.ControlWord = fpstate->X87Status.ControlWord;
+  internal::writeX87StateDescriptor(x87Status);
+
+  // We can write the MXCSR state as is as there are no sensitive bits.
+  internal::writeMXCSR(fpstate->MXCSR);
   return 0;
 }
 #endif
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_X86_64_FENVIMPL_H

libc/test/src/fenv/CMakeLists.txt

 add_libc_unittest(
   getenv_and_setenv_test
   SUITE
     libc_fenv_unittests
   SRCS
     getenv_and_setenv_test.cpp
   DEPENDS
     libc.src.fenv.fegetenv
+    libc.src.fenv.fegetround
     libc.src.fenv.fesetenv
+    libc.src.fenv.fesetround
     libc.src.__support.FPUtil.fputil
 )
 
 add_libc_unittest(
   exception_flags_test
   SUITE
     libc_fenv_unittests
   SRCS

libc/test/src/fenv/getenv_and_setenv_test.cpp

 //===-- Unittests for fegetenv and fesetenv -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/fenv/fegetenv.h"
+#include "src/fenv/fegetround.h"
 #include "src/fenv/fesetenv.h"
+#include "src/fenv/fesetround.h"
 
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 
 TEST(LlvmLibcFenvTest, GetEnvAndSetEnv) {
   // We will disable all exceptions to prevent invocation of the exception
for (int e : excepts) {
     __llvm_libc::fputil::raiseExcept(e);
     // Make sure that the exception is raised.
     ASSERT_NE(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT) & e, 0);
 
     ASSERT_EQ(__llvm_libc::fesetenv(&env), 0);
     ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT) & e, 0);
   }
 }
+
+TEST(LlvmLibcFenvTest, Set_FE_DFL_ENV) {
+  // We will disable all exceptions to prevent invocation of the exception
+  // handler.
+  __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
+
+  int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
+                   FE_UNDERFLOW};
+
+  for (int e : excepts) {
+    __llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT);
+
+    // Save the cleared environment.
+    fenv_t env;
+    ASSERT_EQ(__llvm_libc::fegetenv(&env), 0);
+
+    __llvm_libc::fputil::raiseExcept(e);
+    // Make sure that the exception is raised.
+    ASSERT_NE(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT) & e, 0);
+
+    ASSERT_EQ(__llvm_libc::fesetenv(FE_DFL_ENV), 0);
+    // Setting the default env should clear all exceptions.
+    ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_ALL_EXCEPT) & e, 0);
+  }
+
+  ASSERT_EQ(__llvm_libc::fesetround(FE_DOWNWARD), 0);
+  ASSERT_EQ(__llvm_libc::fesetenv(FE_DFL_ENV), 0);
+  // Setting the default env should set rounding mode to FE_TONEAREST.
+  int rm = __llvm_libc::fegetround();
+  EXPECT_EQ(rm, FE_TONEAREST);
+}