================
@@ -0,0 +1,476 @@
+// 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; implementation wraps.
+static_assert(__builtin_stdc_bit_ceil(0xFFFFFFFFU) == 0xFFFFFFFFU, "");
----------------
efriedma-quic wrote:
gcc does not agree with `static_assert(__builtin_stdc_bit_ceil(0xFFFFFFFFU) ==
0xFFFFFFFFU, "");`.
It's probably worth comparing the output for all your tests with gcc.
https://github.com/llvm/llvm-project/pull/185978
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
