1 // RUN: %clang_cc1 -emit-llvm -o %t %s 2 // RUN: not grep __builtin %t 3 // RUN: %clang_cc1 %s -emit-llvm -o - -triple x86_64-darwin-apple | 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 19 int main() { 20 int N = random(); 21 #define P(n,args) p(#n #args, __builtin_##n args) 22 #define Q(n,args) q(#n #args, __builtin_##n args) 23 #define R(n,args) r(#n #args, __builtin_##n args) 24 #define V(n,args) p(#n #args, (__builtin_##n args, 0)) 25 P(types_compatible_p, (int, float)); 26 P(choose_expr, (0, 10, 20)); 27 P(constant_p, (sizeof(10))); 28 P(expect, (N == 12, 0)); 29 V(prefetch, (&N)); 30 V(prefetch, (&N, 1)); 31 V(prefetch, (&N, 1, 0)); 32 33 // Numeric Constants 34 35 Q(huge_val, ()); 36 Q(huge_valf, ()); 37 Q(huge_vall, ()); 38 Q(inf, ()); 39 Q(inff, ()); 40 Q(infl, ()); 41 42 P(fpclassify, (0, 1, 2, 3, 4, 1.0)); 43 P(fpclassify, (0, 1, 2, 3, 4, 1.0f)); 44 P(fpclassify, (0, 1, 2, 3, 4, 1.0l)); 45 46 Q(nan, ("")); 47 Q(nanf, ("")); 48 Q(nanl, ("")); 49 Q(nans, ("")); 50 Q(nan, ("10")); 51 Q(nanf, ("10")); 52 Q(nanl, ("10")); 53 Q(nans, ("10")); 54 55 P(isgreater, (1., 2.)); 56 P(isgreaterequal, (1., 2.)); 57 P(isless, (1., 2.)); 58 P(islessequal, (1., 2.)); 59 P(islessgreater, (1., 2.)); 60 P(isunordered, (1., 2.)); 61 62 P(isinf, (1.)); 63 P(isinf_sign, (1.)); 64 P(isnan, (1.)); 65 66 // Bitwise & Numeric Functions 67 68 P(abs, (N)); 69 70 P(clz, (N)); 71 P(clzl, (N)); 72 P(clzll, (N)); 73 P(ctz, (N)); 74 P(ctzl, (N)); 75 P(ctzll, (N)); 76 P(ffs, (N)); 77 P(ffsl, (N)); 78 P(ffsll, (N)); 79 P(parity, (N)); 80 P(parityl, (N)); 81 P(parityll, (N)); 82 P(popcount, (N)); 83 P(popcountl, (N)); 84 P(popcountll, (N)); 85 Q(powi, (1.2f, N)); 86 Q(powif, (1.2f, N)); 87 Q(powil, (1.2f, N)); 88 89 // Lib functions 90 int a, b, n = random(); // Avoid optimizing out. 91 char s0[10], s1[] = "Hello"; 92 V(strcat, (s0, s1)); 93 V(strcmp, (s0, s1)); 94 V(strncat, (s0, s1, n)); 95 V(strchr, (s0, s1[0])); 96 V(strrchr, (s0, s1[0])); 97 V(strcpy, (s0, s1)); 98 V(strncpy, (s0, s1, n)); 99 100 // Object size checking 101 V(__memset_chk, (s0, 0, sizeof s0, n)); 102 V(__memcpy_chk, (s0, s1, sizeof s0, n)); 103 V(__memmove_chk, (s0, s1, sizeof s0, n)); 104 V(__mempcpy_chk, (s0, s1, sizeof s0, n)); 105 V(__strncpy_chk, (s0, s1, sizeof s0, n)); 106 V(__strcpy_chk, (s0, s1, n)); 107 s0[0] = 0; 108 V(__strcat_chk, (s0, s1, n)); 109 P(object_size, (s0, 0)); 110 P(object_size, (s0, 1)); 111 P(object_size, (s0, 2)); 112 P(object_size, (s0, 3)); 113 114 // Whatever 115 116 P(bswap16, (N)); 117 P(bswap32, (N)); 118 P(bswap64, (N)); 119 120 // CHECK: @llvm.bitreverse.i8 121 // CHECK: @llvm.bitreverse.i16 122 // CHECK: @llvm.bitreverse.i32 123 // CHECK: @llvm.bitreverse.i64 124 P(bitreverse8, (N)); 125 P(bitreverse16, (N)); 126 P(bitreverse32, (N)); 127 P(bitreverse64, (N)); 128 129 // FIXME 130 // V(clear_cache, (&N, &N+1)); 131 V(trap, ()); 132 R(extract_return_addr, (&N)); 133 P(signbit, (1.0)); 134 135 return 0; 136 } 137 138 139 140 void foo() { 141 __builtin_strcat(0, 0); 142 } 143 144 // CHECK-LABEL: define void @bar( 145 void bar() { 146 float f; 147 double d; 148 long double ld; 149 150 // LLVM's hex representation of float constants is really unfortunate; 151 // basically it does a float-to-double "conversion" and then prints the 152 // hex form of that. That gives us weird artifacts like exponents 153 // that aren't numerically similar to the original exponent and 154 // significand bit-patterns that are offset by three bits (because 155 // the exponent was expanded from 8 bits to 11). 156 // 157 // 0xAE98 == 1010111010011000 158 // 0x15D3 == 1010111010011 159 160 f = __builtin_huge_valf(); // CHECK: float 0x7FF0000000000000 161 d = __builtin_huge_val(); // CHECK: double 0x7FF0000000000000 162 ld = __builtin_huge_vall(); // CHECK: x86_fp80 0xK7FFF8000000000000000 163 f = __builtin_nanf(""); // CHECK: float 0x7FF8000000000000 164 d = __builtin_nan(""); // CHECK: double 0x7FF8000000000000 165 ld = __builtin_nanl(""); // CHECK: x86_fp80 0xK7FFFC000000000000000 166 f = __builtin_nanf("0xAE98"); // CHECK: float 0x7FF815D300000000 167 d = __builtin_nan("0xAE98"); // CHECK: double 0x7FF800000000AE98 168 ld = __builtin_nanl("0xAE98"); // CHECK: x86_fp80 0xK7FFFC00000000000AE98 169 f = __builtin_nansf(""); // CHECK: float 0x7FF4000000000000 170 d = __builtin_nans(""); // CHECK: double 0x7FF4000000000000 171 ld = __builtin_nansl(""); // CHECK: x86_fp80 0xK7FFFA000000000000000 172 f = __builtin_nansf("0xAE98"); // CHECK: float 0x7FF015D300000000 173 d = __builtin_nans("0xAE98"); // CHECK: double 0x7FF000000000AE98 174 ld = __builtin_nansl("0xAE98");// CHECK: x86_fp80 0xK7FFF800000000000AE98 175 176 } 177 // CHECK: } 178 179 180 // CHECK-LABEL: define void @test_float_builtins 181 void test_float_builtins(float F, double D, long double LD) { 182 volatile int res; 183 res = __builtin_isinf(F); 184 // CHECK: call float @llvm.fabs.f32(float 185 // CHECK: fcmp oeq float {{.*}}, 0x7FF0000000000000 186 187 res = __builtin_isinf(D); 188 // CHECK: call double @llvm.fabs.f64(double 189 // CHECK: fcmp oeq double {{.*}}, 0x7FF0000000000000 190 191 res = __builtin_isinf(LD); 192 // CHECK: call x86_fp80 @llvm.fabs.f80(x86_fp80 193 // CHECK: fcmp oeq x86_fp80 {{.*}}, 0xK7FFF8000000000000000 194 195 res = __builtin_isinf_sign(F); 196 // CHECK: %[[ABS:.*]] = call float @llvm.fabs.f32(float %[[ARG:.*]]) 197 // CHECK: %[[ISINF:.*]] = fcmp oeq float %[[ABS]], 0x7FF0000000000000 198 // CHECK: %[[BITCAST:.*]] = bitcast float %[[ARG]] to i32 199 // CHECK: %[[ISNEG:.*]] = icmp slt i32 %[[BITCAST]], 0 200 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1 201 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0 202 203 res = __builtin_isinf_sign(D); 204 // CHECK: %[[ABS:.*]] = call double @llvm.fabs.f64(double %[[ARG:.*]]) 205 // CHECK: %[[ISINF:.*]] = fcmp oeq double %[[ABS]], 0x7FF0000000000000 206 // CHECK: %[[BITCAST:.*]] = bitcast double %[[ARG]] to i64 207 // CHECK: %[[ISNEG:.*]] = icmp slt i64 %[[BITCAST]], 0 208 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1 209 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0 210 211 res = __builtin_isinf_sign(LD); 212 // CHECK: %[[ABS:.*]] = call x86_fp80 @llvm.fabs.f80(x86_fp80 %[[ARG:.*]]) 213 // CHECK: %[[ISINF:.*]] = fcmp oeq x86_fp80 %[[ABS]], 0xK7FFF8000000000000000 214 // CHECK: %[[BITCAST:.*]] = bitcast x86_fp80 %[[ARG]] to i80 215 // CHECK: %[[ISNEG:.*]] = icmp slt i80 %[[BITCAST]], 0 216 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1 217 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0 218 219 res = __builtin_isfinite(F); 220 // CHECK: call float @llvm.fabs.f32(float 221 // CHECK: fcmp one float {{.*}}, 0x7FF0000000000000 222 223 res = finite(D); 224 // CHECK: call double @llvm.fabs.f64(double 225 // CHECK: fcmp one double {{.*}}, 0x7FF0000000000000 226 227 res = __builtin_isnormal(F); 228 // CHECK: fcmp oeq float 229 // CHECK: call float @llvm.fabs.f32(float 230 // CHECK: fcmp ult float {{.*}}, 0x7FF0000000000000 231 // CHECK: fcmp uge float {{.*}}, 0x3810000000000000 232 // CHECK: and i1 233 // CHECK: and i1 234 } 235 236 // CHECK-LABEL: define void @test_float_builtin_ops 237 void test_float_builtin_ops(float F, double D, long double LD) { 238 volatile float resf; 239 volatile double resd; 240 volatile long double resld; 241 242 resf = __builtin_fmodf(F,F); 243 // CHECK: frem float 244 245 resd = __builtin_fmod(D,D); 246 // CHECK: frem double 247 248 resld = __builtin_fmodl(LD,LD); 249 // CHECK: frem x86_fp80 250 251 resf = __builtin_fabsf(F); 252 resd = __builtin_fabs(D); 253 resld = __builtin_fabsl(LD); 254 // CHECK: call float @llvm.fabs.f32(float 255 // CHECK: call double @llvm.fabs.f64(double 256 // CHECK: call x86_fp80 @llvm.fabs.f80(x86_fp80 257 258 resf = __builtin_canonicalizef(F); 259 resd = __builtin_canonicalize(D); 260 resld = __builtin_canonicalizel(LD); 261 // CHECK: call float @llvm.canonicalize.f32(float 262 // CHECK: call double @llvm.canonicalize.f64(double 263 // CHECK: call x86_fp80 @llvm.canonicalize.f80(x86_fp80 264 265 resf = __builtin_fminf(F, F); 266 // CHECK: call float @llvm.minnum.f32 267 268 resd = __builtin_fmin(D, D); 269 // CHECK: call double @llvm.minnum.f64 270 271 resld = __builtin_fminl(LD, LD); 272 // CHECK: call x86_fp80 @llvm.minnum.f80 273 274 resf = __builtin_fmaxf(F, F); 275 // CHECK: call float @llvm.maxnum.f32 276 277 resd = __builtin_fmax(D, D); 278 // CHECK: call double @llvm.maxnum.f64 279 280 resld = __builtin_fmaxl(LD, LD); 281 // CHECK: call x86_fp80 @llvm.maxnum.f80 282 283 resf = __builtin_fabsf(F); 284 // CHECK: call float @llvm.fabs.f32 285 286 resd = __builtin_fabs(D); 287 // CHECK: call double @llvm.fabs.f64 288 289 resld = __builtin_fabsl(LD); 290 // CHECK: call x86_fp80 @llvm.fabs.f80 291 292 resf = __builtin_copysignf(F, F); 293 // CHECK: call float @llvm.copysign.f32 294 295 resd = __builtin_copysign(D, D); 296 // CHECK: call double @llvm.copysign.f64 297 298 resld = __builtin_copysignl(LD, LD); 299 // CHECK: call x86_fp80 @llvm.copysign.f80 300 301 302 resf = __builtin_ceilf(F); 303 // CHECK: call float @llvm.ceil.f32 304 305 resd = __builtin_ceil(D); 306 // CHECK: call double @llvm.ceil.f64 307 308 resld = __builtin_ceill(LD); 309 // CHECK: call x86_fp80 @llvm.ceil.f80 310 311 resf = __builtin_floorf(F); 312 // CHECK: call float @llvm.floor.f32 313 314 resd = __builtin_floor(D); 315 // CHECK: call double @llvm.floor.f64 316 317 resld = __builtin_floorl(LD); 318 // CHECK: call x86_fp80 @llvm.floor.f80 319 320 resf = __builtin_truncf(F); 321 // CHECK: call float @llvm.trunc.f32 322 323 resd = __builtin_trunc(D); 324 // CHECK: call double @llvm.trunc.f64 325 326 resld = __builtin_truncl(LD); 327 // CHECK: call x86_fp80 @llvm.trunc.f80 328 329 resf = __builtin_rintf(F); 330 // CHECK: call float @llvm.rint.f32 331 332 resd = __builtin_rint(D); 333 // CHECK: call double @llvm.rint.f64 334 335 resld = __builtin_rintl(LD); 336 // CHECK: call x86_fp80 @llvm.rint.f80 337 338 resf = __builtin_nearbyintf(F); 339 // CHECK: call float @llvm.nearbyint.f32 340 341 resd = __builtin_nearbyint(D); 342 // CHECK: call double @llvm.nearbyint.f64 343 344 resld = __builtin_nearbyintl(LD); 345 // CHECK: call x86_fp80 @llvm.nearbyint.f80 346 347 resf = __builtin_roundf(F); 348 // CHECK: call float @llvm.round.f32 349 350 resd = __builtin_round(D); 351 // CHECK: call double @llvm.round.f64 352 353 resld = __builtin_roundl(LD); 354 // CHECK: call x86_fp80 @llvm.round.f80 355 356 } 357 358 // __builtin_longjmp isn't supported on all platforms, so only test it on X86. 359 #ifdef __x86_64__ 360 361 // CHECK-LABEL: define void @test_builtin_longjmp 362 void test_builtin_longjmp(void **buffer) { 363 // CHECK: [[BITCAST:%.*]] = bitcast 364 // CHECK-NEXT: call void @llvm.eh.sjlj.longjmp(i8* [[BITCAST]]) 365 __builtin_longjmp(buffer, 1); 366 // CHECK-NEXT: unreachable 367 } 368 369 #endif 370 371 // CHECK-LABEL: define i64 @test_builtin_readcyclecounter 372 long long test_builtin_readcyclecounter() { 373 // CHECK: call i64 @llvm.readcyclecounter() 374 return __builtin_readcyclecounter(); 375 } 376 377 // Behavior of __builtin_os_log differs between platforms, so only test on X86 378 #ifdef __x86_64__ 379 380 // CHECK-LABEL: define void @test_builtin_os_log 381 // CHECK: (i8* [[BUF:%.*]], i32 [[I:%.*]], i8* [[DATA:%.*]]) 382 void test_builtin_os_log(void *buf, int i, const char *data) { 383 volatile int len; 384 // CHECK: store i8* [[BUF]], i8** [[BUF_ADDR:%.*]], align 8 385 // CHECK: store i32 [[I]], i32* [[I_ADDR:%.*]], align 4 386 // CHECK: store i8* [[DATA]], i8** [[DATA_ADDR:%.*]], align 8 387 388 // CHECK: store volatile i32 34 389 len = __builtin_os_log_format_buffer_size("%d %{public}s %{private}.16P", i, data, data); 390 391 // CHECK: [[BUF2:%.*]] = load i8*, i8** [[BUF_ADDR]] 392 // CHECK: [[SUMMARY:%.*]] = getelementptr i8, i8* [[BUF2]], i64 0 393 // CHECK: store i8 3, i8* [[SUMMARY]] 394 // CHECK: [[NUM_ARGS:%.*]] = getelementptr i8, i8* [[BUF2]], i64 1 395 // CHECK: store i8 4, i8* [[NUM_ARGS]] 396 // 397 // CHECK: [[ARG1_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 2 398 // CHECK: store i8 0, i8* [[ARG1_DESC]] 399 // CHECK: [[ARG1_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 3 400 // CHECK: store i8 4, i8* [[ARG1_SIZE]] 401 // CHECK: [[ARG1:%.*]] = getelementptr i8, i8* [[BUF2]], i64 4 402 // CHECK: [[ARG1_INT:%.*]] = bitcast i8* [[ARG1]] to i32* 403 // CHECK: [[I2:%.*]] = load i32, i32* [[I_ADDR]] 404 // CHECK: store i32 [[I2]], i32* [[ARG1_INT]] 405 406 // CHECK: [[ARG2_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 8 407 // CHECK: store i8 34, i8* [[ARG2_DESC]] 408 // CHECK: [[ARG2_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 9 409 // CHECK: store i8 8, i8* [[ARG2_SIZE]] 410 // CHECK: [[ARG2:%.*]] = getelementptr i8, i8* [[BUF2]], i64 10 411 // CHECK: [[ARG2_PTR:%.*]] = bitcast i8* [[ARG2]] to i8** 412 // CHECK: [[DATA2:%.*]] = load i8*, i8** [[DATA_ADDR]] 413 // CHECK: store i8* [[DATA2]], i8** [[ARG2_PTR]] 414 415 // CHECK: [[ARG3_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 18 416 // CHECK: store i8 17, i8* [[ARG3_DESC]] 417 // CHECK: [[ARG3_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 19 418 // CHECK: store i8 4, i8* [[ARG3_SIZE]] 419 // CHECK: [[ARG3:%.*]] = getelementptr i8, i8* [[BUF2]], i64 20 420 // CHECK: [[ARG3_INT:%.*]] = bitcast i8* [[ARG3]] to i32* 421 // CHECK: store i32 16, i32* [[ARG3_INT]] 422 423 // CHECK: [[ARG4_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 24 424 // CHECK: store i8 49, i8* [[ARG4_DESC]] 425 // CHECK: [[ARG4_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 25 426 // CHECK: store i8 8, i8* [[ARG4_SIZE]] 427 // CHECK: [[ARG4:%.*]] = getelementptr i8, i8* [[BUF2]], i64 26 428 // CHECK: [[ARG4_PTR:%.*]] = bitcast i8* [[ARG4]] to i8** 429 // CHECK: [[DATA3:%.*]] = load i8*, i8** [[DATA_ADDR]] 430 // CHECK: store i8* [[DATA3]], i8** [[ARG4_PTR]] 431 432 __builtin_os_log_format(buf, "%d %{public}s %{private}.16P", i, data, data); 433 } 434 435 // CHECK-LABEL: define void @test_builtin_os_log_errno 436 // CHECK: (i8* [[BUF:%.*]], i8* [[DATA:%.*]]) 437 void test_builtin_os_log_errno(void *buf, const char *data) { 438 volatile int len; 439 // CHECK: store i8* [[BUF]], i8** [[BUF_ADDR:%.*]], align 8 440 // CHECK: store i8* [[DATA]], i8** [[DATA_ADDR:%.*]], align 8 441 442 // CHECK: store volatile i32 2 443 len = __builtin_os_log_format_buffer_size("%S"); 444 445 // CHECK: [[BUF2:%.*]] = load i8*, i8** [[BUF_ADDR]] 446 // CHECK: [[SUMMARY:%.*]] = getelementptr i8, i8* [[BUF2]], i64 0 447 // CHECK: store i8 2, i8* [[SUMMARY]] 448 // CHECK: [[NUM_ARGS:%.*]] = getelementptr i8, i8* [[BUF2]], i64 1 449 // CHECK: store i8 1, i8* [[NUM_ARGS]] 450 451 // CHECK: [[ARG1_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 2 452 // CHECK: store i8 96, i8* [[ARG1_DESC]] 453 // CHECK: [[ARG1_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 3 454 // CHECK: store i8 0, i8* [[ARG1_SIZE]] 455 // CHECK: [[ARG1:%.*]] = getelementptr i8, i8* [[BUF2]], i64 4 456 // CHECK: [[ARG1_INT:%.*]] = bitcast i8* [[ARG1]] to i32* 457 // CHECK: store i32 0, i32* [[ARG1_INT]] 458 459 __builtin_os_log_format(buf, "%m"); 460 } 461 462 // CHECK-LABEL: define void @test_builtin_os_log_wide 463 // CHECK: (i8* [[BUF:%.*]], i8* [[DATA:%.*]], i32* [[STR:%.*]]) 464 typedef int wchar_t; 465 void test_builtin_os_log_wide(void *buf, const char *data, wchar_t *str) { 466 volatile int len; 467 // CHECK: store i8* [[BUF]], i8** [[BUF_ADDR:%.*]], align 8 468 // CHECK: store i8* [[DATA]], i8** [[DATA_ADDR:%.*]], align 8 469 // CHECK: store i32* [[STR]], i32** [[STR_ADDR:%.*]], 470 471 // CHECK: store volatile i32 12 472 len = __builtin_os_log_format_buffer_size("%S", str); 473 474 // CHECK: [[BUF2:%.*]] = load i8*, i8** [[BUF_ADDR]] 475 // CHECK: [[SUMMARY:%.*]] = getelementptr i8, i8* [[BUF2]], i64 0 476 // CHECK: store i8 2, i8* [[SUMMARY]] 477 // CHECK: [[NUM_ARGS:%.*]] = getelementptr i8, i8* [[BUF2]], i64 1 478 // CHECK: store i8 1, i8* [[NUM_ARGS]] 479 480 // CHECK: [[ARG1_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 2 481 // CHECK: store i8 80, i8* [[ARG1_DESC]] 482 // CHECK: [[ARG1_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 3 483 // CHECK: store i8 8, i8* [[ARG1_SIZE]] 484 // CHECK: [[ARG1:%.*]] = getelementptr i8, i8* [[BUF2]], i64 4 485 // CHECK: [[ARG1_PTR:%.*]] = bitcast i8* [[ARG1]] to i32** 486 // CHECK: [[STR2:%.*]] = load i32*, i32** [[STR_ADDR]] 487 // CHECK: store i32* [[STR2]], i32** [[ARG1_PTR]] 488 489 __builtin_os_log_format(buf, "%S", str); 490 } 491 492 // CHECK-LABEL: define void @test_builtin_os_log_precision_width 493 // CHECK: (i8* [[BUF:%.*]], i8* [[DATA:%.*]], i32 [[PRECISION:%.*]], i32 [[WIDTH:%.*]]) 494 void test_builtin_os_log_precision_width(void *buf, const char *data, 495 int precision, int width) { 496 volatile int len; 497 // CHECK: store i8* [[BUF]], i8** [[BUF_ADDR:%.*]], align 8 498 // CHECK: store i8* [[DATA]], i8** [[DATA_ADDR:%.*]], align 8 499 // CHECK: store i32 [[PRECISION]], i32* [[PRECISION_ADDR:%.*]], align 4 500 // CHECK: store i32 [[WIDTH]], i32* [[WIDTH_ADDR:%.*]], align 4 501 502 // CHECK: store volatile i32 24, 503 len = __builtin_os_log_format_buffer_size("Hello %*.*s World", precision, width, data); 504 505 // CHECK: [[BUF2:%.*]] = load i8*, i8** [[BUF_ADDR]] 506 // CHECK: [[SUMMARY:%.*]] = getelementptr i8, i8* [[BUF2]], i64 0 507 // CHECK: store i8 2, i8* [[SUMMARY]] 508 // CHECK: [[NUM_ARGS:%.*]] = getelementptr i8, i8* [[BUF2]], i64 1 509 // CHECK: store i8 3, i8* [[NUM_ARGS]] 510 511 // CHECK: [[ARG1_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 2 512 // CHECK: store i8 0, i8* [[ARG1_DESC]] 513 // CHECK: [[ARG1_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 3 514 // CHECK: store i8 4, i8* [[ARG1_SIZE]] 515 // CHECK: [[ARG1:%.*]] = getelementptr i8, i8* [[BUF2]], i64 4 516 // CHECK: [[ARG1_INT:%.*]] = bitcast i8* [[ARG1]] to i32* 517 // CHECK: [[ARG1_VAL:%.*]] = load i32, i32* [[PRECISION_ADDR]] 518 // CHECK: store i32 [[ARG1_VAL]], i32* [[ARG1_INT]] 519 520 // CHECK: [[ARG2_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 8 521 // CHECK: store i8 16, i8* [[ARG2_DESC]] 522 // CHECK: [[ARG2_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 9 523 // CHECK: store i8 4, i8* [[ARG2_SIZE]] 524 // CHECK: [[ARG2:%.*]] = getelementptr i8, i8* [[BUF2]], i64 10 525 // CHECK: [[ARG2_INT:%.*]] = bitcast i8* [[ARG2]] to i32* 526 // CHECK: [[ARG2_VAL:%.*]] = load i32, i32* [[WIDTH_ADDR]] 527 // CHECK: store i32 [[ARG2_VAL]], i32* [[ARG2_INT]] 528 529 // CHECK: [[ARG3_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 14 530 // CHECK: store i8 32, i8* [[ARG3_DESC]] 531 // CHECK: [[ARG3_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 15 532 // CHECK: store i8 8, i8* [[ARG3_SIZE]] 533 // CHECK: [[ARG3:%.*]] = getelementptr i8, i8* [[BUF2]], i64 16 534 // CHECK: [[ARG3_PTR:%.*]] = bitcast i8* [[ARG3]] to i8** 535 // CHECK: [[DATA2:%.*]] = load i8*, i8** [[DATA_ADDR]] 536 // CHECK: store i8* [[DATA2]], i8** [[ARG3_PTR]] 537 538 __builtin_os_log_format(buf, "Hello %*.*s World", precision, width, data); 539 } 540 541 // CHECK-LABEL: define void @test_builtin_os_log_invalid 542 // CHECK: (i8* [[BUF:%.*]], i32 [[DATA:%.*]]) 543 void test_builtin_os_log_invalid(void *buf, int data) { 544 volatile int len; 545 // CHECK: store i8* [[BUF]], i8** [[BUF_ADDR:%.*]], align 8 546 // CHECK: store i32 [[DATA]], i32* [[DATA_ADDR:%.*]] 547 548 // CHECK: store volatile i32 8, 549 len = __builtin_os_log_format_buffer_size("invalid specifier %: %d even a trailing one%", data); 550 551 // CHECK: [[BUF2:%.*]] = load i8*, i8** [[BUF_ADDR]] 552 // CHECK: [[SUMMARY:%.*]] = getelementptr i8, i8* [[BUF2]], i64 0 553 // CHECK: store i8 0, i8* [[SUMMARY]] 554 // CHECK: [[NUM_ARGS:%.*]] = getelementptr i8, i8* [[BUF2]], i64 1 555 // CHECK: store i8 1, i8* [[NUM_ARGS]] 556 557 // CHECK: [[ARG1_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 2 558 // CHECK: store i8 0, i8* [[ARG1_DESC]] 559 // CHECK: [[ARG1_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 3 560 // CHECK: store i8 4, i8* [[ARG1_SIZE]] 561 // CHECK: [[ARG1:%.*]] = getelementptr i8, i8* [[BUF2]], i64 4 562 // CHECK: [[ARG1_INT:%.*]] = bitcast i8* [[ARG1]] to i32* 563 // CHECK: [[ARG1_VAL:%.*]] = load i32, i32* [[DATA_ADDR]] 564 // CHECK: store i32 [[ARG1_VAL]], i32* [[ARG1_INT]] 565 566 __builtin_os_log_format(buf, "invalid specifier %: %d even a trailing one%", data); 567 } 568 569 // CHECK-LABEL: define void @test_builtin_os_log_percent 570 // CHECK: (i8* [[BUF:%.*]], i8* [[DATA1:%.*]], i8* [[DATA2:%.*]]) 571 // Check that the %% which does not consume any argument is correctly handled 572 void test_builtin_os_log_percent(void *buf, const char *data1, const char *data2) { 573 volatile int len; 574 // CHECK: store i8* [[BUF]], i8** [[BUF_ADDR:%.*]], align 8 575 // CHECK: store i8* [[DATA1]], i8** [[DATA1_ADDR:%.*]], align 8 576 // CHECK: store i8* [[DATA2]], i8** [[DATA2_ADDR:%.*]], align 8 577 // CHECK: store volatile i32 22 578 len = __builtin_os_log_format_buffer_size("%s %% %s", data1, data2); 579 580 // CHECK: [[BUF2:%.*]] = load i8*, i8** [[BUF_ADDR]] 581 // CHECK: [[SUMMARY:%.*]] = getelementptr i8, i8* [[BUF2]], i64 0 582 // CHECK: store i8 2, i8* [[SUMMARY]] 583 // CHECK: [[NUM_ARGS:%.*]] = getelementptr i8, i8* [[BUF2]], i64 1 584 // CHECK: store i8 2, i8* [[NUM_ARGS]] 585 // 586 // CHECK: [[ARG1_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 2 587 // CHECK: store i8 32, i8* [[ARG1_DESC]] 588 // CHECK: [[ARG1_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 3 589 // CHECK: store i8 8, i8* [[ARG1_SIZE]] 590 // CHECK: [[ARG1:%.*]] = getelementptr i8, i8* [[BUF2]], i64 4 591 // CHECK: [[ARG1_PTR:%.*]] = bitcast i8* [[ARG1]] to i8** 592 // CHECK: [[DATA1:%.*]] = load i8*, i8** [[DATA1_ADDR]] 593 // CHECK: store i8* [[DATA1]], i8** [[ARG1_PTR]] 594 // 595 // CHECK: [[ARG2_DESC:%.*]] = getelementptr i8, i8* [[BUF2]], i64 12 596 // CHECK: store i8 32, i8* [[ARG2_DESC]] 597 // CHECK: [[ARG2_SIZE:%.*]] = getelementptr i8, i8* [[BUF2]], i64 13 598 // CHECK: store i8 8, i8* [[ARG2_SIZE]] 599 // CHECK: [[ARG2:%.*]] = getelementptr i8, i8* [[BUF2]], i64 14 600 // CHECK: [[ARG2_PTR:%.*]] = bitcast i8* [[ARG2]] to i8** 601 // CHECK: [[DATA2:%.*]] = load i8*, i8** [[DATA2_ADDR]] 602 // CHECK: store i8* [[DATA2]], i8** [[ARG2_PTR]] 603 __builtin_os_log_format(buf, "%s %% %s", data1, data2); 604 } 605 606 #endif