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  return 0;
136}
137
138
139
140void foo() {
141 __builtin_strcat(0, 0);
142}
143
144// CHECK-LABEL: define void @bar(
145void 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
181void 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 = __builtin_isnormal(F);
224  // CHECK: fcmp oeq float
225  // CHECK: call float @llvm.fabs.f32(float
226  // CHECK: fcmp ult float {{.*}}, 0x7FF0000000000000
227  // CHECK: fcmp uge float {{.*}}, 0x3810000000000000
228  // CHECK: and i1
229  // CHECK: and i1
230}
231
232// CHECK-LABEL: define void @test_float_builtin_ops
233void test_float_builtin_ops(float F, double D, long double LD) {
234  volatile float resf;
235  volatile double resd;
236  volatile long double resld;
237
238  resf = __builtin_fmodf(F,F);
239  // CHECK: frem float
240
241  resd = __builtin_fmod(D,D);
242  // CHECK: frem double
243
244  resld = __builtin_fmodl(LD,LD);
245  // CHECK: frem x86_fp80
246
247  resf = __builtin_fabsf(F);
248  resd = __builtin_fabs(D);
249  resld = __builtin_fabsl(LD);
250  // CHECK: call float @llvm.fabs.f32(float
251  // CHECK: call double @llvm.fabs.f64(double
252  // CHECK: call x86_fp80 @llvm.fabs.f80(x86_fp80
253
254  resf = __builtin_canonicalizef(F);
255  resd = __builtin_canonicalize(D);
256  resld = __builtin_canonicalizel(LD);
257  // CHECK: call float @llvm.canonicalize.f32(float
258  // CHECK: call double @llvm.canonicalize.f64(double
259  // CHECK: call x86_fp80 @llvm.canonicalize.f80(x86_fp80
260
261  resf = __builtin_fminf(F, F);
262  // CHECK: call float @llvm.minnum.f32
263
264  resd = __builtin_fmin(D, D);
265  // CHECK: call double @llvm.minnum.f64
266
267  resld = __builtin_fminl(LD, LD);
268  // CHECK: call x86_fp80 @llvm.minnum.f80
269
270  resf = __builtin_fmaxf(F, F);
271  // CHECK: call float @llvm.maxnum.f32
272
273  resd = __builtin_fmax(D, D);
274  // CHECK: call double @llvm.maxnum.f64
275
276  resld = __builtin_fmaxl(LD, LD);
277  // CHECK: call x86_fp80 @llvm.maxnum.f80
278
279  resf = __builtin_fabsf(F);
280  // CHECK: call float @llvm.fabs.f32
281
282  resd = __builtin_fabs(D);
283  // CHECK: call double @llvm.fabs.f64
284
285  resld = __builtin_fabsl(LD);
286  // CHECK: call x86_fp80 @llvm.fabs.f80
287
288  resf = __builtin_copysignf(F, F);
289  // CHECK: call float @llvm.copysign.f32
290
291  resd = __builtin_copysign(D, D);
292  // CHECK: call double @llvm.copysign.f64
293
294  resld = __builtin_copysignl(LD, LD);
295  // CHECK: call x86_fp80 @llvm.copysign.f80
296
297
298  resf = __builtin_ceilf(F);
299  // CHECK: call float @llvm.ceil.f32
300
301  resd = __builtin_ceil(D);
302  // CHECK: call double @llvm.ceil.f64
303
304  resld = __builtin_ceill(LD);
305  // CHECK: call x86_fp80 @llvm.ceil.f80
306
307  resf = __builtin_floorf(F);
308  // CHECK: call float @llvm.floor.f32
309
310  resd = __builtin_floor(D);
311  // CHECK: call double @llvm.floor.f64
312
313  resld = __builtin_floorl(LD);
314  // CHECK: call x86_fp80 @llvm.floor.f80
315
316  resf = __builtin_truncf(F);
317  // CHECK: call float @llvm.trunc.f32
318
319  resd = __builtin_trunc(D);
320  // CHECK: call double @llvm.trunc.f64
321
322  resld = __builtin_truncl(LD);
323  // CHECK: call x86_fp80 @llvm.trunc.f80
324
325  resf = __builtin_rintf(F);
326  // CHECK: call float @llvm.rint.f32
327
328  resd = __builtin_rint(D);
329  // CHECK: call double @llvm.rint.f64
330
331  resld = __builtin_rintl(LD);
332  // CHECK: call x86_fp80 @llvm.rint.f80
333
334  resf = __builtin_nearbyintf(F);
335  // CHECK: call float @llvm.nearbyint.f32
336
337  resd = __builtin_nearbyint(D);
338  // CHECK: call double @llvm.nearbyint.f64
339
340  resld = __builtin_nearbyintl(LD);
341  // CHECK: call x86_fp80 @llvm.nearbyint.f80
342
343  resf = __builtin_roundf(F);
344  // CHECK: call float @llvm.round.f32
345
346  resd = __builtin_round(D);
347  // CHECK: call double @llvm.round.f64
348
349  resld = __builtin_roundl(LD);
350  // CHECK: call x86_fp80 @llvm.round.f80
351
352}
353
354// __builtin_longjmp isn't supported on all platforms, so only test it on X86.
355#ifdef __x86_64__
356// CHECK-LABEL: define void @test_builtin_longjmp
357void test_builtin_longjmp(void **buffer) {
358  // CHECK: [[BITCAST:%.*]] = bitcast
359  // CHECK-NEXT: call void @llvm.eh.sjlj.longjmp(i8* [[BITCAST]])
360  __builtin_longjmp(buffer, 1);
361  // CHECK-NEXT: unreachable
362}
363#endif
364
365// CHECK-LABEL: define i64 @test_builtin_readcyclecounter
366long long test_builtin_readcyclecounter() {
367  // CHECK: call i64 @llvm.readcyclecounter()
368  return __builtin_readcyclecounter();
369}
370