clang/test/Sema/builtins-elementwise-math.c

   1 // RUN: %clang_cc1 -std=c99 %s -pedantic -verify -triple=x86_64-apple-darwin9
   2
   3 typedef double double2 __attribute__((ext_vector_type(2)));
   4 typedef double double4 __attribute__((ext_vector_type(4)));
   5 typedef float float2 __attribute__((ext_vector_type(2)));
   6 typedef float float4 __attribute__((ext_vector_type(4)));
   7
   8 typedef int int2 __attribute__((ext_vector_type(2)));
   9 typedef int int3 __attribute__((ext_vector_type(3)));
  10 typedef unsigned unsigned3 __attribute__((ext_vector_type(3)));
  11 typedef unsigned unsigned4 __attribute__((ext_vector_type(4)));
  12
  13 struct Foo {
  14   char *p;
  15 };
  16
  17 __attribute__((address_space(1))) int int_as_one;
  18 typedef int bar;
  19 bar b;
  20
  21 __attribute__((address_space(1))) float float_as_one;
  22 typedef float waffle;
  23 waffle waf;
  24
  25
  26 void test_builtin_elementwise_abs(int i, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
  27   struct Foo s = __builtin_elementwise_abs(i);
  28   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
  29
  30   i = __builtin_elementwise_abs();
  31   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
  32
  33   i = __builtin_elementwise_abs(i, i);
  34   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
  35
  36   i = __builtin_elementwise_abs(v);
  37   // expected-error@-1 {{assigning to 'int' from incompatible type 'float4' (vector of 4 'float' values)}}
  38
  39   u = __builtin_elementwise_abs(u);
  40   // expected-error@-1 {{1st argument must be a signed integer or floating point type (was 'unsigned int')}}
  41
  42   uv = __builtin_elementwise_abs(uv);
  43   // expected-error@-1 {{1st argument must be a signed integer or floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
  44 }
  45
  46 void test_builtin_elementwise_add_sat(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
  47   i = __builtin_elementwise_add_sat(p, d);
  48   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
  49
  50   struct Foo foo = __builtin_elementwise_add_sat(i, i);
  51   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
  52
  53   i = __builtin_elementwise_add_sat(i);
  54   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
  55
  56   i = __builtin_elementwise_add_sat();
  57   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
  58
  59   i = __builtin_elementwise_add_sat(i, i, i);
  60   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
  61
  62   i = __builtin_elementwise_add_sat(v, iv);
  63   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
  64
  65   i = __builtin_elementwise_add_sat(uv, iv);
  66   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
  67
  68   v = __builtin_elementwise_add_sat(v, v);
  69   // expected-error@-1 {{1st argument must be a vector of integers (was 'float4' (vector of 4 'float' values))}}
  70
  71   s = __builtin_elementwise_add_sat(i, s);
  72
  73   enum e { one,
  74            two };
  75   i = __builtin_elementwise_add_sat(one, two);
  76
  77   enum f { three };
  78   enum f x = __builtin_elementwise_add_sat(one, three);
  79   // expected-warning@-1 {{comparison of different enumeration types ('enum e' and 'enum f')}}
  80
  81   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
  82   ext = __builtin_elementwise_add_sat(ext, ext);
  83
  84   const int ci;
  85   i = __builtin_elementwise_add_sat(ci, i);
  86   i = __builtin_elementwise_add_sat(i, ci);
  87   i = __builtin_elementwise_add_sat(ci, ci);
  88
  89   i = __builtin_elementwise_add_sat(i, int_as_one); // ok (attributes don't match)?
  90   i = __builtin_elementwise_add_sat(i, b);          // ok (sugar doesn't match)?
  91
  92   int A[10];
  93   A = __builtin_elementwise_add_sat(A, A);
  94   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was 'int *')}}
  95
  96   int(ii);
  97   int j;
  98   j = __builtin_elementwise_add_sat(i, j);
  99
 100   _Complex float c1, c2;
 101   c1 = __builtin_elementwise_add_sat(c1, c2);
 102   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 103 }
 104
 105 void test_builtin_elementwise_sub_sat(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
 106   i = __builtin_elementwise_sub_sat(p, d);
 107   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 108
 109   struct Foo foo = __builtin_elementwise_sub_sat(i, i);
 110   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
 111
 112   i = __builtin_elementwise_sub_sat(i);
 113   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 114
 115   i = __builtin_elementwise_sub_sat();
 116   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 117
 118   i = __builtin_elementwise_sub_sat(i, i, i);
 119   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 120
 121   i = __builtin_elementwise_sub_sat(v, iv);
 122   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 123
 124   i = __builtin_elementwise_sub_sat(uv, iv);
 125   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
 126
 127   v = __builtin_elementwise_sub_sat(v, v);
 128   // expected-error@-1 {{1st argument must be a vector of integers (was 'float4' (vector of 4 'float' values))}}
 129
 130   s = __builtin_elementwise_sub_sat(i, s);
 131
 132   enum e { one,
 133            two };
 134   i = __builtin_elementwise_sub_sat(one, two);
 135
 136   enum f { three };
 137   enum f x = __builtin_elementwise_sub_sat(one, three);
 138   // expected-warning@-1 {{comparison of different enumeration types ('enum e' and 'enum f')}}
 139
 140   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
 141   ext = __builtin_elementwise_sub_sat(ext, ext);
 142
 143   const int ci;
 144   i = __builtin_elementwise_sub_sat(ci, i);
 145   i = __builtin_elementwise_sub_sat(i, ci);
 146   i = __builtin_elementwise_sub_sat(ci, ci);
 147
 148   i = __builtin_elementwise_sub_sat(i, int_as_one); // ok (attributes don't match)?
 149   i = __builtin_elementwise_sub_sat(i, b);          // ok (sugar doesn't match)?
 150
 151   int A[10];
 152   A = __builtin_elementwise_sub_sat(A, A);
 153   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was 'int *')}}
 154
 155   int(ii);
 156   int j;
 157   j = __builtin_elementwise_sub_sat(i, j);
 158
 159   _Complex float c1, c2;
 160   c1 = __builtin_elementwise_sub_sat(c1, c2);
 161   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 162 }
 163
 164 void test_builtin_elementwise_max(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
 165   i = __builtin_elementwise_max(p, d);
 166   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 167
 168   struct Foo foo = __builtin_elementwise_max(i, i);
 169   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
 170
 171   i = __builtin_elementwise_max(i);
 172   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 173
 174   i = __builtin_elementwise_max();
 175   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 176
 177   i = __builtin_elementwise_max(i, i, i);
 178   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 179
 180   i = __builtin_elementwise_max(v, iv);
 181   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 182
 183   i = __builtin_elementwise_max(uv, iv);
 184   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
 185
 186   s = __builtin_elementwise_max(i, s);
 187
 188   enum e { one,
 189            two };
 190   i = __builtin_elementwise_max(one, two);
 191
 192   enum f { three };
 193   enum f x = __builtin_elementwise_max(one, three);
 194   // expected-warning@-1 {{comparison of different enumeration types ('enum e' and 'enum f')}}
 195
 196   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
 197   ext = __builtin_elementwise_max(ext, ext);
 198
 199   const int ci;
 200   i = __builtin_elementwise_max(ci, i);
 201   i = __builtin_elementwise_max(i, ci);
 202   i = __builtin_elementwise_max(ci, ci);
 203
 204   i = __builtin_elementwise_max(i, int_as_one); // ok (attributes don't match)?
 205   i = __builtin_elementwise_max(i, b);          // ok (sugar doesn't match)?
 206
 207   int A[10];
 208   A = __builtin_elementwise_max(A, A);
 209   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was 'int *')}}
 210
 211   int(ii);
 212   int j;
 213   j = __builtin_elementwise_max(i, j);
 214
 215   _Complex float c1, c2;
 216   c1 = __builtin_elementwise_max(c1, c2);
 217   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 218 }
 219
 220 void test_builtin_elementwise_min(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
 221   i = __builtin_elementwise_min(p, d);
 222   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 223
 224   struct Foo foo = __builtin_elementwise_min(i, i);
 225   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
 226
 227   i = __builtin_elementwise_min(i);
 228   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 229
 230   i = __builtin_elementwise_min();
 231   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 232
 233   i = __builtin_elementwise_min(i, i, i);
 234   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 235
 236   i = __builtin_elementwise_min(v, iv);
 237   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 238
 239   i = __builtin_elementwise_min(uv, iv);
 240   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
 241
 242   s = __builtin_elementwise_min(i, s);
 243
 244   enum e { one,
 245            two };
 246   i = __builtin_elementwise_min(one, two);
 247
 248   enum f { three };
 249   enum f x = __builtin_elementwise_min(one, three);
 250   // expected-warning@-1 {{comparison of different enumeration types ('enum e' and 'enum f')}}
 251
 252   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
 253   ext = __builtin_elementwise_min(ext, ext);
 254
 255   const int ci;
 256   i = __builtin_elementwise_min(ci, i);
 257   i = __builtin_elementwise_min(i, ci);
 258   i = __builtin_elementwise_min(ci, ci);
 259
 260   i = __builtin_elementwise_min(i, int_as_one); // ok (attributes don't match)?
 261   i = __builtin_elementwise_min(i, b);          // ok (sugar doesn't match)?
 262
 263   int A[10];
 264   A = __builtin_elementwise_min(A, A);
 265   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was 'int *')}}
 266
 267   int(ii);
 268   int j;
 269   j = __builtin_elementwise_min(i, j);
 270
 271   _Complex float c1, c2;
 272   c1 = __builtin_elementwise_min(c1, c2);
 273   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 274 }
 275
 276 void test_builtin_elementwise_maximum(int i, short s, float f, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
 277   i = __builtin_elementwise_maximum(p, d);
 278   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 279
 280   struct Foo foo = __builtin_elementwise_maximum(d, d);
 281   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'double'}}
 282
 283   i = __builtin_elementwise_maximum(i);
 284   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 285
 286   i = __builtin_elementwise_maximum();
 287   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 288
 289   i = __builtin_elementwise_maximum(i, i, i);
 290   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 291
 292   i = __builtin_elementwise_maximum(v, iv);
 293   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 294
 295   i = __builtin_elementwise_maximum(uv, iv);
 296   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
 297
 298   d = __builtin_elementwise_maximum(f, d);
 299
 300   v = __builtin_elementwise_maximum(v, v);
 301
 302   i = __builtin_elementwise_maximum(iv, iv);
 303   // expected-error@-1 {{1st argument must be a floating point type (was 'int3' (vector of 3 'int' values))}}
 304
 305   i = __builtin_elementwise_maximum(i, i);
 306   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 307
 308   int A[10];
 309   A = __builtin_elementwise_maximum(A, A);
 310   // expected-error@-1 {{1st argument must be a floating point type (was 'int *')}}
 311
 312   _Complex float c1, c2;
 313   c1 = __builtin_elementwise_maximum(c1, c2);
 314   // expected-error@-1 {{1st argument must be a floating point type (was '_Complex float')}}
 315 }
 316
 317 void test_builtin_elementwise_minimum(int i, short s, float f, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
 318   i = __builtin_elementwise_minimum(p, d);
 319   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 320
 321   struct Foo foo = __builtin_elementwise_minimum(d, d);
 322   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'double'}}
 323
 324   i = __builtin_elementwise_minimum(i);
 325   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 326
 327   i = __builtin_elementwise_minimum();
 328   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 329
 330   i = __builtin_elementwise_minimum(i, i, i);
 331   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 332
 333   i = __builtin_elementwise_minimum(v, iv);
 334   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 335
 336   i = __builtin_elementwise_minimum(uv, iv);
 337   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
 338
 339   d = __builtin_elementwise_minimum(f, d);
 340
 341   v = __builtin_elementwise_minimum(v, v);
 342
 343   i = __builtin_elementwise_minimum(iv, iv);
 344   // expected-error@-1 {{1st argument must be a floating point type (was 'int3' (vector of 3 'int' values))}}
 345
 346   i = __builtin_elementwise_minimum(i, i);
 347   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 348
 349   int A[10];
 350   A = __builtin_elementwise_minimum(A, A);
 351   // expected-error@-1 {{1st argument must be a floating point type (was 'int *')}}
 352
 353   _Complex float c1, c2;
 354   c1 = __builtin_elementwise_minimum(c1, c2);
 355   // expected-error@-1 {{1st argument must be a floating point type (was '_Complex float')}}
 356 }
 357
 358 void test_builtin_elementwise_bitreverse(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 359
 360   struct Foo s = __builtin_elementwise_bitreverse(i);
 361   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
 362
 363   i = __builtin_elementwise_bitreverse();
 364   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 365
 366   i = __builtin_elementwise_bitreverse(f);
 367   // expected-error@-1 {{1st argument must be a vector of integers (was 'float')}}
 368
 369   i = __builtin_elementwise_bitreverse(f, f);
 370   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 371
 372   u = __builtin_elementwise_bitreverse(d);
 373   // expected-error@-1 {{1st argument must be a vector of integers (was 'double')}}
 374
 375   v = __builtin_elementwise_bitreverse(v);
 376   // expected-error@-1 {{1st argument must be a vector of integers (was 'float4' (vector of 4 'float' values))}}
 377 }
 378
 379 void test_builtin_elementwise_ceil(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 380
 381   struct Foo s = __builtin_elementwise_ceil(f);
 382   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 383
 384   i = __builtin_elementwise_ceil();
 385   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 386
 387   i = __builtin_elementwise_ceil(i);
 388   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 389
 390   i = __builtin_elementwise_ceil(f, f);
 391   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 392
 393   u = __builtin_elementwise_ceil(u);
 394   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 395
 396   uv = __builtin_elementwise_ceil(uv);
 397   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 398 }
 399
 400 void test_builtin_elementwise_acos(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 401
 402   struct Foo s = __builtin_elementwise_acos(f);
 403   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 404
 405   i = __builtin_elementwise_acos();
 406   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 407
 408   i = __builtin_elementwise_acos(i);
 409   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 410
 411   i = __builtin_elementwise_acos(f, f);
 412   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 413
 414   u = __builtin_elementwise_acos(u);
 415   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 416
 417   uv = __builtin_elementwise_acos(uv);
 418   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 419 }
 420
 421 void test_builtin_elementwise_cos(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 422
 423   struct Foo s = __builtin_elementwise_cos(f);
 424   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 425
 426   i = __builtin_elementwise_cos();
 427   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 428
 429   i = __builtin_elementwise_cos(i);
 430   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 431
 432   i = __builtin_elementwise_cos(f, f);
 433   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 434
 435   u = __builtin_elementwise_cos(u);
 436   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 437
 438   uv = __builtin_elementwise_cos(uv);
 439   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 440 }
 441
 442 void test_builtin_elementwise_cosh(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 443
 444   struct Foo s = __builtin_elementwise_cosh(f);
 445   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 446
 447   i = __builtin_elementwise_cosh();
 448   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 449
 450   i = __builtin_elementwise_cosh(i);
 451   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 452
 453   i = __builtin_elementwise_cosh(f, f);
 454   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 455
 456   u = __builtin_elementwise_cosh(u);
 457   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 458
 459   uv = __builtin_elementwise_cosh(uv);
 460   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 461 }
 462
 463 void test_builtin_elementwise_exp(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 464
 465   struct Foo s = __builtin_elementwise_exp(f);
 466   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 467
 468   i = __builtin_elementwise_exp();
 469   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 470
 471   i = __builtin_elementwise_exp(i);
 472   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 473
 474   i = __builtin_elementwise_exp(f, f);
 475   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 476
 477   u = __builtin_elementwise_exp(u);
 478   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 479
 480   uv = __builtin_elementwise_exp(uv);
 481   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 482 }
 483
 484 void test_builtin_elementwise_exp2(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 485
 486   struct Foo s = __builtin_elementwise_exp2(f);
 487   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 488
 489   i = __builtin_elementwise_exp2();
 490   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 491
 492   i = __builtin_elementwise_exp2(i);
 493   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 494
 495   i = __builtin_elementwise_exp2(f, f);
 496   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 497
 498   u = __builtin_elementwise_exp2(u);
 499   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 500
 501   uv = __builtin_elementwise_exp2(uv);
 502   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 503 }
 504
 505
 506 void test_builtin_elementwise_floor(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 507
 508   struct Foo s = __builtin_elementwise_floor(f);
 509   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 510
 511   i = __builtin_elementwise_floor();
 512   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 513
 514   i = __builtin_elementwise_floor(i);
 515   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 516
 517   i = __builtin_elementwise_floor(f, f);
 518   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 519
 520   u = __builtin_elementwise_floor(u);
 521   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 522
 523   uv = __builtin_elementwise_floor(uv);
 524   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 525 }
 526
 527 void test_builtin_elementwise_log(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 528
 529   struct Foo s = __builtin_elementwise_log(f);
 530   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 531
 532   i = __builtin_elementwise_log();
 533   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 534
 535   i = __builtin_elementwise_log(i);
 536   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 537
 538   i = __builtin_elementwise_log(f, f);
 539   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 540
 541   u = __builtin_elementwise_log(u);
 542   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 543
 544   uv = __builtin_elementwise_log(uv);
 545   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 546 }
 547
 548 void test_builtin_elementwise_log10(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 549
 550   struct Foo s = __builtin_elementwise_log10(f);
 551   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 552
 553   i = __builtin_elementwise_log10();
 554   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 555
 556   i = __builtin_elementwise_log10(i);
 557   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 558
 559   i = __builtin_elementwise_log10(f, f);
 560   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 561
 562   u = __builtin_elementwise_log10(u);
 563   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 564
 565   uv = __builtin_elementwise_log10(uv);
 566   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 567 }
 568
 569 void test_builtin_elementwise_log2(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 570
 571   struct Foo s = __builtin_elementwise_log2(f);
 572   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 573
 574   i = __builtin_elementwise_log2();
 575   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 576
 577   i = __builtin_elementwise_log2(i);
 578   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 579
 580   i = __builtin_elementwise_log2(f, f);
 581   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 582
 583   u = __builtin_elementwise_log2(u);
 584   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 585
 586   uv = __builtin_elementwise_log2(uv);
 587   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 588 }
 589
 590 void test_builtin_elementwise_popcount(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 591
 592   struct Foo s = __builtin_elementwise_popcount(i);
 593   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'int'}}
 594
 595   i = __builtin_elementwise_popcount();
 596   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 597
 598   i = __builtin_elementwise_popcount(f);
 599   // expected-error@-1 {{1st argument must be a vector of integers (was 'float')}}
 600
 601   i = __builtin_elementwise_popcount(f, f);
 602   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 603
 604   u = __builtin_elementwise_popcount(d);
 605   // expected-error@-1 {{1st argument must be a vector of integers (was 'double')}}
 606
 607   v = __builtin_elementwise_popcount(v);
 608   // expected-error@-1 {{1st argument must be a vector of integers (was 'float4' (vector of 4 'float' values))}}
 609
 610   int2 i2 = __builtin_elementwise_popcount(iv);
 611   // expected-error@-1 {{initializing 'int2' (vector of 2 'int' values) with an expression of incompatible type 'int3' (vector of 3 'int' values)}}
 612
 613   iv = __builtin_elementwise_popcount(i2);
 614   // expected-error@-1 {{assigning to 'int3' (vector of 3 'int' values) from incompatible type 'int2' (vector of 2 'int' values)}}
 615
 616   unsigned3 u3 = __builtin_elementwise_popcount(iv);
 617   // expected-error@-1 {{initializing 'unsigned3' (vector of 3 'unsigned int' values) with an expression of incompatible type 'int3' (vector of 3 'int' values)}}
 618
 619   iv = __builtin_elementwise_popcount(u3);
 620   // expected-error@-1 {{assigning to 'int3' (vector of 3 'int' values) from incompatible type 'unsigned3' (vector of 3 'unsigned int' values)}}
 621 }
 622
 623 void test_builtin_elementwise_fmod(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
 624   i = __builtin_elementwise_fmod(p, d);
 625   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 626
 627   struct Foo foo = __builtin_elementwise_fmod(i, i);
 628   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 629
 630   i = __builtin_elementwise_fmod(i);
 631   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 632
 633   i = __builtin_elementwise_fmod();
 634   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 635
 636   i = __builtin_elementwise_fmod(i, i, i);
 637   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 638
 639   i = __builtin_elementwise_fmod(v, iv);
 640   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 641
 642   i = __builtin_elementwise_fmod(uv, iv);
 643   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
 644
 645   i = __builtin_elementwise_fmod(d, v);
 646   // expected-error@-1 {{arguments are of different types ('double' vs 'float4' (vector of 4 'float' values))}}
 647 }
 648
 649 void test_builtin_elementwise_pow(int i, short s, double d, float4 v, int3 iv, unsigned3 uv, int *p) {
 650   i = __builtin_elementwise_pow(p, d);
 651   // expected-error@-1 {{arguments are of different types ('int *' vs 'double')}}
 652
 653   struct Foo foo = __builtin_elementwise_pow(i, i);
 654   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 655
 656   i = __builtin_elementwise_pow(i);
 657   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 658
 659   i = __builtin_elementwise_pow();
 660   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 661
 662   i = __builtin_elementwise_pow(i, i, i);
 663   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 664
 665   i = __builtin_elementwise_pow(v, iv);
 666   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'int3' (vector of 3 'int' values))}}
 667
 668   i = __builtin_elementwise_pow(uv, iv);
 669   // expected-error@-1 {{arguments are of different types ('unsigned3' (vector of 3 'unsigned int' values) vs 'int3' (vector of 3 'int' values))}}
 670
 671 }
 672
 673 void test_builtin_elementwise_roundeven(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 674
 675   struct Foo s = __builtin_elementwise_roundeven(f);
 676   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 677
 678   i = __builtin_elementwise_roundeven();
 679   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 680
 681   i = __builtin_elementwise_roundeven(i);
 682   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 683
 684   i = __builtin_elementwise_roundeven(f, f);
 685   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 686
 687   u = __builtin_elementwise_roundeven(u);
 688   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 689
 690   uv = __builtin_elementwise_roundeven(uv);
 691   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 692 }
 693
 694 void test_builtin_elementwise_round(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 695   struct Foo s = __builtin_elementwise_round(f);
 696   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 697
 698   i = __builtin_elementwise_round();
 699   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 700
 701   i = __builtin_elementwise_round(i);
 702   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 703
 704   i = __builtin_elementwise_round(f, f);
 705   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 706
 707   u = __builtin_elementwise_round(u);
 708   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 709
 710   uv = __builtin_elementwise_round(uv);
 711   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 712
 713   // FIXME: Error should not mention integer
 714   _Complex float c1, c2;
 715   c1 = __builtin_elementwise_round(c1);
 716   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 717 }
 718
 719 void test_builtin_elementwise_rint(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 720   struct Foo s = __builtin_elementwise_rint(f);
 721   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 722
 723   i = __builtin_elementwise_rint();
 724   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 725
 726   i = __builtin_elementwise_rint(i);
 727   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 728
 729   i = __builtin_elementwise_rint(f, f);
 730   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 731
 732   u = __builtin_elementwise_rint(u);
 733   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 734
 735   uv = __builtin_elementwise_rint(uv);
 736   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 737
 738   // FIXME: Error should not mention integer
 739   _Complex float c1, c2;
 740   c1 = __builtin_elementwise_rint(c1);
 741   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 742 }
 743
 744 void test_builtin_elementwise_nearbyint(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 745   struct Foo s = __builtin_elementwise_nearbyint(f);
 746   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 747
 748   i = __builtin_elementwise_nearbyint();
 749   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 750
 751   i = __builtin_elementwise_nearbyint(i);
 752   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 753
 754   i = __builtin_elementwise_nearbyint(f, f);
 755   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 756
 757   u = __builtin_elementwise_nearbyint(u);
 758   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 759
 760   uv = __builtin_elementwise_nearbyint(uv);
 761   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 762
 763   // FIXME: Error should not mention integer
 764   _Complex float c1, c2;
 765   c1 = __builtin_elementwise_nearbyint(c1);
 766   // expected-error@-1 {{1st argument must be a vector, integer or floating point type (was '_Complex float')}}
 767 }
 768
 769 void test_builtin_elementwise_asin(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 770
 771   struct Foo s = __builtin_elementwise_asin(f);
 772   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 773
 774   i = __builtin_elementwise_asin();
 775   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 776
 777   i = __builtin_elementwise_asin(i);
 778   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 779
 780   i = __builtin_elementwise_asin(f, f);
 781   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 782
 783   u = __builtin_elementwise_asin(u);
 784   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 785
 786   uv = __builtin_elementwise_asin(uv);
 787   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 788 }
 789
 790 void test_builtin_elementwise_sin(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 791
 792   struct Foo s = __builtin_elementwise_sin(f);
 793   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 794
 795   i = __builtin_elementwise_sin();
 796   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 797
 798   i = __builtin_elementwise_sin(i);
 799   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 800
 801   i = __builtin_elementwise_sin(f, f);
 802   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 803
 804   u = __builtin_elementwise_sin(u);
 805   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 806
 807   uv = __builtin_elementwise_sin(uv);
 808   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 809 }
 810
 811 void test_builtin_elementwise_sinh(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 812
 813   struct Foo s = __builtin_elementwise_sinh(f);
 814   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 815
 816   i = __builtin_elementwise_sinh();
 817   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 818
 819   i = __builtin_elementwise_sinh(i);
 820   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 821
 822   i = __builtin_elementwise_sinh(f, f);
 823   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 824
 825   u = __builtin_elementwise_sinh(u);
 826   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 827
 828   uv = __builtin_elementwise_sinh(uv);
 829   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 830 }
 831
 832 void test_builtin_elementwise_sqrt(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 833
 834   struct Foo s = __builtin_elementwise_sqrt(f);
 835   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 836
 837   i = __builtin_elementwise_sqrt();
 838   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 839
 840   i = __builtin_elementwise_sqrt(i);
 841   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 842
 843   i = __builtin_elementwise_sqrt(f, f);
 844   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 845
 846   u = __builtin_elementwise_sqrt(u);
 847   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 848
 849   uv = __builtin_elementwise_sqrt(uv);
 850   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 851 }
 852
 853 void test_builtin_elementwise_atan(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 854
 855   struct Foo s = __builtin_elementwise_atan(f);
 856   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 857
 858   i = __builtin_elementwise_atan();
 859   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 860
 861   i = __builtin_elementwise_atan(i);
 862   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 863
 864   i = __builtin_elementwise_atan(f, f);
 865   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 866
 867   u = __builtin_elementwise_atan(u);
 868   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 869
 870   uv = __builtin_elementwise_atan(uv);
 871   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 872 }
 873
 874 void test_builtin_elementwise_atan2(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 875
 876   struct Foo s = __builtin_elementwise_atan2(f, f);
 877   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 878
 879   i = __builtin_elementwise_atan2();
 880   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 881
 882   i = __builtin_elementwise_atan2(f);
 883   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 884
 885   i = __builtin_elementwise_atan2(i, i);
 886   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 887
 888   i = __builtin_elementwise_atan2(f, f, f);
 889   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 890
 891   u = __builtin_elementwise_atan2(u, u);
 892   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 893
 894   uv = __builtin_elementwise_atan2(uv, uv);
 895   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 896 }
 897
 898 void test_builtin_elementwise_tan(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 899
 900   struct Foo s = __builtin_elementwise_tan(f);
 901   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 902
 903   i = __builtin_elementwise_tan();
 904   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 905
 906   i = __builtin_elementwise_tan(i);
 907   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 908
 909   i = __builtin_elementwise_tan(f, f);
 910   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 911
 912   u = __builtin_elementwise_tan(u);
 913   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 914
 915   uv = __builtin_elementwise_tan(uv);
 916   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 917 }
 918
 919 void test_builtin_elementwise_tanh(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 920
 921   struct Foo s = __builtin_elementwise_tanh(f);
 922   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 923
 924   i = __builtin_elementwise_tanh();
 925   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 926
 927   i = __builtin_elementwise_tanh(i);
 928   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 929
 930   i = __builtin_elementwise_tanh(f, f);
 931   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 932
 933   u = __builtin_elementwise_tanh(u);
 934   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 935
 936   uv = __builtin_elementwise_tanh(uv);
 937   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 938 }
 939
 940 void test_builtin_elementwise_trunc(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 941
 942   struct Foo s = __builtin_elementwise_trunc(f);
 943   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 944
 945   i = __builtin_elementwise_trunc();
 946   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 947
 948   i = __builtin_elementwise_trunc(i);
 949   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 950
 951   i = __builtin_elementwise_trunc(f, f);
 952   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 953
 954   u = __builtin_elementwise_trunc(u);
 955   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 956
 957   uv = __builtin_elementwise_trunc(uv);
 958   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 959 }
 960
 961 void test_builtin_elementwise_canonicalize(int i, float f, double d, float4 v, int3 iv, unsigned u, unsigned4 uv) {
 962
 963   struct Foo s = __builtin_elementwise_canonicalize(f);
 964   // expected-error@-1 {{initializing 'struct Foo' with an expression of incompatible type 'float'}}
 965
 966   i = __builtin_elementwise_canonicalize();
 967   // expected-error@-1 {{too few arguments to function call, expected 1, have 0}}
 968
 969   i = __builtin_elementwise_canonicalize(i);
 970   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 971
 972   i = __builtin_elementwise_canonicalize(f, f);
 973   // expected-error@-1 {{too many arguments to function call, expected 1, have 2}}
 974
 975   u = __builtin_elementwise_canonicalize(u);
 976   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned int')}}
 977
 978   uv = __builtin_elementwise_canonicalize(uv);
 979   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned4' (vector of 4 'unsigned int' values))}}
 980 }
 981
 982 void test_builtin_elementwise_copysign(int i, short s, double d, float f, float4 v, int3 iv, unsigned3 uv, int *p) {
 983   i = __builtin_elementwise_copysign(p, d);
 984   // expected-error@-1 {{1st argument must be a floating point type (was 'int *')}}
 985
 986   i = __builtin_elementwise_copysign(i, i);
 987   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
 988
 989   i = __builtin_elementwise_copysign(i);
 990   // expected-error@-1 {{too few arguments to function call, expected 2, have 1}}
 991
 992   i = __builtin_elementwise_copysign();
 993   // expected-error@-1 {{too few arguments to function call, expected 2, have 0}}
 994
 995   i = __builtin_elementwise_copysign(i, i, i);
 996   // expected-error@-1 {{too many arguments to function call, expected 2, have 3}}
 997
 998   i = __builtin_elementwise_copysign(v, iv);
 999   // expected-error@-1 {{2nd argument must be a floating point type (was 'int3' (vector of 3 'int' values))}}
1000
1001   i = __builtin_elementwise_copysign(uv, iv);
1002   // expected-error@-1 {{1st argument must be a floating point type (was 'unsigned3' (vector of 3 'unsigned int' values))}}
1003
1004   s = __builtin_elementwise_copysign(i, s);
1005   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
1006
1007   f = __builtin_elementwise_copysign(f, i);
1008   // expected-error@-1 {{2nd argument must be a floating point type (was 'int')}}
1009
1010   f = __builtin_elementwise_copysign(i, f);
1011   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
1012
1013   enum e { one,
1014            two };
1015   i = __builtin_elementwise_copysign(one, two);
1016   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
1017
1018   enum f { three };
1019   enum f x = __builtin_elementwise_copysign(one, three);
1020   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
1021
1022   _BitInt(32) ext; // expected-warning {{'_BitInt' in C17 and earlier is a Clang extension}}
1023   ext = __builtin_elementwise_copysign(ext, ext);
1024   // expected-error@-1 {{1st argument must be a floating point type (was '_BitInt(32)')}}
1025
1026   const float cf32;
1027   f = __builtin_elementwise_copysign(cf32, f);
1028   f = __builtin_elementwise_copysign(f, cf32);
1029   f = __builtin_elementwise_copysign(cf32, f);
1030
1031   f = __builtin_elementwise_copysign(f, float_as_one); // ok (attributes don't match)?
1032   f = __builtin_elementwise_copysign(f, waf);          // ok (sugar doesn't match)?
1033
1034   float A[10];
1035   A = __builtin_elementwise_copysign(A, A);
1036   // expected-error@-1 {{1st argument must be a floating point type (was 'float *')}}
1037
1038   float(ii);
1039   float j;
1040   j = __builtin_elementwise_copysign(f, j);
1041
1042   _Complex float c1, c2;
1043   c1 = __builtin_elementwise_copysign(c1, c2);
1044   // expected-error@-1 {{1st argument must be a floating point type (was '_Complex float')}}
1045
1046   double f64 = 0.0;
1047   double tmp0 = __builtin_elementwise_copysign(f64, f);
1048   // expected-error@-1 {{arguments are of different types ('double' vs 'float')}}
1049
1050   float tmp1 = __builtin_elementwise_copysign(f, f64);
1051   //expected-error@-1 {{arguments are of different types ('float' vs 'double')}}
1052
1053   float4 v4f32 = 0.0f;
1054   float4 tmp2 = __builtin_elementwise_copysign(v4f32, f);
1055   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'float')}}
1056
1057   float tmp3 = __builtin_elementwise_copysign(f, v4f32);
1058   // expected-error@-1 {{arguments are of different types ('float' vs 'float4' (vector of 4 'float' values))}}
1059
1060   float2 v2f32 = 0.0f;
1061   double4 v4f64 = 0.0;
1062   double4 tmp4 = __builtin_elementwise_copysign(v4f64, v4f32);
1063   // expected-error@-1 {{arguments are of different types ('double4' (vector of 4 'double' values) vs 'float4' (vector of 4 'float' values))}}
1064
1065   float4 tmp6 = __builtin_elementwise_copysign(v4f32, v4f64);
1066   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'double4' (vector of 4 'double' values))}}
1067
1068   float4 tmp7 = __builtin_elementwise_copysign(v4f32, v2f32);
1069   // expected-error@-1 {{arguments are of different types ('float4' (vector of 4 'float' values) vs 'float2' (vector of 2 'float' values))}}
1070
1071   float2 tmp8 = __builtin_elementwise_copysign(v2f32, v4f32);
1072   // expected-error@-1 {{arguments are of different types ('float2' (vector of 2 'float' values) vs 'float4' (vector of 4 'float' values))}}
1073
1074   float2 tmp9 = __builtin_elementwise_copysign(v4f32, v4f32);
1075   // expected-error@-1 {{initializing 'float2' (vector of 2 'float' values) with an expression of incompatible type 'float4' (vector of 4 'float' values)}}
1076 }
1077
1078 void test_builtin_elementwise_fma(int i32, int2 v2i32, short i16,
1079                                   double f64, double2 v2f64, double2 v3f64,
1080                                   float f32, float2 v2f32, float v3f32, float4 v4f32,
1081                                   const float4 c_v4f32,
1082                                   int3 v3i32, int *ptr) {
1083
1084   f32 = __builtin_elementwise_fma();
1085   // expected-error@-1 {{too few arguments to function call, expected 3, have 0}}
1086
1087   f32 = __builtin_elementwise_fma(f32);
1088   // expected-error@-1 {{too few arguments to function call, expected 3, have 1}}
1089
1090   f32 = __builtin_elementwise_fma(f32, f32);
1091   // expected-error@-1 {{too few arguments to function call, expected 3, have 2}}
1092
1093   f32 = __builtin_elementwise_fma(f32, f32, f32, f32);
1094   // expected-error@-1 {{too many arguments to function call, expected 3, have 4}}
1095
1096   f32 = __builtin_elementwise_fma(f64, f32, f32);
1097   // expected-error@-1 {{arguments are of different types ('double' vs 'float')}}
1098
1099   f32 = __builtin_elementwise_fma(f32, f64, f32);
1100   // expected-error@-1 {{arguments are of different types ('float' vs 'double')}}
1101
1102   f32 = __builtin_elementwise_fma(f32, f32, f64);
1103   // expected-error@-1 {{arguments are of different types ('float' vs 'double')}}
1104
1105   f32 = __builtin_elementwise_fma(f32, f32, f64);
1106   // expected-error@-1 {{arguments are of different types ('float' vs 'double')}}
1107
1108   f64 = __builtin_elementwise_fma(f64, f32, f32);
1109   // expected-error@-1 {{arguments are of different types ('double' vs 'float')}}
1110
1111   f64 = __builtin_elementwise_fma(f64, f64, f32);
1112   // expected-error@-1 {{arguments are of different types ('double' vs 'float')}}
1113
1114   f64 = __builtin_elementwise_fma(f64, f32, f64);
1115   // expected-error@-1 {{arguments are of different types ('double' vs 'float')}}
1116
1117   v2f64 = __builtin_elementwise_fma(v2f32, f64, f64);
1118   // expected-error@-1 {{arguments are of different types ('float2' (vector of 2 'float' values) vs 'double'}}
1119
1120   v2f64 = __builtin_elementwise_fma(v2f32, v2f64, f64);
1121   // expected-error@-1 {{arguments are of different types ('float2' (vector of 2 'float' values) vs 'double2' (vector of 2 'double' values)}}
1122
1123   v2f64 = __builtin_elementwise_fma(v2f32, f64, v2f64);
1124   // expected-error@-1 {{arguments are of different types ('float2' (vector of 2 'float' values) vs 'double'}}
1125
1126   v2f64 = __builtin_elementwise_fma(f64, v2f32, v2f64);
1127   // expected-error@-1 {{arguments are of different types ('double' vs 'float2' (vector of 2 'float' values)}}
1128
1129   v2f64 = __builtin_elementwise_fma(f64, v2f64, v2f64);
1130   // expected-error@-1 {{arguments are of different types ('double' vs 'double2' (vector of 2 'double' values)}}
1131
1132   i32 = __builtin_elementwise_fma(i32, i32, i32);
1133   // expected-error@-1 {{1st argument must be a floating point type (was 'int')}}
1134
1135   v2i32 = __builtin_elementwise_fma(v2i32, v2i32, v2i32);
1136   // expected-error@-1 {{1st argument must be a floating point type (was 'int2' (vector of 2 'int' values))}}
1137
1138   f32 = __builtin_elementwise_fma(f32, f32, i32);
1139   // expected-error@-1 {{3rd argument must be a floating point type (was 'int')}}
1140
1141   f32 = __builtin_elementwise_fma(f32, i32, f32);
1142   // expected-error@-1 {{2nd argument must be a floating point type (was 'int')}}
1143
1144   f32 = __builtin_elementwise_fma(f32, f32, i32);
1145   // expected-error@-1 {{3rd argument must be a floating point type (was 'int')}}
1146
1147
1148   _Complex float c1, c2, c3;
1149   c1 = __builtin_elementwise_fma(c1, f32, f32);
1150   // expected-error@-1 {{1st argument must be a floating point type (was '_Complex float')}}
1151
1152   c2 = __builtin_elementwise_fma(f32, c2, f32);
1153   // expected-error@-1 {{2nd argument must be a floating point type (was '_Complex float')}}
1154
1155   c3 = __builtin_elementwise_fma(f32, f32, c3);
1156   // expected-error@-1 {{3rd argument must be a floating point type (was '_Complex float')}}
1157 }