derek.holloway
7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
CodeQL / Analyze (python) (push) Canceled after 0s
pre-commit / pre-commit (push) Canceled after 0s
Multi-Arch CI / setup (push) Canceled after 0s
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Setup (Multi-Arch) / setup (push) Canceled after 0s
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Multi-Arch CI / CI Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
659 lines
43 KiB
C
659 lines
43 KiB
C
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -std=c23 -fsyntax-only -verify %s
|
|
// RUN: %clang_cc1 -std=c23 -fsyntax-only -verify %s
|
|
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -std=c23 -isystem %S/Inputs -fsyntax-only -verify %s
|
|
|
|
// 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, "");
|
|
|
|
// 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, "");
|
|
|
|
// 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, "");
|
|
|
|
// 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, "");
|
|
|
|
// 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, "");
|
|
|
|
// 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, "");
|
|
|
|
// 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, "");
|
|
|
|
// 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, "");
|
|
|
|
// 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, "");
|
|
|
|
// 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, "");
|
|
|
|
// 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, "");
|
|
|
|
// 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, "");
|
|
|
|
// 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, "");
|
|
|
|
// 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 char)0x81) == 0, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil((unsigned char)0xFE) == 0, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil((unsigned char)0xFF) == 0, "");
|
|
_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((unsigned short)0x8001) == 0, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil((unsigned short)0xFFFF) == 0, "");
|
|
_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, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil(0x80000001U) == 0U, "");
|
|
_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, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil(0x8000000000000001ULL) == 0ULL, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil(0xFFFFFFFFFFFFFFFFULL) == 0ULL, "");
|
|
|
|
// Test with _BitInt types - cover 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, "");
|
|
|
|
#ifdef __SIZEOF_INT128__
|
|
// Test with __int128 - cover all 14 builtins
|
|
_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)1) == 1, "");
|
|
_Static_assert(__builtin_stdc_bit_width((unsigned __int128)0) == 0, "");
|
|
_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, "");
|
|
#endif // __SIZEOF_INT128__
|
|
|
|
// Test with unsigned long across all targets.
|
|
enum { ULONG_WIDTH = __SIZEOF_LONG__ * 8 };
|
|
|
|
_Static_assert(__builtin_stdc_leading_zeros(0UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_leading_zeros(1UL) == ULONG_WIDTH - 1, "");
|
|
_Static_assert(__builtin_stdc_leading_zeros(1UL << (ULONG_WIDTH - 1)) == 0, "");
|
|
_Static_assert(__builtin_stdc_leading_ones(0UL) == 0, "");
|
|
_Static_assert(__builtin_stdc_leading_ones(~0UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_leading_ones(~0UL << (ULONG_WIDTH - 4)) == 4, "");
|
|
_Static_assert(__builtin_stdc_trailing_zeros(0UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_trailing_zeros(1UL) == 0, "");
|
|
_Static_assert(__builtin_stdc_trailing_zeros(1UL << (ULONG_WIDTH - 1)) == ULONG_WIDTH - 1, "");
|
|
_Static_assert(__builtin_stdc_trailing_ones(0UL) == 0, "");
|
|
_Static_assert(__builtin_stdc_trailing_ones(~0UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_trailing_ones(0xFUL) == 4, "");
|
|
_Static_assert(__builtin_stdc_first_leading_zero(0UL) == 1, "");
|
|
_Static_assert(__builtin_stdc_first_leading_zero(~0UL) == 0, "");
|
|
_Static_assert(__builtin_stdc_first_leading_zero(~0UL << (ULONG_WIDTH - 4)) == 5, "");
|
|
_Static_assert(__builtin_stdc_first_leading_one(0UL) == 0, "");
|
|
_Static_assert(__builtin_stdc_first_leading_one(1UL << (ULONG_WIDTH - 1)) == 1, "");
|
|
_Static_assert(__builtin_stdc_first_leading_one(1UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_first_trailing_zero(0UL) == 1, "");
|
|
_Static_assert(__builtin_stdc_first_trailing_zero(~0UL) == 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(1UL << (ULONG_WIDTH - 1)) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_count_zeros(0UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_count_zeros(~0UL) == 0, "");
|
|
_Static_assert(__builtin_stdc_count_zeros(1UL << (ULONG_WIDTH - 1)) == ULONG_WIDTH - 1, "");
|
|
_Static_assert(__builtin_stdc_count_ones(0UL) == 0, "");
|
|
_Static_assert(__builtin_stdc_count_ones(~0UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_count_ones(1UL << (ULONG_WIDTH - 1)) == 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(1UL << (ULONG_WIDTH - 1)) == 1, "");
|
|
_Static_assert(__builtin_stdc_has_single_bit(~0UL) == 0, "");
|
|
_Static_assert(__builtin_stdc_bit_width(0UL) == 0, "");
|
|
_Static_assert(__builtin_stdc_bit_width(1UL) == 1, "");
|
|
_Static_assert(__builtin_stdc_bit_width(1UL << (ULONG_WIDTH - 1)) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_bit_floor(0UL) == 0UL, "");
|
|
_Static_assert(__builtin_stdc_bit_floor(1UL) == 1UL, "");
|
|
_Static_assert(__builtin_stdc_bit_floor(~0UL) == (1UL << (ULONG_WIDTH - 1)), "");
|
|
_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(1UL << (ULONG_WIDTH - 1)) == (1UL << (ULONG_WIDTH - 1)), "");
|
|
_Static_assert(__builtin_stdc_bit_ceil((1UL << (ULONG_WIDTH - 1)) + 1) == 0UL, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil(~0UL) == 0UL, "");
|
|
|
|
// alternating bit patterns
|
|
_Static_assert(__builtin_stdc_leading_zeros(0x55555555U) == 1, "");
|
|
_Static_assert(__builtin_stdc_leading_ones(0xAAAAAAAAU) == 1, "");
|
|
_Static_assert(__builtin_stdc_trailing_zeros(0xAAAAAAAAU) == 1, "");
|
|
_Static_assert(__builtin_stdc_trailing_ones(0x55555555U) == 1, "");
|
|
_Static_assert(__builtin_stdc_count_zeros(0x55555555U) == 16, "");
|
|
_Static_assert(__builtin_stdc_count_ones(0x55555555U) == 16, "");
|
|
_Static_assert(__builtin_stdc_count_zeros(0xAAAAAAAAU) == 16, "");
|
|
_Static_assert(__builtin_stdc_count_ones(0xAAAAAAAAU) == 16, "");
|
|
_Static_assert(__builtin_stdc_bit_width(0x55555555U) == 31, "");
|
|
_Static_assert(__builtin_stdc_bit_width(0xAAAAAAAAU) == 32, "");
|
|
_Static_assert(__builtin_stdc_bit_floor(0x55555555U) == 0x40000000U, "");
|
|
_Static_assert(__builtin_stdc_bit_floor(0xAAAAAAAAU) == 0x80000000U, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil(0x55555555U) == 0x80000000U, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil(0xAAAAAAAAU) == 0U, "");
|
|
|
|
// nibble patterns
|
|
_Static_assert(__builtin_stdc_leading_zeros(0x0F0F0F0FU) == 4, "");
|
|
_Static_assert(__builtin_stdc_leading_zeros(0xF0F0F0F0U) == 0, "");
|
|
_Static_assert(__builtin_stdc_count_ones(0x0F0F0F0FU) == 16, "");
|
|
_Static_assert(__builtin_stdc_count_ones(0xF0F0F0F0U) == 16, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil(0x0F0F0F0FU) == 0x10000000U, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil(0xF0F0F0F0U) == 0U, "");
|
|
|
|
// Error cases - all 14 builtins reject bool and enumeration arguments
|
|
enum UnsignedEnum { UE_A = 0, UE_B = 1 };
|
|
enum SignedEnum { SE_A = -1, SE_B = 1 };
|
|
void test_bool_enum_errors(_Bool b, enum UnsignedEnum ue, enum SignedEnum se) {
|
|
__builtin_stdc_leading_zeros(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_leading_zeros(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
__builtin_stdc_leading_zeros(se); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum SignedEnum')}}
|
|
|
|
__builtin_stdc_leading_ones(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_leading_ones(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
|
|
__builtin_stdc_trailing_zeros(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_trailing_zeros(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
|
|
__builtin_stdc_trailing_ones(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_trailing_ones(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
|
|
__builtin_stdc_first_leading_zero(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_first_leading_zero(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
|
|
__builtin_stdc_first_leading_one(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_first_leading_one(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
|
|
__builtin_stdc_first_trailing_zero(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_first_trailing_zero(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
|
|
__builtin_stdc_first_trailing_one(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_first_trailing_one(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
|
|
__builtin_stdc_count_ones(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_count_ones(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
|
|
__builtin_stdc_count_zeros(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_count_zeros(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
|
|
__builtin_stdc_has_single_bit(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_has_single_bit(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
|
|
__builtin_stdc_bit_width(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_bit_width(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
|
|
__builtin_stdc_bit_floor(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_bit_floor(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
|
|
__builtin_stdc_bit_ceil(b); // expected-error {{1st argument must not be a boolean or enumeration type (was 'bool')}}
|
|
__builtin_stdc_bit_ceil(ue); // expected-error {{1st argument must not be a boolean or enumeration type (was 'enum UnsignedEnum')}}
|
|
}
|
|
|
|
// Error cases - all 14 builtins reject signed and floating-point arguments
|
|
void test_errors(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')}}
|
|
}
|
|
|
|
#ifdef __has_include
|
|
#if __has_include(<stdbit.h>)
|
|
#include <stdbit.h>
|
|
|
|
_Static_assert(stdc_leading_zeros(0U) == 32, "");
|
|
_Static_assert(stdc_leading_zeros(1U) == 31, "");
|
|
_Static_assert(stdc_leading_ones(0xFFFFFFFFU) == 32, "");
|
|
_Static_assert(stdc_trailing_zeros(0U) == 32, "");
|
|
_Static_assert(stdc_trailing_ones(0xFFFFFFFFU) == 32, "");
|
|
_Static_assert(stdc_first_leading_zero(0U) == 1, "");
|
|
_Static_assert(stdc_first_leading_one(0U) == 0, "");
|
|
_Static_assert(stdc_first_trailing_zero(0U) == 1, "");
|
|
_Static_assert(stdc_first_trailing_one(0U) == 0, "");
|
|
_Static_assert(stdc_count_zeros(0U) == 32, "");
|
|
_Static_assert(stdc_count_ones(0xFFFFFFFFU) == 32, "");
|
|
_Static_assert(stdc_has_single_bit(4U) == 1, "");
|
|
_Static_assert(stdc_bit_width(7U) == 3, "");
|
|
_Static_assert(stdc_bit_floor(6U) == 4U, "");
|
|
_Static_assert(stdc_bit_ceil(6U) == 8U, "");
|
|
|
|
// Type-specific: each builtin truncates to the target type before operating.
|
|
_Static_assert(__builtin_stdc_leading_zeros((unsigned char)0) == 8, "");
|
|
_Static_assert(__builtin_stdc_leading_zeros((unsigned short)0) == 16, "");
|
|
_Static_assert(__builtin_stdc_leading_zeros((unsigned int)0) == 32, "");
|
|
_Static_assert(__builtin_stdc_leading_zeros((unsigned long)0) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_leading_zeros((unsigned long long)0) == 64, "");
|
|
|
|
_Static_assert(__builtin_stdc_leading_ones((unsigned char)0xFF) == 8, "");
|
|
_Static_assert(__builtin_stdc_leading_ones((unsigned short)0xFFFF) == 16, "");
|
|
_Static_assert(__builtin_stdc_leading_ones((unsigned int)0xFFFFFFFF) == 32, "");
|
|
_Static_assert(__builtin_stdc_leading_ones(~0UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_leading_ones((unsigned long long)0xFFFFFFFFFFFFFFFF) == 64, "");
|
|
|
|
_Static_assert(__builtin_stdc_trailing_zeros((unsigned char)0) == 8, "");
|
|
_Static_assert(__builtin_stdc_trailing_zeros((unsigned short)0) == 16, "");
|
|
_Static_assert(__builtin_stdc_trailing_zeros((unsigned int)0) == 32, "");
|
|
_Static_assert(__builtin_stdc_trailing_zeros((unsigned long)0) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_trailing_zeros((unsigned long long)0) == 64, "");
|
|
|
|
_Static_assert(__builtin_stdc_trailing_ones((unsigned char)0xFF) == 8, "");
|
|
_Static_assert(__builtin_stdc_trailing_ones((unsigned short)0xFFFF) == 16, "");
|
|
_Static_assert(__builtin_stdc_trailing_ones((unsigned int)0xFFFFFFFF) == 32, "");
|
|
_Static_assert(__builtin_stdc_trailing_ones(~0UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_trailing_ones((unsigned long long)0xFFFFFFFFFFFFFFFF) == 64, "");
|
|
|
|
_Static_assert(__builtin_stdc_first_leading_zero((unsigned char)0xFE) == 8, "");
|
|
_Static_assert(__builtin_stdc_first_leading_zero((unsigned short)0xFFFE) == 16, "");
|
|
_Static_assert(__builtin_stdc_first_leading_zero((unsigned int)0xFFFFFFFE) == 32, "");
|
|
_Static_assert(__builtin_stdc_first_leading_zero(~1UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_first_leading_zero((unsigned long long)0xFFFFFFFFFFFFFFFE) == 64, "");
|
|
|
|
_Static_assert(__builtin_stdc_first_leading_one((unsigned char)0x01) == 8, "");
|
|
_Static_assert(__builtin_stdc_first_leading_one((unsigned short)0x0001) == 16, "");
|
|
_Static_assert(__builtin_stdc_first_leading_one((unsigned int)0x00000001) == 32, "");
|
|
_Static_assert(__builtin_stdc_first_leading_one(1UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_first_leading_one((unsigned long long)0x0000000000000001) == 64, "");
|
|
|
|
_Static_assert(__builtin_stdc_first_trailing_zero((unsigned char)0x7F) == 8, "");
|
|
_Static_assert(__builtin_stdc_first_trailing_zero((unsigned short)0x7FFF) == 16, "");
|
|
_Static_assert(__builtin_stdc_first_trailing_zero((unsigned int)0x7FFFFFFF) == 32, "");
|
|
_Static_assert(__builtin_stdc_first_trailing_zero(~0UL >> 1) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_first_trailing_zero((unsigned long long)0x7FFFFFFFFFFFFFFF) == 64, "");
|
|
|
|
_Static_assert(__builtin_stdc_first_trailing_one((unsigned char)0x80) == 8, "");
|
|
_Static_assert(__builtin_stdc_first_trailing_one((unsigned short)0x8000) == 16, "");
|
|
_Static_assert(__builtin_stdc_first_trailing_one((unsigned int)0x80000000) == 32, "");
|
|
_Static_assert(__builtin_stdc_first_trailing_one(1UL << (ULONG_WIDTH - 1)) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_first_trailing_one((unsigned long long)0x8000000000000000) == 64, "");
|
|
|
|
_Static_assert(__builtin_stdc_count_zeros((unsigned char)0) == 8, "");
|
|
_Static_assert(__builtin_stdc_count_zeros((unsigned short)0) == 16, "");
|
|
_Static_assert(__builtin_stdc_count_zeros((unsigned int)0) == 32, "");
|
|
_Static_assert(__builtin_stdc_count_zeros((unsigned long)0) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_count_zeros((unsigned long long)0) == 64, "");
|
|
|
|
_Static_assert(__builtin_stdc_count_ones((unsigned char)0xFF) == 8, "");
|
|
_Static_assert(__builtin_stdc_count_ones((unsigned short)0xFFFF) == 16, "");
|
|
_Static_assert(__builtin_stdc_count_ones((unsigned int)0xFFFFFFFF) == 32, "");
|
|
_Static_assert(__builtin_stdc_count_ones(~0UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_count_ones((unsigned long long)0xFFFFFFFFFFFFFFFF) == 64, "");
|
|
|
|
_Static_assert(__builtin_stdc_has_single_bit((unsigned char)0x80) == 1, "");
|
|
_Static_assert(__builtin_stdc_has_single_bit((unsigned short)0x8000) == 1, "");
|
|
_Static_assert(__builtin_stdc_has_single_bit((unsigned int)0x80000000) == 1, "");
|
|
_Static_assert(__builtin_stdc_has_single_bit(1UL << (ULONG_WIDTH - 1)) == 1, "");
|
|
_Static_assert(__builtin_stdc_has_single_bit((unsigned long long)0x8000000000000000) == 1, "");
|
|
|
|
_Static_assert(__builtin_stdc_bit_width((unsigned char)0xFF) == 8, "");
|
|
_Static_assert(__builtin_stdc_bit_width((unsigned short)0xFFFF) == 16, "");
|
|
_Static_assert(__builtin_stdc_bit_width((unsigned int)0xFFFFFFFF) == 32, "");
|
|
_Static_assert(__builtin_stdc_bit_width(~0UL) == ULONG_WIDTH, "");
|
|
_Static_assert(__builtin_stdc_bit_width((unsigned long long)0xFFFFFFFFFFFFFFFF) == 64, "");
|
|
|
|
_Static_assert(__builtin_stdc_bit_floor((unsigned char)0x80) == 0x80, "");
|
|
_Static_assert(__builtin_stdc_bit_floor((unsigned short)0x8000) == 0x8000, "");
|
|
_Static_assert(__builtin_stdc_bit_floor((unsigned int)0x80000000) == 0x80000000U, "");
|
|
_Static_assert(__builtin_stdc_bit_floor(~0UL) == (1UL << (ULONG_WIDTH - 1)), "");
|
|
_Static_assert(__builtin_stdc_bit_floor((unsigned long long)0x8000000000000000) == 0x8000000000000000ULL, "");
|
|
|
|
_Static_assert(__builtin_stdc_bit_ceil((unsigned char)0x7F) == 0x80, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil((unsigned short)0x7FFF) == 0x8000, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil((unsigned int)0x7FFFFFFF) == 0x80000000U, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil(1UL << (ULONG_WIDTH - 1)) == (1UL << (ULONG_WIDTH - 1)), "");
|
|
_Static_assert(__builtin_stdc_bit_ceil((unsigned long long)0x7FFFFFFFFFFFFFFF) == 0x8000000000000000ULL, "");
|
|
|
|
// Truncation: passing a large ull verifies only the low N bits are used.
|
|
_Static_assert(__builtin_stdc_leading_zeros((unsigned char)0x8000000000000000ULL) == 8, "");
|
|
_Static_assert(__builtin_stdc_leading_ones((unsigned char)0xFFFFFFFFFFFFFFFFULL) == 8, "");
|
|
_Static_assert(__builtin_stdc_trailing_zeros((unsigned char)0x8000000000000000ULL) == 8, "");
|
|
_Static_assert(__builtin_stdc_trailing_ones((unsigned char)0xFFFFFFFFFFFFFFFFULL) == 8, "");
|
|
_Static_assert(__builtin_stdc_first_leading_zero((unsigned char)0xFFFFFFFFFFFFFFFFULL) == 0, "");
|
|
_Static_assert(__builtin_stdc_first_leading_one((unsigned char)0xFF00000000000001ULL) == 8, "");
|
|
_Static_assert(__builtin_stdc_first_trailing_zero((unsigned char)0xFFFFFFFFFFFFFFFFULL) == 0, "");
|
|
_Static_assert(__builtin_stdc_first_trailing_one((unsigned char)0x8000000000000080ULL) == 8, "");
|
|
_Static_assert(__builtin_stdc_count_zeros((unsigned char)0x8000000000000000ULL) == 8, "");
|
|
_Static_assert(__builtin_stdc_count_ones((unsigned char)0xFFFFFFFFFFFFFFFFULL) == 8, "");
|
|
_Static_assert(__builtin_stdc_has_single_bit((unsigned char)0x8000000080008080ULL) == 1, "");
|
|
_Static_assert(__builtin_stdc_bit_width((unsigned char)0xFFFFFFFFFFFFFFFFULL) == 8, "");
|
|
_Static_assert(__builtin_stdc_bit_floor((unsigned char)0x8000000080008080ULL) == 0x80, "");
|
|
_Static_assert(__builtin_stdc_bit_ceil((unsigned char)0x800000008000807FULL) == 0x80, "");
|
|
|
|
// Typed variants: verify correct values and return types.
|
|
_Static_assert(stdc_leading_zeros_uc(0) == 8, "");
|
|
_Static_assert(stdc_leading_zeros_uc((unsigned char)0xFF) == 0, "");
|
|
_Static_assert(stdc_leading_zeros_us(0) == 16, "");
|
|
_Static_assert(stdc_leading_zeros_ui(0) == 32, "");
|
|
_Static_assert(stdc_leading_zeros_ull(0) == 64, "");
|
|
|
|
_Static_assert(stdc_leading_ones_uc((unsigned char)0xFF) == 8, "");
|
|
_Static_assert(stdc_leading_ones_us((unsigned short)0xFFFF) == 16, "");
|
|
_Static_assert(stdc_leading_ones_ui(0xFFFFFFFFU) == 32, "");
|
|
_Static_assert(stdc_leading_ones_ull(0xFFFFFFFFFFFFFFFFULL) == 64, "");
|
|
|
|
_Static_assert(stdc_trailing_zeros_uc(0) == 8, "");
|
|
_Static_assert(stdc_trailing_zeros_us(0) == 16, "");
|
|
_Static_assert(stdc_trailing_zeros_ui(0) == 32, "");
|
|
_Static_assert(stdc_trailing_zeros_ull(0) == 64, "");
|
|
|
|
_Static_assert(stdc_trailing_ones_uc((unsigned char)0xFF) == 8, "");
|
|
_Static_assert(stdc_trailing_ones_us((unsigned short)0xFFFF) == 16, "");
|
|
_Static_assert(stdc_trailing_ones_ui(0xFFFFFFFFU) == 32, "");
|
|
_Static_assert(stdc_trailing_ones_ull(0xFFFFFFFFFFFFFFFFULL) == 64, "");
|
|
|
|
_Static_assert(stdc_first_leading_zero_uc(0) == 1, "");
|
|
_Static_assert(stdc_first_leading_zero_uc((unsigned char)0xFF) == 0, "");
|
|
_Static_assert(stdc_first_leading_zero_ui(0xFFFFFFFFU) == 0, "");
|
|
_Static_assert(stdc_first_leading_zero_ull(0) == 1, "");
|
|
|
|
_Static_assert(stdc_first_leading_one_uc(0) == 0, "");
|
|
_Static_assert(stdc_first_leading_one_uc((unsigned char)0x80) == 1, "");
|
|
_Static_assert(stdc_first_leading_one_ui(0x80000000U) == 1, "");
|
|
_Static_assert(stdc_first_leading_one_ull(1ULL) == 64, "");
|
|
|
|
_Static_assert(stdc_first_trailing_zero_uc(0) == 1, "");
|
|
_Static_assert(stdc_first_trailing_zero_uc((unsigned char)0xFF) == 0, "");
|
|
_Static_assert(stdc_first_trailing_zero_ui(0xFFFFFFFFU) == 0, "");
|
|
_Static_assert(stdc_first_trailing_zero_ull(0) == 1, "");
|
|
|
|
_Static_assert(stdc_first_trailing_one_uc(0) == 0, "");
|
|
_Static_assert(stdc_first_trailing_one_uc(1) == 1, "");
|
|
_Static_assert(stdc_first_trailing_one_ui(0x80000000U) == 32, "");
|
|
_Static_assert(stdc_first_trailing_one_ull(1ULL) == 1, "");
|
|
|
|
_Static_assert(stdc_count_zeros_uc(0) == 8, "");
|
|
_Static_assert(stdc_count_zeros_uc((unsigned char)0xFF) == 0, "");
|
|
_Static_assert(stdc_count_zeros_ui(0) == 32, "");
|
|
_Static_assert(stdc_count_zeros_ull(0) == 64, "");
|
|
|
|
_Static_assert(stdc_count_ones_uc((unsigned char)0xFF) == 8, "");
|
|
_Static_assert(stdc_count_ones_uc(0) == 0, "");
|
|
_Static_assert(stdc_count_ones_ui(0xFFFFFFFFU) == 32, "");
|
|
_Static_assert(stdc_count_ones_ull(0xFFFFFFFFFFFFFFFFULL) == 64, "");
|
|
|
|
_Static_assert(stdc_has_single_bit_uc(1) == 1, "");
|
|
_Static_assert(stdc_has_single_bit_uc(3) == 0, "");
|
|
_Static_assert(stdc_has_single_bit_ui(0x80000000U) == 1, "");
|
|
_Static_assert(stdc_has_single_bit_ull(0xFFFFFFFFFFFFFFFFULL) == 0, "");
|
|
|
|
_Static_assert(stdc_bit_width_uc((unsigned char)0xFF) == 8, "");
|
|
_Static_assert(stdc_bit_width_uc(0) == 0, "");
|
|
_Static_assert(stdc_bit_width_ui(0x80000000U) == 32, "");
|
|
_Static_assert(stdc_bit_width_ull(1ULL) == 1, "");
|
|
|
|
// bit_floor and bit_ceil return T, not unsigned int.
|
|
_Static_assert(stdc_bit_floor_uc((unsigned char)0xFF) == 0x80, "");
|
|
_Static_assert(stdc_bit_floor_uc(0) == 0, "");
|
|
_Static_assert(stdc_bit_floor_ui(0xFFFFFFFFU) == 0x80000000U, "");
|
|
_Static_assert(stdc_bit_floor_ull(1ULL) == 1ULL, "");
|
|
|
|
_Static_assert(stdc_bit_ceil_uc(0) == 1, "");
|
|
_Static_assert(stdc_bit_ceil_uc((unsigned char)0x7F) == 0x80, "");
|
|
_Static_assert(stdc_bit_ceil_ui(0x7FFFFFFFU) == 0x80000000U, "");
|
|
_Static_assert(stdc_bit_ceil_ull(1ULL) == 1ULL, "");
|
|
#endif
|
|
#endif
|