[compiler-rt][builtins] Use explicitly-sized integer types for LibCalls

[atrosinenko]

Summary

Use s[iu]_int instead of (unsigned) int and d[ui]_int instead of
(unsigned) long long for LibCall arguments.

Note: the *vfp LibCall versions were NOT touched.

[atrosinenko]

Ping.

[aykevl]

This looks good to me, although I would like someone else to take a look as well. I can confirm that these changes fix an issue on AVR: this patch (together with D86547) make __floatsisf correct on AVR while it would previously do something incorrect.

What I am somewhat worried about is that some of these functions (__floatsisf, __floatunsisf) do not have tests. I think the test for the *vfp variants could be shared between the *vfp and non-*vfp variants. But I think this is best done separately.

[aykevl]

I've looked through the code again. It looks correct and (in past testing) it fixed a bug I had, so I'm going to accept this.

@atrosinenko do you have commit access? If not, I can commit it for you.

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

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 + (su_int)1U;
   }
 
   // Exponent of (fp_t)a is the width of abs(a).
   const int exponent = (aWidth - 1) - __builtin_clz(aAbs);
   rep_t result;
 
   // Shift a into the significand field and clear the implicit bit.
   const int shift = significandBits - exponent;

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

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

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));
     }