xref: /llvm-project/clang/test/Sema/builtins-elementwise-math.c (revision a5d14f757bb1afa47925d7d77bea6bf73bbe0434) 
1 // RUN: %clang_cc1 -std=c99 %s -pedantic -verify -triple=x86_64-apple-darwin9
2 
3 typedef float float4 __attribute__((ext_vector_type(4)));
4 typedef int int3 __attribute__((ext_vector_type(3)));
5 typedef unsigned unsigned3 __attribute__((ext_vector_type(3)));
6 typedef unsigned unsigned4 __attribute__((ext_vector_type(4)));
7 
8 struct Foo {
9   char *p;
10 };
11 
12 __attribute__((address_space(1))) int int_as_one;
13 typedef int bar;
14 bar b;
15 
16 void test_builtin_elementwise_abs(int i, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
17   struct Foo s = __builtin_elementwise_abs(i);
18   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
19 
20   i = __builtin_elementwise_abs();
21   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
22 
23   i = __builtin_elementwise_abs(i, i);
24   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
25 
26   i = __builtin_elementwise_abs(v);
27   // expected-error@-1 {{assigning to 'int' from incompatible type 'float4' (vector of 4 'float' values)}}
28 
29   u = __builtin_elementwise_abs(u);
30   // expected-error@-1 {{1st argument must be a signed integer or floating point type (was 'unsigned int')}}
31 
32   uv = __builtin_elementwise_abs(uv);
33   // expected-error@-1 {{1st argument must be a signed integer or floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
34 }
35 
36 void test_builtin_elementwise_add_sat(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
37   i = __builtin_elementwise_add_sat(p, d);
38   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
39 
40   struct Foo foo = __builtin_elementwise_add_sat(i, i);
41   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
42 
43   i = __builtin_elementwise_add_sat(i);
44   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
45 
46   i = __builtin_elementwise_add_sat();
47   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
48 
49   i = __builtin_elementwise_add_sat(i, i, i);
50   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
51 
52   i = __builtin_elementwise_add_sat(v, iv);
53   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
54 
55   i = __builtin_elementwise_add_sat(uv, iv);
56   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
57 
58   v = __builtin_elementwise_add_sat(v, v);
59   // expected-error@-1 {{1st argument must be a vector of integers (was 'float4' (vector of 4 'float' values))}}
60 
61   s = __builtin_elementwise_add_sat(i, s);
62 
63   enum e { one,
64            two };
65   i = __builtin_elementwise_add_sat(one, two);
66 
67   enum f { three };
68   enum f x = __builtin_elementwise_add_sat(one, three);
69 
70   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
71   ext = __builtin_elementwise_add_sat(ext, ext);
72 
73   const int ci;
74   i = __builtin_elementwise_add_sat(ci, i);
75   i = __builtin_elementwise_add_sat(i, ci);
76   i = __builtin_elementwise_add_sat(ci, ci);
77 
78   i = __builtin_elementwise_add_sat(i, int_as_one); // ok (attributes don't match)?
79   i = __builtin_elementwise_add_sat(i, b);          // ok (sugar doesn't match)?
80 
81   int A[10];
82   A = __builtin_elementwise_add_sat(A, A);
83   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was 'int *')}}
84 
85   int(ii);
86   int j;
87   j = __builtin_elementwise_add_sat(i, j);
88 
89   _Complex float c1, c2;
90   c1 = __builtin_elementwise_add_sat(c1, c2);
91   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
92 }
93 
94 void test_builtin_elementwise_sub_sat(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
95   i = __builtin_elementwise_sub_sat(p, d);
96   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
97 
98   struct Foo foo = __builtin_elementwise_sub_sat(i, i);
99   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
100 
101   i = __builtin_elementwise_sub_sat(i);
102   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
103 
104   i = __builtin_elementwise_sub_sat();
105   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
106 
107   i = __builtin_elementwise_sub_sat(i, i, i);
108   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
109 
110   i = __builtin_elementwise_sub_sat(v, iv);
111   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
112 
113   i = __builtin_elementwise_sub_sat(uv, iv);
114   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
115 
116   v = __builtin_elementwise_sub_sat(v, v);
117   // expected-error@-1 {{1st argument must be a vector of integers (was 'float4' (vector of 4 'float' values))}}
118 
119   s = __builtin_elementwise_sub_sat(i, s);
120 
121   enum e { one,
122            two };
123   i = __builtin_elementwise_sub_sat(one, two);
124 
125   enum f { three };
126   enum f x = __builtin_elementwise_sub_sat(one, three);
127 
128   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
129   ext = __builtin_elementwise_sub_sat(ext, ext);
130 
131   const int ci;
132   i = __builtin_elementwise_sub_sat(ci, i);
133   i = __builtin_elementwise_sub_sat(i, ci);
134   i = __builtin_elementwise_sub_sat(ci, ci);
135 
136   i = __builtin_elementwise_sub_sat(i, int_as_one); // ok (attributes don't match)?
137   i = __builtin_elementwise_sub_sat(i, b);          // ok (sugar doesn't match)?
138 
139   int A[10];
140   A = __builtin_elementwise_sub_sat(A, A);
141   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was 'int *')}}
142 
143   int(ii);
144   int j;
145   j = __builtin_elementwise_sub_sat(i, j);
146 
147   _Complex float c1, c2;
148   c1 = __builtin_elementwise_sub_sat(c1, c2);
149   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
150 }
151 
152 void test_builtin_elementwise_max(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
153   i = __builtin_elementwise_max(p, d);
154   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
155 
156   struct Foo foo = __builtin_elementwise_max(i, i);
157   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
158 
159   i = __builtin_elementwise_max(i);
160   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
161 
162   i = __builtin_elementwise_max();
163   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
164 
165   i = __builtin_elementwise_max(i, i, i);
166   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
167 
168   i = __builtin_elementwise_max(v, iv);
169   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
170 
171   i = __builtin_elementwise_max(uv, iv);
172   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
173 
174   s = __builtin_elementwise_max(i, s);
175 
176   enum e { one,
177            two };
178   i = __builtin_elementwise_max(one, two);
179 
180   enum f { three };
181   enum f x = __builtin_elementwise_max(one, three);
182 
183   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
184   ext = __builtin_elementwise_max(ext, ext);
185 
186   const int ci;
187   i = __builtin_elementwise_max(ci, i);
188   i = __builtin_elementwise_max(i, ci);
189   i = __builtin_elementwise_max(ci, ci);
190 
191   i = __builtin_elementwise_max(i, int_as_one); // ok (attributes don't match)?
192   i = __builtin_elementwise_max(i, b);          // ok (sugar doesn't match)?
193 
194   int A[10];
195   A = __builtin_elementwise_max(A, A);
196   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was 'int *')}}
197 
198   int(ii);
199   int j;
200   j = __builtin_elementwise_max(i, j);
201 
202   _Complex float c1, c2;
203   c1 = __builtin_elementwise_max(c1, c2);
204   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
205 }
206 
207 void test_builtin_elementwise_min(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
208   i = __builtin_elementwise_min(p, d);
209   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
210 
211   struct Foo foo = __builtin_elementwise_min(i, i);
212   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
213 
214   i = __builtin_elementwise_min(i);
215   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
216 
217   i = __builtin_elementwise_min();
218   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
219 
220   i = __builtin_elementwise_min(i, i, i);
221   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
222 
223   i = __builtin_elementwise_min(v, iv);
224   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
225 
226   i = __builtin_elementwise_min(uv, iv);
227   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
228 
229   s = __builtin_elementwise_min(i, s);
230 
231   enum e { one,
232            two };
233   i = __builtin_elementwise_min(one, two);
234 
235   enum f { three };
236   enum f x = __builtin_elementwise_min(one, three);
237 
238   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
239   ext = __builtin_elementwise_min(ext, ext);
240 
241   const int ci;
242   i = __builtin_elementwise_min(ci, i);
243   i = __builtin_elementwise_min(i, ci);
244   i = __builtin_elementwise_min(ci, ci);
245 
246   i = __builtin_elementwise_min(i, int_as_one); // ok (attributes don't match)?
247   i = __builtin_elementwise_min(i, b);          // ok (sugar doesn't match)?
248 
249   int A[10];
250   A = __builtin_elementwise_min(A, A);
251   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was 'int *')}}
252 
253   int(ii);
254   int j;
255   j = __builtin_elementwise_min(i, j);
256 
257   _Complex float c1, c2;
258   c1 = __builtin_elementwise_min(c1, c2);
259   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
260 }
261 
262 void test_builtin_elementwise_ceil(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
263 
264   struct Foo s = __builtin_elementwise_ceil(f);
265   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
266 
267   i = __builtin_elementwise_ceil();
268   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
269 
270   i = __builtin_elementwise_ceil(i);
271   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
272 
273   i = __builtin_elementwise_ceil(f, f);
274   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
275 
276   u = __builtin_elementwise_ceil(u);
277   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
278 
279   uv = __builtin_elementwise_ceil(uv);
280   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
281 }
282 
283 void test_builtin_elementwise_cos(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
284 
285   struct Foo s = __builtin_elementwise_cos(f);
286   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
287 
288   i = __builtin_elementwise_cos();
289   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
290 
291   i = __builtin_elementwise_cos(i);
292   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
293 
294   i = __builtin_elementwise_cos(f, f);
295   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
296 
297   u = __builtin_elementwise_cos(u);
298   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
299 
300   uv = __builtin_elementwise_cos(uv);
301   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
302 }
303 
304 void test_builtin_elementwise_floor(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
305 
306   struct Foo s = __builtin_elementwise_floor(f);
307   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
308 
309   i = __builtin_elementwise_floor();
310   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
311 
312   i = __builtin_elementwise_floor(i);
313   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
314 
315   i = __builtin_elementwise_floor(f, f);
316   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
317 
318   u = __builtin_elementwise_floor(u);
319   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
320 
321   uv = __builtin_elementwise_floor(uv);
322   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
323 }
324 
325 void test_builtin_elementwise_roundeven(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
326 
327   struct Foo s = __builtin_elementwise_roundeven(f);
328   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
329 
330   i = __builtin_elementwise_roundeven();
331   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
332 
333   i = __builtin_elementwise_roundeven(i);
334   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
335 
336   i = __builtin_elementwise_roundeven(f, f);
337   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
338 
339   u = __builtin_elementwise_roundeven(u);
340   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
341 
342   uv = __builtin_elementwise_roundeven(uv);
343   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
344 }
345 
346 void test_builtin_elementwise_sin(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
347 
348   struct Foo s = __builtin_elementwise_sin(f);
349   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
350 
351   i = __builtin_elementwise_sin();
352   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
353 
354   i = __builtin_elementwise_sin(i);
355   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
356 
357   i = __builtin_elementwise_sin(f, f);
358   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
359 
360   u = __builtin_elementwise_sin(u);
361   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
362 
363   uv = __builtin_elementwise_sin(uv);
364   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
365 }
366 
367 void test_builtin_elementwise_trunc(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
368 
369   struct Foo s = __builtin_elementwise_trunc(f);
370   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
371 
372   i = __builtin_elementwise_trunc();
373   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
374 
375   i = __builtin_elementwise_trunc(i);
376   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
377 
378   i = __builtin_elementwise_trunc(f, f);
379   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
380 
381   u = __builtin_elementwise_trunc(u);
382   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
383 
384   uv = __builtin_elementwise_trunc(uv);
385   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
386 }
387