| // RUN: %clang_cc1 -triple x86_64-unknown-unknown -std=c++14 -fsyntax-only -verify %s |
| // RUN: %clang_cc1 -triple x86_64-unknown-unknown -std=c++14 -fsyntax-only -verify %s -fexperimental-new-constant-interpreter |
| // RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify %s |
| // RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify %s -fexperimental-new-constant-interpreter |
| |
| namespace test_stdc_leading_zeros { |
| |
| static_assert(__builtin_stdc_leading_zeros((unsigned char)0) == 8, ""); |
| static_assert(__builtin_stdc_leading_zeros((unsigned char)1) == 7, ""); |
| static_assert(__builtin_stdc_leading_zeros((unsigned char)0x80) == 0, ""); |
| static_assert(__builtin_stdc_leading_zeros((unsigned char)0xFF) == 0, ""); |
| static_assert(__builtin_stdc_leading_zeros((unsigned short)0) == 16, ""); |
| static_assert(__builtin_stdc_leading_zeros((unsigned short)1) == 15, ""); |
| static_assert(__builtin_stdc_leading_zeros((unsigned short)0x8000) == 0, ""); |
| static_assert(__builtin_stdc_leading_zeros(0U) == 32, ""); |
| static_assert(__builtin_stdc_leading_zeros(1U) == 31, ""); |
| static_assert(__builtin_stdc_leading_zeros(0x80000000U) == 0, ""); |
| static_assert(__builtin_stdc_leading_zeros(0ULL) == 64, ""); |
| static_assert(__builtin_stdc_leading_zeros(1ULL) == 63, ""); |
| static_assert(__builtin_stdc_leading_zeros(0x8000000000000000ULL) == 0, ""); |
| |
| } // namespace test_stdc_leading_zeros |
| |
| namespace test_stdc_leading_ones { |
| |
| static_assert(__builtin_stdc_leading_ones((unsigned char)0) == 0, ""); |
| static_assert(__builtin_stdc_leading_ones((unsigned char)0xFF) == 8, ""); |
| static_assert(__builtin_stdc_leading_ones((unsigned char)0xF0) == 4, ""); |
| static_assert(__builtin_stdc_leading_ones((unsigned short)0) == 0, ""); |
| static_assert(__builtin_stdc_leading_ones((unsigned short)0xFFFF) == 16, ""); |
| static_assert(__builtin_stdc_leading_ones((unsigned short)0xF000) == 4, ""); |
| static_assert(__builtin_stdc_leading_ones(0U) == 0, ""); |
| static_assert(__builtin_stdc_leading_ones(0xFFFFFFFFU) == 32, ""); |
| static_assert(__builtin_stdc_leading_ones(0xF0000000U) == 4, ""); |
| static_assert(__builtin_stdc_leading_ones(0ULL) == 0, ""); |
| static_assert(__builtin_stdc_leading_ones(0xFFFFFFFFFFFFFFFFULL) == 64, ""); |
| |
| } // namespace test_stdc_leading_ones |
| |
| namespace test_stdc_trailing_zeros { |
| |
| static_assert(__builtin_stdc_trailing_zeros((unsigned char)0) == 8, ""); |
| static_assert(__builtin_stdc_trailing_zeros((unsigned char)1) == 0, ""); |
| static_assert(__builtin_stdc_trailing_zeros((unsigned char)0x80) == 7, ""); |
| static_assert(__builtin_stdc_trailing_zeros((unsigned short)0) == 16, ""); |
| static_assert(__builtin_stdc_trailing_zeros((unsigned short)1) == 0, ""); |
| static_assert(__builtin_stdc_trailing_zeros((unsigned short)0x8000) == 15, ""); |
| static_assert(__builtin_stdc_trailing_zeros(0U) == 32, ""); |
| static_assert(__builtin_stdc_trailing_zeros(1U) == 0, ""); |
| static_assert(__builtin_stdc_trailing_zeros(0x80000000U) == 31, ""); |
| static_assert(__builtin_stdc_trailing_zeros(0ULL) == 64, ""); |
| static_assert(__builtin_stdc_trailing_zeros(1ULL) == 0, ""); |
| static_assert(__builtin_stdc_trailing_zeros(0x8000000000000000ULL) == 63, ""); |
| |
| } // namespace test_stdc_trailing_zeros |
| |
| namespace test_stdc_trailing_ones { |
| |
| static_assert(__builtin_stdc_trailing_ones((unsigned char)0) == 0, ""); |
| static_assert(__builtin_stdc_trailing_ones((unsigned char)0xFF) == 8, ""); |
| static_assert(__builtin_stdc_trailing_ones((unsigned char)0x0F) == 4, ""); |
| static_assert(__builtin_stdc_trailing_ones((unsigned short)0) == 0, ""); |
| static_assert(__builtin_stdc_trailing_ones((unsigned short)0xFFFF) == 16, ""); |
| static_assert(__builtin_stdc_trailing_ones((unsigned short)0x000F) == 4, ""); |
| static_assert(__builtin_stdc_trailing_ones(0U) == 0, ""); |
| static_assert(__builtin_stdc_trailing_ones(1U) == 1, ""); |
| static_assert(__builtin_stdc_trailing_ones(0xFFFFFFFFU) == 32, ""); |
| static_assert(__builtin_stdc_trailing_ones(0x0000000FU) == 4, ""); |
| static_assert(__builtin_stdc_trailing_ones(0ULL) == 0, ""); |
| static_assert(__builtin_stdc_trailing_ones(1ULL) == 1, ""); |
| static_assert(__builtin_stdc_trailing_ones(0xFFFFFFFFFFFFFFFFULL) == 64, ""); |
| |
| } // namespace test_stdc_trailing_ones |
| |
| namespace test_stdc_first_leading_zero { |
| |
| static_assert(__builtin_stdc_first_leading_zero((unsigned char)0) == 1, ""); |
| static_assert(__builtin_stdc_first_leading_zero((unsigned char)0xFF) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_zero((unsigned char)0xF0) == 5, ""); |
| static_assert(__builtin_stdc_first_leading_zero((unsigned char)0x80) == 2, ""); |
| static_assert(__builtin_stdc_first_leading_zero((unsigned short)0) == 1, ""); |
| static_assert(__builtin_stdc_first_leading_zero((unsigned short)0xFFFF) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_zero((unsigned short)0xF000) == 5, ""); |
| static_assert(__builtin_stdc_first_leading_zero(0xFFFFFFFFU) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_zero(0xF0000000U) == 5, ""); |
| static_assert(__builtin_stdc_first_leading_zero(0ULL) == 1, ""); |
| static_assert(__builtin_stdc_first_leading_zero(0xFFFFFFFFFFFFFFFFULL) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_zero(0xF000000000000000ULL) == 5, ""); |
| |
| } // namespace test_stdc_first_leading_zero |
| |
| namespace test_stdc_first_leading_one { |
| |
| static_assert(__builtin_stdc_first_leading_one((unsigned char)0) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_one((unsigned char)0x80) == 1, ""); |
| static_assert(__builtin_stdc_first_leading_one((unsigned char)0x01) == 8, ""); |
| static_assert(__builtin_stdc_first_leading_one((unsigned char)0x0F) == 5, ""); |
| static_assert(__builtin_stdc_first_leading_one((unsigned short)0) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_one((unsigned short)0x8000) == 1, ""); |
| static_assert(__builtin_stdc_first_leading_one((unsigned short)1) == 16, ""); |
| static_assert(__builtin_stdc_first_leading_one(0U) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_one(0x80000000U) == 1, ""); |
| static_assert(__builtin_stdc_first_leading_one(1U) == 32, ""); |
| static_assert(__builtin_stdc_first_leading_one(0ULL) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_one(0x8000000000000000ULL) == 1, ""); |
| static_assert(__builtin_stdc_first_leading_one(1ULL) == 64, ""); |
| |
| } // namespace test_stdc_first_leading_one |
| |
| namespace test_stdc_first_trailing_zero { |
| |
| static_assert(__builtin_stdc_first_trailing_zero((unsigned char)0) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_zero((unsigned char)0xFF) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_zero((unsigned char)0x0F) == 5, ""); |
| static_assert(__builtin_stdc_first_trailing_zero((unsigned char)0x01) == 2, ""); |
| static_assert(__builtin_stdc_first_trailing_zero((unsigned short)0) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_zero((unsigned short)0xFFFF) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_zero((unsigned short)0x000F) == 5, ""); |
| static_assert(__builtin_stdc_first_trailing_zero(0xFFFFFFFFU) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_zero(0x0000000FU) == 5, ""); |
| static_assert(__builtin_stdc_first_trailing_zero(0ULL) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_zero(0xFFFFFFFFFFFFFFFFULL) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_zero(0x000000000000000FULL) == 5, ""); |
| |
| } // namespace test_stdc_first_trailing_zero |
| |
| namespace test_stdc_first_trailing_one { |
| |
| static_assert(__builtin_stdc_first_trailing_one((unsigned char)0) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_one((unsigned char)0x01) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_one((unsigned char)0x80) == 8, ""); |
| static_assert(__builtin_stdc_first_trailing_one((unsigned char)0xF0) == 5, ""); |
| static_assert(__builtin_stdc_first_trailing_one((unsigned short)0) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_one((unsigned short)1) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_one((unsigned short)0x8000) == 16, ""); |
| static_assert(__builtin_stdc_first_trailing_one(0U) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_one(0x80000000U) == 32, ""); |
| static_assert(__builtin_stdc_first_trailing_one(1U) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_one(0ULL) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_one(1ULL) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_one(0x8000000000000000ULL) == 64, ""); |
| |
| } // namespace test_stdc_first_trailing_one |
| |
| namespace test_stdc_count_zeros { |
| |
| static_assert(__builtin_stdc_count_zeros((unsigned char)0) == 8, ""); |
| static_assert(__builtin_stdc_count_zeros((unsigned char)0xFF) == 0, ""); |
| static_assert(__builtin_stdc_count_zeros((unsigned char)0xAA) == 4, ""); |
| static_assert(__builtin_stdc_count_zeros((unsigned short)0) == 16, ""); |
| static_assert(__builtin_stdc_count_zeros((unsigned short)0xFFFF) == 0, ""); |
| static_assert(__builtin_stdc_count_zeros((unsigned short)0xAAAA) == 8, ""); |
| static_assert(__builtin_stdc_count_zeros(0U) == 32, ""); |
| static_assert(__builtin_stdc_count_zeros(0xFFFFFFFFU) == 0, ""); |
| static_assert(__builtin_stdc_count_zeros(0xAAAAAAAAU) == 16, ""); |
| static_assert(__builtin_stdc_count_zeros(0ULL) == 64, ""); |
| static_assert(__builtin_stdc_count_zeros(0xFFFFFFFFFFFFFFFFULL) == 0, ""); |
| static_assert(__builtin_stdc_count_zeros(0xAAAAAAAAAAAAAAAAULL) == 32, ""); |
| |
| } // namespace test_stdc_count_zeros |
| |
| namespace test_stdc_count_ones { |
| |
| static_assert(__builtin_stdc_count_ones((unsigned char)0) == 0, ""); |
| static_assert(__builtin_stdc_count_ones((unsigned char)0xFF) == 8, ""); |
| static_assert(__builtin_stdc_count_ones((unsigned char)0xAA) == 4, ""); |
| static_assert(__builtin_stdc_count_ones((unsigned short)0) == 0, ""); |
| static_assert(__builtin_stdc_count_ones((unsigned short)0xFFFF) == 16, ""); |
| static_assert(__builtin_stdc_count_ones((unsigned short)0xAAAA) == 8, ""); |
| static_assert(__builtin_stdc_count_ones(0U) == 0, ""); |
| static_assert(__builtin_stdc_count_ones(0xFFFFFFFFU) == 32, ""); |
| static_assert(__builtin_stdc_count_ones(0xAAAAAAAAU) == 16, ""); |
| static_assert(__builtin_stdc_count_ones(0ULL) == 0, ""); |
| static_assert(__builtin_stdc_count_ones(0xFFFFFFFFFFFFFFFFULL) == 64, ""); |
| static_assert(__builtin_stdc_count_ones(0xAAAAAAAAAAAAAAAAULL) == 32, ""); |
| |
| } // namespace test_stdc_count_ones |
| |
| namespace test_stdc_has_single_bit { |
| |
| static_assert(__builtin_stdc_has_single_bit((unsigned char)0) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned char)1) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned char)2) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned char)3) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned char)0x80) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned short)0) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned short)1) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned short)0x8000) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned short)0xFFFF) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit(0U) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit(1U) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit(0x80000000U) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit(0xFFFFFFFFU) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit(0ULL) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit(1ULL) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit(0x8000000000000000ULL) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit(0xFFFFFFFFFFFFFFFFULL) == 0, ""); |
| |
| } // namespace test_stdc_has_single_bit |
| |
| namespace test_stdc_bit_width { |
| |
| static_assert(__builtin_stdc_bit_width((unsigned char)0) == 0, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned char)1) == 1, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned char)2) == 2, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned char)3) == 2, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned char)0x80) == 8, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned char)0xFF) == 8, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned short)0) == 0, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned short)1) == 1, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned short)0x8000) == 16, ""); |
| static_assert(__builtin_stdc_bit_width(0U) == 0, ""); |
| static_assert(__builtin_stdc_bit_width(1U) == 1, ""); |
| static_assert(__builtin_stdc_bit_width(0x80000000U) == 32, ""); |
| static_assert(__builtin_stdc_bit_width(0ULL) == 0, ""); |
| static_assert(__builtin_stdc_bit_width(1ULL) == 1, ""); |
| static_assert(__builtin_stdc_bit_width(0x8000000000000000ULL) == 64, ""); |
| |
| } // namespace test_stdc_bit_width |
| |
| namespace test_stdc_bit_floor { |
| |
| static_assert(__builtin_stdc_bit_floor((unsigned char)0) == 0, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned char)1) == 1, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned char)2) == 2, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned char)3) == 2, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned char)4) == 4, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned char)5) == 4, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned char)0x80) == 0x80, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned char)0xFF) == 0x80, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned short)0) == 0, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned short)1) == 1, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned short)0xFFFF) == 0x8000, ""); |
| static_assert(__builtin_stdc_bit_floor(0U) == 0U, ""); |
| static_assert(__builtin_stdc_bit_floor(1U) == 1U, ""); |
| static_assert(__builtin_stdc_bit_floor(7U) == 4U, ""); |
| static_assert(__builtin_stdc_bit_floor(0x80000000U) == 0x80000000U, ""); |
| static_assert(__builtin_stdc_bit_floor(0xFFFFFFFFU) == 0x80000000U, ""); |
| static_assert(__builtin_stdc_bit_floor(0ULL) == 0ULL, ""); |
| static_assert(__builtin_stdc_bit_floor(1ULL) == 1ULL, ""); |
| static_assert(__builtin_stdc_bit_floor(0xFFFFFFFFFFFFFFFFULL) == 0x8000000000000000ULL, ""); |
| |
| } // namespace test_stdc_bit_floor |
| |
| namespace test_stdc_bit_ceil { |
| |
| static_assert(__builtin_stdc_bit_ceil((unsigned char)0) == 1, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned char)1) == 1, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned char)2) == 2, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned char)3) == 4, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned char)4) == 4, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned char)5) == 8, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned char)0x80) == 0x80, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned short)0) == 1, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned short)1) == 1, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned short)7) == 8, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned short)0x8000) == 0x8000, ""); |
| static_assert(__builtin_stdc_bit_ceil(0U) == 1U, ""); |
| static_assert(__builtin_stdc_bit_ceil(1U) == 1U, ""); |
| static_assert(__builtin_stdc_bit_ceil(7U) == 8U, ""); |
| static_assert(__builtin_stdc_bit_ceil(0x80000000U) == 0x80000000U, ""); |
| // Overflow: next power of 2 exceeds type width; wraps to zero. |
| static_assert(__builtin_stdc_bit_ceil(0xFFFFFFFFU) == 0U, ""); |
| static_assert(__builtin_stdc_bit_ceil(0ULL) == 1ULL, ""); |
| static_assert(__builtin_stdc_bit_ceil(1ULL) == 1ULL, ""); |
| static_assert(__builtin_stdc_bit_ceil(7ULL) == 8ULL, ""); |
| static_assert(__builtin_stdc_bit_ceil(0x8000000000000000ULL) == 0x8000000000000000ULL, ""); |
| |
| } // namespace test_stdc_bit_ceil |
| |
| #ifdef __SIZEOF_INT128__ |
| namespace test_int128 { |
| |
| static_assert(__builtin_stdc_leading_zeros((unsigned __int128)0) == 128, ""); |
| static_assert(__builtin_stdc_leading_zeros((unsigned __int128)1) == 127, ""); |
| static_assert(__builtin_stdc_leading_ones((unsigned __int128)0) == 0, ""); |
| static_assert(__builtin_stdc_leading_ones((unsigned __int128)-1) == 128, ""); |
| static_assert(__builtin_stdc_trailing_zeros((unsigned __int128)0) == 128, ""); |
| static_assert(__builtin_stdc_trailing_zeros((unsigned __int128)1) == 0, ""); |
| static_assert(__builtin_stdc_trailing_ones((unsigned __int128)0) == 0, ""); |
| static_assert(__builtin_stdc_trailing_ones((unsigned __int128)-1) == 128, ""); |
| static_assert(__builtin_stdc_first_leading_zero((unsigned __int128)0) == 1, ""); |
| static_assert(__builtin_stdc_first_leading_zero((unsigned __int128)-1) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_one((unsigned __int128)0) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_zero((unsigned __int128)0) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_zero((unsigned __int128)-1) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_one((unsigned __int128)0) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_one((unsigned __int128)1) == 1, ""); |
| static_assert(__builtin_stdc_count_ones((unsigned __int128)0xFFFFFFFF) == 32, ""); |
| static_assert(__builtin_stdc_count_zeros((unsigned __int128)0) == 128, ""); |
| static_assert(__builtin_stdc_count_zeros((unsigned __int128)-1) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned __int128)1) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned __int128)0) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned __int128)3) == 0, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned __int128)0) == 0, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned __int128)1) == 1, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned __int128)0) == 0, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned __int128)1) == 1, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned __int128)0) == 1, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned __int128)1) == 1, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned __int128)3) == 4, ""); |
| |
| // MSB tests using constexpr to form the value. |
| constexpr unsigned __int128 int128_one = 1; |
| constexpr unsigned __int128 int128_msb = int128_one << 127; |
| static_assert(__builtin_stdc_leading_zeros(int128_msb) == 0, ""); |
| static_assert(__builtin_stdc_leading_ones(int128_msb) == 1, ""); |
| static_assert(__builtin_stdc_trailing_zeros(int128_msb) == 127, ""); |
| static_assert(__builtin_stdc_trailing_ones(int128_msb) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_zero(int128_msb) == 2, ""); |
| static_assert(__builtin_stdc_first_leading_one(int128_msb) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_zero(int128_msb) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_one(int128_msb) == 128, ""); |
| static_assert(__builtin_stdc_count_ones(int128_msb) == 1, ""); |
| static_assert(__builtin_stdc_count_zeros(int128_msb) == 127, ""); |
| static_assert(__builtin_stdc_has_single_bit(int128_msb) == 1, ""); |
| static_assert(__builtin_stdc_bit_width(int128_msb) == 128, ""); |
| static_assert(__builtin_stdc_bit_floor(int128_msb) == int128_msb, ""); |
| static_assert(__builtin_stdc_bit_ceil(int128_msb) == int128_msb, ""); |
| |
| } // namespace test_int128 |
| #endif // __SIZEOF_INT128__ |
| |
| namespace test_bitint { |
| |
| // _BitInt(37): all 14 builtins |
| static_assert(__builtin_stdc_leading_zeros((unsigned _BitInt(37))0) == 37, ""); |
| static_assert(__builtin_stdc_leading_zeros((unsigned _BitInt(37))1) == 36, ""); |
| static_assert(__builtin_stdc_leading_ones((unsigned _BitInt(37))0) == 0, ""); |
| static_assert(__builtin_stdc_leading_ones((unsigned _BitInt(37))-1) == 37, ""); |
| static_assert(__builtin_stdc_trailing_zeros((unsigned _BitInt(37))0) == 37, ""); |
| static_assert(__builtin_stdc_trailing_zeros((unsigned _BitInt(37))1) == 0, ""); |
| static_assert(__builtin_stdc_trailing_ones((unsigned _BitInt(37))0) == 0, ""); |
| static_assert(__builtin_stdc_trailing_ones((unsigned _BitInt(37))-1) == 37, ""); |
| static_assert(__builtin_stdc_first_leading_zero((unsigned _BitInt(37))0) == 1, ""); |
| static_assert(__builtin_stdc_first_leading_zero((unsigned _BitInt(37))-1) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_one((unsigned _BitInt(37))0) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_one((unsigned _BitInt(37))1) == 37, ""); |
| static_assert(__builtin_stdc_first_trailing_zero((unsigned _BitInt(37))0) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_zero((unsigned _BitInt(37))-1) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_one((unsigned _BitInt(37))0) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_one((unsigned _BitInt(37))1) == 1, ""); |
| static_assert(__builtin_stdc_count_ones((unsigned _BitInt(37))0x1F) == 5, ""); |
| static_assert(__builtin_stdc_count_zeros((unsigned _BitInt(37))0) == 37, ""); |
| static_assert(__builtin_stdc_count_zeros((unsigned _BitInt(37))-1) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned _BitInt(37))0x10) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned _BitInt(37))0) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned _BitInt(37))3) == 0, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned _BitInt(37))0x10) == 5, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned _BitInt(37))0) == 0, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned _BitInt(37))-1) == 37, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned _BitInt(37))0x1F) == 0x10, ""); |
| static_assert(__builtin_stdc_bit_ceil((unsigned _BitInt(37))0x11) == 0x20, ""); |
| // Overflow: next power of 2 exceeds _BitInt(17) width; wraps to zero. |
| static_assert(__builtin_stdc_bit_ceil((unsigned _BitInt(17))(-1)) == |
| (unsigned _BitInt(17))(0), ""); |
| |
| // _BitInt(128): sparse pattern, leading zero count, popcount. |
| constexpr unsigned _BitInt(128) bi128_pattern = 0x123456789ABCDEF0ULL; |
| static_assert(__builtin_stdc_count_ones(bi128_pattern) == 32, ""); |
| static_assert(__builtin_stdc_leading_zeros(bi128_pattern) == 67, ""); |
| static_assert(__builtin_stdc_count_zeros(bi128_pattern) == 96, ""); |
| |
| // _BitInt(9): boundary width near a byte. |
| static_assert(__builtin_stdc_leading_zeros((unsigned _BitInt(9))0) == 9, ""); |
| static_assert(__builtin_stdc_trailing_zeros((unsigned _BitInt(9))0x100) == 8, ""); |
| static_assert(__builtin_stdc_count_ones((unsigned _BitInt(9))0x1FF) == 9, ""); |
| static_assert(__builtin_stdc_count_zeros((unsigned _BitInt(9))0x1FF) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit((unsigned _BitInt(9))0x100) == 1, ""); |
| static_assert(__builtin_stdc_bit_width((unsigned _BitInt(9))0x100) == 9, ""); |
| static_assert(__builtin_stdc_bit_floor((unsigned _BitInt(9))0x1FF) == 0x100, ""); |
| |
| } // namespace test_bitint |
| |
| namespace test_stdc_ulong { |
| |
| constexpr unsigned long ULongWidth = __SIZEOF_LONG__ * 8; |
| constexpr unsigned long ULongMSB = 1UL << (ULongWidth - 1); |
| constexpr unsigned long ULongAllOnes = ~0UL; |
| constexpr unsigned long ULongTopNibbleOnes = ULongAllOnes << (ULongWidth - 4); |
| |
| static_assert(__builtin_stdc_leading_zeros(0UL) == ULongWidth, ""); |
| static_assert(__builtin_stdc_leading_zeros(1UL) == ULongWidth - 1, ""); |
| static_assert(__builtin_stdc_leading_zeros(ULongMSB) == 0, ""); |
| static_assert(__builtin_stdc_leading_ones(0UL) == 0, ""); |
| static_assert(__builtin_stdc_leading_ones(ULongAllOnes) == ULongWidth, ""); |
| static_assert(__builtin_stdc_leading_ones(ULongTopNibbleOnes) == 4, ""); |
| static_assert(__builtin_stdc_trailing_zeros(0UL) == ULongWidth, ""); |
| static_assert(__builtin_stdc_trailing_zeros(1UL) == 0, ""); |
| static_assert(__builtin_stdc_trailing_zeros(ULongMSB) == ULongWidth - 1, ""); |
| static_assert(__builtin_stdc_trailing_ones(0UL) == 0, ""); |
| static_assert(__builtin_stdc_trailing_ones(ULongAllOnes) == ULongWidth, ""); |
| static_assert(__builtin_stdc_trailing_ones(0xFUL) == 4, ""); |
| static_assert(__builtin_stdc_first_leading_zero(0UL) == 1, ""); |
| static_assert(__builtin_stdc_first_leading_zero(ULongAllOnes) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_zero(ULongTopNibbleOnes) == 5, ""); |
| static_assert(__builtin_stdc_first_leading_one(0UL) == 0, ""); |
| static_assert(__builtin_stdc_first_leading_one(ULongMSB) == 1, ""); |
| static_assert(__builtin_stdc_first_leading_one(1UL) == ULongWidth, ""); |
| static_assert(__builtin_stdc_first_trailing_zero(0UL) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_zero(ULongAllOnes) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_zero(0xFUL) == 5, ""); |
| static_assert(__builtin_stdc_first_trailing_one(0UL) == 0, ""); |
| static_assert(__builtin_stdc_first_trailing_one(1UL) == 1, ""); |
| static_assert(__builtin_stdc_first_trailing_one(ULongMSB) == ULongWidth, ""); |
| static_assert(__builtin_stdc_count_zeros(0UL) == ULongWidth, ""); |
| static_assert(__builtin_stdc_count_zeros(ULongAllOnes) == 0, ""); |
| static_assert(__builtin_stdc_count_zeros(ULongMSB) == ULongWidth - 1, ""); |
| static_assert(__builtin_stdc_count_ones(0UL) == 0, ""); |
| static_assert(__builtin_stdc_count_ones(ULongAllOnes) == ULongWidth, ""); |
| static_assert(__builtin_stdc_count_ones(ULongMSB) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit(0UL) == 0, ""); |
| static_assert(__builtin_stdc_has_single_bit(1UL) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit(ULongMSB) == 1, ""); |
| static_assert(__builtin_stdc_has_single_bit(ULongAllOnes) == 0, ""); |
| static_assert(__builtin_stdc_bit_width(0UL) == 0, ""); |
| static_assert(__builtin_stdc_bit_width(1UL) == 1, ""); |
| static_assert(__builtin_stdc_bit_width(ULongMSB) == ULongWidth, ""); |
| static_assert(__builtin_stdc_bit_floor(0UL) == 0UL, ""); |
| static_assert(__builtin_stdc_bit_floor(1UL) == 1UL, ""); |
| static_assert(__builtin_stdc_bit_floor(ULongAllOnes) == ULongMSB, ""); |
| static_assert(__builtin_stdc_bit_ceil(0UL) == 1UL, ""); |
| static_assert(__builtin_stdc_bit_ceil(1UL) == 1UL, ""); |
| static_assert(__builtin_stdc_bit_ceil(7UL) == 8UL, ""); |
| static_assert(__builtin_stdc_bit_ceil(ULongMSB) == ULongMSB, ""); |
| |
| } // namespace test_stdc_ulong |
| |
| namespace test_errors { |
| |
| void test_invalid_types(int si, float f) { |
| __builtin_stdc_leading_zeros(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_leading_zeros(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| __builtin_stdc_leading_zeros(-1); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| |
| __builtin_stdc_leading_ones(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_leading_ones(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| |
| __builtin_stdc_trailing_zeros(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_trailing_zeros(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| |
| __builtin_stdc_trailing_ones(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_trailing_ones(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| |
| __builtin_stdc_first_leading_zero(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_first_leading_zero(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| |
| __builtin_stdc_first_leading_one(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_first_leading_one(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| |
| __builtin_stdc_first_trailing_zero(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_first_trailing_zero(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| |
| __builtin_stdc_first_trailing_one(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_first_trailing_one(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| |
| __builtin_stdc_count_ones(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_count_ones(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| |
| __builtin_stdc_count_zeros(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_count_zeros(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| |
| __builtin_stdc_has_single_bit(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_has_single_bit(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| |
| __builtin_stdc_bit_width(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_bit_width(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| |
| __builtin_stdc_bit_floor(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_bit_floor(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| |
| __builtin_stdc_bit_ceil(si); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}} |
| __builtin_stdc_bit_ceil(f); // expected-error {{1st argument must be a scalar unsigned integer type (was 'float')}} |
| } |
| |
| } // namespace test_errors |
