From 21e2bdc8e21b2f618449e4a1a601c2ae427ebce8 Mon Sep 17 00:00:00 2001 From: ZERICO2005 <71151164+ZERICO2005@users.noreply.github.com> Date: Sat, 12 Apr 2025 13:29:44 -0600 Subject: [PATCH 1/2] Fixed std::bit_ceil, made it behave the same as C23 stdc_bit_ceil --- src/libcxx/include/bit | 26 +++++++------------------- test/standalone/stdbit/src/main.cpp | 3 --- 2 files changed, 7 insertions(+), 22 deletions(-) diff --git a/src/libcxx/include/bit b/src/libcxx/include/bit index f38f77832..e0467122b 100644 --- a/src/libcxx/include/bit +++ b/src/libcxx/include/bit @@ -289,7 +289,7 @@ int bit_width(_Tp __t) noexcept; template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr int bit_width(unsigned char __t) noexcept { - return std::numeric_limits::digits- __ez80_clzc(__t); + return std::numeric_limits::digits - __ez80_clzc(__t); } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr @@ -326,44 +326,32 @@ _Tp bit_ceil(_Tp __t) noexcept; template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr unsigned char bit_ceil(unsigned char __t) noexcept { - return - (__t <= static_cast(std::numeric_limits::min())) - ? ((__t != 0) ? (static_cast(1) << bit_width(__t - 1)) : 1) : 0; + return ((__t < 2) ? 1 : (static_cast(2) << (bit_width(__t - 1) - 1))); } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr unsigned short bit_ceil(unsigned short __t) noexcept { - return - (__t <= static_cast(std::numeric_limits::min())) - ? ((__t != 0) ? (static_cast(1) << bit_width(__t - 1)) : 1) : 0; + return ((__t < 2) ? 1 : (static_cast(2) << (bit_width(__t - 1) - 1))); } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr unsigned int bit_ceil(unsigned int __t) noexcept { - return - (__t <= static_cast(std::numeric_limits::min())) - ? ((__t != 0) ? (static_cast(1) << bit_width(__t - 1)) : 1) : 0; + return ((__t < 2) ? 1 : (static_cast(2) << (bit_width(__t - 1) - 1))); } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr unsigned long bit_ceil(unsigned long __t) noexcept { - return - (__t <= static_cast(std::numeric_limits::min())) - ? ((__t != 0) ? (static_cast(1) << bit_width(__t - 1)) : 1) : 0; + return ((__t < 2) ? 1 : (static_cast(2) << (bit_width(__t - 1) - 1))); } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr unsigned __int48 bit_ceil(unsigned __int48 __t) noexcept { - return - (__t <= static_cast(std::numeric_limits::min())) - ? ((__t != 0) ? (static_cast(1) << bit_width(__t - 1)) : 1) : 0; + return ((__t < 2) ? 1 : (static_cast(2) << (bit_width(__t - 1) - 1))); } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr unsigned long long bit_ceil(unsigned long long __t) noexcept { - return - (__t <= static_cast(std::numeric_limits::min())) - ? ((__t != 0) ? (static_cast(1) << bit_width(__t - 1)) : 1) : 0; + return ((__t < 2) ? 1 : (static_cast(2) << (bit_width(__t - 1) - 1))); } //------------------------------------------------------------------------------ diff --git a/test/standalone/stdbit/src/main.cpp b/test/standalone/stdbit/src/main.cpp index 49520ac32..6071f84ba 100644 --- a/test/standalone/stdbit/src/main.cpp +++ b/test/standalone/stdbit/src/main.cpp @@ -349,15 +349,12 @@ int test_bit_ceil(void) { C((std::bit_ceil( one_u32) == one_u32)); C((std::bit_ceil( one_u48) == one_u48)); C((std::bit_ceil( one_u64) == one_u64)); - // optional undefined behaviour -#if 0 C((std::bit_ceil(umax_u8 ) == zero_u8 )); C((std::bit_ceil(umax_u16) == zero_u16)); C((std::bit_ceil(umax_u24) == zero_u24)); C((std::bit_ceil(umax_u32) == zero_u32)); C((std::bit_ceil(umax_u48) == zero_u48)); C((std::bit_ceil(umax_u64) == zero_u64)); -#endif C((std::bit_ceil(smax_u8 ) == smin_u8 )); C((std::bit_ceil(smax_u16) == smin_u16)); C((std::bit_ceil(smax_u24) == smin_u24)); From 29db8e326b1044c6b85236d4a9544a2c7136a63e Mon Sep 17 00:00:00 2001 From: ZERICO2005 <71151164+ZERICO2005@users.noreply.github.com> Date: Sat, 12 Apr 2025 23:14:47 -0600 Subject: [PATCH 2/2] Implemented the rest of C23 and fixed --- .../standalone_examples/math_test/src/main.c | 17 +- src/libc/ez80_builtin.src | 12 - src/libc/include/ez80_builtin.h | 110 +++ src/libc/include/stdbit.h | 900 +++++++++++++++++- src/libc/stdbit.c | 417 ++++++++ test/standalone/ez80_builtin/src/main.c | 15 - test/standalone/stdbit/src/data.asm | 3 + test/standalone/stdbit/src/data.h | 1 + test/standalone/stdbit/src/test.c | 571 ++++++++--- 9 files changed, 1853 insertions(+), 193 deletions(-) create mode 100644 src/libc/stdbit.c diff --git a/examples/standalone_examples/math_test/src/main.c b/examples/standalone_examples/math_test/src/main.c index bad166b77..61c34b271 100644 --- a/examples/standalone_examples/math_test/src/main.c +++ b/examples/standalone_examples/math_test/src/main.c @@ -11,12 +11,12 @@ #include #include - #ifdef _EZ80 # include # include # include +# include # if INTERACTIVE # define x_printf printf @@ -77,6 +77,7 @@ static int24_t __builtin_bitreverse24(int24_t x) #endif +#ifndef _EZ80 static int48_t __builtin_bitreverse48(int48_t x) { // return __builtin_bitreverse64(x) >> 16; @@ -91,6 +92,20 @@ static int __builtin_popcounti48(uint48_t x) { return __builtin_popcountll(x & ((1LL << 48) - 1)); } +#else +static int48_t __builtin_bitreverse48(int48_t x) +{ + return __ez80_bitreverse48(x); +} +static uint48_t __builtin_bswap48(uint48_t x) +{ + return __ez80_bswap48(x); +} +static int __builtin_popcounti48(uint48_t x) +{ + return __ez80_popcounti48(x); +} +#endif static int24_t iabs(int24_t x) { return x < 0 ? (int24_t)-x : x; diff --git a/src/libc/ez80_builtin.src b/src/libc/ez80_builtin.src index e4da6fb05..209ca9eca 100644 --- a/src/libc/ez80_builtin.src +++ b/src/libc/ez80_builtin.src @@ -298,17 +298,6 @@ ___ez80_bswap48: push de, hl, bc jp __i48bswap -;------------------------------------------------------------------------------- - - section .text - - public ___ez80_bitreverse24 -___ez80_bitreverse24: - pop bc - ex (sp), hl - push bc - jp __ibitrev - ;------------------------------------------------------------------------------- section .text @@ -447,7 +436,6 @@ ___ez80_rotateright48: extern __spopcnt extern __i48popcnt - extern __ibitrev extern __i48bitrev extern __i48bswap diff --git a/src/libc/include/ez80_builtin.h b/src/libc/include/ez80_builtin.h index 12eb379a2..031032268 100644 --- a/src/libc/include/ez80_builtin.h +++ b/src/libc/include/ez80_builtin.h @@ -8,39 +8,149 @@ extern "C" { #endif +#if __has_builtin(__builtin_clzc) +#define __ez80_clzc __builtin_clzc +#else unsigned char __ez80_clzc(unsigned char) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_clzi48) +#define __ez80_clzi48 __builtin_clzi48 +#else unsigned char __ez80_clzi48(unsigned __int48) __NOEXCEPT_CONST; +#endif +#if __has_builtin(__builtin_ctzc) +#define __ez80_ctzc __builtin_ctzc +#else unsigned char __ez80_ctzc(unsigned char) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_ctzi48) +#define __ez80_ctzi48 __builtin_ctzi48 +#else unsigned char __ez80_ctzi48(unsigned __int48) __NOEXCEPT_CONST; +#endif +#if __has_builtin(__builtin_ffsc) +#define __ez80_ffsc __builtin_ffsc +#else unsigned char __ez80_ffsc(unsigned char) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_ffss) +#define __ez80_ffss __builtin_ffss +#else unsigned char __ez80_ffss(unsigned short) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_ffsi48) +#define __ez80_ffsi48 __builtin_ffsi48 +#else unsigned char __ez80_ffsi48(unsigned __int48) __NOEXCEPT_CONST; +#endif +#if __has_builtin(__builtin_clrsbc) +#define __ez80_clrsbc __builtin_clrsbc +#else unsigned char __ez80_clrsbc(unsigned char) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_clrsbs) +#define __ez80_clrsbs __builtin_clrsbs +#else unsigned char __ez80_clrsbs(unsigned short) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_clrsbi48) +#define __ez80_clrsbi48 __builtin_clrsbi48 +#else unsigned char __ez80_clrsbi48(unsigned __int48) __NOEXCEPT_CONST; +#endif +#if __has_builtin(__builtin_parityc) +#define __ez80_parityc __builtin_parityc +#else bool __ez80_parityc(unsigned char) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_paritys) +#define __ez80_paritys __builtin_paritys +#else bool __ez80_paritys(unsigned short) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_parityi48) +#define __ez80_parityi48 __builtin_parityi48 +#else bool __ez80_parityi48(unsigned __int48) __NOEXCEPT_CONST; +#endif +#if __has_builtin(__builtin_popcountc) +#define __ez80_popcountc __builtin_popcountc +#else unsigned char __ez80_popcountc(unsigned char) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_popcounts) +#define __ez80_popcounts __builtin_popcounts +#else unsigned char __ez80_popcounts(unsigned short) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_popcounti48) +#define __ez80_popcounti48 __builtin_popcounti48 +#else unsigned char __ez80_popcounti48(unsigned __int48) __NOEXCEPT_CONST; +#endif +#if __has_builtin(__builtin_bswap24) +#define __ez80_bswap24 __builtin_bswap24 +#else unsigned int __ez80_bswap24(unsigned int) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_bswap48) +#define __ez80_bswap48 __builtin_bswap48 +#else unsigned __int48 __ez80_bswap48(unsigned __int48) __NOEXCEPT_CONST; +#endif +#if __has_builtin(__builtin_bitreverse24) +#define __ez80_bitreverse24 __builtin_bitreverse24 +#else unsigned int __ez80_bitreverse24(unsigned int) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_bitreverse48) +#define __ez80_bitreverse48 __builtin_bitreverse48 +#else unsigned __int48 __ez80_bitreverse48(unsigned __int48) __NOEXCEPT_CONST; +#endif +#if __has_builtin(__builtin_rotateleft24) +#define __ez80_rotateleft24 __builtin_rotateleft24 +#else unsigned int __ez80_rotateleft24(unsigned int, unsigned char) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_rotateleft48) +#define __ez80_rotateleft48 __builtin_rotateleft48 +#else unsigned __int48 __ez80_rotateleft48(unsigned __int48, unsigned char) __NOEXCEPT_CONST; +#endif +#if __has_builtin(__builtin_rotateright24) +#define __ez80_rotateright24 __builtin_rotateright24 +#else unsigned int __ez80_rotateright24(unsigned int, unsigned char) __NOEXCEPT_CONST; +#endif + +#if __has_builtin(__builtin_rotateright48) +#define __ez80_rotateright48 __builtin_rotateright48 +#else unsigned __int48 __ez80_rotateright48(unsigned __int48, unsigned char) __NOEXCEPT_CONST; +#endif #ifdef __cplusplus } diff --git a/src/libc/include/stdbit.h b/src/libc/include/stdbit.h index 675cb65cc..e56696d1f 100644 --- a/src/libc/include/stdbit.h +++ b/src/libc/include/stdbit.h @@ -9,198 +9,1024 @@ extern "C" { #endif -// #define __STDC_VERSION_STDBIT_H__ 202311L +#define __STDC_VERSION_STDBIT_H__ 202311L #define __STDC_ENDIAN_LITTLE__ __ORDER_LITTLE_ENDIAN__ #define __STDC_ENDIAN_BIG__ __ORDER_BIG_ENDIAN__ #define __STDC_ENDIAN_NATIVE__ __BYTE_ORDER__ +//------------------------------------------------------------------------------ +// prototypes +//------------------------------------------------------------------------------ + +unsigned int stdc_leading_zeros_uc(unsigned char) __NOEXCEPT_CONST; +unsigned int stdc_leading_zeros_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_leading_zeros_ui(unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_leading_zeros_ul(unsigned long) __NOEXCEPT_CONST; +unsigned int stdc_leading_zeros_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned int stdc_leading_zeros_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned int stdc_leading_ones_uc(unsigned char) __NOEXCEPT_CONST; +unsigned int stdc_leading_ones_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_leading_ones_ui(unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_leading_ones_ul(unsigned long) __NOEXCEPT_CONST; +unsigned int stdc_leading_ones_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned int stdc_leading_ones_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned int stdc_trailing_zeros_uc(unsigned char) __NOEXCEPT_CONST; +unsigned int stdc_trailing_zeros_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_trailing_zeros_ui(unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_trailing_zeros_ul(unsigned long) __NOEXCEPT_CONST; +unsigned int stdc_trailing_zeros_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned int stdc_trailing_zeros_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned int stdc_trailing_ones_uc(unsigned char) __NOEXCEPT_CONST; +unsigned int stdc_trailing_ones_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_trailing_ones_ui(unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_trailing_ones_ul(unsigned long) __NOEXCEPT_CONST; +unsigned int stdc_trailing_ones_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned int stdc_trailing_ones_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned int stdc_first_leading_zero_uc(unsigned char) __NOEXCEPT_CONST; +unsigned int stdc_first_leading_zero_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_first_leading_zero_ui(unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_first_leading_zero_ul(unsigned long) __NOEXCEPT_CONST; +unsigned int stdc_first_leading_zero_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned int stdc_first_leading_zero_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned int stdc_first_leading_one_uc(unsigned char) __NOEXCEPT_CONST; +unsigned int stdc_first_leading_one_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_first_leading_one_ui(unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_first_leading_one_ul(unsigned long) __NOEXCEPT_CONST; +unsigned int stdc_first_leading_one_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned int stdc_first_leading_one_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned int stdc_first_trailing_zero_uc(unsigned char) __NOEXCEPT_CONST; +unsigned int stdc_first_trailing_zero_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_first_trailing_zero_ui(unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_first_trailing_zero_ul(unsigned long) __NOEXCEPT_CONST; +unsigned int stdc_first_trailing_zero_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned int stdc_first_trailing_zero_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned int stdc_first_trailing_one_uc(unsigned char) __NOEXCEPT_CONST; +unsigned int stdc_first_trailing_one_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_first_trailing_one_ui(unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_first_trailing_one_ul(unsigned long) __NOEXCEPT_CONST; +unsigned int stdc_first_trailing_one_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned int stdc_first_trailing_one_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned int stdc_count_zeros_uc(unsigned char) __NOEXCEPT_CONST; +unsigned int stdc_count_zeros_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_count_zeros_ui(unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_count_zeros_ul(unsigned long) __NOEXCEPT_CONST; +unsigned int stdc_count_zeros_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned int stdc_count_zeros_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned int stdc_count_ones_uc(unsigned char) __NOEXCEPT_CONST; +unsigned int stdc_count_ones_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_count_ones_ui(unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_count_ones_ul(unsigned long) __NOEXCEPT_CONST; +unsigned int stdc_count_ones_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned int stdc_count_ones_ull(unsigned long long) __NOEXCEPT_CONST; + +bool stdc_has_single_bit_uc(unsigned char) __NOEXCEPT_CONST; +bool stdc_has_single_bit_us(unsigned short) __NOEXCEPT_CONST; +bool stdc_has_single_bit_ui(unsigned int) __NOEXCEPT_CONST; +bool stdc_has_single_bit_ul(unsigned long) __NOEXCEPT_CONST; +bool stdc_has_single_bit_ui48(unsigned __int48) __NOEXCEPT_CONST; +bool stdc_has_single_bit_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned int stdc_bit_width_uc(unsigned char) __NOEXCEPT_CONST; +unsigned int stdc_bit_width_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_bit_width_ui(unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_bit_width_ul(unsigned long) __NOEXCEPT_CONST; +unsigned int stdc_bit_width_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned int stdc_bit_width_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned char stdc_bit_floor_uc(unsigned char) __NOEXCEPT_CONST; +unsigned short stdc_bit_floor_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_bit_floor_ui(unsigned int) __NOEXCEPT_CONST; +unsigned long stdc_bit_floor_ul(unsigned long) __NOEXCEPT_CONST; +unsigned __int48 stdc_bit_floor_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned long long stdc_bit_floor_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned char stdc_bit_ceil_uc(unsigned char) __NOEXCEPT_CONST; +unsigned short stdc_bit_ceil_us(unsigned short) __NOEXCEPT_CONST; +unsigned int stdc_bit_ceil_ui(unsigned int) __NOEXCEPT_CONST; +unsigned long stdc_bit_ceil_ul(unsigned long) __NOEXCEPT_CONST; +unsigned __int48 stdc_bit_ceil_ui48(unsigned __int48) __NOEXCEPT_CONST; +unsigned long long stdc_bit_ceil_ull(unsigned long long) __NOEXCEPT_CONST; + +unsigned char stdc_rotate_left_uc(unsigned char, unsigned int) __NOEXCEPT_CONST; +unsigned short stdc_rotate_left_us(unsigned short, unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_rotate_left_ui(unsigned int, unsigned int) __NOEXCEPT_CONST; +unsigned long stdc_rotate_left_ul(unsigned long, unsigned int) __NOEXCEPT_CONST; +unsigned __int48 stdc_rotate_left_ui48(unsigned __int48, unsigned int) __NOEXCEPT_CONST; +unsigned long long stdc_rotate_left_ull(unsigned long long, unsigned int) __NOEXCEPT_CONST; + +unsigned char stdc_rotate_right_uc(unsigned char, unsigned int) __NOEXCEPT_CONST; +unsigned short stdc_rotate_right_us(unsigned short, unsigned int) __NOEXCEPT_CONST; +unsigned int stdc_rotate_right_ui(unsigned int, unsigned int) __NOEXCEPT_CONST; +unsigned long stdc_rotate_right_ul(unsigned long, unsigned int) __NOEXCEPT_CONST; +unsigned __int48 stdc_rotate_right_ui48(unsigned __int48, unsigned int) __NOEXCEPT_CONST; +unsigned long long stdc_rotate_right_ull(unsigned long long, unsigned int) __NOEXCEPT_CONST; + //------------------------------------------------------------------------------ // stdc_leading_zeros //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned int __stdc_leading_zeros_uc(unsigned char __x) { + return __ez80_clzc(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_leading_zeros_us(unsigned short __x) { + return __builtin_clzs(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_leading_zeros_ui(unsigned int __x) { + return __builtin_clz(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_leading_zeros_ul(unsigned long __x) { + return __builtin_clzl(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_leading_zeros_ui48(unsigned __int48 __x) { + return __ez80_clzi48(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_leading_zeros_ull(unsigned long long __x) { + return __builtin_clzll(__x); +} + #define stdc_leading_zeros_uc(x) \ -__ez80_clzc(x) +__stdc_leading_zeros_uc(x) #define stdc_leading_zeros_us(x) \ -__builtin_clzs(x) +__stdc_leading_zeros_us(x) #define stdc_leading_zeros_ui(x) \ -__builtin_clz(x) +__stdc_leading_zeros_ui(x) #define stdc_leading_zeros_ul(x) \ -__builtin_clzl(x) +__stdc_leading_zeros_ul(x) #define stdc_leading_zeros_ui48(x) \ -__ez80_clzi48(x) +__stdc_leading_zeros_ui48(x) #define stdc_leading_zeros_ull(x) \ -__builtin_clzll(x) +__stdc_leading_zeros_ull(x) + +#define stdc_leading_zeros(x) _Generic((x), \ + unsigned char: __stdc_leading_zeros_uc, \ + unsigned short: __stdc_leading_zeros_us, \ + unsigned int: __stdc_leading_zeros_ui, \ + unsigned long: __stdc_leading_zeros_ul, \ + unsigned __int48: __stdc_leading_zeros_ui48, \ + unsigned long long: __stdc_leading_zeros_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_leading_ones //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned int __stdc_leading_ones_uc(unsigned char __x) { + return __stdc_leading_zeros_uc(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_leading_ones_us(unsigned short __x) { + return __stdc_leading_zeros_us(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_leading_ones_ui(unsigned int __x) { + return __stdc_leading_zeros_ui(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_leading_ones_ul(unsigned long __x) { + return __stdc_leading_zeros_ul(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_leading_ones_ui48(unsigned __int48 __x) { + return __stdc_leading_zeros_ui48(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_leading_ones_ull(unsigned long long __x) { + return __stdc_leading_zeros_ull(~__x); +} + +#define stdc_leading_ones_uc(x) \ +__stdc_leading_ones_uc(x) + +#define stdc_leading_ones_us(x) \ +__stdc_leading_ones_us(x) + +#define stdc_leading_ones_ui(x) \ +__stdc_leading_ones_ui(x) + +#define stdc_leading_ones_ul(x) \ +__stdc_leading_ones_ul(x) + +#define stdc_leading_ones_ui48(x) \ +__stdc_leading_ones_ui48(x) +#define stdc_leading_ones_ull(x) \ +__stdc_leading_ones_ull(x) + +#define stdc_leading_ones(x) _Generic((x), \ + unsigned char: __stdc_leading_ones_uc, \ + unsigned short: __stdc_leading_ones_us, \ + unsigned int: __stdc_leading_ones_ui, \ + unsigned long: __stdc_leading_ones_ul, \ + unsigned __int48: __stdc_leading_ones_ui48, \ + unsigned long long: __stdc_leading_ones_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_trailing_zeros //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned int __stdc_trailing_zeros_uc(unsigned char __x) { + return __ez80_ctzc(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_trailing_zeros_us(unsigned short __x) { + return __builtin_ctzs(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_trailing_zeros_ui(unsigned int __x) { + return __builtin_ctz(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_trailing_zeros_ul(unsigned long __x) { + return __builtin_ctzl(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_trailing_zeros_ui48(unsigned __int48 __x) { + return __ez80_ctzi48(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_trailing_zeros_ull(unsigned long long __x) { + return __builtin_ctzll(__x); +} + #define stdc_trailing_zeros_uc(x) \ -__ez80_ctzc(x) +__stdc_trailing_zeros_uc(x) #define stdc_trailing_zeros_us(x) \ -__builtin_ctzs(x) +__stdc_trailing_zeros_us(x) #define stdc_trailing_zeros_ui(x) \ -__builtin_ctz(x) +__stdc_trailing_zeros_ui(x) #define stdc_trailing_zeros_ul(x) \ -__builtin_ctzl(x) +__stdc_trailing_zeros_ul(x) #define stdc_trailing_zeros_ui48(x) \ -__ez80_ctzi48(x) +__stdc_trailing_zeros_ui48(x) #define stdc_trailing_zeros_ull(x) \ -__builtin_ctzll(x) +__stdc_trailing_zeros_ull(x) + +#define stdc_trailing_zeros(x) _Generic((x), \ + unsigned char: __stdc_trailing_zeros_uc, \ + unsigned short: __stdc_trailing_zeros_us, \ + unsigned int: __stdc_trailing_zeros_ui, \ + unsigned long: __stdc_trailing_zeros_ul, \ + unsigned __int48: __stdc_trailing_zeros_ui48, \ + unsigned long long: __stdc_trailing_zeros_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_trailing_ones //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned int __stdc_trailing_ones_uc(unsigned char __x) { + return __stdc_trailing_zeros_uc(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_trailing_ones_us(unsigned short __x) { + return __stdc_trailing_zeros_us(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_trailing_ones_ui(unsigned int __x) { + return __stdc_trailing_zeros_ui(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_trailing_ones_ul(unsigned long __x) { + return __stdc_trailing_zeros_ul(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_trailing_ones_ui48(unsigned __int48 __x) { + return __stdc_trailing_zeros_ui48(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_trailing_ones_ull(unsigned long long __x) { + return __stdc_trailing_zeros_ull(~__x); +} + +#define stdc_trailing_ones_uc(x) \ +__stdc_trailing_ones_uc(x) + +#define stdc_trailing_ones_us(x) \ +__stdc_trailing_ones_us(x) +#define stdc_trailing_ones_ui(x) \ +__stdc_trailing_ones_ui(x) + +#define stdc_trailing_ones_ul(x) \ +__stdc_trailing_ones_ul(x) + +#define stdc_trailing_ones_ui48(x) \ +__stdc_trailing_ones_ui48(x) + +#define stdc_trailing_ones_ull(x) \ +__stdc_trailing_ones_ull(x) + +#define stdc_trailing_ones(x) _Generic((x), \ + unsigned char: __stdc_trailing_ones_uc, \ + unsigned short: __stdc_trailing_ones_us, \ + unsigned int: __stdc_trailing_ones_ui, \ + unsigned long: __stdc_trailing_ones_ul, \ + unsigned __int48: __stdc_trailing_ones_ui48, \ + unsigned long long: __stdc_trailing_ones_ull \ +)(x) + +//------------------------------------------------------------------------------ +// stdc_first_leading_one +//------------------------------------------------------------------------------ + +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_leading_one_uc(unsigned char __x) { + return (__x == 0) ? 0 : (__stdc_leading_zeros_uc(__x) + 1); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_leading_one_us(unsigned short __x) { + return (__x == 0) ? 0 : (__stdc_leading_zeros_us(__x) + 1); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_leading_one_ui(unsigned int __x) { + return (__x == 0) ? 0 : (__stdc_leading_zeros_ui(__x) + 1); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_leading_one_ul(unsigned long __x) { + return (__x == 0) ? 0 : (__stdc_leading_zeros_ul(__x) + 1); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_leading_one_ui48(unsigned __int48 __x) { + return (__x == 0) ? 0 : (__stdc_leading_zeros_ui48(__x) + 1); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_leading_one_ull(unsigned long long __x) { + return (__x == 0) ? 0 : (__stdc_leading_zeros_ull(__x) + 1); +} + +#define stdc_first_leading_one_uc(x) \ +__stdc_first_leading_one_uc(x) + +#define stdc_first_leading_one_us(x) \ +__stdc_first_leading_one_us(x) + +#define stdc_first_leading_one_ui(x) \ +__stdc_first_leading_one_ui(x) + +#define stdc_first_leading_one_ul(x) \ +__stdc_first_leading_one_ul(x) + +#define stdc_first_leading_one_ui48(x) \ +__stdc_first_leading_one_ui48(x) + +#define stdc_first_leading_one_ull(x) \ +__stdc_first_leading_one_ull(x) + +#define stdc_first_leading_one(x) _Generic((x), \ + unsigned char: __stdc_first_leading_one_uc, \ + unsigned short: __stdc_first_leading_one_us, \ + unsigned int: __stdc_first_leading_one_ui, \ + unsigned long: __stdc_first_leading_one_ul, \ + unsigned __int48: __stdc_first_leading_one_ui48, \ + unsigned long long: __stdc_first_leading_one_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_first_leading_zero //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_leading_zero_uc(unsigned char __x) { + return __stdc_first_leading_one_uc(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_leading_zero_us(unsigned short __x) { + return __stdc_first_leading_one_us(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_leading_zero_ui(unsigned int __x) { + return __stdc_first_leading_one_ui(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_leading_zero_ul(unsigned long __x) { + return __stdc_first_leading_one_ul(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_leading_zero_ui48(unsigned __int48 __x) { + return __stdc_first_leading_one_ui48(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_leading_zero_ull(unsigned long long __x) { + return __stdc_first_leading_one_ull(~__x); +} + +#define stdc_first_leading_zero_uc(x) \ +__stdc_first_leading_zero_uc(x) + +#define stdc_first_leading_zero_us(x) \ +__stdc_first_leading_zero_us(x) + +#define stdc_first_leading_zero_ui(x) \ +__stdc_first_leading_zero_ui(x) + +#define stdc_first_leading_zero_ul(x) \ +__stdc_first_leading_zero_ul(x) + +#define stdc_first_leading_zero_ui48(x) \ +__stdc_first_leading_zero_ui48(x) + +#define stdc_first_leading_zero_ull(x) \ +__stdc_first_leading_zero_ull(x) +#define stdc_first_leading_zero(x) _Generic((x), \ + unsigned char: __stdc_first_leading_zero_uc, \ + unsigned short: __stdc_first_leading_zero_us, \ + unsigned int: __stdc_first_leading_zero_ui, \ + unsigned long: __stdc_first_leading_zero_ul, \ + unsigned __int48: __stdc_first_leading_zero_ui48, \ + unsigned long long: __stdc_first_leading_zero_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_first_trailing_one //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_trailing_one_uc(unsigned char __x) { + return __ez80_ffsc(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_trailing_one_us(unsigned short __x) { + return __ez80_ffss(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_trailing_one_ui(unsigned int __x) { + return __builtin_ffs(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_trailing_one_ul(unsigned long __x) { + return __builtin_ffsl(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_trailing_one_ui48(unsigned __int48 __x) { + return __ez80_ffsi48(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_trailing_one_ull(unsigned long long __x) { + return __builtin_ffsll(__x); +} + #define stdc_first_trailing_one_uc(x) \ -__ez80_ffsc(x) +__stdc_first_trailing_one_uc(x) #define stdc_first_trailing_one_us(x) \ -__ez80_ffss(x) +__stdc_first_trailing_one_us(x) #define stdc_first_trailing_one_ui(x) \ -__builtin_ffs(x) +__stdc_first_trailing_one_ui(x) #define stdc_first_trailing_one_ul(x) \ -__builtin_ffsl(x) +__stdc_first_trailing_one_ul(x) #define stdc_first_trailing_one_ui48(x) \ -__ez80_ffsi48(x) +__stdc_first_trailing_one_ui48(x) #define stdc_first_trailing_one_ull(x) \ -__builtin_ffsll(x) +__stdc_first_trailing_one_ull(x) + +#define stdc_first_trailing_one(x) _Generic((x), \ + unsigned char: __stdc_first_trailing_one_uc, \ + unsigned short: __stdc_first_trailing_one_us, \ + unsigned int: __stdc_first_trailing_one_ui, \ + unsigned long: __stdc_first_trailing_one_ul, \ + unsigned __int48: __stdc_first_trailing_one_ui48, \ + unsigned long long: __stdc_first_trailing_one_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_first_trailing_zero //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_trailing_zero_uc(unsigned char __x) { + return __stdc_first_trailing_one_uc(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_trailing_zero_us(unsigned short __x) { + return __stdc_first_trailing_one_us(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_trailing_zero_ui(unsigned int __x) { + return __stdc_first_trailing_one_ui(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_trailing_zero_ul(unsigned long __x) { + return __stdc_first_trailing_one_ul(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_trailing_zero_ui48(unsigned __int48 __x) { + return __stdc_first_trailing_one_ui48(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_first_trailing_zero_ull(unsigned long long __x) { + return __stdc_first_trailing_one_ull(~__x); +} + +#define stdc_first_trailing_zero_uc(x) \ +__stdc_first_trailing_zero_uc(x) + +#define stdc_first_trailing_zero_us(x) \ +__stdc_first_trailing_zero_us(x) +#define stdc_first_trailing_zero_ui(x) \ +__stdc_first_trailing_zero_ui(x) + +#define stdc_first_trailing_zero_ul(x) \ +__stdc_first_trailing_zero_ul(x) + +#define stdc_first_trailing_zero_ui48(x) \ +__stdc_first_trailing_zero_ui48(x) + +#define stdc_first_trailing_zero_ull(x) \ +__stdc_first_trailing_zero_ull(x) + +#define stdc_first_trailing_zero(x) _Generic((x), \ + unsigned char: __stdc_first_trailing_zero_uc, \ + unsigned short: __stdc_first_trailing_zero_us, \ + unsigned int: __stdc_first_trailing_zero_ui, \ + unsigned long: __stdc_first_trailing_zero_ul, \ + unsigned __int48: __stdc_first_trailing_zero_ui48, \ + unsigned long long: __stdc_first_trailing_zero_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_count_ones //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned int __stdc_count_ones_uc(unsigned char __x) { + return __ez80_popcountc(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_count_ones_us(unsigned short __x) { + return __ez80_popcounts(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_count_ones_ui(unsigned int __x) { + return __builtin_popcount(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_count_ones_ul(unsigned long __x) { + return __builtin_popcountl(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_count_ones_ui48(unsigned __int48 __x) { + return __ez80_popcounti48(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_count_ones_ull(unsigned long long __x) { + return __builtin_popcountll(__x); +} + #define stdc_count_ones_uc(x) \ -__ez80_popcountc(x) +__stdc_count_ones_uc(x) #define stdc_count_ones_us(x) \ -__ez80_popcounts(x) +__stdc_count_ones_us(x) #define stdc_count_ones_ui(x) \ -__builtin_popcount(x) +__stdc_count_ones_ui(x) #define stdc_count_ones_ul(x) \ -__builtin_popcountl(x) +__stdc_count_ones_ul(x) #define stdc_count_ones_ui48(x) \ -__ez80_popcounti48(x) +__stdc_count_ones_ui48(x) #define stdc_count_ones_ull(x) \ -__builtin_popcountll(x) +__stdc_count_ones_ull(x) + +#define stdc_count_ones(x) _Generic((x), \ + unsigned char: __stdc_count_ones_uc, \ + unsigned short: __stdc_count_ones_us, \ + unsigned int: __stdc_count_ones_ui, \ + unsigned long: __stdc_count_ones_ul, \ + unsigned __int48: __stdc_count_ones_ui48, \ + unsigned long long: __stdc_count_ones_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_count_zeros //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned int __stdc_count_zeros_uc(unsigned char __x) { + return __stdc_count_ones_uc(~__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_count_zeros_us(unsigned short __x) { + return 16 - __stdc_count_ones_us(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_count_zeros_ui(unsigned int __x) { + return 24 - __stdc_count_ones_ui(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_count_zeros_ul(unsigned long __x) { + return 32 - __stdc_count_ones_ul(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_count_zeros_ui48(unsigned __int48 __x) { + return 48 - __stdc_count_ones_ui48(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_count_zeros_ull(unsigned long long __x) { + return 64 - __stdc_count_ones_ull(__x); +} + +#define stdc_count_zeros_uc(x) \ +__stdc_count_zeros_uc(x) + +#define stdc_count_zeros_us(x) \ +__stdc_count_zeros_us(x) + +#define stdc_count_zeros_ui(x) \ +__stdc_count_zeros_ui(x) + +#define stdc_count_zeros_ul(x) \ +__stdc_count_zeros_ul(x) +#define stdc_count_zeros_ui48(x) \ +__stdc_count_zeros_ui48(x) + +#define stdc_count_zeros_ull(x) \ +__stdc_count_zeros_ull(x) + +#define stdc_count_zeros(x) _Generic((x), \ + unsigned char: __stdc_count_zeros_uc, \ + unsigned short: __stdc_count_zeros_us, \ + unsigned int: __stdc_count_zeros_ui, \ + unsigned long: __stdc_count_zeros_ul, \ + unsigned __int48: __stdc_count_zeros_ui48, \ + unsigned long long: __stdc_count_zeros_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_has_single_bit //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +bool __stdc_has_single_bit_uc(unsigned char __x) { + return (__x != 0 && (__x & (__x - 1)) == 0); +} +static inline __attribute__((__always_inline__)) +bool __stdc_has_single_bit_us(unsigned short __x) { + return (__x != 0 && (__x & (__x - 1)) == 0); +} +static inline __attribute__((__always_inline__)) +bool __stdc_has_single_bit_ui(unsigned int __x) { + return (__x != 0 && (__x & (__x - 1)) == 0); +} +static inline __attribute__((__always_inline__)) +bool __stdc_has_single_bit_ul(unsigned long __x) { + return (__x != 0 && (__x & (__x - 1)) == 0); +} +static inline __attribute__((__always_inline__)) +bool __stdc_has_single_bit_ui48(unsigned __int48 __x) { + return (__x != 0 && (__x & (__x - 1)) == 0); +} +static inline __attribute__((__always_inline__)) +bool __stdc_has_single_bit_ull(unsigned long long __x) { + return (__x != 0 && (__x & (__x - 1)) == 0); +} + +#define stdc_has_single_bit_uc(x) \ +__stdc_has_single_bit_uc(x) + +#define stdc_has_single_bit_us(x) \ +__stdc_has_single_bit_us(x) + +#define stdc_has_single_bit_ui(x) \ +__stdc_has_single_bit_ui(x) +#define stdc_has_single_bit_ul(x) \ +__stdc_has_single_bit_ul(x) + +#define stdc_has_single_bit_ui48(x) \ +__stdc_has_single_bit_ui48(x) + +#define stdc_has_single_bit_ull(x) \ +__stdc_has_single_bit_ull(x) + +#define stdc_has_single_bit(x) _Generic((x), \ + unsigned char: __stdc_has_single_bit_uc, \ + unsigned short: __stdc_has_single_bit_us, \ + unsigned int: __stdc_has_single_bit_ui, \ + unsigned long: __stdc_has_single_bit_ul, \ + unsigned __int48: __stdc_has_single_bit_ui48, \ + unsigned long long: __stdc_has_single_bit_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_bit_width //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned int __stdc_bit_width_uc(unsigned char __x) { + return 8 - __stdc_leading_zeros_uc(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_bit_width_us(unsigned short __x) { + return 16 - __stdc_leading_zeros_us(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_bit_width_ui(unsigned int __x) { + return 24 - __stdc_leading_zeros_ui(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_bit_width_ul(unsigned long __x) { + return 32 - __stdc_leading_zeros_ul(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_bit_width_ui48(unsigned __int48 __x) { + return 48 - __stdc_leading_zeros_ui48(__x); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_bit_width_ull(unsigned long long __x) { + return 64 - __stdc_leading_zeros_ull(__x); +} + +#define stdc_bit_width_uc(x) \ +__stdc_bit_width_uc(x) + +#define stdc_bit_width_us(x) \ +__stdc_bit_width_us(x) +#define stdc_bit_width_ui(x) \ +__stdc_bit_width_ui(x) +#define stdc_bit_width_ul(x) \ +__stdc_bit_width_ul(x) + +#define stdc_bit_width_ui48(x) \ +__stdc_bit_width_ui48(x) + +#define stdc_bit_width_ull(x) \ +__stdc_bit_width_ull(x) + +#define stdc_bit_width(x) _Generic((x), \ + unsigned char: __stdc_bit_width_uc, \ + unsigned short: __stdc_bit_width_us, \ + unsigned int: __stdc_bit_width_ui, \ + unsigned long: __stdc_bit_width_ul, \ + unsigned __int48: __stdc_bit_width_ui48, \ + unsigned long long: __stdc_bit_width_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_bit_ceil //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned char __stdc_bit_ceil_uc(unsigned char __x) { + return ((__x < 2) ? 1 : ((unsigned char)(2) << (__stdc_bit_width_uc(__x - 1) - 1))); +} +static inline __attribute__((__always_inline__)) +unsigned short __stdc_bit_ceil_us(unsigned short __x) { + return ((__x < 2) ? 1 : ((unsigned short)(2) << (__stdc_bit_width_us(__x - 1) - 1))); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_bit_ceil_ui(unsigned int __x) { + return ((__x < 2) ? 1 : ((unsigned int)(2) << (__stdc_bit_width_ui(__x - 1) - 1))); +} +static inline __attribute__((__always_inline__)) +unsigned long __stdc_bit_ceil_ul(unsigned long __x) { + return ((__x < 2) ? 1 : ((unsigned long)(2) << (__stdc_bit_width_ul(__x - 1) - 1))); +} +static inline __attribute__((__always_inline__)) +unsigned __int48 __stdc_bit_ceil_ui48(unsigned __int48 __x) { + return ((__x < 2) ? 1 : ((unsigned __int48)(2) << (__stdc_bit_width_ui48(__x - 1) - 1))); +} +static inline __attribute__((__always_inline__)) +unsigned long long __stdc_bit_ceil_ull(unsigned long long __x) { + return ((__x < 2) ? 1 : ((unsigned long long)(2) << (__stdc_bit_width_ull(__x - 1) - 1))); +} + +#define stdc_bit_ceil_uc(x) \ +__stdc_bit_ceil_uc(x) + +#define stdc_bit_ceil_us(x) \ +__stdc_bit_ceil_us(x) +#define stdc_bit_ceil_ui(x) \ +__stdc_bit_ceil_ui(x) + +#define stdc_bit_ceil_ul(x) \ +__stdc_bit_ceil_ul(x) + +#define stdc_bit_ceil_ui48(x) \ +__stdc_bit_ceil_ui48(x) + +#define stdc_bit_ceil_ull(x) \ +__stdc_bit_ceil_ull(x) + +#define stdc_bit_ceil(x) _Generic((x), \ + unsigned char: __stdc_bit_ceil_uc, \ + unsigned short: __stdc_bit_ceil_us, \ + unsigned int: __stdc_bit_ceil_ui, \ + unsigned long: __stdc_bit_ceil_ul, \ + unsigned __int48: __stdc_bit_ceil_ui48, \ + unsigned long long: __stdc_bit_ceil_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_bit_floor //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned char __stdc_bit_floor_uc(unsigned char __x) { + return (__x == 0) ? 0 : ((unsigned char)(1) << (__stdc_bit_width_uc(__x) - 1)); +} +static inline __attribute__((__always_inline__)) +unsigned short __stdc_bit_floor_us(unsigned short __x) { + return (__x == 0) ? 0 : ((unsigned short)(1) << (__stdc_bit_width_us(__x) - 1)); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_bit_floor_ui(unsigned int __x) { + return (__x == 0) ? 0 : ((unsigned int)(1) << (__stdc_bit_width_ui(__x) - 1)); +} +static inline __attribute__((__always_inline__)) +unsigned long __stdc_bit_floor_ul(unsigned long __x) { + return (__x == 0) ? 0 : ((unsigned long)(1) << (__stdc_bit_width_ul(__x) - 1)); +} +static inline __attribute__((__always_inline__)) +unsigned __int48 __stdc_bit_floor_ui48(unsigned __int48 __x) { + return (__x == 0) ? 0 : ((unsigned __int48)(1) << (__stdc_bit_width_ui48(__x) - 1)); +} +static inline __attribute__((__always_inline__)) +unsigned long long __stdc_bit_floor_ull(unsigned long long __x) { + return (__x == 0) ? 0 : ((unsigned long long)(1) << (__stdc_bit_width_ull(__x) - 1)); +} + +#define stdc_bit_floor_uc(x) \ +__stdc_bit_floor_uc(x) +#define stdc_bit_floor_us(x) \ +__stdc_bit_floor_us(x) + +#define stdc_bit_floor_ui(x) \ +__stdc_bit_floor_ui(x) + +#define stdc_bit_floor_ul(x) \ +__stdc_bit_floor_ul(x) + +#define stdc_bit_floor_ui48(x) \ +__stdc_bit_floor_ui48(x) + +#define stdc_bit_floor_ull(x) \ +__stdc_bit_floor_ull(x) + +#define stdc_bit_floor(x) _Generic((x), \ + unsigned char: __stdc_bit_floor_uc, \ + unsigned short: __stdc_bit_floor_us, \ + unsigned int: __stdc_bit_floor_ui, \ + unsigned long: __stdc_bit_floor_ul, \ + unsigned __int48: __stdc_bit_floor_ui48, \ + unsigned long long: __stdc_bit_floor_ull \ +)(x) //------------------------------------------------------------------------------ // stdc_rotate_left //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned char __stdc_rotate_left_uc(unsigned char __x, unsigned int __s) { + return __builtin_rotateleft8(__x, (unsigned char)__s); +} +static inline __attribute__((__always_inline__)) +unsigned short __stdc_rotate_left_us(unsigned short __x, unsigned int __s) { + return __builtin_rotateleft16(__x, (unsigned char)__s); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_rotate_left_ui(unsigned int __x, unsigned int __s) { + return __ez80_rotateleft24(__x, (unsigned char)__s); +} +static inline __attribute__((__always_inline__)) +unsigned long __stdc_rotate_left_ul(unsigned long __x, unsigned int __s) { + return __builtin_rotateleft32(__x, (unsigned char)__s); +} +static inline __attribute__((__always_inline__)) +unsigned __int48 __stdc_rotate_left_ui48(unsigned __int48 __x, unsigned int __s) { + return __ez80_rotateleft48(__x, (unsigned char)__s); +} +static inline __attribute__((__always_inline__)) +unsigned long long __stdc_rotate_left_ull(unsigned long long __x, unsigned int __s) { + return __builtin_rotateleft64(__x, (unsigned char)__s); +} + #define stdc_rotate_left_uc(x, s) \ -__builtin_rotateleft8(x, s) +__stdc_rotate_left_uc(x, s) #define stdc_rotate_left_us(x, s) \ -__builtin_rotateleft16(x, s) +__stdc_rotate_left_us(x, s) #define stdc_rotate_left_ui(x, s) \ -__ez80_rotateleft24(x, s) +__stdc_rotate_left_ui(x, s) #define stdc_rotate_left_ul(x, s) \ -__builtin_rotateleft32(x, s) +__stdc_rotate_left_ul(x, s) #define stdc_rotate_left_ui48(x, s) \ -__ez80_rotateleft48(x, s) +__stdc_rotate_left_ui48(x, s) #define stdc_rotate_left_ull(x, s) \ -__builtin_rotateleft64(x, s) +__stdc_rotate_left_ull(x, s) + +#define stdc_rotate_left(x, s) _Generic((x), \ + unsigned char: __stdc_rotate_left_uc, \ + unsigned short: __stdc_rotate_left_us, \ + unsigned int: __stdc_rotate_left_ui, \ + unsigned long: __stdc_rotate_left_ul, \ + unsigned __int48: __stdc_rotate_left_ui48, \ + unsigned long long: __stdc_rotate_left_ull \ +)(x, s) //------------------------------------------------------------------------------ // stdc_rotate_right //------------------------------------------------------------------------------ +static inline __attribute__((__always_inline__)) +unsigned char __stdc_rotate_right_uc(unsigned char __x, unsigned int __s) { + return __builtin_rotateright8(__x, __s); +} +static inline __attribute__((__always_inline__)) +unsigned short __stdc_rotate_right_us(unsigned short __x, unsigned int __s) { + return __builtin_rotateright16(__x, __s); +} +static inline __attribute__((__always_inline__)) +unsigned int __stdc_rotate_right_ui(unsigned int __x, unsigned int __s) { + return __ez80_rotateright24(__x, (unsigned char)__s); +} +static inline __attribute__((__always_inline__)) +unsigned long __stdc_rotate_right_ul(unsigned long __x, unsigned int __s) { + return __builtin_rotateright32(__x, __s); +} +static inline __attribute__((__always_inline__)) +unsigned __int48 __stdc_rotate_right_ui48(unsigned __int48 __x, unsigned int __s) { + return __ez80_rotateright48(__x, (unsigned char)__s); +} +static inline __attribute__((__always_inline__)) +unsigned long long __stdc_rotate_right_ull(unsigned long long __x, unsigned int __s) { + return __builtin_rotateright64(__x, __s); +} + #define stdc_rotate_right_uc(x, s) \ -__builtin_rotateright8(x, s) +__stdc_rotate_right_uc(x, s) #define stdc_rotate_right_us(x, s) \ -__builtin_rotateright16(x, s) +__stdc_rotate_right_us(x, s) #define stdc_rotate_right_ui(x, s) \ -__ez80_rotateright24(x, s) +__stdc_rotate_right_ui(x, s) #define stdc_rotate_right_ul(x, s) \ -__builtin_rotateright32(x, s) +__stdc_rotate_right_ul(x, s) #define stdc_rotate_right_ui48(x, s) \ -__ez80_rotateright48(x, s) +__stdc_rotate_right_ui48(x, s) #define stdc_rotate_right_ull(x, s) \ -__builtin_rotateright64(x, s) +__stdc_rotate_right_ull(x, s) + +#define stdc_rotate_right(x, s) _Generic((x), \ + unsigned char: __stdc_rotate_right_uc, \ + unsigned short: __stdc_rotate_right_us, \ + unsigned int: __stdc_rotate_right_ui, \ + unsigned long: __stdc_rotate_right_ul, \ + unsigned __int48: __stdc_rotate_right_ui48, \ + unsigned long long: __stdc_rotate_right_ull \ +)(x, s) + #ifdef __cplusplus } diff --git a/src/libc/stdbit.c b/src/libc/stdbit.c new file mode 100644 index 000000000..46f940202 --- /dev/null +++ b/src/libc/stdbit.c @@ -0,0 +1,417 @@ +#include + +#undef stdc_leading_zeros_uc +#undef stdc_leading_zeros_us +#undef stdc_leading_zeros_ui +#undef stdc_leading_zeros_ul +#undef stdc_leading_zeros_ui48 +#undef stdc_leading_zeros_ull + +#undef stdc_leading_ones_uc +#undef stdc_leading_ones_us +#undef stdc_leading_ones_ui +#undef stdc_leading_ones_ul +#undef stdc_leading_ones_ui48 +#undef stdc_leading_ones_ull + +#undef stdc_trailing_zeros_uc +#undef stdc_trailing_zeros_us +#undef stdc_trailing_zeros_ui +#undef stdc_trailing_zeros_ul +#undef stdc_trailing_zeros_ui48 +#undef stdc_trailing_zeros_ull + +#undef stdc_trailing_ones_uc +#undef stdc_trailing_ones_us +#undef stdc_trailing_ones_ui +#undef stdc_trailing_ones_ul +#undef stdc_trailing_ones_ui48 +#undef stdc_trailing_ones_ull + +#undef stdc_first_leading_zero_uc +#undef stdc_first_leading_zero_us +#undef stdc_first_leading_zero_ui +#undef stdc_first_leading_zero_ul +#undef stdc_first_leading_zero_ui48 +#undef stdc_first_leading_zero_ull + +#undef stdc_first_leading_one_uc +#undef stdc_first_leading_one_us +#undef stdc_first_leading_one_ui +#undef stdc_first_leading_one_ul +#undef stdc_first_leading_one_ui48 +#undef stdc_first_leading_one_ull + +#undef stdc_first_trailing_zero_uc +#undef stdc_first_trailing_zero_us +#undef stdc_first_trailing_zero_ui +#undef stdc_first_trailing_zero_ul +#undef stdc_first_trailing_zero_ui48 +#undef stdc_first_trailing_zero_ull + +#undef stdc_first_trailing_one_uc +#undef stdc_first_trailing_one_us +#undef stdc_first_trailing_one_ui +#undef stdc_first_trailing_one_ul +#undef stdc_first_trailing_one_ui48 +#undef stdc_first_trailing_one_ull + +#undef stdc_count_zeros_uc +#undef stdc_count_zeros_us +#undef stdc_count_zeros_ui +#undef stdc_count_zeros_ul +#undef stdc_count_zeros_ui48 +#undef stdc_count_zeros_ull + +#undef stdc_count_ones_uc +#undef stdc_count_ones_us +#undef stdc_count_ones_ui +#undef stdc_count_ones_ul +#undef stdc_count_ones_ui48 +#undef stdc_count_ones_ull + +#undef stdc_has_single_bit_uc +#undef stdc_has_single_bit_us +#undef stdc_has_single_bit_ui +#undef stdc_has_single_bit_ul +#undef stdc_has_single_bit_ui48 +#undef stdc_has_single_bit_ull + +#undef stdc_bit_width_uc +#undef stdc_bit_width_us +#undef stdc_bit_width_ui +#undef stdc_bit_width_ul +#undef stdc_bit_width_ui48 +#undef stdc_bit_width_ull + +#undef stdc_bit_floor_uc +#undef stdc_bit_floor_us +#undef stdc_bit_floor_ui +#undef stdc_bit_floor_ul +#undef stdc_bit_floor_ui48 +#undef stdc_bit_floor_ull + +#undef stdc_bit_ceil_uc +#undef stdc_bit_ceil_us +#undef stdc_bit_ceil_ui +#undef stdc_bit_ceil_ul +#undef stdc_bit_ceil_ui48 +#undef stdc_bit_ceil_ull + +#undef stdc_rotate_left_uc +#undef stdc_rotate_left_us +#undef stdc_rotate_left_ui +#undef stdc_rotate_left_ul +#undef stdc_rotate_left_ui48 +#undef stdc_rotate_left_ull + +#undef stdc_rotate_right_uc +#undef stdc_rotate_right_us +#undef stdc_rotate_right_ui +#undef stdc_rotate_right_ul +#undef stdc_rotate_right_ui48 +#undef stdc_rotate_right_ull + +unsigned int stdc_leading_zeros_uc(unsigned char __x) { + return __stdc_leading_zeros_uc(__x); +} +unsigned int stdc_leading_zeros_us(unsigned short __x) { + return __stdc_leading_zeros_us(__x); +} +unsigned int stdc_leading_zeros_ui(unsigned int __x) { + return __stdc_leading_zeros_ui(__x); +} +unsigned int stdc_leading_zeros_ul(unsigned long __x) { + return __stdc_leading_zeros_ul(__x); +} +unsigned int stdc_leading_zeros_ui48(unsigned __int48 __x) { + return __stdc_leading_zeros_ui48(__x); +} +unsigned int stdc_leading_zeros_ull(unsigned long long __x) { + return __stdc_leading_zeros_ull(__x); +} + +unsigned int stdc_leading_ones_uc(unsigned char __x) { + return __stdc_leading_ones_uc(__x); +} +unsigned int stdc_leading_ones_us(unsigned short __x) { + return __stdc_leading_ones_us(__x); +} +unsigned int stdc_leading_ones_ui(unsigned int __x) { + return __stdc_leading_ones_ui(__x); +} +unsigned int stdc_leading_ones_ul(unsigned long __x) { + return __stdc_leading_ones_ul(__x); +} +unsigned int stdc_leading_ones_ui48(unsigned __int48 __x) { + return __stdc_leading_ones_ui48(__x); +} +unsigned int stdc_leading_ones_ull(unsigned long long __x) { + return __stdc_leading_ones_ull(__x); +} + +unsigned int stdc_trailing_zeros_uc(unsigned char __x) { + return __stdc_trailing_zeros_uc(__x); +} +unsigned int stdc_trailing_zeros_us(unsigned short __x) { + return __stdc_trailing_zeros_us(__x); +} +unsigned int stdc_trailing_zeros_ui(unsigned int __x) { + return __stdc_trailing_zeros_ui(__x); +} +unsigned int stdc_trailing_zeros_ul(unsigned long __x) { + return __stdc_trailing_zeros_ul(__x); +} +unsigned int stdc_trailing_zeros_ui48(unsigned __int48 __x) { + return __stdc_trailing_zeros_ui48(__x); +} +unsigned int stdc_trailing_zeros_ull(unsigned long long __x) { + return __stdc_trailing_zeros_ull(__x); +} + +unsigned int stdc_trailing_ones_uc(unsigned char __x) { + return __stdc_trailing_ones_uc(__x); +} +unsigned int stdc_trailing_ones_us(unsigned short __x) { + return __stdc_trailing_ones_us(__x); +} +unsigned int stdc_trailing_ones_ui(unsigned int __x) { + return __stdc_trailing_ones_ui(__x); +} +unsigned int stdc_trailing_ones_ul(unsigned long __x) { + return __stdc_trailing_ones_ul(__x); +} +unsigned int stdc_trailing_ones_ui48(unsigned __int48 __x) { + return __stdc_trailing_ones_ui48(__x); +} +unsigned int stdc_trailing_ones_ull(unsigned long long __x) { + return __stdc_trailing_ones_ull(__x); +} + +unsigned int stdc_first_leading_zero_uc(unsigned char __x) { + return __stdc_first_leading_zero_uc(__x); +} +unsigned int stdc_first_leading_zero_us(unsigned short __x) { + return __stdc_first_leading_zero_us(__x); +} +unsigned int stdc_first_leading_zero_ui(unsigned int __x) { + return __stdc_first_leading_zero_ui(__x); +} +unsigned int stdc_first_leading_zero_ul(unsigned long __x) { + return __stdc_first_leading_zero_ul(__x); +} +unsigned int stdc_first_leading_zero_ui48(unsigned __int48 __x) { + return __stdc_first_leading_zero_ui48(__x); +} +unsigned int stdc_first_leading_zero_ull(unsigned long long __x) { + return __stdc_first_leading_zero_ull(__x); +} + +unsigned int stdc_first_leading_one_uc(unsigned char __x) { + return __stdc_first_leading_one_uc(__x); +} +unsigned int stdc_first_leading_one_us(unsigned short __x) { + return __stdc_first_leading_one_us(__x); +} +unsigned int stdc_first_leading_one_ui(unsigned int __x) { + return __stdc_first_leading_one_ui(__x); +} +unsigned int stdc_first_leading_one_ul(unsigned long __x) { + return __stdc_first_leading_one_ul(__x); +} +unsigned int stdc_first_leading_one_ui48(unsigned __int48 __x) { + return __stdc_first_leading_one_ui48(__x); +} +unsigned int stdc_first_leading_one_ull(unsigned long long __x) { + return __stdc_first_leading_one_ull(__x); +} + +unsigned int stdc_first_trailing_zero_uc(unsigned char __x) { + return __stdc_first_trailing_zero_uc(__x); +} +unsigned int stdc_first_trailing_zero_us(unsigned short __x) { + return __stdc_first_trailing_zero_us(__x); +} +unsigned int stdc_first_trailing_zero_ui(unsigned int __x) { + return __stdc_first_trailing_zero_ui(__x); +} +unsigned int stdc_first_trailing_zero_ul(unsigned long __x) { + return __stdc_first_trailing_zero_ul(__x); +} +unsigned int stdc_first_trailing_zero_ui48(unsigned __int48 __x) { + return __stdc_first_trailing_zero_ui48(__x); +} +unsigned int stdc_first_trailing_zero_ull(unsigned long long __x) { + return __stdc_first_trailing_zero_ull(__x); +} + +unsigned int stdc_first_trailing_one_uc(unsigned char __x) { + return __stdc_first_trailing_one_uc(__x); +} +unsigned int stdc_first_trailing_one_us(unsigned short __x) { + return __stdc_first_trailing_one_us(__x); +} +unsigned int stdc_first_trailing_one_ui(unsigned int __x) { + return __stdc_first_trailing_one_ui(__x); +} +unsigned int stdc_first_trailing_one_ul(unsigned long __x) { + return __stdc_first_trailing_one_ul(__x); +} +unsigned int stdc_first_trailing_one_ui48(unsigned __int48 __x) { + return __stdc_first_trailing_one_ui48(__x); +} +unsigned int stdc_first_trailing_one_ull(unsigned long long __x) { + return __stdc_first_trailing_one_ull(__x); +} + +unsigned int stdc_count_zeros_uc(unsigned char __x) { + return __stdc_count_zeros_uc(__x); +} +unsigned int stdc_count_zeros_us(unsigned short __x) { + return __stdc_count_zeros_us(__x); +} +unsigned int stdc_count_zeros_ui(unsigned int __x) { + return __stdc_count_zeros_ui(__x); +} +unsigned int stdc_count_zeros_ul(unsigned long __x) { + return __stdc_count_zeros_ul(__x); +} +unsigned int stdc_count_zeros_ui48(unsigned __int48 __x) { + return __stdc_count_zeros_ui48(__x); +} +unsigned int stdc_count_zeros_ull(unsigned long long __x) { + return __stdc_count_zeros_ull(__x); +} + +unsigned int stdc_count_ones_uc(unsigned char __x) { + return __stdc_count_ones_uc(__x); +} +unsigned int stdc_count_ones_us(unsigned short __x) { + return __stdc_count_ones_us(__x); +} +unsigned int stdc_count_ones_ui(unsigned int __x) { + return __stdc_count_ones_ui(__x); +} +unsigned int stdc_count_ones_ul(unsigned long __x) { + return __stdc_count_ones_ul(__x); +} +unsigned int stdc_count_ones_ui48(unsigned __int48 __x) { + return __stdc_count_ones_ui48(__x); +} +unsigned int stdc_count_ones_ull(unsigned long long __x) { + return __stdc_count_ones_ull(__x); +} + +bool stdc_has_single_bit_uc(unsigned char __x) { + return __stdc_has_single_bit_uc(__x); +} +bool stdc_has_single_bit_us(unsigned short __x) { + return __stdc_has_single_bit_us(__x); +} +bool stdc_has_single_bit_ui(unsigned int __x) { + return __stdc_has_single_bit_ui(__x); +} +bool stdc_has_single_bit_ul(unsigned long __x) { + return __stdc_has_single_bit_ul(__x); +} +bool stdc_has_single_bit_ui48(unsigned __int48 __x) { + return __stdc_has_single_bit_ui48(__x); +} +bool stdc_has_single_bit_ull(unsigned long long __x) { + return __stdc_has_single_bit_ull(__x); +} + +unsigned int stdc_bit_width_uc(unsigned char __x) { + return __stdc_bit_width_uc(__x); +} +unsigned int stdc_bit_width_us(unsigned short __x) { + return __stdc_bit_width_us(__x); +} +unsigned int stdc_bit_width_ui(unsigned int __x) { + return __stdc_bit_width_ui(__x); +} +unsigned int stdc_bit_width_ul(unsigned long __x) { + return __stdc_bit_width_ul(__x); +} +unsigned int stdc_bit_width_ui48(unsigned __int48 __x) { + return __stdc_bit_width_ui48(__x); +} +unsigned int stdc_bit_width_ull(unsigned long long __x) { + return __stdc_bit_width_ull(__x); +} + +unsigned char stdc_bit_floor_uc(unsigned char __x) { + return __stdc_bit_floor_uc(__x); +} +unsigned short stdc_bit_floor_us(unsigned short __x) { + return __stdc_bit_floor_us(__x); +} +unsigned int stdc_bit_floor_ui(unsigned int __x) { + return __stdc_bit_floor_ui(__x); +} +unsigned long stdc_bit_floor_ul(unsigned long __x) { + return __stdc_bit_floor_ul(__x); +} +unsigned __int48 stdc_bit_floor_ui48(unsigned __int48 __x) { + return __stdc_bit_floor_ui48(__x); +} +unsigned long long stdc_bit_floor_ull(unsigned long long __x) { + return __stdc_bit_floor_ull(__x); +} + +unsigned char stdc_bit_ceil_uc(unsigned char __x) { + return __stdc_bit_ceil_uc(__x); +} +unsigned short stdc_bit_ceil_us(unsigned short __x) { + return __stdc_bit_ceil_us(__x); +} +unsigned int stdc_bit_ceil_ui(unsigned int __x) { + return __stdc_bit_ceil_ui(__x); +} +unsigned long stdc_bit_ceil_ul(unsigned long __x) { + return __stdc_bit_ceil_ul(__x); +} +unsigned __int48 stdc_bit_ceil_ui48(unsigned __int48 __x) { + return __stdc_bit_ceil_ui48(__x); +} +unsigned long long stdc_bit_ceil_ull(unsigned long long __x) { + return __stdc_bit_floor_ull(__x); +} + +unsigned char stdc_rotate_left_uc(unsigned char __x, unsigned int __s) { + return __stdc_rotate_left_uc(__x, __s); +} +unsigned short stdc_rotate_left_us(unsigned short __x, unsigned int __s) { + return __stdc_rotate_left_us(__x, __s); +} +unsigned int stdc_rotate_left_ui(unsigned int __x, unsigned int __s) { + return __stdc_rotate_left_ui(__x, __s); +} +unsigned long stdc_rotate_left_ul(unsigned long __x, unsigned int __s) { + return __stdc_rotate_left_ul(__x, __s); +} +unsigned __int48 stdc_rotate_left_ui48(unsigned __int48 __x, unsigned int __s) { + return __stdc_rotate_left_ui48(__x, __s); +} +unsigned long long stdc_rotate_left_ull(unsigned long long __x, unsigned int __s) { + return __stdc_rotate_left_ull(__x, __s); +} + +unsigned char stdc_rotate_right_uc(unsigned char __x, unsigned int __s) { + return __stdc_rotate_right_uc(__x, __s); +} +unsigned short stdc_rotate_right_us(unsigned short __x, unsigned int __s) { + return __stdc_rotate_right_us(__x, __s); +} +unsigned int stdc_rotate_right_ui(unsigned int __x, unsigned int __s) { + return __stdc_rotate_right_ui(__x, __s); +} +unsigned long stdc_rotate_right_ul(unsigned long __x, unsigned int __s) { + return __stdc_rotate_right_ul(__x, __s); +} +unsigned __int48 stdc_rotate_right_ui48(unsigned __int48 __x, unsigned int __s) { + return __stdc_rotate_right_ui48(__x, __s); +} +unsigned long long stdc_rotate_right_ull(unsigned long long __x, unsigned int __s) { + return __stdc_rotate_right_ull(__x, __s); +} diff --git a/test/standalone/ez80_builtin/src/main.c b/test/standalone/ez80_builtin/src/main.c index 0e564ef79..db5101213 100644 --- a/test/standalone/ez80_builtin/src/main.c +++ b/test/standalone/ez80_builtin/src/main.c @@ -346,20 +346,6 @@ static int test_parityi48(void) { return 0; } -static int test_bitrev24(void) { - C(__ez80_bitreverse24(0x000000) == 0x000000); - C(__ez80_bitreverse24(0xFFFFFF) == 0xFFFFFF); - C(__ez80_bitreverse24(0xAAAAAA) == 0x555555); - C(__ez80_bitreverse24(0x555555) == 0xAAAAAA); - C(__ez80_bitreverse24(0x000001) == 0x800000); - C(__ez80_bitreverse24(0x800000) == 0x000001); - C(__ez80_bitreverse24(0x00CC00) == 0x003300); - C(__ez80_bitreverse24(0x003300) == 0x00CC00); - C(__ez80_bitreverse24(0x0AA550) == 0x0AA550); - C(__ez80_bitreverse24(0x5F99FA) == 0x5F99FA); - return 0; -} - static int test_bitrev48(void) { C(__ez80_bitreverse48(0x000000000000) == 0x000000000000); C(__ez80_bitreverse48(0xFFFFFFFFFFFF) == 0xFFFFFFFFFFFF); @@ -570,7 +556,6 @@ int run_tests(void) { TEST(test_popcounti48()); TEST(test_parityi48()); - TEST(test_bitrev24()); TEST(test_bitrev48()); TEST(test_rotateleft24()); TEST(test_rotateright24()); diff --git a/test/standalone/stdbit/src/data.asm b/test/standalone/stdbit/src/data.asm index c4cc2b6de..2c15c21dc 100644 --- a/test/standalone/stdbit/src/data.asm +++ b/test/standalone/stdbit/src/data.asm @@ -93,6 +93,9 @@ _val_0: public _val_1 _val_1: db 1 + public _val_2 +_val_2: + db 2 public _val_7 _val_7: db 7 diff --git a/test/standalone/stdbit/src/data.h b/test/standalone/stdbit/src/data.h index d7a3e7598..63e6dc92c 100644 --- a/test/standalone/stdbit/src/data.h +++ b/test/standalone/stdbit/src/data.h @@ -47,6 +47,7 @@ extern uint64_t smax_u64; extern uint8_t val_0; extern uint8_t val_1; +extern uint8_t val_2; extern uint8_t val_7; extern uint8_t val_8; extern uint8_t val_15; diff --git a/test/standalone/stdbit/src/test.c b/test/standalone/stdbit/src/test.c index 7bf51ed86..b312b3fd6 100644 --- a/test/standalone/stdbit/src/test.c +++ b/test/standalone/stdbit/src/test.c @@ -5,147 +5,462 @@ #include "data.h" -int test_stdc_leading_zeros(void) { - C((stdc_leading_zeros_uc (zero_u8 ) == val_8 )); - C((stdc_leading_zeros_us (zero_u16) == val_16)); - C((stdc_leading_zeros_ui (zero_u24) == val_24)); - C((stdc_leading_zeros_ul (zero_u32) == val_32)); - C((stdc_leading_zeros_ui48(zero_u48) == val_48)); - C((stdc_leading_zeros_ull (zero_u64) == val_64)); - C((stdc_leading_zeros_uc ( one_u8 ) == val_7 )); - C((stdc_leading_zeros_us ( one_u16) == val_15)); - C((stdc_leading_zeros_ui ( one_u24) == val_23)); - C((stdc_leading_zeros_ul ( one_u32) == val_31)); - C((stdc_leading_zeros_ui48( one_u48) == val_47)); - C((stdc_leading_zeros_ull ( one_u64) == val_63)); - C((stdc_leading_zeros_uc (umax_u8 ) == val_0 )); - C((stdc_leading_zeros_us (umax_u16) == val_0 )); - C((stdc_leading_zeros_ui (umax_u24) == val_0 )); - C((stdc_leading_zeros_ul (umax_u32) == val_0 )); - C((stdc_leading_zeros_ui48(umax_u48) == val_0 )); - C((stdc_leading_zeros_ull (umax_u64) == val_0 )); - C((stdc_leading_zeros_uc (smax_u8 ) == val_1 )); - C((stdc_leading_zeros_us (smax_u16) == val_1 )); - C((stdc_leading_zeros_ui (smax_u24) == val_1 )); - C((stdc_leading_zeros_ul (smax_u32) == val_1 )); - C((stdc_leading_zeros_ui48(smax_u48) == val_1 )); - C((stdc_leading_zeros_ull (smax_u64) == val_1 )); - C((stdc_leading_zeros_uc (smin_u8 ) == val_0 )); - C((stdc_leading_zeros_us (smin_u16) == val_0 )); - C((stdc_leading_zeros_ui (smin_u24) == val_0 )); - C((stdc_leading_zeros_ul (smin_u32) == val_0 )); - C((stdc_leading_zeros_ui48(smin_u48) == val_0 )); - C((stdc_leading_zeros_ull (smin_u64) == val_0 )); +int test_leading_zeros(void) { + C((stdc_leading_zeros(zero_u8 ) == val_8 )); + C((stdc_leading_zeros(zero_u16) == val_16)); + C((stdc_leading_zeros(zero_u24) == val_24)); + C((stdc_leading_zeros(zero_u32) == val_32)); + C((stdc_leading_zeros(zero_u48) == val_48)); + C((stdc_leading_zeros(zero_u64) == val_64)); + C((stdc_leading_zeros( one_u8 ) == val_7 )); + C((stdc_leading_zeros( one_u16) == val_15)); + C((stdc_leading_zeros( one_u24) == val_23)); + C((stdc_leading_zeros( one_u32) == val_31)); + C((stdc_leading_zeros( one_u48) == val_47)); + C((stdc_leading_zeros( one_u64) == val_63)); + C((stdc_leading_zeros(umax_u8 ) == val_0 )); + C((stdc_leading_zeros(umax_u16) == val_0 )); + C((stdc_leading_zeros(umax_u24) == val_0 )); + C((stdc_leading_zeros(umax_u32) == val_0 )); + C((stdc_leading_zeros(umax_u48) == val_0 )); + C((stdc_leading_zeros(umax_u64) == val_0 )); + C((stdc_leading_zeros(smax_u8 ) == val_1 )); + C((stdc_leading_zeros(smax_u16) == val_1 )); + C((stdc_leading_zeros(smax_u24) == val_1 )); + C((stdc_leading_zeros(smax_u32) == val_1 )); + C((stdc_leading_zeros(smax_u48) == val_1 )); + C((stdc_leading_zeros(smax_u64) == val_1 )); + C((stdc_leading_zeros(smin_u8 ) == val_0 )); + C((stdc_leading_zeros(smin_u16) == val_0 )); + C((stdc_leading_zeros(smin_u24) == val_0 )); + C((stdc_leading_zeros(smin_u32) == val_0 )); + C((stdc_leading_zeros(smin_u48) == val_0 )); + C((stdc_leading_zeros(smin_u64) == val_0 )); return 0; } -int test_stdc_trailing_zeros(void) { - C((stdc_trailing_zeros_uc (zero_u8 ) == val_8 )); - C((stdc_trailing_zeros_us (zero_u16) == val_16)); - C((stdc_trailing_zeros_ui (zero_u24) == val_24)); - C((stdc_trailing_zeros_ul (zero_u32) == val_32)); - C((stdc_trailing_zeros_ui48(zero_u48) == val_48)); - C((stdc_trailing_zeros_ull (zero_u64) == val_64)); - C((stdc_trailing_zeros_uc ( one_u8 ) == val_0 )); - C((stdc_trailing_zeros_us ( one_u16) == val_0 )); - C((stdc_trailing_zeros_ui ( one_u24) == val_0 )); - C((stdc_trailing_zeros_ul ( one_u32) == val_0 )); - C((stdc_trailing_zeros_ui48( one_u48) == val_0 )); - C((stdc_trailing_zeros_ull ( one_u64) == val_0 )); - C((stdc_trailing_zeros_uc (umax_u8 ) == val_0 )); - C((stdc_trailing_zeros_us (umax_u16) == val_0 )); - C((stdc_trailing_zeros_ui (umax_u24) == val_0 )); - C((stdc_trailing_zeros_ul (umax_u32) == val_0 )); - C((stdc_trailing_zeros_ui48(umax_u48) == val_0 )); - C((stdc_trailing_zeros_ull (umax_u64) == val_0 )); - C((stdc_trailing_zeros_uc (smax_u8 ) == val_0 )); - C((stdc_trailing_zeros_us (smax_u16) == val_0 )); - C((stdc_trailing_zeros_ui (smax_u24) == val_0 )); - C((stdc_trailing_zeros_ul (smax_u32) == val_0 )); - C((stdc_trailing_zeros_ui48(smax_u48) == val_0 )); - C((stdc_trailing_zeros_ull (smax_u64) == val_0 )); - C((stdc_trailing_zeros_uc (smin_u8 ) == val_7 )); - C((stdc_trailing_zeros_us (smin_u16) == val_15)); - C((stdc_trailing_zeros_ui (smin_u24) == val_23)); - C((stdc_trailing_zeros_ul (smin_u32) == val_31)); - C((stdc_trailing_zeros_ui48(smin_u48) == val_47)); - C((stdc_trailing_zeros_ull (smin_u64) == val_63)); +int test_leading_ones(void) { + C((stdc_leading_ones(zero_u8 ) == val_0 )); + C((stdc_leading_ones(zero_u16) == val_0 )); + C((stdc_leading_ones(zero_u24) == val_0 )); + C((stdc_leading_ones(zero_u32) == val_0 )); + C((stdc_leading_ones(zero_u48) == val_0 )); + C((stdc_leading_ones(zero_u64) == val_0 )); + C((stdc_leading_ones( one_u8 ) == val_0 )); + C((stdc_leading_ones( one_u16) == val_0 )); + C((stdc_leading_ones( one_u24) == val_0 )); + C((stdc_leading_ones( one_u32) == val_0 )); + C((stdc_leading_ones( one_u48) == val_0 )); + C((stdc_leading_ones( one_u64) == val_0 )); + C((stdc_leading_ones(umax_u8 ) == val_8 )); + C((stdc_leading_ones(umax_u16) == val_16)); + C((stdc_leading_ones(umax_u24) == val_24)); + C((stdc_leading_ones(umax_u32) == val_32)); + C((stdc_leading_ones(umax_u48) == val_48)); + C((stdc_leading_ones(umax_u64) == val_64)); + C((stdc_leading_ones(smax_u8 ) == val_0 )); + C((stdc_leading_ones(smax_u16) == val_0 )); + C((stdc_leading_ones(smax_u24) == val_0 )); + C((stdc_leading_ones(smax_u32) == val_0 )); + C((stdc_leading_ones(smax_u48) == val_0 )); + C((stdc_leading_ones(smax_u64) == val_0 )); + C((stdc_leading_ones(smin_u8 ) == val_1 )); + C((stdc_leading_ones(smin_u16) == val_1 )); + C((stdc_leading_ones(smin_u24) == val_1 )); + C((stdc_leading_ones(smin_u32) == val_1 )); + C((stdc_leading_ones(smin_u48) == val_1 )); + C((stdc_leading_ones(smin_u64) == val_1 )); return 0; } -int test_stdc_first_trailing_one(void) { - C((stdc_first_trailing_one_uc (zero_u8 ) == val_0 )); - C((stdc_first_trailing_one_us (zero_u16) == val_0 )); - C((stdc_first_trailing_one_ui (zero_u24) == val_0 )); - C((stdc_first_trailing_one_ul (zero_u32) == val_0 )); - C((stdc_first_trailing_one_ui48(zero_u48) == val_0 )); - C((stdc_first_trailing_one_ull (zero_u64) == val_0 )); - C((stdc_first_trailing_one_uc ( one_u8 ) == val_1 )); - C((stdc_first_trailing_one_us ( one_u16) == val_1 )); - C((stdc_first_trailing_one_ui ( one_u24) == val_1 )); - C((stdc_first_trailing_one_ul ( one_u32) == val_1 )); - C((stdc_first_trailing_one_ui48( one_u48) == val_1 )); - C((stdc_first_trailing_one_ull ( one_u64) == val_1 )); - C((stdc_first_trailing_one_uc (umax_u8 ) == val_1 )); - C((stdc_first_trailing_one_us (umax_u16) == val_1 )); - C((stdc_first_trailing_one_ui (umax_u24) == val_1 )); - C((stdc_first_trailing_one_ul (umax_u32) == val_1 )); - C((stdc_first_trailing_one_ui48(umax_u48) == val_1 )); - C((stdc_first_trailing_one_ull (umax_u64) == val_1 )); - C((stdc_first_trailing_one_uc (smax_u8 ) == val_1 )); - C((stdc_first_trailing_one_us (smax_u16) == val_1 )); - C((stdc_first_trailing_one_ui (smax_u24) == val_1 )); - C((stdc_first_trailing_one_ul (smax_u32) == val_1 )); - C((stdc_first_trailing_one_ui48(smax_u48) == val_1 )); - C((stdc_first_trailing_one_ull (smax_u64) == val_1 )); - C((stdc_first_trailing_one_uc (smin_u8 ) == val_8 )); - C((stdc_first_trailing_one_us (smin_u16) == val_16)); - C((stdc_first_trailing_one_ui (smin_u24) == val_24)); - C((stdc_first_trailing_one_ul (smin_u32) == val_32)); - C((stdc_first_trailing_one_ui48(smin_u48) == val_48)); - C((stdc_first_trailing_one_ull (smin_u64) == val_64)); +int test_trailing_zeros(void) { + C((stdc_trailing_zeros(zero_u8 ) == val_8 )); + C((stdc_trailing_zeros(zero_u16) == val_16)); + C((stdc_trailing_zeros(zero_u24) == val_24)); + C((stdc_trailing_zeros(zero_u32) == val_32)); + C((stdc_trailing_zeros(zero_u48) == val_48)); + C((stdc_trailing_zeros(zero_u64) == val_64)); + C((stdc_trailing_zeros( one_u8 ) == val_0 )); + C((stdc_trailing_zeros( one_u16) == val_0 )); + C((stdc_trailing_zeros( one_u24) == val_0 )); + C((stdc_trailing_zeros( one_u32) == val_0 )); + C((stdc_trailing_zeros( one_u48) == val_0 )); + C((stdc_trailing_zeros( one_u64) == val_0 )); + C((stdc_trailing_zeros(umax_u8 ) == val_0 )); + C((stdc_trailing_zeros(umax_u16) == val_0 )); + C((stdc_trailing_zeros(umax_u24) == val_0 )); + C((stdc_trailing_zeros(umax_u32) == val_0 )); + C((stdc_trailing_zeros(umax_u48) == val_0 )); + C((stdc_trailing_zeros(umax_u64) == val_0 )); + C((stdc_trailing_zeros(smax_u8 ) == val_0 )); + C((stdc_trailing_zeros(smax_u16) == val_0 )); + C((stdc_trailing_zeros(smax_u24) == val_0 )); + C((stdc_trailing_zeros(smax_u32) == val_0 )); + C((stdc_trailing_zeros(smax_u48) == val_0 )); + C((stdc_trailing_zeros(smax_u64) == val_0 )); + C((stdc_trailing_zeros(smin_u8 ) == val_7 )); + C((stdc_trailing_zeros(smin_u16) == val_15)); + C((stdc_trailing_zeros(smin_u24) == val_23)); + C((stdc_trailing_zeros(smin_u32) == val_31)); + C((stdc_trailing_zeros(smin_u48) == val_47)); + C((stdc_trailing_zeros(smin_u64) == val_63)); return 0; } -int test_stdc_count_ones(void) { - C((stdc_count_ones_uc (zero_u8 ) == val_0 )); - C((stdc_count_ones_us (zero_u16) == val_0 )); - C((stdc_count_ones_ui (zero_u24) == val_0 )); - C((stdc_count_ones_ul (zero_u32) == val_0 )); - C((stdc_count_ones_ui48(zero_u48) == val_0 )); - C((stdc_count_ones_ull (zero_u64) == val_0 )); - C((stdc_count_ones_uc ( one_u8 ) == val_1 )); - C((stdc_count_ones_us ( one_u16) == val_1 )); - C((stdc_count_ones_ui ( one_u24) == val_1 )); - C((stdc_count_ones_ul ( one_u32) == val_1 )); - C((stdc_count_ones_ui48( one_u48) == val_1 )); - C((stdc_count_ones_ull ( one_u64) == val_1 )); - C((stdc_count_ones_uc (umax_u8 ) == val_8 )); - C((stdc_count_ones_us (umax_u16) == val_16)); - C((stdc_count_ones_ui (umax_u24) == val_24)); - C((stdc_count_ones_ul (umax_u32) == val_32)); - C((stdc_count_ones_ui48(umax_u48) == val_48)); - C((stdc_count_ones_ull (umax_u64) == val_64)); - C((stdc_count_ones_uc (smax_u8 ) == val_7 )); - C((stdc_count_ones_us (smax_u16) == val_15)); - C((stdc_count_ones_ui (smax_u24) == val_23)); - C((stdc_count_ones_ul (smax_u32) == val_31)); - C((stdc_count_ones_ui48(smax_u48) == val_47)); - C((stdc_count_ones_ull (smax_u64) == val_63)); - C((stdc_count_ones_uc (smin_u8 ) == val_1 )); - C((stdc_count_ones_us (smin_u16) == val_1 )); - C((stdc_count_ones_ui (smin_u24) == val_1 )); - C((stdc_count_ones_ul (smin_u32) == val_1 )); - C((stdc_count_ones_ui48(smin_u48) == val_1 )); - C((stdc_count_ones_ull (smin_u64) == val_1 )); +int test_trailing_ones(void) { + C((stdc_trailing_ones(zero_u8 ) == val_0 )); + C((stdc_trailing_ones(zero_u16) == val_0 )); + C((stdc_trailing_ones(zero_u24) == val_0 )); + C((stdc_trailing_ones(zero_u32) == val_0 )); + C((stdc_trailing_ones(zero_u48) == val_0 )); + C((stdc_trailing_ones(zero_u64) == val_0 )); + C((stdc_trailing_ones( one_u8 ) == val_1 )); + C((stdc_trailing_ones( one_u16) == val_1 )); + C((stdc_trailing_ones( one_u24) == val_1 )); + C((stdc_trailing_ones( one_u32) == val_1 )); + C((stdc_trailing_ones( one_u48) == val_1 )); + C((stdc_trailing_ones( one_u64) == val_1 )); + C((stdc_trailing_ones(umax_u8 ) == val_8 )); + C((stdc_trailing_ones(umax_u16) == val_16)); + C((stdc_trailing_ones(umax_u24) == val_24)); + C((stdc_trailing_ones(umax_u32) == val_32)); + C((stdc_trailing_ones(umax_u48) == val_48)); + C((stdc_trailing_ones(umax_u64) == val_64)); + C((stdc_trailing_ones(smax_u8 ) == val_7 )); + C((stdc_trailing_ones(smax_u16) == val_15)); + C((stdc_trailing_ones(smax_u24) == val_23)); + C((stdc_trailing_ones(smax_u32) == val_31)); + C((stdc_trailing_ones(smax_u48) == val_47)); + C((stdc_trailing_ones(smax_u64) == val_63)); + C((stdc_trailing_ones(smin_u8 ) == val_0 )); + C((stdc_trailing_ones(smin_u16) == val_0 )); + C((stdc_trailing_ones(smin_u24) == val_0 )); + C((stdc_trailing_ones(smin_u32) == val_0 )); + C((stdc_trailing_ones(smin_u48) == val_0 )); + C((stdc_trailing_ones(smin_u64) == val_0 )); + return 0; +} + +int test_first_leading_one(void) { + C((stdc_first_leading_one(zero_u8 ) == val_0 )); + C((stdc_first_leading_one(zero_u16) == val_0 )); + C((stdc_first_leading_one(zero_u24) == val_0 )); + C((stdc_first_leading_one(zero_u32) == val_0 )); + C((stdc_first_leading_one(zero_u48) == val_0 )); + C((stdc_first_leading_one(zero_u64) == val_0 )); + C((stdc_first_leading_one( one_u8 ) == val_8 )); + C((stdc_first_leading_one( one_u16) == val_16)); + C((stdc_first_leading_one( one_u24) == val_24)); + C((stdc_first_leading_one( one_u32) == val_32)); + C((stdc_first_leading_one( one_u48) == val_48)); + C((stdc_first_leading_one( one_u64) == val_64)); + C((stdc_first_leading_one(umax_u8 ) == val_1 )); + C((stdc_first_leading_one(umax_u16) == val_1 )); + C((stdc_first_leading_one(umax_u24) == val_1 )); + C((stdc_first_leading_one(umax_u32) == val_1 )); + C((stdc_first_leading_one(umax_u48) == val_1 )); + C((stdc_first_leading_one(umax_u64) == val_1 )); + C((stdc_first_leading_one(smax_u8 ) == val_2 )); + C((stdc_first_leading_one(smax_u16) == val_2 )); + C((stdc_first_leading_one(smax_u24) == val_2 )); + C((stdc_first_leading_one(smax_u32) == val_2 )); + C((stdc_first_leading_one(smax_u48) == val_2 )); + C((stdc_first_leading_one(smax_u64) == val_2 )); + C((stdc_first_leading_one(smin_u8 ) == val_1 )); + C((stdc_first_leading_one(smin_u16) == val_1 )); + C((stdc_first_leading_one(smin_u24) == val_1 )); + C((stdc_first_leading_one(smin_u32) == val_1 )); + C((stdc_first_leading_one(smin_u48) == val_1 )); + C((stdc_first_leading_one(smin_u64) == val_1 )); + return 0; +} + +int test_first_leading_zero(void) { + C((stdc_first_leading_zero(zero_u8 ) == val_1 )); + C((stdc_first_leading_zero(zero_u16) == val_1 )); + C((stdc_first_leading_zero(zero_u24) == val_1 )); + C((stdc_first_leading_zero(zero_u32) == val_1 )); + C((stdc_first_leading_zero(zero_u48) == val_1 )); + C((stdc_first_leading_zero(zero_u64) == val_1 )); + C((stdc_first_leading_zero( one_u8 ) == val_1 )); + C((stdc_first_leading_zero( one_u16) == val_1 )); + C((stdc_first_leading_zero( one_u24) == val_1 )); + C((stdc_first_leading_zero( one_u32) == val_1 )); + C((stdc_first_leading_zero( one_u48) == val_1 )); + C((stdc_first_leading_zero( one_u64) == val_1 )); + C((stdc_first_leading_zero(umax_u8 ) == val_0 )); + C((stdc_first_leading_zero(umax_u16) == val_0 )); + C((stdc_first_leading_zero(umax_u24) == val_0 )); + C((stdc_first_leading_zero(umax_u32) == val_0 )); + C((stdc_first_leading_zero(umax_u48) == val_0 )); + C((stdc_first_leading_zero(umax_u64) == val_0 )); + C((stdc_first_leading_zero(smax_u8 ) == val_1 )); + C((stdc_first_leading_zero(smax_u16) == val_1 )); + C((stdc_first_leading_zero(smax_u24) == val_1 )); + C((stdc_first_leading_zero(smax_u32) == val_1 )); + C((stdc_first_leading_zero(smax_u48) == val_1 )); + C((stdc_first_leading_zero(smax_u64) == val_1 )); + C((stdc_first_leading_zero(smin_u8 ) == val_2 )); + C((stdc_first_leading_zero(smin_u16) == val_2 )); + C((stdc_first_leading_zero(smin_u24) == val_2 )); + C((stdc_first_leading_zero(smin_u32) == val_2 )); + C((stdc_first_leading_zero(smin_u48) == val_2 )); + C((stdc_first_leading_zero(smin_u64) == val_2 )); + return 0; +} + +int test_first_trailing_one(void) { + C((stdc_first_trailing_one(zero_u8 ) == val_0)); + C((stdc_first_trailing_one(zero_u16) == val_0)); + C((stdc_first_trailing_one(zero_u24) == val_0)); + C((stdc_first_trailing_one(zero_u32) == val_0)); + C((stdc_first_trailing_one(zero_u48) == val_0)); + C((stdc_first_trailing_one(zero_u64) == val_0)); + C((stdc_first_trailing_one( one_u8 ) == val_1 )); + C((stdc_first_trailing_one( one_u16) == val_1 )); + C((stdc_first_trailing_one( one_u24) == val_1 )); + C((stdc_first_trailing_one( one_u32) == val_1 )); + C((stdc_first_trailing_one( one_u48) == val_1 )); + C((stdc_first_trailing_one( one_u64) == val_1 )); + C((stdc_first_trailing_one(umax_u8 ) == val_1 )); + C((stdc_first_trailing_one(umax_u16) == val_1 )); + C((stdc_first_trailing_one(umax_u24) == val_1 )); + C((stdc_first_trailing_one(umax_u32) == val_1 )); + C((stdc_first_trailing_one(umax_u48) == val_1 )); + C((stdc_first_trailing_one(umax_u64) == val_1 )); + C((stdc_first_trailing_one(smax_u8 ) == val_1 )); + C((stdc_first_trailing_one(smax_u16) == val_1 )); + C((stdc_first_trailing_one(smax_u24) == val_1 )); + C((stdc_first_trailing_one(smax_u32) == val_1 )); + C((stdc_first_trailing_one(smax_u48) == val_1 )); + C((stdc_first_trailing_one(smax_u64) == val_1 )); + C((stdc_first_trailing_one(smin_u8 ) == val_8 )); + C((stdc_first_trailing_one(smin_u16) == val_16)); + C((stdc_first_trailing_one(smin_u24) == val_24)); + C((stdc_first_trailing_one(smin_u32) == val_32)); + C((stdc_first_trailing_one(smin_u48) == val_48)); + C((stdc_first_trailing_one(smin_u64) == val_64)); + return 0; +} + +int test_first_trailing_zero(void) { + C((stdc_first_trailing_zero(zero_u8 ) == val_1 )); + C((stdc_first_trailing_zero(zero_u16) == val_1 )); + C((stdc_first_trailing_zero(zero_u24) == val_1 )); + C((stdc_first_trailing_zero(zero_u32) == val_1 )); + C((stdc_first_trailing_zero(zero_u48) == val_1 )); + C((stdc_first_trailing_zero(zero_u64) == val_1 )); + C((stdc_first_trailing_zero( one_u8 ) == val_2 )); + C((stdc_first_trailing_zero( one_u16) == val_2 )); + C((stdc_first_trailing_zero( one_u24) == val_2 )); + C((stdc_first_trailing_zero( one_u32) == val_2 )); + C((stdc_first_trailing_zero( one_u48) == val_2 )); + C((stdc_first_trailing_zero( one_u64) == val_2 )); + C((stdc_first_trailing_zero(umax_u8 ) == val_0 )); + C((stdc_first_trailing_zero(umax_u16) == val_0 )); + C((stdc_first_trailing_zero(umax_u24) == val_0 )); + C((stdc_first_trailing_zero(umax_u32) == val_0 )); + C((stdc_first_trailing_zero(umax_u48) == val_0 )); + C((stdc_first_trailing_zero(umax_u64) == val_0 )); + C((stdc_first_trailing_zero(smax_u8 ) == val_8 )); + C((stdc_first_trailing_zero(smax_u16) == val_16)); + C((stdc_first_trailing_zero(smax_u24) == val_24)); + C((stdc_first_trailing_zero(smax_u32) == val_32)); + C((stdc_first_trailing_zero(smax_u48) == val_48)); + C((stdc_first_trailing_zero(smax_u64) == val_64)); + C((stdc_first_trailing_zero(smin_u8 ) == val_1 )); + C((stdc_first_trailing_zero(smin_u16) == val_1 )); + C((stdc_first_trailing_zero(smin_u24) == val_1 )); + C((stdc_first_trailing_zero(smin_u32) == val_1 )); + C((stdc_first_trailing_zero(smin_u48) == val_1 )); + C((stdc_first_trailing_zero(smin_u64) == val_1 )); + return 0; +} + +int test_bit_width(void) { + C((stdc_bit_width(zero_u8 ) == val_0 )); + C((stdc_bit_width(zero_u16) == val_0 )); + C((stdc_bit_width(zero_u24) == val_0 )); + C((stdc_bit_width(zero_u32) == val_0 )); + C((stdc_bit_width(zero_u48) == val_0 )); + C((stdc_bit_width(zero_u64) == val_0 )); + C((stdc_bit_width( one_u8 ) == val_1 )); + C((stdc_bit_width( one_u16) == val_1 )); + C((stdc_bit_width( one_u24) == val_1 )); + C((stdc_bit_width( one_u32) == val_1 )); + C((stdc_bit_width( one_u48) == val_1 )); + C((stdc_bit_width( one_u64) == val_1 )); + C((stdc_bit_width(umax_u8 ) == val_8 )); + C((stdc_bit_width(umax_u16) == val_16)); + C((stdc_bit_width(umax_u24) == val_24)); + C((stdc_bit_width(umax_u32) == val_32)); + C((stdc_bit_width(umax_u48) == val_48)); + C((stdc_bit_width(umax_u64) == val_64)); + C((stdc_bit_width(smax_u8 ) == val_7 )); + C((stdc_bit_width(smax_u16) == val_15)); + C((stdc_bit_width(smax_u24) == val_23)); + C((stdc_bit_width(smax_u32) == val_31)); + C((stdc_bit_width(smax_u48) == val_47)); + C((stdc_bit_width(smax_u64) == val_63)); + C((stdc_bit_width(smin_u8 ) == val_8 )); + C((stdc_bit_width(smin_u16) == val_16)); + C((stdc_bit_width(smin_u24) == val_24)); + C((stdc_bit_width(smin_u32) == val_32)); + C((stdc_bit_width(smin_u48) == val_48)); + C((stdc_bit_width(smin_u64) == val_64)); + return 0; +} + +int test_bit_ceil(void) { + C((stdc_bit_ceil(zero_u8 ) == one_u8 )); + C((stdc_bit_ceil(zero_u16) == one_u16)); + C((stdc_bit_ceil(zero_u24) == one_u24)); + C((stdc_bit_ceil(zero_u32) == one_u32)); + C((stdc_bit_ceil(zero_u48) == one_u48)); + C((stdc_bit_ceil(zero_u64) == one_u64)); + C((stdc_bit_ceil( one_u8 ) == one_u8 )); + C((stdc_bit_ceil( one_u16) == one_u16)); + C((stdc_bit_ceil( one_u24) == one_u24)); + C((stdc_bit_ceil( one_u32) == one_u32)); + C((stdc_bit_ceil( one_u48) == one_u48)); + C((stdc_bit_ceil( one_u64) == one_u64)); + C((stdc_bit_ceil(umax_u8 ) == zero_u8 )); + C((stdc_bit_ceil(umax_u16) == zero_u16)); + C((stdc_bit_ceil(umax_u24) == zero_u24)); + C((stdc_bit_ceil(umax_u32) == zero_u32)); + C((stdc_bit_ceil(umax_u48) == zero_u48)); + C((stdc_bit_ceil(umax_u64) == zero_u64)); + C((stdc_bit_ceil(smax_u8 ) == smin_u8 )); + C((stdc_bit_ceil(smax_u16) == smin_u16)); + C((stdc_bit_ceil(smax_u24) == smin_u24)); + C((stdc_bit_ceil(smax_u32) == smin_u32)); + C((stdc_bit_ceil(smax_u48) == smin_u48)); + C((stdc_bit_ceil(smax_u64) == smin_u64)); + C((stdc_bit_ceil(smin_u8 ) == smin_u8 )); + C((stdc_bit_ceil(smin_u16) == smin_u16)); + C((stdc_bit_ceil(smin_u24) == smin_u24)); + C((stdc_bit_ceil(smin_u32) == smin_u32)); + C((stdc_bit_ceil(smin_u48) == smin_u48)); + C((stdc_bit_ceil(smin_u64) == smin_u64)); + return 0; +} + +int test_bit_floor(void) { + C((stdc_bit_floor(zero_u8 ) == zero_u8 )); + C((stdc_bit_floor(zero_u16) == zero_u16)); + C((stdc_bit_floor(zero_u24) == zero_u24)); + C((stdc_bit_floor(zero_u32) == zero_u32)); + C((stdc_bit_floor(zero_u48) == zero_u48)); + C((stdc_bit_floor(zero_u64) == zero_u64)); + C((stdc_bit_floor( one_u8 ) == one_u8 )); + C((stdc_bit_floor( one_u16) == one_u16)); + C((stdc_bit_floor( one_u24) == one_u24)); + C((stdc_bit_floor( one_u32) == one_u32)); + C((stdc_bit_floor( one_u48) == one_u48)); + C((stdc_bit_floor( one_u64) == one_u64)); + C((stdc_bit_floor(umax_u8 ) == smin_u8 )); + C((stdc_bit_floor(umax_u16) == smin_u16)); + C((stdc_bit_floor(umax_u24) == smin_u24)); + C((stdc_bit_floor(umax_u32) == smin_u32)); + C((stdc_bit_floor(umax_u48) == smin_u48)); + C((stdc_bit_floor(umax_u64) == smin_u64)); + C((stdc_bit_floor(smax_u8 ) == smin_u8 >> 1)); + C((stdc_bit_floor(smax_u16) == smin_u16 >> 1)); + C((stdc_bit_floor(smax_u24) == smin_u24 >> 1)); + C((stdc_bit_floor(smax_u32) == smin_u32 >> 1)); + C((stdc_bit_floor(smax_u48) == smin_u48 >> 1)); + C((stdc_bit_floor(smax_u64) == smin_u64 >> 1)); + C((stdc_bit_floor(smin_u8 ) == smin_u8 )); + C((stdc_bit_floor(smin_u16) == smin_u16)); + C((stdc_bit_floor(smin_u24) == smin_u24)); + C((stdc_bit_floor(smin_u32) == smin_u32)); + C((stdc_bit_floor(smin_u48) == smin_u48)); + C((stdc_bit_floor(smin_u64) == smin_u64)); + return 0; +} + +int test_count_ones(void) { + C((stdc_count_ones(zero_u8 ) == val_0 )); + C((stdc_count_ones(zero_u16) == val_0 )); + C((stdc_count_ones(zero_u24) == val_0 )); + C((stdc_count_ones(zero_u32) == val_0 )); + C((stdc_count_ones(zero_u48) == val_0 )); + C((stdc_count_ones(zero_u64) == val_0 )); + C((stdc_count_ones( one_u8 ) == val_1 )); + C((stdc_count_ones( one_u16) == val_1 )); + C((stdc_count_ones( one_u24) == val_1 )); + C((stdc_count_ones( one_u32) == val_1 )); + C((stdc_count_ones( one_u48) == val_1 )); + C((stdc_count_ones( one_u64) == val_1 )); + C((stdc_count_ones(umax_u8 ) == val_8 )); + C((stdc_count_ones(umax_u16) == val_16)); + C((stdc_count_ones(umax_u24) == val_24)); + C((stdc_count_ones(umax_u32) == val_32)); + C((stdc_count_ones(umax_u48) == val_48)); + C((stdc_count_ones(umax_u64) == val_64)); + C((stdc_count_ones(smax_u8 ) == val_7 )); + C((stdc_count_ones(smax_u16) == val_15)); + C((stdc_count_ones(smax_u24) == val_23)); + C((stdc_count_ones(smax_u32) == val_31)); + C((stdc_count_ones(smax_u48) == val_47)); + C((stdc_count_ones(smax_u64) == val_63)); + C((stdc_count_ones(smin_u8 ) == val_1 )); + C((stdc_count_ones(smin_u16) == val_1 )); + C((stdc_count_ones(smin_u24) == val_1 )); + C((stdc_count_ones(smin_u32) == val_1 )); + C((stdc_count_ones(smin_u48) == val_1 )); + C((stdc_count_ones(smin_u64) == val_1 )); + return 0; +} + +int test_count_zeros(void) { + C((stdc_count_zeros(zero_u8 ) == val_8 )); + C((stdc_count_zeros(zero_u16) == val_16)); + C((stdc_count_zeros(zero_u24) == val_24)); + C((stdc_count_zeros(zero_u32) == val_32)); + C((stdc_count_zeros(zero_u48) == val_48)); + C((stdc_count_zeros(zero_u64) == val_64)); + C((stdc_count_zeros( one_u8 ) == val_7 )); + C((stdc_count_zeros( one_u16) == val_15)); + C((stdc_count_zeros( one_u24) == val_23)); + C((stdc_count_zeros( one_u32) == val_31)); + C((stdc_count_zeros( one_u48) == val_47)); + C((stdc_count_zeros( one_u64) == val_63)); + C((stdc_count_zeros(umax_u8 ) == val_0 )); + C((stdc_count_zeros(umax_u16) == val_0 )); + C((stdc_count_zeros(umax_u24) == val_0 )); + C((stdc_count_zeros(umax_u32) == val_0 )); + C((stdc_count_zeros(umax_u48) == val_0 )); + C((stdc_count_zeros(umax_u64) == val_0 )); + C((stdc_count_zeros(smax_u8 ) == val_1 )); + C((stdc_count_zeros(smax_u16) == val_1 )); + C((stdc_count_zeros(smax_u24) == val_1 )); + C((stdc_count_zeros(smax_u32) == val_1 )); + C((stdc_count_zeros(smax_u48) == val_1 )); + C((stdc_count_zeros(smax_u64) == val_1 )); + C((stdc_count_zeros(smin_u8 ) == val_7 )); + C((stdc_count_zeros(smin_u16) == val_15)); + C((stdc_count_zeros(smin_u24) == val_23)); + C((stdc_count_zeros(smin_u32) == val_31)); + C((stdc_count_zeros(smin_u48) == val_47)); + C((stdc_count_zeros(smin_u64) == val_63)); return 0; } int test_stdbit(void) { int ret = 0; - TEST(test_stdc_leading_zeros()); - TEST(test_stdc_trailing_zeros()); - TEST(test_stdc_first_trailing_one()); - TEST(test_stdc_count_ones()); + TEST(test_leading_zeros()); + TEST(test_leading_ones()); + TEST(test_trailing_zeros()); + TEST(test_trailing_ones()); + TEST(test_first_leading_one()); + TEST(test_first_leading_zero()); + TEST(test_first_trailing_one()); + TEST(test_first_trailing_zero()); + TEST(test_bit_width()); + TEST(test_bit_ceil()); + TEST(test_bit_floor()); + TEST(test_count_ones()); + TEST(test_count_zeros()); return 0; }