From e27d268475e19c156c9c75b447ccd524363c50fd Mon Sep 17 00:00:00 2001 From: ZERICO2005 <71151164+ZERICO2005@users.noreply.github.com> Date: Fri, 11 Apr 2025 13:27:20 -0600 Subject: [PATCH] Fixed behaviour of C++ --- src/libcxx/include/bit | 42 ++-- test/standalone/stdbit/src/data.asm | 81 ++++++-- test/standalone/stdbit/src/data.h | 33 +++- test/standalone/stdbit/src/main.cpp | 295 +++++++++++++++++++++++----- test/standalone/stdbit/src/test.c | 142 ++++++++++--- 5 files changed, 470 insertions(+), 123 deletions(-) diff --git a/src/libcxx/include/bit b/src/libcxx/include/bit index 857154f11..f38f77832 100644 --- a/src/libcxx/include/bit +++ b/src/libcxx/include/bit @@ -289,32 +289,32 @@ int bit_width(_Tp __t) noexcept; template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr int bit_width(unsigned char __t) noexcept { - return 8 - __ez80_clzc(__t); + return std::numeric_limits::digits- __ez80_clzc(__t); } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr int bit_width(unsigned short __t) noexcept { - return 16 - __builtin_clzs(__t); + return std::numeric_limits::digits - __builtin_clzs(__t); } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr int bit_width(unsigned int __t) noexcept { - return 24 - __builtin_clz(__t); + return std::numeric_limits::digits - __builtin_clz(__t); } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr int bit_width(unsigned long __t) noexcept { - return 32 - __builtin_clzl(__t); + return std::numeric_limits::digits - __builtin_clzl(__t); } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr int bit_width(unsigned __int48 __t) noexcept { - return 48 - __ez80_clzi48(__t); + return std::numeric_limits::digits - __ez80_clzi48(__t); } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr int bit_width(unsigned long long __t) noexcept { - return 64 - __builtin_clzll(__t); + return std::numeric_limits::digits - __builtin_clzll(__t); } //------------------------------------------------------------------------------ @@ -327,49 +327,43 @@ _Tp bit_ceil(_Tp __t) noexcept; template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr unsigned char bit_ceil(unsigned char __t) noexcept { return - (static_cast(__t) > 0) - ? (static_cast(1) << bit_width(__t - 1)) - : ((__t == 0) ? 1 : 0); + (__t <= static_cast(std::numeric_limits::min())) + ? ((__t != 0) ? (static_cast(1) << bit_width(__t - 1)) : 1) : 0; } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr unsigned short bit_ceil(unsigned short __t) noexcept { return - (static_cast(__t) > 0) - ? (static_cast(1) << bit_width(__t - 1)) - : ((__t == 0) ? 1 : 0); + (__t <= static_cast(std::numeric_limits::min())) + ? ((__t != 0) ? (static_cast(1) << bit_width(__t - 1)) : 1) : 0; } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr unsigned int bit_ceil(unsigned int __t) noexcept { return - (static_cast(__t) > 0) - ? (static_cast(1) << bit_width(__t - 1)) - : ((__t == 0) ? 1 : 0); + (__t <= static_cast(std::numeric_limits::min())) + ? ((__t != 0) ? (static_cast(1) << bit_width(__t - 1)) : 1) : 0; } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr unsigned long bit_ceil(unsigned long __t) noexcept { return - (static_cast(__t) > 0) - ? (static_cast(1) << bit_width(__t - 1)) - : ((__t == 0) ? 1 : 0); + (__t <= static_cast(std::numeric_limits::min())) + ? ((__t != 0) ? (static_cast(1) << bit_width(__t - 1)) : 1) : 0; } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr unsigned __int48 bit_ceil(unsigned __int48 __t) noexcept { return - (static_cast(__t) > 0) - ? (static_cast(1) << bit_width(__t - 1)) - : ((__t == 0) ? 1 : 0); + (__t <= static_cast(std::numeric_limits::min())) + ? ((__t != 0) ? (static_cast(1) << bit_width(__t - 1)) : 1) : 0; } template <> _EZCXX_NODISCARD _EZCXX_INLINE constexpr unsigned long long bit_ceil(unsigned long long __t) noexcept { return - (static_cast(__t) > 0) - ? (static_cast(1) << bit_width(__t - 1)) - : ((__t == 0) ? 1 : 0); + (__t <= static_cast(std::numeric_limits::min())) + ? ((__t != 0) ? (static_cast(1) << bit_width(__t - 1)) : 1) : 0; } //------------------------------------------------------------------------------ diff --git a/test/standalone/stdbit/src/data.asm b/test/standalone/stdbit/src/data.asm index 2e0abc509..c4cc2b6de 100644 --- a/test/standalone/stdbit/src/data.asm +++ b/test/standalone/stdbit/src/data.asm @@ -16,20 +16,77 @@ _zero_u48: _zero_u64: db $00, $00, $00, $00, $00, $00, $00, $00 - public _ones_u8 - public _ones_u16 - public _ones_u24 - public _ones_u32 - public _ones_u48 - public _ones_u64 -_ones_u8: -_ones_u16: -_ones_u24: -_ones_u32: -_ones_u48: -_ones_u64: + public _one_u8 + public _one_u16 + public _one_u24 + public _one_u32 + public _one_u48 + public _one_u64 +_one_u8: +_one_u16: +_one_u24: +_one_u32: +_one_u48: +_one_u64: + db $01, $00, $00, $00, $00, $00, $00, $00 + + public _umax_u8 + public _umax_u16 + public _umax_u24 + public _umax_u32 + public _umax_u48 + public _umax_u64 +_umax_u8: +_umax_u16: +_umax_u24: +_umax_u32: +_umax_u48: +_umax_u64: db $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF + public _smin_u8 + public _smin_u16 + public _smin_u24 + public _smin_u32 + public _smin_u48 + public _smin_u64 +_smin_u64: + db $00 + db $00 +_smin_u48: + db $00 + db $00 +_smin_u32: + db $00 +_smin_u24: + db $00 +_smin_u16: + db $00 +_smin_u8: + db $80 + + public _smax_u8 + public _smax_u16 + public _smax_u24 + public _smax_u32 + public _smax_u48 + public _smax_u64 +_smax_u64: + db $FF + db $FF +_smax_u48: + db $FF + db $FF +_smax_u32: + db $FF +_smax_u24: + db $FF +_smax_u16: + db $FF +_smax_u8: + db $7F + + public _val_0 _val_0: db 0 diff --git a/test/standalone/stdbit/src/data.h b/test/standalone/stdbit/src/data.h index 38cc6aaa7..d7a3e7598 100644 --- a/test/standalone/stdbit/src/data.h +++ b/test/standalone/stdbit/src/data.h @@ -17,12 +17,33 @@ extern uint32_t zero_u32; extern uint48_t zero_u48; extern uint64_t zero_u64; -extern uint8_t ones_u8; -extern uint16_t ones_u16; -extern uint24_t ones_u24; -extern uint32_t ones_u32; -extern uint48_t ones_u48; -extern uint64_t ones_u64; +extern uint8_t one_u8; +extern uint16_t one_u16; +extern uint24_t one_u24; +extern uint32_t one_u32; +extern uint48_t one_u48; +extern uint64_t one_u64; + +extern uint8_t umax_u8; +extern uint16_t umax_u16; +extern uint24_t umax_u24; +extern uint32_t umax_u32; +extern uint48_t umax_u48; +extern uint64_t umax_u64; + +extern uint8_t smin_u8; +extern uint16_t smin_u16; +extern uint24_t smin_u24; +extern uint32_t smin_u32; +extern uint48_t smin_u48; +extern uint64_t smin_u64; + +extern uint8_t smax_u8; +extern uint16_t smax_u16; +extern uint24_t smax_u24; +extern uint32_t smax_u32; +extern uint48_t smax_u48; +extern uint64_t smax_u64; extern uint8_t val_0; extern uint8_t val_1; diff --git a/test/standalone/stdbit/src/main.cpp b/test/standalone/stdbit/src/main.cpp index a603fe5ee..49520ac32 100644 --- a/test/standalone/stdbit/src/main.cpp +++ b/test/standalone/stdbit/src/main.cpp @@ -166,98 +166,278 @@ int test_byteswap(void) { return 0; } -int test_cxxbit_edge_cases(void) { +int test_countl_zero(void) { C((std::countl_zero(zero_u8 ) == val_8 )); C((std::countl_zero(zero_u16) == val_16)); C((std::countl_zero(zero_u24) == val_24)); C((std::countl_zero(zero_u32) == val_32)); C((std::countl_zero(zero_u48) == val_48)); C((std::countl_zero(zero_u64) == val_64)); - C((std::countl_zero(ones_u8 ) == val_0 )); - C((std::countl_zero(ones_u16) == val_0 )); - C((std::countl_zero(ones_u24) == val_0 )); - C((std::countl_zero(ones_u32) == val_0 )); - C((std::countl_zero(ones_u48) == val_0 )); - C((std::countl_zero(ones_u64) == val_0 )); + C((std::countl_zero( one_u8 ) == val_7 )); + C((std::countl_zero( one_u16) == val_15)); + C((std::countl_zero( one_u24) == val_23)); + C((std::countl_zero( one_u32) == val_31)); + C((std::countl_zero( one_u48) == val_47)); + C((std::countl_zero( one_u64) == val_63)); + C((std::countl_zero(umax_u8 ) == val_0 )); + C((std::countl_zero(umax_u16) == val_0 )); + C((std::countl_zero(umax_u24) == val_0 )); + C((std::countl_zero(umax_u32) == val_0 )); + C((std::countl_zero(umax_u48) == val_0 )); + C((std::countl_zero(umax_u64) == val_0 )); + C((std::countl_zero(smax_u8 ) == val_1 )); + C((std::countl_zero(smax_u16) == val_1 )); + C((std::countl_zero(smax_u24) == val_1 )); + C((std::countl_zero(smax_u32) == val_1 )); + C((std::countl_zero(smax_u48) == val_1 )); + C((std::countl_zero(smax_u64) == val_1 )); + C((std::countl_zero(smin_u8 ) == val_0 )); + C((std::countl_zero(smin_u16) == val_0 )); + C((std::countl_zero(smin_u24) == val_0 )); + C((std::countl_zero(smin_u32) == val_0 )); + C((std::countl_zero(smin_u48) == val_0 )); + C((std::countl_zero(smin_u64) == val_0 )); + return 0; +} +int test_countl_one(void) { C((std::countl_one(zero_u8 ) == val_0 )); C((std::countl_one(zero_u16) == val_0 )); C((std::countl_one(zero_u24) == val_0 )); C((std::countl_one(zero_u32) == val_0 )); C((std::countl_one(zero_u48) == val_0 )); C((std::countl_one(zero_u64) == val_0 )); - C((std::countl_one(ones_u8 ) == val_8 )); - C((std::countl_one(ones_u16) == val_16)); - C((std::countl_one(ones_u24) == val_24)); - C((std::countl_one(ones_u32) == val_32)); - C((std::countl_one(ones_u48) == val_48)); - C((std::countl_one(ones_u64) == val_64)); + C((std::countl_one( one_u8 ) == val_0 )); + C((std::countl_one( one_u16) == val_0 )); + C((std::countl_one( one_u24) == val_0 )); + C((std::countl_one( one_u32) == val_0 )); + C((std::countl_one( one_u48) == val_0 )); + C((std::countl_one( one_u64) == val_0 )); + C((std::countl_one(umax_u8 ) == val_8 )); + C((std::countl_one(umax_u16) == val_16)); + C((std::countl_one(umax_u24) == val_24)); + C((std::countl_one(umax_u32) == val_32)); + C((std::countl_one(umax_u48) == val_48)); + C((std::countl_one(umax_u64) == val_64)); + C((std::countl_one(smax_u8 ) == val_0 )); + C((std::countl_one(smax_u16) == val_0 )); + C((std::countl_one(smax_u24) == val_0 )); + C((std::countl_one(smax_u32) == val_0 )); + C((std::countl_one(smax_u48) == val_0 )); + C((std::countl_one(smax_u64) == val_0 )); + C((std::countl_one(smin_u8 ) == val_1 )); + C((std::countl_one(smin_u16) == val_1 )); + C((std::countl_one(smin_u24) == val_1 )); + C((std::countl_one(smin_u32) == val_1 )); + C((std::countl_one(smin_u48) == val_1 )); + C((std::countl_one(smin_u64) == val_1 )); + return 0; +} +int test_countr_zero(void) { C((std::countr_zero(zero_u8 ) == val_8 )); C((std::countr_zero(zero_u16) == val_16)); C((std::countr_zero(zero_u24) == val_24)); C((std::countr_zero(zero_u32) == val_32)); C((std::countr_zero(zero_u48) == val_48)); C((std::countr_zero(zero_u64) == val_64)); - C((std::countr_zero(ones_u8 ) == val_0 )); - C((std::countr_zero(ones_u16) == val_0 )); - C((std::countr_zero(ones_u24) == val_0 )); - C((std::countr_zero(ones_u32) == val_0 )); - C((std::countr_zero(ones_u48) == val_0 )); - C((std::countr_zero(ones_u64) == val_0 )); + C((std::countr_zero( one_u8 ) == val_0 )); + C((std::countr_zero( one_u16) == val_0 )); + C((std::countr_zero( one_u24) == val_0 )); + C((std::countr_zero( one_u32) == val_0 )); + C((std::countr_zero( one_u48) == val_0 )); + C((std::countr_zero( one_u64) == val_0 )); + C((std::countr_zero(umax_u8 ) == val_0 )); + C((std::countr_zero(umax_u16) == val_0 )); + C((std::countr_zero(umax_u24) == val_0 )); + C((std::countr_zero(umax_u32) == val_0 )); + C((std::countr_zero(umax_u48) == val_0 )); + C((std::countr_zero(umax_u64) == val_0 )); + C((std::countr_zero(smax_u8 ) == val_0 )); + C((std::countr_zero(smax_u16) == val_0 )); + C((std::countr_zero(smax_u24) == val_0 )); + C((std::countr_zero(smax_u32) == val_0 )); + C((std::countr_zero(smax_u48) == val_0 )); + C((std::countr_zero(smax_u64) == val_0 )); + C((std::countr_zero(smin_u8 ) == val_7 )); + C((std::countr_zero(smin_u16) == val_15)); + C((std::countr_zero(smin_u24) == val_23)); + C((std::countr_zero(smin_u32) == val_31)); + C((std::countr_zero(smin_u48) == val_47)); + C((std::countr_zero(smin_u64) == val_63)); + return 0; +} +int test_countr_one(void) { C((std::countr_one(zero_u8 ) == val_0 )); C((std::countr_one(zero_u16) == val_0 )); C((std::countr_one(zero_u24) == val_0 )); C((std::countr_one(zero_u32) == val_0 )); C((std::countr_one(zero_u48) == val_0 )); C((std::countr_one(zero_u64) == val_0 )); - C((std::countr_one(ones_u8 ) == val_8 )); - C((std::countr_one(ones_u16) == val_16)); - C((std::countr_one(ones_u24) == val_24)); - C((std::countr_one(ones_u32) == val_32)); - C((std::countr_one(ones_u48) == val_48)); - C((std::countr_one(ones_u64) == val_64)); + C((std::countr_one( one_u8 ) == val_1 )); + C((std::countr_one( one_u16) == val_1 )); + C((std::countr_one( one_u24) == val_1 )); + C((std::countr_one( one_u32) == val_1 )); + C((std::countr_one( one_u48) == val_1 )); + C((std::countr_one( one_u64) == val_1 )); + C((std::countr_one(umax_u8 ) == val_8 )); + C((std::countr_one(umax_u16) == val_16)); + C((std::countr_one(umax_u24) == val_24)); + C((std::countr_one(umax_u32) == val_32)); + C((std::countr_one(umax_u48) == val_48)); + C((std::countr_one(umax_u64) == val_64)); + C((std::countr_one(smax_u8 ) == val_7 )); + C((std::countr_one(smax_u16) == val_15)); + C((std::countr_one(smax_u24) == val_23)); + C((std::countr_one(smax_u32) == val_31)); + C((std::countr_one(smax_u48) == val_47)); + C((std::countr_one(smax_u64) == val_63)); + C((std::countr_one(smin_u8 ) == val_0 )); + C((std::countr_one(smin_u16) == val_0 )); + C((std::countr_one(smin_u24) == val_0 )); + C((std::countr_one(smin_u32) == val_0 )); + C((std::countr_one(smin_u48) == val_0 )); + C((std::countr_one(smin_u64) == val_0 )); + return 0; +} +int test_bit_width(void) { C((std::bit_width(zero_u8 ) == val_0 )); C((std::bit_width(zero_u16) == val_0 )); C((std::bit_width(zero_u24) == val_0 )); C((std::bit_width(zero_u32) == val_0 )); C((std::bit_width(zero_u48) == val_0 )); C((std::bit_width(zero_u64) == val_0 )); - C((std::bit_width(ones_u8 ) == val_8 )); - C((std::bit_width(ones_u16) == val_16)); - C((std::bit_width(ones_u24) == val_24)); - C((std::bit_width(ones_u32) == val_32)); - C((std::bit_width(ones_u48) == val_48)); - C((std::bit_width(ones_u64) == val_64)); - - C((std::bit_ceil(zero_u8 ) == val_1 )); - C((std::bit_ceil(zero_u16) == val_1 )); - C((std::bit_ceil(zero_u24) == val_1 )); - C((std::bit_ceil(zero_u32) == val_1 )); - C((std::bit_ceil(zero_u48) == val_1 )); - C((std::bit_ceil(zero_u64) == val_1 )); - - C((std::bit_floor(zero_u8 ) == val_0 )); - C((std::bit_floor(zero_u16) == val_0 )); - C((std::bit_floor(zero_u24) == val_0 )); - C((std::bit_floor(zero_u32) == val_0 )); - C((std::bit_floor(zero_u48) == val_0 )); - C((std::bit_floor(zero_u64) == val_0 )); + C((std::bit_width( one_u8 ) == val_1 )); + C((std::bit_width( one_u16) == val_1 )); + C((std::bit_width( one_u24) == val_1 )); + C((std::bit_width( one_u32) == val_1 )); + C((std::bit_width( one_u48) == val_1 )); + C((std::bit_width( one_u64) == val_1 )); + C((std::bit_width(umax_u8 ) == val_8 )); + C((std::bit_width(umax_u16) == val_16)); + C((std::bit_width(umax_u24) == val_24)); + C((std::bit_width(umax_u32) == val_32)); + C((std::bit_width(umax_u48) == val_48)); + C((std::bit_width(umax_u64) == val_64)); + C((std::bit_width(smax_u8 ) == val_7 )); + C((std::bit_width(smax_u16) == val_15)); + C((std::bit_width(smax_u24) == val_23)); + C((std::bit_width(smax_u32) == val_31)); + C((std::bit_width(smax_u48) == val_47)); + C((std::bit_width(smax_u64) == val_63)); + C((std::bit_width(smin_u8 ) == val_8 )); + C((std::bit_width(smin_u16) == val_16)); + C((std::bit_width(smin_u24) == val_24)); + C((std::bit_width(smin_u32) == val_32)); + C((std::bit_width(smin_u48) == val_48)); + C((std::bit_width(smin_u64) == val_64)); + return 0; +} +int test_bit_ceil(void) { + C((std::bit_ceil(zero_u8 ) == one_u8 )); + C((std::bit_ceil(zero_u16) == one_u16)); + C((std::bit_ceil(zero_u24) == one_u24)); + C((std::bit_ceil(zero_u32) == one_u32)); + C((std::bit_ceil(zero_u48) == one_u48)); + C((std::bit_ceil(zero_u64) == one_u64)); + C((std::bit_ceil( one_u8 ) == one_u8 )); + C((std::bit_ceil( one_u16) == one_u16)); + C((std::bit_ceil( one_u24) == one_u24)); + 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)); + C((std::bit_ceil(smax_u32) == smin_u32)); + C((std::bit_ceil(smax_u48) == smin_u48)); + C((std::bit_ceil(smax_u64) == smin_u64)); + C((std::bit_ceil(smin_u8 ) == smin_u8 )); + C((std::bit_ceil(smin_u16) == smin_u16)); + C((std::bit_ceil(smin_u24) == smin_u24)); + C((std::bit_ceil(smin_u32) == smin_u32)); + C((std::bit_ceil(smin_u48) == smin_u48)); + C((std::bit_ceil(smin_u64) == smin_u64)); + return 0; +} + +int test_bit_floor(void) { + C((std::bit_floor(zero_u8 ) == zero_u8 )); + C((std::bit_floor(zero_u16) == zero_u16)); + C((std::bit_floor(zero_u24) == zero_u24)); + C((std::bit_floor(zero_u32) == zero_u32)); + C((std::bit_floor(zero_u48) == zero_u48)); + C((std::bit_floor(zero_u64) == zero_u64)); + C((std::bit_floor( one_u8 ) == one_u8 )); + C((std::bit_floor( one_u16) == one_u16)); + C((std::bit_floor( one_u24) == one_u24)); + C((std::bit_floor( one_u32) == one_u32)); + C((std::bit_floor( one_u48) == one_u48)); + C((std::bit_floor( one_u64) == one_u64)); + C((std::bit_floor(umax_u8 ) == smin_u8 )); + C((std::bit_floor(umax_u16) == smin_u16)); + C((std::bit_floor(umax_u24) == smin_u24)); + C((std::bit_floor(umax_u32) == smin_u32)); + C((std::bit_floor(umax_u48) == smin_u48)); + C((std::bit_floor(umax_u64) == smin_u64)); + C((std::bit_floor(smax_u8 ) == smin_u8 >> 1)); + C((std::bit_floor(smax_u16) == smin_u16 >> 1)); + C((std::bit_floor(smax_u24) == smin_u24 >> 1)); + C((std::bit_floor(smax_u32) == smin_u32 >> 1)); + C((std::bit_floor(smax_u48) == smin_u48 >> 1)); + C((std::bit_floor(smax_u64) == smin_u64 >> 1)); + C((std::bit_floor(smin_u8 ) == smin_u8 )); + C((std::bit_floor(smin_u16) == smin_u16)); + C((std::bit_floor(smin_u24) == smin_u24)); + C((std::bit_floor(smin_u32) == smin_u32)); + C((std::bit_floor(smin_u48) == smin_u48)); + C((std::bit_floor(smin_u64) == smin_u64)); + return 0; +} + +int test_popcount(void) { C((std::popcount(zero_u8 ) == val_0 )); C((std::popcount(zero_u16) == val_0 )); C((std::popcount(zero_u24) == val_0 )); C((std::popcount(zero_u32) == val_0 )); C((std::popcount(zero_u48) == val_0 )); C((std::popcount(zero_u64) == val_0 )); - C((std::popcount(ones_u8 ) == val_8 )); - C((std::popcount(ones_u16) == val_16)); - C((std::popcount(ones_u24) == val_24)); - C((std::popcount(ones_u32) == val_32)); - C((std::popcount(ones_u48) == val_48)); - C((std::popcount(ones_u64) == val_64)); + C((std::popcount( one_u8 ) == val_1 )); + C((std::popcount( one_u16) == val_1 )); + C((std::popcount( one_u24) == val_1 )); + C((std::popcount( one_u32) == val_1 )); + C((std::popcount( one_u48) == val_1 )); + C((std::popcount( one_u64) == val_1 )); + C((std::popcount(umax_u8 ) == val_8 )); + C((std::popcount(umax_u16) == val_16)); + C((std::popcount(umax_u24) == val_24)); + C((std::popcount(umax_u32) == val_32)); + C((std::popcount(umax_u48) == val_48)); + C((std::popcount(umax_u64) == val_64)); + C((std::popcount(smax_u8 ) == val_7 )); + C((std::popcount(smax_u16) == val_15)); + C((std::popcount(smax_u24) == val_23)); + C((std::popcount(smax_u32) == val_31)); + C((std::popcount(smax_u48) == val_47)); + C((std::popcount(smax_u64) == val_63)); + C((std::popcount(smin_u8 ) == val_1 )); + C((std::popcount(smin_u16) == val_1 )); + C((std::popcount(smin_u24) == val_1 )); + C((std::popcount(smin_u32) == val_1 )); + C((std::popcount(smin_u48) == val_1 )); + C((std::popcount(smin_u64) == val_1 )); return 0; } @@ -281,7 +461,7 @@ static inline bool verify_bit_ceil(void) { return true; } -int test_bit_ceil(void) { +int extra_test_bit_ceil(void) { C((verify_bit_ceil())); C((verify_bit_ceil())); C((verify_bit_ceil())); @@ -311,7 +491,7 @@ static inline bool verify_bit_floor(void) { return true; } -int test_bit_floor(void) { +int extra_test_bit_floor(void) { C((verify_bit_floor())); C((verify_bit_floor())); C((verify_bit_floor())); @@ -362,9 +542,16 @@ int run_tests(void) { int ret = 0; TEST(test_byteswap()); TEST(test_stdbit()); - TEST(test_cxxbit_edge_cases()); + TEST(test_countl_zero()); + TEST(test_countl_one()); + TEST(test_countr_zero()); + TEST(test_countr_one()); + TEST(test_bit_width()); TEST(test_bit_ceil()); TEST(test_bit_floor()); + TEST(test_popcount()); + TEST(extra_test_bit_ceil()); + TEST(extra_test_bit_floor()); TEST(test_rotate()); return ret; } diff --git a/test/standalone/stdbit/src/test.c b/test/standalone/stdbit/src/test.c index e666b03b3..7bf51ed86 100644 --- a/test/standalone/stdbit/src/test.c +++ b/test/standalone/stdbit/src/test.c @@ -5,59 +5,147 @@ #include "data.h" -#define C(expr) do { if (!(expr)) { return __LINE__; } } while(0) - -int test_stdbit(void) { +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 (ones_u8 ) == val_0 )); - C((stdc_leading_zeros_us (ones_u16) == val_0 )); - C((stdc_leading_zeros_ui (ones_u24) == val_0 )); - C((stdc_leading_zeros_ul (ones_u32) == val_0 )); - C((stdc_leading_zeros_ui48(ones_u48) == val_0 )); - C((stdc_leading_zeros_ull (ones_u64) == val_0 )); + 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 )); + 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 (ones_u8 ) == val_0 )); - C((stdc_trailing_zeros_us (ones_u16) == val_0 )); - C((stdc_trailing_zeros_ui (ones_u24) == val_0 )); - C((stdc_trailing_zeros_ul (ones_u32) == val_0 )); - C((stdc_trailing_zeros_ui48(ones_u48) == val_0 )); - C((stdc_trailing_zeros_ull (ones_u64) == val_0 )); + 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)); + 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 (ones_u8 ) == val_1 )); - C((stdc_first_trailing_one_us (ones_u16) == val_1 )); - C((stdc_first_trailing_one_ui (ones_u24) == val_1 )); - C((stdc_first_trailing_one_ul (ones_u32) == val_1 )); - C((stdc_first_trailing_one_ui48(ones_u48) == val_1 )); - C((stdc_first_trailing_one_ull (ones_u64) == val_1 )); + 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)); + 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 (ones_u8 ) == val_8 )); - C((stdc_count_ones_us (ones_u16) == val_16)); - C((stdc_count_ones_ui (ones_u24) == val_24)); - C((stdc_count_ones_ul (ones_u32) == val_32)); - C((stdc_count_ones_ui48(ones_u48) == val_48)); - C((stdc_count_ones_ull (ones_u64) == val_64)); + 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 )); + 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()); return 0; }