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 = __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
233 void 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
357 void 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
366 long long test_builtin_readcyclecounter() {
367   // CHECK: call i64 @llvm.readcyclecounter()
368   return __builtin_readcyclecounter();
369 }
370