959 lines · c
1// RUN: %clang_cc1 -emit-llvm -o %t %s2// RUN: not grep __builtin %t3// RUN: %clang_cc1 -emit-llvm -triple armv7 -o %t %s4// RUN: not grep __builtin %t5 6// RUN: %clang_cc1 -emit-llvm -triple armv7-darwin-apple -o - %s | FileCheck %s --check-prefixes=CHECK,LD64,LONG327// RUN: %clang_cc1 -emit-llvm -triple arm64-darwin-apple -o - %s | FileCheck %s --check-prefixes=CHECK,LD64,I128,LONG648// RUN: %clang_cc1 -emit-llvm -triple x86_64-darwin-apple -o - %s | FileCheck %s --check-prefixes=CHECK,LD80,I128,LONG649// RUN: %clang_cc1 -emit-llvm -triple x86_64-darwin-apple -o - %s -fexperimental-new-constant-interpreter | FileCheck --check-prefixes=CHECK,LD80,I128,LONG64 %s10 11int printf(const char *, ...);12 13void p(char *str, int x) {14 printf("%s: %d\n", str, x);15}16void q(char *str, double x) {17 printf("%s: %f\n", str, x);18}19void r(char *str, void *ptr) {20 printf("%s: %p\n", str, ptr);21}22 23int random(void);24int finite(double);25 26int main(void) {27 int N = random();28#define P(n,args) p(#n #args, __builtin_##n args)29#define Q(n,args) q(#n #args, __builtin_##n args)30#define R(n,args) r(#n #args, __builtin_##n args)31#define V(n,args) p(#n #args, (__builtin_##n args, 0))32 P(types_compatible_p, (int, float));33 P(choose_expr, (0, 10, 20));34 P(constant_p, (sizeof(10)));35 P(expect, (N == 12, 0));36 V(prefetch, (&N));37 V(prefetch, (&N, 1));38 V(prefetch, (&N, 1, 0));39 40 // Numeric Constants41 42 Q(huge_val, ());43 Q(huge_valf, ());44 Q(huge_vall, ());45 Q(inf, ());46 Q(inff, ());47 Q(infl, ());48 49 P(fpclassify, (0, 1, 2, 3, 4, 1.0));50 P(fpclassify, (0, 1, 2, 3, 4, 1.0f));51 P(fpclassify, (0, 1, 2, 3, 4, 1.0l));52 53 Q(nan, (""));54 Q(nanf, (""));55 Q(nanl, (""));56 Q(nans, (""));57 Q(nan, ("10"));58 Q(nanf, ("10"));59 Q(nanl, ("10"));60 Q(nans, ("10"));61 62 P(isgreater, (1., 2.));63 P(isgreaterequal, (1., 2.));64 P(isless, (1., 2.));65 P(islessequal, (1., 2.));66 P(islessgreater, (1., 2.));67 P(isunordered, (1., 2.));68 69 P(isinf, (1.));70 P(isinf_sign, (1.));71 P(isnan, (1.));72 P(isfinite, (1.));73 P(iszero, (1.));74 P(issubnormal, (1.));75 P(issignaling, (1.));76 P(isfpclass, (1., 1));77 78 Q(fmaximum_num, (1.0, 2.0));79 Q(fmaximum_numf, (1.0, 2.0));80 Q(fmaximum_numl, (1.0, 2.0));81 Q(fminimum_num, (1.0, 2.0));82 Q(fminimum_numf, (1.0, 2.0));83 Q(fminimum_numl, (1.0, 2.0));84 85 // Bitwise & Numeric Functions86 87 P(abs, (N));88 89 P(clz, (N));90 P(clzl, (N));91 P(clzll, (N));92 P(ctz, (N));93 P(ctzl, (N));94 P(ctzll, (N));95 P(ffs, (N));96 P(ffsl, (N));97 P(ffsll, (N));98 P(parity, (N));99 P(parityl, (N));100 P(parityll, (N));101 P(popcount, (N));102 P(popcountl, (N));103 P(popcountll, (N));104 Q(powi, (1.2f, N));105 Q(powif, (1.2f, N));106 Q(powil, (1.2f, N));107 108 // Lib functions109 int a, b, n = random(); // Avoid optimizing out.110 char s0[10], s1[] = "Hello";111 V(strcat, (s0, s1));112 V(strcmp, (s0, s1));113 V(strdup, (s0));114 V(strncat, (s0, s1, n));115 V(strndup, (s0, n));116 V(strchr, (s0, s1[0]));117 V(strrchr, (s0, s1[0]));118 V(strcpy, (s0, s1));119 V(strncpy, (s0, s1, n));120 V(sprintf, (s0, "%s", s1));121 V(snprintf, (s0, n, "%s", s1));122 123 // Object size checking124 V(__memset_chk, (s0, 0, sizeof s0, n));125 V(__memcpy_chk, (s0, s1, sizeof s0, n));126 V(__memmove_chk, (s0, s1, sizeof s0, n));127 V(__mempcpy_chk, (s0, s1, sizeof s0, n));128 V(__strncpy_chk, (s0, s1, sizeof s0, n));129 V(__strcpy_chk, (s0, s1, n));130 s0[0] = 0;131 V(__strcat_chk, (s0, s1, n));132 P(object_size, (s0, 0));133 P(object_size, (s0, 1));134 P(object_size, (s0, 2));135 P(object_size, (s0, 3));136 137 // Whatever138 P(bswapg, ((char)N));139 P(bswapg, ((short)N));140 P(bswapg, ((int)N));141 P(bswapg, ((unsigned long)N));142 P(bswapg, ((_BitInt(8))N));143 P(bswapg, ((_BitInt(16))N));144 P(bswapg, ((_BitInt(32))N));145 P(bswapg, ((_BitInt(64))N));146 P(bswapg, ((_BitInt(128))N));147 P(bswap16, (N));148 P(bswap32, (N));149 P(bswap64, (N));150 151 // CHECK: @llvm.bitreverse.i8152 // CHECK: @llvm.bitreverse.i16153 // CHECK: @llvm.bitreverse.i32154 // CHECK: @llvm.bitreverse.i64155 P(bitreverse8, (N));156 P(bitreverse16, (N));157 P(bitreverse32, (N));158 P(bitreverse64, (N));159 160 // FIXME161 // V(clear_cache, (&N, &N+1));162 V(trap, ());163 R(extract_return_addr, (&N));164 P(signbit, (1.0));165 166 R(launder, (&N));167 168 return 0;169}170 171 172 173void foo(void) {174 __builtin_strcat(0, 0);175}176 177// CHECK-LABEL: define{{.*}} void @bar(178void bar(void) {179 float f;180 double d;181 long double ld;182 183 // LLVM's hex representation of float constants is really unfortunate;184 // basically it does a float-to-double "conversion" and then prints the185 // hex form of that. That gives us weird artifacts like exponents186 // that aren't numerically similar to the original exponent and187 // significand bit-patterns that are offset by three bits (because188 // the exponent was expanded from 8 bits to 11).189 //190 // 0xAE98 == 1010111010011000191 // 0x15D3 == 1010111010011192 193 f = __builtin_huge_valf(); // CHECK: float 0x7FF0000000000000194 d = __builtin_huge_val(); // CHECK: double 0x7FF0000000000000195 ld = __builtin_huge_vall();196 // While we can't manage the constants we use this test to give us LDTYPE197 // for the rest of the tests198 // LD80: [[LDTYPE:x86_fp80]] [[LDHUGE:0xK7FFF8000000000000000]]199 // LD64: [[LDTYPE:double]] [[LDHUGE:0x7FF0000000000000]]200 f = __builtin_nanf(""); // CHECK: float 0x7FF8000000000000201 d = __builtin_nan(""); // CHECK: double 0x7FF8000000000000202 ld = __builtin_nanl("");203 // LD80: [[LDTYPE]] 0xK7FFFC000000000000000204 // LD64: [[LDTYPE]] 0x7FF8000000000000205 f = __builtin_nanf("0xAE98"); // CHECK: float 0x7FF815D300000000206 d = __builtin_nan("0xAE98"); // CHECK: double 0x7FF800000000AE98207 ld = __builtin_nanl("0xAE98");208 // LD80: [[LDTYPE]] 0xK7FFFC00000000000AE98209 // LD64: [[LDTYPE]] 0x7FF800000000AE98210 f = __builtin_nansf(""); // CHECK: float 0x7FF4000000000000211 d = __builtin_nans(""); // CHECK: double 0x7FF4000000000000212 ld = __builtin_nansl("");213 // LD80: [[LDTYPE]] 0xK7FFFA000000000000000214 // LD64: [[LDTYPE]] 0x7FF4000000000000215 f = __builtin_nansf("0xAE98"); // CHECK: float 0x7FF015D300000000216 d = __builtin_nans("0xAE98"); // CHECK: double 0x7FF000000000AE98217 ld = __builtin_nansl("0xAE98");218 // LD80: [[LDTYPE]] 0xK7FFF800000000000AE98219 // LD64: [[LDTYPE]] 0x7FF000000000AE98220 221}222// CHECK: }223 224// CHECK-LABEL: define{{.*}} void @test_conditional_bzero225void test_conditional_bzero(void) {226 char dst[20];227 int _sz = 20, len = 20;228 return (_sz229 ? ((_sz >= len)230 ? __builtin_bzero(dst, len)231 : foo())232 : __builtin_bzero(dst, len));233 // CHECK: call void @llvm.memset234 // CHECK: call void @llvm.memset235 // CHECK-NOT: phi236}237 238// CHECK-LABEL: define{{.*}} void @test_conditional_bcopy239void test_conditional_bcopy(void) {240 char dst[20];241 char src[20];242 int _sz = 20, len = 20;243 return (_sz244 ? ((_sz >= len)245 ? __builtin_bcopy(src, dst, len)246 : foo())247 : __builtin_bcopy(src, dst, len));248 // CHECK: call void @llvm.memmove249 // CHECK: call void @llvm.memmove250 // CHECK-NOT: phi251}252 253// CHECK-LABEL: define{{.*}} void @test_float_builtins254void test_float_builtins(__fp16 *H, float F, double D, long double LD) {255 volatile int res;256 res = __builtin_isinf(*H);257 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f16(half {{.*}}, i32 516)258 // CHECK: zext i1 [[TMP]] to i32259 260 res = __builtin_isinf(F);261 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 516)262 // CHECK: zext i1 [[TMP]] to i32263 264 res = __builtin_isinf(D);265 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f64(double {{.*}}, i32 516)266 // CHECK: zext i1 [[TMP]] to i32267 268 res = __builtin_isinf(LD);269 // LD80: [[TMP:%.*]] = call i1 @llvm.is.fpclass.[[LDLLVMTY:f80]]([[LDTYPE]] {{.*}}, i32 516)270 // LD64: [[TMP:%.*]] = call i1 @llvm.is.fpclass.[[LDLLVMTY:f64]]([[LDTYPE]] {{.*}}, i32 516)271 // CHECK: zext i1 [[TMP]] to i32272 273 res = __builtin_isinf_sign(*H);274 // CHECK: %[[ABS:.*]] = call half @llvm.fabs.f16(half %[[ARG:.*]])275 // CHECK: %[[ISINF:.*]] = fcmp oeq half %[[ABS]], 0xH7C00276 // CHECK: %[[BITCAST:.*]] = bitcast half %[[ARG]] to i16277 // CHECK: %[[ISNEG:.*]] = icmp slt i16 %[[BITCAST]], 0278 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1279 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0280 281 res = __builtin_isinf_sign(F);282 // CHECK: %[[ABS:.*]] = call float @llvm.fabs.f32(float %[[ARG:.*]])283 // CHECK: %[[ISINF:.*]] = fcmp oeq float %[[ABS]], 0x7FF0000000000000284 // CHECK: %[[BITCAST:.*]] = bitcast float %[[ARG]] to i32285 // CHECK: %[[ISNEG:.*]] = icmp slt i32 %[[BITCAST]], 0286 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1287 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0288 289 res = __builtin_isinf_sign(D);290 // CHECK: %[[ABS:.*]] = call double @llvm.fabs.f64(double %[[ARG:.*]])291 // CHECK: %[[ISINF:.*]] = fcmp oeq double %[[ABS]], 0x7FF0000000000000292 // CHECK: %[[BITCAST:.*]] = bitcast double %[[ARG]] to i64293 // CHECK: %[[ISNEG:.*]] = icmp slt i64 %[[BITCAST]], 0294 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1295 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0296 297 res = __builtin_isinf_sign(LD);298 // CHECK: %[[ABS:.*]] = call [[LDTYPE]] @llvm.fabs.[[LDLLVMTY]]([[LDTYPE]] %[[ARG:.*]])299 // CHECK: %[[ISINF:.*]] = fcmp oeq [[LDTYPE]] %[[ABS]], [[LDHUGE]]300 // LD80: %[[BITCAST:.*]] = bitcast [[LDTYPE]] %[[ARG]] to [[LDINTTY:i80]]301 // LD64: %[[BITCAST:.*]] = bitcast [[LDTYPE]] %[[ARG]] to [[LDINTTY:i64]]302 // CHECK: %[[ISNEG:.*]] = icmp slt [[LDINTTY]] %[[BITCAST]], 0303 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1304 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0305 306 res = __builtin_isfinite(*H);307 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f16(half {{.*}}, i32 504)308 // CHECK: zext i1 [[TMP]] to i32309 310 res = __builtin_isfinite(F);311 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 504)312 // CHECK: zext i1 [[TMP]] to i32313 314 res = finite(D);315 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f64(double {{.*}}, i32 504)316 // CHECK: zext i1 [[TMP]] to i32317 318 res = __builtin_isnormal(*H);319 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f16(half {{.*}}, i32 264)320 // CHECK: zext i1 [[TMP]] to i32321 322 res = __builtin_isnormal(F);323 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 264)324 // CHECK: zext i1 [[TMP]] to i32325 326 res = __builtin_issubnormal(F);327 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 144)328 // CHECK: zext i1 [[TMP]] to i32329 330 res = __builtin_iszero(F);331 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 96)332 // CHECK: zext i1 [[TMP]] to i32333 334 res = __builtin_issignaling(F);335 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 1)336 // CHECK: zext i1 [[TMP]] to i32337 338 res = __builtin_flt_rounds();339 // CHECK: call i32 @llvm.get.rounding(340}341 342// CHECK-LABEL: define{{.*}} void @test_float_builtin_ops343void test_float_builtin_ops(float F, double D, long double LD, int I) {344 volatile float resf;345 volatile double resd;346 volatile long double resld;347 volatile long int resli;348 volatile long long int reslli;349 350 resf = __builtin_fmodf(F,F);351 // CHECK: frem float352 353 resd = __builtin_fmod(D,D);354 // CHECK: frem double355 356 resld = __builtin_fmodl(LD,LD);357 // CHECK: frem [[LDTYPE]]358 359 resf = __builtin_fabsf(F);360 resd = __builtin_fabs(D);361 resld = __builtin_fabsl(LD);362 // CHECK: call float @llvm.fabs.f32(float363 // CHECK: call double @llvm.fabs.f64(double364 // CHECK: call [[LDTYPE]] @llvm.fabs.[[LDLLVMTY]]([[LDTYPE]]365 366 resf = __builtin_canonicalizef(F);367 resd = __builtin_canonicalize(D);368 resld = __builtin_canonicalizel(LD);369 // CHECK: call float @llvm.canonicalize.f32(float370 // CHECK: call double @llvm.canonicalize.f64(double371 // CHECK: call [[LDTYPE]] @llvm.canonicalize.[[LDLLVMTY]]([[LDTYPE]]372 373 resf = __builtin_fminf(F, F);374 // CHECK: call float @llvm.minnum.f32375 376 resd = __builtin_fmin(D, D);377 // CHECK: call double @llvm.minnum.f64378 379 resld = __builtin_fminl(LD, LD);380 // CHECK: call [[LDTYPE]] @llvm.minnum.[[LDLLVMTY]]381 382 resf = __builtin_fmaxf(F, F);383 // CHECK: call float @llvm.maxnum.f32384 385 resd = __builtin_fmax(D, D);386 // CHECK: call double @llvm.maxnum.f64387 388 resld = __builtin_fmaxl(LD, LD);389 // CHECK: call [[LDTYPE]] @llvm.maxnum.[[LDLLVMTY]]390 391 resf = __builtin_fminimum_numf(F, F);392 // CHECK: call float @llvm.minimumnum.f32393 394 resf = __builtin_fminimum_numf(I, I);395 // CHECK: sitofp i32 {{%[0-9]+}} to float396 // CHECK: sitofp i32 {{%[0-9]+}} to float397 // CHECK: call float @llvm.minimumnum.f32398 399 resf = __builtin_fminimum_numf(1.0, 2.0);400 // CHECK: store volatile float 1.000000e+00, ptr %resf401 402 resd = __builtin_fminimum_num(D, D);403 // CHECK: call double @llvm.minimumnum.f64404 405 resd = __builtin_fminimum_num(I, I);406 // CHECK: sitofp i32 {{%[0-9]+}} to double407 // CHECK: sitofp i32 {{%[0-9]+}} to double408 // CHECK: call double @llvm.minimumnum.f64409 410 resd = __builtin_fminimum_num(1.0, 2.0);411 // CHECK: store volatile double 1.000000e+00, ptr %resd412 413 //FIXME: __builtin_fminimum_numl is not supported well yet.414 resld = __builtin_fminimum_numl(1.0, 2.0);415 // LD80: store volatile x86_fp80 0xK3FFF8000000000000000, ptr %resld, align 16416 // LD64: store volatile double 1.000000e+00, ptr %resld417 418 resf = __builtin_fmaximum_numf(F, F);419 // CHECK: call float @llvm.maximumnum.f32420 421 resf = __builtin_fmaximum_numf(I, I);422 // CHECK: sitofp i32 {{%[0-9]+}} to float423 // CHECK: sitofp i32 {{%[0-9]+}} to float424 // CHECK: call float @llvm.maximumnum.f32425 426 resf = __builtin_fmaximum_numf(1.0, 2.0);427 // CHECK: store volatile float 2.000000e+00, ptr %resf428 429 resd = __builtin_fmaximum_num(D, D);430 // CHECK: call double @llvm.maximumnum.f64431 432 resd = __builtin_fmaximum_num(I, I);433 // CHECK: sitofp i32 {{%[0-9]+}} to double434 // CHECK: sitofp i32 {{%[0-9]+}} to double435 // CHECK: call double @llvm.maximumnum.f64436 437 resd = __builtin_fmaximum_num(1.0, 2.0);438 // CHECK: store volatile double 2.000000e+00, ptr %resd439 440 //FIXME: __builtin_fmaximum_numl is not supported well yet.441 resld = __builtin_fmaximum_numl(1.0, 2.0);442 // LD80: store volatile x86_fp80 0xK40008000000000000000, ptr %resld, align 16443 // LD64: store volatile double 2.000000e+00, ptr %resld444 445 resf = __builtin_fabsf(F);446 // CHECK: call float @llvm.fabs.f32447 448 resd = __builtin_fabs(D);449 // CHECK: call double @llvm.fabs.f64450 451 resld = __builtin_fabsl(LD);452 // CHECK: call [[LDTYPE]] @llvm.fabs.[[LDLLVMTY]]453 454 resf = __builtin_copysignf(F, F);455 // CHECK: call float @llvm.copysign.f32456 457 resd = __builtin_copysign(D, D);458 // CHECK: call double @llvm.copysign.f64459 460 resld = __builtin_copysignl(LD, LD);461 // CHECK: call [[LDTYPE]] @llvm.copysign.[[LDLLVMTY]]462 463 resf = __builtin_ceilf(F);464 // CHECK: call float @llvm.ceil.f32465 466 resd = __builtin_ceil(D);467 // CHECK: call double @llvm.ceil.f64468 469 resld = __builtin_ceill(LD);470 // CHECK: call [[LDTYPE]] @llvm.ceil.[[LDLLVMTY]]471 472 resf = __builtin_floorf(F);473 // CHECK: call float @llvm.floor.f32474 475 resd = __builtin_floor(D);476 // CHECK: call double @llvm.floor.f64477 478 resld = __builtin_floorl(LD);479 // CHECK: call [[LDTYPE]] @llvm.floor.[[LDLLVMTY]]480 481 resf = __builtin_sqrtf(F);482 // CHECK: call float @llvm.sqrt.f32(483 484 resd = __builtin_sqrt(D);485 // CHECK: call double @llvm.sqrt.f64(486 487 resld = __builtin_sqrtl(LD);488 // CHECK: call [[LDTYPE]] @llvm.sqrt.[[LDLLVMTY]]489 490 resf = __builtin_truncf(F);491 // CHECK: call float @llvm.trunc.f32492 493 resd = __builtin_trunc(D);494 // CHECK: call double @llvm.trunc.f64495 496 resld = __builtin_truncl(LD);497 // CHECK: call [[LDTYPE]] @llvm.trunc.[[LDLLVMTY]]498 499 resf = __builtin_rintf(F);500 // CHECK: call float @llvm.rint.f32501 502 resd = __builtin_rint(D);503 // CHECK: call double @llvm.rint.f64504 505 resld = __builtin_rintl(LD);506 // CHECK: call [[LDTYPE]] @llvm.rint.[[LDLLVMTY]]507 508 resf = __builtin_nearbyintf(F);509 // CHECK: call float @llvm.nearbyint.f32510 511 resd = __builtin_nearbyint(D);512 // CHECK: call double @llvm.nearbyint.f64513 514 resld = __builtin_nearbyintl(LD);515 // CHECK: call [[LDTYPE]] @llvm.nearbyint.[[LDLLVMTY]]516 517 resf = __builtin_roundf(F);518 // CHECK: call float @llvm.round.f32519 520 resd = __builtin_round(D);521 // CHECK: call double @llvm.round.f64522 523 resld = __builtin_roundl(LD);524 // CHECK: call [[LDTYPE]] @llvm.round.[[LDLLVMTY]]525 526 resf = __builtin_roundevenf(F);527 // CHECK: call float @llvm.roundeven.f32528 529 resd = __builtin_roundeven(D);530 // CHECK: call double @llvm.roundeven.f64531 532 __asm__("foo_bar0:");533 // CHECK: foo_bar0534 resld = __builtin_roundevenl(LD);535 // CHECK: call [[LDTYPE]] @llvm.roundeven.[[LDLLVMTY]]536 537 __asm__("foo_bar1:");538// CHECK: foo_bar1539 resli = __builtin_lroundf (F);540 // LONG64: call [[LONGINTTY:i64]] @llvm.lround.[[LONGINTTY]].f32541 // LONG32: call [[LONGINTTY:i32]] @llvm.lround.[[LONGINTTY]].f32542// CHECK: foo_after543 __asm__("foo_after:");544 resli = __builtin_lround (D);545 // CHECK: call [[LONGINTTY]] @llvm.lround.[[LONGINTTY]].f64546 547 resli = __builtin_lroundl (LD);548 // CHECK: call [[LONGINTTY]] @llvm.lround.[[LONGINTTY]].[[LDLLVMTY]]549 550 resli = __builtin_lrintf (F);551 // CHECK: call [[LONGINTTY]] @llvm.lrint.[[LONGINTTY]].f32552 553 resli = __builtin_lrint (D);554 // CHECK: call [[LONGINTTY]] @llvm.lrint.[[LONGINTTY]].f64555 556 resli = __builtin_lrintl (LD);557 // CHECK: call [[LONGINTTY]] @llvm.lrint.[[LONGINTTY]].[[LDLLVMTY]]558}559 560// __builtin_longjmp isn't supported on all platforms, so only test it on X86.561#ifdef __x86_64__562 563// LD80-LABEL: define{{.*}} void @test_builtin_longjmp(ptr{{.*}}564void test_builtin_longjmp(void **buffer) {565 // LD80: [[LOAD:%[a-z0-9]+]] = load ptr, ptr566 // LD80-NEXT: call void @llvm.eh.sjlj.longjmp(ptr [[LOAD]])567 __builtin_longjmp(buffer, 1);568 // LD80-NEXT: unreachable569}570 571#endif572 573// CHECK-LABEL: define{{.*}} void @test_memory_builtins574void test_memory_builtins(int n) {575 // CHECK: call ptr @malloc576 void * p = __builtin_malloc(n);577 // CHECK: call void @free578 __builtin_free(p);579 // CHECK: call ptr @calloc580 p = __builtin_calloc(1, n);581 // CHECK: call ptr @realloc582 p = __builtin_realloc(p, n);583 // CHECK: call void @free584 __builtin_free(p);585}586 587// CHECK-LABEL: define{{.*}} i64 @test_builtin_readcyclecounter588long long test_builtin_readcyclecounter(void) {589 // CHECK: call i64 @llvm.readcyclecounter()590 return __builtin_readcyclecounter();591}592 593// CHECK-LABEL: define{{.*}} i64 @test_builtin_readsteadycounter594long long test_builtin_readsteadycounter(void) {595 // CHECK: call i64 @llvm.readsteadycounter()596 return __builtin_readsteadycounter();597}598 599/// __builtin_launder should be a NOP in C since there are no vtables.600// CHECK-LABEL: define{{.*}} void @test_builtin_launder601void test_builtin_launder(int *p) {602 // CHECK: [[TMP:%.*]] = load ptr,603 // CHECK-NOT: @llvm.launder604 // CHECK: store ptr [[TMP]],605 int *d = __builtin_launder(p);606}607 608#ifdef __SIZEOF_INT128__609 610// __warn_memset_zero_len should be NOP, see https://sourceware.org/bugzilla/show_bug.cgi?id=25399611// I128-LABEL: define{{.*}} void @test___warn_memset_zero_len612void test___warn_memset_zero_len(void) {613 // I128-NOT: @__warn_memset_zero_len614 __warn_memset_zero_len();615}616 617// I128-LABEL: define{{.*}} void @test_builtin_popcountg618void test_builtin_popcountg(unsigned char uc, unsigned short us,619 unsigned int ui, unsigned long ul,620 unsigned long long ull, unsigned __int128 ui128,621 unsigned _BitInt(128) ubi128,622 _Bool __attribute__((ext_vector_type(8))) vb8) {623 volatile int pop;624#if __aarch64__625 int x = 0;626 x = x * 2;627#endif628 // I128: %2 = load i8, ptr %uc.addr, align 1629 // I128-NEXT: %3 = call i8 @llvm.ctpop.i8(i8 %2)630 // I128-NEXT: %cast = zext i8 %3 to i32631 // I128-NEXT: store volatile i32 %cast, ptr %pop, align 4632 pop = __builtin_popcountg(uc);633 // I128: %4 = load i16, ptr %us.addr, align 2634 // I128-NEXT: %5 = call i16 @llvm.ctpop.i16(i16 %4)635 // I128-NEXT: %cast2 = zext i16 %5 to i32636 // I128-NEXT: store volatile i32 %cast2, ptr %pop, align 4637 pop = __builtin_popcountg(us);638 // I128: %6 = load i32, ptr %ui.addr, align 4639 // I128-NEXT: %7 = call i32 @llvm.ctpop.i32(i32 %6)640 // I128-NEXT: store volatile i32 %7, ptr %pop, align 4641 pop = __builtin_popcountg(ui);642 // I128: %8 = load i64, ptr %ul.addr, align 8643 // I128-NEXT: %9 = call i64 @llvm.ctpop.i64(i64 %8)644 // I128-NEXT: %cast3 = trunc i64 %9 to i32645 // I128-NEXT: store volatile i32 %cast3, ptr %pop, align 4646 pop = __builtin_popcountg(ul);647 // I128: %10 = load i64, ptr %ull.addr, align 8648 // I128-NEXT: %11 = call i64 @llvm.ctpop.i64(i64 %10)649 // I128-NEXT: %cast4 = trunc i64 %11 to i32650 // I128-NEXT: store volatile i32 %cast4, ptr %pop, align 4651 pop = __builtin_popcountg(ull);652 // I128: %12 = load i128, ptr %ui128.addr, align 16653 // I128-NEXT: %13 = call i128 @llvm.ctpop.i128(i128 %12)654 // I128-NEXT: %cast5 = trunc i128 %13 to i32655 // I128-NEXT: store volatile i32 %cast5, ptr %pop, align 4656 pop = __builtin_popcountg(ui128);657 // I128: %14 = load i128, ptr %ubi128.addr658 // I128-NEXT: %15 = call i128 @llvm.ctpop.i128(i128 %14)659 // I128-NEXT: %cast6 = trunc i128 %15 to i32660 // I128-NEXT: store volatile i32 %cast6, ptr %pop, align 4661 pop = __builtin_popcountg(ubi128);662 // I128: %load_bits7 = load i8, ptr %vb8.addr, align 1663 // I128-NEXT: %16 = bitcast i8 %load_bits7 to <8 x i1>664 // I128-NEXT: %17 = bitcast <8 x i1> %16 to i8665 // I128-NEXT: %18 = call i8 @llvm.ctpop.i8(i8 %17)666 // I128-NEXT: %cast8 = zext i8 %18 to i32667 // I128-NEXT: store volatile i32 %cast8, ptr %pop, align 4668 pop = __builtin_popcountg(vb8);669}670 671// I128-LABEL: define{{.*}} void @test_builtin_clzg672void test_builtin_clzg(unsigned char uc, unsigned short us, unsigned int ui,673 unsigned long ul, unsigned long long ull,674 unsigned __int128 ui128, unsigned _BitInt(128) ubi128,675 signed char sc, short s, int i,676 _Bool __attribute__((ext_vector_type(8))) vb8) {677 volatile int lz;678#if __aarch64__679 int x = 0;680 x = x * 2;681#endif682 // I128: %2 = load i8, ptr %uc.addr, align 1683 // I128-NEXT: %3 = call i8 @llvm.ctlz.i8(i8 %2, i1684 // I128-NEXT: %cast = zext i8 %3 to i32685 // I128-NEXT: store volatile i32 %cast, ptr %lz, align 4686 lz = __builtin_clzg(uc);687 // I128-NEXT: %4 = load i16, ptr %us.addr, align 2688 // I128-NEXT: %5 = call i16 @llvm.ctlz.i16(i16 %4, i1689 // I128-NEXT: %cast2 = zext i16 %5 to i32690 // I128-NEXT: store volatile i32 %cast2, ptr %lz, align 4691 lz = __builtin_clzg(us);692 // I128-NEXT: %6 = load i32, ptr %ui.addr, align 4693 // I128-NEXT: %7 = call i32 @llvm.ctlz.i32(i32 %6, i1694 // I128-NEXT: store volatile i32 %7, ptr %lz, align 4695 lz = __builtin_clzg(ui);696 // I128-NEXT: %8 = load i64, ptr %ul.addr, align 8697 // I128-NEXT: %9 = call i64 @llvm.ctlz.i64(i64 %8, i1698 // I128-NEXT: %cast3 = trunc i64 %9 to i32699 // I128-NEXT: store volatile i32 %cast3, ptr %lz, align 4700 lz = __builtin_clzg(ul);701 // I128-NEXT: %10 = load i64, ptr %ull.addr, align 8702 // I128-NEXT: %11 = call i64 @llvm.ctlz.i64(i64 %10, i1703 // I128-NEXT: %cast4 = trunc i64 %11 to i32704 // I128-NEXT: store volatile i32 %cast4, ptr %lz, align 4705 lz = __builtin_clzg(ull);706 // I128-NEXT: %12 = load i128, ptr %ui128.addr, align 16707 // I128-NEXT: %13 = call i128 @llvm.ctlz.i128(i128 %12, i1708 // I128-NEXT: %cast5 = trunc i128 %13 to i32709 // I128-NEXT: store volatile i32 %cast5, ptr %lz, align 4710 lz = __builtin_clzg(ui128);711 // I128-NEXT: %14 = load i128, ptr %ubi128.addr712 // I128-NEXT: %15 = call i128 @llvm.ctlz.i128(i128 %14, i1713 // I128-NEXT: %cast6 = trunc i128 %15 to i32714 // I128-NEXT: store volatile i32 %cast6, ptr %lz, align 4715 lz = __builtin_clzg(ubi128);716 // I128-NEXT: %load_bits7 = load i8, ptr %vb8.addr, align 1717 // I128-NEXT: %16 = bitcast i8 %load_bits7 to <8 x i1>718 // I128-NEXT: %17 = bitcast <8 x i1> %16 to i8719 // I128-NEXT: %18 = call i8 @llvm.ctlz.i8(i8 %17, i1720 // I128-NEXT: %cast8 = zext i8 %18 to i32721 // I128-NEXT: store volatile i32 %cast8, ptr %lz, align 4722 lz = __builtin_clzg(vb8);723 // I128-NEXT: %19 = load i8, ptr %uc.addr, align 1724 // I128-NEXT: %20 = call i8 @llvm.ctlz.i8(i8 %19, i1725 // I128-NEXT: %cast9 = zext i8 %20 to i32726 // I128-NEXT: %iszero = icmp eq i8 %19, 0727 // I128-NEXT: %21 = load i8, ptr %sc.addr, align 1728 // I128-NEXT: %conv = sext i8 %21 to i32729 // I128-NEXT: %clzg = select i1 %iszero, i32 %conv, i32 %cast9730 // I128-NEXT: store volatile i32 %clzg, ptr %lz, align 4731 lz = __builtin_clzg(uc, sc);732 // I128-NEXT: %22 = load i16, ptr %us.addr, align 2733 // I128-NEXT: %23 = call i16 @llvm.ctlz.i16(i16 %22, i1734 // I128-NEXT: %cast10 = zext i16 %23 to i32735 // I128-NEXT: %iszero11 = icmp eq i16 %22, 0736 // I128-NEXT: %24 = load i8, ptr %uc.addr, align 1737 // I128-NEXT: %conv12 = zext i8 %24 to i32738 // I128-NEXT: %clzg13 = select i1 %iszero11, i32 %conv12, i32 %cast10739 // I128-NEXT: store volatile i32 %clzg13, ptr %lz, align 4740 lz = __builtin_clzg(us, uc);741 // I128-NEXT: %25 = load i32, ptr %ui.addr, align 4742 // I128-NEXT: %26 = call i32 @llvm.ctlz.i32(i32 %25, i1743 // I128-NEXT: %iszero14 = icmp eq i32 %25, 0744 // I128-NEXT: %27 = load i16, ptr %s.addr, align 2745 // I128-NEXT: %conv15 = sext i16 %27 to i32746 // I128-NEXT: %clzg16 = select i1 %iszero14, i32 %conv15, i32 %26747 // I128-NEXT: store volatile i32 %clzg16, ptr %lz, align 4748 lz = __builtin_clzg(ui, s);749 // I128-NEXT: %28 = load i64, ptr %ul.addr, align 8750 // I128-NEXT: %29 = call i64 @llvm.ctlz.i64(i64 %28, i1751 // I128-NEXT: %cast17 = trunc i64 %29 to i32752 // I128-NEXT: %iszero18 = icmp eq i64 %28, 0753 // I128-NEXT: %30 = load i16, ptr %us.addr, align 2754 // I128-NEXT: %conv19 = zext i16 %30 to i32755 // I128-NEXT: %clzg20 = select i1 %iszero18, i32 %conv19, i32 %cast17756 // I128-NEXT: store volatile i32 %clzg20, ptr %lz, align 4757 lz = __builtin_clzg(ul, us);758 // I128-NEXT: %31 = load i64, ptr %ull.addr, align 8759 // I128-NEXT: %32 = call i64 @llvm.ctlz.i64(i64 %31, i1760 // I128-NEXT: %cast21 = trunc i64 %32 to i32761 // I128-NEXT: %iszero22 = icmp eq i64 %31, 0762 // I128-NEXT: %33 = load i32, ptr %i.addr, align 4763 // I128-NEXT: %clzg23 = select i1 %iszero22, i32 %33, i32 %cast21764 // I128-NEXT: store volatile i32 %clzg23, ptr %lz, align 4765 lz = __builtin_clzg(ull, i);766 // I128-NEXT: %34 = load i128, ptr %ui128.addr, align 16767 // I128-NEXT: %35 = call i128 @llvm.ctlz.i128(i128 %34, i1768 // I128-NEXT: %cast24 = trunc i128 %35 to i32769 // I128-NEXT: %iszero25 = icmp eq i128 %34, 0770 // I128-NEXT: %36 = load i32, ptr %i.addr, align 4771 // I128-NEXT: %clzg26 = select i1 %iszero25, i32 %36, i32 %cast24772 // I128-NEXT: store volatile i32 %clzg26, ptr %lz, align 4773 lz = __builtin_clzg(ui128, i);774 // I128-NEXT: %37 = load i128, ptr %ubi128.addr775 // I128-NEXT: %38 = call i128 @llvm.ctlz.i128(i128 %37, i1776 // I128-NEXT: %cast27 = trunc i128 %38 to i32777 // I128-NEXT: %iszero28 = icmp eq i128 %37, 0778 // I128-NEXT: %39 = load i32, ptr %i.addr, align 4779 // I128-NEXT: %clzg29 = select i1 %iszero28, i32 %39, i32 %cast27780 // I128-NEXT: store volatile i32 %clzg29, ptr %lz, align 4781 lz = __builtin_clzg(ubi128, i);782 // I128-NEXT: %load_bits30 = load i8, ptr %vb8.addr, align 1783 // I128-NEXT: %40 = bitcast i8 %load_bits30 to <8 x i1>784 // I128-NEXT: %41 = bitcast <8 x i1> %40 to i8785 // I128-NEXT: %42 = call i8 @llvm.ctlz.i8(i8 %41, i1786 // I128-NEXT: %cast31 = zext i8 %42 to i32787 // I128-NEXT: %iszero32 = icmp eq i8 %41, 0788 // I128-NEXT: %43 = load i32, ptr %i.addr, align 4789 // I128-NEXT: %clzg33 = select i1 %iszero32, i32 %43, i32 %cast31790 // I128-NEXT: store volatile i32 %clzg33, ptr %lz, align 4791 lz = __builtin_clzg(vb8, i);792}793 794// I128-LABEL: define{{.*}} void @test_builtin_ctzg795void test_builtin_ctzg(unsigned char uc, unsigned short us, unsigned int ui,796 unsigned long ul, unsigned long long ull,797 unsigned __int128 ui128, unsigned _BitInt(128) ubi128,798 signed char sc, short s, int i,799 _Bool __attribute__((ext_vector_type(8))) vb8) {800 volatile int tz;801#if __aarch64__802 int x = 0;803 x = x * 2;804#endif805 // I128: %2 = load i8, ptr %uc.addr, align 1806 // I128-NEXT: %3 = call i8 @llvm.cttz.i8(i8 %2, i1807 // I128-NEXT: %cast = zext i8 %3 to i32808 // I128-NEXT: store volatile i32 %cast, ptr %tz, align 4809 tz = __builtin_ctzg(uc);810 // I128-NEXT: %4 = load i16, ptr %us.addr, align 2811 // I128-NEXT: %5 = call i16 @llvm.cttz.i16(i16 %4, i1812 // I128-NEXT: %cast2 = zext i16 %5 to i32813 // I128-NEXT: store volatile i32 %cast2, ptr %tz, align 4814 tz = __builtin_ctzg(us);815 // I128-NEXT: %6 = load i32, ptr %ui.addr, align 4816 // I128-NEXT: %7 = call i32 @llvm.cttz.i32(i32 %6, i1817 // I128-NEXT: store volatile i32 %7, ptr %tz, align 4818 tz = __builtin_ctzg(ui);819 // I128-NEXT: %8 = load i64, ptr %ul.addr, align 8820 // I128-NEXT: %9 = call i64 @llvm.cttz.i64(i64 %8, i1821 // I128-NEXT: %cast3 = trunc i64 %9 to i32822 // I128-NEXT: store volatile i32 %cast3, ptr %tz, align 4823 tz = __builtin_ctzg(ul);824 // I128-NEXT: %10 = load i64, ptr %ull.addr, align 8825 // I128-NEXT: %11 = call i64 @llvm.cttz.i64(i64 %10, i1826 // I128-NEXT: %cast4 = trunc i64 %11 to i32827 // I128-NEXT: store volatile i32 %cast4, ptr %tz, align 4828 tz = __builtin_ctzg(ull);829 // I128-NEXT: %12 = load i128, ptr %ui128.addr, align 16830 // I128-NEXT: %13 = call i128 @llvm.cttz.i128(i128 %12, i1831 // I128-NEXT: %cast5 = trunc i128 %13 to i32832 // I128-NEXT: store volatile i32 %cast5, ptr %tz, align 4833 tz = __builtin_ctzg(ui128);834 // I128-NEXT: %14 = load i128, ptr %ubi128.addr835 // I128-NEXT: %15 = call i128 @llvm.cttz.i128(i128 %14, i1836 // I128-NEXT: %cast6 = trunc i128 %15 to i32837 // I128-NEXT: store volatile i32 %cast6, ptr %tz, align 4838 tz = __builtin_ctzg(ubi128);839 // I128-NEXT: %load_bits7 = load i8, ptr %vb8.addr, align 1840 // I128-NEXT: %16 = bitcast i8 %load_bits7 to <8 x i1>841 // I128-NEXT: %17 = bitcast <8 x i1> %16 to i8842 // I128-NEXT: %18 = call i8 @llvm.cttz.i8(i8 %17, i1843 // I128-NEXT: %cast8 = zext i8 %18 to i32844 // I128-NEXT: store volatile i32 %cast8, ptr %tz, align 4845 tz = __builtin_ctzg(vb8);846 // I128-NEXT: %19 = load i8, ptr %uc.addr, align 1847 // I128-NEXT: %20 = call i8 @llvm.cttz.i8(i8 %19, i1848 // I128-NEXT: %cast9 = zext i8 %20 to i32849 // I128-NEXT: %iszero = icmp eq i8 %19, 0850 // I128-NEXT: %21 = load i8, ptr %sc.addr, align 1851 // I128-NEXT: %conv = sext i8 %21 to i32852 // I128-NEXT: %ctzg = select i1 %iszero, i32 %conv, i32 %cast9853 // I128-NEXT: store volatile i32 %ctzg, ptr %tz, align 4854 tz = __builtin_ctzg(uc, sc);855 // I128-NEXT: %22 = load i16, ptr %us.addr, align 2856 // I128-NEXT: %23 = call i16 @llvm.cttz.i16(i16 %22, i1857 // I128-NEXT: %cast10 = zext i16 %23 to i32858 // I128-NEXT: %iszero11 = icmp eq i16 %22, 0859 // I128-NEXT: %24 = load i8, ptr %uc.addr, align 1860 // I128-NEXT: %conv12 = zext i8 %24 to i32861 // I128-NEXT: %ctzg13 = select i1 %iszero11, i32 %conv12, i32 %cast10862 // I128-NEXT: store volatile i32 %ctzg13, ptr %tz, align 4863 tz = __builtin_ctzg(us, uc);864 // I128-NEXT: %25 = load i32, ptr %ui.addr, align 4865 // I128-NEXT: %26 = call i32 @llvm.cttz.i32(i32 %25, i1866 // I128-NEXT: %iszero14 = icmp eq i32 %25, 0867 // I128-NEXT: %27 = load i16, ptr %s.addr, align 2868 // I128-NEXT: %conv15 = sext i16 %27 to i32869 // I128-NEXT: %ctzg16 = select i1 %iszero14, i32 %conv15, i32 %26870 // I128-NEXT: store volatile i32 %ctzg16, ptr %tz, align 4871 tz = __builtin_ctzg(ui, s);872 // I128-NEXT: %28 = load i64, ptr %ul.addr, align 8873 // I128-NEXT: %29 = call i64 @llvm.cttz.i64(i64 %28, i1874 // I128-NEXT: %cast17 = trunc i64 %29 to i32875 // I128-NEXT: %iszero18 = icmp eq i64 %28, 0876 // I128-NEXT: %30 = load i16, ptr %us.addr, align 2877 // I128-NEXT: %conv19 = zext i16 %30 to i32878 // I128-NEXT: %ctzg20 = select i1 %iszero18, i32 %conv19, i32 %cast17879 // I128-NEXT: store volatile i32 %ctzg20, ptr %tz, align 4880 tz = __builtin_ctzg(ul, us);881 // I128-NEXT: %31 = load i64, ptr %ull.addr, align 8882 // I128-NEXT: %32 = call i64 @llvm.cttz.i64(i64 %31, i1883 // I128-NEXT: %cast21 = trunc i64 %32 to i32884 // I128-NEXT: %iszero22 = icmp eq i64 %31, 0885 // I128-NEXT: %33 = load i32, ptr %i.addr, align 4886 // I128-NEXT: %ctzg23 = select i1 %iszero22, i32 %33, i32 %cast21887 // I128-NEXT: store volatile i32 %ctzg23, ptr %tz, align 4888 tz = __builtin_ctzg(ull, i);889 // I128-NEXT: %34 = load i128, ptr %ui128.addr, align 16890 // I128-NEXT: %35 = call i128 @llvm.cttz.i128(i128 %34, i1891 // I128-NEXT: %cast24 = trunc i128 %35 to i32892 // I128-NEXT: %iszero25 = icmp eq i128 %34, 0893 // I128-NEXT: %36 = load i32, ptr %i.addr, align 4894 // I128-NEXT: %ctzg26 = select i1 %iszero25, i32 %36, i32 %cast24895 // I128-NEXT: store volatile i32 %ctzg26, ptr %tz, align 4896 tz = __builtin_ctzg(ui128, i);897 // I128-NEXT: %37 = load i128, ptr %ubi128.addr898 // I128-NEXT: %38 = call i128 @llvm.cttz.i128(i128 %37, i1899 // I128-NEXT: %cast27 = trunc i128 %38 to i32900 // I128-NEXT: %iszero28 = icmp eq i128 %37, 0901 // I128-NEXT: %39 = load i32, ptr %i.addr, align 4902 // I128-NEXT: %ctzg29 = select i1 %iszero28, i32 %39, i32 %cast27903 // I128-NEXT: store volatile i32 %ctzg29, ptr %tz, align 4904 tz = __builtin_ctzg(ubi128, i);905 // I128-NEXT: %load_bits30 = load i8, ptr %vb8.addr, align 1906 // I128-NEXT: %40 = bitcast i8 %load_bits30 to <8 x i1>907 // I128-NEXT: %41 = bitcast <8 x i1> %40 to i8908 // I128-NEXT: %42 = call i8 @llvm.cttz.i8(i8 %41, i1909 // I128-NEXT: %cast31 = zext i8 %42 to i32910 // I128-NEXT: %iszero32 = icmp eq i8 %41, 0911 // I128-NEXT: %43 = load i32, ptr %i.addr, align 4912 // I128-NEXT: %ctzg33 = select i1 %iszero32, i32 %43, i32 %cast31913 // I128-NEXT: store volatile i32 %ctzg33, ptr %tz, align 4914 tz = __builtin_ctzg(vb8, i);915}916 917#endif918 919// CHECK-LABEL: define{{.*}} void @test_builtin_bswapg920void test_builtin_bswapg(unsigned char uc, unsigned short us, unsigned int ui,921 unsigned long ul, unsigned long long ull,922#ifdef __SIZEOF_INT128__923 unsigned __int128 ui128,924#endif925 _BitInt(8) bi8,926 _BitInt(16) bi16, _BitInt(32) bi32, 927 _BitInt(64) bi64, _BitInt(128) bi128) {928#if __aarch64__929 int x = 0;930 x = x * 2;931#endif932 uc = __builtin_bswapg(uc);933 // CHECK: %1 = load i8, ptr %uc.addr934 // CHECK: store i8 %1, ptr %uc.addr935 us = __builtin_bswapg(us);936 // CHECK: call i16 @llvm.bswap.i16937 ui = __builtin_bswapg(ui);938 // CHECK: call i32 @llvm.bswap.i32939 ul = __builtin_bswapg(ul);940 // CHECK: call [[LONGINTTY]] @llvm.bswap.[[LONGINTTY]]941 ull = __builtin_bswapg(ull);942 // CHECK: call i64 @llvm.bswap.i64943#ifdef __SIZEOF_INT128__944 ui128 = __builtin_bswapg(ui128);945 // I128: call i128 @llvm.bswap.i128946#endif947 bi8 = __builtin_bswapg(bi8);948 // CHECK: [[BI8SWAP:%.*]] = load i8, ptr %bi8.addr, align 1949 // CHECK: store i8 [[BI8SWAP]], ptr %bi8.addr950 bi16 = __builtin_bswapg(bi16);951 // CHECK: call i16 @llvm.bswap.i16952 bi32 = __builtin_bswapg(bi32);953 // CHECK: call i32 @llvm.bswap.i32954 bi64 = __builtin_bswapg(bi64);955 // CHECK: call i64 @llvm.bswap.i64956 bi128 = __builtin_bswapg(bi128);957 // CHECK: call i128 @llvm.bswap.i128958}959