[builtins] Work around long double return bug on Solaris/sparcv9

[ro]

Summary

As detailed in Bug 47729, several long double tests FAIL on Solaris/sparcv9, ultimately because compiler-rt/lib/builtins/fp_lib.h (fromRep) or similar functions returning long double are miscompiled.

I've been using this patch as a workaround by compiling the affected functions without optimization.

Tested on sparcv9-sun-solaris2.11.

I don't seriously expect this hack to be accepted, but have several times seen that patches (however hacky) tend to attract more attention then bug reports, ultimately leading to a proper solution. Unfortunately, codegen bugs are way beyond my abilities to fix myself, so I have to rely on those who can.

compiler-rt/lib/builtins/floattitf.c

 // Assumption: fp_t is a IEEE 128 bit floating point type
 //             ti_int is a 128 bit integral type
 
 // seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 // mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
 // mmmm mmmm mmmm
 
 #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(__clang__) && defined(__sparc__)
+#pragma clang optimize off
+#endif
 COMPILER_RT_ABI fp_t __floattitf(ti_int a) {
   if (a == 0)
     return 0.0;
   const unsigned N = sizeof(ti_int) * CHAR_BIT;
   const ti_int s = a >> (N - 1);
   a = (a ^ s) - s;
   int sd = N - __clzti2(a); // number of significant digits
   int e = sd - 1;           // exponent
COMPILER_RT_ABI fp_t __floattitf(ti_int a) {
 
   long_double_bits fb;
   fb.u.high.all = (s & 0x8000000000000000LL)            // sign
                   | (du_int)(e + 16383) << 48           // exponent
                   | ((a >> 64) & 0x0000ffffffffffffLL); // significand
   fb.u.low.all = (du_int)(a);
   return fb.f;
 }
+#if defined(__clang__) && defined(__sparc__)
+#pragma clang optimize on
+#endif
 
 #endif

compiler-rt/lib/builtins/floatuntitf.c

 // Assumption: fp_t is a IEEE 128 bit floating point type
 //             tu_int is a 128 bit integral type
 
 // seee eeee eeee eeee mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 // mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
 // mmmm mmmm mmmm
 
 #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
+#if defined(__clang__) && defined(__sparc__)
+#pragma clang optimize off
+#endif
 COMPILER_RT_ABI fp_t __floatuntitf(tu_int a) {
   if (a == 0)
     return 0.0;
   const unsigned N = sizeof(tu_int) * CHAR_BIT;
   int sd = N - __clzti2(a); // number of significant digits
   int e = sd - 1;           // exponent
   if (sd > LDBL_MANT_DIG) {
     //  start:  0000000000000000000001xxxxxxxxxxxxxxxxxxxxxxPQxxxxxxxxxxxxxxxxxx
COMPILER_RT_ABI fp_t __floatuntitf(tu_int a) {
   }
 
   long_double_bits fb;
   fb.u.high.all = (du_int)(e + 16383) << 48             // exponent
                   | ((a >> 64) & 0x0000ffffffffffffLL); // significand
   fb.u.low.all = (du_int)(a);
   return fb.f;
 }
+#if defined(__clang__) && defined(__sparc__)
+#pragma clang optimize on
+#endif
 
 #endif

compiler-rt/lib/builtins/fp_extend.h

 #elif defined SRC_HALF
 typedef uint16_t src_t;
 typedef uint16_t src_rep_t;
 #define SRC_REP_C UINT16_C
 static const int srcSigBits = 10;
 #define src_rep_t_clz __builtin_clz
 
 #else
 #error Source should be half, single, or double precision!
 #endif // end source precision
 
 #if defined DST_SINGLE
 typedef float dst_t;
 typedef uint32_t dst_rep_t;
 #define DST_REP_C UINT32_C
 static const int dstSigBits = 23;
 
 #elif defined DST_DOUBLE
 typedef double dst_t;
 typedef uint64_t dst_rep_t;
 #define DST_REP_C UINT64_C
 static const int dstSigBits = 52;
 
 #elif defined DST_QUAD
 typedef long double dst_t;
 typedef __uint128_t dst_rep_t;
 #define DST_REP_C (__uint128_t)
 static const int dstSigBits = 112;
 
 #else
 #error Destination should be single, double, or quad precision!
 #endif // end destination precision
 
 // End of specialization parameters.  Two helper routines for conversion to and
 // from the representation of floating-point data as integer values follow.
 
 static __inline src_rep_t srcToRep(src_t x) {
   const union {
     src_t f;
     src_rep_t i;
   } rep = {.f = x};
   return rep.i;
 }
 
+#if defined(__clang__) && defined(__sparc__)
+#pragma clang optimize off
+#endif
 static __inline dst_t dstFromRep(dst_rep_t x) {
   const union {
     dst_t f;
     dst_rep_t i;
   } rep = {.i = x};
   return rep.f;
 }
+#if defined(__clang__) && defined(__sparc__)
+#pragma clang optimize on
+#endif
 // End helper routines.  Conversion implementation follows.
 
 #endif // FP_EXTEND_HEADER

compiler-rt/lib/builtins/fp_lib.h

 #undef Word_2
 #undef Word_3
 #undef Word_4
 #undef Word_HiMask
 #undef Word_LoMask
 #undef Word_FullMask
 #endif // __LDBL_MANT_DIG__ == 113 && __SIZEOF_INT128__
 #else
 #error SINGLE_PRECISION, DOUBLE_PRECISION or QUAD_PRECISION must be defined.
 #endif
 
 #if defined(SINGLE_PRECISION) || defined(DOUBLE_PRECISION) ||                  \
     defined(CRT_LDBL_128BIT)
 #define typeWidth (sizeof(rep_t) * CHAR_BIT)
 #define exponentBits (typeWidth - significandBits - 1)
 #define maxExponent ((1 << exponentBits) - 1)
 #define exponentBias (maxExponent >> 1)

 static __inline rep_t toRep(fp_t x) {
   const union {
     fp_t f;
     rep_t i;
   } rep = {.f = x};
   return rep.i;
 }
 
+// Work around miscompilation on sparcv9 (Bug 47729).
+#if defined(__clang__) && defined(__sparc__)
+#pragma clang optimize off
+#endif
 static __inline fp_t fromRep(rep_t x) {
   const union {
     fp_t f;
     rep_t i;
   } rep = {.i = x};
   return rep.f;
 }
+#if defined(__clang__) && defined(__sparc__)
+#pragma clang optimize on
+#endif
 
 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) {