// RUN: %clang_cc1 -ffreestanding -std=c23 %s -emit-llvm -o - | FileCheck %s
// RUN: %if clang-target-64-bits %{ %clang_cc1 -ffreestanding -std=c23 %s -emit-llvm -o - | FileCheck %s --check-prefix=INT128 %}
// RUN: %clang_cc1 -std=c23 -isystem %S/Inputs -DTEST_LIB_SPELLINGS %s -emit-llvm -o - | FileCheck %s --check-prefix=LIB

// CHECK-LABEL: test_leading_zeros
// CHECK: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// CHECK: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// CHECK: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// CHECK: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
void test_leading_zeros(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile int r;
  r = __builtin_stdc_leading_zeros(uc);
  r = __builtin_stdc_leading_zeros(us);
  r = __builtin_stdc_leading_zeros(ui);
  r = __builtin_stdc_leading_zeros(ull);
}

// CHECK-LABEL: test_leading_ones
// CHECK: xor i8 %{{.*}}, -1
// CHECK: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// CHECK: xor i16 %{{.*}}, -1
// CHECK: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// CHECK: xor i32 %{{.*}}, -1
// CHECK: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// CHECK: xor i64 %{{.*}}, -1
// CHECK: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
void test_leading_ones(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile int r;
  r = __builtin_stdc_leading_ones(uc);
  r = __builtin_stdc_leading_ones(us);
  r = __builtin_stdc_leading_ones(ui);
  r = __builtin_stdc_leading_ones(ull);
}

// CHECK-LABEL: test_trailing_zeros
// CHECK: call i8 @llvm.cttz.i8(i8 %{{.*}}, i1 false)
// CHECK: call i16 @llvm.cttz.i16(i16 %{{.*}}, i1 false)
// CHECK: call i32 @llvm.cttz.i32(i32 %{{.*}}, i1 false)
// CHECK: call i64 @llvm.cttz.i64(i64 %{{.*}}, i1 false)
void test_trailing_zeros(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile int r;
  r = __builtin_stdc_trailing_zeros(uc);
  r = __builtin_stdc_trailing_zeros(us);
  r = __builtin_stdc_trailing_zeros(ui);
  r = __builtin_stdc_trailing_zeros(ull);
}

// CHECK-LABEL: test_trailing_ones
// CHECK: xor i8 %{{.*}}, -1
// CHECK: call i8 @llvm.cttz.i8(i8 %{{.*}}, i1 false)
// CHECK: xor i16 %{{.*}}, -1
// CHECK: call i16 @llvm.cttz.i16(i16 %{{.*}}, i1 false)
// CHECK: xor i32 %{{.*}}, -1
// CHECK: call i32 @llvm.cttz.i32(i32 %{{.*}}, i1 false)
// CHECK: xor i64 %{{.*}}, -1
// CHECK: call i64 @llvm.cttz.i64(i64 %{{.*}}, i1 false)
void test_trailing_ones(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile int r;
  r = __builtin_stdc_trailing_ones(uc);
  r = __builtin_stdc_trailing_ones(us);
  r = __builtin_stdc_trailing_ones(ui);
  r = __builtin_stdc_trailing_ones(ull);
}

// CHECK-LABEL: test_first_leading_zero
// CHECK: xor i8 %{{.*}}, -1
// CHECK: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// CHECK: xor i16 %{{.*}}, -1
// CHECK: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// CHECK: xor i32 %{{.*}}, -1
// CHECK: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// CHECK: xor i64 %{{.*}}, -1
// CHECK: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
void test_first_leading_zero(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile int r;
  r = __builtin_stdc_first_leading_zero(uc);
  r = __builtin_stdc_first_leading_zero(us);
  r = __builtin_stdc_first_leading_zero(ui);
  r = __builtin_stdc_first_leading_zero(ull);
}

// CHECK-LABEL: test_first_leading_one
// CHECK: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// CHECK: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// CHECK: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// CHECK: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
void test_first_leading_one(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile int r;
  r = __builtin_stdc_first_leading_one(uc);
  r = __builtin_stdc_first_leading_one(us);
  r = __builtin_stdc_first_leading_one(ui);
  r = __builtin_stdc_first_leading_one(ull);
}

// CHECK-LABEL: test_first_trailing_zero
// CHECK: xor i8 %{{.*}}, -1
// CHECK: call i8 @llvm.cttz.i8(i8 %{{.*}}, i1 false)
// CHECK: xor i16 %{{.*}}, -1
// CHECK: call i16 @llvm.cttz.i16(i16 %{{.*}}, i1 false)
// CHECK: xor i32 %{{.*}}, -1
// CHECK: call i32 @llvm.cttz.i32(i32 %{{.*}}, i1 false)
// CHECK: xor i64 %{{.*}}, -1
// CHECK: call i64 @llvm.cttz.i64(i64 %{{.*}}, i1 false)
void test_first_trailing_zero(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile int r;
  r = __builtin_stdc_first_trailing_zero(uc);
  r = __builtin_stdc_first_trailing_zero(us);
  r = __builtin_stdc_first_trailing_zero(ui);
  r = __builtin_stdc_first_trailing_zero(ull);
}

// CHECK-LABEL: test_first_trailing_one
// CHECK: call i8 @llvm.cttz.i8(i8 %{{.*}}, i1 false)
// CHECK: call i16 @llvm.cttz.i16(i16 %{{.*}}, i1 false)
// CHECK: call i32 @llvm.cttz.i32(i32 %{{.*}}, i1 false)
// CHECK: call i64 @llvm.cttz.i64(i64 %{{.*}}, i1 false)
void test_first_trailing_one(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile int r;
  r = __builtin_stdc_first_trailing_one(uc);
  r = __builtin_stdc_first_trailing_one(us);
  r = __builtin_stdc_first_trailing_one(ui);
  r = __builtin_stdc_first_trailing_one(ull);
}

// CHECK-LABEL: test_count_zeros
// CHECK: call i8 @llvm.ctpop.i8(i8 %{{.*}})
// CHECK: call i16 @llvm.ctpop.i16(i16 %{{.*}})
// CHECK: call i32 @llvm.ctpop.i32(i32 %{{.*}})
// CHECK: call i64 @llvm.ctpop.i64(i64 %{{.*}})
void test_count_zeros(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile int r;
  r = __builtin_stdc_count_zeros(uc);
  r = __builtin_stdc_count_zeros(us);
  r = __builtin_stdc_count_zeros(ui);
  r = __builtin_stdc_count_zeros(ull);
}

// CHECK-LABEL: test_count_ones
// CHECK: call i8 @llvm.ctpop.i8(i8 %{{.*}})
// CHECK: call i16 @llvm.ctpop.i16(i16 %{{.*}})
// CHECK: call i32 @llvm.ctpop.i32(i32 %{{.*}})
// CHECK: call i64 @llvm.ctpop.i64(i64 %{{.*}})
void test_count_ones(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile int r;
  r = __builtin_stdc_count_ones(uc);
  r = __builtin_stdc_count_ones(us);
  r = __builtin_stdc_count_ones(ui);
  r = __builtin_stdc_count_ones(ull);
}

// CHECK-LABEL: test_has_single_bit
// CHECK: call i8 @llvm.ctpop.i8(i8 %{{.*}})
// CHECK: call i16 @llvm.ctpop.i16(i16 %{{.*}})
// CHECK: call i32 @llvm.ctpop.i32(i32 %{{.*}})
// CHECK: call i64 @llvm.ctpop.i64(i64 %{{.*}})
void test_has_single_bit(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile int r;
  r = __builtin_stdc_has_single_bit(uc);
  r = __builtin_stdc_has_single_bit(us);
  r = __builtin_stdc_has_single_bit(ui);
  r = __builtin_stdc_has_single_bit(ull);
}

// CHECK-LABEL: test_bit_width
// CHECK: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// CHECK: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// CHECK: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// CHECK: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
void test_bit_width(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile int r;
  r = __builtin_stdc_bit_width(uc);
  r = __builtin_stdc_bit_width(us);
  r = __builtin_stdc_bit_width(ui);
  r = __builtin_stdc_bit_width(ull);
}

// CHECK-LABEL: test_bit_floor_uc
// CHECK: [[LZ:%.*]] = call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 true)
// CHECK: [[SHIFT:%.*]] = sub i8 7, [[LZ]]
// CHECK: [[SHIFTED:%.*]] = shl i8 1, [[SHIFT]]
// CHECK: [[ISZERO:%.*]] = icmp eq i8 %{{.*}}, 0
// CHECK: select i1 [[ISZERO]], i8 0, i8 [[SHIFTED]]
unsigned char test_bit_floor_uc(unsigned char uc) { return __builtin_stdc_bit_floor(uc); }

// CHECK-LABEL: test_bit_floor_us
// CHECK: [[LZ:%.*]] = call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 true)
// CHECK: [[SHIFT:%.*]] = sub i16 15, [[LZ]]
// CHECK: [[SHIFTED:%.*]] = shl i16 1, [[SHIFT]]
// CHECK: [[ISZERO:%.*]] = icmp eq i16 %{{.*}}, 0
// CHECK: select i1 [[ISZERO]], i16 0, i16 [[SHIFTED]]
unsigned short test_bit_floor_us(unsigned short us) { return __builtin_stdc_bit_floor(us); }

// CHECK-LABEL: test_bit_floor_ui
// CHECK: [[LZ:%.*]] = call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 true)
// CHECK: [[SHIFT:%.*]] = sub i32 31, [[LZ]]
// CHECK: [[SHIFTED:%.*]] = shl i32 1, [[SHIFT]]
// CHECK: [[ISZERO:%.*]] = icmp eq i32 %{{.*}}, 0
// CHECK: select i1 [[ISZERO]], i32 0, i32 [[SHIFTED]]
unsigned int test_bit_floor_ui(unsigned int ui) { return __builtin_stdc_bit_floor(ui); }

// CHECK-LABEL: test_bit_floor_ull
// CHECK: [[LZ:%.*]] = call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 true)
// CHECK: [[SHIFT:%.*]] = sub i64 63, [[LZ]]
// CHECK: [[SHIFTED:%.*]] = shl i64 1, [[SHIFT]]
// CHECK: [[ISZERO:%.*]] = icmp eq i64 %{{.*}}, 0
// CHECK: select i1 [[ISZERO]], i64 0, i64 [[SHIFTED]]
unsigned long long test_bit_floor_ull(unsigned long long ull) { return __builtin_stdc_bit_floor(ull); }

// CHECK-LABEL: test_bit_ceil_uc
// CHECK: icmp ule i8 %{{.*}}, 1
// CHECK: br i1 %{{.*}}, label %bitceil.merge, label %bitceil.calc
// CHECK: bitceil.calc:
// CHECK: sub i8 %{{.*}}, 1
// CHECK: [[LZ:%.*]] = call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// CHECK: [[SHIFT:%.*]] = sub i8 7, [[LZ]]
// CHECK: shl i8 2, [[SHIFT]]
// CHECK: bitceil.merge:
// CHECK: phi i8 [ 1, %{{.*}} ], [ %{{.*}}, %bitceil.calc ]
unsigned char test_bit_ceil_uc(unsigned char uc) { return __builtin_stdc_bit_ceil(uc); }

// CHECK-LABEL: test_bit_ceil_us
// CHECK: icmp ule i16 %{{.*}}, 1
// CHECK: br i1 %{{.*}}, label %bitceil.merge, label %bitceil.calc
// CHECK: bitceil.calc:
// CHECK: sub i16 %{{.*}}, 1
// CHECK: [[LZ:%.*]] = call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// CHECK: [[SHIFT:%.*]] = sub i16 15, [[LZ]]
// CHECK: shl i16 2, [[SHIFT]]
// CHECK: bitceil.merge:
// CHECK: phi i16 [ 1, %{{.*}} ], [ %{{.*}}, %bitceil.calc ]
unsigned short test_bit_ceil_us(unsigned short us) { return __builtin_stdc_bit_ceil(us); }

// CHECK-LABEL: test_bit_ceil_ui
// CHECK: icmp ule i32 %{{.*}}, 1
// CHECK: br i1 %{{.*}}, label %bitceil.merge, label %bitceil.calc
// CHECK: bitceil.calc:
// CHECK: sub i32 %{{.*}}, 1
// CHECK: [[LZ:%.*]] = call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// CHECK: [[SHIFT:%.*]] = sub i32 31, [[LZ]]
// CHECK: shl i32 2, [[SHIFT]]
// CHECK: bitceil.merge:
// CHECK: phi i32 [ 1, %{{.*}} ], [ %{{.*}}, %bitceil.calc ]
unsigned int test_bit_ceil_ui(unsigned int ui) { return __builtin_stdc_bit_ceil(ui); }

// CHECK-LABEL: test_bit_ceil_ull
// CHECK: icmp ule i64 %{{.*}}, 1
// CHECK: br i1 %{{.*}}, label %bitceil.merge, label %bitceil.calc
// CHECK: bitceil.calc:
// CHECK: sub i64 %{{.*}}, 1
// CHECK: [[LZ:%.*]] = call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
// CHECK: [[SHIFT:%.*]] = sub i64 63, [[LZ]]
// CHECK: shl i64 2, [[SHIFT]]
// CHECK: bitceil.merge:
// CHECK: phi i64 [ 1, %{{.*}} ], [ %{{.*}}, %bitceil.calc ]
unsigned long long test_bit_ceil_ull(unsigned long long ull) { return __builtin_stdc_bit_ceil(ull); }

// CHECK-LABEL: test_bit_floor
// CHECK: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 true)
// CHECK: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 true)
// CHECK: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 true)
// CHECK: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 true)
void test_bit_floor(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile unsigned char rc;
  volatile unsigned short rs;
  volatile unsigned int ri;
  volatile unsigned long long rll;
  rc = __builtin_stdc_bit_floor(uc);
  rs = __builtin_stdc_bit_floor(us);
  ri = __builtin_stdc_bit_floor(ui);
  rll = __builtin_stdc_bit_floor(ull);
}

// CHECK-LABEL: test_bit_ceil
// CHECK: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// CHECK: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// CHECK: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// CHECK: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
void test_bit_ceil(unsigned char uc, unsigned short us, unsigned int ui, unsigned long long ull) {
  volatile unsigned char rc;
  volatile unsigned short rs;
  volatile unsigned int ri;
  volatile unsigned long long rll;
  rc = __builtin_stdc_bit_ceil(uc);
  rs = __builtin_stdc_bit_ceil(us);
  ri = __builtin_stdc_bit_ceil(ui);
  rll = __builtin_stdc_bit_ceil(ull);
}

// Test with _BitInt types
// CHECK-LABEL: test_bitint
// CHECK: call i37 @llvm.ctlz.i37(i37 %{{.*}}, i1 false)
// CHECK: call i37 @llvm.cttz.i37(i37 %{{.*}}, i1 false)
// CHECK: call i37 @llvm.ctpop.i37(i37 %{{.*}})
void test_bitint(unsigned _BitInt(37) bi) {
  volatile int r;
  r = __builtin_stdc_leading_zeros(bi);
  r = __builtin_stdc_trailing_zeros(bi);
  r = __builtin_stdc_count_ones(bi);
}

// Additional _BitInt coverage
// CHECK-LABEL: test_bitint_floor_ceil
// CHECK: call i9 @llvm.ctlz.i9(i9 %{{.*}}, i1 true)
// CHECK: call i9 @llvm.ctlz.i9(i9 %{{.*}}, i1 false)
void test_bitint_floor_ceil(unsigned _BitInt(9) bi9) {
  volatile unsigned _BitInt(9) rb;
  rb = __builtin_stdc_bit_floor(bi9);
  rb = __builtin_stdc_bit_ceil(bi9);
}

// CHECK-LABEL: test_bitint_first_and_count
// CHECK: call i9 @llvm.ctlz.i9(i9 %{{.*}}, i1 false)
// CHECK: call i9 @llvm.cttz.i9(i9 %{{.*}}, i1 false)
// CHECK: call i9 @llvm.ctpop.i9(i9 %{{.*}})
void test_bitint_first_and_count(unsigned _BitInt(9) bi9) {
  volatile int r;
  r = __builtin_stdc_first_leading_zero(bi9);
  r = __builtin_stdc_first_trailing_zero(bi9);
  r = __builtin_stdc_count_zeros(bi9);
}

// CHECK-LABEL: test_bit_floor_all_ones_bitint
// CHECK: store volatile i32 65536, ptr %r
void test_bit_floor_all_ones_bitint(void) {
  volatile unsigned _BitInt(17) r =
      __builtin_stdc_bit_floor((unsigned _BitInt(17))(-1));
}

// CHECK-LABEL: test_first_trailing_zero_all_ones_bitint
// CHECK: store volatile i32 0, ptr %r
void test_first_trailing_zero_all_ones_bitint(void) {
  volatile unsigned _BitInt(17) r =
      __builtin_stdc_first_trailing_zero((unsigned _BitInt(17))(-1));
}

#ifdef __SIZEOF_INT128__
// INT128-LABEL: test_int128
// INT128: call i128 @llvm.ctlz.i128(i128 %{{.*}}, i1 false)
// INT128: call i128 @llvm.cttz.i128(i128 %{{.*}}, i1 false)
// INT128: call i128 @llvm.ctpop.i128(i128 %{{.*}})
void test_int128(unsigned __int128 u128) {
  volatile int r;
  r = __builtin_stdc_leading_zeros(u128);
  r = __builtin_stdc_trailing_zeros(u128);
  r = __builtin_stdc_count_ones(u128);
}

// INT128-LABEL: test_int128_leading_trailing_ones
// INT128: xor i128 %{{.*}}, -1
// INT128: call i128 @llvm.ctlz.i128(i128 %{{.*}}, i1 false)
// INT128: xor i128 %{{.*}}, -1
// INT128: call i128 @llvm.cttz.i128(i128 %{{.*}}, i1 false)
void test_int128_leading_trailing_ones(unsigned __int128 u128) {
  volatile int r;
  r = __builtin_stdc_leading_ones(u128);
  r = __builtin_stdc_trailing_ones(u128);
}

// INT128-LABEL: test_int128_first
// INT128: xor i128 %{{.*}}, -1
// INT128: call i128 @llvm.ctlz.i128(i128 %{{.*}}, i1 false)
// INT128: call i128 @llvm.ctlz.i128(i128 %{{.*}}, i1 false)
// INT128: xor i128 %{{.*}}, -1
// INT128: call i128 @llvm.cttz.i128(i128 %{{.*}}, i1 false)
// INT128: call i128 @llvm.cttz.i128(i128 %{{.*}}, i1 false)
void test_int128_first(unsigned __int128 u128) {
  volatile int r;
  r = __builtin_stdc_first_leading_zero(u128);
  r = __builtin_stdc_first_leading_one(u128);
  r = __builtin_stdc_first_trailing_zero(u128);
  r = __builtin_stdc_first_trailing_one(u128);
}

// INT128-LABEL: test_int128_count_has_width
// INT128: call i128 @llvm.ctpop.i128(i128 %{{.*}})
// INT128: call i128 @llvm.ctpop.i128(i128 %{{.*}})
// INT128: call i128 @llvm.ctpop.i128(i128 %{{.*}})
// INT128: call i128 @llvm.ctlz.i128(i128 %{{.*}}, i1 false)
void test_int128_count_has_width(unsigned __int128 u128) {
  volatile int r;
  r = __builtin_stdc_count_zeros(u128);
  r = __builtin_stdc_count_ones(u128);
  r = __builtin_stdc_has_single_bit(u128);
  r = __builtin_stdc_bit_width(u128);
}

// INT128-LABEL: test_int128_floor_ceil
// INT128: call i128 @llvm.ctlz.i128(i128 %{{.*}}, i1 true)
// INT128: call i128 @llvm.ctlz.i128(i128 %{{.*}}, i1 false)
void test_int128_floor_ceil(unsigned __int128 u128) {
  volatile unsigned __int128 r;
  r = __builtin_stdc_bit_floor(u128);
  r = __builtin_stdc_bit_ceil(u128);
}
#endif

// CHECK-LABEL: test_ulong
// CHECK: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// CHECK: xor {{i32|i64}} %{{.*}}, -1
// CHECK: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// CHECK: call {{i32|i64}} @llvm.cttz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// CHECK: xor {{i32|i64}} %{{.*}}, -1
// CHECK: call {{i32|i64}} @llvm.cttz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// CHECK: xor {{i32|i64}} %{{.*}}, -1
// CHECK: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// CHECK: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// CHECK: xor {{i32|i64}} %{{.*}}, -1
// CHECK: call {{i32|i64}} @llvm.cttz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// CHECK: call {{i32|i64}} @llvm.cttz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// CHECK: call {{i32|i64}} @llvm.ctpop.{{i32|i64}}({{i32|i64}} %{{.*}})
// CHECK: call {{i32|i64}} @llvm.ctpop.{{i32|i64}}({{i32|i64}} %{{.*}})
// CHECK: call {{i32|i64}} @llvm.ctpop.{{i32|i64}}({{i32|i64}} %{{.*}})
// CHECK: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// CHECK: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 true)
// CHECK: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
void test_ulong(unsigned long ul) {
  volatile unsigned r;
  volatile unsigned long rl;
  volatile _Bool rb;
  r  = __builtin_stdc_leading_zeros(ul);
  r  = __builtin_stdc_leading_ones(ul);
  r  = __builtin_stdc_trailing_zeros(ul);
  r  = __builtin_stdc_trailing_ones(ul);
  r  = __builtin_stdc_first_leading_zero(ul);
  r  = __builtin_stdc_first_leading_one(ul);
  r  = __builtin_stdc_first_trailing_zero(ul);
  r  = __builtin_stdc_first_trailing_one(ul);
  r  = __builtin_stdc_count_zeros(ul);
  r  = __builtin_stdc_count_ones(ul);
  rb = __builtin_stdc_has_single_bit(ul);
  r  = __builtin_stdc_bit_width(ul);
  rl = __builtin_stdc_bit_floor(ul);
  rl = __builtin_stdc_bit_ceil(ul);
}

#ifdef TEST_LIB_SPELLINGS
#include <stdbit.h>

// LIB-LABEL: test_lib_leading_zeros
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
void test_lib_leading_zeros(unsigned ui) {
  volatile unsigned r = stdc_leading_zeros(ui);
}

// LIB-LABEL: test_lib_leading_ones
// LIB: xor i32 %{{.*}}, -1
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
void test_lib_leading_ones(unsigned ui) {
  volatile unsigned r = stdc_leading_ones(ui);
}

// LIB-LABEL: test_lib_trailing_zeros
// LIB: call i32 @llvm.cttz.i32(i32 %{{.*}}, i1 false)
void test_lib_trailing_zeros(unsigned ui) {
  volatile unsigned r = stdc_trailing_zeros(ui);
}

// LIB-LABEL: test_lib_trailing_ones
// LIB: xor i32 %{{.*}}, -1
// LIB: call i32 @llvm.cttz.i32(i32 %{{.*}}, i1 false)
void test_lib_trailing_ones(unsigned ui) {
  volatile unsigned r = stdc_trailing_ones(ui);
}

// LIB-LABEL: test_lib_first_leading_zero
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
void test_lib_first_leading_zero(unsigned ui) {
  volatile unsigned r = stdc_first_leading_zero(ui);
}

// LIB-LABEL: test_lib_first_leading_one
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
void test_lib_first_leading_one(unsigned ui) {
  volatile unsigned r = stdc_first_leading_one(ui);
}

// LIB-LABEL: test_lib_first_trailing_zero
// LIB: xor i32 %{{.*}}, -1
// LIB: call i32 @llvm.cttz.i32(i32 %{{.*}}, i1 false)
void test_lib_first_trailing_zero(unsigned ui) {
  volatile unsigned r = stdc_first_trailing_zero(ui);
}

// LIB-LABEL: test_lib_first_trailing_one
// LIB: call i32 @llvm.cttz.i32(i32 %{{.*}}, i1 false)
void test_lib_first_trailing_one(unsigned ui) {
  volatile unsigned r = stdc_first_trailing_one(ui);
}

// LIB-LABEL: test_lib_count_zeros
// LIB: call i32 @llvm.ctpop.i32(i32 %{{.*}})
void test_lib_count_zeros(unsigned ui) {
  volatile unsigned r = stdc_count_zeros(ui);
}

// LIB-LABEL: test_lib_count_ones
// LIB: call i32 @llvm.ctpop.i32(i32 %{{.*}})
void test_lib_count_ones(unsigned ui) {
  volatile unsigned r = stdc_count_ones(ui);
}

// LIB-LABEL: test_lib_has_single_bit
// LIB: call i32 @llvm.ctpop.i32(i32 %{{.*}})
void test_lib_has_single_bit(unsigned ui) {
  volatile _Bool r = stdc_has_single_bit(ui);
}

// LIB-LABEL: test_lib_bit_width
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
void test_lib_bit_width(unsigned ui) {
  volatile unsigned r = stdc_bit_width(ui);
}

// LIB-LABEL: test_lib_bit_floor
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 true)
void test_lib_bit_floor(unsigned ui) {
  volatile unsigned r = stdc_bit_floor(ui);
}

// LIB-LABEL: test_lib_bit_ceil
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
void test_lib_bit_ceil(unsigned ui) {
  volatile unsigned r = stdc_bit_ceil(ui);
}

// LIB-LABEL: test_lib_typed_leading_zeros
// LIB: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// LIB: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// LIB: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
void test_lib_typed_leading_zeros(unsigned char uc, unsigned short us,
                                  unsigned int ui, unsigned long long ull) {
  volatile unsigned r;
  r = stdc_leading_zeros_uc(uc);
  r = stdc_leading_zeros_us(us);
  r = stdc_leading_zeros_ui(ui);
  r = stdc_leading_zeros_ull(ull);
}

// LIB-LABEL: test_lib_typed_leading_ones
// LIB: xor i8 %{{.*}}, -1
// LIB: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// LIB: xor i16 %{{.*}}, -1
// LIB: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// LIB: xor i32 %{{.*}}, -1
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// LIB: xor i64 %{{.*}}, -1
// LIB: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
void test_lib_typed_leading_ones(unsigned char uc, unsigned short us,
                                 unsigned int ui, unsigned long long ull) {
  volatile unsigned r;
  r = stdc_leading_ones_uc(uc);
  r = stdc_leading_ones_us(us);
  r = stdc_leading_ones_ui(ui);
  r = stdc_leading_ones_ull(ull);
}

// LIB-LABEL: test_lib_typed_trailing_zeros
// LIB: call i8 @llvm.cttz.i8(i8 %{{.*}}, i1 false)
// LIB: call i16 @llvm.cttz.i16(i16 %{{.*}}, i1 false)
// LIB: call i32 @llvm.cttz.i32(i32 %{{.*}}, i1 false)
// LIB: call i64 @llvm.cttz.i64(i64 %{{.*}}, i1 false)
void test_lib_typed_trailing_zeros(unsigned char uc, unsigned short us,
                                   unsigned int ui, unsigned long long ull) {
  volatile unsigned r;
  r = stdc_trailing_zeros_uc(uc);
  r = stdc_trailing_zeros_us(us);
  r = stdc_trailing_zeros_ui(ui);
  r = stdc_trailing_zeros_ull(ull);
}

// LIB-LABEL: test_lib_typed_trailing_ones
// LIB: xor i8 %{{.*}}, -1
// LIB: call i8 @llvm.cttz.i8(i8 %{{.*}}, i1 false)
// LIB: xor i16 %{{.*}}, -1
// LIB: call i16 @llvm.cttz.i16(i16 %{{.*}}, i1 false)
// LIB: xor i32 %{{.*}}, -1
// LIB: call i32 @llvm.cttz.i32(i32 %{{.*}}, i1 false)
// LIB: xor i64 %{{.*}}, -1
// LIB: call i64 @llvm.cttz.i64(i64 %{{.*}}, i1 false)
void test_lib_typed_trailing_ones(unsigned char uc, unsigned short us,
                                  unsigned int ui, unsigned long long ull) {
  volatile unsigned r;
  r = stdc_trailing_ones_uc(uc);
  r = stdc_trailing_ones_us(us);
  r = stdc_trailing_ones_ui(ui);
  r = stdc_trailing_ones_ull(ull);
}

// LIB-LABEL: test_lib_typed_first_leading_zero
// LIB: xor i8 %{{.*}}, -1
// LIB: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// LIB: xor i16 %{{.*}}, -1
// LIB: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// LIB: xor i32 %{{.*}}, -1
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// LIB: xor i64 %{{.*}}, -1
// LIB: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
void test_lib_typed_first_leading_zero(unsigned char uc, unsigned short us,
                                       unsigned int ui, unsigned long long ull) {
  volatile unsigned r;
  r = stdc_first_leading_zero_uc(uc);
  r = stdc_first_leading_zero_us(us);
  r = stdc_first_leading_zero_ui(ui);
  r = stdc_first_leading_zero_ull(ull);
}

// LIB-LABEL: test_lib_typed_first_leading_one
// LIB: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// LIB: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// LIB: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
void test_lib_typed_first_leading_one(unsigned char uc, unsigned short us,
                                      unsigned int ui, unsigned long long ull) {
  volatile unsigned r;
  r = stdc_first_leading_one_uc(uc);
  r = stdc_first_leading_one_us(us);
  r = stdc_first_leading_one_ui(ui);
  r = stdc_first_leading_one_ull(ull);
}

// LIB-LABEL: test_lib_typed_first_trailing_zero
// LIB: xor i8 %{{.*}}, -1
// LIB: call i8 @llvm.cttz.i8(i8 %{{.*}}, i1 false)
// LIB: xor i16 %{{.*}}, -1
// LIB: call i16 @llvm.cttz.i16(i16 %{{.*}}, i1 false)
// LIB: xor i32 %{{.*}}, -1
// LIB: call i32 @llvm.cttz.i32(i32 %{{.*}}, i1 false)
// LIB: xor i64 %{{.*}}, -1
// LIB: call i64 @llvm.cttz.i64(i64 %{{.*}}, i1 false)
void test_lib_typed_first_trailing_zero(unsigned char uc, unsigned short us,
                                        unsigned int ui, unsigned long long ull) {
  volatile unsigned r;
  r = stdc_first_trailing_zero_uc(uc);
  r = stdc_first_trailing_zero_us(us);
  r = stdc_first_trailing_zero_ui(ui);
  r = stdc_first_trailing_zero_ull(ull);
}

// LIB-LABEL: test_lib_typed_first_trailing_one
// LIB: call i8 @llvm.cttz.i8(i8 %{{.*}}, i1 false)
// LIB: call i16 @llvm.cttz.i16(i16 %{{.*}}, i1 false)
// LIB: call i32 @llvm.cttz.i32(i32 %{{.*}}, i1 false)
// LIB: call i64 @llvm.cttz.i64(i64 %{{.*}}, i1 false)
void test_lib_typed_first_trailing_one(unsigned char uc, unsigned short us,
                                       unsigned int ui, unsigned long long ull) {
  volatile unsigned r;
  r = stdc_first_trailing_one_uc(uc);
  r = stdc_first_trailing_one_us(us);
  r = stdc_first_trailing_one_ui(ui);
  r = stdc_first_trailing_one_ull(ull);
}

// LIB-LABEL: test_lib_typed_count_zeros
// LIB: call i8 @llvm.ctpop.i8(i8 %{{.*}})
// LIB: call i16 @llvm.ctpop.i16(i16 %{{.*}})
// LIB: call i32 @llvm.ctpop.i32(i32 %{{.*}})
// LIB: call i64 @llvm.ctpop.i64(i64 %{{.*}})
void test_lib_typed_count_zeros(unsigned char uc, unsigned short us,
                                unsigned int ui, unsigned long long ull) {
  volatile unsigned r;
  r = stdc_count_zeros_uc(uc);
  r = stdc_count_zeros_us(us);
  r = stdc_count_zeros_ui(ui);
  r = stdc_count_zeros_ull(ull);
}

// LIB-LABEL: test_lib_typed_count_ones
// LIB: call i8 @llvm.ctpop.i8(i8 %{{.*}})
// LIB: call i16 @llvm.ctpop.i16(i16 %{{.*}})
// LIB: call i32 @llvm.ctpop.i32(i32 %{{.*}})
// LIB: call i64 @llvm.ctpop.i64(i64 %{{.*}})
void test_lib_typed_count_ones(unsigned char uc, unsigned short us,
                               unsigned int ui, unsigned long long ull) {
  volatile unsigned r;
  r = stdc_count_ones_uc(uc);
  r = stdc_count_ones_us(us);
  r = stdc_count_ones_ui(ui);
  r = stdc_count_ones_ull(ull);
}

// LIB-LABEL: test_lib_typed_has_single_bit
// LIB: call i8 @llvm.ctpop.i8(i8 %{{.*}})
// LIB: call i16 @llvm.ctpop.i16(i16 %{{.*}})
// LIB: call i32 @llvm.ctpop.i32(i32 %{{.*}})
// LIB: call i64 @llvm.ctpop.i64(i64 %{{.*}})
void test_lib_typed_has_single_bit(unsigned char uc, unsigned short us,
                                   unsigned int ui, unsigned long long ull) {
  volatile _Bool r;
  r = stdc_has_single_bit_uc(uc);
  r = stdc_has_single_bit_us(us);
  r = stdc_has_single_bit_ui(ui);
  r = stdc_has_single_bit_ull(ull);
}

// LIB-LABEL: test_lib_typed_bit_width
// LIB: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// LIB: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// LIB: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
void test_lib_typed_bit_width(unsigned char uc, unsigned short us,
                              unsigned int ui, unsigned long long ull) {
  volatile unsigned r;
  r = stdc_bit_width_uc(uc);
  r = stdc_bit_width_us(us);
  r = stdc_bit_width_ui(ui);
  r = stdc_bit_width_ull(ull);
}

// LIB-LABEL: test_lib_typed_bit_floor
// LIB: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 true)
// LIB: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 true)
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 true)
// LIB: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 true)
void test_lib_typed_bit_floor(unsigned char uc, unsigned short us,
                              unsigned int ui, unsigned long long ull) {
  volatile unsigned char rc = stdc_bit_floor_uc(uc);
  volatile unsigned short rs = stdc_bit_floor_us(us);
  volatile unsigned int ri = stdc_bit_floor_ui(ui);
  volatile unsigned long long rll = stdc_bit_floor_ull(ull);
}

// LIB-LABEL: test_lib_typed_bit_ceil
// LIB: call i8 @llvm.ctlz.i8(i8 %{{.*}}, i1 false)
// LIB: call i16 @llvm.ctlz.i16(i16 %{{.*}}, i1 false)
// LIB: call i32 @llvm.ctlz.i32(i32 %{{.*}}, i1 false)
// LIB: call i64 @llvm.ctlz.i64(i64 %{{.*}}, i1 false)
void test_lib_typed_bit_ceil(unsigned char uc, unsigned short us,
                             unsigned int ui, unsigned long long ull) {
  volatile unsigned char rc = stdc_bit_ceil_uc(uc);
  volatile unsigned short rs = stdc_bit_ceil_us(us);
  volatile unsigned int ri = stdc_bit_ceil_ui(ui);
  volatile unsigned long long rll = stdc_bit_ceil_ull(ull);
}

// LIB-LABEL: test_lib_typed_ul
// LIB: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// LIB: xor {{i32|i64}} %{{.*}}, -1
// LIB: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// LIB: call {{i32|i64}} @llvm.cttz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// LIB: xor {{i32|i64}} %{{.*}}, -1
// LIB: call {{i32|i64}} @llvm.cttz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// LIB: xor {{i32|i64}} %{{.*}}, -1
// LIB: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// LIB: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// LIB: xor {{i32|i64}} %{{.*}}, -1
// LIB: call {{i32|i64}} @llvm.cttz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// LIB: call {{i32|i64}} @llvm.cttz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// LIB: call {{i32|i64}} @llvm.ctpop.{{i32|i64}}({{i32|i64}} %{{.*}})
// LIB: call {{i32|i64}} @llvm.ctpop.{{i32|i64}}({{i32|i64}} %{{.*}})
// LIB: call {{i32|i64}} @llvm.ctpop.{{i32|i64}}({{i32|i64}} %{{.*}})
// LIB: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
// LIB: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 true)
// LIB: call {{i32|i64}} @llvm.ctlz.{{i32|i64}}({{i32|i64}} %{{.*}}, i1 false)
void test_lib_typed_ul(unsigned long ul) {
  volatile unsigned r;
  volatile unsigned long rl;
  volatile _Bool rb;
  r  = stdc_leading_zeros_ul(ul);
  r  = stdc_leading_ones_ul(ul);
  r  = stdc_trailing_zeros_ul(ul);
  r  = stdc_trailing_ones_ul(ul);
  r  = stdc_first_leading_zero_ul(ul);
  r  = stdc_first_leading_one_ul(ul);
  r  = stdc_first_trailing_zero_ul(ul);
  r  = stdc_first_trailing_one_ul(ul);
  r  = stdc_count_zeros_ul(ul);
  r  = stdc_count_ones_ul(ul);
  rb = stdc_has_single_bit_ul(ul);
  r  = stdc_bit_width_ul(ul);
  rl = stdc_bit_floor_ul(ul);
  rl = stdc_bit_ceil_ul(ul);
}
#endif