[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

20

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

20

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

12

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

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

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

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

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
switch (fpcr) {
     default:
       return CRT_FE_TONEAREST;
   }
 #else
   return __aarch64_fe_default_rmode;
 #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
+}
+
 int __fe_raise_inexact(void) {
 #ifdef __ARM_FP
   uint64_t fpsr;
-  __asm__ __volatile__("mrs  %0, fpsr" : "=r" (fpsr));
-  __asm__ __volatile__("msr  fpsr, %0" : : "ri" (fpsr | AARCH64_INEXACT));
+  __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
+}

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
switch (fpscr) {
     default:
       return CRT_FE_TONEAREST;
   }
 #else
   return __arm_fe_default_rmode;
 #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
+}
+
 int __fe_raise_inexact(void) {
 #ifdef __ARM_FP
   uint32_t fpscr;
-  __asm__ __volatile__("vmrs  %0, fpscr" : "=r" (fpscr));
-  __asm__ __volatile__("vmsr  fpscr, %0" : : "ri" (fpscr | ARM_INEXACT));
+  __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
+}

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 || repIsSNaN(bRep))
+        __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 || repIsSNaN(aRep))
+        __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 || repIsSNaN(toRep(b)))
+        __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 || repIsSNaN(toRep(a)))
+        __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 fromRep(rep_t x) {
   const union {
     fp_t f;
     rep_t i;
   } rep = {.i = x};
   return rep.f;
 }
 
+static inline bool repIsSNaN(rep_t x) {
+  return ((x & absMask) > infRep && (x & quietBit) == 0);
+}
+
 static __inline int normalize(rep_t *significand) {
   const int shift = rep_clz(*significand) - rep_clz(implicitBit);
   *significand <<= shift;
   return 1 - shift;
 }
 
 static __inline void wideLeftShift(rep_t *hi, rep_t *lo, int count) {
   *hi = *hi << count | *lo >> (typeWidth - count);
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_divbyzero(void);
 int __fe_raise_inexact(void);
+int __fe_raise_invalid(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(void) { return CRT_FE_TONEAREST; }
 
-int __fe_raise_inexact(void) {
-  return 0;
-}
+int __fe_raise_divbyzero() { return 0; }
+
+int __fe_raise_inexact(void) { return 0; }
+
+int __fe_raise_invalid() { 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 || repIsSNaN(toRep(b)))
+        __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 || repIsSNaN(toRep(a)))
+        __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

switch (cw & X87_RMODE_MASK) {
     case X87_UPWARD:
       return CRT_FE_UPWARD;
     case X87_TOWARDZERO:
       return CRT_FE_TOWARDZERO;
   }
   return CRT_FE_TONEAREST;
 }
 
+int __fe_raise_divbyzero() {
+  float f = 1.0f, g = 0.0f;
+  __asm__ __volatile__("fdivs %1" : "+t"(f) : "m"(g));
+  return 0;
+}
+
 int __fe_raise_inexact(void) {
   float f = 1.0f, g = 3.0f;
-  __asm__ __volatile__ ("fdivs %1" : "+t" (f) : "m" (g));
+  __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;
+}

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

 //=== lib/builtins/riscv/fp_mode.c - Floaing-point mode utilities -*- 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
 //
 //===----------------------------------------------------------------------===//
 #include "../fp_mode.h"
 
 #define RISCV_TONEAREST  0x0
 #define RISCV_TOWARDZERO 0x1
 #define RISCV_DOWNWARD   0x2
 #define RISCV_UPWARD     0x3
 
-#define RISCV_INEXACT    0x1
+#define RISCV_INEXACT 0x01
+#define RISCV_UNDERFLOW 0x02
+#define RISCV_OVERFLOW 0x04
+#define RISCV_DIVBYZERO 0x08
+#define RISCV_INVALID 0x10
 
 CRT_FE_ROUND_MODE __fe_getround(void) {
 #if defined(__riscv_f)
   int frm;
   __asm__ __volatile__("frrm %0" : "=r" (frm));
   switch (frm) {
     case RISCV_TOWARDZERO:
       return CRT_FE_TOWARDZERO;
     case RISCV_DOWNWARD:
       return CRT_FE_DOWNWARD;
     case RISCV_UPWARD:
       return CRT_FE_UPWARD;
     case RISCV_TONEAREST:
     default:
       return CRT_FE_TONEAREST;
   }
 #else
   return CRT_FE_TONEAREST;
 #endif
 }
 
+int __fe_raise_divbyzero() {
+#if defined(__riscv_f)
+  __asm__ __volatile__("csrsi fflags, %0" ::"i"(RISCV_DIVBYZERO));
+#endif
+  return 0;
+}
+
 int __fe_raise_inexact(void) {
 #if defined(__riscv_f)
-  __asm__ __volatile__("csrsi fflags, %0" :: "i" (RISCV_INEXACT));
+  __asm__ __volatile__("csrsi fflags, %0" ::"i"(RISCV_INEXACT));
 #endif
   return 0;
 }
+
+int __fe_raise_invalid() {
+#if defined(__riscv_f)
+  __asm__ __volatile__("csrsi fflags, %0" ::"i"(RISCV_INVALID));
+#endif
+  return 0;
+}

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_addtf3
 
-#include <fenv.h>
+#define QUAD_PRECISION
+#include "fp_lib.h"
+#include "fp_test_fenv.h"
 #include <stdio.h>
 
-#if __LDBL_MANT_DIG__ == 113
-
-#include "int_lib.h"
-#include "fp_test.h"
+#if __LDBL_MANT_DIG__ != 113
+int main() {
+  fprintf(stderr, "Missing f128 support - skipping.\n");
+  return 1;
+}
+#else
+_Static_assert(sizeof(long double) == 16, "");
 
 // Returns: a + b
 COMPILER_RT_ABI long double __addtf3(long double a, long double b);
 
-int test__addtf3(long double a, long double b,
-                 uint64_t expectedHi, uint64_t expectedLo)
-{
-    long double x = __addtf3(a, b);
-    int ret = compareResultLD(x, expectedHi, expectedLo);
-
-    if (ret){
-        printf("error in test__addtf3(%.20Lf, %.20Lf) = %.20Lf, "
-               "expected %.20Lf\n", a, b, x,
-               fromRep128(expectedHi, expectedLo));
-    }
-
-    return ret;
+int _test__addtf3(int line, long double a, long double b, int expectedExc,
+                  uint64_t expectedHi, uint64_t expectedLo) {
+  feclearexcept(FE_ALL_EXCEPT);
+  int actualExc = fetestexcept(FE_ALL_EXCEPT);
+  if (ret) {
+    fprintf(stderr, "%s:%d: error in %s(" F128_FMT ", " F128_FMT ") ", __FILE__,
+            line, __func__, F128_ARG(a), F128_ARG(b));
+    printMismatchLD(x, expectedHi, expectedLo);
+  if (!checkFPException(__FILE__, line, actualExc, expectedExc))
+    ret = 1;
 }
+#  define test__addtf3(...) _test__addtf3(__LINE__, __VA_ARGS__)
 
-char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
-
-#endif
-
-int main()
-{
-#if __LDBL_MANT_DIG__ == 113
-    // qNaN + any = qNaN
-    if (test__addtf3(makeQNaN128(),
-                     0x1.23456789abcdefp+5L,
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // NaN + any = NaN
-    if (test__addtf3(makeNaN128(UINT64_C(0x800030000000)),
-                     0x1.23456789abcdefp+5L,
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // inf + inf = inf
-    if (test__addtf3(makeInf128(),
-                     makeInf128(),
-                     UINT64_C(0x7fff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // inf + any = inf
-    if (test__addtf3(makeInf128(),
-                     0x1.2335653452436234723489432abcdefp+5L,
-                     UINT64_C(0x7fff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // any + any
-    if (test__addtf3(0x1.23456734245345543849abcdefp+5L,
-                     0x1.edcba52449872455634654321fp-1L,
-                     UINT64_C(0x40042afc95c8b579),
-                     UINT64_C(0x61e58dd6c51eb77c)))
-        return 1;
+int main() {
+  if (test__addtf3(makeQNaN128(), 0x1.23456789abcdefp+5L, 0,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+  if (test__addtf3(makeNaN128(UINT64_C(0x800030000000)), 0x1.23456789abcdefp+5L,
+                   0, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+
+  // sNaN + any = qNaN, FE_INVALID
+  if (test__addtf3(makeNaN128(UINT64_C(0x12345)), TF_C(0x1.23456789abcdefp+5),
+                   FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+
+  // any + sNaN = qNaN, FE_INVALID
+  if (test__addtf3(TF_C(0x1.23456789abcdefp+5), makeNaN128(UINT64_C(0x12345)),
+                   FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+
+  if (test__addtf3(makeInf128(), makeInf128(), 0, UINT64_C(0x7fff000000000000),
+  if (test__addtf3(makeInf128(), 0x1.2335653452436234723489432abcdefp+5L, 0,
+                   UINT64_C(0x7fff000000000000), UINT64_C(0x0)))
+
+  // 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;
+
+                   0x1.edcba52449872455634654321fp-1L, 0,
+                   UINT64_C(0x40042afc95c8b579), UINT64_C(0x61e58dd6c51eb77c)))
 
-#if (defined(__arm__) || defined(__aarch64__)) && defined(__ARM_FP) || \
-    defined(i386) || defined(__x86_64__) || (defined(__loongarch__) && \
-    __loongarch_frlen != 0)
-    // Rounding mode tests on supported architectures
-    const long double m = 1234.0L, n = 0.01L;
+#  if (defined(__arm__) || defined(__aarch64__)) && defined(__ARM_FP) ||       \
+      defined(i386) || defined(__x86_64__) ||                                  \
+      (defined(__loongarch__) && __loongarch_frlen != 0)
+  const long double m = assertLDRepresentation(
+      1234.0Q, UINT64_C(0x4009348000000000), UINT64_C(0x0000000000000000));
+  // Closest approximation of 0.1 for f128:
+  const long double n = assertLDRepresentation(
+      0.01Q, UINT64_C(0x3ff847ae147ae147), UINT64_C(0xae147ae147ae147b));
 
-    fesetround(FE_UPWARD);
-    if (test__addtf3(m, n,
-                     UINT64_C(0x40093480a3d70a3d),
-                     UINT64_C(0x70a3d70a3d70a3d8)))
-        return 1;
+  if (test__addtf3(m, n, FE_INEXACT, UINT64_C(0x40093480a3d70a3d),
 
-    fesetround(FE_DOWNWARD);
-    if (test__addtf3(m, n,
-                     UINT64_C(0x40093480a3d70a3d),
-                     UINT64_C(0x70a3d70a3d70a3d7)))
-        return 1;
+  if (test__addtf3(m, n, FE_INEXACT, UINT64_C(0x40093480a3d70a3d),
 
-
-    fesetround(FE_TOWARDZERO);
-    if (test__addtf3(m, n,
-                     UINT64_C(0x40093480a3d70a3d),
-                     UINT64_C(0x70a3d70a3d70a3d7)))
-        return 1;
+  if (test__addtf3(m, n, FE_INEXACT, UINT64_C(0x40093480a3d70a3d),
 
-    fesetround(FE_TONEAREST);
-    if (test__addtf3(m, n,
-                     UINT64_C(0x40093480a3d70a3d),
-                     UINT64_C(0x70a3d70a3d70a3d7)))
-        return 1;
-#endif
+  if (test__addtf3(m, n, FE_INEXACT, UINT64_C(0x40093480a3d70a3d),
+#  endif
 
-#else
-    printf("skipped\n");
-
-#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"
+#define QUAD_PRECISION
+#include "fp_lib.h"
+#include "fp_test_fenv.h"
 #include <stdio.h>
 
-#if __LDBL_MANT_DIG__ == 113
-
-#include "fp_test.h"
+#if __LDBL_MANT_DIG__ != 113
+int main() {
+  fprintf(stderr, "Missing f128 support - skipping.\n");
+  return 1;
+}
+#else
+_Static_assert(sizeof(long double) == 16, "");
 
 // Returns: a / b
 COMPILER_RT_ABI long double __divtf3(long double a, long double b);
 
-int test__divtf3(long double a, long double b,
-                 uint64_t expectedHi, uint64_t expectedLo)
-{
-    long double x = __divtf3(a, b);
-    int ret = compareResultLD(x, expectedHi, expectedLo);
+int _test__divtf3(int line, long double a, long double b, int expectedExc,
+                  uint64_t expectedHi, uint64_t expectedLo) {
+  feclearexcept(FE_ALL_EXCEPT);
+  int actualExc = fetestexcept(FE_ALL_EXCEPT);
 
-    if (ret){
-        printf("error in test__divtf3(%.20Le, %.20Le) = %.20Le, "
-               "expected %.20Le\n", a, b, x,
-               fromRep128(expectedHi, expectedLo));
-    }
-    return ret;
+  if (ret) {
+    fprintf(stderr, "%s:%d: error in %s(" F128_FMT ", " F128_FMT ") ", __FILE__,
+            line, __func__, F128_ARG(a), F128_ARG(b));
+    printMismatchLD(x, expectedHi, expectedLo);
+  if (!checkFPException(__FILE__, line, actualExc, expectedExc))
+    ret = 1;
 }
+#  define test__divtf3(...) _test__divtf3(__LINE__, __VA_ARGS__)
 
-char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
-
-#endif
-
-int main()
-{
-#if __LDBL_MANT_DIG__ == 113
-    // Returned NaNs are assumed to be qNaN by default
+int main() {
 
-    // qNaN / any = qNaN
-    if (test__divtf3(makeQNaN128(),
-                     0x1.23456789abcdefp+5L,
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // NaN / any = NaN
-    if (test__divtf3(makeNaN128(UINT64_C(0x30000000)),
-                     0x1.23456789abcdefp+5L,
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // any / qNaN = qNaN
-    if (test__divtf3(0x1.23456789abcdefp+5L,
-                     makeQNaN128(),
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // any / NaN = NaN
-    if (test__divtf3(0x1.23456789abcdefp+5L,
-                     makeNaN128(UINT64_C(0x30000000)),
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
+  if (test__divtf3(makeQNaN128(), 0x1.23456789abcdefp+5L, 0,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+  // sNaN / any = qNaN, FE_INVALID
+  if (test__divtf3(makeNaN128(UINT64_C(0x30000000)), 0x1.23456789abcdefp+5L,
+                   FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+  if (test__divtf3(0x1.23456789abcdefp+5L, makeQNaN128(), 0,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+  // any / sNaN = NaN, FE_INVALID
+  if (test__divtf3(0x1.23456789abcdefp+5L, makeNaN128(UINT64_C(0x30000000)),
+                   FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
 
-    // +Inf / positive = +Inf
-    if (test__divtf3(makeInf128(), 3.L,
-                     UINT64_C(0x7fff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // +Inf / negative = -Inf
-    if (test__divtf3(makeInf128(), -3.L,
-                     UINT64_C(0xffff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // -Inf / positive = -Inf
-    if (test__divtf3(makeNegativeInf128(), 3.L,
-                     UINT64_C(0xffff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // -Inf / negative = +Inf
-    if (test__divtf3(makeNegativeInf128(), -3.L,
-                     UINT64_C(0x7fff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
+  if (test__divtf3(makeInf128(), 3.L, 0, UINT64_C(0x7fff000000000000),
+  if (test__divtf3(makeInf128(), -3.L, 0, UINT64_C(0xffff000000000000),
+  if (test__divtf3(makeNegativeInf128(), 3.L, 0, UINT64_C(0xffff000000000000),
+  if (test__divtf3(makeNegativeInf128(), -3.L, 0, UINT64_C(0x7fff000000000000),
 
-    // Inf / Inf = NaN
-    if (test__divtf3(makeInf128(), makeInf128(),
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // 0.0 / 0.0 = NaN
-    if (test__divtf3(+0x0.0p+0L, +0x0.0p+0L,
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // +0.0 / +Inf = +0.0
-    if (test__divtf3(+0x0.0p+0L, makeInf128(),
-                     UINT64_C(0x0),
-                     UINT64_C(0x0)))
-        return 1;
-    // +Inf / +0.0 = +Inf
-    if (test__divtf3(makeInf128(), +0x0.0p+0L,
-                     UINT64_C(0x7fff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
+  // Inf / Inf = qNaN, FE_INVALID
+  if (test__divtf3(makeInf128(), makeInf128(), FE_INVALID,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+  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 = qNaN, FE_INVALID
+  if (test__divtf3(+TF_C(0x0.0p+0), +TF_C(0x0.0p+0), FE_INVALID,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+  if (test__divtf3(+TF_C(0x0.0p+0), -TF_C(0x0.0p+0), FE_INVALID,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  if (test__divtf3(-TF_C(0x0.0p+0), +TF_C(0x0.0p+0), FE_INVALID,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  if (test__divtf3(-TF_C(0x0.0p+0), -TF_C(0x0.0p+0), FE_INVALID,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+
+  if (test__divtf3(+0x0.0p+0L, makeInf128(), 0, UINT64_C(0x0), UINT64_C(0x0)))
+  if (test__divtf3(makeInf128(), +0x0.0p+0L, 0, UINT64_C(0x7fff000000000000),
 
-    // positive / +0.0 = +Inf
-    if (test__divtf3(+1.0L, +0x0.0p+0L,
-                     UINT64_C(0x7fff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // positive / -0.0 = -Inf
-    if (test__divtf3(+1.0L, -0x0.0p+0L,
-                     UINT64_C(0xffff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // negative / +0.0 = -Inf
-    if (test__divtf3(-1.0L, +0x0.0p+0L,
-                     UINT64_C(0xffff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // negative / -0.0 = +Inf
-    if (test__divtf3(-1.0L, -0x0.0p+0L,
-                     UINT64_C(0x7fff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
+  // positive / +0.0 = +Inf, FE_DIVBYZERO
+  if (test__divtf3(+1.0L, +0x0.0p+0L, FE_DIVBYZERO,
+                   UINT64_C(0x7fff000000000000), UINT64_C(0x0)))
+  // positive / -0.0 = -Inf, FE_DIVBYZERO
+  if (test__divtf3(+1.0L, -0x0.0p+0L, FE_DIVBYZERO,
+                   UINT64_C(0xffff000000000000), UINT64_C(0x0)))
+  if (test__divtf3(-1.0L, +0x0.0p+0L, FE_DIVBYZERO,
+                   UINT64_C(0xffff000000000000), UINT64_C(0x0)))
+  if (test__divtf3(-1.0L, -0x0.0p+0L, FE_DIVBYZERO,
+                   UINT64_C(0x7fff000000000000), UINT64_C(0x0)))
 
-    // 1/3
-    if (test__divtf3(1.L, 3.L,
-                     UINT64_C(0x3ffd555555555555),
-                     UINT64_C(0x5555555555555555)))
-        return 1;
-    // smallest normal result
-    if (test__divtf3(0x1.0p-16381L, 2.L,
-                     UINT64_C(0x0001000000000000),
-                     UINT64_C(0x0)))
-        return 1;
+  if (test__divtf3(1.L, 3.L, 0, UINT64_C(0x3ffd555555555555),
+  if (test__divtf3(0x1.0p-16381L, 2.L, 0, UINT64_C(0x0001000000000000),
 
-    // divisor is exactly 1.0
-    if (test__divtf3(0x1.0p+0L,
-                     0x1.0p+0L,
-                     UINT64_C(0x3fff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // divisor is truncated to exactly 1.0 in UQ1.63
-    if (test__divtf3(0x1.0p+0L,
-                     0x1.0000000000000001p+0L,
-                     UINT64_C(0x3ffeffffffffffff),
-                     UINT64_C(0xfffe000000000000)))
-        return 1;
+  if (test__divtf3(0x1.0p+0L, 0x1.0p+0L, 0, UINT64_C(0x3fff000000000000),
+  if (test__divtf3(0x1.0p+0L, 0x1.0000000000000001p+0L, 0,
+                   UINT64_C(0x3ffeffffffffffff), UINT64_C(0xfffe000000000000)))
 
-    // smallest normal value divided by 2.0
-    if (test__divtf3(0x1.0p-16382L, 2.L, UINT64_C(0x0000800000000000), UINT64_C(0x0)))
-      return 1;
-    // smallest subnormal result
-    if (test__divtf3(0x1.0p-16382L, 0x1p+112L, UINT64_C(0x0), UINT64_C(0x1)))
-      return 1;
+  if (test__divtf3(0x1.0p-16382L, 2.L, 0, UINT64_C(0x0000800000000000),
+                   UINT64_C(0x0)))
+  if (test__divtf3(0x1.0p-16382L, 0x1p+112L, 0, UINT64_C(0x0), UINT64_C(0x1)))
 
-    // any / any
-    if (test__divtf3(0x1.a23b45362464523375893ab4cdefp+5L,
-                     0x1.eedcbaba3a94546558237654321fp-1L,
-                     UINT64_C(0x4004b0b72924d407),
-                     UINT64_C(0x0717e84356c6eba2)))
-        return 1;
-    if (test__divtf3(0x1.a2b34c56d745382f9abf2c3dfeffp-50L,
-                     0x1.ed2c3ba15935332532287654321fp-9L,
-                     UINT64_C(0x3fd5b2af3f828c9b),
-                     UINT64_C(0x40e51f64cde8b1f2)))
-        return 15;
-    if (test__divtf3(0x1.2345f6aaaa786555f42432abcdefp+456L,
-                     0x1.edacbba9874f765463544dd3621fp+6400L,
-                     UINT64_C(0x28c62e15dc464466),
-                     UINT64_C(0xb5a07586348557ac)))
-        return 1;
-    if (test__divtf3(0x1.2d3456f789ba6322bc665544edefp-234L,
-                     0x1.eddcdba39f3c8b7a36564354321fp-4455L,
-                     UINT64_C(0x507b38442b539266),
-                     UINT64_C(0x22ce0f1d024e1252)))
-        return 1;
-    if (test__divtf3(0x1.2345f6b77b7a8953365433abcdefp+234L,
-                     0x1.edcba987d6bb3aa467754354321fp-4055L,
-                     UINT64_C(0x50bf2e02f0798d36),
-                     UINT64_C(0x5e6fcb6b60044078)))
-        return 1;
-    if (test__divtf3(6.72420628622418701252535563464350521E-4932L,
-                     2.L,
-                     UINT64_C(0x0001000000000000),
-                     UINT64_C(0)))
-        return 1;
+                   TF_C(0x1.eedcbaba3a94546558237654321fp-1), 0,
+                   UINT64_C(0x4004b0b72924d407), UINT64_C(0x0717e84356c6eba2)))
+    return 1;
+  if (test__divtf3(TF_C(0x1.a2b34c56d745382f9abf2c3dfeffp-50),
+                   TF_C(0x1.ed2c3ba15935332532287654321fp-9), 0,
+                   UINT64_C(0x3fd5b2af3f828c9b), UINT64_C(0x40e51f64cde8b1f2)))
+    return 1;
+  if (test__divtf3(TF_C(0x1.2345f6aaaa786555f42432abcdefp+456),
+                   TF_C(0x1.edacbba9874f765463544dd3621fp+6400), 0,
+                   UINT64_C(0x28c62e15dc464466), UINT64_C(0xb5a07586348557ac)))
+    return 1;
+  if (test__divtf3(TF_C(0x1.2d3456f789ba6322bc665544edefp-234),
+                   TF_C(0x1.eddcdba39f3c8b7a36564354321fp-4455), 0,
+                   UINT64_C(0x507b38442b539266), UINT64_C(0x22ce0f1d024e1252)))
+    return 1;
+  if (test__divtf3(TF_C(0x1.2345f6b77b7a8953365433abcdefp+234),
+                   TF_C(0x1.edcba987d6bb3aa467754354321fp-4055), 0,
+                   UINT64_C(0x50bf2e02f0798d36), UINT64_C(0x5e6fcb6b60044078)))
+  if (test__divtf3(TF_C(6.72420628622418701252535563464350521E-4932), TF_C(2.),
+                   0, UINT64_C(0x0001000000000000), UINT64_C(0)))
 
-#else
-    printf("skipped\n");
-
-#endif
-    return 0;
 }
+
+#endif

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

-#include <stdlib.h>
+#include <inttypes.h>
 #include <limits.h>
-#include <string.h>
 #include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #ifdef COMPILER_RT_HAS_FLOAT16
 #define TYPE_FP16 _Float16
 #else
 #define TYPE_FP16 uint16_t
 #endif
 
 enum EXPECTED_RESULT {
static inline int compareResultLD(long double result,
     else if (expectedHi == 0x7fff800000000000UL && expectedLo == 0x0UL){
         if ((hi & 0x7fff000000000000UL) == 0x7fff000000000000UL &&
             ((hi & 0xffffffffffffUL) > 0 || lo > 0)){
             return 0;
         }
     }
     return 1;
 }
+
+#  define F128_FMT "%.20Lg (0x%016" PRIx64 "%016" PRIx64 ")"
+#  define F128_ARG(x)                                                          \
+    ((long double)(x)), (uint64_t)(toRep128(x) >> 64), (uint64_t)(toRep128(x))
+
+static inline void printMismatchLD(long double result, uint64_t expectedHi,
+                                   uint64_t expectedLo) {
+    long double expected = fromRep128(expectedHi, expectedLo);
+    fprintf(stderr, "expected " F128_FMT " but got " F128_FMT "\n",
+            F128_ARG(expected), F128_ARG(result));
+}
+
+static inline long double _assertLDRepresentation(const char *str,
+                                                  long double value,
+                                                  uint64_t expectedHi,
+                                                  uint64_t expectedLo) {
+    if (compareResultLD(value, expectedHi, expectedLo)) {
+        fprintf(stderr, "Unexpected representation of %s: ", str);
+        printMismatchLD(value, expectedHi, expectedLo);
+        exit(1);
+    }
+    return value;
+}
+#  define assertLDRepresentation(value, ...)                                   \
+    _assertLDRepresentation(#value, value, __VA_ARGS__)
+
 #endif
 
 static inline int compareResultCMP(int result,
                                    enum EXPECTED_RESULT expected)
 {
     switch(expected){
         case LESS_0:
             if (result < 0)

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

+#include "fp_mode.h"
+#include "fp_test.h"
+#include <fenv.h>
+#include <stdbool.h>
+#include <stdio.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;
+}
+
+static inline bool checkFPException(const char *file, int line, int actualExc,
+                                    int expectedExc) {
+  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 false;
+  }
+  return true;
+}

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_multf3
 
+#define QUAD_PRECISION
+#include "fp_lib.h"
+#include "fp_test_fenv.h"
 #include <stdio.h>
 
-#if __LDBL_MANT_DIG__ == 113
-
-#include "int_lib.h"
-#include "fp_test.h"
+#if __LDBL_MANT_DIG__ != 113
+int main() {
+  fprintf(stderr, "Missing f128 support - skipping.\n");
+  return 1;
+}
+#else
+_Static_assert(sizeof(long double) == 16, "");
 
 // Returns: a * b
 COMPILER_RT_ABI long double __multf3(long double a, long double b);
 
-int test__multf3(long double a, long double b,
-                 uint64_t expectedHi, uint64_t expectedLo)
-{
-    long double x = __multf3(a, b);
-    int ret = compareResultLD(x, expectedHi, expectedLo);
-
-    if (ret){
-        printf("error in test__multf3(%.20Lf, %.20Lf) = %.20Lf, "
-               "expected %.20Lf\n", a, b, x,
-               fromRep128(expectedHi, expectedLo));
-    }
-    return ret;
+int _test__multf3(int line, long double a, long double b, int expectedExc,
+                  uint64_t expectedHi, uint64_t expectedLo) {
+  feclearexcept(FE_ALL_EXCEPT);
+  int actualExc = fetestexcept(FE_ALL_EXCEPT);
+  if (ret) {
+    fprintf(stderr, "%s:%d: error in %s(" F128_FMT ", " F128_FMT ") ", __FILE__,
+            line, __func__, F128_ARG(a), F128_ARG(b));
+    printMismatchLD(x, expectedHi, expectedLo);
+  if (!checkFPException(__FILE__, line, actualExc, expectedExc))
+    ret = 1;
 }
+#  define test__multf3(...) _test__multf3(__LINE__, __VA_ARGS__)
 
-char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
-
-#endif
-
-int main()
-{
-#if __LDBL_MANT_DIG__ == 113
-    // qNaN * any = qNaN
-    if (test__multf3(makeQNaN128(),
-                     0x1.23456789abcdefp+5L,
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // NaN * any = NaN
-    if (test__multf3(makeNaN128(UINT64_C(0x800030000000)),
-                     0x1.23456789abcdefp+5L,
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // inf * any = inf
-    if (test__multf3(makeInf128(),
-                     0x1.23456789abcdefp+5L,
-                     UINT64_C(0x7fff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // any * any
-    if (test__multf3(0x1.2eab345678439abcdefea56782346p+5L,
-                     0x1.edcb34a235253948765432134674fp-1L,
-                     UINT64_C(0x400423e7f9e3c9fc),
-                     UINT64_C(0xd906c2c2a85777c4)))
-        return 1;
-    if (test__multf3(0x1.353e45674d89abacc3a2ebf3ff4ffp-50L,
-                     0x1.ed8764648369535adf4be3214567fp-9L,
-                     UINT64_C(0x3fc52a163c6223fc),
-                     UINT64_C(0xc94c4bf0430768b4)))
-        return 1;
-    if (test__multf3(0x1.234425696abcad34a35eeffefdcbap+456L,
-                     0x451.ed98d76e5d46e5f24323dff21ffp+600L,
-                     UINT64_C(0x44293a91de5e0e94),
-                     UINT64_C(0xe8ed17cc2cdf64ac)))
-        return 1;
-    if (test__multf3(0x1.4356473c82a9fabf2d22ace345defp-234L,
-                     0x1.eda98765476743ab21da23d45678fp-455L,
-                     UINT64_C(0x3d4f37c1a3137cae),
-                     UINT64_C(0xfc6807048bc2836a)))
-        return 1;
-    // underflow
-    if (test__multf3(0x1.23456734245345p-10000L,
-                     0x1.edcba524498724p-6497L,
-                     UINT64_C(0x0),
-                     UINT64_C(0x0)))
-        return 1;
+int main() {
+  if (test__multf3(makeQNaN128(), TF_C(0x1.23456789abcdefp+5), 0,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  // any * qNaN = qNaN
+  if (test__multf3(TF_C(0x1.23456789abcdefp+5), makeQNaN128(), 0,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  // sNaN * any = qNaN, FE_INVALID
+  if (test__multf3(makeNaN128(UINT64_C(0x100030000000)),
+                   TF_C(0x1.23456789abcdefp+5), FE_INVALID,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  // any * sNaN = qNaN, FE_INVALID
+  if (test__multf3(TF_C(0x1.23456789abcdefp+5),
+                   makeNaN128(UINT64_C(0x100030000000)), FE_INVALID,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  // inf * any = inf
+  if (test__multf3(makeInf128(), TF_C(0x1.23456789abcdefp+5), 0,
+                   UINT64_C(0x7fff000000000000), UINT64_C(0x0)))
+    return 1;
+
+  // +-inf * +-0 = qNaN, FE_INVALID
+  if (test__multf3(makeInf128(), 0.0, FE_INVALID, UINT64_C(0x7fff800000000000),
+  if (test__multf3(makeInf128(), -0.0, FE_INVALID, UINT64_C(0x7fff800000000000),
+  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),
+  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;
+  if (test__multf3(TF_C(0x1.2eab345678439abcdefea56782346p+5),
+                   TF_C(0x1.edcb34a235253948765432134674fp-1), 0,
+                   UINT64_C(0x400423e7f9e3c9fc), UINT64_C(0xd906c2c2a85777c4)))
+    return 1;
+  if (test__multf3(TF_C(0x1.353e45674d89abacc3a2ebf3ff4ffp-50),
+                   TF_C(0x1.ed8764648369535adf4be3214567fp-9), 0,
+                   UINT64_C(0x3fc52a163c6223fc), UINT64_C(0xc94c4bf0430768b4)))
+    return 1;
+  if (test__multf3(TF_C(0x1.234425696abcad34a35eeffefdcbap+456),
+                   TF_C(0x451.ed98d76e5d46e5f24323dff21ffp+600), 0,
+                   UINT64_C(0x44293a91de5e0e94), UINT64_C(0xe8ed17cc2cdf64ac)))
+    return 1;
+  if (test__multf3(TF_C(0x1.4356473c82a9fabf2d22ace345defp-234),
+                   TF_C(0x1.eda98765476743ab21da23d45678fp-455), 0,
+                   UINT64_C(0x3d4f37c1a3137cae), UINT64_C(0xfc6807048bc2836a)))
+  if (test__multf3(TF_C(0x1.23456734245345p-10000),
+                   TF_C(0x1.edcba524498724p-6497), 0, UINT64_C(0x0),
 
-#else
-    printf("skipped\n");
-
-#endif
-    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>
+#define QUAD_PRECISION
+#include "fp_lib.h"
+#include "fp_test_fenv.h"
 #include <stdio.h>
 
-#if __LDBL_MANT_DIG__ == 113
-
-#include "int_lib.h"
-#include "fp_test.h"
+#if __LDBL_MANT_DIG__ != 113
+int main() {
+  fprintf(stderr, "Missing f128 support - skipping.\n");
+  return 1;
+}
+#else
+_Static_assert(sizeof(long double) == 16, "");
 
 // Returns: a - b
 COMPILER_RT_ABI long double __subtf3(long double a, long double b);
 
-int test__subtf3(long double a, long double b,
-                 uint64_t expectedHi, uint64_t expectedLo)
-{
-    long double x = __subtf3(a, b);
-    int ret = compareResultLD(x, expectedHi, expectedLo);
+int _test__subtf3(int line, long double a, long double b, int expectedExc,
+                  uint64_t expectedHi, uint64_t expectedLo) {
+
+  feclearexcept(FE_ALL_EXCEPT);
+  int actualExc = fetestexcept(FE_ALL_EXCEPT);
 
-    if (ret){
-        printf("error in test__subtf3(%.20Lf, %.20Lf) = %.20Lf, "
-               "expected %.20Lf\n", a, b, x,
-               fromRep128(expectedHi, expectedLo));
-    }
-    return ret;
+  if (ret) {
+    fprintf(stderr, "%s:%d: error in %s(" F128_FMT ", " F128_FMT ") ", __FILE__,
+            line, __func__, F128_ARG(a), F128_ARG(b));
+    printMismatchLD(x, expectedHi, expectedLo);
+
+  if (!checkFPException(__FILE__, line, actualExc, expectedExc))
+    ret = 1;
 }
 
-char assumption_1[sizeof(long double) * CHAR_BIT == 128] = {0};
-
-#endif
+#  define test__subtf3(...) _test__subtf3(__LINE__, __VA_ARGS__)
 
-int main()
-{
-#if __LDBL_MANT_DIG__ == 113
-    // qNaN - any = qNaN
-    if (test__subtf3(makeQNaN128(),
-                     0x1.23456789abcdefp+5L,
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // NaN - any = NaN
-    if (test__subtf3(makeNaN128(UINT64_C(0x800030000000)),
-                     0x1.23456789abcdefp+5L,
-                     UINT64_C(0x7fff800000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // inf - any = inf
-    if (test__subtf3(makeInf128(),
-                     0x1.23456789abcdefp+5L,
-                     UINT64_C(0x7fff000000000000),
-                     UINT64_C(0x0)))
-        return 1;
-    // any - any
-    if (test__subtf3(0x1.234567829a3bcdef5678ade36734p+5L,
-                     0x1.ee9d7c52354a6936ab8d7654321fp-1L,
-                     UINT64_C(0x40041b8af1915166),
-                     UINT64_C(0xa44a7bca780a166c)))
-        return 1;
+int main() {
+  if (test__subtf3(makeQNaN128(), TF_C(0x1.23456789abcdefp+5), 0,
+                   UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+                   TF_C(0x1.23456789abcdefp+5), 0, UINT64_C(0x7fff800000000000),
+
+  // sNaN - any = qNaN, FE_INVALID
+  if (test__subtf3(makeNaN128(UINT64_C(0x12345)), TF_C(0x1.23456789abcdefp+5),
+                   FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  // any - sNaN = qNaN, FE_INVALID
+  if (test__subtf3(TF_C(0x1.23456789abcdefp+5), makeNaN128(UINT64_C(0x12345)),
+                   FE_INVALID, UINT64_C(0x7fff800000000000), UINT64_C(0x0)))
+    return 1;
+  if (test__subtf3(makeInf128(), TF_C(0x1.23456789abcdefp+5), 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)))
+
+  if (test__subtf3(TF_C(0x1.234567829a3bcdef5678ade36734p+5),
+                   TF_C(0x1.ee9d7c52354a6936ab8d7654321fp-1), FE_INEXACT,
+                   UINT64_C(0x40041b8af1915166), UINT64_C(0xa44a7bca780a166c)))
 
-#if (defined(__arm__) || defined(__aarch64__)) && defined(__ARM_FP) || \
-    defined(i386) || defined(__x86_64__) || (defined(__loongarch__) && \
-    __loongarch_frlen != 0)
-    // Rounding mode tests on supported architectures
-    const long double m = 1234.02L, n = 0.01L;
+#  if ((defined(__arm__) || defined(__aarch64__)) && defined(__ARM_FP)) ||     \
+      defined(i386) || defined(__x86_64__)
+  const long double m = assertLDRepresentation(
+      1234.02Q, UINT64_C(0x4009348147ae147a), UINT64_C(0xe147ae147ae147ae));
+  const long double n = assertLDRepresentation(
+      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, UINT64_C(0x40093480a3d70a3d),
 
-    fesetround(FE_DOWNWARD);
-    if (test__subtf3(m, n,
-                     UINT64_C(0x40093480a3d70a3d),
-                     UINT64_C(0x70a3d70a3d70a3d6)))
-        return 1;
+  if (test__subtf3(m, n, FE_INEXACT, UINT64_C(0x40093480a3d70a3d),
 
-    fesetround(FE_TOWARDZERO);
-    if (test__subtf3(m, n,
-                     UINT64_C(0x40093480a3d70a3d),
-                     UINT64_C(0x70a3d70a3d70a3d6)))
-        return 1;
+  if (test__subtf3(m, n, FE_INEXACT, UINT64_C(0x40093480a3d70a3d),
 
-    fesetround(FE_TONEAREST);
-    if (test__subtf3(m, n,
-                     UINT64_C(0x40093480a3d70a3d),
-                     UINT64_C(0x70a3d70a3d70a3d7)))
-        return 1;
-#endif
-
-#else
-    printf("skipped\n");
-
-#endif
-    return 0;
+  if (test__subtf3(m, n, FE_INEXACT, UINT64_C(0x40093480a3d70a3d),
+#  endif
 }
+#endif