[compiler-rt][builtins] Do not assume int to be at least 32 bit wide

[atrosinenko]

Summary

This patch drops implicit assumptions on int/unsigned types being at least 32 bit wide. This is not always true on 16 bit targets such as MSP430.

This patch contains the following changes:

• rep_clz(a) and src_rep_t_clz(a) for 64-bit rep_t from soft-float utility headers are moved to int_lib.h as a common clzdi(a) implementation (signedness was changed to match one of __builtin_clz series of intrinsics). The original functions was turned into inline proxy functions that merely adapt the signedness
• __floatsi[st]f and __floatunsi[st]f3 are updated to accept a signed/unsigned integer argument of a specific width
• similar changes were made for some unit tests
• __udivmoddi4 switched to ctzsi macro defined in int_lib.h instead of __builtin_ctz
• the *vfp LibCall versions were NOT touched

[atrosinenko]

On one hand, this clzdi() implementation should be completely harmless when fallback is implemented via clzsi(). On the other hand, it may possibly be completely removed. This code snippet mimics one already existing for clzsi in int_types.h and for currently supported targets it can probably be even as simple as this (provided we can use C99):

#if ULLONG_MAX == 0xFFFFFFFFFFFFFFFF
#define clzdi __builtin_clzll
#define ctzdi __builtin_ctzll
#else
#error could not determine appropriate clzdi macro for this system
#endif

compiler-rt/lib/builtins/int_lib.h

149

@scanon

This function was copied from fp_lib.h almost unchanged, so it can be used from fp_extend.h (the version from that file is almost identical except it does not use the properly-sized clzsi() macro). But is this manual fallback implementation useful nowadays? As I can see, the implementation in fp_lib.h remained almost untouched since 2010 when this file was uploaded via rGb1fdde1d01a3: Adding soft-float comparisons, addition, subtraction, multiplication and…. Now, __builtin_clzll is used in many places of compiler-rt/builtins library for seemingly the same purpose.

[atrosinenko]

Replaced this by D86546: [compiler-rt][builtins] Use explicitly-sized integer types for LibCalls and D86547: [compiler-rt][builtins] Use c[tl]zsi macro instead of __builtin_c[tl]z. These two patches include everything except for factoring out src_rep_t_clz() and rep_clz() to clzdi() for now.

compiler-rt/lib/builtins/floatsisf.c

 //
 //===----------------------------------------------------------------------===//
 
 #define SINGLE_PRECISION
 #include "fp_lib.h"
 
 #include "int_lib.h"
 
-COMPILER_RT_ABI fp_t __floatsisf(int a) {
+COMPILER_RT_ABI fp_t __floatsisf(si_int a) {
 
   const int aWidth = sizeof a * CHAR_BIT;
 
   // Handle zero as a special case to protect clz
   if (a == 0)
     return fromRep(0);
 
   // All other cases begin by extracting the sign and absolute value of a
   rep_t sign = 0;
   if (a < 0) {
     sign = signBit;
     a = -a;
   }
 
   // Exponent of (fp_t)a is the width of abs(a).
-  const int exponent = (aWidth - 1) - __builtin_clz(a);
+  const int exponent = (aWidth - 1) - clzsi(a);
   rep_t result;
 
   // Shift a into the significand field, rounding if it is a right-shift
   if (exponent <= significandBits) {
     const int shift = significandBits - exponent;
     result = (rep_t)a << shift ^ implicitBit;
   } else {
     const int shift = exponent - significandBits;

compiler-rt/lib/builtins/floatsitf.c

 // mode.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
-COMPILER_RT_ABI fp_t __floatsitf(int a) {
+COMPILER_RT_ABI fp_t __floatsitf(si_int a) {
 
   const int aWidth = sizeof a * CHAR_BIT;
 
   // Handle zero as a special case to protect clz
   if (a == 0)
     return fromRep(0);
 
   // All other cases begin by extracting the sign and absolute value of a
   rep_t sign = 0;
-  unsigned aAbs = (unsigned)a;
+  su_int aAbs = (su_int)a;
   if (a < 0) {
     sign = signBit;
-    aAbs = ~(unsigned)a + 1U;
+    aAbs = ~(su_int)a + 1U;
   }
 
   // Exponent of (fp_t)a is the width of abs(a).
-  const int exponent = (aWidth - 1) - __builtin_clz(aAbs);
+  const int exponent = (aWidth - 1) - clzsi(aAbs);
   rep_t result;
 
   // Shift a into the significand field and clear the implicit bit.
   const int shift = significandBits - exponent;
   result = (rep_t)aAbs << shift ^ implicitBit;
 
   // Insert the exponent
   result += (rep_t)(exponent + exponentBias) << significandBits;
   // Insert the sign bit and return
   return fromRep(result | sign);
 }
 
 #endif

compiler-rt/lib/builtins/floatunsisf.c

 //
 //===----------------------------------------------------------------------===//
 
 #define SINGLE_PRECISION
 #include "fp_lib.h"
 
 #include "int_lib.h"
 
-COMPILER_RT_ABI fp_t __floatunsisf(unsigned int a) {
+COMPILER_RT_ABI fp_t __floatunsisf(su_int a) {
 
   const int aWidth = sizeof a * CHAR_BIT;
 
   // Handle zero as a special case to protect clz
   if (a == 0)
     return fromRep(0);
 
   // Exponent of (fp_t)a is the width of abs(a).
-  const int exponent = (aWidth - 1) - __builtin_clz(a);
+  const int exponent = (aWidth - 1) - clzsi(a);
   rep_t result;
 
   // Shift a into the significand field, rounding if it is a right-shift
   if (exponent <= significandBits) {
     const int shift = significandBits - exponent;
     result = (rep_t)a << shift ^ implicitBit;
   } else {
     const int shift = exponent - significandBits;

compiler-rt/lib/builtins/floatunsitf.c

 // mode.
 //
 //===----------------------------------------------------------------------===//
 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
-COMPILER_RT_ABI fp_t __floatunsitf(unsigned int a) {
+COMPILER_RT_ABI fp_t __floatunsitf(su_int a) {
 
   const int aWidth = sizeof a * CHAR_BIT;
 
   // Handle zero as a special case to protect clz
   if (a == 0)
     return fromRep(0);
 
   // Exponent of (fp_t)a is the width of abs(a).
-  const int exponent = (aWidth - 1) - __builtin_clz(a);
+  const int exponent = (aWidth - 1) - clzsi(a);
   rep_t result;
 
   // Shift a into the significand field and clear the implicit bit.
   const int shift = significandBits - exponent;
   result = (rep_t)a << shift ^ implicitBit;
 
   // Insert the exponent
   result += (rep_t)(exponent + exponentBias) << significandBits;
   return fromRep(result);
 }
 
 #endif

compiler-rt/lib/builtins/fp_extend.h

 static const int srcSigBits = 23;
 #define src_rep_t_clz clzsi
 
 #elif defined SRC_DOUBLE
 typedef double src_t;
 typedef uint64_t src_rep_t;
 #define SRC_REP_C UINT64_C
 static const int srcSigBits = 52;
-static __inline int src_rep_t_clz(src_rep_t a) {
-#if defined __LP64__
-  return __builtin_clzl(a);
-#else
-  if (a & REP_C(0xffffffff00000000))
-    return __builtin_clz(a >> 32);
-  else
-    return 32 + __builtin_clz(a & REP_C(0xffffffff));
-#endif
-}
+static __inline int src_rep_t_clz(src_rep_t a) { return clzdi(a); }
 
 #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;
 }
 
 static __inline dst_t dstFromRep(dst_rep_t x) {
   const union {
     dst_t f;
     dst_rep_t i;
   } rep = {.i = x};
   return rep.f;
 }
 // End helper routines.  Conversion implementation follows.
 
 #endif // FP_EXTEND_HEADER

compiler-rt/lib/builtins/fp_lib.h

 #elif defined DOUBLE_PRECISION
 
 typedef uint64_t rep_t;
 typedef int64_t srep_t;
 typedef double fp_t;
 #define REP_C UINT64_C
 #define significandBits 52
 
-static __inline int rep_clz(rep_t a) {
-#if defined __LP64__
-  return __builtin_clzl(a);
-#else
-  if (a & REP_C(0xffffffff00000000))
-    return clzsi(a >> 32);
-  else
-    return 32 + clzsi(a & REP_C(0xffffffff));
-#endif
-}
+static __inline int rep_clz(rep_t a) { return clzdi(a); }
 
 #define loWord(a) (a & 0xffffffffU)
 #define hiWord(a) (a >> 32)
 
 // 64x64 -> 128 wide multiply for platforms that don't have such an operation;
 // many 64-bit platforms have this operation, but they tend to have hardware
 // floating-point, so we don't bother with a special case for them here.
 static __inline void wideMultiply(rep_t a, rep_t b, rep_t *hi, rep_t *lo) {

 #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)

compiler-rt/lib/builtins/int_lib.h

if (msh != 0)
     return __builtin_clz(msh);
   return 32 + __builtin_clz(lsh);
 }
 #endif
 
 #define __builtin_clzl __builtin_clzll
 #endif // defined(_MSC_VER) && !defined(__clang__)
 
+static int __inline clzdi(di_int a) {
+#if defined __LP64__
+  return __builtin_clzl(a);
+#else
+  if (a & UINT64_C(0xffffffff00000000))
+    return clzsi(a >> 32);
+  else
+    return 32 + clzsi(a & UINT64_C(0xffffffff));
+#endif
+}
+
 #endif // INT_LIB_H

compiler-rt/lib/builtins/udivmoddi4.c

if (d.s.low == 0) {
     // ---
     // K 0
     if ((d.s.high & (d.s.high - 1)) == 0) /* if d is a power of 2 */ {
       if (rem) {
         r.s.low = n.s.low;
         r.s.high = n.s.high & (d.s.high - 1);
         *rem = r.all;
       }
-      return n.s.high >> __builtin_ctz(d.s.high);
+      return n.s.high >> ctzsi(d.s.high);
     }
     // K K
     // ---
     // K 0
     sr = clzsi(d.s.high) - clzsi(n.s.high);
     // 0 <= sr <= n_uword_bits - 2 or sr large
     if (sr > n_uword_bits - 2) {
       if (rem)
if (d.s.high == 0) {
       // K X
       // ---
       // 0 K
       if ((d.s.low & (d.s.low - 1)) == 0) /* if d is a power of 2 */ {
         if (rem)
           *rem = n.s.low & (d.s.low - 1);
         if (d.s.low == 1)
           return n.all;
-        sr = __builtin_ctz(d.s.low);
+        sr = ctzsi(d.s.low);
         q.s.high = n.s.high >> sr;
         q.s.low = (n.s.high << (n_uword_bits - sr)) | (n.s.low >> sr);
         return q.all;
       }
       // K X
       // ---
       // 0 K
       sr = 1 + n_uword_bits + clzsi(d.s.low) - clzsi(n.s.high);

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_floatditf
 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
 // Returns: long integer converted to long double
 
-COMPILER_RT_ABI long double __floatditf(long long a);
+COMPILER_RT_ABI long double __floatditf(di_int a);
 
-int test__floatditf(long long a, uint64_t expectedHi, uint64_t expectedLo)
+int test__floatditf(di_int a, uint64_t expectedHi, uint64_t expectedLo)
 {
     long double x = __floatditf(a);
     int ret = compareResultLD(x, expectedHi, expectedLo);
 
     if (ret)
         printf("error in __floatditf(%Ld) = %.20Lf, "
                "expected %.20Lf\n", a, x, fromRep128(expectedHi, expectedLo));
     return ret;

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_floatsitf
 
 #include "int_lib.h"
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
-long COMPILER_RT_ABI double __floatsitf(int a);
+COMPILER_RT_ABI long double __floatsitf(si_int a);
 
-int test__floatsitf(int a, uint64_t expectedHi, uint64_t expectedLo)
+int test__floatsitf(si_int a, uint64_t expectedHi, uint64_t expectedLo)
 {
     long double x = __floatsitf(a);
     int ret = compareResultLD(x, expectedHi, expectedLo);
 
     if (ret)
     {
         printf("error in test__floatsitf(%d) = %.20Lf, "
                "expected %.20Lf\n", a, x, fromRep128(expectedHi, expectedLo));

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_floatunditf
 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
 // Returns: long integer converted to long double
 
-COMPILER_RT_ABI long double __floatunditf(unsigned long long a);
+COMPILER_RT_ABI long double __floatunditf(du_int a);
 
-int test__floatunditf(unsigned long long a, uint64_t expectedHi, uint64_t expectedLo)
+int test__floatunditf(du_int a, uint64_t expectedHi, uint64_t expectedLo)
 {
     long double x = __floatunditf(a);
     int ret = compareResultLD(x, expectedHi, expectedLo);
 
     if (ret)
         printf("error in __floatunditf(%Lu) = %.20Lf, "
                "expected %.20Lf\n", a, x, fromRep128(expectedHi, expectedLo));
     return ret;

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_floatunsitf
 
 #include "int_lib.h"
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "fp_test.h"
 
-COMPILER_RT_ABI long double __floatunsitf(unsigned int a);
+COMPILER_RT_ABI long double __floatunsitf(su_int a);
 
-int test__floatunsitf(unsigned int a, uint64_t expectedHi, uint64_t expectedLo)
+int test__floatunsitf(su_int a, uint64_t expectedHi, uint64_t expectedLo)
 {
     long double x = __floatunsitf(a);
     int ret = compareResultLD(x, expectedHi, expectedLo);
 
     if (ret){
         printf("error in test__floatunsitf(%u) = %.20Lf, "
                "expected %.20Lf\n", a, x, fromRep128(expectedHi, expectedLo));
     }