[builtins] Raise FE_INVALID/FE_DIVBYZERO for 128-bit float math functions

[arichardson]

Summary

I have been trying to get the FreeBSD libm testsuite to pass on AArch64
and it expects certain long double math functions to raise FE_INVALID for
bad inputs. However, the compiler-rt soft-float builtins do not raise
FE_INVALID for cases such as inf-inf, 0/0 etc. so the tests fail.

This patch extends the existing support for raising FE_INEXACT to also
handle FE_INVALID/FE_DIVBYZERO for most cases listed in IEEE-754-2019 7.2
and 7.3. I am not a floating-point expert so I may have missed some cases,
or might have got something wrong but this change allows most of the
FreeBSD libm long double tests to pass on AArch64.

[peter.smith]

From another non-floating point expert, this looks reasonable to me. I'll see if I can find anyone internally that knows more and would like to take a look.

compiler-rt/lib/builtins/arm/fp_mode.c

21

Please could the comment be moved to before ARM_INEXACT. It can be worked out from the 0x1000 what it is referring to, but I think having it above the value would avoid suspicion of ARM_INVALID and ARM_DIVBYZERO.

I'm with you that it looks wrong. From my reading of the Arm ARM 0x1000 (12 IXE) enables hardware trapping of inexact rounding (if hardware supports it), which would be unlikely to be useful given that __fe_raise_inexact is called when adding/subtracting floating point in software.

[arichardson]

In D98332#2616933, @peter.smith wrote:

From another non-floating point expert, this looks reasonable to me. I'll see if I can find anyone internally that knows more and would like to take a look.

Thanks!

I'll also split the ARM_INEXACT change to a separate review.

[arichardson]

• rebase on top of D98353

[peter.smith]

One small concern related to the tests on a target that doesn't implement __fe_raise_invalid and friends.

compiler-rt/lib/builtins/fp_add_impl.inc

29

Something of this form is repeated 6 times (check for isNaN then raise invalid). I'm wondering if this could be hoisted into an inline function. It might make the code easier to follow.

It looks marginal so I can easily see it not being worthwhile, but maybe worth an attempt to see what it looks like.

compiler-rt/test/builtins/Unit/addtf3_test.c

29

What would happen if we ran the test on a target that just returned 0 for __fe_raise_invalid? I can't immediately see how actualExc == expectedExc in that case. I could be missing something though.

[arichardson]

compiler-rt/lib/builtins/fp_add_impl.inc

29

Yes I think that would be more readable, and the compiler should be able to fold the redundant checks anyway.
Will try and update on Monday.

compiler-rt/test/builtins/Unit/addtf3_test.c

29

Good point, this test would fail then. Maybe best to change it to something like

if (CRT_SETS_FP_EXC && actualExc != expectedExc)

and have that be pre-defined by lit depending on the architecture.

[arichardson]

• Don't check fp exception flags if compiler-rt doesn't set them.

[peter.smith]

Thanks for the update. Test changes look good to me. Just wanted to check to see if you had any changes planned for lifting some of the common tests into a function? Or if that can be left to another patch?

[arichardson]

In D98332#2647774, @peter.smith wrote:

Thanks for the update. Test changes look good to me. Just wanted to check to see if you had any changes planned for lifting some of the common tests into a function? Or if that can be left to another patch?

Ah sorry I forgot about that comment. Currently busy merging upstream LLVM into our fork, but I can make that change once I complete the merge.

[arichardson]

Apologies for the long delay just rediscovered this due to test failures.

Rebased on latest main, dropping dependency on my unmerged builtins changes.
I have not factored out the snan checks to a helper function, will try to do that if I find the time.

[arichardson]

Add a isSNaN helper function

[peter.smith]

Thanks for the update. I'll try and get someone from the team with more of a background in floating point to take a look. If not I'll do my best to check it.

[arichardson]

Also handle RISC-V (tested with GCC+user-mode QEMU)

[arichardson]

compiler-rt/test/builtins/Unit/multf3_test.c

10

Hmm looks like this should probably return 0 to skip the test or we add an XFAIL: for x86 since it incorrectly defines multf.

[simon_tatham]

compiler-rt/lib/builtins/fp_fixint_impl.inc

31–33

Nit: shouldn't this also raise the invalid exception in cases where the input exponent is in range but the value rounds up to overflow? E.g. converting 0x7fffffff.ffff to int32_t.

compiler-rt/lib/builtins/fp_fixuint_impl.inc

25

If the number is negative, shouldn't we raise invalid? At least if it's <= -0.5 so that it rounds down to a negative integer instead of up to 0.

29–31

Another 'round up to overflow' case here, e.g. 0xffffffff.ffff → uint32_t should raise invalid, and I don't think it will with this code.

[simon_tatham]

compiler-rt/lib/builtins/fp_fixint_impl.inc

31–33

Oh, hang on – maybe I'm thinking of the wrong rounding mode. This is unconditionally doing round-towards-zero, isn't it? So this code is just fine. Sorry for the noise.

compiler-rt/lib/builtins/fp_fixuint_impl.inc

25

My mistake: if we're rounding towards zero, then x <= -1 is the criterion for raising invalid, not x <= -0.5.

(And even in round-to-nearest/even it should have been x < -0.5, ahem.)

29–31

I retract this complaint for the same reason as the signed integer one.

compiler-rt/lib/builtins/aarch64/fp_mode.c

 #define AARCH64_TONEAREST  0x0
 #define AARCH64_UPWARD     0x1
 #define AARCH64_DOWNWARD   0x2
 #define AARCH64_TOWARDZERO 0x3
 #define AARCH64_RMODE_MASK (AARCH64_TONEAREST | AARCH64_UPWARD | \
                             AARCH64_DOWNWARD | AARCH64_TOWARDZERO)
 #define AARCH64_RMODE_SHIFT 22
 
+#define AARCH64_INVALID     0x1
+#define AARCH64_DIVBYZERO   0x2
 #define AARCH64_INEXACT     0x10
 
 #ifndef __ARM_FP
 // For soft float targets, allow changing rounding mode by overriding the weak
 // __aarch64_fe_default_rmode symbol.
 CRT_FE_ROUND_MODE __attribute__((weak)) __aarch64_fe_default_rmode = CRT_FE_TONEAREST;
 #endif
 
#ifdef __ARM_FP
   uint64_t fpsr;
   __asm__ __volatile__("mrs  %0, fpsr" : "=r" (fpsr));
   __asm__ __volatile__("msr  fpsr, %0" : : "ri" (fpsr | AARCH64_INEXACT));
   return 0;
 #else
   return 0;
 #endif
 }
+
+int __fe_raise_invalid() {
+#ifdef __ARM_FP
+  uint64_t fpsr;
+  __asm__ __volatile__("mrs  %0, fpsr" : "=r" (fpsr));
+  __asm__ __volatile__("msr  fpsr, %0" : : "ri" (fpsr | AARCH64_INVALID));
+  return 0;
+#else
+  return 0;
+#endif
+}
+
+int __fe_raise_divbyzero() {
+#ifdef __ARM_FP
+  uint64_t fpsr;
+  __asm__ __volatile__("mrs  %0, fpsr" : "=r" (fpsr));
+  __asm__ __volatile__("msr  fpsr, %0" : : "ri" (fpsr | AARCH64_DIVBYZERO));
+  return 0;
+#else
+  return 0;
+#endif
+}

compiler-rt/lib/builtins/arm/fp_mode.c

 #define ARM_TONEAREST  0x0
 #define ARM_UPWARD     0x1
 #define ARM_DOWNWARD   0x2
 #define ARM_TOWARDZERO 0x3
 #define ARM_RMODE_MASK (ARM_TONEAREST | ARM_UPWARD | \
                         ARM_DOWNWARD | ARM_TOWARDZERO)
 #define ARM_RMODE_SHIFT 22
 
+#define ARM_INVALID     0x01
+#define ARM_DIVBYZERO   0x02
 #define ARM_INEXACT     0x10
 
 #ifndef __ARM_FP
 // For soft float targets, allow changing rounding mode by overriding the weak
 // __arm_fe_default_rmode symbol.
 CRT_FE_ROUND_MODE __attribute__((weak)) __arm_fe_default_rmode = CRT_FE_TONEAREST;
 #endif
 
#ifdef __ARM_FP
   uint32_t fpscr;
   __asm__ __volatile__("vmrs  %0, fpscr" : "=r" (fpscr));
   __asm__ __volatile__("vmsr  fpscr, %0" : : "ri" (fpscr | ARM_INEXACT));
   return 0;
 #else
   return 0;
 #endif
 }
+
+int __fe_raise_invalid() {
+#ifdef __ARM_FP
+  uint32_t fpscr;
+  __asm__ __volatile__("vmrs  %0, fpscr" : "=r" (fpscr));
+  __asm__ __volatile__("vmsr  fpscr, %0" : : "ri" (fpscr | ARM_INVALID));
+  return 0;
+#else
+  return 0;
+#endif
+}
+
+int __fe_raise_divbyzero() {
+#ifdef __ARM_FP
+  uint32_t fpscr;
+  __asm__ __volatile__("vmrs  %0, fpscr" : "=r" (fpscr));
+  __asm__ __volatile__("vmsr  fpscr, %0" : : "ri" (fpscr | ARM_DIVBYZERO));
+  return 0;
+#else
+  return 0;
+#endif
+}

compiler-rt/lib/builtins/fp_add_impl.inc

static __inline fp_t __addXf3__(fp_t a, fp_t b) {
   rep_t bRep = toRep(b);
   const rep_t aAbs = aRep & absMask;
   const rep_t bAbs = bRep & absMask;
 
   // Detect if a or b is zero, infinity, or NaN.
   if (aAbs - REP_C(1) >= infRep - REP_C(1) ||
       bAbs - REP_C(1) >= infRep - REP_C(1)) {
     // NaN + anything = qNaN
-    if (aAbs > infRep)
+    if (aAbs > infRep) {
+      // Raise invalid if one of the operands is a sNaN (IEEE-754-2019 7.2a).
+      if ((aRep & quietBit) == 0 || (bAbs > infRep && (bRep & quietBit) == 0))
+        __fe_raise_invalid();
       return fromRep(toRep(a) | quietBit);
+    }
     // anything + NaN = qNaN
-    if (bAbs > infRep)
+    if (bAbs > infRep) {
+      // Raise invalid if one of the operands is a sNaN (IEEE-754-2019 7.2a).
+      if ((bRep & quietBit) == 0 || (aAbs > infRep && (aRep & quietBit) == 0))
+        __fe_raise_invalid();
       return fromRep(toRep(b) | quietBit);
+    }
 
     if (aAbs == infRep) {
       // +/-infinity + -/+infinity = qNaN
-      if ((toRep(a) ^ toRep(b)) == signBit)
+      if ((toRep(a) ^ toRep(b)) == signBit) {
+        // Magnitude subtraction of inf raises invalid (IEEE-754-2019 7.2d).
+        __fe_raise_invalid();
         return fromRep(qnanRep);
+      }
       // +/-infinity + anything remaining = +/- infinity
       else
         return a;
     }
 
     // anything remaining + +/-infinity = +/-infinity
     if (bAbs == infRep)
       return b;

compiler-rt/lib/builtins/fp_div_impl.inc

static __inline fp_t __divXf3__(fp_t a, fp_t b) {
   // Detect if a or b is zero, denormal, infinity, or NaN.
   if (aExponent - 1U >= maxExponent - 1U ||
       bExponent - 1U >= maxExponent - 1U) {
 
     const rep_t aAbs = toRep(a) & absMask;
     const rep_t bAbs = toRep(b) & absMask;
 
     // NaN / anything = qNaN
-    if (aAbs > infRep)
+    if (aAbs > infRep) {
+      // Raise invalid if one of the operands is a sNaN (IEEE-754-2019 7.2a).
+      if ((toRep(a) & quietBit) == 0 || (bAbs > infRep && (toRep(b) & quietBit) == 0))
+        __fe_raise_invalid();
       return fromRep(toRep(a) | quietBit);
+    }
     // anything / NaN = qNaN
-    if (bAbs > infRep)
+    if (bAbs > infRep) {
+      // Raise invalid if one of the operands is a sNaN (IEEE-754-2019 7.2a).
+      if ((toRep(b) & quietBit) == 0 || (aAbs > infRep && (toRep(a) & quietBit) == 0))
+        __fe_raise_invalid();
       return fromRep(toRep(b) | quietBit);
+    }
 
     if (aAbs == infRep) {
       // infinity / infinity = NaN
-      if (bAbs == infRep)
+      if (bAbs == infRep) {
+        // infinity / infinity raises invalid (IEEE-754-2019 7.2e).
+        __fe_raise_invalid();
         return fromRep(qnanRep);
+      }
       // infinity / anything else = +/- infinity
       else
         return fromRep(aAbs | quotientSign);
     }
 
     // anything else / infinity = +/- 0
     if (bAbs == infRep)
       return fromRep(quotientSign);
 
     if (!aAbs) {
       // zero / zero = NaN
-      if (!bAbs)
+      if (!bAbs) {
+        // zero / zero raises invalid (IEEE-754-2019 7.2e).
+        __fe_raise_invalid();
         return fromRep(qnanRep);
+      }
       // zero / anything else = +/- zero
       else
         return fromRep(quotientSign);
     }
     // anything else / zero = +/- infinity
-    if (!bAbs)
+    if (!bAbs) {
+      // DIVBYZERO if dividend is a finite non-zero number (IEEE-754-2019 7.3).
+      // We handled the a==infinity, a==zero, and a==Nan cases earlier so
+      // it must be a finite non-zero number now.
+      __fe_raise_divbyzero();
       return fromRep(infRep | quotientSign);
+    }
 
     // One or both of a or b is denormal.  The other (if applicable) is a
     // normal number.  Renormalize one or both of a and b, and set scale to
     // include the necessary exponent adjustment.
     if (aAbs < implicitBit)
       scale += normalize(&aSignificand);
     if (bAbs < implicitBit)
       scale -= normalize(&bSignificand);

compiler-rt/lib/builtins/fp_fixint_impl.inc

static __inline fixint_t __fixint(fp_t a) {
   const int exponent = (aAbs >> significandBits) - exponentBias;
   const rep_t significand = (aAbs & significandMask) | implicitBit;
 
   // If exponent is negative, the result is zero.
   if (exponent < 0)
     return 0;
 
   // If the value is too large for the integer type, saturate.
-  if ((unsigned)exponent >= sizeof(fixint_t) * CHAR_BIT)
+  if ((unsigned)exponent >= sizeof(fixint_t) * CHAR_BIT) {
+    // Values that are too large/infinity/NaN raise invalid (IEEE-754-2019 7.2j).
+    __fe_raise_invalid();
     return sign == 1 ? fixint_max : fixint_min;
+  }
 
   // If 0 <= exponent < significandBits, right shift to get the result.
   // Otherwise, shift left.
   if (exponent < significandBits)
     return sign * (significand >> (significandBits - exponent));
   else
     return sign * ((fixint_t)significand << (exponent - significandBits));
 }

compiler-rt/lib/builtins/fp_fixuint_impl.inc

static __inline fixuint_t __fixuint(fp_t a) {
   // Break a into sign, exponent, significand parts.
   const rep_t aRep = toRep(a);
   const rep_t aAbs = aRep & absMask;
   const int sign = aRep & signBit ? -1 : 1;
   const int exponent = (aAbs >> significandBits) - exponentBias;
   const rep_t significand = (aAbs & significandMask) | implicitBit;
 
   // If either the value or the exponent is negative, the result is zero.
   if (sign == -1 || exponent < 0)
     return 0;
 
   // If the value is too large for the integer type, saturate.
-  if ((unsigned)exponent >= sizeof(fixuint_t) * CHAR_BIT)
+  if ((unsigned)exponent >= sizeof(fixuint_t) * CHAR_BIT) {
+    // Values that are too large/infinity/NaN raise invalid (IEEE-754-2019 7.2j).
+    __fe_raise_invalid();
     return ~(fixuint_t)0;
+  }
 
   // If 0 <= exponent < significandBits, right shift to get the result.
   // Otherwise, shift left.
   if (exponent < significandBits)
     return significand >> (significandBits - exponent);
   else
     return (fixuint_t)significand << (exponent - significandBits);
 }

compiler-rt/lib/builtins/fp_lib.h

 // binary32, binary64 and binary 128 types, respectively, and that integer
 // endianness matches floating point endianness on the target platform.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FP_LIB_HEADER
 #define FP_LIB_HEADER
 
+#include "fp_mode.h"
 #include "int_lib.h"
 #include "int_math.h"
 #include <limits.h>
 #include <stdbool.h>
 #include <stdint.h>
 
 // x86_64 FreeBSD prior v9.3 define fixed-width types incorrectly in
 // 32-bit mode.
static __inline fp_t __compiler_rt_logbX(fp_t x) {
   // 2) 0.0 returns -inf
   if (exp == maxExponent) {
     if (((rep & signBit) == 0) || (x != x)) {
       return x; // NaN or +inf: return x
     } else {
       return -x; // -inf: return -x
     }
   } else if (x == 0.0) {
-    // 0.0: return -inf
+    // 0.0: return -inf and raise divide by zero (IEEE-754-2019 5.3.3 + 7.3)
+    __fe_raise_divbyzero();
     return fromRep(infRep | signBit);
   }
 
   if (exp != 0) {
     // Normal number
     return exp - exponentBias; // Unbias exponent
   } else {
     // Subnormal number; normalize and repeat

compiler-rt/lib/builtins/fp_mode.h

typedef enum {
   CRT_FE_TONEAREST,
   CRT_FE_DOWNWARD,
   CRT_FE_UPWARD,
   CRT_FE_TOWARDZERO
 } CRT_FE_ROUND_MODE;
 
 CRT_FE_ROUND_MODE __fe_getround(void);
 int __fe_raise_inexact(void);
+int __fe_raise_invalid(void);
+int __fe_raise_divbyzero(void);
 
 #endif // FP_MODE_H

compiler-rt/lib/builtins/fp_mode.c

 #include "fp_mode.h"
 
 // IEEE-754 default rounding (to nearest, ties to even).
 CRT_FE_ROUND_MODE __fe_getround() { return CRT_FE_TONEAREST; }
 
 int __fe_raise_inexact() {
   return 0;
 }
+
+int __fe_raise_invalid() {
+  return 0;
+}
+
+int __fe_raise_divbyzero() {
+  return 0;
+}

compiler-rt/lib/builtins/fp_mul_impl.inc

static __inline fp_t __mulXf3__(fp_t a, fp_t b) {
   // Detect if a or b is zero, denormal, infinity, or NaN.
   if (aExponent - 1U >= maxExponent - 1U ||
       bExponent - 1U >= maxExponent - 1U) {
 
     const rep_t aAbs = toRep(a) & absMask;
     const rep_t bAbs = toRep(b) & absMask;
 
     // NaN * anything = qNaN
-    if (aAbs > infRep)
+    if (aAbs > infRep) {
+      // Raise invalid if one of the operands is a sNaN (IEEE-754-2019 7.2a).
+      if ((toRep(a) & quietBit) == 0 || (bAbs > infRep && (toRep(b) & quietBit) == 0))
+        __fe_raise_invalid();
       return fromRep(toRep(a) | quietBit);
+    }
     // anything * NaN = qNaN
-    if (bAbs > infRep)
+    if (bAbs > infRep) {
+      // Raise invalid if one of the operands is a sNaN (IEEE-754-2019 7.2a).
+      if ((toRep(b) & quietBit) == 0 || (aAbs > infRep && (toRep(a) & quietBit) == 0))
+        __fe_raise_invalid();
       return fromRep(toRep(b) | quietBit);
+    }
 
     if (aAbs == infRep) {
+      if (bAbs) {
         // infinity * non-zero = +/- infinity
-      if (bAbs)
         return fromRep(aAbs | productSign);
-      // infinity * zero = NaN
-      else
+      } else {
+        // infinity * zero = NaN, raises invalid (IEEE-754-2019 7.2b).
+        __fe_raise_invalid();
         return fromRep(qnanRep);
       }
+    }
 
     if (bAbs == infRep) {
+      if (aAbs) {
         // non-zero * infinity = +/- infinity
-      if (aAbs)
         return fromRep(bAbs | productSign);
-      // zero * infinity = NaN
-      else
+      } else {
+        // zero * infinity = NaN, raises invalid (IEEE-754-2019 7.2b).
+        __fe_raise_invalid();
         return fromRep(qnanRep);
       }
+    }
 
     // zero * anything = +/- zero
     if (!aAbs)
       return fromRep(productSign);
     // anything * zero = +/- zero
     if (!bAbs)
       return fromRep(productSign);
 

compiler-rt/lib/builtins/i386/fp_mode.c

CRT_FE_ROUND_MODE __fe_getround() {
   return CRT_FE_TONEAREST;
 }
 
 int __fe_raise_inexact() {
   float f = 1.0f, g = 3.0f;
   __asm__ __volatile__ ("fdivs %1" : "+t" (f) : "m" (g));
   return 0;
 }
+
+int __fe_raise_invalid() {
+  float inf = __builtin_inff();
+  __asm__ __volatile__ ("fdivs %1" : "+t" (inf) : "m" (inf));
+  return 0;
+}
+
+int __fe_raise_divbyzero() {
+  float f = 1.0f, g = 0.0f;
+  __asm__ __volatile__ ("fdivs %1" : "+t" (f) : "m" (g));
+  return 0;
+}

compiler-rt/test/builtins/Unit/addtf3_test.c

 // RUN: %clang_builtins %s %librt -Wall -Wextra -Werror=format -o %t && %run %t
 // REQUIRES: librt_has_addtf3
 
-#include <fenv.h>
 #include <stdio.h>
 
 #include "int_lib.h"
-#include "fp_test.h"
+#include "fp_test_fenv.h"
 
 #if !defined(CRT_HAS_F128)
 int main() {
   fprintf(stderr, "Missing f128 support - skipping.\n");
   return 1;
 }
 #else
 
 // Returns: a + b
 COMPILER_RT_ABI f128 __addtf3(f128 a, f128 b);
 
-int _test__addtf3(int line, f128 a, f128 b,
+int _test__addtf3(int line, f128 a, f128 b, int expectedExc,
                   uint64_t expectedHi, uint64_t expectedLo) {
+  feclearexcept(FE_ALL_EXCEPT);
   f128 x = __addtf3(a, b);
+  int actualExc = fetestexcept(FE_ALL_EXCEPT);
   int ret = compareResultF128(x, expectedHi, expectedLo);
   if (ret) {
     printMismatchF128TwoArg(__FILE__, line, "__addtf3", a, b, x,
                             expectedHi, expectedLo);
   }
+  if (crt_sets_fp_exc_flags() && actualExc != expectedExc) {
+    fprintf(stderr, "%s:%d: Got unexpected floating-point exception %#x, expected %#x\n",
+            __FILE__, line, actualExc, expectedExc);
+    return 1;
+  }
   return ret;
 }
 #define test__addtf3(...) _test__addtf3(__LINE__, __VA_ARGS__)
 
 int main() {
   // qNaN + any = qNaN
   if (test__addtf3(makeQNaN128(),
                    0x1.23456789abcdefp+5Q,
+                   0,
                    UINT64_C(0x7fff800000000000),
                    UINT64_C(0x0)))
     return 1;
   // NaN + any = NaN
   if (test__addtf3(makeNaN128(UINT64_C(0x800030000000)),
                    0x1.23456789abcdefp+5Q,
+                   0,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+
+  // sNaN + any = qNaN, FE_INVALID
+  if (test__addtf3(makeNaN128(UINT64_C(0x12345)),
+                   0x1.23456789abcdefp+5Q,
+                   FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+
+  // any + sNaN = qNaN, FE_INVALID
+  if (test__addtf3(0x1.23456789abcdefp+5Q,
+                   makeNaN128(UINT64_C(0x12345)),
+                   FE_INVALID,
                    UINT64_C(0x7fff800000000000),
                    UINT64_C(0x0)))
     return 1;
+
   // inf + inf = inf
   if (test__addtf3(makeInf128(),
                    makeInf128(),
+                   0,
                    UINT64_C(0x7fff000000000000),
                    UINT64_C(0x0)))
     return 1;
   // inf + any = inf
   if (test__addtf3(makeInf128(),
                    0x1.2335653452436234723489432abcdefp+5Q,
+                   0,
                    UINT64_C(0x7fff000000000000),
                    UINT64_C(0x0)))
     return 1;
-  // any + any
+  // inf + -inf = NaN, FE_INVALID
+  if (test__addtf3(makeInf128(),
+                   makeNegativeInf128(),
+                   FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+  // -inf + inf = NaN, FE_INVALID
+  if (test__addtf3(makeNegativeInf128(),
+                   makeInf128(),
+                   FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
 
+  // any + any
   if (test__addtf3(/* 0x1.23456734245345543849abcdefp+5Q */
                    fromRep128(UINT64_C(0x4004234567342453), UINT64_C(0x45543849abcdef00)),
                    /* 0x1.edcba52449872455634654321fp-1Q */
                    fromRep128(UINT64_C(0x3ffeedcba5244987), UINT64_C(0x2455634654321f00)),
+                   0,
                    UINT64_C(0x40042afc95c8b579),
                    UINT64_C(0x61e58dd6c51eb77c)))
     return 1;
 
 #if (defined(__arm__) || defined(__aarch64__)) && defined(__ARM_FP) || \
     defined(i386) || defined(__x86_64__)
   // Rounding mode tests on supported architectures
   const f128 m = assertF128Representation(1234.0Q, UINT64_C(0x4009348000000000), UINT64_C(0x0000000000000000));
   // Closest approximation of 0.1 for f128:
   const f128 n = assertF128Representation(0.1Q, UINT64_C(0x3ffb999999999999), UINT64_C(0x999999999999999a));
   fesetround(FE_UPWARD);
-  if (test__addtf3(m, n,
+  if (test__addtf3(m, n, FE_INEXACT,
                    UINT64_C(0x4009348666666666),
                    UINT64_C(0x6666666666666667)))
     return 1;
 
   fesetround(FE_DOWNWARD);
-  if (test__addtf3(m, n,
+  if (test__addtf3(m, n, FE_INEXACT,
                    UINT64_C(0x4009348666666666),
                    UINT64_C(0x6666666666666666)))
     return 1;
 
   fesetround(FE_TOWARDZERO);
-  if (test__addtf3(m, n,
+  if (test__addtf3(m, n, FE_INEXACT,
                    UINT64_C(0x4009348666666666),
                    UINT64_C(0x6666666666666666)))
     return 1;
 
   fesetround(FE_TONEAREST);
-  if (test__addtf3(m, n,
+  if (test__addtf3(m, n, FE_INEXACT,
                    UINT64_C(0x4009348666666666),
                    UINT64_C(0x6666666666666666)))
     return 1;
 #endif
   return 0;
 }
 
 #endif

compiler-rt/test/builtins/Unit/divtf3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_divtf3
 
 #include "int_lib.h"
 #include <stdio.h>
 
-#include "fp_test.h"
+#include "fp_test_fenv.h"
 #if !defined(CRT_HAS_F128)
 int main() {
   fprintf(stderr, "Missing f128 support - skipping.\n");
   return 1;
 }
 #else
 
 // Returns: a / b
 COMPILER_RT_ABI f128 __divtf3(f128 a, f128 b);
 
-int _test__divtf3(int line, f128 a, f128 b,
+int _test__divtf3(int line, f128 a, f128 b, int expectedExc,
                   uint64_t expectedHi, uint64_t expectedLo) {
+  feclearexcept(FE_ALL_EXCEPT);
   f128 x = __divtf3(a, b);
+  int actualExc = fetestexcept(FE_ALL_EXCEPT);
   int ret = compareResultF128(x, expectedHi, expectedLo);
   if (ret) {
     printMismatchF128TwoArg(__FILE__, line, "__divtf3", a, b, x,
                             expectedHi, expectedLo);
   }
+  if (crt_sets_fp_exc_flags() && actualExc != expectedExc) {
+    fprintf(stderr, "%s:%d: Got unexpected floating-point exception %#x, expected %#x\n",
+            __FILE__, line, actualExc, expectedExc);
+    return 1;
+  }
   return ret;
 }
 #define test__divtf3(...) _test__divtf3(__LINE__, __VA_ARGS__)
 
 int main() {
   // Returned NaNs are assumed to be qNaN by default
 
   // qNaN / any = qNaN
   if (test__divtf3(makeQNaN128(),
                    0x1.23456789abcdefp+5Q,
+                   0,
                    UINT64_C(0x7fff800000000000),
                    UINT64_C(0x0)))
     return 1;
-  // NaN / any = NaN
+  // sNaN / any = qNaN, FE_INVALID
   if (test__divtf3(makeNaN128(UINT64_C(0x30000000)),
                    0x1.23456789abcdefp+5Q,
+                   FE_INVALID,
                    UINT64_C(0x7fff800000000000),
                    UINT64_C(0x0)))
     return 1;
   // any / qNaN = qNaN
   if (test__divtf3(0x1.23456789abcdefp+5Q,
                    makeQNaN128(),
+                   0,
                    UINT64_C(0x7fff800000000000),
                    UINT64_C(0x0)))
     return 1;
-  // any / NaN = NaN
+  // any / sNaN = NaN, FE_INVALID
   if (test__divtf3(0x1.23456789abcdefp+5Q,
                    makeNaN128(UINT64_C(0x30000000)),
+                   FE_INVALID,
                    UINT64_C(0x7fff800000000000),
                    UINT64_C(0x0)))
     return 1;
 
   // +Inf / positive = +Inf
-  if (test__divtf3(makeInf128(), 3.Q,
+  if (test__divtf3(makeInf128(), 3.Q, 0,
                    UINT64_C(0x7fff000000000000),
                    UINT64_C(0x0)))
     return 1;
   // +Inf / negative = -Inf
-  if (test__divtf3(makeInf128(), -3.Q,
+  if (test__divtf3(makeInf128(), -3.Q, 0,
                    UINT64_C(0xffff000000000000),
                    UINT64_C(0x0)))
     return 1;
   // -Inf / positive = -Inf
-  if (test__divtf3(makeNegativeInf128(), 3.Q,
+  if (test__divtf3(makeNegativeInf128(), 3.Q, 0,
                    UINT64_C(0xffff000000000000),
                    UINT64_C(0x0)))
     return 1;
   // -Inf / negative = +Inf
-  if (test__divtf3(makeNegativeInf128(), -3.Q,
+  if (test__divtf3(makeNegativeInf128(), -3.Q, 0,
                    UINT64_C(0x7fff000000000000),
                    UINT64_C(0x0)))
     return 1;
 
-  // Inf / Inf = NaN
-  if (test__divtf3(makeInf128(), makeInf128(),
+  // Inf / Inf = qNaN, FE_INVALID
+  if (test__divtf3(makeInf128(), makeInf128(), FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+  if (test__divtf3(makeInf128(), makeNegativeInf128(), FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+  if (test__divtf3(makeNegativeInf128(), makeInf128(), FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+  if (test__divtf3(makeNegativeInf128(), makeNegativeInf128(), FE_INVALID,
                    UINT64_C(0x7fff800000000000),
                    UINT64_C(0x0)))
     return 1;
-  // 0.0 / 0.0 = NaN
-  if (test__divtf3(+0x0.0p+0Q, +0x0.0p+0Q,
+  // +-0.0 / +-0.0 = qNaN, FE_INVALID
+  if (test__divtf3(+0x0.0p+0Q, +0x0.0p+0Q, FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+  if (test__divtf3(+0x0.0p+0Q, -0x0.0p+0Q, FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+  if (test__divtf3(-0x0.0p+0Q, +0x0.0p+0Q, FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+  if (test__divtf3(-0x0.0p+0Q, -0x0.0p+0Q, FE_INVALID,
                    UINT64_C(0x7fff800000000000),
                    UINT64_C(0x0)))
     return 1;
   // +0.0 / +Inf = +0.0
-  if (test__divtf3(+0x0.0p+0Q, makeInf128(),
+  if (test__divtf3(+0x0.0p+0Q, makeInf128(), 0,
                    UINT64_C(0x0),
                    UINT64_C(0x0)))
     return 1;
   // +Inf / +0.0 = +Inf
-  if (test__divtf3(makeInf128(), +0x0.0p+0Q,
+  if (test__divtf3(makeInf128(), +0x0.0p+0Q, 0,
                    UINT64_C(0x7fff000000000000),
                    UINT64_C(0x0)))
     return 1;
 
   // positive / +0.0 = +Inf
-  if (test__divtf3(+1.0Q, +0x0.0p+0Q,
+  if (test__divtf3(+1.0Q, +0x0.0p+0Q, FE_DIVBYZERO,
                    UINT64_C(0x7fff000000000000),
                    UINT64_C(0x0)))
     return 1;
   // positive / -0.0 = -Inf
-  if (test__divtf3(+1.0Q, -0x0.0p+0Q,
+  if (test__divtf3(+1.0Q, -0x0.0p+0Q, FE_DIVBYZERO,
                    UINT64_C(0xffff000000000000),
                    UINT64_C(0x0)))
     return 1;
   // negative / +0.0 = -Inf
-  if (test__divtf3(-1.0Q, +0x0.0p+0Q,
+  if (test__divtf3(-1.0Q, +0x0.0p+0Q, FE_DIVBYZERO,
                    UINT64_C(0xffff000000000000),
                    UINT64_C(0x0)))
     return 1;
   // negative / -0.0 = +Inf
-  if (test__divtf3(-1.0Q, -0x0.0p+0Q,
+  if (test__divtf3(-1.0Q, -0x0.0p+0Q, FE_DIVBYZERO,
                    UINT64_C(0x7fff000000000000),
                    UINT64_C(0x0)))
     return 1;
 
   // 1/3
-  if (test__divtf3(1.Q, 3.Q,
+  if (test__divtf3(1.Q, 3.Q, 0,
                    UINT64_C(0x3ffd555555555555),
                    UINT64_C(0x5555555555555555)))
     return 1;
   // smallest normal result
-  if (test__divtf3(0x1.0p-16381Q, 2.Q,
+  if (test__divtf3(0x1.0p-16381Q, 2.Q, 0,
                    UINT64_C(0x0001000000000000),
                    UINT64_C(0x0)))
     return 1;
 
   // divisor is exactly 1.0
   if (test__divtf3(0x1.0p+0Q,
                    0x1.0p+0Q,
+                   0,
                    UINT64_C(0x3fff000000000000),
                    UINT64_C(0x0)))
     return 1;
   // divisor is truncated to exactly 1.0 in UQ1.63
   if (test__divtf3(0x1.0p+0Q,
                    0x1.0000000000000001p+0Q,
+                   0,
                    UINT64_C(0x3ffeffffffffffff),
                    UINT64_C(0xfffe000000000000)))
     return 1;
 
   // smallest normal value divided by 2.0
-  if (test__divtf3(0x1.0p-16382Q, 2.Q, UINT64_C(0x0000800000000000), UINT64_C(0x0)))
+  if (test__divtf3(0x1.0p-16382Q, 2.Q, 0, UINT64_C(0x0000800000000000), UINT64_C(0x0)))
     return 1;
   // smallest subnormal result
-  if (test__divtf3(0x1.0p-16382Q, 0x1p+112Q, UINT64_C(0x0), UINT64_C(0x1)))
+  if (test__divtf3(0x1.0p-16382Q, 0x1p+112Q, 0, UINT64_C(0x0), UINT64_C(0x1)))
     return 1;
 
   // any / any
   if (test__divtf3(0x1.a23b45362464523375893ab4cdefp+5Q,
                    0x1.eedcbaba3a94546558237654321fp-1Q,
+                   0,
                    UINT64_C(0x4004b0b72924d407),
                    UINT64_C(0x0717e84356c6eba2)))
     return 1;
   if (test__divtf3(0x1.a2b34c56d745382f9abf2c3dfeffp-50Q,
                    0x1.ed2c3ba15935332532287654321fp-9Q,
+                   0,
                    UINT64_C(0x3fd5b2af3f828c9b),
                    UINT64_C(0x40e51f64cde8b1f2)))
-    return 15;
+    return 1;
   if (test__divtf3(0x1.2345f6aaaa786555f42432abcdefp+456Q,
                    0x1.edacbba9874f765463544dd3621fp+6400Q,
+                   0,
                    UINT64_C(0x28c62e15dc464466),
                    UINT64_C(0xb5a07586348557ac)))
     return 1;
   if (test__divtf3(0x1.2d3456f789ba6322bc665544edefp-234Q,
                    0x1.eddcdba39f3c8b7a36564354321fp-4455Q,
+                   0,
                    UINT64_C(0x507b38442b539266),
                    UINT64_C(0x22ce0f1d024e1252)))
     return 1;
   if (test__divtf3(0x1.2345f6b77b7a8953365433abcdefp+234Q,
                    0x1.edcba987d6bb3aa467754354321fp-4055Q,
+                   0,
                    UINT64_C(0x50bf2e02f0798d36),
                    UINT64_C(0x5e6fcb6b60044078)))
     return 1;
   if (test__divtf3(6.72420628622418701252535563464350521E-4932Q,
                    2.Q,
+                   0,
                    UINT64_C(0x0001000000000000),
                    UINT64_C(0)))
     return 1;
 
   return 0;
 }
 
 #endif

compiler-rt/test/builtins/Unit/fp_test_fenv.h

+#include "fp_mode.h"
+#include "fp_test.h"
+#include <fenv.h>
+
+static inline bool crt_sets_fp_exc_flags(void) {
+  static int result = -1;
+  if (result == -1) {
+    int old_except = fetestexcept(FE_ALL_EXCEPT);
+    feclearexcept(FE_ALL_EXCEPT);
+    __fe_raise_invalid();
+    result = fetestexcept(FE_INVALID) == FE_INVALID;
+    if (old_except != 0)
+      feraiseexcept(old_except);
+  }
+  return result;
+}

compiler-rt/test/builtins/Unit/multf3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_multf3
 
 #include <stdio.h>
 
 #include "int_lib.h"
-#include "fp_test.h"
+#include "fp_test_fenv.h"
 
 #if !defined(CRT_HAS_F128)
 int main() {
   fprintf(stderr, "Missing f128 support - skipping.\n");
   return 1;
 }
 #else
 
 // Returns: a * b
 COMPILER_RT_ABI f128 __multf3(f128 a, f128 b);
 
-int _test__multf3(int line, f128 a, f128 b,
+int _test__multf3(int line, f128 a, f128 b, int expectedExc,
                   uint64_t expectedHi, uint64_t expectedLo) {
+  feclearexcept(FE_ALL_EXCEPT);
   f128 x = __multf3(a, b);
+  int actualExc = fetestexcept(FE_ALL_EXCEPT);
   int ret = compareResultF128(x, expectedHi, expectedLo);
 
   if (ret) {
     printMismatchF128TwoArg(__FILE__, line, "__multf3", a, b, x,
                             expectedHi, expectedLo);
   }
+  if (crt_sets_fp_exc_flags() && actualExc != expectedExc) {
+    fprintf(stderr, "%s:%d: Got unexpected floating-point exception %#x, expected %#x\n",
+            __FILE__, line, actualExc, expectedExc);
+    return 1;
+  }
   return ret;
 }
 #define test__multf3(...) _test__multf3(__LINE__, __VA_ARGS__)
 
-int main()
-{
-    // qNaN * any = qNaN
-    if (test__multf3(makeQNaN128(),
-                     0x1.23456789abcdefp+5Q,
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // NaN * any = NaN
-    if (test__multf3(makeNaN128(UINT64_C(0x800030000000)),
-                     0x1.23456789abcdefp+5Q,
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // inf * any = inf
-    if (test__multf3(makeInf128(),
-                     0x1.23456789abcdefp+5Q,
-                     UINT64_C(0x7fff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // any * any
-    if (test__multf3(0x1.2eab345678439abcdefea56782346p+5Q,
-                     0x1.edcb34a235253948765432134674fp-1Q,
-                     UINT64_C(0x400423e7f9e3c9fc),
-                     UINT64_C(0xd906c2c2a85777c4)))
-        return 1;
-    if (test__multf3(0x1.353e45674d89abacc3a2ebf3ff4ffp-50Q,
-                     0x1.ed8764648369535adf4be3214567fp-9Q,
-                     UINT64_C(0x3fc52a163c6223fc),
-                     UINT64_C(0xc94c4bf0430768b4)))
-        return 1;
-    if (test__multf3(0x1.234425696abcad34a35eeffefdcbap+456Q,
-                     0x451.ed98d76e5d46e5f24323dff21ffp+600Q,
-                     UINT64_C(0x44293a91de5e0e94),
-                     UINT64_C(0xe8ed17cc2cdf64ac)))
-        return 1;
-    if (test__multf3(0x1.4356473c82a9fabf2d22ace345defp-234Q,
-                     0x1.eda98765476743ab21da23d45678fp-455Q,
-                     UINT64_C(0x3d4f37c1a3137cae),
-                     UINT64_C(0xfc6807048bc2836a)))
-        return 1;
-    // underflow
-    if (test__multf3(0x1.23456734245345p-10000Q,
-                     0x1.edcba524498724p-6497Q,
-                     UINT64_C(0x0),
-                     UINT64_C(0x0)))
-        return 1;
+int main() {
+                   0,
+  // any * qNaN = qNaN
+  if (test__multf3(0x1.23456789abcdefp+5Q,
+                   makeQNaN128(),
+                   0,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+  // sNaN * any = qNaN, FE_INVALID
+  if (test__multf3(makeNaN128(UINT64_C(0x100030000000)),
+                   FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+  // any * sNaN = qNaN, FE_INVALID
+  if (test__multf3(0x1.23456789abcdefp+5Q,
+                   makeNaN128(UINT64_C(0x100030000000)),
+                   FE_INVALID,
+                   0,
+
+  // +-inf * +-0 = qNaN, FE_INVALID
+  if (test__multf3(makeInf128(), 0.0, FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  if (test__multf3(makeInf128(), -0.0, FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  if (test__multf3(makeNegativeInf128(), 0.0, FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  if (test__multf3(makeNegativeInf128(), -0.0, FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  // +-0 * +-inf = qNaN, FE_INVALID
+  if (test__multf3(0.0, makeInf128(), FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  if (test__multf3(-0.0, makeInf128(), FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  if (test__multf3(0.0, makeNegativeInf128(), FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  if (test__multf3(-0.0, makeNegativeInf128(), FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+                   0,
+                   0,
+                   0,
+                   0,
+                   0,
 
-    return 0;
 }
 
 #endif

compiler-rt/test/builtins/Unit/subtf3_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_subtf3
 
-#include <fenv.h>
 #include <stdio.h>
 
 #include "int_lib.h"
-#include "fp_test.h"
+#include "fp_test_fenv.h"
 
 #if !defined(CRT_HAS_F128)
 int main() {
   fprintf(stderr, "Missing f128 support - skipping.\n");
   return 1;
 }
 #else
 
 // Returns: a - b
 COMPILER_RT_ABI f128 __subtf3(f128 a, f128 b);
 
-int _test__subtf3(int line, f128 a, f128 b,
+int _test__subtf3(int line, f128 a, f128 b, int expectedExc,
                   uint64_t expectedHi, uint64_t expectedLo) {
+  feclearexcept(FE_ALL_EXCEPT);
   f128 x = __subtf3(a, b);
+  int actualExc = fetestexcept(FE_ALL_EXCEPT);
   int ret = compareResultF128(x, expectedHi, expectedLo);
   if (ret) {
     printMismatchF128TwoArg(__FILE__, line, "__subtf3", a, b, x,
                             expectedHi, expectedLo);
   }
+  if (crt_sets_fp_exc_flags() && actualExc != expectedExc) {
+    fprintf(stderr, "%s:%d: Got unexpected floating-point exception %#x, expected %#x\n",
+            __FILE__, line, actualExc, expectedExc);
+    return 1;
+  }
   return ret;
 }
 
 #define test__subtf3(...) _test__subtf3(__LINE__, __VA_ARGS__)
 
 int main() {
   // qNaN - any = qNaN
   if (test__subtf3(makeQNaN128(),
                    0x1.23456789abcdefp+5Q,
+                   0,
                    UINT64_C(0x7fff800000000000),
                    UINT64_C(0x0)))
     return 1;
   // NaN - any = NaN
   if (test__subtf3(makeNaN128(UINT64_C(0x800030000000)),
                    0x1.23456789abcdefp+5Q,
+                   0,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+
+  // sNaN - any = qNaN, FE_INVALID
+  if (test__subtf3(makeNaN128(UINT64_C(0x12345)),
+                   0x1.23456789abcdefp+5Q,
+                   FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+  // any - sNaN = qNaN, FE_INVALID
+  if (test__subtf3(0x1.23456789abcdefp+5Q,
+                   makeNaN128(UINT64_C(0x12345)),
+                   FE_INVALID,
                    UINT64_C(0x7fff800000000000),
                    UINT64_C(0x0)))
     return 1;
   // inf - any = inf
   if (test__subtf3(makeInf128(),
                    0x1.23456789abcdefp+5Q,
+                   0,
                    UINT64_C(0x7fff000000000000),
                    UINT64_C(0x0)))
     return 1;
+  // inf - inf = NaN, FE_INVALID
+  if (test__subtf3(makeInf128(),
+                   makeInf128(),
+                   FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+  // -inf - -inf = NaN, FE_INVALID
+  if (test__subtf3(makeNegativeInf128(),
+                   makeNegativeInf128(),
+                   FE_INVALID,
+                   UINT64_C(0x7fff800000000000),
+                   UINT64_C(0x0)))
+    return 1;
+
   // any - any
   if (test__subtf3(0x1.234567829a3bcdef5678ade36734p+5Q,
                    0x1.ee9d7c52354a6936ab8d7654321fp-1Q,
+                   FE_INEXACT,
                    UINT64_C(0x40041b8af1915166),
                    UINT64_C(0xa44a7bca780a166c)))
     return 1;
 
 #if (defined(__arm__) || defined(__aarch64__)) && defined(__ARM_FP) || \
     defined(i386) || defined(__x86_64__)
   // Rounding mode tests on supported architectures
-    const f128 m = assertF128Representation(1234.02Q, UINT64_C(0x4009348147ae147a), UINT64_C(0xe147ae147ae147ae));
-    const f128 n = assertF128Representation(0.01Q, UINT64_C(0x3ff847ae147ae147), UINT64_C(0xae147ae147ae147b));
 
-    fesetround(FE_UPWARD);
-    if (test__subtf3(m, n,
-                     UINT64_C(0x40093480a3d70a3d),
-                     UINT64_C(0x70a3d70a3d70a3d7)))
-      return 1;
+  if (test__subtf3(m, n, FE_INEXACT,
 
-    fesetround(FE_DOWNWARD);
-    if (test__subtf3(m, n,
-                     UINT64_C(0x40093480a3d70a3d),
-                     UINT64_C(0x70a3d70a3d70a3d6)))
-      return 1;
+  if (test__subtf3(m, n, FE_INEXACT,
 
-    fesetround(FE_TOWARDZERO);
-    if (test__subtf3(m, n,
-                     UINT64_C(0x40093480a3d70a3d),
-                     UINT64_C(0x70a3d70a3d70a3d6)))
-      return 1;
+  if (test__subtf3(m, n, FE_INEXACT,
 
-    fesetround(FE_TONEAREST);
-    if (test__subtf3(m, n,
-                     UINT64_C(0x40093480a3d70a3d),
-                     UINT64_C(0x70a3d70a3d70a3d7)))
-      return 1;
+  if (test__subtf3(m, n, FE_INEXACT,
 #endif
-    return 0;
 }
 #endif