[libc] Rename FEnv.h and refactor subsequent files

[hedingarcia]

Summary

Because Windows's pathnames are not case sensitive,
to avoid include conflicts between our header file FEnv.h and the
one from the C Standard library, <fenv.h>, the prior file was renamed.
The motive for the relabel came to fix this include error in
TestHelpers.cpp since a conflict arose with a file in the same
directory when #include <fenv.h> was being used.

[sivachandra]

I think you should update CMakeLists.txt to reflect this renaming. Also, can you rename DummyFEnv.h to DummyFEnvImpl.h.

[hedingarcia]

[libc] Updated CMakeLists.txt and renamed DummyFEnv.h

[sivachandra]

libc/utils/FPUtil/CMakeLists.txt

8 ↗

(On Diff #360589)

FEnvImpl.h?

[hedingarcia]

[libc] Made a fix to CMakeLists.txt

libc/src/fenv/feclearexcept.cpp

 //===-- Implementation of feclearexcept function --------------------------===//
 //
 // 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/feclearexcept.h"
 #include "src/__support/common.h"
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, feclearexcept, (int e)) {
   return fputil::clearExcept(e);
 }
 
 } // namespace __llvm_libc

libc/src/fenv/fegetenv.cpp

 //===-- Implementation of fegetenv function -----------------------------===//
 //
 // 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/__support/common.h"
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fegetenv, (fenv_t * envp)) {
   return fputil::getEnv(envp);
 }
 
 } // namespace __llvm_libc

libc/src/fenv/fegetexceptflag.cpp

 //===-- Implementation of fegetexceptflag function ------------------------===//
 //
 // 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/fegetexceptflag.h"
 #include "src/__support/common.h"
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 
 #include <fenv.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fegetexceptflag, (fexcept_t * flagp, int excepts)) {
   // TODO: Add a compile time check to see if the excepts actually fit in flagp.
   *flagp = static_cast<fexcept_t>(fputil::testExcept(FE_ALL_EXCEPT) & excepts);
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/fenv/fegetround.cpp

 //===-- Implementation of fegetround function -----------------------------===//
 //
 // 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/fegetround.h"
 #include "src/__support/common.h"
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fegetround, ()) { return fputil::getRound(); }
 
 } // namespace __llvm_libc

libc/src/fenv/feholdexcept.cpp

 //===-- Implementation of feholdexcept function ---------------------------===//
 //
 // 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/feholdexcept.h"
 #include "src/__support/common.h"
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 
 #include <fenv.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, feholdexcept, (fenv_t * envp)) {
   if (fputil::getEnv(envp) != 0)
     return -1;
   fputil::clearExcept(FE_ALL_EXCEPT);
   fputil::disableExcept(FE_ALL_EXCEPT);
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/fenv/feraiseexcept.cpp

 //===-- Implementation of feraiseexcept function --------------------------===//
 //
 // 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/feraiseexcept.h"
 #include "src/__support/common.h"
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, feraiseexcept, (int e)) {
   return fputil::raiseExcept(e);
 }
 
 } // namespace __llvm_libc

libc/src/fenv/fesetenv.cpp

 //===-- Implementation of fesetenv function -----------------------------===//
 //
 // 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/fesetenv.h"
 #include "src/__support/common.h"
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fesetenv, (const fenv_t *envp)) {
   return fputil::setEnv(envp);
 }
 
 } // namespace __llvm_libc

libc/src/fenv/fesetexceptflag.cpp

 //===-- Implementation of fesetexceptflag function ------------------------===//
 //
 // 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/fesetexceptflag.h"
 #include "src/__support/common.h"
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 
 #include <fenv.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fesetexceptflag,
                    (const fexcept_t *flagp, int excepts)) {
   // Since the return type of fetestexcept is int, we ensure that fexcept_t

libc/src/fenv/fesetround.cpp

 //===-- Implementation of fesetround function -----------------------------===//
 //
 // 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/fesetround.h"
 #include "src/__support/common.h"
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fesetround, (int m)) { return fputil::setRound(m); }
 
 } // namespace __llvm_libc

libc/src/fenv/fetestexcept.cpp

 //===-- Implementation of fetestexcept function ---------------------------===//
 //
 // 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/fetestexcept.h"
 #include "src/__support/common.h"
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fetestexcept, (int e)) { return fputil::testExcept(e); }
 
 } // namespace __llvm_libc

libc/src/fenv/feupdateenv.cpp

 //===-- Implementation of feupdateenv function ----------------------------===//
 //
 // 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/feupdateenv.h"
 #include "src/__support/common.h"
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 
 #include <fenv.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, feupdateenv, (const fenv_t *envp)) {
   int current_excepts = fputil::testExcept(FE_ALL_EXCEPT);
   if (fputil::setEnv(envp) != 0)
     return -1;
   return fputil::raiseExcept(current_excepts);
 }
 
 } // namespace __llvm_libc

libc/test/src/fenv/enabled_exceptions_test.cpp

 //===-- Unittests for feraiseexcept with exceptions enabled ---------------===//
 //
 // 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/feclearexcept.h"
 #include "src/fenv/feraiseexcept.h"
 #include "src/fenv/fetestexcept.h"
 
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 #include <signal.h>
 
 // This test enables an exception and verifies that raising that exception
 // triggers SIGFPE.

libc/test/src/fenv/exception_flags_test.cpp

 //===-- Unittests for fegetexceptflag and fesetexceptflag -----------------===//
 //
 // 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/fegetexceptflag.h"
 #include "src/fenv/fesetexceptflag.h"
 
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 
 TEST(LlvmLibcFenvTest, GetExceptFlagAndSetExceptFlag) {
   // We will disable all exceptions to prevent invocation of the exception
   // handler.
   __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);

libc/test/src/fenv/exception_status_test.cpp

 //===-- Unittests for feclearexcept, feraiseexcept and fetestexpect -------===//
 //
 // 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/feclearexcept.h"
 #include "src/fenv/feraiseexcept.h"
 #include "src/fenv/fetestexcept.h"
 
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 
 TEST(LlvmLibcExceptionStatusTest, RaiseAndTest) {
   // This test raises a set of exceptions and checks that the exception
   // status flags are updated. The intention is really not to invoke the
   // exception handler. Hence, we will disable all exceptions at the

libc/test/src/fenv/feclearexcept_test.cpp

 //===-- Unittests for feclearexcept with exceptions enabled ---------------===//
 //
 // 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/feclearexcept.h"
 
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 #include <stdint.h>
 
 TEST(LlvmLibcFEnvTest, ClearTest) {
   uint16_t excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                         FE_UNDERFLOW};

libc/test/src/fenv/feholdexcept_test.cpp

 //===-- Unittests for feholdexcept with exceptions enabled ----------------===//
 //
 // 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/feholdexcept.h"
 
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 
 TEST(LlvmLibcFEnvTest, RaiseAndCrash) {
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};

libc/test/src/fenv/feupdateenv_test.cpp

 //===-- Unittests for feupdateenv -----------------------------------------===//
 //
 // 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/feupdateenv.h"
 
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 #include <signal.h>
 
 TEST(LlvmLibcFEnvTest, UpdateEnvTest) {
   __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
   __llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT);
 
   fenv_t env;
   ASSERT_EQ(__llvm_libc::fputil::getEnv(&env), 0);
   __llvm_libc::fputil::setExcept(FE_INVALID | FE_INEXACT);
   ASSERT_EQ(__llvm_libc::feupdateenv(&env), 0);
   ASSERT_EQ(__llvm_libc::fputil::testExcept(FE_INVALID | FE_INEXACT),
             FE_INVALID | FE_INEXACT);
 }

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/fesetenv.h"
 
-#include "utils/FPUtil/FEnv.h"
+#include "utils/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
   // handler.
   __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);

libc/test/src/math/RIntTest.h

 //===-- Utility class to test different flavors of rint ---------*- 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_TEST_SRC_MATH_RINTTEST_H
 #define LLVM_LIBC_TEST_SRC_MATH_RINTTEST_H
 
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 #include "utils/FPUtil/FPBits.h"
 #include "utils/FPUtil/TestHelpers.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 #include <math.h>
 #include <stdio.h>

libc/test/src/math/RoundToIntegerTest.h

 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/Test.h"
 
 #include <math.h>
 #if math_errhandling & MATH_ERRNO
 #include <errno.h>
 #endif
 #if math_errhandling & MATH_ERREXCEPT
-#include "utils/FPUtil/FEnv.h"
+#include "utils/FPUtil/FEnvUtils.h"
 #endif
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 static constexpr int roundingModes[4] = {FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO,
                                          FE_TONEAREST};
 
 template <typename F, typename I, bool TestModes = false>

libc/utils/FPUtil/FEnvUtils.h

 //===-- Utilities for manipulating floating point environment ---*- 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_UTILS_FPUTIL_FENV_H
 #define LLVM_LIBC_UTILS_FPUTIL_FENV_H
 
 #ifdef __x86_64__
-#include "x86_64/FEnv.h"
+#include "x86_64/FEnvImpl.h"
 #elif defined(__aarch64__)
-#include "aarch64/FEnv.h"
+#include "aarch64/FEnvImpl.h"
 #else
 #include "DummyFEnv.h"
 #endif
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_FP_BITS_H

libc/utils/FPUtil/NearestIntegerOperations.h

 //===-- Nearest integer floating-point operations ---------------*- 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_UTILS_FPUTIL_NEAREST_INTEGER_OPERATIONS_H
 #define LLVM_LIBC_UTILS_FPUTIL_NEAREST_INTEGER_OPERATIONS_H
 
-#include "FEnv.h"
+#include "FEnvUtils.h"
 #include "FPBits.h"
 
 #include "utils/CPP/TypeTraits.h"
 
 #include <math.h>
 #if math_errhandling & MATH_ERRNO
 #include <errno.h>
 #endif

libc/utils/FPUtil/aarch64/FEnvImpl.h

 //===-- aarch64 floating point env manipulation functions -------*- 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_UTILS_FPUTIL_AARCH64_FENV_H
 #define LLVM_LIBC_UTILS_FPUTIL_AARCH64_FENV_H
 
 #include <arm_acle.h>
 #include <fenv.h>
 #include <stdint.h>
 
 #include "utils/FPUtil/FPBits.h"
 
 namespace __llvm_libc {
 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;
 
   static constexpr uint32_t Invalid = 0x1;
   static constexpr uint32_t DivByZero = 0x2;
   static constexpr uint32_t Overflow = 0x4;
   static constexpr uint32_t Underflow = 0x8;
   static constexpr uint32_t Inexact = 0x10;
 
   // Zero-th bit is the first bit.
   static constexpr uint32_t RoundingControlBitPosition = 22;
   static constexpr uint32_t ExceptionStatusFlagsBitPosition = 0;
   static constexpr uint32_t ExceptionControlFlagsBitPosition = 8;
 
   static inline uint32_t getStatusValueForExcept(int excepts) {
     return (excepts & FE_INVALID ? Invalid : 0) |
            (excepts & FE_DIVBYZERO ? DivByZero : 0) |
            (excepts & FE_OVERFLOW ? Overflow : 0) |
            (excepts & FE_UNDERFLOW ? Underflow : 0) |
            (excepts & FE_INEXACT ? Inexact : 0);
   }
 
   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 =
       (controlWord >> FEnv::ExceptionControlFlagsBitPosition) & 0x1F;
   controlWord |= (newExcepts << FEnv::ExceptionControlFlagsBitPosition);
   FEnv::writeControlWord(controlWord);
   return FEnv::exceptionStatusToMacro(oldExcepts);
 }
 
 static inline int disableExcept(int excepts) {
   uint32_t disabledExcepts = FEnv::getStatusValueForExcept(excepts);
   uint32_t controlWord = FEnv::getControlWord();
   int oldExcepts =
       (controlWord >> FEnv::ExceptionControlFlagsBitPosition) & 0x1F;
   controlWord &= ~(disabledExcepts << FEnv::ExceptionControlFlagsBitPosition);
   FEnv::writeControlWord(controlWord);
   return FEnv::exceptionStatusToMacro(oldExcepts);
 }
 
 static inline int clearExcept(int excepts) {
   uint32_t statusWord = FEnv::getStatusWord();
   uint32_t toClear = FEnv::getStatusValueForExcept(excepts);
   statusWord &= ~(toClear << FEnv::ExceptionStatusFlagsBitPosition);
   FEnv::writeStatusWord(statusWord);
   return 0;
 }
 
 static inline int testExcept(int excepts) {
   uint32_t toTest = FEnv::getStatusValueForExcept(excepts);
   uint32_t statusWord = FEnv::getStatusWord();
   return FEnv::exceptionStatusToMacro(
       (statusWord >> FEnv::ExceptionStatusFlagsBitPosition) & toTest);
 }
 
 static inline int setExcept(int excepts) {
   uint32_t statusWord = FEnv::getControlWord();
   uint32_t statusValue = FEnv::getStatusValueForExcept(excepts);
   statusWord |= (statusValue << FEnv::ExceptionStatusFlagsBitPosition);
   FEnv::writeStatusWord(statusWord);
   return 0;
 }
 
 static inline int raiseExcept(int excepts) {
   float zero = 0.0f;
   float one = 1.0f;
   float largeValue = float(FPBits<float>(FPBits<float>::maxNormal));
   float smallValue = float(FPBits<float>(FPBits<float>::minNormal));
   auto divfunc = [](float a, float b) {
     __asm__ __volatile__("ldr  s0, %0\n\t"
                          "ldr  s1, %1\n\t"
                          "fdiv s0, s0, s1\n\t"
                          : // No outputs
                          : "m"(a), "m"(b)
                          : "s0", "s1" /* s0 and s1 are clobbered */);
   };
 
   uint32_t toRaise = FEnv::getStatusValueForExcept(excepts);
 
   if (toRaise & FEnv::Invalid) {
     divfunc(zero, zero);
     uint32_t statusWord = FEnv::getStatusWord();
     if (!((statusWord >> FEnv::ExceptionStatusFlagsBitPosition) &
           FEnv::Invalid))
       return -1;
   }
 
   if (toRaise & FEnv::DivByZero) {
     divfunc(one, zero);
     uint32_t statusWord = FEnv::getStatusWord();
     if (!((statusWord >> FEnv::ExceptionStatusFlagsBitPosition) &
           FEnv::DivByZero))
       return -1;
   }
   if (toRaise & FEnv::Overflow) {
     divfunc(largeValue, smallValue);
     uint32_t statusWord = FEnv::getStatusWord();
     if (!((statusWord >> FEnv::ExceptionStatusFlagsBitPosition) &
           FEnv::Overflow))
       return -1;
   }
   if (toRaise & FEnv::Underflow) {
     divfunc(smallValue, largeValue);
     uint32_t statusWord = FEnv::getStatusWord();
     if (!((statusWord >> FEnv::ExceptionStatusFlagsBitPosition) &
           FEnv::Underflow))
       return -1;
   }
   if (toRaise & FEnv::Inexact) {
     float two = 2.0f;
     float three = 3.0f;
     // 2.0 / 3.0 cannot be represented exactly in any radix 2 floating point
     // format.
     divfunc(two, three);
     uint32_t statusWord = FEnv::getStatusWord();
     if (!((statusWord >> FEnv::ExceptionStatusFlagsBitPosition) &
           FEnv::Inexact))
       return -1;
   }
   return 0;
 }
 
 static inline int getRound() {
   uint32_t roundingMode =
       (FEnv::getControlWord() >> FEnv::RoundingControlBitPosition) & 0x3;
   switch (roundingMode) {
   case FEnv::ToNearest:
     return FE_TONEAREST;
   case FEnv::Downward:
     return FE_DOWNWARD;
   case FEnv::Upward:
     return FE_UPWARD;
   case FEnv::TowardZero:
     return FE_TOWARDZERO;
   default:
     return -1; // Error value.
   }
 }
 
 static inline int setRound(int mode) {
   uint16_t bitValue;
   switch (mode) {
   case FE_TONEAREST:
     bitValue = FEnv::ToNearest;
     break;
   case FE_DOWNWARD:
     bitValue = FEnv::Downward;
     break;
   case FE_UPWARD:
     bitValue = FEnv::Upward;
     break;
   case FE_TOWARDZERO:
     bitValue = FEnv::TowardZero;
     break;
   default:
     return 1; // To indicate failure
   }
 
   uint32_t controlWord = FEnv::getControlWord();
   controlWord &= ~(0x3 << FEnv::RoundingControlBitPosition);
   controlWord |= (bitValue << FEnv::RoundingControlBitPosition);
   FEnv::writeControlWord(controlWord);
 
   return 0;
 }
 
 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) {
   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_UTILS_FPUTIL_AARCH64_FENV_H

libc/utils/FPUtil/x86_64/FEnvImpl.h

 //===-- x86_64 floating point env manipulation functions --------*- 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_UTILS_FPUTIL_X86_64_FENV_H
 #define LLVM_LIBC_UTILS_FPUTIL_X86_64_FENV_H
 
 #include <fenv.h>
 #include <stdint.h>
 
 #include "src/__support/sanitizer.h"
 
 namespace __llvm_libc {
 namespace fputil {
 
 namespace internal {
 
 // Normally, one should be able to define FE_* macros to the exact rounding mode
 // encodings. However, since we want LLVM libc to be compiled against headers
 // from other libcs, we cannot assume that FE_* macros are always defined in
 // such a manner. So, we will define enums corresponding to the x86_64 bit
 // encodings. The implementations can map from FE_* to the corresponding enum
 // values.
 
 // The rounding control values in the x87 control register and the MXCSR
 // register have the same 2-bit enoding but have different bit positions.
 // See below for the bit positions.
 struct RoundingControlValue {
   static constexpr uint16_t ToNearest = 0x0;
   static constexpr uint16_t Downward = 0x1;
   static constexpr uint16_t Upward = 0x2;
   static constexpr uint16_t TowardZero = 0x3;
 };
 
 static constexpr uint16_t X87RoundingControlBitPosition = 10;
 static constexpr uint16_t MXCSRRoundingControlBitPosition = 13;
 
 // The exception flags in the x87 status register and the MXCSR have the same
 // encoding as well as the same bit positions.
 struct ExceptionFlags {
   static constexpr uint16_t Invalid = 0x1;
   // Some libcs define __FE_DENORM corresponding to the denormal input
   // exception and include it in FE_ALL_EXCEPTS. We define and use it to
   // support compiling against headers provided by such libcs.
   static constexpr uint16_t Denormal = 0x2;
   static constexpr uint16_t DivByZero = 0x4;
   static constexpr uint16_t Overflow = 0x8;
   static constexpr uint16_t Underflow = 0x10;
   static constexpr uint16_t Inexact = 0x20;
 };
 
 // The exception control bits occupy six bits, one bit for each exception.
 // In the x87 control word, they occupy the first 6 bits. In the MXCSR
 // register, they occupy bits 7 to 12.
 static constexpr uint16_t X87ExceptionControlBitPosition = 0;
 static constexpr uint16_t MXCSRExceptionContolBitPoistion = 7;
 
 // Exception flags are individual bits in the corresponding registers.
 // So, we just OR the bit values to get the full set of exceptions.
 static inline uint16_t getStatusValueForExcept(int excepts) {
   // We will make use of the fact that exception control bits are single
   // bit flags in the control registers.
   return (excepts & FE_INVALID ? ExceptionFlags::Invalid : 0) |
 #ifdef __FE_DENORM
          (excepts & __FE_DENORM ? ExceptionFlags::Denormal : 0) |
 #endif // __FE_DENORM
          (excepts & FE_DIVBYZERO ? ExceptionFlags::DivByZero : 0) |
          (excepts & FE_OVERFLOW ? ExceptionFlags::Overflow : 0) |
          (excepts & FE_UNDERFLOW ? ExceptionFlags::Underflow : 0) |
          (excepts & FE_INEXACT ? ExceptionFlags::Inexact : 0);
 }
 
 static inline int exceptionStatusToMacro(uint16_t status) {
   return (status & ExceptionFlags::Invalid ? FE_INVALID : 0) |
 #ifdef __FE_DENORM
          (status & ExceptionFlags::Denormal ? __FE_DENORM : 0) |
 #endif // __FE_DENORM
          (status & ExceptionFlags::DivByZero ? FE_DIVBYZERO : 0) |
          (status & ExceptionFlags::Overflow ? FE_OVERFLOW : 0) |
          (status & ExceptionFlags::Underflow ? FE_UNDERFLOW : 0) |
          (status & ExceptionFlags::Inexact ? FE_INEXACT : 0);
 }
 
 struct X87StateDescriptor {
   uint16_t ControlWord;
   uint16_t Unused1;
   uint16_t StatusWord;
   uint16_t Unused2;
   // TODO: Elaborate the remaining 20 bytes as required.
 #if !(defined(_WIN32))
   uint32_t _[5];
 #endif
 };
 
 struct FPState {
   X87StateDescriptor X87Status;
 #if !(defined(_WIN32))
   uint32_t MXCSR;
 #endif
 };
 
 static_assert(
     sizeof(fenv_t) == sizeof(FPState),
     "Internal floating point state does not match the public fenv_t type.");
 
 static inline uint16_t getX87ControlWord() {
   uint16_t w;
   __asm__ __volatile__("fnstcw %0" : "=m"(w)::);
   SANITIZER_MEMORY_INITIALIZED(&w, sizeof(w));
   return w;
 }
 
 static inline void writeX87ControlWord(uint16_t w) {
   __asm__ __volatile__("fldcw %0" : : "m"(w) :);
 }
 
 static inline uint16_t getX87StatusWord() {
   uint16_t w;
   __asm__ __volatile__("fnstsw %0" : "=m"(w)::);
   SANITIZER_MEMORY_INITIALIZED(&w, sizeof(w));
   return w;
 }
 
 static inline void clearX87Exceptions() {
   __asm__ __volatile__("fnclex" : : :);
 }
 
 static inline uint32_t getMXCSR() {
   uint32_t w;
   __asm__ __volatile__("stmxcsr %0" : "=m"(w)::);
   SANITIZER_MEMORY_INITIALIZED(&w, sizeof(w));
   return w;
 }
 
 static inline void writeMXCSR(uint32_t w) {
   __asm__ __volatile__("ldmxcsr %0" : : "m"(w) :);
 }
 
 static inline void getX87StateDescriptor(X87StateDescriptor &s) {
   __asm__ __volatile__("fnstenv %0" : "=m"(s));
   SANITIZER_MEMORY_INITIALIZED(&s, sizeof(s));
 }
 
 static inline void writeX87StateDescriptor(const X87StateDescriptor &s) {
   __asm__ __volatile__("fldenv %0" : : "m"(s) :);
 }
 
 static inline void fwait() { __asm__ __volatile__("fwait"); }
 
 } // namespace internal
 
 static inline int enableExcept(int excepts) {
   // In the x87 control word and in MXCSR, an exception is blocked
   // if the corresponding bit is set. That is the reason for all the
   // bit-flip operations below as we need to turn the bits to zero
   // to enable them.
 
   uint16_t bitMask = internal::getStatusValueForExcept(excepts);
 
   uint16_t x87CW = internal::getX87ControlWord();
   uint16_t oldExcepts = ~x87CW & 0x3F; // Save previously enabled exceptions.
   x87CW &= ~bitMask;
   internal::writeX87ControlWord(x87CW);
 
   // Enabling SSE exceptions via MXCSR is a nice thing to do but
   // might not be of much use practically as SSE exceptions and the x87
   // exceptions are independent of each other.
   uint32_t mxcsr = internal::getMXCSR();
   mxcsr &= ~(bitMask << internal::MXCSRExceptionContolBitPoistion);
   internal::writeMXCSR(mxcsr);
 
   // Since the x87 exceptions and SSE exceptions are independent of each,
   // it doesn't make much sence to report both in the return value. Most
   // often, the standard floating point functions deal with FPU operations
   // so we will retrun only the old x87 exceptions.
   return internal::exceptionStatusToMacro(oldExcepts);
 }
 
 static inline int disableExcept(int excepts) {
   // In the x87 control word and in MXCSR, an exception is blocked
   // if the corresponding bit is set.
 
   uint16_t bitMask = internal::getStatusValueForExcept(excepts);
 
   uint16_t x87CW = internal::getX87ControlWord();
   uint16_t oldExcepts = ~x87CW & 0x3F; // Save previously enabled exceptions.
   x87CW |= bitMask;
   internal::writeX87ControlWord(x87CW);
 
   // Just like in enableExcept, it is not clear if disabling SSE exceptions
   // is required. But, we will still do it only as a "nice thing to do".
   uint32_t mxcsr = internal::getMXCSR();
   mxcsr |= (bitMask << internal::MXCSRExceptionContolBitPoistion);
   internal::writeMXCSR(mxcsr);
 
   return internal::exceptionStatusToMacro(oldExcepts);
 }
 
 static inline int clearExcept(int excepts) {
   internal::X87StateDescriptor state;
   internal::getX87StateDescriptor(state);
   state.StatusWord &= ~internal::getStatusValueForExcept(excepts);
   internal::writeX87StateDescriptor(state);
 
   uint32_t mxcsr = internal::getMXCSR();
   mxcsr &= ~internal::getStatusValueForExcept(excepts);
   internal::writeMXCSR(mxcsr);
   return 0;
 }
 
 static inline int testExcept(int excepts) {
   uint16_t statusValue = internal::getStatusValueForExcept(excepts);
   // Check both x87 status word and MXCSR.
   return internal::exceptionStatusToMacro(
       (statusValue & internal::getX87StatusWord()) |
       (statusValue & internal::getMXCSR()));
 }
 
 // Sets the exception flags but does not trigger the exception handler.
 static inline int setExcept(int excepts) {
   uint16_t statusValue = internal::getStatusValueForExcept(excepts);
   internal::X87StateDescriptor state;
   internal::getX87StateDescriptor(state);
   state.StatusWord |= statusValue;
   internal::writeX87StateDescriptor(state);
 
   uint32_t mxcsr = internal::getMXCSR();
   mxcsr |= statusValue;
   internal::writeMXCSR(mxcsr);
 
   return 0;
 }
 
 static inline int raiseExcept(int excepts) {
   uint16_t statusValue = internal::getStatusValueForExcept(excepts);
 
   // We set the status flag for exception one at a time and call the
   // fwait instruction to actually get the processor to raise the
   // exception by calling the exception handler. This scheme is per
   // the description in in "8.6 X87 FPU EXCEPTION SYNCHRONIZATION"
   // of the "Intel 64 and IA-32 Architectures Software Developer's
   // Manual, Vol 1".
 
   // FPU status word is read for each exception seperately as the
   // exception handler can potentially write to it (typically to clear
   // the corresponding exception flag). By reading it separately, we
   // ensure that the writes by the exception handler are maintained
   // when raising the next exception.
 
   if (statusValue & internal::ExceptionFlags::Invalid) {
     internal::X87StateDescriptor state;
     internal::getX87StateDescriptor(state);
     state.StatusWord |= internal::ExceptionFlags::Invalid;
     internal::writeX87StateDescriptor(state);
     internal::fwait();
   }
   if (statusValue & internal::ExceptionFlags::DivByZero) {
     internal::X87StateDescriptor state;
     internal::getX87StateDescriptor(state);
     state.StatusWord |= internal::ExceptionFlags::DivByZero;
     internal::writeX87StateDescriptor(state);
     internal::fwait();
   }
   if (statusValue & internal::ExceptionFlags::Overflow) {
     internal::X87StateDescriptor state;
     internal::getX87StateDescriptor(state);
     state.StatusWord |= internal::ExceptionFlags::Overflow;
     internal::writeX87StateDescriptor(state);
     internal::fwait();
   }
   if (statusValue & internal::ExceptionFlags::Underflow) {
     internal::X87StateDescriptor state;
     internal::getX87StateDescriptor(state);
     state.StatusWord |= internal::ExceptionFlags::Underflow;
     internal::writeX87StateDescriptor(state);
     internal::fwait();
   }
   if (statusValue & internal::ExceptionFlags::Inexact) {
     internal::X87StateDescriptor state;
     internal::getX87StateDescriptor(state);
     state.StatusWord |= internal::ExceptionFlags::Inexact;
     internal::writeX87StateDescriptor(state);
     internal::fwait();
   }
 
   // There is no special synchronization scheme available to
   // raise SEE exceptions. So, we will ignore that for now.
   // Just plain writing to the MXCSR register does not guarantee
   // the exception handler will be called.
 
   return 0;
 }
 
 static inline int getRound() {
   uint16_t bitValue =
       (internal::getMXCSR() >> internal::MXCSRRoundingControlBitPosition) & 0x3;
   switch (bitValue) {
   case internal::RoundingControlValue::ToNearest:
     return FE_TONEAREST;
   case internal::RoundingControlValue::Downward:
     return FE_DOWNWARD;
   case internal::RoundingControlValue::Upward:
     return FE_UPWARD;
   case internal::RoundingControlValue::TowardZero:
     return FE_TOWARDZERO;
   default:
     return -1; // Error value.
   }
 }
 
 static inline int setRound(int mode) {
   uint16_t bitValue;
   switch (mode) {
   case FE_TONEAREST:
     bitValue = internal::RoundingControlValue::ToNearest;
     break;
   case FE_DOWNWARD:
     bitValue = internal::RoundingControlValue::Downward;
     break;
   case FE_UPWARD:
     bitValue = internal::RoundingControlValue::Upward;
     break;
   case FE_TOWARDZERO:
     bitValue = internal::RoundingControlValue::TowardZero;
     break;
   default:
     return 1; // To indicate failure
   }
 
   uint16_t x87Value = static_cast<uint16_t>(
       bitValue << internal::X87RoundingControlBitPosition);
   uint16_t x87Control = internal::getX87ControlWord();
   x87Control = static_cast<uint16_t>(
       (x87Control &
        ~(uint16_t(0x3) << internal::X87RoundingControlBitPosition)) |
       x87Value);
   internal::writeX87ControlWord(x87Control);
 
   uint32_t mxcsrValue = bitValue << internal::MXCSRRoundingControlBitPosition;
   uint32_t mxcsrControl = internal::getMXCSR();
   mxcsrControl =
       (mxcsrControl & ~(0x3 << internal::MXCSRRoundingControlBitPosition)) |
       mxcsrValue;
   internal::writeMXCSR(mxcsrControl);
 
   return 0;
 }
 
 #if !(defined(_WIN32))
 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 =
       reinterpret_cast<const internal::FPState *>(envp);
   internal::writeX87StateDescriptor(state->X87Status);
   internal::writeMXCSR(state->MXCSR);
   return 0;
 }
 #endif
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_FPUTIL_X86_64_FENV_H