From patchwork Sat Jan 20 18:04:42 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Jelinek X-Patchwork-Id: 84486 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 4141F3858413 for ; Sat, 20 Jan 2024 18:05:20 +0000 (GMT) X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id 350893858D39 for ; Sat, 20 Jan 2024 18:04:49 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 350893858D39 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 350893858D39 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1705773895; cv=none; b=WPUHRRUxNkdtSUJgjoruqb5lzb4xUCeCJlZ6SmmXKSskQHA3cyQXGLRtIL7Ed5gvF5F2uTcQUfZloi5GM7aToA43DKFGycf0w/DCyNhzscDMh8zfMRbcpsAd01VEdTtYdpdIeZc8miQiBlC/73CuGco7xcRjFIVygVoS8N3kB3E= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1705773895; c=relaxed/simple; bh=cv7Mj8DTaWmeKkJPjTgbWMOwXxU+rycJ5f6FDt+8hOw=; h=DKIM-Signature:Date:From:To:Subject:Message-ID:MIME-Version; b=hzFc/no/+2/cB7P9o/Q0n7JElqc+lHREcyECsw4yLfAUOaYuPtGD0eLzNpNnIuSoDtJIITHKgaXujCsATc1r39KO4NQ67L0rBfFA3y/+BVgqQkzAN6dyNDcnA/UI3IIBMtXLnn2X9KxB7VLKM6U+1Q5tZ0LXM7QSZ8KPavQ4TjM= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1705773888; h=from:from:reply-to:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type; bh=q6DYIVcUdeS0nitoDJixcAQLu7oN/dC26prN8NAG5FQ=; b=XBtl4kwTS3rQIaCilvXm+RECdejj9ZlVo4/JZhMEeAao8N+dbfweiefm2ZD5N7yndUrMuN ovHtlAi6domIvy5zNMAySKbFzNeN/XtZuD9vruzfl88Kl4yICTwadrrGdSqpejbTtsWr0p w/dmWZaXkpbDANdK1s2EsZbPzCwvaIg= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-670-9CCrDJVAMcm6vVX2Hor6iw-1; Sat, 20 Jan 2024 13:04:46 -0500 X-MC-Unique: 9CCrDJVAMcm6vVX2Hor6iw-1 Received: from smtp.corp.redhat.com (int-mx09.intmail.prod.int.rdu2.redhat.com [10.11.54.9]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id AF1078489E2 for ; Sat, 20 Jan 2024 18:04:46 +0000 (UTC) Received: from tucnak.zalov.cz (unknown [10.39.192.70]) by smtp.corp.redhat.com (Postfix) with ESMTPS id C52F1492BC6; Sat, 20 Jan 2024 18:04:45 +0000 (UTC) Received: from tucnak.zalov.cz (localhost [127.0.0.1]) by tucnak.zalov.cz (8.17.1/8.17.1) with ESMTPS id 40KI4hcp2478901 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384 bits=256 verify=NOT); Sat, 20 Jan 2024 19:04:43 +0100 Received: (from jakub@localhost) by tucnak.zalov.cz (8.17.1/8.17.1/Submit) id 40KI4gcB2478900; Sat, 20 Jan 2024 19:04:42 +0100 Date: Sat, 20 Jan 2024 19:04:42 +0100 From: Jakub Jelinek To: libc-alpha@sourceware.org Cc: Joseph Myers Subject: [PATCH] Use gcc __builtin_stdc_* builtins in stdbit.h if possible Message-ID: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.4.1 on 10.11.54.9 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Disposition: inline X-Spam-Status: No, score=-10.0 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: Jakub Jelinek Errors-To: libc-alpha-bounces+patchwork=sourceware.org@sourceware.org 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 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 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 + . */ + +#include +#include +#include + +#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