// RUN: %clang_cc1 -emit-llvm -o %t %s
// RUN: not grep __builtin %t
// RUN: %clang_cc1 -emit-llvm -triple armv7 -o %t %s
// RUN: not grep __builtin %t

// RUN: %clang_cc1 -emit-llvm -triple armv7-darwin-apple  -o - %s | FileCheck %s --check-prefixes=CHECK,LD64,LONG32
// RUN: %clang_cc1 -emit-llvm -triple arm64-darwin-apple  -o - %s | FileCheck %s --check-prefixes=CHECK,LD64,I128,LONG64
// RUN: %clang_cc1 -emit-llvm -triple x86_64-darwin-apple -o - %s | FileCheck %s --check-prefixes=CHECK,LD80,I128,LONG64
// RUN: %clang_cc1 -emit-llvm -triple x86_64-darwin-apple -o - %s -fexperimental-new-constant-interpreter | FileCheck --check-prefixes=CHECK,LD80,I128,LONG64 %s

int printf(const char *, ...);

void p(char *str, int x) {
  printf("%s: %d\n", str, x);
}
void q(char *str, double x) {
  printf("%s: %f\n", str, x);
}
void r(char *str, void *ptr) {
  printf("%s: %p\n", str, ptr);
}

int random(void);
int finite(double);

int main(void) {
  int N = random();
#define P(n,args) p(#n #args, __builtin_##n args)
#define Q(n,args) q(#n #args, __builtin_##n args)
#define R(n,args) r(#n #args, __builtin_##n args)
#define V(n,args) p(#n #args, (__builtin_##n args, 0))
  P(types_compatible_p, (int, float));
  P(choose_expr, (0, 10, 20));
  P(constant_p, (sizeof(10)));
  P(expect, (N == 12, 0));
  V(prefetch, (&N));
  V(prefetch, (&N, 1));
  V(prefetch, (&N, 1, 0));

  // Numeric Constants

  Q(huge_val, ());
  Q(huge_valf, ());
  Q(huge_vall, ());
  Q(inf, ());
  Q(inff, ());
  Q(infl, ());

  P(fpclassify, (0, 1, 2, 3, 4, 1.0));
  P(fpclassify, (0, 1, 2, 3, 4, 1.0f));
  P(fpclassify, (0, 1, 2, 3, 4, 1.0l));

  Q(nan, (""));
  Q(nanf, (""));
  Q(nanl, (""));
  Q(nans, (""));
  Q(nan, ("10"));
  Q(nanf, ("10"));
  Q(nanl, ("10"));
  Q(nans, ("10"));

  P(isgreater, (1., 2.));
  P(isgreaterequal, (1., 2.));
  P(isless, (1., 2.));
  P(islessequal, (1., 2.));
  P(islessgreater, (1., 2.));
  P(isunordered, (1., 2.));

  P(isinf, (1.));
  P(isinf_sign, (1.));
  P(isnan, (1.));
  P(isfinite, (1.));
  P(iszero, (1.));
  P(issubnormal, (1.));
  P(issignaling, (1.));
  P(isfpclass, (1., 1));

  Q(fmaximum_num, (1.0, 2.0));
  Q(fmaximum_numf, (1.0, 2.0));
  Q(fmaximum_numl, (1.0, 2.0));
  Q(fminimum_num, (1.0, 2.0));
  Q(fminimum_numf, (1.0, 2.0));
  Q(fminimum_numl, (1.0, 2.0));

  // Bitwise & Numeric Functions

  P(abs, (N));

  P(clz, (N));
  P(clzl, (N));
  P(clzll, (N));
  P(ctz, (N));
  P(ctzl, (N));
  P(ctzll, (N));
  P(ffs, (N));
  P(ffsl, (N));
  P(ffsll, (N));
  P(parity, (N));
  P(parityl, (N));
  P(parityll, (N));
  P(popcount, (N));
  P(popcountl, (N));
  P(popcountll, (N));
  Q(powi, (1.2f, N));
  Q(powif, (1.2f, N));
  Q(powil, (1.2f, N));

  // Lib functions
  int a, b, n = random(); // Avoid optimizing out.
  char s0[10], s1[] = "Hello";
  V(strcat, (s0, s1));
  V(strcmp, (s0, s1));
  V(strdup, (s0));
  V(strncat, (s0, s1, n));
  V(strndup, (s0, n));
  V(strchr, (s0, s1[0]));
  V(strrchr, (s0, s1[0]));
  V(strcpy, (s0, s1));
  V(strncpy, (s0, s1, n));
  V(sprintf, (s0, "%s", s1));
  V(snprintf, (s0, n, "%s", s1));

  // Object size checking
  V(__memset_chk, (s0, 0, sizeof s0, n));
  V(__memcpy_chk, (s0, s1, sizeof s0, n));
  V(__memmove_chk, (s0, s1, sizeof s0, n));
  V(__mempcpy_chk, (s0, s1, sizeof s0, n));
  V(__strncpy_chk, (s0, s1, sizeof s0, n));
  V(__strcpy_chk, (s0, s1, n));
  s0[0] = 0;
  V(__strcat_chk, (s0, s1, n));
  P(object_size, (s0, 0));
  P(object_size, (s0, 1));
  P(object_size, (s0, 2));
  P(object_size, (s0, 3));

  // Whatever
  P(bswapg, ((_Bool)N));
  P(bswapg, ((char)N));
  P(bswapg, ((short)N));
  P(bswapg, ((int)N));
  P(bswapg, ((unsigned long)N));
  P(bswapg, ((_BitInt(8))N));
  P(bswapg, ((_BitInt(16))N));
  P(bswapg, ((_BitInt(32))N));
  P(bswapg, ((_BitInt(64))N));
  P(bswapg, ((_BitInt(128))N));
  P(bswap16, (N));
  P(bswap32, (N));
  P(bswap64, (N));

  // CHECK: @llvm.bitreverse.i8
  // CHECK: @llvm.bitreverse.i16
  // CHECK: @llvm.bitreverse.i32
  // CHECK: @llvm.bitreverse.i64
  // CHECK: @llvm.bitreverse.i128
  P(bitreverseg, ((char)N));
  P(bitreverseg, ((short)N));
  P(bitreverseg, ((int)N));
  P(bitreverseg, ((unsigned long)N));
  P(bitreverseg, ((_BitInt(8))N));
  P(bitreverseg, ((_BitInt(16))N));
  P(bitreverseg, ((_BitInt(32))N));
  P(bitreverseg, ((_BitInt(64))N));
  P(bitreverseg, ((_BitInt(128))N));
  P(bitreverseg, (N));
  P(bitreverse8, (N));
  P(bitreverse16, (N));
  P(bitreverse32, (N));
  P(bitreverse64, (N));

  // FIXME
  // V(clear_cache, (&N, &N+1));
  V(trap, ());
  R(extract_return_addr, (&N));
  P(signbit, (1.0));

  R(launder, (&N));

  return 0;
}


void foo(void) {
 __builtin_strcat(0, 0);
}

// CHECK-LABEL: define{{.*}} void @bar(
void bar(void) {
  float f;
  double d;
  long double ld;

  // LLVM's hex representation of float constants is really unfortunate;
  // basically it does a float-to-double "conversion" and then prints the
  // hex form of that.  That gives us weird artifacts like exponents
  // that aren't numerically similar to the original exponent and
  // significand bit-patterns that are offset by three bits (because
  // the exponent was expanded from 8 bits to 11).
  //
  // 0xAE98 == 1010111010011000
  // 0x15D3 == 1010111010011

  f = __builtin_huge_valf();     // CHECK: float    0x7FF0000000000000
  d = __builtin_huge_val();      // CHECK: double   0x7FF0000000000000
  ld = __builtin_huge_vall();
      // While we can't manage the constants we use this test to give us LDTYPE
      // for the rest of the tests
      // LD80: [[LDTYPE:x86_fp80]] [[LDHUGE:0xK7FFF8000000000000000]]
      // LD64: [[LDTYPE:double]] [[LDHUGE:0x7FF0000000000000]]
  f = __builtin_nanf("");        // CHECK: float    0x7FF8000000000000
  d = __builtin_nan("");         // CHECK: double   0x7FF8000000000000
  ld = __builtin_nanl("");
      // LD80: [[LDTYPE]] 0xK7FFFC000000000000000
      // LD64: [[LDTYPE]] 0x7FF8000000000000
  f = __builtin_nanf("0xAE98");  // CHECK: float    0x7FF815D300000000
  d = __builtin_nan("0xAE98");   // CHECK: double   0x7FF800000000AE98
  ld = __builtin_nanl("0xAE98");
    // LD80: [[LDTYPE]] 0xK7FFFC00000000000AE98
    // LD64: [[LDTYPE]] 0x7FF800000000AE98
  f = __builtin_nansf("");       // CHECK: float    0x7FF4000000000000
  d = __builtin_nans("");        // CHECK: double   0x7FF4000000000000
  ld = __builtin_nansl("");
    // LD80: [[LDTYPE]] 0xK7FFFA000000000000000
    // LD64: [[LDTYPE]] 0x7FF4000000000000
  f = __builtin_nansf("0xAE98"); // CHECK: float    0x7FF015D300000000
  d = __builtin_nans("0xAE98");  // CHECK: double   0x7FF000000000AE98
  ld = __builtin_nansl("0xAE98");
    // LD80: [[LDTYPE]] 0xK7FFF800000000000AE98
    // LD64: [[LDTYPE]] 0x7FF000000000AE98

}
// CHECK: }

// CHECK-LABEL: define{{.*}} void @test_conditional_bzero
void test_conditional_bzero(void) {
  char dst[20];
  int _sz = 20, len = 20;
  return (_sz
          ? ((_sz >= len)
              ? __builtin_bzero(dst, len)
              : foo())
          : __builtin_bzero(dst, len));
  // CHECK: call void @llvm.memset
  // CHECK: call void @llvm.memset
  // CHECK-NOT: phi
}

// CHECK-LABEL: define{{.*}} void @test_conditional_bcopy
void test_conditional_bcopy(void) {
  char dst[20];
  char src[20];
  int _sz = 20, len = 20;
  return (_sz
          ? ((_sz >= len)
              ? __builtin_bcopy(src, dst, len)
              : foo())
          : __builtin_bcopy(src, dst, len));
  // CHECK: call void @llvm.memmove
  // CHECK: call void @llvm.memmove
  // CHECK-NOT: phi
}

// CHECK-LABEL: define{{.*}} void @test_float_builtins
void test_float_builtins(__fp16 *H, float F, double D, long double LD) {
  volatile int res;
  res = __builtin_isinf(*H);
  // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f16(half {{.*}}, i32 516)
  // CHECK: zext i1 [[TMP]] to i32

  res = __builtin_isinf(F);
  // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 516)
  // CHECK: zext i1 [[TMP]] to i32

  res = __builtin_isinf(D);
  // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f64(double {{.*}}, i32 516)
  // CHECK: zext i1 [[TMP]] to i32

  res = __builtin_isinf(LD);
  // LD80: [[TMP:%.*]] = call i1 @llvm.is.fpclass.[[LDLLVMTY:f80]]([[LDTYPE]] {{.*}}, i32 516)
  // LD64: [[TMP:%.*]] = call i1 @llvm.is.fpclass.[[LDLLVMTY:f64]]([[LDTYPE]] {{.*}}, i32 516)
  // CHECK: zext i1 [[TMP]] to i32

  res = __builtin_isinf_sign(*H);
  // CHECK:  %[[ABS:.*]] = call half @llvm.fabs.f16(half %[[ARG:.*]])
  // CHECK:  %[[ISINF:.*]] = fcmp oeq half %[[ABS]], 0xH7C00
  // CHECK:  %[[BITCAST:.*]] = bitcast half %[[ARG]] to i16
  // CHECK:  %[[ISNEG:.*]] = icmp slt i16 %[[BITCAST]], 0
  // CHECK:  %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1
  // CHECK:  select i1 %[[ISINF]], i32 %[[SIGN]], i32 0

  res = __builtin_isinf_sign(F);
  // CHECK:  %[[ABS:.*]] = call float @llvm.fabs.f32(float %[[ARG:.*]])
  // CHECK:  %[[ISINF:.*]] = fcmp oeq float %[[ABS]], 0x7FF0000000000000
  // CHECK:  %[[BITCAST:.*]] = bitcast float %[[ARG]] to i32
  // CHECK:  %[[ISNEG:.*]] = icmp slt i32 %[[BITCAST]], 0
  // CHECK:  %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1
  // CHECK:  select i1 %[[ISINF]], i32 %[[SIGN]], i32 0

  res = __builtin_isinf_sign(D);
  // CHECK:  %[[ABS:.*]] = call double @llvm.fabs.f64(double %[[ARG:.*]])
  // CHECK:  %[[ISINF:.*]] = fcmp oeq double %[[ABS]], 0x7FF0000000000000
  // CHECK:  %[[BITCAST:.*]] = bitcast double %[[ARG]] to i64
  // CHECK:  %[[ISNEG:.*]] = icmp slt i64 %[[BITCAST]], 0
  // CHECK:  %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1
  // CHECK:  select i1 %[[ISINF]], i32 %[[SIGN]], i32 0

  res = __builtin_isinf_sign(LD);
  // CHECK:  %[[ABS:.*]] = call [[LDTYPE]] @llvm.fabs.[[LDLLVMTY]]([[LDTYPE]] %[[ARG:.*]])
  // CHECK:  %[[ISINF:.*]] = fcmp oeq [[LDTYPE]] %[[ABS]], [[LDHUGE]]
  // LD80:   %[[BITCAST:.*]] = bitcast [[LDTYPE]] %[[ARG]] to [[LDINTTY:i80]]
  // LD64:   %[[BITCAST:.*]] = bitcast [[LDTYPE]] %[[ARG]] to [[LDINTTY:i64]]
  // CHECK:  %[[ISNEG:.*]] = icmp slt [[LDINTTY]] %[[BITCAST]], 0
  // CHECK:  %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1
  // CHECK:  select i1 %[[ISINF]], i32 %[[SIGN]], i32 0

  res = __builtin_isfinite(*H);
  // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f16(half {{.*}}, i32 504)
  // CHECK: zext i1 [[TMP]] to i32

  res = __builtin_isfinite(F);
  // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 504)
  // CHECK: zext i1 [[TMP]] to i32

  res = finite(D);
  // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f64(double {{.*}}, i32 504)
  // CHECK: zext i1 [[TMP]] to i32

  res = __builtin_isnormal(*H);
  // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f16(half {{.*}}, i32 264)
  // CHECK: zext i1 [[TMP]] to i32

  res = __builtin_isnormal(F);
  // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 264)
  // CHECK: zext i1 [[TMP]] to i32

  res = __builtin_issubnormal(F);
  // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 144)
  // CHECK: zext i1 [[TMP]] to i32

  res = __builtin_iszero(F);
  // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 96)
  // CHECK: zext i1 [[TMP]] to i32

  res = __builtin_issignaling(F);
  // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 1)
  // CHECK: zext i1 [[TMP]] to i32

  res = __builtin_flt_rounds();
  // CHECK: call i32 @llvm.get.rounding(
}

// CHECK-LABEL: define{{.*}} void @test_float_builtin_ops
void test_float_builtin_ops(float F, double D, long double LD, int I) {
  volatile float resf;
  volatile double resd;
  volatile long double resld;
  volatile long int resli;
  volatile long long int reslli;

  resf = __builtin_fmodf(F,F);
  // CHECK: frem float

  resd = __builtin_fmod(D,D);
  // CHECK: frem double

  resld = __builtin_fmodl(LD,LD);
  // CHECK: frem [[LDTYPE]]

  resf = __builtin_fabsf(F);
  resd = __builtin_fabs(D);
  resld = __builtin_fabsl(LD);
  // CHECK: call float @llvm.fabs.f32(float
  // CHECK: call double @llvm.fabs.f64(double
  // CHECK: call [[LDTYPE]] @llvm.fabs.[[LDLLVMTY]]([[LDTYPE]]

  resf = __builtin_canonicalizef(F);
  resd = __builtin_canonicalize(D);
  resld = __builtin_canonicalizel(LD);
  // CHECK: call float @llvm.canonicalize.f32(float
  // CHECK: call double @llvm.canonicalize.f64(double
  // CHECK: call [[LDTYPE]] @llvm.canonicalize.[[LDLLVMTY]]([[LDTYPE]]

  resf = __builtin_fminf(F, F);
  // CHECK: call nsz float @llvm.minnum.f32

  resd = __builtin_fmin(D, D);
  // CHECK: call nsz double @llvm.minnum.f64

  resld = __builtin_fminl(LD, LD);
  // CHECK: call nsz [[LDTYPE]] @llvm.minnum.[[LDLLVMTY]]

  resf = __builtin_fmaxf(F, F);
  // CHECK: call nsz float @llvm.maxnum.f32

  resd = __builtin_fmax(D, D);
  // CHECK: call nsz double @llvm.maxnum.f64

  resld = __builtin_fmaxl(LD, LD);
  // CHECK: call nsz [[LDTYPE]] @llvm.maxnum.[[LDLLVMTY]]

  resf = __builtin_fminimum_numf(F, F);
  // CHECK: call float @llvm.minimumnum.f32

  resf = __builtin_fminimum_numf(I, I);
  // CHECK: sitofp i32 {{%[0-9]+}} to float
  // CHECK: sitofp i32 {{%[0-9]+}} to float
  // CHECK: call float @llvm.minimumnum.f32

  resf = __builtin_fminimum_numf(1.0, 2.0);
  // CHECK: store volatile float 1.000000e+00, ptr %resf

  resd = __builtin_fminimum_num(D, D);
  // CHECK: call double @llvm.minimumnum.f64

  resd = __builtin_fminimum_num(I, I);
  // CHECK: sitofp i32 {{%[0-9]+}} to double
  // CHECK: sitofp i32 {{%[0-9]+}} to double
  // CHECK: call double @llvm.minimumnum.f64

  resd = __builtin_fminimum_num(1.0, 2.0);
  // CHECK: store volatile double 1.000000e+00, ptr %resd

  //FIXME: __builtin_fminimum_numl is not supported well yet.
  resld = __builtin_fminimum_numl(1.0, 2.0);
  // LD80: store volatile x86_fp80 0xK3FFF8000000000000000, ptr %resld, align 16
  // LD64: store volatile double 1.000000e+00, ptr %resld

  resf = __builtin_fmaximum_numf(F, F);
  // CHECK: call float @llvm.maximumnum.f32

  resf = __builtin_fmaximum_numf(I, I);
  // CHECK: sitofp i32 {{%[0-9]+}} to float
  // CHECK: sitofp i32 {{%[0-9]+}} to float
  // CHECK: call float @llvm.maximumnum.f32

  resf = __builtin_fmaximum_numf(1.0, 2.0);
  // CHECK: store volatile float 2.000000e+00, ptr %resf

  resd = __builtin_fmaximum_num(D, D);
  // CHECK: call double @llvm.maximumnum.f64

  resd = __builtin_fmaximum_num(I, I);
  // CHECK: sitofp i32 {{%[0-9]+}} to double
  // CHECK: sitofp i32 {{%[0-9]+}} to double
  // CHECK: call double @llvm.maximumnum.f64

  resd = __builtin_fmaximum_num(1.0, 2.0);
  // CHECK: store volatile double 2.000000e+00, ptr %resd

  //FIXME: __builtin_fmaximum_numl is not supported well yet.
  resld = __builtin_fmaximum_numl(1.0, 2.0);
  // LD80: store volatile x86_fp80 0xK40008000000000000000, ptr %resld, align 16
  // LD64: store volatile double 2.000000e+00, ptr %resld

  resf = __builtin_fabsf(F);
  // CHECK: call float @llvm.fabs.f32

  resd = __builtin_fabs(D);
  // CHECK: call double @llvm.fabs.f64

  resld = __builtin_fabsl(LD);
  // CHECK: call [[LDTYPE]] @llvm.fabs.[[LDLLVMTY]]

  resf = __builtin_copysignf(F, F);
  // CHECK: call float @llvm.copysign.f32

  resd = __builtin_copysign(D, D);
  // CHECK: call double @llvm.copysign.f64

  resld = __builtin_copysignl(LD, LD);
  // CHECK: call [[LDTYPE]] @llvm.copysign.[[LDLLVMTY]]

  resf = __builtin_ceilf(F);
  // CHECK: call float @llvm.ceil.f32

  resd = __builtin_ceil(D);
  // CHECK: call double @llvm.ceil.f64

  resld = __builtin_ceill(LD);
  // CHECK: call [[LDTYPE]] @llvm.ceil.[[LDLLVMTY]]

  resf = __builtin_floorf(F);
  // CHECK: call float @llvm.floor.f32

  resd = __builtin_floor(D);
  // CHECK: call double @llvm.floor.f64

  resld = __builtin_floorl(LD);
  // CHECK: call [[LDTYPE]] @llvm.floor.[[LDLLVMTY]]

  resf = __builtin_sqrtf(F);
  // CHECK: call float @llvm.sqrt.f32(

  resd = __builtin_sqrt(D);
  // CHECK: call double @llvm.sqrt.f64(

  resld = __builtin_sqrtl(LD);
  // CHECK: call [[LDTYPE]] @llvm.sqrt.[[LDLLVMTY]]

  resf = __builtin_truncf(F);
  // CHECK: call float @llvm.trunc.f32

  resd = __builtin_trunc(D);
  // CHECK: call double @llvm.trunc.f64

  resld = __builtin_truncl(LD);
  // CHECK: call [[LDTYPE]] @llvm.trunc.[[LDLLVMTY]]

  resf = __builtin_rintf(F);
  // CHECK: call float @llvm.rint.f32

  resd = __builtin_rint(D);
  // CHECK: call double @llvm.rint.f64

  resld = __builtin_rintl(LD);
  // CHECK: call [[LDTYPE]] @llvm.rint.[[LDLLVMTY]]

  resf = __builtin_nearbyintf(F);
  // CHECK: call float @llvm.nearbyint.f32

  resd = __builtin_nearbyint(D);
  // CHECK: call double @llvm.nearbyint.f64

  resld = __builtin_nearbyintl(LD);
  // CHECK: call [[LDTYPE]] @llvm.nearbyint.[[LDLLVMTY]]

  resf = __builtin_roundf(F);
  // CHECK: call float @llvm.round.f32

  resd = __builtin_round(D);
  // CHECK: call double @llvm.round.f64

  resld = __builtin_roundl(LD);
  // CHECK: call [[LDTYPE]] @llvm.round.[[LDLLVMTY]]

  resf = __builtin_roundevenf(F);
  // CHECK: call float @llvm.roundeven.f32

  resd = __builtin_roundeven(D);
  // CHECK: call double @llvm.roundeven.f64

  __asm__("foo_bar0:");
  // CHECK: foo_bar0
  resld = __builtin_roundevenl(LD);
  // CHECK: call [[LDTYPE]] @llvm.roundeven.[[LDLLVMTY]]
  
  __asm__("foo_bar1:");
// CHECK: foo_bar1
  resli = __builtin_lroundf (F);
  // LONG64: call [[LONGINTTY:i64]] @llvm.lround.[[LONGINTTY]].f32
  // LONG32: call [[LONGINTTY:i32]] @llvm.lround.[[LONGINTTY]].f32
// CHECK: foo_after
  __asm__("foo_after:");
  resli = __builtin_lround (D);
  // CHECK: call [[LONGINTTY]] @llvm.lround.[[LONGINTTY]].f64

  resli = __builtin_lroundl (LD);
  // CHECK: call [[LONGINTTY]] @llvm.lround.[[LONGINTTY]].[[LDLLVMTY]]

  resli = __builtin_lrintf (F);
  // CHECK: call [[LONGINTTY]] @llvm.lrint.[[LONGINTTY]].f32

  resli = __builtin_lrint (D);
  // CHECK: call [[LONGINTTY]] @llvm.lrint.[[LONGINTTY]].f64

  resli = __builtin_lrintl (LD);
  // CHECK: call [[LONGINTTY]] @llvm.lrint.[[LONGINTTY]].[[LDLLVMTY]]
}

// __builtin_longjmp isn't supported on all platforms, so only test it on X86.
#ifdef __x86_64__

// LD80-LABEL: define{{.*}} void @test_builtin_longjmp(ptr{{.*}}
void test_builtin_longjmp(void **buffer) {
  // LD80: [[LOAD:%[a-z0-9]+]] = load ptr, ptr
  // LD80-NEXT: call void @llvm.eh.sjlj.longjmp(ptr [[LOAD]])
  __builtin_longjmp(buffer, 1);
  // LD80-NEXT: unreachable
}

#endif

// CHECK-LABEL: define{{.*}} void @test_memory_builtins
void test_memory_builtins(int n) {
  // CHECK: call ptr @malloc
  void * p = __builtin_malloc(n);
  // CHECK: call void @free
  __builtin_free(p);
  // CHECK: call ptr @calloc
  p = __builtin_calloc(1, n);
  // CHECK: call ptr @realloc
  p = __builtin_realloc(p, n);
  // CHECK: call void @free
  __builtin_free(p);
}

// CHECK-LABEL: define{{.*}} i64 @test_builtin_readcyclecounter
long long test_builtin_readcyclecounter(void) {
  // CHECK: call i64 @llvm.readcyclecounter()
  return __builtin_readcyclecounter();
}

// CHECK-LABEL: define{{.*}} i64 @test_builtin_readsteadycounter
long long test_builtin_readsteadycounter(void) {
  // CHECK: call i64 @llvm.readsteadycounter()
  return __builtin_readsteadycounter();
}

/// __builtin_launder should be a NOP in C since there are no vtables.
// CHECK-LABEL: define{{.*}} void @test_builtin_launder
void test_builtin_launder(int *p) {
  // CHECK: [[TMP:%.*]] = load ptr,
  // CHECK-NOT: @llvm.launder
  // CHECK: store ptr [[TMP]],
  int *d = __builtin_launder(p);
}

#ifdef __SIZEOF_INT128__

// __warn_memset_zero_len should be NOP, see https://sourceware.org/bugzilla/show_bug.cgi?id=25399
// I128-LABEL: define{{.*}} void @test___warn_memset_zero_len
void test___warn_memset_zero_len(void) {
  // I128-NOT: @__warn_memset_zero_len
  __warn_memset_zero_len();
}

// I128-LABEL: define{{.*}} void @test_builtin_popcountg
void test_builtin_popcountg(unsigned char uc, unsigned short us,
                            unsigned int ui, unsigned long ul,
                            unsigned long long ull, unsigned __int128 ui128,
                            unsigned _BitInt(128) ubi128,
                            _Bool __attribute__((ext_vector_type(8))) vb8) {
  volatile int pop;
#if __aarch64__
  int x = 0;
  x = x * 2;
#endif
  //      I128: %2 = load i8, ptr %uc.addr, align 1
  // I128-NEXT: %3 = call i8 @llvm.ctpop.i8(i8 %2)
  // I128-NEXT: %cast = zext i8 %3 to i32
  // I128-NEXT: store volatile i32 %cast, ptr %pop, align 4
  pop = __builtin_popcountg(uc);
  //      I128: %4 = load i16, ptr %us.addr, align 2
  // I128-NEXT: %5 = call i16 @llvm.ctpop.i16(i16 %4)
  // I128-NEXT: %cast2 = zext i16 %5 to i32
  // I128-NEXT: store volatile i32 %cast2, ptr %pop, align 4
  pop = __builtin_popcountg(us);
  //      I128: %6 = load i32, ptr %ui.addr, align 4
  // I128-NEXT: %7 = call i32 @llvm.ctpop.i32(i32 %6)
  // I128-NEXT: store volatile i32 %7, ptr %pop, align 4
  pop = __builtin_popcountg(ui);
  // I128: %8 = load i64, ptr %ul.addr, align 8
  // I128-NEXT: %9 = call i64 @llvm.ctpop.i64(i64 %8)
  // I128-NEXT: %cast3 = trunc i64 %9 to i32
  // I128-NEXT: store volatile i32 %cast3, ptr %pop, align 4
  pop = __builtin_popcountg(ul);
  //      I128: %10 = load i64, ptr %ull.addr, align 8
  // I128-NEXT: %11 = call i64 @llvm.ctpop.i64(i64 %10)
  // I128-NEXT: %cast4 = trunc i64 %11 to i32
  // I128-NEXT: store volatile i32 %cast4, ptr %pop, align 4
  pop = __builtin_popcountg(ull);
  //      I128: %12 = load i128, ptr %ui128.addr, align 16
  // I128-NEXT: %13 = call i128 @llvm.ctpop.i128(i128 %12)
  // I128-NEXT: %cast5 = trunc i128 %13 to i32
  // I128-NEXT: store volatile i32 %cast5, ptr %pop, align 4
  pop = __builtin_popcountg(ui128);
  //      I128: %14 = load i128, ptr %ubi128.addr
  // I128-NEXT: %15 = call i128 @llvm.ctpop.i128(i128 %14)
  // I128-NEXT: %cast6 = trunc i128 %15 to i32
  // I128-NEXT: store volatile i32 %cast6, ptr %pop, align 4
  pop = __builtin_popcountg(ubi128);
  //      I128: %load_bits7 = load i8, ptr %vb8.addr, align 1
  // I128-NEXT: %16 = bitcast i8 %load_bits7 to <8 x i1>
  // I128-NEXT: %17 = bitcast <8 x i1> %16 to i8
  // I128-NEXT: %18 = call i8 @llvm.ctpop.i8(i8 %17)
  // I128-NEXT: %cast8 = zext i8 %18 to i32
  // I128-NEXT: store volatile i32 %cast8, ptr %pop, align 4
  pop = __builtin_popcountg(vb8);
}

// I128-LABEL: define{{.*}} void @test_builtin_clzg
void test_builtin_clzg(unsigned char uc, unsigned short us, unsigned int ui,
                       unsigned long ul, unsigned long long ull,
                       unsigned __int128 ui128, unsigned _BitInt(128) ubi128,
                       signed char sc, short s, int i,
                       _Bool __attribute__((ext_vector_type(8))) vb8) {
  volatile int lz;
#if __aarch64__
  int x = 0;
  x = x * 2;
#endif
  //      I128:  %2 = load i8, ptr %uc.addr, align 1
  // I128-NEXT:  %3 = call i8 @llvm.ctlz.i8(i8 %2, i1
  // I128-NEXT:  %cast = zext i8 %3 to i32
  // I128-NEXT:  store volatile i32 %cast, ptr %lz, align 4
  lz = __builtin_clzg(uc);
  // I128-NEXT:  %4 = load i16, ptr %us.addr, align 2
  // I128-NEXT:  %5 = call i16 @llvm.ctlz.i16(i16 %4, i1
  // I128-NEXT:  %cast2 = zext i16 %5 to i32
  // I128-NEXT:  store volatile i32 %cast2, ptr %lz, align 4
  lz = __builtin_clzg(us);
  // I128-NEXT:  %6 = load i32, ptr %ui.addr, align 4
  // I128-NEXT:  %7 = call i32 @llvm.ctlz.i32(i32 %6, i1
  // I128-NEXT:  store volatile i32 %7, ptr %lz, align 4
  lz = __builtin_clzg(ui);
  // I128-NEXT:  %8 = load i64, ptr %ul.addr, align 8
  // I128-NEXT:  %9 = call i64 @llvm.ctlz.i64(i64 %8, i1
  // I128-NEXT:  %cast3 = trunc i64 %9 to i32
  // I128-NEXT:  store volatile i32 %cast3, ptr %lz, align 4
  lz = __builtin_clzg(ul);
  // I128-NEXT:  %10 = load i64, ptr %ull.addr, align 8
  // I128-NEXT:  %11 = call i64 @llvm.ctlz.i64(i64 %10, i1
  // I128-NEXT:  %cast4 = trunc i64 %11 to i32
  // I128-NEXT:  store volatile i32 %cast4, ptr %lz, align 4
  lz = __builtin_clzg(ull);
  // I128-NEXT:  %12 = load i128, ptr %ui128.addr, align 16
  // I128-NEXT:  %13 = call i128 @llvm.ctlz.i128(i128 %12, i1
  // I128-NEXT:  %cast5 = trunc i128 %13 to i32
  // I128-NEXT:  store volatile i32 %cast5, ptr %lz, align 4
  lz = __builtin_clzg(ui128);
  // I128-NEXT:  %14 = load i128, ptr %ubi128.addr
  // I128-NEXT:  %15 = call i128 @llvm.ctlz.i128(i128 %14, i1
  // I128-NEXT:  %cast6 = trunc i128 %15 to i32
  // I128-NEXT:  store volatile i32 %cast6, ptr %lz, align 4
  lz = __builtin_clzg(ubi128);
  // I128-NEXT:  %load_bits7 = load i8, ptr %vb8.addr, align 1
  // I128-NEXT:  %16 = bitcast i8 %load_bits7 to <8 x i1>
  // I128-NEXT:  %17 = bitcast <8 x i1> %16 to i8
  // I128-NEXT:  %18 = call i8 @llvm.ctlz.i8(i8 %17, i1
  // I128-NEXT:  %cast8 = zext i8 %18 to i32
  // I128-NEXT:  store volatile i32 %cast8, ptr %lz, align 4
  lz = __builtin_clzg(vb8);
  // I128-NEXT:  %19 = load i8, ptr %uc.addr, align 1
  // I128-NEXT:  %20 = call i8 @llvm.ctlz.i8(i8 %19, i1
  // I128-NEXT:  %cast9 = zext i8 %20 to i32
  // I128-NEXT:  %iszero = icmp eq i8 %19, 0
  // I128-NEXT:  %21 = load i8, ptr %sc.addr, align 1
  // I128-NEXT:  %conv = sext i8 %21 to i32
  // I128-NEXT:  %clzg = select i1 %iszero, i32 %conv, i32 %cast9
  // I128-NEXT:  store volatile i32 %clzg, ptr %lz, align 4
  lz = __builtin_clzg(uc, sc);
  // I128-NEXT:  %22 = load i16, ptr %us.addr, align 2
  // I128-NEXT:  %23 = call i16 @llvm.ctlz.i16(i16 %22, i1
  // I128-NEXT:  %cast10 = zext i16 %23 to i32
  // I128-NEXT:  %iszero11 = icmp eq i16 %22, 0
  // I128-NEXT:  %24 = load i8, ptr %uc.addr, align 1
  // I128-NEXT:  %conv12 = zext i8 %24 to i32
  // I128-NEXT:  %clzg13 = select i1 %iszero11, i32 %conv12, i32 %cast10
  // I128-NEXT:  store volatile i32 %clzg13, ptr %lz, align 4
  lz = __builtin_clzg(us, uc);
  // I128-NEXT:  %25 = load i32, ptr %ui.addr, align 4
  // I128-NEXT:  %26 = call i32 @llvm.ctlz.i32(i32 %25, i1
  // I128-NEXT:  %iszero14 = icmp eq i32 %25, 0
  // I128-NEXT:  %27 = load i16, ptr %s.addr, align 2
  // I128-NEXT:  %conv15 = sext i16 %27 to i32
  // I128-NEXT:  %clzg16 = select i1 %iszero14, i32 %conv15, i32 %26
  // I128-NEXT:  store volatile i32 %clzg16, ptr %lz, align 4
  lz = __builtin_clzg(ui, s);
  // I128-NEXT:  %28 = load i64, ptr %ul.addr, align 8
  // I128-NEXT:  %29 = call i64 @llvm.ctlz.i64(i64 %28, i1
  // I128-NEXT:  %cast17 = trunc i64 %29 to i32
  // I128-NEXT:  %iszero18 = icmp eq i64 %28, 0
  // I128-NEXT:  %30 = load i16, ptr %us.addr, align 2
  // I128-NEXT:  %conv19 = zext i16 %30 to i32
  // I128-NEXT:  %clzg20 = select i1 %iszero18, i32 %conv19, i32 %cast17
  // I128-NEXT:  store volatile i32 %clzg20, ptr %lz, align 4
  lz = __builtin_clzg(ul, us);
  // I128-NEXT:  %31 = load i64, ptr %ull.addr, align 8
  // I128-NEXT:  %32 = call i64 @llvm.ctlz.i64(i64 %31, i1
  // I128-NEXT:  %cast21 = trunc i64 %32 to i32
  // I128-NEXT:  %iszero22 = icmp eq i64 %31, 0
  // I128-NEXT:  %33 = load i32, ptr %i.addr, align 4
  // I128-NEXT:  %clzg23 = select i1 %iszero22, i32 %33, i32 %cast21
  // I128-NEXT:  store volatile i32 %clzg23, ptr %lz, align 4
  lz = __builtin_clzg(ull, i);
  // I128-NEXT:  %34 = load i128, ptr %ui128.addr, align 16
  // I128-NEXT:  %35 = call i128 @llvm.ctlz.i128(i128 %34, i1
  // I128-NEXT:  %cast24 = trunc i128 %35 to i32
  // I128-NEXT:  %iszero25 = icmp eq i128 %34, 0
  // I128-NEXT:  %36 = load i32, ptr %i.addr, align 4
  // I128-NEXT:  %clzg26 = select i1 %iszero25, i32 %36, i32 %cast24
  // I128-NEXT:  store volatile i32 %clzg26, ptr %lz, align 4
  lz = __builtin_clzg(ui128, i);
  // I128-NEXT:  %37 = load i128, ptr %ubi128.addr
  // I128-NEXT:  %38 = call i128 @llvm.ctlz.i128(i128 %37, i1
  // I128-NEXT:  %cast27 = trunc i128 %38 to i32
  // I128-NEXT:  %iszero28 = icmp eq i128 %37, 0
  // I128-NEXT:  %39 = load i32, ptr %i.addr, align 4
  // I128-NEXT:  %clzg29 = select i1 %iszero28, i32 %39, i32 %cast27
  // I128-NEXT:  store volatile i32 %clzg29, ptr %lz, align 4
  lz = __builtin_clzg(ubi128, i);
  // I128-NEXT:  %load_bits30 = load i8, ptr %vb8.addr, align 1
  // I128-NEXT:  %40 = bitcast i8 %load_bits30 to <8 x i1>
  // I128-NEXT:  %41 = bitcast <8 x i1> %40 to i8
  // I128-NEXT:  %42 = call i8 @llvm.ctlz.i8(i8 %41, i1
  // I128-NEXT:  %cast31 = zext i8 %42 to i32
  // I128-NEXT:  %iszero32 = icmp eq i8 %41, 0
  // I128-NEXT:  %43 = load i32, ptr %i.addr, align 4
  // I128-NEXT:  %clzg33 = select i1 %iszero32, i32 %43, i32 %cast31
  // I128-NEXT:  store volatile i32 %clzg33, ptr %lz, align 4
  lz = __builtin_clzg(vb8, i);
}

// I128-LABEL: define{{.*}} void @test_builtin_ctzg
void test_builtin_ctzg(unsigned char uc, unsigned short us, unsigned int ui,
                       unsigned long ul, unsigned long long ull,
                       unsigned __int128 ui128, unsigned _BitInt(128) ubi128,
                       signed char sc, short s, int i,
                       _Bool __attribute__((ext_vector_type(8))) vb8) {
  volatile int tz;
#if __aarch64__
  int x = 0;
  x = x * 2;
#endif
  //      I128: %2 = load i8, ptr %uc.addr, align 1
  // I128-NEXT: %3 = call i8 @llvm.cttz.i8(i8 %2, i1
  // I128-NEXT: %cast = zext i8 %3 to i32
  // I128-NEXT: store volatile i32 %cast, ptr %tz, align 4
  tz = __builtin_ctzg(uc);
  // I128-NEXT: %4 = load i16, ptr %us.addr, align 2
  // I128-NEXT: %5 = call i16 @llvm.cttz.i16(i16 %4, i1
  // I128-NEXT: %cast2 = zext i16 %5 to i32
  // I128-NEXT: store volatile i32 %cast2, ptr %tz, align 4
  tz = __builtin_ctzg(us);
  // I128-NEXT: %6 = load i32, ptr %ui.addr, align 4
  // I128-NEXT: %7 = call i32 @llvm.cttz.i32(i32 %6, i1
  // I128-NEXT: store volatile i32 %7, ptr %tz, align 4
  tz = __builtin_ctzg(ui);
  // I128-NEXT: %8 = load i64, ptr %ul.addr, align 8
  // I128-NEXT: %9 = call i64 @llvm.cttz.i64(i64 %8, i1
  // I128-NEXT: %cast3 = trunc i64 %9 to i32
  // I128-NEXT: store volatile i32 %cast3, ptr %tz, align 4
  tz = __builtin_ctzg(ul);
  // I128-NEXT: %10 = load i64, ptr %ull.addr, align 8
  // I128-NEXT: %11 = call i64 @llvm.cttz.i64(i64 %10, i1
  // I128-NEXT: %cast4 = trunc i64 %11 to i32
  // I128-NEXT: store volatile i32 %cast4, ptr %tz, align 4
  tz = __builtin_ctzg(ull);
  // I128-NEXT: %12 = load i128, ptr %ui128.addr, align 16
  // I128-NEXT: %13 = call i128 @llvm.cttz.i128(i128 %12, i1
  // I128-NEXT: %cast5 = trunc i128 %13 to i32
  // I128-NEXT: store volatile i32 %cast5, ptr %tz, align 4
  tz = __builtin_ctzg(ui128);
  // I128-NEXT: %14 = load i128, ptr %ubi128.addr
  // I128-NEXT: %15 = call i128 @llvm.cttz.i128(i128 %14, i1
  // I128-NEXT: %cast6 = trunc i128 %15 to i32
  // I128-NEXT: store volatile i32 %cast6, ptr %tz, align 4
  tz = __builtin_ctzg(ubi128);
  // I128-NEXT: %load_bits7 = load i8, ptr %vb8.addr, align 1
  // I128-NEXT: %16 = bitcast i8 %load_bits7 to <8 x i1>
  // I128-NEXT: %17 = bitcast <8 x i1> %16 to i8
  // I128-NEXT: %18 = call i8 @llvm.cttz.i8(i8 %17, i1
  // I128-NEXT: %cast8 = zext i8 %18 to i32
  // I128-NEXT: store volatile i32 %cast8, ptr %tz, align 4
  tz = __builtin_ctzg(vb8);
  // I128-NEXT: %19 = load i8, ptr %uc.addr, align 1
  // I128-NEXT: %20 = call i8 @llvm.cttz.i8(i8 %19, i1
  // I128-NEXT: %cast9 = zext i8 %20 to i32
  // I128-NEXT: %iszero = icmp eq i8 %19, 0
  // I128-NEXT: %21 = load i8, ptr %sc.addr, align 1
  // I128-NEXT: %conv = sext i8 %21 to i32
  // I128-NEXT: %ctzg = select i1 %iszero, i32 %conv, i32 %cast9
  // I128-NEXT: store volatile i32 %ctzg, ptr %tz, align 4
  tz = __builtin_ctzg(uc, sc);
  // I128-NEXT: %22 = load i16, ptr %us.addr, align 2
  // I128-NEXT: %23 = call i16 @llvm.cttz.i16(i16 %22, i1
  // I128-NEXT: %cast10 = zext i16 %23 to i32
  // I128-NEXT: %iszero11 = icmp eq i16 %22, 0
  // I128-NEXT: %24 = load i8, ptr %uc.addr, align 1
  // I128-NEXT: %conv12 = zext i8 %24 to i32
  // I128-NEXT: %ctzg13 = select i1 %iszero11, i32 %conv12, i32 %cast10
  // I128-NEXT: store volatile i32 %ctzg13, ptr %tz, align 4
  tz = __builtin_ctzg(us, uc);
  // I128-NEXT: %25 = load i32, ptr %ui.addr, align 4
  // I128-NEXT: %26 = call i32 @llvm.cttz.i32(i32 %25, i1
  // I128-NEXT: %iszero14 = icmp eq i32 %25, 0
  // I128-NEXT: %27 = load i16, ptr %s.addr, align 2
  // I128-NEXT: %conv15 = sext i16 %27 to i32
  // I128-NEXT: %ctzg16 = select i1 %iszero14, i32 %conv15, i32 %26
  // I128-NEXT: store volatile i32 %ctzg16, ptr %tz, align 4
  tz = __builtin_ctzg(ui, s);
  // I128-NEXT: %28 = load i64, ptr %ul.addr, align 8
  // I128-NEXT: %29 = call i64 @llvm.cttz.i64(i64 %28, i1
  // I128-NEXT: %cast17 = trunc i64 %29 to i32
  // I128-NEXT: %iszero18 = icmp eq i64 %28, 0
  // I128-NEXT: %30 = load i16, ptr %us.addr, align 2
  // I128-NEXT: %conv19 = zext i16 %30 to i32
  // I128-NEXT: %ctzg20 = select i1 %iszero18, i32 %conv19, i32 %cast17
  // I128-NEXT: store volatile i32 %ctzg20, ptr %tz, align 4
  tz = __builtin_ctzg(ul, us);
  // I128-NEXT: %31 = load i64, ptr %ull.addr, align 8
  // I128-NEXT: %32 = call i64 @llvm.cttz.i64(i64 %31, i1
  // I128-NEXT: %cast21 = trunc i64 %32 to i32
  // I128-NEXT: %iszero22 = icmp eq i64 %31, 0
  // I128-NEXT: %33 = load i32, ptr %i.addr, align 4
  // I128-NEXT: %ctzg23 = select i1 %iszero22, i32 %33, i32 %cast21
  // I128-NEXT: store volatile i32 %ctzg23, ptr %tz, align 4
  tz = __builtin_ctzg(ull, i);
  // I128-NEXT: %34 = load i128, ptr %ui128.addr, align 16
  // I128-NEXT: %35 = call i128 @llvm.cttz.i128(i128 %34, i1
  // I128-NEXT: %cast24 = trunc i128 %35 to i32
  // I128-NEXT: %iszero25 = icmp eq i128 %34, 0
  // I128-NEXT: %36 = load i32, ptr %i.addr, align 4
  // I128-NEXT: %ctzg26 = select i1 %iszero25, i32 %36, i32 %cast24
  // I128-NEXT: store volatile i32 %ctzg26, ptr %tz, align 4
  tz = __builtin_ctzg(ui128, i);
  // I128-NEXT: %37 = load i128, ptr %ubi128.addr
  // I128-NEXT: %38 = call i128 @llvm.cttz.i128(i128 %37, i1
  // I128-NEXT: %cast27 = trunc i128 %38 to i32
  // I128-NEXT: %iszero28 = icmp eq i128 %37, 0
  // I128-NEXT: %39 = load i32, ptr %i.addr, align 4
  // I128-NEXT: %ctzg29 = select i1 %iszero28, i32 %39, i32 %cast27
  // I128-NEXT: store volatile i32 %ctzg29, ptr %tz, align 4
  tz = __builtin_ctzg(ubi128, i);
  // I128-NEXT: %load_bits30 = load i8, ptr %vb8.addr, align 1
  // I128-NEXT: %40 = bitcast i8 %load_bits30 to <8 x i1>
  // I128-NEXT: %41 = bitcast <8 x i1> %40 to i8
  // I128-NEXT: %42 = call i8 @llvm.cttz.i8(i8 %41, i1
  // I128-NEXT: %cast31 = zext i8 %42 to i32
  // I128-NEXT: %iszero32 = icmp eq i8 %41, 0
  // I128-NEXT: %43 = load i32, ptr %i.addr, align 4
  // I128-NEXT: %ctzg33 = select i1 %iszero32, i32 %43, i32 %cast31
  // I128-NEXT: store volatile i32 %ctzg33, ptr %tz, align 4
  tz = __builtin_ctzg(vb8, i);
}

#endif

#include <stdbool.h>
// CHECK-LABEL: define{{.*}} void @test_builtin_bswapg
void test_builtin_bswapg(unsigned char uc, unsigned short us, unsigned int ui,
                       unsigned long ul, unsigned long long ull, bool b,
#ifdef __SIZEOF_INT128__
                       unsigned __int128 ui128,
#endif
                       _BitInt(8) bi8,
                       _BitInt(16) bi16, _BitInt(32) bi32, 
                       _BitInt(64) bi64, _BitInt(128) bi128) {
#if __aarch64__
  int x = 0;
  x = x * 2;
#endif
  b = __builtin_bswapg(b);
  // CHECK: %{{.*}} = load i8, ptr %b.addr
  // CHECK: %{{.*}} = icmp ne i8 %{{.*}}, 0
  // CHECK: %{{.*}} = zext i1 %{{.*}} to i8
  // CHECK: store i8 %{{.*}}, ptr %b.addr
  uc = __builtin_bswapg(uc);
  // CHECK: %{{.*}} = load i8, ptr %uc.addr
  // CHECK: store i8 %{{.*}}, ptr %uc.addr
  us = __builtin_bswapg(us);
  // CHECK: call i16 @llvm.bswap.i16
  ui = __builtin_bswapg(ui);
  // CHECK: call i32 @llvm.bswap.i32
  ul = __builtin_bswapg(ul);
  // CHECK: call [[LONGINTTY]] @llvm.bswap.[[LONGINTTY]]
  ull = __builtin_bswapg(ull);
  // CHECK: call i64 @llvm.bswap.i64
#ifdef __SIZEOF_INT128__
  ui128 = __builtin_bswapg(ui128);
  // I128: call i128 @llvm.bswap.i128
#endif
  bi8 = __builtin_bswapg(bi8);
  // CHECK: [[BI8SWAP:%.*]] = load i8, ptr %bi8.addr, align 1
  // CHECK: store i8 [[BI8SWAP]], ptr %bi8.addr
  bi16 = __builtin_bswapg(bi16);
  // CHECK: call i16 @llvm.bswap.i16
  bi32 = __builtin_bswapg(bi32);
  // CHECK: call i32 @llvm.bswap.i32
  bi64 = __builtin_bswapg(bi64);
  // CHECK: call i64 @llvm.bswap.i64
  bi128 = __builtin_bswapg(bi128);
  // CHECK: call i128 @llvm.bswap.i128
}
// CHECK-LABEL: define{{.*}} void @test_builtin_bitreverseg
void test_builtin_bitreverseg(unsigned char uc, unsigned short us, unsigned int ui,
                       unsigned long ul, unsigned long long ull, bool b,
                       unsigned _BitInt(1) bi1,
#ifdef __SIZEOF_INT128__
                       unsigned __int128 ui128,
#endif
                       _BitInt(8) bi8,
                       _BitInt(16) bi16, _BitInt(32) bi32, 
                       _BitInt(64) bi64, _BitInt(128) bi128) {
#if __aarch64__
  int x = 0;
  x = x * 2;
#endif
  b = __builtin_bitreverseg(b);
  // CHECK: %{{.*}} = load i8, ptr %b.addr
  // CHECK: %{{.*}} = icmp ne i8 %{{.*}}, 0
  // CHECK: %{{.*}} = zext i1 %{{.*}} to i8
  // CHECK: store i8 %{{.*}}, ptr %b.addr
  bi1 = __builtin_bitreverseg(bi1);
  // CHECK: %{{.*}} = load i8, ptr %bi1.addr
  // CHECK: %{{.*}} = icmp ne i8 %{{.*}}, 0
  // CHECK: %{{.*}} = zext i1 %{{.*}} to i8
  // CHECK: store i8 %{{.*}}, ptr %bi1.addr
  uc = __builtin_bitreverseg(uc);
  // CHECK: %{{.*}} = load i8, ptr %uc.addr
  // CHECK: %{{.*}} = call i8 @llvm.bitreverse.i8(i8 %{{.*}})
  // CHECK: store i8 %{{.*}}, ptr %uc.addr
  us = __builtin_bitreverseg(us);
  // CHECK: call i16 @llvm.bitreverse.i16
  ui = __builtin_bitreverseg(ui);
  // CHECK: call i32 @llvm.bitreverse.i32
  ul = __builtin_bitreverseg(ul);
  // CHECK: call [[LONGINTTY]] @llvm.bitreverse.[[LONGINTTY]]
  ull = __builtin_bitreverseg(ull);
  // CHECK: call i64 @llvm.bitreverse.i64
#ifdef __SIZEOF_INT128__
  ui128 = __builtin_bitreverseg(ui128);
  // I128: call i128 @llvm.bitreverse.i128
#endif
  bi8 = __builtin_bitreverseg(bi8);
  // CHECK: %{{.*}} = load i8, ptr %bi8.addr, align 1
  // CHECK: %{{.*}} = call i8 @llvm.bitreverse.i8(i8 %{{.*}})
  // CHECK: store i8 %{{.*}}, ptr %bi8.addr
  bi16 = __builtin_bitreverseg(bi16);
  // CHECK: call i16 @llvm.bitreverse.i16
  bi32 = __builtin_bitreverseg(bi32);
  // CHECK: call i32 @llvm.bitreverse.i32
  bi64 = __builtin_bitreverseg(bi64);
  // CHECK: call i64 @llvm.bitreverse.i64
  bi128 = __builtin_bitreverseg(bi128);
  // CHECK: call i128 @llvm.bitreverse.i128
}