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 // CHECK-LABEL: define void @test_conditional_bzero 180 void test_conditional_bzero() { 181 char dst[20]; 182 int _sz = 20, len = 20; 183 return (_sz 184 ? ((_sz >= len) 185 ? __builtin_bzero(dst, len) 186 : foo()) 187 : __builtin_bzero(dst, len)); 188 // CHECK: call void @llvm.memset 189 // CHECK: call void @llvm.memset 190 // CHECK-NOT: phi 191 } 192 193 // CHECK-LABEL: define void @test_float_builtins 194 void test_float_builtins(float F, double D, long double LD) { 195 volatile int res; 196 res = __builtin_isinf(F); 197 // CHECK: call float @llvm.fabs.f32(float 198 // CHECK: fcmp oeq float {{.*}}, 0x7FF0000000000000 199 200 res = __builtin_isinf(D); 201 // CHECK: call double @llvm.fabs.f64(double 202 // CHECK: fcmp oeq double {{.*}}, 0x7FF0000000000000 203 204 res = __builtin_isinf(LD); 205 // CHECK: call x86_fp80 @llvm.fabs.f80(x86_fp80 206 // CHECK: fcmp oeq x86_fp80 {{.*}}, 0xK7FFF8000000000000000 207 208 res = __builtin_isinf_sign(F); 209 // CHECK: %[[ABS:.*]] = call float @llvm.fabs.f32(float %[[ARG:.*]]) 210 // CHECK: %[[ISINF:.*]] = fcmp oeq float %[[ABS]], 0x7FF0000000000000 211 // CHECK: %[[BITCAST:.*]] = bitcast float %[[ARG]] to i32 212 // CHECK: %[[ISNEG:.*]] = icmp slt i32 %[[BITCAST]], 0 213 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1 214 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0 215 216 res = __builtin_isinf_sign(D); 217 // CHECK: %[[ABS:.*]] = call double @llvm.fabs.f64(double %[[ARG:.*]]) 218 // CHECK: %[[ISINF:.*]] = fcmp oeq double %[[ABS]], 0x7FF0000000000000 219 // CHECK: %[[BITCAST:.*]] = bitcast double %[[ARG]] to i64 220 // CHECK: %[[ISNEG:.*]] = icmp slt i64 %[[BITCAST]], 0 221 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1 222 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0 223 224 res = __builtin_isinf_sign(LD); 225 // CHECK: %[[ABS:.*]] = call x86_fp80 @llvm.fabs.f80(x86_fp80 %[[ARG:.*]]) 226 // CHECK: %[[ISINF:.*]] = fcmp oeq x86_fp80 %[[ABS]], 0xK7FFF8000000000000000 227 // CHECK: %[[BITCAST:.*]] = bitcast x86_fp80 %[[ARG]] to i80 228 // CHECK: %[[ISNEG:.*]] = icmp slt i80 %[[BITCAST]], 0 229 // CHECK: %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1 230 // CHECK: select i1 %[[ISINF]], i32 %[[SIGN]], i32 0 231 232 res = __builtin_isfinite(F); 233 // CHECK: call float @llvm.fabs.f32(float 234 // CHECK: fcmp one float {{.*}}, 0x7FF0000000000000 235 236 res = finite(D); 237 // CHECK: call double @llvm.fabs.f64(double 238 // CHECK: fcmp one double {{.*}}, 0x7FF0000000000000 239 240 res = __builtin_isnormal(F); 241 // CHECK: fcmp oeq float 242 // CHECK: call float @llvm.fabs.f32(float 243 // CHECK: fcmp ult float {{.*}}, 0x7FF0000000000000 244 // CHECK: fcmp uge float {{.*}}, 0x3810000000000000 245 // CHECK: and i1 246 // CHECK: and i1 247 } 248 249 // CHECK-LABEL: define void @test_float_builtin_ops 250 void test_float_builtin_ops(float F, double D, long double LD) { 251 volatile float resf; 252 volatile double resd; 253 volatile long double resld; 254 255 resf = __builtin_fmodf(F,F); 256 // CHECK: frem float 257 258 resd = __builtin_fmod(D,D); 259 // CHECK: frem double 260 261 resld = __builtin_fmodl(LD,LD); 262 // CHECK: frem x86_fp80 263 264 resf = __builtin_fabsf(F); 265 resd = __builtin_fabs(D); 266 resld = __builtin_fabsl(LD); 267 // CHECK: call float @llvm.fabs.f32(float 268 // CHECK: call double @llvm.fabs.f64(double 269 // CHECK: call x86_fp80 @llvm.fabs.f80(x86_fp80 270 271 resf = __builtin_canonicalizef(F); 272 resd = __builtin_canonicalize(D); 273 resld = __builtin_canonicalizel(LD); 274 // CHECK: call float @llvm.canonicalize.f32(float 275 // CHECK: call double @llvm.canonicalize.f64(double 276 // CHECK: call x86_fp80 @llvm.canonicalize.f80(x86_fp80 277 278 resf = __builtin_fminf(F, F); 279 // CHECK: call float @llvm.minnum.f32 280 281 resd = __builtin_fmin(D, D); 282 // CHECK: call double @llvm.minnum.f64 283 284 resld = __builtin_fminl(LD, LD); 285 // CHECK: call x86_fp80 @llvm.minnum.f80 286 287 resf = __builtin_fmaxf(F, F); 288 // CHECK: call float @llvm.maxnum.f32 289 290 resd = __builtin_fmax(D, D); 291 // CHECK: call double @llvm.maxnum.f64 292 293 resld = __builtin_fmaxl(LD, LD); 294 // CHECK: call x86_fp80 @llvm.maxnum.f80 295 296 resf = __builtin_fabsf(F); 297 // CHECK: call float @llvm.fabs.f32 298 299 resd = __builtin_fabs(D); 300 // CHECK: call double @llvm.fabs.f64 301 302 resld = __builtin_fabsl(LD); 303 // CHECK: call x86_fp80 @llvm.fabs.f80 304 305 resf = __builtin_copysignf(F, F); 306 // CHECK: call float @llvm.copysign.f32 307 308 resd = __builtin_copysign(D, D); 309 // CHECK: call double @llvm.copysign.f64 310 311 resld = __builtin_copysignl(LD, LD); 312 // CHECK: call x86_fp80 @llvm.copysign.f80 313 314 315 resf = __builtin_ceilf(F); 316 // CHECK: call float @llvm.ceil.f32 317 318 resd = __builtin_ceil(D); 319 // CHECK: call double @llvm.ceil.f64 320 321 resld = __builtin_ceill(LD); 322 // CHECK: call x86_fp80 @llvm.ceil.f80 323 324 resf = __builtin_floorf(F); 325 // CHECK: call float @llvm.floor.f32 326 327 resd = __builtin_floor(D); 328 // CHECK: call double @llvm.floor.f64 329 330 resld = __builtin_floorl(LD); 331 // CHECK: call x86_fp80 @llvm.floor.f80 332 333 resf = __builtin_sqrtf(F); 334 // CHECK: call float @llvm.sqrt.f32( 335 336 resd = __builtin_sqrt(D); 337 // CHECK: call double @llvm.sqrt.f64( 338 339 resld = __builtin_sqrtl(LD); 340 // CHECK: call x86_fp80 @llvm.sqrt.f80 341 342 resf = __builtin_truncf(F); 343 // CHECK: call float @llvm.trunc.f32 344 345 resd = __builtin_trunc(D); 346 // CHECK: call double @llvm.trunc.f64 347 348 resld = __builtin_truncl(LD); 349 // CHECK: call x86_fp80 @llvm.trunc.f80 350 351 resf = __builtin_rintf(F); 352 // CHECK: call float @llvm.rint.f32 353 354 resd = __builtin_rint(D); 355 // CHECK: call double @llvm.rint.f64 356 357 resld = __builtin_rintl(LD); 358 // CHECK: call x86_fp80 @llvm.rint.f80 359 360 resf = __builtin_nearbyintf(F); 361 // CHECK: call float @llvm.nearbyint.f32 362 363 resd = __builtin_nearbyint(D); 364 // CHECK: call double @llvm.nearbyint.f64 365 366 resld = __builtin_nearbyintl(LD); 367 // CHECK: call x86_fp80 @llvm.nearbyint.f80 368 369 resf = __builtin_roundf(F); 370 // CHECK: call float @llvm.round.f32 371 372 resd = __builtin_round(D); 373 // CHECK: call double @llvm.round.f64 374 375 resld = __builtin_roundl(LD); 376 // CHECK: call x86_fp80 @llvm.round.f80 377 378 } 379 380 // __builtin_longjmp isn't supported on all platforms, so only test it on X86. 381 #ifdef __x86_64__ 382 383 // CHECK-LABEL: define void @test_builtin_longjmp 384 void test_builtin_longjmp(void **buffer) { 385 // CHECK: [[BITCAST:%.*]] = bitcast 386 // CHECK-NEXT: call void @llvm.eh.sjlj.longjmp(i8* [[BITCAST]]) 387 __builtin_longjmp(buffer, 1); 388 // CHECK-NEXT: unreachable 389 } 390 391 #endif 392 393 // CHECK-LABEL: define i64 @test_builtin_readcyclecounter 394 long long test_builtin_readcyclecounter() { 395 // CHECK: call i64 @llvm.readcyclecounter() 396 return __builtin_readcyclecounter(); 397 } 398 399 // Behavior of __builtin_os_log differs between platforms, so only test on X86 400 #ifdef __x86_64__ 401 402 // CHECK-LABEL: define void @test_builtin_os_log 403 // CHECK: (i8* %[[BUF:.*]], i32 %[[I:.*]], i8* %[[DATA:.*]]) 404 void test_builtin_os_log(void *buf, int i, const char *data) { 405 volatile int len; 406 // CHECK: %[[BUF_ADDR:.*]] = alloca i8*, align 8 407 // CHECK: %[[I_ADDR:.*]] = alloca i32, align 4 408 // CHECK: %[[DATA_ADDR:.*]] = alloca i8*, align 8 409 // CHECK: %[[LEN:.*]] = alloca i32, align 4 410 // CHECK: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8 411 // CHECK: store i32 %[[I]], i32* %[[I_ADDR]], align 4 412 // CHECK: store i8* %[[DATA]], i8** %[[DATA_ADDR]], align 8 413 414 // CHECK: store volatile i32 34, i32* %[[LEN]] 415 len = __builtin_os_log_format_buffer_size("%d %{public}s %{private}.16P", i, data, data); 416 417 // CHECK: %[[V1:.*]] = load i8*, i8** %[[BUF_ADDR]] 418 // CHECK: %[[V2:.*]] = load i32, i32* %[[I_ADDR]] 419 // CHECK: %[[V3:.*]] = load i8*, i8** %[[DATA_ADDR]] 420 // CHECK: %[[V4:.*]] = ptrtoint i8* %[[V3]] to i64 421 // CHECK: %[[V5:.*]] = load i8*, i8** %[[DATA_ADDR]] 422 // CHECK: %[[V6:.*]] = ptrtoint i8* %[[V5]] to i64 423 // CHECK: call void @__os_log_helper_1_3_4_4_0_8_34_4_17_8_49(i8* %[[V1]], i32 %[[V2]], i64 %[[V4]], i32 16, i64 %[[V6]]) 424 __builtin_os_log_format(buf, "%d %{public}s %{private}.16P", i, data, data); 425 } 426 427 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_3_4_4_0_8_34_4_17_8_49 428 // CHECK: (i8* %[[BUFFER:.*]], i32 %[[ARG0:.*]], i64 %[[ARG1:.*]], i32 %[[ARG2:.*]], i64 %[[ARG3:.*]]) 429 430 // CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8 431 // CHECK: %[[ARG0_ADDR:.*]] = alloca i32, align 4 432 // CHECK: %[[ARG1_ADDR:.*]] = alloca i64, align 8 433 // CHECK: %[[ARG2_ADDR:.*]] = alloca i32, align 4 434 // CHECK: %[[ARG3_ADDR:.*]] = alloca i64, align 8 435 // CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8 436 // CHECK: store i32 %[[ARG0]], i32* %[[ARG0_ADDR]], align 4 437 // CHECK: store i64 %[[ARG1]], i64* %[[ARG1_ADDR]], align 8 438 // CHECK: store i32 %[[ARG2]], i32* %[[ARG2_ADDR]], align 4 439 // CHECK: store i64 %[[ARG3]], i64* %[[ARG3_ADDR]], align 8 440 // CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8 441 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0 442 // CHECK: store i8 3, i8* %[[SUMMARY]], align 1 443 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1 444 // CHECK: store i8 4, i8* %[[NUMARGS]], align 1 445 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2 446 // CHECK: store i8 0, i8* %[[ARGDESCRIPTOR]], align 1 447 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3 448 // CHECK: store i8 4, i8* %[[ARGSIZE]], align 1 449 // CHECK: %[[ARGDATA:.*]] = getelementptr i8, i8* %[[BUF]], i64 4 450 // CHECK: %[[ARGDATACAST:.*]] = bitcast i8* %[[ARGDATA]] to i32* 451 // CHECK: %[[V0:.*]] = load i32, i32* %[[ARG0_ADDR]], align 4 452 // CHECK: store i32 %[[V0]], i32* %[[ARGDATACAST]], align 1 453 // CHECK: %[[ARGDESCRIPTOR1:.*]] = getelementptr i8, i8* %[[BUF]], i64 8 454 // CHECK: store i8 34, i8* %[[ARGDESCRIPTOR1]], align 1 455 // CHECK: %[[ARGSIZE2:.*]] = getelementptr i8, i8* %[[BUF]], i64 9 456 // CHECK: store i8 8, i8* %[[ARGSIZE2]], align 1 457 // CHECK: %[[ARGDATA3:.*]] = getelementptr i8, i8* %[[BUF]], i64 10 458 // CHECK: %[[ARGDATACAST4:.*]] = bitcast i8* %[[ARGDATA3]] to i64* 459 // CHECK: %[[V1:.*]] = load i64, i64* %[[ARG1_ADDR]], align 8 460 // CHECK: store i64 %[[V1]], i64* %[[ARGDATACAST4]], align 1 461 // CHECK: %[[ARGDESCRIPTOR5:.*]] = getelementptr i8, i8* %[[BUF]], i64 18 462 // CHECK: store i8 17, i8* %[[ARGDESCRIPTOR5]], align 1 463 // CHECK: %[[ARGSIZE6:.*]] = getelementptr i8, i8* %[[BUF]], i64 19 464 // CHECK: store i8 4, i8* %[[ARGSIZE6]], align 1 465 // CHECK: %[[ARGDATA7:.*]] = getelementptr i8, i8* %[[BUF]], i64 20 466 // CHECK: %[[ARGDATACAST8:.*]] = bitcast i8* %[[ARGDATA7]] to i32* 467 // CHECK: %[[V2:.*]] = load i32, i32* %[[ARG2_ADDR]], align 4 468 // CHECK: store i32 %[[V2]], i32* %[[ARGDATACAST8]], align 1 469 // CHECK: %[[ARGDESCRIPTOR9:.*]] = getelementptr i8, i8* %[[BUF]], i64 24 470 // CHECK: store i8 49, i8* %[[ARGDESCRIPTOR9]], align 1 471 // CHECK: %[[ARGSIZE10:.*]] = getelementptr i8, i8* %[[BUF]], i64 25 472 // CHECK: store i8 8, i8* %[[ARGSIZE10]], align 1 473 // CHECK: %[[ARGDATA11:.*]] = getelementptr i8, i8* %[[BUF]], i64 26 474 // CHECK: %[[ARGDATACAST12:.*]] = bitcast i8* %[[ARGDATA11]] to i64* 475 // CHECK: %[[V3:.*]] = load i64, i64* %[[ARG3_ADDR]], align 8 476 // CHECK: store i64 %[[V3]], i64* %[[ARGDATACAST12]], align 1 477 478 // CHECK-LABEL: define void @test_builtin_os_log_wide 479 // CHECK: (i8* %[[BUF:.*]], i8* %[[DATA:.*]], i32* %[[STR:.*]]) 480 typedef int wchar_t; 481 void test_builtin_os_log_wide(void *buf, const char *data, wchar_t *str) { 482 volatile int len; 483 484 // CHECK: %[[BUF_ADDR:.*]] = alloca i8*, align 8 485 // CHECK: %[[DATA_ADDR:.*]] = alloca i8*, align 8 486 // CHECK: %[[STR_ADDR:.*]] = alloca i32*, align 8 487 // CHECK: %[[LEN:.*]] = alloca i32, align 4 488 // CHECK: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8 489 // CHECK: store i8* %[[DATA]], i8** %[[DATA_ADDR]], align 8 490 // CHECK: store i32* %[[STR]], i32** %[[STR_ADDR]], align 8 491 492 // CHECK: store volatile i32 12, i32* %[[LEN]], align 4 493 len = __builtin_os_log_format_buffer_size("%S", str); 494 495 // CHECK: %[[V1:.*]] = load i8*, i8** %[[BUF_ADDR]], align 8 496 // CHECK: %[[V2:.*]] = load i32*, i32** %[[STR_ADDR]], align 8 497 // CHECK: %[[V3:.*]] = ptrtoint i32* %[[V2]] to i64 498 // CHECK: call void @__os_log_helper_1_2_1_8_80(i8* %[[V1]], i64 %[[V3]]) 499 500 __builtin_os_log_format(buf, "%S", str); 501 } 502 503 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_1_8_80 504 // CHECK: (i8* %[[BUFFER:.*]], i64 %[[ARG0:.*]]) 505 506 // CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8 507 // CHECK: %[[ARG0_ADDR:.*]] = alloca i64, align 8 508 // CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8 509 // CHECK: store i64 %[[ARG0]], i64* %[[ARG0_ADDR]], align 8 510 // CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8 511 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0 512 // CHECK: store i8 2, i8* %[[SUMMARY]], align 1 513 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1 514 // CHECK: store i8 1, i8* %[[NUMARGS]], align 1 515 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2 516 // CHECK: store i8 80, i8* %[[ARGDESCRIPTOR]], align 1 517 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3 518 // CHECK: store i8 8, i8* %[[ARGSIZE]], align 1 519 // CHECK: %[[ARGDATA:.*]] = getelementptr i8, i8* %[[BUF]], i64 4 520 // CHECK: %[[ARGDATACAST:.*]] = bitcast i8* %[[ARGDATA]] to i64* 521 // CHECK: %[[V0:.*]] = load i64, i64* %[[ARG0_ADDR]], align 8 522 // CHECK: store i64 %[[V0]], i64* %[[ARGDATACAST]], align 1 523 524 // CHECK-LABEL: define void @test_builtin_os_log_precision_width 525 // CHECK: (i8* %[[BUF:.*]], i8* %[[DATA:.*]], i32 %[[PRECISION:.*]], i32 %[[WIDTH:.*]]) 526 void test_builtin_os_log_precision_width(void *buf, const char *data, 527 int precision, int width) { 528 volatile int len; 529 // CHECK: %[[BUF_ADDR:.*]] = alloca i8*, align 8 530 // CHECK: %[[DATA_ADDR:.*]] = alloca i8*, align 8 531 // CHECK: %[[PRECISION_ADDR:.*]] = alloca i32, align 4 532 // CHECK: %[[WIDTH_ADDR:.*]] = alloca i32, align 4 533 // CHECK: %[[LEN:.*]] = alloca i32, align 4 534 // CHECK: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8 535 // CHECK: store i8* %[[DATA]], i8** %[[DATA_ADDR]], align 8 536 // CHECK: store i32 %[[PRECISION]], i32* %[[PRECISION_ADDR]], align 4 537 // CHECK: store i32 %[[WIDTH]], i32* %[[WIDTH_ADDR]], align 4 538 539 // CHECK: store volatile i32 24, i32* %[[LEN]], align 4 540 len = __builtin_os_log_format_buffer_size("Hello %*.*s World", precision, width, data); 541 542 // CHECK: %[[V1:.*]] = load i8*, i8** %[[BUF_ADDR]], align 8 543 // CHECK: %[[V2:.*]] = load i32, i32* %[[PRECISION_ADDR]], align 4 544 // CHECK: %[[V3:.*]] = load i32, i32* %[[WIDTH_ADDR]], align 4 545 // CHECK: %[[V4:.*]] = load i8*, i8** %[[DATA_ADDR]], align 8 546 // CHECK: %[[V5:.*]] = ptrtoint i8* %[[V4]] to i64 547 // CHECK: call void @__os_log_helper_1_2_3_4_0_4_16_8_32(i8* %[[V1]], i32 %[[V2]], i32 %[[V3]], i64 %[[V5]]) 548 __builtin_os_log_format(buf, "Hello %*.*s World", precision, width, data); 549 } 550 551 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_3_4_0_4_16_8_32 552 // CHECK: (i8* %[[BUFFER:.*]], i32 %[[ARG0:.*]], i32 %[[ARG1:.*]], i64 %[[ARG2:.*]]) 553 554 // CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8 555 // CHECK: %[[ARG0_ADDR:.*]] = alloca i32, align 4 556 // CHECK: %[[ARG1_ADDR:.*]] = alloca i32, align 4 557 // CHECK: %[[ARG2_ADDR:.*]] = alloca i64, align 8 558 // CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8 559 // CHECK: store i32 %[[ARG0]], i32* %[[ARG0_ADDR]], align 4 560 // CHECK: store i32 %[[ARG1]], i32* %[[ARG1_ADDR]], align 4 561 // CHECK: store i64 %[[ARG2]], i64* %[[ARG2_ADDR]], align 8 562 // CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8 563 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0 564 // CHECK: store i8 2, i8* %[[SUMMARY]], align 1 565 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1 566 // CHECK: store i8 3, i8* %[[NUMARGS]], align 1 567 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2 568 // CHECK: store i8 0, i8* %[[ARGDESCRIPTOR]], align 1 569 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3 570 // CHECK: store i8 4, i8* %[[ARGSIZE]], align 1 571 // CHECK: %[[ARGDATA:.*]] = getelementptr i8, i8* %[[BUF]], i64 4 572 // CHECK: %[[ARGDATACAST:.*]] = bitcast i8* %[[ARGDATA]] to i32* 573 // CHECK: %[[V0:.*]] = load i32, i32* %[[ARG0_ADDR]], align 4 574 // CHECK: store i32 %[[V0]], i32* %[[ARGDATACAST]], align 1 575 // CHECK: %[[ARGDESCRIPTOR1:.*]] = getelementptr i8, i8* %[[BUF]], i64 8 576 // CHECK: store i8 16, i8* %[[ARGDESCRIPTOR1]], align 1 577 // CHECK: %[[ARGSIZE2:.*]] = getelementptr i8, i8* %[[BUF]], i64 9 578 // CHECK: store i8 4, i8* %[[ARGSIZE2]], align 1 579 // CHECK: %[[ARGDATA3:.*]] = getelementptr i8, i8* %[[BUF]], i64 10 580 // CHECK: %[[ARGDATACAST4:.*]] = bitcast i8* %[[ARGDATA3]] to i32* 581 // CHECK: %[[V1:.*]] = load i32, i32* %[[ARG1_ADDR]], align 4 582 // CHECK: store i32 %[[V1]], i32* %[[ARGDATACAST4]], align 1 583 // CHECK: %[[ARGDESCRIPTOR5:.*]] = getelementptr i8, i8* %[[BUF]], i64 14 584 // CHECK: store i8 32, i8* %[[ARGDESCRIPTOR5]], align 1 585 // CHECK: %[[ARGSIZE6:.*]] = getelementptr i8, i8* %[[BUF]], i64 15 586 // CHECK: store i8 8, i8* %[[ARGSIZE6]], align 1 587 // CHECK: %[[ARGDATA7:.*]] = getelementptr i8, i8* %[[BUF]], i64 16 588 // CHECK: %[[ARGDATACAST8:.*]] = bitcast i8* %[[ARGDATA7]] to i64* 589 // CHECK: %[[V2:.*]] = load i64, i64* %[[ARG2_ADDR]], align 8 590 // CHECK: store i64 %[[V2]], i64* %[[ARGDATACAST8]], align 1 591 592 // CHECK-LABEL: define void @test_builtin_os_log_invalid 593 // CHECK: (i8* %[[BUF:.*]], i32 %[[DATA:.*]]) 594 void test_builtin_os_log_invalid(void *buf, int data) { 595 volatile int len; 596 // CHECK: %[[BUF_ADDR:.*]] = alloca i8*, align 8 597 // CHECK: %[[DATA_ADDR:.*]] = alloca i32, align 4 598 // CHECK: %[[LEN:.*]] = alloca i32, align 4 599 // CHECK: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8 600 // CHECK: store i32 %[[DATA]], i32* %[[DATA_ADDR]], align 4 601 602 // CHECK: store volatile i32 8, i32* %[[LEN]], align 4 603 len = __builtin_os_log_format_buffer_size("invalid specifier %: %d even a trailing one%", data); 604 605 // CHECK: %[[V1:.*]] = load i8*, i8** %[[BUF_ADDR]], align 8 606 // CHECK: %[[V2:.*]] = load i32, i32* %[[DATA_ADDR]], align 4 607 // CHECK: call void @__os_log_helper_1_0_1_4_0(i8* %[[V1]], i32 %[[V2]]) 608 609 __builtin_os_log_format(buf, "invalid specifier %: %d even a trailing one%", data); 610 } 611 612 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_0_1_4_0 613 // CHECK: (i8* %[[BUFFER:.*]], i32 %[[ARG0:.*]]) 614 615 // CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8 616 // CHECK: %[[ARG0_ADDR:.*]] = alloca i32, align 4 617 // CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8 618 // CHECK: store i32 %[[ARG0]], i32* %[[ARG0_ADDR]], align 4 619 // CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8 620 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0 621 // CHECK: store i8 0, i8* %[[SUMMARY]], align 1 622 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1 623 // CHECK: store i8 1, i8* %[[NUMARGS]], align 1 624 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2 625 // CHECK: store i8 0, i8* %[[ARGDESCRIPTOR]], align 1 626 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3 627 // CHECK: store i8 4, i8* %[[ARGSIZE]], align 1 628 // CHECK: %[[ARGDATA:.*]] = getelementptr i8, i8* %[[BUF]], i64 4 629 // CHECK: %[[ARGDATACAST:.*]] = bitcast i8* %[[ARGDATA]] to i32* 630 // CHECK: %[[V0:.*]] = load i32, i32* %[[ARG0_ADDR]], align 4 631 // CHECK: store i32 %[[V0]], i32* %[[ARGDATACAST]], align 1 632 633 // CHECK-LABEL: define void @test_builtin_os_log_percent 634 // CHECK: (i8* %[[BUF:.*]], i8* %[[DATA1:.*]], i8* %[[DATA2:.*]]) 635 // Check that the %% which does not consume any argument is correctly handled 636 void test_builtin_os_log_percent(void *buf, const char *data1, const char *data2) { 637 volatile int len; 638 // CHECK: %[[BUF_ADDR:.*]] = alloca i8*, align 8 639 // CHECK: %[[DATA1_ADDR:.*]] = alloca i8*, align 8 640 // CHECK: %[[DATA2_ADDR:.*]] = alloca i8*, align 8 641 // CHECK: %[[LEN:.*]] = alloca i32, align 4 642 // CHECK: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8 643 // CHECK: store i8* %[[DATA1]], i8** %[[DATA1_ADDR]], align 8 644 // CHECK: store i8* %[[DATA2]], i8** %[[DATA2_ADDR]], align 8 645 // CHECK: store volatile i32 22, i32* %[[LEN]], align 4 646 647 len = __builtin_os_log_format_buffer_size("%s %% %s", data1, data2); 648 649 // CHECK: %[[V1:.*]] = load i8*, i8** %[[BUF_ADDR]], align 8 650 // CHECK: %[[V2:.*]] = load i8*, i8** %[[DATA1_ADDR]], align 8 651 // CHECK: %[[V3:.*]] = ptrtoint i8* %[[V2]] to i64 652 // CHECK: %[[V4:.*]] = load i8*, i8** %[[DATA2_ADDR]], align 8 653 // CHECK: %[[V5:.*]] = ptrtoint i8* %[[V4]] to i64 654 // CHECK: call void @__os_log_helper_1_2_2_8_32_8_32(i8* %[[V1]], i64 %[[V3]], i64 %[[V5]]) 655 656 __builtin_os_log_format(buf, "%s %% %s", data1, data2); 657 } 658 659 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_2_8_32_8_32 660 // CHECK: (i8* %[[BUFFER:.*]], i64 %[[ARG0:.*]], i64 %[[ARG1:.*]]) 661 662 // CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8 663 // CHECK: %[[ARG0_ADDR:.*]] = alloca i64, align 8 664 // CHECK: %[[ARG1_ADDR:.*]] = alloca i64, align 8 665 // CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8 666 // CHECK: store i64 %[[ARG0]], i64* %[[ARG0_ADDR]], align 8 667 // CHECK: store i64 %[[ARG1]], i64* %[[ARG1_ADDR]], align 8 668 // CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8 669 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0 670 // CHECK: store i8 2, i8* %[[SUMMARY]], align 1 671 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1 672 // CHECK: store i8 2, i8* %[[NUMARGS]], align 1 673 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2 674 // CHECK: store i8 32, i8* %[[ARGDESCRIPTOR]], align 1 675 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3 676 // CHECK: store i8 8, i8* %[[ARGSIZE]], align 1 677 // CHECK: %[[ARGDATA:.*]] = getelementptr i8, i8* %[[BUF]], i64 4 678 // CHECK: %[[ARGDATACAST:.*]] = bitcast i8* %[[ARGDATA]] to i64* 679 // CHECK: %[[V0:.*]] = load i64, i64* %[[ARG0_ADDR]], align 8 680 // CHECK: store i64 %[[V0]], i64* %[[ARGDATACAST]], align 1 681 // CHECK: %[[ARGDESCRIPTOR1:.*]] = getelementptr i8, i8* %[[BUF]], i64 12 682 // CHECK: store i8 32, i8* %[[ARGDESCRIPTOR1]], align 1 683 // CHECK: %[[ARGSIZE2:.*]] = getelementptr i8, i8* %[[BUF]], i64 13 684 // CHECK: store i8 8, i8* %[[ARGSIZE2]], align 1 685 // CHECK: %[[ARGDATA3:.*]] = getelementptr i8, i8* %[[BUF]], i64 14 686 // CHECK: %[[ARGDATACAST4:.*]] = bitcast i8* %[[ARGDATA3]] to i64* 687 // CHECK: %[[V1:.*]] = load i64, i64* %[[ARG1_ADDR]], align 8 688 // CHECK: store i64 %[[V1]], i64* %[[ARGDATACAST4]], align 1 689 690 // Check that the following two functions call the same helper function. 691 692 // CHECK-LABEL: define void @test_builtin_os_log_merge_helper0 693 // CHECK: call void @__os_log_helper_1_0_2_4_0_8_0( 694 void test_builtin_os_log_merge_helper0(void *buf, int i, double d) { 695 __builtin_os_log_format(buf, "%d %f", i, d); 696 } 697 698 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_0_2_4_0_8_0( 699 700 // CHECK-LABEL: define void @test_builtin_os_log_merge_helper1 701 // CHECK: call void @__os_log_helper_1_0_2_4_0_8_0( 702 void test_builtin_os_log_merge_helper1(void *buf, unsigned u, long long ll) { 703 __builtin_os_log_format(buf, "%u %lld", u, ll); 704 } 705 706 // Check that this function doesn't write past the end of array 'buf'. 707 708 // CHECK-LABEL: define void @test_builtin_os_log_errno 709 void test_builtin_os_log_errno() { 710 // CHECK: %[[VLA:.*]] = alloca i8, i64 4, align 16 711 // CHECK: call void @__os_log_helper_16_2_1_0_96(i8* %[[VLA]]) 712 713 char buf[__builtin_os_log_format_buffer_size("%m")]; 714 __builtin_os_log_format(buf, "%m"); 715 } 716 717 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_16_2_1_0_96 718 // CHECK: (i8* %[[BUFFER:.*]]) 719 720 // CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8 721 // CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8 722 // CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8 723 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0 724 // CHECK: store i8 2, i8* %[[SUMMARY]], align 16 725 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1 726 // CHECK: store i8 1, i8* %[[NUMARGS]], align 1 727 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2 728 // CHECK: store i8 96, i8* %[[ARGDESCRIPTOR]], align 2 729 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3 730 // CHECK: store i8 0, i8* %[[ARGSIZE]], align 1 731 // CHECK-NEXT: ret void 732 733 // CHECK-LABEL: define void @test_builtin_os_log_long_double 734 // CHECK: (i8* %[[BUF:.*]], x86_fp80 %[[LD:.*]]) 735 void test_builtin_os_log_long_double(void *buf, long double ld) { 736 // CHECK: %[[BUF_ADDR:.*]] = alloca i8*, align 8 737 // CHECK: %[[LD_ADDR:.*]] = alloca x86_fp80, align 16 738 // CHECK: %[[COERCE:.*]] = alloca i128, align 16 739 // CHECK: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8 740 // CHECK: store x86_fp80 %[[LD]], x86_fp80* %[[LD_ADDR]], align 16 741 // CHECK: %[[V0:.*]] = load i8*, i8** %[[BUF_ADDR]], align 8 742 // CHECK: %[[V1:.*]] = load x86_fp80, x86_fp80* %[[LD_ADDR]], align 16 743 // CHECK: %[[V2:.*]] = bitcast x86_fp80 %[[V1]] to i80 744 // CHECK: %[[V3:.*]] = zext i80 %[[V2]] to i128 745 // CHECK: store i128 %[[V3]], i128* %[[COERCE]], align 16 746 // CHECK: %[[V4:.*]] = bitcast i128* %[[COERCE]] to { i64, i64 }* 747 // CHECK: %[[V5:.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[V4]], i32 0, i32 0 748 // CHECK: %[[V6:.*]] = load i64, i64* %[[V5]], align 16 749 // CHECK: %[[V7:.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[V4]], i32 0, i32 1 750 // CHECK: %[[V8:.*]] = load i64, i64* %[[V7]], align 8 751 // CHECK: call void @__os_log_helper_1_0_1_16_0(i8* %[[V0]], i64 %[[V6]], i64 %[[V8]]) 752 753 __builtin_os_log_format(buf, "%Lf", ld); 754 } 755 756 // CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_0_1_16_0 757 // CHECK: (i8* %[[BUFFER:.*]], i64 %[[ARG0_COERCE0:.*]], i64 %[[ARG0_COERCE1:.*]]) 758 759 // CHECK: %[[ARG0:.*]] = alloca i128, align 16 760 // CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8 761 // CHECK: %[[ARG0_ADDR:.*]] = alloca i128, align 16 762 // CHECK: %[[V0:.*]] = bitcast i128* %[[ARG0]] to { i64, i64 }* 763 // CHECK: %[[V1:.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[V0]], i32 0, i32 0 764 // CHECK: store i64 %[[ARG0_COERCE0]], i64* %[[V1]], align 16 765 // CHECK: %[[V2:.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[V0]], i32 0, i32 1 766 // CHECK: store i64 %[[ARG0_COERCE1]], i64* %[[V2]], align 8 767 // CHECK: %[[ARG01:.*]] = load i128, i128* %[[ARG0]], align 16 768 // CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8 769 // CHECK: store i128 %[[ARG01]], i128* %[[ARG0_ADDR]], align 16 770 // CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8 771 // CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0 772 // CHECK: store i8 0, i8* %[[SUMMARY]], align 1 773 // CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1 774 // CHECK: store i8 1, i8* %[[NUMARGS]], align 1 775 // CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2 776 // CHECK: store i8 0, i8* %[[ARGDESCRIPTOR]], align 1 777 // CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3 778 // CHECK: store i8 16, i8* %[[ARGSIZE]], align 1 779 // CHECK: %[[ARGDATA:.*]] = getelementptr i8, i8* %[[BUF]], i64 4 780 // CHECK: %[[ARGDATACAST:.*]] = bitcast i8* %[[ARGDATA]] to i128* 781 // CHECK: %[[V3:.*]] = load i128, i128* %[[ARG0_ADDR]], align 16 782 // CHECK: store i128 %[[V3]], i128* %[[ARGDATACAST]], align 1 783 784 #endif 785