[builtins] Change si_int to int in some helper declarations

[atrosinenko]

Summary

This patch changes types of some integer function arguments or return values from si_int to the default int type to make it more compatible with libgcc.

The compiler-rt/lib/builtins/README.txt has a link to the libgcc specification. This specification has an explicit note on int, float and other such types being just illustrations in some cases while the actual types are expressed with machine modes.

Such usage of always-32-bit-wide integer type may lead to issues on 16-bit platforms such as MSP430. Provided libgcc2.h can be used as a reference for all targets supported by the libgcc, this patch fixes some existing differences in helper declarations.

This patch is expected to not change behavior at all for targets with 32-bit int type.

[aykevl]

I'm not sure whether native_int is any clearer than just int. I'm afraid it only introduces more complexity ("What's native_int? Oh, it's just int").

Perhaps a controversial idea: what about changing to use stdint.h types?
si_int -> int32_t
su_int -> uint32_t
di_int -> int64_t
etc
These types are clearly defined and immediately recognizable. The meaning is, as far as I can see, exactly the same (si_int etc seems to be a leftover from GCC internal naming conventions, such as SImode).

Also note that the libgcc documentation does not always reflect the real world. For example, __divmodsi4 on AVR libgcc has a very different signature: it returns both the division result and the remainder in registers.

compiler-rt/lib/builtins/int_lib.h

113

Why int and not native_int here?

[atrosinenko]

In D81285#2082394, @aykevl wrote:

I'm not sure whether native_int is any clearer than just int. I'm afraid it only introduces more complexity ("What's native_int? Oh, it's just int").

I'm not particularly insisting on the native_int, default_int or something similar. The decision to use some custom typedef is definitely an RFC here. My initial point was it explicitly notifies the reader "this type is not because I had not a better idea, it was specified intentionally as int".

Perhaps a controversial idea: what about changing to use stdint.h types?
si_int -> int32_t
su_int -> uint32_t
di_int -> int64_t
etc
These types are clearly defined and immediately recognizable.

I definitely support using the traditional integer types from stdint.h instead of some locally defined and not generally known ones.

The meaning is, as far as I can see, exactly the same (si_int etc seems to be a leftover from GCC internal naming conventions, such as SImode).

... I would just recheck (myself) that these three modes are identical "by definition" and replace them with sed :)

Also note that the libgcc documentation does not always reflect the real world. For example, __divmodsi4 on AVR libgcc has a very different signature: it returns both the division result and the remainder in registers.

Do you mean some special calling convention not used outside the libgcc/clang_rt? MSP430 has one as well. And I still have to decide how to express for some of generic C implementations that they should use that special calling convention on MSP430 without cluttering the sources with O(target count) complexity. :) Meanwhile, some hacks do exist for ARM target already.

[atrosinenko]

compiler-rt/lib/builtins/int_lib.h

113

Just to use more "textually identical" prototype as for an actual __builtin_ctz from GCC. On the other hand, such dilemma could be one of arguments against native_int.

[aykevl]

I need to recompile LLVM to test this patch so it might take a while.

In D81285#2082517, @atrosinenko wrote:

In D81285#2082394, @aykevl wrote:

Also note that the libgcc documentation does not always reflect the real world. For example, __divmodsi4 on AVR libgcc has a very different signature: it returns both the division result and the remainder in registers.

Do you mean some special calling convention not used outside the libgcc/clang_rt? MSP430 has one as well. And I still have to decide how to express for some of generic C implementations that they should use that special calling convention on MSP430 without cluttering the sources with O(target count) complexity. :) Meanwhile, some hacks do exist for ARM target already.

I don't mean a separate calling convention, although AVR has that as well. Rather, that the builtin has a different function signature. This signature is a bit hard to express in C so you might consider it a different ABI I guess. I implemented it in C by packing the two return values in a single uint64_t.

compiler-rt/lib/builtins/int_lib.h

113

Yes, that makes sense. It is actually defined with int in the official documentation, and because this is at the C language level and not at the ABI/target level, it's not one of the "int but really int32_t" types.

That said, I think the parameter should also be unsigned int instead of uint32_t. And the same goes for the other types below. Although, in practice, it doesn't really matter as it's all MSVC with 32-bit int everywhere.

[atrosinenko]

Replaced native_int by plain int, as @aykevl suggested.

On one hand, I have no specific preference for using some descriptive name such as native_int, default_int, etc. (that should suggest it was chosen intentionally, not because "I had no better idea") or just use standard int instead (supposing special names would be more confusing than explaining).

On the other hand, I aggree with @aykevl that replacing machine mode-related names (locally typedef'ed [sdt][ui]_int) with widely known type names such as uint32_t that should be equivalent by the definition according to GCC documentation would simplify understanding of the builtins source code. And after such change, using native_int for just int and absolutely traditional names for most other types would be quite strange.

On renaming fixed width integer types to their traditional names: I would prefer sending such patch afterwards, it would probably be as simple as just running sed --in-place several times.

[aykevl]

In D81285#2102948, @atrosinenko wrote:

On renaming fixed width integer types to their traditional names: I would prefer sending such patch afterwards, it would probably be as simple as just running sed --in-place several times.

Yes definitely. It seems best to me to separate refactorings from functional changes. If it should indeed be done, I'm not a maintainer of compiler-rt.

[efriedma]

LGTM. (Please wait a few days before merging to see if anyone else has comments.)

[MaskRay]

This patch changes types of some integer function arguments or return values from si_int to the default int type (typedefed to native_int to make it obvious this is intentional) to make it more compatible with libgcc.

Please drop native_int from the description since the code has been adjusted.

I don't use any sizeof(int)==2 platform and can't verify whether the patch is good on MSP430 or AVR. Hope @aykevl con verify the correctness.

[atrosinenko]

Thank you!

In D81285#2110102, @MaskRay wrote:

This patch changes types of some integer function arguments or return values from si_int to the default int type (typedefed to native_int to make it obvious this is intentional) to make it more compatible with libgcc.

Please drop native_int from the description since the code has been adjusted.

Fixed.

[bjope]

Hi!

My users have found problems with miscompiles that seem to originate from this patch.

As a background, my target has 16-bit int, and 32-bit long. And the calling convention is not that an i16 is passed as the low bits in a 32-bit register that would be used for an i32 argument.
Thus, when the bultins are built for my target, and the signature doesn't specify the exact bit-width using si_int, but rather using int, then the lib function will expect to get a 16-bit input.

The problem is that opt/llc does not know about the size of int etc. But opt (SimplifyLibCalls) and llc (LegalizeDAG) can rewrite things into using libcalls to for example __powisf2. But when it generate those calls it will use a function signature with int being mapped to i32.

Afaict the change that made sure the size of si_int was respected (typedef int32_t si_int;) was a nice change.
But I don't really understand why some types where changed to C-types instead of the Machine Mode types. Specially since you also quote that int only is used as an illustration but the real implementation should use the Machine Modes.

The miscompile found was when using pow(x, (double)2u) together with -ffast-math. opt rewrites it into calling @llvm.powi.f64(double, i32), and later LegalizeDAG will rewrite that into a libcall to __powidf2(double , i32), although that call is wrong if the lib function is compiler as __powidf2(double , i16).

Btw, I've found similar problems in for example SimplifyLibCall, that for example could rewrite powf(2.0, itofp(x)) to ldexpf(1.0, x). The second argument of ldexpf is an int according to math.h, but LLVM does not really consider that when doing the transform so it will use i32 in the call (while the lib in our case expect to receive an i16).

So it is kind of a mess. But I figure at least these "GCC low-level runtime library" kind of calls should use the Machine Modes? Or do we need to match up with the types in https://gcc.gnu.org/git/?p=gcc.git;a=blob_plain;f=libgcc/libgcc2.h;hb=HEAD ? If so, then this patch that made changes to compiler-rt (which is what we use for those builtins) isn't enough and we need to teach opt/llc to take the size of int into account when generating certain lib calls.

compiler-rt/lib/builtins/README.txt

 
 A rudimentary script to test each file is in the file called
 test/Unit/test.
 
 Here is the specification for this library:
 
 http://gcc.gnu.org/onlinedocs/gccint/Libgcc.html#Libgcc
 
+Please note that the libgcc specification explicitly mentions actual types of
+arguments and returned values being expressed with machine modes.
+In some cases particular types such as "int", "unsigned", "long long", etc.
+may be specified just as examples there.
+
 Here is a synopsis of the contents of this library:
 
-typedef      int si_int;
-typedef unsigned su_int;
+typedef  int32_t si_int;
+typedef uint32_t su_int;
 
-typedef          long long di_int;
-typedef unsigned long long du_int;
+typedef  int64_t di_int;
+typedef uint64_t du_int;
 
 // Integral bit manipulation
 
 di_int __ashldi3(di_int a, si_int b);      // a << b
 ti_int __ashlti3(ti_int a, si_int b);      // a << b
 
 di_int __ashrdi3(di_int a, si_int b);      // a >> b  arithmetic (sign fill)
 ti_int __ashrti3(ti_int a, si_int b);      // a >> b  arithmetic (sign fill)
 di_int __lshrdi3(di_int a, si_int b);      // a >> b  logical    (zero fill)
 ti_int __lshrti3(ti_int a, si_int b);      // a >> b  logical    (zero fill)
 
-si_int __clzsi2(si_int a);  // count leading zeros
-si_int __clzdi2(di_int a);  // count leading zeros
-si_int __clzti2(ti_int a);  // count leading zeros
-si_int __ctzsi2(si_int a);  // count trailing zeros
-si_int __ctzdi2(di_int a);  // count trailing zeros
-si_int __ctzti2(ti_int a);  // count trailing zeros
-
-si_int __ffssi2(si_int a);  // find least significant 1 bit
-si_int __ffsdi2(di_int a);  // find least significant 1 bit
-si_int __ffsti2(ti_int a);  // find least significant 1 bit
-
-si_int __paritysi2(si_int a);  // bit parity
-si_int __paritydi2(di_int a);  // bit parity
-si_int __parityti2(ti_int a);  // bit parity
-
-si_int __popcountsi2(si_int a);  // bit population
-si_int __popcountdi2(di_int a);  // bit population
-si_int __popcountti2(ti_int a);  // bit population
+int __clzsi2(si_int a);  // count leading zeros
+int __clzdi2(di_int a);  // count leading zeros
+int __clzti2(ti_int a);  // count leading zeros
+int __ctzsi2(si_int a);  // count trailing zeros
+int __ctzdi2(di_int a);  // count trailing zeros
+int __ctzti2(ti_int a);  // count trailing zeros
+
+int __ffssi2(si_int a);  // find least significant 1 bit
+int __ffsdi2(di_int a);  // find least significant 1 bit
+int __ffsti2(ti_int a);  // find least significant 1 bit
+
+int __paritysi2(si_int a);  // bit parity
+int __paritydi2(di_int a);  // bit parity
+int __parityti2(ti_int a);  // bit parity
+
+int __popcountsi2(si_int a);  // bit population
+int __popcountdi2(di_int a);  // bit population
+int __popcountti2(ti_int a);  // bit population
 
 uint32_t __bswapsi2(uint32_t a);   // a byteswapped
 uint64_t __bswapdi2(uint64_t a);   // a byteswapped
 
 // Integral arithmetic
 
 di_int __negdi2    (di_int a);                         // -a
 ti_int __negti2    (ti_int a);                         // -a

 long double __floatunditf(uint64_t a);     // ppc only
 
 float       __floatuntisf(tu_int a);
 double      __floatuntidf(tu_int a);
 long double __floatuntixf(tu_int a);
 
 //  Floating point raised to integer power
 
-float       __powisf2(      float a, si_int b);  // a ^ b
-double      __powidf2(     double a, si_int b);  // a ^ b
-long double __powixf2(long double a, si_int b);  // a ^ b
-long double __powitf2(long double a, si_int b);  // ppc only, a ^ b
+float       __powisf2(      float a, int b);  // a ^ b
+double      __powidf2(     double a, int b);  // a ^ b
+long double __powixf2(long double a, int b);  // a ^ b
+long double __powitf2(long double a, int b);  // ppc only, a ^ b
 
 //  Complex arithmetic
 
 //  (a + ib) * (c + id)
 
       float _Complex __mulsc3( float a,  float b,  float c,  float d);
      double _Complex __muldc3(double a, double b, double c, double d);
 long double _Complex __mulxc3(long double a, long double b,

compiler-rt/lib/builtins/clzdi2.c

 
 #if !defined(__clang__) &&                                                     \
     ((defined(__sparc__) && defined(__arch64__)) || defined(__mips64) ||       \
      (defined(__riscv) && __SIZEOF_POINTER__ >= 8))
 // On 64-bit architectures with neither a native clz instruction nor a native
 // ctz instruction, gcc resolves __builtin_clz to __clzdi2 rather than
 // __clzsi2, leading to infinite recursion.
 #define __builtin_clz(a) __clzsi2(a)
-extern si_int __clzsi2(si_int);
+extern int __clzsi2(si_int);
 #endif
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI si_int __clzdi2(di_int a) {
+COMPILER_RT_ABI int __clzdi2(di_int a) {
   dwords x;
   x.all = a;
   const si_int f = -(x.s.high == 0);
   return clzsi((x.s.high & ~f) | (x.s.low & f)) +
          (f & ((si_int)(sizeof(si_int) * CHAR_BIT)));
 }

compiler-rt/lib/builtins/clzsi2.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // Returns: the number of leading 0-bits
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI si_int __clzsi2(si_int a) {
+COMPILER_RT_ABI int __clzsi2(si_int a) {
   su_int x = (su_int)a;
   si_int t = ((x & 0xFFFF0000) == 0) << 4; // if (x is small) t = 16 else 0
   x >>= 16 - t;                            // x = [0 - 0xFFFF]
   su_int r = t;                            // r = [0, 16]
   // return r + clz(x)
   t = ((x & 0xFF00) == 0) << 3;
   x >>= 8 - t; // x = [0 - 0xFF]
   r += t;      // r = [0, 8, 16, 24]

compiler-rt/lib/builtins/clzti2.c

 #include "int_lib.h"
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: the number of leading 0-bits
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI si_int __clzti2(ti_int a) {
+COMPILER_RT_ABI int __clzti2(ti_int a) {
   twords x;
   x.all = a;
   const di_int f = -(x.s.high == 0);
   return __builtin_clzll((x.s.high & ~f) | (x.s.low & f)) +
          ((si_int)f & ((si_int)(sizeof(di_int) * CHAR_BIT)));
 }
 
 #endif // CRT_HAS_128BIT

compiler-rt/lib/builtins/ctzdi2.c

 
 #if !defined(__clang__) &&                                                     \
     ((defined(__sparc__) && defined(__arch64__)) || defined(__mips64) ||       \
      (defined(__riscv) && __SIZEOF_POINTER__ >= 8))
 // On 64-bit architectures with neither a native clz instruction nor a native
 // ctz instruction, gcc resolves __builtin_ctz to __ctzdi2 rather than
 // __ctzsi2, leading to infinite recursion.
 #define __builtin_ctz(a) __ctzsi2(a)
-extern si_int __ctzsi2(si_int);
+extern int __ctzsi2(si_int);
 #endif
 
 // Precondition: a != 0
 
 COMPILER_RT_ABI int __ctzdi2(di_int a) {
   dwords x;
   x.all = a;
   const si_int f = -(x.s.low == 0);
   return ctzsi((x.s.high & f) | (x.s.low & ~f)) +
          (f & ((si_int)(sizeof(si_int) * CHAR_BIT)));
 }

compiler-rt/lib/builtins/ctzsi2.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // Returns: the number of trailing 0-bits
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI si_int __ctzsi2(si_int a) {
+COMPILER_RT_ABI int __ctzsi2(si_int a) {
   su_int x = (su_int)a;
   si_int t = ((x & 0x0000FFFF) == 0)
              << 4; // if (x has no small bits) t = 16 else 0
   x >>= t;         // x = [0 - 0xFFFF] + higher garbage bits
   su_int r = t;    // r = [0, 16]
   // return r + ctz(x)
   t = ((x & 0x00FF) == 0) << 3;
   x >>= t; // x = [0 - 0xFF] + higher garbage bits

compiler-rt/lib/builtins/ctzti2.c

 #include "int_lib.h"
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: the number of trailing 0-bits
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI si_int __ctzti2(ti_int a) {
+COMPILER_RT_ABI int __ctzti2(ti_int a) {
   twords x;
   x.all = a;
   const di_int f = -(x.s.low == 0);
   return __builtin_ctzll((x.s.high & f) | (x.s.low & ~f)) +
          ((si_int)f & ((si_int)(sizeof(di_int) * CHAR_BIT)));
 }
 
 #endif // CRT_HAS_128BIT

compiler-rt/lib/builtins/ffsti2.c

 
 #include "int_lib.h"
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: the index of the least significant 1-bit in a, or
 // the value zero if a is zero. The least significant bit is index one.
 
-COMPILER_RT_ABI si_int __ffsti2(ti_int a) {
+COMPILER_RT_ABI int __ffsti2(ti_int a) {
   twords x;
   x.all = a;
   if (x.s.low == 0) {
     if (x.s.high == 0)
       return 0;
     return __builtin_ctzll(x.s.high) + (1 + sizeof(di_int) * CHAR_BIT);
   }
   return __builtin_ctzll(x.s.low) + 1;
 }
 
 #endif // CRT_HAS_128BIT

compiler-rt/lib/builtins/int_lib.h

 #endif
 
 // Include the commonly used internal type definitions.
 #include "int_types.h"
 
 // Include internal utility function declarations.
 #include "int_util.h"
 
-COMPILER_RT_ABI si_int __paritysi2(si_int a);
-COMPILER_RT_ABI si_int __paritydi2(di_int a);
+COMPILER_RT_ABI int __paritysi2(si_int a);
+COMPILER_RT_ABI int __paritydi2(di_int a);
 
 COMPILER_RT_ABI di_int __divdi3(di_int a, di_int b);
 COMPILER_RT_ABI si_int __divsi3(si_int a, si_int b);
 COMPILER_RT_ABI su_int __udivsi3(su_int n, su_int d);
 
 COMPILER_RT_ABI su_int __udivmodsi4(su_int a, su_int b, su_int *rem);
 COMPILER_RT_ABI du_int __udivmoddi4(du_int a, du_int b, du_int *rem);
 #ifdef CRT_HAS_128BIT
-COMPILER_RT_ABI si_int __clzti2(ti_int a);
+COMPILER_RT_ABI int __clzti2(ti_int a);
 COMPILER_RT_ABI tu_int __udivmodti4(tu_int a, tu_int b, tu_int *rem);
 #endif
 
 // Definitions for builtins unavailable on MSVC
 #if defined(_MSC_VER) && !defined(__clang__)
 #include <intrin.h>
 
-uint32_t __inline __builtin_ctz(uint32_t value) {
+int __inline __builtin_ctz(uint32_t value) {
   unsigned long trailing_zero = 0;
   if (_BitScanForward(&trailing_zero, value))
     return trailing_zero;
   return 32;
 }
 
-uint32_t __inline __builtin_clz(uint32_t value) {
+int __inline __builtin_clz(uint32_t value) {
   unsigned long leading_zero = 0;
   if (_BitScanReverse(&leading_zero, value))
     return 31 - leading_zero;
   return 32;
 }
 
 #if defined(_M_ARM) || defined(_M_X64)
-uint32_t __inline __builtin_clzll(uint64_t value) {
+int __inline __builtin_clzll(uint64_t value) {
   unsigned long leading_zero = 0;
   if (_BitScanReverse64(&leading_zero, value))
     return 63 - leading_zero;
   return 64;
 }
 #else
-uint32_t __inline __builtin_clzll(uint64_t value) {
+int __inline __builtin_clzll(uint64_t value) {
   if (value == 0)
     return 64;
   uint32_t msh = (uint32_t)(value >> 32);
   uint32_t lsh = (uint32_t)(value & 0xFFFFFFFF);
   if (msh != 0)
     return __builtin_clz(msh);
   return 32 + __builtin_clz(lsh);
 }
 #endif
 
 #define __builtin_clzl __builtin_clzll
 #endif // defined(_MSC_VER) && !defined(__clang__)
 
 #endif // INT_LIB_H

compiler-rt/lib/builtins/paritydi2.c

 //===-- paritydi2.c - Implement __paritydi2 -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements __paritydi2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // Returns: 1 if number of bits is odd else returns 0
 
-COMPILER_RT_ABI si_int __paritydi2(di_int a) {
+COMPILER_RT_ABI int __paritydi2(di_int a) {
   dwords x;
   x.all = a;
   return __paritysi2(x.s.high ^ x.s.low);
 }

compiler-rt/lib/builtins/paritysi2.c

 //===-- paritysi2.c - Implement __paritysi2 -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements __paritysi2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // Returns: 1 if number of bits is odd else returns 0
 
-COMPILER_RT_ABI si_int __paritysi2(si_int a) {
+COMPILER_RT_ABI int __paritysi2(si_int a) {
   su_int x = (su_int)a;
   x ^= x >> 16;
   x ^= x >> 8;
   x ^= x >> 4;
   return (0x6996 >> (x & 0xF)) & 1;
 }

compiler-rt/lib/builtins/parityti2.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: 1 if number of bits is odd else returns 0
 
-COMPILER_RT_ABI si_int __parityti2(ti_int a) {
+COMPILER_RT_ABI int __parityti2(ti_int a) {
   twords x;
   x.all = a;
   return __paritydi2(x.s.high ^ x.s.low);
 }
 
 #endif // CRT_HAS_128BIT

compiler-rt/lib/builtins/popcountsi2.c

 //===-- popcountsi2.c - Implement __popcountsi2 ---------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements __popcountsi2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // Returns: count of 1 bits
 
-COMPILER_RT_ABI si_int __popcountsi2(si_int a) {
+COMPILER_RT_ABI int __popcountsi2(si_int a) {
   su_int x = (su_int)a;
   x = x - ((x >> 1) & 0x55555555);
   // Every 2 bits holds the sum of every pair of bits
   x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
   // Every 4 bits holds the sum of every 4-set of bits (3 significant bits)
   x = (x + (x >> 4)) & 0x0F0F0F0F;
   // Every 8 bits holds the sum of every 8-set of bits (4 significant bits)
   x = (x + (x >> 16));
   // The lower 16 bits hold two 8 bit sums (5 significant bits).
   //    Upper 16 bits are garbage
   return (x + (x >> 8)) & 0x0000003F; // (6 significant bits)
 }

compiler-rt/lib/builtins/popcountti2.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: count of 1 bits
 
-COMPILER_RT_ABI si_int __popcountti2(ti_int a) {
+COMPILER_RT_ABI int __popcountti2(ti_int a) {
   tu_int x3 = (tu_int)a;
   x3 = x3 - ((x3 >> 1) &
              (((tu_int)0x5555555555555555uLL << 64) | 0x5555555555555555uLL));
   // Every 2 bits holds the sum of every pair of bits (64)
   x3 = ((x3 >> 2) &
         (((tu_int)0x3333333333333333uLL << 64) | 0x3333333333333333uLL)) +
        (x3 & (((tu_int)0x3333333333333333uLL << 64) | 0x3333333333333333uLL));
   // Every 4 bits holds the sum of every 4-set of bits (3 significant bits) (32)

compiler-rt/lib/builtins/powidf2.c

 //===-- powidf2.cpp - Implement __powidf2 ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements __powidf2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // Returns: a ^ b
 
-COMPILER_RT_ABI double __powidf2(double a, si_int b) {
+COMPILER_RT_ABI double __powidf2(double a, int b) {
   const int recip = b < 0;
   double r = 1;
   while (1) {
     if (b & 1)
       r *= a;
     b /= 2;
     if (b == 0)
       break;
     a *= a;
   }
   return recip ? 1 / r : r;
 }

compiler-rt/lib/builtins/powisf2.c

 //===-- powisf2.cpp - Implement __powisf2 ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements __powisf2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // Returns: a ^ b
 
-COMPILER_RT_ABI float __powisf2(float a, si_int b) {
+COMPILER_RT_ABI float __powisf2(float a, int b) {
   const int recip = b < 0;
   float r = 1;
   while (1) {
     if (b & 1)
       r *= a;
     b /= 2;
     if (b == 0)
       break;
     a *= a;
   }
   return recip ? 1 / r : r;
 }

compiler-rt/lib/builtins/powitf2.c

 
 #define QUAD_PRECISION
 #include "fp_lib.h"
 
 #if defined(CRT_HAS_128BIT) && defined(CRT_LDBL_128BIT)
 
 // Returns: a ^ b
 
-COMPILER_RT_ABI long double __powitf2(long double a, si_int b) {
+COMPILER_RT_ABI long double __powitf2(long double a, int b) {
   const int recip = b < 0;
   long double r = 1;
   while (1) {
     if (b & 1)
       r *= a;
     b /= 2;
     if (b == 0)
       break;
     a *= a;
   }
   return recip ? 1 / r : r;
 }
 
 #endif

compiler-rt/lib/builtins/powixf2.c

 //===----------------------------------------------------------------------===//
 
 #if !_ARCH_PPC
 
 #include "int_lib.h"
 
 // Returns: a ^ b
 
-COMPILER_RT_ABI long double __powixf2(long double a, si_int b) {
+COMPILER_RT_ABI long double __powixf2(long double a, int b) {
   const int recip = b < 0;
   long double r = 1;
   while (1) {
     if (b & 1)
       r *= a;
     b /= 2;
     if (b == 0)
       break;
     a *= a;
   }
   return recip ? 1 / r : r;
 }
 
 #endif

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_clzdi2
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: the number of leading 0-bits
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI si_int __clzdi2(di_int a);
+COMPILER_RT_ABI int __clzdi2(di_int a);
 
-int test__clzdi2(di_int a, si_int expected)
+int test__clzdi2(di_int a, int expected)
 {
-    si_int x = __clzdi2(a);
+    int x = __clzdi2(a);
     if (x != expected)
         printf("error in __clzdi2(0x%llX) = %d, expected %d\n", a, x, expected);
     return x != expected;
 }
 
 char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
 
 int main()

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_clzsi2
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: the number of leading 0-bits
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI si_int __clzsi2(si_int a);
+COMPILER_RT_ABI int __clzsi2(si_int a);
 
-int test__clzsi2(si_int a, si_int expected)
+int test__clzsi2(si_int a, int expected)
 {
-    si_int x = __clzsi2(a);
+    int x = __clzsi2(a);
     if (x != expected)
         printf("error in __clzsi2(0x%X) = %d, expected %d\n", a, x, expected);
     return x != expected;
 }
 
 char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
 char assumption_2[sizeof(si_int)*CHAR_BIT == 32] = {0};
 

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_clzti2
 // REQUIRES: int128
 
 #include "int_lib.h"
 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: the number of leading 0-bits
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI si_int __clzti2(ti_int a);
+COMPILER_RT_ABI int __clzti2(ti_int a);
 
-int test__clzti2(ti_int a, si_int expected)
+int test__clzti2(ti_int a, int expected)
 {
-    si_int x = __clzti2(a);
+    int x = __clzti2(a);
     if (x != expected)
     {
         twords at;
         at.all = a;
         printf("error in __clzti2(0x%llX%.16llX) = %d, expected %d\n",
                at.s.high, at.s.low, x, expected);
     }
     return x != expected;

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_ctzsi2
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: the number of trailing 0-bits
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI si_int __ctzsi2(si_int a);
+COMPILER_RT_ABI int __ctzsi2(si_int a);
 
-int test__ctzsi2(si_int a, si_int expected)
+int test__ctzsi2(si_int a, int expected)
 {
-    si_int x = __ctzsi2(a);
+    int x = __ctzsi2(a);
     if (x != expected)
         printf("error in __ctzsi2(0x%X) = %d, expected %d\n", a, x, expected);
     return x != expected;
 }
 
 char assumption_1[sizeof(di_int) == 2*sizeof(si_int)] = {0};
 char assumption_2[sizeof(si_int)*CHAR_BIT == 32] = {0};
 

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_ctzti2
 // REQUIRES: int128
 
 #include "int_lib.h"
 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: the number of trailing 0-bits
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI si_int __ctzti2(ti_int a);
+COMPILER_RT_ABI int __ctzti2(ti_int a);
 
-int test__ctzti2(ti_int a, si_int expected)
+int test__ctzti2(ti_int a, int expected)
 {
-    si_int x = __ctzti2(a);
+    int x = __ctzti2(a);
     if (x != expected)
     {
         twords at;
         at.all = a;
         printf("error in __ctzti2(0x%llX%.16llX) = %d, expected %d\n",
                at.s.high, at.s.low, x, expected);
     }
     return x != expected;

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_ffsti2
 // REQUIRES: int128
 
 #include "int_lib.h"
 #include <stdio.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: the index of the least significant 1-bit in a, or
 // the value zero if a is zero. The least significant bit is index one.
 
-COMPILER_RT_ABI si_int __ffsti2(ti_int a);
+COMPILER_RT_ABI int __ffsti2(ti_int a);
 
-int test__ffsti2(ti_int a, si_int expected)
+int test__ffsti2(ti_int a, int expected)
 {
-    si_int x = __ffsti2(a);
+    int x = __ffsti2(a);
     if (x != expected)
     {
         twords at;
         at.all = a;
         printf("error in __ffsti2(0x%llX%.16llX) = %d, expected %d\n",
                at.s.high, at.s.low, x, expected);
     }
     return x != expected;

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_paritydi2
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 // Returns: 1 if number of bits is odd else returns 0
 
-COMPILER_RT_ABI si_int __paritydi2(di_int a);
+COMPILER_RT_ABI int __paritydi2(di_int a);
 
 int naive_parity(di_int a)
 {
     int r = 0;
     for (; a; a = a & (a - 1))
         r = ~r;
     return r & 1;
 }

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_paritysi2
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 // Returns: 1 if number of bits is odd else returns 0
 
-COMPILER_RT_ABI si_int __paritysi2(si_int a);
+COMPILER_RT_ABI int __paritysi2(si_int a);
 
 int naive_parity(si_int a)
 {
     int r = 0;
     for (; a; a = a & (a - 1))
         r = ~r;
     return r & 1;
 }

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_parityti2
 // REQUIRES: int128
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: 1 if number of bits is odd else returns 0
 
-COMPILER_RT_ABI si_int __parityti2(ti_int a);
+COMPILER_RT_ABI int __parityti2(ti_int a);
 
 int naive_parity(ti_int a)
 {
     int r = 0;
     for (; a; a = a & (a - 1))
         r = ~r;
     return r & 1;
 }

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_popcountsi2
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 // Returns: count of 1 bits
 
-COMPILER_RT_ABI si_int __popcountsi2(si_int a);
+COMPILER_RT_ABI int __popcountsi2(si_int a);
 
 int naive_popcount(si_int a)
 {
     int r = 0;
     for (; a; a = (su_int)a >> 1)
         r += a & 1;
     return r;
 }

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_popcountti2
 // REQUIRES: int128
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: count of 1 bits
 
-COMPILER_RT_ABI si_int __popcountti2(ti_int a);
+COMPILER_RT_ABI int __popcountti2(ti_int a);
 
 int naive_popcount(ti_int a)
 {
     int r = 0;
     for (; a; a = (tu_int)a >> 1)
         r += a & 1;
     return r;
 }

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_powidf2
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <math.h>
 
 // Returns: a ^ b
 
-COMPILER_RT_ABI double __powidf2(double a, si_int b);
+COMPILER_RT_ABI double __powidf2(double a, int b);
 
-int test__powidf2(double a, si_int b, double expected)
+int test__powidf2(double a, int b, double expected)
 {
     double x = __powidf2(a, b);
     int correct = (x == expected) && (signbit(x) == signbit(expected));
     if (!correct)
         printf("error in __powidf2(%f, %d) = %f, expected %f\n",
                a, b, x, expected);
     return !correct;
 }
int main()
     if (test__powidf2(0, 1, 0))
         return 1;
     if (test__powidf2(0, 2, 0))
         return 1;
     if (test__powidf2(0, 3, 0))
         return 1;
     if (test__powidf2(0, 4, 0))
         return 1;
-    if (test__powidf2(0, 0x7FFFFFFE, 0))
+    if (test__powidf2(0, INT_MAX - 1, 0))
         return 1;
-    if (test__powidf2(0, 0x7FFFFFFF, 0))
+    if (test__powidf2(0, INT_MAX, 0))
         return 1;
 
     if (test__powidf2(-0., 1, -0.))
         return 1;
     if (test__powidf2(-0., 2, 0))
         return 1;
     if (test__powidf2(-0., 3, -0.))
         return 1;
     if (test__powidf2(-0., 4, 0))
         return 1;
-    if (test__powidf2(-0., 0x7FFFFFFE, 0))
+    if (test__powidf2(-0., INT_MAX - 1, 0))
         return 1;
-    if (test__powidf2(-0., 0x7FFFFFFF, -0.))
+    if (test__powidf2(-0., INT_MAX, -0.))
         return 1;
 
     if (test__powidf2(1, 1, 1))
         return 1;
     if (test__powidf2(1, 2, 1))
         return 1;
     if (test__powidf2(1, 3, 1))
         return 1;
     if (test__powidf2(1, 4, 1))
         return 1;
-    if (test__powidf2(1, 0x7FFFFFFE, 1))
+    if (test__powidf2(1, INT_MAX - 1, 1))
         return 1;
-    if (test__powidf2(1, 0x7FFFFFFF, 1))
+    if (test__powidf2(1, INT_MAX, 1))
         return 1;
 
     if (test__powidf2(INFINITY, 1, INFINITY))
         return 1;
     if (test__powidf2(INFINITY, 2, INFINITY))
         return 1;
     if (test__powidf2(INFINITY, 3, INFINITY))
         return 1;
     if (test__powidf2(INFINITY, 4, INFINITY))
         return 1;
-    if (test__powidf2(INFINITY, 0x7FFFFFFE, INFINITY))
+    if (test__powidf2(INFINITY, INT_MAX - 1, INFINITY))
         return 1;
-    if (test__powidf2(INFINITY, 0x7FFFFFFF, INFINITY))
+    if (test__powidf2(INFINITY, INT_MAX, INFINITY))
         return 1;
 
     if (test__powidf2(-INFINITY, 1, -INFINITY))
         return 1;
     if (test__powidf2(-INFINITY, 2, INFINITY))
         return 1;
     if (test__powidf2(-INFINITY, 3, -INFINITY))
         return 1;
     if (test__powidf2(-INFINITY, 4, INFINITY))
         return 1;
-    if (test__powidf2(-INFINITY, 0x7FFFFFFE, INFINITY))
+    if (test__powidf2(-INFINITY, INT_MAX - 1, INFINITY))
         return 1;
-    if (test__powidf2(-INFINITY, 0x7FFFFFFF, -INFINITY))
+    if (test__powidf2(-INFINITY, INT_MAX, -INFINITY))
         return 1;
 
     if (test__powidf2(0, -1, INFINITY))
         return 1;
     if (test__powidf2(0, -2, INFINITY))
         return 1;
     if (test__powidf2(0, -3, INFINITY))
         return 1;
     if (test__powidf2(0, -4, INFINITY))
         return 1;
-    if (test__powidf2(0, 0x80000002, INFINITY))
+    if (test__powidf2(0, INT_MIN + 2, INFINITY))
         return 1;
-    if (test__powidf2(0, 0x80000001, INFINITY))
+    if (test__powidf2(0, INT_MIN + 1, INFINITY))
         return 1;
-    if (test__powidf2(0, 0x80000000, INFINITY))
+    if (test__powidf2(0, INT_MIN, INFINITY))
         return 1;
 
     if (test__powidf2(-0., -1, -INFINITY))
         return 1;
     if (test__powidf2(-0., -2, INFINITY))
         return 1;
     if (test__powidf2(-0., -3, -INFINITY))
         return 1;
     if (test__powidf2(-0., -4, INFINITY))
         return 1;
-    if (test__powidf2(-0., 0x80000002, INFINITY))
+    if (test__powidf2(-0., INT_MIN + 2, INFINITY))
         return 1;
-    if (test__powidf2(-0., 0x80000001, -INFINITY))
+    if (test__powidf2(-0., INT_MIN + 1, -INFINITY))
         return 1;
-    if (test__powidf2(-0., 0x80000000, INFINITY))
+    if (test__powidf2(-0., INT_MIN, INFINITY))
         return 1;
 
     if (test__powidf2(1, -1, 1))
         return 1;
     if (test__powidf2(1, -2, 1))
         return 1;
     if (test__powidf2(1, -3, 1))
         return 1;
     if (test__powidf2(1, -4, 1))
         return 1;
-    if (test__powidf2(1, 0x80000002, 1))
+    if (test__powidf2(1, INT_MIN + 2, 1))
         return 1;
-    if (test__powidf2(1, 0x80000001, 1))
+    if (test__powidf2(1, INT_MIN + 1, 1))
         return 1;
-    if (test__powidf2(1, 0x80000000, 1))
+    if (test__powidf2(1, INT_MIN, 1))
         return 1;
 
     if (test__powidf2(INFINITY, -1, 0))
         return 1;
     if (test__powidf2(INFINITY, -2, 0))
         return 1;
     if (test__powidf2(INFINITY, -3, 0))
         return 1;
     if (test__powidf2(INFINITY, -4, 0))
         return 1;
-    if (test__powidf2(INFINITY, 0x80000002, 0))
+    if (test__powidf2(INFINITY, INT_MIN + 2, 0))
         return 1;
-    if (test__powidf2(INFINITY, 0x80000001, 0))
+    if (test__powidf2(INFINITY, INT_MIN + 1, 0))
         return 1;
-    if (test__powidf2(INFINITY, 0x80000000, 0))
+    if (test__powidf2(INFINITY, INT_MIN, 0))
         return 1;
 
     if (test__powidf2(-INFINITY, -1, -0.))
         return 1;
     if (test__powidf2(-INFINITY, -2, 0))
         return 1;
     if (test__powidf2(-INFINITY, -3, -0.))
         return 1;
     if (test__powidf2(-INFINITY, -4, 0))
         return 1;
-    if (test__powidf2(-INFINITY, 0x80000002, 0))
+    if (test__powidf2(-INFINITY, INT_MIN + 2, 0))
         return 1;
-    if (test__powidf2(-INFINITY, 0x80000001, -0.))
+    if (test__powidf2(-INFINITY, INT_MIN + 1, -0.))
         return 1;
-    if (test__powidf2(-INFINITY, 0x80000000, 0))
+    if (test__powidf2(-INFINITY, INT_MIN, 0))
         return 1;
 
     if (test__powidf2(2, 10, 1024.))
         return 1;
     if (test__powidf2(-2, 10, 1024.))
         return 1;
     if (test__powidf2(2, -10, 1/1024.))
         return 1;
     if (test__powidf2(-2, -10, 1/1024.))

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_powisf2
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <math.h>
 
 // Returns: a ^ b
 
-COMPILER_RT_ABI float __powisf2(float a, si_int b);
+COMPILER_RT_ABI float __powisf2(float a, int b);
 
-int test__powisf2(float a, si_int b, float expected)
+int test__powisf2(float a, int b, float expected)
 {
     float x = __powisf2(a, b);
     int correct = (x == expected) && (signbit(x) == signbit(expected));
     if (!correct)
         printf("error in __powisf2(%f, %d) = %f, expected %f\n",
                a, b, x, expected);
     return !correct;
 }
int main()
     if (test__powisf2(0, 1, 0))
         return 1;
     if (test__powisf2(0, 2, 0))
         return 1;
     if (test__powisf2(0, 3, 0))
         return 1;
     if (test__powisf2(0, 4, 0))
         return 1;
-    if (test__powisf2(0, 0x7FFFFFFE, 0))
+    if (test__powisf2(0, INT_MAX -1, 0))
         return 1;
-    if (test__powisf2(0, 0x7FFFFFFF, 0))
+    if (test__powisf2(0, INT_MAX, 0))
         return 1;
 
     if (test__powisf2(-0., 1, -0.))
         return 1;
     if (test__powisf2(-0., 2, 0))
         return 1;
     if (test__powisf2(-0., 3, -0.))
         return 1;
     if (test__powisf2(-0., 4, 0))
         return 1;
-    if (test__powisf2(-0., 0x7FFFFFFE, 0))
+    if (test__powisf2(-0., INT_MAX - 1, 0))
         return 1;
-    if (test__powisf2(-0., 0x7FFFFFFF, -0.))
+    if (test__powisf2(-0., INT_MAX, -0.))
         return 1;
 
     if (test__powisf2(1, 1, 1))
         return 1;
     if (test__powisf2(1, 2, 1))
         return 1;
     if (test__powisf2(1, 3, 1))
         return 1;
     if (test__powisf2(1, 4, 1))
         return 1;
-    if (test__powisf2(1, 0x7FFFFFFE, 1))
+    if (test__powisf2(1, INT_MAX - 1, 1))
         return 1;
-    if (test__powisf2(1, 0x7FFFFFFF, 1))
+    if (test__powisf2(1, INT_MAX, 1))
         return 1;
 
     if (test__powisf2(INFINITY, 1, INFINITY))
         return 1;
     if (test__powisf2(INFINITY, 2, INFINITY))
         return 1;
     if (test__powisf2(INFINITY, 3, INFINITY))
         return 1;
     if (test__powisf2(INFINITY, 4, INFINITY))
         return 1;
-    if (test__powisf2(INFINITY, 0x7FFFFFFE, INFINITY))
+    if (test__powisf2(INFINITY, INT_MAX - 1, INFINITY))
         return 1;
-    if (test__powisf2(INFINITY, 0x7FFFFFFF, INFINITY))
+    if (test__powisf2(INFINITY, INT_MAX, INFINITY))
         return 1;
 
     if (test__powisf2(-INFINITY, 1, -INFINITY))
         return 1;
     if (test__powisf2(-INFINITY, 2, INFINITY))
         return 1;
     if (test__powisf2(-INFINITY, 3, -INFINITY))
         return 1;
     if (test__powisf2(-INFINITY, 4, INFINITY))
         return 1;
-    if (test__powisf2(-INFINITY, 0x7FFFFFFE, INFINITY))
+    if (test__powisf2(-INFINITY, INT_MAX - 1, INFINITY))
         return 1;
-    if (test__powisf2(-INFINITY, 0x7FFFFFFF, -INFINITY))
+    if (test__powisf2(-INFINITY, INT_MAX, -INFINITY))
         return 1;
 
     if (test__powisf2(0, -1, INFINITY))
         return 1;
     if (test__powisf2(0, -2, INFINITY))
         return 1;
     if (test__powisf2(0, -3, INFINITY))
         return 1;
     if (test__powisf2(0, -4, INFINITY))
         return 1;
-    if (test__powisf2(0, 0x80000002, INFINITY))
+    if (test__powisf2(0, INT_MIN + 2, INFINITY))
         return 1;
-    if (test__powisf2(0, 0x80000001, INFINITY))
+    if (test__powisf2(0, INT_MIN + 1, INFINITY))
         return 1;
-    if (test__powisf2(0, 0x80000000, INFINITY))
+    if (test__powisf2(0, INT_MIN, INFINITY))
         return 1;
 
     if (test__powisf2(-0., -1, -INFINITY))
         return 1;
     if (test__powisf2(-0., -2, INFINITY))
         return 1;
     if (test__powisf2(-0., -3, -INFINITY))
         return 1;
     if (test__powisf2(-0., -4, INFINITY))
         return 1;
-    if (test__powisf2(-0., 0x80000002, INFINITY))
+    if (test__powisf2(-0., INT_MIN + 2, INFINITY))
         return 1;
-    if (test__powisf2(-0., 0x80000001, -INFINITY))
+    if (test__powisf2(-0., INT_MIN + 1, -INFINITY))
         return 1;
-    if (test__powisf2(-0., 0x80000000, INFINITY))
+    if (test__powisf2(-0., INT_MIN, INFINITY))
         return 1;
 
     if (test__powisf2(1, -1, 1))
         return 1;
     if (test__powisf2(1, -2, 1))
         return 1;
     if (test__powisf2(1, -3, 1))
         return 1;
     if (test__powisf2(1, -4, 1))
         return 1;
-    if (test__powisf2(1, 0x80000002, 1))
+    if (test__powisf2(1, INT_MIN + 2, 1))
         return 1;
-    if (test__powisf2(1, 0x80000001, 1))
+    if (test__powisf2(1, INT_MIN + 1, 1))
         return 1;
-    if (test__powisf2(1, 0x80000000, 1))
+    if (test__powisf2(1, INT_MIN, 1))
         return 1;
 
     if (test__powisf2(INFINITY, -1, 0))
         return 1;
     if (test__powisf2(INFINITY, -2, 0))
         return 1;
     if (test__powisf2(INFINITY, -3, 0))
         return 1;
     if (test__powisf2(INFINITY, -4, 0))
         return 1;
-    if (test__powisf2(INFINITY, 0x80000002, 0))
+    if (test__powisf2(INFINITY, INT_MIN + 2, 0))
         return 1;
-    if (test__powisf2(INFINITY, 0x80000001, 0))
+    if (test__powisf2(INFINITY, INT_MIN + 1, 0))
         return 1;
-    if (test__powisf2(INFINITY, 0x80000000, 0))
+    if (test__powisf2(INFINITY, INT_MIN, 0))
         return 1;
 
     if (test__powisf2(-INFINITY, -1, -0.))
         return 1;
     if (test__powisf2(-INFINITY, -2, 0))
         return 1;
     if (test__powisf2(-INFINITY, -3, -0.))
         return 1;
     if (test__powisf2(-INFINITY, -4, 0))
         return 1;
-    if (test__powisf2(-INFINITY, 0x80000002, 0))
+    if (test__powisf2(-INFINITY, INT_MIN + 2, 0))
         return 1;
-    if (test__powisf2(-INFINITY, 0x80000001, -0.))
+    if (test__powisf2(-INFINITY, INT_MIN + 1, -0.))
         return 1;
-    if (test__powisf2(-INFINITY, 0x80000000, 0))
+    if (test__powisf2(-INFINITY, INT_MIN, 0))
         return 1;
 
     if (test__powisf2(2, 10, 1024.))
         return 1;
     if (test__powisf2(-2, 10, 1024.))
         return 1;
     if (test__powisf2(2, -10, 1/1024.))
         return 1;
     if (test__powisf2(-2, -10, 1/1024.))

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_powitf2
 
 #include <stdio.h>
 
 #if __LDBL_MANT_DIG__ == 113
 
 #include "int_lib.h"
 #include <math.h>
 
 // Returns: a ^ b
 
-COMPILER_RT_ABI long double __powitf2(long double a, si_int b);
+COMPILER_RT_ABI long double __powitf2(long double a, int b);
 
-int test__powitf2(long double a, si_int b, long double expected)
+int test__powitf2(long double a, int b, long double expected)
 {
     long double x = __powitf2(a, b);
     int correct = (x == expected) && (signbit(x) == signbit(expected));
     if (!correct)
         printf("error in __powitf2(%Lf, %d) = %Lf, expected %Lf\n",
                a, b, x, expected);
     return !correct;
 }
#if __LDBL_MANT_DIG__ == 113
     if (test__powitf2(0, 1, 0))
         return 1;
     if (test__powitf2(0, 2, 0))
         return 1;
     if (test__powitf2(0, 3, 0))
         return 1;
     if (test__powitf2(0, 4, 0))
         return 1;
-    if (test__powitf2(0, 0x7FFFFFFE, 0))
+    if (test__powitf2(0, INT_MAX - 1, 0))
         return 1;
-    if (test__powitf2(0, 0x7FFFFFFF, 0))
+    if (test__powitf2(0, INT_MAX, 0))
         return 1;
 
     if (test__powitf2(-0., 1, -0.))
         return 1;
     if (test__powitf2(-0., 2, 0))
         return 1;
     if (test__powitf2(-0., 3, -0.))
         return 1;
     if (test__powitf2(-0., 4, 0))
         return 1;
-    if (test__powitf2(-0., 0x7FFFFFFE, 0))
+    if (test__powitf2(-0., INT_MAX - 1, 0))
         return 1;
-    if (test__powitf2(-0., 0x7FFFFFFF, -0.))
+    if (test__powitf2(-0., INT_MAX, -0.))
         return 1;
 
     if (test__powitf2(1, 1, 1))
         return 1;
     if (test__powitf2(1, 2, 1))
         return 1;
     if (test__powitf2(1, 3, 1))
         return 1;
     if (test__powitf2(1, 4, 1))
         return 1;
-    if (test__powitf2(1, 0x7FFFFFFE, 1))
+    if (test__powitf2(1, INT_MAX - 1, 1))
         return 1;
-    if (test__powitf2(1, 0x7FFFFFFF, 1))
+    if (test__powitf2(1, INT_MAX, 1))
         return 1;
 
     if (test__powitf2(INFINITY, 1, INFINITY))
         return 1;
     if (test__powitf2(INFINITY, 2, INFINITY))
         return 1;
     if (test__powitf2(INFINITY, 3, INFINITY))
         return 1;
     if (test__powitf2(INFINITY, 4, INFINITY))
         return 1;
-    if (test__powitf2(INFINITY, 0x7FFFFFFE, INFINITY))
+    if (test__powitf2(INFINITY, INT_MAX - 1, INFINITY))
         return 1;
-    if (test__powitf2(INFINITY, 0x7FFFFFFF, INFINITY))
+    if (test__powitf2(INFINITY, INT_MAX, INFINITY))
         return 1;
 
     if (test__powitf2(-INFINITY, 1, -INFINITY))
         return 1;
     if (test__powitf2(-INFINITY, 2, INFINITY))
         return 1;
     if (test__powitf2(-INFINITY, 3, -INFINITY))
         return 1;
     if (test__powitf2(-INFINITY, 4, INFINITY))
         return 1;
-    if (test__powitf2(-INFINITY, 0x7FFFFFFE, INFINITY))
+    if (test__powitf2(-INFINITY, INT_MAX - 1, INFINITY))
         return 1;
-    if (test__powitf2(-INFINITY, 0x7FFFFFFF, -INFINITY))
+    if (test__powitf2(-INFINITY, INT_MAX, -INFINITY))
         return 1;
 
     if (test__powitf2(0, -1, INFINITY))
         return 1;
     if (test__powitf2(0, -2, INFINITY))
         return 1;
     if (test__powitf2(0, -3, INFINITY))
         return 1;
     if (test__powitf2(0, -4, INFINITY))
         return 1;
-    if (test__powitf2(0, 0x80000002, INFINITY))
+    if (test__powitf2(0, INT_MIN + 2, INFINITY))
         return 1;
-    if (test__powitf2(0, 0x80000001, INFINITY))
+    if (test__powitf2(0, INT_MIN + 1, INFINITY))
         return 1;
-    if (test__powitf2(0, 0x80000000, INFINITY))
+    if (test__powitf2(0, INT_MIN, INFINITY))
         return 1;
 
     if (test__powitf2(-0., -1, -INFINITY))
         return 1;
     if (test__powitf2(-0., -2, INFINITY))
         return 1;
     if (test__powitf2(-0., -3, -INFINITY))
         return 1;
     if (test__powitf2(-0., -4, INFINITY))
         return 1;
-    if (test__powitf2(-0., 0x80000002, INFINITY))
+    if (test__powitf2(-0., INT_MIN + 2, INFINITY))
         return 1;
-    if (test__powitf2(-0., 0x80000001, -INFINITY))
+    if (test__powitf2(-0., INT_MIN + 1, -INFINITY))
         return 1;
-    if (test__powitf2(-0., 0x80000000, INFINITY))
+    if (test__powitf2(-0., INT_MIN, INFINITY))
         return 1;
 
     if (test__powitf2(1, -1, 1))
         return 1;
     if (test__powitf2(1, -2, 1))
         return 1;
     if (test__powitf2(1, -3, 1))
         return 1;
     if (test__powitf2(1, -4, 1))
         return 1;
-    if (test__powitf2(1, 0x80000002, 1))
+    if (test__powitf2(1, INT_MIN + 2, 1))
         return 1;
-    if (test__powitf2(1, 0x80000001, 1))
+    if (test__powitf2(1, INT_MIN + 1, 1))
         return 1;
-    if (test__powitf2(1, 0x80000000, 1))
+    if (test__powitf2(1, INT_MIN, 1))
         return 1;
 
     if (test__powitf2(INFINITY, -1, 0))
         return 1;
     if (test__powitf2(INFINITY, -2, 0))
         return 1;
     if (test__powitf2(INFINITY, -3, 0))
         return 1;
     if (test__powitf2(INFINITY, -4, 0))
         return 1;
-    if (test__powitf2(INFINITY, 0x80000002, 0))
+    if (test__powitf2(INFINITY, INT_MIN + 2, 0))
         return 1;
-    if (test__powitf2(INFINITY, 0x80000001, 0))
+    if (test__powitf2(INFINITY, INT_MIN + 1, 0))
         return 1;
-    if (test__powitf2(INFINITY, 0x80000000, 0))
+    if (test__powitf2(INFINITY, INT_MIN, 0))
         return 1;
 
     if (test__powitf2(-INFINITY, -1, -0.))
         return 1;
     if (test__powitf2(-INFINITY, -2, 0))
         return 1;
     if (test__powitf2(-INFINITY, -3, -0.))
         return 1;
     if (test__powitf2(-INFINITY, -4, 0))
         return 1;
-    if (test__powitf2(-INFINITY, 0x80000002, 0))
+    if (test__powitf2(-INFINITY, INT_MIN + 2, 0))
         return 1;
-    if (test__powitf2(-INFINITY, 0x80000001, -0.))
+    if (test__powitf2(-INFINITY, INT_MIN + 1, -0.))
         return 1;
-    if (test__powitf2(-INFINITY, 0x80000000, 0))
+    if (test__powitf2(-INFINITY, INT_MIN, 0))
         return 1;
 
     if (test__powitf2(2, 10, 1024.))
         return 1;
     if (test__powitf2(-2, 10, 1024.))
         return 1;
     if (test__powitf2(2, -10, 1/1024.))
         return 1;
     if (test__powitf2(-2, -10, 1/1024.))

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

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_powixf2
 // UNSUPPORTED: powerpc64
 // REQUIRES: x86-target-arch
 
 #if !_ARCH_PPC
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <math.h>
 
 // Returns: a ^ b
 
-COMPILER_RT_ABI long double __powixf2(long double a, si_int b);
+COMPILER_RT_ABI long double __powixf2(long double a, int b);
 
-int test__powixf2(long double a, si_int b, long double expected)
+int test__powixf2(long double a, int b, long double expected)
 {
     long double x = __powixf2(a, b);
     int correct = (x == expected) && (signbit(x) == signbit(expected));
     if (!correct)
         printf("error in __powixf2(%Lf, %d) = %Lf, expected %Lf\n",
                a, b, x, expected);
     return !correct;
 }
#if !_ARCH_PPC
     if (test__powixf2(0, 1, 0))
         return 1;
     if (test__powixf2(0, 2, 0))
         return 1;
     if (test__powixf2(0, 3, 0))
         return 1;
     if (test__powixf2(0, 4, 0))
         return 1;
-    if (test__powixf2(0, 0x7FFFFFFE, 0))
+    if (test__powixf2(0, INT_MAX - 1, 0))
         return 1;
-    if (test__powixf2(0, 0x7FFFFFFF, 0))
+    if (test__powixf2(0, INT_MAX, 0))
         return 1;
 
     if (test__powixf2(-0., 1, -0.))
         return 1;
     if (test__powixf2(-0., 2, 0))
         return 1;
     if (test__powixf2(-0., 3, -0.))
         return 1;
     if (test__powixf2(-0., 4, 0))
         return 1;
-    if (test__powixf2(-0., 0x7FFFFFFE, 0))
+    if (test__powixf2(-0., INT_MAX - 1, 0))
         return 1;
-    if (test__powixf2(-0., 0x7FFFFFFF, -0.))
+    if (test__powixf2(-0., INT_MAX, -0.))
         return 1;
 
     if (test__powixf2(1, 1, 1))
         return 1;
     if (test__powixf2(1, 2, 1))
         return 1;
     if (test__powixf2(1, 3, 1))
         return 1;
     if (test__powixf2(1, 4, 1))
         return 1;
-    if (test__powixf2(1, 0x7FFFFFFE, 1))
+    if (test__powixf2(1, INT_MAX - 1, 1))
         return 1;
-    if (test__powixf2(1, 0x7FFFFFFF, 1))
+    if (test__powixf2(1, INT_MAX, 1))
         return 1;
 
     if (test__powixf2(INFINITY, 1, INFINITY))
         return 1;
     if (test__powixf2(INFINITY, 2, INFINITY))
         return 1;
     if (test__powixf2(INFINITY, 3, INFINITY))
         return 1;
     if (test__powixf2(INFINITY, 4, INFINITY))
         return 1;
-    if (test__powixf2(INFINITY, 0x7FFFFFFE, INFINITY))
+    if (test__powixf2(INFINITY, INT_MAX - 1, INFINITY))
         return 1;
-    if (test__powixf2(INFINITY, 0x7FFFFFFF, INFINITY))
+    if (test__powixf2(INFINITY, INT_MAX, INFINITY))
         return 1;
 
     if (test__powixf2(-INFINITY, 1, -INFINITY))
         return 1;
     if (test__powixf2(-INFINITY, 2, INFINITY))
         return 1;
     if (test__powixf2(-INFINITY, 3, -INFINITY))
         return 1;
     if (test__powixf2(-INFINITY, 4, INFINITY))
         return 1;
-    if (test__powixf2(-INFINITY, 0x7FFFFFFE, INFINITY))
+    if (test__powixf2(-INFINITY, INT_MAX - 1, INFINITY))
         return 1;
-    if (test__powixf2(-INFINITY, 0x7FFFFFFF, -INFINITY))
+    if (test__powixf2(-INFINITY, INT_MAX, -INFINITY))
         return 1;
 
     if (test__powixf2(0, -1, INFINITY))
         return 1;
     if (test__powixf2(0, -2, INFINITY))
         return 1;
     if (test__powixf2(0, -3, INFINITY))
         return 1;
     if (test__powixf2(0, -4, INFINITY))
         return 1;
-    if (test__powixf2(0, 0x80000002, INFINITY))
+    if (test__powixf2(0, INT_MIN + 2, INFINITY))
         return 1;
-    if (test__powixf2(0, 0x80000001, INFINITY))
+    if (test__powixf2(0, INT_MIN + 1, INFINITY))
         return 1;
-    if (test__powixf2(0, 0x80000000, INFINITY))
+    if (test__powixf2(0, INT_MIN, INFINITY))
         return 1;
 
     if (test__powixf2(-0., -1, -INFINITY))
         return 1;
     if (test__powixf2(-0., -2, INFINITY))
         return 1;
     if (test__powixf2(-0., -3, -INFINITY))
         return 1;
     if (test__powixf2(-0., -4, INFINITY))
         return 1;
-    if (test__powixf2(-0., 0x80000002, INFINITY))
+    if (test__powixf2(-0., INT_MIN + 2, INFINITY))
         return 1;
-    if (test__powixf2(-0., 0x80000001, -INFINITY))
+    if (test__powixf2(-0., INT_MIN + 1, -INFINITY))
         return 1;
-    if (test__powixf2(-0., 0x80000000, INFINITY))
+    if (test__powixf2(-0., INT_MIN, INFINITY))
         return 1;
 
     if (test__powixf2(1, -1, 1))
         return 1;
     if (test__powixf2(1, -2, 1))
         return 1;
     if (test__powixf2(1, -3, 1))
         return 1;
     if (test__powixf2(1, -4, 1))
         return 1;
-    if (test__powixf2(1, 0x80000002, 1))
+    if (test__powixf2(1, INT_MIN + 2, 1))
         return 1;
-    if (test__powixf2(1, 0x80000001, 1))
+    if (test__powixf2(1, INT_MIN + 1, 1))
         return 1;
-    if (test__powixf2(1, 0x80000000, 1))
+    if (test__powixf2(1, INT_MIN, 1))
         return 1;
 
     if (test__powixf2(INFINITY, -1, 0))
         return 1;
     if (test__powixf2(INFINITY, -2, 0))
         return 1;
     if (test__powixf2(INFINITY, -3, 0))
         return 1;
     if (test__powixf2(INFINITY, -4, 0))
         return 1;
-    if (test__powixf2(INFINITY, 0x80000002, 0))
+    if (test__powixf2(INFINITY, INT_MIN + 2, 0))
         return 1;
-    if (test__powixf2(INFINITY, 0x80000001, 0))
+    if (test__powixf2(INFINITY, INT_MIN + 1, 0))
         return 1;
-    if (test__powixf2(INFINITY, 0x80000000, 0))
+    if (test__powixf2(INFINITY, INT_MIN, 0))
         return 1;
 
     if (test__powixf2(-INFINITY, -1, -0.))
         return 1;
     if (test__powixf2(-INFINITY, -2, 0))
         return 1;
     if (test__powixf2(-INFINITY, -3, -0.))
         return 1;
     if (test__powixf2(-INFINITY, -4, 0))
         return 1;
-    if (test__powixf2(-INFINITY, 0x80000002, 0))
+    if (test__powixf2(-INFINITY, INT_MIN + 2, 0))
         return 1;
-    if (test__powixf2(-INFINITY, 0x80000001, -0.))
+    if (test__powixf2(-INFINITY, INT_MIN + 1, -0.))
         return 1;
-    if (test__powixf2(-INFINITY, 0x80000000, 0))
+    if (test__powixf2(-INFINITY, INT_MIN, 0))
         return 1;
 
     if (test__powixf2(2, 10, 1024.))
         return 1;
     if (test__powixf2(-2, 10, 1024.))
         return 1;
     if (test__powixf2(2, -10, 1/1024.))
         return 1;
     if (test__powixf2(-2, -10, 1/1024.))