mirror of
https://sourceware.org/git/glibc.git
synced 2025-01-14 21:10:19 +00:00
48ef5aeb1b
With clang 14 and also with main the tst-stdbit-Wconversion
issues the warnings:
../stdlib/stdbit.h:701:40: error: implicit conversion loses integer
precision: 'int' to 'uint16_t' (aka 'unsigned short')
[-Werror,-Wimplicit-int-conversion]
return __x == 0 ? 0 : ((uint16_t) 1) << (__bw16_inline (__x) - 1);
~~~~~~ ~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
../stdlib/stdbit.h:707:39: error: implicit conversion loses integer
precision: 'int' to 'uint8_t' (aka 'unsigned char')
[-Werror,-Wimplicit-int-conversion]
return __x == 0 ? 0 : ((uint8_t) 1) << (__bw8_inline (__x) - 1);
~~~~~~ ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
../stdlib/stdbit.h:751:40: error: implicit conversion loses integer
precision: 'int' to 'uint16_t' (aka 'unsigned short')
[-Werror,-Wimplicit-int-conversion]
return __x <= 1 ? 1 : ((uint16_t) 2) << (__bw16_inline (__x - 1) - 1);
~~~~~~ ~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
../stdlib/stdbit.h:757:39: error: implicit conversion loses integer
precision: 'int' to 'uint8_t' (aka 'unsigned char')
[-Werror,-Wimplicit-int-conversion]
return __x <= 1 ? 1 : ((uint8_t) 2) << (__bw8_inline (__x - 1) - 1);
~~~~~~ ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
tst-stdbit-Wconversion.c:45:31: error: implicit conversion loses integer
precision: 'unsigned short' to 'uint8_t' (aka 'unsigned char')
[-Werror,-Wimplicit-int-conversion]
(void) stdc_trailing_zeros (us);
~~~~~~~~~~~~~~~~~~~~~^~~
../stdlib/stdbit.h:164:30: note: expanded from macro
'stdc_trailing_zeros'
: stdc_trailing_zeros_uc (x))
~~~~~~~~~~~~~~~~~~~~~~~~^~
../stdlib/stdbit.h:191:52: note: expanded from macro
'stdc_trailing_zeros_uc'
# define stdc_trailing_zeros_uc(x) (__ctz8_inline (x))
~~~~~~~~~~~~~ ^
tst-stdbit-Wconversion.c:46:31: error: implicit conversion loses integer
precision: 'unsigned int' to 'uint16_t' (aka 'unsigned short')
[-Werror,-Wimplicit-int-conversion]
(void) stdc_trailing_zeros (ui);
~~~~~~~~~~~~~~~~~~~~~^~~
../stdlib/stdbit.h:163:48: note: expanded from macro
'stdc_trailing_zeros'
: sizeof (x) == 2 ? stdc_trailing_zeros_us (x) \
~~~~~~~~~~~~~~~~~~~~~~~~^~
../stdlib/stdbit.h:192:53: note: expanded from macro
'stdc_trailing_zeros_us'
# define stdc_trailing_zeros_us(x) (__ctz16_inline (x))
~~~~~~~~~~~~~~ ^
tst-stdbit-Wconversion.c:46:31: error: implicit conversion loses integer
precision: 'unsigned int' to 'uint8_t' (aka 'unsigned char')
[-Werror,-Wimplicit-int-conversion]
(void) stdc_trailing_zeros (ui);
~~~~~~~~~~~~~~~~~~~~~^~~
../stdlib/stdbit.h:164:30: note: expanded from macro
'stdc_trailing_zeros'
: stdc_trailing_zeros_uc (x))
~~~~~~~~~~~~~~~~~~~~~~~~^~
../stdlib/stdbit.h:191:52: note: expanded from macro
'stdc_trailing_zeros_uc'
# define stdc_trailing_zeros_uc(x) (__ctz8_inline (x))
~~~~~~~~~~~~~ ^
tst-stdbit-Wconversion.c:47:31: error: implicit conversion loses integer
precision: 'unsigned long' to 'uint16_t' (aka 'unsigned short')
[-Werror,-Wimplicit-int-conversion]
(void) stdc_trailing_zeros (ul);
~~~~~~~~~~~~~~~~~~~~~^~~
../stdlib/stdbit.h:163:48: note: expanded from macro
'stdc_trailing_zeros'
: sizeof (x) == 2 ? stdc_trailing_zeros_us (x) \
~~~~~~~~~~~~~~~~~~~~~~~~^~
../stdlib/stdbit.h:192:53: note: expanded from macro
'stdc_trailing_zeros_us'
# define stdc_trailing_zeros_us(x) (__ctz16_inline (x))
~~~~~~~~~~~~~~ ^
[...]
It seems to boiler down to __builtin_clz not having a variant for 8 or
16 bits. Fix it by explicit casting to the expected types. Although
not strickly required for older gcc, using the same __pacify macro
simpify the required code.
Checked on x86_64-linux-gnu and i686-linux-gnu.
793 lines
24 KiB
C
793 lines
24 KiB
C
/* ISO C23 Standard: 7.18 - Bit and byte utilities <stdbit.h>.
|
|
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/>. */
|
|
|
|
#ifndef _STDBIT_H
|
|
#define _STDBIT_H 1
|
|
|
|
#include <features.h>
|
|
#include <bits/endian.h>
|
|
#include <bits/stdint-intn.h>
|
|
#include <bits/stdint-uintn.h>
|
|
#include <bits/stdint-least.h>
|
|
/* In C23, <stdbool.h> defines only an implementation-namespace macro,
|
|
so is OK to include here. Before C23, including <stdbool.h> allows
|
|
the header to use bool rather than _Bool unconditionally, and so to
|
|
compile as C++ (although the type-generic macros are not a good
|
|
form of type-generic interface for C++). */
|
|
#include <stdbool.h>
|
|
#define __need_size_t
|
|
#include <stddef.h>
|
|
|
|
#define __STDC_VERSION_STDBIT_H__ 202311L
|
|
|
|
#define __STDC_ENDIAN_LITTLE__ __LITTLE_ENDIAN
|
|
#define __STDC_ENDIAN_BIG__ __BIG_ENDIAN
|
|
#define __STDC_ENDIAN_NATIVE__ __BYTE_ORDER
|
|
|
|
__BEGIN_DECLS
|
|
|
|
/* Use __pacify_uint16 (N) instead of (uint16_t) (N) when the cast is helpful
|
|
only to pacify older GCC (e.g., GCC 10 -Wconversion) or non-GCC (e.g
|
|
clang -Wimplicit-int-conversion). */
|
|
#if __GNUC_PREREQ (11, 0)
|
|
# define __pacify_uint8(n) (n)
|
|
# define __pacify_uint16(n) (n)
|
|
#else
|
|
# define __pacify_uint8(n) ((uint8_t) (n))
|
|
# define __pacify_uint16(n) ((uint16_t) (n))
|
|
#endif
|
|
|
|
/* Count leading zeros. */
|
|
extern unsigned int stdc_leading_zeros_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_leading_zeros_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_leading_zeros_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_leading_zeros_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__extension__
|
|
extern unsigned int stdc_leading_zeros_ull (unsigned long long int __x)
|
|
__THROW __attribute_const__;
|
|
#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)
|
|
static __always_inline unsigned int
|
|
__clz64_inline (uint64_t __x)
|
|
{
|
|
return __x == 0 ? 64U : (unsigned int) __builtin_clzll (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__clz32_inline (uint32_t __x)
|
|
{
|
|
return __x == 0 ? 32U : (unsigned int) __builtin_clz (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__clz16_inline (uint16_t __x)
|
|
{
|
|
return __clz32_inline (__x) - 16;
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__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))
|
|
# endif
|
|
# define stdc_leading_zeros_ull(x) (__clz64_inline (x))
|
|
#endif
|
|
|
|
/* Count leading ones. */
|
|
extern unsigned int stdc_leading_ones_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_leading_ones_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_leading_ones_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_leading_ones_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__extension__
|
|
extern unsigned int stdc_leading_ones_ull (unsigned long long int __x)
|
|
__THROW __attribute_const__;
|
|
#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)
|
|
static __always_inline unsigned int
|
|
__clo64_inline (uint64_t __x)
|
|
{
|
|
return __clz64_inline (~__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__clo32_inline (uint32_t __x)
|
|
{
|
|
return __clz32_inline (~__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__clo16_inline (uint16_t __x)
|
|
{
|
|
return __clz16_inline (__pacify_uint16 (~__x));
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__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))
|
|
# endif
|
|
# define stdc_leading_ones_ull(x) (__clo64_inline (x))
|
|
#endif
|
|
|
|
/* Count trailing zeros. */
|
|
extern unsigned int stdc_trailing_zeros_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_trailing_zeros_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_trailing_zeros_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_trailing_zeros_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__extension__
|
|
extern unsigned int stdc_trailing_zeros_ull (unsigned long long int __x)
|
|
__THROW __attribute_const__;
|
|
#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)
|
|
static __always_inline unsigned int
|
|
__ctz64_inline (uint64_t __x)
|
|
{
|
|
return __x == 0 ? 64U : (unsigned int) __builtin_ctzll (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__ctz32_inline (uint32_t __x)
|
|
{
|
|
return __x == 0 ? 32U : (unsigned int) __builtin_ctz (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__ctz16_inline (uint16_t __x)
|
|
{
|
|
return __x == 0 ? 16U : (unsigned int) __builtin_ctz (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__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))
|
|
# endif
|
|
# define stdc_trailing_zeros_ull(x) (__ctz64_inline (x))
|
|
#endif
|
|
|
|
/* Count trailing ones. */
|
|
extern unsigned int stdc_trailing_ones_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_trailing_ones_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_trailing_ones_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_trailing_ones_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__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 __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_ctzll)
|
|
static __always_inline unsigned int
|
|
__cto64_inline (uint64_t __x)
|
|
{
|
|
return __ctz64_inline (~__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__cto32_inline (uint32_t __x)
|
|
{
|
|
return __ctz32_inline (~__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__cto16_inline (uint16_t __x)
|
|
{
|
|
return __ctz16_inline (__pacify_uint16 (~__x));
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__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))
|
|
# endif
|
|
# define stdc_trailing_ones_ull(x) (__cto64_inline (x))
|
|
#endif
|
|
|
|
/* First leading zero. */
|
|
extern unsigned int stdc_first_leading_zero_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_first_leading_zero_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_first_leading_zero_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_first_leading_zero_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__extension__
|
|
extern unsigned int stdc_first_leading_zero_ull (unsigned long long int __x)
|
|
__THROW __attribute_const__;
|
|
#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)
|
|
static __always_inline unsigned int
|
|
__flz64_inline (uint64_t __x)
|
|
{
|
|
return __x == (uint64_t) -1 ? 0 : 1 + __clo64_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__flz32_inline (uint32_t __x)
|
|
{
|
|
return __x == (uint32_t) -1 ? 0 : 1 + __clo32_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__flz16_inline (uint16_t __x)
|
|
{
|
|
return __x == (uint16_t) -1 ? 0 : 1 + __clo16_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__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))
|
|
# endif
|
|
# define stdc_first_leading_zero_ull(x) (__flz64_inline (x))
|
|
#endif
|
|
|
|
/* First leading one. */
|
|
extern unsigned int stdc_first_leading_one_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_first_leading_one_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_first_leading_one_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_first_leading_one_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__extension__
|
|
extern unsigned int stdc_first_leading_one_ull (unsigned long long int __x)
|
|
__THROW __attribute_const__;
|
|
#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)
|
|
static __always_inline unsigned int
|
|
__flo64_inline (uint64_t __x)
|
|
{
|
|
return __x == 0 ? 0 : 1 + __clz64_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__flo32_inline (uint32_t __x)
|
|
{
|
|
return __x == 0 ? 0 : 1 + __clz32_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__flo16_inline (uint16_t __x)
|
|
{
|
|
return __x == 0 ? 0 : 1 + __clz16_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__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))
|
|
# endif
|
|
# define stdc_first_leading_one_ull(x) (__flo64_inline (x))
|
|
#endif
|
|
|
|
/* First trailing zero. */
|
|
extern unsigned int stdc_first_trailing_zero_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_first_trailing_zero_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_first_trailing_zero_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_first_trailing_zero_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__extension__
|
|
extern unsigned int stdc_first_trailing_zero_ull (unsigned long long int __x)
|
|
__THROW __attribute_const__;
|
|
#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)
|
|
static __always_inline unsigned int
|
|
__ftz64_inline (uint64_t __x)
|
|
{
|
|
return __x == (uint64_t) -1 ? 0 : 1 + __cto64_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__ftz32_inline (uint32_t __x)
|
|
{
|
|
return __x == (uint32_t) -1 ? 0 : 1 + __cto32_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__ftz16_inline (uint16_t __x)
|
|
{
|
|
return __x == (uint16_t) -1 ? 0 : 1 + __cto16_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__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))
|
|
# endif
|
|
# define stdc_first_trailing_zero_ull(x) (__ftz64_inline (x))
|
|
#endif
|
|
|
|
/* First trailing one. */
|
|
extern unsigned int stdc_first_trailing_one_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_first_trailing_one_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_first_trailing_one_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_first_trailing_one_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__extension__
|
|
extern unsigned int stdc_first_trailing_one_ull (unsigned long long int __x)
|
|
__THROW __attribute_const__;
|
|
#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)
|
|
static __always_inline unsigned int
|
|
__fto64_inline (uint64_t __x)
|
|
{
|
|
return __x == 0 ? 0 : 1 + __ctz64_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__fto32_inline (uint32_t __x)
|
|
{
|
|
return __x == 0 ? 0 : 1 + __ctz32_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__fto16_inline (uint16_t __x)
|
|
{
|
|
return __x == 0 ? 0 : 1 + __ctz16_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__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))
|
|
# endif
|
|
# define stdc_first_trailing_one_ull(x) (__fto64_inline (x))
|
|
#endif
|
|
|
|
/* Count zeros. */
|
|
extern unsigned int stdc_count_zeros_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_count_zeros_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_count_zeros_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_count_zeros_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__extension__
|
|
extern unsigned int stdc_count_zeros_ull (unsigned long long int __x)
|
|
__THROW __attribute_const__;
|
|
#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)
|
|
static __always_inline unsigned int
|
|
__cz64_inline (uint64_t __x)
|
|
{
|
|
return 64U - (unsigned int) __builtin_popcountll (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__cz32_inline (uint32_t __x)
|
|
{
|
|
return 32U - (unsigned int) __builtin_popcount (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__cz16_inline (uint16_t __x)
|
|
{
|
|
return 16U - (unsigned int) __builtin_popcount (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__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))
|
|
# endif
|
|
# define stdc_count_zeros_ull(x) (__cz64_inline (x))
|
|
#endif
|
|
|
|
/* Count ones. */
|
|
extern unsigned int stdc_count_ones_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_count_ones_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_count_ones_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_count_ones_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__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 __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_popcountll)
|
|
static __always_inline unsigned int
|
|
__co64_inline (uint64_t __x)
|
|
{
|
|
return (unsigned int) __builtin_popcountll (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__co32_inline (uint32_t __x)
|
|
{
|
|
return (unsigned int) __builtin_popcount (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__co16_inline (uint16_t __x)
|
|
{
|
|
return (unsigned int) __builtin_popcount (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__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))
|
|
# endif
|
|
# define stdc_count_ones_ull(x) (__co64_inline (x))
|
|
#endif
|
|
|
|
/* Single-bit check. */
|
|
extern bool stdc_has_single_bit_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern bool stdc_has_single_bit_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern bool stdc_has_single_bit_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern bool stdc_has_single_bit_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__extension__
|
|
extern bool stdc_has_single_bit_ull (unsigned long long int __x)
|
|
__THROW __attribute_const__;
|
|
#define stdc_has_single_bit(x) \
|
|
((bool) (sizeof (x) <= sizeof (unsigned int) \
|
|
? stdc_has_single_bit_ui (x) \
|
|
: stdc_has_single_bit_ull (x)))
|
|
|
|
static __always_inline bool
|
|
__hsb64_inline (uint64_t __x)
|
|
{
|
|
return (__x ^ (__x - 1)) > __x - 1;
|
|
}
|
|
|
|
static __always_inline bool
|
|
__hsb32_inline (uint32_t __x)
|
|
{
|
|
return (__x ^ (__x - 1)) > __x - 1;
|
|
}
|
|
|
|
static __always_inline bool
|
|
__hsb16_inline (uint16_t __x)
|
|
{
|
|
return (__x ^ (__x - 1)) > __x - 1;
|
|
}
|
|
|
|
static __always_inline bool
|
|
__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))
|
|
#endif
|
|
#define stdc_has_single_bit_ull(x) (__hsb64_inline (x))
|
|
|
|
/* Bit width. */
|
|
extern unsigned int stdc_bit_width_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_bit_width_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_bit_width_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_bit_width_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__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 __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
|
|
static __always_inline unsigned int
|
|
__bw64_inline (uint64_t __x)
|
|
{
|
|
return 64 - __clz64_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__bw32_inline (uint32_t __x)
|
|
{
|
|
return 32 - __clz32_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__bw16_inline (uint16_t __x)
|
|
{
|
|
return 16 - __clz16_inline (__x);
|
|
}
|
|
|
|
static __always_inline unsigned int
|
|
__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))
|
|
# endif
|
|
# define stdc_bit_width_ull(x) (__bw64_inline (x))
|
|
#endif
|
|
|
|
/* Bit floor. */
|
|
extern unsigned char stdc_bit_floor_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned short stdc_bit_floor_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_bit_floor_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned long int stdc_bit_floor_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__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 __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
|
|
static __always_inline uint64_t
|
|
__bf64_inline (uint64_t __x)
|
|
{
|
|
return __x == 0 ? 0 : ((uint64_t) 1) << (__bw64_inline (__x) - 1);
|
|
}
|
|
|
|
static __always_inline uint32_t
|
|
__bf32_inline (uint32_t __x)
|
|
{
|
|
return __x == 0 ? 0 : ((uint32_t) 1) << (__bw32_inline (__x) - 1);
|
|
}
|
|
|
|
static __always_inline uint16_t
|
|
__bf16_inline (uint16_t __x)
|
|
{
|
|
return __pacify_uint16 (__x == 0
|
|
? 0 : ((uint16_t) 1) << (__bw16_inline (__x) - 1));
|
|
}
|
|
|
|
static __always_inline uint8_t
|
|
__bf8_inline (uint8_t __x)
|
|
{
|
|
return __pacify_uint8 (__x == 0
|
|
? 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))
|
|
# endif
|
|
# define stdc_bit_floor_ull(x) ((unsigned long long int) __bf64_inline (x))
|
|
#endif
|
|
|
|
/* Bit ceiling. */
|
|
extern unsigned char stdc_bit_ceil_uc (unsigned char __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned short stdc_bit_ceil_us (unsigned short __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned int stdc_bit_ceil_ui (unsigned int __x)
|
|
__THROW __attribute_const__;
|
|
extern unsigned long int stdc_bit_ceil_ul (unsigned long int __x)
|
|
__THROW __attribute_const__;
|
|
__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 __GNUC_PREREQ (3, 4) || __glibc_has_builtin (__builtin_clzll)
|
|
static __always_inline uint64_t
|
|
__bc64_inline (uint64_t __x)
|
|
{
|
|
return __x <= 1 ? 1 : ((uint64_t) 2) << (__bw64_inline (__x - 1) - 1);
|
|
}
|
|
|
|
static __always_inline uint32_t
|
|
__bc32_inline (uint32_t __x)
|
|
{
|
|
return __x <= 1 ? 1 : ((uint32_t) 2) << (__bw32_inline (__x - 1) - 1);
|
|
}
|
|
|
|
static __always_inline uint16_t
|
|
__bc16_inline (uint16_t __x)
|
|
{
|
|
return __pacify_uint16 (__x <= 1
|
|
? 1
|
|
: ((uint16_t) 2)
|
|
<< (__bw16_inline ((uint16_t) (__x - 1)) - 1));
|
|
}
|
|
|
|
static __always_inline uint8_t
|
|
__bc8_inline (uint8_t __x)
|
|
{
|
|
return __pacify_uint8 (__x <= 1
|
|
? 1
|
|
: ((uint8_t) 2)
|
|
<< (__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))
|
|
# endif
|
|
# define stdc_bit_ceil_ull(x) ((unsigned long long int) __bc64_inline (x))
|
|
#endif
|
|
|
|
__END_DECLS
|
|
|
|
#endif /* _STDBIT_H */
|