Clang Project

clang_source_code/test/CodeGen/builtins.c
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
5int printf(const char *, ...);
6
7void p(char *str, int x) {
8  printf("%s: %d\n", str, x);
9}
10void q(char *str, double x) {
11  printf("%s: %f\n", str, x);
12}
13void r(char *str, void *ptr) {
14  printf("%s: %p\n", str, ptr);
15}
16
17int random(void);
18
19int 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  R(launder, (&N));
136
137  return 0;
138}
139
140
141
142void foo() {
143 __builtin_strcat(0, 0);
144}
145
146// CHECK-LABEL: define void @bar(
147void bar() {
148  float f;
149  double d;
150  long double ld;
151
152  // LLVM's hex representation of float constants is really unfortunate;
153  // basically it does a float-to-double "conversion" and then prints the
154  // hex form of that.  That gives us weird artifacts like exponents
155  // that aren't numerically similar to the original exponent and
156  // significand bit-patterns that are offset by three bits (because
157  // the exponent was expanded from 8 bits to 11).
158  //
159  // 0xAE98 == 1010111010011000
160  // 0x15D3 == 1010111010011
161
162  f = __builtin_huge_valf();     // CHECK: float    0x7FF0000000000000
163  d = __builtin_huge_val();      // CHECK: double   0x7FF0000000000000
164  ld = __builtin_huge_vall();    // CHECK: x86_fp80 0xK7FFF8000000000000000
165  f = __builtin_nanf("");        // CHECK: float    0x7FF8000000000000
166  d = __builtin_nan("");         // CHECK: double   0x7FF8000000000000
167  ld = __builtin_nanl("");       // CHECK: x86_fp80 0xK7FFFC000000000000000
168  f = __builtin_nanf("0xAE98");  // CHECK: float    0x7FF815D300000000
169  d = __builtin_nan("0xAE98");   // CHECK: double   0x7FF800000000AE98
170  ld = __builtin_nanl("0xAE98"); // CHECK: x86_fp80 0xK7FFFC00000000000AE98
171  f = __builtin_nansf("");       // CHECK: float    0x7FF4000000000000
172  d = __builtin_nans("");        // CHECK: double   0x7FF4000000000000
173  ld = __builtin_nansl("");      // CHECK: x86_fp80 0xK7FFFA000000000000000
174  f = __builtin_nansf("0xAE98"); // CHECK: float    0x7FF015D300000000
175  d = __builtin_nans("0xAE98");  // CHECK: double   0x7FF000000000AE98
176  ld = __builtin_nansl("0xAE98");// CHECK: x86_fp80 0xK7FFF800000000000AE98
177
178}
179// CHECK: }
180
181// CHECK-LABEL: define void @test_conditional_bzero
182void test_conditional_bzero() {
183  char dst[20];
184  int _sz = 20, len = 20;
185  return (_sz
186          ? ((_sz >= len)
187              ? __builtin_bzero(dst, len)
188              : foo())
189          : __builtin_bzero(dst, len));
190  // CHECK: call void @llvm.memset
191  // CHECK: call void @llvm.memset
192  // CHECK-NOT: phi
193}
194
195// CHECK-LABEL: define void @test_float_builtins
196void test_float_builtins(float F, double D, long double LD) {
197  volatile int res;
198  res = __builtin_isinf(F);
199  // CHECK:  call float @llvm.fabs.f32(float
200  // CHECK:  fcmp oeq float {{.*}}, 0x7FF0000000000000
201
202  res = __builtin_isinf(D);
203  // CHECK:  call double @llvm.fabs.f64(double
204  // CHECK:  fcmp oeq double {{.*}}, 0x7FF0000000000000
205
206  res = __builtin_isinf(LD);
207  // CHECK:  call x86_fp80 @llvm.fabs.f80(x86_fp80
208  // CHECK:  fcmp oeq x86_fp80 {{.*}}, 0xK7FFF8000000000000000
209
210  res = __builtin_isinf_sign(F);
211  // CHECK:  %[[ABS:.*]] = call float @llvm.fabs.f32(float %[[ARG:.*]])
212  // CHECK:  %[[ISINF:.*]] = fcmp oeq float %[[ABS]], 0x7FF0000000000000
213  // CHECK:  %[[BITCAST:.*]] = bitcast float %[[ARG]] to i32
214  // CHECK:  %[[ISNEG:.*]] = icmp slt i32 %[[BITCAST]], 0
215  // CHECK:  %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1
216  // CHECK:  select i1 %[[ISINF]], i32 %[[SIGN]], i32 0
217
218  res = __builtin_isinf_sign(D);
219  // CHECK:  %[[ABS:.*]] = call double @llvm.fabs.f64(double %[[ARG:.*]])
220  // CHECK:  %[[ISINF:.*]] = fcmp oeq double %[[ABS]], 0x7FF0000000000000
221  // CHECK:  %[[BITCAST:.*]] = bitcast double %[[ARG]] to i64
222  // CHECK:  %[[ISNEG:.*]] = icmp slt i64 %[[BITCAST]], 0
223  // CHECK:  %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1
224  // CHECK:  select i1 %[[ISINF]], i32 %[[SIGN]], i32 0
225
226  res = __builtin_isinf_sign(LD);
227  // CHECK:  %[[ABS:.*]] = call x86_fp80 @llvm.fabs.f80(x86_fp80 %[[ARG:.*]])
228  // CHECK:  %[[ISINF:.*]] = fcmp oeq x86_fp80 %[[ABS]], 0xK7FFF8000000000000000
229  // CHECK:  %[[BITCAST:.*]] = bitcast x86_fp80 %[[ARG]] to i80
230  // CHECK:  %[[ISNEG:.*]] = icmp slt i80 %[[BITCAST]], 0
231  // CHECK:  %[[SIGN:.*]] = select i1 %[[ISNEG]], i32 -1, i32 1
232  // CHECK:  select i1 %[[ISINF]], i32 %[[SIGN]], i32 0
233
234  res = __builtin_isfinite(F);
235  // CHECK: call float @llvm.fabs.f32(float
236  // CHECK: fcmp one float {{.*}}, 0x7FF0000000000000
237
238  res = finite(D);
239  // CHECK: call double @llvm.fabs.f64(double
240  // CHECK: fcmp one double {{.*}}, 0x7FF0000000000000
241
242  res = __builtin_isnormal(F);
243  // CHECK: fcmp oeq float
244  // CHECK: call float @llvm.fabs.f32(float
245  // CHECK: fcmp ult float {{.*}}, 0x7FF0000000000000
246  // CHECK: fcmp uge float {{.*}}, 0x3810000000000000
247  // CHECK: and i1
248  // CHECK: and i1
249
250  res = __builtin_flt_rounds();
251  // CHECK: call i32 @llvm.flt.rounds(
252}
253
254// CHECK-LABEL: define void @test_float_builtin_ops
255void test_float_builtin_ops(float F, double D, long double LD) {
256  volatile float resf;
257  volatile double resd;
258  volatile long double resld;
259
260  resf = __builtin_fmodf(F,F);
261  // CHECK: frem float
262
263  resd = __builtin_fmod(D,D);
264  // CHECK: frem double
265
266  resld = __builtin_fmodl(LD,LD);
267  // CHECK: frem x86_fp80
268
269  resf = __builtin_fabsf(F);
270  resd = __builtin_fabs(D);
271  resld = __builtin_fabsl(LD);
272  // CHECK: call float @llvm.fabs.f32(float
273  // CHECK: call double @llvm.fabs.f64(double
274  // CHECK: call x86_fp80 @llvm.fabs.f80(x86_fp80
275
276  resf = __builtin_canonicalizef(F);
277  resd = __builtin_canonicalize(D);
278  resld = __builtin_canonicalizel(LD);
279  // CHECK: call float @llvm.canonicalize.f32(float
280  // CHECK: call double @llvm.canonicalize.f64(double
281  // CHECK: call x86_fp80 @llvm.canonicalize.f80(x86_fp80
282
283  resf = __builtin_fminf(F, F);
284  // CHECK: call float @llvm.minnum.f32
285
286  resd = __builtin_fmin(D, D);
287  // CHECK: call double @llvm.minnum.f64
288
289  resld = __builtin_fminl(LD, LD);
290  // CHECK: call x86_fp80 @llvm.minnum.f80
291
292  resf = __builtin_fmaxf(F, F);
293  // CHECK: call float @llvm.maxnum.f32
294
295  resd = __builtin_fmax(D, D);
296  // CHECK: call double @llvm.maxnum.f64
297
298  resld = __builtin_fmaxl(LD, LD);
299  // CHECK: call x86_fp80 @llvm.maxnum.f80
300
301  resf = __builtin_fabsf(F);
302  // CHECK: call float @llvm.fabs.f32
303
304  resd = __builtin_fabs(D);
305  // CHECK: call double @llvm.fabs.f64
306
307  resld = __builtin_fabsl(LD);
308  // CHECK: call x86_fp80 @llvm.fabs.f80
309
310  resf = __builtin_copysignf(F, F);
311  // CHECK: call float @llvm.copysign.f32
312
313  resd = __builtin_copysign(D, D);
314  // CHECK: call double @llvm.copysign.f64
315
316  resld = __builtin_copysignl(LD, LD);
317  // CHECK: call x86_fp80 @llvm.copysign.f80
318
319
320  resf = __builtin_ceilf(F);
321  // CHECK: call float @llvm.ceil.f32
322
323  resd = __builtin_ceil(D);
324  // CHECK: call double @llvm.ceil.f64
325
326  resld = __builtin_ceill(LD);
327  // CHECK: call x86_fp80 @llvm.ceil.f80
328
329  resf = __builtin_floorf(F);
330  // CHECK: call float @llvm.floor.f32
331
332  resd = __builtin_floor(D);
333  // CHECK: call double @llvm.floor.f64
334
335  resld = __builtin_floorl(LD);
336  // CHECK: call x86_fp80 @llvm.floor.f80
337
338  resf = __builtin_sqrtf(F);
339  // CHECK: call float @llvm.sqrt.f32(
340
341  resd = __builtin_sqrt(D);
342  // CHECK: call double @llvm.sqrt.f64(
343
344  resld = __builtin_sqrtl(LD);
345  // CHECK: call x86_fp80 @llvm.sqrt.f80
346
347  resf = __builtin_truncf(F);
348  // CHECK: call float @llvm.trunc.f32
349
350  resd = __builtin_trunc(D);
351  // CHECK: call double @llvm.trunc.f64
352
353  resld = __builtin_truncl(LD);
354  // CHECK: call x86_fp80 @llvm.trunc.f80
355
356  resf = __builtin_rintf(F);
357  // CHECK: call float @llvm.rint.f32
358
359  resd = __builtin_rint(D);
360  // CHECK: call double @llvm.rint.f64
361
362  resld = __builtin_rintl(LD);
363  // CHECK: call x86_fp80 @llvm.rint.f80
364
365  resf = __builtin_nearbyintf(F);
366  // CHECK: call float @llvm.nearbyint.f32
367
368  resd = __builtin_nearbyint(D);
369  // CHECK: call double @llvm.nearbyint.f64
370
371  resld = __builtin_nearbyintl(LD);
372  // CHECK: call x86_fp80 @llvm.nearbyint.f80
373
374  resf = __builtin_roundf(F);
375  // CHECK: call float @llvm.round.f32
376
377  resd = __builtin_round(D);
378  // CHECK: call double @llvm.round.f64
379
380  resld = __builtin_roundl(LD);
381  // CHECK: call x86_fp80 @llvm.round.f80
382
383}
384
385// __builtin_longjmp isn't supported on all platforms, so only test it on X86.
386#ifdef __x86_64__
387
388// CHECK-LABEL: define void @test_builtin_longjmp
389void test_builtin_longjmp(void **buffer) {
390  // CHECK: [[BITCAST:%.*]] = bitcast
391  // CHECK-NEXT: call void @llvm.eh.sjlj.longjmp(i8* [[BITCAST]])
392  __builtin_longjmp(buffer, 1);
393  // CHECK-NEXT: unreachable
394}
395
396#endif
397
398// CHECK-LABEL: define i64 @test_builtin_readcyclecounter
399long long test_builtin_readcyclecounter() {
400  // CHECK: call i64 @llvm.readcyclecounter()
401  return __builtin_readcyclecounter();
402}
403
404/// __builtin_launder should be a NOP in C since there are no vtables.
405// CHECK-LABEL: define void @test_builtin_launder
406void test_builtin_launder(int *p) {
407  // CHECK: [[TMP:%.*]] = load i32*,
408  // CHECK-NOT: @llvm.launder
409  // CHECK: store i32* [[TMP]],
410  int *d = __builtin_launder(p);
411}
412
413// Behavior of __builtin_os_log differs between platforms, so only test on X86
414#ifdef __x86_64__
415
416// CHECK-LABEL: define void @test_builtin_os_log
417// CHECK: (i8* %[[BUF:.*]], i32 %[[I:.*]], i8* %[[DATA:.*]])
418void test_builtin_os_log(void *buf, int i, const char *data) {
419  volatile int len;
420  // CHECK: %[[BUF_ADDR:.*]] = alloca i8*, align 8
421  // CHECK: %[[I_ADDR:.*]] = alloca i32, align 4
422  // CHECK: %[[DATA_ADDR:.*]] = alloca i8*, align 8
423  // CHECK: %[[LEN:.*]] = alloca i32, align 4
424  // CHECK: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8
425  // CHECK: store i32 %[[I]], i32* %[[I_ADDR]], align 4
426  // CHECK: store i8* %[[DATA]], i8** %[[DATA_ADDR]], align 8
427
428  // CHECK: store volatile i32 34, i32* %[[LEN]]
429  len = __builtin_os_log_format_buffer_size("%d %{public}s %{private}.16P", i, data, data);
430
431  // CHECK: %[[V1:.*]] = load i8*, i8** %[[BUF_ADDR]]
432  // CHECK: %[[V2:.*]] = load i32, i32* %[[I_ADDR]]
433  // CHECK: %[[V3:.*]] = load i8*, i8** %[[DATA_ADDR]]
434  // CHECK: %[[V4:.*]] = ptrtoint i8* %[[V3]] to i64
435  // CHECK: %[[V5:.*]] = load i8*, i8** %[[DATA_ADDR]]
436  // CHECK: %[[V6:.*]] = ptrtoint i8* %[[V5]] to i64
437  // 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]])
438  __builtin_os_log_format(buf, "%d %{public}s %{private}.16P", i, data, data);
439
440  // privacy annotations aren't recognized when they are preceded or followed
441  // by non-whitespace characters.
442
443  // CHECK: call void @__os_log_helper_1_2_1_8_32(
444  __builtin_os_log_format(buf, "%{xyz public}s", data);
445
446  // CHECK: call void @__os_log_helper_1_2_1_8_32(
447  __builtin_os_log_format(buf, "%{ public xyz}s", data);
448
449  // CHECK: call void @__os_log_helper_1_2_1_8_32(
450  __builtin_os_log_format(buf, "%{ public1}s", data);
451
452  // Privacy annotations do not have to be in the first comma-delimited string.
453
454  // CHECK: call void @__os_log_helper_1_2_1_8_34(
455  __builtin_os_log_format(buf, "%{ xyz, public }s", "abc");
456
457  // CHECK: call void @__os_log_helper_1_3_1_8_33(
458  __builtin_os_log_format(buf, "%{ xyz, private }s", "abc");
459
460  // CHECK: call void @__os_log_helper_1_3_1_8_37(
461  __builtin_os_log_format(buf, "%{ xyz, sensitive }s", "abc");
462
463  // The strictest privacy annotation in the string wins.
464
465  // CHECK: call void @__os_log_helper_1_3_1_8_33(
466  __builtin_os_log_format(buf, "%{ private, public, private, public}s", "abc");
467
468  // CHECK: call void @__os_log_helper_1_3_1_8_37(
469  __builtin_os_log_format(buf, "%{ private, sensitive, private, public}s",
470                          "abc");
471
472  // CHECK: store volatile i32 22, i32* %[[LEN]], align 4
473  len = __builtin_os_log_format_buffer_size("%{mask.xyz}s", "abc");
474
475  // CHECK: call void @__os_log_helper_1_2_2_8_112_8_34(i8* {{.*}}, i64 8026488
476  __builtin_os_log_format(buf, "%{mask.xyz, public}s", "abc");
477
478  // CHECK: call void @__os_log_helper_1_3_2_8_112_4_1(i8* {{.*}}, i64 8026488
479  __builtin_os_log_format(buf, "%{ mask.xyz, private }d", 11);
480
481  // Mask type is silently ignored.
482  // CHECK: call void @__os_log_helper_1_2_1_8_32(
483  __builtin_os_log_format(buf, "%{ mask. xyz }s", "abc");
484
485  // CHECK: call void @__os_log_helper_1_2_1_8_32(
486  __builtin_os_log_format(buf, "%{ mask.xy z }s", "abc");
487}
488
489// CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_3_4_4_0_8_34_4_17_8_49
490// CHECK: (i8* %[[BUFFER:.*]], i32 %[[ARG0:.*]], i64 %[[ARG1:.*]], i32 %[[ARG2:.*]], i64 %[[ARG3:.*]])
491
492// CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8
493// CHECK: %[[ARG0_ADDR:.*]] = alloca i32, align 4
494// CHECK: %[[ARG1_ADDR:.*]] = alloca i64, align 8
495// CHECK: %[[ARG2_ADDR:.*]] = alloca i32, align 4
496// CHECK: %[[ARG3_ADDR:.*]] = alloca i64, align 8
497// CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8
498// CHECK: store i32 %[[ARG0]], i32* %[[ARG0_ADDR]], align 4
499// CHECK: store i64 %[[ARG1]], i64* %[[ARG1_ADDR]], align 8
500// CHECK: store i32 %[[ARG2]], i32* %[[ARG2_ADDR]], align 4
501// CHECK: store i64 %[[ARG3]], i64* %[[ARG3_ADDR]], align 8
502// CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8
503// CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0
504// CHECK: store i8 3, i8* %[[SUMMARY]], align 1
505// CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1
506// CHECK: store i8 4, i8* %[[NUMARGS]], align 1
507// CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2
508// CHECK: store i8 0, i8* %[[ARGDESCRIPTOR]], align 1
509// CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3
510// CHECK: store i8 4, i8* %[[ARGSIZE]], align 1
511// CHECK: %[[ARGDATA:.*]] = getelementptr i8, i8* %[[BUF]], i64 4
512// CHECK: %[[ARGDATACAST:.*]] = bitcast i8* %[[ARGDATA]] to i32*
513// CHECK: %[[V0:.*]] = load i32, i32* %[[ARG0_ADDR]], align 4
514// CHECK: store i32 %[[V0]], i32* %[[ARGDATACAST]], align 1
515// CHECK: %[[ARGDESCRIPTOR1:.*]] = getelementptr i8, i8* %[[BUF]], i64 8
516// CHECK: store i8 34, i8* %[[ARGDESCRIPTOR1]], align 1
517// CHECK: %[[ARGSIZE2:.*]] = getelementptr i8, i8* %[[BUF]], i64 9
518// CHECK: store i8 8, i8* %[[ARGSIZE2]], align 1
519// CHECK: %[[ARGDATA3:.*]] = getelementptr i8, i8* %[[BUF]], i64 10
520// CHECK: %[[ARGDATACAST4:.*]] = bitcast i8* %[[ARGDATA3]] to i64*
521// CHECK: %[[V1:.*]] = load i64, i64* %[[ARG1_ADDR]], align 8
522// CHECK: store i64 %[[V1]], i64* %[[ARGDATACAST4]], align 1
523// CHECK: %[[ARGDESCRIPTOR5:.*]] = getelementptr i8, i8* %[[BUF]], i64 18
524// CHECK: store i8 17, i8* %[[ARGDESCRIPTOR5]], align 1
525// CHECK: %[[ARGSIZE6:.*]] = getelementptr i8, i8* %[[BUF]], i64 19
526// CHECK: store i8 4, i8* %[[ARGSIZE6]], align 1
527// CHECK: %[[ARGDATA7:.*]] = getelementptr i8, i8* %[[BUF]], i64 20
528// CHECK: %[[ARGDATACAST8:.*]] = bitcast i8* %[[ARGDATA7]] to i32*
529// CHECK: %[[V2:.*]] = load i32, i32* %[[ARG2_ADDR]], align 4
530// CHECK: store i32 %[[V2]], i32* %[[ARGDATACAST8]], align 1
531// CHECK: %[[ARGDESCRIPTOR9:.*]] = getelementptr i8, i8* %[[BUF]], i64 24
532// CHECK: store i8 49, i8* %[[ARGDESCRIPTOR9]], align 1
533// CHECK: %[[ARGSIZE10:.*]] = getelementptr i8, i8* %[[BUF]], i64 25
534// CHECK: store i8 8, i8* %[[ARGSIZE10]], align 1
535// CHECK: %[[ARGDATA11:.*]] = getelementptr i8, i8* %[[BUF]], i64 26
536// CHECK: %[[ARGDATACAST12:.*]] = bitcast i8* %[[ARGDATA11]] to i64*
537// CHECK: %[[V3:.*]] = load i64, i64* %[[ARG3_ADDR]], align 8
538// CHECK: store i64 %[[V3]], i64* %[[ARGDATACAST12]], align 1
539
540// CHECK-LABEL: define void @test_builtin_os_log_wide
541// CHECK: (i8* %[[BUF:.*]], i8* %[[DATA:.*]], i32* %[[STR:.*]])
542typedef int wchar_t;
543void test_builtin_os_log_wide(void *buf, const char *data, wchar_t *str) {
544  volatile int len;
545
546  // CHECK: %[[BUF_ADDR:.*]] = alloca i8*, align 8
547  // CHECK: %[[DATA_ADDR:.*]] = alloca i8*, align 8
548  // CHECK: %[[STR_ADDR:.*]] = alloca i32*, align 8
549  // CHECK: %[[LEN:.*]] = alloca i32, align 4
550  // CHECK: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8
551  // CHECK: store i8* %[[DATA]], i8** %[[DATA_ADDR]], align 8
552  // CHECK: store i32* %[[STR]], i32** %[[STR_ADDR]], align 8
553
554  // CHECK: store volatile i32 12, i32* %[[LEN]], align 4
555  len = __builtin_os_log_format_buffer_size("%S", str);
556
557  // CHECK: %[[V1:.*]] = load i8*, i8** %[[BUF_ADDR]], align 8
558  // CHECK: %[[V2:.*]] = load i32*, i32** %[[STR_ADDR]], align 8
559  // CHECK: %[[V3:.*]] = ptrtoint i32* %[[V2]] to i64
560  // CHECK: call void @__os_log_helper_1_2_1_8_80(i8* %[[V1]], i64 %[[V3]])
561
562  __builtin_os_log_format(buf, "%S", str);
563}
564
565// CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_1_8_80
566// CHECK: (i8* %[[BUFFER:.*]], i64 %[[ARG0:.*]])
567
568// CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8
569// CHECK: %[[ARG0_ADDR:.*]] = alloca i64, align 8
570// CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8
571// CHECK: store i64 %[[ARG0]], i64* %[[ARG0_ADDR]], align 8
572// CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8
573// CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0
574// CHECK: store i8 2, i8* %[[SUMMARY]], align 1
575// CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1
576// CHECK: store i8 1, i8* %[[NUMARGS]], align 1
577// CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2
578// CHECK: store i8 80, i8* %[[ARGDESCRIPTOR]], align 1
579// CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3
580// CHECK: store i8 8, i8* %[[ARGSIZE]], align 1
581// CHECK: %[[ARGDATA:.*]] = getelementptr i8, i8* %[[BUF]], i64 4
582// CHECK: %[[ARGDATACAST:.*]] = bitcast i8* %[[ARGDATA]] to i64*
583// CHECK: %[[V0:.*]] = load i64, i64* %[[ARG0_ADDR]], align 8
584// CHECK: store i64 %[[V0]], i64* %[[ARGDATACAST]], align 1
585
586// CHECK-LABEL: define void @test_builtin_os_log_precision_width
587// CHECK: (i8* %[[BUF:.*]], i8* %[[DATA:.*]], i32 %[[PRECISION:.*]], i32 %[[WIDTH:.*]])
588void test_builtin_os_log_precision_width(void *buf, const char *data,
589                                         int precision, int width) {
590  volatile int len;
591  // CHECK: %[[BUF_ADDR:.*]] = alloca i8*, align 8
592  // CHECK: %[[DATA_ADDR:.*]] = alloca i8*, align 8
593  // CHECK: %[[PRECISION_ADDR:.*]] = alloca i32, align 4
594  // CHECK: %[[WIDTH_ADDR:.*]] = alloca i32, align 4
595  // CHECK: %[[LEN:.*]] = alloca i32, align 4
596  // CHECK: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8
597  // CHECK: store i8* %[[DATA]], i8** %[[DATA_ADDR]], align 8
598  // CHECK: store i32 %[[PRECISION]], i32* %[[PRECISION_ADDR]], align 4
599  // CHECK: store i32 %[[WIDTH]], i32* %[[WIDTH_ADDR]], align 4
600
601  // CHECK: store volatile i32 24, i32* %[[LEN]], align 4
602  len = __builtin_os_log_format_buffer_size("Hello %*.*s World", precision, width, data);
603
604  // CHECK: %[[V1:.*]] = load i8*, i8** %[[BUF_ADDR]], align 8
605  // CHECK: %[[V2:.*]] = load i32, i32* %[[PRECISION_ADDR]], align 4
606  // CHECK: %[[V3:.*]] = load i32, i32* %[[WIDTH_ADDR]], align 4
607  // CHECK: %[[V4:.*]] = load i8*, i8** %[[DATA_ADDR]], align 8
608  // CHECK: %[[V5:.*]] = ptrtoint i8* %[[V4]] to i64
609  // CHECK: call void @__os_log_helper_1_2_3_4_0_4_16_8_32(i8* %[[V1]], i32 %[[V2]], i32 %[[V3]], i64 %[[V5]])
610  __builtin_os_log_format(buf, "Hello %*.*s World", precision, width, data);
611}
612
613// CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_3_4_0_4_16_8_32
614// CHECK: (i8* %[[BUFFER:.*]], i32 %[[ARG0:.*]], i32 %[[ARG1:.*]], i64 %[[ARG2:.*]])
615
616// CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8
617// CHECK: %[[ARG0_ADDR:.*]] = alloca i32, align 4
618// CHECK: %[[ARG1_ADDR:.*]] = alloca i32, align 4
619// CHECK: %[[ARG2_ADDR:.*]] = alloca i64, align 8
620// CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8
621// CHECK: store i32 %[[ARG0]], i32* %[[ARG0_ADDR]], align 4
622// CHECK: store i32 %[[ARG1]], i32* %[[ARG1_ADDR]], align 4
623// CHECK: store i64 %[[ARG2]], i64* %[[ARG2_ADDR]], align 8
624// CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8
625// CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0
626// CHECK: store i8 2, i8* %[[SUMMARY]], align 1
627// CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1
628// CHECK: store i8 3, i8* %[[NUMARGS]], align 1
629// CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2
630// CHECK: store i8 0, i8* %[[ARGDESCRIPTOR]], align 1
631// CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3
632// CHECK: store i8 4, i8* %[[ARGSIZE]], align 1
633// CHECK: %[[ARGDATA:.*]] = getelementptr i8, i8* %[[BUF]], i64 4
634// CHECK: %[[ARGDATACAST:.*]] = bitcast i8* %[[ARGDATA]] to i32*
635// CHECK: %[[V0:.*]] = load i32, i32* %[[ARG0_ADDR]], align 4
636// CHECK: store i32 %[[V0]], i32* %[[ARGDATACAST]], align 1
637// CHECK: %[[ARGDESCRIPTOR1:.*]] = getelementptr i8, i8* %[[BUF]], i64 8
638// CHECK: store i8 16, i8* %[[ARGDESCRIPTOR1]], align 1
639// CHECK: %[[ARGSIZE2:.*]] = getelementptr i8, i8* %[[BUF]], i64 9
640// CHECK: store i8 4, i8* %[[ARGSIZE2]], align 1
641// CHECK: %[[ARGDATA3:.*]] = getelementptr i8, i8* %[[BUF]], i64 10
642// CHECK: %[[ARGDATACAST4:.*]] = bitcast i8* %[[ARGDATA3]] to i32*
643// CHECK: %[[V1:.*]] = load i32, i32* %[[ARG1_ADDR]], align 4
644// CHECK: store i32 %[[V1]], i32* %[[ARGDATACAST4]], align 1
645// CHECK: %[[ARGDESCRIPTOR5:.*]] = getelementptr i8, i8* %[[BUF]], i64 14
646// CHECK: store i8 32, i8* %[[ARGDESCRIPTOR5]], align 1
647// CHECK: %[[ARGSIZE6:.*]] = getelementptr i8, i8* %[[BUF]], i64 15
648// CHECK: store i8 8, i8* %[[ARGSIZE6]], align 1
649// CHECK: %[[ARGDATA7:.*]] = getelementptr i8, i8* %[[BUF]], i64 16
650// CHECK: %[[ARGDATACAST8:.*]] = bitcast i8* %[[ARGDATA7]] to i64*
651// CHECK: %[[V2:.*]] = load i64, i64* %[[ARG2_ADDR]], align 8
652// CHECK: store i64 %[[V2]], i64* %[[ARGDATACAST8]], align 1
653
654// CHECK-LABEL: define void @test_builtin_os_log_invalid
655// CHECK: (i8* %[[BUF:.*]], i32 %[[DATA:.*]])
656void test_builtin_os_log_invalid(void *buf, int data) {
657  volatile int len;
658  // CHECK: %[[BUF_ADDR:.*]] = alloca i8*, align 8
659  // CHECK: %[[DATA_ADDR:.*]] = alloca i32, align 4
660  // CHECK: %[[LEN:.*]] = alloca i32, align 4
661  // CHECK: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8
662  // CHECK: store i32 %[[DATA]], i32* %[[DATA_ADDR]], align 4
663
664  // CHECK: store volatile i32 8, i32* %[[LEN]], align 4
665  len = __builtin_os_log_format_buffer_size("invalid specifier %: %d even a trailing one%", data);
666
667  // CHECK: %[[V1:.*]] = load i8*, i8** %[[BUF_ADDR]], align 8
668  // CHECK: %[[V2:.*]] = load i32, i32* %[[DATA_ADDR]], align 4
669  // CHECK: call void @__os_log_helper_1_0_1_4_0(i8* %[[V1]], i32 %[[V2]])
670
671  __builtin_os_log_format(buf, "invalid specifier %: %d even a trailing one%", data);
672}
673
674// CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_0_1_4_0
675// CHECK: (i8* %[[BUFFER:.*]], i32 %[[ARG0:.*]])
676
677// CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8
678// CHECK: %[[ARG0_ADDR:.*]] = alloca i32, align 4
679// CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8
680// CHECK: store i32 %[[ARG0]], i32* %[[ARG0_ADDR]], align 4
681// CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8
682// CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0
683// CHECK: store i8 0, i8* %[[SUMMARY]], align 1
684// CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1
685// CHECK: store i8 1, i8* %[[NUMARGS]], align 1
686// CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2
687// CHECK: store i8 0, i8* %[[ARGDESCRIPTOR]], align 1
688// CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3
689// CHECK: store i8 4, i8* %[[ARGSIZE]], align 1
690// CHECK: %[[ARGDATA:.*]] = getelementptr i8, i8* %[[BUF]], i64 4
691// CHECK: %[[ARGDATACAST:.*]] = bitcast i8* %[[ARGDATA]] to i32*
692// CHECK: %[[V0:.*]] = load i32, i32* %[[ARG0_ADDR]], align 4
693// CHECK: store i32 %[[V0]], i32* %[[ARGDATACAST]], align 1
694
695// CHECK-LABEL: define void @test_builtin_os_log_percent
696// CHECK: (i8* %[[BUF:.*]], i8* %[[DATA1:.*]], i8* %[[DATA2:.*]])
697// Check that the %% which does not consume any argument is correctly handled
698void test_builtin_os_log_percent(void *buf, const char *data1, const char *data2) {
699  volatile int len;
700  // CHECK: %[[BUF_ADDR:.*]] = alloca i8*, align 8
701  // CHECK: %[[DATA1_ADDR:.*]] = alloca i8*, align 8
702  // CHECK: %[[DATA2_ADDR:.*]] = alloca i8*, align 8
703  // CHECK: %[[LEN:.*]] = alloca i32, align 4
704  // CHECK: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8
705  // CHECK: store i8* %[[DATA1]], i8** %[[DATA1_ADDR]], align 8
706  // CHECK: store i8* %[[DATA2]], i8** %[[DATA2_ADDR]], align 8
707  // CHECK: store volatile i32 22, i32* %[[LEN]], align 4
708
709  len = __builtin_os_log_format_buffer_size("%s %% %s", data1, data2);
710
711  // CHECK: %[[V1:.*]] = load i8*, i8** %[[BUF_ADDR]], align 8
712  // CHECK: %[[V2:.*]] = load i8*, i8** %[[DATA1_ADDR]], align 8
713  // CHECK: %[[V3:.*]] = ptrtoint i8* %[[V2]] to i64
714  // CHECK: %[[V4:.*]] = load i8*, i8** %[[DATA2_ADDR]], align 8
715  // CHECK: %[[V5:.*]] = ptrtoint i8* %[[V4]] to i64
716  // CHECK: call void @__os_log_helper_1_2_2_8_32_8_32(i8* %[[V1]], i64 %[[V3]], i64 %[[V5]])
717
718  __builtin_os_log_format(buf, "%s %% %s", data1, data2);
719}
720
721// CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_2_8_32_8_32
722// CHECK: (i8* %[[BUFFER:.*]], i64 %[[ARG0:.*]], i64 %[[ARG1:.*]])
723
724// CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8
725// CHECK: %[[ARG0_ADDR:.*]] = alloca i64, align 8
726// CHECK: %[[ARG1_ADDR:.*]] = alloca i64, align 8
727// CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8
728// CHECK: store i64 %[[ARG0]], i64* %[[ARG0_ADDR]], align 8
729// CHECK: store i64 %[[ARG1]], i64* %[[ARG1_ADDR]], align 8
730// CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8
731// CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0
732// CHECK: store i8 2, i8* %[[SUMMARY]], align 1
733// CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1
734// CHECK: store i8 2, i8* %[[NUMARGS]], align 1
735// CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2
736// CHECK: store i8 32, i8* %[[ARGDESCRIPTOR]], align 1
737// CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3
738// CHECK: store i8 8, i8* %[[ARGSIZE]], align 1
739// CHECK: %[[ARGDATA:.*]] = getelementptr i8, i8* %[[BUF]], i64 4
740// CHECK: %[[ARGDATACAST:.*]] = bitcast i8* %[[ARGDATA]] to i64*
741// CHECK: %[[V0:.*]] = load i64, i64* %[[ARG0_ADDR]], align 8
742// CHECK: store i64 %[[V0]], i64* %[[ARGDATACAST]], align 1
743// CHECK: %[[ARGDESCRIPTOR1:.*]] = getelementptr i8, i8* %[[BUF]], i64 12
744// CHECK: store i8 32, i8* %[[ARGDESCRIPTOR1]], align 1
745// CHECK: %[[ARGSIZE2:.*]] = getelementptr i8, i8* %[[BUF]], i64 13
746// CHECK: store i8 8, i8* %[[ARGSIZE2]], align 1
747// CHECK: %[[ARGDATA3:.*]] = getelementptr i8, i8* %[[BUF]], i64 14
748// CHECK: %[[ARGDATACAST4:.*]] = bitcast i8* %[[ARGDATA3]] to i64*
749// CHECK: %[[V1:.*]] = load i64, i64* %[[ARG1_ADDR]], align 8
750// CHECK: store i64 %[[V1]], i64* %[[ARGDATACAST4]], align 1
751
752// Check that the following two functions call the same helper function.
753
754// CHECK-LABEL: define void @test_builtin_os_log_merge_helper0
755// CHECK: call void @__os_log_helper_1_0_2_4_0_8_0(
756void test_builtin_os_log_merge_helper0(void *buf, int i, double d) {
757  __builtin_os_log_format(buf, "%d %f", i, d);
758}
759
760// CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_0_2_4_0_8_0(
761
762// CHECK-LABEL: define void @test_builtin_os_log_merge_helper1
763// CHECK: call void @__os_log_helper_1_0_2_4_0_8_0(
764void test_builtin_os_log_merge_helper1(void *buf, unsigned u, long long ll) {
765  __builtin_os_log_format(buf, "%u %lld", u, ll);
766}
767
768// Check that this function doesn't write past the end of array 'buf'.
769
770// CHECK-LABEL: define void @test_builtin_os_log_errno
771void test_builtin_os_log_errno() {
772  // CHECK-NOT: @stacksave
773  // CHECK: %[[BUF:.*]] = alloca [4 x i8], align 1
774  // CHECK: %[[DECAY:.*]] = getelementptr inbounds [4 x i8], [4 x i8]* %[[BUF]], i64 0, i64 0
775  // CHECK: call void @__os_log_helper_1_2_1_0_96(i8* %[[DECAY]])
776  // CHECK-NOT: @stackrestore
777
778  char buf[__builtin_os_log_format_buffer_size("%m")];
779  __builtin_os_log_format(buf, "%m");
780}
781
782// CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_1_0_96
783// CHECK: (i8* %[[BUFFER:.*]])
784
785// CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8
786// CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8
787// CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8
788// CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0
789// CHECK: store i8 2, i8* %[[SUMMARY]], align 1
790// CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1
791// CHECK: store i8 1, i8* %[[NUMARGS]], align 1
792// CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2
793// CHECK: store i8 96, i8* %[[ARGDESCRIPTOR]], align 1
794// CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3
795// CHECK: store i8 0, i8* %[[ARGSIZE]], align 1
796// CHECK-NEXT: ret void
797
798// CHECK-LABEL: define void @test_builtin_os_log_long_double
799// CHECK: (i8* %[[BUF:.*]], x86_fp80 %[[LD:.*]])
800void test_builtin_os_log_long_double(void *buf, long double ld) {
801  // CHECK: %[[BUF_ADDR:.*]] = alloca i8*, align 8
802  // CHECK: %[[LD_ADDR:.*]] = alloca x86_fp80, align 16
803  // CHECK: %[[COERCE:.*]] = alloca i128, align 16
804  // CHECK: store i8* %[[BUF]], i8** %[[BUF_ADDR]], align 8
805  // CHECK: store x86_fp80 %[[LD]], x86_fp80* %[[LD_ADDR]], align 16
806  // CHECK: %[[V0:.*]] = load i8*, i8** %[[BUF_ADDR]], align 8
807  // CHECK: %[[V1:.*]] = load x86_fp80, x86_fp80* %[[LD_ADDR]], align 16
808  // CHECK: %[[V2:.*]] = bitcast x86_fp80 %[[V1]] to i80
809  // CHECK: %[[V3:.*]] = zext i80 %[[V2]] to i128
810  // CHECK: store i128 %[[V3]], i128* %[[COERCE]], align 16
811  // CHECK: %[[V4:.*]] = bitcast i128* %[[COERCE]] to { i64, i64 }*
812  // CHECK: %[[V5:.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[V4]], i32 0, i32 0
813  // CHECK: %[[V6:.*]] = load i64, i64* %[[V5]], align 16
814  // CHECK: %[[V7:.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[V4]], i32 0, i32 1
815  // CHECK: %[[V8:.*]] = load i64, i64* %[[V7]], align 8
816  // CHECK: call void @__os_log_helper_1_0_1_16_0(i8* %[[V0]], i64 %[[V6]], i64 %[[V8]])
817
818  __builtin_os_log_format(buf, "%Lf", ld);
819}
820
821// CHECK-LABEL: define linkonce_odr hidden void @__os_log_helper_1_0_1_16_0
822// CHECK: (i8* %[[BUFFER:.*]], i64 %[[ARG0_COERCE0:.*]], i64 %[[ARG0_COERCE1:.*]])
823
824// CHECK: %[[ARG0:.*]] = alloca i128, align 16
825// CHECK: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8
826// CHECK: %[[ARG0_ADDR:.*]] = alloca i128, align 16
827// CHECK: %[[V0:.*]] = bitcast i128* %[[ARG0]] to { i64, i64 }*
828// CHECK: %[[V1:.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[V0]], i32 0, i32 0
829// CHECK: store i64 %[[ARG0_COERCE0]], i64* %[[V1]], align 16
830// CHECK: %[[V2:.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* %[[V0]], i32 0, i32 1
831// CHECK: store i64 %[[ARG0_COERCE1]], i64* %[[V2]], align 8
832// CHECK: %[[ARG01:.*]] = load i128, i128* %[[ARG0]], align 16
833// CHECK: store i8* %[[BUFFER]], i8** %[[BUFFER_ADDR]], align 8
834// CHECK: store i128 %[[ARG01]], i128* %[[ARG0_ADDR]], align 16
835// CHECK: %[[BUF:.*]] = load i8*, i8** %[[BUFFER_ADDR]], align 8
836// CHECK: %[[SUMMARY:.*]] = getelementptr i8, i8* %[[BUF]], i64 0
837// CHECK: store i8 0, i8* %[[SUMMARY]], align 1
838// CHECK: %[[NUMARGS:.*]] = getelementptr i8, i8* %[[BUF]], i64 1
839// CHECK: store i8 1, i8* %[[NUMARGS]], align 1
840// CHECK: %[[ARGDESCRIPTOR:.*]] = getelementptr i8, i8* %[[BUF]], i64 2
841// CHECK: store i8 0, i8* %[[ARGDESCRIPTOR]], align 1
842// CHECK: %[[ARGSIZE:.*]] = getelementptr i8, i8* %[[BUF]], i64 3
843// CHECK: store i8 16, i8* %[[ARGSIZE]], align 1
844// CHECK: %[[ARGDATA:.*]] = getelementptr i8, i8* %[[BUF]], i64 4
845// CHECK: %[[ARGDATACAST:.*]] = bitcast i8* %[[ARGDATA]] to i128*
846// CHECK: %[[V3:.*]] = load i128, i128* %[[ARG0_ADDR]], align 16
847// CHECK: store i128 %[[V3]], i128* %[[ARGDATACAST]], align 1
848
849#endif
850
CodeThinker, Enjoy your reading code