[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 (typedefed to native_int to make it obvious this is intentional) 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.

[atrosinenko]

Sorry, forgot to add cfe-commits to CC. Will reopen soon.

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 int native_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
+native_int __clzsi2(si_int a);  // count leading zeros
+native_int __clzdi2(di_int a);  // count leading zeros
+native_int __clzti2(ti_int a);  // count leading zeros
+native_int __ctzsi2(si_int a);  // count trailing zeros
+native_int __ctzdi2(di_int a);  // count trailing zeros
+native_int __ctzti2(ti_int a);  // count trailing zeros
+
+native_int __ffssi2(si_int a);  // find least significant 1 bit
+native_int __ffsdi2(di_int a);  // find least significant 1 bit
+native_int __ffsti2(ti_int a);  // find least significant 1 bit
+
+native_int __paritysi2(si_int a);  // bit parity
+native_int __paritydi2(di_int a);  // bit parity
+native_int __parityti2(ti_int a);  // bit parity
+
+native_int __popcountsi2(si_int a);  // bit population
+native_int __popcountdi2(di_int a);  // bit population
+native_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, native_int b);  // a ^ b
+double      __powidf2(     double a, native_int b);  // a ^ b
+long double __powixf2(long double a, native_int b);  // a ^ b
+long double __powitf2(long double a, native_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 native_int __clzsi2(si_int);
 #endif
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI si_int __clzdi2(di_int a) {
+COMPILER_RT_ABI native_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 native_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 native_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 native_int __ctzsi2(si_int);
 #endif
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI int __ctzdi2(di_int a) {
+COMPILER_RT_ABI native_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 native_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 native_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/ffsdi2.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // 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 int __ffsdi2(di_int a) {
+COMPILER_RT_ABI native_int __ffsdi2(di_int a) {
   dwords x;
   x.all = a;
   if (x.s.low == 0) {
     if (x.s.high == 0)
       return 0;
     return ctzsi(x.s.high) + (1 + sizeof(si_int) * CHAR_BIT);
   }
   return ctzsi(x.s.low) + 1;
 }

compiler-rt/lib/builtins/ffssi2.c

 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // 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 int __ffssi2(si_int a) {
+COMPILER_RT_ABI native_int __ffssi2(si_int a) {
   if (a == 0) {
     return 0;
   }
   return ctzsi(a) + 1;
 }

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 native_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 native_int __paritysi2(si_int a);
+COMPILER_RT_ABI native_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 native_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/int_types.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef INT_TYPES_H
 #define INT_TYPES_H
 
 #include "int_endianness.h"
 
+typedef int native_int;
+
 // si_int is defined in Linux sysroot's asm-generic/siginfo.h
 #ifdef si_int
 #undef si_int
 #endif
 typedef int32_t si_int;
 typedef uint32_t su_int;
 #if UINT_MAX == 0xFFFFFFFF
 #define clzsi __builtin_clz

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 native_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 native_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 native_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/popcountdi2.c

 //===-- popcountdi2.c - Implement __popcountdi2 ---------------------------===//
 //
 // 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 __popcountdi2 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // Returns: count of 1 bits
 
-COMPILER_RT_ABI int __popcountdi2(di_int a) {
+COMPILER_RT_ABI native_int __popcountdi2(di_int a) {
   du_int x2 = (du_int)a;
   x2 = x2 - ((x2 >> 1) & 0x5555555555555555uLL);
   // Every 2 bits holds the sum of every pair of bits (32)
   x2 = ((x2 >> 2) & 0x3333333333333333uLL) + (x2 & 0x3333333333333333uLL);
   // Every 4 bits holds the sum of every 4-set of bits (3 significant bits) (16)
   x2 = (x2 + (x2 >> 4)) & 0x0F0F0F0F0F0F0F0FuLL;
   // Every 8 bits holds the sum of every 8-set of bits (4 significant bits) (8)
   su_int x = (su_int)(x2 + (x2 >> 32));
   // The lower 32 bits hold four 16 bit sums (5 significant bits).
   //   Upper 32 bits are garbage
   x = x + (x >> 16);
   // The lower 16 bits hold two 32 bit sums (6 significant bits).
   //   Upper 16 bits are garbage
   return (x + (x >> 8)) & 0x0000007F; // (7 significant bits)
 }

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 native_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 native_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, native_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, native_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, native_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, native_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

 
 #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 native_int __clzdi2(di_int a);
 
-int test__clzdi2(di_int a, si_int expected)
+int test__clzdi2(di_int a, native_int expected)
 {
-    si_int x = __clzdi2(a);
+    native_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

 
 #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 native_int __clzsi2(si_int a);
 
-int test__clzsi2(si_int a, si_int expected)
+int test__clzsi2(si_int a, native_int expected)
 {
-    si_int x = __clzsi2(a);
+    native_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

 #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 native_int __clzti2(ti_int a);
 
-int test__clzti2(ti_int a, si_int expected)
+int test__clzti2(ti_int a, native_int expected)
 {
-    si_int x = __clzti2(a);
+    native_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/ctzdi2_test.c

 
 #include "int_lib.h"
 #include <stdio.h>
 
 // Returns: the number of trailing 0-bits
 
 // Precondition: a != 0
 
-COMPILER_RT_ABI int __ctzdi2(di_int a);
+COMPILER_RT_ABI native_int __ctzdi2(di_int a);
 
-int test__ctzdi2(di_int a, int expected)
+int test__ctzdi2(di_int a, native_int expected)
 {
-    int x = __ctzdi2(a);
+    native_int x = __ctzdi2(a);
     if (x != expected)
         printf("error in __ctzdi2(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/ctzsi2_test.c

 
 #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 native_int __ctzsi2(si_int a);
 
-int test__ctzsi2(si_int a, si_int expected)
+int test__ctzsi2(si_int a, native_int expected)
 {
-    si_int x = __ctzsi2(a);
+    native_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

 #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 native_int __ctzti2(ti_int a);
 
-int test__ctzti2(ti_int a, si_int expected)
+int test__ctzti2(ti_int a, native_int expected)
 {
-    si_int x = __ctzti2(a);
+    native_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/ffsdi2_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // 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 int __ffsdi2(di_int a);
+COMPILER_RT_ABI native_int __ffsdi2(di_int a);
 
-int test__ffsdi2(di_int a, int expected)
+int test__ffsdi2(di_int a, native_int expected)
 {
-    int x = __ffsdi2(a);
+    native_int x = __ffsdi2(a);
     if (x != expected)
         printf("error in __ffsdi2(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/ffssi2_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 
 // 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 int __ffssi2(si_int a);
+COMPILER_RT_ABI native_int __ffssi2(si_int a);
 
-int test__ffssi2(si_int a, int expected)
+int test__ffssi2(si_int a, native_int expected)
 {
-    int x = __ffssi2(a);
+    native_int x = __ffssi2(a);
     if (x != expected)
         printf("error in __ffssi2(0x%X) = %d, expected %d\n", a, x, expected);
     return x != expected;
 }
 
 int main()
 {
     if (test__ffssi2(0x00000000, 0))

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

 #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 native_int __ffsti2(ti_int a);
 
-int test__ffsti2(ti_int a, si_int expected)
+int test__ffsti2(ti_int a, native_int expected)
 {
-    si_int x = __ffsti2(a);
+    native_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

 //===----------------------------------------------------------------------===//
 
 #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 native_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

 //===----------------------------------------------------------------------===//
 
 #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 native_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

 #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 native_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/popcountdi2_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 // Returns: count of 1 bits
 
-COMPILER_RT_ABI int __popcountdi2(di_int a);
+COMPILER_RT_ABI native_int __popcountdi2(di_int a);
 
 int naive_popcount(di_int a)
 {
     int r = 0;
     for (; a; a = (du_int)a >> 1)
         r += a & 1;
     return r;
 }

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

 //===----------------------------------------------------------------------===//
 
 #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 native_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

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

 //===----------------------------------------------------------------------===//
 
 #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, native_int b);
 
-int test__powidf2(double a, si_int b, double expected)
+int test__powidf2(double a, native_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;

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

 //===----------------------------------------------------------------------===//
 
 #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, native_int b);
 
-int test__powisf2(float a, si_int b, float expected)
+int test__powisf2(float a, native_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;

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

 
 #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, native_int b);
 
-int test__powitf2(long double a, si_int b, long double expected)
+int test__powitf2(long double a, native_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;

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

 #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, native_int b);
 
-int test__powixf2(long double a, si_int b, long double expected)
+int test__powixf2(long double a, native_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;