[libc] Skip fenv exception tests on aarch64 if HW doesn't support exceptions.

[michaelrj]

LGTM

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

static inline int disableExcept(int 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 getExcept() {
+  uint32_t controlWord = FEnv::getControlWord();
+  int enabledExcepts =
+      (controlWord >> FEnv::ExceptionControlFlagsBitPosition) & 0x1F;
+  return FEnv::exceptionStatusToMacro(enabledExcepts);
+}
+
 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;
 }
 

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

static inline int disableExcept(int excepts) {
   // 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 getExcept() {
+  uint16_t x87CW = internal::getX87ControlWord();
+  uint16_t enabledExcepts = ~x87CW & 0x3F;
+  return internal::exceptionStatusToMacro(enabledExcepts);
+}
+
 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);

libc/test/src/fenv/enabled_exceptions_test.cpp

 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 #include <signal.h>
 
 // This test enables an exception and verifies that raising that exception
 // triggers SIGFPE.
 TEST(LlvmLibcExceptionStatusTest, RaiseAndCrash) {
+#ifdef __aarch64__
+  // Few aarch64 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.
+  __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::enableExcept(FE_DIVBYZERO);
+  if (__llvm_libc::fputil::getExcept() == 0)
+    return;
+#endif
+
   // 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
   // longjmp implemented.
 
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};
 

libc/test/src/fenv/feholdexcept_test.cpp

 
 #include "src/__support/FPUtil/FEnvUtils.h"
 #include "src/__support/FPUtil/FPExceptMatcher.h"
 #include "utils/UnitTest/Test.h"
 
 #include <fenv.h>
 
 TEST(LlvmLibcFEnvTest, RaiseAndCrash) {
+#ifdef __aarch64__
+  // Few aarch64 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.
+  __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
+  __llvm_libc::fputil::enableExcept(FE_DIVBYZERO);
+  if (__llvm_libc::fputil::getExcept() == 0)
+    return;
+#endif
+
   int excepts[] = {FE_DIVBYZERO, FE_INVALID, FE_INEXACT, FE_OVERFLOW,
                    FE_UNDERFLOW};
 
   for (int e : excepts) {
     fenv_t env;
     __llvm_libc::fputil::disableExcept(FE_ALL_EXCEPT);
     __llvm_libc::fputil::enableExcept(e);
     ASSERT_EQ(__llvm_libc::fputil::clearExcept(FE_ALL_EXCEPT), 0);