1 // RUN: %clang_cc1 -emit-llvm -o %t %s 2 // RUN: not grep __builtin %t 3 // RUN: %clang_cc1 -emit-llvm -triple x86_64-darwin-apple -o - %s | FileCheck %s 4 5 int printf(const char *, ...); 6 7 void p(char *str, int x) { 8 printf("%s: %d\n", str, x); 9 } 10 void q(char *str, double x) { 11 printf("%s: %f\n", str, x); 12 } 13 void r(char *str, void *ptr) { 14 printf("%s: %p\n", str, ptr); 15 } 16 17 int random(void); 18 int finite(double); 19 20 int main(void) { 21 int N = random(); 22 #define P(n,args) p(#n #args, __builtin_##n args) 23 #define Q(n,args) q(#n #args, __builtin_##n args) 24 #define R(n,args) r(#n #args, __builtin_##n args) 25 #define V(n,args) p(#n #args, (__builtin_##n args, 0)) 26 P(types_compatible_p, (int, float)); 27 P(choose_expr, (0, 10, 20)); 28 P(constant_p, (sizeof(10))); 29 P(expect, (N == 12, 0)); 30 V(prefetch, (&N)); 31 V(prefetch, (&N, 1)); 32 V(prefetch, (&N, 1, 0)); 33 34 // Numeric Constants 35 36 Q(huge_val, ()); 37 Q(huge_valf, ()); 38 Q(huge_vall, ()); 39 Q(inf, ()); 40 Q(inff, ()); 41 Q(infl, ()); 42 43 P(fpclassify, (0, 1, 2, 3, 4, 1.0)); 44 P(fpclassify, (0, 1, 2, 3, 4, 1.0f)); 45 P(fpclassify, (0, 1, 2, 3, 4, 1.0l)); 46 47 Q(nan, ("")); 48 Q(nanf, ("")); 49 Q(nanl, ("")); 50 Q(nans, ("")); 51 Q(nan, ("10")); 52 Q(nanf, ("10")); 53 Q(nanl, ("10")); 54 Q(nans, ("10")); 55 56 P(isgreater, (1., 2.)); 57 P(isgreaterequal, (1., 2.)); 58 P(isless, (1., 2.)); 59 P(islessequal, (1., 2.)); 60 P(islessgreater, (1., 2.)); 61 P(isunordered, (1., 2.)); 62 63 P(isinf, (1.)); 64 P(isinf_sign, (1.)); 65 P(isnan, (1.)); 66 P(isfinite, (1.)); 67 P(iszero, (1.)); 68 P(issubnormal, (1.)); 69 P(issignaling, (1.)); 70 P(isfpclass, (1., 1)); 71 72 Q(fmaximum_num, (1.0, 2.0)); 73 Q(fmaximum_numf, (1.0, 2.0)); 74 Q(fmaximum_numl, (1.0, 2.0)); 75 Q(fminimum_num, (1.0, 2.0)); 76 Q(fminimum_numf, (1.0, 2.0)); 77 Q(fminimum_numl, (1.0, 2.0)); 78 79 // Bitwise & Numeric Functions 80 81 P(abs, (N)); 82 83 P(clz, (N)); 84 P(clzl, (N)); 85 P(clzll, (N)); 86 P(ctz, (N)); 87 P(ctzl, (N)); 88 P(ctzll, (N)); 89 P(ffs, (N)); 90 P(ffsl, (N)); 91 P(ffsll, (N)); 92 P(parity, (N)); 93 P(parityl, (N)); 94 P(parityll, (N)); 95 P(popcount, (N)); 96 P(popcountl, (N)); 97 P(popcountll, (N)); 98 Q(powi, (1.2f, N)); 99 Q(powif, (1.2f, N)); 100 Q(powil, (1.2f, N)); 101 102 // Lib functions 103 int a, b, n = random(); // Avoid optimizing out. 104 char s0[10], s1[] = "Hello"; 105 V(strcat, (s0, s1)); 106 V(strcmp, (s0, s1)); 107 V(strdup, (s0)); 108 V(strncat, (s0, s1, n)); 109 V(strndup, (s0, n)); 110 V(strchr, (s0, s1[0])); 111 V(strrchr, (s0, s1[0])); 112 V(strcpy, (s0, s1)); 113 V(strncpy, (s0, s1, n)); 114 V(sprintf, (s0, "%s", s1)); 115 V(snprintf, (s0, n, "%s", s1)); 116 117 // Object size checking 118 V(__memset_chk, (s0, 0, sizeof s0, n)); 119 V(__memcpy_chk, (s0, s1, sizeof s0, n)); 120 V(__memmove_chk, (s0, s1, sizeof s0, n)); 121 V(__mempcpy_chk, (s0, s1, sizeof s0, n)); 122 V(__strncpy_chk, (s0, s1, sizeof s0, n)); 123 V(__strcpy_chk, (s0, s1, n)); 124 s0[0] = 0; 125 V(__strcat_chk, (s0, s1, n)); 126 P(object_size, (s0, 0)); 127 P(object_size, (s0, 1)); 128 P(object_size, (s0, 2)); 129 P(object_size, (s0, 3)); 130 131 // Whatever 132 133 P(bswap16, (N)); 134 P(bswap32, (N)); 135 P(bswap64, (N)); 136 137 // CHECK: @llvm.bitreverse.i8 138 // CHECK: @llvm.bitreverse.i16 139 // CHECK: @llvm.bitreverse.i32 140 // CHECK: @llvm.bitreverse.i64 141 P(bitreverse8, (N)); 142 P(bitreverse16, (N)); 143 P(bitreverse32, (N)); 144 P(bitreverse64, (N)); 145 146 // FIXME 147 // V(clear_cache, (&N, &N+1)); 148 V(trap, ()); 149 R(extract_return_addr, (&N)); 150 P(signbit, (1.0)); 151 152 R(launder, (&N)); 153 154 return 0; 155 } 156 157 158 159 void foo(void) { 160 __builtin_strcat(0, 0); 161 } 162 163 // CHECK-LABEL: define{{.*}} void @bar( 164 void bar(void) { 165 float f; 166 double d; 167 long double ld; 168 169 // LLVM's hex representation of float constants is really unfortunate; 170 // basically it does a float-to-double "conversion" and then prints the 171 // hex form of that. That gives us weird artifacts like exponents 172 // that aren't numerically similar to the original exponent and 173 // significand bit-patterns that are offset by three bits (because 174 // the exponent was expanded from 8 bits to 11). 175 // 176 // 0xAE98 == 1010111010011000 177 // 0x15D3 == 1010111010011 178 179 f = __builtin_huge_valf(); // CHECK: float 0x7FF0000000000000 180 d = __builtin_huge_val(); // CHECK: double 0x7FF0000000000000 181 ld = __builtin_huge_vall(); // CHECK: x86_fp80 0xK7FFF8000000000000000 182 f = __builtin_nanf(""); // CHECK: float 0x7FF8000000000000 183 d = __builtin_nan(""); // CHECK: double 0x7FF8000000000000 184 ld = __builtin_nanl(""); // CHECK: x86_fp80 0xK7FFFC000000000000000 185 f = __builtin_nanf("0xAE98"); // CHECK: float 0x7FF815D300000000 186 d = __builtin_nan("0xAE98"); // CHECK: double 0x7FF800000000AE98 187 ld = __builtin_nanl("0xAE98"); // CHECK: x86_fp80 0xK7FFFC00000000000AE98 188 f = __builtin_nansf(""); // CHECK: float 0x7FF4000000000000 189 d = __builtin_nans(""); // CHECK: double 0x7FF4000000000000 190 ld = __builtin_nansl(""); // CHECK: x86_fp80 0xK7FFFA000000000000000 191 f = __builtin_nansf("0xAE98"); // CHECK: float 0x7FF015D300000000 192 d = __builtin_nans("0xAE98"); // CHECK: double 0x7FF000000000AE98 193 ld = __builtin_nansl("0xAE98");// CHECK: x86_fp80 0xK7FFF800000000000AE98 194 195 } 196 // CHECK: } 197 198 // CHECK-LABEL: define{{.*}} void @test_conditional_bzero 199 void test_conditional_bzero(void) { 200 char dst[20]; 201 int _sz = 20, len = 20; 202 return (_sz 203 ? ((_sz >= len) 204 ? __builtin_bzero(dst, len) 205 : foo()) 206 : __builtin_bzero(dst, len)); 207 // CHECK: call void @llvm.memset 208 // CHECK: call void @llvm.memset 209 // CHECK-NOT: phi 210 } 211 212 // CHECK-LABEL: define{{.*}} void @test_conditional_bcopy 213 void test_conditional_bcopy(void) { 214 char dst[20]; 215 char src[20]; 216 int _sz = 20, len = 20; 217 return (_sz 218 ? ((_sz >= len) 219 ? __builtin_bcopy(src, dst, len) 220 : foo()) 221 : __builtin_bcopy(src, dst, len)); 222 // CHECK: call void @llvm.memmove 223 // CHECK: call void @llvm.memmove 224 // CHECK-NOT: phi 225 } 226 227 // CHECK-LABEL: define{{.*}} void @test_float_builtins 228 void test_float_builtins(__fp16 *H, float F, double D, long double LD) { 229 volatile int res; 230 res = __builtin_isinf(*H); 231 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f16(half {{.*}}, i32 516) 232 // CHECK: zext i1 [[TMP]] to i32 233 234 res = __builtin_isinf(F); 235 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 516) 236 // CHECK: zext i1 [[TMP]] to i32 237 238 res = __builtin_isinf(D); 239 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f64(double {{.*}}, i32 516) 240 // CHECK: zext i1 [[TMP]] to i32 241 242 res = __builtin_isinf(LD); 243 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f80(x86_fp80 {{.*}}, i32 516) 244 // CHECK: zext i1 [[TMP]] to i32 245 246 res = __builtin_isinf_sign(*H); 247 // CHECK: %[[ABS:.*]] = call half @llvm.fabs.f16(half %[[ARG:.*]]) 248 // CHECK: %[[ISINF:.*]] = fcmp oeq half %[[ABS]], 0xH7C00 249 // CHECK: %[[BITCAST:.*]] = bitcast half %[[ARG]] to i16 250 // CHECK: %[[ISNEG:.*]] = icmp slt i16 %[[BITCAST]], 0 251 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1 252 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0 253 254 res = __builtin_isinf_sign(F); 255 // CHECK: %[[ABS:.*]] = call float @llvm.fabs.f32(float %[[ARG:.*]]) 256 // CHECK: %[[ISINF:.*]] = fcmp oeq float %[[ABS]], 0x7FF0000000000000 257 // CHECK: %[[BITCAST:.*]] = bitcast float %[[ARG]] to i32 258 // CHECK: %[[ISNEG:.*]] = icmp slt i32 %[[BITCAST]], 0 259 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1 260 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0 261 262 res = __builtin_isinf_sign(D); 263 // CHECK: %[[ABS:.*]] = call double @llvm.fabs.f64(double %[[ARG:.*]]) 264 // CHECK: %[[ISINF:.*]] = fcmp oeq double %[[ABS]], 0x7FF0000000000000 265 // CHECK: %[[BITCAST:.*]] = bitcast double %[[ARG]] to i64 266 // CHECK: %[[ISNEG:.*]] = icmp slt i64 %[[BITCAST]], 0 267 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1 268 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0 269 270 res = __builtin_isinf_sign(LD); 271 // CHECK: %[[ABS:.*]] = call x86_fp80 @llvm.fabs.f80(x86_fp80 %[[ARG:.*]]) 272 // CHECK: %[[ISINF:.*]] = fcmp oeq x86_fp80 %[[ABS]], 0xK7FFF8000000000000000 273 // CHECK: %[[BITCAST:.*]] = bitcast x86_fp80 %[[ARG]] to i80 274 // CHECK: %[[ISNEG:.*]] = icmp slt i80 %[[BITCAST]], 0 275 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1 276 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0 277 278 res = __builtin_isfinite(*H); 279 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f16(half {{.*}}, i32 504) 280 // CHECK: zext i1 [[TMP]] to i32 281 282 res = __builtin_isfinite(F); 283 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 504) 284 // CHECK: zext i1 [[TMP]] to i32 285 286 res = finite(D); 287 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f64(double {{.*}}, i32 504) 288 // CHECK: zext i1 [[TMP]] to i32 289 290 res = __builtin_isnormal(*H); 291 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f16(half {{.*}}, i32 264) 292 // CHECK: zext i1 [[TMP]] to i32 293 294 res = __builtin_isnormal(F); 295 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 264) 296 // CHECK: zext i1 [[TMP]] to i32 297 298 res = __builtin_issubnormal(F); 299 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 144) 300 // CHECK: zext i1 [[TMP]] to i32 301 302 res = __builtin_iszero(F); 303 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 96) 304 // CHECK: zext i1 [[TMP]] to i32 305 306 res = __builtin_issignaling(F); 307 // CHECK: [[TMP:%.*]] = call i1 @llvm.is.fpclass.f32(float {{.*}}, i32 1) 308 // CHECK: zext i1 [[TMP]] to i32 309 310 res = __builtin_flt_rounds(); 311 // CHECK: call i32 @llvm.get.rounding( 312 } 313 314 // CHECK-LABEL: define{{.*}} void @test_float_builtin_ops 315 void test_float_builtin_ops(float F, double D, long double LD, int I) { 316 volatile float resf; 317 volatile double resd; 318 volatile long double resld; 319 volatile long int resli; 320 volatile long long int reslli; 321 322 resf = __builtin_fmodf(F,F); 323 // CHECK: frem float 324 325 resd = __builtin_fmod(D,D); 326 // CHECK: frem double 327 328 resld = __builtin_fmodl(LD,LD); 329 // CHECK: frem x86_fp80 330 331 resf = __builtin_fabsf(F); 332 resd = __builtin_fabs(D); 333 resld = __builtin_fabsl(LD); 334 // CHECK: call float @llvm.fabs.f32(float 335 // CHECK: call double @llvm.fabs.f64(double 336 // CHECK: call x86_fp80 @llvm.fabs.f80(x86_fp80 337 338 resf = __builtin_canonicalizef(F); 339 resd = __builtin_canonicalize(D); 340 resld = __builtin_canonicalizel(LD); 341 // CHECK: call float @llvm.canonicalize.f32(float 342 // CHECK: call double @llvm.canonicalize.f64(double 343 // CHECK: call x86_fp80 @llvm.canonicalize.f80(x86_fp80 344 345 resf = __builtin_fminf(F, F); 346 // CHECK: call float @llvm.minnum.f32 347 348 resd = __builtin_fmin(D, D); 349 // CHECK: call double @llvm.minnum.f64 350 351 resld = __builtin_fminl(LD, LD); 352 // CHECK: call x86_fp80 @llvm.minnum.f80 353 354 resf = __builtin_fmaxf(F, F); 355 // CHECK: call float @llvm.maxnum.f32 356 357 resd = __builtin_fmax(D, D); 358 // CHECK: call double @llvm.maxnum.f64 359 360 resld = __builtin_fmaxl(LD, LD); 361 // CHECK: call x86_fp80 @llvm.maxnum.f80 362 363 resf = __builtin_fminimum_numf(F, F); 364 // CHECK: call float @llvm.minimumnum.f32 365 366 resf = __builtin_fminimum_numf(I, I); 367 // CHECK: sitofp i32 {{%[0-9]+}} to float 368 // CHECK: sitofp i32 {{%[0-9]+}} to float 369 // CHECK: call float @llvm.minimumnum.f32 370 371 resf = __builtin_fminimum_numf(1.0, 2.0); 372 // CHECK: store volatile float 1.000000e+00, ptr %resf 373 374 resd = __builtin_fminimum_num(D, D); 375 // CHECK: call double @llvm.minimumnum.f64 376 377 resd = __builtin_fminimum_num(I, I); 378 // CHECK: sitofp i32 {{%[0-9]+}} to double 379 // CHECK: sitofp i32 {{%[0-9]+}} to double 380 // CHECK: call double @llvm.minimumnum.f64 381 382 resd = __builtin_fminimum_num(1.0, 2.0); 383 // CHECK: store volatile double 1.000000e+00, ptr %resd 384 385 //FIXME: __builtin_fminimum_numl is not supported well yet. 386 resld = __builtin_fminimum_numl(1.0, 2.0); 387 // CHECK: store volatile x86_fp80 0xK3FFF8000000000000000, ptr %resld, align 16 388 389 resf = __builtin_fmaximum_numf(F, F); 390 // CHECK: call float @llvm.maximumnum.f32 391 392 resf = __builtin_fmaximum_numf(I, I); 393 // CHECK: sitofp i32 {{%[0-9]+}} to float 394 // CHECK: sitofp i32 {{%[0-9]+}} to float 395 // CHECK: call float @llvm.maximumnum.f32 396 397 resf = __builtin_fmaximum_numf(1.0, 2.0); 398 // CHECK: store volatile float 2.000000e+00, ptr %resf 399 400 resd = __builtin_fmaximum_num(D, D); 401 // CHECK: call double @llvm.maximumnum.f64 402 403 resd = __builtin_fmaximum_num(I, I); 404 // CHECK: sitofp i32 {{%[0-9]+}} to double 405 // CHECK: sitofp i32 {{%[0-9]+}} to double 406 // CHECK: call double @llvm.maximumnum.f64 407 408 resd = __builtin_fmaximum_num(1.0, 2.0); 409 // CHECK: store volatile double 2.000000e+00, ptr %resd 410 411 //FIXME: __builtin_fmaximum_numl is not supported well yet. 412 resld = __builtin_fmaximum_numl(1.0, 2.0); 413 // CHECK: store volatile x86_fp80 0xK40008000000000000000, ptr %resld, align 16 414 415 resf = __builtin_fabsf(F); 416 // CHECK: call float @llvm.fabs.f32 417 418 resd = __builtin_fabs(D); 419 // CHECK: call double @llvm.fabs.f64 420 421 resld = __builtin_fabsl(LD); 422 // CHECK: call x86_fp80 @llvm.fabs.f80 423 424 resf = __builtin_copysignf(F, F); 425 // CHECK: call float @llvm.copysign.f32 426 427 resd = __builtin_copysign(D, D); 428 // CHECK: call double @llvm.copysign.f64 429 430 resld = __builtin_copysignl(LD, LD); 431 // CHECK: call x86_fp80 @llvm.copysign.f80 432 433 434 resf = __builtin_ceilf(F); 435 // CHECK: call float @llvm.ceil.f32 436 437 resd = __builtin_ceil(D); 438 // CHECK: call double @llvm.ceil.f64 439 440 resld = __builtin_ceill(LD); 441 // CHECK: call x86_fp80 @llvm.ceil.f80 442 443 resf = __builtin_floorf(F); 444 // CHECK: call float @llvm.floor.f32 445 446 resd = __builtin_floor(D); 447 // CHECK: call double @llvm.floor.f64 448 449 resld = __builtin_floorl(LD); 450 // CHECK: call x86_fp80 @llvm.floor.f80 451 452 resf = __builtin_sqrtf(F); 453 // CHECK: call float @llvm.sqrt.f32( 454 455 resd = __builtin_sqrt(D); 456 // CHECK: call double @llvm.sqrt.f64( 457 458 resld = __builtin_sqrtl(LD); 459 // CHECK: call x86_fp80 @llvm.sqrt.f80 460 461 resf = __builtin_truncf(F); 462 // CHECK: call float @llvm.trunc.f32 463 464 resd = __builtin_trunc(D); 465 // CHECK: call double @llvm.trunc.f64 466 467 resld = __builtin_truncl(LD); 468 // CHECK: call x86_fp80 @llvm.trunc.f80 469 470 resf = __builtin_rintf(F); 471 // CHECK: call float @llvm.rint.f32 472 473 resd = __builtin_rint(D); 474 // CHECK: call double @llvm.rint.f64 475 476 resld = __builtin_rintl(LD); 477 // CHECK: call x86_fp80 @llvm.rint.f80 478 479 resf = __builtin_nearbyintf(F); 480 // CHECK: call float @llvm.nearbyint.f32 481 482 resd = __builtin_nearbyint(D); 483 // CHECK: call double @llvm.nearbyint.f64 484 485 resld = __builtin_nearbyintl(LD); 486 // CHECK: call x86_fp80 @llvm.nearbyint.f80 487 488 resf = __builtin_roundf(F); 489 // CHECK: call float @llvm.round.f32 490 491 resd = __builtin_round(D); 492 // CHECK: call double @llvm.round.f64 493 494 resld = __builtin_roundl(LD); 495 // CHECK: call x86_fp80 @llvm.round.f80 496 497 resf = __builtin_roundevenf(F); 498 // CHECK: call float @llvm.roundeven.f32 499 500 resd = __builtin_roundeven(D); 501 // CHECK: call double @llvm.roundeven.f64 502 503 resld = __builtin_roundevenl(LD); 504 // CHECK: call x86_fp80 @llvm.roundeven.f80 505 506 resli = __builtin_lroundf (F); 507 // CHECK: call i64 @llvm.lround.i64.f32 508 509 resli = __builtin_lround (D); 510 // CHECK: call i64 @llvm.lround.i64.f64 511 512 resli = __builtin_lroundl (LD); 513 // CHECK: call i64 @llvm.lround.i64.f80 514 515 resli = __builtin_lrintf (F); 516 // CHECK: call i64 @llvm.lrint.i64.f32 517 518 resli = __builtin_lrint (D); 519 // CHECK: call i64 @llvm.lrint.i64.f64 520 521 resli = __builtin_lrintl (LD); 522 // CHECK: call i64 @llvm.lrint.i64.f80 523 } 524 525 // __builtin_longjmp isn't supported on all platforms, so only test it on X86. 526 #ifdef __x86_64__ 527 528 // CHECK-LABEL: define{{.*}} void @test_builtin_longjmp(ptr{{.*}} 529 void test_builtin_longjmp(void **buffer) { 530 // CHECK: [[LOAD:%[a-z0-9]+]] = load ptr, ptr 531 // CHECK-NEXT: call void @llvm.eh.sjlj.longjmp(ptr [[LOAD]]) 532 __builtin_longjmp(buffer, 1); 533 // CHECK-NEXT: unreachable 534 } 535 536 #endif 537 538 // CHECK-LABEL: define{{.*}} void @test_memory_builtins 539 void test_memory_builtins(int n) { 540 // CHECK: call ptr @malloc 541 void * p = __builtin_malloc(n); 542 // CHECK: call void @free 543 __builtin_free(p); 544 // CHECK: call ptr @calloc 545 p = __builtin_calloc(1, n); 546 // CHECK: call ptr @realloc 547 p = __builtin_realloc(p, n); 548 // CHECK: call void @free 549 __builtin_free(p); 550 } 551 552 // CHECK-LABEL: define{{.*}} i64 @test_builtin_readcyclecounter 553 long long test_builtin_readcyclecounter(void) { 554 // CHECK: call i64 @llvm.readcyclecounter() 555 return __builtin_readcyclecounter(); 556 } 557 558 // CHECK-LABEL: define{{.*}} i64 @test_builtin_readsteadycounter 559 long long test_builtin_readsteadycounter(void) { 560 // CHECK: call i64 @llvm.readsteadycounter() 561 return __builtin_readsteadycounter(); 562 } 563 564 /// __builtin_launder should be a NOP in C since there are no vtables. 565 // CHECK-LABEL: define{{.*}} void @test_builtin_launder 566 void test_builtin_launder(int *p) { 567 // CHECK: [[TMP:%.*]] = load ptr, 568 // CHECK-NOT: @llvm.launder 569 // CHECK: store ptr [[TMP]], 570 int *d = __builtin_launder(p); 571 } 572 573 // __warn_memset_zero_len should be NOP, see https://sourceware.org/bugzilla/show_bug.cgi?id=25399 574 // CHECK-LABEL: define{{.*}} void @test___warn_memset_zero_len 575 void test___warn_memset_zero_len(void) { 576 // CHECK-NOT: @__warn_memset_zero_len 577 __warn_memset_zero_len(); 578 } 579 580 // Behavior of __builtin_os_log differs between platforms, so only test on X86 581 #ifdef __x86_64__ 582 583 // CHECK-LABEL: define{{.*}} void @test_builtin_os_log 584 // CHECK: (ptr noundef %[[BUF:.*]], i32 noundef %[[I:.*]], ptr noundef %[[DATA:.*]]) 585 void test_builtin_os_log(void *buf, int i, const char *data) { 586 volatile int len; 587 // CHECK: %[[BUF_ADDR:.*]] = alloca ptr, align 8 588 // CHECK: %[[I_ADDR:.*]] = alloca i32, align 4 589 // CHECK: %[[DATA_ADDR:.*]] = alloca ptr, align 8 590 // CHECK: %[[LEN:.*]] = alloca i32, align 4 591 // CHECK: store ptr %[[BUF]], ptr %[[BUF_ADDR]], align 8 592 // CHECK: store i32 %[[I]], ptr %[[I_ADDR]], align 4 593 // CHECK: store ptr %[[DATA]], ptr %[[DATA_ADDR]], align 8 594 595 // CHECK: store volatile i32 34, ptr %[[LEN]] 596 len = __builtin_os_log_format_buffer_size("%d %{public}s %{private}.16P", i, data, data); 597 598 // CHECK: %[[V1:.*]] = load ptr, ptr %[[BUF_ADDR]] 599 // CHECK: %[[V2:.*]] = load i32, ptr %[[I_ADDR]] 600 // CHECK: %[[V3:.*]] = load ptr, ptr %[[DATA_ADDR]] 601 // CHECK: %[[V4:.*]] = ptrtoint ptr %[[V3]] to i64 602 // CHECK: %[[V5:.*]] = load ptr, ptr %[[DATA_ADDR]] 603 // CHECK: %[[V6:.*]] = ptrtoint ptr %[[V5]] to i64 604 // CHECK: call void @__os_log_helper_1_3_4_4_0_8_34_4_17_8_49(ptr noundef %[[V1]], i32 noundef %[[V2]], i64 noundef %[[V4]], i32 noundef 16, i64 noundef %[[V6]]) 605 __builtin_os_log_format(buf, "%d %{public}s %{private}.16P", i, data, data); 606 607 // privacy annotations aren't recognized when they are preceded or followed 608 // by non-whitespace characters. 609 610 // CHECK: call void @__os_log_helper_1_2_1_8_32( 611 __builtin_os_log_format(buf, "%{xyz public}s", data); 612 613 // CHECK: call void @__os_log_helper_1_2_1_8_32( 614 __builtin_os_log_format(buf, "%{ public xyz}s", data); 615 616 // CHECK: call void @__os_log_helper_1_2_1_8_32( 617 __builtin_os_log_format(buf, "%{ public1}s", data); 618 619 // Privacy annotations do not have to be in the first comma-delimited string. 620 621 // CHECK: call void @__os_log_helper_1_2_1_8_34( 622 __builtin_os_log_format(buf, "%{ xyz, public }s", "abc"); 623 624 // CHECK: call void @__os_log_helper_1_3_1_8_33( 625 __builtin_os_log_format(buf, "%{ xyz, private }s", "abc"); 626 627 // CHECK: call void @__os_log_helper_1_3_1_8_37( 628 __builtin_os_log_format(buf, "%{ xyz, sensitive }s", "abc"); 629 630 // The strictest privacy annotation in the string wins. 631 632 // CHECK: call void @__os_log_helper_1_3_1_8_33( 633 __builtin_os_log_format(buf, "%{ private, public, private, public}s", "abc"); 634 635 // CHECK: call void @__os_log_helper_1_3_1_8_37( 636 __builtin_os_log_format(buf, "%{ private, sensitive, private, public}s", 637 "abc"); 638 639 // CHECK: store volatile i32 22, ptr %[[LEN]], align 4 640 len = __builtin_os_log_format_buffer_size("%{mask.xyz}s", "abc"); 641 642 // CHECK: call void @__os_log_helper_1_2_2_8_112_8_34(ptr noundef {{.*}}, i64 noundef 8026488 643 __builtin_os_log_format(buf, "%{mask.xyz, public}s", "abc"); 644 645 // CHECK: call void @__os_log_helper_1_3_2_8_112_4_1(ptr noundef {{.*}}, i64 noundef 8026488 646 __builtin_os_log_format(buf, "%{ mask.xyz, private }d", 11); 647 648 // Mask type is silently ignored. 649 // CHECK: call void @__os_log_helper_1_2_1_8_32( 650 __builtin_os_log_format(buf, "%{ mask. xyz }s", "abc"); 651 652 // CHECK: call void @__os_log_helper_1_2_1_8_32( 653 __builtin_os_log_format(buf, "%{ mask.xy z }s", "abc"); 654 } 655 656 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_3_4_4_0_8_34_4_17_8_49 657 // CHECK: (ptr noundef %[[BUFFER:.*]], i32 noundef %[[ARG0:.*]], i64 noundef %[[ARG1:.*]], i32 noundef %[[ARG2:.*]], i64 noundef %[[ARG3:.*]]) 658 659 // CHECK: %[[BUFFER_ADDR:.*]] = alloca ptr, align 8 660 // CHECK: %[[ARG0_ADDR:.*]] = alloca i32, align 4 661 // CHECK: %[[ARG1_ADDR:.*]] = alloca i64, align 8 662 // CHECK: %[[ARG2_ADDR:.*]] = alloca i32, align 4 663 // CHECK: %[[ARG3_ADDR:.*]] = alloca i64, align 8 664 // CHECK: store ptr %[[BUFFER]], ptr %[[BUFFER_ADDR]], align 8 665 // CHECK: store i32 %[[ARG0]], ptr %[[ARG0_ADDR]], align 4 666 // CHECK: store i64 %[[ARG1]], ptr %[[ARG1_ADDR]], align 8 667 // CHECK: store i32 %[[ARG2]], ptr %[[ARG2_ADDR]], align 4 668 // CHECK: store i64 %[[ARG3]], ptr %[[ARG3_ADDR]], align 8 669 // CHECK: %[[BUF:.*]] = load ptr, ptr %[[BUFFER_ADDR]], align 8 670 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, ptr %[[BUF]], i64 0 671 // CHECK: store i8 3, ptr %[[SUMMARY]], align 1 672 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, ptr %[[BUF]], i64 1 673 // CHECK: store i8 4, ptr %[[NUMARGS]], align 1 674 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, ptr %[[BUF]], i64 2 675 // CHECK: store i8 0, ptr %[[ARGDESCRIPTOR]], align 1 676 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, ptr %[[BUF]], i64 3 677 // CHECK: store i8 4, ptr %[[ARGSIZE]], align 1 678 // CHECK: %[[ARGDATA:.*]] = getelementptr i8, ptr %[[BUF]], i64 4 679 // CHECK: %[[V0:.*]] = load i32, ptr %[[ARG0_ADDR]], align 4 680 // CHECK: store i32 %[[V0]], ptr %[[ARGDATA]], align 1 681 // CHECK: %[[ARGDESCRIPTOR1:.*]] = getelementptr i8, ptr %[[BUF]], i64 8 682 // CHECK: store i8 34, ptr %[[ARGDESCRIPTOR1]], align 1 683 // CHECK: %[[ARGSIZE2:.*]] = getelementptr i8, ptr %[[BUF]], i64 9 684 // CHECK: store i8 8, ptr %[[ARGSIZE2]], align 1 685 // CHECK: %[[ARGDATA3:.*]] = getelementptr i8, ptr %[[BUF]], i64 10 686 // CHECK: %[[V1:.*]] = load i64, ptr %[[ARG1_ADDR]], align 8 687 // CHECK: store i64 %[[V1]], ptr %[[ARGDATA3]], align 1 688 // CHECK: %[[ARGDESCRIPTOR5:.*]] = getelementptr i8, ptr %[[BUF]], i64 18 689 // CHECK: store i8 17, ptr %[[ARGDESCRIPTOR5]], align 1 690 // CHECK: %[[ARGSIZE6:.*]] = getelementptr i8, ptr %[[BUF]], i64 19 691 // CHECK: store i8 4, ptr %[[ARGSIZE6]], align 1 692 // CHECK: %[[ARGDATA7:.*]] = getelementptr i8, ptr %[[BUF]], i64 20 693 // CHECK: %[[V2:.*]] = load i32, ptr %[[ARG2_ADDR]], align 4 694 // CHECK: store i32 %[[V2]], ptr %[[ARGDATA7]], align 1 695 // CHECK: %[[ARGDESCRIPTOR9:.*]] = getelementptr i8, ptr %[[BUF]], i64 24 696 // CHECK: store i8 49, ptr %[[ARGDESCRIPTOR9]], align 1 697 // CHECK: %[[ARGSIZE10:.*]] = getelementptr i8, ptr %[[BUF]], i64 25 698 // CHECK: store i8 8, ptr %[[ARGSIZE10]], align 1 699 // CHECK: %[[ARGDATA11:.*]] = getelementptr i8, ptr %[[BUF]], i64 26 700 // CHECK: %[[V3:.*]] = load i64, ptr %[[ARG3_ADDR]], align 8 701 // CHECK: store i64 %[[V3]], ptr %[[ARGDATA11]], align 1 702 703 // CHECK-LABEL: define{{.*}} void @test_builtin_os_log_wide 704 // CHECK: (ptr noundef %[[BUF:.*]], ptr noundef %[[DATA:.*]], ptr noundef %[[STR:.*]]) 705 typedef int wchar_t; 706 void test_builtin_os_log_wide(void *buf, const char *data, wchar_t *str) { 707 volatile int len; 708 709 // CHECK: %[[BUF_ADDR:.*]] = alloca ptr, align 8 710 // CHECK: %[[DATA_ADDR:.*]] = alloca ptr, align 8 711 // CHECK: %[[STR_ADDR:.*]] = alloca ptr, align 8 712 // CHECK: %[[LEN:.*]] = alloca i32, align 4 713 // CHECK: store ptr %[[BUF]], ptr %[[BUF_ADDR]], align 8 714 // CHECK: store ptr %[[DATA]], ptr %[[DATA_ADDR]], align 8 715 // CHECK: store ptr %[[STR]], ptr %[[STR_ADDR]], align 8 716 717 // CHECK: store volatile i32 12, ptr %[[LEN]], align 4 718 len = __builtin_os_log_format_buffer_size("%S", str); 719 720 // CHECK: %[[V1:.*]] = load ptr, ptr %[[BUF_ADDR]], align 8 721 // CHECK: %[[V2:.*]] = load ptr, ptr %[[STR_ADDR]], align 8 722 // CHECK: %[[V3:.*]] = ptrtoint ptr %[[V2]] to i64 723 // CHECK: call void @__os_log_helper_1_2_1_8_80(ptr noundef %[[V1]], i64 noundef %[[V3]]) 724 725 __builtin_os_log_format(buf, "%S", str); 726 } 727 728 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_1_8_80 729 // CHECK: (ptr noundef %[[BUFFER:.*]], i64 noundef %[[ARG0:.*]]) 730 731 // CHECK: %[[BUFFER_ADDR:.*]] = alloca ptr, align 8 732 // CHECK: %[[ARG0_ADDR:.*]] = alloca i64, align 8 733 // CHECK: store ptr %[[BUFFER]], ptr %[[BUFFER_ADDR]], align 8 734 // CHECK: store i64 %[[ARG0]], ptr %[[ARG0_ADDR]], align 8 735 // CHECK: %[[BUF:.*]] = load ptr, ptr %[[BUFFER_ADDR]], align 8 736 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, ptr %[[BUF]], i64 0 737 // CHECK: store i8 2, ptr %[[SUMMARY]], align 1 738 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, ptr %[[BUF]], i64 1 739 // CHECK: store i8 1, ptr %[[NUMARGS]], align 1 740 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, ptr %[[BUF]], i64 2 741 // CHECK: store i8 80, ptr %[[ARGDESCRIPTOR]], align 1 742 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, ptr %[[BUF]], i64 3 743 // CHECK: store i8 8, ptr %[[ARGSIZE]], align 1 744 // CHECK: %[[ARGDATA:.*]] = getelementptr i8, ptr %[[BUF]], i64 4 745 // CHECK: %[[V0:.*]] = load i64, ptr %[[ARG0_ADDR]], align 8 746 // CHECK: store i64 %[[V0]], ptr %[[ARGDATA]], align 1 747 748 // CHECK-LABEL: define{{.*}} void @test_builtin_os_log_precision_width 749 // CHECK: (ptr noundef %[[BUF:.*]], ptr noundef %[[DATA:.*]], i32 noundef %[[PRECISION:.*]], i32 noundef %[[WIDTH:.*]]) 750 void test_builtin_os_log_precision_width(void *buf, const char *data, 751 int precision, int width) { 752 volatile int len; 753 // CHECK: %[[BUF_ADDR:.*]] = alloca ptr, align 8 754 // CHECK: %[[DATA_ADDR:.*]] = alloca ptr, align 8 755 // CHECK: %[[PRECISION_ADDR:.*]] = alloca i32, align 4 756 // CHECK: %[[WIDTH_ADDR:.*]] = alloca i32, align 4 757 // CHECK: %[[LEN:.*]] = alloca i32, align 4 758 // CHECK: store ptr %[[BUF]], ptr %[[BUF_ADDR]], align 8 759 // CHECK: store ptr %[[DATA]], ptr %[[DATA_ADDR]], align 8 760 // CHECK: store i32 %[[PRECISION]], ptr %[[PRECISION_ADDR]], align 4 761 // CHECK: store i32 %[[WIDTH]], ptr %[[WIDTH_ADDR]], align 4 762 763 // CHECK: store volatile i32 24, ptr %[[LEN]], align 4 764 len = __builtin_os_log_format_buffer_size("Hello %*.*s World", precision, width, data); 765 766 // CHECK: %[[V1:.*]] = load ptr, ptr %[[BUF_ADDR]], align 8 767 // CHECK: %[[V2:.*]] = load i32, ptr %[[PRECISION_ADDR]], align 4 768 // CHECK: %[[V3:.*]] = load i32, ptr %[[WIDTH_ADDR]], align 4 769 // CHECK: %[[V4:.*]] = load ptr, ptr %[[DATA_ADDR]], align 8 770 // CHECK: %[[V5:.*]] = ptrtoint ptr %[[V4]] to i64 771 // CHECK: call void @__os_log_helper_1_2_3_4_0_4_16_8_32(ptr noundef %[[V1]], i32 noundef %[[V2]], i32 noundef %[[V3]], i64 noundef %[[V5]]) 772 __builtin_os_log_format(buf, "Hello %*.*s World", precision, width, data); 773 } 774 775 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_3_4_0_4_16_8_32 776 // CHECK: (ptr noundef %[[BUFFER:.*]], i32 noundef %[[ARG0:.*]], i32 noundef %[[ARG1:.*]], i64 noundef %[[ARG2:.*]]) 777 778 // CHECK: %[[BUFFER_ADDR:.*]] = alloca ptr, align 8 779 // CHECK: %[[ARG0_ADDR:.*]] = alloca i32, align 4 780 // CHECK: %[[ARG1_ADDR:.*]] = alloca i32, align 4 781 // CHECK: %[[ARG2_ADDR:.*]] = alloca i64, align 8 782 // CHECK: store ptr %[[BUFFER]], ptr %[[BUFFER_ADDR]], align 8 783 // CHECK: store i32 %[[ARG0]], ptr %[[ARG0_ADDR]], align 4 784 // CHECK: store i32 %[[ARG1]], ptr %[[ARG1_ADDR]], align 4 785 // CHECK: store i64 %[[ARG2]], ptr %[[ARG2_ADDR]], align 8 786 // CHECK: %[[BUF:.*]] = load ptr, ptr %[[BUFFER_ADDR]], align 8 787 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, ptr %[[BUF]], i64 0 788 // CHECK: store i8 2, ptr %[[SUMMARY]], align 1 789 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, ptr %[[BUF]], i64 1 790 // CHECK: store i8 3, ptr %[[NUMARGS]], align 1 791 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, ptr %[[BUF]], i64 2 792 // CHECK: store i8 0, ptr %[[ARGDESCRIPTOR]], align 1 793 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, ptr %[[BUF]], i64 3 794 // CHECK: store i8 4, ptr %[[ARGSIZE]], align 1 795 // CHECK: %[[ARGDATA:.*]] = getelementptr i8, ptr %[[BUF]], i64 4 796 // CHECK: %[[V0:.*]] = load i32, ptr %[[ARG0_ADDR]], align 4 797 // CHECK: store i32 %[[V0]], ptr %[[ARGDATA]], align 1 798 // CHECK: %[[ARGDESCRIPTOR1:.*]] = getelementptr i8, ptr %[[BUF]], i64 8 799 // CHECK: store i8 16, ptr %[[ARGDESCRIPTOR1]], align 1 800 // CHECK: %[[ARGSIZE2:.*]] = getelementptr i8, ptr %[[BUF]], i64 9 801 // CHECK: store i8 4, ptr %[[ARGSIZE2]], align 1 802 // CHECK: %[[ARGDATA3:.*]] = getelementptr i8, ptr %[[BUF]], i64 10 803 // CHECK: %[[V1:.*]] = load i32, ptr %[[ARG1_ADDR]], align 4 804 // CHECK: store i32 %[[V1]], ptr %[[ARGDATA3]], align 1 805 // CHECK: %[[ARGDESCRIPTOR5:.*]] = getelementptr i8, ptr %[[BUF]], i64 14 806 // CHECK: store i8 32, ptr %[[ARGDESCRIPTOR5]], align 1 807 // CHECK: %[[ARGSIZE6:.*]] = getelementptr i8, ptr %[[BUF]], i64 15 808 // CHECK: store i8 8, ptr %[[ARGSIZE6]], align 1 809 // CHECK: %[[ARGDATA7:.*]] = getelementptr i8, ptr %[[BUF]], i64 16 810 // CHECK: %[[V2:.*]] = load i64, ptr %[[ARG2_ADDR]], align 8 811 // CHECK: store i64 %[[V2]], ptr %[[ARGDATA7]], align 1 812 813 // CHECK-LABEL: define{{.*}} void @test_builtin_os_log_invalid 814 // CHECK: (ptr noundef %[[BUF:.*]], i32 noundef %[[DATA:.*]]) 815 void test_builtin_os_log_invalid(void *buf, int data) { 816 volatile int len; 817 // CHECK: %[[BUF_ADDR:.*]] = alloca ptr, align 8 818 // CHECK: %[[DATA_ADDR:.*]] = alloca i32, align 4 819 // CHECK: %[[LEN:.*]] = alloca i32, align 4 820 // CHECK: store ptr %[[BUF]], ptr %[[BUF_ADDR]], align 8 821 // CHECK: store i32 %[[DATA]], ptr %[[DATA_ADDR]], align 4 822 823 // CHECK: store volatile i32 8, ptr %[[LEN]], align 4 824 len = __builtin_os_log_format_buffer_size("invalid specifier %: %d even a trailing one%", data); 825 826 // CHECK: %[[V1:.*]] = load ptr, ptr %[[BUF_ADDR]], align 8 827 // CHECK: %[[V2:.*]] = load i32, ptr %[[DATA_ADDR]], align 4 828 // CHECK: call void @__os_log_helper_1_0_1_4_0(ptr noundef %[[V1]], i32 noundef %[[V2]]) 829 830 __builtin_os_log_format(buf, "invalid specifier %: %d even a trailing one%", data); 831 } 832 833 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_0_1_4_0 834 // CHECK: (ptr noundef %[[BUFFER:.*]], i32 noundef %[[ARG0:.*]]) 835 836 // CHECK: %[[BUFFER_ADDR:.*]] = alloca ptr, align 8 837 // CHECK: %[[ARG0_ADDR:.*]] = alloca i32, align 4 838 // CHECK: store ptr %[[BUFFER]], ptr %[[BUFFER_ADDR]], align 8 839 // CHECK: store i32 %[[ARG0]], ptr %[[ARG0_ADDR]], align 4 840 // CHECK: %[[BUF:.*]] = load ptr, ptr %[[BUFFER_ADDR]], align 8 841 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, ptr %[[BUF]], i64 0 842 // CHECK: store i8 0, ptr %[[SUMMARY]], align 1 843 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, ptr %[[BUF]], i64 1 844 // CHECK: store i8 1, ptr %[[NUMARGS]], align 1 845 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, ptr %[[BUF]], i64 2 846 // CHECK: store i8 0, ptr %[[ARGDESCRIPTOR]], align 1 847 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, ptr %[[BUF]], i64 3 848 // CHECK: store i8 4, ptr %[[ARGSIZE]], align 1 849 // CHECK: %[[ARGDATA:.*]] = getelementptr i8, ptr %[[BUF]], i64 4 850 // CHECK: %[[V0:.*]] = load i32, ptr %[[ARG0_ADDR]], align 4 851 // CHECK: store i32 %[[V0]], ptr %[[ARGDATA]], align 1 852 853 // CHECK-LABEL: define{{.*}} void @test_builtin_os_log_percent 854 // CHECK: (ptr noundef %[[BUF:.*]], ptr noundef %[[DATA1:.*]], ptr noundef %[[DATA2:.*]]) 855 // Check that the %% which does not consume any argument is correctly handled 856 void test_builtin_os_log_percent(void *buf, const char *data1, const char *data2) { 857 volatile int len; 858 // CHECK: %[[BUF_ADDR:.*]] = alloca ptr, align 8 859 // CHECK: %[[DATA1_ADDR:.*]] = alloca ptr, align 8 860 // CHECK: %[[DATA2_ADDR:.*]] = alloca ptr, align 8 861 // CHECK: %[[LEN:.*]] = alloca i32, align 4 862 // CHECK: store ptr %[[BUF]], ptr %[[BUF_ADDR]], align 8 863 // CHECK: store ptr %[[DATA1]], ptr %[[DATA1_ADDR]], align 8 864 // CHECK: store ptr %[[DATA2]], ptr %[[DATA2_ADDR]], align 8 865 // CHECK: store volatile i32 22, ptr %[[LEN]], align 4 866 867 len = __builtin_os_log_format_buffer_size("%s %% %s", data1, data2); 868 869 // CHECK: %[[V1:.*]] = load ptr, ptr %[[BUF_ADDR]], align 8 870 // CHECK: %[[V2:.*]] = load ptr, ptr %[[DATA1_ADDR]], align 8 871 // CHECK: %[[V3:.*]] = ptrtoint ptr %[[V2]] to i64 872 // CHECK: %[[V4:.*]] = load ptr, ptr %[[DATA2_ADDR]], align 8 873 // CHECK: %[[V5:.*]] = ptrtoint ptr %[[V4]] to i64 874 // CHECK: call void @__os_log_helper_1_2_2_8_32_8_32(ptr noundef %[[V1]], i64 noundef %[[V3]], i64 noundef %[[V5]]) 875 876 __builtin_os_log_format(buf, "%s %% %s", data1, data2); 877 } 878 879 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_2_8_32_8_32 880 // CHECK: (ptr noundef %[[BUFFER:.*]], i64 noundef %[[ARG0:.*]], i64 noundef %[[ARG1:.*]]) 881 882 // CHECK: %[[BUFFER_ADDR:.*]] = alloca ptr, align 8 883 // CHECK: %[[ARG0_ADDR:.*]] = alloca i64, align 8 884 // CHECK: %[[ARG1_ADDR:.*]] = alloca i64, align 8 885 // CHECK: store ptr %[[BUFFER]], ptr %[[BUFFER_ADDR]], align 8 886 // CHECK: store i64 %[[ARG0]], ptr %[[ARG0_ADDR]], align 8 887 // CHECK: store i64 %[[ARG1]], ptr %[[ARG1_ADDR]], align 8 888 // CHECK: %[[BUF:.*]] = load ptr, ptr %[[BUFFER_ADDR]], align 8 889 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, ptr %[[BUF]], i64 0 890 // CHECK: store i8 2, ptr %[[SUMMARY]], align 1 891 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, ptr %[[BUF]], i64 1 892 // CHECK: store i8 2, ptr %[[NUMARGS]], align 1 893 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, ptr %[[BUF]], i64 2 894 // CHECK: store i8 32, ptr %[[ARGDESCRIPTOR]], align 1 895 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, ptr %[[BUF]], i64 3 896 // CHECK: store i8 8, ptr %[[ARGSIZE]], align 1 897 // CHECK: %[[ARGDATA:.*]] = getelementptr i8, ptr %[[BUF]], i64 4 898 // CHECK: %[[V0:.*]] = load i64, ptr %[[ARG0_ADDR]], align 8 899 // CHECK: store i64 %[[V0]], ptr %[[ARGDATA]], align 1 900 // CHECK: %[[ARGDESCRIPTOR1:.*]] = getelementptr i8, ptr %[[BUF]], i64 12 901 // CHECK: store i8 32, ptr %[[ARGDESCRIPTOR1]], align 1 902 // CHECK: %[[ARGSIZE2:.*]] = getelementptr i8, ptr %[[BUF]], i64 13 903 // CHECK: store i8 8, ptr %[[ARGSIZE2]], align 1 904 // CHECK: %[[ARGDATA3:.*]] = getelementptr i8, ptr %[[BUF]], i64 14 905 // CHECK: %[[V1:.*]] = load i64, ptr %[[ARG1_ADDR]], align 8 906 // CHECK: store i64 %[[V1]], ptr %[[ARGDATA3]], align 1 907 908 // Check that the following two functions call the same helper function. 909 910 // CHECK-LABEL: define{{.*}} void @test_builtin_os_log_merge_helper0 911 // CHECK: call void @__os_log_helper_1_0_2_4_0_8_0( 912 void test_builtin_os_log_merge_helper0(void *buf, int i, double d) { 913 __builtin_os_log_format(buf, "%d %f", i, d); 914 } 915 916 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_0_2_4_0_8_0( 917 918 // CHECK-LABEL: define{{.*}} void @test_builtin_os_log_merge_helper1 919 // CHECK: call void @__os_log_helper_1_0_2_4_0_8_0( 920 void test_builtin_os_log_merge_helper1(void *buf, unsigned u, long long ll) { 921 __builtin_os_log_format(buf, "%u %lld", u, ll); 922 } 923 924 // Check that this function doesn't write past the end of array 'buf'. 925 926 // CHECK-LABEL: define{{.*}} void @test_builtin_os_log_errno 927 void test_builtin_os_log_errno(void) { 928 // CHECK-NOT: @stacksave 929 // CHECK: %[[BUF:.*]] = alloca [4 x i8], align 1 930 // CHECK: %[[DECAY:.*]] = getelementptr inbounds [4 x i8], ptr %[[BUF]], i64 0, i64 0 931 // CHECK: call void @__os_log_helper_1_2_1_0_96(ptr noundef %[[DECAY]]) 932 // CHECK-NOT: @stackrestore 933 934 char buf[__builtin_os_log_format_buffer_size("%m")]; 935 __builtin_os_log_format(buf, "%m"); 936 } 937 938 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_1_0_96 939 // CHECK: (ptr noundef %[[BUFFER:.*]]) 940 941 // CHECK: %[[BUFFER_ADDR:.*]] = alloca ptr, align 8 942 // CHECK: store ptr %[[BUFFER]], ptr %[[BUFFER_ADDR]], align 8 943 // CHECK: %[[BUF:.*]] = load ptr, ptr %[[BUFFER_ADDR]], align 8 944 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, ptr %[[BUF]], i64 0 945 // CHECK: store i8 2, ptr %[[SUMMARY]], align 1 946 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, ptr %[[BUF]], i64 1 947 // CHECK: store i8 1, ptr %[[NUMARGS]], align 1 948 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, ptr %[[BUF]], i64 2 949 // CHECK: store i8 96, ptr %[[ARGDESCRIPTOR]], align 1 950 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, ptr %[[BUF]], i64 3 951 // CHECK: store i8 0, ptr %[[ARGSIZE]], align 1 952 // CHECK-NEXT: ret void 953 954 // CHECK-LABEL: define{{.*}} void @test_builtin_os_log_long_double 955 // CHECK: (ptr noundef %[[BUF:.*]], x86_fp80 noundef %[[LD:.*]]) 956 void test_builtin_os_log_long_double(void *buf, long double ld) { 957 // CHECK: %[[BUF_ADDR:.*]] = alloca ptr, align 8 958 // CHECK: %[[LD_ADDR:.*]] = alloca x86_fp80, align 16 959 // CHECK: %[[COERCE:.*]] = alloca i128, align 16 960 // CHECK: store ptr %[[BUF]], ptr %[[BUF_ADDR]], align 8 961 // CHECK: store x86_fp80 %[[LD]], ptr %[[LD_ADDR]], align 16 962 // CHECK: %[[V0:.*]] = load ptr, ptr %[[BUF_ADDR]], align 8 963 // CHECK: %[[V1:.*]] = load x86_fp80, ptr %[[LD_ADDR]], align 16 964 // CHECK: %[[V2:.*]] = bitcast x86_fp80 %[[V1]] to i80 965 // CHECK: %[[V3:.*]] = zext i80 %[[V2]] to i128 966 // CHECK: store i128 %[[V3]], ptr %[[COERCE]], align 16 967 // CHECK: %[[V5:.*]] = getelementptr inbounds nuw { i64, i64 }, ptr %[[COERCE]], i32 0, i32 0 968 // CHECK: %[[V6:.*]] = load i64, ptr %[[V5]], align 16 969 // CHECK: %[[V7:.*]] = getelementptr inbounds nuw { i64, i64 }, ptr %[[COERCE]], i32 0, i32 1 970 // CHECK: %[[V8:.*]] = load i64, ptr %[[V7]], align 8 971 // CHECK: call void @__os_log_helper_1_0_1_16_0(ptr noundef %[[V0]], i64 noundef %[[V6]], i64 noundef %[[V8]]) 972 973 __builtin_os_log_format(buf, "%Lf", ld); 974 } 975 976 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_0_1_16_0 977 // CHECK: (ptr noundef %[[BUFFER:.*]], i64 noundef %[[ARG0_COERCE0:.*]], i64 noundef %[[ARG0_COERCE1:.*]]) 978 979 // CHECK: %[[ARG0:.*]] = alloca i128, align 16 980 // CHECK: %[[BUFFER_ADDR:.*]] = alloca ptr, align 8 981 // CHECK: %[[ARG0_ADDR:.*]] = alloca i128, align 16 982 // CHECK: %[[V1:.*]] = getelementptr inbounds nuw { i64, i64 }, ptr %[[ARG0]], i32 0, i32 0 983 // CHECK: store i64 %[[ARG0_COERCE0]], ptr %[[V1]], align 16 984 // CHECK: %[[V2:.*]] = getelementptr inbounds nuw { i64, i64 }, ptr %[[ARG0]], i32 0, i32 1 985 // CHECK: store i64 %[[ARG0_COERCE1]], ptr %[[V2]], align 8 986 // CHECK: %[[ARG01:.*]] = load i128, ptr %[[ARG0]], align 16 987 // CHECK: store ptr %[[BUFFER]], ptr %[[BUFFER_ADDR]], align 8 988 // CHECK: store i128 %[[ARG01]], ptr %[[ARG0_ADDR]], align 16 989 // CHECK: %[[BUF:.*]] = load ptr, ptr %[[BUFFER_ADDR]], align 8 990 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, ptr %[[BUF]], i64 0 991 // CHECK: store i8 0, ptr %[[SUMMARY]], align 1 992 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, ptr %[[BUF]], i64 1 993 // CHECK: store i8 1, ptr %[[NUMARGS]], align 1 994 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, ptr %[[BUF]], i64 2 995 // CHECK: store i8 0, ptr %[[ARGDESCRIPTOR]], align 1 996 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, ptr %[[BUF]], i64 3 997 // CHECK: store i8 16, ptr %[[ARGSIZE]], align 1 998 // CHECK: %[[ARGDATA:.*]] = getelementptr i8, ptr %[[BUF]], i64 4 999 // CHECK: %[[V3:.*]] = load i128, ptr %[[ARG0_ADDR]], align 16 1000 // CHECK: store i128 %[[V3]], ptr %[[ARGDATA]], align 1 1001 1002 // CHECK-LABEL: define{{.*}} void @test_builtin_popcountg 1003 void test_builtin_popcountg(unsigned char uc, unsigned short us, 1004 unsigned int ui, unsigned long ul, 1005 unsigned long long ull, unsigned __int128 ui128, 1006 unsigned _BitInt(128) ubi128) { 1007 volatile int pop; 1008 pop = __builtin_popcountg(uc); 1009 // CHECK: %1 = load i8, ptr %uc.addr, align 1 1010 // CHECK-NEXT: %2 = call i8 @llvm.ctpop.i8(i8 %1) 1011 // CHECK-NEXT: %cast = zext i8 %2 to i32 1012 // CHECK-NEXT: store volatile i32 %cast, ptr %pop, align 4 1013 pop = __builtin_popcountg(us); 1014 // CHECK-NEXT: %3 = load i16, ptr %us.addr, align 2 1015 // CHECK-NEXT: %4 = call i16 @llvm.ctpop.i16(i16 %3) 1016 // CHECK-NEXT: %cast1 = zext i16 %4 to i32 1017 // CHECK-NEXT: store volatile i32 %cast1, ptr %pop, align 4 1018 pop = __builtin_popcountg(ui); 1019 // CHECK-NEXT: %5 = load i32, ptr %ui.addr, align 4 1020 // CHECK-NEXT: %6 = call i32 @llvm.ctpop.i32(i32 %5) 1021 // CHECK-NEXT: store volatile i32 %6, ptr %pop, align 4 1022 pop = __builtin_popcountg(ul); 1023 // CHECK-NEXT: %7 = load i64, ptr %ul.addr, align 8 1024 // CHECK-NEXT: %8 = call i64 @llvm.ctpop.i64(i64 %7) 1025 // CHECK-NEXT: %cast2 = trunc i64 %8 to i32 1026 // CHECK-NEXT: store volatile i32 %cast2, ptr %pop, align 4 1027 pop = __builtin_popcountg(ull); 1028 // CHECK-NEXT: %9 = load i64, ptr %ull.addr, align 8 1029 // CHECK-NEXT: %10 = call i64 @llvm.ctpop.i64(i64 %9) 1030 // CHECK-NEXT: %cast3 = trunc i64 %10 to i32 1031 // CHECK-NEXT: store volatile i32 %cast3, ptr %pop, align 4 1032 pop = __builtin_popcountg(ui128); 1033 // CHECK-NEXT: %11 = load i128, ptr %ui128.addr, align 16 1034 // CHECK-NEXT: %12 = call i128 @llvm.ctpop.i128(i128 %11) 1035 // CHECK-NEXT: %cast4 = trunc i128 %12 to i32 1036 // CHECK-NEXT: store volatile i32 %cast4, ptr %pop, align 4 1037 pop = __builtin_popcountg(ubi128); 1038 // CHECK-NEXT: %13 = load i128, ptr %ubi128.addr, align 8 1039 // CHECK-NEXT: %14 = call i128 @llvm.ctpop.i128(i128 %13) 1040 // CHECK-NEXT: %cast5 = trunc i128 %14 to i32 1041 // CHECK-NEXT: store volatile i32 %cast5, ptr %pop, align 4 1042 // CHECK-NEXT: ret void 1043 } 1044 1045 // CHECK-LABEL: define{{.*}} void @test_builtin_clzg 1046 void test_builtin_clzg(unsigned char uc, unsigned short us, unsigned int ui, 1047 unsigned long ul, unsigned long long ull, 1048 unsigned __int128 ui128, unsigned _BitInt(128) ubi128, 1049 signed char sc, short s, int i) { 1050 volatile int lz; 1051 lz = __builtin_clzg(uc); 1052 // CHECK: %1 = load i8, ptr %uc.addr, align 1 1053 // CHECK-NEXT: %2 = call i8 @llvm.ctlz.i8(i8 %1, i1 true) 1054 // CHECK-NEXT: %cast = zext i8 %2 to i32 1055 // CHECK-NEXT: store volatile i32 %cast, ptr %lz, align 4 1056 lz = __builtin_clzg(us); 1057 // CHECK-NEXT: %3 = load i16, ptr %us.addr, align 2 1058 // CHECK-NEXT: %4 = call i16 @llvm.ctlz.i16(i16 %3, i1 true) 1059 // CHECK-NEXT: %cast1 = zext i16 %4 to i32 1060 // CHECK-NEXT: store volatile i32 %cast1, ptr %lz, align 4 1061 lz = __builtin_clzg(ui); 1062 // CHECK-NEXT: %5 = load i32, ptr %ui.addr, align 4 1063 // CHECK-NEXT: %6 = call i32 @llvm.ctlz.i32(i32 %5, i1 true) 1064 // CHECK-NEXT: store volatile i32 %6, ptr %lz, align 4 1065 lz = __builtin_clzg(ul); 1066 // CHECK-NEXT: %7 = load i64, ptr %ul.addr, align 8 1067 // CHECK-NEXT: %8 = call i64 @llvm.ctlz.i64(i64 %7, i1 true) 1068 // CHECK-NEXT: %cast2 = trunc i64 %8 to i32 1069 // CHECK-NEXT: store volatile i32 %cast2, ptr %lz, align 4 1070 lz = __builtin_clzg(ull); 1071 // CHECK-NEXT: %9 = load i64, ptr %ull.addr, align 8 1072 // CHECK-NEXT: %10 = call i64 @llvm.ctlz.i64(i64 %9, i1 true) 1073 // CHECK-NEXT: %cast3 = trunc i64 %10 to i32 1074 // CHECK-NEXT: store volatile i32 %cast3, ptr %lz, align 4 1075 lz = __builtin_clzg(ui128); 1076 // CHECK-NEXT: %11 = load i128, ptr %ui128.addr, align 16 1077 // CHECK-NEXT: %12 = call i128 @llvm.ctlz.i128(i128 %11, i1 true) 1078 // CHECK-NEXT: %cast4 = trunc i128 %12 to i32 1079 // CHECK-NEXT: store volatile i32 %cast4, ptr %lz, align 4 1080 lz = __builtin_clzg(ubi128); 1081 // CHECK-NEXT: %13 = load i128, ptr %ubi128.addr, align 8 1082 // CHECK-NEXT: %14 = call i128 @llvm.ctlz.i128(i128 %13, i1 true) 1083 // CHECK-NEXT: %cast5 = trunc i128 %14 to i32 1084 // CHECK-NEXT: store volatile i32 %cast5, ptr %lz, align 4 1085 lz = __builtin_clzg(uc, sc); 1086 // CHECK-NEXT: %15 = load i8, ptr %uc.addr, align 1 1087 // CHECK-NEXT: %16 = call i8 @llvm.ctlz.i8(i8 %15, i1 true) 1088 // CHECK-NEXT: %cast6 = zext i8 %16 to i32 1089 // CHECK-NEXT: %iszero = icmp eq i8 %15, 0 1090 // CHECK-NEXT: %17 = load i8, ptr %sc.addr, align 1 1091 // CHECK-NEXT: %conv = sext i8 %17 to i32 1092 // CHECK-NEXT: %clzg = select i1 %iszero, i32 %conv, i32 %cast6 1093 // CHECK-NEXT: store volatile i32 %clzg, ptr %lz, align 4 1094 lz = __builtin_clzg(us, uc); 1095 // CHECK-NEXT: %18 = load i16, ptr %us.addr, align 2 1096 // CHECK-NEXT: %19 = call i16 @llvm.ctlz.i16(i16 %18, i1 true) 1097 // CHECK-NEXT: %cast7 = zext i16 %19 to i32 1098 // CHECK-NEXT: %iszero8 = icmp eq i16 %18, 0 1099 // CHECK-NEXT: %20 = load i8, ptr %uc.addr, align 1 1100 // CHECK-NEXT: %conv9 = zext i8 %20 to i32 1101 // CHECK-NEXT: %clzg10 = select i1 %iszero8, i32 %conv9, i32 %cast7 1102 // CHECK-NEXT: store volatile i32 %clzg10, ptr %lz, align 4 1103 lz = __builtin_clzg(ui, s); 1104 // CHECK-NEXT: %21 = load i32, ptr %ui.addr, align 4 1105 // CHECK-NEXT: %22 = call i32 @llvm.ctlz.i32(i32 %21, i1 true) 1106 // CHECK-NEXT: %iszero11 = icmp eq i32 %21, 0 1107 // CHECK-NEXT: %23 = load i16, ptr %s.addr, align 2 1108 // CHECK-NEXT: %conv12 = sext i16 %23 to i32 1109 // CHECK-NEXT: %clzg13 = select i1 %iszero11, i32 %conv12, i32 %22 1110 // CHECK-NEXT: store volatile i32 %clzg13, ptr %lz, align 4 1111 lz = __builtin_clzg(ul, us); 1112 // CHECK-NEXT: %24 = load i64, ptr %ul.addr, align 8 1113 // CHECK-NEXT: %25 = call i64 @llvm.ctlz.i64(i64 %24, i1 true) 1114 // CHECK-NEXT: %cast14 = trunc i64 %25 to i32 1115 // CHECK-NEXT: %iszero15 = icmp eq i64 %24, 0 1116 // CHECK-NEXT: %26 = load i16, ptr %us.addr, align 2 1117 // CHECK-NEXT: %conv16 = zext i16 %26 to i32 1118 // CHECK-NEXT: %clzg17 = select i1 %iszero15, i32 %conv16, i32 %cast14 1119 // CHECK-NEXT: store volatile i32 %clzg17, ptr %lz, align 4 1120 lz = __builtin_clzg(ull, i); 1121 // CHECK-NEXT: %27 = load i64, ptr %ull.addr, align 8 1122 // CHECK-NEXT: %28 = call i64 @llvm.ctlz.i64(i64 %27, i1 true) 1123 // CHECK-NEXT: %cast18 = trunc i64 %28 to i32 1124 // CHECK-NEXT: %iszero19 = icmp eq i64 %27, 0 1125 // CHECK-NEXT: %29 = load i32, ptr %i.addr, align 4 1126 // CHECK-NEXT: %clzg20 = select i1 %iszero19, i32 %29, i32 %cast18 1127 // CHECK-NEXT: store volatile i32 %clzg20, ptr %lz, align 4 1128 lz = __builtin_clzg(ui128, i); 1129 // CHECK-NEXT: %30 = load i128, ptr %ui128.addr, align 16 1130 // CHECK-NEXT: %31 = call i128 @llvm.ctlz.i128(i128 %30, i1 true) 1131 // CHECK-NEXT: %cast21 = trunc i128 %31 to i32 1132 // CHECK-NEXT: %iszero22 = icmp eq i128 %30, 0 1133 // CHECK-NEXT: %32 = load i32, ptr %i.addr, align 4 1134 // CHECK-NEXT: %clzg23 = select i1 %iszero22, i32 %32, i32 %cast21 1135 // CHECK-NEXT: store volatile i32 %clzg23, ptr %lz, align 4 1136 lz = __builtin_clzg(ubi128, i); 1137 // CHECK-NEXT: %33 = load i128, ptr %ubi128.addr, align 8 1138 // CHECK-NEXT: %34 = call i128 @llvm.ctlz.i128(i128 %33, i1 true) 1139 // CHECK-NEXT: %cast24 = trunc i128 %34 to i32 1140 // CHECK-NEXT: %iszero25 = icmp eq i128 %33, 0 1141 // CHECK-NEXT: %35 = load i32, ptr %i.addr, align 4 1142 // CHECK-NEXT: %clzg26 = select i1 %iszero25, i32 %35, i32 %cast24 1143 // CHECK-NEXT: store volatile i32 %clzg26, ptr %lz, align 4 1144 // CHECK-NEXT: ret void 1145 } 1146 1147 // CHECK-LABEL: define{{.*}} void @test_builtin_ctzg 1148 void test_builtin_ctzg(unsigned char uc, unsigned short us, unsigned int ui, 1149 unsigned long ul, unsigned long long ull, 1150 unsigned __int128 ui128, unsigned _BitInt(128) ubi128, 1151 signed char sc, short s, int i) { 1152 volatile int tz; 1153 tz = __builtin_ctzg(uc); 1154 // CHECK: %1 = load i8, ptr %uc.addr, align 1 1155 // CHECK-NEXT: %2 = call i8 @llvm.cttz.i8(i8 %1, i1 true) 1156 // CHECK-NEXT: %cast = zext i8 %2 to i32 1157 // CHECK-NEXT: store volatile i32 %cast, ptr %tz, align 4 1158 tz = __builtin_ctzg(us); 1159 // CHECK-NEXT: %3 = load i16, ptr %us.addr, align 2 1160 // CHECK-NEXT: %4 = call i16 @llvm.cttz.i16(i16 %3, i1 true) 1161 // CHECK-NEXT: %cast1 = zext i16 %4 to i32 1162 // CHECK-NEXT: store volatile i32 %cast1, ptr %tz, align 4 1163 tz = __builtin_ctzg(ui); 1164 // CHECK-NEXT: %5 = load i32, ptr %ui.addr, align 4 1165 // CHECK-NEXT: %6 = call i32 @llvm.cttz.i32(i32 %5, i1 true) 1166 // CHECK-NEXT: store volatile i32 %6, ptr %tz, align 4 1167 tz = __builtin_ctzg(ul); 1168 // CHECK-NEXT: %7 = load i64, ptr %ul.addr, align 8 1169 // CHECK-NEXT: %8 = call i64 @llvm.cttz.i64(i64 %7, i1 true) 1170 // CHECK-NEXT: %cast2 = trunc i64 %8 to i32 1171 // CHECK-NEXT: store volatile i32 %cast2, ptr %tz, align 4 1172 tz = __builtin_ctzg(ull); 1173 // CHECK-NEXT: %9 = load i64, ptr %ull.addr, align 8 1174 // CHECK-NEXT: %10 = call i64 @llvm.cttz.i64(i64 %9, i1 true) 1175 // CHECK-NEXT: %cast3 = trunc i64 %10 to i32 1176 // CHECK-NEXT: store volatile i32 %cast3, ptr %tz, align 4 1177 tz = __builtin_ctzg(ui128); 1178 // CHECK-NEXT: %11 = load i128, ptr %ui128.addr, align 16 1179 // CHECK-NEXT: %12 = call i128 @llvm.cttz.i128(i128 %11, i1 true) 1180 // CHECK-NEXT: %cast4 = trunc i128 %12 to i32 1181 // CHECK-NEXT: store volatile i32 %cast4, ptr %tz, align 4 1182 tz = __builtin_ctzg(ubi128); 1183 // CHECK-NEXT: %13 = load i128, ptr %ubi128.addr, align 8 1184 // CHECK-NEXT: %14 = call i128 @llvm.cttz.i128(i128 %13, i1 true) 1185 // CHECK-NEXT: %cast5 = trunc i128 %14 to i32 1186 // CHECK-NEXT: store volatile i32 %cast5, ptr %tz, align 4 1187 tz = __builtin_ctzg(uc, sc); 1188 // CHECK-NEXT: %15 = load i8, ptr %uc.addr, align 1 1189 // CHECK-NEXT: %16 = call i8 @llvm.cttz.i8(i8 %15, i1 true) 1190 // CHECK-NEXT: %cast6 = zext i8 %16 to i32 1191 // CHECK-NEXT: %iszero = icmp eq i8 %15, 0 1192 // CHECK-NEXT: %17 = load i8, ptr %sc.addr, align 1 1193 // CHECK-NEXT: %conv = sext i8 %17 to i32 1194 // CHECK-NEXT: %ctzg = select i1 %iszero, i32 %conv, i32 %cast6 1195 // CHECK-NEXT: store volatile i32 %ctzg, ptr %tz, align 4 1196 tz = __builtin_ctzg(us, uc); 1197 // CHECK-NEXT: %18 = load i16, ptr %us.addr, align 2 1198 // CHECK-NEXT: %19 = call i16 @llvm.cttz.i16(i16 %18, i1 true) 1199 // CHECK-NEXT: %cast7 = zext i16 %19 to i32 1200 // CHECK-NEXT: %iszero8 = icmp eq i16 %18, 0 1201 // CHECK-NEXT: %20 = load i8, ptr %uc.addr, align 1 1202 // CHECK-NEXT: %conv9 = zext i8 %20 to i32 1203 // CHECK-NEXT: %ctzg10 = select i1 %iszero8, i32 %conv9, i32 %cast7 1204 // CHECK-NEXT: store volatile i32 %ctzg10, ptr %tz, align 4 1205 tz = __builtin_ctzg(ui, s); 1206 // CHECK-NEXT: %21 = load i32, ptr %ui.addr, align 4 1207 // CHECK-NEXT: %22 = call i32 @llvm.cttz.i32(i32 %21, i1 true) 1208 // CHECK-NEXT: %iszero11 = icmp eq i32 %21, 0 1209 // CHECK-NEXT: %23 = load i16, ptr %s.addr, align 2 1210 // CHECK-NEXT: %conv12 = sext i16 %23 to i32 1211 // CHECK-NEXT: %ctzg13 = select i1 %iszero11, i32 %conv12, i32 %22 1212 // CHECK-NEXT: store volatile i32 %ctzg13, ptr %tz, align 4 1213 tz = __builtin_ctzg(ul, us); 1214 // CHECK-NEXT: %24 = load i64, ptr %ul.addr, align 8 1215 // CHECK-NEXT: %25 = call i64 @llvm.cttz.i64(i64 %24, i1 true) 1216 // CHECK-NEXT: %cast14 = trunc i64 %25 to i32 1217 // CHECK-NEXT: %iszero15 = icmp eq i64 %24, 0 1218 // CHECK-NEXT: %26 = load i16, ptr %us.addr, align 2 1219 // CHECK-NEXT: %conv16 = zext i16 %26 to i32 1220 // CHECK-NEXT: %ctzg17 = select i1 %iszero15, i32 %conv16, i32 %cast14 1221 // CHECK-NEXT: store volatile i32 %ctzg17, ptr %tz, align 4 1222 tz = __builtin_ctzg(ull, i); 1223 // CHECK-NEXT: %27 = load i64, ptr %ull.addr, align 8 1224 // CHECK-NEXT: %28 = call i64 @llvm.cttz.i64(i64 %27, i1 true) 1225 // CHECK-NEXT: %cast18 = trunc i64 %28 to i32 1226 // CHECK-NEXT: %iszero19 = icmp eq i64 %27, 0 1227 // CHECK-NEXT: %29 = load i32, ptr %i.addr, align 4 1228 // CHECK-NEXT: %ctzg20 = select i1 %iszero19, i32 %29, i32 %cast18 1229 // CHECK-NEXT: store volatile i32 %ctzg20, ptr %tz, align 4 1230 tz = __builtin_ctzg(ui128, i); 1231 // CHECK-NEXT: %30 = load i128, ptr %ui128.addr, align 16 1232 // CHECK-NEXT: %31 = call i128 @llvm.cttz.i128(i128 %30, i1 true) 1233 // CHECK-NEXT: %cast21 = trunc i128 %31 to i32 1234 // CHECK-NEXT: %iszero22 = icmp eq i128 %30, 0 1235 // CHECK-NEXT: %32 = load i32, ptr %i.addr, align 4 1236 // CHECK-NEXT: %ctzg23 = select i1 %iszero22, i32 %32, i32 %cast21 1237 // CHECK-NEXT: store volatile i32 %ctzg23, ptr %tz, align 4 1238 tz = __builtin_ctzg(ubi128, i); 1239 // CHECK-NEXT: %33 = load i128, ptr %ubi128.addr, align 8 1240 // CHECK-NEXT: %34 = call i128 @llvm.cttz.i128(i128 %33, i1 true) 1241 // CHECK-NEXT: %cast24 = trunc i128 %34 to i32 1242 // CHECK-NEXT: %iszero25 = icmp eq i128 %33, 0 1243 // CHECK-NEXT: %35 = load i32, ptr %i.addr, align 4 1244 // CHECK-NEXT: %ctzg26 = select i1 %iszero25, i32 %35, i32 %cast24 1245 // CHECK-NEXT: store volatile i32 %ctzg26, ptr %tz, align 4 1246 // CHECK-NEXT: ret void 1247 } 1248 1249 #endif 1250