diff mbox series

Use gcc __builtin_stdc_* builtins in stdbit.h if possible

Message ID ZawLOilk2vh1EDYP@tucnak
State New
Headers show
Series Use gcc __builtin_stdc_* builtins in stdbit.h if possible | expand

Commit Message

Jakub Jelinek Jan. 20, 2024, 6:04 p.m. UTC
Hi!

The following patch uses the GCC 14 __builtin_stdc_* builtins in stdbit.h,
so that when compiled with GCC 14 or later, it supports not just
8/16/32/64-bit unsigned integers, but also 128-bit (if target supports them)
and unsigned _BitInt (any supported precision).  And so that the macros
don't expand arguments multiple times and can be evaluated in constant
expressions.

The new testcase is gcc's gcc/testsuite/gcc.dg/builtin-stdc-bit-1.c
adjusted to test stdbit.h and the type-generic macros in there instead
of the builtins and adjusted to use glibc test framework rather than
gcc style tests with __builtin_abort ().

Tested on x86_64-linux (with GCC 12), additionally tested with
rm stdlib/tst-std{c,bit}*
CC=/gcc14/usr/local/bin/gcc PATH=/gcc14/usr/local/bin:$PATH make CC=/gcc14/usr/local/bin/gcc check subdirs=stdlib -j32


	Jakub

Comments

Joseph Myers Jan. 20, 2024, 11:27 p.m. UTC | #1
On Sat, 20 Jan 2024, Jakub Jelinek wrote:

> +# define stdc_leading_zeros_uc(x) \
> +  (__builtin_stdc_leading_zeros ((unsigned char) (x)))
> +# define stdc_leading_zeros_us(x) \
> +  (__builtin_stdc_leading_zeros ((unsigned short) (x)))
> +# define stdc_leading_zeros_ui(x) \
> +  (__builtin_stdc_leading_zeros ((unsigned int) (x)))
> +# define stdc_leading_zeros_ul(x) \
> +  (__builtin_stdc_leading_zeros ((unsigned long int) (x)))
> +# define stdc_leading_zeros_ull(x) \
> +  (__builtin_stdc_leading_zeros ((unsigned long long int) (x)))

I don't like defining any of the type-specific functions as macros using 
casts (as opposed to implicit conversions); implicit conversions ensure 
they have appropriate diagnostics for bad argument types that might be 
lost with a cast (in particular, if someone passes a pointer to one of the 
functions taking a pointer-sized integer, getting an error from the 
implicit conversion is desirable, rather that a cast from pointer to 
integer without a diagnostic).
diff mbox series

Patch

diff --git a/manual/stdbit.texi b/manual/stdbit.texi
index fe41c671d8..0878015cc7 100644
--- a/manual/stdbit.texi
+++ b/manual/stdbit.texi
@@ -32,7 +32,9 @@  and @code{unsigned long long int}.  In addition, there is a
 corresponding type-generic macro (not listed below), named the same as
 the functions but without any suffix such as @samp{_uc}.  The
 type-generic macro can only be used with an argument of an unsigned
-integer type with a width of 8, 16, 32 or 64 bits.
+integer type with a width of 8, 16, 32 or 64 bits, or when using
+a compiler with support for stdc builtins such as GCC 14.1 or later
+any unsigned integer type those builtins support.
 
 @deftypefun {unsigned int} stdc_leading_zeros_uc (unsigned char @var{x})
 @deftypefunx {unsigned int} stdc_leading_zeros_us (unsigned short @var{x})
diff --git a/stdlib/Makefile b/stdlib/Makefile
index d587f054d1..9898cc5d8a 100644
--- a/stdlib/Makefile
+++ b/stdlib/Makefile
@@ -308,6 +308,7 @@  tests := \
   tst-setcontext10 \
   tst-setcontext11 \
   tst-stdbit-Wconversion \
+  tst-stdbit-builtins \
   tst-stdc_bit_ceil \
   tst-stdc_bit_floor \
   tst-stdc_bit_width \
diff --git a/stdlib/stdbit.h b/stdlib/stdbit.h
index f334eb174d..09a45b06a8 100644
--- a/stdlib/stdbit.h
+++ b/stdlib/stdbit.h
@@ -64,11 +64,24 @@  extern unsigned int stdc_leading_zeros_ul (unsigned long int __x)
 __extension__
 extern unsigned int stdc_leading_zeros_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_leading_zeros(x)				\
+#if __glibc_has_builtin (__builtin_stdc_leading_zeros)
+# define stdc_leading_zeros(x) (__builtin_stdc_leading_zeros (x))
+# define stdc_leading_zeros_uc(x) \
+  (__builtin_stdc_leading_zeros ((unsigned char) (x)))
+# define stdc_leading_zeros_us(x) \
+  (__builtin_stdc_leading_zeros ((unsigned short) (x)))
+# define stdc_leading_zeros_ui(x) \
+  (__builtin_stdc_leading_zeros ((unsigned int) (x)))
+# define stdc_leading_zeros_ul(x) \
+  (__builtin_stdc_leading_zeros ((unsigned long int) (x)))
+# define stdc_leading_zeros_ull(x) \
+  (__builtin_stdc_leading_zeros ((unsigned long long int) (x)))
+#else
+# define stdc_leading_zeros(x)				\
   (stdc_leading_zeros_ull (x)				\
    - (unsigned int) (8 * (sizeof (0ULL) - sizeof (x))))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
 static __always_inline unsigned int
 __clz64_inline (uint64_t __x)
 {
@@ -93,15 +106,16 @@  __clz8_inline (uint8_t __x)
   return __clz32_inline (__x) - 24;
 }
 
-# define stdc_leading_zeros_uc(x) (__clz8_inline (x))
-# define stdc_leading_zeros_us(x) (__clz16_inline (x))
-# define stdc_leading_zeros_ui(x) (__clz32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_leading_zeros_ul(x) (__clz64_inline (x))
-# else
-#  define stdc_leading_zeros_ul(x) (__clz32_inline (x))
+#  define stdc_leading_zeros_uc(x) (__clz8_inline (x))
+#  define stdc_leading_zeros_us(x) (__clz16_inline (x))
+#  define stdc_leading_zeros_ui(x) (__clz32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_leading_zeros_ul(x) (__clz64_inline (x))
+#  else
+#   define stdc_leading_zeros_ul(x) (__clz32_inline (x))
+#  endif
+#  define stdc_leading_zeros_ull(x) (__clz64_inline (x))
 # endif
-# define stdc_leading_zeros_ull(x) (__clz64_inline (x))
 #endif
 
 /* Count leading ones.  */
@@ -116,11 +130,24 @@  extern unsigned int stdc_leading_ones_ul (unsigned long int __x)
 __extension__
 extern unsigned int stdc_leading_ones_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_leading_ones(x)					\
+#if __glibc_has_builtin (__builtin_stdc_leading_ones)
+# define stdc_leading_ones(x) (__builtin_stdc_leading_ones (x))
+# define stdc_leading_ones_uc(x) \
+  (__builtin_stdc_leading_ones ((unsigned char) (x)))
+# define stdc_leading_ones_us(x) \
+  (__builtin_stdc_leading_ones ((unsigned short) (x)))
+# define stdc_leading_ones_ui(x) \
+  (__builtin_stdc_leading_ones ((unsigned int) (x)))
+# define stdc_leading_ones_ul(x) \
+  (__builtin_stdc_leading_ones ((unsigned long int) (x)))
+# define stdc_leading_ones_ull(x) \
+  (__builtin_stdc_leading_ones ((unsigned long long int) (x)))
+#else
+# define stdc_leading_ones(x)					\
   (stdc_leading_ones_ull ((unsigned long long int) (x)		\
 			  << 8 * (sizeof (0ULL) - sizeof (x))))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
 static __always_inline unsigned int
 __clo64_inline (uint64_t __x)
 {
@@ -145,15 +172,16 @@  __clo8_inline (uint8_t __x)
   return __clz8_inline (__pacify_uint8 (~__x));
 }
 
-# define stdc_leading_ones_uc(x) (__clo8_inline (x))
-# define stdc_leading_ones_us(x) (__clo16_inline (x))
-# define stdc_leading_ones_ui(x) (__clo32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_leading_ones_ul(x) (__clo64_inline (x))
-# else
-#  define stdc_leading_ones_ul(x) (__clo32_inline (x))
+#  define stdc_leading_ones_uc(x) (__clo8_inline (x))
+#  define stdc_leading_ones_us(x) (__clo16_inline (x))
+#  define stdc_leading_ones_ui(x) (__clo32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_leading_ones_ul(x) (__clo64_inline (x))
+#  else
+#   define stdc_leading_ones_ul(x) (__clo32_inline (x))
+#  endif
+#  define stdc_leading_ones_ull(x) (__clo64_inline (x))
 # endif
-# define stdc_leading_ones_ull(x) (__clo64_inline (x))
 #endif
 
 /* Count trailing zeros.  */
@@ -168,13 +196,26 @@  extern unsigned int stdc_trailing_zeros_ul (unsigned long int __x)
 __extension__
 extern unsigned int stdc_trailing_zeros_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_trailing_zeros(x)				\
+#if __glibc_has_builtin (__builtin_stdc_trailing_zeros)
+# define stdc_trailing_zeros(x) (__builtin_stdc_trailing_zeros (x))
+# define stdc_trailing_zeros_uc(x) \
+  (__builtin_stdc_trailing_zeros ((unsigned char) (x)))
+# define stdc_trailing_zeros_us(x) \
+  (__builtin_stdc_trailing_zeros ((unsigned short) (x)))
+# define stdc_trailing_zeros_ui(x) \
+  (__builtin_stdc_trailing_zeros ((unsigned int) (x)))
+# define stdc_trailing_zeros_ul(x) \
+  (__builtin_stdc_trailing_zeros ((unsigned long int) (x)))
+# define stdc_trailing_zeros_ull(x) \
+  (__builtin_stdc_trailing_zeros ((unsigned long long int) (x)))
+#else
+# define stdc_trailing_zeros(x)				\
   (sizeof (x) == 8 ? stdc_trailing_zeros_ull (x)	\
    : sizeof (x) == 4 ? stdc_trailing_zeros_ui (x)	\
    : sizeof (x) == 2 ? stdc_trailing_zeros_us (__pacify_uint16 (x))	\
    : stdc_trailing_zeros_uc (__pacify_uint8 (x)))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_ctzll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_ctzll)
 static __always_inline unsigned int
 __ctz64_inline (uint64_t __x)
 {
@@ -199,15 +240,16 @@  __ctz8_inline (uint8_t __x)
   return __x == 0 ? 8U : (unsigned int) __builtin_ctz (__x);
 }
 
-# define stdc_trailing_zeros_uc(x) (__ctz8_inline (x))
-# define stdc_trailing_zeros_us(x) (__ctz16_inline (x))
-# define stdc_trailing_zeros_ui(x) (__ctz32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_trailing_zeros_ul(x) (__ctz64_inline (x))
-# else
-#  define stdc_trailing_zeros_ul(x) (__ctz32_inline (x))
+#  define stdc_trailing_zeros_uc(x) (__ctz8_inline (x))
+#  define stdc_trailing_zeros_us(x) (__ctz16_inline (x))
+#  define stdc_trailing_zeros_ui(x) (__ctz32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_trailing_zeros_ul(x) (__ctz64_inline (x))
+#  else
+#   define stdc_trailing_zeros_ul(x) (__ctz32_inline (x))
+#  endif
+#  define stdc_trailing_zeros_ull(x) (__ctz64_inline (x))
 # endif
-# define stdc_trailing_zeros_ull(x) (__ctz64_inline (x))
 #endif
 
 /* Count trailing ones.  */
@@ -222,9 +264,22 @@  extern unsigned int stdc_trailing_ones_ul (unsigned long int __x)
 __extension__
 extern unsigned int stdc_trailing_ones_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_trailing_ones(x) (stdc_trailing_ones_ull (x))
+#if __glibc_has_builtin (__builtin_stdc_trailing_ones)
+# define stdc_trailing_ones(x) (__builtin_stdc_trailing_ones (x))
+# define stdc_trailing_ones_uc(x) \
+  (__builtin_stdc_trailing_ones ((unsigned char) (x)))
+# define stdc_trailing_ones_us(x) \
+  (__builtin_stdc_trailing_ones ((unsigned short) (x)))
+# define stdc_trailing_ones_ui(x) \
+  (__builtin_stdc_trailing_ones ((unsigned int) (x)))
+# define stdc_trailing_ones_ul(x) \
+  (__builtin_stdc_trailing_ones ((unsigned long int) (x)))
+# define stdc_trailing_ones_ull(x) \
+  (__builtin_stdc_trailing_ones ((unsigned long long int) (x)))
+#else
+# define stdc_trailing_ones(x) (stdc_trailing_ones_ull (x))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_ctzll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_ctzll)
 static __always_inline unsigned int
 __cto64_inline (uint64_t __x)
 {
@@ -249,15 +304,16 @@  __cto8_inline (uint8_t __x)
   return __ctz8_inline (__pacify_uint8 (~__x));
 }
 
-# define stdc_trailing_ones_uc(x) (__cto8_inline (x))
-# define stdc_trailing_ones_us(x) (__cto16_inline (x))
-# define stdc_trailing_ones_ui(x) (__cto32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_trailing_ones_ul(x) (__cto64_inline (x))
-# else
-#  define stdc_trailing_ones_ul(x) (__cto32_inline (x))
+#  define stdc_trailing_ones_uc(x) (__cto8_inline (x))
+#  define stdc_trailing_ones_us(x) (__cto16_inline (x))
+#  define stdc_trailing_ones_ui(x) (__cto32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_trailing_ones_ul(x) (__cto64_inline (x))
+#  else
+#   define stdc_trailing_ones_ul(x) (__cto32_inline (x))
+#  endif
+#  define stdc_trailing_ones_ull(x) (__cto64_inline (x))
 # endif
-# define stdc_trailing_ones_ull(x) (__cto64_inline (x))
 #endif
 
 /* First leading zero.  */
@@ -272,13 +328,26 @@  extern unsigned int stdc_first_leading_zero_ul (unsigned long int __x)
 __extension__
 extern unsigned int stdc_first_leading_zero_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_first_leading_zero(x)			\
+#if __glibc_has_builtin (__builtin_stdc_first_leading_zero)
+# define stdc_first_leading_zero(x) (__builtin_stdc_first_leading_zero (x))
+# define stdc_first_leading_zero_uc(x) \
+  (__builtin_stdc_first_leading_zero ((unsigned char) (x)))
+# define stdc_first_leading_zero_us(x) \
+  (__builtin_stdc_first_leading_zero ((unsigned short) (x)))
+# define stdc_first_leading_zero_ui(x) \
+  (__builtin_stdc_first_leading_zero ((unsigned int) (x)))
+# define stdc_first_leading_zero_ul(x) \
+  (__builtin_stdc_first_leading_zero ((unsigned long int) (x)))
+# define stdc_first_leading_zero_ull(x) \
+  (__builtin_stdc_first_leading_zero ((unsigned long long int) (x)))
+#else
+# define stdc_first_leading_zero(x)			\
   (sizeof (x) == 8 ? stdc_first_leading_zero_ull (x)	\
    : sizeof (x) == 4 ? stdc_first_leading_zero_ui (x)	\
    : sizeof (x) == 2 ? stdc_first_leading_zero_us (__pacify_uint16 (x))	\
    : stdc_first_leading_zero_uc (__pacify_uint8 (x)))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
 static __always_inline unsigned int
 __flz64_inline (uint64_t __x)
 {
@@ -303,15 +372,16 @@  __flz8_inline (uint8_t __x)
   return __x == (uint8_t) -1 ? 0 : 1 + __clo8_inline (__x);
 }
 
-# define stdc_first_leading_zero_uc(x) (__flz8_inline (x))
-# define stdc_first_leading_zero_us(x) (__flz16_inline (x))
-# define stdc_first_leading_zero_ui(x) (__flz32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_first_leading_zero_ul(x) (__flz64_inline (x))
-# else
-#  define stdc_first_leading_zero_ul(x) (__flz32_inline (x))
+#  define stdc_first_leading_zero_uc(x) (__flz8_inline (x))
+#  define stdc_first_leading_zero_us(x) (__flz16_inline (x))
+#  define stdc_first_leading_zero_ui(x) (__flz32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_first_leading_zero_ul(x) (__flz64_inline (x))
+#  else
+#   define stdc_first_leading_zero_ul(x) (__flz32_inline (x))
+#  endif
+#  define stdc_first_leading_zero_ull(x) (__flz64_inline (x))
 # endif
-# define stdc_first_leading_zero_ull(x) (__flz64_inline (x))
 #endif
 
 /* First leading one.  */
@@ -326,13 +396,26 @@  extern unsigned int stdc_first_leading_one_ul (unsigned long int __x)
 __extension__
 extern unsigned int stdc_first_leading_one_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_first_leading_one(x)			\
+#if __glibc_has_builtin (__builtin_stdc_first_leading_one)
+# define stdc_first_leading_one(x) (__builtin_stdc_first_leading_one (x))
+# define stdc_first_leading_one_uc(x) \
+  (__builtin_stdc_first_leading_one ((unsigned char) (x)))
+# define stdc_first_leading_one_us(x) \
+  (__builtin_stdc_first_leading_one ((unsigned short) (x)))
+# define stdc_first_leading_one_ui(x) \
+  (__builtin_stdc_first_leading_one ((unsigned int) (x)))
+# define stdc_first_leading_one_ul(x) \
+  (__builtin_stdc_first_leading_one ((unsigned long int) (x)))
+# define stdc_first_leading_one_ull(x) \
+  (__builtin_stdc_first_leading_one ((unsigned long long int) (x)))
+#else
+# define stdc_first_leading_one(x)			\
   (sizeof (x) == 8 ? stdc_first_leading_one_ull (x)	\
    : sizeof (x) == 4 ? stdc_first_leading_one_ui (x)	\
    : sizeof (x) == 2 ? stdc_first_leading_one_us (__pacify_uint16 (x))	\
    : stdc_first_leading_one_uc (__pacify_uint8 (x)))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
 static __always_inline unsigned int
 __flo64_inline (uint64_t __x)
 {
@@ -357,15 +440,16 @@  __flo8_inline (uint8_t __x)
   return __x == 0 ? 0 : 1 + __clz8_inline (__x);
 }
 
-# define stdc_first_leading_one_uc(x) (__flo8_inline (x))
-# define stdc_first_leading_one_us(x) (__flo16_inline (x))
-# define stdc_first_leading_one_ui(x) (__flo32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_first_leading_one_ul(x) (__flo64_inline (x))
-# else
-#  define stdc_first_leading_one_ul(x) (__flo32_inline (x))
+#  define stdc_first_leading_one_uc(x) (__flo8_inline (x))
+#  define stdc_first_leading_one_us(x) (__flo16_inline (x))
+#  define stdc_first_leading_one_ui(x) (__flo32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_first_leading_one_ul(x) (__flo64_inline (x))
+#  else
+#   define stdc_first_leading_one_ul(x) (__flo32_inline (x))
+#  endif
+#  define stdc_first_leading_one_ull(x) (__flo64_inline (x))
 # endif
-# define stdc_first_leading_one_ull(x) (__flo64_inline (x))
 #endif
 
 /* First trailing zero.  */
@@ -380,13 +464,26 @@  extern unsigned int stdc_first_trailing_zero_ul (unsigned long int __x)
 __extension__
 extern unsigned int stdc_first_trailing_zero_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_first_trailing_zero(x)			\
+#if __glibc_has_builtin (__builtin_stdc_first_trailing_zero)
+# define stdc_first_trailing_zero(x) (__builtin_stdc_first_trailing_zero (x))
+# define stdc_first_trailing_zero_uc(x) \
+  (__builtin_stdc_first_trailing_zero ((unsigned char) (x)))
+# define stdc_first_trailing_zero_us(x) \
+  (__builtin_stdc_first_trailing_zero ((unsigned short) (x)))
+# define stdc_first_trailing_zero_ui(x) \
+  (__builtin_stdc_first_trailing_zero ((unsigned int) (x)))
+# define stdc_first_trailing_zero_ul(x) \
+  (__builtin_stdc_first_trailing_zero ((unsigned long int) (x)))
+# define stdc_first_trailing_zero_ull(x) \
+  (__builtin_stdc_first_trailing_zero ((unsigned long long int) (x)))
+#else
+# define stdc_first_trailing_zero(x)			\
   (sizeof (x) == 8 ? stdc_first_trailing_zero_ull (x)	\
    : sizeof (x) == 4 ? stdc_first_trailing_zero_ui (x)	\
    : sizeof (x) == 2 ? stdc_first_trailing_zero_us (__pacify_uint16 (x)) \
    : stdc_first_trailing_zero_uc (__pacify_uint8 (x)))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_ctzll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_ctzll)
 static __always_inline unsigned int
 __ftz64_inline (uint64_t __x)
 {
@@ -411,15 +508,16 @@  __ftz8_inline (uint8_t __x)
   return __x == (uint8_t) -1 ? 0 : 1 + __cto8_inline (__x);
 }
 
-# define stdc_first_trailing_zero_uc(x) (__ftz8_inline (x))
-# define stdc_first_trailing_zero_us(x) (__ftz16_inline (x))
-# define stdc_first_trailing_zero_ui(x) (__ftz32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_first_trailing_zero_ul(x) (__ftz64_inline (x))
-# else
-#  define stdc_first_trailing_zero_ul(x) (__ftz32_inline (x))
+#  define stdc_first_trailing_zero_uc(x) (__ftz8_inline (x))
+#  define stdc_first_trailing_zero_us(x) (__ftz16_inline (x))
+#  define stdc_first_trailing_zero_ui(x) (__ftz32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_first_trailing_zero_ul(x) (__ftz64_inline (x))
+#  else
+#   define stdc_first_trailing_zero_ul(x) (__ftz32_inline (x))
+#  endif
+#  define stdc_first_trailing_zero_ull(x) (__ftz64_inline (x))
 # endif
-# define stdc_first_trailing_zero_ull(x) (__ftz64_inline (x))
 #endif
 
 /* First trailing one.  */
@@ -434,13 +532,26 @@  extern unsigned int stdc_first_trailing_one_ul (unsigned long int __x)
 __extension__
 extern unsigned int stdc_first_trailing_one_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_first_trailing_one(x)			\
+#if __glibc_has_builtin (__builtin_stdc_first_trailing_one)
+# define stdc_first_trailing_one(x) (__builtin_stdc_first_trailing_one (x))
+# define stdc_first_trailing_one_uc(x) \
+  (__builtin_stdc_first_trailing_one ((unsigned char) (x)))
+# define stdc_first_trailing_one_us(x) \
+  (__builtin_stdc_first_trailing_one ((unsigned short) (x)))
+# define stdc_first_trailing_one_ui(x) \
+  (__builtin_stdc_first_trailing_one ((unsigned int) (x)))
+# define stdc_first_trailing_one_ul(x) \
+  (__builtin_stdc_first_trailing_one ((unsigned long int) (x)))
+# define stdc_first_trailing_one_ull(x) \
+  (__builtin_stdc_first_trailing_one ((unsigned long long int) (x)))
+#else
+# define stdc_first_trailing_one(x)			\
   (sizeof (x) == 8 ? stdc_first_trailing_one_ull (x)	\
    : sizeof (x) == 4 ? stdc_first_trailing_one_ui (x)	\
    : sizeof (x) == 2 ? stdc_first_trailing_one_us (__pacify_uint16 (x))	\
    : stdc_first_trailing_one_uc (__pacify_uint8 (x)))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_ctzll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_ctzll)
 static __always_inline unsigned int
 __fto64_inline (uint64_t __x)
 {
@@ -465,15 +576,16 @@  __fto8_inline (uint8_t __x)
   return __x == 0 ? 0 : 1 + __ctz8_inline (__x);
 }
 
-# define stdc_first_trailing_one_uc(x) (__fto8_inline (x))
-# define stdc_first_trailing_one_us(x) (__fto16_inline (x))
-# define stdc_first_trailing_one_ui(x) (__fto32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_first_trailing_one_ul(x) (__fto64_inline (x))
-# else
-#  define stdc_first_trailing_one_ul(x) (__fto32_inline (x))
+#  define stdc_first_trailing_one_uc(x) (__fto8_inline (x))
+#  define stdc_first_trailing_one_us(x) (__fto16_inline (x))
+#  define stdc_first_trailing_one_ui(x) (__fto32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_first_trailing_one_ul(x) (__fto64_inline (x))
+#  else
+#   define stdc_first_trailing_one_ul(x) (__fto32_inline (x))
+#  endif
+#  define stdc_first_trailing_one_ull(x) (__fto64_inline (x))
 # endif
-# define stdc_first_trailing_one_ull(x) (__fto64_inline (x))
 #endif
 
 /* Count zeros.  */
@@ -488,11 +600,24 @@  extern unsigned int stdc_count_zeros_ul (unsigned long int __x)
 __extension__
 extern unsigned int stdc_count_zeros_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_count_zeros(x)				\
+#if __glibc_has_builtin (__builtin_stdc_count_zeros)
+# define stdc_count_zeros(x) (__builtin_stdc_count_zeros (x))
+# define stdc_count_zeros_uc(x) \
+  (__builtin_stdc_count_zeros ((unsigned char) (x)))
+# define stdc_count_zeros_us(x) \
+  (__builtin_stdc_count_zeros ((unsigned short) (x)))
+# define stdc_count_zeros_ui(x) \
+  (__builtin_stdc_count_zeros ((unsigned int) (x)))
+# define stdc_count_zeros_ul(x) \
+  (__builtin_stdc_count_zeros ((unsigned long int) (x)))
+# define stdc_count_zeros_ull(x) \
+  (__builtin_stdc_count_zeros ((unsigned long long int) (x)))
+#else
+# define stdc_count_zeros(x)				\
   (stdc_count_zeros_ull (x)				\
    - (unsigned int) (8 * (sizeof (0ULL) - sizeof (x))))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_popcountll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_popcountll)
 static __always_inline unsigned int
 __cz64_inline (uint64_t __x)
 {
@@ -517,15 +642,16 @@  __cz8_inline (uint8_t __x)
   return 8U - (unsigned int) __builtin_popcount (__x);
 }
 
-# define stdc_count_zeros_uc(x) (__cz8_inline (x))
-# define stdc_count_zeros_us(x) (__cz16_inline (x))
-# define stdc_count_zeros_ui(x) (__cz32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_count_zeros_ul(x) (__cz64_inline (x))
-# else
-#  define stdc_count_zeros_ul(x) (__cz32_inline (x))
+#  define stdc_count_zeros_uc(x) (__cz8_inline (x))
+#  define stdc_count_zeros_us(x) (__cz16_inline (x))
+#  define stdc_count_zeros_ui(x) (__cz32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_count_zeros_ul(x) (__cz64_inline (x))
+#  else
+#   define stdc_count_zeros_ul(x) (__cz32_inline (x))
+#  endif
+#  define stdc_count_zeros_ull(x) (__cz64_inline (x))
 # endif
-# define stdc_count_zeros_ull(x) (__cz64_inline (x))
 #endif
 
 /* Count ones.  */
@@ -540,9 +666,22 @@  extern unsigned int stdc_count_ones_ul (unsigned long int __x)
 __extension__
 extern unsigned int stdc_count_ones_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_count_ones(x) (stdc_count_ones_ull (x))
+#if __glibc_has_builtin (__builtin_stdc_count_ones)
+# define stdc_count_ones(x) (__builtin_stdc_count_ones (x))
+# define stdc_count_ones_uc(x) \
+  (__builtin_stdc_count_ones ((unsigned char) (x)))
+# define stdc_count_ones_us(x) \
+  (__builtin_stdc_count_ones ((unsigned short) (x)))
+# define stdc_count_ones_ui(x) \
+  (__builtin_stdc_count_ones ((unsigned int) (x)))
+# define stdc_count_ones_ul(x) \
+  (__builtin_stdc_count_ones ((unsigned long int) (x)))
+# define stdc_count_ones_ull(x) \
+  (__builtin_stdc_count_ones ((unsigned long long int) (x)))
+#else
+# define stdc_count_ones(x) (stdc_count_ones_ull (x))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_popcountll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_popcountll)
 static __always_inline unsigned int
 __co64_inline (uint64_t __x)
 {
@@ -567,15 +706,16 @@  __co8_inline (uint8_t __x)
   return (unsigned int) __builtin_popcount (__x);
 }
 
-# define stdc_count_ones_uc(x) (__co8_inline (x))
-# define stdc_count_ones_us(x) (__co16_inline (x))
-# define stdc_count_ones_ui(x) (__co32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_count_ones_ul(x) (__co64_inline (x))
-# else
-#  define stdc_count_ones_ul(x) (__co32_inline (x))
+#  define stdc_count_ones_uc(x) (__co8_inline (x))
+#  define stdc_count_ones_us(x) (__co16_inline (x))
+#  define stdc_count_ones_ui(x) (__co32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_count_ones_ul(x) (__co64_inline (x))
+#  else
+#   define stdc_count_ones_ul(x) (__co32_inline (x))
+#  endif
+#  define stdc_count_ones_ull(x) (__co64_inline (x))
 # endif
-# define stdc_count_ones_ull(x) (__co64_inline (x))
 #endif
 
 /* Single-bit check.  */
@@ -590,7 +730,20 @@  extern bool stdc_has_single_bit_ul (unsigned long int __x)
 __extension__
 extern bool stdc_has_single_bit_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_has_single_bit(x)				\
+#if __glibc_has_builtin (__builtin_stdc_has_single_bit)
+# define stdc_has_single_bit(x) (__builtin_stdc_has_single_bit (x))
+# define stdc_has_single_bit_uc(x) \
+  (__builtin_stdc_has_single_bit ((unsigned char) (x)))
+# define stdc_has_single_bit_us(x) \
+  (__builtin_stdc_has_single_bit ((unsigned short) (x)))
+# define stdc_has_single_bit_ui(x) \
+  (__builtin_stdc_has_single_bit ((unsigned int) (x)))
+# define stdc_has_single_bit_ul(x) \
+  (__builtin_stdc_has_single_bit ((unsigned long int) (x)))
+# define stdc_has_single_bit_ull(x) \
+  (__builtin_stdc_has_single_bit ((unsigned long long int) (x)))
+#else
+# define stdc_has_single_bit(x)				\
   ((bool) (sizeof (x) <= sizeof (unsigned int)		\
 	   ? stdc_has_single_bit_ui (x)			\
 	   : stdc_has_single_bit_ull (x)))
@@ -619,15 +772,16 @@  __hsb8_inline (uint8_t __x)
   return (__x ^ (__x - 1)) > __x - 1;
 }
 
-#define stdc_has_single_bit_uc(x) (__hsb8_inline (x))
-#define stdc_has_single_bit_us(x) (__hsb16_inline (x))
-#define stdc_has_single_bit_ui(x) (__hsb32_inline (x))
-#if __WORDSIZE == 64
-# define stdc_has_single_bit_ul(x) (__hsb64_inline (x))
-#else
-# define stdc_has_single_bit_ul(x) (__hsb32_inline (x))
+# define stdc_has_single_bit_uc(x) (__hsb8_inline (x))
+# define stdc_has_single_bit_us(x) (__hsb16_inline (x))
+# define stdc_has_single_bit_ui(x) (__hsb32_inline (x))
+# if __WORDSIZE == 64
+#  define stdc_has_single_bit_ul(x) (__hsb64_inline (x))
+# else
+#  define stdc_has_single_bit_ul(x) (__hsb32_inline (x))
+# endif
+# define stdc_has_single_bit_ull(x) (__hsb64_inline (x))
 #endif
-#define stdc_has_single_bit_ull(x) (__hsb64_inline (x))
 
 /* Bit width.  */
 extern unsigned int stdc_bit_width_uc (unsigned char __x)
@@ -641,9 +795,22 @@  extern unsigned int stdc_bit_width_ul (unsigned long int __x)
 __extension__
 extern unsigned int stdc_bit_width_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_bit_width(x) (stdc_bit_width_ull (x))
+#if __glibc_has_builtin (__builtin_stdc_bit_width)
+# define stdc_bit_width(x) (__builtin_stdc_bit_width (x))
+# define stdc_bit_width_uc(x) \
+  (__builtin_stdc_bit_width ((unsigned char) (x)))
+# define stdc_bit_width_us(x) \
+  (__builtin_stdc_bit_width ((unsigned short) (x)))
+# define stdc_bit_width_ui(x) \
+  (__builtin_stdc_bit_width ((unsigned int) (x)))
+# define stdc_bit_width_ul(x) \
+  (__builtin_stdc_bit_width ((unsigned long int) (x)))
+# define stdc_bit_width_ull(x) \
+  (__builtin_stdc_bit_width ((unsigned long long int) (x)))
+#else
+# define stdc_bit_width(x) (stdc_bit_width_ull (x))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
 static __always_inline unsigned int
 __bw64_inline (uint64_t __x)
 {
@@ -668,15 +835,16 @@  __bw8_inline (uint8_t __x)
   return 8 - __clz8_inline (__x);
 }
 
-# define stdc_bit_width_uc(x) (__bw8_inline (x))
-# define stdc_bit_width_us(x) (__bw16_inline (x))
-# define stdc_bit_width_ui(x) (__bw32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_bit_width_ul(x) (__bw64_inline (x))
-# else
-#  define stdc_bit_width_ul(x) (__bw32_inline (x))
+#  define stdc_bit_width_uc(x) (__bw8_inline (x))
+#  define stdc_bit_width_us(x) (__bw16_inline (x))
+#  define stdc_bit_width_ui(x) (__bw32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_bit_width_ul(x) (__bw64_inline (x))
+#  else
+#   define stdc_bit_width_ul(x) (__bw32_inline (x))
+#  endif
+#  define stdc_bit_width_ull(x) (__bw64_inline (x))
 # endif
-# define stdc_bit_width_ull(x) (__bw64_inline (x))
 #endif
 
 /* Bit floor.  */
@@ -691,9 +859,22 @@  extern unsigned long int stdc_bit_floor_ul (unsigned long int __x)
 __extension__
 extern unsigned long long int stdc_bit_floor_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_bit_floor(x) ((__typeof (x)) stdc_bit_floor_ull (x))
+#if __glibc_has_builtin (__builtin_stdc_bit_floor)
+# define stdc_bit_floor(x) (__builtin_stdc_bit_floor (x))
+# define stdc_bit_floor_uc(x) \
+  (__builtin_stdc_bit_floor ((unsigned char) (x)))
+# define stdc_bit_floor_us(x) \
+  (__builtin_stdc_bit_floor ((unsigned short) (x)))
+# define stdc_bit_floor_ui(x) \
+  (__builtin_stdc_bit_floor ((unsigned int) (x)))
+# define stdc_bit_floor_ul(x) \
+  (__builtin_stdc_bit_floor ((unsigned long int) (x)))
+# define stdc_bit_floor_ull(x) \
+  (__builtin_stdc_bit_floor ((unsigned long long int) (x)))
+#else
+# define stdc_bit_floor(x) ((__typeof (x)) stdc_bit_floor_ull (x))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
 static __always_inline uint64_t
 __bf64_inline (uint64_t __x)
 {
@@ -720,15 +901,16 @@  __bf8_inline (uint8_t __x)
 			 ? 0 : ((uint8_t) 1) << (__bw8_inline (__x) - 1));
 }
 
-# define stdc_bit_floor_uc(x) ((unsigned char) __bf8_inline (x))
-# define stdc_bit_floor_us(x) ((unsigned short) __bf16_inline (x))
-# define stdc_bit_floor_ui(x) ((unsigned int) __bf32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_bit_floor_ul(x) ((unsigned long int) __bf64_inline (x))
-# else
-#  define stdc_bit_floor_ul(x) ((unsigned long int) __bf32_inline (x))
+#  define stdc_bit_floor_uc(x) ((unsigned char) __bf8_inline (x))
+#  define stdc_bit_floor_us(x) ((unsigned short) __bf16_inline (x))
+#  define stdc_bit_floor_ui(x) ((unsigned int) __bf32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_bit_floor_ul(x) ((unsigned long int) __bf64_inline (x))
+#  else
+#   define stdc_bit_floor_ul(x) ((unsigned long int) __bf32_inline (x))
+#  endif
+#  define stdc_bit_floor_ull(x) ((unsigned long long int) __bf64_inline (x))
 # endif
-# define stdc_bit_floor_ull(x) ((unsigned long long int) __bf64_inline (x))
 #endif
 
 /* Bit ceiling.  */
@@ -743,9 +925,22 @@  extern unsigned long int stdc_bit_ceil_ul (unsigned long int __x)
 __extension__
 extern unsigned long long int stdc_bit_ceil_ull (unsigned long long int __x)
      __THROW __attribute_const__;
-#define stdc_bit_ceil(x) ((__typeof (x)) stdc_bit_ceil_ull (x))
+#if __glibc_has_builtin (__builtin_stdc_bit_ceil)
+# define stdc_bit_ceil(x) (__builtin_stdc_bit_ceil (x))
+# define stdc_bit_ceil_uc(x) \
+  (__builtin_stdc_bit_ceil ((unsigned char) (x)))
+# define stdc_bit_ceil_us(x) \
+  (__builtin_stdc_bit_ceil ((unsigned short) (x)))
+# define stdc_bit_ceil_ui(x) \
+  (__builtin_stdc_bit_ceil ((unsigned int) (x)))
+# define stdc_bit_ceil_ul(x) \
+  (__builtin_stdc_bit_ceil ((unsigned long int) (x)))
+# define stdc_bit_ceil_ull(x) \
+  (__builtin_stdc_bit_ceil ((unsigned long long int) (x)))
+#else
+# define stdc_bit_ceil(x) ((__typeof (x)) stdc_bit_ceil_ull (x))
 
-#if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
+# if __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
 static __always_inline uint64_t
 __bc64_inline (uint64_t __x)
 {
@@ -776,15 +971,16 @@  __bc8_inline (uint8_t __x)
 			   << (__bw8_inline ((uint8_t) (__x - 1)) - 1));
 }
 
-# define stdc_bit_ceil_uc(x) ((unsigned char) __bc8_inline (x))
-# define stdc_bit_ceil_us(x) ((unsigned short) __bc16_inline (x))
-# define stdc_bit_ceil_ui(x) ((unsigned int) __bc32_inline (x))
-# if __WORDSIZE == 64
-#  define stdc_bit_ceil_ul(x) ((unsigned long int) __bc64_inline (x))
-# else
-#  define stdc_bit_ceil_ul(x) ((unsigned long int) __bc32_inline (x))
+#  define stdc_bit_ceil_uc(x) ((unsigned char) __bc8_inline (x))
+#  define stdc_bit_ceil_us(x) ((unsigned short) __bc16_inline (x))
+#  define stdc_bit_ceil_ui(x) ((unsigned int) __bc32_inline (x))
+#  if __WORDSIZE == 64
+#   define stdc_bit_ceil_ul(x) ((unsigned long int) __bc64_inline (x))
+#  else
+#   define stdc_bit_ceil_ul(x) ((unsigned long int) __bc32_inline (x))
+#  endif
+#  define stdc_bit_ceil_ull(x) ((unsigned long long int) __bc64_inline (x))
 # endif
-# define stdc_bit_ceil_ull(x) ((unsigned long long int) __bc64_inline (x))
 #endif
 
 __END_DECLS
diff --git a/stdlib/tst-stdbit-builtins.c b/stdlib/tst-stdbit-builtins.c
new file mode 100644
index 0000000000..9540e963ee
--- /dev/null
+++ b/stdlib/tst-stdbit-builtins.c
@@ -0,0 +1,918 @@ 
+/* Test <stdbit.h> type-generic macros with compiler __builtin_stdc_* support.
+   Copyright (C) 2024 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include <stdbit.h>
+#include <limits.h>
+#include <support/check.h>
+
+#if __glibc_has_builtin (__builtin_stdc_leading_zeros) \
+    && __glibc_has_builtin (__builtin_stdc_leading_ones) \
+    && __glibc_has_builtin (__builtin_stdc_trailing_zeros) \
+    && __glibc_has_builtin (__builtin_stdc_trailing_ones) \
+    && __glibc_has_builtin (__builtin_stdc_first_leading_zero) \
+    && __glibc_has_builtin (__builtin_stdc_first_leading_one) \
+    && __glibc_has_builtin (__builtin_stdc_first_trailing_zero) \
+    && __glibc_has_builtin (__builtin_stdc_first_trailing_one) \
+    && __glibc_has_builtin (__builtin_stdc_count_zeros) \
+    && __glibc_has_builtin (__builtin_stdc_count_ones) \
+    && __glibc_has_builtin (__builtin_stdc_has_single_bit) \
+    && __glibc_has_builtin (__builtin_stdc_bit_width) \
+    && __glibc_has_builtin (__builtin_stdc_bit_floor) \
+    && __glibc_has_builtin (__builtin_stdc_bit_ceil)
+
+# if !defined (BITINT_MAXWIDTH) && defined (__BITINT_MAXWIDTH__)
+#  define BITINT_MAXWIDTH __BITINT_MAXWIDTH__
+# endif
+
+typedef unsigned char uc;
+typedef unsigned short us;
+typedef unsigned int ui;
+typedef unsigned long int ul;
+typedef unsigned long long int ull;
+
+ui
+leading_zeros (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_leading_zeros (a)
+	  + stdc_leading_zeros (b)
+	  + stdc_leading_zeros (c)
+	  + stdc_leading_zeros (d)
+	  + stdc_leading_zeros (e));
+}
+
+ui
+leading_ones (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_leading_ones (a)
+	  + stdc_leading_ones (b)
+	  + stdc_leading_ones (c)
+	  + stdc_leading_ones (d)
+	  + stdc_leading_ones (e));
+}
+
+ui
+trailing_zeros (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_trailing_zeros (a)
+	  + stdc_trailing_zeros (b)
+	  + stdc_trailing_zeros (c)
+	  + stdc_trailing_zeros (d)
+	  + stdc_trailing_zeros (e));
+}
+
+ui
+trailing_ones (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_trailing_ones (a)
+	  + stdc_trailing_ones (b)
+	  + stdc_trailing_ones (c)
+	  + stdc_trailing_ones (d)
+	  + stdc_trailing_ones (e));
+}
+
+ui
+first_leading_zero (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_first_leading_zero (a)
+	  + stdc_first_leading_zero (b)
+	  + stdc_first_leading_zero (c)
+	  + stdc_first_leading_zero (d)
+	  + stdc_first_leading_zero (e));
+}
+
+ui
+first_leading_one (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_first_leading_one (a)
+	  + stdc_first_leading_one (b)
+	  + stdc_first_leading_one (c)
+	  + stdc_first_leading_one (d)
+	  + stdc_first_leading_one (e));
+}
+
+ui
+first_trailing_zero (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_first_trailing_zero (a)
+	  + stdc_first_trailing_zero (b)
+	  + stdc_first_trailing_zero (c)
+	  + stdc_first_trailing_zero (d)
+	  + stdc_first_trailing_zero (e));
+}
+
+ui
+first_trailing_one (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_first_trailing_one (a)
+	  + stdc_first_trailing_one (b)
+	  + stdc_first_trailing_one (c)
+	  + stdc_first_trailing_one (d)
+	  + stdc_first_trailing_one (e));
+}
+
+ui
+count_zeros (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_count_zeros (a)
+	  + stdc_count_zeros (b)
+	  + stdc_count_zeros (c)
+	  + stdc_count_zeros (d)
+	  + stdc_count_zeros (e));
+}
+
+ui
+count_ones (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_count_ones (a)
+	  + stdc_count_ones (b)
+	  + stdc_count_ones (c)
+	  + stdc_count_ones (d)
+	  + stdc_count_ones (e));
+}
+
+ui
+has_single_bit (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_has_single_bit (a)
+	  || stdc_has_single_bit (b)
+	  || stdc_has_single_bit (c)
+	  || stdc_has_single_bit (d)
+	  || stdc_has_single_bit (e));
+}
+
+ui
+bit_width (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_bit_width (a)
+	  + stdc_bit_width (b)
+	  + stdc_bit_width (c)
+	  + stdc_bit_width (d)
+	  + stdc_bit_width (e));
+}
+
+ull
+bit_floor (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_bit_floor (a)
+	  + stdc_bit_floor (b)
+	  + stdc_bit_floor (c)
+	  + stdc_bit_floor (d)
+	  + stdc_bit_floor (e));
+}
+
+ull
+bit_ceil (uc a, us b, ui c, ul d, ull e)
+{
+  return (stdc_bit_ceil (a)
+	  + stdc_bit_ceil (b)
+	  + stdc_bit_ceil (c)
+	  + stdc_bit_ceil (d)
+	  + stdc_bit_ceil (e));
+}
+
+# define expr_has_type(e, t) _Generic (e, default : 0, t : 1)
+
+static int
+do_test (void)
+{
+  TEST_COMPARE (stdc_leading_zeros ((uc) 0), CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_leading_zeros ((uc) 0), ui), 1);
+  TEST_COMPARE (stdc_leading_zeros ((us) 0), sizeof (short) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_leading_zeros ((us) 0), ui), 1);
+  TEST_COMPARE (stdc_leading_zeros (0U), sizeof (int) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_leading_zeros (0U), ui), 1);
+  TEST_COMPARE (stdc_leading_zeros (0UL), sizeof (long int) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_leading_zeros (0UL), ui), 1);
+  TEST_COMPARE (stdc_leading_zeros (0ULL), sizeof (long long int) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_leading_zeros (0ULL), ui), 1);
+  TEST_COMPARE (stdc_leading_zeros ((uc) ~0U), 0);
+  TEST_COMPARE (stdc_leading_zeros ((us) ~0U), 0);
+  TEST_COMPARE (stdc_leading_zeros (~0U), 0);
+  TEST_COMPARE (stdc_leading_zeros (~0UL), 0);
+  TEST_COMPARE (stdc_leading_zeros (~0ULL), 0);
+  TEST_COMPARE (stdc_leading_zeros ((uc) 3), CHAR_BIT - 2);
+  TEST_COMPARE (stdc_leading_zeros ((us) 9), sizeof (short) * CHAR_BIT - 4);
+  TEST_COMPARE (stdc_leading_zeros (34U), sizeof (int) * CHAR_BIT - 6);
+  TEST_COMPARE (stdc_leading_zeros (130UL), sizeof (long int) * CHAR_BIT - 8);
+  TEST_COMPARE (stdc_leading_zeros (512ULL),
+		sizeof (long long int) * CHAR_BIT - 10);
+  TEST_COMPARE (stdc_leading_ones ((uc) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_leading_ones ((uc) 0), ui), 1);
+  TEST_COMPARE (stdc_leading_ones ((us) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_leading_ones ((us) 0), ui), 1);
+  TEST_COMPARE (stdc_leading_ones (0U), 0);
+  TEST_COMPARE (expr_has_type (stdc_leading_ones (0U), ui), 1);
+  TEST_COMPARE (stdc_leading_ones (0UL), 0);
+  TEST_COMPARE (expr_has_type (stdc_leading_ones (0UL), ui), 1);
+  TEST_COMPARE (stdc_leading_ones (0ULL), 0);
+  TEST_COMPARE (expr_has_type (stdc_leading_ones (0ULL), ui), 1);
+  TEST_COMPARE (stdc_leading_ones ((uc) ~0U), CHAR_BIT);
+  TEST_COMPARE (stdc_leading_ones ((us) ~0U), sizeof (short) * CHAR_BIT);
+  TEST_COMPARE (stdc_leading_ones (~0U), sizeof (int) * CHAR_BIT);
+  TEST_COMPARE (stdc_leading_ones (~0UL), sizeof (long int) * CHAR_BIT);
+  TEST_COMPARE (stdc_leading_ones (~0ULL), sizeof (long long int) * CHAR_BIT);
+  TEST_COMPARE (stdc_leading_ones ((uc) ~3), CHAR_BIT - 2);
+  TEST_COMPARE (stdc_leading_ones ((us) ~9), sizeof (short) * CHAR_BIT - 4);
+  TEST_COMPARE (stdc_leading_ones (~34U), sizeof (int) * CHAR_BIT - 6);
+  TEST_COMPARE (stdc_leading_ones (~130UL), sizeof (long int) * CHAR_BIT - 8);
+  TEST_COMPARE (stdc_leading_ones (~512ULL),
+		sizeof (long long int) * CHAR_BIT - 10);
+  TEST_COMPARE (stdc_trailing_zeros ((uc) 0), CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_trailing_zeros ((uc) 0), ui), 1);
+  TEST_COMPARE (stdc_trailing_zeros ((us) 0), sizeof (short) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_trailing_zeros ((us) 0), ui), 1);
+  TEST_COMPARE (stdc_trailing_zeros (0U), sizeof (int) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_trailing_zeros (0U), ui), 1);
+  TEST_COMPARE (stdc_trailing_zeros (0UL), sizeof (long int) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_trailing_zeros (0UL), ui), 1);
+  TEST_COMPARE (stdc_trailing_zeros (0ULL), sizeof (long long int) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_trailing_zeros (0ULL), ui), 1);
+  TEST_COMPARE (stdc_trailing_zeros ((uc) ~0U), 0);
+  TEST_COMPARE (stdc_trailing_zeros ((us) ~0U), 0);
+  TEST_COMPARE (stdc_trailing_zeros (~0U), 0);
+  TEST_COMPARE (stdc_trailing_zeros (~0UL), 0);
+  TEST_COMPARE (stdc_trailing_zeros (~0ULL), 0);
+  TEST_COMPARE (stdc_trailing_zeros ((uc) 2), 1);
+  TEST_COMPARE (stdc_trailing_zeros ((us) 24), 3);
+  TEST_COMPARE (stdc_trailing_zeros (32U), 5);
+  TEST_COMPARE (stdc_trailing_zeros (128UL), 7);
+  TEST_COMPARE (stdc_trailing_zeros (512ULL), 9);
+  TEST_COMPARE (stdc_trailing_ones ((uc) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_trailing_ones ((uc) 0), ui), 1);
+  TEST_COMPARE (stdc_trailing_ones ((us) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_trailing_ones ((us) 0), ui), 1);
+  TEST_COMPARE (stdc_trailing_ones (0U), 0);
+  TEST_COMPARE (expr_has_type (stdc_trailing_ones (0U), ui), 1);
+  TEST_COMPARE (stdc_trailing_ones (0UL), 0);
+  TEST_COMPARE (expr_has_type (stdc_trailing_ones (0UL), ui), 1);
+  TEST_COMPARE (stdc_trailing_ones (0ULL), 0);
+  TEST_COMPARE (expr_has_type (stdc_trailing_ones (0ULL), ui), 1);
+  TEST_COMPARE (stdc_trailing_ones ((uc) ~0U), CHAR_BIT);
+  TEST_COMPARE (stdc_trailing_ones ((us) ~0U), sizeof (short) * CHAR_BIT);
+  TEST_COMPARE (stdc_trailing_ones (~0U), sizeof (int) * CHAR_BIT);
+  TEST_COMPARE (stdc_trailing_ones (~0UL), sizeof (long int) * CHAR_BIT);
+  TEST_COMPARE (stdc_trailing_ones (~0ULL), sizeof (long long int) * CHAR_BIT);
+  TEST_COMPARE (stdc_trailing_ones ((uc) 5), 1);
+  TEST_COMPARE (stdc_trailing_ones ((us) 15), 4);
+  TEST_COMPARE (stdc_trailing_ones (127U), 7);
+  TEST_COMPARE (stdc_trailing_ones (511UL), 9);
+  TEST_COMPARE (stdc_trailing_ones (~0ULL >> 2),
+		sizeof (long long int) * CHAR_BIT - 2);
+  TEST_COMPARE (stdc_first_leading_zero ((uc) 0), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_zero ((uc) 0), ui), 1);
+  TEST_COMPARE (stdc_first_leading_zero ((us) 0), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_zero ((us) 0), ui), 1);
+  TEST_COMPARE (stdc_first_leading_zero (0U), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_zero (0U), ui), 1);
+  TEST_COMPARE (stdc_first_leading_zero (0UL), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_zero (0UL), ui), 1);
+  TEST_COMPARE (stdc_first_leading_zero (0ULL), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_zero (0ULL), ui), 1);
+  TEST_COMPARE (stdc_first_leading_zero ((uc) ~0U), 0);
+  TEST_COMPARE (stdc_first_leading_zero ((us) ~0U), 0);
+  TEST_COMPARE (stdc_first_leading_zero (~0U), 0);
+  TEST_COMPARE (stdc_first_leading_zero (~0UL), 0);
+  TEST_COMPARE (stdc_first_leading_zero (~0ULL), 0);
+  TEST_COMPARE (stdc_first_leading_zero ((uc) ~3U), CHAR_BIT - 1);
+  TEST_COMPARE (stdc_first_leading_zero ((us) ~15U),
+		sizeof (short) * CHAR_BIT - 3);
+  TEST_COMPARE (stdc_first_leading_zero (~63U), sizeof (int) * CHAR_BIT - 5);
+  TEST_COMPARE (stdc_first_leading_zero (~255UL),
+		sizeof (long int) * CHAR_BIT - 7);
+  TEST_COMPARE (stdc_first_leading_zero (~1023ULL),
+		sizeof (long long int) * CHAR_BIT - 9);
+  TEST_COMPARE (stdc_first_leading_one ((uc) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_one ((uc) 0), ui), 1);
+  TEST_COMPARE (stdc_first_leading_one ((us) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_one ((us) 0), ui), 1);
+  TEST_COMPARE (stdc_first_leading_one (0U), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_one (0U), ui), 1);
+  TEST_COMPARE (stdc_first_leading_one (0UL), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_one (0UL), ui), 1);
+  TEST_COMPARE (stdc_first_leading_one (0ULL), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_one (0ULL), ui), 1);
+  TEST_COMPARE (stdc_first_leading_one ((uc) ~0U), 1);
+  TEST_COMPARE (stdc_first_leading_one ((us) ~0U), 1);
+  TEST_COMPARE (stdc_first_leading_one (~0U), 1);
+  TEST_COMPARE (stdc_first_leading_one (~0UL), 1);
+  TEST_COMPARE (stdc_first_leading_one (~0ULL), 1);
+  TEST_COMPARE (stdc_first_leading_one ((uc) 3), CHAR_BIT - 1);
+  TEST_COMPARE (stdc_first_leading_one ((us) 9),
+		sizeof (short) * CHAR_BIT - 3);
+  TEST_COMPARE (stdc_first_leading_one (34U), sizeof (int) * CHAR_BIT - 5);
+  TEST_COMPARE (stdc_first_leading_one (130UL),
+		sizeof (long int) * CHAR_BIT - 7);
+  TEST_COMPARE (stdc_first_leading_one (512ULL),
+		sizeof (long long int) * CHAR_BIT - 9);
+  TEST_COMPARE (stdc_first_trailing_zero ((uc) 0), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_zero ((uc) 0), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_zero ((us) 0), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_zero ((us) 0), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_zero (0U), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_zero (0U), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_zero (0UL), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_zero (0UL), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_zero (0ULL), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_zero (0ULL), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_zero ((uc) ~0U), 0);
+  TEST_COMPARE (stdc_first_trailing_zero ((us) ~0U), 0);
+  TEST_COMPARE (stdc_first_trailing_zero (~0U), 0);
+  TEST_COMPARE (stdc_first_trailing_zero (~0UL), 0);
+  TEST_COMPARE (stdc_first_trailing_zero (~0ULL), 0);
+  TEST_COMPARE (stdc_first_trailing_zero ((uc) 2), 1);
+  TEST_COMPARE (stdc_first_trailing_zero ((us) 15), 5);
+  TEST_COMPARE (stdc_first_trailing_zero (63U), 7);
+  TEST_COMPARE (stdc_first_trailing_zero (128UL), 1);
+  TEST_COMPARE (stdc_first_trailing_zero (511ULL), 10);
+  TEST_COMPARE (stdc_first_trailing_one ((uc) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_one ((uc) 0), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_one ((us) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_one ((us) 0), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_one (0U), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_one (0U), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_one (0UL), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_one (0UL), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_one (0ULL), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_one (0ULL), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_one ((uc) ~0U), 1);
+  TEST_COMPARE (stdc_first_trailing_one ((us) ~0U), 1);
+  TEST_COMPARE (stdc_first_trailing_one (~0U), 1);
+  TEST_COMPARE (stdc_first_trailing_one (~0UL), 1);
+  TEST_COMPARE (stdc_first_trailing_one (~0ULL), 1);
+  TEST_COMPARE (stdc_first_trailing_one ((uc) 4), 3);
+  TEST_COMPARE (stdc_first_trailing_one ((us) 96), 6);
+  TEST_COMPARE (stdc_first_trailing_one (127U), 1);
+  TEST_COMPARE (stdc_first_trailing_one (511UL), 1);
+  TEST_COMPARE (stdc_first_trailing_one (~0ULL << 12), 13);
+  TEST_COMPARE (stdc_count_zeros ((uc) 0), CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_count_zeros ((uc) 0), ui), 1);
+  TEST_COMPARE (stdc_count_zeros ((us) 0), sizeof (short) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_count_zeros ((us) 0), ui), 1);
+  TEST_COMPARE (stdc_count_zeros (0U), sizeof (int) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_count_zeros (0U), ui), 1);
+  TEST_COMPARE (stdc_count_zeros (0UL), sizeof (long int) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_count_zeros (0UL), ui), 1);
+  TEST_COMPARE (stdc_count_zeros (0ULL), sizeof (long long int) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_count_zeros (0ULL), ui), 1);
+  TEST_COMPARE (stdc_count_zeros ((uc) ~0U), 0);
+  TEST_COMPARE (stdc_count_zeros ((us) ~0U), 0);
+  TEST_COMPARE (stdc_count_zeros (~0U), 0);
+  TEST_COMPARE (stdc_count_zeros (~0UL), 0);
+  TEST_COMPARE (stdc_count_zeros (~0ULL), 0);
+  TEST_COMPARE (stdc_count_zeros ((uc) 1U), CHAR_BIT - 1);
+  TEST_COMPARE (stdc_count_zeros ((us) 42), sizeof (short) * CHAR_BIT - 3);
+  TEST_COMPARE (stdc_count_zeros (291U), sizeof (int) * CHAR_BIT - 4);
+  TEST_COMPARE (stdc_count_zeros (~1315UL), 5);
+  TEST_COMPARE (stdc_count_zeros (3363ULL),
+		sizeof (long long int) * CHAR_BIT - 6);
+  TEST_COMPARE (stdc_count_ones ((uc) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_count_ones ((uc) 0), ui), 1);
+  TEST_COMPARE (stdc_count_ones ((us) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_count_ones ((us) 0), ui), 1);
+  TEST_COMPARE (stdc_count_ones (0U), 0);
+  TEST_COMPARE (expr_has_type (stdc_count_ones (0U), ui), 1);
+  TEST_COMPARE (stdc_count_ones (0UL), 0);
+  TEST_COMPARE (expr_has_type (stdc_count_ones (0UL), ui), 1);
+  TEST_COMPARE (stdc_count_ones (0ULL), 0);
+  TEST_COMPARE (expr_has_type (stdc_count_ones (0ULL), ui), 1);
+  TEST_COMPARE (stdc_count_ones ((uc) ~0U), CHAR_BIT);
+  TEST_COMPARE (stdc_count_ones ((us) ~0U), sizeof (short) * CHAR_BIT);
+  TEST_COMPARE (stdc_count_ones (~0U), sizeof (int) * CHAR_BIT);
+  TEST_COMPARE (stdc_count_ones (~0UL), sizeof (long int) * CHAR_BIT);
+  TEST_COMPARE (stdc_count_ones (~0ULL), sizeof (long long int) * CHAR_BIT);
+  TEST_COMPARE (stdc_count_ones ((uc) ~1U), CHAR_BIT - 1);
+  TEST_COMPARE (stdc_count_ones ((us) ~42), sizeof (short) * CHAR_BIT - 3);
+  TEST_COMPARE (stdc_count_ones (~291U), sizeof (int) * CHAR_BIT - 4);
+  TEST_COMPARE (stdc_count_ones (1315UL), 5);
+  TEST_COMPARE (stdc_count_ones (~3363ULL),
+		sizeof (long long int) * CHAR_BIT - 6);
+  TEST_COMPARE (stdc_has_single_bit ((uc) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_has_single_bit ((uc) 0), _Bool), 1);
+  TEST_COMPARE (stdc_has_single_bit ((us) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_has_single_bit ((us) 0), _Bool), 1);
+  TEST_COMPARE (stdc_has_single_bit (0U), 0);
+  TEST_COMPARE (expr_has_type (stdc_has_single_bit (0U), _Bool), 1);
+  TEST_COMPARE (stdc_has_single_bit (0UL), 0);
+  TEST_COMPARE (expr_has_type (stdc_has_single_bit (0UL), _Bool), 1);
+  TEST_COMPARE (stdc_has_single_bit (0ULL), 0);
+  TEST_COMPARE (expr_has_type (stdc_has_single_bit (0ULL), _Bool), 1);
+  TEST_COMPARE (stdc_has_single_bit ((uc) 2), 1);
+  TEST_COMPARE (stdc_has_single_bit ((us) 8), 1);
+  TEST_COMPARE (stdc_has_single_bit (32U), 1);
+  TEST_COMPARE (stdc_has_single_bit (128UL), 1);
+  TEST_COMPARE (stdc_has_single_bit (512ULL), 1);
+  TEST_COMPARE (stdc_has_single_bit ((uc) 7), 0);
+  TEST_COMPARE (stdc_has_single_bit ((us) 96), 0);
+  TEST_COMPARE (stdc_has_single_bit (513U), 0);
+  TEST_COMPARE (stdc_has_single_bit (1022UL), 0);
+  TEST_COMPARE (stdc_has_single_bit (12ULL), 0);
+  TEST_COMPARE (stdc_bit_width ((uc) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_width ((uc) 0), ui), 1);
+  TEST_COMPARE (stdc_bit_width ((us) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_width ((us) 0), ui), 1);
+  TEST_COMPARE (stdc_bit_width (0U), 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_width (0U), ui), 1);
+  TEST_COMPARE (stdc_bit_width (0UL), 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_width (0UL), ui), 1);
+  TEST_COMPARE (stdc_bit_width (0ULL), 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_width (0ULL), ui), 1);
+  TEST_COMPARE (stdc_bit_width ((uc) ~0U), CHAR_BIT);
+  TEST_COMPARE (stdc_bit_width ((us) ~0U), sizeof (short) * CHAR_BIT);
+  TEST_COMPARE (stdc_bit_width (~0U), sizeof (int) * CHAR_BIT);
+  TEST_COMPARE (stdc_bit_width (~0UL), sizeof (long int) * CHAR_BIT);
+  TEST_COMPARE (stdc_bit_width (~0ULL), sizeof (long long int) * CHAR_BIT);
+  TEST_COMPARE (stdc_bit_width ((uc) ((uc) ~0U >> 1)), CHAR_BIT - 1);
+  TEST_COMPARE (stdc_bit_width ((uc) 6), 3);
+  TEST_COMPARE (stdc_bit_width ((us) 12U), 4);
+  TEST_COMPARE (stdc_bit_width ((us) ((us) ~0U >> 5)),
+		sizeof (short) * CHAR_BIT - 5);
+  TEST_COMPARE (stdc_bit_width (137U), 8);
+  TEST_COMPARE (stdc_bit_width (269U), 9);
+  TEST_COMPARE (stdc_bit_width (39UL), 6);
+  TEST_COMPARE (stdc_bit_width (~0UL >> 2), sizeof (long int) * CHAR_BIT - 2);
+  TEST_COMPARE (stdc_bit_width (1023ULL), 10);
+  TEST_COMPARE (stdc_bit_width (1024ULL), 11);
+  TEST_COMPARE (stdc_bit_floor ((uc) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_floor ((uc) 0), uc), 1);
+  TEST_COMPARE (stdc_bit_floor ((us) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_floor ((us) 0), us), 1);
+  TEST_COMPARE (stdc_bit_floor (0U), 0U);
+  TEST_COMPARE (expr_has_type (stdc_bit_floor (0U), ui), 1);
+  TEST_COMPARE (stdc_bit_floor (0UL), 0UL);
+  TEST_COMPARE (expr_has_type (stdc_bit_floor (0UL), ul), 1);
+  TEST_COMPARE (stdc_bit_floor (0ULL), 0ULL);
+  TEST_COMPARE (expr_has_type (stdc_bit_floor (0ULL), ull), 1);
+  TEST_COMPARE (stdc_bit_floor ((uc) ~0U), (1U << (CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_floor ((us) ~0U),
+		(1U << (sizeof (short) * CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_floor (~0U), (1U << (sizeof (int) * CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_floor (~0UL),
+		(1UL << (sizeof (long int) * CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_floor (~0ULL),
+		(1ULL << (sizeof (long long int) * CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_floor ((uc) 4), 4);
+  TEST_COMPARE (stdc_bit_floor ((uc) 7), 4);
+  TEST_COMPARE (stdc_bit_floor ((us) 8U), 8);
+  TEST_COMPARE (stdc_bit_floor ((us) 31U), 16);
+  TEST_COMPARE (stdc_bit_floor (137U), 128U);
+  TEST_COMPARE (stdc_bit_floor (269U), 256U);
+  TEST_COMPARE (stdc_bit_floor (511UL), 256UL);
+  TEST_COMPARE (stdc_bit_floor (512UL), 512UL);
+  TEST_COMPARE (stdc_bit_floor (513UL), 512ULL);
+  TEST_COMPARE (stdc_bit_floor (1024ULL), 1024ULL);
+  TEST_COMPARE (stdc_bit_ceil ((uc) 0), 1);
+  TEST_COMPARE (expr_has_type (stdc_bit_ceil ((uc) 0), uc), 1);
+  TEST_COMPARE (stdc_bit_ceil ((us) 0), 1);
+  TEST_COMPARE (expr_has_type (stdc_bit_ceil ((us) 0), us), 1);
+  TEST_COMPARE (stdc_bit_ceil (0U), 1U);
+  TEST_COMPARE (expr_has_type (stdc_bit_ceil (0U), ui), 1);
+  TEST_COMPARE (stdc_bit_ceil (0UL), 1UL);
+  TEST_COMPARE (expr_has_type (stdc_bit_ceil (0UL), ul), 1);
+  TEST_COMPARE (stdc_bit_ceil (0ULL), 1ULL);
+  TEST_COMPARE (expr_has_type (stdc_bit_ceil (0ULL), ull), 1);
+  TEST_COMPARE (stdc_bit_ceil ((uc) ~0U), 0);
+  TEST_COMPARE (stdc_bit_ceil ((us) ~0U), 0);
+  TEST_COMPARE (stdc_bit_ceil (~0U), 0U);
+  TEST_COMPARE (stdc_bit_ceil (~0UL), 0UL);
+  TEST_COMPARE (stdc_bit_ceil (~0ULL), 0ULL);
+  TEST_COMPARE (stdc_bit_ceil ((uc) ((uc) ~0U >> 1)), (1U << (CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_ceil ((uc) ((uc) ~0U >> 1)), (1U << (CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_ceil ((us) ((us) ~0U >> 1)),
+		(1U << (sizeof (short) * CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_ceil ((us) ((us) ~0U >> 1)),
+		(1U << (sizeof (short) * CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_ceil (~0U >> 1),
+		(1U << (sizeof (int) * CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_ceil (1U << (sizeof (int) * CHAR_BIT - 1)),
+		(1U << (sizeof (int) * CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_ceil (~0UL >> 1),
+		(1UL << (sizeof (long int) * CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_ceil (~0UL >> 1),
+		(1UL << (sizeof (long int) * CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_ceil (1ULL
+			       << (sizeof (long long int) * CHAR_BIT - 1)),
+		(1ULL << (sizeof (long long int) * CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_ceil (~0ULL >> 1),
+		(1ULL << (sizeof (long long int) * CHAR_BIT - 1)));
+  TEST_COMPARE (stdc_bit_ceil ((uc) 1), 1);
+  TEST_COMPARE (stdc_bit_ceil ((uc) 2), 2);
+  TEST_COMPARE (stdc_bit_ceil ((us) 3U), 4);
+  TEST_COMPARE (stdc_bit_ceil ((us) 4U), 4);
+  TEST_COMPARE (stdc_bit_ceil (5U), 8U);
+  TEST_COMPARE (stdc_bit_ceil (269U), 512U);
+  TEST_COMPARE (stdc_bit_ceil (511UL), 512UL);
+  TEST_COMPARE (stdc_bit_ceil (512UL), 512UL);
+  TEST_COMPARE (stdc_bit_ceil (513ULL), 1024ULL);
+  TEST_COMPARE (stdc_bit_ceil (1025ULL), 2048ULL);
+# ifdef __SIZEOF_INT128__
+  TEST_COMPARE (stdc_leading_zeros ((unsigned __int128) 0),
+		sizeof (__int128) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_leading_zeros ((unsigned __int128) 0), ui),
+		1);
+  TEST_COMPARE (stdc_leading_zeros (~(unsigned __int128) 0), 0);
+  TEST_COMPARE (stdc_leading_ones ((unsigned __int128) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_leading_ones ((unsigned __int128) 0), ui),
+		1);
+  TEST_COMPARE (stdc_leading_ones (~(unsigned __int128) 0),
+		sizeof (__int128) * CHAR_BIT);
+  TEST_COMPARE (stdc_trailing_zeros ((unsigned __int128) 0),
+		sizeof (__int128) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_trailing_zeros ((unsigned __int128) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_trailing_zeros (~(unsigned __int128) 0), 0);
+  TEST_COMPARE (stdc_trailing_ones ((unsigned __int128) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_trailing_ones ((unsigned __int128) 0), ui),
+		1);
+  TEST_COMPARE (stdc_trailing_ones (~(unsigned __int128) 0),
+		sizeof (__int128) * CHAR_BIT);
+  TEST_COMPARE (stdc_first_leading_zero ((unsigned __int128) 0), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_zero ((unsigned __int128) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_first_leading_zero (~(unsigned __int128) 0), 0);
+  TEST_COMPARE (stdc_first_leading_one ((unsigned __int128) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_one ((unsigned __int128) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_first_leading_one (~(unsigned __int128) 0), 1);
+  TEST_COMPARE (stdc_first_trailing_zero ((unsigned __int128) 0), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_zero ((unsigned __int128)
+							 0), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_zero (~(unsigned __int128) 0), 0);
+  TEST_COMPARE (stdc_first_trailing_one ((unsigned __int128) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_one ((unsigned __int128) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_first_trailing_one (~(unsigned __int128) 0), 1);
+  TEST_COMPARE (stdc_count_zeros ((unsigned __int128) 0),
+		sizeof (__int128) * CHAR_BIT);
+  TEST_COMPARE (expr_has_type (stdc_count_zeros ((unsigned __int128) 0), ui),
+		1);
+  TEST_COMPARE (stdc_count_zeros (~(unsigned __int128) 0), 0);
+  TEST_COMPARE (stdc_count_ones ((unsigned __int128) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_count_ones ((unsigned __int128) 0), ui),
+		1);
+  TEST_COMPARE (stdc_count_ones (~(unsigned __int128) 0),
+		sizeof (__int128) * CHAR_BIT);
+  TEST_COMPARE (stdc_has_single_bit ((unsigned __int128) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_has_single_bit ((unsigned __int128) 0),
+		_Bool), 1);
+  TEST_COMPARE (stdc_has_single_bit (~(unsigned __int128) 0), 0);
+  TEST_COMPARE (stdc_bit_width ((unsigned __int128) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_width ((unsigned __int128) 0), ui), 1);
+  TEST_COMPARE (stdc_bit_width (~(unsigned __int128) 0),
+		sizeof (__int128) * CHAR_BIT);
+  TEST_COMPARE (stdc_bit_floor ((unsigned __int128) 0) != 0, 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_floor ((unsigned __int128) 0),
+			       unsigned __int128), 1);
+  TEST_COMPARE (stdc_bit_floor (~(unsigned __int128) 0)
+		!= ((unsigned __int128) 1) << (sizeof (__int128)
+					       * CHAR_BIT - 1), 0);
+  TEST_COMPARE (stdc_bit_ceil ((unsigned __int128) 0) != 1, 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_ceil ((unsigned __int128) 0),
+			       unsigned __int128), 1);
+  TEST_COMPARE (stdc_bit_ceil ((unsigned __int128) 1) != 1, 0);
+  TEST_COMPARE (stdc_bit_ceil ((~(unsigned __int128) 0) >> 1)
+		!= ((unsigned __int128) 1) << (sizeof (__int128)
+					       * CHAR_BIT - 1), 0);
+  TEST_COMPARE (stdc_bit_ceil (~(unsigned __int128) 0) != 0, 0);
+# endif
+  uc a = 0;
+  TEST_COMPARE (stdc_bit_width (a++), 0);
+  TEST_COMPARE (a, 1);
+  ull b = 0;
+  TEST_COMPARE (stdc_bit_width (b++), 0);
+  TEST_COMPARE (b, 1);
+  TEST_COMPARE (stdc_bit_floor (a++), 1);
+  TEST_COMPARE (a, 2);
+  TEST_COMPARE (stdc_bit_floor (b++), 1);
+  TEST_COMPARE (b, 2);
+  TEST_COMPARE (stdc_bit_ceil (a++), 2);
+  TEST_COMPARE (a, 3);
+  TEST_COMPARE (stdc_bit_ceil (b++), 2);
+  TEST_COMPARE (b, 3);
+  TEST_COMPARE (stdc_leading_zeros (a++), CHAR_BIT - 2);
+  TEST_COMPARE (a, 4);
+  TEST_COMPARE (stdc_leading_zeros (b++),
+		sizeof (long long int) * CHAR_BIT - 2);
+  TEST_COMPARE (b, 4);
+  TEST_COMPARE (stdc_leading_ones (a++), 0);
+  TEST_COMPARE (a, 5);
+  TEST_COMPARE (stdc_leading_ones (b++), 0);
+  TEST_COMPARE (b, 5);
+  TEST_COMPARE (stdc_trailing_zeros (a++), 0);
+  TEST_COMPARE (a, 6);
+  TEST_COMPARE (stdc_trailing_zeros (b++), 0);
+  TEST_COMPARE (b, 6);
+  TEST_COMPARE (stdc_trailing_ones (a++), 0);
+  TEST_COMPARE (a, 7);
+  TEST_COMPARE (stdc_trailing_ones (b++), 0);
+  TEST_COMPARE (b, 7);
+  TEST_COMPARE (stdc_first_leading_zero (a++), 1);
+  TEST_COMPARE (a, 8);
+  TEST_COMPARE (stdc_first_leading_zero (b++), 1);
+  TEST_COMPARE (b, 8);
+  TEST_COMPARE (stdc_first_leading_one (a++), CHAR_BIT - 3);
+  TEST_COMPARE (a, 9);
+  TEST_COMPARE (stdc_first_leading_one (b++),
+		sizeof (long long int) * CHAR_BIT - 3);
+  TEST_COMPARE (b, 9);
+  TEST_COMPARE (stdc_first_trailing_zero (a++), 2);
+  TEST_COMPARE (a, 10);
+  TEST_COMPARE (stdc_first_trailing_zero (b++), 2);
+  TEST_COMPARE (b, 10);
+  TEST_COMPARE (stdc_first_trailing_one (a++), 2);
+  TEST_COMPARE (a, 11);
+  TEST_COMPARE (stdc_first_trailing_one (b++), 2);
+  TEST_COMPARE (b, 11);
+  TEST_COMPARE (stdc_count_zeros (a++), CHAR_BIT - 3);
+  TEST_COMPARE (a, 12);
+  TEST_COMPARE (stdc_count_zeros (b++),
+		sizeof (long long int) * CHAR_BIT - 3);
+  TEST_COMPARE (b, 12);
+  TEST_COMPARE (stdc_count_ones (a++), 2);
+  TEST_COMPARE (a, 13);
+  TEST_COMPARE (stdc_count_ones (b++), 2);
+  TEST_COMPARE (b, 13);
+  TEST_COMPARE (stdc_has_single_bit (a++), 0);
+  TEST_COMPARE (a, 14);
+  TEST_COMPARE (stdc_has_single_bit (b++), 0);
+  TEST_COMPARE (b, 14);
+# ifdef BITINT_MAXWIDTH
+#  if BITINT_MAXWIDTH >= 64
+  TEST_COMPARE (stdc_leading_zeros (0uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_leading_zeros (0uwb), ui), 1);
+  TEST_COMPARE (stdc_leading_zeros (1uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_leading_zeros (1uwb), ui), 1);
+  TEST_COMPARE (stdc_leading_ones (0uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_leading_ones (0uwb), ui), 1);
+  TEST_COMPARE (stdc_leading_ones (1uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_leading_ones (1uwb), ui), 1);
+  TEST_COMPARE (stdc_trailing_zeros (0uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_trailing_zeros (0uwb), ui), 1);
+  TEST_COMPARE (stdc_trailing_zeros (1uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_trailing_zeros (1uwb), ui), 1);
+  TEST_COMPARE (stdc_trailing_ones (0uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_trailing_ones (0uwb), ui), 1);
+  TEST_COMPARE (stdc_trailing_ones (1uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_trailing_ones (1uwb), ui), 1);
+  TEST_COMPARE (stdc_first_leading_zero (0uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_zero (0uwb), ui), 1);
+  TEST_COMPARE (stdc_first_leading_zero (1uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_zero (1uwb), ui), 1);
+  TEST_COMPARE (stdc_first_leading_one (0uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_one (0uwb), ui), 1);
+  TEST_COMPARE (stdc_first_leading_one (1uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_one (1uwb), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_zero (0uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_zero (0uwb), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_zero (1uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_zero (1uwb), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_one (0uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_one (0uwb), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_one (1uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_one (1uwb), ui), 1);
+  TEST_COMPARE (stdc_count_zeros (0uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_count_zeros (0uwb), ui), 1);
+  TEST_COMPARE (stdc_count_zeros (1uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_count_zeros (1uwb), ui), 1);
+  TEST_COMPARE (stdc_count_ones (0uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_count_ones (0uwb), ui), 1);
+  TEST_COMPARE (stdc_count_ones (1uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_count_ones (1uwb), ui), 1);
+  TEST_COMPARE (stdc_has_single_bit (0uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_has_single_bit (0uwb), _Bool), 1);
+  TEST_COMPARE (stdc_has_single_bit (1uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_has_single_bit (1uwb), _Bool), 1);
+  TEST_COMPARE (stdc_bit_width (0uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_width (0uwb), ui), 1);
+  TEST_COMPARE (stdc_bit_width (1uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_bit_width (1uwb), ui), 1);
+  TEST_COMPARE (stdc_bit_floor (0uwb), 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_floor (0uwb), unsigned _BitInt(1)), 1);
+  TEST_COMPARE (stdc_bit_floor (1uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_bit_floor (1uwb), unsigned _BitInt(1)), 1);
+  TEST_COMPARE (stdc_bit_ceil (0uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_bit_ceil (0uwb), unsigned _BitInt(1)), 1);
+  TEST_COMPARE (stdc_bit_ceil (1uwb), 1);
+  TEST_COMPARE (expr_has_type (stdc_bit_ceil (1uwb), unsigned _BitInt(1)), 1);
+  unsigned _BitInt(1) c = 0;
+  TEST_COMPARE (stdc_bit_floor (c++), 0);
+  TEST_COMPARE (c, 1);
+  TEST_COMPARE (stdc_bit_floor (c++), 1);
+  TEST_COMPARE (c, 0);
+  TEST_COMPARE (stdc_bit_ceil (c++), 1);
+  TEST_COMPARE (c, 1);
+  TEST_COMPARE (stdc_bit_ceil (c++), 1);
+  TEST_COMPARE (c, 0);
+#  endif
+#  if BITINT_MAXWIDTH >= 512
+  TEST_COMPARE (stdc_leading_zeros ((unsigned _BitInt(512)) 0), 512);
+  TEST_COMPARE (expr_has_type (stdc_leading_zeros ((unsigned _BitInt(512)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_leading_zeros ((unsigned _BitInt(373)) 0), 373);
+  TEST_COMPARE (expr_has_type (stdc_leading_zeros ((unsigned _BitInt(373)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_leading_zeros (~(unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (stdc_leading_zeros (~(unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (stdc_leading_zeros ((unsigned _BitInt(512)) 275), 512 - 9);
+  TEST_COMPARE (stdc_leading_zeros ((unsigned _BitInt(373)) 512), 373 - 10);
+  TEST_COMPARE (stdc_leading_ones ((unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_leading_ones ((unsigned _BitInt(512)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_leading_ones ((unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_leading_ones ((unsigned _BitInt(373)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_leading_ones (~(unsigned _BitInt(512)) 0), 512);
+  TEST_COMPARE (stdc_leading_ones (~(unsigned _BitInt(373)) 0), 373);
+  TEST_COMPARE (stdc_leading_ones (~(unsigned _BitInt(512)) 275), 512 - 9);
+  TEST_COMPARE (stdc_leading_ones (~(unsigned _BitInt(373)) 512), 373 - 10);
+  TEST_COMPARE (stdc_trailing_zeros ((unsigned _BitInt(512)) 0), 512);
+  TEST_COMPARE (expr_has_type (stdc_trailing_zeros ((unsigned _BitInt(512)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_trailing_zeros ((unsigned _BitInt(373)) 0), 373);
+  TEST_COMPARE (expr_has_type (stdc_trailing_zeros ((unsigned _BitInt(373)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_trailing_zeros (~(unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (stdc_trailing_zeros (~(unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (stdc_trailing_zeros ((unsigned _BitInt(512)) 256), 8);
+  TEST_COMPARE (stdc_trailing_zeros ((unsigned _BitInt(373)) 512), 9);
+  TEST_COMPARE (stdc_trailing_ones ((unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_trailing_ones ((unsigned _BitInt(512)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_trailing_ones ((unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_trailing_ones ((unsigned _BitInt(373)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_trailing_ones (~(unsigned _BitInt(512)) 0), 512);
+  TEST_COMPARE (stdc_trailing_ones (~(unsigned _BitInt(373)) 0), 373);
+  TEST_COMPARE (stdc_trailing_ones ((unsigned _BitInt(512)) 255), 8);
+  TEST_COMPARE (stdc_trailing_ones ((~(unsigned _BitInt(373)) 0) >> 2),
+		373 - 2);
+  TEST_COMPARE (stdc_first_leading_zero ((unsigned _BitInt(512)) 0), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_zero ((unsigned _BitInt(512))
+							0), ui), 1);
+  TEST_COMPARE (stdc_first_leading_zero ((unsigned _BitInt(373)) 0), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_zero ((unsigned _BitInt(373))
+							0), ui), 1);
+  TEST_COMPARE (stdc_first_leading_zero (~(unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (stdc_first_leading_zero (~(unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (stdc_first_leading_zero (~(unsigned _BitInt(512)) 511),
+		512 - 8);
+  TEST_COMPARE (stdc_first_leading_zero (~(unsigned _BitInt(373)) 1023),
+		373 - 9);
+  TEST_COMPARE (stdc_first_leading_one ((unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_one ((unsigned _BitInt(512))
+						       0), ui), 1);
+  TEST_COMPARE (stdc_first_leading_one ((unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_leading_one ((unsigned _BitInt(373))
+						       0), ui), 1);
+  TEST_COMPARE (stdc_first_leading_one (~(unsigned _BitInt(512)) 0), 1);
+  TEST_COMPARE (stdc_first_leading_one (~(unsigned _BitInt(373)) 0), 1);
+  TEST_COMPARE (stdc_first_leading_one ((unsigned _BitInt(512)) 275), 512 - 8);
+  TEST_COMPARE (stdc_first_leading_one ((unsigned _BitInt(373)) 512), 373 - 9);
+  TEST_COMPARE (stdc_first_trailing_zero ((unsigned _BitInt(512)) 0), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_zero ((unsigned
+							  _BitInt(512)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_first_trailing_zero ((unsigned _BitInt(373)) 0), 1);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_zero ((unsigned
+							  _BitInt(373)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_first_trailing_zero (~(unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (stdc_first_trailing_zero (~(unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (stdc_first_trailing_zero ((unsigned _BitInt(512)) 255), 9);
+  TEST_COMPARE (stdc_first_trailing_zero ((unsigned _BitInt(373)) 511), 10);
+  TEST_COMPARE (stdc_first_trailing_one ((unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_one ((unsigned _BitInt(512))
+							0), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_one ((unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_first_trailing_one ((unsigned _BitInt(373))
+							0), ui), 1);
+  TEST_COMPARE (stdc_first_trailing_one (~(unsigned _BitInt(512)) 0), 1);
+  TEST_COMPARE (stdc_first_trailing_one (~(unsigned _BitInt(373)) 0), 1);
+  TEST_COMPARE (stdc_first_trailing_one (((unsigned _BitInt(512)) 255) << 175),
+		176);
+  TEST_COMPARE (stdc_first_trailing_one ((~(unsigned _BitInt(373)) 0) << 311),
+		312);
+  TEST_COMPARE (stdc_count_zeros ((unsigned _BitInt(512)) 0), 512);
+  TEST_COMPARE (expr_has_type (stdc_count_zeros ((unsigned _BitInt(512)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_count_zeros ((unsigned _BitInt(373)) 0), 373);
+  TEST_COMPARE (expr_has_type (stdc_count_zeros ((unsigned _BitInt(373)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_count_zeros (~(unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (stdc_count_zeros (~(unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (stdc_count_zeros ((unsigned _BitInt(512)) 1315), 512 - 5);
+  TEST_COMPARE (stdc_count_zeros ((unsigned _BitInt(373)) 3363), 373 - 6);
+  TEST_COMPARE (stdc_count_ones ((unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_count_ones ((unsigned _BitInt(512)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_count_ones ((unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_count_ones ((unsigned _BitInt(373)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_count_ones (~(unsigned _BitInt(512)) 0), 512);
+  TEST_COMPARE (stdc_count_ones (~(unsigned _BitInt(373)) 0), 373);
+  TEST_COMPARE (stdc_count_ones (~(unsigned _BitInt(512)) 1315), 512 - 5);
+  TEST_COMPARE (stdc_count_ones (~(unsigned _BitInt(373)) 3363), 373 - 6);
+  TEST_COMPARE (stdc_has_single_bit ((unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_has_single_bit ((unsigned _BitInt(512)) 0),
+			       _Bool), 1);
+  TEST_COMPARE (stdc_has_single_bit ((unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_has_single_bit ((unsigned _BitInt(373)) 0),
+			       _Bool), 1);
+  TEST_COMPARE (stdc_has_single_bit (~(unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (stdc_has_single_bit (~(unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (stdc_has_single_bit (((unsigned _BitInt(512)) 1022) << 279),
+		0);
+  TEST_COMPARE (stdc_has_single_bit (((unsigned _BitInt(373)) 12) << 305), 0);
+  TEST_COMPARE (stdc_bit_width ((unsigned _BitInt(512)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_width ((unsigned _BitInt(512)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_bit_width ((unsigned _BitInt(373)) 0), 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_width ((unsigned _BitInt(373)) 0),
+			       ui), 1);
+  TEST_COMPARE (stdc_bit_width (~(unsigned _BitInt(512)) 0), 512);
+  TEST_COMPARE (stdc_bit_width (~(unsigned _BitInt(373)) 0), 373);
+  TEST_COMPARE (stdc_bit_width (((unsigned _BitInt(512)) 1023) << 405),
+		405 + 10);
+  TEST_COMPARE (stdc_bit_width (((unsigned _BitInt(373)) 1024) << 242),
+		242 + 11);
+  TEST_COMPARE (stdc_bit_floor ((unsigned _BitInt(512)) 0) != 0, 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_floor ((unsigned _BitInt(512)) 0),
+			       unsigned _BitInt(512)), 1);
+  TEST_COMPARE (stdc_bit_floor ((unsigned _BitInt(373)) 0) != 0, 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_floor ((unsigned _BitInt(373)) 0),
+			       unsigned _BitInt(373)), 1);
+  TEST_COMPARE (stdc_bit_floor (~(unsigned _BitInt(512)) 0)
+		!= ((unsigned _BitInt(512)) 1) << (512 - 1), 0);
+  TEST_COMPARE (stdc_bit_floor (~(unsigned _BitInt(373)) 0)
+		!= ((unsigned _BitInt(373)) 1) << (373 - 1), 0);
+  TEST_COMPARE (stdc_bit_floor (((unsigned _BitInt(512)) 511) << 405)
+		!= (((unsigned _BitInt(512)) 256) << 405), 0);
+  TEST_COMPARE (stdc_bit_floor (((unsigned _BitInt(373)) 512) << 242)
+		!= (((unsigned _BitInt(512)) 512) << 242), 0);
+  TEST_COMPARE (stdc_bit_ceil ((unsigned _BitInt(512)) 0) != 1, 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_ceil ((unsigned _BitInt(512)) 0),
+			       unsigned _BitInt(512)), 1);
+  TEST_COMPARE (stdc_bit_ceil ((unsigned _BitInt(373)) 0) != 1, 0);
+  TEST_COMPARE (expr_has_type (stdc_bit_ceil ((unsigned _BitInt(373)) 0),
+			       unsigned _BitInt(373)), 1);
+  TEST_COMPARE (stdc_bit_ceil (~(unsigned _BitInt(512)) 0) != 0, 0);
+  TEST_COMPARE (stdc_bit_ceil (~(unsigned _BitInt(373)) 0) != 0, 0);
+  TEST_COMPARE (stdc_bit_ceil (((unsigned _BitInt(512)) 1) << (512 - 1))
+		!= ((unsigned _BitInt(512)) 1) << (512 - 1), 0);
+  TEST_COMPARE (stdc_bit_ceil ((~(unsigned _BitInt(373)) 0) >> 1)
+		!= ((unsigned _BitInt(373)) 1) << (373 - 1), 0);
+  TEST_COMPARE (stdc_bit_ceil (((unsigned _BitInt(512)) 512) << 405)
+		!= (((unsigned _BitInt(512)) 512) << 405), 0);
+  TEST_COMPARE (stdc_bit_ceil (((unsigned _BitInt(373)) 513) << 242)
+		!= (((unsigned _BitInt(512)) 1024) << 242), 0);
+  TEST_COMPARE (stdc_bit_floor ((unsigned _BitInt(BITINT_MAXWIDTH)) 0) != 0,
+		0);
+  TEST_COMPARE (stdc_bit_floor (~(unsigned _BitInt(BITINT_MAXWIDTH)) 0)
+		!= ((unsigned _BitInt(BITINT_MAXWIDTH)) 1) << (BITINT_MAXWIDTH
+							       - 1), 0);
+  TEST_COMPARE (stdc_bit_floor (((unsigned _BitInt(BITINT_MAXWIDTH)) 511)
+				<< 405)
+		!= (((unsigned _BitInt(BITINT_MAXWIDTH)) 256) << 405), 0);
+  TEST_COMPARE (stdc_bit_floor (((unsigned _BitInt(BITINT_MAXWIDTH)) 512)
+				<< 405)
+		!= (((unsigned _BitInt(BITINT_MAXWIDTH)) 512) << 405), 0);
+  TEST_COMPARE (stdc_bit_ceil ((unsigned _BitInt(BITINT_MAXWIDTH)) 0) != 1, 0);
+  TEST_COMPARE (stdc_bit_ceil (~(unsigned _BitInt(BITINT_MAXWIDTH)) 0) != 0,
+		0);
+  TEST_COMPARE (stdc_bit_ceil (((unsigned _BitInt(BITINT_MAXWIDTH)) 1)
+			       << (BITINT_MAXWIDTH - 1))
+		!= ((unsigned _BitInt(BITINT_MAXWIDTH)) 1) << (BITINT_MAXWIDTH
+							       - 1), 0);
+  TEST_COMPARE (stdc_bit_ceil (((unsigned _BitInt(BITINT_MAXWIDTH)) 512)
+			       << 405)
+		!= (((unsigned _BitInt(BITINT_MAXWIDTH)) 512) << 405), 0);
+  TEST_COMPARE (stdc_bit_ceil (((unsigned _BitInt(BITINT_MAXWIDTH)) 513)
+			       << 405)
+		!= (((unsigned _BitInt(BITINT_MAXWIDTH)) 1024) << 405), 0);
+#  endif
+# endif
+  return 0;
+}
+#else
+static int
+do_test (void)
+{
+  return 0;
+}
+#endif
+
+#include <support/test-driver.c>